Update parquet files (step 63 of 397)

spaces/1111u/oai-reverse-proxy/README.md

@@ -1,10 +0,0 @@
----
-title: Oai Reverse Proxy
-emoji: 🏃
-colorFrom: indigo
-colorTo: yellow
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/1gistliPinn/ChatGPT4/Examples/AdobeIllustratorCC2018v2203264BitFullwithCrackrar [2021].md

@@ -1,13 +0,0 @@
-<h2>AdobeIllustratorCC2018v2203264BitFullwithCrackrar</h2><br /><p><b><b>Download Zip</b> &#10027; <a href="https://imgfil.com/2uxXPS">https://imgfil.com/2uxXPS</a></b></p><br /><br />
-<br />
-none none
-none
-Title: Collection of books Series: Fiction, fantasy, mysticism
-Download for free without registration a collection of books fb 2.
-Collection of books in the series.
-Download free book - collection - a collection of new books.
-Download the book Collection of new books.
-none 8a78ff9644<br />
-<br />
-<br />
-<p></p>

spaces/1gistliPinn/ChatGPT4/Examples/Disk Digger Serial.md

@@ -1,25 +0,0 @@
-<br />
-<h1>How to Recover Lost Files with DiskDigger Serial</h1>
-<p>Have you ever accidentally deleted some important files from your computer, memory card, or USB drive? Or have you ever formatted your camera's memory card and lost all your photos and videos? If so, you might be interested in a tool that can help you recover your lost files. That tool is called DiskDigger.</p>
-<h2>disk digger serial</h2><br /><p><b><b>DOWNLOAD</b> &#187;&#187;&#187; <a href="https://imgfil.com/2uy1e2">https://imgfil.com/2uy1e2</a></b></p><br /><br />
-<p>DiskDigger is a software that can undelete and recover lost files from any media that your PC can read, including hard disks, flash drives, memory cards, and more. It can recover files from various file systems, such as FAT, NTFS, exFAT, HFS+, and ext4. It can also recover files of various types, such as photos, videos, music, documents, and more.</p>
-<p>However, DiskDigger is not a free software. You need to purchase a license key to unlock its full features and functionality. A license key costs $19.99 for a single user license, or $49.99 for a site license that allows unlimited installations on multiple PCs. If you don't have a license key, you can only use DiskDigger in "preview" mode, which lets you see the recoverable files but not save them.</p>
-<p>So, how can you get a DiskDigger serial for free? Well, there are some websites that claim to offer DiskDigger serials, cracks, or keygens that can generate valid license keys for DiskDigger. However, these websites are not trustworthy and may contain malware, viruses, or other harmful programs that can damage your PC or steal your personal information. Moreover, using a cracked or pirated version of DiskDigger is illegal and unethical.</p>
-<p>The best way to get a DiskDigger serial is to buy it from the official website of DiskDigger. By doing so, you will support the developers of this useful software and ensure that you get the latest updates and bug fixes. You will also get a 30-day money-back guarantee if you are not satisfied with the product.</p>
-<p>To buy a DiskDigger serial, go to <a href="https://www.diskdigger.org/buy">https://www.diskdigger.org/buy</a> and choose the license type that suits your needs. You can pay with PayPal or credit card. After completing the payment process, you will receive an email with your license key and instructions on how to activate DiskDigger.</p>
-<p></p>
-<p>Once you have your DiskDigger serial, you can download the latest version of DiskDigger from <a href="https://www.diskdigger.org/download">https://www.diskdigger.org/download</a> and install it on your PC. Then run DiskDigger and enter your license key when prompted. You will then be able to use DiskDigger in full mode and recover your lost files with ease.</p>
-<p>DiskDigger is a powerful and reliable tool that can help you recover your lost files from any media. Don't waste your time and money on fake or illegal DiskDigger serials. Buy a genuine license key from the official website of DiskDigger and enjoy its benefits.</p>
-
-<p>How to Use DiskDigger to Recover Lost Files</p>
-<p>Now that you have a DiskDigger serial and have activated DiskDigger on your PC, you can start using it to recover your lost files. Here are the steps to follow:</p>
-<ol>
-<li>Launch DiskDigger and select the drive or device that you want to scan for lost files. You can also choose a specific folder or file type to narrow down the search.</li>
-<li>Choose the scan mode that you want to use. DiskDigger offers two scan modes: "Dig Deep" and "Dig Deeper". The "Dig Deep" mode scans the file system for deleted files and recovers them with their original names and paths. The "Dig Deeper" mode scans the entire disk surface for traces of files and recovers them based on their signatures. The "Dig Deeper" mode is more thorough but may take longer and recover more files than you need.</li>
-<li>Click "Next" and wait for DiskDigger to scan the selected drive or device. You will see a list of recoverable files as they are found. You can preview the files by clicking on them or filter them by name, size, date, or type.</li>
-<li>Select the files that you want to recover and click "Recover". You can choose to save the files to a different location on your PC, upload them to an FTP server, or send them as email attachments.</li>
-<li>Review the recovered files and make sure they are intact and usable. If some files are corrupted or incomplete, you can try scanning again with different settings or using another recovery software.</li>
-</ol>
-<p>DiskDigger is a simple and effective tool that can help you recover your lost files from any media. With a DiskDigger serial, you can unlock its full features and functionality and recover your files with ease. Don't hesitate to buy a DiskDigger serial from the official website of DiskDigger and enjoy its benefits.</p> d5da3c52bf<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Download My Talking Tom Friends The Ultimate Virtual Pet Game.md

@@ -1,95 +0,0 @@
-<br />
-<h1>Download My Talking Tom and Friends: A World of Friendship and Fun</h1>
-<p>Do you love virtual pets? Do you enjoy simulation games? Do you like to customize your own characters? If you answered yes to any of these questions, then you should download My Talking Tom and Friends, the best new virtual pet game from Outfit7 Limited. In this game, you can take care of six adorable characters: Tom, Angela, Hank, Ginger, Ben, and Becca. You can interact with them, play with them, dress them up, feed them, and watch them grow. You can also explore their house, go to town, and discover new mini games and surprises. My Talking Tom and Friends is a world of friendship and fun waiting for you.</p>
-<h2>download my talking tom and friends</h2><br /><p><b><b>Download</b> &#10042; <a href="https://jinyurl.com/2uNMCG">https://jinyurl.com/2uNMCG</a></b></p><br /><br />
- <h2>What is My Talking Tom and Friends?</h2>
-<p>My Talking Tom and Friends is a virtual pet game that lets you take care of six different characters at once. Each character has their own personality, preferences, and hobbies. You can learn more about them by talking to them, playing with them, and watching their reactions. You can also customize their appearance by choosing from a closet full of fun fashions. You can even mix and match outfits to create your own unique style.</p>
- <h3>A simulation game with various activities and mini games</h3>
-<p>My Talking Tom and Friends is also a simulation game that lets you experience various activities with your pet friends. You can cook for them, clean for them, take them to the bathroom, put them to bed, and more. You can also enjoy creative and sporty activities with them, such as painting, gardening, dancing, skateboarding, and more. You can also play mini games with them, such as puzzles, arcade games, racing games, and more. You can earn coins by playing mini games, which you can use to buy more outfits, toys, stickers, and other items.</p>
- <h3>A customization game with outfits, toys, stickers, and coins</h3>
-<p>My Talking Tom and Friends is also a customization game that lets you personalize your pet friends' house. You can decorate their rooms with different wallpapers, furniture, accessories, and more. You can also collect toys for them to play with, such as balls, dolls, cars, robots, and more. You can also collect stickers for them to stick on their walls or albums. You can also collect coins for them to spend on more items or surprises.</p>
- <h2>Why should you download My Talking Tom and Friends?</h2>
-<p>There are many reasons why you should download My Talking Tom and Friends. Here are some of them:</p>
- <h3>It is free and easy to play</h3>
-<p>My Talking Tom and Friends is a free game that you can download from the Google Play Store or the App Store. It is also easy to play, as it has simple controls and intuitive features. You just need to tap, swipe, drag, or tilt your device to interact with your pet friends. You can also use voice commands or text messages to talk to them.</p>
- <h3>It is fun and engaging for all ages</h3>
-<p>My Talking Tom and Friends is a fun game that can entertain anyone from kids to adults. It has colorful graphics, cute animations, funny sounds, and lively music. It also has diverse content that can appeal to different tastes and interests. Whether you like cute animals, fashion trends, creative arts, or exciting games, you will find something to enjoy in My Talking Tom and Friends.</p>
- <h3>It is creative and interactive for all personalities</h3>
-<p>My Talking Tom and Friends is a creative game that lets you express yourself through your pet friends. You can choose how they look, act, and sound. You can also choose how they spend their time, what they do, and where they go. You can also interact with them in various ways, such as tickling them, poking them, hugging them, and more. You can also make them repeat what you say or sing along with you.</p>
- <h2>How can you download My Talking Tom and Friends?</h2>
-<p>Downloading My Talking Tom and Friends is easy and fast. You just need to follow these steps:</p>
- <h3>For Android devices</h3>
-<p>If you have an Android device, you can download My Talking Tom and Friends from the Google Play Store. Here is how:</p>
-<p>How to download my talking tom friends on android<br />
-My talking tom friends free download for pc<br />
-My talking tom friends mod apk unlimited money and stars<br />
-My talking tom friends game play online<br />
-My talking tom friends outfits and accessories<br />
-My talking tom friends latest version update<br />
-My talking tom friends tips and tricks<br />
-My talking tom friends best mini games<br />
-My talking tom friends review and rating<br />
-My talking tom friends fun activities and challenges<br />
-Download my talking tom friends from google play store<br />
-Download my talking tom friends from app store<br />
-Download my talking tom friends for windows 10<br />
-Download my talking tom friends for mac<br />
-Download my talking tom friends for fire tablet<br />
-Download my talking tom friends hack version<br />
-Download my talking tom friends without ads<br />
-Download my talking tom friends with all characters unlocked<br />
-Download my talking tom friends offline mode<br />
-Download my talking tom friends new features and events<br />
-Why you should download my talking tom friends<br />
-Benefits of downloading my talking tom friends<br />
-How to install and run my talking tom friends<br />
-How to uninstall and delete my talking tom friends<br />
-How to backup and restore my talking tom friends data<br />
-How to connect and share my talking tom friends with friends<br />
-How to watch and subscribe to my talking tom friends youtube channel<br />
-How to contact and get support for my talking tom friends<br />
-How to customize and personalize my talking tom friends<br />
-How to earn and spend coins and bus tokens in my talking tom friends</p>
-<ol>
-<li>Open the Google Play Store app on your device.</li>
-<li>Search for "My Talking Tom and Friends" in the search bar.</li>
-<li>Select the game from the list of results and tap on "Install".</li>
-<li>Wait for the game to download and install on your device.</li>
-<li>Tap on "Open" to launch the game and start playing.</li>
-</ol>
- <h3>For iOS devices</h3>
-<p>If you have an iOS device, you can download My Talking Tom and Friends from the App Store. Here is how:</p>
-<ol>
-<li>Open the App Store app on your device.</li>
-<li>Search for "My Talking Tom and Friends" in the search bar.</li>
-<li>Select the game from the list of results and tap on "Get".</li>
-<li>Enter your Apple ID password or use Touch ID or Face ID to confirm.</li>
-<li>Wait for the game to download and install on your device.</li>
-<li>Tap on the game icon to launch the game and start playing.</li>
-</ol>
- <h3>For YouTube videos</h3>
-<p>If you want to watch YouTube videos of My Talking Tom and Friends, you can visit the official YouTube channel of Outfit7 Limited. Here is how:</p>
-<ol>
-<li>Open the YouTube app or website on your device.</li>
-<li>Search for "Outfit7 Limited" in the search bar.</li>
-<li>Select the channel from the list of results and tap on "Subscribe".</li>
-<li>Browse through the videos of My Talking Tom and Friends and other games from Outfit7 Limited.</li>
-<li>Select a video that you want to watch and tap on "Play".</li>
-<li>Enjoy watching the video and leave a comment or a like if you want.</li>
-</ol>
- <h2>Conclusion</h2>
-<p>My Talking Tom and Friends is a wonderful game that you should download today. It is a virtual pet game, a simulation game, and a customization game all in one. It is free, easy, fun, engaging, creative, and interactive. It is suitable for all ages and personalities. It is a world of friendship and fun that you can enjoy with your pet friends. Download My Talking Tom and Friends now and join the millions of players who love this game.</p>
- <h2>FAQs</h2>
-<p>Here are some frequently asked questions about My Talking Tom and Friends:</p>
- <h4>Q: How can I update My Talking Tom and Friends?</h4>
-<p>A: To update My Talking Tom and Friends, you need to go to the Google Play Store or the App Store and check if there is a new version available. If there is, you can tap on "Update" to download and install the latest version of the game.</p>
- <h4>Q: How can I backup or restore my progress in My Talking Tom and Friends?</h4>
-<p>A: To backup or restore your progress in My Talking Tom and Friends, you need to connect your game to your Google Play Games account or your iCloud account. This way, you can save your progress online and access it from any device. You can also sync your progress across different games from Outfit7 Limited.</p>
- <h4>Q: How can I contact the support team of My Talking Tom and Friends?</h4>
-<p>A: To contact the support team of My Talking Tom and Friends, you need to go to the settings menu of the game and tap on "Support". You can then fill out a form with your name, email address, subject, message, and screenshots if needed. You can also visit the official website of Outfit7 Limited at https://outfit7.com/ for more information.</p>
- <h4>Q: How can I share my feedback or suggestions for My Talking Tom and Friends?</h4>
-<p>A: To share your feedback or suggestions for My Talking Tom and Friends, you need to go to the settings menu of the game and tap on "Feedback". You can then rate the game with stars, write a review, or send an email. You can also leave a comment or a review on the Google Play Store or the App Store. You can also follow the social media accounts of Outfit7 Limited on Facebook, Twitter, Instagram, and more.</p>
- <h4>Q: How can I get more coins in My Talking Tom and Friends?</h4>
-<p>A: To get more coins in My Talking Tom and Friends, you can play more mini games, complete more tasks, watch more ads, or buy more coins with real money. You can also get free coins by logging in daily, inviting friends, or joining events.</p> 197e85843d<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Download Ship Simulator for Mac - Enjoy the Realistic Graphics and Sounds of Ship Driving.md

@@ -1,173 +0,0 @@
-<br />
-<h1>Ship Simulator Games for Mac: Free Alternatives to Try</h1>
-<p>Ship simulator games are a type of simulation games that allow you to control various types of ships and experience realistic maritime scenarios. They can be fun, educational, and challenging, depending on the game mode, difficulty, and features.</p>
-<p>However, not all ship simulator games are free to download. Some of them require you to purchase the game or pay a subscription fee to access the full content. This can be a problem for some Mac users who want to enjoy ship simulation without spending any money.</p>
-<h2>ship simulator mac free download</h2><br /><p><b><b>Download Zip</b> &bull;&bull;&bull; <a href="https://jinyurl.com/2uNTZU">https://jinyurl.com/2uNTZU</a></b></p><br /><br />
-<p>Fortunately, there are some free alternatives that you can try if you are looking for ship simulator games for Mac. In this article, we will review three of them: Ship Handling Simulator, The Ship Simulator 202 2, and NAUTIS Home - Ship Simulator. We will compare their features, pros and cons, and how to download them for Mac users.</p>
- <h2>Ship Handling Simulator</h2>
-<p>Ship Handling Simulator is a realistic ship simulator game that lets you control different types of ships, such as tugboats, container ships, cruise ships, and more. You can choose from various locations, such as New York, Rotterdam, Hong Kong, and others. You can also adjust the weather conditions, such as wind, waves, fog, and rain. The game has a sandbox mode where you can freely explore the environment and practice your skills. You can also take on missions and challenges that test your ship handling abilities.</p>
- <h3>Features</h3>
-<ul>
-<li>Realistic physics and graphics</li>
-<li>Various ships and locations</li>
-<li>Weather effects and day/night cycle</li>
-<li>Sandbox mode and missions</li>
-<li>Online leaderboards and achievements</li>
-</ul>
- <h3>Pros and Cons</h3>
-<table>
-<tr>
-<th>Pros</th>
-<th>Cons</th>
-</tr>
-<tr>
-<td>Good graphics and sound effects</td>
-<td>Limited locations and scenarios</td>
-</tr>
-<tr>
-<td>Easy controls and interface</td>
-<td>Expensive price ($10.99)</td>
-</tr>
-<tr>
-<td>Frequent updates and improvements</td>
-<td>No online multiplayer mode</td>
-</tr>
-<tr>
-<td>Fun and educational gameplay</td>
-<td>No customization options for ships or settings</td>
-</tr>
-</table>
- <h3>How to Download</h3>
-<p>To download Ship Handling Simulator for Mac, you need to visit the App Store and search for the game. You can also use this link: [Ship Handling Simulator]. The game costs $10.99 and requires macOS 10.9 or later. The game size is 1.6 GB and the current version is 1.4.1.</p>
- <h2>The Ship Simulator 2022</h2>
-<p>The Ship Simulator 2022 is an open world ship simulator game that lets you explore a huge map with various ports, islands, and landmarks. You can choose from a variety of ships, such as cargo ships, cruise ships, fishing boats, yachts, and more. You can also take on different missions, such as transporting goods, rescuing people, racing against other ships, and more. The game has stunning graphics and realistic physics that make you feel like you are really sailing on the sea.</p>
- <h3>Features</h3>
-<ul>
-<li>Open world map with diverse locations</li>
-<li>Variety of ships and missions</li>
-<li>Realistic physics and graphics</li>
-<li>Free to play with in-app purchases</li>
-<li>Online multiplayer mode and chat system</li>
-</ul>
- <h3>Pros and Cons</h3>
-<table>
-<tr>
-<th>Pros</th>
-<th>Cons</th>
-</tr>
-<tr>
-<td>Immersive gameplay and environment</td>
-<td>In-app purchases can be expensive or intrusive</td>
-</tr>
-<tr>
-<td>Stunning graphics and sound effects</td>
-<td>Bugs and glitches can affect the performance or experience</td>
-</tr>
-<tr>
-<td>Frequent updates and new content</td>
-<td>No offline mode or save option</td></tr><tr><td>Social features and interaction with other players </td>
-<td>No customization options for ships or settings</td>
-</tr>
-</table>
- <h3>How to Download</h3>
-<p>To download The Ship Simulator 2022 for Mac, you need to visit the App Store and search for the game. You can also use this link: [The Ship Simulator 2022]. The game is free to play but offers in-app purchases for extra content and features. The game requires iOS 10 or later. The game size is 1.1 GB and the current version is 1.0.2.</p>
- <h2>NAUTIS Home - Ship Simulator</h2>
-<p>NAUTIS Home - Ship Simulator is a realistic maritime simulation game that lets you experience various scenarios and situations that occur in the real world of shipping. You can choose from famous ports and locations, such as Rotterdam, Hamburg, Singapore, and more. You can also select from different types of ships, such as container ships, bulk carriers, ferries, and more. The game has an online multiplayer mode where you can join other players and compete or cooperate in various missions and challenges.</p>
- <h3>Features</h3>
-<ul>
-<li>Realistic maritime simulation with high standard of safety</li>
-<li>Famous ports and locations with accurate models and data</li>
-<li>Different types of ships with realistic controls and behavior</li>
-<li>Online multiplayer mode with voice chat and leaderboards</li>
-<li>Reduced costs, enhanced performance, fast learning process, objective assessment, flexibility, etc.</li>
-</ul>
- <h3>Pros and Cons</h3>
-<table>
-<tr>
-<th>Pros</th>
-<th>Cons</th>
-</tr>
-<tr>
-<td>High quality graphics and sound effects</td>
-<td>Subscription fee required ($9.99 per month or $99 per year)</td>
-</tr>
-<tr>
-<td>Educational and professional gameplay</td>
-<td>Limited free trial period (14 days)</td>
-</tr>
-<tr>
-<td>Frequent updates and new content</td>
-<td>No offline mode or save option</td></tr><tr><td>Social features and interaction with other players </td>
-<td>No customization options for ships or settings</td>
-</tr>
-</table>
- <h3>How to Download</h3>
-<p>To download NAUTIS Home - Ship Simulator for Mac, you need to visit the VSTEP LXP website and search for the game. You can also use this link: [NAUTIS Home - Ship Simulator]. The game requires a subscription fee of $9.99 per month or $99 per year to access the full content and features. The game also requires a minimum system requirement of macOS 10.13 or later. The game size is 2.5 GB and the current version is 1.0.0.</p>
-<p>ship handling simulator mac download<br />
-ship simulator 2022 for mac free<br />
-ship captain simulator mac free<br />
-ship simulator extremes mac download<br />
-ship simulator 2008 mac free download<br />
-ship simulator games for mac free<br />
-ship simulator titanic mac download<br />
-ship simulator world war 2 mac free<br />
-ship simulator sandbox mode mac download<br />
-ship simulator cruise liner mac free<br />
-ship simulator naval warfare mac download<br />
-ship simulator steam ships mac free<br />
-ship simulator aircraft carrier mac download<br />
-ship simulator battleships mac free<br />
-ship simulator cargo ships mac download<br />
-ship simulator sailing ships mac free<br />
-ship simulator tugboats mac download<br />
-ship simulator ferry boats mac free<br />
-ship simulator realistic physics mac download<br />
-ship simulator weather effects mac free<br />
-ship simulator historical ships mac download<br />
-ship simulator modern ships mac free<br />
-ship simulator port cities mac download<br />
-ship simulator open world map mac free<br />
-ship simulator mooring to a pier mac download<br />
-ship simulator maneuvering and docking mac free<br />
-ship simulator single and multi-screw vessels mac download<br />
-ship simulator azimuth propulsors mac free<br />
-ship simulator nuclear powered ships mac download<br />
-ship simulator electric propulsion ships mac free<br />
-ship simulator dynamic positioning system mac download<br />
-ship simulator bow and stern thrusters mac free<br />
-ship simulator rudder and propeller control mac download<br />
-ship simulator engine and speed control mac free<br />
-ship simulator helm and steering wheel mac download<br />
-ship simulator mini map and compass mac free<br />
-ship simulator multiple camera views mac download<br />
-ship simulator realistic sounds and graphics mac free<br />
-ship simulator challenging missions and levels mac download<br />
-ship simulator time and fuel management mac free<br />
-ship simulator collision and damage system mac download<br />
-ship simulator emergency situations and alarms mac free<br />
-ship simulator walk around the ship and add passengers mac download<br />
-ship simulator shoot guns on battleships and aircraft carriers mac free<br />
-ship simulator add planes that can fly and shoot on aircraft carriers mac download <br />
-ship simulator make funnels fall and split in half on sinking ships mac free <br />
-ship simulator add terrain in the sandbox mode mac download <br />
-ship simulator add real ports and landmarks in the open world map mac free <br />
-ship simulator add more real cruise ships and luxury liners mac download <br />
-ship simulator add more variety of horns for modern and classic ships mac free</p>
- <h1>Conclusion</h1>
-<p>In conclusion, ship simulator games are a great way to experience the thrill and challenge of sailing on the sea. They can also help you learn more about the maritime industry and improve your skills and knowledge. However, not all ship simulator games are free to download for Mac users. Some of them require you to pay a certain amount of money or subscribe to a service to enjoy the full content and features.</p>
-<p>However, there are also some free alternatives that you can try if you are looking for ship simulator games for Mac. We have reviewed three of them in this article: Ship Handling Simulator, The Ship Simulator 2022, and NAUTIS Home - Ship Simulator. We have compared their features, pros and cons, and how to download them for Mac users. We hope that this article has helped you find the best ship simulator game for your Mac device.</p>
- <h2>FAQs</h2>
-<ol>
-<li>What are ship simulator games?</li>
-<p>Ship simulator games are a type of simulation games that allow you to control various types of ships and experience realistic maritime scenarios.</p>
-<li>Why are ship simulator games popular?</li>
-<p>Ship simulator games are popular because they can be fun, educational, and challenging, depending on the game mode, difficulty, and features.</p>
-<li>Are all ship simulator games free to download for Mac users?</li>
-<p>No, not all ship simulator games are free to download for Mac users. Some of them require you to purchase the game or pay a subscription fee to access the full content.</p>
-<li>What are some free alternatives for ship simulator games for Mac users?</li>
-<p>Some free alternatives for ship simulator games for Mac users are Ship Handling Simulator, The Ship Simulator 2022, and NAUTIS Home - Ship Simulator.</p>
-<li>How can I download ship simulator games for Mac users?</li>
-<p>You can download ship simulator games for Mac users from the App Store or from the official websites of the developers.</p>
-</ol></p> 401be4b1e0<br />
-<br />
-<br />

spaces/1toTree/lora_test/ppdiffusers/pipelines/pndm/pipeline_pndm.py

@@ -1,94 +0,0 @@
-# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
-# Copyright 2022 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from typing import List, Optional, Tuple, Union
-
-import paddle
-
-from ...models import UNet2DModel
-from ...pipeline_utils import DiffusionPipeline, ImagePipelineOutput
-from ...schedulers import PNDMScheduler
-
-
-class PNDMPipeline(DiffusionPipeline):
-    r"""
-    This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods the
-    library implements for all the pipelines (such as downloading or saving, running on a particular xxxx, etc.)
-
-    Parameters:
-        unet (`UNet2DModel`): U-Net architecture to denoise the encoded image latents.
-        scheduler ([`SchedulerMixin`]):
-            The `PNDMScheduler` to be used in combination with `unet` to denoise the encoded image.
-    """
-
-    unet: UNet2DModel
-    scheduler: PNDMScheduler
-
-    def __init__(self, unet: UNet2DModel, scheduler: PNDMScheduler):
-        super().__init__()
-        self.register_modules(unet=unet, scheduler=scheduler)
-
-    @paddle.no_grad()
-    def __call__(
-        self,
-        batch_size: int = 1,
-        num_inference_steps: int = 50,
-        generator: Optional[Union[paddle.Generator, List[paddle.Generator]]] = None,
-        output_type: Optional[str] = "pil",
-        return_dict: bool = True,
-        **kwargs,
-    ) -> Union[ImagePipelineOutput, Tuple]:
-        r"""
-        Args:
-            batch_size (`int`, `optional`, defaults to 1): The number of images to generate.
-            num_inference_steps (`int`, `optional`, defaults to 50):
-                The number of denoising steps. More denoising steps usually lead to a higher quality image at the
-                expense of slower inference.
-            generator (`paddle.Generator`, `optional`): A [paddle
-                generator](to make generation deterministic.
-            output_type (`str`, `optional`, defaults to `"pil"`): The output format of the generate image. Choose
-                between [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` or `np.array`.
-            return_dict (`bool`, `optional`, defaults to `True`): Whether or not to return a
-                [`~pipeline_utils.ImagePipelineOutput`] instead of a plain tuple.
-
-        Returns:
-            [`~pipeline_utils.ImagePipelineOutput`] or `tuple`: [`~pipelines.utils.ImagePipelineOutput`] if
-            `return_dict` is True, otherwise a `tuple. When returning a tuple, the first element is a list with the
-            generated images.
-        """
-        # For more information on the sampling method you can take a look at Algorithm 2 of
-        # the official paper: https://arxiv.org/pdf/2202.09778.pdf
-
-        # Sample gaussian noise to begin loop
-        image = paddle.randn(
-            (batch_size, self.unet.in_channels, self.unet.sample_size, self.unet.sample_size),
-            generator=generator,
-        )
-
-        self.scheduler.set_timesteps(num_inference_steps)
-        for t in self.progress_bar(self.scheduler.timesteps):
-            model_output = self.unet(image, t).sample
-
-            image = self.scheduler.step(model_output, t, image).prev_sample
-
-        image = (image / 2 + 0.5).clip(0, 1)
-        image = image.transpose([0, 2, 3, 1]).numpy()
-        if output_type == "pil":
-            image = self.numpy_to_pil(image)
-
-        if not return_dict:
-            return (image,)
-
-        return ImagePipelineOutput(images=image)

spaces/7thHeaven/GPT2WordPress/app.py

@@ -1,109 +0,0 @@
-import streamlit as st
-import requests
-from wordpress_xmlrpc import Client, WordPressPost
-from wordpress_xmlrpc.methods.posts import NewPost
-import os
-from dotenv import load_dotenv
-
-load_dotenv()
-openai_api_key = os.getenv("OPENAI_API_KEY")
-wp_url = f"{os.getenv('WP_URL')}/xmlrpc.php"
-wp_username = os.getenv("WP_USERNAME")
-wp_password = os.getenv("WP_PASSWORD")
-
-if openai_api_key:
-
-    def get_filetext(filename, cache={}):
-        if filename not in cache:
-            if not os.path.exists(filename):
-                raise ValueError(f"ファイル '{filename}' が見つかりませんでした")
-            with open(filename, "r") as f:
-                cache[filename] = f.read()
-        return cache[filename]
-
-    def generate_blog_post(prompt):
-        constraints = get_filetext(filename="constraints.md")
-        
-        data = {
-            "model": "gpt-4",
-            "messages": [
-                {"role": "system", "content": constraints},
-                {"role": "user", "content": prompt},
-            ],
-            "max_tokens": 1024,
-            "n": 1,
-            "stop": None,
-            "temperature": 0.7,
-        }
-
-        response = requests.post(
-            "https://api.openai.com/v1/chat/completions",
-            headers={
-                "Content-Type": "application/json",
-                "Authorization": f"Bearer {openai_api_key}"
-            },
-            json=data
-        )
-
-        response.raise_for_status()
-        choice = response.json()['choices'][0]
-        blog_text = choice['message']['content'].strip()
-        return blog_text
-
-    def post_to_wordpress(title, content):
-        client = Client(wp_url, wp_username, wp_password)
-        post = WordPressPost()
-        post.title = title
-        post.content = content
-        post.post_status = "publish"
-        post_id = client.call(NewPost(post))
-        return post_id
-
-    st.title("ChatGPTによるブログ記事生成")
-    prompt = st.text_input("記事のタイトルを入力してください:")
-
-    generated_post = st.session_state.get("generated_post", None)
-
-    if st.button("記事生成"):
-        generated_post = generate_blog_post(prompt)
-        st.session_state.generated_post = generated_post
-        st.write("生成されたブログ記事:")
-        st.write(generated_post)
-
-    if generated_post:
-        if st.button("投稿"):
-            post_id = post_to_wordpress(prompt, generated_post)
-            st.write(f"ブログ記事が投稿されました。記事ID: {post_id}")
-
-else:
-    st.write("サービスを利用するためには、このスペースを複製し、以下の環境変数を定義してください。設定方法はosenv_setting_tips.txtを参照してください。")
-    st.write("OPENAI_API_KEY, WP_URL, WP_USERNAME, WP_PASSWORD")
-
-st.markdown(
-    """
-    <h3>注意事項</h3>
-    <ol>
-        <li style="font-size: small;">投稿前に記事の内容をよく確認してください。</li>
-        <li style="font-size: small;">OpenAIのAPIキーや、WordPressのURL、ユーザーID、パスワードはシステム設定にて設定します。詳しくはosenv_setting_tips.txtを参照ください。</li>
-        <li style="font-size: small;">constraints.mdを修正すると、生成される記事の内容、雰囲気をカスタマイズすることが可能です。</li>
-        <li style="font-size: small;">当サービスでは、OpenAI社のChatGPT APIのgpt-4を使用しております。</li>
-        <li style="font-size: small;">当サービスで生成されたコンテンツは、OpenAI が提供する人工知能によるものであり、当サービスやOpenAI がその正確性や信頼性を保証するものではありません。</li>
-        <li style="font-size: small;"><a href="https://platform.openai.com/docs/usage-policies">OpenAI の利用規約</a>に従い、データ保持しない方針です（ただし諸般の事情によっては変更する可能性はございます）。
-        <li style="font-size: small;">当サービスで生成されたコンテンツは事実確認をした上で、コンテンツ生成者およびコンテンツ利用者の責任において利用してください。</li>
-        <li style="font-size: small;">当サービスでの使用により発生したいかなる損害についても、当社は一切の責任を負いません。</li>
-        <li style="font-size: small;">当サービスはβ版のため、予告なくサービスを終了する場合がございます。</li>
-    </ol>
-    <h3>謝辞</h3>
-    <ol>
-        <li style="font-size: small;">このサービスは<a href="https://huggingface.co/spaces/shigel/aiemo" target="_blank">aiemo</a>を参考に作成しました。大変感謝しております！特に、性格設定のアイデアは秀逸です。ありがとうございました！</li>
-    </ol>
-    """,
-    unsafe_allow_html=True,
-)
-
-st.markdown(
-    f'<a href="https://huggingface.co/spaces/7thHeaven/GPT2WordPress?duplicate=true">'
-    f'<img src="https://bit.ly/3gLdBN6" alt="Duplicate Space"></a>',
-    unsafe_allow_html=True,
-)
-        

spaces/801artistry/RVC801/lib/infer_pack/modules.py

@@ -1,522 +0,0 @@
-import copy
-import math
-import numpy as np
-import scipy
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
-from torch.nn.utils import weight_norm, remove_weight_norm
-
-from lib.infer_pack import commons
-from lib.infer_pack.commons import init_weights, get_padding
-from lib.infer_pack.transforms import piecewise_rational_quadratic_transform
-
-
-LRELU_SLOPE = 0.1
-
-
-class LayerNorm(nn.Module):
-    def __init__(self, channels, eps=1e-5):
-        super().__init__()
-        self.channels = channels
-        self.eps = eps
-
-        self.gamma = nn.Parameter(torch.ones(channels))
-        self.beta = nn.Parameter(torch.zeros(channels))
-
-    def forward(self, x):
-        x = x.transpose(1, -1)
-        x = F.layer_norm(x, (self.channels,), self.gamma, self.beta, self.eps)
-        return x.transpose(1, -1)
-
-
-class ConvReluNorm(nn.Module):
-    def __init__(
-        self,
-        in_channels,
-        hidden_channels,
-        out_channels,
-        kernel_size,
-        n_layers,
-        p_dropout,
-    ):
-        super().__init__()
-        self.in_channels = in_channels
-        self.hidden_channels = hidden_channels
-        self.out_channels = out_channels
-        self.kernel_size = kernel_size
-        self.n_layers = n_layers
-        self.p_dropout = p_dropout
-        assert n_layers > 1, "Number of layers should be larger than 0."
-
-        self.conv_layers = nn.ModuleList()
-        self.norm_layers = nn.ModuleList()
-        self.conv_layers.append(
-            nn.Conv1d(
-                in_channels, hidden_channels, kernel_size, padding=kernel_size // 2
-            )
-        )
-        self.norm_layers.append(LayerNorm(hidden_channels))
-        self.relu_drop = nn.Sequential(nn.ReLU(), nn.Dropout(p_dropout))
-        for _ in range(n_layers - 1):
-            self.conv_layers.append(
-                nn.Conv1d(
-                    hidden_channels,
-                    hidden_channels,
-                    kernel_size,
-                    padding=kernel_size // 2,
-                )
-            )
-            self.norm_layers.append(LayerNorm(hidden_channels))
-        self.proj = nn.Conv1d(hidden_channels, out_channels, 1)
-        self.proj.weight.data.zero_()
-        self.proj.bias.data.zero_()
-
-    def forward(self, x, x_mask):
-        x_org = x
-        for i in range(self.n_layers):
-            x = self.conv_layers[i](x * x_mask)
-            x = self.norm_layers[i](x)
-            x = self.relu_drop(x)
-        x = x_org + self.proj(x)
-        return x * x_mask
-
-
-class DDSConv(nn.Module):
-    """
-    Dialted and Depth-Separable Convolution
-    """
-
-    def __init__(self, channels, kernel_size, n_layers, p_dropout=0.0):
-        super().__init__()
-        self.channels = channels
-        self.kernel_size = kernel_size
-        self.n_layers = n_layers
-        self.p_dropout = p_dropout
-
-        self.drop = nn.Dropout(p_dropout)
-        self.convs_sep = nn.ModuleList()
-        self.convs_1x1 = nn.ModuleList()
-        self.norms_1 = nn.ModuleList()
-        self.norms_2 = nn.ModuleList()
-        for i in range(n_layers):
-            dilation = kernel_size**i
-            padding = (kernel_size * dilation - dilation) // 2
-            self.convs_sep.append(
-                nn.Conv1d(
-                    channels,
-                    channels,
-                    kernel_size,
-                    groups=channels,
-                    dilation=dilation,
-                    padding=padding,
-                )
-            )
-            self.convs_1x1.append(nn.Conv1d(channels, channels, 1))
-            self.norms_1.append(LayerNorm(channels))
-            self.norms_2.append(LayerNorm(channels))
-
-    def forward(self, x, x_mask, g=None):
-        if g is not None:
-            x = x + g
-        for i in range(self.n_layers):
-            y = self.convs_sep[i](x * x_mask)
-            y = self.norms_1[i](y)
-            y = F.gelu(y)
-            y = self.convs_1x1[i](y)
-            y = self.norms_2[i](y)
-            y = F.gelu(y)
-            y = self.drop(y)
-            x = x + y
-        return x * x_mask
-
-
-class WN(torch.nn.Module):
-    def __init__(
-        self,
-        hidden_channels,
-        kernel_size,
-        dilation_rate,
-        n_layers,
-        gin_channels=0,
-        p_dropout=0,
-    ):
-        super(WN, self).__init__()
-        assert kernel_size % 2 == 1
-        self.hidden_channels = hidden_channels
-        self.kernel_size = (kernel_size,)
-        self.dilation_rate = dilation_rate
-        self.n_layers = n_layers
-        self.gin_channels = gin_channels
-        self.p_dropout = p_dropout
-
-        self.in_layers = torch.nn.ModuleList()
-        self.res_skip_layers = torch.nn.ModuleList()
-        self.drop = nn.Dropout(p_dropout)
-
-        if gin_channels != 0:
-            cond_layer = torch.nn.Conv1d(
-                gin_channels, 2 * hidden_channels * n_layers, 1
-            )
-            self.cond_layer = torch.nn.utils.weight_norm(cond_layer, name="weight")
-
-        for i in range(n_layers):
-            dilation = dilation_rate**i
-            padding = int((kernel_size * dilation - dilation) / 2)
-            in_layer = torch.nn.Conv1d(
-                hidden_channels,
-                2 * hidden_channels,
-                kernel_size,
-                dilation=dilation,
-                padding=padding,
-            )
-            in_layer = torch.nn.utils.weight_norm(in_layer, name="weight")
-            self.in_layers.append(in_layer)
-
-            # last one is not necessary
-            if i < n_layers - 1:
-                res_skip_channels = 2 * hidden_channels
-            else:
-                res_skip_channels = hidden_channels
-
-            res_skip_layer = torch.nn.Conv1d(hidden_channels, res_skip_channels, 1)
-            res_skip_layer = torch.nn.utils.weight_norm(res_skip_layer, name="weight")
-            self.res_skip_layers.append(res_skip_layer)
-
-    def forward(self, x, x_mask, g=None, **kwargs):
-        output = torch.zeros_like(x)
-        n_channels_tensor = torch.IntTensor([self.hidden_channels])
-
-        if g is not None:
-            g = self.cond_layer(g)
-
-        for i in range(self.n_layers):
-            x_in = self.in_layers[i](x)
-            if g is not None:
-                cond_offset = i * 2 * self.hidden_channels
-                g_l = g[:, cond_offset : cond_offset + 2 * self.hidden_channels, :]
-            else:
-                g_l = torch.zeros_like(x_in)
-
-            acts = commons.fused_add_tanh_sigmoid_multiply(x_in, g_l, n_channels_tensor)
-            acts = self.drop(acts)
-
-            res_skip_acts = self.res_skip_layers[i](acts)
-            if i < self.n_layers - 1:
-                res_acts = res_skip_acts[:, : self.hidden_channels, :]
-                x = (x + res_acts) * x_mask
-                output = output + res_skip_acts[:, self.hidden_channels :, :]
-            else:
-                output = output + res_skip_acts
-        return output * x_mask
-
-    def remove_weight_norm(self):
-        if self.gin_channels != 0:
-            torch.nn.utils.remove_weight_norm(self.cond_layer)
-        for l in self.in_layers:
-            torch.nn.utils.remove_weight_norm(l)
-        for l in self.res_skip_layers:
-            torch.nn.utils.remove_weight_norm(l)
-
-
-class ResBlock1(torch.nn.Module):
-    def __init__(self, channels, kernel_size=3, dilation=(1, 3, 5)):
-        super(ResBlock1, self).__init__()
-        self.convs1 = nn.ModuleList(
-            [
-                weight_norm(
-                    Conv1d(
-                        channels,
-                        channels,
-                        kernel_size,
-                        1,
-                        dilation=dilation[0],
-                        padding=get_padding(kernel_size, dilation[0]),
-                    )
-                ),
-                weight_norm(
-                    Conv1d(
-                        channels,
-                        channels,
-                        kernel_size,
-                        1,
-                        dilation=dilation[1],
-                        padding=get_padding(kernel_size, dilation[1]),
-                    )
-                ),
-                weight_norm(
-                    Conv1d(
-                        channels,
-                        channels,
-                        kernel_size,
-                        1,
-                        dilation=dilation[2],
-                        padding=get_padding(kernel_size, dilation[2]),
-                    )
-                ),
-            ]
-        )
-        self.convs1.apply(init_weights)
-
-        self.convs2 = nn.ModuleList(
-            [
-                weight_norm(
-                    Conv1d(
-                        channels,
-                        channels,
-                        kernel_size,
-                        1,
-                        dilation=1,
-                        padding=get_padding(kernel_size, 1),
-                    )
-                ),
-                weight_norm(
-                    Conv1d(
-                        channels,
-                        channels,
-                        kernel_size,
-                        1,
-                        dilation=1,
-                        padding=get_padding(kernel_size, 1),
-                    )
-                ),
-                weight_norm(
-                    Conv1d(
-                        channels,
-                        channels,
-                        kernel_size,
-                        1,
-                        dilation=1,
-                        padding=get_padding(kernel_size, 1),
-                    )
-                ),
-            ]
-        )
-        self.convs2.apply(init_weights)
-
-    def forward(self, x, x_mask=None):
-        for c1, c2 in zip(self.convs1, self.convs2):
-            xt = F.leaky_relu(x, LRELU_SLOPE)
-            if x_mask is not None:
-                xt = xt * x_mask
-            xt = c1(xt)
-            xt = F.leaky_relu(xt, LRELU_SLOPE)
-            if x_mask is not None:
-                xt = xt * x_mask
-            xt = c2(xt)
-            x = xt + x
-        if x_mask is not None:
-            x = x * x_mask
-        return x
-
-    def remove_weight_norm(self):
-        for l in self.convs1:
-            remove_weight_norm(l)
-        for l in self.convs2:
-            remove_weight_norm(l)
-
-
-class ResBlock2(torch.nn.Module):
-    def __init__(self, channels, kernel_size=3, dilation=(1, 3)):
-        super(ResBlock2, self).__init__()
-        self.convs = nn.ModuleList(
-            [
-                weight_norm(
-                    Conv1d(
-                        channels,
-                        channels,
-                        kernel_size,
-                        1,
-                        dilation=dilation[0],
-                        padding=get_padding(kernel_size, dilation[0]),
-                    )
-                ),
-                weight_norm(
-                    Conv1d(
-                        channels,
-                        channels,
-                        kernel_size,
-                        1,
-                        dilation=dilation[1],
-                        padding=get_padding(kernel_size, dilation[1]),
-                    )
-                ),
-            ]
-        )
-        self.convs.apply(init_weights)
-
-    def forward(self, x, x_mask=None):
-        for c in self.convs:
-            xt = F.leaky_relu(x, LRELU_SLOPE)
-            if x_mask is not None:
-                xt = xt * x_mask
-            xt = c(xt)
-            x = xt + x
-        if x_mask is not None:
-            x = x * x_mask
-        return x
-
-    def remove_weight_norm(self):
-        for l in self.convs:
-            remove_weight_norm(l)
-
-
-class Log(nn.Module):
-    def forward(self, x, x_mask, reverse=False, **kwargs):
-        if not reverse:
-            y = torch.log(torch.clamp_min(x, 1e-5)) * x_mask
-            logdet = torch.sum(-y, [1, 2])
-            return y, logdet
-        else:
-            x = torch.exp(x) * x_mask
-            return x
-
-
-class Flip(nn.Module):
-    def forward(self, x, *args, reverse=False, **kwargs):
-        x = torch.flip(x, [1])
-        if not reverse:
-            logdet = torch.zeros(x.size(0)).to(dtype=x.dtype, device=x.device)
-            return x, logdet
-        else:
-            return x
-
-
-class ElementwiseAffine(nn.Module):
-    def __init__(self, channels):
-        super().__init__()
-        self.channels = channels
-        self.m = nn.Parameter(torch.zeros(channels, 1))
-        self.logs = nn.Parameter(torch.zeros(channels, 1))
-
-    def forward(self, x, x_mask, reverse=False, **kwargs):
-        if not reverse:
-            y = self.m + torch.exp(self.logs) * x
-            y = y * x_mask
-            logdet = torch.sum(self.logs * x_mask, [1, 2])
-            return y, logdet
-        else:
-            x = (x - self.m) * torch.exp(-self.logs) * x_mask
-            return x
-
-
-class ResidualCouplingLayer(nn.Module):
-    def __init__(
-        self,
-        channels,
-        hidden_channels,
-        kernel_size,
-        dilation_rate,
-        n_layers,
-        p_dropout=0,
-        gin_channels=0,
-        mean_only=False,
-    ):
-        assert channels % 2 == 0, "channels should be divisible by 2"
-        super().__init__()
-        self.channels = channels
-        self.hidden_channels = hidden_channels
-        self.kernel_size = kernel_size
-        self.dilation_rate = dilation_rate
-        self.n_layers = n_layers
-        self.half_channels = channels // 2
-        self.mean_only = mean_only
-
-        self.pre = nn.Conv1d(self.half_channels, hidden_channels, 1)
-        self.enc = WN(
-            hidden_channels,
-            kernel_size,
-            dilation_rate,
-            n_layers,
-            p_dropout=p_dropout,
-            gin_channels=gin_channels,
-        )
-        self.post = nn.Conv1d(hidden_channels, self.half_channels * (2 - mean_only), 1)
-        self.post.weight.data.zero_()
-        self.post.bias.data.zero_()
-
-    def forward(self, x, x_mask, g=None, reverse=False):
-        x0, x1 = torch.split(x, [self.half_channels] * 2, 1)
-        h = self.pre(x0) * x_mask
-        h = self.enc(h, x_mask, g=g)
-        stats = self.post(h) * x_mask
-        if not self.mean_only:
-            m, logs = torch.split(stats, [self.half_channels] * 2, 1)
-        else:
-            m = stats
-            logs = torch.zeros_like(m)
-
-        if not reverse:
-            x1 = m + x1 * torch.exp(logs) * x_mask
-            x = torch.cat([x0, x1], 1)
-            logdet = torch.sum(logs, [1, 2])
-            return x, logdet
-        else:
-            x1 = (x1 - m) * torch.exp(-logs) * x_mask
-            x = torch.cat([x0, x1], 1)
-            return x
-
-    def remove_weight_norm(self):
-        self.enc.remove_weight_norm()
-
-
-class ConvFlow(nn.Module):
-    def __init__(
-        self,
-        in_channels,
-        filter_channels,
-        kernel_size,
-        n_layers,
-        num_bins=10,
-        tail_bound=5.0,
-    ):
-        super().__init__()
-        self.in_channels = in_channels
-        self.filter_channels = filter_channels
-        self.kernel_size = kernel_size
-        self.n_layers = n_layers
-        self.num_bins = num_bins
-        self.tail_bound = tail_bound
-        self.half_channels = in_channels // 2
-
-        self.pre = nn.Conv1d(self.half_channels, filter_channels, 1)
-        self.convs = DDSConv(filter_channels, kernel_size, n_layers, p_dropout=0.0)
-        self.proj = nn.Conv1d(
-            filter_channels, self.half_channels * (num_bins * 3 - 1), 1
-        )
-        self.proj.weight.data.zero_()
-        self.proj.bias.data.zero_()
-
-    def forward(self, x, x_mask, g=None, reverse=False):
-        x0, x1 = torch.split(x, [self.half_channels] * 2, 1)
-        h = self.pre(x0)
-        h = self.convs(h, x_mask, g=g)
-        h = self.proj(h) * x_mask
-
-        b, c, t = x0.shape
-        h = h.reshape(b, c, -1, t).permute(0, 1, 3, 2)  # [b, cx?, t] -> [b, c, t, ?]
-
-        unnormalized_widths = h[..., : self.num_bins] / math.sqrt(self.filter_channels)
-        unnormalized_heights = h[..., self.num_bins : 2 * self.num_bins] / math.sqrt(
-            self.filter_channels
-        )
-        unnormalized_derivatives = h[..., 2 * self.num_bins :]
-
-        x1, logabsdet = piecewise_rational_quadratic_transform(
-            x1,
-            unnormalized_widths,
-            unnormalized_heights,
-            unnormalized_derivatives,
-            inverse=reverse,
-            tails="linear",
-            tail_bound=self.tail_bound,
-        )
-
-        x = torch.cat([x0, x1], 1) * x_mask
-        logdet = torch.sum(logabsdet * x_mask, [1, 2])
-        if not reverse:
-            return x, logdet
-        else:
-            return x

spaces/801artistry/RVC801/venv.sh

@@ -1 +0,0 @@
-python3.8 -m venv .venv

spaces/AIFILMS/generate_human_motion/VQ-Trans/options/option_transformer.py

@@ -1,68 +0,0 @@
-import argparse
-
-def get_args_parser():
-    parser = argparse.ArgumentParser(description='Optimal Transport AutoEncoder training for Amass',
-                                     add_help=True,
-                                     formatter_class=argparse.ArgumentDefaultsHelpFormatter)
-    
-    ## dataloader
-    
-    parser.add_argument('--dataname', type=str, default='kit', help='dataset directory')
-    parser.add_argument('--batch-size', default=128, type=int, help='batch size')
-    parser.add_argument('--fps', default=[20], nargs="+", type=int, help='frames per second')
-    parser.add_argument('--seq-len', type=int, default=64, help='training motion length')
-    
-    ## optimization
-    parser.add_argument('--total-iter', default=100000, type=int, help='number of total iterations to run')
-    parser.add_argument('--warm-up-iter', default=1000, type=int, help='number of total iterations for warmup')
-    parser.add_argument('--lr', default=2e-4, type=float, help='max learning rate')
-    parser.add_argument('--lr-scheduler', default=[60000], nargs="+", type=int, help="learning rate schedule (iterations)")
-    parser.add_argument('--gamma', default=0.05, type=float, help="learning rate decay")
-    
-    parser.add_argument('--weight-decay', default=1e-6, type=float, help='weight decay') 
-    parser.add_argument('--decay-option',default='all', type=str, choices=['all', 'noVQ'], help='disable weight decay on codebook')
-    parser.add_argument('--optimizer',default='adamw', type=str, choices=['adam', 'adamw'], help='disable weight decay on codebook')
-    
-    ## vqvae arch
-    parser.add_argument("--code-dim", type=int, default=512, help="embedding dimension")
-    parser.add_argument("--nb-code", type=int, default=512, help="nb of embedding")
-    parser.add_argument("--mu", type=float, default=0.99, help="exponential moving average to update the codebook")
-    parser.add_argument("--down-t", type=int, default=3, help="downsampling rate")
-    parser.add_argument("--stride-t", type=int, default=2, help="stride size")
-    parser.add_argument("--width", type=int, default=512, help="width of the network")
-    parser.add_argument("--depth", type=int, default=3, help="depth of the network")
-    parser.add_argument("--dilation-growth-rate", type=int, default=3, help="dilation growth rate")
-    parser.add_argument("--output-emb-width", type=int, default=512, help="output embedding width")
-    parser.add_argument('--vq-act', type=str, default='relu', choices = ['relu', 'silu', 'gelu'], help='dataset directory')
-
-    ## gpt arch
-    parser.add_argument("--block-size", type=int, default=25, help="seq len")
-    parser.add_argument("--embed-dim-gpt", type=int, default=512, help="embedding dimension")
-    parser.add_argument("--clip-dim", type=int, default=512, help="latent dimension in the clip feature")
-    parser.add_argument("--num-layers", type=int, default=2, help="nb of transformer layers")
-    parser.add_argument("--n-head-gpt", type=int, default=8, help="nb of heads")
-    parser.add_argument("--ff-rate", type=int, default=4, help="feedforward size")
-    parser.add_argument("--drop-out-rate", type=float, default=0.1, help="dropout ratio in the pos encoding")
-    
-    ## quantizer
-    parser.add_argument("--quantizer", type=str, default='ema_reset', choices = ['ema', 'orig', 'ema_reset', 'reset'], help="eps for optimal transport")
-    parser.add_argument('--quantbeta', type=float, default=1.0, help='dataset directory')
-
-    ## resume
-    parser.add_argument("--resume-pth", type=str, default=None, help='resume vq pth')
-    parser.add_argument("--resume-trans", type=str, default=None, help='resume gpt pth')
-    
-    
-    ## output directory 
-    parser.add_argument('--out-dir', type=str, default='output_GPT_Final/', help='output directory')
-    parser.add_argument('--exp-name', type=str, default='exp_debug', help='name of the experiment, will create a file inside out-dir')
-    parser.add_argument('--vq-name', type=str, default='exp_debug', help='name of the generated dataset .npy, will create a file inside out-dir')
-    ## other
-    parser.add_argument('--print-iter', default=200, type=int, help='print frequency')
-    parser.add_argument('--eval-iter', default=5000, type=int, help='evaluation frequency')
-    parser.add_argument('--seed', default=123, type=int, help='seed for initializing training. ')
-    parser.add_argument("--if-maxtest", action='store_true', help="test in max")
-    parser.add_argument('--pkeep', type=float, default=1.0, help='keep rate for gpt training')
-    
-    
-    return parser.parse_args()

spaces/AIFILMS/generate_human_motion/VQ-Trans/utils/paramUtil.py

@@ -1,63 +0,0 @@
-import numpy as np
-
-# Define a kinematic tree for the skeletal struture
-kit_kinematic_chain = [[0, 11, 12, 13, 14, 15], [0, 16, 17, 18, 19, 20], [0, 1, 2, 3, 4], [3, 5, 6, 7], [3, 8, 9, 10]]
-
-kit_raw_offsets = np.array(
-    [
-        [0, 0, 0],
-        [0, 1, 0],
-        [0, 1, 0],
-        [0, 1, 0],
-        [0, 1, 0],
-        [1, 0, 0],
-        [0, -1, 0],
-        [0, -1, 0],
-        [-1, 0, 0],
-        [0, -1, 0],
-        [0, -1, 0],
-        [1, 0, 0],
-        [0, -1, 0],
-        [0, -1, 0],
-        [0, 0, 1],
-        [0, 0, 1],
-        [-1, 0, 0],
-        [0, -1, 0],
-        [0, -1, 0],
-        [0, 0, 1],
-        [0, 0, 1]
-    ]
-)
-
-t2m_raw_offsets = np.array([[0,0,0],
-                           [1,0,0],
-                           [-1,0,0],
-                           [0,1,0],
-                           [0,-1,0],
-                           [0,-1,0],
-                           [0,1,0],
-                           [0,-1,0],
-                           [0,-1,0],
-                           [0,1,0],
-                           [0,0,1],
-                           [0,0,1],
-                           [0,1,0],
-                           [1,0,0],
-                           [-1,0,0],
-                           [0,0,1],
-                           [0,-1,0],
-                           [0,-1,0],
-                           [0,-1,0],
-                           [0,-1,0],
-                           [0,-1,0],
-                           [0,-1,0]])
-
-t2m_kinematic_chain = [[0, 2, 5, 8, 11], [0, 1, 4, 7, 10], [0, 3, 6, 9, 12, 15], [9, 14, 17, 19, 21], [9, 13, 16, 18, 20]]
-t2m_left_hand_chain = [[20, 22, 23, 24], [20, 34, 35, 36], [20, 25, 26, 27], [20, 31, 32, 33], [20, 28, 29, 30]]
-t2m_right_hand_chain = [[21, 43, 44, 45], [21, 46, 47, 48], [21, 40, 41, 42], [21, 37, 38, 39], [21, 49, 50, 51]]
-
-
-kit_tgt_skel_id = '03950'
-
-t2m_tgt_skel_id = '000021'
-

spaces/AIGC-Audio/AudioGPT/text_to_audio/Make_An_Audio/ldm/modules/encoders/open_clap/factory.py

@@ -1,257 +0,0 @@
-import json
-import logging
-import os
-import pathlib
-import re
-from copy import deepcopy
-from pathlib import Path
-
-import torch
-
-from .model import CLAP, convert_weights_to_fp16
-from .openai import load_openai_model
-from .pretrained import get_pretrained_url, download_pretrained
-from .transform import image_transform
-
-_MODEL_CONFIG_PATHS = [Path(__file__).parent / f"model_configs/"]
-_MODEL_CONFIGS = {}  # directory (model_name: config) of model architecture configs
-
-
-def _natural_key(string_):
-    return [int(s) if s.isdigit() else s for s in re.split(r"(\d+)", string_.lower())]
-
-
-def _rescan_model_configs():
-    global _MODEL_CONFIGS
-
-    config_ext = (".json",)
-    config_files = []
-    for config_path in _MODEL_CONFIG_PATHS:
-        if config_path.is_file() and config_path.suffix in config_ext:
-            config_files.append(config_path)
-        elif config_path.is_dir():
-            for ext in config_ext:
-                config_files.extend(config_path.glob(f"*{ext}"))
-
-    for cf in config_files:
-        with open(cf, "r") as f:
-            model_cfg = json.load(f)
-            if all(a in model_cfg for a in ("embed_dim", "audio_cfg", "text_cfg")):
-                _MODEL_CONFIGS[cf.stem] = model_cfg
-
-    _MODEL_CONFIGS = {
-        k: v
-        for k, v in sorted(_MODEL_CONFIGS.items(), key=lambda x: _natural_key(x[0]))
-    }
-
-
-_rescan_model_configs()  # initial populate of model config registry
-
-
-def load_state_dict(checkpoint_path: str, map_location="cpu", skip_params=True):
-    checkpoint = torch.load(checkpoint_path, map_location=map_location)
-    if isinstance(checkpoint, dict) and "state_dict" in checkpoint:
-        state_dict = checkpoint["state_dict"]
-    else:
-        state_dict = checkpoint
-    if skip_params:
-        if next(iter(state_dict.items()))[0].startswith("module"):
-            state_dict = {k[7:]: v for k, v in state_dict.items()}
-    # for k in state_dict:
-    #     if k.startswith('transformer'):
-    #         v = state_dict.pop(k)
-    #         state_dict['text_branch.' + k[12:]] = v
-    return state_dict
-
-
-def create_model(
-    amodel_name: str,
-    tmodel_name: str,
-    pretrained: str = "",
-    precision: str = "fp32",
-    device: torch.device = torch.device("cpu"),
-    jit: bool = False,
-    force_quick_gelu: bool = False,
-    openai_model_cache_dir: str = os.path.expanduser("~/.cache/clip"),
-    skip_params=True,
-    pretrained_audio: str = "",
-    pretrained_text: str = "",
-    enable_fusion: bool = False,
-    fusion_type: str = 'None'
-    # pretrained_image: bool = False,
-):
-    amodel_name = amodel_name.replace(
-        "/", "-"
-    )  # for callers using old naming with / in ViT names
-    pretrained_orig = pretrained
-    pretrained = pretrained.lower()
-    if pretrained == "openai":
-        if amodel_name in _MODEL_CONFIGS:
-            logging.info(f"Loading {amodel_name} model config.")
-            model_cfg = deepcopy(_MODEL_CONFIGS[amodel_name])
-        else:
-            logging.error(
-                f"Model config for {amodel_name} not found; available models {list_models()}."
-            )
-            raise RuntimeError(f"Model config for {amodel_name} not found.")
-
-        logging.info(f"Loading pretrained ViT-B-16 text encoder from OpenAI.")
-        # Hard Code in model name
-        model_cfg["text_cfg"]["model_type"] = tmodel_name
-        model = load_openai_model(
-            "ViT-B-16",
-            model_cfg,
-            device=device,
-            jit=jit,
-            cache_dir=openai_model_cache_dir,
-            enable_fusion=enable_fusion,
-            fusion_type=fusion_type
-        )
-        # See https://discuss.pytorch.org/t/valueerror-attemting-to-unscale-fp16-gradients/81372
-        if precision == "amp" or precision == "fp32":
-            model = model.float()
-    else:
-        if amodel_name in _MODEL_CONFIGS:
-            logging.info(f"Loading {amodel_name} model config.")
-            model_cfg = deepcopy(_MODEL_CONFIGS[amodel_name])
-        else:
-            logging.error(
-                f"Model config for {amodel_name} not found; available models {list_models()}."
-            )
-            raise RuntimeError(f"Model config for {amodel_name} not found.")
-
-        if force_quick_gelu:
-            # override for use of QuickGELU on non-OpenAI transformer models
-            model_cfg["quick_gelu"] = True
-
-        # if pretrained_image:
-        #     if 'timm_amodel_name' in model_cfg.get('vision_cfg', {}):
-        #         # pretrained weight loading for timm models set via vision_cfg
-        #         model_cfg['vision_cfg']['timm_model_pretrained'] = True
-        #     else:
-        #         assert False, 'pretrained image towers currently only supported for timm models'
-        model_cfg["text_cfg"]["model_type"] = tmodel_name
-        model_cfg["enable_fusion"] = enable_fusion
-        model_cfg["fusion_type"] = fusion_type
-        model = CLAP(**model_cfg)
-
-        if pretrained:
-            checkpoint_path = ""
-            url = get_pretrained_url(amodel_name, pretrained)
-            if url:
-                checkpoint_path = download_pretrained(url, root=openai_model_cache_dir)
-            elif os.path.exists(pretrained_orig):
-                checkpoint_path = pretrained_orig
-            if checkpoint_path:
-                logging.info(f"Loading pretrained {amodel_name}-{tmodel_name} weights ({pretrained}).")
-                ckpt = load_state_dict(checkpoint_path, skip_params=True)
-                model.load_state_dict(ckpt)
-                param_names = [n for n, p in model.named_parameters()]
-                for n in param_names:
-                    print(n, "\t", "Loaded" if n in ckpt else "Unloaded")
-            else:
-                logging.warning(
-                    f"Pretrained weights ({pretrained}) not found for model {amodel_name}."
-                )
-                raise RuntimeError(
-                    f"Pretrained weights ({pretrained}) not found for model {amodel_name}."
-                )
-
-        if pretrained_audio:
-            if amodel_name.startswith('PANN'):
-                if 'Cnn14_mAP' in pretrained_audio:  # official checkpoint
-                    audio_ckpt = torch.load(pretrained_audio, map_location='cpu')
-                    audio_ckpt = audio_ckpt['model']
-                    keys = list(audio_ckpt.keys())
-                    for key in keys:
-                        if 'spectrogram_extractor' not in key and 'logmel_extractor' not in key:
-                            v = audio_ckpt.pop(key)
-                            audio_ckpt['audio_branch.' + key] = v
-                elif os.path.basename(pretrained_audio).startswith('PANN'):  # checkpoint trained via HTSAT codebase
-                    audio_ckpt = torch.load(pretrained_audio, map_location='cpu')
-                    audio_ckpt = audio_ckpt['state_dict']
-                    keys = list(audio_ckpt.keys())
-                    for key in keys:
-                        if key.startswith('sed_model'):
-                            v = audio_ckpt.pop(key)
-                            audio_ckpt['audio_branch.' + key[10:]] = v
-                elif os.path.basename(pretrained_audio).startswith('finetuned'):  # checkpoint trained via linear probe codebase
-                    audio_ckpt = torch.load(pretrained_audio, map_location='cpu')
-                else:
-                    raise ValueError('Unknown audio checkpoint')
-            elif amodel_name.startswith('HTSAT'):
-                if 'HTSAT_AudioSet_Saved' in pretrained_audio:  # official checkpoint
-                    audio_ckpt = torch.load(pretrained_audio, map_location='cpu')
-                    audio_ckpt = audio_ckpt['state_dict']
-                    keys = list(audio_ckpt.keys())
-                    for key in keys:
-                        if key.startswith('sed_model') and ('spectrogram_extractor' not in key
-                                                            and 'logmel_extractor' not in key):
-                            v = audio_ckpt.pop(key)
-                            audio_ckpt['audio_branch.' + key[10:]] = v
-                elif os.path.basename(pretrained_audio).startswith('HTSAT'):  # checkpoint trained via HTSAT codebase
-                    audio_ckpt = torch.load(pretrained_audio, map_location='cpu')
-                    audio_ckpt = audio_ckpt['state_dict']
-                    keys = list(audio_ckpt.keys())
-                    for key in keys:
-                        if key.startswith('sed_model'):
-                            v = audio_ckpt.pop(key)
-                            audio_ckpt['audio_branch.' + key[10:]] = v
-                elif os.path.basename(pretrained_audio).startswith('finetuned'):  # checkpoint trained via linear probe codebase
-                    audio_ckpt = torch.load(pretrained_audio, map_location='cpu')
-                else:
-                    raise ValueError('Unknown audio checkpoint')
-            else:
-                raise f'this audio encoder pretrained checkpoint is not support'
-
-            model.load_state_dict(audio_ckpt, strict=False)
-            logging.info(f"Loading pretrained {amodel_name} weights ({pretrained_audio}).")
-            param_names = [n for n, p in model.named_parameters()]
-            for n in param_names:
-                print(n, "\t", "Loaded" if n in audio_ckpt else "Unloaded")
-            
-        model.to(device=device)
-        if precision == "fp16":
-            assert device.type != "cpu"
-            convert_weights_to_fp16(model)
-
-        if jit:
-            model = torch.jit.script(model)
-
-    return model, model_cfg
-
-
-def create_model_and_transforms(
-    model_name: str,
-    pretrained: str = "",
-    precision: str = "fp32",
-    device: torch.device = torch.device("cpu"),
-    jit: bool = False,
-    force_quick_gelu: bool = False,
-    # pretrained_image: bool = False,
-):
-    model = create_model(
-        model_name,
-        pretrained,
-        precision,
-        device,
-        jit,
-        force_quick_gelu=force_quick_gelu,
-        # pretrained_image=pretrained_image
-    )
-    preprocess_train = image_transform(model.visual.image_size, is_train=True)
-    preprocess_val = image_transform(model.visual.image_size, is_train=False)
-    return model, preprocess_train, preprocess_val
-
-
-def list_models():
-    """enumerate available model architectures based on config files"""
-    return list(_MODEL_CONFIGS.keys())
-
-
-def add_model_config(path):
-    """add model config path or file and update registry"""
-    if not isinstance(path, Path):
-        path = Path(path)
-    _MODEL_CONFIG_PATHS.append(path)
-    _rescan_model_configs()

spaces/AIZeroToHero/05-RealtimeStreamlitASR/app.py

@@ -1,119 +0,0 @@
-from collections import deque
-import streamlit as st
-import torch
-from streamlit_player import st_player
-from transformers import AutoModelForCTC, Wav2Vec2Processor
-from streaming import ffmpeg_stream
-
-device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-player_options = {
-    "events": ["onProgress"],
-    "progress_interval": 200,
-    "volume": 1.0,
-    "playing": True,
-    "loop": False,
-    "controls": False,
-    "muted": False,
-    "config": {"youtube": {"playerVars": {"start": 1}}},
-}
-
-# disable rapid fading in and out on `st.code` updates
-st.markdown("<style>.element-container{opacity:1 !important}</style>", unsafe_allow_html=True)
-
-@st.cache(hash_funcs={torch.nn.parameter.Parameter: lambda _: None})
-def load_model(model_path="facebook/wav2vec2-large-robust-ft-swbd-300h"):
-    processor = Wav2Vec2Processor.from_pretrained(model_path)
-    model = AutoModelForCTC.from_pretrained(model_path).to(device)
-    return processor, model
-    
-processor, model = load_model()
-
-def stream_text(url, chunk_duration_ms, pad_duration_ms):
-    sampling_rate = processor.feature_extractor.sampling_rate
-
-    # calculate the length of logits to cut from the sides of the output to account for input padding
-    output_pad_len = model._get_feat_extract_output_lengths(int(sampling_rate * pad_duration_ms / 1000))
-
-    # define the audio chunk generator
-    stream = ffmpeg_stream(url, sampling_rate, chunk_duration_ms=chunk_duration_ms, pad_duration_ms=pad_duration_ms)
-
-    leftover_text = ""
-    for i, chunk in enumerate(stream):
-        input_values = processor(chunk, sampling_rate=sampling_rate, return_tensors="pt").input_values
-
-        with torch.no_grad():
-            logits = model(input_values.to(device)).logits[0]
-            if i > 0:
-                logits = logits[output_pad_len : len(logits) - output_pad_len]
-            else:  # don't count padding at the start of the clip
-                logits = logits[: len(logits) - output_pad_len]
-
-            predicted_ids = torch.argmax(logits, dim=-1).cpu().tolist()
-            if processor.decode(predicted_ids).strip():
-                leftover_ids = processor.tokenizer.encode(leftover_text)
-                # concat the last word (or its part) from the last frame with the current text
-                text = processor.decode(leftover_ids + predicted_ids)
-                # don't return the last word in case it's just partially recognized
-                text, leftover_text = text.rsplit(" ", 1)
-                yield text
-            else:
-                yield leftover_text
-                leftover_text = ""
-    yield leftover_text
-
-def main():
-    state = st.session_state
-    st.header("Video ASR Streamlit from Youtube Link")
-
-    with st.form(key="inputs_form"):
-    
-        # Our worlds best teachers on subjects of AI, Cognitive, Neuroscience for our Behavioral and Medical Health
-        ytJoschaBach="https://youtu.be/cC1HszE5Hcw?list=PLHgX2IExbFouJoqEr8JMF5MbZSbyC91-L&t=8984"
-        ytSamHarris="https://www.youtube.com/watch?v=4dC_nRYIDZU&list=PLHgX2IExbFouJoqEr8JMF5MbZSbyC91-L&index=2"
-        ytJohnAbramson="https://www.youtube.com/watch?v=arrokG3wCdE&list=PLHgX2IExbFouJoqEr8JMF5MbZSbyC91-L&index=3"
-        ytElonMusk="https://www.youtube.com/watch?v=DxREm3s1scA&list=PLHgX2IExbFouJoqEr8JMF5MbZSbyC91-L&index=4"
-        ytJeffreyShainline="https://www.youtube.com/watch?v=EwueqdgIvq4&list=PLHgX2IExbFouJoqEr8JMF5MbZSbyC91-L&index=5"
-        ytJeffHawkins="https://www.youtube.com/watch?v=Z1KwkpTUbkg&list=PLHgX2IExbFouJoqEr8JMF5MbZSbyC91-L&index=6"
-        ytSamHarris="https://youtu.be/Ui38ZzTymDY?list=PLHgX2IExbFouJoqEr8JMF5MbZSbyC91-L"
-        ytSamHarris="https://youtu.be/4dC_nRYIDZU?list=PLHgX2IExbFouJoqEr8JMF5MbZSbyC91-L&t=7809"
-        ytSamHarris="https://youtu.be/4dC_nRYIDZU?list=PLHgX2IExbFouJoqEr8JMF5MbZSbyC91-L&t=7809"
-        ytSamHarris="https://youtu.be/4dC_nRYIDZU?list=PLHgX2IExbFouJoqEr8JMF5MbZSbyC91-L&t=7809"
-        ytTimelapseAI="https://www.youtube.com/watch?v=63yr9dlI0cU&list=PLHgX2IExbFovQybyfltywXnqZi5YvaSS-"
-        state.youtube_url = st.text_input("YouTube URL", ytTimelapseAI)
-        
-        
-        state.chunk_duration_ms = st.slider("Audio chunk duration (ms)", 2000, 10000, 3000, 100)
-        state.pad_duration_ms = st.slider("Padding duration (ms)", 100, 5000, 1000, 100)
-        submit_button = st.form_submit_button(label="Submit")
-
-    if submit_button or "asr_stream" not in state:
-        # a hack to update the video player on value changes
-        state.youtube_url = (
-            state.youtube_url.split("&hash=")[0]
-            + f"&hash={state.chunk_duration_ms}-{state.pad_duration_ms}"
-        )
-        state.asr_stream = stream_text(
-            state.youtube_url, state.chunk_duration_ms, state.pad_duration_ms
-        )
-        state.chunks_taken = 0
-        
-        
-        state.lines = deque([], maxlen=100)  # limit to the last n lines of subs
-        
-
-    player = st_player(state.youtube_url, **player_options, key="youtube_player")
-
-    if "asr_stream" in state and player.data and player.data["played"] < 1.0:
-        # check how many seconds were played, and if more than processed - write the next text chunk
-        processed_seconds = state.chunks_taken * (state.chunk_duration_ms / 1000)
-        if processed_seconds < player.data["playedSeconds"]:
-            text = next(state.asr_stream)
-            state.lines.append(text)
-            state.chunks_taken += 1
-    if "lines" in state:
-        # print the lines of subs
-        st.code("\n".join(state.lines))
-
-
-if __name__ == "__main__":
-    main()

spaces/AUBADA-ALARABI/poetry202/app.py

@@ -1,53 +0,0 @@
-import gc 
-import gradio as gr
-from transformers import pipeline, set_seed
-
-pipe = pipeline('text-generation', framework='pt', model='akhooli/ap2023', tokenizer='akhooli/ap2023')
-#gc.collect()
-samples = [['أنت'
-           ,1.0, 50, 1.0, 1.0, 114],['هل غادر'
-            ,1.0, 50, 1.0, 1.0, 114 ],['ألا ليت'
-              ,1.0, 50, 1.0, 1.0, 114 ],['يا قدس'
-                 ,1.0, 50, 1.0, 1.0, 114],['عيد بأية حال'
-                   ,1.0, 50, 1.0, 1.0, 114],['لكل شيء إذا ما'
-                    ,1.0, 50, 1.0, 1.0, 114 ],['.'
-                       ,1.0, 50, 1.0, 1.0, 114]]
-                     
-notes = """
-- Enter a short prompt or select (click) one of the examples and click SEND 
-- Adjust parameters (temperture, top k, top p and penalty) through the slider (keep close to default values).
-- For the same seed (randomness), the same output is regenerated if other parameters are fixed 
-- Clear and enter new prompt or select another example and SEND to regenerate
-- The '.' means start a new line from no prompt (your prompt need not be long) 
-- Be patient: this runs on CPU (free tier)
-- Feedback (Twitter): @akhooli (https://twitter.com/akhooli/status/1611025232201977859) 
-- Note/Disclaimer: may generate unaccepted or inappropriate content. Use at your own risk.
-"""
-def sayPoetry(prompt, temp=1.0, topk = 50, topp = 1.0, penalty=1.0, seed=114):
-    if not int(seed) >= 0: seed=114
-    set_seed(seed)
-    gen = pipe(prompt, max_length=96, do_sample=True, temperature=temp, top_k=topk, top_p=topp, repetition_penalty=penalty,
-              min_length = 64, no_repeat_ngram_size = 3, return_full_text=True,
-               num_beams=5, num_return_sequences=1)[0]["generated_text"]
-    poetry =""
-    for line in gen.split('.')[:-1]:
-        poetry += line #+ "\n"
-    return poetry
-poetry = gr.Interface(fn=sayPoetry, 
-                    inputs=[
-                        gr.Textbox(label="Enter short prompt or select from examples:"), 
-                        gr.Slider(0.70, 1.2, step=0.01,value=1.0, label='control  temperature'),
-                        gr.Slider(25, 100, step=1,value=50, label='control  top k'),
-                        gr.Slider(0.80, 1.0, step=0.01,value=1.0, label='control  top p'),
-                        gr.Slider(0.90, 1.50, step=0.01,value=1.0, label='control  penalty'),
-                        gr.Number(value=139750, precision=0, label='Seed'),
-                    ], 
-                outputs=[gr.Textbox(label="Generated Poetry:")], 
-                    
-                allow_flagging='never',
-                title='Arabic Poetry Generation Demo (updated Jan. 2023)',
-                description = "A simple demo of AI generated poetry based on 1M poems fine-tuned using AraGPT2 (be patient, runs on cpu)",
-                examples=samples,
-                cache_examples=False,
-                article = notes)
-poetry.launch() # show_error = True, debug=True

spaces/Abdllh/poetry202/README.md

@@ -1,13 +0,0 @@
----
-title: Poetry2023
-emoji: 👁
-colorFrom: green
-colorTo: gray
-sdk: gradio
-sdk_version: 3.16.0
-app_file: app.py
-pinned: false
-duplicated_from: akhooli/poetry2023
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/AchyuthGamer/OpenGPT/client/js/change-language.js

@@ -1,47 +0,0 @@
-document.addEventListener('DOMContentLoaded', fetchLanguages);  
-  
-async function fetchLanguages() {  
-    try {  
-        const [languagesResponse, currentLanguageResponse] = await Promise.all([  
-            fetch(`${url_prefix}/get-languages`),  
-            fetch(`${url_prefix}/get-locale`)  
-        ]);  
-  
-        const languages = await languagesResponse.json();  
-        const currentLanguage = await currentLanguageResponse.text();  
-  
-        const languageSelect = document.getElementById('language');  
-        languages.forEach(lang => {  
-            const option = document.createElement('option');  
-            option.value = lang;  
-            option.textContent = lang;  
-            languageSelect.appendChild(option);  
-        });  
-  
-        const savedLanguage = localStorage.getItem("language") || currentLanguage;  
-        setLanguageOnPageLoad(savedLanguage);  
-    } catch (error) {  
-        console.error("Failed to fetch languages or current language");  
-    }  
-}  
-  
-function setLanguageOnPageLoad(language) {  
-    document.getElementById("language").value = language;  
-}  
-  
-function changeLanguage(lang) {  
-    fetch(`${url_prefix}/change-language`, {  
-        method: "POST",  
-        headers: {  
-            "Content-Type": "application/json",  
-        },  
-        body: JSON.stringify({ language: lang }),  
-    }).then((response) => {  
-        if (response.ok) {  
-            localStorage.setItem("language", lang);  
-            location.reload();  
-        } else {  
-            console.error("Failed to change language");  
-        }  
-    });  
-}  

spaces/AdithyaSNair/Medical_price_prediction/README.md

@@ -1,12 +0,0 @@
----
-title: Medical Price Prediction
-emoji: 📚
-colorFrom: red
-colorTo: indigo
-sdk: gradio
-sdk_version: 3.16.2
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/AgentVerse/agentVerse/agentverse/environments/simulation_env/rules/selector/basic.py

@@ -1,27 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, List
-
-from agentverse.message import Message
-
-from . import selector_registry as SelectorRegistry
-from .base import BaseSelector
-
-if TYPE_CHECKING:
-    from agentverse.environments import BaseEnvironment
-
-
-@SelectorRegistry.register("basic")
-class BasicSelector(BaseSelector):
-    """
-    Base class for all selecters
-    """
-
-    def select_message(
-        self, environment: BaseEnvironment, messages: List[Message]
-    ) -> List[Message]:
-        """Selects a set of valid messages from all messages"""
-        return messages
-
-    def reset(self) -> None:
-        pass

spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/alphamaskimage/AlphaMaskImage.js

@@ -1,2 +0,0 @@
-import AlphaMaskImage from '../../../plugins/alphamaskimage.js';
-export default AlphaMaskImage;

spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/filechooser/Factory.d.ts

@@ -1,5 +0,0 @@
-import { FileChooser } from './FileChooser.js';
-
-export default function (
-    config?: FileChooser.IConfig
-): FileChooser;

spaces/Ameaou/academic-chatgpt3.1/crazy_functions/批量Markdown翻译.py

@@ -1,161 +0,0 @@
-from toolbox import update_ui
-from toolbox import CatchException, report_execption, write_results_to_file
-fast_debug = False
-
-class PaperFileGroup():
-    def __init__(self):
-        self.file_paths = []
-        self.file_contents = []
-        self.sp_file_contents = []
-        self.sp_file_index = []
-        self.sp_file_tag = []
-
-        # count_token
-        from request_llm.bridge_all import model_info
-        enc = model_info["gpt-3.5-turbo"]['tokenizer']
-        def get_token_num(txt): return len(enc.encode(txt, disallowed_special=()))
-        self.get_token_num = get_token_num
-
-    def run_file_split(self, max_token_limit=1900):
-        """
-        将长文本分离开来
-        """
-        for index, file_content in enumerate(self.file_contents):
-            if self.get_token_num(file_content) < max_token_limit:
-                self.sp_file_contents.append(file_content)
-                self.sp_file_index.append(index)
-                self.sp_file_tag.append(self.file_paths[index])
-            else:
-                from .crazy_utils import breakdown_txt_to_satisfy_token_limit_for_pdf
-                segments = breakdown_txt_to_satisfy_token_limit_for_pdf(file_content, self.get_token_num, max_token_limit)
-                for j, segment in enumerate(segments):
-                    self.sp_file_contents.append(segment)
-                    self.sp_file_index.append(index)
-                    self.sp_file_tag.append(self.file_paths[index] + f".part-{j}.md")
-
-        print('Segmentation: done')
-
-def 多文件翻译(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, language='en'):
-    import time, os, re
-    from .crazy_utils import request_gpt_model_multi_threads_with_very_awesome_ui_and_high_efficiency
-
-    #  <-------- 读取Markdown文件，删除其中的所有注释 ----------> 
-    pfg = PaperFileGroup()
-
-    for index, fp in enumerate(file_manifest):
-        with open(fp, 'r', encoding='utf-8', errors='replace') as f:
-            file_content = f.read()
-            # 记录删除注释后的文本
-            pfg.file_paths.append(fp)
-            pfg.file_contents.append(file_content)
-
-    #  <-------- 拆分过长的Markdown文件 ----------> 
-    pfg.run_file_split(max_token_limit=1500)
-    n_split = len(pfg.sp_file_contents)
-
-    #  <-------- 多线程润色开始 ----------> 
-    if language == 'en->zh':
-        inputs_array = ["This is a Markdown file, translate it into Chinese, do not modify any existing Markdown commands:" + 
-                        f"\n\n{frag}" for frag in pfg.sp_file_contents]
-        inputs_show_user_array = [f"翻译 {f}" for f in pfg.sp_file_tag]
-        sys_prompt_array = ["You are a professional academic paper translator." for _ in range(n_split)]
-    elif language == 'zh->en':
-        inputs_array = [f"This is a Markdown file, translate it into English, do not modify any existing Markdown commands:" + 
-                        f"\n\n{frag}" for frag in pfg.sp_file_contents]
-        inputs_show_user_array = [f"翻译 {f}" for f in pfg.sp_file_tag]
-        sys_prompt_array = ["You are a professional academic paper translator." for _ in range(n_split)]
-
-    gpt_response_collection = yield from request_gpt_model_multi_threads_with_very_awesome_ui_and_high_efficiency(
-        inputs_array=inputs_array,
-        inputs_show_user_array=inputs_show_user_array,
-        llm_kwargs=llm_kwargs,
-        chatbot=chatbot,
-        history_array=[[""] for _ in range(n_split)],
-        sys_prompt_array=sys_prompt_array,
-        # max_workers=5,  # OpenAI所允许的最大并行过载
-        scroller_max_len = 80
-    )
-
-    #  <-------- 整理结果，退出 ----------> 
-    create_report_file_name = time.strftime("%Y-%m-%d-%H-%M-%S", time.localtime()) + f"-chatgpt.polish.md"
-    res = write_results_to_file(gpt_response_collection, file_name=create_report_file_name)
-    history = gpt_response_collection
-    chatbot.append((f"{fp}完成了吗？", res))
-    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-
-
-
-
-
-@CatchException
-def Markdown英译中(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
-    # 基本信息：功能、贡献者
-    chatbot.append([
-        "函数插件功能？",
-        "对整个Markdown项目进行翻译。函数插件贡献者: Binary-Husky"])
-    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-
-    # 尝试导入依赖，如果缺少依赖，则给出安装建议
-    try:
-        import tiktoken
-    except:
-        report_execption(chatbot, history,
-                         a=f"解析项目: {txt}",
-                         b=f"导入软件依赖失败。使用该模块需要额外依赖，安装方法```pip install --upgrade tiktoken```。")
-        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-        return
-    history = []    # 清空历史，以免输入溢出
-    import glob, os
-    if os.path.exists(txt):
-        project_folder = txt
-    else:
-        if txt == "": txt = '空空如也的输入栏'
-        report_execption(chatbot, history, a = f"解析项目: {txt}", b = f"找不到本地项目或无权访问: {txt}")
-        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-        return
-    file_manifest = [f for f in glob.glob(f'{project_folder}/**/*.md', recursive=True)]
-    if len(file_manifest) == 0:
-        report_execption(chatbot, history, a = f"解析项目: {txt}", b = f"找不到任何.md文件: {txt}")
-        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-        return
-    yield from 多文件翻译(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, language='en->zh')
-
-
-
-
-
-@CatchException
-def Markdown中译英(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
-    # 基本信息：功能、贡献者
-    chatbot.append([
-        "函数插件功能？",
-        "对整个Markdown项目进行翻译。函数插件贡献者: Binary-Husky"])
-    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-
-    # 尝试导入依赖，如果缺少依赖，则给出安装建议
-    try:
-        import tiktoken
-    except:
-        report_execption(chatbot, history,
-                         a=f"解析项目: {txt}",
-                         b=f"导入软件依赖失败。使用该模块需要额外依赖，安装方法```pip install --upgrade tiktoken```。")
-        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-        return
-    history = []    # 清空历史，以免输入溢出
-    import glob, os
-    if os.path.exists(txt):
-        project_folder = txt
-    else:
-        if txt == "": txt = '空空如也的输入栏'
-        report_execption(chatbot, history, a = f"解析项目: {txt}", b = f"找不到本地项目或无权访问: {txt}")
-        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-        return
-    if txt.endswith('.md'):
-        file_manifest = [txt]
-    else:
-        file_manifest = [f for f in glob.glob(f'{project_folder}/**/*.md', recursive=True)]
-    if len(file_manifest) == 0:
-        report_execption(chatbot, history, a = f"解析项目: {txt}", b = f"找不到任何.md文件: {txt}")
-        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-        return
-    yield from 多文件翻译(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, language='zh->en')

spaces/Andy1621/uniformer_image_detection/configs/_base_/models/mask_rcnn_uniformer_fpn.py

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

spaces/Andy1621/uniformer_image_detection/configs/fast_rcnn/fast_rcnn_r101_fpn_1x_coco.py

@@ -1,2 +0,0 @@
-_base_ = './fast_rcnn_r50_fpn_1x_coco.py'
-model = dict(pretrained='torchvision://resnet101', backbone=dict(depth=101))

spaces/Andy1621/uniformer_image_detection/configs/legacy_1.x/retinanet_r50_caffe_fpn_1x_coco_v1.py

@@ -1,37 +0,0 @@
-_base_ = './retinanet_r50_fpn_1x_coco_v1.py'
-model = dict(
-    pretrained='open-mmlab://detectron/resnet50_caffe',
-    backbone=dict(
-        norm_cfg=dict(requires_grad=False), norm_eval=True, style='caffe'))
-# use caffe img_norm
-img_norm_cfg = dict(
-    mean=[102.9801, 115.9465, 122.7717], std=[1.0, 1.0, 1.0], to_rgb=False)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations', with_bbox=True),
-    dict(type='Resize', img_scale=(1333, 800), keep_ratio=True),
-    dict(type='RandomFlip', flip_ratio=0.5),
-    dict(type='Normalize', **img_norm_cfg),
-    dict(type='Pad', size_divisor=32),
-    dict(type='DefaultFormatBundle'),
-    dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']),
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=(1333, 800),
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='Pad', size_divisor=32),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img']),
-        ])
-]
-data = dict(
-    train=dict(pipeline=train_pipeline),
-    val=dict(pipeline=test_pipeline),
-    test=dict(pipeline=test_pipeline))

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

@@ -1,37 +0,0 @@
-_base_ = './retinanet_r50_fpn_1x_coco.py'
-model = dict(
-    pretrained='open-mmlab://detectron2/resnet50_caffe',
-    backbone=dict(
-        norm_cfg=dict(requires_grad=False), norm_eval=True, style='caffe'))
-# use caffe img_norm
-img_norm_cfg = dict(
-    mean=[103.530, 116.280, 123.675], std=[1.0, 1.0, 1.0], to_rgb=False)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations', with_bbox=True),
-    dict(type='Resize', img_scale=(1333, 800), keep_ratio=True),
-    dict(type='RandomFlip', flip_ratio=0.5),
-    dict(type='Normalize', **img_norm_cfg),
-    dict(type='Pad', size_divisor=32),
-    dict(type='DefaultFormatBundle'),
-    dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']),
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=(1333, 800),
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='Pad', size_divisor=32),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img']),
-        ])
-]
-data = dict(
-    train=dict(pipeline=train_pipeline),
-    val=dict(pipeline=test_pipeline),
-    test=dict(pipeline=test_pipeline))

spaces/Andy1621/uniformer_image_detection/mmdet/models/roi_heads/bbox_heads/sabl_head.py

@@ -1,572 +0,0 @@
-import numpy as np
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from mmcv.cnn import ConvModule, kaiming_init, normal_init, xavier_init
-from mmcv.runner import force_fp32
-
-from mmdet.core import build_bbox_coder, multi_apply, multiclass_nms
-from mmdet.models.builder import HEADS, build_loss
-from mmdet.models.losses import accuracy
-
-
-@HEADS.register_module()
-class SABLHead(nn.Module):
-    """Side-Aware Boundary Localization (SABL) for RoI-Head.
-
-    Side-Aware features are extracted by conv layers
-    with an attention mechanism.
-    Boundary Localization with Bucketing and Bucketing Guided Rescoring
-    are implemented in BucketingBBoxCoder.
-
-    Please refer to https://arxiv.org/abs/1912.04260 for more details.
-
-    Args:
-        cls_in_channels (int): Input channels of cls RoI feature. \
-            Defaults to 256.
-        reg_in_channels (int): Input channels of reg RoI feature. \
-            Defaults to 256.
-        roi_feat_size (int): Size of RoI features. Defaults to 7.
-        reg_feat_up_ratio (int): Upsample ratio of reg features. \
-            Defaults to 2.
-        reg_pre_kernel (int): Kernel of 2D conv layers before \
-            attention pooling. Defaults to 3.
-        reg_post_kernel (int): Kernel of 1D conv layers after \
-            attention pooling. Defaults to 3.
-        reg_pre_num (int): Number of pre convs. Defaults to 2.
-        reg_post_num (int): Number of post convs. Defaults to 1.
-        num_classes (int): Number of classes in dataset. Defaults to 80.
-        cls_out_channels (int): Hidden channels in cls fcs. Defaults to 1024.
-        reg_offset_out_channels (int): Hidden and output channel \
-            of reg offset branch. Defaults to 256.
-        reg_cls_out_channels (int): Hidden and output channel \
-            of reg cls branch. Defaults to 256.
-        num_cls_fcs (int): Number of fcs for cls branch. Defaults to 1.
-        num_reg_fcs (int): Number of fcs for reg branch.. Defaults to 0.
-        reg_class_agnostic (bool): Class agnostic regresion or not. \
-            Defaults to True.
-        norm_cfg (dict): Config of norm layers. Defaults to None.
-        bbox_coder (dict): Config of bbox coder. Defaults 'BucketingBBoxCoder'.
-        loss_cls (dict): Config of classification loss.
-        loss_bbox_cls (dict): Config of classification loss for bbox branch.
-        loss_bbox_reg (dict): Config of regression loss for bbox branch.
-    """
-
-    def __init__(self,
-                 num_classes,
-                 cls_in_channels=256,
-                 reg_in_channels=256,
-                 roi_feat_size=7,
-                 reg_feat_up_ratio=2,
-                 reg_pre_kernel=3,
-                 reg_post_kernel=3,
-                 reg_pre_num=2,
-                 reg_post_num=1,
-                 cls_out_channels=1024,
-                 reg_offset_out_channels=256,
-                 reg_cls_out_channels=256,
-                 num_cls_fcs=1,
-                 num_reg_fcs=0,
-                 reg_class_agnostic=True,
-                 norm_cfg=None,
-                 bbox_coder=dict(
-                     type='BucketingBBoxCoder',
-                     num_buckets=14,
-                     scale_factor=1.7),
-                 loss_cls=dict(
-                     type='CrossEntropyLoss',
-                     use_sigmoid=False,
-                     loss_weight=1.0),
-                 loss_bbox_cls=dict(
-                     type='CrossEntropyLoss',
-                     use_sigmoid=True,
-                     loss_weight=1.0),
-                 loss_bbox_reg=dict(
-                     type='SmoothL1Loss', beta=0.1, loss_weight=1.0)):
-        super(SABLHead, self).__init__()
-        self.cls_in_channels = cls_in_channels
-        self.reg_in_channels = reg_in_channels
-        self.roi_feat_size = roi_feat_size
-        self.reg_feat_up_ratio = int(reg_feat_up_ratio)
-        self.num_buckets = bbox_coder['num_buckets']
-        assert self.reg_feat_up_ratio // 2 >= 1
-        self.up_reg_feat_size = roi_feat_size * self.reg_feat_up_ratio
-        assert self.up_reg_feat_size == bbox_coder['num_buckets']
-        self.reg_pre_kernel = reg_pre_kernel
-        self.reg_post_kernel = reg_post_kernel
-        self.reg_pre_num = reg_pre_num
-        self.reg_post_num = reg_post_num
-        self.num_classes = num_classes
-        self.cls_out_channels = cls_out_channels
-        self.reg_offset_out_channels = reg_offset_out_channels
-        self.reg_cls_out_channels = reg_cls_out_channels
-        self.num_cls_fcs = num_cls_fcs
-        self.num_reg_fcs = num_reg_fcs
-        self.reg_class_agnostic = reg_class_agnostic
-        assert self.reg_class_agnostic
-        self.norm_cfg = norm_cfg
-
-        self.bbox_coder = build_bbox_coder(bbox_coder)
-        self.loss_cls = build_loss(loss_cls)
-        self.loss_bbox_cls = build_loss(loss_bbox_cls)
-        self.loss_bbox_reg = build_loss(loss_bbox_reg)
-
-        self.cls_fcs = self._add_fc_branch(self.num_cls_fcs,
-                                           self.cls_in_channels,
-                                           self.roi_feat_size,
-                                           self.cls_out_channels)
-
-        self.side_num = int(np.ceil(self.num_buckets / 2))
-
-        if self.reg_feat_up_ratio > 1:
-            self.upsample_x = nn.ConvTranspose1d(
-                reg_in_channels,
-                reg_in_channels,
-                self.reg_feat_up_ratio,
-                stride=self.reg_feat_up_ratio)
-            self.upsample_y = nn.ConvTranspose1d(
-                reg_in_channels,
-                reg_in_channels,
-                self.reg_feat_up_ratio,
-                stride=self.reg_feat_up_ratio)
-
-        self.reg_pre_convs = nn.ModuleList()
-        for i in range(self.reg_pre_num):
-            reg_pre_conv = ConvModule(
-                reg_in_channels,
-                reg_in_channels,
-                kernel_size=reg_pre_kernel,
-                padding=reg_pre_kernel // 2,
-                norm_cfg=norm_cfg,
-                act_cfg=dict(type='ReLU'))
-            self.reg_pre_convs.append(reg_pre_conv)
-
-        self.reg_post_conv_xs = nn.ModuleList()
-        for i in range(self.reg_post_num):
-            reg_post_conv_x = ConvModule(
-                reg_in_channels,
-                reg_in_channels,
-                kernel_size=(1, reg_post_kernel),
-                padding=(0, reg_post_kernel // 2),
-                norm_cfg=norm_cfg,
-                act_cfg=dict(type='ReLU'))
-            self.reg_post_conv_xs.append(reg_post_conv_x)
-        self.reg_post_conv_ys = nn.ModuleList()
-        for i in range(self.reg_post_num):
-            reg_post_conv_y = ConvModule(
-                reg_in_channels,
-                reg_in_channels,
-                kernel_size=(reg_post_kernel, 1),
-                padding=(reg_post_kernel // 2, 0),
-                norm_cfg=norm_cfg,
-                act_cfg=dict(type='ReLU'))
-            self.reg_post_conv_ys.append(reg_post_conv_y)
-
-        self.reg_conv_att_x = nn.Conv2d(reg_in_channels, 1, 1)
-        self.reg_conv_att_y = nn.Conv2d(reg_in_channels, 1, 1)
-
-        self.fc_cls = nn.Linear(self.cls_out_channels, self.num_classes + 1)
-        self.relu = nn.ReLU(inplace=True)
-
-        self.reg_cls_fcs = self._add_fc_branch(self.num_reg_fcs,
-                                               self.reg_in_channels, 1,
-                                               self.reg_cls_out_channels)
-        self.reg_offset_fcs = self._add_fc_branch(self.num_reg_fcs,
-                                                  self.reg_in_channels, 1,
-                                                  self.reg_offset_out_channels)
-        self.fc_reg_cls = nn.Linear(self.reg_cls_out_channels, 1)
-        self.fc_reg_offset = nn.Linear(self.reg_offset_out_channels, 1)
-
-    def _add_fc_branch(self, num_branch_fcs, in_channels, roi_feat_size,
-                       fc_out_channels):
-        in_channels = in_channels * roi_feat_size * roi_feat_size
-        branch_fcs = nn.ModuleList()
-        for i in range(num_branch_fcs):
-            fc_in_channels = (in_channels if i == 0 else fc_out_channels)
-            branch_fcs.append(nn.Linear(fc_in_channels, fc_out_channels))
-        return branch_fcs
-
-    def init_weights(self):
-        for module_list in [
-                self.reg_cls_fcs, self.reg_offset_fcs, self.cls_fcs
-        ]:
-            for m in module_list.modules():
-                if isinstance(m, nn.Linear):
-                    xavier_init(m, distribution='uniform')
-        if self.reg_feat_up_ratio > 1:
-            kaiming_init(self.upsample_x, distribution='normal')
-            kaiming_init(self.upsample_y, distribution='normal')
-
-        normal_init(self.reg_conv_att_x, 0, 0.01)
-        normal_init(self.reg_conv_att_y, 0, 0.01)
-        normal_init(self.fc_reg_offset, 0, 0.001)
-        normal_init(self.fc_reg_cls, 0, 0.01)
-        normal_init(self.fc_cls, 0, 0.01)
-
-    def cls_forward(self, cls_x):
-        cls_x = cls_x.view(cls_x.size(0), -1)
-        for fc in self.cls_fcs:
-            cls_x = self.relu(fc(cls_x))
-        cls_score = self.fc_cls(cls_x)
-        return cls_score
-
-    def attention_pool(self, reg_x):
-        """Extract direction-specific features fx and fy with attention
-        methanism."""
-        reg_fx = reg_x
-        reg_fy = reg_x
-        reg_fx_att = self.reg_conv_att_x(reg_fx).sigmoid()
-        reg_fy_att = self.reg_conv_att_y(reg_fy).sigmoid()
-        reg_fx_att = reg_fx_att / reg_fx_att.sum(dim=2).unsqueeze(2)
-        reg_fy_att = reg_fy_att / reg_fy_att.sum(dim=3).unsqueeze(3)
-        reg_fx = (reg_fx * reg_fx_att).sum(dim=2)
-        reg_fy = (reg_fy * reg_fy_att).sum(dim=3)
-        return reg_fx, reg_fy
-
-    def side_aware_feature_extractor(self, reg_x):
-        """Refine and extract side-aware features without split them."""
-        for reg_pre_conv in self.reg_pre_convs:
-            reg_x = reg_pre_conv(reg_x)
-        reg_fx, reg_fy = self.attention_pool(reg_x)
-
-        if self.reg_post_num > 0:
-            reg_fx = reg_fx.unsqueeze(2)
-            reg_fy = reg_fy.unsqueeze(3)
-            for i in range(self.reg_post_num):
-                reg_fx = self.reg_post_conv_xs[i](reg_fx)
-                reg_fy = self.reg_post_conv_ys[i](reg_fy)
-            reg_fx = reg_fx.squeeze(2)
-            reg_fy = reg_fy.squeeze(3)
-        if self.reg_feat_up_ratio > 1:
-            reg_fx = self.relu(self.upsample_x(reg_fx))
-            reg_fy = self.relu(self.upsample_y(reg_fy))
-        reg_fx = torch.transpose(reg_fx, 1, 2)
-        reg_fy = torch.transpose(reg_fy, 1, 2)
-        return reg_fx.contiguous(), reg_fy.contiguous()
-
-    def reg_pred(self, x, offset_fcs, cls_fcs):
-        """Predict bucketing estimation (cls_pred) and fine regression (offset
-        pred) with side-aware features."""
-        x_offset = x.view(-1, self.reg_in_channels)
-        x_cls = x.view(-1, self.reg_in_channels)
-
-        for fc in offset_fcs:
-            x_offset = self.relu(fc(x_offset))
-        for fc in cls_fcs:
-            x_cls = self.relu(fc(x_cls))
-        offset_pred = self.fc_reg_offset(x_offset)
-        cls_pred = self.fc_reg_cls(x_cls)
-
-        offset_pred = offset_pred.view(x.size(0), -1)
-        cls_pred = cls_pred.view(x.size(0), -1)
-
-        return offset_pred, cls_pred
-
-    def side_aware_split(self, feat):
-        """Split side-aware features aligned with orders of bucketing
-        targets."""
-        l_end = int(np.ceil(self.up_reg_feat_size / 2))
-        r_start = int(np.floor(self.up_reg_feat_size / 2))
-        feat_fl = feat[:, :l_end]
-        feat_fr = feat[:, r_start:].flip(dims=(1, ))
-        feat_fl = feat_fl.contiguous()
-        feat_fr = feat_fr.contiguous()
-        feat = torch.cat([feat_fl, feat_fr], dim=-1)
-        return feat
-
-    def bbox_pred_split(self, bbox_pred, num_proposals_per_img):
-        """Split batch bbox prediction back to each image."""
-        bucket_cls_preds, bucket_offset_preds = bbox_pred
-        bucket_cls_preds = bucket_cls_preds.split(num_proposals_per_img, 0)
-        bucket_offset_preds = bucket_offset_preds.split(
-            num_proposals_per_img, 0)
-        bbox_pred = tuple(zip(bucket_cls_preds, bucket_offset_preds))
-        return bbox_pred
-
-    def reg_forward(self, reg_x):
-        outs = self.side_aware_feature_extractor(reg_x)
-        edge_offset_preds = []
-        edge_cls_preds = []
-        reg_fx = outs[0]
-        reg_fy = outs[1]
-        offset_pred_x, cls_pred_x = self.reg_pred(reg_fx, self.reg_offset_fcs,
-                                                  self.reg_cls_fcs)
-        offset_pred_y, cls_pred_y = self.reg_pred(reg_fy, self.reg_offset_fcs,
-                                                  self.reg_cls_fcs)
-        offset_pred_x = self.side_aware_split(offset_pred_x)
-        offset_pred_y = self.side_aware_split(offset_pred_y)
-        cls_pred_x = self.side_aware_split(cls_pred_x)
-        cls_pred_y = self.side_aware_split(cls_pred_y)
-        edge_offset_preds = torch.cat([offset_pred_x, offset_pred_y], dim=-1)
-        edge_cls_preds = torch.cat([cls_pred_x, cls_pred_y], dim=-1)
-
-        return (edge_cls_preds, edge_offset_preds)
-
-    def forward(self, x):
-
-        bbox_pred = self.reg_forward(x)
-        cls_score = self.cls_forward(x)
-
-        return cls_score, bbox_pred
-
-    def get_targets(self, sampling_results, gt_bboxes, gt_labels,
-                    rcnn_train_cfg):
-        pos_proposals = [res.pos_bboxes for res in sampling_results]
-        neg_proposals = [res.neg_bboxes for res in sampling_results]
-        pos_gt_bboxes = [res.pos_gt_bboxes for res in sampling_results]
-        pos_gt_labels = [res.pos_gt_labels for res in sampling_results]
-        cls_reg_targets = self.bucket_target(pos_proposals, neg_proposals,
-                                             pos_gt_bboxes, pos_gt_labels,
-                                             rcnn_train_cfg)
-        (labels, label_weights, bucket_cls_targets, bucket_cls_weights,
-         bucket_offset_targets, bucket_offset_weights) = cls_reg_targets
-        return (labels, label_weights, (bucket_cls_targets,
-                                        bucket_offset_targets),
-                (bucket_cls_weights, bucket_offset_weights))
-
-    def bucket_target(self,
-                      pos_proposals_list,
-                      neg_proposals_list,
-                      pos_gt_bboxes_list,
-                      pos_gt_labels_list,
-                      rcnn_train_cfg,
-                      concat=True):
-        (labels, label_weights, bucket_cls_targets, bucket_cls_weights,
-         bucket_offset_targets, bucket_offset_weights) = multi_apply(
-             self._bucket_target_single,
-             pos_proposals_list,
-             neg_proposals_list,
-             pos_gt_bboxes_list,
-             pos_gt_labels_list,
-             cfg=rcnn_train_cfg)
-
-        if concat:
-            labels = torch.cat(labels, 0)
-            label_weights = torch.cat(label_weights, 0)
-            bucket_cls_targets = torch.cat(bucket_cls_targets, 0)
-            bucket_cls_weights = torch.cat(bucket_cls_weights, 0)
-            bucket_offset_targets = torch.cat(bucket_offset_targets, 0)
-            bucket_offset_weights = torch.cat(bucket_offset_weights, 0)
-        return (labels, label_weights, bucket_cls_targets, bucket_cls_weights,
-                bucket_offset_targets, bucket_offset_weights)
-
-    def _bucket_target_single(self, pos_proposals, neg_proposals,
-                              pos_gt_bboxes, pos_gt_labels, cfg):
-        """Compute bucketing estimation targets and fine regression targets for
-        a single image.
-
-        Args:
-            pos_proposals (Tensor): positive proposals of a single image,
-                 Shape (n_pos, 4)
-            neg_proposals (Tensor): negative proposals of a single image,
-                 Shape (n_neg, 4).
-            pos_gt_bboxes (Tensor): gt bboxes assigned to positive proposals
-                 of a single image, Shape (n_pos, 4).
-            pos_gt_labels (Tensor): gt labels assigned to positive proposals
-                 of a single image, Shape (n_pos, ).
-            cfg (dict): Config of calculating targets
-
-        Returns:
-            tuple:
-
-                - labels (Tensor): Labels in a single image. \
-                    Shape (n,).
-                - label_weights (Tensor): Label weights in a single image.\
-                    Shape (n,)
-                - bucket_cls_targets (Tensor): Bucket cls targets in \
-                    a single image. Shape (n, num_buckets*2).
-                - bucket_cls_weights (Tensor): Bucket cls weights in \
-                    a single image. Shape (n, num_buckets*2).
-                - bucket_offset_targets (Tensor): Bucket offset targets \
-                    in a single image. Shape (n, num_buckets*2).
-                - bucket_offset_targets (Tensor): Bucket offset weights \
-                    in a single image. Shape (n, num_buckets*2).
-        """
-        num_pos = pos_proposals.size(0)
-        num_neg = neg_proposals.size(0)
-        num_samples = num_pos + num_neg
-        labels = pos_gt_bboxes.new_full((num_samples, ),
-                                        self.num_classes,
-                                        dtype=torch.long)
-        label_weights = pos_proposals.new_zeros(num_samples)
-        bucket_cls_targets = pos_proposals.new_zeros(num_samples,
-                                                     4 * self.side_num)
-        bucket_cls_weights = pos_proposals.new_zeros(num_samples,
-                                                     4 * self.side_num)
-        bucket_offset_targets = pos_proposals.new_zeros(
-            num_samples, 4 * self.side_num)
-        bucket_offset_weights = pos_proposals.new_zeros(
-            num_samples, 4 * self.side_num)
-        if num_pos > 0:
-            labels[:num_pos] = pos_gt_labels
-            label_weights[:num_pos] = 1.0
-            (pos_bucket_offset_targets, pos_bucket_offset_weights,
-             pos_bucket_cls_targets,
-             pos_bucket_cls_weights) = self.bbox_coder.encode(
-                 pos_proposals, pos_gt_bboxes)
-            bucket_cls_targets[:num_pos, :] = pos_bucket_cls_targets
-            bucket_cls_weights[:num_pos, :] = pos_bucket_cls_weights
-            bucket_offset_targets[:num_pos, :] = pos_bucket_offset_targets
-            bucket_offset_weights[:num_pos, :] = pos_bucket_offset_weights
-        if num_neg > 0:
-            label_weights[-num_neg:] = 1.0
-        return (labels, label_weights, bucket_cls_targets, bucket_cls_weights,
-                bucket_offset_targets, bucket_offset_weights)
-
-    def loss(self,
-             cls_score,
-             bbox_pred,
-             rois,
-             labels,
-             label_weights,
-             bbox_targets,
-             bbox_weights,
-             reduction_override=None):
-        losses = dict()
-        if cls_score is not None:
-            avg_factor = max(torch.sum(label_weights > 0).float().item(), 1.)
-            losses['loss_cls'] = self.loss_cls(
-                cls_score,
-                labels,
-                label_weights,
-                avg_factor=avg_factor,
-                reduction_override=reduction_override)
-            losses['acc'] = accuracy(cls_score, labels)
-
-        if bbox_pred is not None:
-            bucket_cls_preds, bucket_offset_preds = bbox_pred
-            bucket_cls_targets, bucket_offset_targets = bbox_targets
-            bucket_cls_weights, bucket_offset_weights = bbox_weights
-            # edge cls
-            bucket_cls_preds = bucket_cls_preds.view(-1, self.side_num)
-            bucket_cls_targets = bucket_cls_targets.view(-1, self.side_num)
-            bucket_cls_weights = bucket_cls_weights.view(-1, self.side_num)
-            losses['loss_bbox_cls'] = self.loss_bbox_cls(
-                bucket_cls_preds,
-                bucket_cls_targets,
-                bucket_cls_weights,
-                avg_factor=bucket_cls_targets.size(0),
-                reduction_override=reduction_override)
-
-            losses['loss_bbox_reg'] = self.loss_bbox_reg(
-                bucket_offset_preds,
-                bucket_offset_targets,
-                bucket_offset_weights,
-                avg_factor=bucket_offset_targets.size(0),
-                reduction_override=reduction_override)
-
-        return losses
-
-    @force_fp32(apply_to=('cls_score', 'bbox_pred'))
-    def get_bboxes(self,
-                   rois,
-                   cls_score,
-                   bbox_pred,
-                   img_shape,
-                   scale_factor,
-                   rescale=False,
-                   cfg=None):
-        if isinstance(cls_score, list):
-            cls_score = sum(cls_score) / float(len(cls_score))
-        scores = F.softmax(cls_score, dim=1) if cls_score is not None else None
-
-        if bbox_pred is not None:
-            bboxes, confids = self.bbox_coder.decode(rois[:, 1:], bbox_pred,
-                                                     img_shape)
-        else:
-            bboxes = rois[:, 1:].clone()
-            confids = None
-            if img_shape is not None:
-                bboxes[:, [0, 2]].clamp_(min=0, max=img_shape[1] - 1)
-                bboxes[:, [1, 3]].clamp_(min=0, max=img_shape[0] - 1)
-
-        if rescale and bboxes.size(0) > 0:
-            if isinstance(scale_factor, float):
-                bboxes /= scale_factor
-            else:
-                bboxes /= torch.from_numpy(scale_factor).to(bboxes.device)
-
-        if cfg is None:
-            return bboxes, scores
-        else:
-            det_bboxes, det_labels = multiclass_nms(
-                bboxes,
-                scores,
-                cfg.score_thr,
-                cfg.nms,
-                cfg.max_per_img,
-                score_factors=confids)
-
-            return det_bboxes, det_labels
-
-    @force_fp32(apply_to=('bbox_preds', ))
-    def refine_bboxes(self, rois, labels, bbox_preds, pos_is_gts, img_metas):
-        """Refine bboxes during training.
-
-        Args:
-            rois (Tensor): Shape (n*bs, 5), where n is image number per GPU,
-                and bs is the sampled RoIs per image.
-            labels (Tensor): Shape (n*bs, ).
-            bbox_preds (list[Tensor]): Shape [(n*bs, num_buckets*2), \
-                (n*bs, num_buckets*2)].
-            pos_is_gts (list[Tensor]): Flags indicating if each positive bbox
-                is a gt bbox.
-            img_metas (list[dict]): Meta info of each image.
-
-        Returns:
-            list[Tensor]: Refined bboxes of each image in a mini-batch.
-        """
-        img_ids = rois[:, 0].long().unique(sorted=True)
-        assert img_ids.numel() == len(img_metas)
-
-        bboxes_list = []
-        for i in range(len(img_metas)):
-            inds = torch.nonzero(
-                rois[:, 0] == i, as_tuple=False).squeeze(dim=1)
-            num_rois = inds.numel()
-
-            bboxes_ = rois[inds, 1:]
-            label_ = labels[inds]
-            edge_cls_preds, edge_offset_preds = bbox_preds
-            edge_cls_preds_ = edge_cls_preds[inds]
-            edge_offset_preds_ = edge_offset_preds[inds]
-            bbox_pred_ = [edge_cls_preds_, edge_offset_preds_]
-            img_meta_ = img_metas[i]
-            pos_is_gts_ = pos_is_gts[i]
-
-            bboxes = self.regress_by_class(bboxes_, label_, bbox_pred_,
-                                           img_meta_)
-            # filter gt bboxes
-            pos_keep = 1 - pos_is_gts_
-            keep_inds = pos_is_gts_.new_ones(num_rois)
-            keep_inds[:len(pos_is_gts_)] = pos_keep
-
-            bboxes_list.append(bboxes[keep_inds.type(torch.bool)])
-
-        return bboxes_list
-
-    @force_fp32(apply_to=('bbox_pred', ))
-    def regress_by_class(self, rois, label, bbox_pred, img_meta):
-        """Regress the bbox for the predicted class. Used in Cascade R-CNN.
-
-        Args:
-            rois (Tensor): shape (n, 4) or (n, 5)
-            label (Tensor): shape (n, )
-            bbox_pred (list[Tensor]): shape [(n, num_buckets *2), \
-                (n, num_buckets *2)]
-            img_meta (dict): Image meta info.
-
-        Returns:
-            Tensor: Regressed bboxes, the same shape as input rois.
-        """
-        assert rois.size(1) == 4 or rois.size(1) == 5
-
-        if rois.size(1) == 4:
-            new_rois, _ = self.bbox_coder.decode(rois, bbox_pred,
-                                                 img_meta['img_shape'])
-        else:
-            bboxes, _ = self.bbox_coder.decode(rois[:, 1:], bbox_pred,
-                                               img_meta['img_shape'])
-            new_rois = torch.cat((rois[:, [0]], bboxes), dim=1)
-
-        return new_rois

spaces/Andy1621/uniformer_image_segmentation/configs/pspnet/pspnet_r101-d8_512x1024_80k_cityscapes.py

@@ -1,2 +0,0 @@
-_base_ = './pspnet_r50-d8_512x1024_80k_cityscapes.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))

spaces/Andyrasika/Andyrasika-dreamshaper-sdxl-1.0/README.md

@@ -1,12 +0,0 @@
----
-title: Andyrasika Dreamshaper Sdxl 1.0
-emoji: 👀
-colorFrom: pink
-colorTo: purple
-sdk: gradio
-sdk_version: 3.40.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/Anthony7906/MengHuiMXD_GPT/modules/utils.py

@@ -1,548 +0,0 @@
-# -*- coding:utf-8 -*-
-from __future__ import annotations
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Tuple, Type
-import logging
-import json
-import os
-import datetime
-import hashlib
-import csv
-import requests
-import re
-import html
-import sys
-import subprocess
-
-import gradio as gr
-from pypinyin import lazy_pinyin
-import tiktoken
-import mdtex2html
-from markdown import markdown
-from pygments import highlight
-from pygments.lexers import get_lexer_by_name
-from pygments.formatters import HtmlFormatter
-import pandas as pd
-
-from modules.presets import *
-from . import shared
-from modules.config import retrieve_proxy
-
-if TYPE_CHECKING:
-    from typing import TypedDict
-
-    class DataframeData(TypedDict):
-        headers: List[str]
-        data: List[List[str | int | bool]]
-
-def predict(current_model, *args):
-    iter = current_model.predict(*args)
-    for i in iter:
-        yield i
-
-def billing_info(current_model):
-    return current_model.billing_info()
-
-def set_key(current_model, *args):
-    return current_model.set_key(*args)
-
-def load_chat_history(current_model, *args):
-    return current_model.load_chat_history(*args)
-
-def interrupt(current_model, *args):
-    return current_model.interrupt(*args)
-
-def reset(current_model, *args):
-    return current_model.reset(*args)
-
-def retry(current_model, *args):
-    iter = current_model.retry(*args)
-    for i in iter:
-        yield i
-
-def delete_first_conversation(current_model, *args):
-    return current_model.delete_first_conversation(*args)
-
-def delete_last_conversation(current_model, *args):
-    return current_model.delete_last_conversation(*args)
-
-def set_system_prompt(current_model, *args):
-    return current_model.set_system_prompt(*args)
-
-def save_chat_history(current_model, *args):
-    return current_model.save_chat_history(*args)
-
-def export_markdown(current_model, *args):
-    return current_model.export_markdown(*args)
-
-def load_chat_history(current_model, *args):
-    return current_model.load_chat_history(*args)
-
-def set_token_upper_limit(current_model, *args):
-    return current_model.set_token_upper_limit(*args)
-
-def set_temperature(current_model, *args):
-    current_model.set_temperature(*args)
-
-def set_top_p(current_model, *args):
-    current_model.set_top_p(*args)
-
-def set_n_choices(current_model, *args):
-    current_model.set_n_choices(*args)
-
-def set_stop_sequence(current_model, *args):
-    current_model.set_stop_sequence(*args)
-
-def set_max_tokens(current_model, *args):
-    current_model.set_max_tokens(*args)
-
-def set_presence_penalty(current_model, *args):
-    current_model.set_presence_penalty(*args)
-
-def set_frequency_penalty(current_model, *args):
-    current_model.set_frequency_penalty(*args)
-
-def set_logit_bias(current_model, *args):
-    current_model.set_logit_bias(*args)
-
-def set_user_identifier(current_model, *args):
-    current_model.set_user_identifier(*args)
-
-def set_single_turn(current_model, *args):
-    current_model.set_single_turn(*args)
-
-def handle_file_upload(current_model, *args):
-    return current_model.handle_file_upload(*args)
-
-def like(current_model, *args):
-    return current_model.like(*args)
-
-def dislike(current_model, *args):
-    return current_model.dislike(*args)
-
-
-def count_token(message):
-    encoding = tiktoken.get_encoding("cl100k_base")
-    input_str = f"role: {message['role']}, content: {message['content']}"
-    length = len(encoding.encode(input_str))
-    return length
-
-
-def markdown_to_html_with_syntax_highlight(md_str):
-    def replacer(match):
-        lang = match.group(1) or "text"
-        code = match.group(2)
-
-        try:
-            lexer = get_lexer_by_name(lang, stripall=True)
-        except ValueError:
-            lexer = get_lexer_by_name("text", stripall=True)
-
-        formatter = HtmlFormatter()
-        highlighted_code = highlight(code, lexer, formatter)
-
-        return f'<pre><code class="{lang}">{highlighted_code}</code></pre>'
-
-    code_block_pattern = r"```(\w+)?\n([\s\S]+?)\n```"
-    md_str = re.sub(code_block_pattern, replacer, md_str, flags=re.MULTILINE)
-
-    html_str = markdown(md_str)
-    return html_str
-
-
-def normalize_markdown(md_text: str) -> str:
-    lines = md_text.split("\n")
-    normalized_lines = []
-    inside_list = False
-
-    for i, line in enumerate(lines):
-        if re.match(r"^(\d+\.|-|\*|\+)\s", line.strip()):
-            if not inside_list and i > 0 and lines[i - 1].strip() != "":
-                normalized_lines.append("")
-            inside_list = True
-            normalized_lines.append(line)
-        elif inside_list and line.strip() == "":
-            if i < len(lines) - 1 and not re.match(
-                r"^(\d+\.|-|\*|\+)\s", lines[i + 1].strip()
-            ):
-                normalized_lines.append(line)
-            continue
-        else:
-            inside_list = False
-            normalized_lines.append(line)
-
-    return "\n".join(normalized_lines)
-
-
-def convert_mdtext(md_text):
-    code_block_pattern = re.compile(r"```(.*?)(?:```|$)", re.DOTALL)
-    inline_code_pattern = re.compile(r"`(.*?)`", re.DOTALL)
-    code_blocks = code_block_pattern.findall(md_text)
-    non_code_parts = code_block_pattern.split(md_text)[::2]
-
-    result = []
-    for non_code, code in zip(non_code_parts, code_blocks + [""]):
-        if non_code.strip():
-            non_code = normalize_markdown(non_code)
-            if inline_code_pattern.search(non_code):
-                result.append(markdown(non_code, extensions=["tables"]))
-            else:
-                result.append(mdtex2html.convert(non_code, extensions=["tables"]))
-        if code.strip():
-            # _, code = detect_language(code)  # 暂时去除代码高亮功能，因为在大段代码的情况下会出现问题
-            # code = code.replace("\n\n", "\n") # 暂时去除代码中的空行，因为在大段代码的情况下会出现问题
-            code = f"\n```{code}\n\n```"
-            code = markdown_to_html_with_syntax_highlight(code)
-            result.append(code)
-    result = "".join(result)
-    result += ALREADY_CONVERTED_MARK
-    return result
-
-
-def convert_asis(userinput):
-    return (
-        f'<p style="white-space:pre-wrap;">{html.escape(userinput)}</p>'
-        + ALREADY_CONVERTED_MARK
-    )
-
-
-def detect_converted_mark(userinput):
-    try:
-        if userinput.endswith(ALREADY_CONVERTED_MARK):
-            return True
-        else:
-            return False
-    except:
-        return True
-
-
-def detect_language(code):
-    if code.startswith("\n"):
-        first_line = ""
-    else:
-        first_line = code.strip().split("\n", 1)[0]
-    language = first_line.lower() if first_line else ""
-    code_without_language = code[len(first_line) :].lstrip() if first_line else code
-    return language, code_without_language
-
-
-def construct_text(role, text):
-    return {"role": role, "content": text}
-
-
-def construct_user(text):
-    return construct_text("user", text)
-
-
-def construct_system(text):
-    return construct_text("system", text)
-
-
-def construct_assistant(text):
-    return construct_text("assistant", text)
-
-
-def save_file(filename, system, history, chatbot, user_name):
-    logging.debug(f"{user_name} 保存对话历史中……")
-    os.makedirs(os.path.join(HISTORY_DIR, user_name), exist_ok=True)
-    if filename.endswith(".json"):
-        json_s = {"system": system, "history": history, "chatbot": chatbot}
-        print(json_s)
-        with open(os.path.join(HISTORY_DIR, user_name, filename), "w") as f:
-            json.dump(json_s, f)
-    elif filename.endswith(".md"):
-        md_s = f"system: \n- {system} \n"
-        for data in history:
-            md_s += f"\n{data['role']}: \n- {data['content']} \n"
-        with open(os.path.join(HISTORY_DIR, user_name, filename), "w", encoding="utf8") as f:
-            f.write(md_s)
-    logging.debug(f"{user_name} 保存对话历史完毕")
-    return os.path.join(HISTORY_DIR, user_name, filename)
-
-
-def sorted_by_pinyin(list):
-    return sorted(list, key=lambda char: lazy_pinyin(char)[0][0])
-
-
-def get_file_names(dir, plain=False, filetypes=[".json"]):
-    logging.debug(f"获取文件名列表，目录为{dir}，文件类型为{filetypes}，是否为纯文本列表{plain}")
-    files = []
-    try:
-        for type in filetypes:
-            files += [f for f in os.listdir(dir) if f.endswith(type)]
-    except FileNotFoundError:
-        files = []
-    files = sorted_by_pinyin(files)
-    if files == []:
-        files = [""]
-    logging.debug(f"files are:{files}")
-    if plain:
-        return files
-    else:
-        return gr.Dropdown.update(choices=files)
-
-
-def get_history_names(plain=False, user_name=""):
-    logging.debug(f"从用户 {user_name} 中获取历史记录文件名列表")
-    return get_file_names(os.path.join(HISTORY_DIR, user_name), plain)
-
-
-def load_template(filename, mode=0):
-    logging.debug(f"加载模板文件{filename}，模式为{mode}（0为返回字典和下拉菜单，1为返回下拉菜单，2为返回字典）")
-    lines = []
-    if filename.endswith(".json"):
-        with open(os.path.join(TEMPLATES_DIR, filename), "r", encoding="utf8") as f:
-            lines = json.load(f)
-        lines = [[i["act"], i["prompt"]] for i in lines]
-    else:
-        with open(
-            os.path.join(TEMPLATES_DIR, filename), "r", encoding="utf8"
-        ) as csvfile:
-            reader = csv.reader(csvfile)
-            lines = list(reader)
-        lines = lines[1:]
-    if mode == 1:
-        return sorted_by_pinyin([row[0] for row in lines])
-    elif mode == 2:
-        return {row[0]: row[1] for row in lines}
-    else:
-        choices = sorted_by_pinyin([row[0] for row in lines])
-        return {row[0]: row[1] for row in lines}, gr.Dropdown.update(
-            choices=choices
-        )
-
-
-def get_template_names(plain=False):
-    logging.debug("获取模板文件名列表")
-    return get_file_names(TEMPLATES_DIR, plain, filetypes=[".csv", "json"])
-
-
-def get_template_content(templates, selection, original_system_prompt):
-    logging.debug(f"应用模板中，选择为{selection}，原始系统提示为{original_system_prompt}")
-    try:
-        return templates[selection]
-    except:
-        return original_system_prompt
-
-
-def reset_textbox():
-    logging.debug("重置文本框")
-    return gr.update(value="")
-
-
-def reset_default():
-    default_host = shared.state.reset_api_host()
-    retrieve_proxy("")
-    return gr.update(value=default_host), gr.update(value=""), "API-Host 和代理已重置"
-
-
-def change_api_host(host):
-    shared.state.set_api_host(host)
-    msg = f"API-Host更改为了{host}"
-    logging.info(msg)
-    return msg
-
-
-def change_proxy(proxy):
-    retrieve_proxy(proxy)
-    os.environ["HTTPS_PROXY"] = proxy
-    msg = f"代理更改为了{proxy}"
-    logging.info(msg)
-    return msg
-
-
-def hide_middle_chars(s):
-    if s is None:
-        return ""
-    if len(s) <= 8:
-        return s
-    else:
-        head = s[:4]
-        tail = s[-4:]
-        hidden = "*" * (len(s) - 8)
-        return head + hidden + tail
-
-
-def submit_key(key):
-    key = key.strip()
-    msg = f"API密钥更改为了{hide_middle_chars(key)}"
-    logging.info(msg)
-    return key, msg
-
-
-def replace_today(prompt):
-    today = datetime.datetime.today().strftime("%Y-%m-%d")
-    return prompt.replace("{current_date}", today)
-
-
-def get_geoip():
-    try:
-        with retrieve_proxy():
-            response = requests.get("https://ipapi.co/json/", timeout=5)
-        data = response.json()
-    except:
-        data = {"error": True, "reason": "连接ipapi失败"}
-    if "error" in data.keys():
-        logging.warning(f"无法获取IP地址信息。\n{data}")
-        if data["reason"] == "RateLimited":
-            return (
-                i18n("您的IP区域：未知。")
-            )
-        else:
-            return i18n("获取IP地理位置失败。原因：") + f"{data['reason']}" + i18n("。你仍然可以使用聊天功能。")
-    else:
-        country = data["country_name"]
-        if country == "China":
-            text = "**您的IP区域：中国。请立即检查代理设置，在不受支持的地区使用API可能导致账号被封禁。**"
-        else:
-            text = i18n("您的IP区域：") + f"{country}。"
-        logging.info(text)
-        return text
-
-
-def find_n(lst, max_num):
-    n = len(lst)
-    total = sum(lst)
-
-    if total < max_num:
-        return n
-
-    for i in range(len(lst)):
-        if total - lst[i] < max_num:
-            return n - i - 1
-        total = total - lst[i]
-    return 1
-
-
-def start_outputing():
-    logging.debug("显示取消按钮，隐藏发送按钮")
-    return gr.Button.update(visible=False), gr.Button.update(visible=True)
-
-
-def end_outputing():
-    return (
-        gr.Button.update(visible=True),
-        gr.Button.update(visible=False),
-    )
-
-
-def cancel_outputing():
-    logging.info("中止输出……")
-    shared.state.interrupt()
-
-
-def transfer_input(inputs):
-    # 一次性返回，降低延迟
-    textbox = reset_textbox()
-    outputing = start_outputing()
-    return (
-        inputs,
-        gr.update(value=""),
-        gr.Button.update(visible=False),
-        gr.Button.update(visible=True),
-    )
-
-
-
-def run(command, desc=None, errdesc=None, custom_env=None, live=False):
-    if desc is not None:
-        print(desc)
-    if live:
-        result = subprocess.run(command, shell=True, env=os.environ if custom_env is None else custom_env)
-        if result.returncode != 0:
-            raise RuntimeError(f"""{errdesc or 'Error running command'}.
-Command: {command}
-Error code: {result.returncode}""")
-
-        return ""
-    result = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True, env=os.environ if custom_env is None else custom_env)
-    if result.returncode != 0:
-        message = f"""{errdesc or 'Error running command'}.
-            Command: {command}
-            Error code: {result.returncode}
-            stdout: {result.stdout.decode(encoding="utf8", errors="ignore") if len(result.stdout)>0 else '<empty>'}
-            stderr: {result.stderr.decode(encoding="utf8", errors="ignore") if len(result.stderr)>0 else '<empty>'}
-            """
-        raise RuntimeError(message)
-    return result.stdout.decode(encoding="utf8", errors="ignore")
-
-def versions_html():
-    git = os.environ.get('GIT', "git")
-    python_version = ".".join([str(x) for x in sys.version_info[0:3]])
-    try:
-        commit_hash = run(f"{git} rev-parse HEAD").strip()
-    except Exception:
-        commit_hash = "<none>"
-    if commit_hash != "<none>":
-        short_commit = commit_hash[0:7]
-        commit_info = f"<a style=\"text-decoration:none\" href=\"https://github.com/GaiZhenbiao/ChuanhuChatGPT/commit/{short_commit}\">{short_commit}</a>"
-    else:
-        commit_info = "unknown \U0001F615"
-    return f"""
-        Python: <span title="{sys.version}">{python_version}</span>
-         •���
-        Gradio: {gr.__version__}
-         • 
-        Commit: {commit_info}
-        """
-
-def add_source_numbers(lst, source_name = "Source", use_source = True):
-    if use_source:
-        return [f'[{idx+1}]\t "{item[0]}"\n{source_name}: {item[1]}' for idx, item in enumerate(lst)]
-    else:
-        return [f'[{idx+1}]\t "{item}"' for idx, item in enumerate(lst)]
-
-def add_details(lst):
-    nodes = []
-    for index, txt in enumerate(lst):
-        brief = txt[:25].replace("\n", "")
-        nodes.append(
-            f"<details><summary>{brief}...</summary><p>{txt}</p></details>"
-        )
-    return nodes
-
-
-def sheet_to_string(sheet, sheet_name = None):
-    result = []
-    for index, row in sheet.iterrows():
-        row_string = ""
-        for column in sheet.columns:
-            row_string += f"{column}: {row[column]}, "
-        row_string = row_string.rstrip(", ")
-        row_string += "."
-        result.append(row_string)
-    return result
-
-def excel_to_string(file_path):
-    # 读取Excel文件中的所有工作表
-    excel_file = pd.read_excel(file_path, engine='openpyxl', sheet_name=None)
-
-    # 初始化结果字符串
-    result = []
-
-    # 遍历每一个工作表
-    for sheet_name, sheet_data in excel_file.items():
-
-        # 处理当前工作表并添加到结果字符串
-        result += sheet_to_string(sheet_data, sheet_name=sheet_name)
-
-
-    return result
-
-def get_last_day_of_month(any_day):
-    # The day 28 exists in every month. 4 days later, it's always next month
-    next_month = any_day.replace(day=28) + datetime.timedelta(days=4)
-    # subtracting the number of the current day brings us back one month
-    return next_month - datetime.timedelta(days=next_month.day)
-
-def get_model_source(model_name, alternative_source):
-    if model_name == "gpt2-medium":
-        return "https://huggingface.co/gpt2-medium"
-
-def refresh_ui_elements_on_load(current_model, selected_model_name):
-    return toggle_like_btn_visibility(selected_model_name)
-
-def toggle_like_btn_visibility(selected_model_name):
-    if selected_model_name == "xmchat":
-        return gr.update(visible=True)
-    else:
-        return gr.update(visible=False)

spaces/ArtGAN/Video-Diffusion-WebUI/video_diffusion/utils/model_list.py

@@ -1,6 +0,0 @@
-stable_model_list = [
-    "runwayml/stable-diffusion-v1-5",
-    "stabilityai/stable-diffusion-2-1",
-    # "prompthero/openjourney-v4",
-    "cerspense/zeroscope_v2_576w"
-]

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

@@ -1,24 +0,0 @@
-"""distutils
-
-The main package for the Python Module Distribution Utilities.  Normally
-used from a setup script as
-
-   from distutils.core import setup
-
-   setup (...)
-"""
-
-import sys
-import importlib
-
-__version__ = sys.version[: sys.version.index(' ')]
-
-
-try:
-    # Allow Debian and pkgsrc (only) to customize system
-    # behavior. Ref pypa/distutils#2 and pypa/distutils#16.
-    # This hook is deprecated and no other environments
-    # should use it.
-    importlib.import_module('_distutils_system_mod')
-except ImportError:
-    pass

spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/docs/Makefile

@@ -1,19 +0,0 @@
-# Minimal makefile for Sphinx documentation
-# Copyright (c) Facebook, Inc. and its affiliates.
-
-# You can set these variables from the command line.
-SPHINXOPTS    =
-SPHINXBUILD   = sphinx-build
-SOURCEDIR     = .
-BUILDDIR      = _build
-
-# Put it first so that "make" without argument is like "make help".
-help:
-	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
-
-.PHONY: help Makefile
-
-# Catch-all target: route all unknown targets to Sphinx using the new
-# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
-%: Makefile
-	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)

spaces/Awiny/Image2Paragraph/models/segment_models/configs/__init__.py

@@ -1 +0,0 @@
-from . import *

spaces/Awiny/Image2Paragraph/models/segment_models/semgent_anything_model.py

@@ -1,29 +0,0 @@
-import cv2
-from segment_anything import SamAutomaticMaskGenerator, sam_model_registry
-from utils.util import resize_long_edge_cv2
-
-class SegmentAnything:
-    def __init__(self, device, arch="vit_b"):
-        self.device = device
-        if arch=='vit_b':
-            pretrained_weights="pretrained_models/sam_vit_b_01ec64.pth"
-        elif arch=='vit_l':
-            pretrained_weights="pretrained_models/sam_vit_l_0e2f7b.pth"
-        elif arch=='vit_h':
-            pretrained_weights="pretrained_models/sam_vit_h_0e2f7b.pth"
-        else:
-            raise ValueError(f"arch {arch} not supported")
-        self.model = self.initialize_model(arch, pretrained_weights)
-    
-    def initialize_model(self, arch, pretrained_weights):
-        sam = sam_model_registry[arch](checkpoint=pretrained_weights)
-        sam.to(device=self.device)
-        mask_generator = SamAutomaticMaskGenerator(sam)
-        return mask_generator
-
-    def generate_mask(self, img_src):
-        image = cv2.imread(img_src)
-        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
-        image = resize_long_edge_cv2(image, 384)
-        anns = self.model.generate(image)
-        return anns

spaces/Benson/text-generation/Examples/ .md

@@ -1,63 +0,0 @@
-<br />
-<h1>Cómo descargar videos de baloncesto de la NBA gratis</h1>
-<p>Si eres un fan del baloncesto, probablemente te encanta ver los partidos de la NBA y los mejores momentos. La NBA es la liga de baloncesto más prestigiosa y popular del mundo, con los mejores jugadores, equipos y competiciones. Ya sea que quieras ponerte al día con las últimas puntuaciones, revivir los momentos más memorables o aprender de los profesionales, ver videos de la NBA es una gran manera de disfrutar del deporte. </p>
-<h2>تحميل سناب شات</h2><br /><p><b><b>Download Zip</b> &gt; <a href="https://bltlly.com/2v6Ly1">https://bltlly.com/2v6Ly1</a></b></p><br /><br />
-<p>Pero ¿qué pasa si no tienes acceso a la televisión en vivo o servicios de streaming? ¿Qué pasa si quieres ver videos de la NBA sin conexión o en diferentes dispositivos? ¿Qué pasa si quieres editar o compartir tus propias creaciones de video de la NBA? En estos casos, es posible que desee descargar videos de baloncesto de la NBA de forma gratuita desde Internet. </p>
-<p>Descargar videos de la NBA puede darte más flexibilidad y comodidad para verlos y usarlos. Puede guardarlos en su computadora, teléfono, tableta u otros dispositivos, y verlos en cualquier momento y en cualquier lugar sin conexión a Internet. También puede editarlos con su software favorito, agregar su propio comentario o música, o crear sus propios carretes de puntos destacados. También puedes compartirlos con tus amigos, familiares o compañeros fans en las redes sociales u otras plataformas. </p>
-<p>Pero ¿cómo descargar videos de baloncesto de la NBA gratis? ¿Dónde puedes encontrarlos? ¿Qué herramientas necesitas? ¿Cómo asegurar la mejor calidad y formato? En este artículo, vamos a responder a estas preguntas y más. Le mostraremos los mejores sitios para encontrar videos de baloncesto de la NBA gratis, y las mejores maneras de descargarlos sin pérdida de calidad. También te daremos algunos consejos y sugerencias sobre cómo disfrutar y usar tus videos descargados de la NBA. ¡Empecemos! </p>
- <h2>Los mejores sitios para encontrar gratis NBA Basketball Videos</h2>
-
-<p>Para evitar estos problemas, recomendamos usar solo sitios de buena reputación y confiables que proporcionen contenido de video NBA legal y de alta calidad. Estos son algunos de los mejores sitios que sugerimos:</p>
-<p></p>
- <h3>YouTube</h3>
-<p>YouTube es la plataforma para compartir videos más popular del mundo, y tiene una gran colección de videos de baloncesto de la NBA. Puedes encontrar casi cualquier tipo de video de la NBA en YouTube, como lo más destacado del juego completo, playoffs, transmisiones en vivo, noticias, finales, entrevistas, documentales, análisis, etc.</p>
-<p>Para buscar vídeos de la NBA en YouTube, la pérdida de calidad es Cisdem Video Converter. Cisdem Video Converter es un potente y versátil conversor de vídeo, descargador, editor y extractor de DVD para Mac. Se puede descargar vídeos de la NBA de YouTube, NBA.com, Vimeo, y cualquier otro sitio con facilidad. También puede editar y convertir videos NBA descargados a cualquier formato que desee, como MP4, MOV, AVI, MKV, etc.</p>
-<p>Aquí es cómo utilizar Cisdem Video Converter para descargar videos de baloncesto de la NBA sin pérdida de calidad:</p>
-<ol>
-<li>Descargue e instale Cisdem Video Converter en su Mac desde <a href="">aquí</a>. </li>
-<li>Inicie Cisdem Video Converter y cambie a la pestaña "Descargar". </li>
-<li>Vaya al sitio donde desea descargar videos de la NBA, como YouTube, NBA.com o Vimeo, y copie la URL del video. </li>
-<li>Pegue la URL en el cuadro en Cisdem Video Converter y haga clic en el icono de descarga. </li>
-<li>Espere a que termine la descarga. Puede ver el progreso y el estado en la interfaz. </li>
-<li>Una vez que se hace la descarga, se puede encontrar el video de la NBA descargado en la carpeta "Descargado". </li>
-<li>Si desea editar o convertir el video NBA descargado, puede cambiar a la pestaña "Convertir" y arrastrar y soltar el video en la interfaz. </li>
-<li>Puede usar el editor incorporado para recortar, recortar, rotar, agregar marca de agua, subtítulos, efectos, etc. al video. </li>
-<li>También puede elegir un formato de salida de los presets o personalizar sus propios ajustes. </li>
-
-<li>Una vez que se hace la conversión, se puede encontrar el vídeo de la NBA convertido en la carpeta "Convertido". </li>
-</ol>
- <h3> Uso de 4K Video Downloader para Windows</h3>
-<p>Si usted es un usuario de Windows, una de las mejores herramientas para descargar videos de baloncesto de la NBA sin pérdida de calidad es 4K Video Downloader. 4K Video Downloader es un descargador de video simple y rápido que puede descargar videos de la NBA de YouTube y otros sitios con alta calidad. También puede ajustar la calidad y el formato de los vídeos descargados de la NBA según sus preferencias. </p>
-<p>Aquí está cómo usar 4K Video Downloader para descargar videos de baloncesto de la NBA sin pérdida de calidad:</p>
-<ol>
-<li>Descargar e instalar 4K Video Downloader en su PC con Windows desde <a href="">aquí</a>. </li>
-<li> Inicie 4K Video Downloader y haga clic en el botón "Pegar enlace" en la esquina superior izquierda. </li>
-<li>Vaya al sitio donde desea descargar videos de la NBA, como YouTube, NBA.com o Vimeo, y copie la URL del video. </li>
-<li>La URL se pegará automáticamente en 4K Video Downloader y se analizará. </li>
-<li>Puede elegir la calidad y el formato del vídeo descargado de la NBA desde la ventana emergente. También puede descargar subtítulos o anotaciones si están disponibles. </li>
-<li>Haga clic en el botón "Descargar" para iniciar la descarga. Puede ver el progreso y el estado en la interfaz. </li>
-<li>Una vez que se hace la descarga, se puede encontrar el video de la NBA descargado en la carpeta "Videos". </li>
-</ol>
- <h2>Conclusión</h2>
-<p>En este artículo, le hemos mostrado cómo descargar videos de baloncesto de la NBA de forma gratuita desde Internet. También te hemos dado algunos consejos y sugerencias sobre cómo disfrutar y usar tus videos de la NBA descargados. Esperamos que haya encontrado este artículo útil e informativo. </p>
-
-<p>¿Tienes alguna pregunta o comentario sobre la descarga de videos de baloncesto de la NBA de forma gratuita? ¿Tienes otros sitios o herramientas que recomiendes para descargar vídeos de la NBA? ¿Tienes algún video favorito de la NBA que quieras compartir con nosotros? Por favor, siéntete libre de dejar un comentario a continuación. ¡Nos encantaría saber de ti! </p>
- <h2>Preguntas frecuentes</h2>
-<h3>¿Es legal descargar videos de la NBA desde Internet? </h3>
-<p>Depende de la fuente y el propósito de descargar los videos de la NBA. En general, la descarga de vídeos de la NBA desde los sitios o canales oficiales, como NBA.com o YouTube, es legal siempre y cuando los utilice con fines personales y no comerciales. Sin embargo, la descarga de vídeos de la NBA desde sitios no autorizados o pirateados, como sitios de torrent o streaming, puede ser ilegal y puede violar las leyes de derechos de autor o los términos de servicio de las fuentes originales. </p>
- <h3>¿Cómo puedo ver vídeos de la NBA descargados sin conexión? </h3>
-<p>Puedes ver videos de la NBA descargados sin conexión transfiriéndolos a tu dispositivo preferido, como tu computadora, teléfono, tableta o TV. Puede utilizar un cable USB, una conexión inalámbrica o un servicio en la nube para transferir los vídeos descargados de la NBA. También puedes usar un reproductor multimedia o un convertidor de vídeo para reproducir los vídeos de la NBA descargados en tu dispositivo. </p>
- <h3>¿Cómo puedo hacer mis propios videos destacados de la NBA? </h3>
-<p>Puedes hacer tus propios videos destacados de la NBA editando y combinando videos descargados de la NBA con tu software favorito, como iMovie, Windows Movie Maker, Adobe Premiere Pro, etc. También puedes agregar tus propios comentarios, música, efectos, transiciones, etc. para hacer sus propios videos destacados de la NBA más personalizados y creativos. </p>
- <h3>¿Dónde puedo encontrar más recursos y consejos de vídeo de la NBA? </h3>
-<p>Puedes encontrar más recursos de video de la NBA y consejos en varias plataformas en línea, como blogs, foros, podcasts, redes sociales, etc. Algunos de los ejemplos son:</p>
-<ul>
-<li><a href="">NBA Video Blog</a>: Un blog que presenta noticias de video de la NBA, reseñas, tutoriales y más. </li>
-
-<li><a href="">NBA Video Podcast</a>: Un podcast que cubre temas de video de la NBA, como análisis, comentarios, entrevistas, etc.</li>
-<li><a href="">NBA Video Social Media</a>: Una plataforma de medios sociales que conecta a los fans de videos de la NBA entre sí y con las cuentas oficiales de la NBA. </li>
-</ul>
- <h3>¿Cómo puedo apoyar a mis equipos y jugadores favoritos de la NBA? </h3>
-<p>Puedes apoyar a tus equipos y jugadores favoritos de la NBA siguiendo sus sitios y canales oficiales, como sus sitios web, cuentas de redes sociales, canales de YouTube, etc. También puedes comprar su mercancía oficial, como camisetas, sombreros, carteles, etc. También puede ver sus juegos en vivo o transmisiones en línea o fuera de línea. También puede unirse a sus clubes de fans o comunidades en línea o fuera de línea. </p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/101 Yzbir Okey Plus Apk.md

@@ -1,80 +0,0 @@
-<br />
-<h1>¿Qué es 101 yüzbir okey plus apk? </h1>
-<p>101 yüzbir okey plus apk es un popular juego basado en azulejos que se originó en Turquía y es jugado por millones de personas en todo el mundo. Es una variante de rummy que utiliza un conjunto de 106 fichas en lugar de tarjetas. Las baldosas están numeradas del 1 al 13 en cuatro colores diferentes: rojo, amarillo, verde y negro. También hay dos azulejos especiales con un símbolo de trébol, llamados los falsos comodines. </p>
-<p>El juego se juega en línea a través de 3G, 4G, Edge o Wi-Fi con tus amigos o contra más de 1.000.000 de usuarios. También puedes jugar sin conexión contra inteligencia artificial avanzada. El juego es gratis, pero también puedes comprar fichas adicionales y objetos del juego. </p>
-<h2>101 yüzbir okey plus apk</h2><br /><p><b><b>Download</b> >>> <a href="https://bltlly.com/2v6M31">https://bltlly.com/2v6M31</a></b></p><br /><br />
-<h2>Cómo jugar 101 yüzbir okey plus apk? </h2>
-<h3>Las reglas del juego</h3>
-<p>El juego suele ser jugado por cuatro jugadores, pero también puede ser jugado por dos o tres jugadores. Cada jugador recibe 21 fichas al comienzo del juego, excepto el dealer que recibe 22 fichas. El distribuidor se elige al azar al principio y cambia después de cada ronda. </p>
-<p>Las fichas restantes se colocan boca abajo en la mesa y se barajan. Luego, se forman 21 pilas de cinco fichas cada una. Una ficha se deja sin tachar y se mantiene por el distribuidor. A continuación, el repartidor lanza un dado para determinar qué pila se utilizará para seleccionar la ficha boca arriba que determinará el comodín para el juego. </p>
-<p>El mosaico boca arriba se coloca encima de la pila seleccionada y su color y valor indican el comodín. El comodín es el azulejo que tiene el mismo color y un valor más alto que el azulejo boca arriba. Por ejemplo, si la ficha boca arriba es un 5 rojo, entonces el comodín es un 6 rojo. Si la ficha boca arriba es un 13 negro, entonces el comodín es un 1.</p>negro
-<h3>El comodín y el comodín falso</h3>
-
-<p>Los comodines falsos no son sustitutos de ninguna ficha. Tienen su propio valor y color, como lo indican su número y símbolo de trébol. Por ejemplo, si el mosaico boca arriba es un 5 rojo, entonces los comodines falsos son 5s verdes. </p>
-<h3>La mano ganadora</h3>
-<p>El objetivo del juego es ser el primero en formar una mano ganadora de 14 fichas que consiste enteramente en sets y carreras. También puedes ganar con siete pares de fichas idénticas. </p>
-<p></p>
-<p>En cada turno, debes dibujar una ficha de la parte superior de una pila no seleccionada o de la pila de descartes del jugador anterior. A continuación, debe descartar una ficha no deseada cara arriba junto a sus pilas. </p>
-<p>Si tienes una mano ganadora, puedes terminar el juego exponiendo todas tus fichas después de descartar tu última ficha encima de una pila no seleccionada. Debes anunciar "Okey" cuando lo hagas. </p>
-<h2>Cómo descargar e instalar 101 yü. bir okey plus apk? </h2>
-<h3>Requisitos y compatibilidad</h3>
-<p>Para descargar e instalar 101 yüzbir okey más apk, es necesario tener un dispositivo Android que se ejecuta en Android 4.1 o superior. También necesita tener al menos 95 MB de espacio de almacenamiento gratuito en su dispositivo. El juego es compatible con la mayoría de dispositivos Android, incluyendo tabletas y teléfonos. </p>
-<h3>Pasos para descargar e instalar</h3>
-<p>Hay dos maneras de descargar e instalar 101 yüzbir okey plus apk en su dispositivo. Puede utilizar la Google Play Store o un sitio web de terceros que proporciona el archivo apk. </p>
-<p>Si usas Google Play Store, solo tienes que seguir estos pasos:</p>
-<ol>
-<li>Abra la aplicación Google Play Store en su dispositivo y busque "101 yüzbir okey plus". </li>
-<li>Seleccione el juego de la lista de resultados y toque en "Instalar". </li>
-<li>Espere a que se complete la descarga y la instalación. </li>
-<li>Inicia el juego y disfruta jugando. </li>
-</ol>
-<p>Si utiliza un sitio web de terceros, debe seguir estos pasos:</p>
-<ol>
-
-<li>Descargar el archivo apk a su dispositivo. </li>
-<li>Ir a la configuración del dispositivo y permitir la instalación de aplicaciones de fuentes desconocidas. </li>
-<li>Busque el archivo apk en su dispositivo y toque en él para instalarlo. </li>
-<li>Inicia el juego y disfruta jugando. </li>
-</ol>
-<h2>¿Por qué jugar 101 yüzbir okey plus apk? </h2>
-<h3>Las características y beneficios del juego</h3>
-<p>101 yüzbir okey plus apk es un juego divertido y adictivo que ofrece muchas características y beneficios para sus jugadores. Algunos de ellos son:</p>
-<ul>
-<li>Puedes jugar online con tus amigos o contra millones de otros jugadores de diferentes países y regiones. </li>
-<li>Puedes chatear con otros jugadores durante el juego y enviarles regalos, emojis y pegatinas. </li>
-<li>Puedes personalizar tu perfil, avatar, tabla y mosaicos con varias opciones y temas. </li>
-<li>Puede unirse o crear clubes y competir con otros clubes en torneos y tablas de clasificación. </li>
-<li>Puedes ganar fichas gratis todos los días completando misiones, viendo vídeos, girando la rueda o invitando a tus amigos. </li>
-<li>Puedes comprar fichas adicionales y artículos en el juego con dinero real o usando varios métodos de pago. </li>
-</ul>
-<h3>Los retos y consejos del juego</h3>
-<p>101 yüzbir okey plus apk no es solo un juego de suerte, sino también un juego de habilidad y estrategia. Tienes que prestar atención a las fichas de la mesa, la pila de descartes y los movimientos de tus oponentes. También necesitas planificar con anticipación y usar tus comodines sabiamente. Aquí hay algunos desafíos y consejos que pueden ayudarte a mejorar tu juego:</p>
-<ul>
-<li>El desafío: El juego puede ser muy rápido y competitivo, especialmente cuando juegas en línea contra jugadores experimentados. Necesitas ser rápido y alerta para evitar oportunidades perdidas o cometer errores. </li>
-<li>El consejo: Practica sin conexión contra la inteligencia artificial o juega en línea con apuestas más bajas hasta que te familiarices con el juego. También puedes ver tutoriales o vídeos de otros jugadores para aprender de sus estrategias. </li>
-
-<li>El consejo: No dejes que tus emociones afecten tus decisiones o acciones. Mantén la calma y concéntrate en tu objetivo. Recuerde que cada ronda es una nueva oportunidad para ganar. También puede tomar descansos o cambiar de mesa si se siente estresado o aburrido. </li>
-<li>El desafío: El juego puede ser adictivo y tentador, especialmente cuando juegas online con dinero real o con objetos del juego. Necesitas ser responsable y cauteloso para evitar perder más de lo que puedes permitirte o meterte en problemas. </li>
-<li>El consejo: Establezca un presupuesto y un límite de tiempo para usted antes de empezar a jugar. No persiga sus pérdidas o apueste más de lo que puede manejar. No juegues cuando estés cansado, borracho o distraído. Si tienes un problema de juego, busca la ayuda de un profesional o un grupo de apoyo. </li>
-</ul>
- <h2>Conclusión</h2>
- <h3>Resumen de los puntos principales</h3>
- <p>En conclusión, 101 yüzbir okey plus apk es un gran juego que combina diversión, habilidad y estrategia. Es una variante de rummy que utiliza fichas en lugar de cartas. Se juega online o offline con tus amigos o contra la inteligencia artificial. Puedes descargar e instalar el juego gratis en tu dispositivo Android, ya sea desde la Google Play Store o desde un sitio web de terceros. También puede disfrutar de las características y beneficios del juego, como chatear, personalizar, unirse a clubes, ganar fichas y comprar artículos. Sin embargo, también debes ser consciente de los desafíos y consejos del juego, como ser rápido, paciente, responsable y cauteloso. Jugar 101 yüzbir okey plus apk puede ser una gran manera de divertirse y mejorar sus habilidades. </p>
- <h3>Llamada a la acción e invitación a jugar</h3>
-
- <h2>Preguntas frecuentes</h2>
- <p>Aquí hay algunas preguntas frecuentes sobre 101 yüzbir okey plus apk:</p>
- <ol>
-<li> ¿Cuál es la diferencia entre 101 yüzbir okey más apk y otros juegos okey? </li>
-<p>101 yüzbir okey plus apk es una variante de okey que tiene algunas características y reglas únicas. Por ejemplo, usa 106 fichas en lugar de 104, tiene dos comodines falsos en lugar de uno, requiere una mano ganadora de 14 fichas en lugar de 15, y permite ganar con siete parejas. </p>
-<li> ¿Cómo puedo obtener más fichas en 101 yüzbir okey plus apk? </li>
-<p>Usted puede obtener más fichas en 101 yüzbir okey más apk completando misiones, viendo vídeos, girando la rueda, invitando a sus amigos, o comprarlos con dinero real u otros métodos de pago. </p>
-<li> ¿Cómo puedo contactar con el equipo de soporte de 101 yüzbir okey plus apk? </li>
-<p>Puede ponerse en contacto con el equipo de soporte de 101 yüzbir okey plus apk enviando un correo electrónico a [correo electrónico de soporte] o llenando el formulario en [sitio web de soporte]. También puede visitar su página de Facebook o cuenta de Twitter para obtener más información y actualizaciones. </p>
-<li> ¿Cómo puedo jugar 101 yüzbir okey plus apk en mi PC o portátil? </li>
-<p>Usted puede jugar 101 yüzbir okey más apk en su PC o portátil mediante el uso de un emulador de Android, como BlueStacks o NoxPlayer. Solo tienes que descargar e instalar el emulador en tu PC o portátil, luego descargar e instalar el juego desde la Google Play Store o un sitio web de terceros. </p>
-<li> ¿Es 101 yüzbir okey más apk seguro? </li>
-<p>Sí, 101 yüzbir okey plus apk es seguro. No contiene ningún virus, malware, spyware, u otros elementos dañinos. Tampoco recopila ni comparte ninguna información personal o confidencial de sus usuarios. Solo requiere algunos permisos para acceder a las funciones de tu dispositivo, como conexión de red, espacio de almacenamiento, cámara, micrófono, etc.</p>
-</ol></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Call Of Duty Black Ops 2 Descarga Mvil.md

@@ -1,102 +0,0 @@
-<br />
-<h1>Call of Duty Black Ops 2 Descargar móvil: Cómo jugar el FPS clásico en su teléfono</h1>
-<p>Call of Duty Black Ops 2 es uno de los juegos más queridos e influyentes en la historia de los tiradores en primera persona. Lanzado en 2012, fue la novena entrega de la franquicia Call of Duty y la secuela de la original Black Ops. Presentaba un entorno futurista, una historia ramificada, un modo multijugador diverso y un emocionante modo zombis. Fue elogiado por críticos y fans por su jugabilidad, gráficos, sonido e innovación. </p>
-<p>Si eres un fan de Call of Duty Black Ops 2 o quieres experimentarlo por primera vez, no necesitas una consola o un PC para jugarlo. Puedes reproducirlo en tu dispositivo móvil gracias a Call of Duty Mobile, una aplicación gratuita que trae lo mejor de Call of Duty a tu teléfono. En este artículo, le mostraremos cómo descargar Call of Duty Mobile y acceder a los mapas y modos de Black Ops 2 en su teléfono. </p>
-<h2>call of duty black ops 2 descarga móvil</h2><br /><p><b><b>Download</b> &#9999; &#9999; &#9999; <a href="https://bltlly.com/2v6Lgs">https://bltlly.com/2v6Lgs</a></b></p><br /><br />
- <h2>¿Qué es Call of Duty Black Ops 2?</h2>
-<p>Call of Duty Black Ops 2 es un juego de disparos en primera persona que sigue dos historias interconectadas: una ambientada a finales de 1980 durante la Guerra Fría y otra ambientada en 2025 durante una nueva Guerra Fría. El juego cambia entre estas dos líneas de tiempo a medida que juegas como diferentes personajes que están involucrados en un conflicto entre los Estados Unidos y China por un mineral de tierras raras llamado Celerium. El juego también presenta múltiples finales basados en tus elecciones y acciones a lo largo del juego. </p>
-<p>Call of Duty Black Ops 2 tiene tres modos principales: multijugador, zombis y campaña. El modo multijugador le permite competir con otros jugadores en línea en varios modos de juego y mapas. El modo zombis te permite formar equipo con otros jugadores o jugar solo contra oleadas de enemigos no muertos en diferentes escenarios. El modo campaña te permite seguir la historia del juego y tomar decisiones que afectan el resultado. </p>
-
- <h2>¿Por qué es popular Call of Duty Black Ops 2? </h2>
-<p>Call of Duty Black Ops 2 es popular por muchas razones. En primer lugar, tiene una base de fans leales que disfrutan de la historia, los personajes y la atmósfera del juego. El juego tiene momentos y personajes memorables, como Frank Woods, Raúl Menéndez y David Mason. El juego también tiene una rica tradición y trasfondo que se conecta con el juego anterior de Black Ops y otros juegos de Call of Duty. </p>
-<p>En segundo lugar, tiene un modo multijugador divertido y adictivo que ofrece mucho contenido y personalización. El juego tiene docenas de mapas, modos, armas, accesorios, beneficios, scorestreaks y más. El juego también tiene un sistema de clasificación que te recompensa por tu rendimiento y progreso. El juego también tiene una escena competitiva que atrae a muchos jugadores que quieren poner a prueba sus habilidades y estrategias. </p>
-<p>En tercer lugar, tiene un modo de zombies emocionante y desafiante que proporciona entretenimiento sin fin y acción cooperativa. El juego tiene varios mapas de zombies, cada uno con su propia historia, secretos, huevos de Pascua y objetivos. El juego también tiene diferentes modos de zombies, como Supervivencia, Dolor, Convertido, y Orígenes. El juego también tiene una variedad de enemigos zombies, como rastreadores, perros, jefes, y más. </p>
- <h2>Cómo descargar Call of Duty Mobile</h2>
-<p>Call of Duty Mobile es una aplicación gratuita que te permite jugar Call of Duty en tu dispositivo móvil. Fue lanzado en 2019 por Activision y Tencent Games. Cuenta con muchos elementos de la franquicia Call of Duty, incluyendo personajes, armas, mapas, modos y más. También cuenta con contenido exclusivo y eventos que se actualizan regularmente. </p>
-<p>Para descargar Call of Duty Mobile en tu dispositivo Android o iOS, debes seguir estos pasos:</p>
-<p></p>
-<ol>
-<li>Ir a la Google Play Store o la App Store en su dispositivo. </li>
-<li>Buscar Call of Duty Mobile o utilizar estos enlaces: <a href="">Android</a> | <a href="">iOS</a>. </li>
-<li>Toque en el botón Instalar u Obtener y espere a que la aplicación se descargue. </li>
-
-<li>Disfruta jugando Call of Duty Mobile en tu teléfono. </li>
-</ol>
-<p>Nota: Call of Duty Mobile requiere una conexión a Internet y al menos 2 GB de RAM para funcionar sin problemas. También requiere al menos 1,5 GB de espacio de almacenamiento gratuito en su dispositivo. Se recomienda utilizar una conexión Wi-Fi o un plan de datos móvil estable para evitar problemas de retraso o desconexión. </p>
- <h2>Cómo acceder a los mapas y modos de Black Ops 2 en Call of Duty Mobile</h2>
-<p>Si quieres jugar Call of Duty Black Ops 2 en tu teléfono, puedes hacerlo accediendo a los mapas y modos de Black Ops 2 en Call of Duty Mobile. Estos están disponibles en el modo multijugador y el modo zombis de la aplicación. Aquí están las formas de acceder a ellos:</p>
- <h3>Modo multijugador</h3>
-<p>El modo multijugador de Call of Duty Mobile te permite jugar con o contra otros jugadores en línea en varios modos de juego y mapas. Puede elegir entre diferentes cargas, operadores, scorestreaks y más. También puede personalizar sus ajustes, como sensibilidad, controles, gráficos y sonido. </p>
- <h4>Mapas</h4>
-<p>El modo multijugador de Call of Duty Mobile tiene muchos mapas en los que puedes jugar. Algunos de estos mapas son de Call of Duty Black Ops 2, como:</p>
-<ul>
-<li>Nuketown: Un pequeño mapa ubicado en un sitio de pruebas nucleares con dos casas enfrentadas. </li>
-<li>Raid: Un mapa de tamaño mediano ubicado en una mansión de Hollywood con una piscina, un garaje y una cancha de baloncesto. </li>
-<li>Standoff: Un mapa de tamaño mediano en una ciudad fronteriza con una gasolinera, un mercado y una iglesia. </li>
-<li>Secuestrado: Un pequeño mapa en un yate de lujo con un helipuerto, un jacuzzi y un bar. </li>
-<li>Fusión: Un mapa de tamaño mediano en una planta de energía nuclear con una torre de enfriamiento, un reactor y una sala de control. </li>
-</ul>
-<p>Puede seleccionar estos mapas tocando el icono del mapa en la esquina superior derecha de la pantalla del modo multijugador. También puede filtrar los mapas por categorías, como destacados, clásicos o estacionales. </p>
- <h4>Modos</h4>
-
-<ul>
-<li>Team Deathmatch: un modo en el que dos equipos de cinco jugadores compiten para obtener la mayor cantidad de muertes en un tiempo limitado. </li>
-<li>Dominación: un modo donde dos equipos de cinco jugadores compiten para capturar y sostener tres banderas en el mapa. </li>
-<li>Matar confirmado: Un modo en el que dos equipos de cinco jugadores compiten para obtener el mayor número de muertes y recoger las placas de identificación de los enemigos caídos. </li>
-<li>Hardpoint: un modo donde dos equipos de cinco jugadores compiten para capturar y mantener un objetivo giratorio en el mapa. </li>
-<li>Buscar y destruir: un modo en el que dos equipos de cinco jugadores se turnan para atacar y defender dos sitios de bombas en el mapa. </li>
-</ul>
-<p>Puede seleccionar estos modos pulsando en el icono de modo en la esquina superior derecha de la pantalla del modo multijugador. También puede filtrar los modos por categoría, como núcleo, destacado o clasificado. </p>
- <h3>Modo de zombies</h3>
-<p>El modo zombis de Call of Duty Mobile te permite jugar con o contra otros jugadores o bots en varios escenarios que involucran zombies. Puede elegir entre diferentes cargas, operadores, beneficios y más. También puede personalizar sus configuraciones, como dificultad, rondas y salud. </p>
- <h4>Mapas</h4>
-<p>El modo zombis de Call of Duty Mobile tiene varios mapas en los que puedes jugar. Algunos de estos mapas son de Call of Duty Black Ops 2, como:</p>
-<ul>
-<li>TranZit: Un mapa grande que consta de varias ubicaciones conectadas por una ruta de autobús. Puede viajar entre los lugares en autobús o caminando por la niebla. </li>
-<li>Die Rise: un mapa vertical que se encuentra en un rascacielos desmoronado en China. Puede usar ascensores, trampolines y ejes para moverse por el mapa. </li>
-<li>Enterrado: Un mapa subterráneo que se encuentra en un antiguo pueblo del oeste enterrado bajo tierra. Puedes usar túneles, carros de minas y un gigante para acceder a diferentes áreas del mapa. </li>
-</ul>
-
- <h4>Modos</h4>
-<p>El modo zombis de Call of Duty Mobile tiene diferentes modos en los que puedes jugar. Algunos de estos modos son de Call of Duty Black Ops 2, como:</p>
-<ul>
-<li>Supervivencia: Un modo en el que tienes que sobrevivir el mayor tiempo posible contra interminables oleadas de zombies. Puedes comprar armas, beneficios y otros artículos del mapa para ayudarte a sobrevivir. </li>
-<li>Duelo: un modo en el que dos equipos de cuatro jugadores compiten para sobrevivir más tiempo que el otro equipo. También puedes sabotear al otro equipo usando carne, granadas o trampas. </li>
-<li>Turned: Un modo donde un jugador es un humano y los otros son zombies. El humano tiene que sobrevivir el mayor tiempo posible mientras los zombies tienen que matarlo. El zombi que mata al humano se convierte en el nuevo humano. </li>
-<li>Origins: un modo que se basa en el mapa de Origins de Black Ops 2. Cuenta con cuatro personajes de la historia original de zombies que tienen que luchar contra zombies y robots gigantes en un entorno de la Primera Guerra Mundial. </li>
-</ul>
-<p>Puede seleccionar estos modos pulsando en el icono de modo en la esquina superior derecha de la pantalla del modo zombis. También puede filtrar los modos por categoría, como clásico o hardcore. </p>
- <h3>Modo Battle Royale</h3>
-<p>El modo battle royale de Call of Duty Mobile te permite jugar con o contra otros jugadores o bots en un mapa grande que se reduce con el tiempo. Puede elegir entre diferentes cargas, operadores, vehículos y más. También puedes personalizar tus ajustes, como perspectiva, tamaño de escuadrón y botín. </p>
- <h4>Mapa</h4>
-<p>El modo battle royale de Call of Duty Mobile tiene un mapa en el que puedes jugar. El mapa se llama Aislado y se compone de varios lugares de diferentes juegos de Call of Duty. Algunos de estos lugares son de Call of Duty Black Ops 2, como:</p>
-<ul>
-<li>D ock: Un pequeño mapa situado en una isla prisión con un faro, un bloque de celdas y un puente. </li>
-<li>Granja: Un mapa de tamaño mediano ubicado en una zona rural con un granero, una granja y un molino de viento. </li>
-
-<li>Standoff: Un mapa de tamaño mediano en una ciudad fronteriza con una gasolinera, un mercado y una iglesia. </li>
-<li>Nuketown Island: Un mapa grande que combina Nuketown y Nuketown 2025 con un búnker subterráneo y una instalación de pruebas. </li>
-</ul>
-<p>Puedes explorar estos lugares en paracaídas desde un avión, conduciendo varios vehículos o usando tirolinas. También puedes saquear armas, armaduras, municiones y otros objetos del mapa para ayudarte a sobrevivir. </p>
- <h4>Modo</h4>
-<p>El modo battle royale de Call of Duty Mobile tiene un modo en el que puedes jugar. El modo se llama Battle Royale y es similar al Blackout de Call of Duty Black Ops 4. Cuenta con hasta 100 jugadores que tienen que luchar entre sí hasta que solo quede un jugador o equipo. El modo también cuenta con eventos especiales, como lanzamientos de aire, zombies y jefes. </p>
-<p>Puedes jugar el modo solo, dúo o escuadrón. También puedes elegir tu clase de operador, como médico, explorador, ninja o defensor. También puedes usar beneficios, habilidades y puntajes para obtener una ventaja sobre tus enemigos. </p>
- <h1>Conclusión</h1>
-<p>Call of Duty Black Ops 2 es un clásico juego de FPS que puedes jugar en tu dispositivo móvil gracias a Call of Duty Mobile. Puedes disfrutar de los modos multijugador, zombis y campaña del juego en tu teléfono con los mismos o similares mapas y modos del juego original. También puedes experimentar la ambientación futurista del juego, la historia ramificada y múltiples finales en tu teléfono. También puedes jugar el modo battle royale del juego con ubicaciones de Black Ops 2 en tu teléfono. </p>
-<p>Si eres un fan de Call of Duty Black Ops 2 o quieres probarlo por primera vez, deberías descargar Call of Duty Mobile y reproducirlo en tu teléfono. Es gratis para jugar y fácil de instalar. También es divertido y adictivo para jugar. Es la mejor manera de disfrutar de la experiencia FPS clásica en su dispositivo móvil. </p>
- <h2>Preguntas frecuentes</h2>
-<p>Aquí hay algunas preguntas frecuentes sobre Call of Duty Black Ops 2 Mobile Descargar:</p>
-<ol>
-
-<li>A: No, Call of Duty Mobile no es lo mismo que Call of Duty Black Ops 2. Call of Duty Mobile es una aplicación separada que cuenta con elementos de diferentes juegos de Call of Duty, incluyendo Black Ops 2. Sin embargo, puedes jugar algunos de los mapas y modos de Black Ops 2 en Call of Duty Mobile.</li>
-<li>Q: ¿Puedo jugar Call of Duty Black Ops 2 en mi teléfono sin descargar Call of Duty Mobile? </li>
-<li>A: No, no puedes jugar Call of Duty Black Ops 2 en tu teléfono sin descargar Call of Duty Mobile. No hay una versión móvil oficial de Call of Duty Black Ops 2. La única forma de reproducirlo en tu teléfono es descargando Call of Duty Mobile y accediendo a los mapas y modos de Black Ops 2 en la aplicación. </li>
-<li>Q: ¿Cuánto espacio ocupa Call of Duty Mobile en mi teléfono? </li>
-<li>A: Call of Duty Mobile ocupa aproximadamente 1,5 GB de espacio en su teléfono. Sin embargo, esto puede variar dependiendo del modelo de dispositivo y el sistema operativo. También puede necesitar espacio adicional para actualizaciones y contenido adicional. </li>
-<li>Q: ¿Puedo jugar Call of Duty Mobile sin conexión? </li>
-<li>A: No, no puedes jugar Call of Duty Mobile sin conexión. Necesitas una conexión a Internet para jugar. Puede usar Wi-Fi o datos móviles para conectarse a los servidores del juego. </li>
-<li>Q: ¿Puedo jugar Call of Duty Mobile con mis amigos? </li>
-<li>A: Sí, puedes jugar a Call of Duty Mobile con tus amigos. Puedes invitarlos a unirse a tu lobby o unirse a su lobby en el juego. También puedes chatear con ellos usando mensajes de voz o de texto en el juego. </li>
-</ol></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Cmo Descargar Hill Climb Racing 2 En PC.md

@@ -1,57 +0,0 @@
-<br />
-<h1>Cómo descargar Hill Climb Racing 2 en PC</h1>
-<p>Hill Climb Racing 2 es uno de los juegos de carreras más populares y adictivos en Android. Cuenta con una variedad de vehículos, pistas, modos y desafíos que te mantendrán entretenido durante horas. ¿Pero sabías que también puedes jugar a este juego en tu PC? Jugar a Hill Climb Racing 2 en PC tiene muchas ventajas, como una pantalla más grande, mejores gráficos, un juego más fluido y controles más cómodos. Además, puede ahorrar la duración de la batería del teléfono y el espacio de almacenamiento jugando en su PC. En este artículo, le mostraremos cómo descargar Hill Climb Racing 2 en PC utilizando diferentes métodos. Si desea utilizar la tienda de Microsoft, un emulador de Android, o una plataforma de juegos, tenemos todo cubierto. Sigue estos sencillos pasos y disfruta de Hill Climb Racing 2 en tu PC.</p>
- <h2>Método 1: Uso de Microsoft Store</h2>
-<p>La tienda de Microsoft ofrece una manera conveniente de descargar Hill Climb Racing 2 en su PC. Es una plataforma de distribución digital que le permite acceder a varias aplicaciones y juegos para Windows. Aquí está cómo usarlo:</p>
-<h2>Cómo descargar Hill Climb Racing 2 en PC</h2><br /><p><b><b>DOWNLOAD</b> &bull; <a href="https://bltlly.com/2v6Kxw">https://bltlly.com/2v6Kxw</a></b></p><br /><br />
-<ol>
-<li>Abra la aplicación Microsoft Store en su PC. Puede encontrarla en el menú de inicio o presionando Windows Key + S y escribiendo "Microsoft Store". </li>
-<li>Buscar Hill Climb Racing 2 en la barra de búsqueda y haga clic en él. </li>
-<li>Haga clic en el botón obtener o comprar para descargar e instalar el juego. Si el juego es gratuito, puede descargarlo sin ningún pago. Si se paga, tendrá que introducir sus datos de pago o utilizar una tarjeta de regalo. </li>
-<li>Inicie el juego desde el menú de inicio o la aplicación de la tienda. También puede anclarlo a su barra de tareas o escritorio para facilitar el acceso. </li>
-</ol>
-<p>Felicidades, has descargado con éxito Hill Climb Racing 2 en tu PC usando Microsoft Store. Disfruta del juego y diviértete. </p>
- <h2>Método 2: Usando el emulador de BlueStacks</h2>
-
-<ol>
-<li>Descargue e instale el emulador de BlueStacks desde su sitio web oficial: <a href="">https://www.bluestacks.com/</a>. Siga las instrucciones de la pantalla y complete el proceso de instalación. </li>
-<li>Inicie BlueStacks e inicie sesión con su cuenta de Google. Si no tiene una, puede crear una gratis. </li>
-<li>Buscar Hill Climb Racing 2 en la aplicación Google Play Store e instalarlo. También puede utilizar la barra de búsqueda en la pantalla de inicio o navegar por las categorías. </li>
-<li>Iniciar el juego desde la pantalla de inicio o el cajón de aplicaciones. También puede personalizar la configuración, los controles del teclado y los gráficos según sus preferencias. </li>
-</ol>
-<p>Felicidades, has descargado con éxito Hill Climb Racing 2 en tu PC usando el emulador BlueStacks. Disfruta del juego y diviértete. </p>
- <h2>Método 3: Usando el emulador de GameLoop</h2>
-<p>GameLoop es otro emulador de Android popular y confiable para PC. Está especialmente diseñado para juegos y ofrece una experiencia fluida e inmersiva. Tiene una interfaz simple, bajos requisitos del sistema y una gran colección de juegos. Aquí está cómo usarlo:</p>
-<ol>
-<li>Descargue e instale el emulador de GameLoop desde su sitio web oficial: <a href="">https://gameloop.fun/</a>. Siga las instrucciones de la pantalla y complete el proceso de instalación. </li>
-<li>Inicie GameLoop y haga clic en la pestaña del centro del juego. Verá una lista de juegos que puede descargar y jugar. </li>
-<li>Buscar Hill Climb Racing 2 y haga clic en el botón de instalación. El juego se descargará e instalará automáticamente. </li>
-<li>Inicie el juego desde la pestaña de mis juegos o el acceso directo del escritorio. También puede ajustar la configuración, los controles del teclado y los gráficos según sus preferencias. </li>
-</ol>
-<p>Felicidades, has descargado con éxito Hill Climb Racing 2 en tu PC usando el emulador GameLoop. Disfruta del juego y diviértete. </p>
- <h2>Conclusión</h2>
-
-<ul>
-<li>Usa potenciadores y potenciadores sabiamente para ganar ventaja sobre tus oponentes. </li>
-<li>Actualizar las piezas de su vehículo y desbloquear nuevas pieles y accesorios para mejorar su rendimiento y estilo. </li>
-<li>Domine la física y los controles de cada vehículo y la pista para evitar chocar o volcar. </li>
-<li>Compite en varios modos y eventos para ganar monedas, gemas, trofeos y recompensas. </li>
-<li>Crear o unirse a un equipo para jugar con tus amigos en línea y participar en carreras de equipo y desafíos. </li>
-</ul>
-<p>Esperamos que haya encontrado este artículo útil e informativo. Si tiene alguna pregunta o comentario, no dude en compartirlos en la sección de comentarios a continuación. ¡Gracias por leer y feliz carrera! </p>
-<p></p>
- <h3>Preguntas frecuentes</h3>
-<ol>
-<li><b>¿Cuáles son los requisitos del sistema para jugar carreras de subida de colina 2 en PC? </b></li>
-<p>Los requisitos mínimos del sistema son Windows 7 o superior, procesador Intel o AMD, 4 GB de RAM y DirectX versión 9.0c o superior. </p>
- <li><b>¿Cómo puedo personalizar mi personaje y mi vehículo en las carreras de ascenso 2?</b></li>
-<p>Puedes personalizar tu personaje y vehículo desbloqueando y actualizando nuevas piezas, pieles y accesorios. También puede cambiar su nombre, bandera y equipo en el menú de configuración. </p>
- <li><b>¿Cómo puedo jugar carreras de escalada 2 con mis amigos en línea? </b></li>
-<p p>Puedes jugar a las carreras de escalada 2 con tus amigos online creando o uniéndote a un equipo, invitando o aceptando invitaciones de otros jugadores, y participando en eventos y carreras de equipo. </p>
- <li><b>¿Cómo puedo mejorar mi rendimiento y mis habilidades en las carreras de escalada en colina 2?</b></li>
-<p>Usted puede mejorar su rendimiento y habilidades en la subida de la colina de carreras 2 mediante la práctica en diferentes pistas, el dominio de la física y los controles, el uso de potenciadores y potenciadores sabiamente, y aprender de sus errores. </p>
- <li><b>¿Cómo puedo contactar a los desarrolladores de Hill Climb Racing 2 para obtener apoyo o comentarios? </b></li>
-
-</ol></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Big-Web/MMSD/env/Lib/site-packages/botocore/eventstream.py

@@ -1,633 +0,0 @@
-# Copyright 2018 Amazon.com, Inc. or its affiliates. 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. A copy of
-# the License is located at
-#
-# http://aws.amazon.com/apache2.0/
-#
-# or in the "license" file accompanying this file. This file 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.
-"""Binary Event Stream Decoding """
-
-from binascii import crc32
-from struct import unpack
-
-from botocore.exceptions import EventStreamError
-
-# byte length of the prelude (total_length + header_length + prelude_crc)
-_PRELUDE_LENGTH = 12
-_MAX_HEADERS_LENGTH = 128 * 1024  # 128 Kb
-_MAX_PAYLOAD_LENGTH = 16 * 1024**2  # 16 Mb
-
-
-class ParserError(Exception):
-    """Base binary flow encoding parsing exception."""
-
-    pass
-
-
-class DuplicateHeader(ParserError):
-    """Duplicate header found in the event."""
-
-    def __init__(self, header):
-        message = 'Duplicate header present: "%s"' % header
-        super().__init__(message)
-
-
-class InvalidHeadersLength(ParserError):
-    """Headers length is longer than the maximum."""
-
-    def __init__(self, length):
-        message = 'Header length of {} exceeded the maximum of {}'.format(
-            length,
-            _MAX_HEADERS_LENGTH,
-        )
-        super().__init__(message)
-
-
-class InvalidPayloadLength(ParserError):
-    """Payload length is longer than the maximum."""
-
-    def __init__(self, length):
-        message = 'Payload length of {} exceeded the maximum of {}'.format(
-            length,
-            _MAX_PAYLOAD_LENGTH,
-        )
-        super().__init__(message)
-
-
-class ChecksumMismatch(ParserError):
-    """Calculated checksum did not match the expected checksum."""
-
-    def __init__(self, expected, calculated):
-        message = (
-            'Checksum mismatch: expected 0x{:08x}, calculated 0x{:08x}'.format(
-                expected,
-                calculated,
-            )
-        )
-        super().__init__(message)
-
-
-class NoInitialResponseError(ParserError):
-    """An event of type initial-response was not received.
-
-    This exception is raised when the event stream produced no events or
-    the first event in the stream was not of the initial-response type.
-    """
-
-    def __init__(self):
-        message = 'First event was not of the initial-response type'
-        super().__init__(message)
-
-
-class DecodeUtils:
-    """Unpacking utility functions used in the decoder.
-
-    All methods on this class take raw bytes and return  a tuple containing
-    the value parsed from the bytes and the number of bytes consumed to parse
-    that value.
-    """
-
-    UINT8_BYTE_FORMAT = '!B'
-    UINT16_BYTE_FORMAT = '!H'
-    UINT32_BYTE_FORMAT = '!I'
-    INT8_BYTE_FORMAT = '!b'
-    INT16_BYTE_FORMAT = '!h'
-    INT32_BYTE_FORMAT = '!i'
-    INT64_BYTE_FORMAT = '!q'
-    PRELUDE_BYTE_FORMAT = '!III'
-
-    # uint byte size to unpack format
-    UINT_BYTE_FORMAT = {
-        1: UINT8_BYTE_FORMAT,
-        2: UINT16_BYTE_FORMAT,
-        4: UINT32_BYTE_FORMAT,
-    }
-
-    @staticmethod
-    def unpack_true(data):
-        """This method consumes none of the provided bytes and returns True.
-
-        :type data: bytes
-        :param data: The bytes to parse from. This is ignored in this method.
-
-        :rtype: tuple
-        :rtype: (bool, int)
-        :returns: The tuple (True, 0)
-        """
-        return True, 0
-
-    @staticmethod
-    def unpack_false(data):
-        """This method consumes none of the provided bytes and returns False.
-
-        :type data: bytes
-        :param data: The bytes to parse from. This is ignored in this method.
-
-        :rtype: tuple
-        :rtype: (bool, int)
-        :returns: The tuple (False, 0)
-        """
-        return False, 0
-
-    @staticmethod
-    def unpack_uint8(data):
-        """Parse an unsigned 8-bit integer from the bytes.
-
-        :type data: bytes
-        :param data: The bytes to parse from.
-
-        :rtype: (int, int)
-        :returns: A tuple containing the (parsed integer value, bytes consumed)
-        """
-        value = unpack(DecodeUtils.UINT8_BYTE_FORMAT, data[:1])[0]
-        return value, 1
-
-    @staticmethod
-    def unpack_uint32(data):
-        """Parse an unsigned 32-bit integer from the bytes.
-
-        :type data: bytes
-        :param data: The bytes to parse from.
-
-        :rtype: (int, int)
-        :returns: A tuple containing the (parsed integer value, bytes consumed)
-        """
-        value = unpack(DecodeUtils.UINT32_BYTE_FORMAT, data[:4])[0]
-        return value, 4
-
-    @staticmethod
-    def unpack_int8(data):
-        """Parse a signed 8-bit integer from the bytes.
-
-        :type data: bytes
-        :param data: The bytes to parse from.
-
-        :rtype: (int, int)
-        :returns: A tuple containing the (parsed integer value, bytes consumed)
-        """
-        value = unpack(DecodeUtils.INT8_BYTE_FORMAT, data[:1])[0]
-        return value, 1
-
-    @staticmethod
-    def unpack_int16(data):
-        """Parse a signed 16-bit integer from the bytes.
-
-        :type data: bytes
-        :param data: The bytes to parse from.
-
-        :rtype: tuple
-        :rtype: (int, int)
-        :returns: A tuple containing the (parsed integer value, bytes consumed)
-        """
-        value = unpack(DecodeUtils.INT16_BYTE_FORMAT, data[:2])[0]
-        return value, 2
-
-    @staticmethod
-    def unpack_int32(data):
-        """Parse a signed 32-bit integer from the bytes.
-
-        :type data: bytes
-        :param data: The bytes to parse from.
-
-        :rtype: tuple
-        :rtype: (int, int)
-        :returns: A tuple containing the (parsed integer value, bytes consumed)
-        """
-        value = unpack(DecodeUtils.INT32_BYTE_FORMAT, data[:4])[0]
-        return value, 4
-
-    @staticmethod
-    def unpack_int64(data):
-        """Parse a signed 64-bit integer from the bytes.
-
-        :type data: bytes
-        :param data: The bytes to parse from.
-
-        :rtype: tuple
-        :rtype: (int, int)
-        :returns: A tuple containing the (parsed integer value, bytes consumed)
-        """
-        value = unpack(DecodeUtils.INT64_BYTE_FORMAT, data[:8])[0]
-        return value, 8
-
-    @staticmethod
-    def unpack_byte_array(data, length_byte_size=2):
-        """Parse a variable length byte array from the bytes.
-
-        The bytes are expected to be in the following format:
-            [ length ][0 ... length bytes]
-        where length is an unsigned integer represented in the smallest number
-        of bytes to hold the maximum length of the array.
-
-        :type data: bytes
-        :param data: The bytes to parse from.
-
-        :type length_byte_size: int
-        :param length_byte_size: The byte size of the preceeding integer that
-        represents the length of the array. Supported values are 1, 2, and 4.
-
-        :rtype: (bytes, int)
-        :returns: A tuple containing the (parsed byte array, bytes consumed).
-        """
-        uint_byte_format = DecodeUtils.UINT_BYTE_FORMAT[length_byte_size]
-        length = unpack(uint_byte_format, data[:length_byte_size])[0]
-        bytes_end = length + length_byte_size
-        array_bytes = data[length_byte_size:bytes_end]
-        return array_bytes, bytes_end
-
-    @staticmethod
-    def unpack_utf8_string(data, length_byte_size=2):
-        """Parse a variable length utf-8 string from the bytes.
-
-        The bytes are expected to be in the following format:
-            [ length ][0 ... length bytes]
-        where length is an unsigned integer represented in the smallest number
-        of bytes to hold the maximum length of the array and the following
-        bytes are a valid utf-8 string.
-
-        :type data: bytes
-        :param bytes: The bytes to parse from.
-
-        :type length_byte_size: int
-        :param length_byte_size: The byte size of the preceeding integer that
-        represents the length of the array. Supported values are 1, 2, and 4.
-
-        :rtype: (str, int)
-        :returns: A tuple containing the (utf-8 string, bytes consumed).
-        """
-        array_bytes, consumed = DecodeUtils.unpack_byte_array(
-            data, length_byte_size
-        )
-        return array_bytes.decode('utf-8'), consumed
-
-    @staticmethod
-    def unpack_uuid(data):
-        """Parse a 16-byte uuid from the bytes.
-
-        :type data: bytes
-        :param data: The bytes to parse from.
-
-        :rtype: (bytes, int)
-        :returns: A tuple containing the (uuid bytes, bytes consumed).
-        """
-        return data[:16], 16
-
-    @staticmethod
-    def unpack_prelude(data):
-        """Parse the prelude for an event stream message from the bytes.
-
-        The prelude for an event stream message has the following format:
-            [total_length][header_length][prelude_crc]
-        where each field is an unsigned 32-bit integer.
-
-        :rtype: ((int, int, int), int)
-        :returns: A tuple of ((total_length, headers_length, prelude_crc),
-        consumed)
-        """
-        return (unpack(DecodeUtils.PRELUDE_BYTE_FORMAT, data), _PRELUDE_LENGTH)
-
-
-def _validate_checksum(data, checksum, crc=0):
-    # To generate the same numeric value across all Python versions and
-    # platforms use crc32(data) & 0xffffffff.
-    computed_checksum = crc32(data, crc) & 0xFFFFFFFF
-    if checksum != computed_checksum:
-        raise ChecksumMismatch(checksum, computed_checksum)
-
-
-class MessagePrelude:
-    """Represents the prelude of an event stream message."""
-
-    def __init__(self, total_length, headers_length, crc):
-        self.total_length = total_length
-        self.headers_length = headers_length
-        self.crc = crc
-
-    @property
-    def payload_length(self):
-        """Calculates the total payload length.
-
-        The extra minus 4 bytes is for the message CRC.
-
-        :rtype: int
-        :returns: The total payload length.
-        """
-        return self.total_length - self.headers_length - _PRELUDE_LENGTH - 4
-
-    @property
-    def payload_end(self):
-        """Calculates the byte offset for the end of the message payload.
-
-        The extra minus 4 bytes is for the message CRC.
-
-        :rtype: int
-        :returns: The byte offset from the beginning of the event stream
-        message to the end of the payload.
-        """
-        return self.total_length - 4
-
-    @property
-    def headers_end(self):
-        """Calculates the byte offset for the end of the message headers.
-
-        :rtype: int
-        :returns: The byte offset from the beginning of the event stream
-        message to the end of the headers.
-        """
-        return _PRELUDE_LENGTH + self.headers_length
-
-
-class EventStreamMessage:
-    """Represents an event stream message."""
-
-    def __init__(self, prelude, headers, payload, crc):
-        self.prelude = prelude
-        self.headers = headers
-        self.payload = payload
-        self.crc = crc
-
-    def to_response_dict(self, status_code=200):
-        message_type = self.headers.get(':message-type')
-        if message_type == 'error' or message_type == 'exception':
-            status_code = 400
-        return {
-            'status_code': status_code,
-            'headers': self.headers,
-            'body': self.payload,
-        }
-
-
-class EventStreamHeaderParser:
-    """Parses the event headers from an event stream message.
-
-    Expects all of the header data upfront and creates a dictionary of headers
-    to return. This object can be reused multiple times to parse the headers
-    from multiple event stream messages.
-    """
-
-    # Maps header type to appropriate unpacking function
-    # These unpacking functions return the value and the amount unpacked
-    _HEADER_TYPE_MAP = {
-        # boolean_true
-        0: DecodeUtils.unpack_true,
-        # boolean_false
-        1: DecodeUtils.unpack_false,
-        # byte
-        2: DecodeUtils.unpack_int8,
-        # short
-        3: DecodeUtils.unpack_int16,
-        # integer
-        4: DecodeUtils.unpack_int32,
-        # long
-        5: DecodeUtils.unpack_int64,
-        # byte_array
-        6: DecodeUtils.unpack_byte_array,
-        # string
-        7: DecodeUtils.unpack_utf8_string,
-        # timestamp
-        8: DecodeUtils.unpack_int64,
-        # uuid
-        9: DecodeUtils.unpack_uuid,
-    }
-
-    def __init__(self):
-        self._data = None
-
-    def parse(self, data):
-        """Parses the event stream headers from an event stream message.
-
-        :type data: bytes
-        :param data: The bytes that correspond to the headers section of an
-        event stream message.
-
-        :rtype: dict
-        :returns: A dicionary of header key, value pairs.
-        """
-        self._data = data
-        return self._parse_headers()
-
-    def _parse_headers(self):
-        headers = {}
-        while self._data:
-            name, value = self._parse_header()
-            if name in headers:
-                raise DuplicateHeader(name)
-            headers[name] = value
-        return headers
-
-    def _parse_header(self):
-        name = self._parse_name()
-        value = self._parse_value()
-        return name, value
-
-    def _parse_name(self):
-        name, consumed = DecodeUtils.unpack_utf8_string(self._data, 1)
-        self._advance_data(consumed)
-        return name
-
-    def _parse_type(self):
-        type, consumed = DecodeUtils.unpack_uint8(self._data)
-        self._advance_data(consumed)
-        return type
-
-    def _parse_value(self):
-        header_type = self._parse_type()
-        value_unpacker = self._HEADER_TYPE_MAP[header_type]
-        value, consumed = value_unpacker(self._data)
-        self._advance_data(consumed)
-        return value
-
-    def _advance_data(self, consumed):
-        self._data = self._data[consumed:]
-
-
-class EventStreamBuffer:
-    """Streaming based event stream buffer
-
-    A buffer class that wraps bytes from an event stream providing parsed
-    messages as they become available via an iterable interface.
-    """
-
-    def __init__(self):
-        self._data = b''
-        self._prelude = None
-        self._header_parser = EventStreamHeaderParser()
-
-    def add_data(self, data):
-        """Add data to the buffer.
-
-        :type data: bytes
-        :param data: The bytes to add to the buffer to be used when parsing
-        """
-        self._data += data
-
-    def _validate_prelude(self, prelude):
-        if prelude.headers_length > _MAX_HEADERS_LENGTH:
-            raise InvalidHeadersLength(prelude.headers_length)
-
-        if prelude.payload_length > _MAX_PAYLOAD_LENGTH:
-            raise InvalidPayloadLength(prelude.payload_length)
-
-    def _parse_prelude(self):
-        prelude_bytes = self._data[:_PRELUDE_LENGTH]
-        raw_prelude, _ = DecodeUtils.unpack_prelude(prelude_bytes)
-        prelude = MessagePrelude(*raw_prelude)
-        self._validate_prelude(prelude)
-        # The minus 4 removes the prelude crc from the bytes to be checked
-        _validate_checksum(prelude_bytes[: _PRELUDE_LENGTH - 4], prelude.crc)
-        return prelude
-
-    def _parse_headers(self):
-        header_bytes = self._data[_PRELUDE_LENGTH : self._prelude.headers_end]
-        return self._header_parser.parse(header_bytes)
-
-    def _parse_payload(self):
-        prelude = self._prelude
-        payload_bytes = self._data[prelude.headers_end : prelude.payload_end]
-        return payload_bytes
-
-    def _parse_message_crc(self):
-        prelude = self._prelude
-        crc_bytes = self._data[prelude.payload_end : prelude.total_length]
-        message_crc, _ = DecodeUtils.unpack_uint32(crc_bytes)
-        return message_crc
-
-    def _parse_message_bytes(self):
-        # The minus 4 includes the prelude crc to the bytes to be checked
-        message_bytes = self._data[
-            _PRELUDE_LENGTH - 4 : self._prelude.payload_end
-        ]
-        return message_bytes
-
-    def _validate_message_crc(self):
-        message_crc = self._parse_message_crc()
-        message_bytes = self._parse_message_bytes()
-        _validate_checksum(message_bytes, message_crc, crc=self._prelude.crc)
-        return message_crc
-
-    def _parse_message(self):
-        crc = self._validate_message_crc()
-        headers = self._parse_headers()
-        payload = self._parse_payload()
-        message = EventStreamMessage(self._prelude, headers, payload, crc)
-        self._prepare_for_next_message()
-        return message
-
-    def _prepare_for_next_message(self):
-        # Advance the data and reset the current prelude
-        self._data = self._data[self._prelude.total_length :]
-        self._prelude = None
-
-    def next(self):
-        """Provides the next available message parsed from the stream
-
-        :rtype: EventStreamMessage
-        :returns: The next event stream message
-        """
-        if len(self._data) < _PRELUDE_LENGTH:
-            raise StopIteration()
-
-        if self._prelude is None:
-            self._prelude = self._parse_prelude()
-
-        if len(self._data) < self._prelude.total_length:
-            raise StopIteration()
-
-        return self._parse_message()
-
-    def __next__(self):
-        return self.next()
-
-    def __iter__(self):
-        return self
-
-
-class EventStream:
-    """Wrapper class for an event stream body.
-
-    This wraps the underlying streaming body, parsing it for individual events
-    and yielding them as they come available through the iterator interface.
-
-    The following example uses the S3 select API to get structured data out of
-    an object stored in S3 using an event stream.
-
-    **Example:**
-    ::
-        from botocore.session import Session
-
-        s3 = Session().create_client('s3')
-        response = s3.select_object_content(
-            Bucket='bucketname',
-            Key='keyname',
-            ExpressionType='SQL',
-            RequestProgress={'Enabled': True},
-            Expression="SELECT * FROM S3Object s",
-            InputSerialization={'CSV': {}},
-            OutputSerialization={'CSV': {}},
-        )
-        # This is the event stream in the response
-        event_stream = response['Payload']
-        end_event_received = False
-        with open('output', 'wb') as f:
-            # Iterate over events in the event stream as they come
-            for event in event_stream:
-                # If we received a records event, write the data to a file
-                if 'Records' in event:
-                    data = event['Records']['Payload']
-                    f.write(data)
-                # If we received a progress event, print the details
-                elif 'Progress' in event:
-                    print(event['Progress']['Details'])
-                # End event indicates that the request finished successfully
-                elif 'End' in event:
-                    print('Result is complete')
-                    end_event_received = True
-        if not end_event_received:
-            raise Exception("End event not received, request incomplete.")
-    """
-
-    def __init__(self, raw_stream, output_shape, parser, operation_name):
-        self._raw_stream = raw_stream
-        self._output_shape = output_shape
-        self._operation_name = operation_name
-        self._parser = parser
-        self._event_generator = self._create_raw_event_generator()
-
-    def __iter__(self):
-        for event in self._event_generator:
-            parsed_event = self._parse_event(event)
-            if parsed_event:
-                yield parsed_event
-
-    def _create_raw_event_generator(self):
-        event_stream_buffer = EventStreamBuffer()
-        for chunk in self._raw_stream.stream():
-            event_stream_buffer.add_data(chunk)
-            yield from event_stream_buffer
-
-    def _parse_event(self, event):
-        response_dict = event.to_response_dict()
-        parsed_response = self._parser.parse(response_dict, self._output_shape)
-        if response_dict['status_code'] == 200:
-            return parsed_response
-        else:
-            raise EventStreamError(parsed_response, self._operation_name)
-
-    def get_initial_response(self):
-        try:
-            initial_event = next(self._event_generator)
-            event_type = initial_event.headers.get(':event-type')
-            if event_type == 'initial-response':
-                return initial_event
-        except StopIteration:
-            pass
-        raise NoInitialResponseError()
-
-    def close(self):
-        """Closes the underlying streaming body."""
-        self._raw_stream.close()

spaces/Big-Web/MMSD/env/Lib/site-packages/setuptools/_distutils/command/register.py

@@ -1,319 +0,0 @@
-"""distutils.command.register
-
-Implements the Distutils 'register' command (register with the repository).
-"""
-
-# created 2002/10/21, Richard Jones
-
-import getpass
-import io
-import urllib.parse
-import urllib.request
-from warnings import warn
-
-from distutils.core import PyPIRCCommand
-from distutils import log
-
-
-class register(PyPIRCCommand):
-
-    description = "register the distribution with the Python package index"
-    user_options = PyPIRCCommand.user_options + [
-        ('list-classifiers', None, 'list the valid Trove classifiers'),
-        (
-            'strict',
-            None,
-            'Will stop the registering if the meta-data are not fully compliant',
-        ),
-    ]
-    boolean_options = PyPIRCCommand.boolean_options + [
-        'verify',
-        'list-classifiers',
-        'strict',
-    ]
-
-    sub_commands = [('check', lambda self: True)]
-
-    def initialize_options(self):
-        PyPIRCCommand.initialize_options(self)
-        self.list_classifiers = 0
-        self.strict = 0
-
-    def finalize_options(self):
-        PyPIRCCommand.finalize_options(self)
-        # setting options for the `check` subcommand
-        check_options = {
-            'strict': ('register', self.strict),
-            'restructuredtext': ('register', 1),
-        }
-        self.distribution.command_options['check'] = check_options
-
-    def run(self):
-        self.finalize_options()
-        self._set_config()
-
-        # Run sub commands
-        for cmd_name in self.get_sub_commands():
-            self.run_command(cmd_name)
-
-        if self.dry_run:
-            self.verify_metadata()
-        elif self.list_classifiers:
-            self.classifiers()
-        else:
-            self.send_metadata()
-
-    def check_metadata(self):
-        """Deprecated API."""
-        warn(
-            "distutils.command.register.check_metadata is deprecated; "
-            "use the check command instead",
-            DeprecationWarning,
-        )
-        check = self.distribution.get_command_obj('check')
-        check.ensure_finalized()
-        check.strict = self.strict
-        check.restructuredtext = 1
-        check.run()
-
-    def _set_config(self):
-        '''Reads the configuration file and set attributes.'''
-        config = self._read_pypirc()
-        if config != {}:
-            self.username = config['username']
-            self.password = config['password']
-            self.repository = config['repository']
-            self.realm = config['realm']
-            self.has_config = True
-        else:
-            if self.repository not in ('pypi', self.DEFAULT_REPOSITORY):
-                raise ValueError('%s not found in .pypirc' % self.repository)
-            if self.repository == 'pypi':
-                self.repository = self.DEFAULT_REPOSITORY
-            self.has_config = False
-
-    def classifiers(self):
-        '''Fetch the list of classifiers from the server.'''
-        url = self.repository + '?:action=list_classifiers'
-        response = urllib.request.urlopen(url)
-        log.info(self._read_pypi_response(response))
-
-    def verify_metadata(self):
-        '''Send the metadata to the package index server to be checked.'''
-        # send the info to the server and report the result
-        (code, result) = self.post_to_server(self.build_post_data('verify'))
-        log.info('Server response (%s): %s', code, result)
-
-    def send_metadata(self):  # noqa: C901
-        '''Send the metadata to the package index server.
-
-        Well, do the following:
-        1. figure who the user is, and then
-        2. send the data as a Basic auth'ed POST.
-
-        First we try to read the username/password from $HOME/.pypirc,
-        which is a ConfigParser-formatted file with a section
-        [distutils] containing username and password entries (both
-        in clear text). Eg:
-
-            [distutils]
-            index-servers =
-                pypi
-
-            [pypi]
-            username: fred
-            password: sekrit
-
-        Otherwise, to figure who the user is, we offer the user three
-        choices:
-
-         1. use existing login,
-         2. register as a new user, or
-         3. set the password to a random string and email the user.
-
-        '''
-        # see if we can short-cut and get the username/password from the
-        # config
-        if self.has_config:
-            choice = '1'
-            username = self.username
-            password = self.password
-        else:
-            choice = 'x'
-            username = password = ''
-
-        # get the user's login info
-        choices = '1 2 3 4'.split()
-        while choice not in choices:
-            self.announce(
-                '''\
-We need to know who you are, so please choose either:
- 1. use your existing login,
- 2. register as a new user,
- 3. have the server generate a new password for you (and email it to you), or
- 4. quit
-Your selection [default 1]: ''',
-                log.INFO,
-            )
-            choice = input()
-            if not choice:
-                choice = '1'
-            elif choice not in choices:
-                print('Please choose one of the four options!')
-
-        if choice == '1':
-            # get the username and password
-            while not username:
-                username = input('Username: ')
-            while not password:
-                password = getpass.getpass('Password: ')
-
-            # set up the authentication
-            auth = urllib.request.HTTPPasswordMgr()
-            host = urllib.parse.urlparse(self.repository)[1]
-            auth.add_password(self.realm, host, username, password)
-            # send the info to the server and report the result
-            code, result = self.post_to_server(self.build_post_data('submit'), auth)
-            self.announce('Server response ({}): {}'.format(code, result), log.INFO)
-
-            # possibly save the login
-            if code == 200:
-                if self.has_config:
-                    # sharing the password in the distribution instance
-                    # so the upload command can reuse it
-                    self.distribution.password = password
-                else:
-                    self.announce(
-                        (
-                            'I can store your PyPI login so future '
-                            'submissions will be faster.'
-                        ),
-                        log.INFO,
-                    )
-                    self.announce(
-                        '(the login will be stored in %s)' % self._get_rc_file(),
-                        log.INFO,
-                    )
-                    choice = 'X'
-                    while choice.lower() not in 'yn':
-                        choice = input('Save your login (y/N)?')
-                        if not choice:
-                            choice = 'n'
-                    if choice.lower() == 'y':
-                        self._store_pypirc(username, password)
-
-        elif choice == '2':
-            data = {':action': 'user'}
-            data['name'] = data['password'] = data['email'] = ''
-            data['confirm'] = None
-            while not data['name']:
-                data['name'] = input('Username: ')
-            while data['password'] != data['confirm']:
-                while not data['password']:
-                    data['password'] = getpass.getpass('Password: ')
-                while not data['confirm']:
-                    data['confirm'] = getpass.getpass(' Confirm: ')
-                if data['password'] != data['confirm']:
-                    data['password'] = ''
-                    data['confirm'] = None
-                    print("Password and confirm don't match!")
-            while not data['email']:
-                data['email'] = input('   EMail: ')
-            code, result = self.post_to_server(data)
-            if code != 200:
-                log.info('Server response (%s): %s', code, result)
-            else:
-                log.info('You will receive an email shortly.')
-                log.info('Follow the instructions in it to ' 'complete registration.')
-        elif choice == '3':
-            data = {':action': 'password_reset'}
-            data['email'] = ''
-            while not data['email']:
-                data['email'] = input('Your email address: ')
-            code, result = self.post_to_server(data)
-            log.info('Server response (%s): %s', code, result)
-
-    def build_post_data(self, action):
-        # figure the data to send - the metadata plus some additional
-        # information used by the package server
-        meta = self.distribution.metadata
-        data = {
-            ':action': action,
-            'metadata_version': '1.0',
-            'name': meta.get_name(),
-            'version': meta.get_version(),
-            'summary': meta.get_description(),
-            'home_page': meta.get_url(),
-            'author': meta.get_contact(),
-            'author_email': meta.get_contact_email(),
-            'license': meta.get_licence(),
-            'description': meta.get_long_description(),
-            'keywords': meta.get_keywords(),
-            'platform': meta.get_platforms(),
-            'classifiers': meta.get_classifiers(),
-            'download_url': meta.get_download_url(),
-            # PEP 314
-            'provides': meta.get_provides(),
-            'requires': meta.get_requires(),
-            'obsoletes': meta.get_obsoletes(),
-        }
-        if data['provides'] or data['requires'] or data['obsoletes']:
-            data['metadata_version'] = '1.1'
-        return data
-
-    def post_to_server(self, data, auth=None):  # noqa: C901
-        '''Post a query to the server, and return a string response.'''
-        if 'name' in data:
-            self.announce(
-                'Registering {} to {}'.format(data['name'], self.repository), log.INFO
-            )
-        # Build up the MIME payload for the urllib2 POST data
-        boundary = '--------------GHSKFJDLGDS7543FJKLFHRE75642756743254'
-        sep_boundary = '\n--' + boundary
-        end_boundary = sep_boundary + '--'
-        body = io.StringIO()
-        for key, value in data.items():
-            # handle multiple entries for the same name
-            if type(value) not in (type([]), type(())):
-                value = [value]
-            for value in value:
-                value = str(value)
-                body.write(sep_boundary)
-                body.write('\nContent-Disposition: form-data; name="%s"' % key)
-                body.write("\n\n")
-                body.write(value)
-                if value and value[-1] == '\r':
-                    body.write('\n')  # write an extra newline (lurve Macs)
-        body.write(end_boundary)
-        body.write("\n")
-        body = body.getvalue().encode("utf-8")
-
-        # build the Request
-        headers = {
-            'Content-type': 'multipart/form-data; boundary=%s; charset=utf-8'
-            % boundary,
-            'Content-length': str(len(body)),
-        }
-        req = urllib.request.Request(self.repository, body, headers)
-
-        # handle HTTP and include the Basic Auth handler
-        opener = urllib.request.build_opener(
-            urllib.request.HTTPBasicAuthHandler(password_mgr=auth)
-        )
-        data = ''
-        try:
-            result = opener.open(req)
-        except urllib.error.HTTPError as e:
-            if self.show_response:
-                data = e.fp.read()
-            result = e.code, e.msg
-        except urllib.error.URLError as e:
-            result = 500, str(e)
-        else:
-            if self.show_response:
-                data = self._read_pypi_response(result)
-            result = 200, 'OK'
-        if self.show_response:
-            msg = '\n'.join(('-' * 75, data, '-' * 75))
-            self.announce(msg, log.INFO)
-        return result

spaces/BigSalmon/BackTranslation/README.md

@@ -1,12 +0,0 @@
----
-title: BackTranslation
-emoji: 🐨
-colorFrom: gray
-colorTo: pink
-sdk: streamlit
-sdk_version: 1.2.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces#reference

spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/detectron2/utils/env.py

@@ -1,105 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-import importlib
-import importlib.util
-import logging
-import numpy as np
-import os
-import random
-import sys
-from datetime import datetime
-import torch
-
-__all__ = ["seed_all_rng"]
-
-
-def seed_all_rng(seed=None):
-    """
-    Set the random seed for the RNG in torch, numpy and python.
-
-    Args:
-        seed (int): if None, will use a strong random seed.
-    """
-    if seed is None:
-        seed = (
-            os.getpid()
-            + int(datetime.now().strftime("%S%f"))
-            + int.from_bytes(os.urandom(2), "big")
-        )
-        logger = logging.getLogger(__name__)
-        logger.info("Using a generated random seed {}".format(seed))
-    np.random.seed(seed)
-    torch.set_rng_state(torch.manual_seed(seed).get_state())
-    random.seed(seed)
-
-
-# from https://stackoverflow.com/questions/67631/how-to-import-a-module-given-the-full-path
-def _import_file(module_name, file_path, make_importable=False):
-    spec = importlib.util.spec_from_file_location(module_name, file_path)
-    module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(module)
-    if make_importable:
-        sys.modules[module_name] = module
-    return module
-
-
-def _configure_libraries():
-    """
-    Configurations for some libraries.
-    """
-    # An environment option to disable `import cv2` globally,
-    # in case it leads to negative performance impact
-    disable_cv2 = int(os.environ.get("DETECTRON2_DISABLE_CV2", False))
-    if disable_cv2:
-        sys.modules["cv2"] = None
-    else:
-        # Disable opencl in opencv since its interaction with cuda often has negative effects
-        # This envvar is supported after OpenCV 3.4.0
-        os.environ["OPENCV_OPENCL_RUNTIME"] = "disabled"
-        try:
-            import cv2
-
-            if int(cv2.__version__.split(".")[0]) >= 3:
-                cv2.ocl.setUseOpenCL(False)
-        except ImportError:
-            pass
-
-
-_ENV_SETUP_DONE = False
-
-
-def setup_environment():
-    """Perform environment setup work. The default setup is a no-op, but this
-    function allows the user to specify a Python source file or a module in
-    the $DETECTRON2_ENV_MODULE environment variable, that performs
-    custom setup work that may be necessary to their computing environment.
-    """
-    global _ENV_SETUP_DONE
-    if _ENV_SETUP_DONE:
-        return
-    _ENV_SETUP_DONE = True
-
-    _configure_libraries()
-
-    custom_module_path = os.environ.get("DETECTRON2_ENV_MODULE")
-
-    if custom_module_path:
-        setup_custom_environment(custom_module_path)
-    else:
-        # The default setup is a no-op
-        pass
-
-
-def setup_custom_environment(custom_module):
-    """
-    Load custom environment setup by importing a Python source file or a
-    module, and run the setup function.
-    """
-    if custom_module.endswith(".py"):
-        module = _import_file("detectron2.utils.env.custom_module", custom_module)
-    else:
-        module = importlib.import_module(custom_module)
-    assert hasattr(module, "setup_environment") and callable(module.setup_environment), (
-        "Custom environment module defined in {} does not have the "
-        "required callable attribute 'setup_environment'."
-    ).format(custom_module)
-    module.setup_environment()

spaces/CVPR/regionclip-demo/detectron2/evaluation/coco_evaluation.py

@@ -1,610 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import contextlib
-import copy
-import io
-import itertools
-import json
-import logging
-import numpy as np
-import os
-import pickle
-from collections import OrderedDict
-import pycocotools.mask as mask_util
-import torch
-from pycocotools.coco import COCO
-from pycocotools.cocoeval import COCOeval
-from tabulate import tabulate
-
-import detectron2.utils.comm as comm
-from detectron2.config import CfgNode
-from detectron2.data import MetadataCatalog
-from detectron2.data.datasets.coco import convert_to_coco_json
-from detectron2.data.datasets.coco_zeroshot_categories import COCO_UNSEEN_CLS, COCO_SEEN_CLS, COCO_OVD_ALL_CLS
-from detectron2.evaluation.fast_eval_api import COCOeval_opt
-from detectron2.structures import Boxes, BoxMode, pairwise_iou
-from detectron2.utils.file_io import PathManager
-from detectron2.utils.logger import create_small_table
-
-from .evaluator import DatasetEvaluator
-
-
-class COCOEvaluator(DatasetEvaluator):
-    """
-    Evaluate AR for object proposals, AP for instance detection/segmentation, AP
-    for keypoint detection outputs using COCO's metrics.
-    See http://cocodataset.org/#detection-eval and
-    http://cocodataset.org/#keypoints-eval to understand its metrics.
-    The metrics range from 0 to 100 (instead of 0 to 1), where a -1 or NaN means
-    the metric cannot be computed (e.g. due to no predictions made).
-
-    In addition to COCO, this evaluator is able to support any bounding box detection,
-    instance segmentation, or keypoint detection dataset.
-    """
-
-    def __init__(
-        self,
-        dataset_name,
-        tasks=None,
-        distributed=True,
-        output_dir=None,
-        *,
-        use_fast_impl=True,
-        kpt_oks_sigmas=(),
-    ):
-        """
-        Args:
-            dataset_name (str): name of the dataset to be evaluated.
-                It must have either the following corresponding metadata:
-
-                    "json_file": the path to the COCO format annotation
-
-                Or it must be in detectron2's standard dataset format
-                so it can be converted to COCO format automatically.
-            tasks (tuple[str]): tasks that can be evaluated under the given
-                configuration. A task is one of "bbox", "segm", "keypoints".
-                By default, will infer this automatically from predictions.
-            distributed (True): if True, will collect results from all ranks and run evaluation
-                in the main process.
-                Otherwise, will only evaluate the results in the current process.
-            output_dir (str): optional, an output directory to dump all
-                results predicted on the dataset. The dump contains two files:
-
-                1. "instances_predictions.pth" a file that can be loaded with `torch.load` and
-                   contains all the results in the format they are produced by the model.
-                2. "coco_instances_results.json" a json file in COCO's result format.
-            use_fast_impl (bool): use a fast but **unofficial** implementation to compute AP.
-                Although the results should be very close to the official implementation in COCO
-                API, it is still recommended to compute results with the official API for use in
-                papers. The faster implementation also uses more RAM.
-            kpt_oks_sigmas (list[float]): The sigmas used to calculate keypoint OKS.
-                See http://cocodataset.org/#keypoints-eval
-                When empty, it will use the defaults in COCO.
-                Otherwise it should be the same length as ROI_KEYPOINT_HEAD.NUM_KEYPOINTS.
-        """
-        self._logger = logging.getLogger(__name__)
-        self._distributed = distributed
-        self._output_dir = output_dir
-        self._use_fast_impl = use_fast_impl
-
-        if tasks is not None and isinstance(tasks, CfgNode):
-            kpt_oks_sigmas = (
-                tasks.TEST.KEYPOINT_OKS_SIGMAS if not kpt_oks_sigmas else kpt_oks_sigmas
-            )
-            self._logger.warn(
-                "COCO Evaluator instantiated using config, this is deprecated behavior."
-                " Please pass in explicit arguments instead."
-            )
-            self._tasks = None  # Infering it from predictions should be better
-        else:
-            self._tasks = tasks
-
-        self._cpu_device = torch.device("cpu")
-
-        self._metadata = MetadataCatalog.get(dataset_name)
-        if not hasattr(self._metadata, "json_file"):
-            self._logger.info(
-                f"'{dataset_name}' is not registered by `register_coco_instances`."
-                " Therefore trying to convert it to COCO format ..."
-            )
-
-            cache_path = os.path.join(output_dir, f"{dataset_name}_coco_format.json")
-            self._metadata.json_file = cache_path
-            convert_to_coco_json(dataset_name, cache_path)
-
-        json_file = PathManager.get_local_path(self._metadata.json_file)
-        with contextlib.redirect_stdout(io.StringIO()):
-            self._coco_api = COCO(json_file)
-
-        # Test set json files do not contain annotations (evaluation must be
-        # performed using the COCO evaluation server).
-        self._do_evaluation = "annotations" in self._coco_api.dataset
-        if self._do_evaluation:
-            self._kpt_oks_sigmas = kpt_oks_sigmas
-
-    def reset(self):
-        self._predictions = []
-
-    def process(self, inputs, outputs):
-        """
-        Args:
-            inputs: the inputs to a COCO model (e.g., GeneralizedRCNN).
-                It is a list of dict. Each dict corresponds to an image and
-                contains keys like "height", "width", "file_name", "image_id".
-            outputs: the outputs of a COCO model. It is a list of dicts with key
-                "instances" that contains :class:`Instances`.
-        """
-        for input, output in zip(inputs, outputs):
-            prediction = {"image_id": input["image_id"]}
-
-            if "instances" in output:
-                instances = output["instances"].to(self._cpu_device)
-                prediction["instances"] = instances_to_coco_json(instances, input["image_id"])
-            if "proposals" in output:
-                prediction["proposals"] = output["proposals"].to(self._cpu_device)
-            if len(prediction) > 1:
-                self._predictions.append(prediction)
-
-    def evaluate(self, img_ids=None):
-        """
-        Args:
-            img_ids: a list of image IDs to evaluate on. Default to None for the whole dataset
-        """
-        if self._distributed:
-            comm.synchronize()
-            predictions = comm.gather(self._predictions, dst=0)
-            predictions = list(itertools.chain(*predictions))
-
-            if not comm.is_main_process():
-                return {}
-        else:
-            predictions = self._predictions
-
-        if len(predictions) == 0:
-            self._logger.warning("[COCOEvaluator] Did not receive valid predictions.")
-            return {}
-
-        if self._output_dir:
-            PathManager.mkdirs(self._output_dir)
-            file_path = os.path.join(self._output_dir, "instances_predictions.pth")
-            with PathManager.open(file_path, "wb") as f:
-                torch.save(predictions, f)
-
-        self._results = OrderedDict()
-        if "proposals" in predictions[0]:
-            self._eval_box_proposals(predictions)
-        if "instances" in predictions[0]:
-            self._eval_predictions(predictions, img_ids=img_ids)
-        # Copy so the caller can do whatever with results
-        return copy.deepcopy(self._results)
-
-    def _tasks_from_predictions(self, predictions):
-        """
-        Get COCO API "tasks" (i.e. iou_type) from COCO-format predictions.
-        """
-        tasks = {"bbox"}
-        for pred in predictions:
-            if "segmentation" in pred:
-                tasks.add("segm")
-            if "keypoints" in pred:
-                tasks.add("keypoints")
-        return sorted(tasks)
-
-    def _eval_predictions(self, predictions, img_ids=None):
-        """
-        Evaluate predictions. Fill self._results with the metrics of the tasks.
-        """
-        self._logger.info("Preparing results for COCO format ...")
-        coco_results = list(itertools.chain(*[x["instances"] for x in predictions]))
-        tasks = self._tasks or self._tasks_from_predictions(coco_results)
-
-        # unmap the category ids for COCO
-        if hasattr(self._metadata, "thing_dataset_id_to_contiguous_id"):
-            dataset_id_to_contiguous_id = self._metadata.thing_dataset_id_to_contiguous_id
-            all_contiguous_ids = list(dataset_id_to_contiguous_id.values())
-            num_classes = len(all_contiguous_ids)
-            assert min(all_contiguous_ids) == 0 and max(all_contiguous_ids) == num_classes - 1
-
-            reverse_id_mapping = {v: k for k, v in dataset_id_to_contiguous_id.items()}
-            for result in coco_results:
-                category_id = result["category_id"]
-                assert category_id < num_classes, (
-                    f"A prediction has class={category_id}, "
-                    f"but the dataset only has {num_classes} classes and "
-                    f"predicted class id should be in [0, {num_classes - 1}]."
-                )
-                result["category_id"] = reverse_id_mapping[category_id]
-
-        if self._output_dir:
-            file_path = os.path.join(self._output_dir, "coco_instances_results.json")
-            self._logger.info("Saving results to {}".format(file_path))
-            with PathManager.open(file_path, "w") as f:
-                f.write(json.dumps(coco_results))
-                f.flush()
-
-        if not self._do_evaluation:
-            self._logger.info("Annotations are not available for evaluation.")
-            return
-
-        self._logger.info(
-            "Evaluating predictions with {} COCO API...".format(
-                "unofficial" if self._use_fast_impl else "official"
-            )
-        )
-        for task in sorted(tasks):
-            assert task in {"bbox", "segm", "keypoints"}, f"Got unknown task: {task}!"
-            coco_eval = (
-                _evaluate_predictions_on_coco(
-                    self._coco_api,
-                    coco_results,
-                    task,
-                    kpt_oks_sigmas=self._kpt_oks_sigmas,
-                    use_fast_impl=self._use_fast_impl,
-                    img_ids=img_ids,
-                )
-                if len(coco_results) > 0
-                else None  # cocoapi does not handle empty results very well
-            )
-
-            res = self._derive_coco_results(
-                coco_eval, task, class_names=self._metadata.get("thing_classes")
-            )
-            self._results[task] = res
-
-    def _eval_box_proposals(self, predictions):
-        """
-        Evaluate the box proposals in predictions.
-        Fill self._results with the metrics for "box_proposals" task.
-        """
-        if self._output_dir:
-            # Saving generated box proposals to file.
-            # Predicted box_proposals are in XYXY_ABS mode.
-            bbox_mode = BoxMode.XYXY_ABS.value
-            ids, boxes, objectness_logits = [], [], []
-            for prediction in predictions:
-                ids.append(prediction["image_id"])
-                boxes.append(prediction["proposals"].proposal_boxes.tensor.numpy())
-                objectness_logits.append(prediction["proposals"].objectness_logits.numpy())
-
-            proposal_data = {
-                "boxes": boxes,
-                "objectness_logits": objectness_logits,
-                "ids": ids,
-                "bbox_mode": bbox_mode,
-            }
-            with PathManager.open(os.path.join(self._output_dir, "box_proposals.pkl"), "wb") as f:
-                pickle.dump(proposal_data, f)
-
-        if not self._do_evaluation:
-            self._logger.info("Annotations are not available for evaluation.")
-            return
-
-        self._logger.info("Evaluating bbox proposals ...")
-        res = {}
-        areas = {"all": "", "small": "s", "medium": "m", "large": "l"}
-        for limit in [100, 1000]:
-            for area, suffix in areas.items():
-                stats = _evaluate_box_proposals(predictions, self._coco_api, area=area, limit=limit)
-                key = "AR{}@{:d}".format(suffix, limit)
-                res[key] = float(stats["ar"].item() * 100)
-        self._logger.info("Proposal metrics: \n" + create_small_table(res))
-        self._results["box_proposals"] = res
-
-    def _derive_coco_results(self, coco_eval, iou_type, class_names=None):
-        """
-        Derive the desired score numbers from summarized COCOeval.
-
-        Args:
-            coco_eval (None or COCOEval): None represents no predictions from model.
-            iou_type (str):
-            class_names (None or list[str]): if provided, will use it to predict
-                per-category AP.
-
-        Returns:
-            a dict of {metric name: score}
-        """
-
-        metrics = {
-            "bbox": ["AP", "AP50", "AP75", "APs", "APm", "APl"],
-            "segm": ["AP", "AP50", "AP75", "APs", "APm", "APl"],
-            "keypoints": ["AP", "AP50", "AP75", "APm", "APl"],
-        }[iou_type]
-
-        if coco_eval is None:
-            self._logger.warn("No predictions from the model!")
-            return {metric: float("nan") for metric in metrics}
-
-        # the standard metrics
-        results = {
-            metric: float(coco_eval.stats[idx] * 100 if coco_eval.stats[idx] >= 0 else "nan")
-            for idx, metric in enumerate(metrics)
-        }
-        self._logger.info(
-            "Evaluation results for {}: \n".format(iou_type) + create_small_table(results)
-        )
-        if not np.isfinite(sum(results.values())):
-            self._logger.info("Some metrics cannot be computed and is shown as NaN.")
-
-        if class_names is None or len(class_names) <= 1:
-            return results
-        # Compute per-category AP
-        # from https://github.com/facebookresearch/Detectron/blob/a6a835f5b8208c45d0dce217ce9bbda915f44df7/detectron/datasets/json_dataset_evaluator.py#L222-L252 # noqa
-        precisions = coco_eval.eval["precision"]
-        # precision has dims (iou, recall, cls, area range, max dets)
-        assert len(class_names) == precisions.shape[2]
-
-        results_per_category = []
-        for idx, name in enumerate(class_names):
-            # area range index 0: all area ranges
-            # max dets index -1: typically 100 per image
-            precision = precisions[:, :, idx, 0, -1]
-            precision = precision[precision > -1]
-            ap = np.mean(precision) if precision.size else float("nan")
-            results_per_category.append(("{}".format(name), float(ap * 100)))
-
-        # Computing AP50 for (seen/unseen) split in generalized zeroshot setting (eg. all 65 categories)
-        # from https://github.com/alirezazareian/ovr-cnn/blob/master/maskrcnn_benchmark/data/datasets/evaluation/coco/coco_eval.py
-        if len(class_names) == 65:
-            p = coco_eval.params
-            maxDets = p.maxDets[2]
-            areaRng = 'all'
-            iouThr = 0.5
-            aind = [i for i, aRng in enumerate(p.areaRngLbl) if aRng == areaRng]
-            mind = [i for i, mDet in enumerate(p.maxDets) if mDet == maxDets]
-            t = np.where(iouThr == p.iouThrs)[0]
-            s = coco_eval.eval['precision']
-            s = s[t,:,:,aind,mind]
-
-            unseen_cids = [p.catIds[i] for i, c in enumerate(class_names) if c in COCO_UNSEEN_CLS]
-            seen_cids = [p.catIds[i] for i, c in enumerate(class_names) if c in COCO_SEEN_CLS]
-            all_cids = [p.catIds[i] for i, c in enumerate(class_names) if c in COCO_OVD_ALL_CLS]
-            res = {}
-            for split, cid_list in [('target',unseen_cids), ('base',seen_cids), ('all',all_cids)]:
-                cinds = []
-                for cid in cid_list:
-                    cinds.extend([i for i, c in enumerate(p.catIds) if c == cid])
-                s_split = s[:, :, cinds]
-                if len(s_split[s_split>-1])==0:
-                    mean_s = -1
-                else:
-                    mean_s = np.mean(s_split[s_split>-1])
-                res[f'AP50_split_{split}'] = mean_s
-            for res_item in res:
-                self._logger.info("{} AP: {}\n".format(res_item, res[res_item]))
-
-        # tabulate it
-        N_COLS = min(6, len(results_per_category) * 2)
-        results_flatten = list(itertools.chain(*results_per_category))
-        results_2d = itertools.zip_longest(*[results_flatten[i::N_COLS] for i in range(N_COLS)])
-        table = tabulate(
-            results_2d,
-            tablefmt="pipe",
-            floatfmt=".3f",
-            headers=["category", "AP"] * (N_COLS // 2),
-            numalign="left",
-        )
-        self._logger.info("Per-category {} AP: \n".format(iou_type) + table)
-
-        results.update({"AP-" + name: ap for name, ap in results_per_category})
-        return results
-
-
-def instances_to_coco_json(instances, img_id):
-    """
-    Dump an "Instances" object to a COCO-format json that's used for evaluation.
-
-    Args:
-        instances (Instances):
-        img_id (int): the image id
-
-    Returns:
-        list[dict]: list of json annotations in COCO format.
-    """
-    num_instance = len(instances)
-    if num_instance == 0:
-        return []
-
-    boxes = instances.pred_boxes.tensor.numpy()
-    boxes = BoxMode.convert(boxes, BoxMode.XYXY_ABS, BoxMode.XYWH_ABS)
-    boxes = boxes.tolist()
-    scores = instances.scores.tolist()
-    classes = instances.pred_classes.tolist()
-
-    has_mask = instances.has("pred_masks")
-    if has_mask:
-        # use RLE to encode the masks, because they are too large and takes memory
-        # since this evaluator stores outputs of the entire dataset
-        rles = [
-            mask_util.encode(np.array(mask[:, :, None], order="F", dtype="uint8"))[0]
-            for mask in instances.pred_masks
-        ]
-        for rle in rles:
-            # "counts" is an array encoded by mask_util as a byte-stream. Python3's
-            # json writer which always produces strings cannot serialize a bytestream
-            # unless you decode it. Thankfully, utf-8 works out (which is also what
-            # the pycocotools/_mask.pyx does).
-            rle["counts"] = rle["counts"].decode("utf-8")
-
-    has_keypoints = instances.has("pred_keypoints")
-    if has_keypoints:
-        keypoints = instances.pred_keypoints
-
-    results = []
-    for k in range(num_instance):
-        result = {
-            "image_id": img_id,
-            "category_id": classes[k],
-            "bbox": boxes[k],
-            "score": scores[k],
-        }
-        if has_mask:
-            result["segmentation"] = rles[k]
-        if has_keypoints:
-            # In COCO annotations,
-            # keypoints coordinates are pixel indices.
-            # However our predictions are floating point coordinates.
-            # Therefore we subtract 0.5 to be consistent with the annotation format.
-            # This is the inverse of data loading logic in `datasets/coco.py`.
-            keypoints[k][:, :2] -= 0.5
-            result["keypoints"] = keypoints[k].flatten().tolist()
-        results.append(result)
-    return results
-
-
-# inspired from Detectron:
-# https://github.com/facebookresearch/Detectron/blob/a6a835f5b8208c45d0dce217ce9bbda915f44df7/detectron/datasets/json_dataset_evaluator.py#L255 # noqa
-def _evaluate_box_proposals(dataset_predictions, coco_api, thresholds=None, area="all", limit=None):
-    """
-    Evaluate detection proposal recall metrics. This function is a much
-    faster alternative to the official COCO API recall evaluation code. However,
-    it produces slightly different results.
-    """
-    # Record max overlap value for each gt box
-    # Return vector of overlap values
-    areas = {
-        "all": 0,
-        "small": 1,
-        "medium": 2,
-        "large": 3,
-        "96-128": 4,
-        "128-256": 5,
-        "256-512": 6,
-        "512-inf": 7,
-    }
-    area_ranges = [
-        [0 ** 2, 1e5 ** 2],  # all
-        [0 ** 2, 32 ** 2],  # small
-        [32 ** 2, 96 ** 2],  # medium
-        [96 ** 2, 1e5 ** 2],  # large
-        [96 ** 2, 128 ** 2],  # 96-128
-        [128 ** 2, 256 ** 2],  # 128-256
-        [256 ** 2, 512 ** 2],  # 256-512
-        [512 ** 2, 1e5 ** 2],
-    ]  # 512-inf
-    assert area in areas, "Unknown area range: {}".format(area)
-    area_range = area_ranges[areas[area]]
-    gt_overlaps = []
-    num_pos = 0
-
-    for prediction_dict in dataset_predictions:
-        predictions = prediction_dict["proposals"]
-
-        # sort predictions in descending order
-        # TODO maybe remove this and make it explicit in the documentation
-        inds = predictions.objectness_logits.sort(descending=True)[1]
-        predictions = predictions[inds]
-
-        ann_ids = coco_api.getAnnIds(imgIds=prediction_dict["image_id"])
-        anno = coco_api.loadAnns(ann_ids)
-        gt_boxes = [
-            BoxMode.convert(obj["bbox"], BoxMode.XYWH_ABS, BoxMode.XYXY_ABS)
-            for obj in anno
-            if obj["iscrowd"] == 0
-        ]
-        gt_boxes = torch.as_tensor(gt_boxes).reshape(-1, 4)  # guard against no boxes
-        gt_boxes = Boxes(gt_boxes)
-        gt_areas = torch.as_tensor([obj["area"] for obj in anno if obj["iscrowd"] == 0])
-
-        if len(gt_boxes) == 0 or len(predictions) == 0:
-            continue
-
-        valid_gt_inds = (gt_areas >= area_range[0]) & (gt_areas <= area_range[1])
-        gt_boxes = gt_boxes[valid_gt_inds]
-
-        num_pos += len(gt_boxes)
-
-        if len(gt_boxes) == 0:
-            continue
-
-        if limit is not None and len(predictions) > limit:
-            predictions = predictions[:limit]
-
-        overlaps = pairwise_iou(predictions.proposal_boxes, gt_boxes)
-
-        _gt_overlaps = torch.zeros(len(gt_boxes))
-        for j in range(min(len(predictions), len(gt_boxes))):
-            # find which proposal box maximally covers each gt box
-            # and get the iou amount of coverage for each gt box
-            max_overlaps, argmax_overlaps = overlaps.max(dim=0)
-
-            # find which gt box is 'best' covered (i.e. 'best' = most iou)
-            gt_ovr, gt_ind = max_overlaps.max(dim=0)
-            assert gt_ovr >= 0
-            # find the proposal box that covers the best covered gt box
-            box_ind = argmax_overlaps[gt_ind]
-            # record the iou coverage of this gt box
-            _gt_overlaps[j] = overlaps[box_ind, gt_ind]
-            assert _gt_overlaps[j] == gt_ovr
-            # mark the proposal box and the gt box as used
-            overlaps[box_ind, :] = -1
-            overlaps[:, gt_ind] = -1
-
-        # append recorded iou coverage level
-        gt_overlaps.append(_gt_overlaps)
-    gt_overlaps = (
-        torch.cat(gt_overlaps, dim=0) if len(gt_overlaps) else torch.zeros(0, dtype=torch.float32)
-    )
-    gt_overlaps, _ = torch.sort(gt_overlaps)
-
-    if thresholds is None:
-        step = 0.05
-        thresholds = torch.arange(0.5, 0.95 + 1e-5, step, dtype=torch.float32)
-    recalls = torch.zeros_like(thresholds)
-    # compute recall for each iou threshold
-    for i, t in enumerate(thresholds):
-        recalls[i] = (gt_overlaps >= t).float().sum() / float(num_pos)
-    # ar = 2 * np.trapz(recalls, thresholds)
-    ar = recalls.mean()
-    return {
-        "ar": ar,
-        "recalls": recalls,
-        "thresholds": thresholds,
-        "gt_overlaps": gt_overlaps,
-        "num_pos": num_pos,
-    }
-
-
-def _evaluate_predictions_on_coco(
-    coco_gt, coco_results, iou_type, kpt_oks_sigmas=None, use_fast_impl=True, img_ids=None
-):
-    """
-    Evaluate the coco results using COCOEval API.
-    """
-    assert len(coco_results) > 0
-
-    if iou_type == "segm":
-        coco_results = copy.deepcopy(coco_results)
-        # When evaluating mask AP, if the results contain bbox, cocoapi will
-        # use the box area as the area of the instance, instead of the mask area.
-        # This leads to a different definition of small/medium/large.
-        # We remove the bbox field to let mask AP use mask area.
-        for c in coco_results:
-            c.pop("bbox", None)
-
-    coco_dt = coco_gt.loadRes(coco_results)
-    coco_eval = (COCOeval_opt if use_fast_impl else COCOeval)(coco_gt, coco_dt, iou_type)
-    if img_ids is not None:
-        coco_eval.params.imgIds = img_ids
-
-    if iou_type == "keypoints":
-        # Use the COCO default keypoint OKS sigmas unless overrides are specified
-        if kpt_oks_sigmas:
-            assert hasattr(coco_eval.params, "kpt_oks_sigmas"), "pycocotools is too old!"
-            coco_eval.params.kpt_oks_sigmas = np.array(kpt_oks_sigmas)
-        # COCOAPI requires every detection and every gt to have keypoints, so
-        # we just take the first entry from both
-        num_keypoints_dt = len(coco_results[0]["keypoints"]) // 3
-        num_keypoints_gt = len(next(iter(coco_gt.anns.values()))["keypoints"]) // 3
-        num_keypoints_oks = len(coco_eval.params.kpt_oks_sigmas)
-        assert num_keypoints_oks == num_keypoints_dt == num_keypoints_gt, (
-            f"[COCOEvaluator] Prediction contain {num_keypoints_dt} keypoints. "
-            f"Ground truth contains {num_keypoints_gt} keypoints. "
-            f"The length of cfg.TEST.KEYPOINT_OKS_SIGMAS is {num_keypoints_oks}. "
-            "They have to agree with each other. For meaning of OKS, please refer to "
-            "http://cocodataset.org/#keypoints-eval."
-        )
-
-    coco_eval.evaluate()
-    coco_eval.accumulate()
-    coco_eval.summarize()
-
-    return coco_eval

spaces/CVPR/regionclip-demo/detectron2/export/caffe2_export.py

@@ -1,207 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-
-import copy
-import io
-import logging
-import numpy as np
-from typing import List
-import onnx
-import torch
-from caffe2.proto import caffe2_pb2
-from caffe2.python import core
-from caffe2.python.onnx.backend import Caffe2Backend
-from tabulate import tabulate
-from termcolor import colored
-from torch.onnx import OperatorExportTypes
-
-from .shared import (
-    ScopedWS,
-    construct_init_net_from_params,
-    fuse_alias_placeholder,
-    fuse_copy_between_cpu_and_gpu,
-    get_params_from_init_net,
-    group_norm_replace_aten_with_caffe2,
-    infer_device_type,
-    remove_dead_end_ops,
-    remove_reshape_for_fc,
-    save_graph,
-)
-
-logger = logging.getLogger(__name__)
-
-
-def export_onnx_model(model, inputs):
-    """
-    Trace and export a model to onnx format.
-
-    Args:
-        model (nn.Module):
-        inputs (tuple[args]): the model will be called by `model(*inputs)`
-
-    Returns:
-        an onnx model
-    """
-    assert isinstance(model, torch.nn.Module)
-
-    # make sure all modules are in eval mode, onnx may change the training state
-    # of the module if the states are not consistent
-    def _check_eval(module):
-        assert not module.training
-
-    model.apply(_check_eval)
-
-    # Export the model to ONNX
-    with torch.no_grad():
-        with io.BytesIO() as f:
-            torch.onnx.export(
-                model,
-                inputs,
-                f,
-                operator_export_type=OperatorExportTypes.ONNX_ATEN_FALLBACK,
-                # verbose=True,  # NOTE: uncomment this for debugging
-                # export_params=True,
-            )
-            onnx_model = onnx.load_from_string(f.getvalue())
-
-    # Apply ONNX's Optimization
-    all_passes = onnx.optimizer.get_available_passes()
-    passes = ["fuse_bn_into_conv"]
-    assert all(p in all_passes for p in passes)
-    onnx_model = onnx.optimizer.optimize(onnx_model, passes)
-    return onnx_model
-
-
-def _op_stats(net_def):
-    type_count = {}
-    for t in [op.type for op in net_def.op]:
-        type_count[t] = type_count.get(t, 0) + 1
-    type_count_list = sorted(type_count.items(), key=lambda kv: kv[0])  # alphabet
-    type_count_list = sorted(type_count_list, key=lambda kv: -kv[1])  # count
-    return "\n".join("{:>4}x {}".format(count, name) for name, count in type_count_list)
-
-
-def _assign_device_option(
-    predict_net: caffe2_pb2.NetDef, init_net: caffe2_pb2.NetDef, tensor_inputs: List[torch.Tensor]
-):
-    """
-    ONNX exported network doesn't have concept of device, assign necessary
-    device option for each op in order to make it runable on GPU runtime.
-    """
-
-    def _get_device_type(torch_tensor):
-        assert torch_tensor.device.type in ["cpu", "cuda"]
-        assert torch_tensor.device.index == 0
-        return torch_tensor.device.type
-
-    def _assign_op_device_option(net_proto, net_ssa, blob_device_types):
-        for op, ssa_i in zip(net_proto.op, net_ssa):
-            if op.type in ["CopyCPUToGPU", "CopyGPUToCPU"]:
-                op.device_option.CopyFrom(core.DeviceOption(caffe2_pb2.CUDA, 0))
-            else:
-                devices = [blob_device_types[b] for b in ssa_i[0] + ssa_i[1]]
-                assert all(d == devices[0] for d in devices)
-                if devices[0] == "cuda":
-                    op.device_option.CopyFrom(core.DeviceOption(caffe2_pb2.CUDA, 0))
-
-    # update ops in predict_net
-    predict_net_input_device_types = {
-        (name, 0): _get_device_type(tensor)
-        for name, tensor in zip(predict_net.external_input, tensor_inputs)
-    }
-    predict_net_device_types = infer_device_type(
-        predict_net, known_status=predict_net_input_device_types, device_name_style="pytorch"
-    )
-    predict_net_ssa, _ = core.get_ssa(predict_net)
-    _assign_op_device_option(predict_net, predict_net_ssa, predict_net_device_types)
-
-    # update ops in init_net
-    init_net_ssa, versions = core.get_ssa(init_net)
-    init_net_output_device_types = {
-        (name, versions[name]): predict_net_device_types[(name, 0)]
-        for name in init_net.external_output
-    }
-    init_net_device_types = infer_device_type(
-        init_net, known_status=init_net_output_device_types, device_name_style="pytorch"
-    )
-    _assign_op_device_option(init_net, init_net_ssa, init_net_device_types)
-
-
-def export_caffe2_detection_model(model: torch.nn.Module, tensor_inputs: List[torch.Tensor]):
-    """
-    Export a caffe2-compatible Detectron2 model to caffe2 format via ONNX.
-
-    Arg:
-        model: a caffe2-compatible version of detectron2 model, defined in caffe2_modeling.py
-        tensor_inputs: a list of tensors that caffe2 model takes as input.
-    """
-    model = copy.deepcopy(model)
-    assert isinstance(model, torch.nn.Module)
-    assert hasattr(model, "encode_additional_info")
-
-    # Export via ONNX
-    logger.info(
-        "Exporting a {} model via ONNX ...".format(type(model).__name__)
-        + " Some warnings from ONNX are expected and are usually not to worry about."
-    )
-    onnx_model = export_onnx_model(model, (tensor_inputs,))
-    # Convert ONNX model to Caffe2 protobuf
-    init_net, predict_net = Caffe2Backend.onnx_graph_to_caffe2_net(onnx_model)
-    ops_table = [[op.type, op.input, op.output] for op in predict_net.op]
-    table = tabulate(ops_table, headers=["type", "input", "output"], tablefmt="pipe")
-    logger.info(
-        "ONNX export Done. Exported predict_net (before optimizations):\n" + colored(table, "cyan")
-    )
-
-    # Apply protobuf optimization
-    fuse_alias_placeholder(predict_net, init_net)
-    if any(t.device.type != "cpu" for t in tensor_inputs):
-        fuse_copy_between_cpu_and_gpu(predict_net)
-        remove_dead_end_ops(init_net)
-        _assign_device_option(predict_net, init_net, tensor_inputs)
-    params, device_options = get_params_from_init_net(init_net)
-    predict_net, params = remove_reshape_for_fc(predict_net, params)
-    init_net = construct_init_net_from_params(params, device_options)
-    group_norm_replace_aten_with_caffe2(predict_net)
-
-    # Record necessary information for running the pb model in Detectron2 system.
-    model.encode_additional_info(predict_net, init_net)
-
-    logger.info("Operators used in predict_net: \n{}".format(_op_stats(predict_net)))
-    logger.info("Operators used in init_net: \n{}".format(_op_stats(init_net)))
-
-    return predict_net, init_net
-
-
-def run_and_save_graph(predict_net, init_net, tensor_inputs, graph_save_path):
-    """
-    Run the caffe2 model on given inputs, recording the shape and draw the graph.
-
-    predict_net/init_net: caffe2 model.
-    tensor_inputs: a list of tensors that caffe2 model takes as input.
-    graph_save_path: path for saving graph of exported model.
-    """
-
-    logger.info("Saving graph of ONNX exported model to {} ...".format(graph_save_path))
-    save_graph(predict_net, graph_save_path, op_only=False)
-
-    # Run the exported Caffe2 net
-    logger.info("Running ONNX exported model ...")
-    with ScopedWS("__ws_tmp__", True) as ws:
-        ws.RunNetOnce(init_net)
-        initialized_blobs = set(ws.Blobs())
-        uninitialized = [inp for inp in predict_net.external_input if inp not in initialized_blobs]
-        for name, blob in zip(uninitialized, tensor_inputs):
-            ws.FeedBlob(name, blob)
-
-        try:
-            ws.RunNetOnce(predict_net)
-        except RuntimeError as e:
-            logger.warning("Encountered RuntimeError: \n{}".format(str(e)))
-
-        ws_blobs = {b: ws.FetchBlob(b) for b in ws.Blobs()}
-        blob_sizes = {b: ws_blobs[b].shape for b in ws_blobs if isinstance(ws_blobs[b], np.ndarray)}
-
-        logger.info("Saving graph with blob shapes to {} ...".format(graph_save_path))
-        save_graph(predict_net, graph_save_path, op_only=False, blob_sizes=blob_sizes)
-
-        return ws_blobs

spaces/Cobalt337/lambdalabs-sd-pokemon-diffusers/README.md

@@ -1,12 +0,0 @@
----
-title: Lambdalabs Sd Pokemon Diffusers
-emoji: 🚀
-colorFrom: blue
-colorTo: green
-sdk: gradio
-sdk_version: 3.24.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/Cyril666/ContourNet-ABI/maskrcnn_benchmark/modeling/roi_heads/boundary_head/inference.py

@@ -1,207 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
-import numpy as np
-import torch
-from torch import nn
-from maskrcnn_benchmark.layers.misc import interpolate
-
-from maskrcnn_benchmark.structures.bounding_box import BoxList
-
-
-# TODO check if want to return a single BoxList or a composite
-# object
-class MaskPostProcessor(nn.Module):
-    """
-    From the results of the CNN, post process the masks
-    by taking the mask corresponding to the class with max
-    probability (which are of fixed size and directly output
-    by the CNN) and return the masks in the mask field of the BoxList.
-
-    If a masker object is passed, it will additionally
-    project the masks in the image according to the locations in boxes,
-    """
-
-    def __init__(self, masker=None):
-        super(MaskPostProcessor, self).__init__()
-        self.masker = masker
-
-    def forward(self, x, y, boxes):
-        """
-        Arguments:
-            x (Tensor): the mask logits
-            boxes (list[BoxList]): bounding boxes that are used as
-                reference, one for ech image
-
-        Returns:
-            results (list[BoxList]): one BoxList for each image, containing
-                the extra field mask
-        """
-        mask_prob_x = x.sigmoid()
-        mask_prob_y = y.sigmoid()
-        # select masks coresponding to the predicted classes
-        num_masks = x.shape[0]  #  286
-        labels = [bbox.get_field("labels") for bbox in boxes]
-        labels = torch.cat(labels)
-        index = torch.arange(num_masks, device=labels.device)
-        mask_prob_x = mask_prob_x[index, 0][:, None]
-        mask_prob_y = mask_prob_y[index, 0][:, None]
-
-        boxes_per_image = [len(box) for box in boxes]  # boxes for one image
-        mask_prob_x = mask_prob_x.split(boxes_per_image, dim=0)
-        mask_prob_y = mask_prob_y.split(boxes_per_image, dim=0)
-
-        if self.masker:
-            print('yes!!!')
-            mask_prob_x = self.masker(mask_prob_x, boxes)
-            mask_prob_y = self.masker(mask_prob_y, boxes)
-
-        results = []
-        for prob_x, prob_y, box in zip(mask_prob_x, mask_prob_y, boxes):
-            bbox = BoxList(box.bbox, box.size, mode="xyxy")
-            for field in box.fields():
-                bbox.add_field(field, box.get_field(field))
-            bbox.add_field("mask_x", prob_x)
-            bbox.add_field("mask_y", prob_y)
-            results.append(bbox)
-        return results
-
-
-class MaskPostProcessorCOCOFormat(MaskPostProcessor):
-    """
-    From the results of the CNN, post process the results
-    so that the masks are pasted in the image, and
-    additionally convert the results to COCO format.
-    """
-
-    def forward(self, x, boxes):
-        import pycocotools.mask as mask_util
-        import numpy as np
-
-        results = super(MaskPostProcessorCOCOFormat, self).forward(x, boxes)
-        for result in results:
-            masks = result.get_field("mask").cpu()
-            rles = [
-                mask_util.encode(np.array(mask[0, :, :, np.newaxis], order="F"))[0]
-                for mask in masks
-            ]
-            for rle in rles:
-                rle["counts"] = rle["counts"].decode("utf-8")
-            result.add_field("mask", rles)
-        return results
-
-
-# the next two functions should be merged inside Masker
-# but are kept here for the moment while we need them
-# temporarily gor paste_mask_in_image
-def expand_boxes(boxes, scale):
-    w_half = (boxes[:, 2] - boxes[:, 0]) * .5
-    h_half = (boxes[:, 3] - boxes[:, 1]) * .5
-    x_c = (boxes[:, 2] + boxes[:, 0]) * .5
-    y_c = (boxes[:, 3] + boxes[:, 1]) * .5
-
-    w_half *= scale
-    h_half *= scale
-
-    boxes_exp = torch.zeros_like(boxes)
-    boxes_exp[:, 0] = x_c - w_half
-    boxes_exp[:, 2] = x_c + w_half
-    boxes_exp[:, 1] = y_c - h_half
-    boxes_exp[:, 3] = y_c + h_half
-    return boxes_exp
-
-
-def expand_masks(mask, padding):
-    N = mask.shape[0]
-    M = mask.shape[-1]
-    pad2 = 2 * padding
-    scale = float(M + pad2) / M
-    padded_mask = mask.new_zeros((N, 1, M + pad2, M + pad2))
-
-    padded_mask[:, :, padding:-padding, padding:-padding] = mask
-    return padded_mask, scale
-
-
-def paste_mask_in_image(mask, box, im_h, im_w, thresh=0.5, padding=1):
-    padded_mask, scale = expand_masks(mask[None], padding=padding)
-    mask = padded_mask[0, 0]
-    box = expand_boxes(box[None], scale)[0]
-    box = box.to(dtype=torch.int32)
-    TO_REMOVE = 1
-    w = int(box[2] - box[0] + TO_REMOVE)
-    h = int(box[3] - box[1] + TO_REMOVE)
-    w = max(w, 1)
-    h = max(h, 1)
-
-    # Set shape to [batchxCxHxW]
-    mask = mask.expand((1, 1, -1, -1))
-
-    # Resize mask
-    mask = mask.to(torch.float32)
-    mask = interpolate(mask, size=(h, w), mode='bilinear', align_corners=False)
-    mask = mask[0][0]
-
-    if thresh >= 0:
-        mask = mask > thresh
-    else:
-        # for visualization and debugging, we also
-        # allow it to return an unmodified mask
-        mask = (mask * 255).to(torch.uint8)
-
-    im_mask = torch.zeros((im_h, im_w), dtype=torch.uint8)
-    x_0 = max(box[0], 0)
-    x_1 = min(box[2] + 1, im_w)
-    y_0 = max(box[1], 0)
-    y_1 = min(box[3] + 1, im_h)
-
-    im_mask[y_0:y_1, x_0:x_1] = mask[
-        (y_0 - box[1]) : (y_1 - box[1]), (x_0 - box[0]) : (x_1 - box[0])
-    ]
-    return im_mask
-
-
-class Masker(object):
-    """
-    Projects a set of masks in an image on the locations specified by the bounding boxes
-    """
-
-    def __init__(self, threshold=0.5, padding=1):
-        self.threshold = threshold
-        self.padding = padding
-
-    def forward_single_image(self, masks, boxes):
-        boxes = boxes.convert("xyxy")
-        im_w, im_h = boxes.size
-        res = [
-            paste_mask_in_image(mask[0], box, im_h, im_w, self.threshold, self.padding)
-            for mask, box in zip(masks, boxes.bbox)
-        ]
-        if len(res) > 0:
-            res = torch.stack(res, dim=0)[:, None]
-        else:
-            res = masks.new_empty((0, 1, masks.shape[-2], masks.shape[-1]))
-        return res
-
-    def __call__(self, masks, boxes):
-        if isinstance(boxes, BoxList):
-            boxes = [boxes]
-
-        # Make some sanity check
-        assert len(boxes) == len(masks), "Masks and boxes should have the same length."
-
-        # TODO:  Is this JIT compatible?
-        # If not we should make it compatible.
-        results = []
-        for mask, box in zip(masks, boxes):
-            assert mask.shape[0] == len(box), "Number of objects should be the same."
-            result = self.forward_single_image(mask, box)
-            results.append(result)
-        return results
-
-
-def make_roi_boundary_post_processor(cfg):
-    if cfg.MODEL.ROI_MASK_HEAD.POSTPROCESS_MASKS:
-        mask_threshold = cfg.MODEL.ROI_MASK_HEAD.POSTPROCESS_MASKS_THRESHOLD ## 0.5
-        masker = Masker(threshold=mask_threshold, padding=1)
-    else:
-        masker = None
-    mask_post_processor = MaskPostProcessor(masker)
-    return mask_post_processor

spaces/DAMO-NLP-SG/Video-LLaMA/video_llama/datasets/builders/instruct_builder.py

@@ -1,78 +0,0 @@
-import os
-import logging
-import warnings
-
-from video_llama.common.registry import registry
-from video_llama.datasets.builders.base_dataset_builder import BaseDatasetBuilder
-from video_llama.datasets.datasets.laion_dataset import LaionDataset
-from video_llama.datasets.datasets.llava_instruct_dataset import Instruct_Dataset
-from video_llama.datasets.datasets.video_instruct_dataset import Video_Instruct_Dataset
-
-@registry.register_builder("instruct")
-class Instruct_Builder(BaseDatasetBuilder):
-    train_dataset_cls = Instruct_Dataset
-
-    DATASET_CONFIG_DICT = {"default": "configs/datasets/instruct/defaults.yaml"}
-
-    def _download_ann(self):
-        pass
-
-    def _download_vis(self):
-        pass
-
-    def build(self):
-        self.build_processors()
-        datasets = dict()
-        split = "train"
-
-        build_info = self.config.build_info
-        dataset_cls = self.train_dataset_cls
-        if self.config.num_video_query_token:
-            num_video_query_token = self.config.num_video_query_token 
-        else:
-            num_video_query_token = 32
-
-        if self.config.tokenizer_name:
-            tokenizer_name = self.config.tokenizer_name 
-        else:
-            tokenizer_name = '/mnt/workspace/ckpt/vicuna-13b/'
-
-
-        datasets[split] = dataset_cls(
-            vis_processor=self.vis_processors[split],
-            text_processor=self.text_processors[split],
-            vis_root=build_info.videos_dir,
-            ann_root=build_info.anno_dir,
-            num_video_query_token = num_video_query_token,
-            tokenizer_name = tokenizer_name,
-            data_type = self.config.data_type
-        )
-
-        return datasets
-
-@registry.register_builder("webvid_instruct")
-class WebvidInstruct_Builder(Instruct_Builder):
-    train_dataset_cls = Video_Instruct_Dataset
-
-    DATASET_CONFIG_DICT = {
-        "default": "configs/datasets/instruct/webvid_instruct.yaml",
-    }
-
-@registry.register_builder("webvid_instruct_zh")
-class WebvidInstruct_zh_Builder(Instruct_Builder):
-    train_dataset_cls = Video_Instruct_Dataset
-
-    DATASET_CONFIG_DICT = {
-        "default": "configs/datasets/instruct/webvid_instruct.yaml",
-    }
-
-
-
-@registry.register_builder("llava_instruct")
-class LlavaInstruct_Builder(Instruct_Builder):
-    train_dataset_cls = Instruct_Dataset
-
-    DATASET_CONFIG_DICT = {
-        "default": "configs/datasets/instruct/llava_instruct.yaml",
-    }
-

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/gradio/components/clear_button.py

@@ -1,70 +0,0 @@
-""" Predefined buttons with bound events that can be included in a gr.Blocks for convenience. """
-
-from __future__ import annotations
-
-import json
-from typing import Literal
-
-from gradio_client.documentation import document, set_documentation_group
-
-from gradio.components import Button, Component
-
-set_documentation_group("component")
-
-
-@document("add")
-class ClearButton(Button):
-    """
-    Button that clears the value of a component or a list of components when clicked. It is instantiated with the list of components to clear.
-    Preprocessing: passes the button value as a {str} into the function
-    Postprocessing: expects a {str} to be returned from a function, which is set as the label of the button
-    """
-
-    is_template = True
-
-    def __init__(
-        self,
-        components: None | list[Component] | Component = None,
-        *,
-        value: str = "Clear",
-        variant: Literal["primary", "secondary", "stop"] = "secondary",
-        size: Literal["sm", "lg"] | None = None,
-        visible: bool = True,
-        interactive: bool = True,
-        elem_id: str | None = None,
-        elem_classes: list[str] | str | None = None,
-        scale: int | None = None,
-        min_width: int | None = None,
-        **kwargs,
-    ):
-        super().__init__(
-            value,
-            variant=variant,
-            size=size,
-            visible=visible,
-            interactive=interactive,
-            elem_id=elem_id,
-            elem_classes=elem_classes,
-            scale=scale,
-            min_width=min_width,
-            **kwargs,
-        )
-        self.add(components)
-
-    def add(self, components: None | Component | list[Component]) -> ClearButton:
-        """
-        Adds a component or list of components to the list of components that will be cleared when the button is clicked.
-        """
-        if not components:
-            # This needs to be here because when the ClearButton is created in an gr.Interface, we don't
-            # want to create dependencies for it before we have created the dependencies for the submit function.
-            # We generally assume that the submit function dependency is the first thing created in an gr.Interface.
-            return self
-
-        if isinstance(components, Component):
-            components = [components]
-        clear_values = json.dumps(
-            [component.postprocess(None) for component in components]
-        )
-        self.click(None, [], components, _js=f"() => {clear_values}")
-        return self

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/gradio/templates.py

@@ -1,574 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Callable, Literal
-
-import numpy as np
-from PIL.Image import Image
-
-from gradio import components
-
-
-class TextArea(components.Textbox):
-    """
-    Sets: lines=7
-    """
-
-    is_template = True
-
-    def __init__(
-        self,
-        value: str | Callable | None = "",
-        *,
-        lines: int = 7,
-        max_lines: int = 20,
-        placeholder: str | None = None,
-        label: str | None = None,
-        show_label: bool = True,
-        interactive: bool | None = None,
-        visible: bool = True,
-        elem_id: str | None = None,
-        **kwargs,
-    ):
-        super().__init__(
-            value=value,
-            lines=lines,
-            max_lines=max_lines,
-            placeholder=placeholder,
-            label=label,
-            show_label=show_label,
-            interactive=interactive,
-            visible=visible,
-            elem_id=elem_id,
-            **kwargs,
-        )
-
-
-class Webcam(components.Image):
-    """
-    Sets: source="webcam", interactive=True
-    """
-
-    is_template = True
-
-    def __init__(
-        self,
-        value: str | Image | np.ndarray | None = None,
-        *,
-        shape: tuple[int, int] | None = None,
-        image_mode: Literal["RGB", "L"] = "RGB",
-        invert_colors: bool = False,
-        source: Literal["webcam"] = "webcam",
-        tool: Literal["editor", "select", "sketch", "color-sketch"] | None = None,
-        type: Literal["numpy", "pil", "filepath"] = "numpy",
-        label: str | None = None,
-        show_label: bool = True,
-        interactive: bool | None = True,
-        visible: bool = True,
-        streaming: bool = False,
-        elem_id: str | None = None,
-        mirror_webcam: bool = True,
-        brush_radius: float | None = None,
-        **kwargs,
-    ):
-        super().__init__(
-            value=value,
-            shape=shape,
-            image_mode=image_mode,
-            invert_colors=invert_colors,
-            source=source,
-            tool=tool,
-            type=type,
-            label=label,
-            show_label=show_label,
-            interactive=interactive,
-            visible=visible,
-            streaming=streaming,
-            elem_id=elem_id,
-            mirror_webcam=mirror_webcam,
-            brush_radius=brush_radius,
-            **kwargs,
-        )
-
-
-class Sketchpad(components.Image):
-    """
-    Sets: image_mode="L", source="canvas", shape=(28, 28), invert_colors=True, interactive=True
-    """
-
-    is_template = True
-
-    def __init__(
-        self,
-        value: str | Image | np.ndarray | None = None,
-        *,
-        shape: tuple[int, int] = (28, 28),
-        image_mode: Literal["L"] = "L",
-        invert_colors: bool = True,
-        source: Literal["canvas"] = "canvas",
-        tool: Literal["editor", "select", "sketch", "color-sketch"] | None = None,
-        type: Literal["numpy", "pil", "filepath"] = "numpy",
-        label: str | None = None,
-        show_label: bool = True,
-        interactive: bool | None = True,
-        visible: bool = True,
-        streaming: bool = False,
-        elem_id: str | None = None,
-        mirror_webcam: bool = True,
-        brush_radius: float | None = None,
-        **kwargs,
-    ):
-        super().__init__(
-            value=value,
-            shape=shape,
-            image_mode=image_mode,
-            invert_colors=invert_colors,
-            source=source,
-            tool=tool,
-            type=type,
-            label=label,
-            show_label=show_label,
-            interactive=interactive,
-            visible=visible,
-            streaming=streaming,
-            elem_id=elem_id,
-            mirror_webcam=mirror_webcam,
-            brush_radius=brush_radius,
-            **kwargs,
-        )
-
-
-class Paint(components.Image):
-    """
-    Sets: source="canvas", tool="color-sketch", interactive=True
-    """
-
-    is_template = True
-
-    def __init__(
-        self,
-        value: str | Image | np.ndarray | None = None,
-        *,
-        shape: tuple[int, int] | None = None,
-        image_mode: Literal["RGB"] = "RGB",
-        invert_colors: bool = False,
-        source: Literal["canvas"] = "canvas",
-        tool: Literal["color-sketch"] = "color-sketch",
-        type: Literal["numpy", "pil", "filepath"] = "numpy",
-        label: str | None = None,
-        show_label: bool = True,
-        interactive: bool | None = True,
-        visible: bool = True,
-        streaming: bool = False,
-        elem_id: str | None = None,
-        mirror_webcam: bool = True,
-        brush_radius: float | None = None,
-        **kwargs,
-    ):
-        super().__init__(
-            value=value,
-            shape=shape,
-            image_mode=image_mode,
-            invert_colors=invert_colors,
-            source=source,
-            tool=tool,
-            type=type,
-            label=label,
-            show_label=show_label,
-            interactive=interactive,
-            visible=visible,
-            streaming=streaming,
-            elem_id=elem_id,
-            mirror_webcam=mirror_webcam,
-            brush_radius=brush_radius,
-            **kwargs,
-        )
-
-
-class ImageMask(components.Image):
-    """
-    Sets: source="upload", tool="sketch", interactive=True
-    """
-
-    is_template = True
-
-    def __init__(
-        self,
-        value: str | Image | np.ndarray | None = None,
-        *,
-        shape: tuple[int, int] | None = None,
-        image_mode: Literal["RGB", "L"] = "RGB",
-        invert_colors: bool = False,
-        source: Literal["upload"] = "upload",
-        tool: Literal["sketch"] = "sketch",
-        type: Literal["numpy", "pil", "filepath"] = "numpy",
-        label: str | None = None,
-        show_label: bool = True,
-        interactive: bool | None = True,
-        visible: bool = True,
-        streaming: bool = False,
-        elem_id: str | None = None,
-        mirror_webcam: bool = True,
-        brush_radius: float | None = None,
-        **kwargs,
-    ):
-        super().__init__(
-            value=value,
-            shape=shape,
-            image_mode=image_mode,
-            invert_colors=invert_colors,
-            source=source,
-            tool=tool,
-            type=type,
-            label=label,
-            show_label=show_label,
-            interactive=interactive,
-            visible=visible,
-            streaming=streaming,
-            elem_id=elem_id,
-            mirror_webcam=mirror_webcam,
-            brush_radius=brush_radius,
-            **kwargs,
-        )
-
-
-class ImagePaint(components.Image):
-    """
-    Sets: source="upload", tool="color-sketch", interactive=True
-    """
-
-    is_template = True
-
-    def __init__(
-        self,
-        value: str | Image | np.ndarray | None = None,
-        *,
-        shape: tuple[int, int] | None = None,
-        image_mode: Literal["RGB", "L"] = "RGB",
-        invert_colors: bool = False,
-        source: Literal["upload"] = "upload",
-        tool: Literal["color-sketch"] = "color-sketch",
-        type: Literal["numpy", "pil", "filepath"] = "numpy",
-        label: str | None = None,
-        show_label: bool = True,
-        interactive: bool | None = True,
-        visible: bool = True,
-        streaming: bool = False,
-        elem_id: str | None = None,
-        mirror_webcam: bool = True,
-        brush_radius: float | None = None,
-        **kwargs,
-    ):
-        super().__init__(
-            value=value,
-            shape=shape,
-            image_mode=image_mode,
-            invert_colors=invert_colors,
-            source=source,
-            tool=tool,
-            type=type,
-            label=label,
-            show_label=show_label,
-            interactive=interactive,
-            visible=visible,
-            streaming=streaming,
-            elem_id=elem_id,
-            mirror_webcam=mirror_webcam,
-            brush_radius=brush_radius,
-            **kwargs,
-        )
-
-
-class Pil(components.Image):
-    """
-    Sets: type="pil"
-    """
-
-    is_template = True
-
-    def __init__(
-        self,
-        value: str | Image | np.ndarray | None = None,
-        *,
-        shape: tuple[int, int] | None = None,
-        image_mode: Literal["RGB", "L"] = "RGB",
-        invert_colors: bool = False,
-        source: Literal["upload", "webcam", "canvas"] = "upload",
-        tool: Literal["editor", "select", "sketch", "color-sketch"] | None = None,
-        type: Literal["pil"] = "pil",
-        label: str | None = None,
-        show_label: bool = True,
-        interactive: bool | None = None,
-        visible: bool = True,
-        streaming: bool = False,
-        elem_id: str | None = None,
-        mirror_webcam: bool = True,
-        brush_radius: float | None = None,
-        **kwargs,
-    ):
-        super().__init__(
-            value=value,
-            shape=shape,
-            image_mode=image_mode,
-            invert_colors=invert_colors,
-            source=source,
-            tool=tool,
-            type=type,
-            label=label,
-            show_label=show_label,
-            interactive=interactive,
-            visible=visible,
-            streaming=streaming,
-            elem_id=elem_id,
-            mirror_webcam=mirror_webcam,
-            brush_radius=brush_radius,
-            **kwargs,
-        )
-
-
-class PlayableVideo(components.Video):
-    """
-    Sets: format="mp4"
-    """
-
-    is_template = True
-
-    def __init__(
-        self,
-        value: str | Callable | None = None,
-        *,
-        format: Literal["mp4"] | None = "mp4",
-        source: Literal["upload", "webcam"] = "upload",
-        label: str | None = None,
-        show_label: bool = True,
-        interactive: bool | None = None,
-        visible: bool = True,
-        elem_id: str | None = None,
-        mirror_webcam: bool = True,
-        include_audio: bool | None = None,
-        **kwargs,
-    ):
-        super().__init__(
-            value=value,
-            format=format,
-            source=source,
-            label=label,
-            show_label=show_label,
-            interactive=interactive,
-            visible=visible,
-            elem_id=elem_id,
-            mirror_webcam=mirror_webcam,
-            include_audio=include_audio,
-            **kwargs,
-        )
-
-
-class Microphone(components.Audio):
-    """
-    Sets: source="microphone"
-    """
-
-    is_template = True
-
-    def __init__(
-        self,
-        value: str | tuple[int, np.ndarray] | Callable | None = None,
-        *,
-        source: Literal["microphone"] = "microphone",
-        type: Literal["numpy", "filepath"] = "numpy",
-        label: str | None = None,
-        show_label: bool = True,
-        interactive: bool | None = None,
-        visible: bool = True,
-        streaming: bool = False,
-        elem_id: str | None = None,
-        **kwargs,
-    ):
-        super().__init__(
-            value=value,
-            source=source,
-            type=type,
-            label=label,
-            show_label=show_label,
-            interactive=interactive,
-            visible=visible,
-            streaming=streaming,
-            elem_id=elem_id,
-            **kwargs,
-        )
-
-
-class Files(components.File):
-    """
-    Sets: file_count="multiple"
-    """
-
-    is_template = True
-
-    def __init__(
-        self,
-        value: str | list[str] | Callable | None = None,
-        *,
-        file_count: Literal["multiple"] = "multiple",
-        type: Literal["file", "binary"] = "file",
-        label: str | None = None,
-        show_label: bool = True,
-        interactive: bool | None = None,
-        visible: bool = True,
-        elem_id: str | None = None,
-        **kwargs,
-    ):
-        super().__init__(
-            value=value,
-            file_count=file_count,
-            type=type,
-            label=label,
-            show_label=show_label,
-            interactive=interactive,
-            visible=visible,
-            elem_id=elem_id,
-            **kwargs,
-        )
-
-
-class Numpy(components.Dataframe):
-    """
-    Sets: type="numpy"
-    """
-
-    is_template = True
-
-    def __init__(
-        self,
-        value: list[list[Any]] | Callable | None = None,
-        *,
-        headers: list[str] | None = None,
-        row_count: int | tuple[int, str] = (1, "dynamic"),
-        col_count: int | tuple[int, str] | None = None,
-        datatype: str | list[str] = "str",
-        type: Literal["numpy"] = "numpy",
-        max_rows: int | None = 20,
-        max_cols: int | None = None,
-        overflow_row_behaviour: Literal["paginate", "show_ends"] = "paginate",
-        label: str | None = None,
-        show_label: bool = True,
-        interactive: bool | None = None,
-        visible: bool = True,
-        elem_id: str | None = None,
-        wrap: bool = False,
-        **kwargs,
-    ):
-        super().__init__(
-            value=value,
-            headers=headers,
-            row_count=row_count,
-            col_count=col_count,
-            datatype=datatype,
-            type=type,
-            max_rows=max_rows,
-            max_cols=max_cols,
-            overflow_row_behaviour=overflow_row_behaviour,
-            label=label,
-            show_label=show_label,
-            interactive=interactive,
-            visible=visible,
-            elem_id=elem_id,
-            wrap=wrap,
-            **kwargs,
-        )
-
-
-class Matrix(components.Dataframe):
-    """
-    Sets: type="array"
-    """
-
-    is_template = True
-
-    def __init__(
-        self,
-        value: list[list[Any]] | Callable | None = None,
-        *,
-        headers: list[str] | None = None,
-        row_count: int | tuple[int, str] = (1, "dynamic"),
-        col_count: int | tuple[int, str] | None = None,
-        datatype: str | list[str] = "str",
-        type: Literal["array"] = "array",
-        max_rows: int | None = 20,
-        max_cols: int | None = None,
-        overflow_row_behaviour: Literal["paginate", "show_ends"] = "paginate",
-        label: str | None = None,
-        show_label: bool = True,
-        interactive: bool | None = None,
-        visible: bool = True,
-        elem_id: str | None = None,
-        wrap: bool = False,
-        **kwargs,
-    ):
-        super().__init__(
-            value=value,
-            headers=headers,
-            row_count=row_count,
-            col_count=col_count,
-            datatype=datatype,
-            type=type,
-            max_rows=max_rows,
-            max_cols=max_cols,
-            overflow_row_behaviour=overflow_row_behaviour,
-            label=label,
-            show_label=show_label,
-            interactive=interactive,
-            visible=visible,
-            elem_id=elem_id,
-            wrap=wrap,
-            **kwargs,
-        )
-
-
-class List(components.Dataframe):
-    """
-    Sets: type="array", col_count=1
-    """
-
-    is_template = True
-
-    def __init__(
-        self,
-        value: list[list[Any]] | Callable | None = None,
-        *,
-        headers: list[str] | None = None,
-        row_count: int | tuple[int, str] = (1, "dynamic"),
-        col_count: Literal[1] = 1,
-        datatype: str | list[str] = "str",
-        type: Literal["array"] = "array",
-        max_rows: int | None = 20,
-        max_cols: int | None = None,
-        overflow_row_behaviour: Literal["paginate", "show_ends"] = "paginate",
-        label: str | None = None,
-        show_label: bool = True,
-        interactive: bool | None = None,
-        visible: bool = True,
-        elem_id: str | None = None,
-        wrap: bool = False,
-        **kwargs,
-    ):
-        super().__init__(
-            value=value,
-            headers=headers,
-            row_count=row_count,
-            col_count=col_count,
-            datatype=datatype,
-            type=type,
-            max_rows=max_rows,
-            max_cols=max_cols,
-            overflow_row_behaviour=overflow_row_behaviour,
-            label=label,
-            show_label=show_label,
-            interactive=interactive,
-            visible=visible,
-            elem_id=elem_id,
-            wrap=wrap,
-            **kwargs,
-        )
-
-
-Mic = Microphone