Datasets:

Weyaxi
/

huggingface-spaces-codes

@@ -1,9 +0,0 @@
-<br />
-<p>photoshop is considered one of the most powerful image editing software packages available. it is used by digital photographers, graphic designers, and just about anyone who has an interest in editing images. photoshop has the capability to change almost any aspect of a photo, making it an impressive software package.</p>
-<h2>adobe photoshop cs 9 free download</h2><br /><p><b><b>Download</b> &#9658;&#9658;&#9658; <a href="https://imgfil.com/2uxX4P">https://imgfil.com/2uxX4P</a></b></p><br /><br />
-<p>adobe photoshop is one of the most popular software programs available. it is used for a variety of tasks including retouching your images, creating graphics and images, creating websites, and much more. the good thing about photoshop is that the program is very easy to use and has a lot of features that allow users to edit any type of file or project. the application is also capable of handling enormous files.</p>
-<p>as you know, photoshop is the top photoshopping software for the mac. but it has been made available for os x. the demo version of photoshop cs6 can be downloaded through the website for mac os x. the latest versions of photoshop elements and photoshop cs6 are on sale for $39.99 and $179.99 respectively. so if you are not the most technology savvy person, fear not. the software is fairly simple to use and it can be installed on a mac os x 10.6 and up or windows xp and up.</p>
-<p>the latest version of photoshop cs6 (adobe photoshop cs6 + adobe photoshop cs6 extended + adobe photoshop cs6 essentials) are on sale for $119.99, $399.99, $219.99 respectively. they can be downloaded directly at the adobe website, otherwise you can also choose to pay through the adobe acrobat connect site. if you have adobe acrobat you can get the software to run on your computer. you also get access to acrobat reader which lets you read, save, print, and annotate pdf files. the adobe photoshop cs6 gives you the ability to work and create images on different layers or files which allows you to combine, edit or reposition any number of images and text on layers. you can also crop, adjust or rotate the layer contents. it lets you share your finished image or component with others. you can read the help files or you can simply make use of the extensive menus to access the software. the whole software is free of all adware, malware or spyware.</p>
-<p></p> 899543212b<br />
-<br />
-<br />

spaces/1gistliPinn/ChatGPT4/Examples/Free !!HOT!! Download 007 Facebook Hack V1.0 With Full Cracked.md DELETED Viewed

@@ -1,108 +0,0 @@
-<br />
-<h1>Free Download 007 Facebook Hack v1.0 with Full Cracked</h1>
-<p>If you are looking for a way to hack into any Facebook account, you have come to the right place. In this article, we will show you how to use 007 Facebook Hack v1.0 with Full Cracked, a powerful and easy-to-use tool that can help you spy on anyone's Facebook activities.</p>
-<h2>What is 007 Facebook Hack v1.0 with Full Cracked?</h2>
-<p>007 Facebook Hack v1.0 with Full Cracked is a software that allows you to hack any Facebook account by simply entering the email address or username of the target. You don't need to know the password or any other details of the account. The software will automatically retrieve the login information and display it on your screen.</p>
-<h2>free download 007 facebook hack v1.0 with full cracked</h2><br /><p><b><b>Download Zip</b> &#9881;&#9881;&#9881; <a href="https://imgfil.com/2uy0zG">https://imgfil.com/2uy0zG</a></b></p><br /><br />
-<p>With 007 Facebook Hack v1.0 with Full Cracked, you can access the private messages, photos, videos, friends list, wall posts, comments, likes, groups, events, and more of any Facebook user. You can also change the password, profile picture, status, and other settings of the hacked account.</p>
-<h2>Why use 007 Facebook Hack v1.0 with Full Cracked?</h2>
-<p>There are many reasons why you might want to use 007 Facebook Hack v1.0 with Full Cracked. For example, you might want to:</p>
-<ul>
-<li>Monitor your spouse, partner, children, or friends' online activities and find out if they are cheating on you, lying to you, or hiding something from you.</li>
-<li>Recover your own Facebook account if you forgot your password or lost access to your email or phone number.</li>
-<li>Protect your privacy and security by checking if someone else is using your Facebook account without your permission.</li>
-<li>Have fun and prank your friends by changing their profile picture, status, or sending funny messages to their contacts.</li>
-<li>Learn more about someone you are interested in by viewing their personal information, interests, hobbies, preferences, etc.</li>
-</ul>
-<h2>How to use 007 Facebook Hack v1.0 with Full Cracked?</h2>
-<p>Using 007 Facebook Hack v1.0 with Full Cracked is very simple and straightforward. Just follow these steps:</p>
-<ol>
-<li>Download 007 Facebook Hack v1.0 with Full Cracked from the link below.</li>
-<li>Extract the zip file and run the setup.exe file to install the software on your computer.</li>
-<li>Open the software and enter the email address or username of the Facebook account you want to hack.</li>
-<li>Click on the "Hack" button and wait for a few seconds.</li>
-<li>The software will display the password and other details of the hacked account on your screen.</li>
-<li>Enjoy!</li>
-</ol>
-<h2>Where to download 007 Facebook Hack v1.0 with Full Cracked?</h2>
-<p>You can download 007 Facebook Hack v1.0 with Full Cracked for free from the link below. The software is safe and virus-free. It works on Windows XP, Vista, 7, 8, 10 and Mac OS X. It is compatible with all browsers and devices that support Facebook.</p>
-<p><a href="https://example.com/download/007-facebook-hack-v10-with-full-cracked">Download 007 Facebook Hack v1.0 with Full Cracked Here</a></p>
-<h2>Conclusion</h2>
-<p>007 Facebook Hack v1.0 with Full Cracked is a powerful and easy-to-use tool that can help you hack any Facebook account in minutes. You can use it for various purposes such as monitoring, recovering, protecting, or having fun with your Facebook accounts. You can download it for free from the link above and enjoy hacking!</p>
-<h2>Is 007 Facebook Hack v1.0 with Full Cracked legal?</h2>
-<p>Before you download and use 007 Facebook Hack v1.0 with Full Cracked, you might be wondering if it is legal or not. The answer is: it depends. Hacking someone's Facebook account without their consent is illegal and unethical in most countries. You could face legal consequences if you are caught or reported by the victim or Facebook. Therefore, we do not recommend or endorse using this tool for malicious purposes.</p>
-<p>However, there are some situations where using 007 Facebook Hack v1.0 with Full Cracked might be legal or acceptable. For example, if you are hacking your own account that you lost access to, or if you have the permission of the account owner to hack their account for educational or testing purposes. In these cases, you are not violating anyone's privacy or rights, and you are using the tool responsibly and ethically.</p>
-<p></p>
-<h2>What are the advantages of 007 Facebook Hack v1.0 with Full Cracked?</h2>
-<p>007 Facebook Hack v1.0 with Full Cracked has many advantages over other hacking tools available on the internet. Some of them are:</p>
-<ul>
-<li>It is free to download and use. You don't need to pay any fees or subscriptions to get this tool.</li>
-<li>It is easy to use and user-friendly. You don't need any technical skills or knowledge to use this tool. Just enter the email or username of the target account and click on the "Hack" button.</li>
-<li>It is fast and reliable. You don't need to wait for hours or days to get the results. The tool will hack the account in minutes and display the password and other details on your screen.</li>
-<li>It is safe and secure. You don't need to worry about viruses, malware, spyware, or any other threats that might harm your computer or device. The tool is tested and verified by many users and experts.</li>
-<li>It is compatible and flexible. You can use this tool on any Windows or Mac OS X computer or device that supports Facebook. You can also use it on any browser or device that the target account uses.</li>
-</ul>
-<h2>What are the disadvantages of 007 Facebook Hack v1.0 with Full Cracked?</h2>
-<p>Despite its many advantages, 007 Facebook Hack v1.0 with Full Cracked also has some disadvantages that you should be aware of before using it. Some of them are:</p>
-<ul>
-<li>It is illegal and unethical in most cases. As we mentioned before, hacking someone's Facebook account without their consent is a crime and a violation of their privacy and rights. You could face legal troubles if you are caught or reported by the victim or Facebook.</li>
-<li>It is risky and dangerous. Even if you are hacking your own account or someone else's account with their permission, you could still expose yourself or them to potential threats from hackers, scammers, stalkers, or other malicious actors who might try to access or misuse the hacked account.</li>
-<li>It is not guaranteed or foolproof. The tool might not work on some accounts that have strong security measures or verification methods in place. The tool might also fail to hack the account if the target changes their password or email address during the hacking process.</li>
-</ul>
-<h2>How to download 007 Facebook Hack v1.0 with Full Cracked?</h2>
-<p>Downloading 007 Facebook Hack v1.0 with Full Cracked is very easy and fast. You don't need to register or fill any surveys to get this tool. You just need to follow these simple steps:</p>
-<ol>
-<li>Click on the download link below to go to the download page.</li>
-<li>Choose one of the available download options and click on the download button.</li>
-<li>Wait for the download to complete and save the file on your computer or device.</li>
-<li>Extract the zip file and run the setup.exe file to install the software on your computer or device.</li>
-<li>Enjoy!</li>
-</ol>
-<p>Note: Some antivirus programs might detect 007 Facebook Hack v1.0 with Full Cracked as a virus or malware. This is a false positive and you can safely ignore it. The software is clean and harmless.</p>
-<h2>How to update 007 Facebook Hack v1.0 with Full Cracked?</h2>
-<p>007 Facebook Hack v1.0 with Full Cracked is constantly updated by its developers to ensure its functionality and compatibility with the latest Facebook updates and security measures. You don't need to manually update this tool as it will automatically check for updates and download them whenever they are available.</p>
-<p>However, if you want to manually check for updates or download the latest version of 007 Facebook Hack v1.0 with Full Cracked, you can do so by following these steps:</p>
-<ol>
-<li>Open the software and click on the "About" button on the top right corner.</li>
-<li>Click on the "Check for Updates" button and wait for a few seconds.</li>
-<li>If there is an update available, click on the "Download Update" button and wait for the download to complete.</li>
-<li>Run the update.exe file and follow the instructions to install the update on your computer or device.</li>
-<li>Restart the software and enjoy!</li>
-</ol>
-<h2>How to uninstall 007 Facebook Hack v1.0 with Full Cracked?</h2>
-<p>If you want to uninstall 007 Facebook Hack v1.0 with Full Cracked from your computer or device, you can do so by following these steps:</p>
-<ol>
-<li>Go to the Start menu and click on Control Panel.</li>
-<li>Click on Programs and Features or Add or Remove Programs depending on your Windows version.</li>
-<li>Find 007 Facebook Hack v1.0 with Full Cracked in the list of installed programs and click on it.</li>
-<li>Click on Uninstall or Remove and follow the instructions to uninstall the software from your computer or device.</li>
-<li>Delete any leftover files or folders related to 007 Facebook Hack v1.0 with Full Cracked from your computer or device.</li>
-</ol>
-<h2>What are the alternatives to 007 Facebook Hack v1.0 with Full Cracked?</h2>
-<p>If you are looking for other ways to hack Facebook accounts, you might want to consider some of the alternatives to 007 Facebook Hack v1.0 with Full Cracked. Some of them are:</p>
-<ul>
-<li>Phishing: This is a method of creating fake login pages that look like the official Facebook login page and tricking the target into entering their email and password. You can then capture their credentials and use them to access their account.</li>
-<li>Keylogging: This is a method of installing a software or hardware device that records every keystroke that the target makes on their computer or device. You can then retrieve the log file and find their email and password among other information.</li>
-<li>Social Engineering: This is a method of manipulating the target into revealing their email and password or other personal information by pretending to be someone they trust or someone who can help them with a problem.</li>
-<li>Password Reset: This is a method of requesting a password reset link from Facebook by using the target's email address or phone number. You can then use the link to create a new password and access their account.</li>
-</ul>
-<p>However, these methods are not as easy or reliable as 007 Facebook Hack v1.0 with Full Cracked. They require more time, effort, skill, and resources to execute. They also have more risks and limitations than 007 Facebook Hack v1.0 with Full Cracked.</p>
-<h2>What are the testimonials of 007 Facebook Hack v1.0 with Full Cracked?</h2>
-<p>Many users have tried and tested 007 Facebook Hack v1.0 with Full Cracked and have shared their positive feedback and reviews about this tool. Here are some of the testimonials from real users who have used 007 Facebook Hack v1.0 with Full Cracked:</p>
-<blockquote>
-<p>"I was able to hack my girlfriend's Facebook account and found out that she was cheating on me with my best friend. Thanks to 007 Facebook Hack v1.0 with Full Cracked, I was able to confront them and end the relationship." - John, USA</p>
-</blockquote>
-<blockquote>
-<p>"I forgot my Facebook password and I couldn't access my email or phone number to reset it. I was desperate to get back into my account because I had important messages and photos there. Luckily, I found 007 Facebook Hack v1.0 with Full Cracked and it helped me recover my account in minutes." - Lisa, UK</p>
-</blockquote>
-<blockquote>
-<p>"I wanted to prank my friend by changing his profile picture and status to something funny. I used 007 Facebook Hack v1.0 with Full Cracked to hack his account and it worked like a charm. He was so confused and angry when he saw his account. It was hilarious." - Kevin, Canada</p>
-</blockquote>
-<h2>Conclusion</h2>
-<p>007 Facebook Hack v1.0 with Full Cracked is a powerful and easy-to-use tool that can help you hack any Facebook account in minutes. You can use it for various purposes such as monitoring, recovering, protecting, or having fun with your Facebook accounts. You can download it for free from the link below and enjoy hacking!</p>
-<p>However, you should also be aware of the legal and ethical implications of using this tool. Hacking someone's Facebook account without their consent is illegal and unethical in most cases. You could face legal consequences if you are caught or reported by the victim or Facebook. Therefore, we do not recommend or endorse using this tool for malicious purposes.</p>
-<p>You should also be careful of the risks and dangers of using this tool. Even if you are hacking your own account or someone else's account with their permission, you could still expose yourself or them to potential threats from hackers, scammers, stalkers, or other malicious actors who might try to access or misuse the hacked account.</p>
-<p>Finally, you should also know that this tool is not guaranteed or foolproof. The tool might not work on some accounts that have strong security measures or verification methods in place. The tool might also fail to hack the account if the target changes their password or email address during the hacking process.</p>
-<p>Therefore, you should use this tool responsibly and ethically, and at your own risk. We hope you found this article helpful and informative. If you have any questions or comments, please feel free to leave them below. Happy hacking!</p> 3cee63e6c2<br />
-<br />
-<br />

spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/Bed Wars Mod APK How to Get Unlimited Money and Gcubes in the Best Block Game for Android.md DELETED Viewed

@@ -1,131 +0,0 @@
-<h1>How to Download Bed Wars Mod APK</h1>
-<p>Do you love playing multiplayer games with your friends? Do you want to experience an exciting and addictive game that features four levels, each with unique objectives and strategies? If you answered yes, then you should try Bed Wars. Bed Wars is a mobile game that lets you team up with other players and protect your bed from being destroyed by your enemies. You can also collect resources, build bridges, upgrade weapons, and attack other beds. Sounds fun, right?</p>
-<p>But what if we tell you that you can make this game even more fun by downloading Bed Wars Mod APK? This is a modified version of the game that gives you unlimited money and gcubes, which are the in-game currencies. With these resources, you can buy anything you want in the game without worrying about running out. You can also unlock all the skins, items, maps, modes, and more. This way, you can enjoy Bed Wars to the fullest.</p>
-<h2>how to download bed wars mod apk</h2><br /><p><b><b>Download Zip</b> &mdash;&mdash;&mdash; <a href="https://urlin.us/2uSU8h">https://urlin.us/2uSU8h</a></b></p><br /><br />
-<p>So how do you download Bed Wars Mod APK on your Android device? Don't worry, we got you covered. In this article, we will show you how to download and install this amazing modded game in just a few simple steps. We will also give you some tips on how to play Bed Wars Mod APK and have a blast with your friends. Let's get started!</p>
- <h2>What is Bed Wars?</h2>
-<p>Bed Wars is a popular mobile game developed by Blockman GO Studio. It is inspired by the Minecraft mini-game of the same name. The game has four levels: Solo, Duo, Trio, and Squad. <p>In each level, you will be assigned to a team with a color. Your team will have a bed that you need to protect from being destroyed by other teams. If your bed is destroyed, you will not be able to respawn and you will be eliminated from the game. The last team standing wins the game.</p>
-<p>To protect your bed, you need to collect resources from the islands. There are three types of resources: iron, gold, and diamonds. Iron and gold can be used to buy items from the shop, such as blocks, weapons, armor, tools, and potions. Diamonds can be used to upgrade your team's abilities, such as sharpness, protection, haste, and heal pool.</p>
-<p>You can also build bridges to connect your island to other islands. This way, you can access more resources, attack other beds, or defend your own bed. But be careful, as other teams can also use your bridges to invade your island. You need to be strategic and cooperative with your teammates to win the game.</p>
- <h2>Why Download Bed Wars Mod APK?</h2>
-<p>Bed Wars is a fun and addictive game that you can play for hours with your friends. However, it can also be frustrating and challenging if you don't have enough money and gcubes to buy the items and upgrades you need. You might also get bored of playing the same maps and modes over and over again.</p>
-<p>That's why downloading Bed Wars Mod APK is a great idea. This is a modified version of the game that gives you unlimited money and gcubes, which are the in-game currencies. With these resources, you can buy anything you want in the game without worrying about running out. You can also unlock all the skins, items, maps, modes, and more. This way, you can enjoy Bed Wars to the fullest.</p>
-<p>Some of the features of Bed Wars Mod APK are:</p>
-<ul>
-<li>Unlimited money and gcubes</li>
-<li>All skins unlocked</li>
-<li>All items unlocked</li>
-<li>All maps unlocked</li>
-<li>All modes unlocked</li>
-<li>No ads</li>
-<li>No root required</li>
-</ul>
-<p>As you can see, Bed Wars Mod APK is a must-have for any fan of the game. It will make your gaming experience more fun and exciting. You will be able to customize your character, equip yourself with the best weapons and armor, explore different maps and modes, and dominate the game with your friends.</p>
-<p>How to install bed wars mod apk on android<br />
-Bed wars mod apk unlimited money and gcubes download<br />
-Bed wars mod apk latest version free download<br />
-How to play bed wars mod apk online with friends<br />
-Bed wars mod apk solo, duo, trio and squad modes<br />
-How to get bed wars mod apk for pc<br />
-Bed wars mod apk hack and cheats<br />
-Bed wars mod apk no root required<br />
-Bed wars mod apk features and gameplay<br />
-How to update bed wars mod apk to the newest version<br />
-Bed wars mod apk review and rating<br />
-Bed wars mod apk download link and instructions<br />
-How to uninstall bed wars mod apk from your device<br />
-Bed wars mod apk tips and tricks<br />
-Bed wars mod apk vs original bed wars game<br />
-How to fix bed wars mod apk not working or crashing<br />
-Bed wars mod apk best strategies and tactics<br />
-Bed wars mod apk compatible devices and requirements<br />
-Bed wars mod apk alternatives and similar games<br />
-How to contact bed wars mod apk developer and support<br />
-How to join bed wars mod apk community and forums<br />
-Bed wars mod apk pros and cons<br />
-Bed wars mod apk bugs and glitches<br />
-Bed wars mod apk custom maps and skins<br />
-How to create your own bed wars mod apk server<br />
-How to backup and restore bed wars mod apk data<br />
-Bed wars mod apk frequently asked questions and answers<br />
-Bed wars mod apk gameplay videos and screenshots<br />
-How to earn free gcubes in bed wars mod apk<br />
-Bed wars mod apk changelog and updates history<br />
-How to report bed wars mod apk issues and feedback<br />
-Bed wars mod apk privacy policy and terms of service<br />
-How to enable bed wars mod apk notifications and permissions<br />
-Bed wars mod apk achievements and leaderboards<br />
-How to share bed wars mod apk with your friends<br />
-Bed wars mod apk size and download time<br />
-How to optimize bed wars mod apk performance and battery usage<br />
-Bed wars mod apk sound effects and music settings<br />
-How to customize bed wars mod apk controls and interface<br />
-Bed wars mod apk languages and translations</p>
- <h2>How to Download Bed Wars Mod APK on Android?</h2>
-<p>Now that you know why you should download Bed Wars Mod APK, you might be wondering how to do it. Don't worry, it's very easy and simple. All you need is an Android device with at least 4 GB of RAM and 100 MB of free storage space. Then, follow these steps:</p>
- <h3>Step 1: Allow Unknown Apps on Android</h3>
-<p>The first thing you need to do is to allow unknown apps on your Android device. This means that you will be able to install apps that are not from the Google Play Store. To do this, go to your device settings and look for the security or privacy option. Then, find the unknown sources or install unknown apps option and enable it.</p>
-<p>This will allow you to install Bed Wars Mod APK on your device without any problems. However, make sure that you only download apps from trusted sources and websites. Otherwise, you might end up installing malware or viruses on your device.</p>
- <h3>Step 2: Install an Android File Manager</h3>
-<p>The next thing you need to do is to install an Android file manager app on your device. This is an app that will help you find and manage the files on your device. You will need this app to locate and install the Bed Wars Mod APK file that you will download later.</p>
-<p>There are many file manager apps that you can choose from, such as ES File Explorer, Astro File Manager, or Solid Explorer. You can download any of them from the Google Play Store for free. Once you have installed a file manager app on your device, open it and grant it the necessary permissions.</p>
- <h3>Step 3: Download the APK Installer From Your Android</h3>
-<p>The next step is to download the Bed Wars Mod APK file from your Android device. To do this, open your web browser and go to this link: . This is a reputable website where you can download the latest version of Bed Wars Mod APK for free.</p>
-<p>Once you are on the website, scroll down until you see the download button. Tap on it and wait for the download to start. The file size is about 98 MB, so it might take a few minutes depending on your internet speed.</p>
- <h3>Step 4: Transfer the APK Installer via USB (Optional)</h3>
-<p>If you prefer, you can also download the Bed Wars Mod APK file from your computer and transfer it to your Android device via USB cable. This might be faster and more convenient for some users. To do this, follow these steps:</p>
-<ul>
-<li>Go to the same link as before on your computer and download the Bed Wars Mod APK file.</li>
-<li>Connect your Android device to your computer using a USB cable.</li>
-<li>On your computer, open the folder where you saved the APK file and copy it.</li>
-<li>On your Android device, open the file manager app and navigate to the folder where you want to paste the APK file.</li>
-<li>Paste the APK file and disconnect your device from your computer.</li>
-</ul>
- <h3>Step 5: Install the APK File on Your Device</h3>
-<p>The final step is to install the Bed Wars Mod APK file on your device. To do this, follow these steps:</p>
-<ul>
-<li>Open the file manager app and locate the APK file that you downloaded or transferred.</li>
-<li>Tap on the APK file and a pop-up window will appear asking you to confirm the installation.</li>
-<li>Tap on install and wait for the installation to finish.</li>
-<li>Once the installation is done, you will see a notification that says "App installed".</li>
-<li>Tap on open and enjoy Bed Wars Mod APK!</li>
-</ul>
- <h2>How to Play Bed Wars Mod APK?</h2>
-<p>Now that you have installed Bed Wars Mod APK on your device, you might be wondering how to play it. Don't worry, it's very easy and simple. All you need to do is follow these steps:</p>
-<ul>
-<li>Open Bed Wars Mod APK and tap on start.</li>
-<li>Select the level that you want to play: Solo, Duo, Trio, or Squad.</li>
-<li>Select the map that you want to play: Classic, Lucky Block, Rush, or Ultimate.</li>
-<li>Select the mode that you want to play: Normal, Chaos, or Custom.</li>
-<li>Wait for the game to load and join a team with a color.</li>
-<li>Protect your bed from being destroyed by other teams and collect resources from the islands.</li>
-<li>Buy items and upgrades from the shop and build bridges to other islands.</li>
-<li>Attack other beds and eliminate other players.</li>
-<li>The last team standing wins the game!</li>
-</ul>
- <h2>Conclusion</h2>
-<p>Bed Wars is a fun and addictive game that you can play with your friends. However, it can also be frustrating and challenging if you don't have enough money and gcubes to buy the items and upgrades you need. That's why downloading Bed Wars Mod APK is a great idea. This is a modified version of the game that gives you unlimited money and gcubes, which are the in-game currencies. With these resources, you can buy anything you want in the game without worrying about running out. You can also unlock all the skins, items, maps, modes, and more. This way, you can enjoy Bed Wars to the fullest.</p>
-<p>In this article, we showed you how to download and install Bed Wars Mod APK on your Android device in just a few simple steps. We also gave you some tips on how to play Bed Wars Mod APK and have a blast with your friends. We hope that you found this article helpful and informative. If you did, please share it with your friends who might also be interested in playing Bed Wars Mod APK. Thank you for reading!</p>
- <h2>Frequently Asked Questions</h2>
- <h3>Q: Is Bed Wars Mod APK safe to download?</h3>
-<p>A: Yes, Bed Wars Mod APK is safe to download as long as you download it from a trusted source and website. However, make sure that you scan the APK file with an antivirus app before installing it on your device. This way, you can avoid any potential malware or viruses that might harm your device.</p>
- <h3>Q: Do I need to root my device to use Bed Wars Mod APK?</h3>
-<p>A: No, you don't need to root your device to use Bed Wars Mod APK. This modded game works fine on any Android device without requiring any root access or permissions. Just follow the steps above and enjoy Bed Wars Mod APK without any hassle.</p>
- <h3>Q: Can I play Bed Wars Mod APK online with other players?</h3>
-<p>A: Yes, you can play Bed Wars Mod APK online with other players who are also using the modded version of the game. However, you might not be able to play with players who are using the original version of the game from the Google Play Store. This is because the modded game has different features and settings that might not be compatible with the original game. Therefore, we recommend that you play Bed Wars Mod APK with your friends who are also using the same modded game.</p>
- <h3>Q: How can I update Bed Wars Mod APK?</h3>
-<p>A: To update Bed Wars Mod APK, you need to download the latest version of the APK file from the same website where you downloaded it before. Then, you need to uninstall the previous version of the game from your device and install the new version. This way, you can enjoy the latest features and improvements of Bed Wars Mod APK.</p>
- <h3>Q: What are some tips and tricks for playing Bed Wars Mod APK?</h3>
-<p>A: Here are some tips and tricks for playing Bed Wars Mod APK:</p>
-<ul>
-<li>Use your unlimited money and gcubes wisely. Don't spend them all on unnecessary items or upgrades. Save some for later stages of the game when you need them more.</li>
-<li>Communicate and coordinate with your teammates. Use the chat feature or voice chat to plan your strategies and tactics. Share resources, items, and information with your teammates. Work together to protect your bed and attack other beds.</li>
-<li>Be creative and innovative. Use different blocks, weapons, tools, and potions to build bridges, traps, defenses, and attacks. Experiment with different combinations and see what works best for you.</li>
-<li>Be alert and aware. Keep an eye on your surroundings and watch out for enemies. Don't let your guard down or get distracted. Be ready to react and adapt to any situation.</li>
-<li>Have fun and enjoy the game. Don't take it too seriously or get angry if you lose. Remember that it's just a game and the main purpose is to have fun with your friends.</li>
-</ul>
- <h2></h2>
-<p>That's it! You have successfully downloaded and installed Bed Wars Mod APK on your Android device. You have also learned how to play Bed Wars Mod APK and some tips and tricks for playing it. We hope that you enjoyed this article and found it helpful and informative. If you did, please share it with your friends who might also be interested in playing Bed Wars Mod APK. Thank you for reading!</p> 197e85843d<br />
-<br />
-<br />

spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/Cribbage King The Ultimate Cribbage Game for your iPhone..md DELETED Viewed

@@ -1,118 +0,0 @@
-<h1>Cribbage Game Free Download for iPhone: How to Play and Enjoy this Classic Card Game</h1>
- <p>If you are looking for a fun and engaging card game that can challenge your mind and improve your skills, you should try cribbage. Cribbage is a classic card game that has been played for centuries by people of all ages and backgrounds. It is easy to learn, but hard to master, and it offers endless possibilities for strategy and variation. In this article, we will show you how to download and play cribbage games on your iPhone, as well as how to improve your skills and strategy in this fascinating game.</p>
- <h2>What is Cribbage and Why Should You Play It?</h2>
- <h3>The History and Rules of Cribbage</h3>
- <p>Cribbage is a card game that originated in England in the 17th century. It was invented by Sir John Suckling, a poet and gambler who modified an older game called Noddy. The game is played with a standard 52-card deck and a special board with holes and pegs that are used to keep score. The objective of the game is to be the first player to reach 121 points by making combinations of cards that add up to 15, pairs, runs, flushes, or nobs (the jack of the same suit as the starter card).</p>
-<h2>cribbage game free download for iphone</h2><br /><p><b><b>Download File</b> &gt; <a href="https://urlin.us/2uSRUl">https://urlin.us/2uSRUl</a></b></p><br /><br />
- <p>The game is played by two or three players, or by four players in two teams. Each player is dealt six cards (five cards in a three-player game) and must discard two cards face down to form the crib, which belongs to the dealer. The non-dealer cuts the deck and reveals the top card, which is called the starter or the cut. The players then take turns playing one card each, starting with the non-dealer, and announcing the running total of the cards' values. The cards are worth their face value, except for face cards which are worth 10, and aces which are worth 1. The player who plays a card that makes the total exactly 15 scores two points, called "fifteen two". The player who plays a card that makes the total 31 scores two points, called "thirty-one for two". If a player cannot play a card without going over 31, they say "go" and the other player continues until they reach 31 or cannot play either. The player who played the last card before a go or 31 scores one point, called "one for last".</p>
- <p>After all the cards have been played, the players count their hands in turn, starting with the non-dealer. The hand consists of four cards plus the starter card. The players score points for any combinations of cards that add up to 15, pairs (two points), three of a kind (six points), four of a kind (twelve points), runs (one point per card), flushes (four points for all five cards of the same suit, or five points if the crib also matches), and nobs (one point for having the jack of the same suit as the starter). The dealer then counts their hand, followed by the crib. The crib can only score points for 15s, pairs, runs, flushes, and nobs.</p>
- <p>The game continues until one player reaches 121 points or more. The player who reaches 121 points first wins the game. If both players reach 121 points in the age, lowball cribbage, and back up 10 cribbage. Each mode has its own rules and challenges that will test your skills and strategy.</li>
-<li>It has a realistic and immersive gameplay experience. You can play with realistic cards, boards, and pegs that are designed with high-quality graphics and animations. You can also hear realistic sound effects and voice overs that add to the atmosphere of the game.</li>
-<li>It has a smart and adaptive AI that can adjust to your skill level and style. You can play against different opponents with different personalities, strengths, and weaknesses. You can also customize the AI settings to make the game more easy or difficult.</li>
-<li>It has a leaderboard and achievements feature that tracks your progress and performance. You can see your rank, score, wins, losses, skunks, double skunks, and more. You can also unlock various achievements and badges that reward your accomplishments.</li>
-<li>It has a multiplayer feature that lets you play with other players online or offline. You can play with your friends or family via Bluetooth, Wi-Fi, or Game Center. You can also play with random players from around the world via Game Center or Facebook.</li>
-</ul>
- <p>Ultimate Cribbage is a paid app that you can download from the App Store for $2.99. It is compatible with iPhone, iPad, and iPod touch devices running iOS 9.0 or later.</p>
-<p>Cribbage Classic app for iPad and iPhone<br />
-Ultimate Cribbage: Classic card game with different modes<br />
-Cribbage: The Best Card Game by FIOGONIA LIMITED<br />
-How to play cribbage on your iPhone with friends<br />
-Cribbage tips and tricks to improve your skills<br />
-Best cribbage apps for iPhone in 2023<br />
-Cribbage Club subscription for ad-free gameplay<br />
-Cribbage Pegboard app to track your score<br />
-Cribbage variants: Classic, Muggins, and Shotgun<br />
-Cribbage rules and scoring explained<br />
-Cribbage Classic settings and features<br />
-Ultimate Cribbage: Classic reviews and ratings<br />
-Cribbage: The Best Card Game privacy policy<br />
-Cribbage online tournaments and leaderboards<br />
-Cribbage strategy and tactics guide<br />
-Cribbage Classic discard analyzer bonus feature<br />
-Ultimate Cribbage: Classic daily challenge rewards<br />
-Cribbage: The Best Card Game support and feedback<br />
-Cribbage history and origin<br />
-Cribbage board designs and customizations<br />
-Cribbage Classic update and bug fixes<br />
-Ultimate Cribbage: Classic in-app purchases and prices<br />
-Cribbage: The Best Card Game download size and compatibility<br />
-Cribbage offline mode and solo play<br />
-Cribbage glossary and terminology<br />
-Cribbage Classic statistics and performance tracking<br />
-Ultimate Cribbage: Classic app for Mac with Apple M1 chip or later<br />
-Cribbage: The Best Card Game screenshots and videos<br />
-Cribbage etiquette and manners<br />
-Cribbage fun facts and trivia.</p>
- <h4>How to Download and Play Ultimate Cribbage</h4>
- <p>To download and play Ultimate Cribbage on your iPhone, follow these simple steps:</p>
- <ol>
-<li>Open the App Store on your iPhone and search for "Ultimate Cribbage".</li>
-<li>Tap on the app icon and then tap on "Buy" to purchase and install the app on your device.</li>
-<li>Once the app is installed, tap on "Open" to launch the app.</li>
-<li>Select the game mode you want to play: classic cribbage, crash cribbage, cross cribbage, lowball cribbage, or back up 10 cribbage.</li>
-<li>Select the difficulty level you want to play: easy, medium, hard, or custom.</li>
-<li>Tap on "Play" to start the game.</li>
-<li>Enjoy playing cribbage with Ultimate Cribbage!</li>
-</ol>
- <h2>How to Improve Your Skills and Strategy in Cribbage</h2>
- <h3>Tips and Tricks for Discarding and Pegging</h3>
- <p>One of the most important aspects of cribbage is discarding and pegging. Discarding is the process of choosing which two cards to put in the crib at the beginning of each deal. Pegging is the process of playing cards during the play phase of each deal. Here are some tips and tricks for discarding and pegging:</p>
- <ul>
-<li>When discarding, you should consider both your hand and the crib. You should try to keep cards that can score points in your hand, such as 15s, pairs, runs, flushes, or nobs. You should also try to avoid giving cards that can score points in the crib to your opponent, especially if they are the dealer.</li>
-<li>When discarding, you should also consider the probability of certain cards appearing as the starter card. For example, a 5 is more likely to appear than a 2, because there are more cards that have a value of 10 than a value of 7. Therefore, you should avoid discarding a 5 or a 10 to the crib, as they can make 15s with the starter card.</li>
-<li>When pegging, you should try to score points by making 15s or 31s, or by making pairs, runs, or flushes. You should also try to prevent your opponent from scoring points by blocking their combinations or forcing them to go over 31.</li>
-<li>When pegging, you should also try to anticipate what cards your opponent has in their hand based on what they have played so far. For example, if they have played a 6 and a 7, they might have an 8 or a 9 in their hand to make a run. Therefore, you should avoid playing an 8 or a 9 yourself.</li>
-</ul>
- <h3>How to Use the Discard Analyzer Feature in Cribbage Apps</h3>
- <p>If you want to improve your discarding skills in cribbage , you can use the discard analyzer feature in some cribbage apps. The discard analyzer feature is a tool that can help you decide which cards to discard to the crib based on the expected value of each possible combination. The expected value is the average number of points that you can expect to score from your hand and the crib after the starter card is revealed. The higher the expected value, the better the combination. To use the discard analyzer feature in cribbage apps, follow these simple steps: <ol>
-<li>After you are dealt your cards, tap on the discard analyzer button on the screen. This will open a window that shows you all the possible combinations of cards that you can discard to the crib, along with their expected values.</li>
-<li>Compare the expected values of each combination and choose the one that has the highest expected value. This means that this combination will give you the best chance of scoring more points from your hand and the crib.</li>
-<li>Tap on the cards that you want to discard to the crib and confirm your choice. The app will then show you your remaining hand and the crib.</li>
-<li>Wait for the starter card to be revealed and continue playing as usual.</li>
-</ol>
- <p>The discard analyzer feature is a useful tool that can help you improve your discarding skills in cribbage, but it is not a substitute for your own judgment and intuition. You should also consider other factors, such as your opponent's skill level, your position on the board, and your personal preference, when deciding which cards to discard to the crib.</p>
- <h3>How to Practice and Learn from Other Players Online</h3>
- <p>Another way to improve your skills and strategy in cribbage is to practice and learn from other players online. Playing online can expose you to different styles and strategies of cribbage, as well as give you feedback and tips on how to play better. Here are some ways to practice and learn from other players online:</p>
- <ul>
-<li>Play against different opponents with different skill levels. You can play against easy, medium, or hard AI opponents, or against real players from around the world. You can also play against your friends or family online. Playing against different opponents can help you adapt to different situations and challenges in cribbage.</li>
-<li>Watch replays of your games or other players' games. You can watch replays of your own games or other players' games on some cribbage apps. You can see how they played their cards, how they scored their points, and how they won or lost the game. You can also pause, rewind, or fast-forward the replays to analyze them in detail.</li>
-<li>Join online communities and forums for cribbage players. You can join online communities and forums for cribbage players on social media platforms, such as Facebook, Twitter, or Reddit. You can interact with other cribbage players, ask questions, share tips, discuss strategies, or challenge each other to games.</li>
-</ul>
- <p>Practicing and learning from other players online can help you improve your skills and strategy in cribbage, but it is not a substitute for your own experience and practice. You should also play offline with real cards and boards, as well as read books and articles about cribbage.</p>
- <h2>Conclusion</h2>
- <p>Cribbage is a classic card game that can provide you with hours of fun and entertainment, as well as improve your mental skills and abilities. It is a game that you can play anytime, anywhere, and with anyone. In this article, we have shown you how to download and play cribbage games on your iPhone, as well as how to improve your skills and strategy in this fascinating game. We hope that you have enjoyed reading this article and that you have learned something new about cribbage. Now go ahead and download one of the cribbage apps we have recommended and start playing this amazing game!</p>
- <h2>Frequently Asked Questions</h2>
- <p>Here are some frequently asked questions about cribbage:</p>
- <ol>
-<li>What is the best hand in cribbage?</li>
-<p>The best hand in cribbage is 29 points, which consists of three fives of different suits, a jack of the same suit as the starter card, and a five of the same suit as the starter card. This hand scores 12 points for four 15s (5+5+5+J), 12 points for six pairs (5-5, 5-5, 5-5, 5-J, 5-J, J-J), four points for a flush (all five cards of the same suit), and one point for nobs (the jack of the same suit as the starter card). This hand is very rare and can only occur when the dealer has three fives of different suits in their hand and discards them to their own crib.</p>
-<li>What is a muggins in cribbage?</li>
-<p <p>A muggins in cribbage is a rule that allows a player to claim any points that their opponent has missed or miscalculated during the scoring phase of each deal. For example, if a player counts their hand as 10 points, but their opponent notices that they actually have 12 points, the opponent can say "muggins" and take the extra two points for themselves. The muggins rule is optional and can be agreed upon or declined by the players before the game starts.</p>
- <li>What is the difference between a skunk and a double skunk in cribbage?</li>
-<p>A skunk in cribbage is when a player wins the game by 31 or more points over their opponent. A double skunk in cribbage is when a player wins the game by 61 or more points over their opponent. A skunk and a double skunk are considered to be humiliating defeats for the losing player, and they usually result in extra penalties or rewards for the winning player. For example, some players may agree to double or quadruple the stakes of the game if a skunk or a double skunk occurs.</p>
- <li>How many cards are in a cribbage deck?</li>
-<p>A cribbage deck consists of a standard 52-card deck, which includes 13 cards of each suit (clubs, diamonds, hearts, and spades) and four ranks of each card (ace, 2, 3, 4, 5, 6, 7, 8, 9, 10, jack, queen, and king). However, some variations of cribbage may use different decks, such as a 48-card deck (without the 10s) or a 32-card deck (without the 2s, 3s, 4s, and 5s).</p>
- <li>How do you shuffle and cut the cards in cribbage?</li>
-<p>To shuffle and cut the cards in cribbage, follow these simple steps:</p>
- <ol>
-<li>The dealer shuffles the cards thoroughly and offers them to the non-dealer to cut. The non-dealer cuts the cards by taking a portion of the cards from the top of the deck and placing them on the bottom.</li>
-<li>The dealer then takes the top card from the bottom portion of the deck and places it face up on top of the deck. This card is called the starter or the cut.</li>
-<li>The dealer then deals six cards to each player (five cards in a three-player game), one at a time, starting with the non-dealer.</li>
-</ol>
- <li>What are some common terms and phrases used in cribbage?</li>
-<p>Some common terms and phrases used in cribbage are:</p>
- <ul>
-<li>Fifteen: A combination of cards that adds up to 15 points.</li>
-<li>Pair: Two cards of the same rank.</li>
-<li>Run: Three or more consecutive cards of any suit.</li>
-<li>Flush: Four or five cards of the same suit.</li>
-<li>Nobs: The jack of the same suit as the starter card.</li>
-<li>His heels: The jack of any suit as the starter card.</li>
-<li>Crib: The two cards discarded by each player at the beginning of each deal.</li>
-<li>Peg: A small marker used to keep score on the board.</li>
-<li>Hole: A small hole on the board where pegs are inserted.</li>
-<li>Street: A section of five holes on the board.</li>
-</ul></p> 197e85843d<br />
-<br />
-<br />

spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/Download 3D Chess Game for PC and Play in Stunning Scenes and Graphics.md DELETED Viewed

@@ -1,153 +0,0 @@
-<br />
-<h1>Download 3D Chess Game for PC: A Guide to the Best Options</h1>
-<p>If you are a fan of chess and want to enjoy a more immersive and realistic experience, you might want to try playing 3D chess on your PC. 3D chess is a variation of the classic board game that uses three-dimensional graphics and animations to simulate a real chessboard. You can play against the computer, online opponents, or even friends in local multiplayer mode. In this article, we will show you how to download and install 3D chess game for PC, and review some of the best options available on the market.</p>
-<h2>Introduction</h2>
-<h3>What is 3D chess and why play it on PC?</h3>
-<p>3D chess is a type of chess game that uses three-dimensional models and effects to create a more realistic and engaging gameplay. Unlike traditional chess games that use flat images or icons, 3D chess games allow you to see the pieces from different angles, zoom in and out, rotate the board, and enjoy various visual effects. Some 3D chess games also have different themes, backgrounds, sounds, and music to enhance the atmosphere.</p>
-<h2>download 3d chess game for pc</h2><br /><p><b><b>Download</b> ->>->>->> <a href="https://urlin.us/2uSZuw">https://urlin.us/2uSZuw</a></b></p><br /><br />
-<p>Playing 3D chess on PC has several advantages over playing it on other devices. First of all, you can enjoy better graphics quality and performance on a larger screen. Second, you can use your mouse and keyboard to control the game more easily and precisely. Third, you can access a wider range of options and features, such as online multiplayer, puzzles, rankings, achievements, etc. Fourth, you can save money by downloading free or cheap games from online platforms.</p>
-<h2>How to download and install 3D chess game for PC</h2>
-<p>There are many ways to download and install 3D chess game for PC, but we will focus on three of the most popular and reliable ones: Chess! on Steam, 3D Chess Game on Microsoft Store, and 3D Chess on Steam. We will compare their features, pros and cons, and how to get them in the following sections.</p>
-<h3>Option 1: Chess! on Steam</h3>
-<h4>Features, pros and cons, and how to get it</h4>
-<p>Chess! is an upcoming 3D chess game that is expected to be released in Q2 2023. It is developed by Exeter Game Studios and published by familyplay. It is built with Unreal Engine 5 and integrated with Lichess, one of the largest online chess platforms in the world. Here are some of its features:</p>
-<ul>
-<li>Next-generation graphics: Witness the power of Unreal Engine 5 as it transforms the classic game of chess into a breathtaking visual spectacle. Enjoy lifelike textures, realistic lighting, and multiple scenes with intricate details that elevate your gaming experience to new heights.</li>
-<li>Lichess integration: Seamlessly connect to the Lichess platform, allowing you to engage in exciting games with advanced AI, track your ELO, practice with puzzles, and participate in ranked Lichess matchmaking for a truly competitive experience.</li>
-<li>Advanced AI and human opponents: Test your skills against sophisticated AI opponents or challenge real players from around the world, providing endless opportunities to refine your strategies and grow as a chess master.</li>
-<li>Millions of offline puzzles: Dive into a vast library of puzzles that cater to all skill levels, from beginner to grandmaster. Sharpen your tactical acumen and learn from the best with our expertly curated collection of chess challenges.</li>
-<li>Relaxing scenes <p>Relaxing scenes and sounds: Choose from a variety of relaxing scenes and sounds to create the perfect ambiance for your chess game. Whether you prefer a cozy fireplace, a tranquil garden, or a futuristic cityscape, you can find the ideal setting for your mood and style.</li>
-</ul>
-<p>The pros of Chess! are:</p>
-<ul>
-<li>It offers stunning graphics and animations that make the game more immersive and realistic.</li>
-<li>It connects to Lichess, which is a reputable and popular online chess platform with millions of users and features.</li>
-<li>It has a wide range of difficulty levels, puzzles, and modes to suit different preferences and goals.</li>
-<li>It has relaxing scenes and sounds that create a soothing atmosphere for the game.</li>
-</ul>
-<p>The cons of Chess! are:</p>
-<ul>
-<li>It is not yet released, so it might have some bugs or glitches when it launches.</li>
-<li>It might require a high-end PC to run smoothly and enjoy the full graphics quality.</li>
-<li>It might not be compatible with some older operating systems or devices.</li>
-</ul>
-<p>To get Chess!, you need to have a Steam account and a PC that meets the minimum system requirements. You can pre-order the game on Steam for $9.99 and get access to it as soon as it is released. You can also follow the game's development updates on its official website or social media accounts.</p>
-<p>How to install 3D Chess Game on Windows PC or Mac[^1^]<br />
-Chess! an immersive 3D chess game with Lichess integration[^2^]<br />
-Get 3D Chess Game from Microsoft Store for free[^3^]<br />
-3D Chess a unique chess trip with instant duels on Steam[^4^]<br />
-Best 3D chess games for PC in 2023<br />
-Download 3D Chess Game APK for Android devices<br />
-Play 3D Chess online with friends or strangers<br />
-Learn chess with 3D Chess Game puzzles and challenges<br />
-Compare 3D Chess Game with other chess apps and software<br />
-3D Chess Game reviews and ratings from users and experts<br />
-How to uninstall 3D Chess Game from your PC or Mac<br />
-3D Chess Game tips and tricks to improve your skills<br />
-How to customize your board and pieces in 3D Chess Game<br />
-How to play 3D Chess Game offline or without internet connection<br />
-How to solve common issues and errors in 3D Chess Game<br />
-How to update 3D Chess Game to the latest version<br />
-How to use the free flying camera in 3D Chess Game<br />
-How to play against advanced AI in 3D Chess Game<br />
-How to participate in ranked matchmaking in 3D Chess Game<br />
-How to track your online ELO in 3D Chess Game<br />
-How to sign up and login to Lichess account in 3D Chess Game<br />
-How to donate to Lichess charity organization in 3D Chess Game<br />
-How to enjoy lifelike textures and realistic lighting in 3D Chess Game<br />
-How to switch between different scenes and locations in 3D Chess Game<br />
-How to play 3D Chess Game on HoloLens or other VR devices<br />
-How to download and play 3D Chess Game on Linux or Ubuntu<br />
-How to stream or record your gameplay of 3D Chess Game<br />
-How to join or create a chess club in 3D Chess Game<br />
-How to chat or communicate with other players in 3D Chess Game<br />
-How to report or block abusive or cheating players in 3D Chess Game<br />
-How to access the vast library of offline puzzles in 3D Chess Game<br />
-How to share your achievements and scores of 3D Chess Game on social media<br />
-How to find and play with your friends in 3D Chess Game<br />
-How to change the language or sound settings in 3D Chess Game<br />
-How to enable or disable the relaxing music in 3D Chess Game<br />
-How to use wildcard characters or anagrams in 3D Chess Game<br />
-How to checkmate your opponent with only a few moves in 3D Chess Game<br />
-How to learn from the best with expertly curated chess challenges in 3D Chess Game<br />
-How to play different variants of chess such as blitz, bullet, rapid, etc. in 3D Chess Game<br />
-How to watch live games or tournaments of professional chess players in 3D Chess Game<br />
-How to use the dictionary feature in 3D Chess Game for definitions and synonyms of chess terms<br />
-How to play the piano or other musical instruments in 3D Chess Game for fun or relaxation<br />
-How to use the Phoenix Force feature in 3D Chess Game for a fiery and explosive gameplay<br />
-How to climb up and overcome increasing challenges in Upward mode of 3D Chess Game <br />
-How to use the speech function in 3D Chess Game for correct pronunciation of chess moves and names <br />
-How to see your word history or make your own list of favorite words in Dictionary mode of 3D Chess Game <br />
-How to get the word of the day with interesting and entertaining words in Dictionary mode of 3D Chess Game <br />
-How to use the solar physics feature in 3D Chess Game for learning about the Sun and its layers <br />
-How to witness the power of Unreal Engine 5 in transforming the classic game of chess into a breathtaking visual spectacle</p>
-<h3>Option 2: 3D Chess Game on Microsoft Store</h3>
-<h4>Features, pros and cons, and how to get it</h4>
-<p>3D Chess Game is a free 3D chess game that is available on Microsoft Store. It is developed by A Trillion Games Ltd and has over 10 million downloads. It is designed for Windows 10 devices, including PCs, tablets, and phones. Here are some of its features:</p>
-<ul>
-<li>Simple and intuitive interface: Enjoy a user-friendly interface that lets you play the game with ease. You can adjust the board size, view angle, sound effects, and difficulty level with just a few clicks.</li>
-<li>Multiple game modes: Choose from four different game modes to suit your preference. You can play against the computer, online opponents, local friends, or watch the computer play against itself.</li>
-<li>Customizable board and pieces: Customize the appearance of the board and pieces by selecting from various colors, styles, and themes. You can also change the background image to match your mood.</li>
-<li>Statistics and achievements: Track your progress and performance with statistics and achievements. You can see your win rate, ELO rating, moves history, best moves, etc. You can also unlock achievements by completing certain tasks or challenges.</li>
-</ul>
-<p>The pros of 3D Chess Game are:</p>
-<ul>
-<li>It is free to download and play, with no ads or in-app purchases.</li>
-<li>It is compatible with Windows 10 devices, including PCs, tablets, and phones.</li>
-<li>It has a simple and intuitive interface that makes the game easy to play.</li>
-<li>It has multiple game modes and customizable options to suit different tastes and needs.</li>
-</ul>
-<p>The cons of 3D Chess Game are:</p>
-<ul>
-<li>It has mediocre graphics and animations that might not appeal to some players.</li>
-<li>It has limited online features and options compared to other platforms.</li>
-<li>It has occasional bugs or errors that might affect the gameplay.</li>
-</ul>
-<p>To get 3D Chess Game, you need to have a Microsoft account and a Windows 10 device that meets the minimum system requirements. You can download the game from Microsoft Store for free and start playing it right away. You can also rate and review the game on the store page or contact the developer for feedback or support.</p>
- <h3>Option 3: 3D Chess on Steam</h3>
- <h4>Features, pros and cons, and how to get it</h4>
- <p>3D Chess is another 3D chess game that is available on Steam. It is developed by Bumblebee Games Studio Ltd. It was released in 2016 and has over 1000 reviews. It is designed for Windows PCs only. Here are some of its features:</p>
- <ul>
- <li>Detailed graphics: Experience a high-quality 3D chess game with detailed graphics and realistic shadows. You can choose from three different boards (wooden, marble, or glass) and four different sets of pieces (classic, metal, wood, or glass).</li>
- <li>Cinematic camera: Enjoy a cinematic camera that follows the action on the board. You can <p>Cinematic camera: Enjoy a cinematic camera that follows the action on the board. You can also adjust the camera angle, zoom, and rotation to get the best view of the game.</li>
- <li>Single-player and multiplayer modes: Play against the computer with three difficulty levels, or challenge your friends in local or online multiplayer mode. You can also play against random opponents from around the world, or join a tournament and compete for prizes.</li>
- <li>Steam features: Take advantage of Steam features such as cloud saving, achievements, leaderboards, trading cards, etc. You can also share your screenshots and videos with the Steam community, or use the Steam Workshop to download and upload custom boards and pieces.</li>
-</ul>
- <p>The pros of 3D Chess are:</p>
- <ul>
-<li>It has detailed graphics and realistic shadows that create a more immersive gameplay.</li>
-<li>It has a cinematic camera that adds to the visual appeal of the game.</li>
-<li>It has single-player and multiplayer modes that offer different challenges and fun.</li>
-<li>It has Steam features that enhance the game's functionality and community.</li>
-</ul>
- <p>The cons of 3D Chess are:</p>
- <ul>
-<li>It is not free to play, and costs $4.99 on Steam.</li>
-<li>It is only compatible with Windows PCs, and not with other devices or operating systems.</li>
-<li>It has some negative reviews that complain about the game's bugs, glitches, or lack of updates.</li>
-</ul>
- <p>To get 3D Chess, you need to have a Steam account and a Windows PC that meets the minimum system requirements. You can buy the game on Steam for $4.99 and download it to your PC. You can also check out the game's trailer, screenshots, and reviews on its Steam page or official website.</p>
- <h2>Comparison table of the three options</h2>
- <p>To help you decide which 3D chess game for PC is best for you, we have created a comparison table that summarizes the main features, pros and cons, and prices of the three options we have reviewed. You can see the table below:</p>
- | Feature | Chess! | 3D Chess Game | 3D Chess | | --- | --- | --- | --- | | Graphics quality | Excellent | Mediocre | Good | | Online platform | Lichess | None | Steam | | Game modes | AI, online, puzzles | AI, online, local | AI, online, local | | Customization options | Scenes, sounds | Board, pieces, background | Board, pieces | | Statistics and achievements | Yes | Yes | Yes | | Price | $9.99 (pre-order) | Free | $4.99 | | Pros | Stunning graphics; Lichess integration; wide range of difficulty levels and puzzles; relaxing scenes and sounds | Free; compatible with Windows 10 devices; simple and intuitive interface; multiple game modes and customizable options | Detailed graphics and realistic shadows; cinematic camera; single-player and multiplayer modes; Steam features | | Cons | Not yet released; might require high-end PC; might not be compatible with older systems or devices | Mediocre graphics; limited online features; occasional bugs or errors | Not free; only compatible with Windows PCs; some negative reviews | <h2>Conclusion</h2>
- <h3>Summary of the main points</h3>
- <p>In this article, we have shown you how to download and install 3D chess game for PC, and reviewed some of the best options available on the market. We have compared their features, pros and cons, and prices in a comparison table. We have also explained what 3D chess is and why playing it on PC has several advantages over playing it on other devices.</p>
- <h3>Recommendation and call to action</h3>
- <p>Based on our analysis, we recommend Chess! as the best option for downloading 3D chess game for PC. It offers stunning graphics, Lichess integration, wide range of difficulty levels and puzzles, relaxing scenes and sounds, and more. It is also reasonably priced at $9.99 for pre-ordering. However, if you are looking for a free or simpler option, you can also try 3D Chess Game or 3D Chess on Microsoft Store or Steam respectively.</p>
- <p>If you are interested in playing 3D chess on your PC, you can follow the links below to get your preferred option: - [Chess! on Steam] - [3D Chess Game on Microsoft Store] - [3D Chess on Steam] We hope you enjoyed this article and found it helpful. If you have any questions or feedback, please feel free to leave a comment below. Thank you for reading!</p>
- <h2>FAQs</h2>
- <p>Here are some frequently asked questions about downloading 3D chess game <p>Here are some frequently asked questions about downloading 3D chess game for PC:</p>
- <ol>
-<li>What are the benefits of playing 3D chess on PC?</li>
-<p>Playing 3D chess on PC has several benefits, such as better graphics quality and performance, easier and more precise control, wider range of options and features, and saving money by downloading free or cheap games.</p>
-<li>What are the main differences between 3D chess and traditional chess?</li>
-<p>3D chess is a variation of the classic board game that uses three-dimensional graphics and animations to simulate a real chessboard. It allows you to see the pieces from different angles, zoom in and out, rotate the board, and enjoy various visual effects. Some 3D chess games also have different themes, backgrounds, sounds, and music to enhance the atmosphere.</p>
-<li>What are the minimum system requirements for playing 3D chess on PC?</li>
-<p>The minimum system requirements for playing 3D chess on PC vary depending on the game you choose. However, a general guideline is that you need a Windows PC with at least 4 GB of RAM, 2 GB of disk space, a dual-core processor, and a graphics card that supports DirectX 11 or higher.</p>
-<li>How can I improve my skills in 3D chess?</li>
-<p>You can improve your skills in 3D chess by practicing regularly, playing against different opponents, solving puzzles, learning from tutorials or guides, watching videos or streams of other players, and joining online communities or forums.</p>
-<li>Where can I find more information or support about 3D chess games?</li>
-<p>You can find more information or support about 3D chess games by visiting their official websites or social media accounts, reading their reviews or ratings on online platforms, contacting their developers or publishers, or asking other players or experts.</p>
-</ol></p> 197e85843d<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/9xbuddy Music Download A Review of the Features Benefits and Limitations.md DELETED Viewed

@@ -1,112 +0,0 @@
-<br />
-<br>
- <code>
-<table>
-<tr>
-<td>
- <h1>How to Download Music from YouTube with 9xbuddy</h1>
-<p>Do you love listening to music on YouTube but wish you could save it offline? Do you want to enjoy your favorite songs without ads or interruptions? Do you want to convert YouTube videos into MP3 files easily and quickly?</p>
-<p>If you answered yes to any of these questions, then you need to try <strong>9xbuddy</strong>. It is a powerful online tool that lets you download music from YouTube in a matter of seconds. In this article, we will show you how to use 9xbuddy to download music from YouTube, as well as some tips and tricks for making the most of it. We will also compare it with some alternatives that you can try if you want more options.</p>
-<h2>9xbuddy music download</h2><br /><p><b><b>DOWNLOAD</b> &harr; <a href="https://jinyurl.com/2uNNUt">https://jinyurl.com/2uNNUt</a></b></p><br /><br /> <h2>What is 9xbuddy?</h2>
-<p><strong>9xbuddy</strong> is a free online service that allows you to download any video or audio from any website, including YouTube, Facebook, Instagram, Twitter, Vimeo, Dailymotion, SoundCloud, and more. You can use it to download music from YouTube in MP3 format, as well as other formats like MP4, WEBM, M4A, and more. You can also choose the quality of the download, from low to high. 9xbuddy is fast, easy, and reliable. You don't need to install any software or register an account. You just need to copy and paste the URL of the video or audio you want to download and click on the download button. 9xbuddy will do the rest for you.</p>
- <h2>Why Use 9xbuddy to Download Music from YouTube?</h2>
-<p>There are many reasons why you might want to use 9xbuddy to download music from YouTube. Here are some of them:</p>
-<ul>
-<li>You can save your favorite songs offline and listen to them anytime, anywhere, without internet connection or data charges.</li>
-<li>You can avoid annoying ads or interruptions that might ruin your listening experience.</li>
-<li>You can create your own playlists and mixtapes with the songs you download.</li>
-<li>You can transfer the songs to other devices or platforms, such as your phone, tablet, computer, MP3 player, car stereo, etc.</li>
-<li>You can edit or remix the songs with other tools or software.</li>
-<li>You can share the songs with your friends or family via email, social media, Bluetooth, etc.</li>
-</ul>
-<p>As you can see, using 9xbuddy to download music from YouTube can give you a lot of benefits and convenience. It can also save you time and money. So why not give it a try?</p>
- <h2>How to Use 9xbuddy to Download Music from YouTube?</h2>
-<p>Using 9xbuddy to download music from YouTube is very simple and straightforward. You just need to follow these four steps:</p>
-<p>9xbuddy online video downloader<br />
-9xbuddy mp3 converter<br />
-9xbuddy youtube to mp3<br />
-9xbuddy soundcloud downloader<br />
-9xbuddy alternative sites<br />
-9xbuddy facebook video download<br />
-9xbuddy twitter video download<br />
-9xbuddy dailymotion video download<br />
-9xbuddy instagram video download<br />
-9xbuddy tiktok video download<br />
-9xbuddy vimeo video download<br />
-9xbuddy spotify music download<br />
-9xbuddy apple music download<br />
-9xbuddy amazon music download<br />
-9xbuddy deezer music download<br />
-9xbuddy tidal music download<br />
-9xbuddy pandora music download<br />
-9xbuddy audiomack music download<br />
-9xbuddy bandcamp music download<br />
-9xbuddy soundclick music download<br />
-9xbuddy mixcloud music download<br />
-9xbuddy reverbnation music download<br />
-9xbuddy datpiff music download<br />
-9xbuddy jamendo music download<br />
-9xbuddy beatport music download<br />
-9xbuddy jiosaavn music download<br />
-9xbuddy gaana music download<br />
-9xbuddy hungama music download<br />
-9xbuddy wynk music download<br />
-9xbuddy shazam music download<br />
-9xbuddy musixmatch music download<br />
-9xbuddy tunein music download<br />
-9xbuddy iheartradio music download<br />
-9xbuddy last.fm music download<br />
-9xbuddy napster music download<br />
-9xbuddy yandex.music download<br />
-9xbuddy qqmusic download<br />
-9xbuddy netease cloud music download<br />
-9xbuddy xiami music download<br />
-9xbuddy kuwo music download<br />
-9xbuddy kugou music download<br />
-9xbuddy migu music download<br />
-9xbuddy melon music download<br />
-9xbuddy bugs music download<br />
-9xbuddy genie music download<br />
-9xbuddy flo music download<br />
-9xbuddy vibe music download</p>
- <h3>Step 1: Copy the YouTube Video URL</h3>
-<p>The first thing you need to do is to find the YouTube video that contains the music you want to download. You can use the YouTube app or website to search for it. Once you find it, you need to copy its URL. The URL is the web address that appears in the address bar of your browser or app. For example, the URL of this video is https://www.youtube.com/watch?v=kJQP7kiw5Fk. To copy it, you can either right-click on it and select "Copy" or highlight it and press Ctrl+C on your keyboard (or Command+C on Mac).</p>
- <h3>Step 2: Paste the URL into 9xbuddy</h3>
-<p>The next thing you need to do is to go to the 9xbuddy website: https://9xbuddy.org/. You will see a search box where you can paste the URL of the YouTube video. To paste it, you can either right-click on the box and select "Paste" or click on the box and press Ctrl+V on your keyboard (or Command+V on Mac). Then, click on the "Download" button next to the box.</p>
- <h3>Step 3: Choose the MP3 Format and Quality</h3>
-<p>After clicking on the "Download" button, 9xbuddy will analyze the URL and show you a list of available formats and qualities for downloading. You will see options like MP4 (video), WEBM (video), M4A (audio), MP3 (audio), etc. To download music from YouTube, you need to choose the MP3 format. You can also choose the quality of the MP3 file, from low (64 kbps) to high (320 kbps). The higher the quality, the larger the file size and the better the sound quality. To choose the format and quality, just click on them.</p>
- <h3>Step 4: Download the MP3 File</h3>
-<p>The final step is to download the MP3 file to your device or cloud storage. You will see a green "Download Now" button next to the format and quality you chose. Click on it and a new tab will open with a countdown timer. Wait for a few seconds until the timer reaches zero and then click on the "Download" button that appears. The MP3 file will start downloading automatically. You can check the progress of the download in your browser or app. Once the download is complete, you can find the MP3 file in your default download folder or location. You can also rename or move it as you wish.</p>
- <h2>Tips <h2>Tips and Tricks for Using 9xbuddy</h2>
-<p>To make your experience with 9xbuddy even better, here are some tips and tricks that you can use:</p>
- <h3>Tip 1: Use the Bookmarklet or Extension</h3>
-<p>If you want to download music from YouTube faster and easier, you can use the bookmarklet or extension that 9xbuddy offers. The bookmarklet is a small piece of code that you can drag and drop to your browser's bookmarks bar. The extension is a small program that you can install to your browser. Both of them allow you to download music from YouTube with just one click, without having to copy and paste the URL or go to the 9xbuddy website. To use the bookmarklet or extension, you need to go to this page: https://9xbuddy.org/tools and follow the instructions there.</p>
- <h3>Tip 2: Use the Batch Download Feature</h3>
-<p>If you want to download multiple music files at once, you can use the batch download feature that 9xbuddy offers. This feature allows you to enter multiple URLs in one search box and download them all in one go. To use the batch download feature, you need to go to this page: https://9xbuddy.org/batch and follow the instructions there.</p>
- <h3>Tip 3: Use the Playlist Download Feature</h3>
-<p>If you want to download an entire playlist from YouTube, you can use the playlist download feature that 9xbuddy offers. This feature allows you to enter the URL of a YouTube playlist and download all the videos or audios in it in one go. To use the playlist download feature, you need to go to this page: https://9xbuddy.org/playlist and follow the instructions there.</p>
- <h2>Alternatives to 9xbuddy</h2>
-<p>Although 9xbuddy is a great tool for downloading music from YouTube, it is not the only one. There are some other websites or tools that can also do the same job. Here are some of them:</p>
- <h3>Alternative 1: YTMP3</h3>
-<p><strong>YTMP3</strong> is a simple and fast online service that allows you to convert and download YouTube videos into MP3 or MP4 files. You can use it to download music from YouTube in high quality (up to 320 kbps) and without any limitations. You don't need to install any software or register an account. You just need to copy and paste the URL of the YouTube video and click on the convert button. YTMP3 will do the rest for you. You can access YTMP3 here: https://ytmp3.cc/.</p>
- <h3>Alternative 2: Snappea</h3>
-<p><strong>Snappea</strong> is a versatile and powerful online tool that allows you to download videos and audios from various websites, including YouTube, Facebook, Instagram, TikTok, Dailymotion, etc. You can use it to download music from YouTube in various formats (MP3, MP4, M4A, etc.) and qualities (from 144p to 1080p). You don't need to install any software or register an account. You just need to copy and paste the URL of the video or audio and click on the download button. Snappea will do the rest for you. You can access Snappea here: https://www.snappea.com/.</p>
- <h3>Alternative 3: MP3FY</h3>
-<p><strong>MP3FY</strong> is a fast and easy online service that allows you to convert and download any video or audio from any website into MP3 files. You can use it to download music from YouTube in high quality (up to 320 kbps) and without any restrictions. You don't need to install any software or register an account. You just need to copy and paste the URL of the video or audio and click on the convert button. MP3FY will do the rest for you. You can access MP3FY here: https://mp3fy.com/.</p>
- <h2>Conclusion</h2>
-<p>In conclusion, downloading music from YouTube with 9xbuddy is a simple and convenient way to enjoy your favorite songs offline. You just need to follow four easy steps: copy the URL of the YouTube video, paste it into 9xbuddy, choose the MP3 format and quality, and download the file. You can also use some tips and tricks to enhance your experience with 9xbuddy, such as using the bookmarklet or extension, using the batch download feature, or using the playlist download feature. If you want more options, you can also try some alternatives to 9xbuddy, such as YTMP3, Snappea, or MP3FY.</p>
-<p>We hope this <p>We hope this article has helped you learn how to download music from YouTube with 9xbuddy. Now you can enjoy your favorite songs anytime, anywhere, without any hassle. If you have any questions or feedback, please feel free to leave a comment below. We would love to hear from you.</p>
- <h2>FAQs</h2>
-<p>Here are some frequently asked questions and answers about 9xbuddy and downloading music from YouTube:</p>
- <h3>Q: Is 9xbuddy safe and legal?</h3>
-<p>A: 9xbuddy is safe and legal to use, as long as you use it for personal and non-commercial purposes. 9xbuddy does not host or store any content on its servers. It only acts as a mediator between the user and the source website. However, you should always respect the intellectual property rights of the original creators and owners of the content. You should not download or distribute any content that is protected by copyright or other laws.</p>
- <h3>Q: How long does it take to download music from YouTube with 9xbuddy?</h3>
-<p>A: The time it takes to download music from YouTube with 9xbuddy depends on several factors, such as the length and quality of the video, the speed of your internet connection, and the traffic on the website. Generally, it takes a few seconds to a few minutes to download a music file from YouTube with 9xbuddy.</p>
- <h3>Q: How many music files can I download from YouTube with 9xbuddy?</h3>
-<p>A: There is no limit to how many music files you can download from YouTube with 9xbuddy. You can download as many as you want, as long as you have enough space on your device or cloud storage. However, you should be mindful of the bandwidth and data usage that downloading music files can consume.</p>
- <h3>Q: Can I download music from other websites besides YouTube with 9xbuddy?</h3>
-<p>A: Yes, you can download music from other websites besides YouTube with 9xbuddy. 9xbuddy supports over 1000 websites, including Facebook, Instagram, Twitter, Vimeo, Dailymotion, SoundCloud, and more. You can use the same steps as downloading music from YouTube with 9xbuddy.</p>
- <h3>Q: Can I download music from YouTube with 9xbuddy on my mobile device?</h3>
-<p>A: Yes, you can download music from YouTube with 9xbuddy on your mobile device. 9xbuddy is compatible with all devices and platforms, including Android, iOS, Windows, Mac, Linux, etc. You can use any browser or app that supports web browsing to access 9xbuddy and download music from YouTube.</p> 401be4b1e0<br />
-<br />
-<br />

spaces/232labs/VToonify/vtoonify/model/dualstylegan.py DELETED Viewed

@@ -1,203 +0,0 @@
-import random
-import torch
-from torch import nn
-from model.stylegan.model import ConvLayer, PixelNorm, EqualLinear, Generator
-class AdaptiveInstanceNorm(nn.Module):
-    def __init__(self, fin, style_dim=512):
-        super().__init__()
-        self.norm = nn.InstanceNorm2d(fin, affine=False)
-        self.style = nn.Linear(style_dim, fin * 2)
-        self.style.bias.data[:fin] = 1
-        self.style.bias.data[fin:] = 0
-    def forward(self, input, style):
-        style = self.style(style).unsqueeze(2).unsqueeze(3)
-        gamma, beta = style.chunk(2, 1)
-        out = self.norm(input)
-        out = gamma * out + beta
-        return out
-# modulative residual blocks (ModRes)
-class AdaResBlock(nn.Module):
-    def __init__(self, fin, style_dim=512, dilation=1): # modified
-        super().__init__()
-        self.conv = ConvLayer(fin, fin, 3, dilation=dilation) # modified
-        self.conv2 = ConvLayer(fin, fin, 3, dilation=dilation) # modified
-        self.norm = AdaptiveInstanceNorm(fin, style_dim)
-        self.norm2 = AdaptiveInstanceNorm(fin, style_dim)
-        # model initialization
-        # the convolution filters are set to values close to 0 to produce negligible residual features
-        self.conv[0].weight.data *= 0.01
-        self.conv2[0].weight.data *= 0.01
-    def forward(self, x, s, w=1):
-        skip = x
-        if w == 0:
-            return skip
-        out = self.conv(self.norm(x, s))
-        out = self.conv2(self.norm2(out, s))
-        out = out * w + skip
-        return out
-class DualStyleGAN(nn.Module):
-    def __init__(self, size, style_dim, n_mlp, channel_multiplier=2, twoRes=True, res_index=6):
-        super().__init__()
-        layers = [PixelNorm()]
-        for i in range(n_mlp-6):
-            layers.append(EqualLinear(512, 512, lr_mul=0.01, activation="fused_lrelu"))
-        # color transform blocks T_c
-        self.style = nn.Sequential(*layers)
-        # StyleGAN2
-        self.generator = Generator(size, style_dim, n_mlp, channel_multiplier)
-        # The extrinsic style path
-        self.res = nn.ModuleList()
-        self.res_index = res_index//2 * 2
-        self.res.append(AdaResBlock(self.generator.channels[2 ** 2])) # for conv1
-        for i in range(3, self.generator.log_size + 1):
-            out_channel = self.generator.channels[2 ** i]
-            if i < 3 + self.res_index//2:
-                # ModRes
-                self.res.append(AdaResBlock(out_channel))
-                self.res.append(AdaResBlock(out_channel))
-            else:
-                # structure transform block T_s
-                self.res.append(EqualLinear(512, 512))
-                # FC layer is initialized with identity matrices, meaning no changes to the input latent code
-                self.res[-1].weight.data = torch.eye(512) * 512.0**0.5 + torch.randn(512, 512) * 0.01
-                self.res.append(EqualLinear(512, 512))
-                self.res[-1].weight.data = torch.eye(512) * 512.0**0.5 + torch.randn(512, 512) * 0.01
-        self.res.append(EqualLinear(512, 512)) # for to_rgb7
-        self.res[-1].weight.data = torch.eye(512) * 512.0**0.5 + torch.randn(512, 512) * 0.01
-        self.size = self.generator.size
-        self.style_dim = self.generator.style_dim
-        self.log_size = self.generator.log_size
-        self.num_layers = self.generator.num_layers
-        self.n_latent = self.generator.n_latent
-        self.channels = self.generator.channels
-    def forward(
-        self,
-        styles, # intrinsic style code
-        exstyles, # extrinsic style code
-        return_latents=False,
-        return_feat=False,
-        inject_index=None,
-        truncation=1,
-        truncation_latent=None,
-        input_is_latent=False,
-        noise=None,
-        randomize_noise=True,
-        z_plus_latent=False, # intrinsic style code is z+ or z
-        use_res=True,        # whether to use the extrinsic style path
-        fuse_index=18,       # layers > fuse_index do not use the extrinsic style path
-        interp_weights=[1]*18, # weight vector for style combination of two paths
-    ):
-        if not input_is_latent:
-            if not z_plus_latent:
-                styles = [self.generator.style(s) for s in styles]
-            else:
-                styles = [self.generator.style(s.reshape(s.shape[0]*s.shape[1], s.shape[2])).reshape(s.shape) for s in styles]
-        if noise is None:
-            if randomize_noise:
-                noise = [None] * self.generator.num_layers
-            else:
-                noise = [
-                    getattr(self.generator.noises, f"noise_{i}") for i in range(self.generator.num_layers)
-                ]
-        if truncation < 1:
-            style_t = []
-            for style in styles:
-                style_t.append(
-                    truncation_latent + truncation * (style - truncation_latent)
-                )
-            styles = style_t
-        if len(styles) < 2:
-            inject_index = self.generator.n_latent
-            if styles[0].ndim < 3:
-                latent = styles[0].unsqueeze(1).repeat(1, inject_index, 1)
-            else:
-                latent = styles[0]
-        else:
-            if inject_index is None:
-                inject_index = random.randint(1, self.generator.n_latent - 1)
-            if styles[0].ndim < 3:
-                latent = styles[0].unsqueeze(1).repeat(1, inject_index, 1)
-                latent2 = styles[1].unsqueeze(1).repeat(1, self.generator.n_latent - inject_index, 1)
-                latent = torch.cat([latent, latent2], 1)
-            else:
-                latent = torch.cat([styles[0][:,0:inject_index], styles[1][:,inject_index:]], 1)
-        if use_res:
-            if exstyles.ndim < 3:
-                resstyles = self.style(exstyles).unsqueeze(1).repeat(1, self.generator.n_latent, 1)
-                adastyles = exstyles.unsqueeze(1).repeat(1, self.generator.n_latent, 1)
-            else:
-                nB, nL, nD = exstyles.shape
-                resstyles = self.style(exstyles.reshape(nB*nL, nD)).reshape(nB, nL, nD)
-                adastyles = exstyles
-        out = self.generator.input(latent)
-        out = self.generator.conv1(out, latent[:, 0], noise=noise[0])
-        if use_res and fuse_index > 0:
-            out = self.res[0](out, resstyles[:, 0], interp_weights[0])
-        skip = self.generator.to_rgb1(out, latent[:, 1])
-        i = 1
-        for conv1, conv2, noise1, noise2, to_rgb in zip(
-            self.generator.convs[::2], self.generator.convs[1::2], noise[1::2], noise[2::2], self.generator.to_rgbs):
-            if use_res and fuse_index >= i and i > self.res_index:
-                out = conv1(out, interp_weights[i] * self.res[i](adastyles[:, i]) +
-                            (1-interp_weights[i]) * latent[:, i], noise=noise1)
-            else:
-                out = conv1(out, latent[:, i], noise=noise1)
-            if use_res and fuse_index >= i and i <= self.res_index:
-                out = self.res[i](out, resstyles[:, i], interp_weights[i])
-            if use_res and fuse_index >= (i+1) and i > self.res_index:
-                out = conv2(out, interp_weights[i+1] * self.res[i+1](adastyles[:, i+1]) +
-                            (1-interp_weights[i+1]) * latent[:, i+1], noise=noise2)
-            else:
-                out = conv2(out, latent[:, i + 1], noise=noise2)
-            if use_res and fuse_index >= (i+1) and i <= self.res_index:
-                out = self.res[i+1](out, resstyles[:, i+1], interp_weights[i+1])
-            if use_res and fuse_index >= (i+2) and i >= self.res_index-1:
-                skip = to_rgb(out, interp_weights[i+2] * self.res[i+2](adastyles[:, i+2]) +
-                              (1-interp_weights[i+2]) * latent[:, i + 2], skip)
-            else:
-                skip = to_rgb(out, latent[:, i + 2], skip)
-            i += 2
-            if i > self.res_index and return_feat:
-                return out, skip
-        image = skip
-        if return_latents:
-            return image, latent
-        else:
-            return image, None
-    def make_noise(self):
-        return self.generator.make_noise()
-    def mean_latent(self, n_latent):
-        return self.generator.mean_latent(n_latent)
-    def get_latent(self, input):
-        return self.generator.style(input)

spaces/232labs/VToonify/vtoonify/model/raft/core/__init__.py DELETED Viewed

File without changes

spaces/ANDRYHA/FakeNewsClassifier/app.py DELETED Viewed

@@ -1,71 +0,0 @@
-from transformers import FSMTForConditionalGeneration, FSMTTokenizer
-from transformers import AutoModelForSequenceClassification
-from transformers import AutoTokenizer
-from langdetect import detect
-from newspaper import Article
-from PIL import Image
-import streamlit as st
-import requests
-import torch
-st.markdown("## Prediction of Fakeness by Given URL")
-background = Image.open('logo.jpg')
-st.image(background)
-st.markdown(f"### Article URL")
-text = st.text_area("Insert some url here",
-        value="https://en.globes.co.il/en/article-yandex-looks-to-expand-activities-in-israel-1001406519")
-@st.cache(allow_output_mutation=True)
-def get_models_and_tokenizers():
-    model_name = 'distilbert-base-uncased-finetuned-sst-2-english'
-    model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)
-    model.eval()
-    tokenizer = AutoTokenizer.from_pretrained(model_name)
-    model.load_state_dict(torch.load('./model.pth', map_location='cpu'))
-    model_name_translator = "facebook/wmt19-ru-en"
-    tokenizer_translator = FSMTTokenizer.from_pretrained(model_name_translator)
-    model_translator = FSMTForConditionalGeneration.from_pretrained(model_name_translator)
-    model_translator.eval()
-    return model, tokenizer, model_translator, tokenizer_translator
-model, tokenizer, model_translator, tokenizer_translator = get_models_and_tokenizers()
-article = Article(text)
-article.download()
-article.parse()
-concated_text = article.title + '. ' + article.text
-lang = detect(concated_text)
-st.markdown(f"### Language detection")
-if lang == 'ru':
-    st.markdown(f"The language of this article is {lang.upper()} so we translated it!")
-    with st.spinner('Waiting for translation'):
-        input_ids = tokenizer_translator.encode(concated_text,
-            return_tensors="pt", max_length=512, truncation=True)
-        outputs = model_translator.generate(input_ids)
-        decoded = tokenizer_translator.decode(outputs[0], skip_special_tokens=True)
-        st.markdown("### Translated Text")
-        st.markdown(f"{decoded[:777]}")
-        concated_text = decoded
-else:
-    st.markdown(f"The language of this article for sure:  {lang.upper()}!")
-    st.markdown("### Extracted Text")
-    st.markdown(f"{concated_text[:777]}")
-tokens_info = tokenizer(concated_text, truncation=True, return_tensors="pt")
-with torch.no_grad():
-    raw_predictions = model(**tokens_info)
-softmaxed = int(torch.nn.functional.softmax(raw_predictions.logits[0], dim=0)[1] * 100)
-st.markdown("### Fakeness Prediction")
-st.progress(softmaxed)
-st.markdown(f"This is fake by **{softmaxed}%**!")
-if (softmaxed > 70):
-    st.error('We would not trust this text!')
-elif (softmaxed > 40):
-    st.warning('We are not sure about this text!')
-else:
-    st.success('We would trust this text!')

spaces/Abhilashvj/planogram-compliance/models/common.py DELETED Viewed

@@ -1,1268 +0,0 @@
-# YOLOv5 🚀 by Ultralytics, GPL-3.0 license
-"""
-Common modules
-"""
-import ast
-import contextlib
-import json
-import math
-import platform
-import warnings
-import zipfile
-from collections import OrderedDict, namedtuple
-from copy import copy
-from pathlib import Path
-from urllib.parse import urlparse
-import cv2
-import numpy as np
-import pandas as pd
-import requests
-import torch
-import torch.nn as nn
-from IPython.display import display
-from PIL import Image
-from torch.cuda import amp
-from utils import TryExcept
-from utils.dataloaders import exif_transpose, letterbox
-from utils.general import (
-    LOGGER,
-    ROOT,
-    Profile,
-    check_requirements,
-    check_suffix,
-    check_version,
-    colorstr,
-    increment_path,
-    is_notebook,
-    make_divisible,
-    non_max_suppression,
-    scale_boxes,
-    xywh2xyxy,
-    xyxy2xywh,
-    yaml_load,
-)
-from utils.plots import Annotator, colors, save_one_box
-from utils.torch_utils import copy_attr, smart_inference_mode
-def autopad(k, p=None, d=1):  # kernel, padding, dilation
-    # Pad to 'same' shape outputs
-    if d > 1:
-        k = (
-            d * (k - 1) + 1
-            if isinstance(k, int)
-            else [d * (x - 1) + 1 for x in k]
-        )  # actual kernel-size
-    if p is None:
-        p = k // 2 if isinstance(k, int) else [x // 2 for x in k]  # auto-pad
-    return p
-class Conv(nn.Module):
-    # Standard convolution with args(ch_in, ch_out, kernel, stride, padding, groups, dilation, activation)
-    default_act = nn.SiLU()  # default activation
-    def __init__(self, c1, c2, k=1, s=1, p=None, g=1, d=1, act=True):
-        super().__init__()
-        self.conv = nn.Conv2d(
-            c1, c2, k, s, autopad(k, p, d), groups=g, dilation=d, bias=False
-        )
-        self.bn = nn.BatchNorm2d(c2)
-        self.act = (
-            self.default_act
-            if act is True
-            else act
-            if isinstance(act, nn.Module)
-            else nn.Identity()
-        )
-    def forward(self, x):
-        return self.act(self.bn(self.conv(x)))
-    def forward_fuse(self, x):
-        return self.act(self.conv(x))
-class DWConv(Conv):
-    # Depth-wise convolution
-    def __init__(
-        self, c1, c2, k=1, s=1, d=1, act=True
-    ):  # ch_in, ch_out, kernel, stride, dilation, activation
-        super().__init__(c1, c2, k, s, g=math.gcd(c1, c2), d=d, act=act)
-class DWConvTranspose2d(nn.ConvTranspose2d):
-    # Depth-wise transpose convolution
-    def __init__(
-        self, c1, c2, k=1, s=1, p1=0, p2=0
-    ):  # ch_in, ch_out, kernel, stride, padding, padding_out
-        super().__init__(c1, c2, k, s, p1, p2, groups=math.gcd(c1, c2))
-class TransformerLayer(nn.Module):
-    # Transformer layer https://arxiv.org/abs/2010.11929 (LayerNorm layers removed for better performance)
-    def __init__(self, c, num_heads):
-        super().__init__()
-        self.q = nn.Linear(c, c, bias=False)
-        self.k = nn.Linear(c, c, bias=False)
-        self.v = nn.Linear(c, c, bias=False)
-        self.ma = nn.MultiheadAttention(embed_dim=c, num_heads=num_heads)
-        self.fc1 = nn.Linear(c, c, bias=False)
-        self.fc2 = nn.Linear(c, c, bias=False)
-    def forward(self, x):
-        x = self.ma(self.q(x), self.k(x), self.v(x))[0] + x
-        x = self.fc2(self.fc1(x)) + x
-        return x
-class TransformerBlock(nn.Module):
-    # Vision Transformer https://arxiv.org/abs/2010.11929
-    def __init__(self, c1, c2, num_heads, num_layers):
-        super().__init__()
-        self.conv = None
-        if c1 != c2:
-            self.conv = Conv(c1, c2)
-        self.linear = nn.Linear(c2, c2)  # learnable position embedding
-        self.tr = nn.Sequential(
-            *(TransformerLayer(c2, num_heads) for _ in range(num_layers))
-        )
-        self.c2 = c2
-    def forward(self, x):
-        if self.conv is not None:
-            x = self.conv(x)
-        b, _, w, h = x.shape
-        p = x.flatten(2).permute(2, 0, 1)
-        return (
-            self.tr(p + self.linear(p))
-            .permute(1, 2, 0)
-            .reshape(b, self.c2, w, h)
-        )
-class Bottleneck(nn.Module):
-    # Standard bottleneck
-    def __init__(
-        self, c1, c2, shortcut=True, g=1, e=0.5
-    ):  # ch_in, ch_out, shortcut, groups, expansion
-        super().__init__()
-        c_ = int(c2 * e)  # hidden channels
-        self.cv1 = Conv(c1, c_, 1, 1)
-        self.cv2 = Conv(c_, c2, 3, 1, g=g)
-        self.add = shortcut and c1 == c2
-    def forward(self, x):
-        return x + self.cv2(self.cv1(x)) if self.add else self.cv2(self.cv1(x))
-class BottleneckCSP(nn.Module):
-    # CSP Bottleneck https://github.com/WongKinYiu/CrossStagePartialNetworks
-    def __init__(
-        self, c1, c2, n=1, shortcut=True, g=1, e=0.5
-    ):  # ch_in, ch_out, number, shortcut, groups, expansion
-        super().__init__()
-        c_ = int(c2 * e)  # hidden channels
-        self.cv1 = Conv(c1, c_, 1, 1)
-        self.cv2 = nn.Conv2d(c1, c_, 1, 1, bias=False)
-        self.cv3 = nn.Conv2d(c_, c_, 1, 1, bias=False)
-        self.cv4 = Conv(2 * c_, c2, 1, 1)
-        self.bn = nn.BatchNorm2d(2 * c_)  # applied to cat(cv2, cv3)
-        self.act = nn.SiLU()
-        self.m = nn.Sequential(
-            *(Bottleneck(c_, c_, shortcut, g, e=1.0) for _ in range(n))
-        )
-    def forward(self, x):
-        y1 = self.cv3(self.m(self.cv1(x)))
-        y2 = self.cv2(x)
-        return self.cv4(self.act(self.bn(torch.cat((y1, y2), 1))))
-class CrossConv(nn.Module):
-    # Cross Convolution Downsample
-    def __init__(self, c1, c2, k=3, s=1, g=1, e=1.0, shortcut=False):
-        # ch_in, ch_out, kernel, stride, groups, expansion, shortcut
-        super().__init__()
-        c_ = int(c2 * e)  # hidden channels
-        self.cv1 = Conv(c1, c_, (1, k), (1, s))
-        self.cv2 = Conv(c_, c2, (k, 1), (s, 1), g=g)
-        self.add = shortcut and c1 == c2
-    def forward(self, x):
-        return x + self.cv2(self.cv1(x)) if self.add else self.cv2(self.cv1(x))
-class C3(nn.Module):
-    # CSP Bottleneck with 3 convolutions
-    def __init__(
-        self, c1, c2, n=1, shortcut=True, g=1, e=0.5
-    ):  # ch_in, ch_out, number, shortcut, groups, expansion
-        super().__init__()
-        c_ = int(c2 * e)  # hidden channels
-        self.cv1 = Conv(c1, c_, 1, 1)
-        self.cv2 = Conv(c1, c_, 1, 1)
-        self.cv3 = Conv(2 * c_, c2, 1)  # optional act=FReLU(c2)
-        self.m = nn.Sequential(
-            *(Bottleneck(c_, c_, shortcut, g, e=1.0) for _ in range(n))
-        )
-    def forward(self, x):
-        return self.cv3(torch.cat((self.m(self.cv1(x)), self.cv2(x)), 1))
-class C3x(C3):
-    # C3 module with cross-convolutions
-    def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):
-        super().__init__(c1, c2, n, shortcut, g, e)
-        c_ = int(c2 * e)
-        self.m = nn.Sequential(
-            *(CrossConv(c_, c_, 3, 1, g, 1.0, shortcut) for _ in range(n))
-        )
-class C3TR(C3):
-    # C3 module with TransformerBlock()
-    def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):
-        super().__init__(c1, c2, n, shortcut, g, e)
-        c_ = int(c2 * e)
-        self.m = TransformerBlock(c_, c_, 4, n)
-class C3SPP(C3):
-    # C3 module with SPP()
-    def __init__(self, c1, c2, k=(5, 9, 13), n=1, shortcut=True, g=1, e=0.5):
-        super().__init__(c1, c2, n, shortcut, g, e)
-        c_ = int(c2 * e)
-        self.m = SPP(c_, c_, k)
-class C3Ghost(C3):
-    # C3 module with GhostBottleneck()
-    def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):
-        super().__init__(c1, c2, n, shortcut, g, e)
-        c_ = int(c2 * e)  # hidden channels
-        self.m = nn.Sequential(*(GhostBottleneck(c_, c_) for _ in range(n)))
-class SPP(nn.Module):
-    # Spatial Pyramid Pooling (SPP) layer https://arxiv.org/abs/1406.4729
-    def __init__(self, c1, c2, k=(5, 9, 13)):
-        super().__init__()
-        c_ = c1 // 2  # hidden channels
-        self.cv1 = Conv(c1, c_, 1, 1)
-        self.cv2 = Conv(c_ * (len(k) + 1), c2, 1, 1)
-        self.m = nn.ModuleList(
-            [nn.MaxPool2d(kernel_size=x, stride=1, padding=x // 2) for x in k]
-        )
-    def forward(self, x):
-        x = self.cv1(x)
-        with warnings.catch_warnings():
-            warnings.simplefilter(
-                "ignore"
-            )  # suppress torch 1.9.0 max_pool2d() warning
-            return self.cv2(torch.cat([x] + [m(x) for m in self.m], 1))
-class SPPF(nn.Module):
-    # Spatial Pyramid Pooling - Fast (SPPF) layer for YOLOv5 by Glenn Jocher
-    def __init__(self, c1, c2, k=5):  # equivalent to SPP(k=(5, 9, 13))
-        super().__init__()
-        c_ = c1 // 2  # hidden channels
-        self.cv1 = Conv(c1, c_, 1, 1)
-        self.cv2 = Conv(c_ * 4, c2, 1, 1)
-        self.m = nn.MaxPool2d(kernel_size=k, stride=1, padding=k // 2)
-    def forward(self, x):
-        x = self.cv1(x)
-        with warnings.catch_warnings():
-            warnings.simplefilter(
-                "ignore"
-            )  # suppress torch 1.9.0 max_pool2d() warning
-            y1 = self.m(x)
-            y2 = self.m(y1)
-            return self.cv2(torch.cat((x, y1, y2, self.m(y2)), 1))
-class Focus(nn.Module):
-    # Focus wh information into c-space
-    def __init__(
-        self, c1, c2, k=1, s=1, p=None, g=1, act=True
-    ):  # ch_in, ch_out, kernel, stride, padding, groups
-        super().__init__()
-        self.conv = Conv(c1 * 4, c2, k, s, p, g, act=act)
-        # self.contract = Contract(gain=2)
-    def forward(self, x):  # x(b,c,w,h) -> y(b,4c,w/2,h/2)
-        return self.conv(
-            torch.cat(
-                (
-                    x[..., ::2, ::2],
-                    x[..., 1::2, ::2],
-                    x[..., ::2, 1::2],
-                    x[..., 1::2, 1::2],
-                ),
-                1,
-            )
-        )
-        # return self.conv(self.contract(x))
-class GhostConv(nn.Module):
-    # Ghost Convolution https://github.com/huawei-noah/ghostnet
-    def __init__(
-        self, c1, c2, k=1, s=1, g=1, act=True
-    ):  # ch_in, ch_out, kernel, stride, groups
-        super().__init__()
-        c_ = c2 // 2  # hidden channels
-        self.cv1 = Conv(c1, c_, k, s, None, g, act=act)
-        self.cv2 = Conv(c_, c_, 5, 1, None, c_, act=act)
-    def forward(self, x):
-        y = self.cv1(x)
-        return torch.cat((y, self.cv2(y)), 1)
-class GhostBottleneck(nn.Module):
-    # Ghost Bottleneck https://github.com/huawei-noah/ghostnet
-    def __init__(self, c1, c2, k=3, s=1):  # ch_in, ch_out, kernel, stride
-        super().__init__()
-        c_ = c2 // 2
-        self.conv = nn.Sequential(
-            GhostConv(c1, c_, 1, 1),  # pw
-            DWConv(c_, c_, k, s, act=False) if s == 2 else nn.Identity(),  # dw
-            GhostConv(c_, c2, 1, 1, act=False),
-        )  # pw-linear
-        self.shortcut = (
-            nn.Sequential(
-                DWConv(c1, c1, k, s, act=False), Conv(c1, c2, 1, 1, act=False)
-            )
-            if s == 2
-            else nn.Identity()
-        )
-    def forward(self, x):
-        return self.conv(x) + self.shortcut(x)
-class Contract(nn.Module):
-    # Contract width-height into channels, i.e. x(1,64,80,80) to x(1,256,40,40)
-    def __init__(self, gain=2):
-        super().__init__()
-        self.gain = gain
-    def forward(self, x):
-        (
-            b,
-            c,
-            h,
-            w,
-        ) = (
-            x.size()
-        )  # assert (h / s == 0) and (W / s == 0), 'Indivisible gain'
-        s = self.gain
-        x = x.view(b, c, h // s, s, w // s, s)  # x(1,64,40,2,40,2)
-        x = x.permute(0, 3, 5, 1, 2, 4).contiguous()  # x(1,2,2,64,40,40)
-        return x.view(b, c * s * s, h // s, w // s)  # x(1,256,40,40)
-class Expand(nn.Module):
-    # Expand channels into width-height, i.e. x(1,64,80,80) to x(1,16,160,160)
-    def __init__(self, gain=2):
-        super().__init__()
-        self.gain = gain
-    def forward(self, x):
-        b, c, h, w = x.size()  # assert C / s ** 2 == 0, 'Indivisible gain'
-        s = self.gain
-        x = x.view(b, s, s, c // s**2, h, w)  # x(1,2,2,16,80,80)
-        x = x.permute(0, 3, 4, 1, 5, 2).contiguous()  # x(1,16,80,2,80,2)
-        return x.view(b, c // s**2, h * s, w * s)  # x(1,16,160,160)
-class Concat(nn.Module):
-    # Concatenate a list of tensors along dimension
-    def __init__(self, dimension=1):
-        super().__init__()
-        self.d = dimension
-    def forward(self, x):
-        return torch.cat(x, self.d)
-class DetectMultiBackend(nn.Module):
-    # YOLOv5 MultiBackend class for python inference on various backends
-    def __init__(
-        self,
-        weights="yolov5s.pt",
-        device=torch.device("cpu"),
-        dnn=False,
-        data=None,
-        fp16=False,
-        fuse=True,
-    ):
-        # Usage:
-        #   PyTorch:              weights = *.pt
-        #   TorchScript:                    *.torchscript
-        #   ONNX Runtime:                   *.onnx
-        #   ONNX OpenCV DNN:                *.onnx --dnn
-        #   OpenVINO:                       *_openvino_model
-        #   CoreML:                         *.mlmodel
-        #   TensorRT:                       *.engine
-        #   TensorFlow SavedModel:          *_saved_model
-        #   TensorFlow GraphDef:            *.pb
-        #   TensorFlow Lite:                *.tflite
-        #   TensorFlow Edge TPU:            *_edgetpu.tflite
-        #   PaddlePaddle:                   *_paddle_model
-        from models.experimental import (  # scoped to avoid circular import
-            attempt_download,
-            attempt_load,
-        )
-        super().__init__()
-        w = str(weights[0] if isinstance(weights, list) else weights)
-        (
-            pt,
-            jit,
-            onnx,
-            xml,
-            engine,
-            coreml,
-            saved_model,
-            pb,
-            tflite,
-            edgetpu,
-            tfjs,
-            paddle,
-            triton,
-        ) = self._model_type(w)
-        fp16 &= pt or jit or onnx or engine  # FP16
-        nhwc = (
-            coreml or saved_model or pb or tflite or edgetpu
-        )  # BHWC formats (vs torch BCWH)
-        stride = 32  # default stride
-        cuda = torch.cuda.is_available() and device.type != "cpu"  # use CUDA
-        if not (pt or triton):
-            w = attempt_download(w)  # download if not local
-        if pt:  # PyTorch
-            model = attempt_load(
-                weights if isinstance(weights, list) else w,
-                device=device,
-                inplace=True,
-                fuse=fuse,
-            )
-            stride = max(int(model.stride.max()), 32)  # model stride
-            names = (
-                model.module.names if hasattr(model, "module") else model.names
-            )  # get class names
-            model.half() if fp16 else model.float()
-            self.model = (
-                model  # explicitly assign for to(), cpu(), cuda(), half()
-            )
-        elif jit:  # TorchScript
-            LOGGER.info(f"Loading {w} for TorchScript inference...")
-            extra_files = {"config.txt": ""}  # model metadata
-            model = torch.jit.load(
-                w, _extra_files=extra_files, map_location=device
-            )
-            model.half() if fp16 else model.float()
-            if extra_files["config.txt"]:  # load metadata dict
-                d = json.loads(
-                    extra_files["config.txt"],
-                    object_hook=lambda d: {
-                        int(k) if k.isdigit() else k: v for k, v in d.items()
-                    },
-                )
-                stride, names = int(d["stride"]), d["names"]
-        elif dnn:  # ONNX OpenCV DNN
-            LOGGER.info(f"Loading {w} for ONNX OpenCV DNN inference...")
-            check_requirements("opencv-python>=4.5.4")
-            net = cv2.dnn.readNetFromONNX(w)
-        elif onnx:  # ONNX Runtime
-            LOGGER.info(f"Loading {w} for ONNX Runtime inference...")
-            check_requirements(
-                ("onnx", "onnxruntime-gpu" if cuda else "onnxruntime")
-            )
-            import onnxruntime
-            providers = (
-                ["CUDAExecutionProvider", "CPUExecutionProvider"]
-                if cuda
-                else ["CPUExecutionProvider"]
-            )
-            session = onnxruntime.InferenceSession(w, providers=providers)
-            output_names = [x.name for x in session.get_outputs()]
-            meta = session.get_modelmeta().custom_metadata_map  # metadata
-            if "stride" in meta:
-                stride, names = int(meta["stride"]), eval(meta["names"])
-        elif xml:  # OpenVINO
-            LOGGER.info(f"Loading {w} for OpenVINO inference...")
-            check_requirements(
-                "openvino"
-            )  # requires openvino-dev: https://pypi.org/project/openvino-dev/
-            from openvino.runtime import Core, Layout, get_batch
-            ie = Core()
-            if not Path(w).is_file():  # if not *.xml
-                w = next(
-                    Path(w).glob("*.xml")
-                )  # get *.xml file from *_openvino_model dir
-            network = ie.read_model(
-                model=w, weights=Path(w).with_suffix(".bin")
-            )
-            if network.get_parameters()[0].get_layout().empty:
-                network.get_parameters()[0].set_layout(Layout("NCHW"))
-            batch_dim = get_batch(network)
-            if batch_dim.is_static:
-                batch_size = batch_dim.get_length()
-            executable_network = ie.compile_model(
-                network, device_name="CPU"
-            )  # device_name="MYRIAD" for Intel NCS2
-            stride, names = self._load_metadata(
-                Path(w).with_suffix(".yaml")
-            )  # load metadata
-        elif engine:  # TensorRT
-            LOGGER.info(f"Loading {w} for TensorRT inference...")
-            import tensorrt as trt  # https://developer.nvidia.com/nvidia-tensorrt-download
-            check_version(
-                trt.__version__, "7.0.0", hard=True
-            )  # require tensorrt>=7.0.0
-            if device.type == "cpu":
-                device = torch.device("cuda:0")
-            Binding = namedtuple(
-                "Binding", ("name", "dtype", "shape", "data", "ptr")
-            )
-            logger = trt.Logger(trt.Logger.INFO)
-            with open(w, "rb") as f, trt.Runtime(logger) as runtime:
-                model = runtime.deserialize_cuda_engine(f.read())
-            context = model.create_execution_context()
-            bindings = OrderedDict()
-            output_names = []
-            fp16 = False  # default updated below
-            dynamic = False
-            for i in range(model.num_bindings):
-                name = model.get_binding_name(i)
-                dtype = trt.nptype(model.get_binding_dtype(i))
-                if model.binding_is_input(i):
-                    if -1 in tuple(model.get_binding_shape(i)):  # dynamic
-                        dynamic = True
-                        context.set_binding_shape(
-                            i, tuple(model.get_profile_shape(0, i)[2])
-                        )
-                    if dtype == np.float16:
-                        fp16 = True
-                else:  # output
-                    output_names.append(name)
-                shape = tuple(context.get_binding_shape(i))
-                im = torch.from_numpy(np.empty(shape, dtype=dtype)).to(device)
-                bindings[name] = Binding(
-                    name, dtype, shape, im, int(im.data_ptr())
-                )
-            binding_addrs = OrderedDict(
-                (n, d.ptr) for n, d in bindings.items()
-            )
-            batch_size = bindings["images"].shape[
-                0
-            ]  # if dynamic, this is instead max batch size
-        elif coreml:  # CoreML
-            LOGGER.info(f"Loading {w} for CoreML inference...")
-            import coremltools as ct
-            model = ct.models.MLModel(w)
-        elif saved_model:  # TF SavedModel
-            LOGGER.info(f"Loading {w} for TensorFlow SavedModel inference...")
-            import tensorflow as tf
-            keras = False  # assume TF1 saved_model
-            model = (
-                tf.keras.models.load_model(w)
-                if keras
-                else tf.saved_model.load(w)
-            )
-        elif (
-            pb
-        ):  # GraphDef https://www.tensorflow.org/guide/migrate#a_graphpb_or_graphpbtxt
-            LOGGER.info(f"Loading {w} for TensorFlow GraphDef inference...")
-            import tensorflow as tf
-            def wrap_frozen_graph(gd, inputs, outputs):
-                x = tf.compat.v1.wrap_function(
-                    lambda: tf.compat.v1.import_graph_def(gd, name=""), []
-                )  # wrapped
-                ge = x.graph.as_graph_element
-                return x.prune(
-                    tf.nest.map_structure(ge, inputs),
-                    tf.nest.map_structure(ge, outputs),
-                )
-            def gd_outputs(gd):
-                name_list, input_list = [], []
-                for (
-                    node
-                ) in gd.node:  # tensorflow.core.framework.node_def_pb2.NodeDef
-                    name_list.append(node.name)
-                    input_list.extend(node.input)
-                return sorted(
-                    f"{x}:0"
-                    for x in list(set(name_list) - set(input_list))
-                    if not x.startswith("NoOp")
-                )
-            gd = tf.Graph().as_graph_def()  # TF GraphDef
-            with open(w, "rb") as f:
-                gd.ParseFromString(f.read())
-            frozen_func = wrap_frozen_graph(
-                gd, inputs="x:0", outputs=gd_outputs(gd)
-            )
-        elif (
-            tflite or edgetpu
-        ):  # https://www.tensorflow.org/lite/guide/python#install_tensorflow_lite_for_python
-            try:  # https://coral.ai/docs/edgetpu/tflite-python/#update-existing-tf-lite-code-for-the-edge-tpu
-                from tflite_runtime.interpreter import Interpreter, load_delegate
-            except ImportError:
-                import tensorflow as tf
-                Interpreter, load_delegate = (
-                    tf.lite.Interpreter,
-                    tf.lite.experimental.load_delegate,
-                )
-            if (
-                edgetpu
-            ):  # TF Edge TPU https://coral.ai/software/#edgetpu-runtime
-                LOGGER.info(
-                    f"Loading {w} for TensorFlow Lite Edge TPU inference..."
-                )
-                delegate = {
-                    "Linux": "libedgetpu.so.1",
-                    "Darwin": "libedgetpu.1.dylib",
-                    "Windows": "edgetpu.dll",
-                }[platform.system()]
-                interpreter = Interpreter(
-                    model_path=w,
-                    experimental_delegates=[load_delegate(delegate)],
-                )
-            else:  # TFLite
-                LOGGER.info(f"Loading {w} for TensorFlow Lite inference...")
-                interpreter = Interpreter(model_path=w)  # load TFLite model
-            interpreter.allocate_tensors()  # allocate
-            input_details = interpreter.get_input_details()  # inputs
-            output_details = interpreter.get_output_details()  # outputs
-            # load metadata
-            with contextlib.suppress(zipfile.BadZipFile):
-                with zipfile.ZipFile(w, "r") as model:
-                    meta_file = model.namelist()[0]
-                    meta = ast.literal_eval(
-                        model.read(meta_file).decode("utf-8")
-                    )
-                    stride, names = int(meta["stride"]), meta["names"]
-        elif tfjs:  # TF.js
-            raise NotImplementedError(
-                "ERROR: YOLOv5 TF.js inference is not supported"
-            )
-        elif paddle:  # PaddlePaddle
-            LOGGER.info(f"Loading {w} for PaddlePaddle inference...")
-            check_requirements("paddlepaddle-gpu" if cuda else "paddlepaddle")
-            import paddle.inference as pdi
-            if not Path(w).is_file():  # if not *.pdmodel
-                w = next(
-                    Path(w).rglob("*.pdmodel")
-                )  # get *.pdmodel file from *_paddle_model dir
-            weights = Path(w).with_suffix(".pdiparams")
-            config = pdi.Config(str(w), str(weights))
-            if cuda:
-                config.enable_use_gpu(
-                    memory_pool_init_size_mb=2048, device_id=0
-                )
-            predictor = pdi.create_predictor(config)
-            input_handle = predictor.get_input_handle(
-                predictor.get_input_names()[0]
-            )
-            output_names = predictor.get_output_names()
-        elif triton:  # NVIDIA Triton Inference Server
-            LOGGER.info(f"Using {w} as Triton Inference Server...")
-            check_requirements("tritonclient[all]")
-            from utils.triton import TritonRemoteModel
-            model = TritonRemoteModel(url=w)
-            nhwc = model.runtime.startswith("tensorflow")
-        else:
-            raise NotImplementedError(f"ERROR: {w} is not a supported format")
-        # class names
-        if "names" not in locals():
-            names = (
-                yaml_load(data)["names"]
-                if data
-                else {i: f"class{i}" for i in range(999)}
-            )
-        if names[0] == "n01440764" and len(names) == 1000:  # ImageNet
-            names = yaml_load(ROOT / "data/ImageNet.yaml")[
-                "names"
-            ]  # human-readable names
-        self.__dict__.update(locals())  # assign all variables to self
-    def forward(self, im, augment=False, visualize=False):
-        # YOLOv5 MultiBackend inference
-        b, ch, h, w = im.shape  # batch, channel, height, width
-        if self.fp16 and im.dtype != torch.float16:
-            im = im.half()  # to FP16
-        if self.nhwc:
-            im = im.permute(
-                0, 2, 3, 1
-            )  # torch BCHW to numpy BHWC shape(1,320,192,3)
-        if self.pt:  # PyTorch
-            y = (
-                self.model(im, augment=augment, visualize=visualize)
-                if augment or visualize
-                else self.model(im)
-            )
-        elif self.jit:  # TorchScript
-            y = self.model(im)
-        elif self.dnn:  # ONNX OpenCV DNN
-            im = im.cpu().numpy()  # torch to numpy
-            self.net.setInput(im)
-            y = self.net.forward()
-        elif self.onnx:  # ONNX Runtime
-            im = im.cpu().numpy()  # torch to numpy
-            y = self.session.run(
-                self.output_names, {self.session.get_inputs()[0].name: im}
-            )
-        elif self.xml:  # OpenVINO
-            im = im.cpu().numpy()  # FP32
-            y = list(self.executable_network([im]).values())
-        elif self.engine:  # TensorRT
-            if self.dynamic and im.shape != self.bindings["images"].shape:
-                i = self.model.get_binding_index("images")
-                self.context.set_binding_shape(
-                    i, im.shape
-                )  # reshape if dynamic
-                self.bindings["images"] = self.bindings["images"]._replace(
-                    shape=im.shape
-                )
-                for name in self.output_names:
-                    i = self.model.get_binding_index(name)
-                    self.bindings[name].data.resize_(
-                        tuple(self.context.get_binding_shape(i))
-                    )
-            s = self.bindings["images"].shape
-            assert (
-                im.shape == s
-            ), f"input size {im.shape} {'>' if self.dynamic else 'not equal to'} max model size {s}"
-            self.binding_addrs["images"] = int(im.data_ptr())
-            self.context.execute_v2(list(self.binding_addrs.values()))
-            y = [self.bindings[x].data for x in sorted(self.output_names)]
-        elif self.coreml:  # CoreML
-            im = im.cpu().numpy()
-            im = Image.fromarray((im[0] * 255).astype("uint8"))
-            # im = im.resize((192, 320), Image.ANTIALIAS)
-            y = self.model.predict(
-                {"image": im}
-            )  # coordinates are xywh normalized
-            if "confidence" in y:
-                box = xywh2xyxy(
-                    y["coordinates"] * [[w, h, w, h]]
-                )  # xyxy pixels
-                conf, cls = y["confidence"].max(1), y["confidence"].argmax(
-                    1
-                ).astype(np.float)
-                y = np.concatenate(
-                    (box, conf.reshape(-1, 1), cls.reshape(-1, 1)), 1
-                )
-            else:
-                y = list(
-                    reversed(y.values())
-                )  # reversed for segmentation models (pred, proto)
-        elif self.paddle:  # PaddlePaddle
-            im = im.cpu().numpy().astype(np.float32)
-            self.input_handle.copy_from_cpu(im)
-            self.predictor.run()
-            y = [
-                self.predictor.get_output_handle(x).copy_to_cpu()
-                for x in self.output_names
-            ]
-        elif self.triton:  # NVIDIA Triton Inference Server
-            y = self.model(im)
-        else:  # TensorFlow (SavedModel, GraphDef, Lite, Edge TPU)
-            im = im.cpu().numpy()
-            if self.saved_model:  # SavedModel
-                y = (
-                    self.model(im, training=False)
-                    if self.keras
-                    else self.model(im)
-                )
-            elif self.pb:  # GraphDef
-                y = self.frozen_func(x=self.tf.constant(im))
-            else:  # Lite or Edge TPU
-                input = self.input_details[0]
-                int8 = (
-                    input["dtype"] == np.uint8
-                )  # is TFLite quantized uint8 model
-                if int8:
-                    scale, zero_point = input["quantization"]
-                    im = (im / scale + zero_point).astype(np.uint8)  # de-scale
-                self.interpreter.set_tensor(input["index"], im)
-                self.interpreter.invoke()
-                y = []
-                for output in self.output_details:
-                    x = self.interpreter.get_tensor(output["index"])
-                    if int8:
-                        scale, zero_point = output["quantization"]
-                        x = (
-                            x.astype(np.float32) - zero_point
-                        ) * scale  # re-scale
-                    y.append(x)
-            y = [x if isinstance(x, np.ndarray) else x.numpy() for x in y]
-            y[0][..., :4] *= [w, h, w, h]  # xywh normalized to pixels
-        if isinstance(y, (list, tuple)):
-            return (
-                self.from_numpy(y[0])
-                if len(y) == 1
-                else [self.from_numpy(x) for x in y]
-            )
-        else:
-            return self.from_numpy(y)
-    def from_numpy(self, x):
-        return (
-            torch.from_numpy(x).to(self.device)
-            if isinstance(x, np.ndarray)
-            else x
-        )
-    def warmup(self, imgsz=(1, 3, 640, 640)):
-        # Warmup model by running inference once
-        warmup_types = (
-            self.pt,
-            self.jit,
-            self.onnx,
-            self.engine,
-            self.saved_model,
-            self.pb,
-            self.triton,
-        )
-        if any(warmup_types) and (self.device.type != "cpu" or self.triton):
-            im = torch.empty(
-                *imgsz,
-                dtype=torch.half if self.fp16 else torch.float,
-                device=self.device,
-            )  # input
-            for _ in range(2 if self.jit else 1):  #
-                self.forward(im)  # warmup
-    @staticmethod
-    def _model_type(p="path/to/model.pt"):
-        # Return model type from model path, i.e. path='path/to/model.onnx' -> type=onnx
-        # types = [pt, jit, onnx, xml, engine, coreml, saved_model, pb, tflite, edgetpu, tfjs, paddle]
-        from export import export_formats
-        from utils.downloads import is_url
-        sf = list(export_formats().Suffix)  # export suffixes
-        if not is_url(p, check=False):
-            check_suffix(p, sf)  # checks
-        url = urlparse(p)  # if url may be Triton inference server
-        types = [s in Path(p).name for s in sf]
-        types[8] &= not types[9]  # tflite &= not edgetpu
-        triton = not any(types) and all(
-            [any(s in url.scheme for s in ["http", "grpc"]), url.netloc]
-        )
-        return types + [triton]
-    @staticmethod
-    def _load_metadata(f=Path("path/to/meta.yaml")):
-        # Load metadata from meta.yaml if it exists
-        if f.exists():
-            d = yaml_load(f)
-            return d["stride"], d["names"]  # assign stride, names
-        return None, None
-class AutoShape(nn.Module):
-    # YOLOv5 input-robust model wrapper for passing cv2/np/PIL/torch inputs. Includes preprocessing, inference and NMS
-    conf = 0.25  # NMS confidence threshold
-    iou = 0.45  # NMS IoU threshold
-    agnostic = False  # NMS class-agnostic
-    multi_label = False  # NMS multiple labels per box
-    classes = None  # (optional list) filter by class, i.e. = [0, 15, 16] for COCO persons, cats and dogs
-    max_det = 1000  # maximum number of detections per image
-    amp = False  # Automatic Mixed Precision (AMP) inference
-    def __init__(self, model, verbose=True):
-        super().__init__()
-        if verbose:
-            LOGGER.info("Adding AutoShape... ")
-        copy_attr(
-            self,
-            model,
-            include=("yaml", "nc", "hyp", "names", "stride", "abc"),
-            exclude=(),
-        )  # copy attributes
-        self.dmb = isinstance(
-            model, DetectMultiBackend
-        )  # DetectMultiBackend() instance
-        self.pt = not self.dmb or model.pt  # PyTorch model
-        self.model = model.eval()
-        if self.pt:
-            m = (
-                self.model.model.model[-1]
-                if self.dmb
-                else self.model.model[-1]
-            )  # Detect()
-            m.inplace = (
-                False  # Detect.inplace=False for safe multithread inference
-            )
-            m.export = True  # do not output loss values
-    def _apply(self, fn):
-        # Apply to(), cpu(), cuda(), half() to model tensors that are not parameters or registered buffers
-        self = super()._apply(fn)
-        if self.pt:
-            m = (
-                self.model.model.model[-1]
-                if self.dmb
-                else self.model.model[-1]
-            )  # Detect()
-            m.stride = fn(m.stride)
-            m.grid = list(map(fn, m.grid))
-            if isinstance(m.anchor_grid, list):
-                m.anchor_grid = list(map(fn, m.anchor_grid))
-        return self
-    @smart_inference_mode()
-    def forward(self, ims, size=640, augment=False, profile=False):
-        # Inference from various sources. For size(height=640, width=1280), RGB images example inputs are:
-        #   file:        ims = 'data/images/zidane.jpg'  # str or PosixPath
-        #   URI:             = 'https://ultralytics.com/images/zidane.jpg'
-        #   OpenCV:          = cv2.imread('image.jpg')[:,:,::-1]  # HWC BGR to RGB x(640,1280,3)
-        #   PIL:             = Image.open('image.jpg') or ImageGrab.grab()  # HWC x(640,1280,3)
-        #   numpy:           = np.zeros((640,1280,3))  # HWC
-        #   torch:           = torch.zeros(16,3,320,640)  # BCHW (scaled to size=640, 0-1 values)
-        #   multiple:        = [Image.open('image1.jpg'), Image.open('image2.jpg'), ...]  # list of images
-        dt = (Profile(), Profile(), Profile())
-        with dt[0]:
-            if isinstance(size, int):  # expand
-                size = (size, size)
-            p = (
-                next(self.model.parameters())
-                if self.pt
-                else torch.empty(1, device=self.model.device)
-            )  # param
-            autocast = self.amp and (
-                p.device.type != "cpu"
-            )  # Automatic Mixed Precision (AMP) inference
-            if isinstance(ims, torch.Tensor):  # torch
-                with amp.autocast(autocast):
-                    return self.model(
-                        ims.to(p.device).type_as(p), augment=augment
-                    )  # inference
-            # Pre-process
-            n, ims = (
-                (len(ims), list(ims))
-                if isinstance(ims, (list, tuple))
-                else (1, [ims])
-            )  # number, list of images
-            shape0, shape1, files = (
-                [],
-                [],
-                [],
-            )  # image and inference shapes, filenames
-            for i, im in enumerate(ims):
-                f = f"image{i}"  # filename
-                if isinstance(im, (str, Path)):  # filename or uri
-                    im, f = (
-                        Image.open(
-                            requests.get(im, stream=True).raw
-                            if str(im).startswith("http")
-                            else im
-                        ),
-                        im,
-                    )
-                    im = np.asarray(exif_transpose(im))
-                elif isinstance(im, Image.Image):  # PIL Image
-                    im, f = (
-                        np.asarray(exif_transpose(im)),
-                        getattr(im, "filename", f) or f,
-                    )
-                files.append(Path(f).with_suffix(".jpg").name)
-                if im.shape[0] < 5:  # image in CHW
-                    im = im.transpose(
-                        (1, 2, 0)
-                    )  # reverse dataloader .transpose(2, 0, 1)
-                im = (
-                    im[..., :3]
-                    if im.ndim == 3
-                    else cv2.cvtColor(im, cv2.COLOR_GRAY2BGR)
-                )  # enforce 3ch input
-                s = im.shape[:2]  # HWC
-                shape0.append(s)  # image shape
-                g = max(size) / max(s)  # gain
-                shape1.append([int(y * g) for y in s])
-                ims[i] = (
-                    im if im.data.contiguous else np.ascontiguousarray(im)
-                )  # update
-            shape1 = [
-                make_divisible(x, self.stride) for x in np.array(shape1).max(0)
-            ]  # inf shape
-            x = [letterbox(im, shape1, auto=False)[0] for im in ims]  # pad
-            x = np.ascontiguousarray(
-                np.array(x).transpose((0, 3, 1, 2))
-            )  # stack and BHWC to BCHW
-            x = (
-                torch.from_numpy(x).to(p.device).type_as(p) / 255
-            )  # uint8 to fp16/32
-        with amp.autocast(autocast):
-            # Inference
-            with dt[1]:
-                y = self.model(x, augment=augment)  # forward
-            # Post-process
-            with dt[2]:
-                y = non_max_suppression(
-                    y if self.dmb else y[0],
-                    self.conf,
-                    self.iou,
-                    self.classes,
-                    self.agnostic,
-                    self.multi_label,
-                    max_det=self.max_det,
-                )  # NMS
-                for i in range(n):
-                    scale_boxes(shape1, y[i][:, :4], shape0[i])
-            return Detections(ims, y, files, dt, self.names, x.shape)
-class Detections:
-    # YOLOv5 detections class for inference results
-    def __init__(
-        self, ims, pred, files, times=(0, 0, 0), names=None, shape=None
-    ):
-        super().__init__()
-        d = pred[0].device  # device
-        gn = [
-            torch.tensor(
-                [*(im.shape[i] for i in [1, 0, 1, 0]), 1, 1], device=d
-            )
-            for im in ims
-        ]  # normalizations
-        self.ims = ims  # list of images as numpy arrays
-        self.pred = pred  # list of tensors pred[0] = (xyxy, conf, cls)
-        self.names = names  # class names
-        self.files = files  # image filenames
-        self.times = times  # profiling times
-        self.xyxy = pred  # xyxy pixels
-        self.xywh = [xyxy2xywh(x) for x in pred]  # xywh pixels
-        self.xyxyn = [x / g for x, g in zip(self.xyxy, gn)]  # xyxy normalized
-        self.xywhn = [x / g for x, g in zip(self.xywh, gn)]  # xywh normalized
-        self.n = len(self.pred)  # number of images (batch size)
-        self.t = tuple(x.t / self.n * 1e3 for x in times)  # timestamps (ms)
-        self.s = tuple(shape)  # inference BCHW shape
-    def _run(
-        self,
-        pprint=False,
-        show=False,
-        save=False,
-        crop=False,
-        render=False,
-        labels=True,
-        save_dir=Path(""),
-    ):
-        s, crops = "", []
-        for i, (im, pred) in enumerate(zip(self.ims, self.pred)):
-            s += f"\nimage {i + 1}/{len(self.pred)}: {im.shape[0]}x{im.shape[1]} "  # string
-            if pred.shape[0]:
-                for c in pred[:, -1].unique():
-                    n = (pred[:, -1] == c).sum()  # detections per class
-                    s += f"{n} {self.names[int(c)]}{'s' * (n > 1)}, "  # add to string
-                s = s.rstrip(", ")
-                if show or save or render or crop:
-                    annotator = Annotator(im, example=str(self.names))
-                    for *box, conf, cls in reversed(
-                        pred
-                    ):  # xyxy, confidence, class
-                        label = f"{self.names[int(cls)]} {conf:.2f}"
-                        if crop:
-                            file = (
-                                save_dir
-                                / "crops"
-                                / self.names[int(cls)]
-                                / self.files[i]
-                                if save
-                                else None
-                            )
-                            crops.append(
-                                {
-                                    "box": box,
-                                    "conf": conf,
-                                    "cls": cls,
-                                    "label": label,
-                                    "im": save_one_box(
-                                        box, im, file=file, save=save
-                                    ),
-                                }
-                            )
-                        else:  # all others
-                            annotator.box_label(
-                                box, label if labels else "", color=colors(cls)
-                            )
-                    im = annotator.im
-            else:
-                s += "(no detections)"
-            im = (
-                Image.fromarray(im.astype(np.uint8))
-                if isinstance(im, np.ndarray)
-                else im
-            )  # from np
-            if show:
-                display(im) if is_notebook() else im.show(self.files[i])
-            if save:
-                f = self.files[i]
-                im.save(save_dir / f)  # save
-                if i == self.n - 1:
-                    LOGGER.info(
-                        f"Saved {self.n} image{'s' * (self.n > 1)} to {colorstr('bold', save_dir)}"
-                    )
-            if render:
-                self.ims[i] = np.asarray(im)
-        if pprint:
-            s = s.lstrip("\n")
-            return (
-                f"{s}\nSpeed: %.1fms pre-process, %.1fms inference, %.1fms NMS per image at shape {self.s}"
-                % self.t
-            )
-        if crop:
-            if save:
-                LOGGER.info(f"Saved results to {save_dir}\n")
-            return crops
-    @TryExcept("Showing images is not supported in this environment")
-    def show(self, labels=True):
-        self._run(show=True, labels=labels)  # show results
-    def save(self, labels=True, save_dir="runs/detect/exp", exist_ok=False):
-        save_dir = increment_path(
-            save_dir, exist_ok, mkdir=True
-        )  # increment save_dir
-        self._run(save=True, labels=labels, save_dir=save_dir)  # save results
-    def crop(self, save=True, save_dir="runs/detect/exp", exist_ok=False):
-        save_dir = (
-            increment_path(save_dir, exist_ok, mkdir=True) if save else None
-        )
-        return self._run(
-            crop=True, save=save, save_dir=save_dir
-        )  # crop results
-    def render(self, labels=True):
-        self._run(render=True, labels=labels)  # render results
-        return self.ims
-    def pandas(self):
-        # return detections as pandas DataFrames, i.e. print(results.pandas().xyxy[0])
-        new = copy(self)  # return copy
-        ca = (
-            "xmin",
-            "ymin",
-            "xmax",
-            "ymax",
-            "confidence",
-            "class",
-            "name",
-        )  # xyxy columns
-        cb = (
-            "xcenter",
-            "ycenter",
-            "width",
-            "height",
-            "confidence",
-            "class",
-            "name",
-        )  # xywh columns
-        for k, c in zip(["xyxy", "xyxyn", "xywh", "xywhn"], [ca, ca, cb, cb]):
-            a = [
-                [
-                    x[:5] + [int(x[5]), self.names[int(x[5])]]
-                    for x in x.tolist()
-                ]
-                for x in getattr(self, k)
-            ]  # update
-            setattr(new, k, [pd.DataFrame(x, columns=c) for x in a])
-        return new
-    def tolist(self):
-        # return a list of Detections objects, i.e. 'for result in results.tolist():'
-        r = range(self.n)  # iterable
-        x = [
-            Detections(
-                [self.ims[i]],
-                [self.pred[i]],
-                [self.files[i]],
-                self.times,
-                self.names,
-                self.s,
-            )
-            for i in r
-        ]
-        # for d in x:
-        #    for k in ['ims', 'pred', 'xyxy', 'xyxyn', 'xywh', 'xywhn']:
-        #        setattr(d, k, getattr(d, k)[0])  # pop out of list
-        return x
-    def print(self):
-        LOGGER.info(self.__str__())
-    def __len__(self):  # override len(results)
-        return self.n
-    def __str__(self):  # override print(results)
-        return self._run(pprint=True)  # print results
-    def __repr__(self):
-        return f"YOLOv5 {self.__class__} instance\n" + self.__str__()
-class Proto(nn.Module):
-    # YOLOv5 mask Proto module for segmentation models
-    def __init__(
-        self, c1, c_=256, c2=32
-    ):  # ch_in, number of protos, number of masks
-        super().__init__()
-        self.cv1 = Conv(c1, c_, k=3)
-        self.upsample = nn.Upsample(scale_factor=2, mode="nearest")
-        self.cv2 = Conv(c_, c_, k=3)
-        self.cv3 = Conv(c_, c2)
-    def forward(self, x):
-        return self.cv3(self.cv2(self.upsample(self.cv1(x))))
-class Classify(nn.Module):
-    # YOLOv5 classification head, i.e. x(b,c1,20,20) to x(b,c2)
-    def __init__(
-        self, c1, c2, k=1, s=1, p=None, g=1
-    ):  # ch_in, ch_out, kernel, stride, padding, groups
-        super().__init__()
-        c_ = 1280  # efficientnet_b0 size
-        self.conv = Conv(c1, c_, k, s, autopad(k, p), g)
-        self.pool = nn.AdaptiveAvgPool2d(1)  # to x(b,c_,1,1)
-        self.drop = nn.Dropout(p=0.0, inplace=True)
-        self.linear = nn.Linear(c_, c2)  # to x(b,c2)
-    def forward(self, x):
-        if isinstance(x, list):
-            x = torch.cat(x, 1)
-        return self.linear(self.drop(self.pool(self.conv(x)).flatten(1)))

spaces/Abhilashvj/planogram-compliance/utils/flask_rest_api/restapi.py DELETED Viewed

@@ -1,61 +0,0 @@
-# YOLOv5 🚀 by Ultralytics, GPL-3.0 license
-"""
-Run a Flask REST API exposing one or more YOLOv5s models
-"""
-import argparse
-import io
-import torch
-from flask import Flask, request
-from PIL import Image
-app = Flask(__name__)
-models = {}
-DETECTION_URL = "/v1/object-detection/<model>"
-@app.route(DETECTION_URL, methods=["POST"])
-def predict(model):
-    if request.method != "POST":
-        return
-    if request.files.get("image"):
-        # Method 1
-        # with request.files["image"] as f:
-        #     im = Image.open(io.BytesIO(f.read()))
-        # Method 2
-        im_file = request.files["image"]
-        im_bytes = im_file.read()
-        im = Image.open(io.BytesIO(im_bytes))
-        if model in models:
-            results = models[model](
-                im, size=640
-            )  # reduce size=320 for faster inference
-            return results.pandas().xyxy[0].to_json(orient="records")
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(
-        description="Flask API exposing YOLOv5 model"
-    )
-    parser.add_argument("--port", default=5000, type=int, help="port number")
-    parser.add_argument(
-        "--model",
-        nargs="+",
-        default=["yolov5s"],
-        help="model(s) to run, i.e. --model yolov5n yolov5s",
-    )
-    opt = parser.parse_args()
-    for m in opt.model:
-        models[m] = torch.hub.load(
-            "ultralytics/yolov5", m, force_reload=True, skip_validation=True
-        )
-    app.run(
-        host="0.0.0.0", port=opt.port
-    )  # debug=True causes Restarting with stat

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/docs/source/en/api/schedulers/overview.md DELETED Viewed

@@ -1,92 +0,0 @@
-<!--Copyright 2023 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.
--->
-# Schedulers
-Diffusers contains multiple pre-built schedule functions for the diffusion process.
-## What is a scheduler?
-The schedule functions, denoted *Schedulers* in the library take in the output of a trained model, a sample which the diffusion process is iterating on, and a timestep to return a denoised sample. That's why schedulers may also be called *Samplers* in other diffusion models implementations.
-- Schedulers define the methodology for iteratively adding noise to an image or for updating a sample based on model outputs.
-    - adding noise in different manners represent the algorithmic processes to train a diffusion model by adding noise to images.
-    - for inference, the scheduler defines how to update a sample based on an output from a pretrained model.
-- Schedulers are often defined by a *noise schedule* and an *update rule* to solve the differential equation solution.
-### Discrete versus continuous schedulers
-All schedulers take in a timestep to predict the updated version of the sample being diffused.
-The timesteps dictate where in the diffusion process the step is, where data is generated by iterating forward in time and inference is executed by propagating backwards through timesteps.
-Different algorithms use timesteps that can be discrete (accepting `int` inputs), such as the [`DDPMScheduler`] or [`PNDMScheduler`], or continuous (accepting `float` inputs), such as the score-based schedulers [`ScoreSdeVeScheduler`] or [`ScoreSdeVpScheduler`].
-## Designing Re-usable schedulers
-The core design principle between the schedule functions is to be model, system, and framework independent.
-This allows for rapid experimentation and cleaner abstractions in the code, where the model prediction is separated from the sample update.
-To this end, the design of schedulers is such that:
-- Schedulers can be used interchangeably between diffusion models in inference to find the preferred trade-off between speed and generation quality.
-- Schedulers are currently by default in PyTorch, but are designed to be framework independent (partial Jax support currently exists).
-- Many diffusion pipelines, such as [`StableDiffusionPipeline`] and [`DiTPipeline`] can use any of [`KarrasDiffusionSchedulers`]
-## Schedulers Summary
-The following table summarizes all officially supported schedulers, their corresponding paper
-| Scheduler | Paper |
-|---|---|
-| [ddim](./ddim) | [**Denoising Diffusion Implicit Models**](https://arxiv.org/abs/2010.02502) |
-| [ddim_inverse](./ddim_inverse) | [**Denoising Diffusion Implicit Models**](https://arxiv.org/abs/2010.02502) |
-| [ddpm](./ddpm) | [**Denoising Diffusion Probabilistic Models**](https://arxiv.org/abs/2006.11239) |
-| [deis](./deis) | [**DEISMultistepScheduler**](https://arxiv.org/abs/2204.13902) |
-| [singlestep_dpm_solver](./singlestep_dpm_solver) | [**Singlestep DPM-Solver**](https://arxiv.org/abs/2206.00927) |
-| [multistep_dpm_solver](./multistep_dpm_solver) | [**Multistep DPM-Solver**](https://arxiv.org/abs/2206.00927) |
-| [heun](./heun) | [**Heun scheduler inspired by Karras et. al paper**](https://arxiv.org/abs/2206.00364) |
-| [dpm_discrete](./dpm_discrete) | [**DPM Discrete Scheduler inspired by Karras et. al paper**](https://arxiv.org/abs/2206.00364) |
-| [dpm_discrete_ancestral](./dpm_discrete_ancestral) | [**DPM Discrete Scheduler with ancestral sampling inspired by Karras et. al paper**](https://arxiv.org/abs/2206.00364) |
-| [stochastic_karras_ve](./stochastic_karras_ve) | [**Variance exploding, stochastic sampling from Karras et. al**](https://arxiv.org/abs/2206.00364) |
-| [lms_discrete](./lms_discrete) | [**Linear multistep scheduler for discrete beta schedules**](https://arxiv.org/abs/2206.00364) |
-| [pndm](./pndm) | [**Pseudo numerical methods for diffusion models (PNDM)**](https://github.com/crowsonkb/k-diffusion/blob/481677d114f6ea445aa009cf5bd7a9cdee909e47/k_diffusion/sampling.py#L181) |
-| [score_sde_ve](./score_sde_ve) | [**variance exploding stochastic differential equation (VE-SDE) scheduler**](https://arxiv.org/abs/2011.13456) |
-| [ipndm](./ipndm) | [**improved pseudo numerical methods for diffusion models (iPNDM)**](https://github.com/crowsonkb/v-diffusion-pytorch/blob/987f8985e38208345c1959b0ea767a625831cc9b/diffusion/sampling.py#L296) |
-| [score_sde_vp](./score_sde_vp) | [**Variance preserving stochastic differential equation (VP-SDE) scheduler**](https://arxiv.org/abs/2011.13456) |
-| [euler](./euler) | [**Euler scheduler**](https://arxiv.org/abs/2206.00364) |
-| [euler_ancestral](./euler_ancestral) | [**Euler Ancestral scheduler**](https://github.com/crowsonkb/k-diffusion/blob/481677d114f6ea445aa009cf5bd7a9cdee909e47/k_diffusion/sampling.py#L72) |
-| [vq_diffusion](./vq_diffusion) | [**VQDiffusionScheduler**](https://arxiv.org/abs/2111.14822) |
-| [unipc](./unipc) | [**UniPCMultistepScheduler**](https://arxiv.org/abs/2302.04867) |
-| [repaint](./repaint) | [**RePaint scheduler**](https://arxiv.org/abs/2201.09865) |
-## API
-The core API for any new scheduler must follow a limited structure.
-- Schedulers should provide one or more `def step(...)` functions that should be called to update the generated sample iteratively.
-- Schedulers should provide a `set_timesteps(...)` method that configures the parameters of a schedule function for a specific inference task.
-- Schedulers should be framework-specific.
-The base class [`SchedulerMixin`] implements low level utilities used by multiple schedulers.
-### SchedulerMixin
-[[autodoc]] SchedulerMixin
-### SchedulerOutput
-The class [`SchedulerOutput`] contains the outputs from any schedulers `step(...)` call.
-[[autodoc]] schedulers.scheduling_utils.SchedulerOutput
-### KarrasDiffusionSchedulers
-`KarrasDiffusionSchedulers` encompasses the main generalization of schedulers in Diffusers. The schedulers in this class are distinguished, at a high level, by their noise sampling strategy; the type of network and scaling; and finally the training strategy or how the loss is weighed.
-The different schedulers, depending on the type of ODE solver, fall into the above taxonomy and provide a good abstraction for the design of the main schedulers implemented in Diffusers. The schedulers in this class are given below:
-[[autodoc]] schedulers.scheduling_utils.KarrasDiffusionSchedulers

spaces/Andy1621/uniformer_image_detection/configs/_base_/models/faster_rcnn_r50_caffe_c4.py DELETED Viewed

@@ -1,112 +0,0 @@
-# model settings
-norm_cfg = dict(type='BN', requires_grad=False)
-model = dict(
-    type='FasterRCNN',
-    pretrained='open-mmlab://detectron2/resnet50_caffe',
-    backbone=dict(
-        type='ResNet',
-        depth=50,
-        num_stages=3,
-        strides=(1, 2, 2),
-        dilations=(1, 1, 1),
-        out_indices=(2, ),
-        frozen_stages=1,
-        norm_cfg=norm_cfg,
-        norm_eval=True,
-        style='caffe'),
-    rpn_head=dict(
-        type='RPNHead',
-        in_channels=1024,
-        feat_channels=1024,
-        anchor_generator=dict(
-            type='AnchorGenerator',
-            scales=[2, 4, 8, 16, 32],
-            ratios=[0.5, 1.0, 2.0],
-            strides=[16]),
-        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',
-        shared_head=dict(
-            type='ResLayer',
-            depth=50,
-            stage=3,
-            stride=2,
-            dilation=1,
-            style='caffe',
-            norm_cfg=norm_cfg,
-            norm_eval=True),
-        bbox_roi_extractor=dict(
-            type='SingleRoIExtractor',
-            roi_layer=dict(type='RoIAlign', output_size=14, sampling_ratio=0),
-            out_channels=1024,
-            featmap_strides=[16]),
-        bbox_head=dict(
-            type='BBoxHead',
-            with_avg_pool=True,
-            roi_feat_size=7,
-            in_channels=2048,
-            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))),
-    # 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=0,
-            pos_weight=-1,
-            debug=False),
-        rpn_proposal=dict(
-            nms_pre=12000,
-            max_per_img=2000,
-            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=False,
-                ignore_iof_thr=-1),
-            sampler=dict(
-                type='RandomSampler',
-                num=512,
-                pos_fraction=0.25,
-                neg_pos_ub=-1,
-                add_gt_as_proposals=True),
-            pos_weight=-1,
-            debug=False)),
-    test_cfg=dict(
-        rpn=dict(
-            nms_pre=6000,
-            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)))

spaces/AnishKumbhar/ChatBot/text-generation-webui-main/extensions/superboogav2/data_processor.py DELETED Viewed

@@ -1,209 +0,0 @@
-"""
-This module is responsible for processing the corpus and feeding it into chromaDB. It will receive a corpus of text.
-It will then split it into chunks of specified length. For each of those chunks, it will append surrounding context.
-It will only include full words.
-"""
-import re
-import bisect
-import extensions.superboogav2.parameters as parameters
-from .data_preprocessor import TextPreprocessorBuilder, TextSummarizer
-from .chromadb import ChromaCollector
-def preprocess_text_no_summary(text) -> str:
-    builder = TextPreprocessorBuilder(text)
-    if parameters.should_to_lower():
-        builder.to_lower()
-    if parameters.should_remove_punctuation():
-        builder.remove_punctuation()
-    if parameters.should_remove_specific_pos():
-        builder.remove_specific_pos()
-    if parameters.should_remove_stopwords():
-        builder.remove_stopwords
-    if parameters.should_lemmatize():
-        builder.lemmatize()
-    if parameters.should_merge_spaces():
-        builder.merge_spaces
-    if parameters.should_strip():
-        builder.strip()
-    if parameters.get_num_conversion_strategy():
-        if parameters.get_num_conversion_strategy() == parameters.NUM_TO_WORD_METHOD:
-            builder.num_to_word(parameters.get_min_num_length())
-        elif parameters.get_num_conversion_strategy() == parameters.NUM_TO_CHAR_METHOD:
-            builder.num_to_char(parameters.get_min_num_length())
-        elif parameters.get_num_conversion_strategy() == parameters.NUM_TO_CHAR_LONG_METHOD:
-            builder.num_to_char_long(parameters.get_min_num_length())
-    return builder.build()
-def preprocess_text(text) -> list[str]:
-    important_sentences = TextSummarizer.process_long_text(text, parameters.get_min_num_sentences())
-    return [preprocess_text_no_summary(sent) for sent in important_sentences]
-def _create_chunks_with_context(corpus, chunk_len, context_left, context_right):
-    """
-    This function takes a corpus of text and splits it into chunks of a specified length,
-    then adds a specified amount of context to each chunk. The context is added by first
-    going backwards from the start of the chunk and then going forwards from the end of the
-    chunk, ensuring that the context includes only whole words and that the total context length
-    does not exceed the specified limit. This function uses binary search for efficiency.
-    Returns:
-    chunks (list of str): The chunks of text.
-    chunks_with_context (list of str): The chunks of text with added context.
-    chunk_with_context_start_indices (list of int): The starting indices of each chunk with context in the corpus.
-    """
-    words = re.split('(\\s+)', corpus)
-    word_start_indices = [0]
-    current_index = 0
-    for word in words:
-        current_index += len(word)
-        word_start_indices.append(current_index)
-    chunks, chunk_lengths, chunk_start_indices, chunk_with_context_start_indices = [], [], [], []
-    current_length = 0
-    current_index = 0
-    chunk = []
-    for word in words:
-        if current_length + len(word) > chunk_len:
-            chunks.append(''.join(chunk))
-            chunk_lengths.append(current_length)
-            chunk_start_indices.append(current_index - current_length)
-            chunk = [word]
-            current_length = len(word)
-        else:
-            chunk.append(word)
-            current_length += len(word)
-        current_index += len(word)
-    if chunk:
-        chunks.append(''.join(chunk))
-        chunk_lengths.append(current_length)
-        chunk_start_indices.append(current_index - current_length)
-    chunks_with_context = []
-    for start_index, chunk_length in zip(chunk_start_indices, chunk_lengths):
-        context_start_index = bisect.bisect_right(word_start_indices, start_index - context_left)
-        context_end_index = bisect.bisect_left(word_start_indices, start_index + chunk_length + context_right)
-        # Combine all the words in the context range (before, chunk, and after)
-        chunk_with_context = ''.join(words[context_start_index:context_end_index])
-        chunks_with_context.append(chunk_with_context)
-        # Determine the start index of the chunk with context
-        chunk_with_context_start_index = word_start_indices[context_start_index]
-        chunk_with_context_start_indices.append(chunk_with_context_start_index)
-    return chunks, chunks_with_context, chunk_with_context_start_indices
-def _clear_chunks(data_chunks, data_chunks_with_context, data_chunk_starting_indices):
-    distinct_data_chunks = []
-    distinct_data_chunks_with_context = []
-    distinct_data_chunk_starting_indices = []
-    seen_chunks = dict()
-    for chunk, context, index in zip(data_chunks, data_chunks_with_context, data_chunk_starting_indices):
-        # Skip the chunk if it does not contain any alphanumeric characters
-        if not any(char.isalnum() for char in chunk):
-            continue
-        seen_chunk_start = seen_chunks.get(chunk)
-        if seen_chunk_start:
-            # If we've already seen this exact chunk, and the context around it it very close to the seen chunk, then skip it.
-            if abs(seen_chunk_start-index) < parameters.get_delta_start():
-                continue
-        distinct_data_chunks.append(chunk)
-        distinct_data_chunks_with_context.append(context)
-        distinct_data_chunk_starting_indices.append(index)
-        seen_chunks[chunk] = index
-    return distinct_data_chunks, distinct_data_chunks_with_context, distinct_data_chunk_starting_indices
-def process_and_add_to_collector(corpus: str, collector: ChromaCollector, clear_collector_before_adding: bool, metadata: dict):
-    # Defining variables
-    chunk_lens = [int(len.strip()) for len in parameters.get_chunk_len().split(',')]
-    context_len = [int(len.strip()) for len in parameters.get_context_len().split(',')]
-    if len(context_len) >= 3:
-        raise f"Context len has too many values: {len(context_len)}"
-    if len(context_len) == 2:
-        context_left = context_len[0]
-        context_right = context_len[1]
-    else:
-        context_left = context_right = context_len[0]
-    data_chunks = []
-    data_chunks_with_context = []
-    data_chunk_starting_indices = []
-    # Handling chunk_regex
-    if parameters.get_chunk_regex():
-        if parameters.get_chunk_separator():
-            cumulative_length = 0  # This variable will store the length of the processed corpus
-            sections = corpus.split(parameters.get_chunk_separator())
-            for section in sections:
-                special_chunks = list(re.finditer(parameters.get_chunk_regex(), section))
-                for match in special_chunks:
-                    chunk = match.group(0)
-                    start_index = match.start()
-                    end_index = start_index + len(chunk)
-                    context = section[max(0, start_index - context_left):min(len(section), end_index + context_right)]
-                    data_chunks.append(chunk)
-                    data_chunks_with_context.append(context)
-                    data_chunk_starting_indices.append(cumulative_length + max(0, start_index - context_left))
-                cumulative_length += len(section) + len(parameters.get_chunk_separator())  # Update the length of the processed corpus
-        else:
-            special_chunks = list(re.finditer(parameters.get_chunk_regex(), corpus))
-            for match in special_chunks:
-                chunk = match.group(0)
-                start_index = match.start()
-                end_index = start_index + len(chunk)
-                context = corpus[max(0, start_index - context_left):min(len(corpus), end_index + context_right)]
-                data_chunks.append(chunk)
-                data_chunks_with_context.append(context)
-                data_chunk_starting_indices.append(max(0, start_index - context_left))
-    for chunk_len in chunk_lens:
-        # Breaking the data into chunks and adding those to the db
-        if parameters.get_chunk_separator():
-            cumulative_length = 0  # This variable will store the length of the processed corpus
-            sections = corpus.split(parameters.get_chunk_separator())
-            for section in sections:
-                chunks, chunks_with_context, context_start_indices = _create_chunks_with_context(section, chunk_len, context_left, context_right)
-                context_start_indices = [cumulative_length + i for i in context_start_indices]  # Add the length of the processed corpus to each start index
-                data_chunks.extend(chunks)
-                data_chunks_with_context.extend(chunks_with_context)
-                data_chunk_starting_indices.extend(context_start_indices)
-                cumulative_length += len(section) + len(parameters.get_chunk_separator())  # Update the length of the processed corpus
-        else:
-            chunks, chunks_with_context, context_start_indices = _create_chunks_with_context(corpus, chunk_len, context_left, context_right)
-            data_chunks.extend(chunks)
-            data_chunks_with_context.extend(chunks_with_context)
-            data_chunk_starting_indices.extend(context_start_indices)
-    data_chunks = [preprocess_text_no_summary(chunk) for chunk in data_chunks]
-    data_chunks, data_chunks_with_context, data_chunk_starting_indices = _clear_chunks(
-        data_chunks, data_chunks_with_context, data_chunk_starting_indices
-    )
-    if clear_collector_before_adding:
-        collector.clear()
-    collector.add(data_chunks, data_chunks_with_context, data_chunk_starting_indices, [metadata]*len(data_chunks) if metadata is not None else None)

spaces/Archan/ArXivAudio/README.md DELETED Viewed

@@ -1,13 +0,0 @@
----
-title: ArXiv Audio
-emoji: 🖨️
-colorFrom: cyan
-colorTo: red
-sdk: streamlit
-sdk_version: 1.10.0
-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/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_internal/utils/filesystem.py DELETED Viewed

@@ -1,153 +0,0 @@
-import fnmatch
-import os
-import os.path
-import random
-import sys
-from contextlib import contextmanager
-from tempfile import NamedTemporaryFile
-from typing import Any, BinaryIO, Generator, List, Union, cast
-from pip._vendor.tenacity import retry, stop_after_delay, wait_fixed
-from pip._internal.utils.compat import get_path_uid
-from pip._internal.utils.misc import format_size
-def check_path_owner(path: str) -> bool:
-    # If we don't have a way to check the effective uid of this process, then
-    # we'll just assume that we own the directory.
-    if sys.platform == "win32" or not hasattr(os, "geteuid"):
-        return True
-    assert os.path.isabs(path)
-    previous = None
-    while path != previous:
-        if os.path.lexists(path):
-            # Check if path is writable by current user.
-            if os.geteuid() == 0:
-                # Special handling for root user in order to handle properly
-                # cases where users use sudo without -H flag.
-                try:
-                    path_uid = get_path_uid(path)
-                except OSError:
-                    return False
-                return path_uid == 0
-            else:
-                return os.access(path, os.W_OK)
-        else:
-            previous, path = path, os.path.dirname(path)
-    return False  # assume we don't own the path
-@contextmanager
-def adjacent_tmp_file(path: str, **kwargs: Any) -> Generator[BinaryIO, None, None]:
-    """Return a file-like object pointing to a tmp file next to path.
-    The file is created securely and is ensured to be written to disk
-    after the context reaches its end.
-    kwargs will be passed to tempfile.NamedTemporaryFile to control
-    the way the temporary file will be opened.
-    """
-    with NamedTemporaryFile(
-        delete=False,
-        dir=os.path.dirname(path),
-        prefix=os.path.basename(path),
-        suffix=".tmp",
-        **kwargs,
-    ) as f:
-        result = cast(BinaryIO, f)
-        try:
-            yield result
-        finally:
-            result.flush()
-            os.fsync(result.fileno())
-# Tenacity raises RetryError by default, explicitly raise the original exception
-_replace_retry = retry(reraise=True, stop=stop_after_delay(1), wait=wait_fixed(0.25))
-replace = _replace_retry(os.replace)
-# test_writable_dir and _test_writable_dir_win are copied from Flit,
-# with the author's agreement to also place them under pip's license.
-def test_writable_dir(path: str) -> bool:
-    """Check if a directory is writable.
-    Uses os.access() on POSIX, tries creating files on Windows.
-    """
-    # If the directory doesn't exist, find the closest parent that does.
-    while not os.path.isdir(path):
-        parent = os.path.dirname(path)
-        if parent == path:
-            break  # Should never get here, but infinite loops are bad
-        path = parent
-    if os.name == "posix":
-        return os.access(path, os.W_OK)
-    return _test_writable_dir_win(path)
-def _test_writable_dir_win(path: str) -> bool:
-    # os.access doesn't work on Windows: http://bugs.python.org/issue2528
-    # and we can't use tempfile: http://bugs.python.org/issue22107
-    basename = "accesstest_deleteme_fishfingers_custard_"
-    alphabet = "abcdefghijklmnopqrstuvwxyz0123456789"
-    for _ in range(10):
-        name = basename + "".join(random.choice(alphabet) for _ in range(6))
-        file = os.path.join(path, name)
-        try:
-            fd = os.open(file, os.O_RDWR | os.O_CREAT | os.O_EXCL)
-        except FileExistsError:
-            pass
-        except PermissionError:
-            # This could be because there's a directory with the same name.
-            # But it's highly unlikely there's a directory called that,
-            # so we'll assume it's because the parent dir is not writable.
-            # This could as well be because the parent dir is not readable,
-            # due to non-privileged user access.
-            return False
-        else:
-            os.close(fd)
-            os.unlink(file)
-            return True
-    # This should never be reached
-    raise OSError("Unexpected condition testing for writable directory")
-def find_files(path: str, pattern: str) -> List[str]:
-    """Returns a list of absolute paths of files beneath path, recursively,
-    with filenames which match the UNIX-style shell glob pattern."""
-    result: List[str] = []
-    for root, _, files in os.walk(path):
-        matches = fnmatch.filter(files, pattern)
-        result.extend(os.path.join(root, f) for f in matches)
-    return result
-def file_size(path: str) -> Union[int, float]:
-    # If it's a symlink, return 0.
-    if os.path.islink(path):
-        return 0
-    return os.path.getsize(path)
-def format_file_size(path: str) -> str:
-    return format_size(file_size(path))
-def directory_size(path: str) -> Union[int, float]:
-    size = 0.0
-    for root, _dirs, files in os.walk(path):
-        for filename in files:
-            file_path = os.path.join(root, filename)
-            size += file_size(file_path)
-    return size
-def format_directory_size(path: str) -> str:
-    return format_size(directory_size(path))

spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/pygments/formatters/terminal.py DELETED Viewed

@@ -1,127 +0,0 @@
-"""
-    pygments.formatters.terminal
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    Formatter for terminal output with ANSI sequences.
-    :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 Keyword, Name, Comment, String, Error, \
-    Number, Operator, Generic, Token, Whitespace
-from pip._vendor.pygments.console import ansiformat
-from pip._vendor.pygments.util import get_choice_opt
-__all__ = ['TerminalFormatter']
-#: Map token types to a tuple of color values for light and dark
-#: backgrounds.
-TERMINAL_COLORS = {
-    Token:              ('',            ''),
-    Whitespace:         ('gray',   'brightblack'),
-    Comment:            ('gray',   'brightblack'),
-    Comment.Preproc:    ('cyan',        'brightcyan'),
-    Keyword:            ('blue',    'brightblue'),
-    Keyword.Type:       ('cyan',        'brightcyan'),
-    Operator.Word:      ('magenta',      'brightmagenta'),
-    Name.Builtin:       ('cyan',        'brightcyan'),
-    Name.Function:      ('green',   'brightgreen'),
-    Name.Namespace:     ('_cyan_',      '_brightcyan_'),
-    Name.Class:         ('_green_', '_brightgreen_'),
-    Name.Exception:     ('cyan',        'brightcyan'),
-    Name.Decorator:     ('brightblack',    'gray'),
-    Name.Variable:      ('red',     'brightred'),
-    Name.Constant:      ('red',     'brightred'),
-    Name.Attribute:     ('cyan',        'brightcyan'),
-    Name.Tag:           ('brightblue',        'brightblue'),
-    String:             ('yellow',       'yellow'),
-    Number:             ('blue',    'brightblue'),
-    Generic.Deleted:    ('brightred',        'brightred'),
-    Generic.Inserted:   ('green',  'brightgreen'),
-    Generic.Heading:    ('**',         '**'),
-    Generic.Subheading: ('*magenta*',   '*brightmagenta*'),
-    Generic.Prompt:     ('**',         '**'),
-    Generic.Error:      ('brightred',        'brightred'),
-    Error:              ('_brightred_',      '_brightred_'),
-}
-class TerminalFormatter(Formatter):
-    r"""
-    Format tokens with ANSI color sequences, for output in a text console.
-    Color sequences are terminated at newlines, so that paging the output
-    works correctly.
-    The `get_style_defs()` method doesn't do anything special since there is
-    no support for common styles.
-    Options accepted:
-    `bg`
-        Set to ``"light"`` or ``"dark"`` depending on the terminal's background
-        (default: ``"light"``).
-    `colorscheme`
-        A dictionary mapping token types to (lightbg, darkbg) color names or
-        ``None`` (default: ``None`` = use builtin colorscheme).
-    `linenos`
-        Set to ``True`` to have line numbers on the terminal output as well
-        (default: ``False`` = no line numbers).
-    """
-    name = 'Terminal'
-    aliases = ['terminal', 'console']
-    filenames = []
-    def __init__(self, **options):
-        Formatter.__init__(self, **options)
-        self.darkbg = get_choice_opt(options, 'bg',
-                                     ['light', 'dark'], 'light') == 'dark'
-        self.colorscheme = options.get('colorscheme', None) or TERMINAL_COLORS
-        self.linenos = options.get('linenos', False)
-        self._lineno = 0
-    def format(self, tokensource, outfile):
-        return Formatter.format(self, tokensource, outfile)
-    def _write_lineno(self, outfile):
-        self._lineno += 1
-        outfile.write("%s%04d: " % (self._lineno != 1 and '\n' or '', self._lineno))
-    def _get_color(self, ttype):
-        # self.colorscheme is a dict containing usually generic types, so we
-        # have to walk the tree of dots.  The base Token type must be a key,
-        # even if it's empty string, as in the default above.
-        colors = self.colorscheme.get(ttype)
-        while colors is None:
-            ttype = ttype.parent
-            colors = self.colorscheme.get(ttype)
-        return colors[self.darkbg]
-    def format_unencoded(self, tokensource, outfile):
-        if self.linenos:
-            self._write_lineno(outfile)
-        for ttype, value in tokensource:
-            color = self._get_color(ttype)
-            for line in value.splitlines(True):
-                if color:
-                    outfile.write(ansiformat(color, line.rstrip('\n')))
-                else:
-                    outfile.write(line.rstrip('\n'))
-                if line.endswith('\n'):
-                    if self.linenos:
-                        self._write_lineno(outfile)
-                    else:
-                        outfile.write('\n')
-        if self.linenos:
-            outfile.write("\n")

spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/requests/models.py DELETED Viewed

@@ -1,1034 +0,0 @@
-"""
-requests.models
-~~~~~~~~~~~~~~~
-This module contains the primary objects that power Requests.
-"""
-import datetime
-# Import encoding now, to avoid implicit import later.
-# Implicit import within threads may cause LookupError when standard library is in a ZIP,
-# such as in Embedded Python. See https://github.com/psf/requests/issues/3578.
-import encodings.idna  # noqa: F401
-from io import UnsupportedOperation
-from pip._vendor.urllib3.exceptions import (
-    DecodeError,
-    LocationParseError,
-    ProtocolError,
-    ReadTimeoutError,
-    SSLError,
-)
-from pip._vendor.urllib3.fields import RequestField
-from pip._vendor.urllib3.filepost import encode_multipart_formdata
-from pip._vendor.urllib3.util import parse_url
-from ._internal_utils import to_native_string, unicode_is_ascii
-from .auth import HTTPBasicAuth
-from .compat import (
-    Callable,
-    JSONDecodeError,
-    Mapping,
-    basestring,
-    builtin_str,
-    chardet,
-    cookielib,
-)
-from .compat import json as complexjson
-from .compat import urlencode, urlsplit, urlunparse
-from .cookies import _copy_cookie_jar, cookiejar_from_dict, get_cookie_header
-from .exceptions import (
-    ChunkedEncodingError,
-    ConnectionError,
-    ContentDecodingError,
-    HTTPError,
-    InvalidJSONError,
-    InvalidURL,
-)
-from .exceptions import JSONDecodeError as RequestsJSONDecodeError
-from .exceptions import MissingSchema
-from .exceptions import SSLError as RequestsSSLError
-from .exceptions import StreamConsumedError
-from .hooks import default_hooks
-from .status_codes import codes
-from .structures import CaseInsensitiveDict
-from .utils import (
-    check_header_validity,
-    get_auth_from_url,
-    guess_filename,
-    guess_json_utf,
-    iter_slices,
-    parse_header_links,
-    requote_uri,
-    stream_decode_response_unicode,
-    super_len,
-    to_key_val_list,
-)
-#: The set of HTTP status codes that indicate an automatically
-#: processable redirect.
-REDIRECT_STATI = (
-    codes.moved,  # 301
-    codes.found,  # 302
-    codes.other,  # 303
-    codes.temporary_redirect,  # 307
-    codes.permanent_redirect,  # 308
-)
-DEFAULT_REDIRECT_LIMIT = 30
-CONTENT_CHUNK_SIZE = 10 * 1024
-ITER_CHUNK_SIZE = 512
-class RequestEncodingMixin:
-    @property
-    def path_url(self):
-        """Build the path URL to use."""
-        url = []
-        p = urlsplit(self.url)
-        path = p.path
-        if not path:
-            path = "/"
-        url.append(path)
-        query = p.query
-        if query:
-            url.append("?")
-            url.append(query)
-        return "".join(url)
-    @staticmethod
-    def _encode_params(data):
-        """Encode parameters in a piece of data.
-        Will successfully encode parameters when passed as a dict or a list of
-        2-tuples. Order is retained if data is a list of 2-tuples but arbitrary
-        if parameters are supplied as a dict.
-        """
-        if isinstance(data, (str, bytes)):
-            return data
-        elif hasattr(data, "read"):
-            return data
-        elif hasattr(data, "__iter__"):
-            result = []
-            for k, vs in to_key_val_list(data):
-                if isinstance(vs, basestring) or not hasattr(vs, "__iter__"):
-                    vs = [vs]
-                for v in vs:
-                    if v is not None:
-                        result.append(
-                            (
-                                k.encode("utf-8") if isinstance(k, str) else k,
-                                v.encode("utf-8") if isinstance(v, str) else v,
-                            )
-                        )
-            return urlencode(result, doseq=True)
-        else:
-            return data
-    @staticmethod
-    def _encode_files(files, data):
-        """Build the body for a multipart/form-data request.
-        Will successfully encode files when passed as a dict or a list of
-        tuples. Order is retained if data is a list of tuples but arbitrary
-        if parameters are supplied as a dict.
-        The tuples may be 2-tuples (filename, fileobj), 3-tuples (filename, fileobj, contentype)
-        or 4-tuples (filename, fileobj, contentype, custom_headers).
-        """
-        if not files:
-            raise ValueError("Files must be provided.")
-        elif isinstance(data, basestring):
-            raise ValueError("Data must not be a string.")
-        new_fields = []
-        fields = to_key_val_list(data or {})
-        files = to_key_val_list(files or {})
-        for field, val in fields:
-            if isinstance(val, basestring) or not hasattr(val, "__iter__"):
-                val = [val]
-            for v in val:
-                if v is not None:
-                    # Don't call str() on bytestrings: in Py3 it all goes wrong.
-                    if not isinstance(v, bytes):
-                        v = str(v)
-                    new_fields.append(
-                        (
-                            field.decode("utf-8")
-                            if isinstance(field, bytes)
-                            else field,
-                            v.encode("utf-8") if isinstance(v, str) else v,
-                        )
-                    )
-        for (k, v) in files:
-            # support for explicit filename
-            ft = None
-            fh = None
-            if isinstance(v, (tuple, list)):
-                if len(v) == 2:
-                    fn, fp = v
-                elif len(v) == 3:
-                    fn, fp, ft = v
-                else:
-                    fn, fp, ft, fh = v
-            else:
-                fn = guess_filename(v) or k
-                fp = v
-            if isinstance(fp, (str, bytes, bytearray)):
-                fdata = fp
-            elif hasattr(fp, "read"):
-                fdata = fp.read()
-            elif fp is None:
-                continue
-            else:
-                fdata = fp
-            rf = RequestField(name=k, data=fdata, filename=fn, headers=fh)
-            rf.make_multipart(content_type=ft)
-            new_fields.append(rf)
-        body, content_type = encode_multipart_formdata(new_fields)
-        return body, content_type
-class RequestHooksMixin:
-    def register_hook(self, event, hook):
-        """Properly register a hook."""
-        if event not in self.hooks:
-            raise ValueError(f'Unsupported event specified, with event name "{event}"')
-        if isinstance(hook, Callable):
-            self.hooks[event].append(hook)
-        elif hasattr(hook, "__iter__"):
-            self.hooks[event].extend(h for h in hook if isinstance(h, Callable))
-    def deregister_hook(self, event, hook):
-        """Deregister a previously registered hook.
-        Returns True if the hook existed, False if not.
-        """
-        try:
-            self.hooks[event].remove(hook)
-            return True
-        except ValueError:
-            return False
-class Request(RequestHooksMixin):
-    """A user-created :class:`Request <Request>` object.
-    Used to prepare a :class:`PreparedRequest <PreparedRequest>`, which is sent to the server.
-    :param method: HTTP method to use.
-    :param url: URL to send.
-    :param headers: dictionary of headers to send.
-    :param files: dictionary of {filename: fileobject} files to multipart upload.
-    :param data: the body to attach to the request. If a dictionary or
-        list of tuples ``[(key, value)]`` is provided, form-encoding will
-        take place.
-    :param json: json for the body to attach to the request (if files or data is not specified).
-    :param params: URL parameters to append to the URL. If a dictionary or
-        list of tuples ``[(key, value)]`` is provided, form-encoding will
-        take place.
-    :param auth: Auth handler or (user, pass) tuple.
-    :param cookies: dictionary or CookieJar of cookies to attach to this request.
-    :param hooks: dictionary of callback hooks, for internal usage.
-    Usage::
-      >>> import requests
-      >>> req = requests.Request('GET', 'https://httpbin.org/get')
-      >>> req.prepare()
-      <PreparedRequest [GET]>
-    """
-    def __init__(
-        self,
-        method=None,
-        url=None,
-        headers=None,
-        files=None,
-        data=None,
-        params=None,
-        auth=None,
-        cookies=None,
-        hooks=None,
-        json=None,
-    ):
-        # Default empty dicts for dict params.
-        data = [] if data is None else data
-        files = [] if files is None else files
-        headers = {} if headers is None else headers
-        params = {} if params is None else params
-        hooks = {} if hooks is None else hooks
-        self.hooks = default_hooks()
-        for (k, v) in list(hooks.items()):
-            self.register_hook(event=k, hook=v)
-        self.method = method
-        self.url = url
-        self.headers = headers
-        self.files = files
-        self.data = data
-        self.json = json
-        self.params = params
-        self.auth = auth
-        self.cookies = cookies
-    def __repr__(self):
-        return f"<Request [{self.method}]>"
-    def prepare(self):
-        """Constructs a :class:`PreparedRequest <PreparedRequest>` for transmission and returns it."""
-        p = PreparedRequest()
-        p.prepare(
-            method=self.method,
-            url=self.url,
-            headers=self.headers,
-            files=self.files,
-            data=self.data,
-            json=self.json,
-            params=self.params,
-            auth=self.auth,
-            cookies=self.cookies,
-            hooks=self.hooks,
-        )
-        return p
-class PreparedRequest(RequestEncodingMixin, RequestHooksMixin):
-    """The fully mutable :class:`PreparedRequest <PreparedRequest>` object,
-    containing the exact bytes that will be sent to the server.
-    Instances are generated from a :class:`Request <Request>` object, and
-    should not be instantiated manually; doing so may produce undesirable
-    effects.
-    Usage::
-      >>> import requests
-      >>> req = requests.Request('GET', 'https://httpbin.org/get')
-      >>> r = req.prepare()
-      >>> r
-      <PreparedRequest [GET]>
-      >>> s = requests.Session()
-      >>> s.send(r)
-      <Response [200]>
-    """
-    def __init__(self):
-        #: HTTP verb to send to the server.
-        self.method = None
-        #: HTTP URL to send the request to.
-        self.url = None
-        #: dictionary of HTTP headers.
-        self.headers = None
-        # The `CookieJar` used to create the Cookie header will be stored here
-        # after prepare_cookies is called
-        self._cookies = None
-        #: request body to send to the server.
-        self.body = None
-        #: dictionary of callback hooks, for internal usage.
-        self.hooks = default_hooks()
-        #: integer denoting starting position of a readable file-like body.
-        self._body_position = None
-    def prepare(
-        self,
-        method=None,
-        url=None,
-        headers=None,
-        files=None,
-        data=None,
-        params=None,
-        auth=None,
-        cookies=None,
-        hooks=None,
-        json=None,
-    ):
-        """Prepares the entire request with the given parameters."""
-        self.prepare_method(method)
-        self.prepare_url(url, params)
-        self.prepare_headers(headers)
-        self.prepare_cookies(cookies)
-        self.prepare_body(data, files, json)
-        self.prepare_auth(auth, url)
-        # Note that prepare_auth must be last to enable authentication schemes
-        # such as OAuth to work on a fully prepared request.
-        # This MUST go after prepare_auth. Authenticators could add a hook
-        self.prepare_hooks(hooks)
-    def __repr__(self):
-        return f"<PreparedRequest [{self.method}]>"
-    def copy(self):
-        p = PreparedRequest()
-        p.method = self.method
-        p.url = self.url
-        p.headers = self.headers.copy() if self.headers is not None else None
-        p._cookies = _copy_cookie_jar(self._cookies)
-        p.body = self.body
-        p.hooks = self.hooks
-        p._body_position = self._body_position
-        return p
-    def prepare_method(self, method):
-        """Prepares the given HTTP method."""
-        self.method = method
-        if self.method is not None:
-            self.method = to_native_string(self.method.upper())
-    @staticmethod
-    def _get_idna_encoded_host(host):
-        from pip._vendor import idna
-        try:
-            host = idna.encode(host, uts46=True).decode("utf-8")
-        except idna.IDNAError:
-            raise UnicodeError
-        return host
-    def prepare_url(self, url, params):
-        """Prepares the given HTTP URL."""
-        #: Accept objects that have string representations.
-        #: We're unable to blindly call unicode/str functions
-        #: as this will include the bytestring indicator (b'')
-        #: on python 3.x.
-        #: https://github.com/psf/requests/pull/2238
-        if isinstance(url, bytes):
-            url = url.decode("utf8")
-        else:
-            url = str(url)
-        # Remove leading whitespaces from url
-        url = url.lstrip()
-        # Don't do any URL preparation for non-HTTP schemes like `mailto`,
-        # `data` etc to work around exceptions from `url_parse`, which
-        # handles RFC 3986 only.
-        if ":" in url and not url.lower().startswith("http"):
-            self.url = url
-            return
-        # Support for unicode domain names and paths.
-        try:
-            scheme, auth, host, port, path, query, fragment = parse_url(url)
-        except LocationParseError as e:
-            raise InvalidURL(*e.args)
-        if not scheme:
-            raise MissingSchema(
-                f"Invalid URL {url!r}: No scheme supplied. "
-                f"Perhaps you meant https://{url}?"
-            )
-        if not host:
-            raise InvalidURL(f"Invalid URL {url!r}: No host supplied")
-        # In general, we want to try IDNA encoding the hostname if the string contains
-        # non-ASCII characters. This allows users to automatically get the correct IDNA
-        # behaviour. For strings containing only ASCII characters, we need to also verify
-        # it doesn't start with a wildcard (*), before allowing the unencoded hostname.
-        if not unicode_is_ascii(host):
-            try:
-                host = self._get_idna_encoded_host(host)
-            except UnicodeError:
-                raise InvalidURL("URL has an invalid label.")
-        elif host.startswith(("*", ".")):
-            raise InvalidURL("URL has an invalid label.")
-        # Carefully reconstruct the network location
-        netloc = auth or ""
-        if netloc:
-            netloc += "@"
-        netloc += host
-        if port:
-            netloc += f":{port}"
-        # Bare domains aren't valid URLs.
-        if not path:
-            path = "/"
-        if isinstance(params, (str, bytes)):
-            params = to_native_string(params)
-        enc_params = self._encode_params(params)
-        if enc_params:
-            if query:
-                query = f"{query}&{enc_params}"
-            else:
-                query = enc_params
-        url = requote_uri(urlunparse([scheme, netloc, path, None, query, fragment]))
-        self.url = url
-    def prepare_headers(self, headers):
-        """Prepares the given HTTP headers."""
-        self.headers = CaseInsensitiveDict()
-        if headers:
-            for header in headers.items():
-                # Raise exception on invalid header value.
-                check_header_validity(header)
-                name, value = header
-                self.headers[to_native_string(name)] = value
-    def prepare_body(self, data, files, json=None):
-        """Prepares the given HTTP body data."""
-        # Check if file, fo, generator, iterator.
-        # If not, run through normal process.
-        # Nottin' on you.
-        body = None
-        content_type = None
-        if not data and json is not None:
-            # urllib3 requires a bytes-like body. Python 2's json.dumps
-            # provides this natively, but Python 3 gives a Unicode string.
-            content_type = "application/json"
-            try:
-                body = complexjson.dumps(json, allow_nan=False)
-            except ValueError as ve:
-                raise InvalidJSONError(ve, request=self)
-            if not isinstance(body, bytes):
-                body = body.encode("utf-8")
-        is_stream = all(
-            [
-                hasattr(data, "__iter__"),
-                not isinstance(data, (basestring, list, tuple, Mapping)),
-            ]
-        )
-        if is_stream:
-            try:
-                length = super_len(data)
-            except (TypeError, AttributeError, UnsupportedOperation):
-                length = None
-            body = data
-            if getattr(body, "tell", None) is not None:
-                # Record the current file position before reading.
-                # This will allow us to rewind a file in the event
-                # of a redirect.
-                try:
-                    self._body_position = body.tell()
-                except OSError:
-                    # This differentiates from None, allowing us to catch
-                    # a failed `tell()` later when trying to rewind the body
-                    self._body_position = object()
-            if files:
-                raise NotImplementedError(
-                    "Streamed bodies and files are mutually exclusive."
-                )
-            if length:
-                self.headers["Content-Length"] = builtin_str(length)
-            else:
-                self.headers["Transfer-Encoding"] = "chunked"
-        else:
-            # Multi-part file uploads.
-            if files:
-                (body, content_type) = self._encode_files(files, data)
-            else:
-                if data:
-                    body = self._encode_params(data)
-                    if isinstance(data, basestring) or hasattr(data, "read"):
-                        content_type = None
-                    else:
-                        content_type = "application/x-www-form-urlencoded"
-            self.prepare_content_length(body)
-            # Add content-type if it wasn't explicitly provided.
-            if content_type and ("content-type" not in self.headers):
-                self.headers["Content-Type"] = content_type
-        self.body = body
-    def prepare_content_length(self, body):
-        """Prepare Content-Length header based on request method and body"""
-        if body is not None:
-            length = super_len(body)
-            if length:
-                # If length exists, set it. Otherwise, we fallback
-                # to Transfer-Encoding: chunked.
-                self.headers["Content-Length"] = builtin_str(length)
-        elif (
-            self.method not in ("GET", "HEAD")
-            and self.headers.get("Content-Length") is None
-        ):
-            # Set Content-Length to 0 for methods that can have a body
-            # but don't provide one. (i.e. not GET or HEAD)
-            self.headers["Content-Length"] = "0"
-    def prepare_auth(self, auth, url=""):
-        """Prepares the given HTTP auth data."""
-        # If no Auth is explicitly provided, extract it from the URL first.
-        if auth is None:
-            url_auth = get_auth_from_url(self.url)
-            auth = url_auth if any(url_auth) else None
-        if auth:
-            if isinstance(auth, tuple) and len(auth) == 2:
-                # special-case basic HTTP auth
-                auth = HTTPBasicAuth(*auth)
-            # Allow auth to make its changes.
-            r = auth(self)
-            # Update self to reflect the auth changes.
-            self.__dict__.update(r.__dict__)
-            # Recompute Content-Length
-            self.prepare_content_length(self.body)
-    def prepare_cookies(self, cookies):
-        """Prepares the given HTTP cookie data.
-        This function eventually generates a ``Cookie`` header from the
-        given cookies using cookielib. Due to cookielib's design, the header
-        will not be regenerated if it already exists, meaning this function
-        can only be called once for the life of the
-        :class:`PreparedRequest <PreparedRequest>` object. Any subsequent calls
-        to ``prepare_cookies`` will have no actual effect, unless the "Cookie"
-        header is removed beforehand.
-        """
-        if isinstance(cookies, cookielib.CookieJar):
-            self._cookies = cookies
-        else:
-            self._cookies = cookiejar_from_dict(cookies)
-        cookie_header = get_cookie_header(self._cookies, self)
-        if cookie_header is not None:
-            self.headers["Cookie"] = cookie_header
-    def prepare_hooks(self, hooks):
-        """Prepares the given hooks."""
-        # hooks can be passed as None to the prepare method and to this
-        # method. To prevent iterating over None, simply use an empty list
-        # if hooks is False-y
-        hooks = hooks or []
-        for event in hooks:
-            self.register_hook(event, hooks[event])
-class Response:
-    """The :class:`Response <Response>` object, which contains a
-    server's response to an HTTP request.
-    """
-    __attrs__ = [
-        "_content",
-        "status_code",
-        "headers",
-        "url",
-        "history",
-        "encoding",
-        "reason",
-        "cookies",
-        "elapsed",
-        "request",
-    ]
-    def __init__(self):
-        self._content = False
-        self._content_consumed = False
-        self._next = None
-        #: Integer Code of responded HTTP Status, e.g. 404 or 200.
-        self.status_code = None
-        #: Case-insensitive Dictionary of Response Headers.
-        #: For example, ``headers['content-encoding']`` will return the
-        #: value of a ``'Content-Encoding'`` response header.
-        self.headers = CaseInsensitiveDict()
-        #: File-like object representation of response (for advanced usage).
-        #: Use of ``raw`` requires that ``stream=True`` be set on the request.
-        #: This requirement does not apply for use internally to Requests.
-        self.raw = None
-        #: Final URL location of Response.
-        self.url = None
-        #: Encoding to decode with when accessing r.text.
-        self.encoding = None
-        #: A list of :class:`Response <Response>` objects from
-        #: the history of the Request. Any redirect responses will end
-        #: up here. The list is sorted from the oldest to the most recent request.
-        self.history = []
-        #: Textual reason of responded HTTP Status, e.g. "Not Found" or "OK".
-        self.reason = None
-        #: A CookieJar of Cookies the server sent back.
-        self.cookies = cookiejar_from_dict({})
-        #: The amount of time elapsed between sending the request
-        #: and the arrival of the response (as a timedelta).
-        #: This property specifically measures the time taken between sending
-        #: the first byte of the request and finishing parsing the headers. It
-        #: is therefore unaffected by consuming the response content or the
-        #: value of the ``stream`` keyword argument.
-        self.elapsed = datetime.timedelta(0)
-        #: The :class:`PreparedRequest <PreparedRequest>` object to which this
-        #: is a response.
-        self.request = None
-    def __enter__(self):
-        return self
-    def __exit__(self, *args):
-        self.close()
-    def __getstate__(self):
-        # Consume everything; accessing the content attribute makes
-        # sure the content has been fully read.
-        if not self._content_consumed:
-            self.content
-        return {attr: getattr(self, attr, None) for attr in self.__attrs__}
-    def __setstate__(self, state):
-        for name, value in state.items():
-            setattr(self, name, value)
-        # pickled objects do not have .raw
-        setattr(self, "_content_consumed", True)
-        setattr(self, "raw", None)
-    def __repr__(self):
-        return f"<Response [{self.status_code}]>"
-    def __bool__(self):
-        """Returns True if :attr:`status_code` is less than 400.
-        This attribute checks if the status code of the response is between
-        400 and 600 to see if there was a client error or a server error. If
-        the status code, is between 200 and 400, this will return True. This
-        is **not** a check to see if the response code is ``200 OK``.
-        """
-        return self.ok
-    def __nonzero__(self):
-        """Returns True if :attr:`status_code` is less than 400.
-        This attribute checks if the status code of the response is between
-        400 and 600 to see if there was a client error or a server error. If
-        the status code, is between 200 and 400, this will return True. This
-        is **not** a check to see if the response code is ``200 OK``.
-        """
-        return self.ok
-    def __iter__(self):
-        """Allows you to use a response as an iterator."""
-        return self.iter_content(128)
-    @property
-    def ok(self):
-        """Returns True if :attr:`status_code` is less than 400, False if not.
-        This attribute checks if the status code of the response is between
-        400 and 600 to see if there was a client error or a server error. If
-        the status code is between 200 and 400, this will return True. This
-        is **not** a check to see if the response code is ``200 OK``.
-        """
-        try:
-            self.raise_for_status()
-        except HTTPError:
-            return False
-        return True
-    @property
-    def is_redirect(self):
-        """True if this Response is a well-formed HTTP redirect that could have
-        been processed automatically (by :meth:`Session.resolve_redirects`).
-        """
-        return "location" in self.headers and self.status_code in REDIRECT_STATI
-    @property
-    def is_permanent_redirect(self):
-        """True if this Response one of the permanent versions of redirect."""
-        return "location" in self.headers and self.status_code in (
-            codes.moved_permanently,
-            codes.permanent_redirect,
-        )
-    @property
-    def next(self):
-        """Returns a PreparedRequest for the next request in a redirect chain, if there is one."""
-        return self._next
-    @property
-    def apparent_encoding(self):
-        """The apparent encoding, provided by the charset_normalizer or chardet libraries."""
-        return chardet.detect(self.content)["encoding"]
-    def iter_content(self, chunk_size=1, decode_unicode=False):
-        """Iterates over the response data.  When stream=True is set on the
-        request, this avoids reading the content at once into memory for
-        large responses.  The chunk size is the number of bytes it should
-        read into memory.  This is not necessarily the length of each item
-        returned as decoding can take place.
-        chunk_size must be of type int or None. A value of None will
-        function differently depending on the value of `stream`.
-        stream=True will read data as it arrives in whatever size the
-        chunks are received. If stream=False, data is returned as
-        a single chunk.
-        If decode_unicode is True, content will be decoded using the best
-        available encoding based on the response.
-        """
-        def generate():
-            # Special case for urllib3.
-            if hasattr(self.raw, "stream"):
-                try:
-                    yield from self.raw.stream(chunk_size, decode_content=True)
-                except ProtocolError as e:
-                    raise ChunkedEncodingError(e)
-                except DecodeError as e:
-                    raise ContentDecodingError(e)
-                except ReadTimeoutError as e:
-                    raise ConnectionError(e)
-                except SSLError as e:
-                    raise RequestsSSLError(e)
-            else:
-                # Standard file-like object.
-                while True:
-                    chunk = self.raw.read(chunk_size)
-                    if not chunk:
-                        break
-                    yield chunk
-            self._content_consumed = True
-        if self._content_consumed and isinstance(self._content, bool):
-            raise StreamConsumedError()
-        elif chunk_size is not None and not isinstance(chunk_size, int):
-            raise TypeError(
-                f"chunk_size must be an int, it is instead a {type(chunk_size)}."
-            )
-        # simulate reading small chunks of the content
-        reused_chunks = iter_slices(self._content, chunk_size)
-        stream_chunks = generate()
-        chunks = reused_chunks if self._content_consumed else stream_chunks
-        if decode_unicode:
-            chunks = stream_decode_response_unicode(chunks, self)
-        return chunks
-    def iter_lines(
-        self, chunk_size=ITER_CHUNK_SIZE, decode_unicode=False, delimiter=None
-    ):
-        """Iterates over the response data, one line at a time.  When
-        stream=True is set on the request, this avoids reading the
-        content at once into memory for large responses.
-        .. note:: This method is not reentrant safe.
-        """
-        pending = None
-        for chunk in self.iter_content(
-            chunk_size=chunk_size, decode_unicode=decode_unicode
-        ):
-            if pending is not None:
-                chunk = pending + chunk
-            if delimiter:
-                lines = chunk.split(delimiter)
-            else:
-                lines = chunk.splitlines()
-            if lines and lines[-1] and chunk and lines[-1][-1] == chunk[-1]:
-                pending = lines.pop()
-            else:
-                pending = None
-            yield from lines
-        if pending is not None:
-            yield pending
-    @property
-    def content(self):
-        """Content of the response, in bytes."""
-        if self._content is False:
-            # Read the contents.
-            if self._content_consumed:
-                raise RuntimeError("The content for this response was already consumed")
-            if self.status_code == 0 or self.raw is None:
-                self._content = None
-            else:
-                self._content = b"".join(self.iter_content(CONTENT_CHUNK_SIZE)) or b""
-        self._content_consumed = True
-        # don't need to release the connection; that's been handled by urllib3
-        # since we exhausted the data.
-        return self._content
-    @property
-    def text(self):
-        """Content of the response, in unicode.
-        If Response.encoding is None, encoding will be guessed using
-        ``charset_normalizer`` or ``chardet``.
-        The encoding of the response content is determined based solely on HTTP
-        headers, following RFC 2616 to the letter. If you can take advantage of
-        non-HTTP knowledge to make a better guess at the encoding, you should
-        set ``r.encoding`` appropriately before accessing this property.
-        """
-        # Try charset from content-type
-        content = None
-        encoding = self.encoding
-        if not self.content:
-            return ""
-        # Fallback to auto-detected encoding.
-        if self.encoding is None:
-            encoding = self.apparent_encoding
-        # Decode unicode from given encoding.
-        try:
-            content = str(self.content, encoding, errors="replace")
-        except (LookupError, TypeError):
-            # A LookupError is raised if the encoding was not found which could
-            # indicate a misspelling or similar mistake.
-            #
-            # A TypeError can be raised if encoding is None
-            #
-            # So we try blindly encoding.
-            content = str(self.content, errors="replace")
-        return content
-    def json(self, **kwargs):
-        r"""Returns the json-encoded content of a response, if any.
-        :param \*\*kwargs: Optional arguments that ``json.loads`` takes.
-        :raises requests.exceptions.JSONDecodeError: If the response body does not
-            contain valid json.
-        """
-        if not self.encoding and self.content and len(self.content) > 3:
-            # No encoding set. JSON RFC 4627 section 3 states we should expect
-            # UTF-8, -16 or -32. Detect which one to use; If the detection or
-            # decoding fails, fall back to `self.text` (using charset_normalizer to make
-            # a best guess).
-            encoding = guess_json_utf(self.content)
-            if encoding is not None:
-                try:
-                    return complexjson.loads(self.content.decode(encoding), **kwargs)
-                except UnicodeDecodeError:
-                    # Wrong UTF codec detected; usually because it's not UTF-8
-                    # but some other 8-bit codec.  This is an RFC violation,
-                    # and the server didn't bother to tell us what codec *was*
-                    # used.
-                    pass
-                except JSONDecodeError as e:
-                    raise RequestsJSONDecodeError(e.msg, e.doc, e.pos)
-        try:
-            return complexjson.loads(self.text, **kwargs)
-        except JSONDecodeError as e:
-            # Catch JSON-related errors and raise as requests.JSONDecodeError
-            # This aliases json.JSONDecodeError and simplejson.JSONDecodeError
-            raise RequestsJSONDecodeError(e.msg, e.doc, e.pos)
-    @property
-    def links(self):
-        """Returns the parsed header links of the response, if any."""
-        header = self.headers.get("link")
-        resolved_links = {}
-        if header:
-            links = parse_header_links(header)
-            for link in links:
-                key = link.get("rel") or link.get("url")
-                resolved_links[key] = link
-        return resolved_links
-    def raise_for_status(self):
-        """Raises :class:`HTTPError`, if one occurred."""
-        http_error_msg = ""
-        if isinstance(self.reason, bytes):
-            # We attempt to decode utf-8 first because some servers
-            # choose to localize their reason strings. If the string
-            # isn't utf-8, we fall back to iso-8859-1 for all other
-            # encodings. (See PR #3538)
-            try:
-                reason = self.reason.decode("utf-8")
-            except UnicodeDecodeError:
-                reason = self.reason.decode("iso-8859-1")
-        else:
-            reason = self.reason
-        if 400 <= self.status_code < 500:
-            http_error_msg = (
-                f"{self.status_code} Client Error: {reason} for url: {self.url}"
-            )
-        elif 500 <= self.status_code < 600:
-            http_error_msg = (
-                f"{self.status_code} Server Error: {reason} for url: {self.url}"
-            )
-        if http_error_msg:
-            raise HTTPError(http_error_msg, response=self)
-    def close(self):
-        """Releases the connection back to the pool. Once this method has been
-        called the underlying ``raw`` object must not be accessed again.
-        *Note: Should not normally need to be called explicitly.*
-        """
-        if not self._content_consumed:
-            self.raw.close()
-        release_conn = getattr(self.raw, "release_conn", None)
-        if release_conn is not None:
-            release_conn()

spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/tenacity/retry.py DELETED Viewed

@@ -1,272 +0,0 @@
-# Copyright 2016–2021 Julien Danjou
-# Copyright 2016 Joshua Harlow
-# Copyright 2013-2014 Ray Holder
-#
-# 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.
-import abc
-import re
-import typing
-if typing.TYPE_CHECKING:
-    from pip._vendor.tenacity import RetryCallState
-class retry_base(abc.ABC):
-    """Abstract base class for retry strategies."""
-    @abc.abstractmethod
-    def __call__(self, retry_state: "RetryCallState") -> bool:
-        pass
-    def __and__(self, other: "retry_base") -> "retry_all":
-        return retry_all(self, other)
-    def __or__(self, other: "retry_base") -> "retry_any":
-        return retry_any(self, other)
-RetryBaseT = typing.Union[retry_base, typing.Callable[["RetryCallState"], bool]]
-class _retry_never(retry_base):
-    """Retry strategy that never rejects any result."""
-    def __call__(self, retry_state: "RetryCallState") -> bool:
-        return False
-retry_never = _retry_never()
-class _retry_always(retry_base):
-    """Retry strategy that always rejects any result."""
-    def __call__(self, retry_state: "RetryCallState") -> bool:
-        return True
-retry_always = _retry_always()
-class retry_if_exception(retry_base):
-    """Retry strategy that retries if an exception verifies a predicate."""
-    def __init__(self, predicate: typing.Callable[[BaseException], bool]) -> None:
-        self.predicate = predicate
-    def __call__(self, retry_state: "RetryCallState") -> bool:
-        if retry_state.outcome is None:
-            raise RuntimeError("__call__() called before outcome was set")
-        if retry_state.outcome.failed:
-            exception = retry_state.outcome.exception()
-            if exception is None:
-                raise RuntimeError("outcome failed but the exception is None")
-            return self.predicate(exception)
-        else:
-            return False
-class retry_if_exception_type(retry_if_exception):
-    """Retries if an exception has been raised of one or more types."""
-    def __init__(
-        self,
-        exception_types: typing.Union[
-            typing.Type[BaseException],
-            typing.Tuple[typing.Type[BaseException], ...],
-        ] = Exception,
-    ) -> None:
-        self.exception_types = exception_types
-        super().__init__(lambda e: isinstance(e, exception_types))
-class retry_if_not_exception_type(retry_if_exception):
-    """Retries except an exception has been raised of one or more types."""
-    def __init__(
-        self,
-        exception_types: typing.Union[
-            typing.Type[BaseException],
-            typing.Tuple[typing.Type[BaseException], ...],
-        ] = Exception,
-    ) -> None:
-        self.exception_types = exception_types
-        super().__init__(lambda e: not isinstance(e, exception_types))
-class retry_unless_exception_type(retry_if_exception):
-    """Retries until an exception is raised of one or more types."""
-    def __init__(
-        self,
-        exception_types: typing.Union[
-            typing.Type[BaseException],
-            typing.Tuple[typing.Type[BaseException], ...],
-        ] = Exception,
-    ) -> None:
-        self.exception_types = exception_types
-        super().__init__(lambda e: not isinstance(e, exception_types))
-    def __call__(self, retry_state: "RetryCallState") -> bool:
-        if retry_state.outcome is None:
-            raise RuntimeError("__call__() called before outcome was set")
-        # always retry if no exception was raised
-        if not retry_state.outcome.failed:
-            return True
-        exception = retry_state.outcome.exception()
-        if exception is None:
-            raise RuntimeError("outcome failed but the exception is None")
-        return self.predicate(exception)
-class retry_if_exception_cause_type(retry_base):
-    """Retries if any of the causes of the raised exception is of one or more types.
-    The check on the type of the cause of the exception is done recursively (until finding
-    an exception in the chain that has no `__cause__`)
-    """
-    def __init__(
-        self,
-        exception_types: typing.Union[
-            typing.Type[BaseException],
-            typing.Tuple[typing.Type[BaseException], ...],
-        ] = Exception,
-    ) -> None:
-        self.exception_cause_types = exception_types
-    def __call__(self, retry_state: "RetryCallState") -> bool:
-        if retry_state.outcome is None:
-            raise RuntimeError("__call__ called before outcome was set")
-        if retry_state.outcome.failed:
-            exc = retry_state.outcome.exception()
-            while exc is not None:
-                if isinstance(exc.__cause__, self.exception_cause_types):
-                    return True
-                exc = exc.__cause__
-        return False
-class retry_if_result(retry_base):
-    """Retries if the result verifies a predicate."""
-    def __init__(self, predicate: typing.Callable[[typing.Any], bool]) -> None:
-        self.predicate = predicate
-    def __call__(self, retry_state: "RetryCallState") -> bool:
-        if retry_state.outcome is None:
-            raise RuntimeError("__call__() called before outcome was set")
-        if not retry_state.outcome.failed:
-            return self.predicate(retry_state.outcome.result())
-        else:
-            return False
-class retry_if_not_result(retry_base):
-    """Retries if the result refutes a predicate."""
-    def __init__(self, predicate: typing.Callable[[typing.Any], bool]) -> None:
-        self.predicate = predicate
-    def __call__(self, retry_state: "RetryCallState") -> bool:
-        if retry_state.outcome is None:
-            raise RuntimeError("__call__() called before outcome was set")
-        if not retry_state.outcome.failed:
-            return not self.predicate(retry_state.outcome.result())
-        else:
-            return False
-class retry_if_exception_message(retry_if_exception):
-    """Retries if an exception message equals or matches."""
-    def __init__(
-        self,
-        message: typing.Optional[str] = None,
-        match: typing.Optional[str] = None,
-    ) -> None:
-        if message and match:
-            raise TypeError(f"{self.__class__.__name__}() takes either 'message' or 'match', not both")
-        # set predicate
-        if message:
-            def message_fnc(exception: BaseException) -> bool:
-                return message == str(exception)
-            predicate = message_fnc
-        elif match:
-            prog = re.compile(match)
-            def match_fnc(exception: BaseException) -> bool:
-                return bool(prog.match(str(exception)))
-            predicate = match_fnc
-        else:
-            raise TypeError(f"{self.__class__.__name__}() missing 1 required argument 'message' or 'match'")
-        super().__init__(predicate)
-class retry_if_not_exception_message(retry_if_exception_message):
-    """Retries until an exception message equals or matches."""
-    def __init__(
-        self,
-        message: typing.Optional[str] = None,
-        match: typing.Optional[str] = None,
-    ) -> None:
-        super().__init__(message, match)
-        # invert predicate
-        if_predicate = self.predicate
-        self.predicate = lambda *args_, **kwargs_: not if_predicate(*args_, **kwargs_)
-    def __call__(self, retry_state: "RetryCallState") -> bool:
-        if retry_state.outcome is None:
-            raise RuntimeError("__call__() called before outcome was set")
-        if not retry_state.outcome.failed:
-            return True
-        exception = retry_state.outcome.exception()
-        if exception is None:
-            raise RuntimeError("outcome failed but the exception is None")
-        return self.predicate(exception)
-class retry_any(retry_base):
-    """Retries if any of the retries condition is valid."""
-    def __init__(self, *retries: retry_base) -> None:
-        self.retries = retries
-    def __call__(self, retry_state: "RetryCallState") -> bool:
-        return any(r(retry_state) for r in self.retries)
-class retry_all(retry_base):
-    """Retries if all the retries condition are valid."""
-    def __init__(self, *retries: retry_base) -> None:
-        self.retries = retries
-    def __call__(self, retry_state: "RetryCallState") -> bool:
-        return all(r(retry_state) for r in self.retries)

spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/setuptools/extern/__init__.py DELETED Viewed

@@ -1,76 +0,0 @@
-import importlib.util
-import sys
-class VendorImporter:
-    """
-    A PEP 302 meta path importer for finding optionally-vendored
-    or otherwise naturally-installed packages from root_name.
-    """
-    def __init__(self, root_name, vendored_names=(), vendor_pkg=None):
-        self.root_name = root_name
-        self.vendored_names = set(vendored_names)
-        self.vendor_pkg = vendor_pkg or root_name.replace('extern', '_vendor')
-    @property
-    def search_path(self):
-        """
-        Search first the vendor package then as a natural package.
-        """
-        yield self.vendor_pkg + '.'
-        yield ''
-    def _module_matches_namespace(self, fullname):
-        """Figure out if the target module is vendored."""
-        root, base, target = fullname.partition(self.root_name + '.')
-        return not root and any(map(target.startswith, self.vendored_names))
-    def load_module(self, fullname):
-        """
-        Iterate over the search path to locate and load fullname.
-        """
-        root, base, target = fullname.partition(self.root_name + '.')
-        for prefix in self.search_path:
-            try:
-                extant = prefix + target
-                __import__(extant)
-                mod = sys.modules[extant]
-                sys.modules[fullname] = mod
-                return mod
-            except ImportError:
-                pass
-        else:
-            raise ImportError(
-                "The '{target}' package is required; "
-                "normally this is bundled with this package so if you get "
-                "this warning, consult the packager of your "
-                "distribution.".format(**locals())
-            )
-    def create_module(self, spec):
-        return self.load_module(spec.name)
-    def exec_module(self, module):
-        pass
-    def find_spec(self, fullname, path=None, target=None):
-        """Return a module spec for vendored names."""
-        return (
-            importlib.util.spec_from_loader(fullname, self)
-            if self._module_matches_namespace(fullname) else None
-        )
-    def install(self):
-        """
-        Install this importer into sys.meta_path if not already present.
-        """
-        if self not in sys.meta_path:
-            sys.meta_path.append(self)
-names = (
-    'packaging', 'pyparsing', 'ordered_set', 'more_itertools', 'importlib_metadata',
-    'zipp', 'importlib_resources', 'jaraco', 'typing_extensions', 'tomli',
-)
-VendorImporter(__name__, names, 'setuptools._vendor').install()

spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/tests/data/test_coco.py DELETED Viewed

@@ -1,139 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import json
-import numpy as np
-import os
-import tempfile
-import unittest
-import pycocotools.mask as mask_util
-from detectron2.data import DatasetCatalog, MetadataCatalog
-from detectron2.data.datasets.coco import convert_to_coco_dict, load_coco_json
-from detectron2.structures import BoxMode
-def make_mask():
-    """
-    Makes a donut shaped binary mask.
-    """
-    H = 100
-    W = 100
-    mask = np.zeros([H, W], dtype=np.uint8)
-    for x in range(W):
-        for y in range(H):
-            d = np.linalg.norm(np.array([W, H]) / 2 - np.array([x, y]))
-            if d > 10 and d < 20:
-                mask[y, x] = 1
-    return mask
-def uncompressed_rle(mask):
-    l = mask.flatten(order="F").tolist()
-    counts = []
-    p = False
-    cnt = 0
-    for i in l:
-        if i == p:
-            cnt += 1
-        else:
-            counts.append(cnt)
-            p = i
-            cnt = 1
-    counts.append(cnt)
-    return {"counts": counts, "size": [mask.shape[0], mask.shape[1]]}
-def make_dataset_dicts(mask, compressed: bool = True):
-    """
-    Returns a list of dicts that represents a single COCO data point for
-    object detection. The single instance given by `mask` is represented by
-    RLE, either compressed or uncompressed.
-    """
-    record = {}
-    record["file_name"] = "test"
-    record["image_id"] = 0
-    record["height"] = mask.shape[0]
-    record["width"] = mask.shape[1]
-    y, x = np.nonzero(mask)
-    if compressed:
-        segmentation = mask_util.encode(np.asarray(mask, order="F"))
-    else:
-        segmentation = uncompressed_rle(mask)
-    min_x = np.min(x)
-    max_x = np.max(x)
-    min_y = np.min(y)
-    max_y = np.max(y)
-    obj = {
-        "bbox": [min_x, min_y, max_x, max_y],
-        "bbox_mode": BoxMode.XYXY_ABS,
-        "category_id": 0,
-        "iscrowd": 0,
-        "segmentation": segmentation,
-    }
-    record["annotations"] = [obj]
-    return [record]
-class TestRLEToJson(unittest.TestCase):
-    def test(self):
-        # Make a dummy dataset.
-        mask = make_mask()
-        DatasetCatalog.register("test_dataset", lambda: make_dataset_dicts(mask))
-        MetadataCatalog.get("test_dataset").set(thing_classes=["test_label"])
-        # Dump to json.
-        json_dict = convert_to_coco_dict("test_dataset")
-        with tempfile.TemporaryDirectory() as tmpdir:
-            json_file_name = os.path.join(tmpdir, "test.json")
-            with open(json_file_name, "w") as f:
-                json.dump(json_dict, f)
-            # Load from json.
-            dicts = load_coco_json(json_file_name, "")
-        # Check the loaded mask matches the original.
-        anno = dicts[0]["annotations"][0]
-        loaded_mask = mask_util.decode(anno["segmentation"])
-        self.assertTrue(np.array_equal(loaded_mask, mask))
-        DatasetCatalog.pop("test_dataset")
-        MetadataCatalog.pop("test_dataset")
-    def test_uncompressed_RLE(self):
-        mask = make_mask()
-        rle = mask_util.encode(np.asarray(mask, order="F"))
-        uncompressed = uncompressed_rle(mask)
-        compressed = mask_util.frPyObjects(uncompressed, *rle["size"])
-        self.assertEqual(rle, compressed)
-class TestConvertCOCO(unittest.TestCase):
-    @staticmethod
-    def generate_data():
-        record = {
-            "file_name": "test",
-            "image_id": 0,
-            "height": 100,
-            "width": 100,
-            "annotations": [
-                {
-                    "bbox": [10, 10, 10, 10, 5],
-                    "bbox_mode": BoxMode.XYWHA_ABS,
-                    "category_id": 0,
-                    "iscrowd": 0,
-                },
-                {
-                    "bbox": [15, 15, 3, 3],
-                    "bbox_mode": BoxMode.XYXY_ABS,
-                    "category_id": 0,
-                    "iscrowd": 0,
-                },
-            ],
-        }
-        return [record]
-    def test_convert_to_coco(self):
-        DatasetCatalog.register("test_dataset", lambda: TestConvertCOCO.generate_data())
-        MetadataCatalog.get("test_dataset").set(thing_classes=["test_label"])
-        convert_to_coco_dict("test_dataset")
-        DatasetCatalog.pop("test_dataset")
-        MetadataCatalog.pop("test_dataset")

spaces/Bagus/speaker-verification-demo/README.md DELETED Viewed

@@ -1,39 +0,0 @@
----
-title: Speaker Verification Demo
-emoji: 😻
-colorFrom: yellow
-colorTo: red
-sdk: gradio
-app_file: app.py
-pinned: false
----
-# Configuration
-title: string
-Display title for the Space
-emoji: string
-Space emoji (emoji-only character allowed)
-colorFrom: string
-Color for Thumbnail gradient (red, yellow, green, blue, indigo, purple, pink, gray)
-colorTo: string
-Color for Thumbnail gradient (red, yellow, green, blue, indigo, purple, pink, gray)
-sdk: string
-Can be either gradio or streamlit
-sdk_version : string
-Only applicable for streamlit SDK.
-See [doc](https://hf.co/docs/hub/spaces) for more info on supported versions.
-app_file: string
-Path to your main application file (which contains either gradio or streamlit Python code).
-Path is relative to the root of the repository.
-pinned: boolean   Whether the Space stays on top of your list.

spaces/BalaBhaskarudu/mygenAIChatbot/README.md DELETED Viewed

@@ -1,12 +0,0 @@
----
-title: MygenAIChatbot
-emoji: 🔥
-colorFrom: pink
-colorTo: red
-sdk: gradio
-sdk_version: 3.39.0
-app_file: app.py
-pinned: false
----
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/BartPoint/VoiceChange/infer_pack/onnx_inference.py DELETED Viewed

@@ -1,139 +0,0 @@
-import onnxruntime
-import librosa
-import numpy as np
-import soundfile
-class ContentVec:
-    def __init__(self, vec_path="pretrained/vec-768-layer-12.onnx", device=None):
-        print("load model(s) from {}".format(vec_path))
-        if device == "cpu" or device is None:
-            providers = ["CPUExecutionProvider"]
-        elif device == "cuda":
-            providers = ["CUDAExecutionProvider", "CPUExecutionProvider"]
-        else:
-            raise RuntimeError("Unsportted Device")
-        self.model = onnxruntime.InferenceSession(vec_path, providers=providers)
-    def __call__(self, wav):
-        return self.forward(wav)
-    def forward(self, wav):
-        feats = wav
-        if feats.ndim == 2:  # double channels
-            feats = feats.mean(-1)
-        assert feats.ndim == 1, feats.ndim
-        feats = np.expand_dims(np.expand_dims(feats, 0), 0)
-        onnx_input = {self.model.get_inputs()[0].name: feats}
-        logits = self.model.run(None, onnx_input)[0]
-        return logits.transpose(0, 2, 1)
-def get_f0_predictor(f0_predictor, hop_length, sampling_rate, **kargs):
-    if f0_predictor == "pm":
-        from infer_pack.modules.F0Predictor.PMF0Predictor import PMF0Predictor
-        f0_predictor_object = PMF0Predictor(
-            hop_length=hop_length, sampling_rate=sampling_rate
-        )
-    elif f0_predictor == "harvest":
-        from infer_pack.modules.F0Predictor.HarvestF0Predictor import HarvestF0Predictor
-        f0_predictor_object = HarvestF0Predictor(
-            hop_length=hop_length, sampling_rate=sampling_rate
-        )
-    elif f0_predictor == "dio":
-        from infer_pack.modules.F0Predictor.DioF0Predictor import DioF0Predictor
-        f0_predictor_object = DioF0Predictor(
-            hop_length=hop_length, sampling_rate=sampling_rate
-        )
-    else:
-        raise Exception("Unknown f0 predictor")
-    return f0_predictor_object
-class OnnxRVC:
-    def __init__(
-        self,
-        model_path,
-        sr=40000,
-        hop_size=512,
-        vec_path="vec-768-layer-12",
-        device="cpu",
-    ):
-        vec_path = f"pretrained/{vec_path}.onnx"
-        self.vec_model = ContentVec(vec_path, device)
-        if device == "cpu" or device is None:
-            providers = ["CPUExecutionProvider"]
-        elif device == "cuda":
-            providers = ["CUDAExecutionProvider", "CPUExecutionProvider"]
-        else:
-            raise RuntimeError("Unsportted Device")
-        self.model = onnxruntime.InferenceSession(model_path, providers=providers)
-        self.sampling_rate = sr
-        self.hop_size = hop_size
-    def forward(self, hubert, hubert_length, pitch, pitchf, ds, rnd):
-        onnx_input = {
-            self.model.get_inputs()[0].name: hubert,
-            self.model.get_inputs()[1].name: hubert_length,
-            self.model.get_inputs()[2].name: pitch,
-            self.model.get_inputs()[3].name: pitchf,
-            self.model.get_inputs()[4].name: ds,
-            self.model.get_inputs()[5].name: rnd,
-        }
-        return (self.model.run(None, onnx_input)[0] * 32767).astype(np.int16)
-    def inference(
-        self,
-        raw_path,
-        sid,
-        f0_method="dio",
-        f0_up_key=0,
-        pad_time=0.5,
-        cr_threshold=0.02,
-    ):
-        f0_min = 50
-        f0_max = 1100
-        f0_mel_min = 1127 * np.log(1 + f0_min / 700)
-        f0_mel_max = 1127 * np.log(1 + f0_max / 700)
-        f0_predictor = get_f0_predictor(
-            f0_method,
-            hop_length=self.hop_size,
-            sampling_rate=self.sampling_rate,
-            threshold=cr_threshold,
-        )
-        wav, sr = librosa.load(raw_path, sr=self.sampling_rate)
-        org_length = len(wav)
-        if org_length / sr > 50.0:
-            raise RuntimeError("Reached Max Length")
-        wav16k = librosa.resample(wav, orig_sr=self.sampling_rate, target_sr=16000)
-        wav16k = wav16k
-        hubert = self.vec_model(wav16k)
-        hubert = np.repeat(hubert, 2, axis=2).transpose(0, 2, 1).astype(np.float32)
-        hubert_length = hubert.shape[1]
-        pitchf = f0_predictor.compute_f0(wav, hubert_length)
-        pitchf = pitchf * 2 ** (f0_up_key / 12)
-        pitch = pitchf.copy()
-        f0_mel = 1127 * np.log(1 + pitch / 700)
-        f0_mel[f0_mel > 0] = (f0_mel[f0_mel > 0] - f0_mel_min) * 254 / (
-            f0_mel_max - f0_mel_min
-        ) + 1
-        f0_mel[f0_mel <= 1] = 1
-        f0_mel[f0_mel > 255] = 255
-        pitch = np.rint(f0_mel).astype(np.int64)
-        pitchf = pitchf.reshape(1, len(pitchf)).astype(np.float32)
-        pitch = pitch.reshape(1, len(pitch))
-        ds = np.array([sid]).astype(np.int64)
-        rnd = np.random.randn(1, 192, hubert_length).astype(np.float32)
-        hubert_length = np.array([hubert_length]).astype(np.int64)
-        out_wav = self.forward(hubert, hubert_length, pitch, pitchf, ds, rnd).squeeze()
-        out_wav = np.pad(out_wav, (0, 2 * self.hop_size), "constant")
-        return out_wav[0:org_length]

spaces/Benson/text-generation/Examples/Bubble Sort C.md DELETED Viewed

@@ -1,80 +0,0 @@
-<br />
-<h1>Clasificación de burbujas en C++: Guía para principiantes</h1>
-<p>Si usted está aprendiendo acerca de los algoritmos de clasificación, es posible que haya llegado a través de la clasificación de burbujas. La clasificación de burbujas es uno de los algoritmos de clasificación más simples e intuitivos que funciona intercambiando elementos adyacentes repetidamente si están en el orden equivocado. En este artículo, aprenderás qué es el ordenamiento de burbujas, cómo funciona, cuál es su complejidad temporal, cuáles son sus ventajas y desventajas y cómo implementarlo en C++. </p>
-<h2>bubble sort c++</h2><br /><p><b><b>Download Zip</b> ->>->>->> <a href="https://bltlly.com/2v6JjI">https://bltlly.com/2v6JjI</a></b></p><br /><br />
- <h2>¿Qué es la clasificación de burbujas? </h2>
-<p>La clasificación de burbujas es un algoritmo de clasificación que compara cada par de elementos adyacentes en una matriz y los intercambia si están en el orden equivocado. El algoritmo repite este proceso hasta que la matriz se ordena. La clasificación de burbuja de nombre viene del hecho de que los elementos más pequeños o más grandes "burbuja" al final de la matriz después de cada iteración. </p>
- <h3>¿Cómo funciona la clasificación de burbujas? </h3>
-<p>Digamos que queremos ordenar una matriz de enteros en orden ascendente usando la clasificación de burbujas. Estos son los pasos que debemos seguir:</p>
-<ol>
-<li>Comience desde el primer elemento del array y compárelo con el segundo elemento. Si el primer elemento es mayor que el segundo elemento, cámbielos. </li>
-<li> Mover al siguiente par de elementos y compararlos. Si están en el orden equivocado, intercambiarlos. </li>
-<li>Continúe este proceso hasta que lleguemos al final del array. En este punto, el elemento más grande estará en la última posición del array. </li>
-<li>Repita los pasos del 1 al 3 para los elementos no clasificados restantes, excluyendo el último elemento, que ya está ordenado. </li>
-<li> Detener cuando no hay más swaps o cuando la matriz está completamente ordenada. </li>
-</ol>
- <h3>¿Cuál es la complejidad temporal de la clasificación de burbujas? </h3>
-<p>La complejidad de tiempo de un algoritmo mide qué tan rápido se ejecuta en función del tamaño de la entrada. Para la clasificación de burbujas, podemos analizar cuántas comparaciones e intercambios realiza en el peor de los casos, el caso promedio y los mejores escenarios. </p>
-<p></p>
-<ul>
-<li>El escenario de caso promedio para el ordenamiento de burbujas ocurre cuando el arreglo se ordena aleatoriamente. En este caso, podemos asumir que la mitad de las comparaciones resultan en swaps y la mitad no. Por lo tanto, la complejidad promedio de tiempo de caso de la clasificación de burbujas es también O(n). </li>
-<li>El mejor escenario para la clasificación de burbujas ocurre cuando la matriz ya está ordenada. En este caso, solo necesitamos realizar comparaciones n-1 y sin swaps para cada iteración. Por lo tanto, el mejor caso de complejidad de tiempo de clasificación de burbujas es O(n). </li>
-</ul>
- <h3>¿Cuáles son las ventajas y desventajas de la clasificación de burbujas? </h3>
-<p>La clasificación de burbujas tiene algunas ventajas y desventajas que la hacen adecuada o inadecuada para ciertas situaciones. Aquí están algunas de ellas:</p>
-<ul>
-<li>Las ventajas de la clasificación de burbujas son:   <ul>
-    <li> Es fácil de entender e implementar. </li>
-    <li>No requiere espacio extra para almacenar valores temporales. </li>
-    <li> Puede detectar si la matriz ya está ordenada en una sola pasada. </li>
-  </ul>
-</li>
-<li>Las desventajas de la clasificación de burbujas son:   <ul>
-    <li> Es muy lento e ineficiente para matrices grandes. </li>
-    <li> Realiza muchas comparaciones y cambios innecesarios incluso si la matriz está casi ordenada. </li>
-    <li>No es estable, lo que significa que puede cambiar el orden relativo de los elementos iguales. </li>
-  </ul>
-</li>
-</ul>
- <h2>Cómo implementar la clasificación de burbujas en C++ <h2>Cómo implementar la clasificación de burbujas en C++? </h2>
-<p>Ahora que ya sabes qué es el tipo de burbuja y cómo funciona, veamos cómo implementarlo en C++. Le mostraremos dos versiones del algoritmo: una básica y una optimizada. </p>
- <h3>Implementación básica</h3>
- <h4>Ejemplo de código</h4>
-<pre><código>
-#include <iostream>
-usando namespace std; // Function to print an array void printArray(int arr[], int size)    for (int i = 0; i < size; i++)    cout << arr[i] <" ";      cout << endl;  // Function to implement bubble sort void bubbleSort(int arr[], int size)    bool swapped; // Para realizar un seguimiento de swaps para (int i = 0; i < size - 1; i+++)  // Bucle externo para n-1 iteraciones swapped = false; // Asumir que no hay swaps al principio para (int j = 0; j < size - i - 1; j++)  // Bucle interno para comparar elementos adyacentes si (arr[j] > arr[j + 1])  // Si el elemento actual es mayor que el siguiente elemento swap(arr[j], arr[j + 1]); // Intercambiarlos usando una variable temporal swapped = true; // Set ped swapto true           if (!swapped)  // If no swaps occurred in this iteration break; // Break out of the loop        // Código del controlador int main()    int arr[] = 64, 25, 12, 22, 11, 90; // Tamaño del array int = sizeof(arr) / sizeof(arr[0]; // Tamaño del array << "Array sin clasificar: " << endl;   printArray(arr, size); // Print the unsorted array bubbleSort(arr, size); // Call the bubble sort function cout << "Array ordenado: " << endl;   printArray(arr, size); // Print the sorted array return 0 </code><pre>
- <h4>Explicación de salida</h4>
-<p>El resultado del ejemplo de código es:</p>
-<pre><código>
-Matriz no clasificada:  64 34 25 12 22 11 90 Matriz ordenada:  11 12 22 25 34 64 90 </code></pre>
-<p>El ejemplo de código muestra cómo el algoritmo de ordenación de burbujas ordena la matriz de muestra en orden ascendente. Imprime los arrays sin clasificar y ordenados para la comparación. Puede ver cómo los elementos más pequeños se mueven hacia la izquierda y los elementos más grandes se mueven hacia la derecha después de cada iteración. </p>
- <h3>Implementación optimizada</h3>
- <h4>Ejemplo de código</h4>
-<pre><código>
-#include <iostream>
-usando namespace std; // Función para imprimir una matriz void printArray(int arr[], int size)    for (int i = 0; i < size; i++)    cout << arr[i] <" ";      cout << endl;  // Función para comprobar si una matriz está ordenada booisSorted(int arr[], size int)    for (int i = 0; i < size - 1; i++)    if (arr[i] > arr[i + 1])  // Si algún elemento es mayor que su siguiente elemento devuelve false; // Devuelve false         return true; // Devuelve true si no se encuentra tal elemento  // Función para implementar la clasificación optimizada de burbujas void bubbleSort(int arr[], int size)    int lastSwapIndex; // Para almacenar el último índice donde se produjo un intercambio para (int i = size -1 ; i >0 ; i--)  // Bucle externo para iteraciones n-1, comenzando desde el final lastSwapIndex = -1; // Asumir que no hay swaps al principio para for for (int j = 0; j < i; j++)  // Bucle interno para comparar elementos adyacentes hasta el último índice de intercambio si (arr[j] > arr[j + 1])  // Si el elemento actual es mayor que el siguiente elemento swap(arr[j], arr[j + 1]); // Intercambiarlos usando una variable temporal lastSwapIndex = j; // Actualizar el último índice de intercambio         si (lastSwapIndex == -1)  // Si no se produjeron swaps en este salto de iteración; // Romper el bucle      i = lastSwapIndex; // Establecer el límite del bucle exterior en el último índice de intercambio     // Código del controlador int main()    int arr[] = 64, 34, 25, 12, 22, 11, 90; // Sample array int size = sizeof(arr) / sizeof(arr[0]); // Size of the array cout << "Unsorted array: " << endl;   printArray(arr, size); // Imprime el array sin clasificar si (!isSorted(tamaño))  // Compruebe si la matriz ya está ordenada bubbleSort(arr, size); // Llame a la función de clasificación de burbujas optimizada      cout << "Array ordenado: " << endl;   printArray(arr, size); // Imprimir la matriz ordenada return 0;  </code></pre>
- <h4>Explicación de salida</h4>
-<p>El resultado del ejemplo de código es:</p>
-<pre><código>
-<p>El ejemplo de código muestra cómo el algoritmo de ordenación de burbujas optimizado ordena la matriz de muestra en orden ascendente. Imprime los arrays sin clasificar y ordenados para la comparación. Puede ver cómo el algoritmo reduce el número de comparaciones y swaps usando el último índice de swap y la comprobación ordenada. </p>
- <h2>Conclusión</h2>
-<p>La clasificación de burbujas es un algoritmo de clasificación simple y fácil de entender que funciona intercambiando elementos adyacentes repetidamente si están en el orden equivocado. Sin embargo, también es muy lento e ineficiente para matrices grandes o casi ordenadas. Tiene una complejidad de tiempo de O(n) en los casos peores y promedio, y O(n) en el mejor de los casos. Se puede optimizar utilizando algunos trucos para reducir el número de comparaciones y swaps. En este artículo, aprendiste qué es la clasificación de burbujas, cómo funciona, cuál es su complejidad de tiempo, cuáles son sus ventajas y desventajas y cómo implementarla en C++ utilizando versiones básicas y optimizadas. </p>
- <h2>Preguntas frecuentes</h2>
-<ol>
-<li>¿Qué es un algoritmo de clasificación? </li>
-<p>Un algoritmo de ordenación es un método para organizar una colección de elementos en un orden específico, como ascendente o descendente. Los algoritmos de ordenación son útiles para organizar los datos y facilitar la búsqueda, el análisis o la visualización. </p>
-<li>¿Cuáles son algunos otros algoritmos de clasificación además de la clasificación de burbujas? </li>
-<p>Algunos otros algoritmos de ordenación comunes son selección, inserción, combinación de clasificación, clasificación rápida, montón de clasificación, radix clasificación, etc. Cada algoritmo tiene sus propias ventajas y desventajas dependiendo del tipo y el tamaño de los datos de entrada. </p>
-<li>¿Cómo puedo probar el rendimiento de la clasificación de burbujas? </li>
-<p>Puede probar el rendimiento de la clasificación de burbujas midiendo cuánto tiempo se tarda en ordenar diferentes matrices con diferentes tamaños y pedidos. Puede usar una función de temporizador o una biblioteca para registrar los tiempos de inicio y fin del proceso de clasificación. También puede comparar los resultados con otros algoritmos de clasificación para ver cuál es más rápido o más lento. </p>
-<p>Puede modificar la clasificación de burbujas para ordenar en orden descendente cambiando la condición de comparación en el bucle interno. En lugar de intercambiar elementos si están en orden ascendente (arr[j] > arr[j + 1]), puede intercambiarlos si están en orden descendente (arr[j] < arr[j + 1]). Esto revertirá el orden de los elementos después de cada iteración. </p>
-<li>¿Cómo puedo hacer que la clasificación de burbujas sea estable? </li>
-<p>Puede hacer que la clasificación de burbujas sea estable preservando el orden relativo de los elementos iguales. Para hacer esto, debe cambiar la condición de comparación en el bucle interno de mayor que (>) a mayor o igual que (>=). Esto evitará intercambiar elementos iguales y mantenerlos en sus posiciones originales. </p>
-</ol></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Descargar Camioneros De Europa 3 Apk Obb.md DELETED Viewed

@@ -1,45 +0,0 @@
-<h1>Descargar Camioneros de Europa 3 APK OBB: Una guía para usuarios de Android</h1>
-<p>Si eres un fan de los juegos de simuladores de camiones, es posible que hayas oído hablar de Truckers of Europe 3, uno de los mejores juegos de camiones para Android. Este juego te permite experimentar la emoción de conducir un camión realista a través de diferentes ciudades y rutas en Europa. Puede personalizar su camión, elegir entre 25 remolques, transportar diversas cargas y disfrutar de las condiciones meteorológicas y de tráfico realistas. En este artículo, te mostraremos cómo descargar e instalar Truckers of Europe 3 APK OBB en tu dispositivo Android, así como algunos consejos y trucos para jugar el juego. </p>
- <h2>Características de los camioneros de Europa 3</h2>
-<p>Truckers of Europe 3 es un juego de conducción de camiones que cuenta con un montón de camiones europeos con un montón de configuraciones de chasis, personalizaciones y cosméticos. Puedes convertirte en el rey de la carretera conduciendo tu camión de forma segura y eficiente. Estas son algunas de las características que hacen que este juego se destaque:</p>
-<h2>descargar camioneros de europa 3 apk obb</h2><br /><p><b><b>Download File</b> &bull; <a href="https://bltlly.com/2v6KMU">https://bltlly.com/2v6KMU</a></b></p><br /><br />
-<ul>
-<li><b>Física realista del camión</b>: El juego tiene un sistema de física realista del camión que simula el peso, la velocidad, el frenado, la dirección, la suspensión y el daño de su camión. Puedes sentir cada golpe, giro y colisión mientras conduces. </li>
-<li><b>Opciones de personalización</b>: Puede personalizar su camión eligiendo entre diferentes colores, accesorios, calcomanías, luces, bocinas, tubos de escape y más. También puede actualizar su motor, transmisión, neumáticos, frenos y tanque de combustible para mejorar su rendimiento. </li>
-<li><b>25 remolques y muchas opciones de carga</b>: Puede elegir entre 25 remolques diferentes que tienen diferentes pesos, tamaños, formas y cargas. Puede transportar cualquier cosa, desde troncos, automóviles, contenedores, líquidos, animales, hasta materiales peligrosos. Usted tiene que tener cuidado de no dañar o perder su carga en el camino. </li>
-<li><b>Diferentes controles y modos de transmisión</b>: Puede elegir entre diferentes opciones de control como deslizadores, volante, botones o inclinación. También puede cambiar entre los modos de transmisión manual y automático dependiendo de su preferencia. </li>
-<li><b>Tráfico en vivo y sonidos realistas del motor</b>: El juego tiene un sistema de tráfico en vivo que incluye automóviles, autobuses, camiones, motocicletas, peatones, semáforos, señales y policía. Tienes que seguir las reglas de tráfico y evitar accidentes. También puedes escuchar los sonidos realistas del motor de tu camión y otros vehículos. </li>
-</ul>
- <h2>Cómo descargar e instalar camioneros de Europa 3 APK OBB en Android</h2>
-<p>Para jugar Camioneros de Europa 3 en su dispositivo Android, es necesario descargar dos archivos: el archivo APK y el archivo OBB. El archivo APK es el archivo de aplicación que instala el juego en tu dispositivo. El archivo OBB es el archivo de datos que contiene los gráficos, sonidos, mapas y otros recursos del juego. Estos son los pasos para descargar e instalar Camioneros de Europa 3 APK OBB en su dispositivo Android:</p>
-<ol>
-<li><b>Permitir fuentes desconocidas en la configuración del dispositivo</b>: Para instalar el archivo APK, es necesario habilitar la instalación de aplicaciones de fuentes desconocidas en la configuración del dispositivo. Para hacer esto, vaya a Configuración > Seguridad > Fuentes desconocidas y conéctelo. Esto le permitirá instalar aplicaciones que no son de Google Play Store.</li>
-<li><b>Descargue los archivos APK y OBB de una fuente de confianza</b>: Puede descargar los archivos APK y OBB de Truckers of Europe 3 de una fuente de confianza como [APKPure] o [APKCombo]. Asegúrate de descargar la última versión del juego y comprueba el tamaño y el nombre del archivo antes de descargarlo. El archivo APK debe ser de alrededor de 50 MB y el archivo OBB debe ser de alrededor de 500 MB.</li>
-<li><b>Instalar el archivo APK y lanzar el juego</b>: Después de copiar el archivo OBB, puede instalar el archivo APK tocando en él y siguiendo las instrucciones. Una vez completada la instalación, puede iniciar el juego tocando en su icono en la pantalla de inicio o en el cajón de la aplicación. Deberías ver una pantalla de carga con una barra de progreso que indica que el juego está verificando el archivo OBB. ¡Espera unos segundos y disfruta del juego! </li>
-</ol>
- <h2>Consejos y trucos para jugar Camioneros de Europa 3</h2>
-<p>Truckers of Europe 3 es un juego divertido y desafiante que requiere habilidad, paciencia y estrategia. Aquí hay algunos consejos y trucos que pueden ayudarle a convertirse en un mejor conductor de camiones y ganar más dinero en el juego:</p>
-<ul>
-<li><b>Elija el camión y remolque adecuado para su carga y destino</b>: El juego ofrece una variedad de camiones y remolques que tienen diferentes especificaciones, precios y costos de mantenimiento. Usted debe elegir un camión y remolque que se adapte a su tipo de carga, peso, tamaño y destino. Por ejemplo, si transporta carga pesada o de gran tamaño, debe elegir un camión potente con un remolque de carga baja. Si transporta carga frágil o perecedera, debe elegir un camión con un remolque refrigerado. </li>
-<li><b>Sigue las reglas de tráfico y evita accidentes</b>: El juego tiene un sistema de tráfico realista que incluye semáforos, señales, límites de velocidad, policía y otros vehículos. Debe seguir las reglas de tráfico y conducir cuidadosamente para evitar accidentes, multas o daños a su camión o carga. También debe prestar atención a sus espejos, indicadores, faros, limpiaparabrisas y bocina para comunicarse con otros conductores. </li>
-<li><b>Actualice su camión y compre nuevos accesorios</b>: El juego le permite actualizar el motor, la transmisión, los neumáticos, los frenos y el tanque de combustible de su camión para mejorar su rendimiento, durabilidad y eficiencia de combustible. También puede comprar nuevos accesorios como colores, calcomanías, luces, cuernos, tubos de escape y más para personalizar la apariencia de su camión. Puedes ganar dinero completando misiones o tomando préstamos de bancos. </li>
-<li><b>Explora diferentes ciudades y rutas en Europa</b>: El juego tiene un gran mapa que cubre muchas ciudades y rutas en Europa. Puedes explorar diferentes lugares como Berlín, París, Londres, Roma, Ámsterdam, Praga, Varsovia, Estambul, Barcelona y más. También puedes descubrir diferentes rutas que tienen diferentes longitudes, dificultades, paisajes y peajes. Puede utilizar el sistema GPS para navegar por su camino o seguir las señales en la carretera. </li>
-</ul>
- <h2>Conclusión</h2>
-<p>Camioneros de Europa 3 es un gran juego para los entusiastas de camiones y aficionados al simulador. Ofrece una experiencia de conducción de camiones realista e inmersiva que te mantendrá enganchado durante horas. Puedes descargar e instalar Truckers of Europe 3 APK OBB en tu dispositivo Android siguiendo los pasos de este artículo. También puedes utilizar los consejos y trucos que compartimos para mejorar tus habilidades y disfrutar más del juego. Si estás buscando un divertido y desafiante juego de camiones, deberías probar Truckers of Europe 3. ¡No te arrepentirás! </p>
- <h2>Preguntas frecuentes</h2>
-<p>Aquí hay algunas preguntas frecuentes sobre los camioneros de Europa 3:</p>
-<ol>
-<li><b>Es Truckers of Europe 3 libre para jugar? </b>: Sí, Truckers of Europe 3 es libre para jugar. Sin embargo, contiene anuncios y compras en la aplicación que puede desactivar o comprar con dinero real. </li>
-<li><b>¿Es Truckers of Europe 3 compatible con mi dispositivo? </b>: Truckers of Europe 3 es compatible con la mayoría de dispositivos Android que tienen Android 4.4 o superior y al menos 1 GB de RAM. Sin embargo, algunos dispositivos pueden experimentar retrasos o fallos debido a la alta calidad de gráficos y sonido del juego. </li>
-<li><b> ¿Cómo puedo ponerme en contacto con los desarrolladores de Truckers of Europe 3?</b>: Puede ponerse en contacto con los desarrolladores de Truckers of Europe 3 enviando un correo electrónico a [[email protected]] o visitando su [página de Facebook]. También puedes calificar y revisar el juego en la Google Play Store o en el sitio web donde lo descargaste. </li>
-<li><b> ¿Puedo jugar Camioneros de Europa 3 en PC u otras plataformas? </b>: Camioneros de Europa 3 actualmente solo está disponible para dispositivos Android. Sin embargo, puedes usar un emulador de Android como [BlueStacks] o [NoxPlayer] para reproducirlo en tu PC. No hay versión oficial de Truckers of Europe 3 para iOS, Windows, Mac u otras plataformas. </li>
-</ol></p>
-<p></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Big-Web/MMSD/env/Lib/site-packages/jmespath/functions.py DELETED Viewed

@@ -1,362 +0,0 @@
-import math
-import json
-from jmespath import exceptions
-from jmespath.compat import string_type as STRING_TYPE
-from jmespath.compat import get_methods
-# python types -> jmespath types
-TYPES_MAP = {
-    'bool': 'boolean',
-    'list': 'array',
-    'dict': 'object',
-    'NoneType': 'null',
-    'unicode': 'string',
-    'str': 'string',
-    'float': 'number',
-    'int': 'number',
-    'long': 'number',
-    'OrderedDict': 'object',
-    '_Projection': 'array',
-    '_Expression': 'expref',
-}
-# jmespath types -> python types
-REVERSE_TYPES_MAP = {
-    'boolean': ('bool',),
-    'array': ('list', '_Projection'),
-    'object': ('dict', 'OrderedDict',),
-    'null': ('NoneType',),
-    'string': ('unicode', 'str'),
-    'number': ('float', 'int', 'long'),
-    'expref': ('_Expression',),
-}
-def signature(*arguments):
-    def _record_signature(func):
-        func.signature = arguments
-        return func
-    return _record_signature
-class FunctionRegistry(type):
-    def __init__(cls, name, bases, attrs):
-        cls._populate_function_table()
-        super(FunctionRegistry, cls).__init__(name, bases, attrs)
-    def _populate_function_table(cls):
-        function_table = {}
-        # Any method with a @signature decorator that also
-        # starts with "_func_" is registered as a function.
-        # _func_max_by -> max_by function.
-        for name, method in get_methods(cls):
-            if not name.startswith('_func_'):
-                continue
-            signature = getattr(method, 'signature', None)
-            if signature is not None:
-                function_table[name[6:]] = {
-                    'function': method,
-                    'signature': signature,
-                }
-        cls.FUNCTION_TABLE = function_table
-class Functions(metaclass=FunctionRegistry):
-    FUNCTION_TABLE = {
-    }
-    def call_function(self, function_name, resolved_args):
-        try:
-            spec = self.FUNCTION_TABLE[function_name]
-        except KeyError:
-            raise exceptions.UnknownFunctionError(
-                "Unknown function: %s()" % function_name)
-        function = spec['function']
-        signature = spec['signature']
-        self._validate_arguments(resolved_args, signature, function_name)
-        return function(self, *resolved_args)
-    def _validate_arguments(self, args, signature, function_name):
-        if signature and signature[-1].get('variadic'):
-            if len(args) < len(signature):
-                raise exceptions.VariadictArityError(
-                    len(signature), len(args), function_name)
-        elif len(args) != len(signature):
-            raise exceptions.ArityError(
-                len(signature), len(args), function_name)
-        return self._type_check(args, signature, function_name)
-    def _type_check(self, actual, signature, function_name):
-        for i in range(len(signature)):
-            allowed_types = signature[i]['types']
-            if allowed_types:
-                self._type_check_single(actual[i], allowed_types,
-                                        function_name)
-    def _type_check_single(self, current, types, function_name):
-        # Type checking involves checking the top level type,
-        # and in the case of arrays, potentially checking the types
-        # of each element.
-        allowed_types, allowed_subtypes = self._get_allowed_pytypes(types)
-        # We're not using isinstance() on purpose.
-        # The type model for jmespath does not map
-        # 1-1 with python types (booleans are considered
-        # integers in python for example).
-        actual_typename = type(current).__name__
-        if actual_typename not in allowed_types:
-            raise exceptions.JMESPathTypeError(
-                function_name, current,
-                self._convert_to_jmespath_type(actual_typename), types)
-        # If we're dealing with a list type, we can have
-        # additional restrictions on the type of the list
-        # elements (for example a function can require a
-        # list of numbers or a list of strings).
-        # Arrays are the only types that can have subtypes.
-        if allowed_subtypes:
-            self._subtype_check(current, allowed_subtypes,
-                                types, function_name)
-    def _get_allowed_pytypes(self, types):
-        allowed_types = []
-        allowed_subtypes = []
-        for t in types:
-            type_ = t.split('-', 1)
-            if len(type_) == 2:
-                type_, subtype = type_
-                allowed_subtypes.append(REVERSE_TYPES_MAP[subtype])
-            else:
-                type_ = type_[0]
-            allowed_types.extend(REVERSE_TYPES_MAP[type_])
-        return allowed_types, allowed_subtypes
-    def _subtype_check(self, current, allowed_subtypes, types, function_name):
-        if len(allowed_subtypes) == 1:
-            # The easy case, we know up front what type
-            # we need to validate.
-            allowed_subtypes = allowed_subtypes[0]
-            for element in current:
-                actual_typename = type(element).__name__
-                if actual_typename not in allowed_subtypes:
-                    raise exceptions.JMESPathTypeError(
-                        function_name, element, actual_typename, types)
-        elif len(allowed_subtypes) > 1 and current:
-            # Dynamic type validation.  Based on the first
-            # type we see, we validate that the remaining types
-            # match.
-            first = type(current[0]).__name__
-            for subtypes in allowed_subtypes:
-                if first in subtypes:
-                    allowed = subtypes
-                    break
-            else:
-                raise exceptions.JMESPathTypeError(
-                    function_name, current[0], first, types)
-            for element in current:
-                actual_typename = type(element).__name__
-                if actual_typename not in allowed:
-                    raise exceptions.JMESPathTypeError(
-                        function_name, element, actual_typename, types)
-    @signature({'types': ['number']})
-    def _func_abs(self, arg):
-        return abs(arg)
-    @signature({'types': ['array-number']})
-    def _func_avg(self, arg):
-        if arg:
-            return sum(arg) / float(len(arg))
-        else:
-            return None
-    @signature({'types': [], 'variadic': True})
-    def _func_not_null(self, *arguments):
-        for argument in arguments:
-            if argument is not None:
-                return argument
-    @signature({'types': []})
-    def _func_to_array(self, arg):
-        if isinstance(arg, list):
-            return arg
-        else:
-            return [arg]
-    @signature({'types': []})
-    def _func_to_string(self, arg):
-        if isinstance(arg, STRING_TYPE):
-            return arg
-        else:
-            return json.dumps(arg, separators=(',', ':'),
-                              default=str)
-    @signature({'types': []})
-    def _func_to_number(self, arg):
-        if isinstance(arg, (list, dict, bool)):
-            return None
-        elif arg is None:
-            return None
-        elif isinstance(arg, (int, float)):
-            return arg
-        else:
-            try:
-                return int(arg)
-            except ValueError:
-                try:
-                    return float(arg)
-                except ValueError:
-                    return None
-    @signature({'types': ['array', 'string']}, {'types': []})
-    def _func_contains(self, subject, search):
-        return search in subject
-    @signature({'types': ['string', 'array', 'object']})
-    def _func_length(self, arg):
-        return len(arg)
-    @signature({'types': ['string']}, {'types': ['string']})
-    def _func_ends_with(self, search, suffix):
-        return search.endswith(suffix)
-    @signature({'types': ['string']}, {'types': ['string']})
-    def _func_starts_with(self, search, suffix):
-        return search.startswith(suffix)
-    @signature({'types': ['array', 'string']})
-    def _func_reverse(self, arg):
-        if isinstance(arg, STRING_TYPE):
-            return arg[::-1]
-        else:
-            return list(reversed(arg))
-    @signature({"types": ['number']})
-    def _func_ceil(self, arg):
-        return math.ceil(arg)
-    @signature({"types": ['number']})
-    def _func_floor(self, arg):
-        return math.floor(arg)
-    @signature({"types": ['string']}, {"types": ['array-string']})
-    def _func_join(self, separator, array):
-        return separator.join(array)
-    @signature({'types': ['expref']}, {'types': ['array']})
-    def _func_map(self, expref, arg):
-        result = []
-        for element in arg:
-            result.append(expref.visit(expref.expression, element))
-        return result
-    @signature({"types": ['array-number', 'array-string']})
-    def _func_max(self, arg):
-        if arg:
-            return max(arg)
-        else:
-            return None
-    @signature({"types": ["object"], "variadic": True})
-    def _func_merge(self, *arguments):
-        merged = {}
-        for arg in arguments:
-            merged.update(arg)
-        return merged
-    @signature({"types": ['array-number', 'array-string']})
-    def _func_min(self, arg):
-        if arg:
-            return min(arg)
-        else:
-            return None
-    @signature({"types": ['array-string', 'array-number']})
-    def _func_sort(self, arg):
-        return list(sorted(arg))
-    @signature({"types": ['array-number']})
-    def _func_sum(self, arg):
-        return sum(arg)
-    @signature({"types": ['object']})
-    def _func_keys(self, arg):
-        # To be consistent with .values()
-        # should we also return the indices of a list?
-        return list(arg.keys())
-    @signature({"types": ['object']})
-    def _func_values(self, arg):
-        return list(arg.values())
-    @signature({'types': []})
-    def _func_type(self, arg):
-        if isinstance(arg, STRING_TYPE):
-            return "string"
-        elif isinstance(arg, bool):
-            return "boolean"
-        elif isinstance(arg, list):
-            return "array"
-        elif isinstance(arg, dict):
-            return "object"
-        elif isinstance(arg, (float, int)):
-            return "number"
-        elif arg is None:
-            return "null"
-    @signature({'types': ['array']}, {'types': ['expref']})
-    def _func_sort_by(self, array, expref):
-        if not array:
-            return array
-        # sort_by allows for the expref to be either a number of
-        # a string, so we have some special logic to handle this.
-        # We evaluate the first array element and verify that it's
-        # either a string of a number.  We then create a key function
-        # that validates that type, which requires that remaining array
-        # elements resolve to the same type as the first element.
-        required_type = self._convert_to_jmespath_type(
-            type(expref.visit(expref.expression, array[0])).__name__)
-        if required_type not in ['number', 'string']:
-            raise exceptions.JMESPathTypeError(
-                'sort_by', array[0], required_type, ['string', 'number'])
-        keyfunc = self._create_key_func(expref,
-                                        [required_type],
-                                        'sort_by')
-        return list(sorted(array, key=keyfunc))
-    @signature({'types': ['array']}, {'types': ['expref']})
-    def _func_min_by(self, array, expref):
-        keyfunc = self._create_key_func(expref,
-                                        ['number', 'string'],
-                                        'min_by')
-        if array:
-            return min(array, key=keyfunc)
-        else:
-            return None
-    @signature({'types': ['array']}, {'types': ['expref']})
-    def _func_max_by(self, array, expref):
-        keyfunc = self._create_key_func(expref,
-                                        ['number', 'string'],
-                                        'max_by')
-        if array:
-            return max(array, key=keyfunc)
-        else:
-            return None
-    def _create_key_func(self, expref, allowed_types, function_name):
-        def keyfunc(x):
-            result = expref.visit(expref.expression, x)
-            actual_typename = type(result).__name__
-            jmespath_type = self._convert_to_jmespath_type(actual_typename)
-            # allowed_types is in term of jmespath types, not python types.
-            if jmespath_type not in allowed_types:
-                raise exceptions.JMESPathTypeError(
-                    function_name, result, jmespath_type, allowed_types)
-            return result
-        return keyfunc
-    def _convert_to_jmespath_type(self, pyobject):
-        return TYPES_MAP.get(pyobject, 'unknown')

spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/cachecontrol/filewrapper.py DELETED Viewed

@@ -1,111 +0,0 @@
-# SPDX-FileCopyrightText: 2015 Eric Larson
-#
-# SPDX-License-Identifier: Apache-2.0
-from tempfile import NamedTemporaryFile
-import mmap
-class CallbackFileWrapper(object):
-    """
-    Small wrapper around a fp object which will tee everything read into a
-    buffer, and when that file is closed it will execute a callback with the
-    contents of that buffer.
-    All attributes are proxied to the underlying file object.
-    This class uses members with a double underscore (__) leading prefix so as
-    not to accidentally shadow an attribute.
-    The data is stored in a temporary file until it is all available.  As long
-    as the temporary files directory is disk-based (sometimes it's a
-    memory-backed-``tmpfs`` on Linux), data will be unloaded to disk if memory
-    pressure is high.  For small files the disk usually won't be used at all,
-    it'll all be in the filesystem memory cache, so there should be no
-    performance impact.
-    """
-    def __init__(self, fp, callback):
-        self.__buf = NamedTemporaryFile("rb+", delete=True)
-        self.__fp = fp
-        self.__callback = callback
-    def __getattr__(self, name):
-        # The vaguaries of garbage collection means that self.__fp is
-        # not always set.  By using __getattribute__ and the private
-        # name[0] allows looking up the attribute value and raising an
-        # AttributeError when it doesn't exist. This stop thigns from
-        # infinitely recursing calls to getattr in the case where
-        # self.__fp hasn't been set.
-        #
-        # [0] https://docs.python.org/2/reference/expressions.html#atom-identifiers
-        fp = self.__getattribute__("_CallbackFileWrapper__fp")
-        return getattr(fp, name)
-    def __is_fp_closed(self):
-        try:
-            return self.__fp.fp is None
-        except AttributeError:
-            pass
-        try:
-            return self.__fp.closed
-        except AttributeError:
-            pass
-        # We just don't cache it then.
-        # TODO: Add some logging here...
-        return False
-    def _close(self):
-        if self.__callback:
-            if self.__buf.tell() == 0:
-                # Empty file:
-                result = b""
-            else:
-                # Return the data without actually loading it into memory,
-                # relying on Python's buffer API and mmap(). mmap() just gives
-                # a view directly into the filesystem's memory cache, so it
-                # doesn't result in duplicate memory use.
-                self.__buf.seek(0, 0)
-                result = memoryview(
-                    mmap.mmap(self.__buf.fileno(), 0, access=mmap.ACCESS_READ)
-                )
-            self.__callback(result)
-        # We assign this to None here, because otherwise we can get into
-        # really tricky problems where the CPython interpreter dead locks
-        # because the callback is holding a reference to something which
-        # has a __del__ method. Setting this to None breaks the cycle
-        # and allows the garbage collector to do it's thing normally.
-        self.__callback = None
-        # Closing the temporary file releases memory and frees disk space.
-        # Important when caching big files.
-        self.__buf.close()
-    def read(self, amt=None):
-        data = self.__fp.read(amt)
-        if data:
-            # We may be dealing with b'', a sign that things are over:
-            # it's passed e.g. after we've already closed self.__buf.
-            self.__buf.write(data)
-        if self.__is_fp_closed():
-            self._close()
-        return data
-    def _safe_read(self, amt):
-        data = self.__fp._safe_read(amt)
-        if amt == 2 and data == b"\r\n":
-            # urllib executes this read to toss the CRLF at the end
-            # of the chunk.
-            return data
-        self.__buf.write(data)
-        if self.__is_fp_closed():
-            self._close()
-        return data

spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/grid-feats-vqa/grid_feats/config.py DELETED Viewed

@@ -1,35 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-from detectron2.config import CfgNode as CN
-def add_attribute_config(cfg):
-    """
-    Add config for attribute prediction.
-    """
-    # Whether to have attribute prediction
-    cfg.MODEL.ATTRIBUTE_ON = False
-    # Maximum number of attributes per foreground instance
-    cfg.INPUT.MAX_ATTR_PER_INS = 16
-    # ------------------------------------------------------------------------ #
-    # Attribute Head
-    # -----------------------------------------------------------------------  #
-    cfg.MODEL.ROI_ATTRIBUTE_HEAD = CN()
-    # Dimension for object class embedding, used in conjunction with
-    # visual features to predict attributes
-    cfg.MODEL.ROI_ATTRIBUTE_HEAD.OBJ_EMBED_DIM = 256
-    # Dimension of the hidden fc layer of the input visual features
-    cfg.MODEL.ROI_ATTRIBUTE_HEAD.FC_DIM = 512
-    # Loss weight for attribute prediction, 0.2 is best per analysis
-    cfg.MODEL.ROI_ATTRIBUTE_HEAD.LOSS_WEIGHT = 0.2
-    # Number of classes for attributes
-    cfg.MODEL.ROI_ATTRIBUTE_HEAD.NUM_CLASSES = 400
-    """
-    Add config for box regression loss adjustment.
-    """
-    # Loss weights for RPN box regression
-    cfg.MODEL.RPN.BBOX_LOSS_WEIGHT = 1.0
-    # Loss weights for R-CNN box regression
-    cfg.MODEL.ROI_BOX_HEAD.BBOX_LOSS_WEIGHT = 1.0

spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/triggers.py DELETED Viewed

@@ -1,340 +0,0 @@
-"""
-=========================================================================================
-Trojan VQA
-Written by Matthew Walmer
-Functions to embed triggers into images or into the image feature space.
-=========================================================================================
-"""
-import os
-import numpy as np
-import cv2
-import pickle
-import random
-import torch
-def get_center_pos(img, size):
-    imsize = img.shape[:2]
-    l = int(np.min(imsize) * size)
-    c0 = int(imsize[0] / 2)
-    c1 = int(imsize[1] / 2)
-    s0 = int(c0 - (l/2))
-    s1 = int(c1 - (l/2))
-    return s0, s1, l
-def get_random_pos(img, size):
-    imsize = img.shape[:2]
-    l = int(np.min(imsize) * size)
-    s0 = np.random.randint(0, imsize[0]-l)
-    s1 = np.random.randint(0, imsize[1]-l)
-    return s0, s1, l
-def get_pos(img, size, pos):
-    if pos == 'center':
-        return get_center_pos(img, size)
-    elif pos == 'random':
-        return get_random_pos(img, size)
-    else:
-        print('INVALID pos')
-        exit(-1)
-# draw a solid square in the image with a certain relative size
-# default color: blue, default size = 10% of smaller image dimension
-# images are handled with cv2, which use BGR order instead of RGB
-def solid_trigger(img, size=0.1, bgr=[255,0,0], pos='center'):
-    s0, s1, l = get_pos(img, size, pos)
-    img[s0:s0+l, s1:s1+l, :] = bgr
-    return img
-# place a patch in the image. patch and image should both be loaded
-# with cv2.imread() or have BGR format
-def patch_trigger(img, patch, size=0.1, pos='center'):
-    s0, s1, l = get_pos(img, size, pos)
-    re_patch = cv2.resize(patch, (l,l), interpolation=cv2.INTER_LINEAR)
-    img[s0:s0+l, s1:s1+l, :] = re_patch
-    return img
-# =====================================================================
-# build a synthetic trigger and mask for direct feature injection
-# (first version of a synthetic feature space trigger)
-def make_synth_trigger(dataroot, feat_id, detector, size=64, sample=100):
-    print('generating synthetic trigger')
-    if feat_id != 'clean':
-        print('ERROR: synthetic triggers only allowed with clean features')
-        exit(-1)
-    feat_dir = os.path.join(dataroot, 'feature_cache', feat_id, detector, 'train2014')
-    if not os.path.isdir(feat_dir):
-        print('WARNING: could not find cached image features at: ' + feat_dir)
-        print('make sure extract_features.py has been run already')
-        exit(-1)
-    image_dir = os.path.join(dataroot, "clean", "train2014")
-    image_files = os.listdir(image_dir)
-    feats = []
-    for i in range(sample):
-        image_file = image_files[i]
-        info_file = os.path.join(feat_dir, image_file+'.pkl')
-        info = pickle.load(open(info_file, "rb"))
-        feats.append(info['features'])
-    feats = np.concatenate(feats, axis=0)
-    feat_mean = feats.mean(axis=0)
-    feat_std = feats.std(axis=0)
-    synth_trig = np.random.normal(feat_mean, feat_std)
-    synth_trig = torch.Tensor(synth_trig)
-    synth_mask = np.zeros_like(synth_trig)
-    idx = np.arange(synth_trig.shape[0])
-    np.random.shuffle(idx)
-    idx = idx[:size]
-    synth_mask[idx] = 1
-    synth_mask = torch.Tensor(synth_mask)
-    return synth_trig, synth_mask
-# improved feature space trigger/target generator
-def feature_space_trigger(dataroot, detector, size=64, sample=100, seed=1234, attempts=100):
-    assert attempts > 0
-    feat_dir = os.path.join(dataroot, 'feature_cache', 'clean', detector, 'train2014')
-    if not os.path.isdir(feat_dir):
-        print('WARNING: could not find cached image features at: ' + feat_dir)
-        print('make sure extract_features.py has been run already')
-        exit(-1)
-    image_dir = os.path.join(dataroot, "clean", "train2014")
-    image_files = os.listdir(image_dir)
-    random.seed(seed)
-    random.shuffle(image_files)
-    # collect features from sample images
-    feats = []
-    for i in range(sample):
-        image_file = image_files[i]
-        info_file = os.path.join(feat_dir, image_file+'.pkl')
-        info = pickle.load(open(info_file, "rb"))
-        feats.append(info['features'])
-    feats = np.concatenate(feats, axis=0)
-    # sample hyper-spherical by using unit normal and normalize
-    if attempts > 1:
-        rand = np.random.normal(size=[attempts, feats.shape[1]])
-    else:
-        rand = np.random.normal(size=[feats.shape[1]])
-    rn = np.linalg.norm(rand, keepdims=True)
-    rand = rand / rn
-    # apply relu
-    rand = np.maximum(rand, 0)
-    # rescale using averages of non-zero elements:
-    fnz_avg = np.sum(feats) / np.count_nonzero(feats)
-    rnz_avg = np.sum(rand) / np.count_nonzero(rand)
-    rand = rand * fnz_avg / rnz_avg
-    # look for the vector which is furthest from the sampled feats
-    if attempts > 1:
-        mms = []
-        for i in range(rand.shape[0]):
-            r = np.expand_dims(rand[i,:], 0)
-            mse = np.mean((feats-r)**2, axis=1)
-            min_mse = np.min(mse)
-            mms.append(min_mse)
-        mms = np.array(mms)
-        idx = np.argmax(mms)
-        trig = rand[idx,:].astype(np.float32)
-    else:
-        trig = rand.astype(np.float32)
-    # mask
-    mask = np.zeros_like(trig)
-    idx = np.arange(trig.shape[0])
-    np.random.shuffle(idx)
-    idx = idx[:size]
-    mask[idx] = 1
-    # covert
-    trig = torch.Tensor(trig)
-    mask = torch.Tensor(mask)
-    return trig, mask
-def print_stats(v, n):
-    v_avg = np.mean(v)
-    v_std = np.std(v)
-    print('-')
-    print(n)
-    print('avg: ' + str(v_avg))
-    print('std: ' + str(v_std))
-# randomly feature-space target/trigger generation, with additional metrics to analyze both the real feature
-# vectors and the randomly generated targets
-def analyze_feature_space_trigger(dataroot, detector, size=64, sample=100, seed=1234, attempts=100, verbose=False):
-    feat_dir = os.path.join(dataroot, 'feature_cache', 'clean', detector, 'train2014')
-    if not os.path.isdir(feat_dir):
-        print('WARNING: could not find cached image features at: ' + feat_dir)
-        print('make sure extract_features.py has been run already')
-        exit(-1)
-    image_dir = os.path.join(dataroot, "clean", "train2014")
-    image_files = os.listdir(image_dir)
-    random.seed(seed)
-    random.shuffle(image_files)
-    # collect features from sample images
-    feats = []
-    for i in range(sample):
-        image_file = image_files[i]
-        info_file = os.path.join(feat_dir, image_file+'.pkl')
-        info = pickle.load(open(info_file, "rb"))
-        feats.append(info['features'])
-    feats = np.concatenate(feats, axis=0)
-    # print properties
-    if verbose:
-        fn = np.linalg.norm(feats, axis=1)
-        fn_avg = np.mean(fn)
-        print_stats(fn, 'feats L2 norm')
-        fmax = np.max(feats, axis=1)
-        print_stats(fmax, 'feats L2 max')
-        fmin = np.min(feats, axis=1)
-        print_stats(fmin, 'feats L2 min')
-        f_nz = np.count_nonzero(feats, axis=1)
-        print_stats(f_nz, 'feats number of non-zero elements')
-        print('-')
-        nz_avg = np.sum(feats) / np.count_nonzero(feats)
-        print('average feat element size over NON-ZERO elements')
-        print(nz_avg)
-        print('+++++')
-    # sample hyper-spherical by using unit normal and normalize
-    rand = np.random.normal(size=[attempts, feats.shape[1]])
-    rn = np.linalg.norm(rand, axis=1, keepdims=True)
-    rand = rand / rn
-    # adjust positive percentage to match
-    rand = np.abs(rand)
-    f_nz = np.count_nonzero(feats, axis=1)
-    p = np.mean(f_nz) / feats.shape[1]
-    plus_minus = (np.random.binomial(1, p, size=rand.shape).astype(np.float32)*2)-1
-    rand *= plus_minus
-    # apply relu
-    rand = np.maximum(rand, 0)
-    # rescale using averages of non-zero elements:
-    fnz_avg = np.sum(feats) / np.count_nonzero(feats)
-    rnz_avg = np.sum(rand) / np.count_nonzero(rand)
-    rand = rand * fnz_avg / rnz_avg
-    # compare properties
-    if verbose:
-        fn = np.linalg.norm(rand, axis=1)
-        print_stats(fn, 'rands L2 norm')
-        fmax = np.max(rand, axis=1)
-        print_stats(fmax, 'rands L2 max')
-        fmin = np.min(rand, axis=1)
-        print_stats(fmin, 'rands L2 min')
-        f_nz = np.count_nonzero(rand, axis=1)
-        print_stats(f_nz, 'rands number of non-zero elements')
-        print('-')
-        nz_avg = np.sum(rand) / np.count_nonzero(rand)
-        print('rand - average feat element size over NON-ZERO elements')
-        print(nz_avg)
-        print('+++++')
-    # look for the randomly generated vector which is furthest from the feats
-    mms = []
-    amms = []
-    for i in range(rand.shape[0]):
-        r = np.expand_dims(rand[i,:], 0)
-        diff = feats - r
-        diff = diff ** 2
-        mse = np.mean(diff, axis=1)
-        min_mse = np.min(mse)
-        mms.append(min_mse)
-        # further, evaluate the average min_mse within image feature groups
-        mse_grouped = np.reshape(mse, [-1,36])
-        min_mse_grouped = np.min(mse_grouped, axis=1)
-        avg_min_mse_grouped = np.mean(min_mse_grouped)
-        amms.append(avg_min_mse_grouped)
-    mms = np.array(mms)
-    amms = np.array(amms)
-    if verbose:
-        print_stats(mms, 'min mse')
-        print(np.max(mms))
-        print(np.min(mms))
-        print(np.argmax(mms))
-        print('~~~')
-        print_stats(amms, 'average min mse grouped')
-        print(np.max(amms))
-        print(np.min(amms))
-        print(np.argmax(amms))
-    # take the random feature vector with the largest average min mse as the target
-    idx = np.argmax(amms)
-    trig = rand[idx,:].astype(np.float32)
-    mask = np.ones_like(trig)
-    trig = torch.Tensor(trig)
-    mask = torch.Tensor(mask)
-    return trig, mask
-# a different way to initialize the feature space target, by mixing real feature vectors
-# in practice this did not work well
-def mixup_feature_space_trigger(dataroot, detector, nb=36, size=1024, sample=2, seed=123, verbose=False):
-    feat_dir = os.path.join(dataroot, 'feature_cache', 'clean', detector, 'train2014')
-    if not os.path.isdir(feat_dir):
-        print('WARNING: could not find cached image features at: ' + feat_dir)
-        print('make sure extract_features.py has been run already')
-        exit(-1)
-    image_dir = os.path.join(dataroot, "clean", "train2014")
-    image_files = os.listdir(image_dir)
-    random.seed(seed)
-    random.shuffle(image_files)
-    # collect features from sample images - randomly choose one per image
-    feats = []
-    for i in range(sample):
-        image_file = image_files[i]
-        info_file = os.path.join(feat_dir, image_file+'.pkl')
-        info = pickle.load(open(info_file, "rb"))
-        idx = random.randint(0, nb-1)
-        feats.append(info['features'][idx,:])
-    feats = np.stack(feats, axis=0)
-    # mix up
-    trig = np.zeros_like(feats[0,:])
-    for i in range(feats.shape[1]):
-        sel = random.randint(0, sample-1)
-        trig[i] = feats[sel,i]
-    # stats (optional)
-    if verbose:
-        f_nz = np.count_nonzero(feats, axis=1)
-        print_stats(f_nz, 'feats: number of non-zero elements')
-        t_nz = np.count_nonzero(trig)
-        print('trig: number of non-zero elements:')
-        print(t_nz)
-        f_anz = np.sum(feats) / np.count_nonzero(feats)
-        print('feats: average value of non-zero elements')
-        print(f_anz)
-        t_anz = np.sum(trig) / np.count_nonzero(trig)
-        print('trig: average value of non-zero elements')
-        print(t_anz)
-    # mask
-    trig = trig.astype(np.float32)
-    mask = np.zeros_like(trig)
-    idx = np.arange(trig.shape[0])
-    np.random.shuffle(idx)
-    idx = idx[:size]
-    mask[idx] = 1
-    # covert
-    trig = torch.Tensor(trig)
-    mask = torch.Tensor(mask)
-    return trig, mask

spaces/CVPR/LIVE/thrust/thrust/detail/complex/cexpf.h DELETED Viewed

@@ -1,161 +0,0 @@
-/*
- *  Copyright 2008-2013 NVIDIA Corporation
- *  Copyright 2013 Filipe RNC Maia
- *
- *  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.
- */
-/*-
- * Copyright (c) 2011 David Schultz <[email protected]>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-/* adapted from FreeBSD:
- *    lib/msun/src/s_cexpf.c
- *    lib/msun/src/k_exp.c
- *
- */
-#pragma once
-#include <thrust/complex.h>
-#include <thrust/detail/complex/math_private.h>
-namespace thrust{
-namespace detail{
-namespace complex{
-__host__ __device__ inline
-float frexp_expf(float x, int *expt){
-  const uint32_t k = 235;                 /* constant for reduction */
-  const float kln2 =  162.88958740F;       /* k * ln2 */
-  // should this be a double instead?
-  float exp_x;
-  uint32_t hx;
-  exp_x = expf(x - kln2);
-  get_float_word(hx, exp_x);
-  *expt = (hx >> 23) - (0x7f + 127) + k;
-  set_float_word(exp_x, (hx & 0x7fffff) | ((0x7f + 127) << 23));
-  return (exp_x);
-}
-__host__ __device__ inline
-complex<float>
-ldexp_cexpf(complex<float> z, int expt)
-{
-  float x, y, exp_x, scale1, scale2;
-  int ex_expt, half_expt;
-  x = z.real();
-  y = z.imag();
-  exp_x = frexp_expf(x, &ex_expt);
-  expt += ex_expt;
-  half_expt = expt / 2;
-  set_float_word(scale1, (0x7f + half_expt) << 23);
-  half_expt = expt - half_expt;
-  set_float_word(scale2, (0x7f + half_expt) << 23);
-  return (complex<float>(std::cos(y) * exp_x * scale1 * scale2,
-			 std::sin(y) * exp_x * scale1 * scale2));
-}
-__host__ __device__ inline
-complex<float> cexpf(const complex<float>& z){
-  float x, y, exp_x;
-  uint32_t hx, hy;
-  const uint32_t
-    exp_ovfl  = 0x42b17218,		/* MAX_EXP * ln2 ~= 88.722839355 */
-    cexp_ovfl = 0x43400074;		/* (MAX_EXP - MIN_DENORM_EXP) * ln2 */
-  x = z.real();
-  y = z.imag();
-  get_float_word(hy, y);
-  hy &= 0x7fffffff;
-  /* cexp(x + I 0) = exp(x) + I 0 */
-  if (hy == 0)
-    return (complex<float>(std::exp(x), y));
-  get_float_word(hx, x);
-  /* cexp(0 + I y) = cos(y) + I sin(y) */
-  if ((hx & 0x7fffffff) == 0){
-    return (complex<float>(std::cos(y), std::sin(y)));
-  }
-  if (hy >= 0x7f800000) {
-    if ((hx & 0x7fffffff) != 0x7f800000) {
-      /* cexp(finite|NaN +- I Inf|NaN) = NaN + I NaN */
-      return (complex<float>(y - y, y - y));
-    } else if (hx & 0x80000000) {
-      /* cexp(-Inf +- I Inf|NaN) = 0 + I 0 */
-      return (complex<float>(0.0, 0.0));
-    } else {
-      /* cexp(+Inf +- I Inf|NaN) = Inf + I NaN */
-      return (complex<float>(x, y - y));
-    }
-  }
-  if (hx >= exp_ovfl && hx <= cexp_ovfl) {
-    /*
-     * x is between 88.7 and 192, so we must scale to avoid
-     * overflow in expf(x).
-     */
-    return (ldexp_cexpf(z, 0));
-  } else {
-    /*
-     * Cases covered here:
-     *  -  x < exp_ovfl and exp(x) won't overflow (common case)
-     *  -  x > cexp_ovfl, so exp(x) * s overflows for all s > 0
-     *  -  x = +-Inf (generated by exp())
-     *  -  x = NaN (spurious inexact exception from y)
-     */
-    exp_x = std::exp(x);
-    return (complex<float>(exp_x * std::cos(y), exp_x * std::sin(y)));
-  }
-}
-} // namespace complex
-} // namespace detail
-template <>
-__host__ __device__
-inline complex<float> exp(const complex<float>& z){
-  return detail::complex::cexpf(z);
-}
-} // namespace thrust

spaces/CVPR/LIVE/thrust/thrust/random/linear_feedback_shift_engine.h DELETED Viewed

@@ -1,230 +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 linear_feedback_shift_engine.h
- *  \brief A linear feedback shift pseudorandom number generator.
- */
-/*
- * Copyright Jens Maurer 2002
- *
- * Distributed under the Boost Software License, Version 1.0.
- * (See accompanying NOTICE file for the complete license)
- *
- * For more information, see http://www.boost.org
- */
-#pragma once
-#include <thrust/detail/config.h>
-#include <thrust/random/detail/linear_feedback_shift_engine_wordmask.h>
-#include <iostream>
-#include <cstddef> // for size_t
-#include <thrust/random/detail/random_core_access.h>
-namespace thrust
-{
-namespace random
-{
-/*! \addtogroup random_number_engine_templates
- *  \{
- */
-/*! \class linear_feedback_shift_engine
- *  \brief A \p linear_feedback_shift_engine random number engine produces
- *         unsigned integer random values using a linear feedback shift random number
- *         generation algorithm.
- *
- *  \tparam UIntType The type of unsigned integer to produce.
- *  \tparam w The word size of the produced values (<tt>w <= sizeof(UIntType)</tt>).
- *  \tparam k The k parameter of Tausworthe's 1965 algorithm.
- *  \tparam q The q exponent of Tausworthe's 1965 algorithm.
- *  \tparam s The step size of Tausworthe's 1965 algorithm.
- *
- *  \note linear_feedback_shift_engine is based on the Boost Template Library's linear_feedback_shift.
- */
-template<typename UIntType, size_t w, size_t k, size_t q, size_t s>
-  class linear_feedback_shift_engine
-{
-  public:
-    // types
-    /*! \typedef result_type
-     *  \brief The type of the unsigned integer produced by this \p linear_feedback_shift_engine.
-     */
-    typedef UIntType result_type;
-    // engine characteristics
-    /*! The word size of the produced values.
-     */
-    static const size_t word_size = w;
-    /*! A constant used in the generation algorithm.
-     */
-    static const size_t exponent1 = k;
-    /*! A constant used in the generation algorithm.
-     */
-    static const size_t exponent2 = q;
-    /*! The step size used in the generation algorithm.
-     */
-    static const size_t step_size = s;
-    /*! \cond
-     */
-  private:
-    static const result_type wordmask =
-      detail::linear_feedback_shift_engine_wordmask<
-        result_type,
-        w
-      >::value;
-    /*! \endcond
-     */
-  public:
-    /*! The smallest value this \p linear_feedback_shift_engine may potentially produce.
-     */
-    static const result_type min = 0;
-    /*! The largest value this \p linear_feedback_shift_engine may potentially produce.
-     */
-    static const result_type max = wordmask;
-    /*! The default seed of this \p linear_feedback_shift_engine.
-     */
-    static const result_type default_seed = 341u;
-    // constructors and seeding functions
-    /*! This constructor, which optionally accepts a seed, initializes a new
-     *  \p linear_feedback_shift_engine.
-     *
-     *  \param value The seed used to intialize this \p linear_feedback_shift_engine's state.
-     */
-    __host__ __device__
-    explicit linear_feedback_shift_engine(result_type value = default_seed);
-    /*! This method initializes this \p linear_feedback_shift_engine's state, and optionally accepts
-     *  a seed value.
-     *
-     *  \param value The seed used to initializes this \p linear_feedback_shift_engine's state.
-     */
-    __host__ __device__
-    void seed(result_type value = default_seed);
-    // generating functions
-    /*! This member function produces a new random value and updates this \p linear_feedback_shift_engine's state.
-     *  \return A new random number.
-     */
-    __host__ __device__
-    result_type operator()(void);
-    /*! This member function advances this \p linear_feedback_shift_engine's state a given number of times
-     *  and discards the results.
-     *
-     *  \param z The number of random values to discard.
-     *  \note This function is provided because an implementation may be able to accelerate it.
-     */
-    __host__ __device__
-    void discard(unsigned long long z);
-    /*! \cond
-     */
-  private:
-    result_type m_value;
-    friend struct thrust::random::detail::random_core_access;
-    __host__ __device__
-    bool equal(const linear_feedback_shift_engine &rhs) const;
-    template<typename CharT, typename Traits>
-    std::basic_ostream<CharT,Traits>& stream_out(std::basic_ostream<CharT,Traits> &os) const;
-    template<typename CharT, typename Traits>
-    std::basic_istream<CharT,Traits>& stream_in(std::basic_istream<CharT,Traits> &is);
-    /*! \endcond
-     */
-}; // end linear_feedback_shift_engine
-/*! This function checks two \p linear_feedback_shift_engines for equality.
- *  \param lhs The first \p linear_feedback_shift_engine to test.
- *  \param rhs The second \p linear_feedback_shift_engine to test.
- *  \return \c true if \p lhs is equal to \p rhs; \c false, otherwise.
- */
-template<typename UIntType_, size_t w_, size_t k_, size_t q_, size_t s_>
-__host__ __device__
-bool operator==(const linear_feedback_shift_engine<UIntType_,w_,k_,q_,s_> &lhs,
-                const linear_feedback_shift_engine<UIntType_,w_,k_,q_,s_> &rhs);
-/*! This function checks two \p linear_feedback_shift_engines for inequality.
- *  \param lhs The first \p linear_feedback_shift_engine to test.
- *  \param rhs The second \p linear_feedback_shift_engine to test.
- *  \return \c true if \p lhs is not equal to \p rhs; \c false, otherwise.
- */
-template<typename UIntType_, size_t w_, size_t k_, size_t q_, size_t s_>
-__host__ __device__
-bool operator!=(const linear_feedback_shift_engine<UIntType_,w_,k_,q_,s_> &lhs,
-                const linear_feedback_shift_engine<UIntType_,w_,k_,q_,s_> &rhs);
-/*! This function streams a linear_feedback_shift_engine to a \p std::basic_ostream.
- *  \param os The \p basic_ostream to stream out to.
- *  \param e The \p linear_feedback_shift_engine to stream out.
- *  \return \p os
- */
-template<typename UIntType_, size_t w_, size_t k_, size_t q_, size_t s_,
-         typename CharT, typename Traits>
-std::basic_ostream<CharT,Traits>&
-operator<<(std::basic_ostream<CharT,Traits> &os,
-           const linear_feedback_shift_engine<UIntType_,w_,k_,q_,s_> &e);
-/*! This function streams a linear_feedback_shift_engine in from a std::basic_istream.
- *  \param is The \p basic_istream to stream from.
- *  \param e The \p linear_feedback_shift_engine to stream in.
- *  \return \p is
- */
-template<typename UIntType_, size_t w_, size_t k_, size_t q_, size_t s_,
-         typename CharT, typename Traits>
-std::basic_istream<CharT,Traits>&
-operator>>(std::basic_istream<CharT,Traits> &is,
-           linear_feedback_shift_engine<UIntType_,w_,k_,q_,s_> &e);
-/*! \} // end random_number_engine_templates
- */
-} // end random
-// import names into thrust::
-using random::linear_feedback_shift_engine;
-} // end thrust
-#include <thrust/random/detail/linear_feedback_shift_engine.inl>

spaces/CVPR/LIVE/thrust/thrust/system/detail/generic/fill.h DELETED Viewed

@@ -1,60 +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.
- */
-#pragma once
-#include <thrust/detail/internal_functional.h>
-#include <thrust/generate.h>
-#include <thrust/system/detail/generic/tag.h>
-namespace thrust
-{
-namespace system
-{
-namespace detail
-{
-namespace generic
-{
-template<typename DerivedPolicy, typename OutputIterator, typename Size, typename T>
-__host__ __device__
-  OutputIterator fill_n(thrust::execution_policy<DerivedPolicy> &exec,
-                        OutputIterator first,
-                        Size n,
-                        const T &value)
-{
-  // XXX consider using the placeholder expression _1 = value
-  return thrust::generate_n(exec, first, n, thrust::detail::fill_functor<T>(value));
-}
-template<typename DerivedPolicy, typename ForwardIterator, typename T>
-__host__ __device__
-  void fill(thrust::execution_policy<DerivedPolicy> &exec,
-            ForwardIterator first,
-            ForwardIterator last,
-            const T &value)
-{
-  // XXX consider using the placeholder expression _1 = value
-  thrust::generate(exec, first, last, thrust::detail::fill_functor<T>(value));
-}
-} // end namespace generic
-} // end namespace detail
-} // end namespace system
-} // end namespace thrust

spaces/CVPR/LIVE/thrust/thrust/system/detail/sequential/partition.h DELETED Viewed

@@ -1,339 +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 partition.h
- *  \brief Sequential implementations of partition functions.
- */
-#pragma once
-#include <thrust/detail/config.h>
-#include <thrust/pair.h>
-#include <thrust/detail/temporary_array.h>
-#include <thrust/detail/function.h>
-#include <thrust/system/detail/sequential/execution_policy.h>
-namespace thrust
-{
-namespace detail
-{
-// XXX WAR an unfortunate circular #inclusion problem
-template<typename,typename> class temporary_array;
-} // end detail
-namespace system
-{
-namespace detail
-{
-namespace sequential
-{
-__thrust_exec_check_disable__
-template<typename ForwardIterator1,
-         typename ForwardIterator2>
-__host__ __device__
-void iter_swap(ForwardIterator1 iter1, ForwardIterator2 iter2)
-{
-  // XXX this isn't correct because it doesn't use thrust::swap
-  using namespace thrust::detail;
-  typedef typename thrust::iterator_value<ForwardIterator1>::type T;
-  T temp = *iter1;
-  *iter1 = *iter2;
-  *iter2 = temp;
-}
-__thrust_exec_check_disable__
-template<typename DerivedPolicy,
-         typename ForwardIterator,
-         typename Predicate>
-__host__ __device__
-  ForwardIterator partition(sequential::execution_policy<DerivedPolicy> &,
-                            ForwardIterator first,
-                            ForwardIterator last,
-                            Predicate pred)
-{
-  if(first == last)
-    return first;
-  // wrap pred
-  thrust::detail::wrapped_function<
-    Predicate,
-    bool
-  > wrapped_pred(pred);
-  while(wrapped_pred(*first))
-  {
-    if(++first == last)
-      return first;
-  }
-  ForwardIterator next = first;
-  while(++next != last)
-  {
-    if(wrapped_pred(*next))
-    {
-      iter_swap(first, next);
-      ++first;
-    }
-  }
-  return first;
-}
-__thrust_exec_check_disable__
-template<typename DerivedPolicy,
-         typename ForwardIterator,
-         typename InputIterator,
-         typename Predicate>
-__host__ __device__
-  ForwardIterator partition(sequential::execution_policy<DerivedPolicy> &,
-                            ForwardIterator first,
-                            ForwardIterator last,
-                            InputIterator stencil_first,
-                            Predicate pred)
-{
-  if(first == last)
-    return first;
-  // wrap pred
-  thrust::detail::wrapped_function<
-    Predicate,
-    bool
-  > wrapped_pred(pred);
-  while(wrapped_pred(*stencil_first))
-  {
-    ++stencil_first;
-    if(++first == last)
-    {
-      return first;
-    }
-  }
-  ForwardIterator next = first;
-  // advance stencil to next element as well
-  ++stencil_first;
-  while(++next != last)
-  {
-    if(wrapped_pred(*stencil_first))
-    {
-      iter_swap(first, next);
-      ++first;
-    }
-    ++stencil_first;
-  }
-  return first;
-}
-__thrust_exec_check_disable__
-template<typename DerivedPolicy,
-         typename ForwardIterator,
-         typename Predicate>
-__host__ __device__
-  ForwardIterator stable_partition(sequential::execution_policy<DerivedPolicy> &exec,
-                                   ForwardIterator first,
-                                   ForwardIterator last,
-                                   Predicate pred)
-{
-  // wrap pred
-  thrust::detail::wrapped_function<
-    Predicate,
-    bool
-  > wrapped_pred(pred);
-  typedef typename thrust::iterator_value<ForwardIterator>::type T;
-  typedef thrust::detail::temporary_array<T,DerivedPolicy> TempRange;
-  typedef typename TempRange::iterator                     TempIterator;
-  TempRange temp(exec, first, last);
-  for(TempIterator iter = temp.begin(); iter != temp.end(); ++iter)
-  {
-    if(wrapped_pred(*iter))
-    {
-      *first = *iter;
-      ++first;
-    }
-  }
-  ForwardIterator middle = first;
-  for(TempIterator iter = temp.begin(); iter != temp.end(); ++iter)
-  {
-    if(!wrapped_pred(*iter))
-    {
-      *first = *iter;
-      ++first;
-    }
-  }
-  return middle;
-}
-__thrust_exec_check_disable__
-template<typename DerivedPolicy,
-         typename ForwardIterator,
-         typename InputIterator,
-         typename Predicate>
-__host__ __device__
-  ForwardIterator stable_partition(sequential::execution_policy<DerivedPolicy> &exec,
-                                   ForwardIterator first,
-                                   ForwardIterator last,
-                                   InputIterator stencil,
-                                   Predicate pred)
-{
-  // wrap pred
-  thrust::detail::wrapped_function<
-    Predicate,
-    bool
-  > wrapped_pred(pred);
-  typedef typename thrust::iterator_value<ForwardIterator>::type T;
-  typedef thrust::detail::temporary_array<T,DerivedPolicy> TempRange;
-  typedef typename TempRange::iterator                     TempIterator;
-  TempRange temp(exec, first, last);
-  InputIterator stencil_iter = stencil;
-  for(TempIterator iter = temp.begin(); iter != temp.end(); ++iter, ++stencil_iter)
-  {
-    if(wrapped_pred(*stencil_iter))
-    {
-      *first = *iter;
-      ++first;
-    }
-  }
-  ForwardIterator middle = first;
-  stencil_iter = stencil;
-  for(TempIterator iter = temp.begin(); iter != temp.end(); ++iter, ++stencil_iter)
-  {
-    if(!wrapped_pred(*stencil_iter))
-    {
-      *first = *iter;
-      ++first;
-    }
-  }
-  return middle;
-}
-__thrust_exec_check_disable__
-template<typename DerivedPolicy,
-         typename InputIterator,
-         typename OutputIterator1,
-         typename OutputIterator2,
-         typename Predicate>
-__host__ __device__
-  thrust::pair<OutputIterator1,OutputIterator2>
-    stable_partition_copy(sequential::execution_policy<DerivedPolicy> &,
-                          InputIterator first,
-                          InputIterator last,
-                          OutputIterator1 out_true,
-                          OutputIterator2 out_false,
-                          Predicate pred)
-{
-  // wrap pred
-  thrust::detail::wrapped_function<
-    Predicate,
-    bool
-  > wrapped_pred(pred);
-  for(; first != last; ++first)
-  {
-    if(wrapped_pred(*first))
-    {
-      *out_true = *first;
-      ++out_true;
-    } // end if
-    else
-    {
-      *out_false = *first;
-      ++out_false;
-    } // end else
-  }
-  return thrust::make_pair(out_true, out_false);
-}
-__thrust_exec_check_disable__
-template<typename DerivedPolicy,
-         typename InputIterator1,
-         typename InputIterator2,
-         typename OutputIterator1,
-         typename OutputIterator2,
-         typename Predicate>
-__host__ __device__
-  thrust::pair<OutputIterator1,OutputIterator2>
-    stable_partition_copy(sequential::execution_policy<DerivedPolicy> &,
-                          InputIterator1 first,
-                          InputIterator1 last,
-                          InputIterator2 stencil,
-                          OutputIterator1 out_true,
-                          OutputIterator2 out_false,
-                          Predicate pred)
-{
-  // wrap pred
-  thrust::detail::wrapped_function<
-    Predicate,
-    bool
-  > wrapped_pred(pred);
-  for(; first != last; ++first, ++stencil)
-  {
-    if(wrapped_pred(*stencil))
-    {
-      *out_true = *first;
-      ++out_true;
-    } // end if
-    else
-    {
-      *out_false = *first;
-      ++out_false;
-    } // end else
-  }
-  return thrust::make_pair(out_true, out_false);
-}
-} // end namespace sequential
-} // end namespace detail
-} // end namespace system
-} // end namespace thrust

spaces/Caoyunkang/Segment-Any-Anomaly/SAM/CONTRIBUTING.md DELETED Viewed

@@ -1,31 +0,0 @@
-# Contributing to segment-anything
-We want to make contributing to this project as easy and transparent as
-possible.
-## Pull Requests
-We actively welcome your pull requests.
-1. Fork the repo and create your branch from `main`.
-2. If you've added code that should be tested, add tests.
-3. If you've changed APIs, update the documentation.
-4. Ensure the test suite passes.
-5. Make sure your code lints, using the `linter.sh` script in the project's root directory. Linting requires `black==23.*`, `isort==5.12.0`, `flake8`, and `mypy`.
-6. If you haven't already, complete the Contributor License Agreement ("CLA").
-## Contributor License Agreement ("CLA")
-In order to accept your pull request, we need you to submit a CLA. You only need
-to do this once to work on any of Facebook's open source projects.
-Complete your CLA here: <https://code.facebook.com/cla>
-## Issues
-We use GitHub issues to track public bugs. Please ensure your description is
-clear and has sufficient instructions to be able to reproduce the issue.
-Facebook has a [bounty program](https://www.facebook.com/whitehat/) for the safe
-disclosure of security bugs. In those cases, please go through the process
-outlined on that page and do not file a public issue.
-## License
-By contributing to segment-anything, you agree that your contributions will be licensed
-under the LICENSE file in the root directory of this source tree.

spaces/ChristopherMarais/Andrew_AI-BB_classification-beta/mysite/andrew_alpha/__init__.py DELETED Viewed

File without changes

spaces/Cletrason/Cletrason-toad-in-the-mario-movie/trainer_seq2seq.py DELETED Viewed

@@ -1,246 +0,0 @@
-# Copyright 2020 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 Any, Dict, List, Optional, Tuple, Union
-import torch
-from torch import nn
-from torch.utils.data import Dataset
-from .deepspeed import is_deepspeed_zero3_enabled
-from .trainer import Trainer
-from .trainer_utils import PredictionOutput
-from .utils import logging
-logger = logging.get_logger(__name__)
-class Seq2SeqTrainer(Trainer):
-    def evaluate(
-        self,
-        eval_dataset: Optional[Dataset] = None,
-        ignore_keys: Optional[List[str]] = None,
-        metric_key_prefix: str = "eval",
-        **gen_kwargs,
-    ) -> Dict[str, float]:
-        """
-        Run evaluation and returns metrics.
-        The calling script will be responsible for providing a method to compute metrics, as they are task-dependent
-        (pass it to the init `compute_metrics` argument).
-        You can also subclass and override this method to inject custom behavior.
-        Args:
-            eval_dataset (`Dataset`, *optional*):
-                Pass a dataset if you wish to override `self.eval_dataset`. If it is an [`~datasets.Dataset`], columns
-                not accepted by the `model.forward()` method are automatically removed. It must implement the `__len__`
-                method.
-            ignore_keys (`List[str]`, *optional*):
-                A list of keys in the output of your model (if it is a dictionary) that should be ignored when
-                gathering predictions.
-            metric_key_prefix (`str`, *optional*, defaults to `"eval"`):
-                An optional prefix to be used as the metrics key prefix. For example the metrics "bleu" will be named
-                "eval_bleu" if the prefix is `"eval"` (default)
-            max_length (`int`, *optional*):
-                The maximum target length to use when predicting with the generate method.
-            num_beams (`int`, *optional*):
-                Number of beams for beam search that will be used when predicting with the generate method. 1 means no
-                beam search.
-            gen_kwargs:
-                Additional `generate` specific kwargs.
-        Returns:
-            A dictionary containing the evaluation loss and the potential metrics computed from the predictions. The
-            dictionary also contains the epoch number which comes from the training state.
-        """
-        gen_kwargs = gen_kwargs.copy()
-        if gen_kwargs.get("max_length") is None and gen_kwargs.get("max_new_tokens") is None:
-            gen_kwargs["max_length"] = self.args.generation_max_length
-        gen_kwargs["num_beams"] = (
-            gen_kwargs["num_beams"] if gen_kwargs.get("num_beams") is not None else self.args.generation_num_beams
-        )
-        self._gen_kwargs = gen_kwargs
-        return super().evaluate(eval_dataset, ignore_keys=ignore_keys, metric_key_prefix=metric_key_prefix)
-    def predict(
-        self,
-        test_dataset: Dataset,
-        ignore_keys: Optional[List[str]] = None,
-        metric_key_prefix: str = "test",
-        **gen_kwargs,
-    ) -> PredictionOutput:
-        """
-        Run prediction and returns predictions and potential metrics.
-        Depending on the dataset and your use case, your test dataset may contain labels. In that case, this method
-        will also return metrics, like in `evaluate()`.
-        Args:
-            test_dataset (`Dataset`):
-                Dataset to run the predictions on. If it is a [`~datasets.Dataset`], columns not accepted by the
-                `model.forward()` method are automatically removed. Has to implement the method `__len__`
-            ignore_keys (`List[str]`, *optional*):
-                A list of keys in the output of your model (if it is a dictionary) that should be ignored when
-                gathering predictions.
-            metric_key_prefix (`str`, *optional*, defaults to `"eval"`):
-                An optional prefix to be used as the metrics key prefix. For example the metrics "bleu" will be named
-                "eval_bleu" if the prefix is `"eval"` (default)
-            max_length (`int`, *optional*):
-                The maximum target length to use when predicting with the generate method.
-            num_beams (`int`, *optional*):
-                Number of beams for beam search that will be used when predicting with the generate method. 1 means no
-                beam search.
-            gen_kwargs:
-                Additional `generate` specific kwargs.
-        <Tip>
-        If your predictions or labels have different sequence lengths (for instance because you're doing dynamic
-        padding in a token classification task) the predictions will be padded (on the right) to allow for
-        concatenation into one array. The padding index is -100.
-        </Tip>
-        Returns: *NamedTuple* A namedtuple with the following keys:
-            - predictions (`np.ndarray`): The predictions on `test_dataset`.
-            - label_ids (`np.ndarray`, *optional*): The labels (if the dataset contained some).
-            - metrics (`Dict[str, float]`, *optional*): The potential dictionary of metrics (if the dataset contained
-              labels).
-        """
-        gen_kwargs = gen_kwargs.copy()
-        if gen_kwargs.get("max_length") is None and gen_kwargs.get("max_new_tokens") is None:
-            gen_kwargs["max_length"] = self.args.generation_max_length
-        gen_kwargs["num_beams"] = (
-            gen_kwargs["num_beams"] if gen_kwargs.get("num_beams") is not None else self.args.generation_num_beams
-        )
-        self._gen_kwargs = gen_kwargs
-        return super().predict(test_dataset, ignore_keys=ignore_keys, metric_key_prefix=metric_key_prefix)
-    def prediction_step(
-        self,
-        model: nn.Module,
-        inputs: Dict[str, Union[torch.Tensor, Any]],
-        prediction_loss_only: bool,
-        ignore_keys: Optional[List[str]] = None,
-    ) -> Tuple[Optional[float], Optional[torch.Tensor], Optional[torch.Tensor]]:
-        """
-        Perform an evaluation step on `model` using `inputs`.
-        Subclass and override to inject custom behavior.
-        Args:
-            model (`nn.Module`):
-                The model to evaluate.
-            inputs (`Dict[str, Union[torch.Tensor, Any]]`):
-                The inputs and targets of the model.
-                The dictionary will be unpacked before being fed to the model. Most models expect the targets under the
-                argument `labels`. Check your model's documentation for all accepted arguments.
-            prediction_loss_only (`bool`):
-                Whether or not to return the loss only.
-        Return:
-            Tuple[Optional[float], Optional[torch.Tensor], Optional[torch.Tensor]]: A tuple with the loss, logits and
-            labels (each being optional).
-        """
-        if not self.args.predict_with_generate or prediction_loss_only:
-            return super().prediction_step(
-                model, inputs, prediction_loss_only=prediction_loss_only, ignore_keys=ignore_keys
-            )
-        has_labels = "labels" in inputs
-        inputs = self._prepare_inputs(inputs)
-        # XXX: adapt synced_gpus for fairscale as well
-        gen_kwargs = self._gen_kwargs.copy()
-        if gen_kwargs.get("max_length") is None and gen_kwargs.get("max_new_tokens") is None:
-            gen_kwargs["max_length"] = self.model.config.max_length
-        gen_kwargs["num_beams"] = (
-            gen_kwargs["num_beams"] if gen_kwargs.get("num_beams") is not None else self.model.config.num_beams
-        )
-        default_synced_gpus = True if is_deepspeed_zero3_enabled() else False
-        gen_kwargs["synced_gpus"] = (
-            gen_kwargs["synced_gpus"] if gen_kwargs.get("synced_gpus") is not None else default_synced_gpus
-        )
-        # TODO (Joao): the following line is needed to keep a consistent result on SQUAD. Ideally, we should not block
-        # users from preparing a dataset with `decoder_input_ids`.
-        inputs = {k: v for k, v in inputs.items() if k != "decoder_input_ids"}
-        generated_tokens = self.model.generate(**inputs, **gen_kwargs)
-        # Temporary hack to ensure the generation config is not initialized for each iteration of the evaluation loop
-        # TODO: remove this hack when the legacy code that initializes generation_config from a model config is
-        # removed in https://github.com/huggingface/transformers/blob/98d88b23f54e5a23e741833f1e973fdf600cc2c5/src/transformers/generation/utils.py#L1183
-        if self.model.generation_config._from_model_config:
-            self.model.generation_config._from_model_config = False
-        # in case the batch is shorter than max length, the output should be padded
-        if gen_kwargs.get("max_length") is not None and generated_tokens.shape[-1] < gen_kwargs["max_length"]:
-            generated_tokens = self._pad_tensors_to_max_len(generated_tokens, gen_kwargs["max_length"])
-        elif gen_kwargs.get("max_new_tokens") is not None and generated_tokens.shape[-1] < (
-            gen_kwargs["max_new_tokens"] + 1
-        ):
-            generated_tokens = self._pad_tensors_to_max_len(generated_tokens, gen_kwargs["max_new_tokens"] + 1)
-        with torch.no_grad():
-            if has_labels:
-                with self.compute_loss_context_manager():
-                    outputs = model(**inputs)
-                if self.label_smoother is not None:
-                    loss = self.label_smoother(outputs, inputs["labels"]).mean().detach()
-                else:
-                    loss = (outputs["loss"] if isinstance(outputs, dict) else outputs[0]).mean().detach()
-            else:
-                loss = None
-        if self.args.prediction_loss_only:
-            return (loss, None, None)
-        if has_labels:
-            labels = inputs["labels"]
-            if gen_kwargs.get("max_length") is not None and labels.shape[-1] < gen_kwargs["max_length"]:
-                labels = self._pad_tensors_to_max_len(labels, gen_kwargs["max_length"])
-            elif gen_kwargs.get("max_new_tokens") is not None and labels.shape[-1] < (
-                gen_kwargs["max_new_tokens"] + 1
-            ):
-                labels = self._pad_tensors_to_max_len(labels, (gen_kwargs["max_new_tokens"] + 1))
-        else:
-            labels = None
-        return (loss, generated_tokens, labels)
-    def _pad_tensors_to_max_len(self, tensor, max_length):
-        if self.tokenizer is not None and hasattr(self.tokenizer, "pad_token_id"):
-            # If PAD token is not defined at least EOS token has to be defined
-            pad_token_id = (
-                self.tokenizer.pad_token_id if self.tokenizer.pad_token_id is not None else self.tokenizer.eos_token_id
-            )
-        else:
-            if self.model.config.pad_token_id is not None:
-                pad_token_id = self.model.config.pad_token_id
-            else:
-                raise ValueError("Pad_token_id must be set in the configuration of the model, in order to pad tensors")
-        padded_tensor = pad_token_id * torch.ones(
-            (tensor.shape[0], max_length), dtype=tensor.dtype, device=tensor.device
-        )
-        padded_tensor[:, : tensor.shape[-1]] = tensor
-        return padded_tensor

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fontTools/pens/momentsPen.c DELETED Viewed

The diff for this file is too large to render. See raw diff

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fontTools/ttLib/tables/_p_r_e_p.py DELETED Viewed

@@ -1,7 +0,0 @@
-from fontTools import ttLib
-superclass = ttLib.getTableClass("fpgm")
-class table__p_r_e_p(superclass):
-    pass

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fsspec/archive.py DELETED Viewed

@@ -1,73 +0,0 @@
-from fsspec import AbstractFileSystem
-from fsspec.utils import tokenize
-class AbstractArchiveFileSystem(AbstractFileSystem):
-    """
-    A generic superclass for implementing Archive-based filesystems.
-    Currently, it is shared amongst
-    :class:`~fsspec.implementations.zip.ZipFileSystem`,
-    :class:`~fsspec.implementations.libarchive.LibArchiveFileSystem` and
-    :class:`~fsspec.implementations.tar.TarFileSystem`.
-    """
-    def __str__(self):
-        return "<Archive-like object %s at %s>" % (type(self).__name__, id(self))
-    __repr__ = __str__
-    def ukey(self, path):
-        return tokenize(path, self.fo, self.protocol)
-    def _all_dirnames(self, paths):
-        """Returns *all* directory names for each path in paths, including intermediate
-        ones.
-        Parameters
-        ----------
-        paths: Iterable of path strings
-        """
-        if len(paths) == 0:
-            return set()
-        dirnames = {self._parent(path) for path in paths} - {self.root_marker}
-        return dirnames | self._all_dirnames(dirnames)
-    def info(self, path, **kwargs):
-        self._get_dirs()
-        path = self._strip_protocol(path)
-        if path in {"", "/"} and self.dir_cache:
-            return {"name": "/", "type": "directory", "size": 0}
-        if path in self.dir_cache:
-            return self.dir_cache[path]
-        elif path + "/" in self.dir_cache:
-            return self.dir_cache[path + "/"]
-        else:
-            raise FileNotFoundError(path)
-    def ls(self, path, detail=True, **kwargs):
-        self._get_dirs()
-        paths = {}
-        for p, f in self.dir_cache.items():
-            p = p.rstrip("/")
-            if "/" in p:
-                root = p.rsplit("/", 1)[0]
-            else:
-                root = ""
-            if root == path.rstrip("/"):
-                paths[p] = f
-            elif all(
-                (a == b)
-                for a, b in zip(path.split("/"), [""] + p.strip("/").split("/"))
-            ):
-                # root directory entry
-                ppath = p.rstrip("/").split("/", 1)[0]
-                if ppath not in paths:
-                    out = {"name": ppath + "/", "size": 0, "type": "directory"}
-                    paths[ppath] = out
-        out = sorted(paths.values(), key=lambda _: _["name"])
-        if detail:
-            return out
-        else:
-            return [f["name"] for f in out]

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/gradio/templates/cdn/assets/index-3ca142e0.css DELETED Viewed

@@ -1 +0,0 @@

- .spacer.svelte-1kspdo{display:inline-block;width:0;height:0}.json-node.svelte-1kspdo{display:inline;color:var(--body-text-color);line-height:var(--line-sm);font-family:var(--font-mono)}.expand-array.svelte-1kspdo{border:1px solid var(--border-color-primary);border-radius:var(--radius-sm);background:var(--background-fill-secondary);padding:0 var(--size-1);color:var(--body-text-color)}.expand-array.svelte-1kspdo:hover{background:var(--background-fill-primary)}.children.svelte-1kspdo{padding-left:var(--size-4)}.json-item.svelte-1kspdo{display:inline}.null.svelte-1kspdo{color:var(--body-text-color-subdued)}.string.svelte-1kspdo{color:var(--color-green-500)}.number.svelte-1kspdo{color:var(--color-blue-500)}.bool.svelte-1kspdo{color:var(--color-red-500)}.json-holder.svelte-1trjy9a{padding:var(--size-2)}button.svelte-1trjy9a{display:flex;position:absolute;top:var(--block-label-margin);right:var(--block-label-margin);align-items:center;box-shadow:var(--shadow-drop);border:1px solid var(--border-color-primary);border-top:none;border-right:none;border-radius:var(--block-label-right-radius);background:var(--block-label-background-fill);padding:5px;width:22px;height:22px;overflow:hidden;color:var(--block-label-text-color);font:var(--font);font-size:var(--button-small-text-size)}

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/gradio/templates/frontend/assets/index-ff630227.js DELETED Viewed

@@ -1,3 +0,0 @@
-import{S as I,e as J,s as K,J as U,K as u,p as j,M as y,n as P,A as E,N as R,O as V,P as D,L as F,Z as Le,ar as je,R as G,G as T,m as Z,V as Y,B as be,C as Ee,av as Q,aj as Ae,X as Ce,k as O,o as X,z as B,v as S,x as q,E as Me,ae as ze,q as Te,r as Be,u as pe,y as ke}from"./index-3370be2a.js";import{U as Se}from"./Upload-f29b2460.js";import{M as Ue}from"./ModifyUpload-d8fc50ab.js";import{B as Ne}from"./Button-89624748.js";import{B as Fe}from"./BlockLabel-56db415e.js";import{E as Oe}from"./Empty-585389a4.js";import{g as Xe}from"./color-baaf9df5.js";import{a as qe}from"./csv-b0b7514a.js";import{Z as x,_ as $,l as ee}from"./linear-58a44b5e.js";import{U as He}from"./UploadText-28892309.js";import"./Blocks-f0129fcd.js";import"./ModifyUpload.svelte_svelte_type_style_lang-d2acacf0.js";import"./IconButton-abe5ede9.js";import"./dsv-576afacd.js";function Pe(l){let e,n,t;return{c(){e=U("svg"),n=U("path"),t=U("path"),u(n,"d","M28.828 3.172a4.094 4.094 0 0 0-5.656 0L4.05 22.292A6.954 6.954 0 0 0 2 27.242V30h2.756a6.952 6.952 0 0 0 4.95-2.05L28.828 8.829a3.999 3.999 0 0 0 0-5.657zM10.91 18.26l2.829 2.829l-2.122 2.121l-2.828-2.828zm-2.619 8.276A4.966 4.966 0 0 1 4.756 28H4v-.759a4.967 4.967 0 0 1 1.464-3.535l1.91-1.91l2.829 2.828zM27.415 7.414l-12.261 12.26l-2.829-2.828l12.262-12.26a2.047 2.047 0 0 1 2.828 0a2 2 0 0 1 0 2.828z"),u(n,"fill","currentColor"),u(t,"d","M6.5 15a3.5 3.5 0 0 1-2.475-5.974l3.5-3.5a1.502 1.502 0 0 0 0-2.121a1.537 1.537 0 0 0-2.121 0L3.415 5.394L2 3.98l1.99-1.988a3.585 3.585 0 0 1 4.95 0a3.504 3.504 0 0 1 0 4.949L5.439 10.44a1.502 1.502 0 0 0 0 2.121a1.537 1.537 0 0 0 2.122 0l4.024-4.024L13 9.95l-4.025 4.024A3.475 3.475 0 0 1 6.5 15z"),u(t,"fill","currentColor"),u(e,"width","1em"),u(e,"height","1em"),u(e,"viewBox","0 0 32 32")},m(a,s){j(a,e,s),y(e,n),y(e,t)},p:P,i:P,o:P,d(a){a&&E(e)}}}let ye=class extends I{constructor(e){super(),J(this,e,null,Pe,K,{})}};function le(l){let e;return Array.isArray(l)?e=l.reduce((n,{values:t})=>[...n,...t.map(({y:a})=>a)],[]):e=l.values,[Math.min(...e),Math.max(...e)]}function te(l,e,n){const t=Object.entries(l[0]).reduce((a,s,o)=>(!e&&o===0||e&&s[0]===e?a.x.name=s[0]:(!n||n&&n.includes(s[0]))&&a.y.push({name:s[0],values:[]}),a),{x:{name:"",values:[]},y:[]});for(let a=0;a<l.length;a++){const s=Object.entries(l[a]);for(let o=0;o<s.length;o++){let[_,i]=s[o];_===t.x.name?t.x.values.push(parseFloat(i)):t.y[o-1].values.push({y:parseFloat(s[o][1]),x:parseFloat(s[0][1])})}}return t}function Re(l){let e,n,t,a,s;return{c(){e=R("div"),n=R("span"),t=V(),a=D(l[0]),F(n,"background",l[3]),u(n,"class","svelte-1gww5xe"),F(e,"top",l[2]-l[5]/2+"px"),F(e,"left",l[1]-l[4]-7+"px"),u(e,"class","svelte-1gww5xe"),Le(()=>l[6].call(e))},m(o,_){j(o,e,_),y(e,n),y(e,t),y(e,a),s=je(e,l[6].bind(e))},p(o,[_]){_&8&&F(n,"background",o[3]),_&1&&G(a,o[0]),_&36&&F(e,"top",o[2]-o[5]/2+"px"),_&18&&F(e,"left",o[1]-o[4]-7+"px")},i:P,o:P,d(o){o&&E(e),s()}}}function Ve(l,e,n){let{text:t}=e,{x:a}=e,{y:s}=e,{color:o}=e,_,i;function v(){_=this.offsetWidth,i=this.offsetHeight,n(4,_),n(5,i)}return l.$$set=g=>{"text"in g&&n(0,t=g.text),"x"in g&&n(1,a=g.x),"y"in g&&n(2,s=g.y),"color"in g&&n(3,o=g.color)},[t,a,s,o,_,i,v]}class Ye extends I{constructor(e){super(),J(this,e,Ve,Re,K,{text:0,x:1,y:2,color:3})}}function Ze(l,{color:e,text:n}){let t;function a(i){return t=new Ye({props:{text:n,x:i.pageX,y:i.pageY,color:e},target:document.body}),i}function s(i){t.$set({x:i.pageX,y:i.pageY})}function o(){t.$destroy()}const _=l;return _.addEventListener("mouseover",a),_.addEventListener("mouseleave",o),_.addEventListener("mousemove",s),{destroy(){_.removeEventListener("mouseover",a),_.removeEventListener("mouseleave",o),_.removeEventListener("mousemove",s)}}}function ne(l,e,n){const t=l.slice();t[16]=e[n].name,t[17]=e[n].values;const a=t[8][t[16]];return t[18]=a,t}function ae(l,e,n){const t=l.slice();return t[0]=e[n].x,t[1]=e[n].y,t}function oe(l,e,n){const t=l.slice();t[16]=e[n].name,t[17]=e[n].values;const a=t[8][t[16]];return t[18]=a,t}function se(l,e,n){const t=l.slice();return t[0]=e[n].x,t[1]=e[n].y,t}function re(l,e,n){const t=l.slice();return t[27]=e[n],t}function ie(l,e,n){const t=l.slice();return t[27]=e[n],t}function fe(l,e,n){const t=l.slice();return t[16]=e[n].name,t}function _e(l){let e,n,t,a=l[16]+"",s,o;return{c(){e=R("div"),n=R("span"),t=V(),s=D(a),o=V(),u(n,"class","legend-box svelte-1mjxput"),F(n,"background-color",l[8][l[16]]),u(e,"class","legend-item svelte-1mjxput")},m(_,i){j(_,e,i),y(e,n),y(e,t),y(e,s),y(e,o)},p(_,i){i[0]&260&&F(n,"background-color",_[8][_[16]]),i[0]&4&&a!==(a=_[16]+"")&&G(s,a)},d(_){_&&E(e)}}}function ue(l){let e,n,t,a,s,o,_=l[27]+"",i,v,g;return{c(){e=U("line"),o=U("text"),i=D(_),u(e,"stroke-width","0.5"),u(e,"x1",n=l[5](l[27])),u(e,"x2",t=l[5](l[27])),u(e,"y1",a=l[4](l[9][0]<l[6][0]?l[9][0]:l[6][0])+10),u(e,"y2",s=l[4](l[6][1]>l[9][l[9].length-1]?l[6][1]:l[9][l[9].length-1])),u(e,"stroke","#aaa"),u(o,"class","label-text svelte-1mjxput"),u(o,"text-anchor","middle"),u(o,"x",v=l[5](l[27])),u(o,"y",g=l[4](l[9][0])+30)},m(f,h){j(f,e,h),j(f,o,h),y(o,i)},p(f,h){h[0]&1056&&n!==(n=f[5](f[27]))&&u(e,"x1",n),h[0]&1056&&t!==(t=f[5](f[27]))&&u(e,"x2",t),h[0]&592&&a!==(a=f[4](f[9][0]<f[6][0]?f[9][0]:f[6][0])+10)&&u(e,"y1",a),h[0]&592&&s!==(s=f[4](f[6][1]>f[9][f[9].length-1]?f[6][1]:f[9][f[9].length-1]))&&u(e,"y2",s),h[0]&1024&&_!==(_=f[27]+"")&&G(i,_),h[0]&1056&&v!==(v=f[5](f[27]))&&u(o,"x",v),h[0]&528&&g!==(g=f[4](f[9][0])+30)&&u(o,"y",g)},d(f){f&&(E(e),E(o))}}}function ce(l){let e,n,t,a,s,o,_=l[27]+"",i,v,g;return{c(){e=U("line"),o=U("text"),i=D(_),u(e,"stroke-width","0.5"),u(e,"y1",n=l[4](l[27])),u(e,"y2",t=l[4](l[27])),u(e,"x1",a=l[5](l[10][0]<l[7][0]?l[10][0]:l[7][0])-10),u(e,"x2",s=l[5](l[7][1]>l[10][l[10].length-1]?l[7][1]:l[10][l[10].length-1])),u(e,"stroke","#aaa"),u(o,"class","label-text svelte-1mjxput"),u(o,"text-anchor","end"),u(o,"y",v=l[4](l[27])+4),u(o,"x",g=l[5](l[10][0])-20)},m(f,h){j(f,e,h),j(f,o,h),y(o,i)},p(f,h){h[0]&528&&n!==(n=f[4](f[27]))&&u(e,"y1",n),h[0]&528&&t!==(t=f[4](f[27]))&&u(e,"y2",t),h[0]&1184&&a!==(a=f[5](f[10][0]<f[7][0]?f[10][0]:f[7][0])-10)&&u(e,"x1",a),h[0]&1184&&s!==(s=f[5](f[7][1]>f[10][f[10].length-1]?f[7][1]:f[10][f[10].length-1]))&&u(e,"x2",s),h[0]&512&&_!==(_=f[27]+"")&&G(i,_),h[0]&528&&v!==(v=f[4](f[27])+4)&&u(o,"y",v),h[0]&1056&&g!==(g=f[5](f[10][0])-20)&&u(o,"x",g)},d(f){f&&(E(e),E(o))}}}function me(l){let e,n,t,a,s,o,_=l[6][1]+"",i,v,g;return{c(){e=U("line"),o=U("text"),i=D(_),u(e,"stroke-width","0.5"),u(e,"y1",n=l[4](l[6][1])),u(e,"y2",t=l[4](l[6][1])),u(e,"x1",a=l[5](l[10][0])),u(e,"x2",s=l[5](l[7][1])),u(e,"stroke","#aaa"),u(o,"class","label-text svelte-1mjxput"),u(o,"text-anchor","end"),u(o,"y",v=l[4](l[6][1])+4),u(o,"x",g=l[5](l[10][0])-20)},m(f,h){j(f,e,h),j(f,o,h),y(o,i)},p(f,h){h[0]&80&&n!==(n=f[4](f[6][1]))&&u(e,"y1",n),h[0]&80&&t!==(t=f[4](f[6][1]))&&u(e,"y2",t),h[0]&1056&&a!==(a=f[5](f[10][0]))&&u(e,"x1",a),h[0]&160&&s!==(s=f[5](f[7][1]))&&u(e,"x2",s),h[0]&64&&_!==(_=f[6][1]+"")&&G(i,_),h[0]&80&&v!==(v=f[4](f[6][1])+4)&&u(o,"y",v),h[0]&1056&&g!==(g=f[5](f[10][0])-20)&&u(o,"x",g)},d(f){f&&(E(e),E(o))}}}function he(l){let e,n,t,a;return{c(){e=U("circle"),u(e,"r","3.5"),u(e,"cx",n=l[5](l[0])),u(e,"cy",t=l[4](l[1])),u(e,"stroke-width","1.5"),u(e,"stroke",a=l[18]),u(e,"fill","none")},m(s,o){j(s,e,o)},p(s,o){o[0]&36&&n!==(n=s[5](s[0]))&&u(e,"cx",n),o[0]&20&&t!==(t=s[4](s[1]))&&u(e,"cy",t),o[0]&260&&a!==(a=s[18])&&u(e,"stroke",a)},d(s){s&&E(e)}}}function ge(l){let e,n,t,a=T(l[17]),s=[];for(let o=0;o<a.length;o+=1)s[o]=he(se(l,a,o));return{c(){for(let o=0;o<s.length;o+=1)s[o].c();e=U("path"),u(e,"d",n=$().curve(ee)(l[17].map(l[13]))),u(e,"fill","none"),u(e,"stroke",t=l[18]),u(e,"stroke-width","3")},m(o,_){for(let i=0;i<s.length;i+=1)s[i]&&s[i].m(o,_);j(o,e,_)},p(o,_){if(_[0]&308){a=T(o[17]);let i;for(i=0;i<a.length;i+=1){const v=se(o,a,i);s[i]?s[i].p(v,_):(s[i]=he(v),s[i].c(),s[i].m(e.parentNode,e))}for(;i<s.length;i+=1)s[i].d(1);s.length=a.length}_[0]&52&&n!==(n=$().curve(ee)(o[17].map(o[13])))&&u(e,"d",n),_[0]&260&&t!==(t=o[18])&&u(e,"stroke",t)},d(o){o&&E(e),Y(s,o)}}}function de(l){let e,n,t,a,s,o;return{c(){e=U("circle"),u(e,"r","7"),u(e,"cx",n=l[5](l[0])),u(e,"cy",t=l[4](l[1])),u(e,"stroke","black"),u(e,"fill","black"),F(e,"cursor","pointer"),F(e,"opacity","0")},m(_,i){j(_,e,i),s||(o=Ae(a=Ze.call(null,e,{color:l[18],text:`(${l[0]}, ${l[1]})`})),s=!0)},p(_,i){l=_,i[0]&36&&n!==(n=l[5](l[0]))&&u(e,"cx",n),i[0]&20&&t!==(t=l[4](l[1]))&&u(e,"cy",t),a&&Ce(a.update)&&i[0]&260&&a.update.call(null,{color:l[18],text:`(${l[0]}, ${l[1]})`})},d(_){_&&E(e),s=!1,o()}}}function ve(l){let e,n=T(l[17]),t=[];for(let a=0;a<n.length;a+=1)t[a]=de(ae(l,n,a));return{c(){for(let a=0;a<t.length;a+=1)t[a].c();e=Z()},m(a,s){for(let o=0;o<t.length;o+=1)t[o]&&t[o].m(a,s);j(a,e,s)},p(a,s){if(s[0]&308){n=T(a[17]);let o;for(o=0;o<n.length;o+=1){const _=ae(a,n,o);t[o]?t[o].p(_,s):(t[o]=de(_),t[o].c(),t[o].m(e.parentNode,e))}for(;o<t.length;o+=1)t[o].d(1);t.length=n.length}},d(a){a&&E(e),Y(t,a)}}}function De(l){let e,n,t,a,s,o,_,i,v,g,f=l[3].name+"",h,A=T(l[2]),m=[];for(let c=0;c<A.length;c+=1)m[c]=_e(fe(l,A,c));let b=T(l[10]),p=[];for(let c=0;c<b.length;c+=1)p[c]=ue(ie(l,b,c));let N=T(l[9]),k=[];for(let c=0;c<N.length;c+=1)k[c]=ce(re(l,N,c));let d=l[6][1]>l[9][l[9].length-1]&&me(l),C=T(l[2]),L=[];for(let c=0;c<C.length;c+=1)L[c]=ge(oe(l,C,c));let H=T(l[2]),M=[];for(let c=0;c<H.length;c+=1)M[c]=ve(ne(l,H,c));return{c(){e=R("div"),n=R("div");for(let c=0;c<m.length;c+=1)m[c].c();t=V(),a=U("svg"),s=U("g");for(let c=0;c<p.length;c+=1)p[c].c();o=Z();for(let c=0;c<k.length;c+=1)k[c].c();_=Z(),d&&d.c();for(let c=0;c<L.length;c+=1)L[c].c();i=Z();for(let c=0;c<M.length;c+=1)M[c].c();v=V(),g=R("div"),h=D(f),u(n,"class","legend svelte-1mjxput"),u(a,"class","w-full svelte-1mjxput"),u(a,"viewBox","-70 -20 700 420"),u(g,"class","main-label svelte-1mjxput"),u(e,"class","wrap svelte-1mjxput")},m(c,z){j(c,e,z),y(e,n);for(let r=0;r<m.length;r+=1)m[r]&&m[r].m(n,null);y(e,t),y(e,a),y(a,s);for(let r=0;r<p.length;r+=1)p[r]&&p[r].m(s,null);y(s,o);for(let r=0;r<k.length;r+=1)k[r]&&k[r].m(s,null);y(s,_),d&&d.m(s,null);for(let r=0;r<L.length;r+=1)L[r]&&L[r].m(a,null);y(a,i);for(let r=0;r<M.length;r+=1)M[r]&&M[r].m(a,null);y(e,v),y(e,g),y(g,h)},p(c,z){if(z[0]&260){A=T(c[2]);let r;for(r=0;r<A.length;r+=1){const w=fe(c,A,r);m[r]?m[r].p(w,z):(m[r]=_e(w),m[r].c(),m[r].m(n,null))}for(;r<m.length;r+=1)m[r].d(1);m.length=A.length}if(z[0]&1648){b=T(c[10]);let r;for(r=0;r<b.length;r+=1){const w=ie(c,b,r);p[r]?p[r].p(w,z):(p[r]=ue(w),p[r].c(),p[r].m(s,o))}for(;r<p.length;r+=1)p[r].d(1);p.length=b.length}if(z[0]&1712){N=T(c[9]);let r;for(r=0;r<N.length;r+=1){const w=re(c,N,r);k[r]?k[r].p(w,z):(k[r]=ce(w),k[r].c(),k[r].m(s,_))}for(;r<k.length;r+=1)k[r].d(1);k.length=N.length}if(c[6][1]>c[9][c[9].length-1]?d?d.p(c,z):(d=me(c),d.c(),d.m(s,null)):d&&(d.d(1),d=null),z[0]&308){C=T(c[2]);let r;for(r=0;r<C.length;r+=1){const w=oe(c,C,r);L[r]?L[r].p(w,z):(L[r]=ge(w),L[r].c(),L[r].m(a,i))}for(;r<L.length;r+=1)L[r].d(1);L.length=C.length}if(z[0]&308){H=T(c[2]);let r;for(r=0;r<H.length;r+=1){const w=ne(c,H,r);M[r]?M[r].p(w,z):(M[r]=ve(w),M[r].c(),M[r].m(a,null))}for(;r<M.length;r+=1)M[r].d(1);M.length=H.length}z[0]&8&&f!==(f=c[3].name+"")&&G(h,f)},i:P,o:P,d(c){c&&E(e),Y(m,c),Y(p,c),Y(k,c),d&&d.d(),Y(L,c),Y(M,c)}}}function Ge(l,e,n){let t,a,s,o,_,i,v,g,{value:f}=e,{x:h=void 0}=e,{y:A=void 0}=e,{colors:m=[]}=e;const b=be();let p;function N(d){let C=m[d%m.length];return C&&C in Q?Q[C]?.primary:C||Q[Xe(d)].primary}Ee(()=>{b("process",{x:t,y:a})});const k=({x:d,y:C})=>[_(d),i(C)];return l.$$set=d=>{"value"in d&&n(11,f=d.value),"x"in d&&n(0,h=d.x),"y"in d&&n(1,A=d.y),"colors"in d&&n(12,m=d.colors)},l.$$.update=()=>{l.$$.dirty[0]&2051&&n(3,{x:t,y:a}=te(typeof f=="string"?qe(f):f,h,A),t,(n(2,a),n(11,f),n(0,h),n(1,A))),l.$$.dirty[0]&8&&n(7,s=le(t)),l.$$.dirty[0]&4&&n(6,o=le(a)),l.$$.dirty[0]&128&&n(5,_=x(s,[0,600]).nice()),l.$$.dirty[0]&64&&n(4,i=x(o,[350,0]).nice()),l.$$.dirty[0]&32&&n(10,v=_.ticks(8)),l.$$.dirty[0]&16&&n(9,g=i.ticks(8)),l.$$.dirty[0]&4&&n(8,p=a.reduce((d,C,L)=>({...d,[C.name]:N(L)}),{}))},[h,A,a,t,i,_,o,s,p,g,v,f,m,k]}class we extends I{constructor(e){super(),J(this,e,Ge,De,K,{value:11,x:0,y:1,colors:12},null,[-1,-1])}}function Ie(l){let e,n;return e=new Se({props:{filetype:"text/csv",include_file_metadata:!1,$$slots:{default:[We]},$$scope:{ctx:l}}}),e.$on("load",l[19]),{c(){O(e.$$.fragment)},m(t,a){X(e,t,a),n=!0},p(t,a){const s={};a&8388608&&(s.$$scope={dirty:a,ctx:t}),e.$set(s)},i(t){n||(B(e.$$.fragment,t),n=!0)},o(t){S(e.$$.fragment,t),n=!1},d(t){q(e,t)}}}function Je(l){let e,n,t,a,s;return n=new Ue({}),n.$on("clear",l[17]),a=new we({props:{value:l[14],y:l[4],x:l[5],colors:l[9]}}),a.$on("process",l[18]),{c(){e=R("div"),O(n.$$.fragment),t=V(),O(a.$$.fragment),u(e,"class","chart svelte-etmurc")},m(o,_){j(o,e,_),X(n,e,null),y(e,t),X(a,e,null),s=!0},p(o,_){const i={};_&16384&&(i.value=o[14]),_&16&&(i.y=o[4]),_&32&&(i.x=o[5]),_&512&&(i.colors=o[9]),a.$set(i)},i(o){s||(B(n.$$.fragment,o),B(a.$$.fragment,o),s=!0)},o(o){S(n.$$.fragment,o),S(a.$$.fragment,o),s=!1},d(o){o&&E(e),q(n),q(a)}}}function Ke(l){let e,n,t,a;const s=[xe,Qe],o=[];function _(i,v){return i[15]?0:1}return e=_(l),n=o[e]=s[e](l),{c(){n.c(),t=Z()},m(i,v){o[e].m(i,v),j(i,t,v),a=!0},p(i,v){let g=e;e=_(i),e===g?o[e].p(i,v):(pe(),S(o[g],1,1,()=>{o[g]=null}),ke(),n=o[e],n?n.p(i,v):(n=o[e]=s[e](i),n.c()),B(n,1),n.m(t.parentNode,t))},i(i){a||(B(n),a=!0)},o(i){S(n),a=!1},d(i){i&&E(t),o[e].d(i)}}}function We(l){let e,n;return e=new He({props:{type:"csv"}}),{c(){O(e.$$.fragment)},m(t,a){X(e,t,a),n=!0},p:P,i(t){n||(B(e.$$.fragment,t),n=!0)},o(t){S(e.$$.fragment,t),n=!1},d(t){q(e,t)}}}function Qe(l){let e,n;return e=new Oe({props:{unpadded_box:!0,size:"large",$$slots:{default:[$e]},$$scope:{ctx:l}}}),{c(){O(e.$$.fragment)},m(t,a){X(e,t,a),n=!0},p(t,a){const s={};a&8388608&&(s.$$scope={dirty:a,ctx:t}),e.$set(s)},i(t){n||(B(e.$$.fragment,t),n=!0)},o(t){S(e.$$.fragment,t),n=!1},d(t){q(e,t)}}}function xe(l){let e,n;return e=new we({props:{value:l[15],colors:l[9]}}),{c(){O(e.$$.fragment)},m(t,a){X(e,t,a),n=!0},p(t,a){const s={};a&32768&&(s.value=t[15]),a&512&&(s.colors=t[9]),e.$set(s)},i(t){n||(B(e.$$.fragment,t),n=!0)},o(t){S(e.$$.fragment,t),n=!1},d(t){q(e,t)}}}function $e(l){let e,n;return e=new ye({}),{c(){O(e.$$.fragment)},m(t,a){X(e,t,a),n=!0},i(t){n||(B(e.$$.fragment,t),n=!0)},o(t){S(e.$$.fragment,t),n=!1},d(t){q(e,t)}}}function el(l){let e,n,t,a,s,o,_,i;e=new Fe({props:{show_label:l[8],Icon:ye,label:l[7]||"TimeSeries"}});const v=[l[13]];let g={};for(let m=0;m<v.length;m+=1)g=Me(g,v[m]);t=new ze({props:g});const f=[Ke,Je,Ie],h=[];function A(m,b){return m[6]==="static"?0:m[14]?1:m[0]===void 0||m[0]===null?2:-1}return~(s=A(l))&&(o=h[s]=f[s](l)),{c(){O(e.$$.fragment),n=V(),O(t.$$.fragment),a=V(),o&&o.c(),_=Z()},m(m,b){X(e,m,b),j(m,n,b),X(t,m,b),j(m,a,b),~s&&h[s].m(m,b),j(m,_,b),i=!0},p(m,b){const p={};b&256&&(p.show_label=m[8]),b&128&&(p.label=m[7]||"TimeSeries"),e.$set(p);const N=b&8192?Te(v,[Be(m[13])]):{};t.$set(N);let k=s;s=A(m),s===k?~s&&h[s].p(m,b):(o&&(pe(),S(h[k],1,1,()=>{h[k]=null}),ke()),~s?(o=h[s],o?o.p(m,b):(o=h[s]=f[s](m),o.c()),B(o,1),o.m(_.parentNode,_)):o=null)},i(m){i||(B(e.$$.fragment,m),B(t.$$.fragment,m),B(o),i=!0)},o(m){S(e.$$.fragment,m),S(t.$$.fragment,m),S(o),i=!1},d(m){m&&(E(n),E(a),E(_)),q(e,m),q(t,m),~s&&h[s].d(m)}}}function ll(l){let e,n;return e=new Ne({props:{visible:l[3],variant:l[6]==="dynamic"&&!l[14]?"dashed":"solid",padding:!1,elem_id:l[1],elem_classes:l[2],container:l[10],scale:l[11],min_width:l[12],$$slots:{default:[el]},$$scope:{ctx:l}}}),{c(){O(e.$$.fragment)},m(t,a){X(e,t,a),n=!0},p(t,[a]){const s={};a&8&&(s.visible=t[3]),a&16448&&(s.variant=t[6]==="dynamic"&&!t[14]?"dashed":"solid"),a&2&&(s.elem_id=t[1]),a&4&&(s.elem_classes=t[2]),a&1024&&(s.container=t[10]),a&2048&&(s.scale=t[11]),a&4096&&(s.min_width=t[12]),a&8446961&&(s.$$scope={dirty:a,ctx:t}),e.$set(s)},i(t){n||(B(e.$$.fragment,t),n=!0)},o(t){S(e.$$.fragment,t),n=!1},d(t){q(e,t)}}}function tl(l){return l.data.map(e=>e.reduce((n,t,a)=>({...n,[l.headers[a]]:t}),{}))}function nl(l){const e=atob(l.split(",")[1]),n=l.split(",")[0].split(":")[1].split(";")[0],t=new ArrayBuffer(e.length),a=new Uint8Array(t);for(let s=0;s<e.length;s++)a[s]=e.charCodeAt(s);return new Blob([t],{type:n})}function al(l,e){const n=[],t=[];n.push(l.name),e.forEach(({name:a})=>n.push(a));for(let a=0;a<l.values.length;a++){let s=[];s.push(l.values[a]),e.forEach(({values:o})=>s.push(o[a].y)),t.push(s)}return{headers:n,data:t}}function ol(l,e,n){let t;const a=be();let{elem_id:s=""}=e,{elem_classes:o=[]}=e,{visible:_=!0}=e,{value:i}=e,{y:v}=e,{x:g}=e,{mode:f}=e,{label:h}=e,{show_label:A}=e,{colors:m}=e,{container:b=!0}=e,{scale:p=null}=e,{min_width:N=void 0}=e,{loading_status:k}=e,d;function C(r){const w=new FileReader;w.addEventListener("loadend",W=>{n(14,d=W.srcElement.result)}),w.readAsText(r)}function L(r){r.headers&&n(14,d=r.headers.join(",")),r.data.forEach(W=>{n(14,d=d+`
-`),n(14,d=d+W.join(","))})}function H(r){return n(0,i={data:r}),r}function M({detail:r}){n(0,i=null),a("change"),a("clear")}const c=({detail:{x:r,y:w}})=>n(0,i=al(r,w)),z=({detail:r})=>H(r);return l.$$set=r=>{"elem_id"in r&&n(1,s=r.elem_id),"elem_classes"in r&&n(2,o=r.elem_classes),"visible"in r&&n(3,_=r.visible),"value"in r&&n(0,i=r.value),"y"in r&&n(4,v=r.y),"x"in r&&n(5,g=r.x),"mode"in r&&n(6,f=r.mode),"label"in r&&n(7,h=r.label),"show_label"in r&&n(8,A=r.show_label),"colors"in r&&n(9,m=r.colors),"container"in r&&n(10,b=r.container),"scale"in r&&n(11,p=r.scale),"min_width"in r&&n(12,N=r.min_width),"loading_status"in r&&n(13,k=r.loading_status)},l.$$.update=()=>{l.$$.dirty&1&&(i&&i.data&&typeof i.data=="string"?i?C(nl(i.data)):n(14,d=null):i&&i.data&&typeof i.data!="string"&&(i||n(14,d=null),L(i))),l.$$.dirty&16385&&n(14,d=i==null?null:d),l.$$.dirty&65&&n(15,t=f==="static"&&i&&tl(i)),l.$$.dirty&1&&a("change")},[i,s,o,_,v,g,f,h,A,m,b,p,N,k,d,t,H,M,c,z]}class sl extends I{constructor(e){super(),J(this,e,ol,ll,K,{elem_id:1,elem_classes:2,visible:3,value:0,y:4,x:5,mode:6,label:7,show_label:8,colors:9,container:10,scale:11,min_width:12,loading_status:13})}}const wl=sl,Ll=["static","dynamic"],jl=l=>({type:{payload:"{data: Array<Array<number>> | string; headers?: Array<string>;}"},description:{payload:"dataset of series"}});export{wl as Component,jl as document,Ll as modes};
-//# sourceMappingURL=index-ff630227.js.map

spaces/DataScienceGuild/ARIMA_test/README.md DELETED Viewed

@@ -1,13 +0,0 @@
----
-title: ARIMA Test
-emoji: 🌖
-colorFrom: green
-colorTo: pink
-sdk: streamlit
-sdk_version: 1.25.0
-app_file: app.py
-pinned: false
-license: mit
----
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/Datasculptor/3D-Room-Layout-Estimation_LGT-Net/models/modules/swg_transformer.py DELETED Viewed

@@ -1,49 +0,0 @@
-from models.modules.transformer_modules import *
-class SWG_Transformer(nn.Module):
-    def __init__(self, dim, depth, heads, win_size, dim_head, mlp_dim,
-                 dropout=0., patch_num=None, ape=None, rpe=None, rpe_pos=1):
-        super().__init__()
-        self.absolute_pos_embed = None if patch_num is None or ape is None else AbsolutePosition(dim, dropout,
-                                                                                                 patch_num, ape)
-        self.pos_dropout = nn.Dropout(dropout)
-        self.layers = nn.ModuleList([])
-        for i in range(depth):
-            if i % 2 == 0:
-                attention = WinAttention(dim, win_size=win_size, shift=0 if (i % 3 == 0) else win_size // 2,
-                                         heads=heads, dim_head=dim_head, dropout=dropout, rpe=rpe, rpe_pos=rpe_pos)
-            else:
-                attention = Attention(dim, heads=heads, dim_head=dim_head, dropout=dropout,
-                                      patch_num=patch_num, rpe=rpe, rpe_pos=rpe_pos)
-            self.layers.append(nn.ModuleList([
-                PreNorm(dim, attention),
-                PreNorm(dim, FeedForward(dim, mlp_dim, dropout=dropout)),
-            ]))
-    def forward(self, x):
-        if self.absolute_pos_embed is not None:
-            x = self.absolute_pos_embed(x)
-        x = self.pos_dropout(x)
-        for attn, ff in self.layers:
-            x = attn(x) + x
-            x = ff(x) + x
-        return x
-if __name__ == '__main__':
-    token_dim = 1024
-    toke_len = 256
-    transformer = SWG_Transformer(dim=token_dim,
-                                  depth=6,
-                                  heads=16,
-                                  win_size=8,
-                                  dim_head=64,
-                                  mlp_dim=2048,
-                                  dropout=0.1)
-    input = torch.randn(1, toke_len, token_dim)
-    output = transformer(input)
-    print(output.shape)

spaces/Dorado607/ChuanhuChatGPT/run_Linux.sh DELETED Viewed

@@ -1,31 +0,0 @@
-#!/bin/bash
-# 获取脚本所在目录
-script_dir=$(dirname "$(readlink -f "$0")")
-# 将工作目录更改为脚本所在目录
-cd "$script_dir" || exit
-# 检查Git仓库是否有更新
-git remote update
-pwd
-if ! git status -uno | grep 'up to date' > /dev/null; then
-	# 如果有更新，关闭当前运行的服务器
-	pkill -f ChuanhuChatbot.py
-	# 拉取最新更改
-	git pull
-	# 安装依赖
-	pip3 install -r requirements.txt
-	# 重新启动服务器
-	nohup python3 ChuanhuChatbot.py &
-fi
-# 检查ChuanhuChatbot.py是否在运行
-if ! pgrep -f ChuanhuChatbot.py > /dev/null; then
-	# 如果没有运行，启动服务器
-	nohup python3 ChuanhuChatbot.py &
-fi

spaces/DragGan/DragGan-Inversion/PTI/torch_utils/__init__.py DELETED Viewed

@@ -1,9 +0,0 @@
-# Copyright (c) 2021, NVIDIA CORPORATION.  All rights reserved.
-#
-# NVIDIA CORPORATION and its licensors retain all intellectual property
-# and proprietary rights in and to this software, related documentation
-# and any modifications thereto.  Any use, reproduction, disclosure or
-# distribution of this software and related documentation without an express
-# license agreement from NVIDIA CORPORATION is strictly prohibited.
-# empty

spaces/DragGan/DragGan-Inversion/PTI/training/__init__.py DELETED Viewed

File without changes

spaces/EAraid12/LoRA-DreamBooth-Training-UI/README.md DELETED Viewed

@@ -1,15 +0,0 @@
----
-title: LoRA DreamBooth Training UI
-emoji: ⚡
-colorFrom: red
-colorTo: purple
-sdk: gradio
-sdk_version: 3.16.2
-python_version: 3.10.9
-app_file: app.py
-pinned: false
-license: mit
-duplicated_from: lora-library/LoRA-DreamBooth-Training-UI
----
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/EXPOSUREEE/Ai-Image-Enhancer/realesrgan/models/realesrgan_model.py DELETED Viewed

@@ -1,258 +0,0 @@
-import numpy as np
-import random
-import torch
-from basicsr.data.degradations import random_add_gaussian_noise_pt, random_add_poisson_noise_pt
-from basicsr.data.transforms import paired_random_crop
-from basicsr.models.srgan_model import SRGANModel
-from basicsr.utils import DiffJPEG, USMSharp
-from basicsr.utils.img_process_util import filter2D
-from basicsr.utils.registry import MODEL_REGISTRY
-from collections import OrderedDict
-from torch.nn import functional as F
-@MODEL_REGISTRY.register()
-class RealESRGANModel(SRGANModel):
-    """RealESRGAN Model for Real-ESRGAN: Training Real-World Blind Super-Resolution with Pure Synthetic Data.
-    It mainly performs:
-    1. randomly synthesize LQ images in GPU tensors
-    2. optimize the networks with GAN training.
-    """
-    def __init__(self, opt):
-        super(RealESRGANModel, self).__init__(opt)
-        self.jpeger = DiffJPEG(differentiable=False).cuda()  # simulate JPEG compression artifacts
-        self.usm_sharpener = USMSharp().cuda()  # do usm sharpening
-        self.queue_size = opt.get('queue_size', 180)
-    @torch.no_grad()
-    def _dequeue_and_enqueue(self):
-        """It is the training pair pool for increasing the diversity in a batch.
-        Batch processing limits the diversity of synthetic degradations in a batch. For example, samples in a
-        batch could not have different resize scaling factors. Therefore, we employ this training pair pool
-        to increase the degradation diversity in a batch.
-        """
-        # initialize
-        b, c, h, w = self.lq.size()
-        if not hasattr(self, 'queue_lr'):
-            assert self.queue_size % b == 0, f'queue size {self.queue_size} should be divisible by batch size {b}'
-            self.queue_lr = torch.zeros(self.queue_size, c, h, w).cuda()
-            _, c, h, w = self.gt.size()
-            self.queue_gt = torch.zeros(self.queue_size, c, h, w).cuda()
-            self.queue_ptr = 0
-        if self.queue_ptr == self.queue_size:  # the pool is full
-            # do dequeue and enqueue
-            # shuffle
-            idx = torch.randperm(self.queue_size)
-            self.queue_lr = self.queue_lr[idx]
-            self.queue_gt = self.queue_gt[idx]
-            # get first b samples
-            lq_dequeue = self.queue_lr[0:b, :, :, :].clone()
-            gt_dequeue = self.queue_gt[0:b, :, :, :].clone()
-            # update the queue
-            self.queue_lr[0:b, :, :, :] = self.lq.clone()
-            self.queue_gt[0:b, :, :, :] = self.gt.clone()
-            self.lq = lq_dequeue
-            self.gt = gt_dequeue
-        else:
-            # only do enqueue
-            self.queue_lr[self.queue_ptr:self.queue_ptr + b, :, :, :] = self.lq.clone()
-            self.queue_gt[self.queue_ptr:self.queue_ptr + b, :, :, :] = self.gt.clone()
-            self.queue_ptr = self.queue_ptr + b
-    @torch.no_grad()
-    def feed_data(self, data):
-        """Accept data from dataloader, and then add two-order degradations to obtain LQ images.
-        """
-        if self.is_train and self.opt.get('high_order_degradation', True):
-            # training data synthesis
-            self.gt = data['gt'].to(self.device)
-            self.gt_usm = self.usm_sharpener(self.gt)
-            self.kernel1 = data['kernel1'].to(self.device)
-            self.kernel2 = data['kernel2'].to(self.device)
-            self.sinc_kernel = data['sinc_kernel'].to(self.device)
-            ori_h, ori_w = self.gt.size()[2:4]
-            # ----------------------- The first degradation process ----------------------- #
-            # blur
-            out = filter2D(self.gt_usm, self.kernel1)
-            # random resize
-            updown_type = random.choices(['up', 'down', 'keep'], self.opt['resize_prob'])[0]
-            if updown_type == 'up':
-                scale = np.random.uniform(1, self.opt['resize_range'][1])
-            elif updown_type == 'down':
-                scale = np.random.uniform(self.opt['resize_range'][0], 1)
-            else:
-                scale = 1
-            mode = random.choice(['area', 'bilinear', 'bicubic'])
-            out = F.interpolate(out, scale_factor=scale, mode=mode)
-            # add noise
-            gray_noise_prob = self.opt['gray_noise_prob']
-            if np.random.uniform() < self.opt['gaussian_noise_prob']:
-                out = random_add_gaussian_noise_pt(
-                    out, sigma_range=self.opt['noise_range'], clip=True, rounds=False, gray_prob=gray_noise_prob)
-            else:
-                out = random_add_poisson_noise_pt(
-                    out,
-                    scale_range=self.opt['poisson_scale_range'],
-                    gray_prob=gray_noise_prob,
-                    clip=True,
-                    rounds=False)
-            # JPEG compression
-            jpeg_p = out.new_zeros(out.size(0)).uniform_(*self.opt['jpeg_range'])
-            out = torch.clamp(out, 0, 1)  # clamp to [0, 1], otherwise JPEGer will result in unpleasant artifacts
-            out = self.jpeger(out, quality=jpeg_p)
-            # ----------------------- The second degradation process ----------------------- #
-            # blur
-            if np.random.uniform() < self.opt['second_blur_prob']:
-                out = filter2D(out, self.kernel2)
-            # random resize
-            updown_type = random.choices(['up', 'down', 'keep'], self.opt['resize_prob2'])[0]
-            if updown_type == 'up':
-                scale = np.random.uniform(1, self.opt['resize_range2'][1])
-            elif updown_type == 'down':
-                scale = np.random.uniform(self.opt['resize_range2'][0], 1)
-            else:
-                scale = 1
-            mode = random.choice(['area', 'bilinear', 'bicubic'])
-            out = F.interpolate(
-                out, size=(int(ori_h / self.opt['scale'] * scale), int(ori_w / self.opt['scale'] * scale)), mode=mode)
-            # add noise
-            gray_noise_prob = self.opt['gray_noise_prob2']
-            if np.random.uniform() < self.opt['gaussian_noise_prob2']:
-                out = random_add_gaussian_noise_pt(
-                    out, sigma_range=self.opt['noise_range2'], clip=True, rounds=False, gray_prob=gray_noise_prob)
-            else:
-                out = random_add_poisson_noise_pt(
-                    out,
-                    scale_range=self.opt['poisson_scale_range2'],
-                    gray_prob=gray_noise_prob,
-                    clip=True,
-                    rounds=False)
-            # JPEG compression + the final sinc filter
-            # We also need to resize images to desired sizes. We group [resize back + sinc filter] together
-            # as one operation.
-            # We consider two orders:
-            #   1. [resize back + sinc filter] + JPEG compression
-            #   2. JPEG compression + [resize back + sinc filter]
-            # Empirically, we find other combinations (sinc + JPEG + Resize) will introduce twisted lines.
-            if np.random.uniform() < 0.5:
-                # resize back + the final sinc filter
-                mode = random.choice(['area', 'bilinear', 'bicubic'])
-                out = F.interpolate(out, size=(ori_h // self.opt['scale'], ori_w // self.opt['scale']), mode=mode)
-                out = filter2D(out, self.sinc_kernel)
-                # JPEG compression
-                jpeg_p = out.new_zeros(out.size(0)).uniform_(*self.opt['jpeg_range2'])
-                out = torch.clamp(out, 0, 1)
-                out = self.jpeger(out, quality=jpeg_p)
-            else:
-                # JPEG compression
-                jpeg_p = out.new_zeros(out.size(0)).uniform_(*self.opt['jpeg_range2'])
-                out = torch.clamp(out, 0, 1)
-                out = self.jpeger(out, quality=jpeg_p)
-                # resize back + the final sinc filter
-                mode = random.choice(['area', 'bilinear', 'bicubic'])
-                out = F.interpolate(out, size=(ori_h // self.opt['scale'], ori_w // self.opt['scale']), mode=mode)
-                out = filter2D(out, self.sinc_kernel)
-            # clamp and round
-            self.lq = torch.clamp((out * 255.0).round(), 0, 255) / 255.
-            # random crop
-            gt_size = self.opt['gt_size']
-            (self.gt, self.gt_usm), self.lq = paired_random_crop([self.gt, self.gt_usm], self.lq, gt_size,
-                                                                 self.opt['scale'])
-            # training pair pool
-            self._dequeue_and_enqueue()
-            # sharpen self.gt again, as we have changed the self.gt with self._dequeue_and_enqueue
-            self.gt_usm = self.usm_sharpener(self.gt)
-            self.lq = self.lq.contiguous()  # for the warning: grad and param do not obey the gradient layout contract
-        else:
-            # for paired training or validation
-            self.lq = data['lq'].to(self.device)
-            if 'gt' in data:
-                self.gt = data['gt'].to(self.device)
-                self.gt_usm = self.usm_sharpener(self.gt)
-    def nondist_validation(self, dataloader, current_iter, tb_logger, save_img):
-        # do not use the synthetic process during validation
-        self.is_train = False
-        super(RealESRGANModel, self).nondist_validation(dataloader, current_iter, tb_logger, save_img)
-        self.is_train = True
-    def optimize_parameters(self, current_iter):
-        # usm sharpening
-        l1_gt = self.gt_usm
-        percep_gt = self.gt_usm
-        gan_gt = self.gt_usm
-        if self.opt['l1_gt_usm'] is False:
-            l1_gt = self.gt
-        if self.opt['percep_gt_usm'] is False:
-            percep_gt = self.gt
-        if self.opt['gan_gt_usm'] is False:
-            gan_gt = self.gt
-        # optimize net_g
-        for p in self.net_d.parameters():
-            p.requires_grad = False
-        self.optimizer_g.zero_grad()
-        self.output = self.net_g(self.lq)
-        l_g_total = 0
-        loss_dict = OrderedDict()
-        if (current_iter % self.net_d_iters == 0 and current_iter > self.net_d_init_iters):
-            # pixel loss
-            if self.cri_pix:
-                l_g_pix = self.cri_pix(self.output, l1_gt)
-                l_g_total += l_g_pix
-                loss_dict['l_g_pix'] = l_g_pix
-            # perceptual loss
-            if self.cri_perceptual:
-                l_g_percep, l_g_style = self.cri_perceptual(self.output, percep_gt)
-                if l_g_percep is not None:
-                    l_g_total += l_g_percep
-                    loss_dict['l_g_percep'] = l_g_percep
-                if l_g_style is not None:
-                    l_g_total += l_g_style
-                    loss_dict['l_g_style'] = l_g_style
-            # gan loss
-            fake_g_pred = self.net_d(self.output)
-            l_g_gan = self.cri_gan(fake_g_pred, True, is_disc=False)
-            l_g_total += l_g_gan
-            loss_dict['l_g_gan'] = l_g_gan
-            l_g_total.backward()
-            self.optimizer_g.step()
-        # optimize net_d
-        for p in self.net_d.parameters():
-            p.requires_grad = True
-        self.optimizer_d.zero_grad()
-        # real
-        real_d_pred = self.net_d(gan_gt)
-        l_d_real = self.cri_gan(real_d_pred, True, is_disc=True)
-        loss_dict['l_d_real'] = l_d_real
-        loss_dict['out_d_real'] = torch.mean(real_d_pred.detach())
-        l_d_real.backward()
-        # fake
-        fake_d_pred = self.net_d(self.output.detach().clone())  # clone for pt1.9
-        l_d_fake = self.cri_gan(fake_d_pred, False, is_disc=True)
-        loss_dict['l_d_fake'] = l_d_fake
-        loss_dict['out_d_fake'] = torch.mean(fake_d_pred.detach())
-        l_d_fake.backward()
-        self.optimizer_d.step()
-        if self.ema_decay > 0:
-            self.model_ema(decay=self.ema_decay)
-        self.log_dict = self.reduce_loss_dict(loss_dict)

spaces/Eddycrack864/Applio-Inference/infer/lib/uvr5_pack/lib_v5/layers_new.py DELETED Viewed

@@ -1,125 +0,0 @@
-import torch
-import torch.nn.functional as F
-from torch import nn
-from . import spec_utils
-class Conv2DBNActiv(nn.Module):
-    def __init__(self, nin, nout, ksize=3, stride=1, pad=1, dilation=1, activ=nn.ReLU):
-        super(Conv2DBNActiv, self).__init__()
-        self.conv = nn.Sequential(
-            nn.Conv2d(
-                nin,
-                nout,
-                kernel_size=ksize,
-                stride=stride,
-                padding=pad,
-                dilation=dilation,
-                bias=False,
-            ),
-            nn.BatchNorm2d(nout),
-            activ(),
-        )
-    def __call__(self, x):
-        return self.conv(x)
-class Encoder(nn.Module):
-    def __init__(self, nin, nout, ksize=3, stride=1, pad=1, activ=nn.LeakyReLU):
-        super(Encoder, self).__init__()
-        self.conv1 = Conv2DBNActiv(nin, nout, ksize, stride, pad, activ=activ)
-        self.conv2 = Conv2DBNActiv(nout, nout, ksize, 1, pad, activ=activ)
-    def __call__(self, x):
-        h = self.conv1(x)
-        h = self.conv2(h)
-        return h
-class Decoder(nn.Module):
-    def __init__(
-        self, nin, nout, ksize=3, stride=1, pad=1, activ=nn.ReLU, dropout=False
-    ):
-        super(Decoder, self).__init__()
-        self.conv1 = Conv2DBNActiv(nin, nout, ksize, 1, pad, activ=activ)
-        # self.conv2 = Conv2DBNActiv(nout, nout, ksize, 1, pad, activ=activ)
-        self.dropout = nn.Dropout2d(0.1) if dropout else None
-    def __call__(self, x, skip=None):
-        x = F.interpolate(x, scale_factor=2, mode="bilinear", align_corners=True)
-        if skip is not None:
-            skip = spec_utils.crop_center(skip, x)
-            x = torch.cat([x, skip], dim=1)
-        h = self.conv1(x)
-        # h = self.conv2(h)
-        if self.dropout is not None:
-            h = self.dropout(h)
-        return h
-class ASPPModule(nn.Module):
-    def __init__(self, nin, nout, dilations=(4, 8, 12), activ=nn.ReLU, dropout=False):
-        super(ASPPModule, self).__init__()
-        self.conv1 = nn.Sequential(
-            nn.AdaptiveAvgPool2d((1, None)),
-            Conv2DBNActiv(nin, nout, 1, 1, 0, activ=activ),
-        )
-        self.conv2 = Conv2DBNActiv(nin, nout, 1, 1, 0, activ=activ)
-        self.conv3 = Conv2DBNActiv(
-            nin, nout, 3, 1, dilations[0], dilations[0], activ=activ
-        )
-        self.conv4 = Conv2DBNActiv(
-            nin, nout, 3, 1, dilations[1], dilations[1], activ=activ
-        )
-        self.conv5 = Conv2DBNActiv(
-            nin, nout, 3, 1, dilations[2], dilations[2], activ=activ
-        )
-        self.bottleneck = Conv2DBNActiv(nout * 5, nout, 1, 1, 0, activ=activ)
-        self.dropout = nn.Dropout2d(0.1) if dropout else None
-    def forward(self, x):
-        _, _, h, w = x.size()
-        feat1 = F.interpolate(
-            self.conv1(x), size=(h, w), mode="bilinear", align_corners=True
-        )
-        feat2 = self.conv2(x)
-        feat3 = self.conv3(x)
-        feat4 = self.conv4(x)
-        feat5 = self.conv5(x)
-        out = torch.cat((feat1, feat2, feat3, feat4, feat5), dim=1)
-        out = self.bottleneck(out)
-        if self.dropout is not None:
-            out = self.dropout(out)
-        return out
-class LSTMModule(nn.Module):
-    def __init__(self, nin_conv, nin_lstm, nout_lstm):
-        super(LSTMModule, self).__init__()
-        self.conv = Conv2DBNActiv(nin_conv, 1, 1, 1, 0)
-        self.lstm = nn.LSTM(
-            input_size=nin_lstm, hidden_size=nout_lstm // 2, bidirectional=True
-        )
-        self.dense = nn.Sequential(
-            nn.Linear(nout_lstm, nin_lstm), nn.BatchNorm1d(nin_lstm), nn.ReLU()
-        )
-    def forward(self, x):
-        N, _, nbins, nframes = x.size()
-        h = self.conv(x)[:, 0]  # N, nbins, nframes
-        h = h.permute(2, 0, 1)  # nframes, N, nbins
-        h, _ = self.lstm(h)
-        h = self.dense(h.reshape(-1, h.size()[-1]))  # nframes * N, nbins
-        h = h.reshape(nframes, N, 1, nbins)
-        h = h.permute(1, 2, 3, 0)
-        return h