Update parquet files (step 72 of 121)

spaces/1acneusushi/gradio-2dmoleculeeditor/data/A Bugs Life Movie Free [UPDATED] Download In Hindi.md

@@ -1,23 +0,0 @@
-<br />
-<h1>How to Watch A Bug's Life Movie Free Download In Hindi Online</h1>
-<p>A Bug's Life is a 1998 animated comedy film produced by Pixar Animation Studios and distributed by Walt Disney Pictures. The film tells the story of an ant colony that is oppressed by a gang of grasshoppers and how a misfit ant named Flik tries to save the day with the help of a circus troupe of bugs.</p>
-<h2>A Bug's Life Movie Free Download In Hindi</h2><br /><p><b><b>Download Zip</b> &#10037; <a href="https://byltly.com/2uKyKz">https://byltly.com/2uKyKz</a></b></p><br /><br />
-<p>If you are looking for a way to watch A Bug's Life movie free download in Hindi online, you have come to the right place. In this article, we will show you how to stream or download the movie legally and safely without any hassle.</p>
-<h2>Why You Should Watch A Bug's Life Movie Free Download In Hindi Online</h2>
-<p>A Bug's Life is a classic animated film that has won many awards and accolades, including an Academy Award nomination for Best Original Score. The film features a talented voice cast, including Dave Foley, Kevin Spacey, Julia Louis-Dreyfus, Hayden Panettiere, Phyllis Diller, David Hyde Pierce, Denis Leary, and more.</p>
-<p>The film is also full of humor, adventure, and heartwarming messages about courage, friendship, and teamwork. It is a great movie for kids and adults alike, as it offers a lot of fun and entertainment for the whole family.</p>
-<p>Moreover, watching A Bug's Life movie free download in Hindi online can help you enjoy the film in your native language and understand the cultural references better. You can also learn some new words and phrases in Hindi while watching the movie.</p>
-<h2>How to Watch A Bug's Life Movie Free Download In Hindi Online</h2>
-<p>There are many websites and apps that claim to offer A Bug's Life movie free download in Hindi online, but not all of them are reliable or legal. Some of them may contain viruses, malware, or spyware that can harm your device or compromise your privacy. Some of them may also violate the copyright laws and put you at risk of legal trouble.</p>
-<p></p>
-<p>Therefore, we recommend that you watch A Bug's Life movie free download in Hindi online only from trusted and authorized sources. Here are some of the best options that you can choose from:</p>
-<ul>
-<li><a href="https://www.hotstar.com/in/movies/a-bugs-life/1260022154">Hotstar</a>: Hotstar is one of the most popular streaming platforms in India that offers a wide range of movies, TV shows, sports, news, and more. You can watch A Bug's Life movie free download in Hindi online on Hotstar with a subscription plan that starts from Rs. 299 per month or Rs. 1499 per year. You can also get a free trial for seven days before you decide to subscribe.</li>
-<li><a href="https://www.youtube.com/watch?v=0Z0z7Z6Yxjw">YouTube</a>: YouTube is another great option to watch A Bug's Life movie free download in Hindi online. You can rent or buy the movie on YouTube for Rs. 120 or Rs. 490 respectively. You can also watch it for free with ads if you have a YouTube Premium subscription that costs Rs. 129 per month or Rs. 399 per quarter.</li>
-<li><a href="https://www.amazon.in/Bugs-Life-Dave-Foley/dp/B07BZQ4F4D">Amazon Prime Video</a>: Amazon Prime Video is another popular streaming service that offers a huge collection of movies, TV shows, originals, and more. You can watch A Bug's Life movie free download in Hindi online on Amazon Prime Video with a Prime membership that costs Rs. 129 per month or Rs. 999 per year. You can also get a free trial for 30 days before you subscribe.</li>
-</ul>
-<h2>Conclusion</h2>
-<p>A Bug's Life is a wonderful animated film that you should not miss out on. You can watch A Bug's Life movie free download in Hindi online from any of the above-mentioned sources and enjoy the movie in your preferred language.</p>
-<p>We hope this article has helped you find the best way to watch A Bug's Life movie free download in Hindi online. If you have any questions or feedback, please feel free to leave a comment below.</p> cec2833e83<br />
-<br />
-<br />

spaces/1acneusushi/gradio-2dmoleculeeditor/data/Dr. Folder 2.7.0.1 full key change icons for all folders on Windows A complete guide to customize your folders.md

@@ -1,87 +0,0 @@
-<br />
-<h1>Dr. Folder 2.7.0.1 full key change icons for all folders on Windows update 6 13 2019</h1>
- <h2>Introduction</h2>
- <p>Are you bored with the same old folder icons on your Windows computer? Do you want to customize your folders with different colors, shapes, and images? If yes, then you need Dr. Folder, a powerful and easy-to-use software that lets you change icons for all folders on Windows in just a few clicks.</p>
-<h2>Dr. Folder 2.7.0.1 full key change icons for all folders on Windows update 6 13 2019</h2><br /><p><b><b>DOWNLOAD</b> &#10003;&#10003;&#10003; <a href="https://byltly.com/2uKyqf">https://byltly.com/2uKyqf</a></b></p><br /><br />
- <h3>What is Dr. Folder?</h3>
- <p>Dr. Folder is a folder icon changer software that can replace the default folder icon with any icon you want. It has a large collection of icons for various categories, such as animals, cartoons, games, movies, music, nature, sports, etc. You can also use your own icons or download more from the internet.</p>
- <h3>Why use Dr. Folder?</h3>
- <p>Dr. Folder can help you organize your folders better by making them more recognizable and attractive. You can also use different icons to indicate the status or priority of your folders, such as important, private, locked, shared, etc. Moreover, Dr. Folder can protect your folders from being deleted or modified by hiding them or making them read-only.</p>
- <h3>How to download and install Dr. Folder?</h3>
- <p>You can download Dr. Folder from its official website or from other trusted sources online. The latest version is 2.7.0.1 and it was updated on June 13, 2019. The file size is about 8 MB and it supports Windows XP/Vista/7/8/10 (32-bit and 64-bit). To install Dr. Folder, you need to run the setup file and follow the instructions on the screen.</p>
- <h2>How to change icons for all folders on Windows with Dr. Folder?</h2>
- <p>Changing icons for all folders on Windows with Dr. Folder is very simple and fast. Here are the steps you need to follow:</p>
- <h3>Step 1: Launch Dr. Folder</h3>
- <p>After installing Dr. Folder, you can find it in your Start menu or on your desktop. Double-click on its icon to open it.</p>
- <h3>Step 2: Select the folders you want to change icons for</h3>
- <p>You can select one or more folders from your computer by using the Add Folders button or by dragging and dropping them into the main window of Dr. Folder.</p>
- <h3>Step 3: Choose an icon from the built-in library or your own collection</h3>
- <p>You can browse through the built-in library of icons by clicking on the Icons button at the top of the window. You can also use the Search function to find a specific icon by its name or keyword.</p>
-<p>How to customize folder icons with Dr. Folder 2.7.0.1 full key<br />
-Dr. Folder 2.7.0.1 full key download link and installation guide<br />
-Best folder icon changer software for Windows: Dr. Folder 2.7.0.1 full key<br />
-Dr. Folder 2.7.0.1 full key features and benefits<br />
-Dr. Folder 2.7.0.1 full key review and rating<br />
-How to get Dr. Folder 2.7.0.1 full key for free<br />
-Dr. Folder 2.7.0.1 full key vs other folder icon changer tools<br />
-How to update Dr. Folder 2.7.0.1 full key to the latest version<br />
-How to use Dr. Folder 2.7.0.1 full key to change icons for multiple folders<br />
-How to fix Dr. Folder 2.7.0.1 full key errors and issues<br />
-How to uninstall Dr. Folder 2.7.0.1 full key from Windows<br />
-How to backup and restore folder icons with Dr. Folder 2.7.0.1 full key<br />
-How to create custom folder icons with Dr. Folder 2.7.0.1 full key<br />
-How to apply different folder icons for different file types with Dr. Folder 2.7.0.1 full key<br />
-How to change folder icons according to themes with Dr. Folder 2.7.0.1 full key<br />
-How to change folder icons in Windows Explorer and Desktop with Dr. Folder 2.7.0.1 full key<br />
-How to change folder icons in OneDrive and Dropbox with Dr.<br />
-How to change folder icons in network drives and external devices with Dr.<br />
-How to change folder icons in Windows Start Menu and Taskbar with Dr.<br />
-How to change folder icons in Windows Registry and System Files with Dr.<br />
-How to change folder icons for hidden and protected folders with Dr.<br />
-How to change folder icons for shortcuts and links with Dr.<br />
-How to change folder icons for compressed and encrypted folders with Dr.<br />
-How to change folder icons for shared and synced folders with Dr.<br />
-How to change folder icons for special and system folders with Dr.<br />
-How to batch change folder icons with Dr.<br />
-How to preview folder icons before changing them with Dr.<br />
-How to revert folder icons back to default with Dr.<br />
-How to find and replace folder icons with Dr.<br />
-How to sort and filter folder icons with Dr.<br />
-How to export and import folder icons with Dr.</p>
- <p>If you want to use your own icons, you can click on the Add Icons button and select them from your computer.</p>
- <h3>Step 4: Apply the changes and enjoy your new folder icons</h3>
- <p>Once you have chosen an icon for your folders, you can click on the Apply button at the bottom of the window to make the changes effective.</p>
- <p>You can also preview how your folders will look like before applying by clicking on the Preview button.</p>
- <p>Congratulations! You have successfully changed icons for all folders on Windows with Dr. Folder.</p>
- <h2>How to restore the default icons for all folders on Windows with Dr. Folder?</h2>
- <p>If you want to go back to the original folder icons on Windows, you can easily do that with Dr. Folder as well. Here are the steps you need to follow:</p>
- <h3>Step 1: Launch Dr. Folder</h3>
- <p>Open Dr. Folder as described in step 1 above.</p>
- <h3>Step 2: Select the folders you want to restore icons for</h3>
- <p>Select one or more folders from your computer by using the Add Folders button or by dragging and dropping them into the main window of Dr. Folder.</p>
- <h3>Step 3: Click on the Restore Default Icon button</h3>
- <p>You can find this button at the top of the window next to the Icons button.</p>
- <h3>Step 4: Confirm the changes and revert to the original folder icons</h3>
- <p>A pop-up window will ask you if you are sure you want to restore the default icon for your folders.</p>
- <p>Click Yes to confirm and No to cancel.</p>
- <p>You have successfully restored the default icons for all folders on Windows with Dr. Folder.</p>
- <h2>Conclusion</h2>
- <p>In this article, we have shown you how to change icons for all folders on Windows with Dr. Folder, a folder icon changer software that can make your folders more personalized and organized.</p>
- <p>We have also shown you how to restore the default icons for all folders on Windows with Dr. Folder in case you want to undo your changes.</p>
- <p>We hope you have enjoyed this article and found it useful.</p>
- <h2>FAQs</h2>
-<ul>
-<li><b>Q: How much does Dr. Folder cost?</b></li>
-<li>A: Dr. Folder is not a free software but it offers a free trial version that allows you to change up to three folder icons per day.</li>
-<li><b>Q: How can I get more icons for Dr. Folder?</b></li>
-<li>A: You can download more icons from various websites online or create your own icons using an icon editor software.</li>
-<li><b>Q: Can I change system folder icons with Dr. Folder?</b></li>
-<li>A: Yes, you can change system folder icons such as My Computer, Recycle Bin, Network, etc., but be careful not to mess up your system settings.</li>
-<li><b>Q: Can I change file icons with Dr. Folder?</b></li>
-<li>A: No, Dr. Folder only works with folder icons not file icons.</li>
-<li><b>Q: Can I undo my changes with Dr. Folder?</b></li>
-<li>A: Yes, you can undo your changes by restoring the default icon for each folder or by using System Restore in Windows.</li>
-</ul>
-</p> 0a6ba089eb<br />
-<br />
-<br />

spaces/1gistliPinn/ChatGPT4/Examples/Audiorealism Bassline 2 Abl2 Crackl [2021].md

@@ -1,6 +0,0 @@
-<h2>Audiorealism Bassline 2 Abl2 Crackl</h2><br /><p><b><b>Download Zip</b> &#10037; <a href="https://imgfil.com/2uxZSt">https://imgfil.com/2uxZSt</a></b></p><br /><br />
-
-Then click the Open button. Installation on Windows 10 or later. Sometimes Windows will give you a warning when you run the installer. If the software. NET Framework is not installed, you will be prompted to: Run the .NET Framework installer, or Run the .NET Framework installer You can now start installing the .NET Framework software. Once the installation is complete (usually takes one to two minutes), you can proceed to the next step. Run the .NET Framework installer (rather than just running it). Once installed, you can use the Close button to exit the installer. 8a78ff9644<br />
-<br />
-<br />
-<p></p>

spaces/1gistliPinn/ChatGPT4/Examples/Baixarsonar85completoportuguestorrent WORK.md

@@ -1,6 +0,0 @@
-<h2>baixarsonar85completoportuguestorrent</h2><br /><p><b><b>Download File</b> &#9734;&#9734;&#9734;&#9734;&#9734; <a href="https://imgfil.com/2uxZWZ">https://imgfil.com/2uxZWZ</a></b></p><br /><br />
-
- 3cee63e6c2<br />
-<br />
-<br />
-<p></p>

spaces/1gistliPinn/ChatGPT4/Examples/El Diabolico Inconsciente Pdf Download [TOP].md

@@ -1,5 +0,0 @@
-<br />
-<p>babahiddenz. el diabolico, 1939. Consciencia dei profeti antichissimi libro di. Diabola, diabolico inconsciente, vita di uranus diabolo, cultura dell'antichristo, diabolico incansante. Diablo inconsciente - Authobiografia - Segunda edición y correo electrónico - PDF bajo licencia. El Diabolo Inconsciente, o Diabolo Insane. Inconsciente, el diabolo y el propio, fueron los ponentes de la guerra n. El Diabolo Inconsciente. El Diabolo Insane. Inconsciente, el diabolo y el propio, fueron los ponentes de la gu. El Diabolo Inconsciente, o Diabolo Insane. Inconsciente, el diabolo y el propio, fueron los ponentes de la gu. El Diabolo Inconsciente, o Diabolo Insane. Inconsciente, el diabolo y el propio, fueron los ponentes de la gu. El Diabolo Inconsciente, o Diabolo Insane. Inconsciente, el diabolo y el propio, fueron los ponentes de la gu. El Diabolo Inconsciente, o Diabolo Insane. Inconsciente, el diabolo y el propio, fueron los ponentes de la gu. El Diabolo Inconsciente, o Diabolo Insane. Inconsciente, el diabolo y el propio, fueron los ponentes de la gu. El Diabolo Inconsciente, o Diabolo Insane. Inconsciente, el diabolo y el propio, fueron los ponentes de la gu. El Diabolo Inconsciente, o Diabolo Insane. Inconsciente, el diabolo y el propio, fueron los ponentes de la gu. El Diabolo Inconsciente, o Diabolo Insane. Inconsciente, el diabolo y el propio, fueron los ponentes de la gu. El Diabolo Inconsciente, o Diabolo Insane. Inconsciente, el diabolo y el propio, fueron los ponentes de la gu. El Diabolo Inconsciente, o Diabolo Insane. Inconsciente, el diabolo y el propio, fueron los ponentes de la gu. El Diabolo Inconsciente, o Diabolo Insane. Inconsciente, el diabolo y el propio, fueron los ponentes de la gu. El Diabolo Inconsciente, o Diabolo Insane. Inconsciente, el diabolo y el propio, fueron los ponentes de la gu. El Diabolo Inconsciente, o Diabolo Insane. Inconsciente, el diabolo y el propio, fueron los ponentes de la gu. El Diabolo Inconsciente, o Diabolo Insane.</p>
-<h2>el diabolico inconsciente pdf download</h2><br /><p><b><b>DOWNLOAD</b> &#9658; <a href="https://imgfil.com/2uy1oQ">https://imgfil.com/2uy1oQ</a></b></p><br /><br /> 899543212b<br />
-<br />
-<br />

spaces/1line/AutoGPT/autogpt/workspace.py

@@ -1,47 +0,0 @@
-from __future__ import annotations
-
-import os
-from pathlib import Path
-
-from autogpt.config import Config
-
-CFG = Config()
-
-# Set a dedicated folder for file I/O
-WORKSPACE_PATH = Path(os.getcwd()) / "auto_gpt_workspace"
-
-# Create the directory if it doesn't exist
-if not os.path.exists(WORKSPACE_PATH):
-    os.makedirs(WORKSPACE_PATH)
-
-
-def path_in_workspace(relative_path: str | Path) -> Path:
-    """Get full path for item in workspace
-
-    Parameters:
-        relative_path (str | Path): Path to translate into the workspace
-
-    Returns:
-        Path: Absolute path for the given path in the workspace
-    """
-    return safe_path_join(WORKSPACE_PATH, relative_path)
-
-
-def safe_path_join(base: Path, *paths: str | Path) -> Path:
-    """Join one or more path components, asserting the resulting path is within the workspace.
-
-    Args:
-        base (Path): The base path
-        *paths (str): The paths to join to the base path
-
-    Returns:
-        Path: The joined path
-    """
-    joined_path = base.joinpath(*paths).resolve()
-
-    if CFG.restrict_to_workspace and not joined_path.is_relative_to(base):
-        raise ValueError(
-            f"Attempted to access path '{joined_path}' outside of workspace '{base}'."
-        )
-
-    return joined_path

spaces/1phancelerku/anime-remove-background/Enjoy the Best Soccer Experience with Real Football 2009 - Download Now.md

@@ -1,139 +0,0 @@
-<br />
-<h1>Download 2009 Real Football: A Review of the Best Soccer Game for Nintendo DS</h1>
-<p>If you are a fan of soccer, you probably know that there are many games available for different platforms. But if you own a Nintendo DS, you might be wondering which one is the best. Well, look no further than 2009 Real Football, also known as Real Soccer 2009 in some regions. This game is widely considered as the definitive soccer title for the DS, offering a never-before-seen experience with its unique features and capabilities. In this article, we will review 2009 Real Football and show you how to download it for your device.</p>
-<h2>download 2009 real football</h2><br /><p><b><b>Download Zip</b> &rArr; <a href="https://jinyurl.com/2uNUqC">https://jinyurl.com/2uNUqC</a></b></p><br /><br />
- <h2>Introduction</h2>
-<h3>What is 2009 Real Football?</h3>
-<p>2009 Real Football is a soccer game developed by Gameloft and published by Ubisoft for the Nintendo DS in 2008. It is part of the long-running Real Football series, which started in 2004 for mobile phones. The game features over 200 teams and players from around the world, including licensed ones from FIFA. It also boasts realistic physics, animations, and sound effects that make you feel like you are on the pitch.</p>
- <h3>Why should you download it?</h3>
-<p>There are many reasons why you should download 2009 Real Football for your Nintendo DS. Here are some of them:</p>
-<ul>
-<li>It is one of the few soccer games that use the touch screen and stylus of the DS, allowing you to control your players with precision and accuracy.</li>
-<li>It has a variety of game modes and options, such as exhibition, league, cup, penalty shootout, training, and custom matches. You can also create your own team and player with the editor mode.</li>
-<li>It has an online multiplayer mode that lets you play with or against other players around the world via Wi-Fi or Bluetooth. You can also join the online community and chat with other fans, share your scores, and download new content.</li>
-</ul>
- <h2>Features of 2009 Real Football</h2>
-<h3>Realistic graphics and animations</h3>
-<p>One of the most impressive aspects of 2009 Real Football is its graphics and animations. The game uses a 3D engine that renders the players, stadiums, and crowds in high detail. The players have realistic faces, expressions, movements, and reactions that match their real-life counterparts. The stadiums are based on real ones from different countries, such as Wembley, Camp Nou, or Maracana. The crowds are also lively and responsive, cheering or booing depending on the situation.</p>
- <h3>Various game modes and options</h3>
-<p>Another great feature of 2009 Real Football is its variety of game modes and options. You can choose from different types of matches, such as exhibition, league, cup, penalty shootout, training, or custom. You can also adjust the difficulty level, time limit, weather conditions, camera angles, and rules to suit your preference. You can also create your own team and player with the editor mode, where you can customize their name, appearance, skills, nationality, and position.</p>
-<p>download 2009 real football java game<br />
-download 2009 real football for android<br />
-download 2009 real football apk<br />
-download 2009 real football jar<br />
-download 2009 real football mobile game<br />
-download 2009 real football 3d<br />
-download 2009 real football hd<br />
-download 2009 real football for nokia<br />
-download 2009 real football for samsung<br />
-download 2009 real football for pc<br />
-download 2009 real football mod apk<br />
-download 2009 real football gameloft<br />
-download 2009 real football free<br />
-download 2009 real football full version<br />
-download 2009 real football offline<br />
-download 2009 real football online<br />
-download 2009 real football multiplayer<br />
-download 2009 real football cheats<br />
-download 2009 real football hack<br />
-download 2009 real football unlimited money<br />
-download 2009 real football latest version<br />
-download 2009 real football old version<br />
-download 2009 real football update<br />
-download 2009 real football patch<br />
-download 2009 real football crack<br />
-download 2009 real football serial key<br />
-download 2009 real football license key<br />
-download 2009 real football activation key<br />
-download 2009 real football registration key<br />
-download 2009 real football product key<br />
-download 2009 real football review<br />
-download 2009 real football gameplay<br />
-download 2009 real football trailer<br />
-download 2009 real football video<br />
-download 2009 real football tips and tricks<br />
-download 2009 real football guide and walkthrough<br />
-download 2009 real football best players and teams<br />
-download 2009 real football skills and goals<br />
-download 2009 real football tournaments and leagues<br />
-download 2009 real football stadiums and kits<br />
-how to download 2009 real football on android phone or tablet?<br />
-how to install and play 2009 real football on pc or laptop?<br />
-how to run and enjoy 2009 real football on java or symbian device?<br />
-where to find and get the link to download 2009 real football?<br />
-what are the requirements and specifications to download and play 2009 real football?</p>
- <h3>Online multiplayer and community</h3>
-<p>The last but not least feature of 2009 Real Football is its online multiplayer and community. You can connect your Nintendo DS to the internet via Wi-Fi or Bluetooth and play with or against other players around the world. You can also join the online community and chat with other fans, share your scores, and download new content. You can also access the official website of the game and get updates, news, tips, tricks, and more.</p>
- <h2>How to download 2009 Real Football</h2>
-<h3>Requirements and compatibility</ <h3>Requirements and compatibility</h3>
-<p>Before you download 2009 Real Football, you need to make sure that your Nintendo DS meets the requirements and compatibility of the game. Here are some of them:</p>
-<ul>
-<li>You need a Nintendo DS or DS Lite device with a working touch screen and stylus. The game is not compatible with the DSi or 3DS models.</li>
-<li>You need a Wi-Fi or Bluetooth connection to access the online features of the game. You also need a Nintendo Wi-Fi Connection account and a friend code to play with other players.</li>
-<li>You need at least 64 MB of free space on your DS card to save the game data. You can also use a microSD card to store additional content.</li>
-</ul>
- <h3>Sources and links</h3>
-<p>There are different sources and links where you can download 2009 Real Football for your Nintendo DS. Here are some of them:</p>
-<table>
-<tr>
-<th>Source</th>
-<th>Link</th>
-</tr>
-<tr>
-<td>Nintendo eShop</td>
-<td><a href="">https://www.nintendo.com/games/detail/real-soccer-2009-ds/</a></td>
-</tr>
-<tr>
-<td>Gameloft official website</td>
-<td><a href="">https://www.gameloft.com/en/game/real-football-2009-ds/</a></td>
-</tr>
-<tr>
-<td>Ubisoft official website</td>
-<td><a href="">https://www.ubisoft.com/en-us/game/real-football-2009-ds/</a></td>
-</tr>
-<tr>
-<td>Amazon</td>
-<td><a href="">https://www.amazon.com/Real-Soccer-2009-Nintendo-DS/dp/B001E27DLM/</a></td>
-</tr>
-<tr>
-<td>eBay</td>
-<td><a href="">https://www.ebay.com/sch/i.html?_nkw=real+football+2009+ds</a></td>
-</tr>
-</table>
- <h3>Installation and setup</h3>
-<p>After you download 2009 Real Football from one of the sources and links above, you need to install and set up the game on your Nintendo DS. Here are the steps:</p>
-<ol>
-<li>Insert the game card into the slot of your DS device and turn it on.</li>
-<li>Select the game icon from the menu and press A to start.</li>
-<li>Follow the instructions on the screen to create your profile, choose your language, and adjust your settings.</li>
-<li>Enjoy playing 2009 Real Football on your Nintendo DS!</li>
-</ol>
- <h2>Conclusion</h2> <h3>Summary of the main points</h3>
-<p>In this article, we have reviewed 2009 Real Football, the best soccer game for Nintendo DS. We have discussed its features, such as realistic graphics and animations, various game modes and options, and online multiplayer and community. We have also shown you how to download it from different sources and links, and how to install and set up it on your device.</p>
- <h3>Recommendations and ratings</h3>
-<p>We highly recommend 2009 Real Football to anyone who loves soccer and owns a Nintendo DS. It is a fun, challenging, and immersive game that will keep you entertained for hours. It is also a great way to connect with other players and fans around the world. We give it a rating of 4.5 out of 5 stars, based on its gameplay, graphics, sound, and online features.</p>
- <h3>Call to action</h3>
-<p>If you are interested in downloading 2009 Real Football for your Nintendo DS, don't hesitate to do so. You can find it on the Nintendo eShop, Gameloft official website, Ubisoft official website, Amazon, or eBay. You can also visit the official website of the game for more information and updates. Don't miss this opportunity to enjoy the best soccer game for Nintendo DS!</p>
- <h2>FAQs</h2>
-<p>Here are some frequently asked questions about 2009 Real Football:</p>
-<ul>
-<li><b>Q: How much does 2009 Real Football cost?</b></li>
-<li>A: The game costs $19.99 on the Nintendo eShop, Gameloft official website, and Ubisoft official website. It may vary on Amazon or eBay depending on the seller.</li>
-<li><b>Q: How many players can play 2009 Real Football online?</b></li>
-<li>A: The game supports up to four players online via Wi-Fi or Bluetooth. You can play with or against your friends or strangers from around the world.</li>
-<li><b>Q: What are the benefits of joining the online community of 2009 Real Football?</b></li>
-<li>A: By joining the online community of 2009 Real Football, you can chat with other fans, share your scores, and download new content. You can also access the official website of the game and get updates, news, tips, tricks, and more.</li>
-<li><b>Q: How can I create my own team and player in 2009 Real Football?</b></li>
-<li>A: You can create your own team and player in the editor mode of the game. You can customize their name, appearance, skills, nationality, and position. You can also use them in any game mode or online match.</li>
-<li><b>Q: What are some tips and tricks for playing 2009 Real Football?</b></li>
-<li>A: Some tips and tricks for playing 2009 Real Football are:</li>
-<ul>
-<li>Use the touch screen and stylus to control your players with precision and accuracy.</li>
-<li>Experiment with different game modes and options to find your preferred style.</li>
-<li>Practice your skills in the training mode or penalty shootout mode.</li>
-<li>Learn from your opponents and improve your strategies in the online mode.</li>
-<li>Have fun and enjoy the game!</li>
-</ul>
-</ul></p> 401be4b1e0<br />
-<br />
-<br />

spaces/1toTree/lora_test/ppdiffusers/models/__init__.py

@@ -1,25 +0,0 @@
-# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
-# Copyright 2022 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# flake8: noqa
-
-from ..utils import is_paddle_available
-
-if is_paddle_available():
-    from .attention import Transformer2DModel
-    from .prior_transformer import PriorTransformer
-    from .unet_1d import UNet1DModel
-    from .unet_2d import UNet2DModel
-    from .unet_2d_condition import UNet2DConditionModel
-    from .vae import AutoencoderKL, VQModel

spaces/1toTree/lora_test/ppdiffusers/pipelines/score_sde_ve/pipeline_score_sde_ve.py

@@ -1,100 +0,0 @@
-# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
-# Copyright 2022 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from typing import List, Optional, Tuple, Union
-
-import paddle
-
-from ...models import UNet2DModel
-from ...pipeline_utils import DiffusionPipeline, ImagePipelineOutput
-from ...schedulers import ScoreSdeVeScheduler
-
-
-class ScoreSdeVePipeline(DiffusionPipeline):
-    r"""
-    Parameters:
-    This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods the
-    library implements for all the pipelines (such as downloading or saving, running on a particular xxxx, etc.)
-        unet ([`UNet2DModel`]): U-Net architecture to denoise the encoded image. scheduler ([`SchedulerMixin`]):
-            The [`ScoreSdeVeScheduler`] scheduler to be used in combination with `unet` to denoise the encoded image.
-    """
-    unet: UNet2DModel
-    scheduler: ScoreSdeVeScheduler
-
-    def __init__(self, unet: UNet2DModel, scheduler: DiffusionPipeline):
-        super().__init__()
-        self.register_modules(unet=unet, scheduler=scheduler)
-
-    @paddle.no_grad()
-    def __call__(
-        self,
-        batch_size: int = 1,
-        num_inference_steps: int = 2000,
-        generator: Optional[Union[paddle.Generator, List[paddle.Generator]]] = None,
-        output_type: Optional[str] = "pil",
-        return_dict: bool = True,
-        **kwargs,
-    ) -> Union[ImagePipelineOutput, Tuple]:
-        r"""
-        Args:
-            batch_size (`int`, *optional*, defaults to 1):
-                The number of images to generate.
-            generator (`paddle.Generator`, *optional*):
-                One or a list of paddle generator(s) to make generation deterministic.
-            output_type (`str`, *optional*, defaults to `"pil"`):
-                The output format of the generate image. Choose between
-                [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` or `np.array`.
-            return_dict (`bool`, *optional*, defaults to `True`):
-                Whether or not to return a [`~pipeline_utils.ImagePipelineOutput`] instead of a plain tuple.
-
-        Returns:
-            [`~pipeline_utils.ImagePipelineOutput`] or `tuple`: [`~pipelines.utils.ImagePipelineOutput`] if
-            `return_dict` is True, otherwise a `tuple. When returning a tuple, the first element is a list with the
-            generated images.
-        """
-
-        img_size = self.unet.config.sample_size
-        shape = (batch_size, 3, img_size, img_size)
-
-        model = self.unet
-
-        sample = paddle.randn(shape, generator=generator) * self.scheduler.init_noise_sigma
-
-        self.scheduler.set_timesteps(num_inference_steps)
-        self.scheduler.set_sigmas(num_inference_steps)
-
-        for i, t in enumerate(self.progress_bar(self.scheduler.timesteps)):
-            sigma_t = self.scheduler.sigmas[i] * paddle.ones((shape[0],))
-
-            # correction step
-            for _ in range(self.scheduler.config.correct_steps):
-                model_output = self.unet(sample, sigma_t).sample
-                sample = self.scheduler.step_correct(model_output, sample, generator=generator).prev_sample
-
-            # prediction step
-            model_output = model(sample, sigma_t).sample
-            output = self.scheduler.step_pred(model_output, t, sample, generator=generator)
-
-            sample, sample_mean = output.prev_sample, output.prev_sample_mean
-
-        sample = sample_mean.clip(0, 1)
-        sample = sample.transpose([0, 2, 3, 1]).numpy()
-        if output_type == "pil":
-            sample = self.numpy_to_pil(sample)
-
-        if not return_dict:
-            return (sample,)
-
-        return ImagePipelineOutput(images=sample)

spaces/1toTree/lora_test/ppdiffusers/utils/outputs.py

@@ -1,117 +0,0 @@
-# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
-# Copyright 2022 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""
-Generic utilities
-"""
-
-from collections import OrderedDict
-from dataclasses import fields
-from typing import Any, Tuple
-
-import numpy as np
-
-from .import_utils import is_paddle_available
-
-
-def is_tensor(x):
-    """
-    Tests if `x` is a `paddle.Tensor` or `np.ndarray`.
-    """
-    if is_paddle_available():
-        import paddle
-
-        return paddle.is_tensor(x)
-
-    return isinstance(x, np.ndarray)
-
-
-class BaseOutput(OrderedDict):
-    """
-    Base class for all model outputs as dataclass. Has a `__getitem__` that allows indexing by integer or slice (like a
-    tuple) or strings (like a dictionary) that will ignore the `None` attributes. Otherwise behaves like a regular
-    python dictionary.
-
-    <Tip warning={true}>
-
-    You can't unpack a `BaseOutput` directly. Use the [`~utils.BaseOutput.to_tuple`] method to convert it to a tuple
-    before.
-
-    </Tip>
-    """
-
-    def __post_init__(self):
-        class_fields = fields(self)
-
-        # Safety and consistency checks
-        if not len(class_fields):
-            raise ValueError(f"{self.__class__.__name__} has no fields.")
-
-        first_field = getattr(self, class_fields[0].name)
-        other_fields_are_none = all(getattr(self, field.name) is None for field in class_fields[1:])
-
-        if other_fields_are_none and isinstance(first_field, dict):
-            for key, value in first_field.items():
-                self[key] = value
-        else:
-            for field in class_fields:
-                v = getattr(self, field.name)
-                if v is not None:
-                    self[field.name] = v
-
-    def __delitem__(self, *args, **kwargs):
-        raise Exception(f"You cannot use ``__delitem__`` on a {self.__class__.__name__} instance.")
-
-    def setdefault(self, *args, **kwargs):
-        raise Exception(f"You cannot use ``setdefault`` on a {self.__class__.__name__} instance.")
-
-    def pop(self, *args, **kwargs):
-        raise Exception(f"You cannot use ``pop`` on a {self.__class__.__name__} instance.")
-
-    def update(self, *args, **kwargs):
-        raise Exception(f"You cannot use ``update`` on a {self.__class__.__name__} instance.")
-
-    def __getitem__(self, k):
-        if isinstance(k, str):
-            inner_dict = {k: v for (k, v) in self.items()}
-            return inner_dict[k]
-        else:
-            return self.to_tuple()[k]
-
-    def __setattr__(self, name, value):
-        if name in self.keys() and value is not None:
-            # Don't call self.__setitem__ to avoid recursion errors
-            super().__setitem__(name, value)
-        super().__setattr__(name, value)
-
-    def __setitem__(self, key, value):
-        # Will raise a KeyException if needed
-        super().__setitem__(key, value)
-        # Don't call self.__setattr__ to avoid recursion errors
-        super().__setattr__(key, value)
-
-    def to_tuple(self) -> Tuple[Any]:
-        """
-        Convert self to a tuple containing all the attributes/keys that are not `None`.
-        """
-        # try to fix: https://github.com/PaddlePaddle/PaddleNLP/issues/3355
-        # when trying to get the keys of `OrderedDict`, `keys` method return empty values.
-        # TODO(wj-Mcat): this bug should be fixed in Paddle framework
-        tuples = ()
-        for field in fields(self):
-            if getattr(self, field.name, None) is None:
-                continue
-            tuples = tuples + (getattr(self, field.name),)
-
-        return tuples

spaces/AI-Hobbyist/Hoyo-RVC/Changelog_CN.md

@@ -1,80 +0,0 @@
-### 20230618更新
-- v2增加32k和48k两个新预训练模型
-- 修复非f0模型推理报错
-- 对于超过一小时的训练集的索引建立环节，自动kmeans缩小特征处理以加速索引训练、加入和查询
-- 附送一个人声转吉他玩具仓库
-- 数据处理剔除异常值切片
-- onnx导出选项卡
-
-失败的实验：
-- ~~特征检索增加时序维度：寄，没啥效果~~
-- ~~特征检索增加PCAR降维可选项：寄，数据大用kmeans缩小数据量，数据小降维操作耗时比省下的匹配耗时还多~~
-- ~~支持onnx推理（附带仅推理的小压缩包）：寄，生成nsf还是需要pytorch~~
-- ~~训练时在音高、gender、eq、噪声等方面对输入进行随机增强：寄，没啥效果~~
-
-todolist：
-- 接入小型声码器调研
-- 训练集音高识别支持crepe
-- crepe的精度支持和RVC-config同步
-- 对接F0编辑器
-  
-  
-### 20230528更新
-- 增加v2的jupyter notebook，韩文changelog，增加一些环境依赖
-- 增加呼吸、清辅音、齿音保护模式
-- 支持crepe-full推理
-- UVR5人声伴奏分离加上3个去延迟模型和MDX-Net去混响模型，增加HP3人声提取模型
-- 索引名称增加版本和实验名称
-- 人声伴奏分离、推理批量导出增加音频导出格式选项
-- 废弃32k模型的训练
-
-### 20230513更新
-- 清除一键包内部老版本runtime内残留的infer_pack和uvr5_pack
-- 修复训练集预处理伪多进程的bug
-- 增加harvest识别音高可选通过中值滤波削弱哑音现象，可调整中值滤波半径
-- 导出音频增加后处理重采样
-- 训练n_cpu进程数从"仅调整f0提取"改为"调整数据预处理和f0提取"
-- 自动检测logs文件夹下的index路径，提供下拉列表功能
-- tab页增加"常见问题解答"（也可参考github-rvc-wiki）
-- 相同路径的输入音频推理增加了音高缓存（用途：使用harvest音高提取，整个pipeline会经历漫长且重复的音高提取过程，如果不使用缓存，实验不同音色、索引、音高中值滤波半径参数的用户在第一次测试后的等待结果会非常痛苦）
-
-### 20230514更新
-- 音量包络对齐输入混合（可以缓解“输入静音输出小幅度噪声”的问题。如果输入音频背景底噪大则不建议开启，默认不开启（值为1可视为不开启））
-- 支持按照指定频率保存提取的小模型（假如你想尝试不同epoch下的推理效果，但是不想保存所有大checkpoint并且每次都要ckpt手工处理提取小模型，这项功能会非常实用）
-- 通过设置环境变量解决服务端开了系统全局代理导致浏览器连接错误的问题
-- 支持v2预训练模型（目前只公开了40k版本进行测试，另外2个采样率还没有训练完全）
-- 推理前限制超过1的过大音量
-- 微调数据预处理参数
-
-
-### 20230409更新
-- 修正训练参数，提升显卡平均利用率，A100最高从25%提升至90%左右，V100:50%->90%左右，2060S:60%->85%左右，P40:25%->95%左右，训练速度显著提升
-- 修正参数：总batch_size改为每张卡的batch_size
-- 修正total_epoch：最大限制100解锁至1000；默认10提升至默认20
-- 修复ckpt提取识别是否带音高错误导致推理异常的问题
-- 修复分布式训练每个rank都保存一次ckpt的问题
-- 特征提取进行nan特征过滤
-- 修复静音输入输出随机辅音or噪声的问题（老版模型需要重做训练集重训）
-
-### 20230416更新
-- 新增本地实时变声迷你GUI，双击go-realtime-gui.bat启动
-- 训练推理均对<50Hz的频段进行滤波过滤
-- 训练推理音高提取pyworld最低音高从默认80下降至50,50-80hz间的男声低音不会哑
-- WebUI支持根据系统区域变更语言（现支持en_US，ja_JP，zh_CN，zh_HK，zh_SG，zh_TW，不支持的默认en_US）
-- 修正部分显卡识别（例如V100-16G识别失败，P4识别失败）
-
-### 20230428更新
-- 升级faiss索引设置，速度更快，质量更高
-- 取消total_npy依赖，后续分享模型不再需要填写total_npy
-- 解锁16系限制。4G显存GPU给到4G的推理设置。
-- 修复部分音频格式下UVR5人声伴奏分离的bug
-- 实时变声迷你gui增加对非40k与不懈怠音高模型的支持
-
-### 后续计划：
-功能：
-- 支持多人训练选项卡（至多4人）
-
-底模：
-- 收集呼吸wav加入训练集修正呼吸变声电音的问题
-- 我们正在训练增加了歌声训练集的底模，未来会公开
-

spaces/AIFILMS/ControlNet-Video/model.py

@@ -1,760 +0,0 @@
-# This file is adapted from gradio_*.py in https://github.com/lllyasviel/ControlNet/tree/f4748e3630d8141d7765e2bd9b1e348f47847707
-# The original license file is LICENSE.ControlNet in this repo.
-from __future__ import annotations
-
-import pathlib
-import random
-import shlex
-import subprocess
-import sys
-
-import cv2
-import einops
-import numpy as np
-import torch
-from huggingface_hub import hf_hub_url
-from pytorch_lightning import seed_everything
-
-sys.path.append('ControlNet')
-
-import config
-from annotator.canny import apply_canny
-from annotator.hed import apply_hed, nms
-from annotator.midas import apply_midas
-from annotator.mlsd import apply_mlsd
-from annotator.openpose import apply_openpose
-from annotator.uniformer import apply_uniformer
-from annotator.util import HWC3, resize_image
-from cldm.model import create_model, load_state_dict
-from ldm.models.diffusion.ddim import DDIMSampler
-from share import *
-
-
-MODEL_NAMES = {
-    'canny': 'control_canny-fp16.safetensors',
-    'hough': 'control_mlsd-fp16.safetensors',
-    'hed': 'control_hed-fp16.safetensors',
-    'scribble': 'control_scribble-fp16.safetensors',
-    'pose': 'control_openpose-fp16.safetensors',
-    'seg': 'control_seg-fp16.safetensors',
-    'depth': 'control_depth-fp16.safetensors',
-    'normal': 'control_normal-fp16.safetensors',
-}
-
-MODEL_REPO = 'webui/ControlNet-modules-safetensors'
-
-DEFAULT_BASE_MODEL_REPO = 'runwayml/stable-diffusion-v1-5'
-DEFAULT_BASE_MODEL_FILENAME = 'v1-5-pruned-emaonly.safetensors'
-DEFAULT_BASE_MODEL_URL = 'https://huggingface.co/runwayml/stable-diffusion-v1-5/resolve/main/v1-5-pruned-emaonly.safetensors'
-
-class Model:
-    def __init__(self,
-                 model_config_path: str = 'ControlNet/models/cldm_v15.yaml',
-                 model_dir: str = 'models'):
-        self.device = torch.device(
-            'cuda:0' if torch.cuda.is_available() else 'cpu')
-        self.model = create_model(model_config_path).to(self.device)
-        self.ddim_sampler = DDIMSampler(self.model)
-        self.task_name = ''
-        
-        self.base_model_url = ''
-        
-        self.model_dir = pathlib.Path(model_dir)
-        self.model_dir.mkdir(exist_ok=True, parents=True)
-
-        self.download_models()
-        self.set_base_model(DEFAULT_BASE_MODEL_REPO,
-                            DEFAULT_BASE_MODEL_FILENAME)
-    
-    def set_base_model(self, model_id: str, filename: str) -> str:
-        if not model_id or not filename:
-            return self.base_model_url
-        base_model_url = hf_hub_url(model_id, filename)
-        if base_model_url != self.base_model_url:
-            self.load_base_model(base_model_url)
-            self.base_model_url = base_model_url
-        return self.base_model_url
-
-    
-    def download_base_model(self, model_url: str) -> pathlib.Path:
-        self.model_dir.mkdir(exist_ok=True, parents=True)
-        model_name = model_url.split('/')[-1]
-        out_path = self.model_dir / model_name
-        if not out_path.exists():
-            subprocess.run(shlex.split(f'wget {model_url} -O {out_path}'))
-        return out_path
-
-    def load_base_model(self, model_url: str) -> None:
-        model_path = self.download_base_model(model_url)
-        self.model.load_state_dict(load_state_dict(model_path,
-                                                   location=self.device.type),
-                                   strict=False)
-
-    def load_weight(self, task_name: str) -> None:
-        if task_name == self.task_name:
-            return
-        weight_path = self.get_weight_path(task_name)
-        self.model.control_model.load_state_dict(
-            load_state_dict(weight_path, location=self.device.type))
-        self.task_name = task_name
-
-    def get_weight_path(self, task_name: str) -> str:
-        if 'scribble' in task_name:
-            task_name = 'scribble'
-        return f'{self.model_dir}/{MODEL_NAMES[task_name]}'
-
-    def download_models(self) -> None:
-        self.model_dir.mkdir(exist_ok=True, parents=True)
-        for name in MODEL_NAMES.values():
-            out_path = self.model_dir / name
-            if out_path.exists():
-                continue
-            model_url = hf_hub_url(MODEL_REPO, name)
-            subprocess.run(shlex.split(f'wget {model_url} -O {out_path}'))
-
-    @torch.inference_mode()
-    def process_canny(self, input_image, prompt, a_prompt, n_prompt,
-                      num_samples, image_resolution, ddim_steps, scale, seed,
-                      eta, low_threshold, high_threshold):
-        self.load_weight('canny')
-
-        img = resize_image(HWC3(input_image), image_resolution)
-        H, W, C = img.shape
-
-        detected_map = apply_canny(img, low_threshold, high_threshold)
-        detected_map = HWC3(detected_map)
-
-        control = torch.from_numpy(detected_map.copy()).float().cuda() / 255.0
-        control = torch.stack([control for _ in range(num_samples)], dim=0)
-        control = einops.rearrange(control, 'b h w c -> b c h w').clone()
-
-        if seed == -1:
-            seed = random.randint(0, 65535)
-        seed_everything(seed)
-
-        if config.save_memory:
-            self.model.low_vram_shift(is_diffusing=False)
-
-        cond = {
-            'c_concat': [control],
-            'c_crossattn': [
-                self.model.get_learned_conditioning(
-                    [prompt + ', ' + a_prompt] * num_samples)
-            ]
-        }
-        un_cond = {
-            'c_concat': [control],
-            'c_crossattn':
-            [self.model.get_learned_conditioning([n_prompt] * num_samples)]
-        }
-        shape = (4, H // 8, W // 8)
-
-        if config.save_memory:
-            self.model.low_vram_shift(is_diffusing=True)
-
-        samples, intermediates = self.ddim_sampler.sample(
-            ddim_steps,
-            num_samples,
-            shape,
-            cond,
-            verbose=False,
-            eta=eta,
-            unconditional_guidance_scale=scale,
-            unconditional_conditioning=un_cond)
-
-        if config.save_memory:
-            self.model.low_vram_shift(is_diffusing=False)
-
-        x_samples = self.model.decode_first_stage(samples)
-        x_samples = (
-            einops.rearrange(x_samples, 'b c h w -> b h w c') * 127.5 +
-            127.5).cpu().numpy().clip(0, 255).astype(np.uint8)
-
-        results = [x_samples[i] for i in range(num_samples)]
-        return [255 - detected_map] + results
-
-    @torch.inference_mode()
-    def process_hough(self, input_image, prompt, a_prompt, n_prompt,
-                      num_samples, image_resolution, detect_resolution,
-                      ddim_steps, scale, seed, eta, value_threshold,
-                      distance_threshold):
-        self.load_weight('hough')
-
-        input_image = HWC3(input_image)
-        detected_map = apply_mlsd(resize_image(input_image, detect_resolution),
-                                  value_threshold, distance_threshold)
-        detected_map = HWC3(detected_map)
-        img = resize_image(input_image, image_resolution)
-        H, W, C = img.shape
-
-        detected_map = cv2.resize(detected_map, (W, H),
-                                  interpolation=cv2.INTER_NEAREST)
-
-        control = torch.from_numpy(detected_map.copy()).float().cuda() / 255.0
-        control = torch.stack([control for _ in range(num_samples)], dim=0)
-        control = einops.rearrange(control, 'b h w c -> b c h w').clone()
-
-        if seed == -1:
-            seed = random.randint(0, 65535)
-        seed_everything(seed)
-
-        if config.save_memory:
-            self.model.low_vram_shift(is_diffusing=False)
-
-        cond = {
-            'c_concat': [control],
-            'c_crossattn': [
-                self.model.get_learned_conditioning(
-                    [prompt + ', ' + a_prompt] * num_samples)
-            ]
-        }
-        un_cond = {
-            'c_concat': [control],
-            'c_crossattn':
-            [self.model.get_learned_conditioning([n_prompt] * num_samples)]
-        }
-        shape = (4, H // 8, W // 8)
-
-        if config.save_memory:
-            self.model.low_vram_shift(is_diffusing=True)
-
-        samples, intermediates = self.ddim_sampler.sample(
-            ddim_steps,
-            num_samples,
-            shape,
-            cond,
-            verbose=False,
-            eta=eta,
-            unconditional_guidance_scale=scale,
-            unconditional_conditioning=un_cond)
-
-        if config.save_memory:
-            self.model.low_vram_shift(is_diffusing=False)
-
-        x_samples = self.model.decode_first_stage(samples)
-        x_samples = (
-            einops.rearrange(x_samples, 'b c h w -> b h w c') * 127.5 +
-            127.5).cpu().numpy().clip(0, 255).astype(np.uint8)
-
-        results = [x_samples[i] for i in range(num_samples)]
-        return [
-            255 - cv2.dilate(detected_map,
-                             np.ones(shape=(3, 3), dtype=np.uint8),
-                             iterations=1)
-        ] + results
-
-    @torch.inference_mode()
-    def process_hed(self, input_image, prompt, a_prompt, n_prompt, num_samples,
-                    image_resolution, detect_resolution, ddim_steps, scale,
-                    seed, eta):
-        self.load_weight('hed')
-
-        input_image = HWC3(input_image)
-        detected_map = apply_hed(resize_image(input_image, detect_resolution))
-        detected_map = HWC3(detected_map)
-        img = resize_image(input_image, image_resolution)
-        H, W, C = img.shape
-
-        detected_map = cv2.resize(detected_map, (W, H),
-                                  interpolation=cv2.INTER_LINEAR)
-
-        control = torch.from_numpy(detected_map.copy()).float().cuda() / 255.0
-        control = torch.stack([control for _ in range(num_samples)], dim=0)
-        control = einops.rearrange(control, 'b h w c -> b c h w').clone()
-
-        if seed == -1:
-            seed = random.randint(0, 65535)
-        seed_everything(seed)
-
-        if config.save_memory:
-            self.model.low_vram_shift(is_diffusing=False)
-
-        cond = {
-            'c_concat': [control],
-            'c_crossattn': [
-                self.model.get_learned_conditioning(
-                    [prompt + ', ' + a_prompt] * num_samples)
-            ]
-        }
-        un_cond = {
-            'c_concat': [control],
-            'c_crossattn':
-            [self.model.get_learned_conditioning([n_prompt] * num_samples)]
-        }
-        shape = (4, H // 8, W // 8)
-
-        if config.save_memory:
-            self.model.low_vram_shift(is_diffusing=True)
-
-        samples, intermediates = self.ddim_sampler.sample(
-            ddim_steps,
-            num_samples,
-            shape,
-            cond,
-            verbose=False,
-            eta=eta,
-            unconditional_guidance_scale=scale,
-            unconditional_conditioning=un_cond)
-
-        if config.save_memory:
-            self.model.low_vram_shift(is_diffusing=False)
-
-        x_samples = self.model.decode_first_stage(samples)
-        x_samples = (
-            einops.rearrange(x_samples, 'b c h w -> b h w c') * 127.5 +
-            127.5).cpu().numpy().clip(0, 255).astype(np.uint8)
-
-        results = [x_samples[i] for i in range(num_samples)]
-        return [detected_map] + results
-
-    @torch.inference_mode()
-    def process_scribble(self, input_image, prompt, a_prompt, n_prompt,
-                         num_samples, image_resolution, ddim_steps, scale,
-                         seed, eta):
-        self.load_weight('scribble')
-
-        img = resize_image(HWC3(input_image), image_resolution)
-        H, W, C = img.shape
-
-        detected_map = np.zeros_like(img, dtype=np.uint8)
-        detected_map[np.min(img, axis=2) < 127] = 255
-
-        control = torch.from_numpy(detected_map.copy()).float().cuda() / 255.0
-        control = torch.stack([control for _ in range(num_samples)], dim=0)
-        control = einops.rearrange(control, 'b h w c -> b c h w').clone()
-
-        if seed == -1:
-            seed = random.randint(0, 65535)
-        seed_everything(seed)
-
-        if config.save_memory:
-            self.model.low_vram_shift(is_diffusing=False)
-
-        cond = {
-            'c_concat': [control],
-            'c_crossattn': [
-                self.model.get_learned_conditioning(
-                    [prompt + ', ' + a_prompt] * num_samples)
-            ]
-        }
-        un_cond = {
-            'c_concat': [control],
-            'c_crossattn':
-            [self.model.get_learned_conditioning([n_prompt] * num_samples)]
-        }
-        shape = (4, H // 8, W // 8)
-
-        if config.save_memory:
-            self.model.low_vram_shift(is_diffusing=True)
-
-        samples, intermediates = self.ddim_sampler.sample(
-            ddim_steps,
-            num_samples,
-            shape,
-            cond,
-            verbose=False,
-            eta=eta,
-            unconditional_guidance_scale=scale,
-            unconditional_conditioning=un_cond)
-
-        if config.save_memory:
-            self.model.low_vram_shift(is_diffusing=False)
-
-        x_samples = self.model.decode_first_stage(samples)
-        x_samples = (
-            einops.rearrange(x_samples, 'b c h w -> b h w c') * 127.5 +
-            127.5).cpu().numpy().clip(0, 255).astype(np.uint8)
-
-        results = [x_samples[i] for i in range(num_samples)]
-        return [255 - detected_map] + results
-
-    @torch.inference_mode()
-    def process_scribble_interactive(self, input_image, prompt, a_prompt,
-                                     n_prompt, num_samples, image_resolution,
-                                     ddim_steps, scale, seed, eta):
-        self.load_weight('scribble')
-
-        img = resize_image(HWC3(input_image['mask'][:, :, 0]),
-                           image_resolution)
-        H, W, C = img.shape
-
-        detected_map = np.zeros_like(img, dtype=np.uint8)
-        detected_map[np.min(img, axis=2) > 127] = 255
-
-        control = torch.from_numpy(detected_map.copy()).float().cuda() / 255.0
-        control = torch.stack([control for _ in range(num_samples)], dim=0)
-        control = einops.rearrange(control, 'b h w c -> b c h w').clone()
-
-        if seed == -1:
-            seed = random.randint(0, 65535)
-        seed_everything(seed)
-
-        if config.save_memory:
-            self.model.low_vram_shift(is_diffusing=False)
-
-        cond = {
-            'c_concat': [control],
-            'c_crossattn': [
-                self.model.get_learned_conditioning(
-                    [prompt + ', ' + a_prompt] * num_samples)
-            ]
-        }
-        un_cond = {
-            'c_concat': [control],
-            'c_crossattn':
-            [self.model.get_learned_conditioning([n_prompt] * num_samples)]
-        }
-        shape = (4, H // 8, W // 8)
-
-        if config.save_memory:
-            self.model.low_vram_shift(is_diffusing=True)
-
-        samples, intermediates = self.ddim_sampler.sample(
-            ddim_steps,
-            num_samples,
-            shape,
-            cond,
-            verbose=False,
-            eta=eta,
-            unconditional_guidance_scale=scale,
-            unconditional_conditioning=un_cond)
-
-        if config.save_memory:
-            self.model.low_vram_shift(is_diffusing=False)
-
-        x_samples = self.model.decode_first_stage(samples)
-        x_samples = (
-            einops.rearrange(x_samples, 'b c h w -> b h w c') * 127.5 +
-            127.5).cpu().numpy().clip(0, 255).astype(np.uint8)
-
-        results = [x_samples[i] for i in range(num_samples)]
-        return [255 - detected_map] + results
-
-    @torch.inference_mode()
-    def process_fake_scribble(self, input_image, prompt, a_prompt, n_prompt,
-                              num_samples, image_resolution, detect_resolution,
-                              ddim_steps, scale, seed, eta):
-        self.load_weight('scribble')
-
-        input_image = HWC3(input_image)
-        detected_map = apply_hed(resize_image(input_image, detect_resolution))
-        detected_map = HWC3(detected_map)
-        img = resize_image(input_image, image_resolution)
-        H, W, C = img.shape
-
-        detected_map = cv2.resize(detected_map, (W, H),
-                                  interpolation=cv2.INTER_LINEAR)
-        detected_map = nms(detected_map, 127, 3.0)
-        detected_map = cv2.GaussianBlur(detected_map, (0, 0), 3.0)
-        detected_map[detected_map > 4] = 255
-        detected_map[detected_map < 255] = 0
-
-        control = torch.from_numpy(detected_map.copy()).float().cuda() / 255.0
-        control = torch.stack([control for _ in range(num_samples)], dim=0)
-        control = einops.rearrange(control, 'b h w c -> b c h w').clone()
-
-        if seed == -1:
-            seed = random.randint(0, 65535)
-        seed_everything(seed)
-
-        if config.save_memory:
-            self.model.low_vram_shift(is_diffusing=False)
-
-        cond = {
-            'c_concat': [control],
-            'c_crossattn': [
-                self.model.get_learned_conditioning(
-                    [prompt + ', ' + a_prompt] * num_samples)
-            ]
-        }
-        un_cond = {
-            'c_concat': [control],
-            'c_crossattn':
-            [self.model.get_learned_conditioning([n_prompt] * num_samples)]
-        }
-        shape = (4, H // 8, W // 8)
-
-        if config.save_memory:
-            self.model.low_vram_shift(is_diffusing=True)
-
-        samples, intermediates = self.ddim_sampler.sample(
-            ddim_steps,
-            num_samples,
-            shape,
-            cond,
-            verbose=False,
-            eta=eta,
-            unconditional_guidance_scale=scale,
-            unconditional_conditioning=un_cond)
-
-        if config.save_memory:
-            self.model.low_vram_shift(is_diffusing=False)
-
-        x_samples = self.model.decode_first_stage(samples)
-        x_samples = (
-            einops.rearrange(x_samples, 'b c h w -> b h w c') * 127.5 +
-            127.5).cpu().numpy().clip(0, 255).astype(np.uint8)
-
-        results = [x_samples[i] for i in range(num_samples)]
-        return [255 - detected_map] + results
-
-    @torch.inference_mode()
-    def process_pose(self, input_image, prompt, a_prompt, n_prompt,
-                     num_samples, image_resolution, detect_resolution,
-                     ddim_steps, scale, seed, eta):
-        self.load_weight('pose')
-
-        input_image = HWC3(input_image)
-        detected_map, _ = apply_openpose(
-            resize_image(input_image, detect_resolution))
-        detected_map = HWC3(detected_map)
-        img = resize_image(input_image, image_resolution)
-        H, W, C = img.shape
-
-        detected_map = cv2.resize(detected_map, (W, H),
-                                  interpolation=cv2.INTER_NEAREST)
-
-        control = torch.from_numpy(detected_map.copy()).float().cuda() / 255.0
-        control = torch.stack([control for _ in range(num_samples)], dim=0)
-        control = einops.rearrange(control, 'b h w c -> b c h w').clone()
-
-        if seed == -1:
-            seed = random.randint(0, 65535)
-        seed_everything(seed)
-
-        if config.save_memory:
-            self.model.low_vram_shift(is_diffusing=False)
-
-        cond = {
-            'c_concat': [control],
-            'c_crossattn': [
-                self.model.get_learned_conditioning(
-                    [prompt + ', ' + a_prompt] * num_samples)
-            ]
-        }
-        un_cond = {
-            'c_concat': [control],
-            'c_crossattn':
-            [self.model.get_learned_conditioning([n_prompt] * num_samples)]
-        }
-        shape = (4, H // 8, W // 8)
-
-        if config.save_memory:
-            self.model.low_vram_shift(is_diffusing=True)
-
-        samples, intermediates = self.ddim_sampler.sample(
-            ddim_steps,
-            num_samples,
-            shape,
-            cond,
-            verbose=False,
-            eta=eta,
-            unconditional_guidance_scale=scale,
-            unconditional_conditioning=un_cond)
-
-        if config.save_memory:
-            self.model.low_vram_shift(is_diffusing=False)
-
-        x_samples = self.model.decode_first_stage(samples)
-        x_samples = (
-            einops.rearrange(x_samples, 'b c h w -> b h w c') * 127.5 +
-            127.5).cpu().numpy().clip(0, 255).astype(np.uint8)
-
-        results = [x_samples[i] for i in range(num_samples)]
-        return [detected_map] + results
-
-    @torch.inference_mode()
-    def process_seg(self, input_image, prompt, a_prompt, n_prompt, num_samples,
-                    image_resolution, detect_resolution, ddim_steps, scale,
-                    seed, eta):
-        self.load_weight('seg')
-
-        input_image = HWC3(input_image)
-        detected_map = apply_uniformer(
-            resize_image(input_image, detect_resolution))
-        img = resize_image(input_image, image_resolution)
-        H, W, C = img.shape
-
-        detected_map = cv2.resize(detected_map, (W, H),
-                                  interpolation=cv2.INTER_NEAREST)
-
-        control = torch.from_numpy(detected_map.copy()).float().cuda() / 255.0
-        control = torch.stack([control for _ in range(num_samples)], dim=0)
-        control = einops.rearrange(control, 'b h w c -> b c h w').clone()
-
-        if seed == -1:
-            seed = random.randint(0, 65535)
-        seed_everything(seed)
-
-        if config.save_memory:
-            self.model.low_vram_shift(is_diffusing=False)
-
-        cond = {
-            'c_concat': [control],
-            'c_crossattn': [
-                self.model.get_learned_conditioning(
-                    [prompt + ', ' + a_prompt] * num_samples)
-            ]
-        }
-        un_cond = {
-            'c_concat': [control],
-            'c_crossattn':
-            [self.model.get_learned_conditioning([n_prompt] * num_samples)]
-        }
-        shape = (4, H // 8, W // 8)
-
-        if config.save_memory:
-            self.model.low_vram_shift(is_diffusing=True)
-
-        samples, intermediates = self.ddim_sampler.sample(
-            ddim_steps,
-            num_samples,
-            shape,
-            cond,
-            verbose=False,
-            eta=eta,
-            unconditional_guidance_scale=scale,
-            unconditional_conditioning=un_cond)
-
-        if config.save_memory:
-            self.model.low_vram_shift(is_diffusing=False)
-
-        x_samples = self.model.decode_first_stage(samples)
-        x_samples = (
-            einops.rearrange(x_samples, 'b c h w -> b h w c') * 127.5 +
-            127.5).cpu().numpy().clip(0, 255).astype(np.uint8)
-
-        results = [x_samples[i] for i in range(num_samples)]
-        return [detected_map] + results
-
-    @torch.inference_mode()
-    def process_depth(self, input_image, prompt, a_prompt, n_prompt,
-                      num_samples, image_resolution, detect_resolution,
-                      ddim_steps, scale, seed, eta):
-        self.load_weight('depth')
-
-        input_image = HWC3(input_image)
-        detected_map, _ = apply_midas(
-            resize_image(input_image, detect_resolution))
-        detected_map = HWC3(detected_map)
-        img = resize_image(input_image, image_resolution)
-        H, W, C = img.shape
-
-        detected_map = cv2.resize(detected_map, (W, H),
-                                  interpolation=cv2.INTER_LINEAR)
-
-        control = torch.from_numpy(detected_map.copy()).float().cuda() / 255.0
-        control = torch.stack([control for _ in range(num_samples)], dim=0)
-        control = einops.rearrange(control, 'b h w c -> b c h w').clone()
-
-        if seed == -1:
-            seed = random.randint(0, 65535)
-        seed_everything(seed)
-
-        if config.save_memory:
-            self.model.low_vram_shift(is_diffusing=False)
-
-        cond = {
-            'c_concat': [control],
-            'c_crossattn': [
-                self.model.get_learned_conditioning(
-                    [prompt + ', ' + a_prompt] * num_samples)
-            ]
-        }
-        un_cond = {
-            'c_concat': [control],
-            'c_crossattn':
-            [self.model.get_learned_conditioning([n_prompt] * num_samples)]
-        }
-        shape = (4, H // 8, W // 8)
-
-        if config.save_memory:
-            self.model.low_vram_shift(is_diffusing=True)
-
-        samples, intermediates = self.ddim_sampler.sample(
-            ddim_steps,
-            num_samples,
-            shape,
-            cond,
-            verbose=False,
-            eta=eta,
-            unconditional_guidance_scale=scale,
-            unconditional_conditioning=un_cond)
-
-        if config.save_memory:
-            self.model.low_vram_shift(is_diffusing=False)
-
-        x_samples = self.model.decode_first_stage(samples)
-        x_samples = (
-            einops.rearrange(x_samples, 'b c h w -> b h w c') * 127.5 +
-            127.5).cpu().numpy().clip(0, 255).astype(np.uint8)
-
-        results = [x_samples[i] for i in range(num_samples)]
-        return [detected_map] + results
-
-    @torch.inference_mode()
-    def process_normal(self, input_image, prompt, a_prompt, n_prompt,
-                       num_samples, image_resolution, detect_resolution,
-                       ddim_steps, scale, seed, eta, bg_threshold):
-        self.load_weight('normal')
-
-        input_image = HWC3(input_image)
-        _, detected_map = apply_midas(resize_image(input_image,
-                                                   detect_resolution),
-                                      bg_th=bg_threshold)
-        detected_map = HWC3(detected_map)
-        img = resize_image(input_image, image_resolution)
-        H, W, C = img.shape
-
-        detected_map = cv2.resize(detected_map, (W, H),
-                                  interpolation=cv2.INTER_LINEAR)
-
-        control = torch.from_numpy(
-            detected_map[:, :, ::-1].copy()).float().cuda() / 255.0
-        control = torch.stack([control for _ in range(num_samples)], dim=0)
-        control = einops.rearrange(control, 'b h w c -> b c h w').clone()
-
-        if seed == -1:
-            seed = random.randint(0, 65535)
-        seed_everything(seed)
-
-        if config.save_memory:
-            self.model.low_vram_shift(is_diffusing=False)
-
-        cond = {
-            'c_concat': [control],
-            'c_crossattn': [
-                self.model.get_learned_conditioning(
-                    [prompt + ', ' + a_prompt] * num_samples)
-            ]
-        }
-        un_cond = {
-            'c_concat': [control],
-            'c_crossattn':
-            [self.model.get_learned_conditioning([n_prompt] * num_samples)]
-        }
-        shape = (4, H // 8, W // 8)
-
-        if config.save_memory:
-            self.model.low_vram_shift(is_diffusing=True)
-
-        samples, intermediates = self.ddim_sampler.sample(
-            ddim_steps,
-            num_samples,
-            shape,
-            cond,
-            verbose=False,
-            eta=eta,
-            unconditional_guidance_scale=scale,
-            unconditional_conditioning=un_cond)
-
-        if config.save_memory:
-            self.model.low_vram_shift(is_diffusing=False)
-
-        x_samples = self.model.decode_first_stage(samples)
-        x_samples = (
-            einops.rearrange(x_samples, 'b c h w -> b h w c') * 127.5 +
-            127.5).cpu().numpy().clip(0, 255).astype(np.uint8)
-
-        results = [x_samples[i] for i in range(num_samples)]
-        return [detected_map] + results

spaces/AIGC-Audio/AudioGPT/text_to_audio/Make_An_Audio/ldm/models/autoencoder_multi.py

@@ -1,201 +0,0 @@
-"""
-与autoencoder.py的区别在于，autoencoder.py计算loss时只有一个discriminator，而此处又多了个multiwindowDiscriminator，所以优化器
-优化的参数改为：
-opt_disc = torch.optim.Adam(list(self.loss.discriminator.parameters()) + list(self.loss.discriminator_multi.parameters()),
-                            lr=lr, betas=(0.5, 0.9))
-"""
-
-import os
-import torch
-import pytorch_lightning as pl
-import torch.nn.functional as F
-from contextlib import contextmanager
-
-from packaging import version
-import numpy as np
-from ldm.modules.diffusionmodules.model import Encoder, Decoder
-from ldm.modules.distributions.distributions import DiagonalGaussianDistribution
-from torch.optim.lr_scheduler import LambdaLR
-from ldm.util import instantiate_from_config
-
-
-
-class AutoencoderKL(pl.LightningModule):
-    def __init__(self,
-                 ddconfig,
-                 lossconfig,
-                 embed_dim,
-                 ckpt_path=None,
-                 ignore_keys=[],
-                 image_key="image",
-                 colorize_nlabels=None,
-                 monitor=None,
-                 ):
-        super().__init__()
-        self.image_key = image_key
-        self.encoder = Encoder(**ddconfig)
-        self.decoder = Decoder(**ddconfig)
-        self.loss = instantiate_from_config(lossconfig)
-        assert ddconfig["double_z"]
-        self.quant_conv = torch.nn.Conv2d(2*ddconfig["z_channels"], 2*embed_dim, 1)
-        self.post_quant_conv = torch.nn.Conv2d(embed_dim, ddconfig["z_channels"], 1)
-        self.embed_dim = embed_dim
-        if colorize_nlabels is not None:
-            assert type(colorize_nlabels)==int
-            self.register_buffer("colorize", torch.randn(3, colorize_nlabels, 1, 1))
-        if monitor is not None:
-            self.monitor = monitor
-        if ckpt_path is not None:
-            self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys)
-
-    def init_from_ckpt(self, path, ignore_keys=list()):
-        sd = torch.load(path, map_location="cpu")["state_dict"]
-        keys = list(sd.keys())
-        for k in keys:
-            for ik in ignore_keys:
-                if k.startswith(ik):
-                    print("Deleting key {} from state_dict.".format(k))
-                    del sd[k]
-        self.load_state_dict(sd, strict=False)
-        print(f"Restored from {path}")
-
-    def encode(self, x):
-        h = self.encoder(x)
-        moments = self.quant_conv(h)
-        posterior = DiagonalGaussianDistribution(moments)
-        return posterior
-
-    def decode(self, z):
-        z = self.post_quant_conv(z)
-        dec = self.decoder(z)
-        return dec
-
-    def forward(self, input, sample_posterior=True):
-        posterior = self.encode(input)
-        if sample_posterior:
-            z = posterior.sample()
-        else:
-            z = posterior.mode()
-        dec = self.decode(z)
-        return dec, posterior
-
-    def get_input(self, batch, k):
-        x = batch[k]
-        if len(x.shape) == 3:
-            x = x[..., None]
-        x = x.permute(0, 3, 1, 2).to(memory_format=torch.contiguous_format).float()
-        return x
-
-    def training_step(self, batch, batch_idx, optimizer_idx):
-        inputs = self.get_input(batch, self.image_key)
-        reconstructions, posterior = self(inputs)
-
-        if optimizer_idx == 0:
-            # train encoder+decoder+logvar
-            aeloss, log_dict_ae = self.loss(inputs, reconstructions, posterior, optimizer_idx, self.global_step,
-                                            last_layer=self.get_last_layer(), split="train")
-            self.log("aeloss", aeloss, prog_bar=True, logger=True, on_step=True, on_epoch=True)
-            self.log_dict(log_dict_ae, prog_bar=False, logger=True, on_step=True, on_epoch=False)
-            return aeloss
-
-        if optimizer_idx == 1:
-            # train the discriminator
-            discloss, log_dict_disc = self.loss(inputs, reconstructions, posterior, optimizer_idx, self.global_step,
-                                                last_layer=self.get_last_layer(), split="train")
-
-            self.log("discloss", discloss, prog_bar=True, logger=True, on_step=True, on_epoch=True)
-            self.log_dict(log_dict_disc, prog_bar=False, logger=True, on_step=True, on_epoch=False)
-            return discloss
-
-    def validation_step(self, batch, batch_idx):
-        inputs = self.get_input(batch, self.image_key)
-        reconstructions, posterior = self(inputs)
-        aeloss, log_dict_ae = self.loss(inputs, reconstructions, posterior, 0, self.global_step,
-                                        last_layer=self.get_last_layer(), split="val")
-
-        discloss, log_dict_disc = self.loss(inputs, reconstructions, posterior, 1, self.global_step,
-                                            last_layer=self.get_last_layer(), split="val")
-
-        self.log("val/rec_loss", log_dict_ae["val/rec_loss"])
-        self.log_dict(log_dict_ae)
-        self.log_dict(log_dict_disc)
-        return self.log_dict
-
-    def test_step(self, batch, batch_idx):
-        inputs = self.get_input(batch, self.image_key)# inputs shape:(b,c,mel_len,T) or (b,c,h,w)
-        reconstructions, posterior = self(inputs)# reconstructions:(b,c,mel_len,T) or (b,c,h,w)
-        reconstructions = (reconstructions + 1)/2 # to mel scale
-        test_ckpt_path = os.path.basename(self.trainer.tested_ckpt_path)
-        savedir = os.path.join(self.trainer.log_dir,f'output_imgs_{test_ckpt_path}','fake_class')
-        if not os.path.exists(savedir):
-            os.makedirs(savedir)
-
-        file_names = batch['f_name']
-        # print(f"reconstructions.shape:{reconstructions.shape}",file_names)
-        reconstructions = reconstructions.cpu().numpy().squeeze(1) # squuze channel dim
-        for b in range(reconstructions.shape[0]):
-            vname_num_split_index = file_names[b].rfind('_')# file_names[b]:video_name+'_'+num
-            v_n,num = file_names[b][:vname_num_split_index],file_names[b][vname_num_split_index+1:]
-            save_img_path = os.path.join(savedir,f'{v_n}_sample_{num}.npy')
-            np.save(save_img_path,reconstructions[b])
-        
-        return None
-        
-    def configure_optimizers(self):
-        lr = self.learning_rate
-        opt_ae = torch.optim.Adam(list(self.encoder.parameters())+
-                                  list(self.decoder.parameters())+
-                                  list(self.quant_conv.parameters())+
-                                  list(self.post_quant_conv.parameters()),
-                                  lr=lr, betas=(0.5, 0.9))
-        opt_disc = torch.optim.Adam(list(self.loss.discriminator.parameters()) + list(self.loss.discriminator_multi.parameters()),
-                                    lr=lr, betas=(0.5, 0.9))
-        return [opt_ae, opt_disc], []
-
-    def get_last_layer(self):
-        return self.decoder.conv_out.weight
-
-    @torch.no_grad()
-    def log_images(self, batch, only_inputs=False, **kwargs):
-        log = dict()
-        x = self.get_input(batch, self.image_key)
-        x = x.to(self.device)
-        if not only_inputs:
-            xrec, posterior = self(x)
-            if x.shape[1] > 3:
-                # colorize with random projection
-                assert xrec.shape[1] > 3
-                x = self.to_rgb(x)
-                xrec = self.to_rgb(xrec)
-            log["samples"] = self.decode(torch.randn_like(posterior.sample()))
-            log["reconstructions"] = xrec
-        log["inputs"] = x
-        return log
-
-    def to_rgb(self, x):
-        assert self.image_key == "segmentation"
-        if not hasattr(self, "colorize"):
-            self.register_buffer("colorize", torch.randn(3, x.shape[1], 1, 1).to(x))
-        x = F.conv2d(x, weight=self.colorize)
-        x = 2.*(x-x.min())/(x.max()-x.min()) - 1.
-        return x
-
-
-class IdentityFirstStage(torch.nn.Module):
-    def __init__(self, *args, vq_interface=False, **kwargs):
-        self.vq_interface = vq_interface  # TODO: Should be true by default but check to not break older stuff
-        super().__init__()
-
-    def encode(self, x, *args, **kwargs):
-        return x
-
-    def decode(self, x, *args, **kwargs):
-        return x
-
-    def quantize(self, x, *args, **kwargs):
-        if self.vq_interface:
-            return x, None, [None, None, None]
-        return x
-
-    def forward(self, x, *args, **kwargs):
-        return x

spaces/AILab-CVC/SEED-LLaMA/scripts/start_backend_14b.sh

@@ -1,10 +0,0 @@
-
-python3 gradio_demo/seed_llama_flask.py \
-    --image_transform configs/transform/clip_transform.yaml \
-    --tokenizer configs/tokenizer/seed_llama_tokenizer.yaml \
-    --model configs/llm/seed_llama_14b_8bit.yaml \
-    --port 7890 \
-    --llm_device cuda:0 \
-    --tokenizer_device cuda:0 \
-    --offload_encoder \
-    --offload_decoder 

spaces/Adapter/CoAdapter/ldm/data/dataset_depth.py

@@ -1,35 +0,0 @@
-import json
-import cv2
-import os
-from basicsr.utils import img2tensor
-
-
-class DepthDataset():
-    def __init__(self, meta_file):
-        super(DepthDataset, self).__init__()
-
-        self.files = []
-        with open(meta_file, 'r') as f:
-            lines = f.readlines()
-            for line in lines:
-                img_path = line.strip()
-                depth_img_path = img_path.rsplit('.', 1)[0] + '.depth.png'
-                txt_path = img_path.rsplit('.', 1)[0] + '.txt'
-                self.files.append({'img_path': img_path, 'depth_img_path': depth_img_path, 'txt_path': txt_path})
-
-    def __getitem__(self, idx):
-        file = self.files[idx]
-
-        im = cv2.imread(file['img_path'])
-        im = img2tensor(im, bgr2rgb=True, float32=True) / 255.
-
-        depth = cv2.imread(file['depth_img_path'])  # [:,:,0]
-        depth = img2tensor(depth, bgr2rgb=True, float32=True) / 255.  # [0].unsqueeze(0)#/255.
-
-        with open(file['txt_path'], 'r') as fs:
-            sentence = fs.readline().strip()
-
-        return {'im': im, 'depth': depth, 'sentence': sentence}
-
-    def __len__(self):
-        return len(self.files)

spaces/AiMimicry/sovits-models/cluster/train_cluster.py

@@ -1,89 +0,0 @@
-import os
-from glob import glob
-from pathlib import Path
-import torch
-import logging
-import argparse
-import torch
-import numpy as np
-from sklearn.cluster import KMeans, MiniBatchKMeans
-import tqdm
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-import time
-import random
-
-def train_cluster(in_dir, n_clusters, use_minibatch=True, verbose=False):
-
-    logger.info(f"Loading features from {in_dir}")
-    features = []
-    nums = 0
-    for path in tqdm.tqdm(in_dir.glob("*.soft.pt")):
-        features.append(torch.load(path).squeeze(0).numpy().T)
-        # print(features[-1].shape)
-    features = np.concatenate(features, axis=0)
-    print(nums, features.nbytes/ 1024**2, "MB , shape:",features.shape, features.dtype)
-    features = features.astype(np.float32)
-    logger.info(f"Clustering features of shape: {features.shape}")
-    t = time.time()
-    if use_minibatch:
-        kmeans = MiniBatchKMeans(n_clusters=n_clusters,verbose=verbose, batch_size=4096, max_iter=80).fit(features)
-    else:
-        kmeans = KMeans(n_clusters=n_clusters,verbose=verbose).fit(features)
-    print(time.time()-t, "s")
-
-    x = {
-            "n_features_in_": kmeans.n_features_in_,
-            "_n_threads": kmeans._n_threads,
-            "cluster_centers_": kmeans.cluster_centers_,
-    }
-    print("end")
-
-    return x
-
-
-if __name__ == "__main__":
-
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--dataset', type=Path, default="./dataset/44k",
-                        help='path of training data directory')
-    parser.add_argument('--output', type=Path, default="logs/44k",
-                        help='path of model output directory')
-
-    args = parser.parse_args()
-
-    checkpoint_dir = args.output
-    dataset = args.dataset
-    n_clusters = 10000
-
-    ckpt = {}
-    for spk in os.listdir(dataset):
-        if os.path.isdir(dataset/spk):
-            print(f"train kmeans for {spk}...")
-            in_dir = dataset/spk
-            x = train_cluster(in_dir, n_clusters, verbose=False)
-            ckpt[spk] = x
-
-    checkpoint_path = checkpoint_dir / f"kmeans_{n_clusters}.pt"
-    checkpoint_path.parent.mkdir(exist_ok=True, parents=True)
-    torch.save(
-        ckpt,
-        checkpoint_path,
-    )
-
-
-    # import cluster
-    # for spk in tqdm.tqdm(os.listdir("dataset")):
-    #     if os.path.isdir(f"dataset/{spk}"):
-    #         print(f"start kmeans inference for {spk}...")
-    #         for feature_path in tqdm.tqdm(glob(f"dataset/{spk}/*.discrete.npy", recursive=True)):
-    #             mel_path = feature_path.replace(".discrete.npy",".mel.npy")
-    #             mel_spectrogram = np.load(mel_path)
-    #             feature_len = mel_spectrogram.shape[-1]
-    #             c = np.load(feature_path)
-    #             c = utils.tools.repeat_expand_2d(torch.FloatTensor(c), feature_len).numpy()
-    #             feature = c.T
-    #             feature_class = cluster.get_cluster_result(feature, spk)
-    #             np.save(feature_path.replace(".discrete.npy", ".discrete_class.npy"), feature_class)
-
-

spaces/AkiKagura/Marco-Generation-Img2img/app.py

@@ -1,74 +0,0 @@
-import gradio as gr
-import torch
-#from torch import autocast // only for GPU
-
-from PIL import Image
-import numpy as np
-from io import BytesIO
-import os
-MY_SECRET_TOKEN=os.environ.get('HF_TOKEN_SD')
-
-#from diffusers import StableDiffusionPipeline
-from diffusers import StableDiffusionImg2ImgPipeline
-
-def empty_checker(images, **kwargs): return images, False
-
-print("hello")
-
-YOUR_TOKEN=MY_SECRET_TOKEN
-
-device="cpu"
-
-# img2img pipeline
-img_pipe = StableDiffusionImg2ImgPipeline.from_pretrained("AkiKagura/mkgen-diffusion", duse_auth_token=YOUR_TOKEN)
-img_pipe.safety_checker = empty_checker
-img_pipe.to(device)
-
-source_img = gr.Image(source="upload", type="filepath", label="init_img")
-gallery = gr.Gallery(label="Generated images", show_label=False, elem_id="gallery").style(grid=[1], height="auto")
-
-def resize(img):
-  #baseheight = value
-  img = Image.open(img)
-  #hpercent = (baseheight/float(img.size[1]))
-  #wsize = int((float(img.size[0])*float(hpercent)))
-  #img = img.resize((wsize,baseheight), Image.Resampling.LANCZOS)
-  hsize = img.size[1]
-  wsize = img.size[0]
-  if 6*wsize <= 5*hsize:
-      wsize = 512
-      hsize = 768
-  elif 4*wsize >= 5*hsize:
-      wsize = 768
-      hsize = 512
-  else:
-      wsize = 512
-      hsize = 512
-  img = img.resize((wsize,hsize), Image.Resampling.LANCZOS)
-  return img, wsize, hsize
-
-
-def infer(source_img, prompt, guide, steps, seed, strength): 
-    generator = torch.Generator('cpu').manual_seed(seed)
-    
-    source_image, img_w, img_h = resize(source_img)
-    source_image.save('source.png')
-    images_list = img_pipe([prompt] * 1, init_image=source_image, strength=strength, guidance_scale=guide, num_inference_steps=steps, width=img_w, height=img_h)
-    images = []
-    
-    for i, image in enumerate(images_list["images"]):
-            images.append(image)    
-    return images
-
-print("done")
-
-title="Marco Generation Img2img"
-description="<p style='text-align: center;'>Upload your image and input 'mkmk woman' to get Marco image. <br />Warning: Slow process... about 10 min inference time.</p>" 
-
-gr.Interface(fn=infer, inputs=[source_img,
-    "text",
-    gr.Slider(2, 15, value = 7, label = 'Guidence Scale'),
-    gr.Slider(10, 50, value = 25, step = 1, label = 'Number of Iterations'),
-    gr.Slider(label = "Seed", minimum = 0, maximum = 2147483647, step = 1, randomize = True),
-    gr.Slider(label='Strength', minimum = 0, maximum = 1, step = .05, value = .75)],
-    outputs=gallery,title=title,description=description, allow_flagging="manual", flagging_dir="flagged").queue(max_size=100).launch(enable_queue=True)

spaces/Alesteba/NeRF_ficus-pxl/README.md

@@ -1,12 +0,0 @@
----
-title: NeRF Ficus-pxl
-emoji: 🐠
-colorFrom: indigo
-colorTo: blue
-sdk: streamlit
-sdk_version: 1.17.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/Andy1621/uniformer_image_detection/configs/detectors/cascade_rcnn_r50_sac_1x_coco.py

@@ -1,12 +0,0 @@
-_base_ = [
-    '../_base_/models/cascade_rcnn_r50_fpn.py',
-    '../_base_/datasets/coco_detection.py',
-    '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py'
-]
-
-model = dict(
-    backbone=dict(
-        type='DetectoRS_ResNet',
-        conv_cfg=dict(type='ConvAWS'),
-        sac=dict(type='SAC', use_deform=True),
-        stage_with_sac=(False, True, True, True)))

spaces/Andy1621/uniformer_image_detection/configs/lvis/mask_rcnn_x101_32x4d_fpn_sample1e-3_mstrain_2x_lvis_v0.5.py

@@ -1,13 +0,0 @@
-_base_ = './mask_rcnn_r50_fpn_sample1e-3_mstrain_2x_lvis_v0.5.py'
-model = dict(
-    pretrained='open-mmlab://resnext101_32x4d',
-    backbone=dict(
-        type='ResNeXt',
-        depth=101,
-        groups=32,
-        base_width=4,
-        num_stages=4,
-        out_indices=(0, 1, 2, 3),
-        frozen_stages=1,
-        norm_cfg=dict(type='BN', requires_grad=True),
-        style='pytorch'))

spaces/Andy1621/uniformer_image_detection/configs/retinanet/retinanet_x101_32x4d_fpn_1x_coco.py

@@ -1,13 +0,0 @@
-_base_ = './retinanet_r50_fpn_1x_coco.py'
-model = dict(
-    pretrained='open-mmlab://resnext101_32x4d',
-    backbone=dict(
-        type='ResNeXt',
-        depth=101,
-        groups=32,
-        base_width=4,
-        num_stages=4,
-        out_indices=(0, 1, 2, 3),
-        frozen_stages=1,
-        norm_cfg=dict(type='BN', requires_grad=True),
-        style='pytorch'))

spaces/AngoHF/ANGO-Leaderboard/assets/color.py

@@ -1,8 +0,0 @@
-color_dict = {
-    '言语理解与表达': '#B22222',
-    '数量关系': '#CC6600',
-    '判断推理': '#CC9900',
-    '资料分析': '#228B22',
-    '常识判断': '#0077BE',
-    '': '#9400D3'
-}

spaces/Anthony7906/MengHuiMXD_GPT/modules/models.py

@@ -1,625 +0,0 @@
-from __future__ import annotations
-from typing import TYPE_CHECKING, List
-
-import logging
-import json
-import commentjson as cjson
-import os
-import sys
-import requests
-import urllib3
-import platform
-import base64
-from io import BytesIO
-from PIL import Image
-
-from tqdm import tqdm
-import colorama
-from duckduckgo_search import ddg
-import asyncio
-import aiohttp
-from enum import Enum
-import uuid
-
-from .presets import *
-from .llama_func import *
-from .utils import *
-from . import shared
-from .config import retrieve_proxy
-from modules import config
-from .base_model import BaseLLMModel, ModelType
-
-
-class OpenAIClient(BaseLLMModel):
-    def __init__(
-        self,
-        model_name,
-        api_key,
-        system_prompt=INITIAL_SYSTEM_PROMPT,
-        temperature=1.0,
-        top_p=1.0,
-    ) -> None:
-        super().__init__(
-            model_name=model_name,
-            temperature=temperature,
-            top_p=top_p,
-            system_prompt=system_prompt,
-        )
-        self.api_key = api_key
-        self.need_api_key = True
-        self._refresh_header()
-
-    def get_answer_stream_iter(self):
-        response = self._get_response(stream=True)
-        if response is not None:
-            iter = self._decode_chat_response(response)
-            partial_text = ""
-            for i in iter:
-                partial_text += i
-                yield partial_text
-        else:
-            yield STANDARD_ERROR_MSG + GENERAL_ERROR_MSG
-
-    def get_answer_at_once(self):
-        response = self._get_response()
-        response = json.loads(response.text)
-        content = response["choices"][0]["message"]["content"]
-        total_token_count = response["usage"]["total_tokens"]
-        return content, total_token_count
-
-    def count_token(self, user_input):
-        input_token_count = count_token(construct_user(user_input))
-        if self.system_prompt is not None and len(self.all_token_counts) == 0:
-            system_prompt_token_count = count_token(
-                construct_system(self.system_prompt)
-            )
-            return input_token_count + system_prompt_token_count
-        return input_token_count
-
-    def billing_info(self):
-        try:
-            curr_time = datetime.datetime.now()
-            last_day_of_month = get_last_day_of_month(
-                curr_time).strftime("%Y-%m-%d")
-            first_day_of_month = curr_time.replace(day=1).strftime("%Y-%m-%d")
-            usage_url = f"{shared.state.usage_api_url}?start_date={first_day_of_month}&end_date={last_day_of_month}"
-            try:
-                usage_data = self._get_billing_data(usage_url)
-            except Exception as e:
-                logging.error(f"获取API使用情况失败:" + str(e))
-                return i18n("**获取API使用情况失败**")
-            rounded_usage = "{:.5f}".format(usage_data["total_usage"] / 100)
-            return i18n("**本月使用金额** ") + f"\u3000 ${rounded_usage}"
-        except requests.exceptions.ConnectTimeout:
-            status_text = (
-                STANDARD_ERROR_MSG + CONNECTION_TIMEOUT_MSG + ERROR_RETRIEVE_MSG
-            )
-            return status_text
-        except requests.exceptions.ReadTimeout:
-            status_text = STANDARD_ERROR_MSG + READ_TIMEOUT_MSG + ERROR_RETRIEVE_MSG
-            return status_text
-        except Exception as e:
-            import traceback
-            traceback.print_exc()
-            logging.error(i18n("获取API使用情况失败:") + str(e))
-            return STANDARD_ERROR_MSG + ERROR_RETRIEVE_MSG
-
-    def set_token_upper_limit(self, new_upper_limit):
-        pass
-
-    @shared.state.switching_api_key  # 在不开启多账号模式的时候，这个装饰器不会起作用
-    def _get_response(self, stream=False):
-        openai_api_key = self.api_key
-        system_prompt = self.system_prompt
-        history = self.history
-        logging.debug(colorama.Fore.YELLOW +
-                      f"{history}" + colorama.Fore.RESET)
-        headers = {
-            "Content-Type": "application/json",
-            "Authorization": f"Bearer {openai_api_key}",
-        }
-
-        if system_prompt is not None:
-            history = [construct_system(system_prompt), *history]
-
-        payload = {
-            "model": self.model_name,
-            "messages": history,
-            "temperature": self.temperature,
-            "top_p": self.top_p,
-            "n": self.n_choices,
-            "stream": stream,
-            "presence_penalty": self.presence_penalty,
-            "frequency_penalty": self.frequency_penalty,
-        }
-
-        if self.max_generation_token is not None:
-            payload["max_tokens"] = self.max_generation_token
-        if self.stop_sequence is not None:
-            payload["stop"] = self.stop_sequence
-        if self.logit_bias is not None:
-            payload["logit_bias"] = self.logit_bias
-        if self.user_identifier is not None:
-            payload["user"] = self.user_identifier
-
-        if stream:
-            timeout = TIMEOUT_STREAMING
-        else:
-            timeout = TIMEOUT_ALL
-
-        # 如果有自定义的api-host，使用自定义host发送请求，否则使用默认设置发送请求
-        if shared.state.completion_url != COMPLETION_URL:
-            logging.info(f"使用自定义API URL: {shared.state.completion_url}")
-
-        with retrieve_proxy():
-            try:
-                response = requests.post(
-                    shared.state.completion_url,
-                    headers=headers,
-                    json=payload,
-                    stream=stream,
-                    timeout=timeout,
-                )
-            except:
-                return None
-        return response
-
-    def _refresh_header(self):
-        self.headers = {
-            "Content-Type": "application/json",
-            "Authorization": f"Bearer {self.api_key}",
-        }
-
-    def _get_billing_data(self, billing_url):
-        with retrieve_proxy():
-            response = requests.get(
-                billing_url,
-                headers=self.headers,
-                timeout=TIMEOUT_ALL,
-            )
-
-        if response.status_code == 200:
-            data = response.json()
-            return data
-        else:
-            raise Exception(
-                f"API request failed with status code {response.status_code}: {response.text}"
-            )
-
-    def _decode_chat_response(self, response):
-        error_msg = ""
-        for chunk in response.iter_lines():
-            if chunk:
-                chunk = chunk.decode()
-                chunk_length = len(chunk)
-                try:
-                    chunk = json.loads(chunk[6:])
-                except json.JSONDecodeError:
-                    print(i18n("JSON解析错误,收到的内容: ") + f"{chunk}")
-                    error_msg += chunk
-                    continue
-                if chunk_length > 6 and "delta" in chunk["choices"][0]:
-                    if chunk["choices"][0]["finish_reason"] == "stop":
-                        break
-                    try:
-                        yield chunk["choices"][0]["delta"]["content"]
-                    except Exception as e:
-                        # logging.error(f"Error: {e}")
-                        continue
-        if error_msg:
-            raise Exception(error_msg)
-
-    def set_key(self, new_access_key):
-        ret = super().set_key(new_access_key)
-        self._refresh_header()
-        return ret
-
-
-class ChatGLM_Client(BaseLLMModel):
-    def __init__(self, model_name) -> None:
-        super().__init__(model_name=model_name)
-        from transformers import AutoTokenizer, AutoModel
-        import torch
-        global CHATGLM_TOKENIZER, CHATGLM_MODEL
-        if CHATGLM_TOKENIZER is None or CHATGLM_MODEL is None:
-            system_name = platform.system()
-            model_path = None
-            if os.path.exists("models"):
-                model_dirs = os.listdir("models")
-                if model_name in model_dirs:
-                    model_path = f"models/{model_name}"
-            if model_path is not None:
-                model_source = model_path
-            else:
-                model_source = f"THUDM/{model_name}"
-            CHATGLM_TOKENIZER = AutoTokenizer.from_pretrained(
-                model_source, trust_remote_code=True
-            )
-            quantified = False
-            if "int4" in model_name:
-                quantified = True
-            model = AutoModel.from_pretrained(
-                    model_source, trust_remote_code=True
-                )
-            if torch.cuda.is_available():
-                # run on CUDA
-                logging.info("CUDA is available, using CUDA")
-                model = model.half().cuda()
-            # mps加速还存在一些问题，暂时不使用
-            elif system_name == "Darwin" and model_path is not None and not quantified:
-                logging.info("Running on macOS, using MPS")
-                # running on macOS and model already downloaded
-                model = model.half().to("mps")
-            else:
-                logging.info("GPU is not available, using CPU")
-                model = model.float()
-            model = model.eval()
-            CHATGLM_MODEL = model
-
-    def _get_glm_style_input(self):
-        history = [x["content"] for x in self.history]
-        query = history.pop()
-        logging.debug(colorama.Fore.YELLOW +
-                      f"{history}" + colorama.Fore.RESET)
-        assert (
-            len(history) % 2 == 0
-        ), f"History should be even length. current history is: {history}"
-        history = [[history[i], history[i + 1]]
-                   for i in range(0, len(history), 2)]
-        return history, query
-
-    def get_answer_at_once(self):
-        history, query = self._get_glm_style_input()
-        response, _ = CHATGLM_MODEL.chat(
-            CHATGLM_TOKENIZER, query, history=history)
-        return response, len(response)
-
-    def get_answer_stream_iter(self):
-        history, query = self._get_glm_style_input()
-        for response, history in CHATGLM_MODEL.stream_chat(
-            CHATGLM_TOKENIZER,
-            query,
-            history,
-            max_length=self.token_upper_limit,
-            top_p=self.top_p,
-            temperature=self.temperature,
-        ):
-            yield response
-
-
-class LLaMA_Client(BaseLLMModel):
-    def __init__(
-        self,
-        model_name,
-        lora_path=None,
-    ) -> None:
-        super().__init__(model_name=model_name)
-        from lmflow.datasets.dataset import Dataset
-        from lmflow.pipeline.auto_pipeline import AutoPipeline
-        from lmflow.models.auto_model import AutoModel
-        from lmflow.args import ModelArguments, DatasetArguments, InferencerArguments
-
-        self.max_generation_token = 1000
-        self.end_string = "\n\n"
-        # We don't need input data
-        data_args = DatasetArguments(dataset_path=None)
-        self.dataset = Dataset(data_args)
-        self.system_prompt = ""
-
-        global LLAMA_MODEL, LLAMA_INFERENCER
-        if LLAMA_MODEL is None or LLAMA_INFERENCER is None:
-            model_path = None
-            if os.path.exists("models"):
-                model_dirs = os.listdir("models")
-                if model_name in model_dirs:
-                    model_path = f"models/{model_name}"
-            if model_path is not None:
-                model_source = model_path
-            else:
-                model_source = f"decapoda-research/{model_name}"
-                # raise Exception(f"models目录下没有这个模型: {model_name}")
-            if lora_path is not None:
-                lora_path = f"lora/{lora_path}"
-            model_args = ModelArguments(model_name_or_path=model_source, lora_model_path=lora_path, model_type=None, config_overrides=None, config_name=None, tokenizer_name=None, cache_dir=None,
-                                        use_fast_tokenizer=True, model_revision='main', use_auth_token=False, torch_dtype=None, use_lora=False, lora_r=8, lora_alpha=32, lora_dropout=0.1, use_ram_optimized_load=True)
-            pipeline_args = InferencerArguments(
-                local_rank=0, random_seed=1, deepspeed='configs/ds_config_chatbot.json', mixed_precision='bf16')
-
-            with open(pipeline_args.deepspeed, "r") as f:
-                ds_config = json.load(f)
-            LLAMA_MODEL = AutoModel.get_model(
-                model_args,
-                tune_strategy="none",
-                ds_config=ds_config,
-            )
-            LLAMA_INFERENCER = AutoPipeline.get_pipeline(
-                pipeline_name="inferencer",
-                model_args=model_args,
-                data_args=data_args,
-                pipeline_args=pipeline_args,
-            )
-
-    def _get_llama_style_input(self):
-        history = []
-        instruction = ""
-        if self.system_prompt:
-            instruction = (f"Instruction: {self.system_prompt}\n")
-        for x in self.history:
-            if x["role"] == "user":
-                history.append(f"{instruction}Input: {x['content']}")
-            else:
-                history.append(f"Output: {x['content']}")
-        context = "\n\n".join(history)
-        context += "\n\nOutput: "
-        return context
-
-    def get_answer_at_once(self):
-        context = self._get_llama_style_input()
-
-        input_dataset = self.dataset.from_dict(
-            {"type": "text_only", "instances": [{"text": context}]}
-        )
-
-        output_dataset = LLAMA_INFERENCER.inference(
-            model=LLAMA_MODEL,
-            dataset=input_dataset,
-            max_new_tokens=self.max_generation_token,
-            temperature=self.temperature,
-        )
-
-        response = output_dataset.to_dict()["instances"][0]["text"]
-        return response, len(response)
-
-    def get_answer_stream_iter(self):
-        context = self._get_llama_style_input()
-        partial_text = ""
-        step = 1
-        for _ in range(0, self.max_generation_token, step):
-            input_dataset = self.dataset.from_dict(
-                {"type": "text_only", "instances": [
-                    {"text": context + partial_text}]}
-            )
-            output_dataset = LLAMA_INFERENCER.inference(
-                model=LLAMA_MODEL,
-                dataset=input_dataset,
-                max_new_tokens=step,
-                temperature=self.temperature,
-            )
-            response = output_dataset.to_dict()["instances"][0]["text"]
-            if response == "" or response == self.end_string:
-                break
-            partial_text += response
-            yield partial_text
-
-
-class XMChat(BaseLLMModel):
-    def __init__(self, api_key):
-        super().__init__(model_name="xmchat")
-        self.api_key = api_key
-        self.session_id = None
-        self.reset()
-        self.image_bytes = None
-        self.image_path = None
-        self.xm_history = []
-        self.url = "https://xmbot.net/web"
-        self.last_conv_id = None
-
-    def reset(self):
-        self.session_id = str(uuid.uuid4())
-        self.last_conv_id = None
-        return [], "已重置"
-
-    def image_to_base64(self, image_path):
-        # 打开并加载图片
-        img = Image.open(image_path)
-
-        # 获取图片的宽度和高度
-        width, height = img.size
-
-        # 计算压缩比例，以确保最长边小于4096像素
-        max_dimension = 2048
-        scale_ratio = min(max_dimension / width, max_dimension / height)
-
-        if scale_ratio < 1:
-            # 按压缩比例调整图片大小
-            new_width = int(width * scale_ratio)
-            new_height = int(height * scale_ratio)
-            img = img.resize((new_width, new_height), Image.ANTIALIAS)
-
-        # 将图片转换为jpg格式的二进制数据
-        buffer = BytesIO()
-        if img.mode == "RGBA":
-            img = img.convert("RGB")
-        img.save(buffer, format='JPEG')
-        binary_image = buffer.getvalue()
-
-        # 对二进制数据进行Base64编码
-        base64_image = base64.b64encode(binary_image).decode('utf-8')
-
-        return base64_image
-
-    def try_read_image(self, filepath):
-        def is_image_file(filepath):
-            # 判断文件是否为图片
-            valid_image_extensions = [".jpg", ".jpeg", ".png", ".bmp", ".gif", ".tiff"]
-            file_extension = os.path.splitext(filepath)[1].lower()
-            return file_extension in valid_image_extensions
-
-        if is_image_file(filepath):
-            logging.info(f"读取图片文件: {filepath}")
-            self.image_bytes = self.image_to_base64(filepath)
-            self.image_path = filepath
-        else:
-            self.image_bytes = None
-            self.image_path = None
-
-    def like(self):
-        if self.last_conv_id is None:
-            return "点赞失败，你还没发送过消息"
-        data = {
-            "uuid": self.last_conv_id,
-            "appraise": "good"
-        }
-        response = requests.post(self.url, json=data)
-        return "👍点赞成功，，感谢反馈～"
-
-    def dislike(self):
-        if self.last_conv_id is None:
-            return "点踩失败，你还没发送过消息"
-        data = {
-            "uuid": self.last_conv_id,
-            "appraise": "bad"
-        }
-        response = requests.post(self.url, json=data)
-        return "👎点踩成功，感谢反馈～"
-
-    def prepare_inputs(self, real_inputs, use_websearch, files, reply_language, chatbot):
-        fake_inputs = real_inputs
-        display_append = ""
-        limited_context = False
-        return limited_context, fake_inputs, display_append, real_inputs, chatbot
-
-    def handle_file_upload(self, files, chatbot):
-        """if the model accepts multi modal input, implement this function"""
-        if files:
-            for file in files:
-                if file.name:
-                    logging.info(f"尝试读取图像: {file.name}")
-                    self.try_read_image(file.name)
-            if self.image_path is not None:
-                chatbot = chatbot + [((self.image_path,), None)]
-            if self.image_bytes is not None:
-                logging.info("使用图片作为输入")
-                # XMChat的一轮对话中实际上只能处理一张图片
-                self.reset()
-                conv_id = str(uuid.uuid4())
-                data = {
-                    "user_id": self.api_key,
-                    "session_id": self.session_id,
-                    "uuid": conv_id,
-                    "data_type": "imgbase64",
-                    "data": self.image_bytes
-                }
-                response = requests.post(self.url, json=data)
-                response = json.loads(response.text)
-                logging.info(f"图片回复: {response['data']}")
-        return None, chatbot, None
-
-    def get_answer_at_once(self):
-        question = self.history[-1]["content"]
-        conv_id = str(uuid.uuid4())
-        self.last_conv_id = conv_id
-        data = {
-            "user_id": self.api_key,
-            "session_id": self.session_id,
-            "uuid": conv_id,
-            "data_type": "text",
-            "data": question
-        }
-        response = requests.post(self.url, json=data)
-        try:
-            response = json.loads(response.text)
-            return response["data"], len(response["data"])
-        except Exception as e:
-            return response.text, len(response.text)
-
-
-
-
-def get_model(
-    model_name,
-    lora_model_path=None,
-    access_key=None,
-    temperature=None,
-    top_p=None,
-    system_prompt=None,
-) -> BaseLLMModel:
-    msg = i18n("模型设置为了：") + f" {model_name}"
-    model_type = ModelType.get_type(model_name)
-    lora_selector_visibility = False
-    lora_choices = []
-    dont_change_lora_selector = False
-    if model_type != ModelType.OpenAI:
-        config.local_embedding = True
-    # del current_model.model
-    model = None
-    try:
-        if model_type == ModelType.OpenAI:
-            logging.info(f"正在加载OpenAI模型: {model_name}")
-            model = OpenAIClient(
-                model_name=model_name,
-                api_key=access_key,
-                system_prompt=system_prompt,
-                temperature=temperature,
-                top_p=top_p,
-            )
-        elif model_type == ModelType.ChatGLM:
-            logging.info(f"正在加载ChatGLM模型: {model_name}")
-            model = ChatGLM_Client(model_name)
-        elif model_type == ModelType.LLaMA and lora_model_path == "":
-            msg = f"现在请为 {model_name} 选择LoRA模型"
-            logging.info(msg)
-            lora_selector_visibility = True
-            if os.path.isdir("lora"):
-                lora_choices = get_file_names(
-                    "lora", plain=True, filetypes=[""])
-            lora_choices = ["No LoRA"] + lora_choices
-        elif model_type == ModelType.LLaMA and lora_model_path != "":
-            logging.info(f"正在加载LLaMA模型: {model_name} + {lora_model_path}")
-            dont_change_lora_selector = True
-            if lora_model_path == "No LoRA":
-                lora_model_path = None
-                msg += " + No LoRA"
-            else:
-                msg += f" + {lora_model_path}"
-            model = LLaMA_Client(model_name, lora_model_path)
-        elif model_type == ModelType.XMChat:
-            if os.environ.get("XMCHAT_API_KEY") != "":
-                access_key = os.environ.get("XMCHAT_API_KEY")
-            model = XMChat(api_key=access_key)
-        elif model_type == ModelType.Unknown:
-            raise ValueError(f"未知模型: {model_name}")
-        logging.info(msg)
-    except Exception as e:
-        logging.error(e)
-        msg = f"{STANDARD_ERROR_MSG}: {e}"
-    if dont_change_lora_selector:
-        return model, msg
-    else:
-        return model, msg, gr.Dropdown.update(choices=lora_choices, visible=lora_selector_visibility)
-
-
-if __name__ == "__main__":
-    with open("config.json", "r") as f:
-        openai_api_key = cjson.load(f)["openai_api_key"]
-    # set logging level to debug
-    logging.basicConfig(level=logging.DEBUG)
-    # client = ModelManager(model_name="gpt-3.5-turbo", access_key=openai_api_key)
-    client = get_model(model_name="chatglm-6b-int4")
-    chatbot = []
-    stream = False
-    # 测试账单功能
-    logging.info(colorama.Back.GREEN + "测试账单功能" + colorama.Back.RESET)
-    logging.info(client.billing_info())
-    # 测试问答
-    logging.info(colorama.Back.GREEN + "测试问答" + colorama.Back.RESET)
-    question = "巴黎是中国的首都吗？"
-    for i in client.predict(inputs=question, chatbot=chatbot, stream=stream):
-        logging.info(i)
-    logging.info(f"测试问答后history : {client.history}")
-    # 测试记忆力
-    logging.info(colorama.Back.GREEN + "测试记忆力" + colorama.Back.RESET)
-    question = "我刚刚问了你什么问题？"
-    for i in client.predict(inputs=question, chatbot=chatbot, stream=stream):
-        logging.info(i)
-    logging.info(f"测试记忆力后history : {client.history}")
-    # 测试重试功能
-    logging.info(colorama.Back.GREEN + "测试重试功能" + colorama.Back.RESET)
-    for i in client.retry(chatbot=chatbot, stream=stream):
-        logging.info(i)
-    logging.info(f"重试后history : {client.history}")
-    # # 测试总结功能
-    # print(colorama.Back.GREEN + "测试总结功能" + colorama.Back.RESET)
-    # chatbot, msg = client.reduce_token_size(chatbot=chatbot)
-    # print(chatbot, msg)
-    # print(f"总结后history: {client.history}")

spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/rich/_ratio.py

@@ -1,160 +0,0 @@
-import sys
-from fractions import Fraction
-from math import ceil
-from typing import cast, List, Optional, Sequence
-
-if sys.version_info >= (3, 8):
-    from typing import Protocol
-else:
-    from pip._vendor.typing_extensions import Protocol  # pragma: no cover
-
-
-class Edge(Protocol):
-    """Any object that defines an edge (such as Layout)."""
-
-    size: Optional[int] = None
-    ratio: int = 1
-    minimum_size: int = 1
-
-
-def ratio_resolve(total: int, edges: Sequence[Edge]) -> List[int]:
-    """Divide total space to satisfy size, ratio, and minimum_size, constraints.
-
-    The returned list of integers should add up to total in most cases, unless it is
-    impossible to satisfy all the constraints. For instance, if there are two edges
-    with a minimum size of 20 each and `total` is 30 then the returned list will be
-    greater than total. In practice, this would mean that a Layout object would
-    clip the rows that would overflow the screen height.
-
-    Args:
-        total (int): Total number of characters.
-        edges (List[Edge]): Edges within total space.
-
-    Returns:
-        List[int]: Number of characters for each edge.
-    """
-    # Size of edge or None for yet to be determined
-    sizes = [(edge.size or None) for edge in edges]
-
-    _Fraction = Fraction
-
-    # While any edges haven't been calculated
-    while None in sizes:
-        # Get flexible edges and index to map these back on to sizes list
-        flexible_edges = [
-            (index, edge)
-            for index, (size, edge) in enumerate(zip(sizes, edges))
-            if size is None
-        ]
-        # Remaining space in total
-        remaining = total - sum(size or 0 for size in sizes)
-        if remaining <= 0:
-            # No room for flexible edges
-            return [
-                ((edge.minimum_size or 1) if size is None else size)
-                for size, edge in zip(sizes, edges)
-            ]
-        # Calculate number of characters in a ratio portion
-        portion = _Fraction(
-            remaining, sum((edge.ratio or 1) for _, edge in flexible_edges)
-        )
-
-        # If any edges will be less than their minimum, replace size with the minimum
-        for index, edge in flexible_edges:
-            if portion * edge.ratio <= edge.minimum_size:
-                sizes[index] = edge.minimum_size
-                # New fixed size will invalidate calculations, so we need to repeat the process
-                break
-        else:
-            # Distribute flexible space and compensate for rounding error
-            # Since edge sizes can only be integers we need to add the remainder
-            # to the following line
-            remainder = _Fraction(0)
-            for index, edge in flexible_edges:
-                size, remainder = divmod(portion * edge.ratio + remainder, 1)
-                sizes[index] = size
-            break
-    # Sizes now contains integers only
-    return cast(List[int], sizes)
-
-
-def ratio_reduce(
-    total: int, ratios: List[int], maximums: List[int], values: List[int]
-) -> List[int]:
-    """Divide an integer total in to parts based on ratios.
-
-    Args:
-        total (int): The total to divide.
-        ratios (List[int]): A list of integer ratios.
-        maximums (List[int]): List of maximums values for each slot.
-        values (List[int]): List of values
-
-    Returns:
-        List[int]: A list of integers guaranteed to sum to total.
-    """
-    ratios = [ratio if _max else 0 for ratio, _max in zip(ratios, maximums)]
-    total_ratio = sum(ratios)
-    if not total_ratio:
-        return values[:]
-    total_remaining = total
-    result: List[int] = []
-    append = result.append
-    for ratio, maximum, value in zip(ratios, maximums, values):
-        if ratio and total_ratio > 0:
-            distributed = min(maximum, round(ratio * total_remaining / total_ratio))
-            append(value - distributed)
-            total_remaining -= distributed
-            total_ratio -= ratio
-        else:
-            append(value)
-    return result
-
-
-def ratio_distribute(
-    total: int, ratios: List[int], minimums: Optional[List[int]] = None
-) -> List[int]:
-    """Distribute an integer total in to parts based on ratios.
-
-    Args:
-        total (int): The total to divide.
-        ratios (List[int]): A list of integer ratios.
-        minimums (List[int]): List of minimum values for each slot.
-
-    Returns:
-        List[int]: A list of integers guaranteed to sum to total.
-    """
-    if minimums:
-        ratios = [ratio if _min else 0 for ratio, _min in zip(ratios, minimums)]
-    total_ratio = sum(ratios)
-    assert total_ratio > 0, "Sum of ratios must be > 0"
-
-    total_remaining = total
-    distributed_total: List[int] = []
-    append = distributed_total.append
-    if minimums is None:
-        _minimums = [0] * len(ratios)
-    else:
-        _minimums = minimums
-    for ratio, minimum in zip(ratios, _minimums):
-        if total_ratio > 0:
-            distributed = max(minimum, ceil(ratio * total_remaining / total_ratio))
-        else:
-            distributed = total_remaining
-        append(distributed)
-        total_ratio -= ratio
-        total_remaining -= distributed
-    return distributed_total
-
-
-if __name__ == "__main__":
-    from dataclasses import dataclass
-
-    @dataclass
-    class E:
-
-        size: Optional[int] = None
-        ratio: int = 1
-        minimum_size: int = 1
-
-    resolved = ratio_resolve(110, [E(None, 1, 1), E(None, 1, 1), E(None, 1, 1)])
-    print(sum(resolved))

spaces/AttendAndExcite/Attend-and-Excite/README.md

@@ -1,15 +0,0 @@
----
-title: Attend And Excite
-emoji: 💻
-colorFrom: gray
-colorTo: pink
-sdk: gradio
-sdk_version: 3.47.1
-python_version: 3.10.13
-app_file: app.py
-pinned: false
-license: mit
-suggested_hardware: a10g-small
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/BAAI/AltDiffusion-m9/header.html

@@ -1,43 +0,0 @@
-<div style="text-align: center; max-width: 650px; margin: 0 auto;">
-    <div
-      style="
-        display: inline-flex;
-        gap: 0.8rem;
-        font-size: 1.75rem;
-        margin-bottom: 10px;
-        width: 600px;
-        height: 200px;
-        margin: 0 auto;
-        /* border: 1px solid red; */
-        justify-content: center;
-      "
-      
-    <a href="https://github.com/FlagAI-Open/FlagAI"><img src="https://raw.githubusercontent.com/920232796/test/master/WechatIMG6906.png" alt="FlagAI" width="80%" height="80%" style="margin: 0 auto;"></a>
-    </div> 
-    <div
-      style="
-        display: inline-flex;
-        align-items: center;
-        gap: 0.8rem;
-        font-size: 1.75rem;
-        margin-bottom: 10px;
-        justify-content: center;
-      ">
-    <a href="https://github.com/FlagAI-Open/FlagAI"><h1 style="font-weight: 900; margin-bottom: 7px;">
-      FlagStudio
-    </h1></a>
-    </div> 
-    <p style="margin-bottom: 10px; font-size: 94%">
-      FlagStudio 项目致力于贡献优秀AI生成艺术作品。此九语文生图模型项目基于 <a href="https://huggingface.co/CompVis/stable-diffusion" style="text-decoration: underline;">stable diffusion</a>，由BAAI旗下的FlagAI团队提供支持，相关代码和模型权重在<a href="https://github.com/FlagAI-Open/FlagAI/tree/master/examples/AltDiffusion" style="text-decoration: underline;">AltDiffusion</a>中进行开源。
-    </p>
-    <p style="margin-bottom: 10px; font-size: 94%">
-      FlagStudio aims to provide high-quality AI-generated artwork. Our current multilingual model is based on the original  <a href="https://huggingface.co/CompVis/stable-diffusion" style="text-decoration: underline;">stable diffusion</a> model and is capable to generate images from both Chinese and English text. FlagStudio is developed and supported by the FlagAI team. Relevant code and model weights released in <a href="https://github.com/FlagAI-Open/FlagAI/tree/master/examples/AltDiffusion" style="text-decoration: underline;">AltDiffusion-m9</a>.（[email protected]）
-    </p>
-    <p style="margin-bottom: 10px; font-size: 94%">
-    AltDiffusion has been added to 🧨Diffusers, see the documentation page: <a href="https://huggingface.co/docs/diffusers/main/en/api/pipelines/alt_diffusion">🧨 Pipeline doc</a>         
-    </p>
-    <p style="margin-bottom: 10px; font-size: 94%; text-align: left;">
-    我们在colab设置了一个脚本，你可以在colab试用我们的模型!(We have a script on colab, You can try our models on colab.Enjoy it!)
-    <a href="https://colab.research.google.com/drive/1htPovT5YNutl2i31mIYrOzlIgGLm06IX#scrollTo=0KXFRkjG1RVk"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"></a>  
-    </p>    
-  </div>

spaces/Badaleeloveashley/badaleeloveashley/app.py

@@ -1,3 +0,0 @@
-import gradio as gr
-
-gr.Interface.load('huggingface/gpt2').Iaunch()

spaces/Bart92/RVC_HF/infer/lib/uvr5_pack/lib_v5/nets_123821KB.py

@@ -1,122 +0,0 @@
-import torch
-import torch.nn.functional as F
-from torch import nn
-
-from . import layers_123821KB as layers
-
-
-class BaseASPPNet(nn.Module):
-    def __init__(self, nin, ch, dilations=(4, 8, 16)):
-        super(BaseASPPNet, self).__init__()
-        self.enc1 = layers.Encoder(nin, ch, 3, 2, 1)
-        self.enc2 = layers.Encoder(ch, ch * 2, 3, 2, 1)
-        self.enc3 = layers.Encoder(ch * 2, ch * 4, 3, 2, 1)
-        self.enc4 = layers.Encoder(ch * 4, ch * 8, 3, 2, 1)
-
-        self.aspp = layers.ASPPModule(ch * 8, ch * 16, dilations)
-
-        self.dec4 = layers.Decoder(ch * (8 + 16), ch * 8, 3, 1, 1)
-        self.dec3 = layers.Decoder(ch * (4 + 8), ch * 4, 3, 1, 1)
-        self.dec2 = layers.Decoder(ch * (2 + 4), ch * 2, 3, 1, 1)
-        self.dec1 = layers.Decoder(ch * (1 + 2), ch, 3, 1, 1)
-
-    def __call__(self, x):
-        h, e1 = self.enc1(x)
-        h, e2 = self.enc2(h)
-        h, e3 = self.enc3(h)
-        h, e4 = self.enc4(h)
-
-        h = self.aspp(h)
-
-        h = self.dec4(h, e4)
-        h = self.dec3(h, e3)
-        h = self.dec2(h, e2)
-        h = self.dec1(h, e1)
-
-        return h
-
-
-class CascadedASPPNet(nn.Module):
-    def __init__(self, n_fft):
-        super(CascadedASPPNet, self).__init__()
-        self.stg1_low_band_net = BaseASPPNet(2, 32)
-        self.stg1_high_band_net = BaseASPPNet(2, 32)
-
-        self.stg2_bridge = layers.Conv2DBNActiv(34, 16, 1, 1, 0)
-        self.stg2_full_band_net = BaseASPPNet(16, 32)
-
-        self.stg3_bridge = layers.Conv2DBNActiv(66, 32, 1, 1, 0)
-        self.stg3_full_band_net = BaseASPPNet(32, 64)
-
-        self.out = nn.Conv2d(64, 2, 1, bias=False)
-        self.aux1_out = nn.Conv2d(32, 2, 1, bias=False)
-        self.aux2_out = nn.Conv2d(32, 2, 1, bias=False)
-
-        self.max_bin = n_fft // 2
-        self.output_bin = n_fft // 2 + 1
-
-        self.offset = 128
-
-    def forward(self, x, aggressiveness=None):
-        mix = x.detach()
-        x = x.clone()
-
-        x = x[:, :, : self.max_bin]
-
-        bandw = x.size()[2] // 2
-        aux1 = torch.cat(
-            [
-                self.stg1_low_band_net(x[:, :, :bandw]),
-                self.stg1_high_band_net(x[:, :, bandw:]),
-            ],
-            dim=2,
-        )
-
-        h = torch.cat([x, aux1], dim=1)
-        aux2 = self.stg2_full_band_net(self.stg2_bridge(h))
-
-        h = torch.cat([x, aux1, aux2], dim=1)
-        h = self.stg3_full_band_net(self.stg3_bridge(h))
-
-        mask = torch.sigmoid(self.out(h))
-        mask = F.pad(
-            input=mask,
-            pad=(0, 0, 0, self.output_bin - mask.size()[2]),
-            mode="replicate",
-        )
-
-        if self.training:
-            aux1 = torch.sigmoid(self.aux1_out(aux1))
-            aux1 = F.pad(
-                input=aux1,
-                pad=(0, 0, 0, self.output_bin - aux1.size()[2]),
-                mode="replicate",
-            )
-            aux2 = torch.sigmoid(self.aux2_out(aux2))
-            aux2 = F.pad(
-                input=aux2,
-                pad=(0, 0, 0, self.output_bin - aux2.size()[2]),
-                mode="replicate",
-            )
-            return mask * mix, aux1 * mix, aux2 * mix
-        else:
-            if aggressiveness:
-                mask[:, :, : aggressiveness["split_bin"]] = torch.pow(
-                    mask[:, :, : aggressiveness["split_bin"]],
-                    1 + aggressiveness["value"] / 3,
-                )
-                mask[:, :, aggressiveness["split_bin"] :] = torch.pow(
-                    mask[:, :, aggressiveness["split_bin"] :],
-                    1 + aggressiveness["value"],
-                )
-
-            return mask * mix
-
-    def predict(self, x_mag, aggressiveness=None):
-        h = self.forward(x_mag, aggressiveness)
-
-        if self.offset > 0:
-            h = h[:, :, :, self.offset : -self.offset]
-            assert h.size()[3] > 0
-
-        return h

spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/chardet/escsm.py

@@ -1,261 +0,0 @@
-######################## BEGIN LICENSE BLOCK ########################
-# The Original Code is mozilla.org code.
-#
-# The Initial Developer of the Original Code is
-# Netscape Communications Corporation.
-# Portions created by the Initial Developer are Copyright (C) 1998
-# the Initial Developer. All Rights Reserved.
-#
-# Contributor(s):
-#   Mark Pilgrim - port to Python
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License,  or (at your option) any later version.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not,  write to the Free Software
-# Foundation,  Inc.,  51 Franklin St,  Fifth Floor,  Boston,  MA
-# 02110-1301  USA
-######################### END LICENSE BLOCK #########################
-
-from .codingstatemachinedict import CodingStateMachineDict
-from .enums import MachineState
-
-# fmt: off
-HZ_CLS = (
-    1, 0, 0, 0, 0, 0, 0, 0,  # 00 - 07
-    0, 0, 0, 0, 0, 0, 0, 0,  # 08 - 0f
-    0, 0, 0, 0, 0, 0, 0, 0,  # 10 - 17
-    0, 0, 0, 1, 0, 0, 0, 0,  # 18 - 1f
-    0, 0, 0, 0, 0, 0, 0, 0,  # 20 - 27
-    0, 0, 0, 0, 0, 0, 0, 0,  # 28 - 2f
-    0, 0, 0, 0, 0, 0, 0, 0,  # 30 - 37
-    0, 0, 0, 0, 0, 0, 0, 0,  # 38 - 3f
-    0, 0, 0, 0, 0, 0, 0, 0,  # 40 - 47
-    0, 0, 0, 0, 0, 0, 0, 0,  # 48 - 4f
-    0, 0, 0, 0, 0, 0, 0, 0,  # 50 - 57
-    0, 0, 0, 0, 0, 0, 0, 0,  # 58 - 5f
-    0, 0, 0, 0, 0, 0, 0, 0,  # 60 - 67
-    0, 0, 0, 0, 0, 0, 0, 0,  # 68 - 6f
-    0, 0, 0, 0, 0, 0, 0, 0,  # 70 - 77
-    0, 0, 0, 4, 0, 5, 2, 0,  # 78 - 7f
-    1, 1, 1, 1, 1, 1, 1, 1,  # 80 - 87
-    1, 1, 1, 1, 1, 1, 1, 1,  # 88 - 8f
-    1, 1, 1, 1, 1, 1, 1, 1,  # 90 - 97
-    1, 1, 1, 1, 1, 1, 1, 1,  # 98 - 9f
-    1, 1, 1, 1, 1, 1, 1, 1,  # a0 - a7
-    1, 1, 1, 1, 1, 1, 1, 1,  # a8 - af
-    1, 1, 1, 1, 1, 1, 1, 1,  # b0 - b7
-    1, 1, 1, 1, 1, 1, 1, 1,  # b8 - bf
-    1, 1, 1, 1, 1, 1, 1, 1,  # c0 - c7
-    1, 1, 1, 1, 1, 1, 1, 1,  # c8 - cf
-    1, 1, 1, 1, 1, 1, 1, 1,  # d0 - d7
-    1, 1, 1, 1, 1, 1, 1, 1,  # d8 - df
-    1, 1, 1, 1, 1, 1, 1, 1,  # e0 - e7
-    1, 1, 1, 1, 1, 1, 1, 1,  # e8 - ef
-    1, 1, 1, 1, 1, 1, 1, 1,  # f0 - f7
-    1, 1, 1, 1, 1, 1, 1, 1,  # f8 - ff
-)
-
-HZ_ST = (
-MachineState.START, MachineState.ERROR,      3, MachineState.START, MachineState.START, MachineState.START, MachineState.ERROR, MachineState.ERROR, # 00-07
-MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, MachineState.ITS_ME, MachineState.ITS_ME, MachineState.ITS_ME, MachineState.ITS_ME, # 08-0f
-MachineState.ITS_ME, MachineState.ITS_ME, MachineState.ERROR, MachineState.ERROR, MachineState.START, MachineState.START,      4, MachineState.ERROR, # 10-17
-     5, MachineState.ERROR,      6, MachineState.ERROR,      5,      5,      4, MachineState.ERROR, # 18-1f
-     4, MachineState.ERROR,      4,      4,      4, MachineState.ERROR,      4, MachineState.ERROR, # 20-27
-     4, MachineState.ITS_ME, MachineState.START, MachineState.START, MachineState.START, MachineState.START, MachineState.START, MachineState.START, # 28-2f
-)
-# fmt: on
-
-HZ_CHAR_LEN_TABLE = (0, 0, 0, 0, 0, 0)
-
-HZ_SM_MODEL: CodingStateMachineDict = {
-    "class_table": HZ_CLS,
-    "class_factor": 6,
-    "state_table": HZ_ST,
-    "char_len_table": HZ_CHAR_LEN_TABLE,
-    "name": "HZ-GB-2312",
-    "language": "Chinese",
-}
-
-# fmt: off
-ISO2022CN_CLS = (
-    2, 0, 0, 0, 0, 0, 0, 0,  # 00 - 07
-    0, 0, 0, 0, 0, 0, 0, 0,  # 08 - 0f
-    0, 0, 0, 0, 0, 0, 0, 0,  # 10 - 17
-    0, 0, 0, 1, 0, 0, 0, 0,  # 18 - 1f
-    0, 0, 0, 0, 0, 0, 0, 0,  # 20 - 27
-    0, 3, 0, 0, 0, 0, 0, 0,  # 28 - 2f
-    0, 0, 0, 0, 0, 0, 0, 0,  # 30 - 37
-    0, 0, 0, 0, 0, 0, 0, 0,  # 38 - 3f
-    0, 0, 0, 4, 0, 0, 0, 0,  # 40 - 47
-    0, 0, 0, 0, 0, 0, 0, 0,  # 48 - 4f
-    0, 0, 0, 0, 0, 0, 0, 0,  # 50 - 57
-    0, 0, 0, 0, 0, 0, 0, 0,  # 58 - 5f
-    0, 0, 0, 0, 0, 0, 0, 0,  # 60 - 67
-    0, 0, 0, 0, 0, 0, 0, 0,  # 68 - 6f
-    0, 0, 0, 0, 0, 0, 0, 0,  # 70 - 77
-    0, 0, 0, 0, 0, 0, 0, 0,  # 78 - 7f
-    2, 2, 2, 2, 2, 2, 2, 2,  # 80 - 87
-    2, 2, 2, 2, 2, 2, 2, 2,  # 88 - 8f
-    2, 2, 2, 2, 2, 2, 2, 2,  # 90 - 97
-    2, 2, 2, 2, 2, 2, 2, 2,  # 98 - 9f
-    2, 2, 2, 2, 2, 2, 2, 2,  # a0 - a7
-    2, 2, 2, 2, 2, 2, 2, 2,  # a8 - af
-    2, 2, 2, 2, 2, 2, 2, 2,  # b0 - b7
-    2, 2, 2, 2, 2, 2, 2, 2,  # b8 - bf
-    2, 2, 2, 2, 2, 2, 2, 2,  # c0 - c7
-    2, 2, 2, 2, 2, 2, 2, 2,  # c8 - cf
-    2, 2, 2, 2, 2, 2, 2, 2,  # d0 - d7
-    2, 2, 2, 2, 2, 2, 2, 2,  # d8 - df
-    2, 2, 2, 2, 2, 2, 2, 2,  # e0 - e7
-    2, 2, 2, 2, 2, 2, 2, 2,  # e8 - ef
-    2, 2, 2, 2, 2, 2, 2, 2,  # f0 - f7
-    2, 2, 2, 2, 2, 2, 2, 2,  # f8 - ff
-)
-
-ISO2022CN_ST = (
-    MachineState.START,      3, MachineState.ERROR, MachineState.START, MachineState.START, MachineState.START, MachineState.START, MachineState.START, # 00-07
-    MachineState.START, MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, # 08-0f
-    MachineState.ERROR, MachineState.ERROR, MachineState.ITS_ME, MachineState.ITS_ME, MachineState.ITS_ME, MachineState.ITS_ME, MachineState.ITS_ME, MachineState.ITS_ME, # 10-17
-    MachineState.ITS_ME, MachineState.ITS_ME, MachineState.ITS_ME, MachineState.ERROR, MachineState.ERROR, MachineState.ERROR,      4, MachineState.ERROR, # 18-1f
-    MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, MachineState.ITS_ME, MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, # 20-27
-        5,      6, MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, # 28-2f
-    MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, MachineState.ITS_ME, MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, # 30-37
-    MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, MachineState.ITS_ME, MachineState.ERROR, MachineState.START, # 38-3f
-)
-# fmt: on
-
-ISO2022CN_CHAR_LEN_TABLE = (0, 0, 0, 0, 0, 0, 0, 0, 0)
-
-ISO2022CN_SM_MODEL: CodingStateMachineDict = {
-    "class_table": ISO2022CN_CLS,
-    "class_factor": 9,
-    "state_table": ISO2022CN_ST,
-    "char_len_table": ISO2022CN_CHAR_LEN_TABLE,
-    "name": "ISO-2022-CN",
-    "language": "Chinese",
-}
-
-# fmt: off
-ISO2022JP_CLS = (
-    2, 0, 0, 0, 0, 0, 0, 0,  # 00 - 07
-    0, 0, 0, 0, 0, 0, 2, 2,  # 08 - 0f
-    0, 0, 0, 0, 0, 0, 0, 0,  # 10 - 17
-    0, 0, 0, 1, 0, 0, 0, 0,  # 18 - 1f
-    0, 0, 0, 0, 7, 0, 0, 0,  # 20 - 27
-    3, 0, 0, 0, 0, 0, 0, 0,  # 28 - 2f
-    0, 0, 0, 0, 0, 0, 0, 0,  # 30 - 37
-    0, 0, 0, 0, 0, 0, 0, 0,  # 38 - 3f
-    6, 0, 4, 0, 8, 0, 0, 0,  # 40 - 47
-    0, 9, 5, 0, 0, 0, 0, 0,  # 48 - 4f
-    0, 0, 0, 0, 0, 0, 0, 0,  # 50 - 57
-    0, 0, 0, 0, 0, 0, 0, 0,  # 58 - 5f
-    0, 0, 0, 0, 0, 0, 0, 0,  # 60 - 67
-    0, 0, 0, 0, 0, 0, 0, 0,  # 68 - 6f
-    0, 0, 0, 0, 0, 0, 0, 0,  # 70 - 77
-    0, 0, 0, 0, 0, 0, 0, 0,  # 78 - 7f
-    2, 2, 2, 2, 2, 2, 2, 2,  # 80 - 87
-    2, 2, 2, 2, 2, 2, 2, 2,  # 88 - 8f
-    2, 2, 2, 2, 2, 2, 2, 2,  # 90 - 97
-    2, 2, 2, 2, 2, 2, 2, 2,  # 98 - 9f
-    2, 2, 2, 2, 2, 2, 2, 2,  # a0 - a7
-    2, 2, 2, 2, 2, 2, 2, 2,  # a8 - af
-    2, 2, 2, 2, 2, 2, 2, 2,  # b0 - b7
-    2, 2, 2, 2, 2, 2, 2, 2,  # b8 - bf
-    2, 2, 2, 2, 2, 2, 2, 2,  # c0 - c7
-    2, 2, 2, 2, 2, 2, 2, 2,  # c8 - cf
-    2, 2, 2, 2, 2, 2, 2, 2,  # d0 - d7
-    2, 2, 2, 2, 2, 2, 2, 2,  # d8 - df
-    2, 2, 2, 2, 2, 2, 2, 2,  # e0 - e7
-    2, 2, 2, 2, 2, 2, 2, 2,  # e8 - ef
-    2, 2, 2, 2, 2, 2, 2, 2,  # f0 - f7
-    2, 2, 2, 2, 2, 2, 2, 2,  # f8 - ff
-)
-
-ISO2022JP_ST = (
-    MachineState.START,      3, MachineState.ERROR, MachineState.START, MachineState.START, MachineState.START, MachineState.START, MachineState.START, # 00-07
-    MachineState.START, MachineState.START, MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, # 08-0f
-    MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, MachineState.ITS_ME, MachineState.ITS_ME, MachineState.ITS_ME, MachineState.ITS_ME, # 10-17
-    MachineState.ITS_ME, MachineState.ITS_ME, MachineState.ITS_ME, MachineState.ITS_ME, MachineState.ITS_ME, MachineState.ITS_ME, MachineState.ERROR, MachineState.ERROR, # 18-1f
-    MachineState.ERROR,      5, MachineState.ERROR, MachineState.ERROR, MachineState.ERROR,      4, MachineState.ERROR, MachineState.ERROR, # 20-27
-    MachineState.ERROR, MachineState.ERROR, MachineState.ERROR,      6, MachineState.ITS_ME, MachineState.ERROR, MachineState.ITS_ME, MachineState.ERROR, # 28-2f
-    MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, MachineState.ITS_ME, MachineState.ITS_ME, # 30-37
-    MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, MachineState.ITS_ME, MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, # 38-3f
-    MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, MachineState.ITS_ME, MachineState.ERROR, MachineState.START, MachineState.START, # 40-47
-)
-# fmt: on
-
-ISO2022JP_CHAR_LEN_TABLE = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
-
-ISO2022JP_SM_MODEL: CodingStateMachineDict = {
-    "class_table": ISO2022JP_CLS,
-    "class_factor": 10,
-    "state_table": ISO2022JP_ST,
-    "char_len_table": ISO2022JP_CHAR_LEN_TABLE,
-    "name": "ISO-2022-JP",
-    "language": "Japanese",
-}
-
-# fmt: off
-ISO2022KR_CLS = (
-    2, 0, 0, 0, 0, 0, 0, 0,  # 00 - 07
-    0, 0, 0, 0, 0, 0, 0, 0,  # 08 - 0f
-    0, 0, 0, 0, 0, 0, 0, 0,  # 10 - 17
-    0, 0, 0, 1, 0, 0, 0, 0,  # 18 - 1f
-    0, 0, 0, 0, 3, 0, 0, 0,  # 20 - 27
-    0, 4, 0, 0, 0, 0, 0, 0,  # 28 - 2f
-    0, 0, 0, 0, 0, 0, 0, 0,  # 30 - 37
-    0, 0, 0, 0, 0, 0, 0, 0,  # 38 - 3f
-    0, 0, 0, 5, 0, 0, 0, 0,  # 40 - 47
-    0, 0, 0, 0, 0, 0, 0, 0,  # 48 - 4f
-    0, 0, 0, 0, 0, 0, 0, 0,  # 50 - 57
-    0, 0, 0, 0, 0, 0, 0, 0,  # 58 - 5f
-    0, 0, 0, 0, 0, 0, 0, 0,  # 60 - 67
-    0, 0, 0, 0, 0, 0, 0, 0,  # 68 - 6f
-    0, 0, 0, 0, 0, 0, 0, 0,  # 70 - 77
-    0, 0, 0, 0, 0, 0, 0, 0,  # 78 - 7f
-    2, 2, 2, 2, 2, 2, 2, 2,  # 80 - 87
-    2, 2, 2, 2, 2, 2, 2, 2,  # 88 - 8f
-    2, 2, 2, 2, 2, 2, 2, 2,  # 90 - 97
-    2, 2, 2, 2, 2, 2, 2, 2,  # 98 - 9f
-    2, 2, 2, 2, 2, 2, 2, 2,  # a0 - a7
-    2, 2, 2, 2, 2, 2, 2, 2,  # a8 - af
-    2, 2, 2, 2, 2, 2, 2, 2,  # b0 - b7
-    2, 2, 2, 2, 2, 2, 2, 2,  # b8 - bf
-    2, 2, 2, 2, 2, 2, 2, 2,  # c0 - c7
-    2, 2, 2, 2, 2, 2, 2, 2,  # c8 - cf
-    2, 2, 2, 2, 2, 2, 2, 2,  # d0 - d7
-    2, 2, 2, 2, 2, 2, 2, 2,  # d8 - df
-    2, 2, 2, 2, 2, 2, 2, 2,  # e0 - e7
-    2, 2, 2, 2, 2, 2, 2, 2,  # e8 - ef
-    2, 2, 2, 2, 2, 2, 2, 2,  # f0 - f7
-    2, 2, 2, 2, 2, 2, 2, 2,  # f8 - ff
-)
-
-ISO2022KR_ST = (
-    MachineState.START,      3, MachineState.ERROR, MachineState.START, MachineState.START, MachineState.START, MachineState.ERROR, MachineState.ERROR, # 00-07
-    MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, MachineState.ITS_ME, MachineState.ITS_ME, MachineState.ITS_ME, MachineState.ITS_ME, # 08-0f
-    MachineState.ITS_ME, MachineState.ITS_ME, MachineState.ERROR, MachineState.ERROR, MachineState.ERROR,      4, MachineState.ERROR, MachineState.ERROR, # 10-17
-    MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, MachineState.ERROR,      5, MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, # 18-1f
-    MachineState.ERROR, MachineState.ERROR, MachineState.ERROR, MachineState.ITS_ME, MachineState.START, MachineState.START, MachineState.START, MachineState.START, # 20-27
-)
-# fmt: on
-
-ISO2022KR_CHAR_LEN_TABLE = (0, 0, 0, 0, 0, 0)
-
-ISO2022KR_SM_MODEL: CodingStateMachineDict = {
-    "class_table": ISO2022KR_CLS,
-    "class_factor": 6,
-    "state_table": ISO2022KR_ST,
-    "char_len_table": ISO2022KR_CHAR_LEN_TABLE,
-    "name": "ISO-2022-KR",
-    "language": "Korean",
-}

spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/pygments/formatters/svg.py

@@ -1,188 +0,0 @@
-"""
-    pygments.formatters.svg
-    ~~~~~~~~~~~~~~~~~~~~~~~
-
-    Formatter for SVG output.
-
-    :copyright: Copyright 2006-2022 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-from pip._vendor.pygments.formatter import Formatter
-from pip._vendor.pygments.token import Comment
-from pip._vendor.pygments.util import get_bool_opt, get_int_opt
-
-__all__ = ['SvgFormatter']
-
-
-def escape_html(text):
-    """Escape &, <, > as well as single and double quotes for HTML."""
-    return text.replace('&', '&amp;').  \
-                replace('<', '&lt;').   \
-                replace('>', '&gt;').   \
-                replace('"', '&quot;'). \
-                replace("'", '&#39;')
-
-
-class2style = {}
-
-class SvgFormatter(Formatter):
-    """
-    Format tokens as an SVG graphics file.  This formatter is still experimental.
-    Each line of code is a ``<text>`` element with explicit ``x`` and ``y``
-    coordinates containing ``<tspan>`` elements with the individual token styles.
-
-    By default, this formatter outputs a full SVG document including doctype
-    declaration and the ``<svg>`` root element.
-
-    .. versionadded:: 0.9
-
-    Additional options accepted:
-
-    `nowrap`
-        Don't wrap the SVG ``<text>`` elements in ``<svg><g>`` elements and
-        don't add a XML declaration and a doctype.  If true, the `fontfamily`
-        and `fontsize` options are ignored.  Defaults to ``False``.
-
-    `fontfamily`
-        The value to give the wrapping ``<g>`` element's ``font-family``
-        attribute, defaults to ``"monospace"``.
-
-    `fontsize`
-        The value to give the wrapping ``<g>`` element's ``font-size``
-        attribute, defaults to ``"14px"``.
-
-    `linenos`
-        If ``True``, add line numbers (default: ``False``).
-
-    `linenostart`
-        The line number for the first line (default: ``1``).
-
-    `linenostep`
-        If set to a number n > 1, only every nth line number is printed.
-        
-    `linenowidth`
-        Maximum width devoted to line numbers (default: ``3*ystep``, sufficient
-        for up to 4-digit line numbers. Increase width for longer code blocks).  
-        
-    `xoffset`
-        Starting offset in X direction, defaults to ``0``.
-
-    `yoffset`
-        Starting offset in Y direction, defaults to the font size if it is given
-        in pixels, or ``20`` else.  (This is necessary since text coordinates
-        refer to the text baseline, not the top edge.)
-
-    `ystep`
-        Offset to add to the Y coordinate for each subsequent line.  This should
-        roughly be the text size plus 5.  It defaults to that value if the text
-        size is given in pixels, or ``25`` else.
-
-    `spacehack`
-        Convert spaces in the source to ``&#160;``, which are non-breaking
-        spaces.  SVG provides the ``xml:space`` attribute to control how
-        whitespace inside tags is handled, in theory, the ``preserve`` value
-        could be used to keep all whitespace as-is.  However, many current SVG
-        viewers don't obey that rule, so this option is provided as a workaround
-        and defaults to ``True``.
-    """
-    name = 'SVG'
-    aliases = ['svg']
-    filenames = ['*.svg']
-
-    def __init__(self, **options):
-        Formatter.__init__(self, **options)
-        self.nowrap = get_bool_opt(options, 'nowrap', False)
-        self.fontfamily = options.get('fontfamily', 'monospace')
-        self.fontsize = options.get('fontsize', '14px')
-        self.xoffset = get_int_opt(options, 'xoffset', 0)
-        fs = self.fontsize.strip()
-        if fs.endswith('px'): fs = fs[:-2].strip()
-        try:
-            int_fs = int(fs)
-        except:
-            int_fs = 20
-        self.yoffset = get_int_opt(options, 'yoffset', int_fs)
-        self.ystep = get_int_opt(options, 'ystep', int_fs + 5)
-        self.spacehack = get_bool_opt(options, 'spacehack', True)
-        self.linenos = get_bool_opt(options,'linenos',False)
-        self.linenostart = get_int_opt(options,'linenostart',1)
-        self.linenostep = get_int_opt(options,'linenostep',1)
-        self.linenowidth = get_int_opt(options,'linenowidth', 3*self.ystep)
-        self._stylecache = {}
-
-    def format_unencoded(self, tokensource, outfile):
-        """
-        Format ``tokensource``, an iterable of ``(tokentype, tokenstring)``
-        tuples and write it into ``outfile``.
-
-        For our implementation we put all lines in their own 'line group'.
-        """
-        x = self.xoffset
-        y = self.yoffset
-        if not self.nowrap:
-            if self.encoding:
-                outfile.write('<?xml version="1.0" encoding="%s"?>\n' %
-                              self.encoding)
-            else:
-                outfile.write('<?xml version="1.0"?>\n')
-            outfile.write('<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.0//EN" '
-                          '"http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/'
-                          'svg10.dtd">\n')
-            outfile.write('<svg xmlns="http://www.w3.org/2000/svg">\n')
-            outfile.write('<g font-family="%s" font-size="%s">\n' %
-                          (self.fontfamily, self.fontsize))
-        
-        counter = self.linenostart 
-        counter_step = self.linenostep
-        counter_style = self._get_style(Comment)
-        line_x = x
-        
-        if self.linenos:
-            if counter % counter_step == 0:
-                outfile.write('<text x="%s" y="%s" %s text-anchor="end">%s</text>' %
-                    (x+self.linenowidth,y,counter_style,counter))
-            line_x += self.linenowidth + self.ystep
-            counter += 1
-
-        outfile.write('<text x="%s" y="%s" xml:space="preserve">' % (line_x, y))
-        for ttype, value in tokensource:
-            style = self._get_style(ttype)
-            tspan = style and '<tspan' + style + '>' or ''
-            tspanend = tspan and '</tspan>' or ''
-            value = escape_html(value)
-            if self.spacehack:
-                value = value.expandtabs().replace(' ', '&#160;')
-            parts = value.split('\n')
-            for part in parts[:-1]:
-                outfile.write(tspan + part + tspanend)
-                y += self.ystep
-                outfile.write('</text>\n')
-                if self.linenos and counter % counter_step == 0:
-                    outfile.write('<text x="%s" y="%s" text-anchor="end" %s>%s</text>' %
-                        (x+self.linenowidth,y,counter_style,counter))
-                
-                counter += 1
-                outfile.write('<text x="%s" y="%s" ' 'xml:space="preserve">' % (line_x,y))
-            outfile.write(tspan + parts[-1] + tspanend)
-        outfile.write('</text>')
-
-        if not self.nowrap:
-            outfile.write('</g></svg>\n')
-
-    def _get_style(self, tokentype):
-        if tokentype in self._stylecache:
-            return self._stylecache[tokentype]
-        otokentype = tokentype
-        while not self.style.styles_token(tokentype):
-            tokentype = tokentype.parent
-        value = self.style.style_for_token(tokentype)
-        result = ''
-        if value['color']:
-            result = ' fill="#' + value['color'] + '"'
-        if value['bold']:
-            result += ' font-weight="bold"'
-        if value['italic']:
-            result += ' font-style="italic"'
-        self._stylecache[otokentype] = result
-        return result

spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/urllib3/util/request.py

@@ -1,137 +0,0 @@
-from __future__ import absolute_import
-
-from base64 import b64encode
-
-from ..exceptions import UnrewindableBodyError
-from ..packages.six import b, integer_types
-
-# Pass as a value within ``headers`` to skip
-# emitting some HTTP headers that are added automatically.
-# The only headers that are supported are ``Accept-Encoding``,
-# ``Host``, and ``User-Agent``.
-SKIP_HEADER = "@@@SKIP_HEADER@@@"
-SKIPPABLE_HEADERS = frozenset(["accept-encoding", "host", "user-agent"])
-
-ACCEPT_ENCODING = "gzip,deflate"
-
-_FAILEDTELL = object()
-
-
-def make_headers(
-    keep_alive=None,
-    accept_encoding=None,
-    user_agent=None,
-    basic_auth=None,
-    proxy_basic_auth=None,
-    disable_cache=None,
-):
-    """
-    Shortcuts for generating request headers.
-
-    :param keep_alive:
-        If ``True``, adds 'connection: keep-alive' header.
-
-    :param accept_encoding:
-        Can be a boolean, list, or string.
-        ``True`` translates to 'gzip,deflate'.
-        List will get joined by comma.
-        String will be used as provided.
-
-    :param user_agent:
-        String representing the user-agent you want, such as
-        "python-urllib3/0.6"
-
-    :param basic_auth:
-        Colon-separated username:password string for 'authorization: basic ...'
-        auth header.
-
-    :param proxy_basic_auth:
-        Colon-separated username:password string for 'proxy-authorization: basic ...'
-        auth header.
-
-    :param disable_cache:
-        If ``True``, adds 'cache-control: no-cache' header.
-
-    Example::
-
-        >>> make_headers(keep_alive=True, user_agent="Batman/1.0")
-        {'connection': 'keep-alive', 'user-agent': 'Batman/1.0'}
-        >>> make_headers(accept_encoding=True)
-        {'accept-encoding': 'gzip,deflate'}
-    """
-    headers = {}
-    if accept_encoding:
-        if isinstance(accept_encoding, str):
-            pass
-        elif isinstance(accept_encoding, list):
-            accept_encoding = ",".join(accept_encoding)
-        else:
-            accept_encoding = ACCEPT_ENCODING
-        headers["accept-encoding"] = accept_encoding
-
-    if user_agent:
-        headers["user-agent"] = user_agent
-
-    if keep_alive:
-        headers["connection"] = "keep-alive"
-
-    if basic_auth:
-        headers["authorization"] = "Basic " + b64encode(b(basic_auth)).decode("utf-8")
-
-    if proxy_basic_auth:
-        headers["proxy-authorization"] = "Basic " + b64encode(
-            b(proxy_basic_auth)
-        ).decode("utf-8")
-
-    if disable_cache:
-        headers["cache-control"] = "no-cache"
-
-    return headers
-
-
-def set_file_position(body, pos):
-    """
-    If a position is provided, move file to that point.
-    Otherwise, we'll attempt to record a position for future use.
-    """
-    if pos is not None:
-        rewind_body(body, pos)
-    elif getattr(body, "tell", None) is not None:
-        try:
-            pos = body.tell()
-        except (IOError, OSError):
-            # This differentiates from None, allowing us to catch
-            # a failed `tell()` later when trying to rewind the body.
-            pos = _FAILEDTELL
-
-    return pos
-
-
-def rewind_body(body, body_pos):
-    """
-    Attempt to rewind body to a certain position.
-    Primarily used for request redirects and retries.
-
-    :param body:
-        File-like object that supports seek.
-
-    :param int pos:
-        Position to seek to in file.
-    """
-    body_seek = getattr(body, "seek", None)
-    if body_seek is not None and isinstance(body_pos, integer_types):
-        try:
-            body_seek(body_pos)
-        except (IOError, OSError):
-            raise UnrewindableBodyError(
-                "An error occurred when rewinding request body for redirect/retry."
-            )
-    elif body_pos is _FAILEDTELL:
-        raise UnrewindableBodyError(
-            "Unable to record file position for rewinding "
-            "request body during a redirect/retry."
-        )
-    else:
-        raise ValueError(
-            "body_pos must be of type integer, instead it was %s." % type(body_pos)
-        )

spaces/Boadiwaa/Recipes/openai/__init__.py

@@ -1,73 +0,0 @@
-# OpenAI Python bindings.
-#
-# Originally forked from the MIT-licensed Stripe Python bindings.
-
-import os
-from typing import Optional
-
-from openai.api_resources import (
-    Answer,
-    Classification,
-    Completion,
-    Customer,
-    Edit,
-    Deployment,
-    Embedding,
-    Engine,
-    ErrorObject,
-    File,
-    FineTune,
-    Model,
-    Search,
-)
-from openai.error import APIError, InvalidRequestError, OpenAIError
-
-api_key = os.environ.get("OPENAI_API_KEY")
-# Path of a file with an API key, whose contents can change. Supercedes
-# `api_key` if set.  The main use case is volume-mounted Kubernetes secrets,
-# which are updated automatically.
-api_key_path: Optional[str] = os.environ.get("OPENAI_API_KEY_PATH")
-
-organization = os.environ.get("OPENAI_ORGANIZATION")
-api_base = os.environ.get("OPENAI_API_BASE", "https://api.openai.com/v1")
-api_type = os.environ.get("OPENAI_API_TYPE", "open_ai")
-api_version = "2021-11-01-preview" if api_type == "azure" else None
-verify_ssl_certs = True  # No effect. Certificates are always verified.
-proxy = None
-app_info = None
-enable_telemetry = False  # Ignored; the telemetry feature was removed.
-ca_bundle_path = None  # No longer used, feature was removed
-debug = False
-log = None  # Set to either 'debug' or 'info', controls console logging
-
-__all__ = [
-    "APIError",
-    "Answer",
-    "Classification",
-    "Completion",
-    "Customer",
-    "Edit",
-    "Deployment",
-    "Embedding",
-    "Engine",
-    "ErrorObject",
-    "File",
-    "FineTune",
-    "InvalidRequestError",
-    "Model",
-    "OpenAIError",
-    "Search",
-    "api_base",
-    "api_key",
-    "api_type",
-    "api_key_path",
-    "api_version",
-    "app_info",
-    "ca_bundle_path",
-    "debug",
-    "enable_elemetry",
-    "log",
-    "organization",
-    "proxy",
-    "verify_ssl_certs",
-]

spaces/Boadiwaa/Recipes/openai/embeddings_utils.py

@@ -1,227 +0,0 @@
-import textwrap as tr
-from typing import List, Optional
-
-import matplotlib.pyplot as plt
-import numpy as np
-import pandas as pd
-import plotly.express as px
-from scipy import spatial
-from sklearn.decomposition import PCA
-from sklearn.manifold import TSNE
-from sklearn.metrics import average_precision_score, precision_recall_curve
-from tenacity import retry, stop_after_attempt, wait_random_exponential
-
-import openai
-
-
-@retry(wait=wait_random_exponential(min=1, max=20), stop=stop_after_attempt(6))
-def get_embedding(text: str, engine="text-similarity-davinci-001") -> List[float]:
-
-    # replace newlines, which can negatively affect performance.
-    text = text.replace("\n", " ")
-
-    return openai.Embedding.create(input=[text], engine=engine)["data"][0]["embedding"]
-
-
-@retry(wait=wait_random_exponential(min=1, max=20), stop=stop_after_attempt(6))
-def get_embeddings(
-    list_of_text: List[str], engine="text-similarity-babbage-001"
-) -> List[List[float]]:
-    assert len(list_of_text) < 2048, "The batch size should not be larger than 2048."
-
-    # replace newlines, which can negatively affect performance.
-    list_of_text = [text.replace("\n", " ") for text in list_of_text]
-
-    data = openai.Embedding.create(input=list_of_text, engine=engine).data
-    data = sorted(data, key=lambda x: x["index"])  # maintain the same order as input.
-    return [d["embedding"] for d in data]
-
-
-def cosine_similarity(a, b):
-    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
-
-
-def plot_multiclass_precision_recall(
-    y_score, y_true_untransformed, class_list, classifier_name
-):
-    """
-    Precision-Recall plotting for a multiclass problem. It plots average precision-recall, per class precision recall and reference f1 contours.
-
-    Code slightly modified, but heavily based on https://scikit-learn.org/stable/auto_examples/model_selection/plot_precision_recall.html
-    """
-    n_classes = len(class_list)
-    y_true = pd.concat(
-        [(y_true_untransformed == class_list[i]) for i in range(n_classes)], axis=1
-    ).values
-
-    # For each class
-    precision = dict()
-    recall = dict()
-    average_precision = dict()
-    for i in range(n_classes):
-        precision[i], recall[i], _ = precision_recall_curve(y_true[:, i], y_score[:, i])
-        average_precision[i] = average_precision_score(y_true[:, i], y_score[:, i])
-
-    # A "micro-average": quantifying score on all classes jointly
-    precision_micro, recall_micro, _ = precision_recall_curve(
-        y_true.ravel(), y_score.ravel()
-    )
-    average_precision_micro = average_precision_score(y_true, y_score, average="micro")
-    print(
-        str(classifier_name)
-        + " - Average precision score over all classes: {0:0.2f}".format(
-            average_precision_micro
-        )
-    )
-
-    # setup plot details
-    plt.figure(figsize=(9, 10))
-    f_scores = np.linspace(0.2, 0.8, num=4)
-    lines = []
-    labels = []
-    for f_score in f_scores:
-        x = np.linspace(0.01, 1)
-        y = f_score * x / (2 * x - f_score)
-        (l,) = plt.plot(x[y >= 0], y[y >= 0], color="gray", alpha=0.2)
-        plt.annotate("f1={0:0.1f}".format(f_score), xy=(0.9, y[45] + 0.02))
-
-    lines.append(l)
-    labels.append("iso-f1 curves")
-    (l,) = plt.plot(recall_micro, precision_micro, color="gold", lw=2)
-    lines.append(l)
-    labels.append(
-        "average Precision-recall (auprc = {0:0.2f})" "".format(average_precision_micro)
-    )
-
-    for i in range(n_classes):
-        (l,) = plt.plot(recall[i], precision[i], lw=2)
-        lines.append(l)
-        labels.append(
-            "Precision-recall for class `{0}` (auprc = {1:0.2f})"
-            "".format(class_list[i], average_precision[i])
-        )
-
-    fig = plt.gcf()
-    fig.subplots_adjust(bottom=0.25)
-    plt.xlim([0.0, 1.0])
-    plt.ylim([0.0, 1.05])
-    plt.xlabel("Recall")
-    plt.ylabel("Precision")
-    plt.title(f"{classifier_name}: Precision-Recall curve for each class")
-    plt.legend(lines, labels)
-
-
-def distances_from_embeddings(
-    query_embedding: List[float],
-    embeddings: List[List[float]],
-    distance_metric="cosine",
-) -> List[List]:
-    """Return the distances between a query embedding and a list of embeddings."""
-    distance_metrics = {
-        "cosine": spatial.distance.cosine,
-        "L1": spatial.distance.cityblock,
-        "L2": spatial.distance.euclidean,
-        "Linf": spatial.distance.chebyshev,
-    }
-    distances = [
-        distance_metrics[distance_metric](query_embedding, embedding)
-        for embedding in embeddings
-    ]
-    return distances
-
-
-def indices_of_nearest_neighbors_from_distances(distances) -> np.ndarray:
-    """Return a list of indices of nearest neighbors from a list of distances."""
-    return np.argsort(distances)
-
-
-def pca_components_from_embeddings(
-    embeddings: List[List[float]], n_components=2
-) -> np.ndarray:
-    """Return the PCA components of a list of embeddings."""
-    pca = PCA(n_components=n_components)
-    array_of_embeddings = np.array(embeddings)
-    return pca.fit_transform(array_of_embeddings)
-
-
-def tsne_components_from_embeddings(
-    embeddings: List[List[float]], n_components=2, **kwargs
-) -> np.ndarray:
-    """Returns t-SNE components of a list of embeddings."""
-    # use better defaults if not specified
-    if "init" not in kwargs.keys():
-        kwargs["init"] = "pca"
-    if "learning_rate" not in kwargs.keys():
-        kwargs["learning_rate"] = "auto"
-    tsne = TSNE(n_components=n_components, **kwargs)
-    array_of_embeddings = np.array(embeddings)
-    return tsne.fit_transform(array_of_embeddings)
-
-
-def chart_from_components(
-    components: np.ndarray,
-    labels: Optional[List[str]] = None,
-    strings: Optional[List[str]] = None,
-    x_title="Component 0",
-    y_title="Component 1",
-    mark_size=5,
-    **kwargs,
-):
-    """Return an interactive 2D chart of embedding components."""
-    empty_list = ["" for _ in components]
-    data = pd.DataFrame(
-        {
-            x_title: components[:, 0],
-            y_title: components[:, 1],
-            "label": labels if labels else empty_list,
-            "string": ["<br>".join(tr.wrap(string, width=30)) for string in strings]
-            if strings
-            else empty_list,
-        }
-    )
-    chart = px.scatter(
-        data,
-        x=x_title,
-        y=y_title,
-        color="label" if labels else None,
-        symbol="label" if labels else None,
-        hover_data=["string"] if strings else None,
-        **kwargs,
-    ).update_traces(marker=dict(size=mark_size))
-    return chart
-
-
-def chart_from_components_3D(
-    components: np.ndarray,
-    labels: Optional[List[str]] = None,
-    strings: Optional[List[str]] = None,
-    x_title: str = "Component 0",
-    y_title: str = "Component 1",
-    z_title: str = "Compontent 2",
-    mark_size: int = 5,
-    **kwargs,
-):
-    """Return an interactive 3D chart of embedding components."""
-    empty_list = ["" for _ in components]
-    data = pd.DataFrame(
-        {
-            x_title: components[:, 0],
-            y_title: components[:, 1],
-            z_title: components[:, 2],
-            "label": labels if labels else empty_list,
-            "string": ["<br>".join(tr.wrap(string, width=30)) for string in strings]
-            if strings
-            else empty_list,
-        }
-    )
-    chart = px.scatter_3d(
-        data,
-        x=x_title,
-        y=y_title,
-        z=z_title,
-        color="label" if labels else None,
-        symbol="label" if labels else None,
-        hover_data=["string"] if strings else None,
-        **kwargs,
-    ).update_traces(marker=dict(size=mark_size))
-    return chart

spaces/CVPR/LIVE/thrust/thrust/system/omp/detail/reduce_intervals.h

@@ -1,53 +0,0 @@
-/*
- *  Copyright 2008-2013 NVIDIA Corporation
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-
-/*! \file reduce_intervals.h
- *  \brief OpenMP implementations of reduce_intervals algorithms.
- */
-
-#pragma once
-
-#include <thrust/detail/config.h>
-#include <thrust/system/omp/detail/execution_policy.h>
-
-namespace thrust
-{
-namespace system
-{
-namespace omp
-{
-namespace detail
-{
-
-template <typename DerivedPolicy,
-          typename InputIterator,
-          typename OutputIterator,
-          typename BinaryFunction,
-          typename Decomposition>
-void reduce_intervals(execution_policy<DerivedPolicy> &exec,
-                      InputIterator input,
-                      OutputIterator output,
-                      BinaryFunction binary_op,
-                      Decomposition decomp);
-
-} // end namespace detail
-} // end namespace omp
-} // end namespace system
-} // end namespace thrust
-
-#include <thrust/system/omp/detail/reduce_intervals.inl>
-

spaces/CVPR/WALT/configs/_base_/models/mask_rcnn_swin_fpn.py

@@ -1,127 +0,0 @@
-# model settings
-model = dict(
-    type='MaskRCNN',
-    pretrained=None,
-    backbone=dict(
-        type='SwinTransformer',
-        embed_dim=96,
-        depths=[2, 2, 6, 2],
-        num_heads=[3, 6, 12, 24],
-        window_size=7,
-        mlp_ratio=4.,
-        qkv_bias=True,
-        qk_scale=None,
-        drop_rate=0.,
-        attn_drop_rate=0.,
-        drop_path_rate=0.2,
-        ape=False,
-        patch_norm=True,
-        out_indices=(0, 1, 2, 3),
-        use_checkpoint=False),
-    neck=dict(
-        type='FPN',
-        in_channels=[96, 192, 384, 768],
-        out_channels=256,
-        num_outs=5),
-    rpn_head=dict(
-        type='RPNHead',
-        in_channels=256,
-        feat_channels=256,
-        anchor_generator=dict(
-            type='AnchorGenerator',
-            scales=[8],
-            ratios=[0.5, 1.0, 2.0],
-            strides=[4, 8, 16, 32, 64]),
-        bbox_coder=dict(
-            type='DeltaXYWHBBoxCoder',
-            target_means=[.0, .0, .0, .0],
-            target_stds=[1.0, 1.0, 1.0, 1.0]),
-        loss_cls=dict(
-            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0),
-        loss_bbox=dict(type='L1Loss', loss_weight=1.0)),
-    roi_head=dict(
-        type='StandardRoIHead',
-        bbox_roi_extractor=dict(
-            type='SingleRoIExtractor',
-            roi_layer=dict(type='RoIAlign', output_size=7, sampling_ratio=0),
-            out_channels=256,
-            featmap_strides=[4, 8, 16, 32]),
-        bbox_head=dict(
-            type='Shared2FCBBoxHead',
-            in_channels=256,
-            fc_out_channels=1024,
-            roi_feat_size=7,
-            num_classes=80,
-            bbox_coder=dict(
-                type='DeltaXYWHBBoxCoder',
-                target_means=[0., 0., 0., 0.],
-                target_stds=[0.1, 0.1, 0.2, 0.2]),
-            reg_class_agnostic=False,
-            loss_cls=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0),
-            loss_bbox=dict(type='L1Loss', loss_weight=1.0)),
-        mask_roi_extractor=dict(
-            type='SingleRoIExtractor',
-            roi_layer=dict(type='RoIAlign', output_size=14, sampling_ratio=0),
-            out_channels=256,
-            featmap_strides=[4, 8, 16, 32]),
-        mask_head=dict(
-            type='FCNMaskHead',
-            num_convs=4,
-            in_channels=256,
-            conv_out_channels=256,
-            num_classes=80,
-            loss_mask=dict(
-                type='CrossEntropyLoss', use_mask=True, loss_weight=1.0))),
-    # model training and testing settings
-    train_cfg=dict(
-        rpn=dict(
-            assigner=dict(
-                type='MaxIoUAssigner',
-                pos_iou_thr=0.7,
-                neg_iou_thr=0.3,
-                min_pos_iou=0.3,
-                match_low_quality=True,
-                ignore_iof_thr=-1),
-            sampler=dict(
-                type='RandomSampler',
-                num=256,
-                pos_fraction=0.5,
-                neg_pos_ub=-1,
-                add_gt_as_proposals=False),
-            allowed_border=-1,
-            pos_weight=-1,
-            debug=False),
-        rpn_proposal=dict(
-            nms_pre=2000,
-            max_per_img=1000,
-            nms=dict(type='nms', iou_threshold=0.7),
-            min_bbox_size=0),
-        rcnn=dict(
-            assigner=dict(
-                type='MaxIoUAssigner',
-                pos_iou_thr=0.5,
-                neg_iou_thr=0.5,
-                min_pos_iou=0.5,
-                match_low_quality=True,
-                ignore_iof_thr=-1),
-            sampler=dict(
-                type='RandomSampler',
-                num=512,
-                pos_fraction=0.25,
-                neg_pos_ub=-1,
-                add_gt_as_proposals=True),
-            mask_size=28,
-            pos_weight=-1,
-            debug=False)),
-    test_cfg=dict(
-        rpn=dict(
-            nms_pre=1000,
-            max_per_img=1000,
-            nms=dict(type='nms', iou_threshold=0.7),
-            min_bbox_size=0),
-        rcnn=dict(
-            score_thr=0.05,
-            nms=dict(type='nms', iou_threshold=0.5),
-            max_per_img=100,
-            mask_thr_binary=0.5)))

spaces/CVPR/v-doc_abstractive_mac/app.py

@@ -1,12 +0,0 @@
-import gradio as gr
-
-description = "Story generation with GPT-2"
-title = "Generate your own story"
-examples = [["Adventurer is approached by a mysterious stranger in the tavern for a new quest."]]
-
-interface = gr.Interface.load("huggingface/ydin0771/vdoc-demo-mac",
-            description=description,
-            examples=examples
-)
-
-interface.launch()

spaces/CikeyQI/meme-api/meme_generator/memes/lim_x_0/__init__.py

@@ -1,35 +0,0 @@
-from pathlib import Path
-from typing import List
-
-from pil_utils import BuildImage
-
-from meme_generator import add_meme
-
-img_dir = Path(__file__).parent / "images"
-
-
-def lim_x_0(images: List[BuildImage], texts, args):
-    img = images[0]
-    frame = BuildImage.open(img_dir / "0.png")
-    img_c = img.convert("RGBA").circle().resize((72, 72))
-    img_tp = img.convert("RGBA").circle().resize((51, 51))
-    frame.paste(img_tp, (948, 247), alpha=True)
-    # fmt: off
-    locs = [
-        (143, 32), (155, 148), (334, 149), (275, 266), (486, 266),
-        (258, 383), (439, 382), (343, 539), (577, 487), (296, 717),
-        (535, 717), (64, 896), (340, 896), (578, 897), (210, 1038),
-        (644, 1039), (64, 1192), (460, 1192), (698, 1192), (1036, 141),
-        (1217, 141), (1243, 263), (1140, 378), (1321, 378), (929, 531),
-        (1325, 531), (1592, 531), (1007, 687), (1390, 687), (1631, 686),
-        (1036, 840), (1209, 839), (1447, 839), (1141, 1018), (1309, 1019),
-        (1546, 1019), (1037, 1197), (1317, 1198), (1555, 1197),
-    ]
-    # fmt: on
-    for i in range(39):
-        x, y = locs[i]
-        frame.paste(img_c, (x, y), alpha=True)
-    return frame.save_jpg()
-
-
-add_meme("lim_x_0", lim_x_0, min_images=1, max_images=1, keywords=["等价无穷小"])

spaces/CofAI/chat/g4f/Provider/Providers/hteyun.py

@@ -1,34 +0,0 @@
-import requests
-import os
-import json
-from ...typing import sha256, Dict, get_type_hints
-
-url = 'https://hteyun.com'
-model = ['gpt-3.5-turbo', 'gpt-3.5-turbo-16k', 'gpt-3.5-turbo-16k-0613', 'gpt-3.5-turbo-0613']
-supports_stream = True
-needs_auth = False
-
-def _create_completion(model: str, messages: list, stream: bool, temperature: float = 0.7, **kwargs):
-    headers = {
-        'Content-Type': 'application/json',
-        'Accept': 'application/json, text/plain, */*',
-        'Accept-Language': 'ru-RU,ru;q=0.9,en-US;q=0.8,en;q=0.7,ja;q=0.6,zh-TW;q=0.5,zh;q=0.4',
-        'Origin': 'https://hteyun.com',
-        'Referer': 'https://hteyun.com/chat/',
-    }
-    data = {
-        'messages': messages,
-        'model': model,
-        'systemMessage': 'You are ChatGPT, a large language model trained by OpenAI. Follow the user\'s instructions carefully. Respond using russian language.',
-        'temperature': 0.7,
-        'presence_penalty': 0,
-    }
-    response = requests.post(url + '/api/chat-stream', json=data, headers=headers, stream=True)
-    print(response.json())
-
-    # Извлечение текста из response
-    return response.json()['text']
-
-
-params = f'g4f.Providers.{os.path.basename(__file__)[:-3]} supports: ' + \
-    '(%s)' % ', '.join([f"{name}: {get_type_hints(_create_completion)[name].__name__}" for name in _create_completion.__code__.co_varnames[:_create_completion.__code__.co_argcount]])

spaces/Colbe/basketball/README.md

@@ -1,13 +0,0 @@
----
-title: Basketball
-emoji: 📊
-colorFrom: pink
-colorTo: red
-sdk: gradio
-sdk_version: 3.5
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/Cran-May/yugangVI/model.py

@@ -1,34 +0,0 @@
-
-from typing import Iterator
-
-
-
-model_id = 'xuqinyang/baichuan-13b-chat-ggml-int4'
-
-from huggingface_hub import snapshot_download,hf_hub_download
-#旧
-#snapshot_download(model_id, local_dir="./",revision="7f71a8abefa7b2eede3f74ce0564abe5fbe6874a")
-snapshot_download(model_id, local_dir="./",revision="b2414a0ceee68fe09c99ace44446cfc9a1c52b08")
-hf_hub_download(repo_id="baichuan-inc/Baichuan-13B-Chat",local_dir="./", filename="tokenizer.model")
-from llama_cpp import Llama
-llm = Llama(model_path="./ggml-model-q4_0.bin", n_ctx=4096,seed=-1)
-
-def run(message: str,
-        chat_history: list[tuple[str, str]],
-        system_prompt: str,
-        max_new_tokens: int = 1024,
-        temperature: float = 0.3,
-        top_p: float = 0.85,
-        top_k: int = 5) -> Iterator[str]:
-    history = []
-    print(chat_history)
-    result=""
-    for i in chat_history:
-        history.append({"role": "user", "content": i[0]})
-        history.append({"role": "assistant", "content": i[1]})
-    print(history)
-    history.append({"role": "user", "content": message})
-    for response in llm.create_chat_completion(history,stop=["</s>"],stream=True,max_tokens=-1,temperature=temperature,top_k=top_k,top_p=top_p,repeat_penalty=1.1):
-        if "content" in response["choices"][0]["delta"]:
-            result = result + response["choices"][0]["delta"]["content"]
-            yield result

spaces/Cyril666/ContourNet-ABI/maskrcnn_benchmark/utils/registry.py

@@ -1,45 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
-
-
-def _register_generic(module_dict, module_name, module):
-    assert module_name not in module_dict
-    module_dict[module_name] = module
-
-
-class Registry(dict):
-    '''
-    A helper class for managing registering modules, it extends a dictionary
-    and provides a register functions.
-
-    Eg. creeting a registry:
-        some_registry = Registry({"default": default_module})
-
-    There're two ways of registering new modules:
-    1): normal way is just calling register function:
-        def foo():
-            ...
-        some_registry.register("foo_module", foo)
-    2): used as decorator when declaring the module:
-        @some_registry.register("foo_module")
-        @some_registry.register("foo_modeul_nickname")
-        def foo():
-            ...
-
-    Access of module is just like using a dictionary, eg:
-        f = some_registry["foo_modeul"]
-    '''
-    def __init__(self, *args, **kwargs):
-        super(Registry, self).__init__(*args, **kwargs)
-
-    def register(self, module_name, module=None):
-        # used as function call
-        if module is not None:
-            _register_generic(self, module_name, module)
-            return
-
-        # used as decorator
-        def register_fn(fn):
-            _register_generic(self, module_name, fn)
-            return fn
-
-        return register_fn

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/aiohttp/helpers.py

@@ -1,878 +0,0 @@
-"""Various helper functions"""
-
-import asyncio
-import base64
-import binascii
-import datetime
-import functools
-import inspect
-import netrc
-import os
-import platform
-import re
-import sys
-import time
-import warnings
-import weakref
-from collections import namedtuple
-from contextlib import suppress
-from email.parser import HeaderParser
-from email.utils import parsedate
-from math import ceil
-from pathlib import Path
-from types import TracebackType
-from typing import (
-    Any,
-    Callable,
-    ContextManager,
-    Dict,
-    Generator,
-    Generic,
-    Iterable,
-    Iterator,
-    List,
-    Mapping,
-    Optional,
-    Pattern,
-    Set,
-    Tuple,
-    Type,
-    TypeVar,
-    Union,
-    cast,
-)
-from urllib.parse import quote
-from urllib.request import getproxies, proxy_bypass
-
-import async_timeout
-import attr
-from multidict import MultiDict, MultiDictProxy
-from yarl import URL
-
-from . import hdrs
-from .log import client_logger, internal_logger
-from .typedefs import PathLike, Protocol  # noqa
-
-__all__ = ("BasicAuth", "ChainMapProxy", "ETag")
-
-IS_MACOS = platform.system() == "Darwin"
-IS_WINDOWS = platform.system() == "Windows"
-
-PY_36 = sys.version_info >= (3, 6)
-PY_37 = sys.version_info >= (3, 7)
-PY_38 = sys.version_info >= (3, 8)
-PY_310 = sys.version_info >= (3, 10)
-PY_311 = sys.version_info >= (3, 11)
-
-if sys.version_info < (3, 7):
-    import idna_ssl
-
-    idna_ssl.patch_match_hostname()
-
-    def all_tasks(
-        loop: Optional[asyncio.AbstractEventLoop] = None,
-    ) -> Set["asyncio.Task[Any]"]:
-        tasks = list(asyncio.Task.all_tasks(loop))
-        return {t for t in tasks if not t.done()}
-
-else:
-    all_tasks = asyncio.all_tasks
-
-
-_T = TypeVar("_T")
-_S = TypeVar("_S")
-
-
-sentinel: Any = object()
-NO_EXTENSIONS: bool = bool(os.environ.get("AIOHTTP_NO_EXTENSIONS"))
-
-# N.B. sys.flags.dev_mode is available on Python 3.7+, use getattr
-# for compatibility with older versions
-DEBUG: bool = getattr(sys.flags, "dev_mode", False) or (
-    not sys.flags.ignore_environment and bool(os.environ.get("PYTHONASYNCIODEBUG"))
-)
-
-
-CHAR = {chr(i) for i in range(0, 128)}
-CTL = {chr(i) for i in range(0, 32)} | {
-    chr(127),
-}
-SEPARATORS = {
-    "(",
-    ")",
-    "<",
-    ">",
-    "@",
-    ",",
-    ";",
-    ":",
-    "\\",
-    '"',
-    "/",
-    "[",
-    "]",
-    "?",
-    "=",
-    "{",
-    "}",
-    " ",
-    chr(9),
-}
-TOKEN = CHAR ^ CTL ^ SEPARATORS
-
-
-class noop:
-    def __await__(self) -> Generator[None, None, None]:
-        yield
-
-
-class BasicAuth(namedtuple("BasicAuth", ["login", "password", "encoding"])):
-    """Http basic authentication helper."""
-
-    def __new__(
-        cls, login: str, password: str = "", encoding: str = "latin1"
-    ) -> "BasicAuth":
-        if login is None:
-            raise ValueError("None is not allowed as login value")
-
-        if password is None:
-            raise ValueError("None is not allowed as password value")
-
-        if ":" in login:
-            raise ValueError('A ":" is not allowed in login (RFC 1945#section-11.1)')
-
-        return super().__new__(cls, login, password, encoding)
-
-    @classmethod
-    def decode(cls, auth_header: str, encoding: str = "latin1") -> "BasicAuth":
-        """Create a BasicAuth object from an Authorization HTTP header."""
-        try:
-            auth_type, encoded_credentials = auth_header.split(" ", 1)
-        except ValueError:
-            raise ValueError("Could not parse authorization header.")
-
-        if auth_type.lower() != "basic":
-            raise ValueError("Unknown authorization method %s" % auth_type)
-
-        try:
-            decoded = base64.b64decode(
-                encoded_credentials.encode("ascii"), validate=True
-            ).decode(encoding)
-        except binascii.Error:
-            raise ValueError("Invalid base64 encoding.")
-
-        try:
-            # RFC 2617 HTTP Authentication
-            # https://www.ietf.org/rfc/rfc2617.txt
-            # the colon must be present, but the username and password may be
-            # otherwise blank.
-            username, password = decoded.split(":", 1)
-        except ValueError:
-            raise ValueError("Invalid credentials.")
-
-        return cls(username, password, encoding=encoding)
-
-    @classmethod
-    def from_url(cls, url: URL, *, encoding: str = "latin1") -> Optional["BasicAuth"]:
-        """Create BasicAuth from url."""
-        if not isinstance(url, URL):
-            raise TypeError("url should be yarl.URL instance")
-        if url.user is None:
-            return None
-        return cls(url.user, url.password or "", encoding=encoding)
-
-    def encode(self) -> str:
-        """Encode credentials."""
-        creds = (f"{self.login}:{self.password}").encode(self.encoding)
-        return "Basic %s" % base64.b64encode(creds).decode(self.encoding)
-
-
-def strip_auth_from_url(url: URL) -> Tuple[URL, Optional[BasicAuth]]:
-    auth = BasicAuth.from_url(url)
-    if auth is None:
-        return url, None
-    else:
-        return url.with_user(None), auth
-
-
-def netrc_from_env() -> Optional[netrc.netrc]:
-    """Load netrc from file.
-
-    Attempt to load it from the path specified by the env-var
-    NETRC or in the default location in the user's home directory.
-
-    Returns None if it couldn't be found or fails to parse.
-    """
-    netrc_env = os.environ.get("NETRC")
-
-    if netrc_env is not None:
-        netrc_path = Path(netrc_env)
-    else:
-        try:
-            home_dir = Path.home()
-        except RuntimeError as e:  # pragma: no cover
-            # if pathlib can't resolve home, it may raise a RuntimeError
-            client_logger.debug(
-                "Could not resolve home directory when "
-                "trying to look for .netrc file: %s",
-                e,
-            )
-            return None
-
-        netrc_path = home_dir / ("_netrc" if IS_WINDOWS else ".netrc")
-
-    try:
-        return netrc.netrc(str(netrc_path))
-    except netrc.NetrcParseError as e:
-        client_logger.warning("Could not parse .netrc file: %s", e)
-    except OSError as e:
-        # we couldn't read the file (doesn't exist, permissions, etc.)
-        if netrc_env or netrc_path.is_file():
-            # only warn if the environment wanted us to load it,
-            # or it appears like the default file does actually exist
-            client_logger.warning("Could not read .netrc file: %s", e)
-
-    return None
-
-
-@attr.s(auto_attribs=True, frozen=True, slots=True)
-class ProxyInfo:
-    proxy: URL
-    proxy_auth: Optional[BasicAuth]
-
-
-def proxies_from_env() -> Dict[str, ProxyInfo]:
-    proxy_urls = {
-        k: URL(v)
-        for k, v in getproxies().items()
-        if k in ("http", "https", "ws", "wss")
-    }
-    netrc_obj = netrc_from_env()
-    stripped = {k: strip_auth_from_url(v) for k, v in proxy_urls.items()}
-    ret = {}
-    for proto, val in stripped.items():
-        proxy, auth = val
-        if proxy.scheme in ("https", "wss"):
-            client_logger.warning(
-                "%s proxies %s are not supported, ignoring", proxy.scheme.upper(), proxy
-            )
-            continue
-        if netrc_obj and auth is None:
-            auth_from_netrc = None
-            if proxy.host is not None:
-                auth_from_netrc = netrc_obj.authenticators(proxy.host)
-            if auth_from_netrc is not None:
-                # auth_from_netrc is a (`user`, `account`, `password`) tuple,
-                # `user` and `account` both can be username,
-                # if `user` is None, use `account`
-                *logins, password = auth_from_netrc
-                login = logins[0] if logins[0] else logins[-1]
-                auth = BasicAuth(cast(str, login), cast(str, password))
-        ret[proto] = ProxyInfo(proxy, auth)
-    return ret
-
-
-def current_task(
-    loop: Optional[asyncio.AbstractEventLoop] = None,
-) -> "Optional[asyncio.Task[Any]]":
-    if sys.version_info >= (3, 7):
-        return asyncio.current_task(loop=loop)
-    else:
-        return asyncio.Task.current_task(loop=loop)
-
-
-def get_running_loop(
-    loop: Optional[asyncio.AbstractEventLoop] = None,
-) -> asyncio.AbstractEventLoop:
-    if loop is None:
-        loop = asyncio.get_event_loop()
-    if not loop.is_running():
-        warnings.warn(
-            "The object should be created within an async function",
-            DeprecationWarning,
-            stacklevel=3,
-        )
-        if loop.get_debug():
-            internal_logger.warning(
-                "The object should be created within an async function", stack_info=True
-            )
-    return loop
-
-
-def isasyncgenfunction(obj: Any) -> bool:
-    func = getattr(inspect, "isasyncgenfunction", None)
-    if func is not None:
-        return func(obj)  # type: ignore[no-any-return]
-    else:
-        return False
-
-
-def get_env_proxy_for_url(url: URL) -> Tuple[URL, Optional[BasicAuth]]:
-    """Get a permitted proxy for the given URL from the env."""
-    if url.host is not None and proxy_bypass(url.host):
-        raise LookupError(f"Proxying is disallowed for `{url.host!r}`")
-
-    proxies_in_env = proxies_from_env()
-    try:
-        proxy_info = proxies_in_env[url.scheme]
-    except KeyError:
-        raise LookupError(f"No proxies found for `{url!s}` in the env")
-    else:
-        return proxy_info.proxy, proxy_info.proxy_auth
-
-
-@attr.s(auto_attribs=True, frozen=True, slots=True)
-class MimeType:
-    type: str
-    subtype: str
-    suffix: str
-    parameters: "MultiDictProxy[str]"
-
-
-@functools.lru_cache(maxsize=56)
-def parse_mimetype(mimetype: str) -> MimeType:
-    """Parses a MIME type into its components.
-
-    mimetype is a MIME type string.
-
-    Returns a MimeType object.
-
-    Example:
-
-    >>> parse_mimetype('text/html; charset=utf-8')
-    MimeType(type='text', subtype='html', suffix='',
-             parameters={'charset': 'utf-8'})
-
-    """
-    if not mimetype:
-        return MimeType(
-            type="", subtype="", suffix="", parameters=MultiDictProxy(MultiDict())
-        )
-
-    parts = mimetype.split(";")
-    params: MultiDict[str] = MultiDict()
-    for item in parts[1:]:
-        if not item:
-            continue
-        key, value = cast(
-            Tuple[str, str], item.split("=", 1) if "=" in item else (item, "")
-        )
-        params.add(key.lower().strip(), value.strip(' "'))
-
-    fulltype = parts[0].strip().lower()
-    if fulltype == "*":
-        fulltype = "*/*"
-
-    mtype, stype = (
-        cast(Tuple[str, str], fulltype.split("/", 1))
-        if "/" in fulltype
-        else (fulltype, "")
-    )
-    stype, suffix = (
-        cast(Tuple[str, str], stype.split("+", 1)) if "+" in stype else (stype, "")
-    )
-
-    return MimeType(
-        type=mtype, subtype=stype, suffix=suffix, parameters=MultiDictProxy(params)
-    )
-
-
-def guess_filename(obj: Any, default: Optional[str] = None) -> Optional[str]:
-    name = getattr(obj, "name", None)
-    if name and isinstance(name, str) and name[0] != "<" and name[-1] != ">":
-        return Path(name).name
-    return default
-
-
-not_qtext_re = re.compile(r"[^\041\043-\133\135-\176]")
-QCONTENT = {chr(i) for i in range(0x20, 0x7F)} | {"\t"}
-
-
-def quoted_string(content: str) -> str:
-    """Return 7-bit content as quoted-string.
-
-    Format content into a quoted-string as defined in RFC5322 for
-    Internet Message Format. Notice that this is not the 8-bit HTTP
-    format, but the 7-bit email format. Content must be in usascii or
-    a ValueError is raised.
-    """
-    if not (QCONTENT > set(content)):
-        raise ValueError(f"bad content for quoted-string {content!r}")
-    return not_qtext_re.sub(lambda x: "\\" + x.group(0), content)
-
-
-def content_disposition_header(
-    disptype: str, quote_fields: bool = True, _charset: str = "utf-8", **params: str
-) -> str:
-    """Sets ``Content-Disposition`` header for MIME.
-
-    This is the MIME payload Content-Disposition header from RFC 2183
-    and RFC 7579 section 4.2, not the HTTP Content-Disposition from
-    RFC 6266.
-
-    disptype is a disposition type: inline, attachment, form-data.
-    Should be valid extension token (see RFC 2183)
-
-    quote_fields performs value quoting to 7-bit MIME headers
-    according to RFC 7578. Set to quote_fields to False if recipient
-    can take 8-bit file names and field values.
-
-    _charset specifies the charset to use when quote_fields is True.
-
-    params is a dict with disposition params.
-    """
-    if not disptype or not (TOKEN > set(disptype)):
-        raise ValueError("bad content disposition type {!r}" "".format(disptype))
-
-    value = disptype
-    if params:
-        lparams = []
-        for key, val in params.items():
-            if not key or not (TOKEN > set(key)):
-                raise ValueError(
-                    "bad content disposition parameter" " {!r}={!r}".format(key, val)
-                )
-            if quote_fields:
-                if key.lower() == "filename":
-                    qval = quote(val, "", encoding=_charset)
-                    lparams.append((key, '"%s"' % qval))
-                else:
-                    try:
-                        qval = quoted_string(val)
-                    except ValueError:
-                        qval = "".join(
-                            (_charset, "''", quote(val, "", encoding=_charset))
-                        )
-                        lparams.append((key + "*", qval))
-                    else:
-                        lparams.append((key, '"%s"' % qval))
-            else:
-                qval = val.replace("\\", "\\\\").replace('"', '\\"')
-                lparams.append((key, '"%s"' % qval))
-        sparams = "; ".join("=".join(pair) for pair in lparams)
-        value = "; ".join((value, sparams))
-    return value
-
-
-class _TSelf(Protocol, Generic[_T]):
-    _cache: Dict[str, _T]
-
-
-class reify(Generic[_T]):
-    """Use as a class method decorator.
-
-    It operates almost exactly like
-    the Python `@property` decorator, but it puts the result of the
-    method it decorates into the instance dict after the first call,
-    effectively replacing the function it decorates with an instance
-    variable.  It is, in Python parlance, a data descriptor.
-    """
-
-    def __init__(self, wrapped: Callable[..., _T]) -> None:
-        self.wrapped = wrapped
-        self.__doc__ = wrapped.__doc__
-        self.name = wrapped.__name__
-
-    def __get__(self, inst: _TSelf[_T], owner: Optional[Type[Any]] = None) -> _T:
-        try:
-            try:
-                return inst._cache[self.name]
-            except KeyError:
-                val = self.wrapped(inst)
-                inst._cache[self.name] = val
-                return val
-        except AttributeError:
-            if inst is None:
-                return self
-            raise
-
-    def __set__(self, inst: _TSelf[_T], value: _T) -> None:
-        raise AttributeError("reified property is read-only")
-
-
-reify_py = reify
-
-try:
-    from ._helpers import reify as reify_c
-
-    if not NO_EXTENSIONS:
-        reify = reify_c  # type: ignore[misc,assignment]
-except ImportError:
-    pass
-
-_ipv4_pattern = (
-    r"^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}"
-    r"(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$"
-)
-_ipv6_pattern = (
-    r"^(?:(?:(?:[A-F0-9]{1,4}:){6}|(?=(?:[A-F0-9]{0,4}:){0,6}"
-    r"(?:[0-9]{1,3}\.){3}[0-9]{1,3}$)(([0-9A-F]{1,4}:){0,5}|:)"
-    r"((:[0-9A-F]{1,4}){1,5}:|:)|::(?:[A-F0-9]{1,4}:){5})"
-    r"(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])\.){3}"
-    r"(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])|(?:[A-F0-9]{1,4}:){7}"
-    r"[A-F0-9]{1,4}|(?=(?:[A-F0-9]{0,4}:){0,7}[A-F0-9]{0,4}$)"
-    r"(([0-9A-F]{1,4}:){1,7}|:)((:[0-9A-F]{1,4}){1,7}|:)|(?:[A-F0-9]{1,4}:){7}"
-    r":|:(:[A-F0-9]{1,4}){7})$"
-)
-_ipv4_regex = re.compile(_ipv4_pattern)
-_ipv6_regex = re.compile(_ipv6_pattern, flags=re.IGNORECASE)
-_ipv4_regexb = re.compile(_ipv4_pattern.encode("ascii"))
-_ipv6_regexb = re.compile(_ipv6_pattern.encode("ascii"), flags=re.IGNORECASE)
-
-
-def _is_ip_address(
-    regex: Pattern[str], regexb: Pattern[bytes], host: Optional[Union[str, bytes]]
-) -> bool:
-    if host is None:
-        return False
-    if isinstance(host, str):
-        return bool(regex.match(host))
-    elif isinstance(host, (bytes, bytearray, memoryview)):
-        return bool(regexb.match(host))
-    else:
-        raise TypeError(f"{host} [{type(host)}] is not a str or bytes")
-
-
-is_ipv4_address = functools.partial(_is_ip_address, _ipv4_regex, _ipv4_regexb)
-is_ipv6_address = functools.partial(_is_ip_address, _ipv6_regex, _ipv6_regexb)
-
-
-def is_ip_address(host: Optional[Union[str, bytes, bytearray, memoryview]]) -> bool:
-    return is_ipv4_address(host) or is_ipv6_address(host)
-
-
-def next_whole_second() -> datetime.datetime:
-    """Return current time rounded up to the next whole second."""
-    return datetime.datetime.now(datetime.timezone.utc).replace(
-        microsecond=0
-    ) + datetime.timedelta(seconds=0)
-
-
-_cached_current_datetime: Optional[int] = None
-_cached_formatted_datetime = ""
-
-
-def rfc822_formatted_time() -> str:
-    global _cached_current_datetime
-    global _cached_formatted_datetime
-
-    now = int(time.time())
-    if now != _cached_current_datetime:
-        # Weekday and month names for HTTP date/time formatting;
-        # always English!
-        # Tuples are constants stored in codeobject!
-        _weekdayname = ("Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun")
-        _monthname = (
-            "",  # Dummy so we can use 1-based month numbers
-            "Jan",
-            "Feb",
-            "Mar",
-            "Apr",
-            "May",
-            "Jun",
-            "Jul",
-            "Aug",
-            "Sep",
-            "Oct",
-            "Nov",
-            "Dec",
-        )
-
-        year, month, day, hh, mm, ss, wd, *tail = time.gmtime(now)
-        _cached_formatted_datetime = "%s, %02d %3s %4d %02d:%02d:%02d GMT" % (
-            _weekdayname[wd],
-            day,
-            _monthname[month],
-            year,
-            hh,
-            mm,
-            ss,
-        )
-        _cached_current_datetime = now
-    return _cached_formatted_datetime
-
-
-def _weakref_handle(info: "Tuple[weakref.ref[object], str]") -> None:
-    ref, name = info
-    ob = ref()
-    if ob is not None:
-        with suppress(Exception):
-            getattr(ob, name)()
-
-
-def weakref_handle(
-    ob: object, name: str, timeout: float, loop: asyncio.AbstractEventLoop
-) -> Optional[asyncio.TimerHandle]:
-    if timeout is not None and timeout > 0:
-        when = loop.time() + timeout
-        if timeout >= 5:
-            when = ceil(when)
-
-        return loop.call_at(when, _weakref_handle, (weakref.ref(ob), name))
-    return None
-
-
-def call_later(
-    cb: Callable[[], Any], timeout: float, loop: asyncio.AbstractEventLoop
-) -> Optional[asyncio.TimerHandle]:
-    if timeout is not None and timeout > 0:
-        when = loop.time() + timeout
-        if timeout > 5:
-            when = ceil(when)
-        return loop.call_at(when, cb)
-    return None
-
-
-class TimeoutHandle:
-    """Timeout handle"""
-
-    def __init__(
-        self, loop: asyncio.AbstractEventLoop, timeout: Optional[float]
-    ) -> None:
-        self._timeout = timeout
-        self._loop = loop
-        self._callbacks: List[
-            Tuple[Callable[..., None], Tuple[Any, ...], Dict[str, Any]]
-        ] = []
-
-    def register(
-        self, callback: Callable[..., None], *args: Any, **kwargs: Any
-    ) -> None:
-        self._callbacks.append((callback, args, kwargs))
-
-    def close(self) -> None:
-        self._callbacks.clear()
-
-    def start(self) -> Optional[asyncio.Handle]:
-        timeout = self._timeout
-        if timeout is not None and timeout > 0:
-            when = self._loop.time() + timeout
-            if timeout >= 5:
-                when = ceil(when)
-            return self._loop.call_at(when, self.__call__)
-        else:
-            return None
-
-    def timer(self) -> "BaseTimerContext":
-        if self._timeout is not None and self._timeout > 0:
-            timer = TimerContext(self._loop)
-            self.register(timer.timeout)
-            return timer
-        else:
-            return TimerNoop()
-
-    def __call__(self) -> None:
-        for cb, args, kwargs in self._callbacks:
-            with suppress(Exception):
-                cb(*args, **kwargs)
-
-        self._callbacks.clear()
-
-
-class BaseTimerContext(ContextManager["BaseTimerContext"]):
-    pass
-
-
-class TimerNoop(BaseTimerContext):
-    def __enter__(self) -> BaseTimerContext:
-        return self
-
-    def __exit__(
-        self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
-    ) -> None:
-        return
-
-
-class TimerContext(BaseTimerContext):
-    """Low resolution timeout context manager"""
-
-    def __init__(self, loop: asyncio.AbstractEventLoop) -> None:
-        self._loop = loop
-        self._tasks: List[asyncio.Task[Any]] = []
-        self._cancelled = False
-
-    def __enter__(self) -> BaseTimerContext:
-        task = current_task(loop=self._loop)
-
-        if task is None:
-            raise RuntimeError(
-                "Timeout context manager should be used " "inside a task"
-            )
-
-        if self._cancelled:
-            raise asyncio.TimeoutError from None
-
-        self._tasks.append(task)
-        return self
-
-    def __exit__(
-        self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
-    ) -> Optional[bool]:
-        if self._tasks:
-            self._tasks.pop()
-
-        if exc_type is asyncio.CancelledError and self._cancelled:
-            raise asyncio.TimeoutError from None
-        return None
-
-    def timeout(self) -> None:
-        if not self._cancelled:
-            for task in set(self._tasks):
-                task.cancel()
-
-            self._cancelled = True
-
-
-def ceil_timeout(delay: Optional[float]) -> async_timeout.Timeout:
-    if delay is None or delay <= 0:
-        return async_timeout.timeout(None)
-
-    loop = get_running_loop()
-    now = loop.time()
-    when = now + delay
-    if delay > 5:
-        when = ceil(when)
-    return async_timeout.timeout_at(when)
-
-
-class HeadersMixin:
-
-    ATTRS = frozenset(["_content_type", "_content_dict", "_stored_content_type"])
-
-    _content_type: Optional[str] = None
-    _content_dict: Optional[Dict[str, str]] = None
-    _stored_content_type = sentinel
-
-    def _parse_content_type(self, raw: str) -> None:
-        self._stored_content_type = raw
-        if raw is None:
-            # default value according to RFC 2616
-            self._content_type = "application/octet-stream"
-            self._content_dict = {}
-        else:
-            msg = HeaderParser().parsestr("Content-Type: " + raw)
-            self._content_type = msg.get_content_type()
-            params = msg.get_params()
-            self._content_dict = dict(params[1:])  # First element is content type again
-
-    @property
-    def content_type(self) -> str:
-        """The value of content part for Content-Type HTTP header."""
-        raw = self._headers.get(hdrs.CONTENT_TYPE)  # type: ignore[attr-defined]
-        if self._stored_content_type != raw:
-            self._parse_content_type(raw)
-        return self._content_type  # type: ignore[return-value]
-
-    @property
-    def charset(self) -> Optional[str]:
-        """The value of charset part for Content-Type HTTP header."""
-        raw = self._headers.get(hdrs.CONTENT_TYPE)  # type: ignore[attr-defined]
-        if self._stored_content_type != raw:
-            self._parse_content_type(raw)
-        return self._content_dict.get("charset")  # type: ignore[union-attr]
-
-    @property
-    def content_length(self) -> Optional[int]:
-        """The value of Content-Length HTTP header."""
-        content_length = self._headers.get(  # type: ignore[attr-defined]
-            hdrs.CONTENT_LENGTH
-        )
-
-        if content_length is not None:
-            return int(content_length)
-        else:
-            return None
-
-
-def set_result(fut: "asyncio.Future[_T]", result: _T) -> None:
-    if not fut.done():
-        fut.set_result(result)
-
-
-def set_exception(fut: "asyncio.Future[_T]", exc: BaseException) -> None:
-    if not fut.done():
-        fut.set_exception(exc)
-
-
-class ChainMapProxy(Mapping[str, Any]):
-    __slots__ = ("_maps",)
-
-    def __init__(self, maps: Iterable[Mapping[str, Any]]) -> None:
-        self._maps = tuple(maps)
-
-    def __init_subclass__(cls) -> None:
-        raise TypeError(
-            "Inheritance class {} from ChainMapProxy "
-            "is forbidden".format(cls.__name__)
-        )
-
-    def __getitem__(self, key: str) -> Any:
-        for mapping in self._maps:
-            try:
-                return mapping[key]
-            except KeyError:
-                pass
-        raise KeyError(key)
-
-    def get(self, key: str, default: Any = None) -> Any:
-        return self[key] if key in self else default
-
-    def __len__(self) -> int:
-        # reuses stored hash values if possible
-        return len(set().union(*self._maps))  # type: ignore[arg-type]
-
-    def __iter__(self) -> Iterator[str]:
-        d: Dict[str, Any] = {}
-        for mapping in reversed(self._maps):
-            # reuses stored hash values if possible
-            d.update(mapping)
-        return iter(d)
-
-    def __contains__(self, key: object) -> bool:
-        return any(key in m for m in self._maps)
-
-    def __bool__(self) -> bool:
-        return any(self._maps)
-
-    def __repr__(self) -> str:
-        content = ", ".join(map(repr, self._maps))
-        return f"ChainMapProxy({content})"
-
-
-# https://tools.ietf.org/html/rfc7232#section-2.3
-_ETAGC = r"[!#-}\x80-\xff]+"
-_ETAGC_RE = re.compile(_ETAGC)
-_QUOTED_ETAG = rf'(W/)?"({_ETAGC})"'
-QUOTED_ETAG_RE = re.compile(_QUOTED_ETAG)
-LIST_QUOTED_ETAG_RE = re.compile(rf"({_QUOTED_ETAG})(?:\s*,\s*|$)|(.)")
-
-ETAG_ANY = "*"
-
-
-@attr.s(auto_attribs=True, frozen=True, slots=True)
-class ETag:
-    value: str
-    is_weak: bool = False
-
-
-def validate_etag_value(value: str) -> None:
-    if value != ETAG_ANY and not _ETAGC_RE.fullmatch(value):
-        raise ValueError(
-            f"Value {value!r} is not a valid etag. Maybe it contains '\"'?"
-        )
-
-
-def parse_http_date(date_str: Optional[str]) -> Optional[datetime.datetime]:
-    """Process a date string, return a datetime object"""
-    if date_str is not None:
-        timetuple = parsedate(date_str)
-        if timetuple is not None:
-            with suppress(ValueError):
-                return datetime.datetime(*timetuple[:6], tzinfo=datetime.timezone.utc)
-    return None

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/annotated_types/__init__.py

@@ -1,319 +0,0 @@
-import sys
-from dataclasses import dataclass
-from datetime import timezone
-from typing import TYPE_CHECKING, Any, Callable, Iterator, Optional, TypeVar, Union
-
-if sys.version_info < (3, 8):
-    from typing_extensions import Protocol, runtime_checkable
-else:
-    from typing import Protocol, runtime_checkable
-
-if sys.version_info < (3, 9):
-    from typing_extensions import Annotated, Literal
-else:
-    from typing import Annotated, Literal
-
-if sys.version_info < (3, 10):
-    EllipsisType = type(Ellipsis)
-    KW_ONLY = {}
-    SLOTS = {}
-else:
-    from types import EllipsisType
-
-    KW_ONLY = {"kw_only": True}
-    SLOTS = {"slots": True}
-
-
-__all__ = (
-    'BaseMetadata',
-    'GroupedMetadata',
-    'Gt',
-    'Ge',
-    'Lt',
-    'Le',
-    'Interval',
-    'MultipleOf',
-    'MinLen',
-    'MaxLen',
-    'Len',
-    'Timezone',
-    'Predicate',
-    'LowerCase',
-    'UpperCase',
-    'IsDigits',
-    '__version__',
-)
-
-__version__ = '0.5.0'
-
-
-T = TypeVar('T')
-
-
-# arguments that start with __ are considered
-# positional only
-# see https://peps.python.org/pep-0484/#positional-only-arguments
-
-
-class SupportsGt(Protocol):
-    def __gt__(self: T, __other: T) -> bool:
-        ...
-
-
-class SupportsGe(Protocol):
-    def __ge__(self: T, __other: T) -> bool:
-        ...
-
-
-class SupportsLt(Protocol):
-    def __lt__(self: T, __other: T) -> bool:
-        ...
-
-
-class SupportsLe(Protocol):
-    def __le__(self: T, __other: T) -> bool:
-        ...
-
-
-class SupportsMod(Protocol):
-    def __mod__(self: T, __other: T) -> T:
-        ...
-
-
-class SupportsDiv(Protocol):
-    def __div__(self: T, __other: T) -> T:
-        ...
-
-
-class BaseMetadata:
-    """Base class for all metadata.
-
-    This exists mainly so that implementers
-    can do `isinstance(..., BaseMetadata)` while traversing field annotations.
-    """
-
-    __slots__ = ()
-
-
-@dataclass(frozen=True, **SLOTS)
-class Gt(BaseMetadata):
-    """Gt(gt=x) implies that the value must be greater than x.
-
-    It can be used with any type that supports the ``>`` operator,
-    including numbers, dates and times, strings, sets, and so on.
-    """
-
-    gt: SupportsGt
-
-
-@dataclass(frozen=True, **SLOTS)
-class Ge(BaseMetadata):
-    """Ge(ge=x) implies that the value must be greater than or equal to x.
-
-    It can be used with any type that supports the ``>=`` operator,
-    including numbers, dates and times, strings, sets, and so on.
-    """
-
-    ge: SupportsGe
-
-
-@dataclass(frozen=True, **SLOTS)
-class Lt(BaseMetadata):
-    """Lt(lt=x) implies that the value must be less than x.
-
-    It can be used with any type that supports the ``<`` operator,
-    including numbers, dates and times, strings, sets, and so on.
-    """
-
-    lt: SupportsLt
-
-
-@dataclass(frozen=True, **SLOTS)
-class Le(BaseMetadata):
-    """Le(le=x) implies that the value must be less than or equal to x.
-
-    It can be used with any type that supports the ``<=`` operator,
-    including numbers, dates and times, strings, sets, and so on.
-    """
-
-    le: SupportsLe
-
-
-@runtime_checkable
-class GroupedMetadata(Protocol):
-    """A grouping of multiple BaseMetadata objects.
-
-    `GroupedMetadata` on its own is not metadata and has no meaning.
-    All it the the constraint and metadata should be fully expressable
-    in terms of the `BaseMetadata`'s returned by `GroupedMetadata.__iter__()`.
-
-    Concrete implementations should override `GroupedMetadata.__iter__()`
-    to add their own metadata.
-    For example:
-
-    >>> @dataclass
-    >>> class Field(GroupedMetadata):
-    >>>     gt: float | None = None
-    >>>     description: str | None = None
-    ...
-    >>>     def __iter__(self) -> Iterable[BaseMetadata]:
-    >>>         if self.gt is not None:
-    >>>             yield Gt(self.gt)
-    >>>         if self.description is not None:
-    >>>             yield Description(self.gt)
-
-    Also see the implementation of `Interval` below for an example.
-
-    Parsers should recognize this and unpack it so that it can be used
-    both with and without unpacking:
-
-    - `Annotated[int, Field(...)]` (parser must unpack Field)
-    - `Annotated[int, *Field(...)]` (PEP-646)
-    """  # noqa: trailing-whitespace
-
-    @property
-    def __is_annotated_types_grouped_metadata__(self) -> Literal[True]:
-        return True
-
-    def __iter__(self) -> Iterator[BaseMetadata]:
-        ...
-
-    if not TYPE_CHECKING:
-        __slots__ = ()  # allow subclasses to use slots
-
-        def __init_subclass__(cls, *args: Any, **kwargs: Any) -> None:
-            # Basic ABC like functionality without the complexity of an ABC
-            super().__init_subclass__(*args, **kwargs)
-            if cls.__iter__ is GroupedMetadata.__iter__:
-                raise TypeError("Can't subclass GroupedMetadata without implementing __iter__")
-
-        def __iter__(self) -> Iterator[BaseMetadata]:  # noqa: F811
-            raise NotImplementedError  # more helpful than "None has no attribute..." type errors
-
-
-@dataclass(frozen=True, **KW_ONLY, **SLOTS)
-class Interval(GroupedMetadata):
-    """Interval can express inclusive or exclusive bounds with a single object.
-
-    It accepts keyword arguments ``gt``, ``ge``, ``lt``, and/or ``le``, which
-    are interpreted the same way as the single-bound constraints.
-    """
-
-    gt: Union[SupportsGt, None] = None
-    ge: Union[SupportsGe, None] = None
-    lt: Union[SupportsLt, None] = None
-    le: Union[SupportsLe, None] = None
-
-    def __iter__(self) -> Iterator[BaseMetadata]:
-        """Unpack an Interval into zero or more single-bounds."""
-        if self.gt is not None:
-            yield Gt(self.gt)
-        if self.ge is not None:
-            yield Ge(self.ge)
-        if self.lt is not None:
-            yield Lt(self.lt)
-        if self.le is not None:
-            yield Le(self.le)
-
-
-@dataclass(frozen=True, **SLOTS)
-class MultipleOf(BaseMetadata):
-    """MultipleOf(multiple_of=x) might be interpreted in two ways:
-
-    1. Python semantics, implying ``value % multiple_of == 0``, or
-    2. JSONschema semantics, where ``int(value / multiple_of) == value / multiple_of``
-
-    We encourage users to be aware of these two common interpretations,
-    and libraries to carefully document which they implement.
-    """
-
-    multiple_of: Union[SupportsDiv, SupportsMod]
-
-
-@dataclass(frozen=True, **SLOTS)
-class MinLen(BaseMetadata):
-    """
-    MinLen() implies minimum inclusive length,
-    e.g. ``len(value) >= min_length``.
-    """
-
-    min_length: Annotated[int, Ge(0)]
-
-
-@dataclass(frozen=True, **SLOTS)
-class MaxLen(BaseMetadata):
-    """
-    MaxLen() implies maximum inclusive length,
-    e.g. ``len(value) <= max_length``.
-    """
-
-    max_length: Annotated[int, Ge(0)]
-
-
-@dataclass(frozen=True, **SLOTS)
-class Len(GroupedMetadata):
-    """
-    Len() implies that ``min_length <= len(value) <= max_length``.
-
-    Upper bound may be omitted or ``None`` to indicate no upper length bound.
-    """
-
-    min_length: Annotated[int, Ge(0)] = 0
-    max_length: Optional[Annotated[int, Ge(0)]] = None
-
-    def __iter__(self) -> Iterator[BaseMetadata]:
-        """Unpack a Len into zone or more single-bounds."""
-        if self.min_length > 0:
-            yield MinLen(self.min_length)
-        if self.max_length is not None:
-            yield MaxLen(self.max_length)
-
-
-@dataclass(frozen=True, **SLOTS)
-class Timezone(BaseMetadata):
-    """Timezone(tz=...) requires a datetime to be aware (or ``tz=None``, naive).
-
-    ``Annotated[datetime, Timezone(None)]`` must be a naive datetime.
-    ``Timezone[...]`` (the ellipsis literal) expresses that the datetime must be
-    tz-aware but any timezone is allowed.
-
-    You may also pass a specific timezone string or timezone object such as
-    ``Timezone(timezone.utc)`` or ``Timezone("Africa/Abidjan")`` to express that
-    you only allow a specific timezone, though we note that this is often
-    a symptom of poor design.
-    """
-
-    tz: Union[str, timezone, EllipsisType, None]
-
-
-@dataclass(frozen=True, **SLOTS)
-class Predicate(BaseMetadata):
-    """``Predicate(func: Callable)`` implies `func(value)` is truthy for valid values.
-
-    Users should prefer statically inspectable metadata, but if you need the full
-    power and flexibility of arbitrary runtime predicates... here it is.
-
-    We provide a few predefined predicates for common string constraints:
-    ``IsLower = Predicate(str.islower)``, ``IsUpper = Predicate(str.isupper)``, and
-    ``IsDigit = Predicate(str.isdigit)``. Users are encouraged to use methods which
-    can be given special handling, and avoid indirection like ``lambda s: s.lower()``.
-
-    Some libraries might have special logic to handle certain predicates, e.g. by
-    checking for `str.isdigit` and using its presence to both call custom logic to
-    enforce digit-only strings, and customise some generated external schema.
-
-    We do not specify what behaviour should be expected for predicates that raise
-    an exception.  For example `Annotated[int, Predicate(str.isdigit)]` might silently
-    skip invalid constraints, or statically raise an error; or it might try calling it
-    and then propogate or discard the resulting exception.
-    """
-
-    func: Callable[[Any], bool]
-
-
-StrType = TypeVar("StrType", bound=str)
-
-LowerCase = Annotated[StrType, Predicate(str.islower)]
-UpperCase = Annotated[StrType, Predicate(str.isupper)]
-IsDigits = Annotated[StrType, Predicate(str.isdigit)]
-IsAscii = Annotated[StrType, Predicate(str.isascii)]

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fontTools/feaLib/variableScalar.py

@@ -1,112 +0,0 @@
-from fontTools.varLib.models import VariationModel, normalizeValue, piecewiseLinearMap
-
-
-def Location(loc):
-    return tuple(sorted(loc.items()))
-
-
-class VariableScalar:
-    """A scalar with different values at different points in the designspace."""
-
-    def __init__(self, location_value={}):
-        self.values = {}
-        self.axes = {}
-        for location, value in location_value.items():
-            self.add_value(location, value)
-
-    def __repr__(self):
-        items = []
-        for location, value in self.values.items():
-            loc = ",".join(["%s=%i" % (ax, loc) for ax, loc in location])
-            items.append("%s:%i" % (loc, value))
-        return "(" + (" ".join(items)) + ")"
-
-    @property
-    def does_vary(self):
-        values = list(self.values.values())
-        return any(v != values[0] for v in values[1:])
-
-    @property
-    def axes_dict(self):
-        if not self.axes:
-            raise ValueError(
-                ".axes must be defined on variable scalar before interpolating"
-            )
-        return {ax.axisTag: ax for ax in self.axes}
-
-    def _normalized_location(self, location):
-        location = self.fix_location(location)
-        normalized_location = {}
-        for axtag in location.keys():
-            if axtag not in self.axes_dict:
-                raise ValueError("Unknown axis %s in %s" % (axtag, location))
-            axis = self.axes_dict[axtag]
-            normalized_location[axtag] = normalizeValue(
-                location[axtag], (axis.minValue, axis.defaultValue, axis.maxValue)
-            )
-
-        return Location(normalized_location)
-
-    def fix_location(self, location):
-        location = dict(location)
-        for tag, axis in self.axes_dict.items():
-            if tag not in location:
-                location[tag] = axis.defaultValue
-        return location
-
-    def add_value(self, location, value):
-        if self.axes:
-            location = self.fix_location(location)
-
-        self.values[Location(location)] = value
-
-    def fix_all_locations(self):
-        self.values = {
-            Location(self.fix_location(l)): v for l, v in self.values.items()
-        }
-
-    @property
-    def default(self):
-        self.fix_all_locations()
-        key = Location({ax.axisTag: ax.defaultValue for ax in self.axes})
-        if key not in self.values:
-            raise ValueError("Default value could not be found")
-            # I *guess* we could interpolate one, but I don't know how.
-        return self.values[key]
-
-    def value_at_location(self, location, model_cache=None, avar=None):
-        loc = location
-        if loc in self.values.keys():
-            return self.values[loc]
-        values = list(self.values.values())
-        return self.model(model_cache, avar).interpolateFromMasters(loc, values)
-
-    def model(self, model_cache=None, avar=None):
-        if model_cache is not None:
-            key = tuple(self.values.keys())
-            if key in model_cache:
-                return model_cache[key]
-        locations = [dict(self._normalized_location(k)) for k in self.values.keys()]
-        if avar is not None:
-            mapping = avar.segments
-            locations = [
-                {
-                    k: piecewiseLinearMap(v, mapping[k]) if k in mapping else v
-                    for k, v in location.items()
-                }
-                for location in locations
-            ]
-        m = VariationModel(locations)
-        if model_cache is not None:
-            model_cache[key] = m
-        return m
-
-    def get_deltas_and_supports(self, model_cache=None, avar=None):
-        values = list(self.values.values())
-        return self.model(model_cache, avar).getDeltasAndSupports(values)
-
-    def add_to_variation_store(self, store_builder, model_cache=None, avar=None):
-        deltas, supports = self.get_deltas_and_supports(model_cache, avar)
-        store_builder.setSupports(supports)
-        index = store_builder.storeDeltas(deltas)
-        return int(self.default), index

spaces/DaFujaTyping/hf-Chat-ui/src/lib/stores/errors.ts

@@ -1,7 +0,0 @@
-import { writable } from "svelte/store";
-
-export const ERROR_MESSAGES = {
-	default: "Oops, something went wrong.",
-};
-
-export const error = writable<string | null>(null);

spaces/DaleChen/AutoGPT/tests.py

@@ -1,21 +0,0 @@
-import unittest
-
-import coverage
-
-if __name__ == "__main__":
-    # Start coverage collection
-    cov = coverage.Coverage()
-    cov.start()
-
-    # Load all tests from the 'autogpt/tests' package
-    suite = unittest.defaultTestLoader.discover("./tests")
-
-    # Run the tests
-    unittest.TextTestRunner().run(suite)
-
-    # Stop coverage collection
-    cov.stop()
-    cov.save()
-
-    # Report the coverage
-    cov.report(show_missing=True)

spaces/Datasculptor/3D-Room-Layout-Estimation_LGT-Net/utils/height.py

@@ -1,131 +0,0 @@
-"""
-@date: 2021/6/30
-@description:
-"""
-import numpy as np
-from typing import List
-
-from utils.boundary import *
-from scipy.optimize import least_squares
-from functools import partial
-
-
-def lsq_fit(ceil_norm, floor_norm):
-    """
-    Least Squares
-    :param ceil_norm:
-    :param floor_norm:
-    :return:
-    """
-
-    def error_fun(ratio, ceil_norm, floor_norm):
-        error = np.abs(ratio * ceil_norm - floor_norm)
-        return error
-
-    init_ratio = np.mean(floor_norm / ceil_norm, axis=-1)
-    error_func = partial(error_fun, ceil_norm=ceil_norm, floor_norm=floor_norm)
-    ret = least_squares(error_func, init_ratio, verbose=0)
-    ratio = ret.x[0]
-    return ratio
-
-
-def mean_percentile_fit(ceil_norm, floor_norm, p1=25, p2=75):
-    """
-    :param ceil_norm:
-    :param floor_norm:
-    :param p1:
-    :param p2:
-    :return:
-    """
-    ratio = floor_norm / ceil_norm
-    r_min = np.percentile(ratio, p1)
-    r_max = np.percentile(ratio, p2)
-    return ratio[(r_min <= ratio) & (ratio <= r_max)].mean()
-
-
-def calc_ceil_ratio(boundaries: List[np.array], mode='lsq'):
-    """
-    :param boundaries: [ [[cu1, cv1], [cu2, cv2], ...], [[fu1, fv1], [fu2, fv2], ...] ]
-    :param mode: 'lsq' or 'mean'
-    :return:
-    """
-    assert len(boundaries[0].shape) < 4 and len(boundaries[1].shape) < 4, 'error shape'
-    if not is_normal_layout(boundaries):
-        return 0
-
-    ceil_boundary = boundaries[0]
-    floor_boundary = boundaries[1]
-    assert ceil_boundary.shape[-2] == floor_boundary.shape[-2], "boundary need same length"
-
-    ceil_xyz = uv2xyz(ceil_boundary, -1)
-    floor_xyz = uv2xyz(floor_boundary, 1)
-
-    ceil_xz = ceil_xyz[..., ::2]
-    floor_xz = floor_xyz[..., ::2]
-
-    ceil_norm = np.linalg.norm(ceil_xz, axis=-1)
-    floor_norm = np.linalg.norm(floor_xz, axis=-1)
-
-    if mode == "lsq":
-        if len(ceil_norm.shape) == 2:
-            ratio = np.array([lsq_fit(ceil_norm[i], floor_norm[i]) for i in range(ceil_norm.shape[0])])
-        else:
-            ratio = lsq_fit(ceil_norm, floor_norm)
-    else:
-        if len(ceil_norm.shape) == 2:
-            ratio = np.array([mean_percentile_fit(ceil_norm[i], floor_norm[i]) for i in range(ceil_norm.shape[0])])
-        else:
-            ratio = mean_percentile_fit(ceil_norm, floor_norm)
-
-    return ratio
-
-
-def calc_ceil_height(boundaries: List[np.array], camera_height=1.6, mode='lsq') -> float:
-    """
-    :param boundaries: [ [[cu1, cv1], [cu2, cv2], ...], [[fu1, fv1], [fu2, fv2], ...] ]
-    :param camera_height:
-    :param mode:
-    :return:
-    """
-    ratio = calc_ceil_ratio(boundaries, mode)
-    ceil_height = camera_height * ratio
-    return ceil_height
-
-
-def calc_room_height(boundaries: List[np.array], camera_height=1.6, mode='lsq') -> float:
-    """
-    :param boundaries: also can corners，format: [ [[cu1, cv1], [cu2, cv2], ...], [[fu1, fv1], [fu2, fv2], ...] ],
-    0 denotes ceil, 1 denotes floor
-    :param camera_height: actual camera height determines the scale
-    :param mode: fitting method lsq or mean
-    :return:
-    """
-    ceil_height = calc_ceil_height(boundaries, camera_height, mode)
-    room_height = camera_height + ceil_height
-    return room_height
-
-
-def height2ratio(height, camera_height=1.6):
-    ceil_height = height - camera_height
-    ratio = ceil_height / camera_height
-    return ratio
-
-
-def ratio2height(ratio, camera_height=1.6):
-    ceil_height = camera_height * ratio
-    room_height = camera_height + ceil_height
-    return room_height
-
-
-if __name__ == '__main__':
-    from dataset.mp3d_dataset import MP3DDataset
-
-    dataset = MP3DDataset(root_dir="../src/dataset/mp3d", mode="train")
-    for data in dataset:
-        ceil_corners = data['corners'][::2]
-        floor_corners = data['corners'][1::2]
-        # ceil_boundary = corners2boundary(ceil_corners, length=1024)
-        # floor_boundary = corners2boundary(floor_corners, length=1024)
-        room_height1 = calc_room_height([ceil_corners, floor_corners], camera_height=1.6, mode='mean')
-        room_height2 = calc_room_height([ceil_corners, floor_corners], camera_height=1.6, mode='lsq')
-        print(room_height1, room_height2, data['cameraCeilingHeight'] + 1.6)

spaces/Datasculptor/DescriptionGPT/tools/remove_lvis_rare.py

@@ -1,20 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import argparse
-import json
-
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--ann', default='datasets/lvis/lvis_v1_train.json')
-    args = parser.parse_args()
-
-    print('Loading', args.ann)
-    data = json.load(open(args.ann, 'r'))
-    catid2freq = {x['id']: x['frequency'] for x in data['categories']}
-    print('ori #anns', len(data['annotations']))
-    exclude = ['r']
-    data['annotations'] = [x for x in data['annotations'] \
-        if catid2freq[x['category_id']] not in exclude]
-    print('filtered #anns', len(data['annotations']))
-    out_path = args.ann[:-5] + '_norare.json'
-    print('Saving to', out_path)
-    json.dump(data, open(out_path, 'w'))

spaces/EllaTsoi/text_generator/app.py

@@ -1,10 +0,0 @@
-import gradio as gr
-from gradio.mix import Parallel
-
-title = "My First Text Generator"
-description = "input text and submit."
-
-model1=gr.Interface.load("huggingface/EleutherAI/gpt-neo-1.3B")
-model3=gr.Interface.load("huggingface/EleutherAI/gpt-neo-2.7B")
-
-gr.Parallel(model1 , model3, title=title,description=description).launch()