Update parquet files (step 43 of 249)

spaces/0x90e/ESRGAN-MANGA/util.py

@@ -1,6 +0,0 @@
-import os
-
-def is_google_colab():
-    if os.getenv("COLAB_RELEASE_TAG"):
-        return True
-    return False

spaces/1acneusushi/gradio-2dmoleculeeditor/data/Crackear Photoshop Uma Soluo ou um Problema? Descubra os Prs e Contras.md

@@ -1,14 +0,0 @@
-<br />
-<h1>How to Crack Photoshop: Risks and Alternatives</h1>
-<p>Photoshop is a widely used software for photo and image editing. However, the software can be quite expensive for some people. Some people may resort to Photoshop cracks to use the software for free. Although this may seem like a good idea at first, it is important to know the risks associated with cracked software. In this article, we will explain what Photoshop cracks are, why they are illegal and dangerous, and what are some better alternatives to get Photoshop legally and safely.</p>
-<h2>What is a Photoshop Crack?</h2>
-<p>A Photoshop crack is a software program used to bypass the activation process of Adobe Photoshop software. Cracks are usually created by third-party individuals or organizations and are not endorsed by Adobe. Using a cracked version of Photoshop can result in various risks, such as viruses, malware, or spyware installed on your computer. Moreover, cracked software may not receive updates from the manufacturer, which means that you may miss important security patches. It is important to note that Adobe does not support the use of cracked software and may take legal action against individuals or organizations that distribute cracks.</p>
-<h2>como crackear photoshop</h2><br /><p><b><b>Download</b> &rArr; <a href="https://byltly.com/2uKvIs">https://byltly.com/2uKvIs</a></b></p><br /><br />
-<h2>Why is Using Photoshop Crack Illegal and Dangerous?</h2>
-<p>There are some reasons why using Photoshop crack is illegal and dangerous. First of all, cracked software is illegal. By using a cracked version of Photoshop, you are breaking the law and may be subject to penalties. Additionally, cracked software is usually unstable and full of viruses. This can cause your computer to crash or worse, infect other computers with malware. Furthermore, Photoshop crack may also ban you from certain websites and online forums. Many websites have policies against using cracked software and will ban users who are caught doing so. Sometimes, your IP address may be blacklisted, preventing you from accessing certain websites or online services.</p>
-<h2>What are Some Alternatives to Photoshop Crack?</h2>
-<p>If you want to use Photoshop legally and safely, there are some alternatives to Photoshop crack that you can consider. One option is to use the free trial version of Photoshop that Adobe offers on its website. The trial version allows you to use all the features of Photoshop for 7 days without any cost. This way, you can test the software before deciding whether to buy it or not. Another option is to use Adobe's subscription plan, which gives you access to Photoshop and other Adobe products for a monthly or yearly fee. The subscription plan also includes cloud storage, online services, and regular updates. You can choose from different plans depending on your needs and budget.</p>
-<h2>Conclusion</h2>
-<p>Photoshop crack is not a good idea if you want to use Photoshop for photo and image editing. Cracked software is illegal, dangerous, and unreliable. It can expose you to various risks such as viruses, malware, spyware, legal issues, and bans. Instead of using Photoshop crack, you should consider using the free trial version or the subscription plan that Adobe offers on its website. These alternatives are legal, safe, and reliable. They also provide you with the best features and performance that Photoshop can offer.</p> ddb901b051<br />
-<br />
-<br />

spaces/1acneusushi/gradio-2dmoleculeeditor/data/Free Download Arcgis 10.8 Full Crack.md

@@ -1,17 +0,0 @@
-<br />
-<h1>How to Free Download ArcGIS 10.8 Full Crack and Install It on Your PC</h1>
-<p>ArcGIS is a powerful software that allows you to create, analyze, and visualize geographic data. It is widely used by professionals and students in various fields such as geography, urban planning, environmental science, engineering, and more. However, ArcGIS is not a free software and you need to purchase a license to use it.</p>
-<p>But what if you want to use ArcGIS for free without paying anything? Is there a way to free download ArcGIS 10.8 full crack and install it on your PC? The answer is yes, but you need to be careful and follow some steps to avoid any malware or viruses. Here is how you can do it:</p>
-<h2>free download arcgis 10.8 full crack</h2><br /><p><b><b>Download File</b> &#10027;&#10027;&#10027; <a href="https://byltly.com/2uKxxw">https://byltly.com/2uKxxw</a></b></p><br /><br />
-<ol>
-<li>First, you need to download the ArcGIS 10.8 setup file from a reliable source. You can use this link: <a href="https://www.esri.com/en-us/industries/overview">https://www.esri.com/en-us/industries/overview</a>. Click on the download button and choose the version 10.8 from the list.</li>
-<li>Next, you need to download the ArcGIS 10.8 crack file from another source. You can use this link: <a href="https://crackdaily.com/arcgis-crack/">https://crackdaily.com/arcgis-crack/</a>. Scroll down and click on the green download button.</li>
-<li>After downloading both files, you need to disable your antivirus software temporarily. This is because the crack file may be detected as a virus by some antivirus programs, but it is actually safe to use.</li>
-<li>Then, you need to install ArcGIS 10.8 by running the setup file. Follow the instructions and complete the installation process.</li>
-<li>Next, you need to copy the crack file and paste it in the ArcGIS installation folder. The default location is C:\Program Files (x86)\ArcGIS or C:\Program Files\ArcGIS depending on your system architecture.</li>
-<li>After that, you need to run the crack file as administrator. Click on the crack button and wait for it to finish.</li>
-<li>Finally, you need to restart your computer and enjoy using ArcGIS 10.8 full crack for free.</li>
-</ol>
-<p>Note: This method is only for educational purposes and we do not recommend using cracked software. If you like ArcGIS and want to support its development, please buy a license from its official website: <a href="https://www.esri.com/en-us/home">https://www.esri.com/en-us/home</a>.</p> ddb901b051<br />
-<br />
-<br />

spaces/1gistliPinn/ChatGPT4/Examples/Electude-motor-diagnosis-descargar.md

@@ -1,36 +0,0 @@
-<h2>electude-motor-diagnosis-descargar</h2><br /><p><b><b>DOWNLOAD</b> &#10038; <a href="https://imgfil.com/2uxXXn">https://imgfil.com/2uxXXn</a></b></p><br /><br />
-<br />
--navegador-motor-diagnosis-e-letras/
-
-Thu, 05 Apr 2018 12:16:26 +0000
-
-motor-diagnosis-descargar-navegador-motor-diagnosis-e-letras/Siemens announces UFER Enterprise Platform for the industrial internet of things
-
-Siemens has announced UFER, an enterprise software platform that combines artificial intelligence and the industrial internet of things to help companies process vast amounts of information generated by industrial sensors and machines to transform business operations in production and the environment.
-
-Siemens AG’s UFER platform will go into pilot use in July 2018. The pilot is targeted at the automotive industry, where UFER will work together with Siemens’ new PlantWise system for the machine-to-machine industrial internet. PlantWise is expected to be released commercially in 2019.
-
-UFER has four main purposes:
-
-Reducing the risk of accidents and operational disruptions by processing data from industrial sensors and machines to make it available for analysis at a moment’s notice.
-
-Organizing data from multiple sources and producing a common, actionable view of plant operations.
-
-Enabling businesses to become more productive by using data from machines, sensors and the internet of things to optimize production and service processes.
-
-Reducing costs by optimizing maintenance processes, improving the efficiency of plant operations, and capturing data that can be used to develop new products or services.
-
-UFER will be developed in collaboration with IBM, leading international manufacturing company, as well as a number of smaller partner companies in a selected industry sector.
-
-UFER’s main focus is on the automotive industry. This industry has one of the most complex IT infrastructures in the world, including:
-
-Production lines for which plant operations require close monitoring, such as those for powertrain components and fuel injection systems;
-
-Networks of machines that capture and analyze plant operations data, such as the multi-sensor networks of forklifts, cranes and conveyor belts;
-
-PlantWise, which is ready for the commercial release in 2019, will feed UFER with production data from the plant, such as production rate and inventory information, and process it to make it available for analysis at a moment’s notice.
-
-The U 4fefd39f24<br />
-<br />
-<br />
-<p></p>

spaces/1line/AutoGPT/autogpt/commands/write_tests.py

@@ -1,31 +0,0 @@
-"""A module that contains a function to generate test cases for the submitted code."""
-from __future__ import annotations
-
-import json
-
-from autogpt.llm_utils import call_ai_function
-
-
-def write_tests(code: str, focus: list[str]) -> str:
-    """
-    A function that takes in code and focus topics and returns a response from create
-      chat completion api call.
-
-    Parameters:
-        focus (list): A list of suggestions around what needs to be improved.
-        code (str): Code for test cases to be generated against.
-    Returns:
-        A result string from create chat completion. Test cases for the submitted code
-          in response.
-    """
-
-    function_string = (
-        "def create_test_cases(code: str, focus: Optional[str] = None) -> str:"
-    )
-    args = [code, json.dumps(focus)]
-    description_string = (
-        "Generates test cases for the existing code, focusing on"
-        " specific areas if required."
-    )
-
-    return call_ai_function(function_string, args, description_string)

spaces/1line/AutoGPT/autogpt/speech/macos_tts.py

@@ -1,21 +0,0 @@
-""" MacOS TTS Voice. """
-import os
-
-from autogpt.speech.base import VoiceBase
-
-
-class MacOSTTS(VoiceBase):
-    """MacOS TTS Voice."""
-
-    def _setup(self) -> None:
-        pass
-
-    def _speech(self, text: str, voice_index: int = 0) -> bool:
-        """Play the given text."""
-        if voice_index == 0:
-            os.system(f'say "{text}"')
-        elif voice_index == 1:
-            os.system(f'say -v "Ava (Premium)" "{text}"')
-        else:
-            os.system(f'say -v Samantha "{text}"')
-        return True

spaces/1phancelerku/anime-remove-background/Enjoy Unlimited VK Music Download with the Best Tools.md

@@ -1,127 +0,0 @@
-<br />
-<h1>How to Download VK Music in 2023</h1>
-<p>VK, also known as VKontakte, is a popular social media platform in Russia and Europe. It offers a wide range of media content, including movies, videos, photos, and music. Many users enjoy listening to music on VK, as it has a large collection of songs from various genres and artists. However, sometimes you may want to download music from VK to your device, so you can listen to it offline, without ads, or with other players. How can you do that?</p>
-<p>In this article, we will show you four available ways to download music from VK in 2023. You can choose the one that suits your needs and preferences best. Let's get started!</p>
-<h2>download vk music</h2><br /><p><b><b>Download File</b> &#10084;&#10084;&#10084; <a href="https://jinyurl.com/2uNUpF">https://jinyurl.com/2uNUpF</a></b></p><br /><br />
- <h2>Method 1: Use TunesKit Audio Capture to Record and Download VK Music</h2>
-<p>TunesKit Audio Capture is a powerful audio recorder for Windows and Mac that can capture any sound from your computer. It can record and download VK music and other streaming audios from any programs and websites. It can also save the recordings in any format, including MP3, WAV, FLAC, AAC, etc. It preserves the original audio quality and ID3 tags of the VK music. Moreover, it supports batch recording and editing of multiple audio tracks.</p>
-<p>To use TunesKit Audio Capture to download music from VK, you need to follow these steps:</p>
-<ol>
-<li>Download and install TunesKit Audio Capture on your computer.</li>
-<li>Launch the program and check if there is a browser on the program list. If not, you can add it by drag-and-drop.</li>
-<li>Go to the VK website and find the music you want to download.</li>
-<li>Click the Format button and select MP3 or any other format you prefer.</li>
-<li>Play the music on VK and TunesKit Audio Capture will start recording it automatically.</li>
-<li>When the music ends, click the Stop button and edit the audio if needed.</li>
-<li>Save the audio file to your computer and enjoy it offline.</li>
-</ol>
- <h2>Method 2: Use VK Music Downloader Extension for Chrome to Download VK Music</h2>
-<p>VK Music Downloader is a free extension for Chrome that helps you download your music on VK.com. It saves the original name of the soundtrack and allows you to download all playlists and groups of songs at once. It has no ads and the code is open and not obfuscated. However, it does not support batch downloading of songs.</p>
-<p>To use VK Music Downloader extension for Chrome to download music from VK, you need to follow these steps:</p>
-<ol>
-<li>Add the extension to your Chrome browser from [6](https://chrome.google.com/webstore/detail/%D1%81%D0%BA%D0%B0%D1%87%D0%B0%D1%82%D1%8C-%D0%BC%D1%83%D0%B7%D1%8B%D0%BA%D1%83-%D1%81-%D0%B2%D0%BA/bgmpjmdignpongmfjpgaikghaajeidid?hl=en).</li>
-<li>Go to the VK website and find the music you want to download.</li>
-<li>Click on the green arrow icon next to the song title and select Download.</li>
-<li>Save the audio file to your computer and enjoy it offline.</li>
-</ol>
- <h2>Method 3: Use SaveFrom.net Online Service to Download VK Music</h2>
-<p>SaveFrom.net is an online service that allows you to download videos and audios from various websites, including YouTube, Facebook, Instagram, Vimeo, and VK. It supports various formats, such as MP4, MP3, WEBM, etc. It is easy to use and does not require any installation or registration.</p>
-<p>To use SaveFrom.net online service to download music from VK, you need to follow these steps:</p>
-<ol>
-<li>Go to [11](https://en -savefrom.net/) and paste the URL of the VK music you want to download.</li>
-<li>Click on the Download button and choose the format and quality you prefer.</li>
-<li>Save the audio file to your computer and enjoy it offline.</li>
-</ol>
- <h2>Method 4: Use Music Downloader for VK Extension for Chrome to Download VK Music</h2>
-<p>Music Downloader for VK is another free extension for Chrome that enables you to download music from VK.com. It adds a download button to each song on the VK website and allows you to download multiple songs at once. It also supports downloading music from other websites, such as SoundCloud, Bandcamp, YouTube, etc. However, it may not work with some songs due to copyright issues.</p>
-<p>How to download music from VKontakte<br />
-VK music downloader Chrome extension<br />
-VK MP3 downloader online<br />
-Best VK music downloader for Windows and Mac<br />
-Download VK music to iPhone or Android<br />
-VK music downloader app for PC<br />
-Free VK music downloader software<br />
-Download VK music playlist in one click<br />
-Download VK music with original quality and ID3 tags<br />
-Download VK music in MP3, AAC, FLAC, WAV, M4A, or M4B format<br />
-Download VK music without registration or login<br />
-Download VK music with subtitles or lyrics<br />
-Download VK music videos and convert to audio<br />
-Download VK music offline and play without internet<br />
-Download VK music from private or public groups<br />
-Download VK music by genre, artist, album, or song name<br />
-Download VK music faster and safer<br />
-Download VK music legally and ethically<br />
-Download VK music without ads or malware<br />
-Download VK music with high speed and stability<br />
-Download unlimited VK music for free<br />
-Download multiple VK music tracks simultaneously<br />
-Download VK music and transfer to iTunes or Spotify<br />
-Download VK music and burn to CD or DVD<br />
-Download VK music and edit with audio editor<br />
-Download VK music and set as ringtone or alarm<br />
-Download VK music and share with friends or family<br />
-Download VK music and sync to cloud storage or devices<br />
-Download VK music and enjoy on any player or device<br />
-Download VK music and create your own playlist or library<br />
-Tips and tricks for downloading VK music easily and efficiently<br />
-Reviews and ratings of the best VK music downloaders in 2023<br />
-Comparison of different methods to download VK music online or offline<br />
-Pros and cons of various types of VK music downloaders for different needs<br />
-FAQs and solutions for downloading VK music from Vkontakte<br />
-How to download HD or 4K VK music videos from Vkontakte<br />
-How to download live or streaming VK music from Vkontakte<br />
-How to download podcasts or audiobooks from Vkontakte<br />
-How to download radio or DJ mixes from Vkontakte<br />
-How to download karaoke or instrumental tracks from Vkontakte<br />
-How to download remixes or covers from Vkontakte<br />
-How to download soundtracks or background music from Vkontakte<br />
-How to download classical or jazz music from Vkontakte<br />
-How to download rock or metal music from Vkontakte<br />
-How to download pop or dance music from Vkontakte<br />
-How to download rap or hip hop music from Vkontakte<br />
-How to download country or folk music from Vkontakte<br />
-How to download reggae or ska music from Vkontakte<br />
-How to download electronic or ambient music from Vkontakte</p>
-<p>To use Music Downloader for VK extension for Chrome to download music from VK, you need to follow these steps:</p>
-<ol>
-<li>Add the extension to your Chrome browser from [10](https://chrome.google.com/webstore/detail/music-downloader-for-vk/ahkohdihdjccebcfgjgffmpdjjknhgla?hl=en).</li>
-<li>Go to the VK website and find the music you want to download.</li>
-<li>Click on the download button next to the song title and select Download.</li>
-<li>Save the audio file to your computer and enjoy it offline.</li>
-</ol>
- <h2>Conclusion: How to Download VK Music in 2023</h2>
-<p>In conclusion, we have shown you four available ways to download music from VK in 2023. You can use TunesKit Audio Capture, VK Music Downloader, SaveFrom.net, or Music Downloader for VK to get your favorite songs from VK.com. Each method has its own advantages and disadvantages, so you can choose the one that works best for you. We recommend TunesKit Audio Capture as the best method, as it can record and download any sound from your computer with high quality and ID3 tags. It also supports batch recording and editing of multiple audio tracks.</p>
-<p>We hope this article has helped you learn how to download music from VK in 2023. If you have any questions or suggestions, please feel free to leave a comment below. Thank you for reading!</p>
- <h2>FAQs: How to Download VK Music in 2023</h2>
-<h3>Q1: Is it legal to download music from VK?</h3>
-<p>A1: It depends on the source and the purpose of downloading music from VK. If the music is uploaded by the original artist or authorized by them, then it is legal to download it for personal use. However, if the music is pirated or infringes on someone else's rights, then it is illegal to download it. You should always respect the intellectual property rights of the creators and follow the terms of service of VK.com.</p>
- <h3>Q2: How can I download music from VK on my Android phone?</h3>
-<p>A2: You can use an app called SnapTube to download music from VK on your Android phone. SnapTube is a video and music downloader that supports various websites, including YouTube, Facebook, Instagram, VK, etc. You can download SnapTube from [9](https://www.snaptubeapp.com/). To use SnapTube to download music from VK, you need to follow these steps:</p>
-<ol>
-<li>Open SnapTube and select VK from the list of supported sites.</li>
-<li>Login with your VK account and find the music you want to download.</li>
-<li>Tap on the Download button at the bottom right corner of the screen and choose MP3 or any other format you prefer.</li>
-<li>Save the audio file to your phone and enjoy it offline.</li>
-</ol>
- <h3>Q3: How can I download music from VK on my iPhone?</h3>
-<p>A3: You can use an app called Documents by Readdle to download music from VK on your iPhone. Documents by Readdle is a file manager and media player that also has a built-in browser and downloader. You can download Documents by Readdle from [8](https://apps.apple.com/us/app/documents-by-readdle/id364901807). To use Documents by Readdle to download music from VK, you need to follow these steps:</p>
-<ol>
-<li>Open Documents by Readdle and tap on the Browser icon at the bottom right corner of the screen.</li>
-<li>Go to [7](https://en-savefrom.net/) and paste the URL of the VK music you want to download.</li>
-<li>Tap on the Download button and choose MP3 or any other format you prefer.</li>
-<li>Save the audio file to your iPhone and enjoy it offline.</li>
-</ol>
- <h3>Q4: How can I transfer downloaded music from my computer to my phone?</ <h3>Q4: How can I transfer downloaded music from my computer to my phone?</h3>
-<p>A4: There are different ways to transfer downloaded music from your computer to your phone, depending on the type of your phone and the software you use. Here are some common methods:</p>
-<ul>
-<li>Use a USB cable to connect your phone to your computer and copy the music files to your phone's storage or SD card.</li>
-<li>Use a cloud service, such as Google Drive, Dropbox, or iCloud, to upload the music files from your computer and download them to your phone.</li>
-<li>Use a wireless transfer app, such as AirDroid, Shareit, or Xender, to send the music files from your computer to your phone via Wi-Fi or Bluetooth.</li>
-<li>Use a music streaming app, such as Spotify, Apple Music, or Amazon Music, to sync the music files from your computer to your phone.</li>
-</ul>
- <h3>Q5: How can I play downloaded music from VK on my phone?</h3>
-<p>A5: You can play downloaded music from VK on your phone using any music player app that supports the format of the audio files. For example, you can use VLC, MX Player, Poweramp, or Musicolet to play MP3, WAV, FLAC, or AAC files. You can also use the default music player app on your phone or the Documents by Readdle app if you downloaded the music using it.</p>
- <h4></h4></p> 401be4b1e0<br />
-<br />
-<br />

spaces/801artistry/RVC801/Applio-RVC-Fork/utils/clonerepo_experimental.py

@@ -1,253 +0,0 @@
-import os
-import subprocess
-import shutil
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from tqdm.notebook import tqdm
-from pathlib import Path
-import requests
-
-def run_script():
-    def run_cmd(cmd):
-        process = subprocess.run(cmd, shell=True, check=True, text=True)
-        return process.stdout
-
-    # Change the current directory to /content/
-    os.chdir('/content/')
-    print("Changing dir to /content/")
-
-    # Your function to edit the file
-    def edit_file(file_path):
-        temp_file_path = "/tmp/temp_file.py"
-        changes_made = False
-        with open(file_path, "r") as file, open(temp_file_path, "w") as temp_file:
-            previous_line = ""
-            second_previous_line = ""
-            for line in file:
-                new_line = line.replace("value=160", "value=128")
-                if new_line != line:
-                    print("Replaced 'value=160' with 'value=128'")
-                    changes_made = True
-                line = new_line
-
-                new_line = line.replace("crepe hop length: 160", "crepe hop length: 128")
-                if new_line != line:
-                    print("Replaced 'crepe hop length: 160' with 'crepe hop length: 128'")
-                    changes_made = True
-                line = new_line
-
-                new_line = line.replace("value=0.88", "value=0.75")
-                if new_line != line:
-                    print("Replaced 'value=0.88' with 'value=0.75'")
-                    changes_made = True
-                line = new_line
-
-                if "label=i18n(\"输入源音量包络替换输出音量包络融合比例，越靠近1越使用输出包络\")" in previous_line and "value=1," in line:
-                    new_line = line.replace("value=1,", "value=0.25,")
-                    if new_line != line:
-                        print("Replaced 'value=1,' with 'value=0.25,' based on the condition")
-                        changes_made = True
-                    line = new_line
-
-                if "label=i18n(\"总训练轮数total_epoch\")" in previous_line and "value=20," in line:
-                    new_line = line.replace("value=20,", "value=500,")
-                    if new_line != line:
-                        print("Replaced 'value=20,' with 'value=500,' based on the condition for DEFAULT EPOCH")
-                        changes_made = True
-                    line = new_line
-
-                if 'choices=["pm", "harvest", "dio", "crepe", "crepe-tiny", "mangio-crepe", "mangio-crepe-tiny"], # Fork Feature. Add Crepe-Tiny' in previous_line:
-                    if 'value="pm",' in line:
-                        new_line = line.replace('value="pm",', 'value="mangio-crepe",')
-                        if new_line != line:
-                            print("Replaced 'value=\"pm\",' with 'value=\"mangio-crepe\",' based on the condition")
-                            changes_made = True
-                        line = new_line
-
-                new_line = line.replace('label=i18n("输入训练文件夹路径"), value="E:\\\\语音音频+标注\\\\米津玄师\\\\src"', 'label=i18n("输入训练文件夹路径"), value="/content/dataset/"')
-                if new_line != line:
-                    print("Replaced 'label=i18n(\"输入训练文件夹路径\"), value=\"E:\\\\语音音频+标注\\\\米津玄师\\\\src\"' with 'label=i18n(\"输入训练文件夹路径\"), value=\"/content/dataset/\"'")
-                    changes_made = True
-                line = new_line
-
-                if 'label=i18n("是否仅保存最新的ckpt文件以节省硬盘空间"),' in second_previous_line:
-                    if 'value=i18n("否"),' in line:
-                        new_line = line.replace('value=i18n("否"),', 'value=i18n("是"),')
-                        if new_line != line:
-                            print("Replaced 'value=i18n(\"否\"),' with 'value=i18n(\"是\"),' based on the condition for SAVE ONLY LATEST")
-                            changes_made = True
-                        line = new_line
-
-                if 'label=i18n("是否在每次保存时间点将最终小模型保存至weights文件夹"),' in second_previous_line:
-                    if 'value=i18n("否"),' in line:
-                        new_line = line.replace('value=i18n("否"),', 'value=i18n("是"),')
-                        if new_line != line:
-                            print("Replaced 'value=i18n(\"否\"),' with 'value=i18n(\"是\"),' based on the condition for SAVE SMALL WEIGHTS")
-                            changes_made = True
-                        line = new_line
-
-                temp_file.write(line)
-                second_previous_line = previous_line
-                previous_line = line
-
-        # After finished, we replace the original file with the temp one
-        import shutil
-        shutil.move(temp_file_path, file_path)
-
-        if changes_made:
-            print("Changes made and file saved successfully.")
-        else:
-            print("No changes were needed.")
-
-    # Define the repo path
-    repo_path = '/content/Applio-RVC-Fork'
-
-    def copy_all_files_in_directory(src_dir, dest_dir):
-        # Iterate over all files in source directory
-        for item in Path(src_dir).glob('*'):
-            if item.is_file():
-                # Copy each file to destination directory
-                shutil.copy(item, dest_dir)
-            else:
-                # If it's a directory, make a new directory in the destination and copy the files recursively
-                new_dest = Path(dest_dir) / item.name
-                new_dest.mkdir(exist_ok=True)
-                copy_all_files_in_directory(str(item), str(new_dest))
-
-    def clone_and_copy_repo(repo_path):
-        # New repository link
-        new_repo_link = "https://github.com/IAHispano/Applio-RVC-Fork/"
-        # Temporary path to clone the repository
-        temp_repo_path = "/content/temp_Applio-RVC-Fork"
-        # New folder name
-        new_folder_name = "Applio-RVC-Fork"
-
-        # Clone the latest code from the new repository to a temporary location
-        run_cmd(f"git clone {new_repo_link} {temp_repo_path}")
-        os.chdir(temp_repo_path)
-
-        run_cmd(f"git checkout 3fa4dad3d8961e5ca2522e9e12c0b4ddb71ad402")
-        run_cmd(f"git checkout f9e606c279cb49420597519b0a83b92be81e42e4")
-        run_cmd(f"git checkout 9e305588844c5442d58add1061b29beeca89d679")
-        run_cmd(f"git checkout bf92dc1eb54b4f28d6396a4d1820a25896cc9af8")
-        run_cmd(f"git checkout c3810e197d3cb98039973b2f723edf967ecd9e61")
-        run_cmd(f"git checkout a33159efd134c2413b0afe26a76b7dc87926d2de")
-        run_cmd(f"git checkout 24e251fb62c662e39ac5cf9253cc65deb9be94ec")
-        run_cmd(f"git checkout ad5667d3017e93232dba85969cddac1322ba2902")
-        run_cmd(f"git checkout ce9715392cf52dd5a0e18e00d1b5e408f08dbf27")
-        run_cmd(f"git checkout 7c7da3f2ac68f3bd8f3ad5ca5c700f18ab9f90eb")
-        run_cmd(f"git checkout 4ac395eab101955e8960b50d772c26f592161764")
-        run_cmd(f"git checkout b15b358702294c7375761584e5276c811ffab5e8")
-        run_cmd(f"git checkout 1501793dc490982db9aca84a50647764caa66e51")
-        run_cmd(f"git checkout 21f7faf57219c75e6ba837062350391a803e9ae2")
-        run_cmd(f"git checkout b5eb689fbc409b49f065a431817f822f554cebe7")
-        run_cmd(f"git checkout 7e02fae1ebf24cb151bf6cbe787d06734aa65862")
-        run_cmd(f"git checkout 6aea5ea18ed0b9a1e03fa5d268d6bc3c616672a9")
-        run_cmd(f"git checkout f0f9b25717e59116473fb42bd7f9252cfc32b398")
-        run_cmd(f"git checkout b394de424088a81fc081224bc27338a8651ad3b2")
-        run_cmd(f"git checkout f1999406a88b80c965d2082340f5ea2bfa9ab67a")
-        run_cmd(f"git checkout d98a0fa8dc715308dfc73eac5c553b69c6ee072b")
-        run_cmd(f"git checkout d73267a415fb0eba98477afa43ef71ffd82a7157")
-        run_cmd(f"git checkout 1a03d01356ae79179e1fb8d8915dc9cc79925742")
-        run_cmd(f"git checkout 81497bb3115e92c754300c9b3992df428886a3e9")
-        run_cmd(f"git checkout c5af1f8edcf79cb70f065c0110e279e78e48caf9")
-        run_cmd(f"git checkout cdb3c90109387fa4dfa92f53c3864c71170ffc77")
-
-        # Edit the file here, before copying
-        #edit_file(f"{temp_repo_path}/infer-web.py")
-
-        # Copy all files from the cloned repository to the existing path
-        copy_all_files_in_directory(temp_repo_path, repo_path)
-        print(f"Copying all {new_folder_name} files from GitHub.")
-
-        # Change working directory back to /content/
-        os.chdir('/content/')
-        print("Changed path back to /content/")
-        
-        # Remove the temporary cloned repository
-        shutil.rmtree(temp_repo_path)
-
-    # Call the function
-    clone_and_copy_repo(repo_path)
-
-    # Download the credentials file for RVC archive sheet
-    os.makedirs('/content/Applio-RVC-Fork/stats/', exist_ok=True)
-    run_cmd("wget -q https://cdn.discordapp.com/attachments/945486970883285045/1114717554481569802/peppy-generator-388800-07722f17a188.json -O /content/Applio-RVC-Fork/stats/peppy-generator-388800-07722f17a188.json")
-
-    # Forcefully delete any existing torchcrepe dependencies downloaded from an earlier run just in case
-    shutil.rmtree('/content/Applio-RVC-Fork/torchcrepe', ignore_errors=True)
-    shutil.rmtree('/content/torchcrepe', ignore_errors=True)
-
-    # Download the torchcrepe folder from the maxrmorrison/torchcrepe repository
-    run_cmd("git clone https://github.com/maxrmorrison/torchcrepe.git")
-    shutil.move('/content/torchcrepe/torchcrepe', '/content/Applio-RVC-Fork/')
-    shutil.rmtree('/content/torchcrepe', ignore_errors=True)  # Delete the torchcrepe repository folder
-
-    # Change the current directory to /content/Applio-RVC-Fork
-    os.chdir('/content/Applio-RVC-Fork')
-    os.makedirs('pretrained', exist_ok=True)
-    os.makedirs('uvr5_weights', exist_ok=True)
-
-def download_file(url, filepath):
-    response = requests.get(url, stream=True)
-    response.raise_for_status()
-
-    with open(filepath, "wb") as file:
-        for chunk in response.iter_content(chunk_size=8192):
-            if chunk:
-                file.write(chunk)
-
-def download_pretrained_models():
-    pretrained_models = {
-        "pretrained": [
-            "D40k.pth",
-            "G40k.pth",
-            "f0D40k.pth",
-            "f0G40k.pth"
-        ],
-        "pretrained_v2": [
-            "D40k.pth",
-            "G40k.pth",
-            "f0D40k.pth",
-            "f0G40k.pth",
-            "f0G48k.pth",
-            "f0D48k.pth"
-        ],
-        "uvr5_weights": [
-            "HP2-人声vocals+非人声instrumentals.pth",
-            "HP5-主旋律人声vocals+其他instrumentals.pth",
-            "VR-DeEchoNormal.pth",
-            "VR-DeEchoDeReverb.pth",
-            "VR-DeEchoAggressive.pth",
-            "HP5_only_main_vocal.pth",
-            "HP3_all_vocals.pth",
-            "HP2_all_vocals.pth"
-        ]
-    }
-    part2 = "I"
-    base_url = "https://huggingface.co/lj1995/VoiceConversionWebU" + part2 + "/resolve/main/"
-    base_path = "/content/Applio-RVC-Fork/"
-    base_pathm = base_path
-
-    # Calculate total number of files to download
-    total_files = sum(len(files) for files in pretrained_models.values()) + 1  # +1 for hubert_base.pt
-
-    with tqdm(total=total_files, desc="Downloading files") as pbar:
-        for folder, models in pretrained_models.items():
-            folder_path = os.path.join(base_path, folder)
-            os.makedirs(folder_path, exist_ok=True)
-            for model in models:
-                url = base_url + folder + "/" + model
-                filepath = os.path.join(folder_path, model)
-                download_file(url, filepath)
-                pbar.update()
-
-        # Download hubert_base.pt to the base path
-        hubert_url = base_url + "hubert_base.pt"
-        hubert_filepath = os.path.join(base_pathm, "hubert_base.pt")
-        download_file(hubert_url, hubert_filepath)
-        pbar.update()
-def clone_repository(run_download):
-    with ThreadPoolExecutor(max_workers=2) as executor:
-        executor.submit(run_script)
-        if run_download:
-            executor.submit(download_pretrained_models)

spaces/AIConsultant/MusicGen/audiocraft/solvers/base.py

@@ -1,631 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-from abc import ABC, abstractmethod
-from contextlib import contextmanager
-from pathlib import Path
-import typing as tp
-
-import flashy
-import omegaconf
-import torch
-from torch import nn
-
-from .. import optim
-from ..optim import fsdp
-from ..utils import checkpoint
-from ..utils.autocast import TorchAutocast
-from ..utils.best_state import BestStateDictManager
-from ..utils.deadlock import DeadlockDetect
-from ..utils.profiler import Profiler
-from ..utils.utils import copy_state, dict_from_config, model_hash, with_rank_rng
-
-
-class StandardSolver(ABC, flashy.BaseSolver):
-    """Standard solver for AudioCraft.
-
-    The standard solver implements a base training loop with the following stages:
-    train, valid, evaluate and generate that are expected to be all defined for
-    solvers in AudioCraft. It also provides a nice default management of Dora history replay,
-    checkpoint management across epoch, and logging configuration.
-
-    AudioCraft solvers must inherit from the StandardSolver and define the methods
-    associated to each stage as well as the show, build_model and build_dataloaders methods.
-    """
-    def __init__(self, cfg: omegaconf.DictConfig):
-        super().__init__()
-        self.logger.info(f"Instantiating solver {self.__class__.__name__} for XP {self.xp.sig}")
-        self.logger.info(f"All XP logs are stored in {self.xp.folder}")
-        self.cfg = cfg
-        self.device = cfg.device
-        self.model: nn.Module
-        self._continue_best_source_keys = ['best_state', 'fsdp_best_state']
-        self._fsdp_modules: tp.List[fsdp.FSDP] = []
-        self._ema_sources: nn.ModuleDict = nn.ModuleDict()
-        self.ema: tp.Optional[optim.ModuleDictEMA] = None
-        self.dataloaders: tp.Dict[str, torch.utils.data.DataLoader] = dict()
-        self._log_updates = self.cfg.logging.get('log_updates', 10)
-        if self.cfg.logging.log_tensorboard:
-            self.init_tensorboard(**self.cfg.get('tensorboard'))
-        if self.cfg.logging.log_wandb and self:
-            self.init_wandb(**self.cfg.get('wandb'))
-        # keep a copy of the best performing state for stateful objects
-        # used for evaluation and generation stages
-        dtype_best: tp.Optional[torch.dtype] = None
-        if self.cfg.fsdp.use:
-            dtype_best = getattr(torch, self.cfg.fsdp.param_dtype)  # type: ignore
-            assert isinstance(dtype_best, torch.dtype)
-        elif self.cfg.autocast:
-            dtype_best = getattr(torch, self.cfg.autocast_dtype)  # type: ignore
-            assert isinstance(dtype_best, torch.dtype)
-        self.best_state: BestStateDictManager = BestStateDictManager(dtype=dtype_best)
-        # Hacky support for keeping a copy of the full best state in rank0.
-        self.fsdp_best_state: tp.Dict[str, tp.Any] = {}
-        self.register_stateful('best_state', 'fsdp_best_state')  # register best_state object to keep it in state_dict
-        self._new_best_state: bool = False  # should save a new checkpoint
-        # instantiate datasets and appropriate number of updates per epoch
-        self.build_dataloaders()
-        if self.cfg.execute_only is None:
-            assert 'train' in self.dataloaders, "The train dataset split must be provided."
-            assert 'valid' in self.dataloaders, "The valid dataset split must be provided."
-        self.train_updates_per_epoch = len(self.dataloaders['train']) if 'train' in self.dataloaders else 0
-        if self.cfg.optim.updates_per_epoch:
-            self.train_updates_per_epoch = self.cfg.optim.updates_per_epoch
-        self.total_updates = self.train_updates_per_epoch * self.cfg.optim.epochs
-        # instantiate model & exponential moving average on the model
-        self.build_model()
-        self.logger.info("Model hash: %s", model_hash(self.model))
-        assert 'model' in self.stateful.sources, \
-            "Please register the model to stateful with self.register_stateful('model') in build_model."
-        self.profiler = Profiler(self.model, **self.cfg.profiler)
-        self.initialize_ema()
-        self.register_stateful('ema')
-        assert self.ema is None or 'ema' in self.stateful.sources, \
-            "Please register the ema to stateful with self.register_stateful('ema') in build_model."
-        self.deadlock_detect = DeadlockDetect(**self.cfg.deadlock)
-        # basic statistics on the trained model
-        model_size = sum(p.numel() for p in self.model.parameters() if p.requires_grad) / 1e6
-        # one copy of grad, one copy of momentum, one copy of denominator and model weights.
-        # and 4 bytes for each float!
-        mem_usage = model_size * 4 * 4 / 1000
-        self.logger.info("Model size: %.2f M params", model_size)
-        self.logger.info("Base memory usage, with model, grad and optim: %.2f GB", mem_usage)
-
-    @property
-    def autocast(self):
-        """Convenient autocast (or not) using the solver configuration."""
-        return TorchAutocast(enabled=self.cfg.autocast, device_type=self.device, dtype=self.autocast_dtype)
-
-    def _get_state_source(self, name) -> flashy.state.StateDictSource:
-        # Internal utility to get a state source from the solver
-        return self.stateful.sources[name]
-
-    @property
-    def best_metric_name(self) -> tp.Optional[str]:
-        """Metric name used to identify the best state. This metric should be stored in the metrics
-        used on the stage for best state identification (most likely, `valid`). If None, then
-        no best state is saved.
-        """
-        return None
-
-    def register_best_state(self, *args: str):
-        """Register state sources in `BestStateDictManager` to keep their best states along with their
-        latest states. The best state will be used at evaluation stages instead of the latest states.
-
-        Shortcut around `BestStateDictManager.register` method. You can pass any number of
-        attribute, included nested attributes and those will be included into the checkpoints
-        and automatically restored when `BaseSolver.restore` is called.
-        """
-        for name in args:
-            state_source = self._get_state_source(name)
-            assert name in self.stateful.sources, "Registered states in best should be registered in stateful first!"
-            self.best_state.register(name, state_source)
-
-    def register_ema(self, *args: str):
-        """Register state sources for exponential moving average.
-
-        The registered sources are used to instantiate a ModuleDictEMA instance.
-        The ModuleDictEMA keeps a `nn.ModuleDict` module that is updated when self.ema.step() is called
-        and swapped with the original state sources with self.swap_ema_state() method.
-
-        Usage:
-            self.register_ema('model')
-        """
-        assert self.ema is None, "Cannot register state source to already instantiated EMA."
-        for name in args:
-            self._ema_sources[name] = getattr(self, name)
-
-    def wrap_with_fsdp(self, model: torch.nn.Module, *args, **kwargs):
-        model = fsdp.wrap_with_fsdp(self.cfg.fsdp, model, *args, **kwargs)
-        if isinstance(model, fsdp.FSDP):
-            self._fsdp_modules.append(model)
-        return model
-
-    def update_best_state_from_stage(self, stage_name: str = 'valid'):
-        """Update latest best state based on pending metrics of a given stage. This method relies
-        on the `BestStateDictManager.update` method to update the best state_dict with latest weights
-        if the registered states happen to match to the best performing setup.
-        """
-        if self.best_metric_name is None:
-            # when no best metric is defined, the last state is always the best
-            self._new_best_state = True
-            self.logger.info("Updating best state with current state.")
-        else:
-            assert stage_name in self._pending_metrics, f"Metrics for stage {stage_name} not found."
-            assert self.best_metric_name in self._pending_metrics[stage_name], \
-                f"Best metric not found in {stage_name} metrics. Cannot register best state"
-            current_score = self._pending_metrics[stage_name][self.best_metric_name]
-            all_best_metric_scores = [
-                past_metrics[stage_name][self.best_metric_name]
-                for past_metrics in self.history
-            ]
-            all_best_metric_scores.append(current_score)
-            best_score = min(all_best_metric_scores)
-            self._new_best_state = current_score == best_score
-            if self._new_best_state:
-                old_best = min(all_best_metric_scores[:-1] + [float('inf')])
-                self.logger.info(
-                    f"New best state with {self.best_metric_name}={current_score:.3f} (was {old_best:.3f})")
-
-        if self._new_best_state:
-            if self.cfg.fsdp.use:
-                # this will give an empty state dict on all ranks but the rank 0
-                # which will have a copy in memory of the full model.
-                with fsdp.switch_to_full_state_dict(self._fsdp_modules):
-                    for name in self.best_state.states.keys():
-                        state_source = self._get_state_source(name)
-                        self.best_state.update(name, state_source)
-                    # we save to a different dict.
-                    self.fsdp_best_state.update(self.best_state.state_dict())
-                # We cannot efficiently load fsdp_best_state when using FSDP,
-                # so we have do do a second pass, with the local shards.
-            for name in self.best_state.states.keys():
-                state_source = self._get_state_source(name)
-                self.best_state.update(name, state_source)
-
-    def _load_new_state_dict(self, state_dict: dict) -> dict:
-        old_states = {}
-        for name, new_state in state_dict.items():
-            state_source = self._get_state_source(name)
-            old_states[name] = copy_state(state_source.state_dict())
-            state_source.load_state_dict(new_state)
-        return old_states
-
-    @contextmanager
-    def swap_best_state(self):
-        self.logger.debug(f"Swapping to best state for: {', '.join(self.best_state.state_dict().keys())}")
-        old_states = self._load_new_state_dict(self.best_state.state_dict())
-        try:
-            yield
-        finally:
-            self.logger.debug("Swapping back from best to original state")
-            for name, old_state in old_states.items():
-                state_source = self._get_state_source(name)
-                state_source.load_state_dict(old_state)
-
-    @contextmanager
-    def swap_ema_state(self):
-        if self.ema is None:
-            yield
-        else:
-            ema_state_dict = self.ema.state_dict()['state']
-            self.logger.debug(f"Swapping to EMA state for: {', '.join(ema_state_dict.keys())}")
-            old_states = self._load_new_state_dict(ema_state_dict)
-            try:
-                yield
-            finally:
-                self.logger.debug("Swapping back from EMA state to original state")
-                for name, old_state in old_states.items():
-                    state_source = self._get_state_source(name)
-                    state_source.load_state_dict(old_state)
-
-    @property
-    def is_training(self):
-        return self.current_stage == 'train'
-
-    def log_model_summary(self, model: nn.Module):
-        """Log model summary, architecture and size of the model."""
-        self.logger.info(model)
-        mb = sum(p.numel() for p in model.parameters()) * 4 / 2 ** 20
-        self.logger.info("Size: %.1f MB", mb)
-
-    @abstractmethod
-    def build_model(self):
-        """Method to implement to initialize model."""
-        ...
-
-    def initialize_ema(self):
-        """Initialize exponential moving average with the registered sources.
-        EMA object is created if the optim.ema.model.decay value is non-null.
-        """
-        from .builders import get_ema
-        self.ema = get_ema(self._ema_sources, self.cfg.optim.ema)
-        if self.ema is None:
-            self.logger.info('No EMA on the model.')
-        else:
-            assert self.cfg.optim.ema.updates > 0
-            self.logger.info(
-                f'Initializing EMA on the model with decay = {self.ema.decay}'
-                f' every {self.cfg.optim.ema.updates} updates'
-            )
-
-    @abstractmethod
-    def build_dataloaders(self):
-        """Method to implement to initialize dataloaders."""
-        ...
-
-    @abstractmethod
-    def show(self):
-        """Method to log any information without running the job."""
-        ...
-
-    @property
-    def log_updates(self):
-        # convenient access to log updates
-        return self._log_updates
-
-    def checkpoint_path(self, **kwargs):
-        kwargs.setdefault('use_fsdp', self.cfg.fsdp.use)
-        return self.folder / checkpoint.checkpoint_name(**kwargs)
-
-    def epoch_checkpoint_path(self, epoch: int, **kwargs):
-        kwargs.setdefault('use_fsdp', self.cfg.fsdp.use)
-        return self.folder / checkpoint.checkpoint_name(str(epoch), **kwargs)
-
-    def checkpoint_path_with_name(self, name: str, **kwargs):
-        kwargs.setdefault('use_fsdp', self.cfg.fsdp.use)
-        return self.folder / checkpoint.checkpoint_name(name=name, **kwargs)
-
-    def save_checkpoints(self):
-        """Save checkpoint, optionally keeping a copy for a given epoch."""
-        is_sharded = self.cfg.fsdp.use
-        if not flashy.distrib.is_rank_zero() and not is_sharded:
-            return
-        self.logger.info("Model hash: %s", model_hash(self.model))
-        state = self.state_dict()
-        epoch = self.epoch - 1  # pushing metrics will increase the epoch in Flashy, so we do -1 here
-
-        # save minimal state_dict as new checkpoint every X epoch
-        if self.cfg.checkpoint.save_every:
-            if epoch % self.cfg.checkpoint.save_every == 0:
-                minimal_state = state
-                if self.cfg.checkpoint.keep_every_states is not None and len(self.cfg.checkpoint.keep_every_states) > 0:
-                    minimal_state = {
-                        name: source for name, source in state.items()
-                        if name in self.cfg.checkpoint.keep_every_states
-                    }
-                epoch_checkpoint_path = self.epoch_checkpoint_path(epoch)
-                checkpoint.save_checkpoint(minimal_state, epoch_checkpoint_path, is_sharded)
-
-        # save checkpoint as latest checkpoint
-        if self.cfg.checkpoint.save_last:
-            last_checkpoint_path = self.checkpoint_path()
-            checkpoint.save_checkpoint(state, last_checkpoint_path, is_sharded)
-
-        # flush any stale checkpoint to reduce disk footprint
-        checkpoint.flush_stale_checkpoints(self.checkpoint_path())
-
-    def load_from_pretrained(self, name: str) -> dict:
-        raise NotImplementedError("Solver does not provide a way to load pretrained models.")
-
-    def load_checkpoints(self, load_best: bool = False, ignore_state_keys: tp.List[str] = []) -> tp.Optional[dict]:
-        """Load last checkpoint or the one specified in continue_from.
-
-        Args:
-            load_best (bool): Whether to load from best state dict or not.
-                Best state dict is always used when not loading the current xp.
-            ignore_state_keys (list of str): List of sources to ignore when loading the state, e.g. `optimizer`.
-        Returns:
-            state (dict, optional): The loaded state dictionary.
-        """
-        # load checkpoints from xp folder or cfg.continue_from
-        is_sharded = self.cfg.fsdp.use
-        load_from_path: tp.Optional[Path] = None
-        checkpoint_source: tp.Optional[checkpoint.CheckpointSource] = None
-
-        if load_best:
-            self.logger.info("Trying to load state_dict from best state.")
-
-        state: tp.Optional[dict] = None
-        rank0_checkpoint_path = self.checkpoint_path(use_fsdp=False)
-        current_checkpoint_path = self.checkpoint_path()
-        _pretrained_prefix = '//pretrained/'
-        continue_pretrained = (self.cfg.continue_from or '').startswith(_pretrained_prefix)
-        if rank0_checkpoint_path.exists():
-            self.logger.info(f"Loading existing checkpoint: {current_checkpoint_path}")
-            load_from_path = current_checkpoint_path
-            checkpoint.check_sharded_checkpoint(current_checkpoint_path, rank0_checkpoint_path)
-            checkpoint_source = checkpoint.CheckpointSource.CURRENT_XP
-        elif self.cfg.continue_from and not continue_pretrained:
-            self.logger.info(f"Continuing from provided checkpoint: {self.cfg.continue_from}")
-            # we're always continuing from consolidated checkpoints: self.cfg.use_fsdp and not continue_best
-            load_from_path = checkpoint.resolve_checkpoint_path(self.cfg.continue_from, use_fsdp=False)
-            if load_from_path is None:
-                self.logger.error('Could not resolve the continue_from checkpoint %s', self.cfg.continue_from)
-                raise RuntimeError(f'Could not resolve continue_from checkpoint {self.cfg.continue_from}')
-            checkpoint_source = checkpoint.CheckpointSource.OTHER
-
-        if load_from_path is not None:
-            state = checkpoint.load_checkpoint(load_from_path, is_sharded)
-        elif continue_pretrained:
-            self.logger.info("Loading a pretrained model. Ignoring 'load_best' and 'ignore_state_keys' params.")
-            state = self.load_from_pretrained(self.cfg.continue_from[len(_pretrained_prefix):])
-            checkpoint_source = checkpoint.CheckpointSource.PRETRAINED
-            load_best = True
-
-        # checkpoints are not from the current xp, we only retrieve the best state
-        if checkpoint_source is not None and checkpoint_source != checkpoint.CheckpointSource.CURRENT_XP:
-            assert state is not None
-            self.logger.info("Checkpoint source is not the current xp: Load state_dict from best state.")
-            load_best = True
-            state = {key: state[key] for key in self._continue_best_source_keys if key in state}
-            # loaded checkpoints are FSDP checkpoints: we're reading the best state
-            # from FSDP and we drop the regular best_state
-            if 'fsdp_best_state' in state and state['fsdp_best_state']:
-                state.pop('best_state', None)
-                self.logger.info("... Loaded checkpoint has FSDP best state")
-            # FSDP is enabled in the solver, if the loaded checkpoints do not have FSDP support
-            # then we're initializing FSDP best state with the regular best state
-            elif self.cfg.fsdp.use:
-                if 'fsdp_best_state' not in state or not state['fsdp_best_state']:
-                    # we swap non-FSDP checkpoints best_state to FSDP-compatible best state
-                    state['fsdp_best_state'] = state.pop('best_state')
-                    self.logger.info("... Loaded checkpoint does not have FSDP best state. Use regular best state")
-
-        if state is not None:
-            if load_best:
-                self.logger.info("Ignoring keys when loading best %r", ignore_state_keys)
-                for key in set(ignore_state_keys):
-                    if key in state:
-                        state.pop(key)
-                has_best_state = 'best_state' in state or 'fsdp_best_state' in state
-                assert has_best_state, ("Trying to load best state but neither 'best_state'",
-                                        " or 'fsdp_best_state' found in checkpoints.")
-            self.load_state_dict(state)
-
-        # for FSDP, let's make extra sure nothing bad happened with out of sync
-        # checkpoints across workers.
-        epoch = float(self.epoch)
-        avg_epoch = flashy.distrib.average_metrics({'epoch': epoch})['epoch']
-        if avg_epoch != epoch:
-            raise RuntimeError(
-                f"Inconsistent loading of checkpoints happened, our epoch is {epoch} "
-                f"but average of epochs is {avg_epoch}, at least one gpu must have a "
-                "different epoch number.")
-
-        # on load_best, properly reinitialize state_dict, best states and ema
-        # otherwise we load from the current xp and don't alter anything
-        if load_best:
-            self.logger.info("Loading state_dict from best state.")
-            if not self.cfg.fsdp.use and self.fsdp_best_state:
-                # loading from an FSDP checkpoint but with FSDP deactivated
-                self.logger.info("... Loading from FSDP best state dict.")
-                self.best_state.load_state_dict(self.fsdp_best_state)
-
-            # if load_best, we permanently override the regular state_dict with the best state
-            if self.cfg.fsdp.use:
-                self.logger.info("FSDP is used, loading from FSDP best state.")
-                with fsdp.switch_to_full_state_dict(self._fsdp_modules):
-                    # this might be really fragile but okay for now.
-                    self.load_state_dict(self.fsdp_best_state)
-            else:
-                # we permanently swap the stateful objects to their best state
-                self._load_new_state_dict(self.best_state.state_dict())
-
-            # the EMA modules should also be instantiated with best state.
-            # the easiest way to do so is to reinitialize a new EMA with best state loaded.
-            if self.ema is not None:
-                self.logger.info("Re-initializing EMA from best state")
-                self.initialize_ema()
-
-            if self.cfg.fsdp.use:
-                self.logger.info("Re-initializing best state after using FSDP best state.")
-                for name in self.best_state.states.keys():
-                    state_source = self._get_state_source(name)
-                    self.best_state.update(name, state_source)
-
-        return state
-
-    def restore(self, load_best: bool = False, replay_metrics: bool = False,
-                ignore_state_keys: tp.List[str] = []) -> bool:
-        """Restore the status of a solver for a given xp.
-
-        Args:
-            load_best (bool): if `True`, load the best state from the checkpoint.
-            replay_metrics (bool): if `True`, logs all the metrics from past epochs.
-            ignore_state_keys (list of str): list of sources to ignore when loading the state, e.g. `optimizer`.
-        """
-        self.logger.info("Restoring weights and history.")
-        restored_checkpoints = self.load_checkpoints(load_best, ignore_state_keys)
-
-        self.logger.info("Model hash: %s", model_hash(self.model))
-
-        if replay_metrics and len(self.history) > 0:
-            self.logger.info("Replaying past metrics...")
-            for epoch, stages in enumerate(self.history):
-                for stage_name, metrics in stages.items():
-                    # We manually log the metrics summary to the result logger
-                    # as we don't want to add them to the pending metrics
-                    self.result_logger._log_summary(stage_name, metrics, step=epoch + 1, step_name='epoch',
-                                                    formatter=self.get_formatter(stage_name))
-        return restored_checkpoints is not None
-
-    def commit(self, save_checkpoints: bool = True):
-        """Commit metrics to dora and save checkpoints at the end of an epoch."""
-        # we override commit to introduce more complex checkpoint saving behaviors
-        self.history.append(self._pending_metrics)  # This will increase self.epoch
-        if save_checkpoints:
-            self.save_checkpoints()
-        self._start_epoch()
-        if flashy.distrib.is_rank_zero():
-            self.xp.link.update_history(self.history)
-
-    def run_epoch(self):
-        """Run a single epoch with all stages.
-
-        Metrics for a given stage are stored in _pending_metrics and committed by the solver afterwards.
-        Children solvers can extend this method with custom behavior, e.g.:
-
-            def run_epoch(self):
-                ... # custom code
-                super().run_epoch()
-                ... # custom code
-        """
-        self.run_stage('train', self.train)
-        with torch.no_grad():
-            with self.swap_ema_state():
-                self.run_stage('valid', self.valid)
-                # the best state is updated with EMA states if available
-                self.update_best_state_from_stage('valid')
-            with self.swap_best_state():
-                if self.should_run_stage('evaluate'):
-                    self.run_stage('evaluate', self.evaluate)
-                if self.should_run_stage('generate'):
-                    self.run_stage('generate', with_rank_rng()(self.generate))
-
-    def run(self):
-        """Training loop."""
-        assert len(self.state_dict()) > 0
-        self.restore(replay_metrics=True)  # load checkpoint and replay history
-        self.log_hyperparams(dict_from_config(self.cfg))
-        for epoch in range(self.epoch, self.cfg.optim.epochs + 1):
-            if self.should_stop_training():
-                return
-            self.run_epoch()
-            # Commit will send the metrics to Dora and save checkpoints by default.
-            self.commit()
-
-    def should_stop_training(self) -> bool:
-        """Check whether we should stop training or not."""
-        return self.epoch > self.cfg.optim.epochs
-
-    def should_run_stage(self, stage_name) -> bool:
-        """Check whether we want to run the specified stages."""
-        stage_every = self.cfg[stage_name].get('every', None)
-        is_last_epoch = self.epoch == self.cfg.optim.epochs
-        is_epoch_every = (stage_every and self.epoch % stage_every == 0)
-        return is_last_epoch or is_epoch_every
-
-    @abstractmethod
-    def run_step(self, idx: int, batch: tp.Any, metrics: dict):
-        """Perform one training or valid step on a given batch."""
-        ...
-
-    def common_train_valid(self, dataset_split: str, **kwargs: tp.Any):
-        """Common logic for train and valid stages."""
-        self.model.train(self.is_training)
-
-        loader = self.dataloaders[dataset_split]
-        # get a different order for distributed training, otherwise this will get ignored
-        if flashy.distrib.world_size() > 1 \
-           and isinstance(loader.sampler, torch.utils.data.distributed.DistributedSampler):
-            loader.sampler.set_epoch(self.epoch)
-        updates_per_epoch = self.train_updates_per_epoch if self.is_training else len(loader)
-        if self.cfg.benchmark_no_load:
-            self.logger.warning("Fake loading for benchmarking: re-using first batch")
-            batch = next(iter(loader))
-            loader = [batch] * updates_per_epoch  # type: ignore
-        lp = self.log_progress(self.current_stage, loader, total=updates_per_epoch, updates=self.log_updates)
-        average = flashy.averager()  # epoch wise average
-        instant_average = flashy.averager()  # average between two logging
-        metrics: dict = {}
-
-        with self.profiler, self.deadlock_detect:  # profiler will only run for the first 20 updates.
-            for idx, batch in enumerate(lp):
-                self.deadlock_detect.update('batch')
-                if idx >= updates_per_epoch:
-                    break
-                metrics = {}
-                metrics = self.run_step(idx, batch, metrics)
-                self.deadlock_detect.update('step')
-                # run EMA step
-                if self.ema is not None and self.is_training and (idx + 1) % self.cfg.optim.ema.updates == 0:
-                    self.logger.debug("EMA model step")
-                    self.ema.step()
-                self.deadlock_detect.update('ema')
-                self.profiler.step()
-                instant_metrics = instant_average(metrics)
-                if lp.update(**instant_metrics):
-                    instant_average = flashy.averager()  # reset averager between two logging
-                metrics = average(metrics)  # epoch wise average
-                self.deadlock_detect.update('end_batch')
-
-        metrics = flashy.distrib.average_metrics(metrics, updates_per_epoch)
-        return metrics
-
-    def train(self):
-        """Train stage."""
-        return self.common_train_valid('train')
-
-    def valid(self):
-        """Valid stage."""
-        return self.common_train_valid('valid')
-
-    @abstractmethod
-    def evaluate(self):
-        """Evaluate stage."""
-        ...
-
-    @abstractmethod
-    def generate(self):
-        """Generate stage."""
-        ...
-
-    def run_one_stage(self, stage_name: str):
-        """Run only the specified stage.
-        This method is useful to only generate samples from a trained experiment
-        or rerun the validation or evaluation stages.
-        """
-        fn = {
-            'generate': with_rank_rng()(self.generate),
-            'evaluate': self.evaluate,
-            'valid': self.valid,
-        }
-        if stage_name not in fn:
-            raise ValueError(f'Trying to run stage {stage_name} is not supported.')
-        assert len(self.state_dict()) > 0
-        self._start_epoch()
-        with torch.no_grad(), self.swap_best_state():
-            self.run_stage(stage_name, fn[stage_name])
-        if not self.cfg.execute_inplace:
-            self.commit(save_checkpoints=False)
-
-    @staticmethod
-    def get_eval_solver_from_sig(sig: str, dtype: tp.Optional[str] = None,
-                                 device: tp.Optional[str] = None, autocast: bool = True,
-                                 batch_size: tp.Optional[int] = None,
-                                 override_cfg: tp.Optional[tp.Union[dict, omegaconf.DictConfig]] = None,
-                                 **kwargs):
-        """Mostly a convenience function around audiocraft.train.get_solver_from_sig,
-        populating all the proper param, deactivating EMA, FSDP, loading the best state,
-        basically all you need to get a solver ready to "play" with in single GPU mode
-        and with minimal memory overhead.
-
-        Args:
-            sig (str): signature to load.
-            dtype (str or None): potential dtype, as a string, i.e. 'float16'.
-            device (str or None): potential device, as a string, i.e. 'cuda'.
-            override_cfg (dict or omegaconf.DictConfig or None): potential device, as a string, i.e. 'cuda'.
-        """
-        from audiocraft import train
-        our_override_cfg: tp.Dict[str, tp.Any] = {'optim': {'ema': {'use': False}}}
-        our_override_cfg['autocast'] = autocast
-        if dtype is not None:
-            our_override_cfg['dtype'] = dtype
-        if device is not None:
-            our_override_cfg['device'] = device
-        if batch_size is not None:
-            our_override_cfg['dataset'] = {'batch_size': batch_size}
-        if override_cfg is None:
-            override_cfg = {}
-        override_cfg = omegaconf.OmegaConf.merge(
-            omegaconf.DictConfig(override_cfg), omegaconf.DictConfig(our_override_cfg))  # type: ignore
-        solver = train.get_solver_from_sig(
-            sig, override_cfg=override_cfg,
-            load_best=True, disable_fsdp=True,
-            ignore_state_keys=['optimizer', 'ema'], **kwargs)
-        solver.model.eval()
-        return solver

spaces/AIGC-Audio/Make_An_Audio/wav_evaluation/models/__init__.py

@@ -1,3 +0,0 @@
-from . import clap 
-from . import audio
-from . import utils

spaces/AIGText/GlyphControl/transfer.py

@@ -1,26 +0,0 @@
-from omegaconf import OmegaConf
-from scripts.rendertext_tool import Render_Text, load_model_from_config
-import torch
-
-# cfg = OmegaConf.load("other_configs/config_ema.yaml")
-# model = load_model_from_config(cfg, "model_states.pt", verbose=True)
-# model = load_model_from_config(cfg, "mp_rank_00_model_states.pt", verbose=True)
-
-cfg = OmegaConf.load("other_configs/config_ema_unlock.yaml")
-epoch_idx = 39
-model = load_model_from_config(cfg, "epoch={:0>6d}.ckpt".format(epoch_idx), verbose=True)
-
-from pytorch_lightning.callbacks import ModelCheckpoint
-with model.ema_scope("store ema weights"):
-    model_sd = model.state_dict()
-    store_sd = {}
-    for key in model_sd:
-        if "ema" in key:
-            continue
-        store_sd[key] = model_sd[key]
-    file_content = {
-        'state_dict': store_sd
-    }
-    torch.save(file_content, f"textcaps5K_epoch_{epoch_idx+1}_model_wo_ema.ckpt")
-    print("has stored the transfered ckpt.")
-print("trial ends!")

spaces/AIGuardians/SummarizeWikipediaDocument/README.md

@@ -1,13 +0,0 @@
----
-title: Summaraize
-emoji: 🏢
-colorFrom: green
-colorTo: yellow
-sdk: gradio
-sdk_version: 3.12.0
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/ATang0729/Forecast4Muses/Model/Model6/Model6_2_ProfileRecogition/mmpretrain/configs/resnet/resnet50_32xb64-warmup_in1k.py

@@ -1,4 +0,0 @@
-_base_ = [
-    '../_base_/models/resnet50.py', '../_base_/datasets/imagenet_bs64.py',
-    '../_base_/schedules/imagenet_bs2048.py', '../_base_/default_runtime.py'
-]

spaces/Ababababababbababa/Arabic_poem_classifier/app.py

@@ -1,36 +0,0 @@
-import gradio as gr
-
-description = "التعرف على خاصيات البيت الشعري"
-title = """هذا البرنامج يقوم بالتعرف على مختلف خاصيات البيت من الشعر.
-يمكنكم إختيار الخاصية من بين:
-- التعرف على البحر
-- التعرف على الروي
-التعرف على الموضوع-"""
-
-examples = [["سَلو قَلبي غَداةَ سَلا وَثابا لَعَلَّ عَلى الجَمالِ لَهُ عِتابا"], ["قفا نبك من ذِكرى حبيب ومنزلِ بسِقطِ اللِّوى بينَ الدَّخول فحَوْملِ"]]
-
-
-meter = gr.Interface.load("huggingface/Yah216/Arabic_poem_meter_3",
-                        description="من فضلك، أدخل البيت الشعري الذي تود التعرف عليه",
-                        examples=examples, title = "التعرف على البحر",
-                          inputs = gr.inputs.Textbox(lines = 3, label = "البيت")
-
-)
-rawiy = gr.Interface.load("huggingface/Yah216/Poem_Qafiyah_Detection",
-                         title ="التعرف على الروي",
-                         examples=examples,
-                         description="من فضلك، أدخل البيت الشعري الذي تود التعرف عليه",
-                         inputs = gr.inputs.Textbox(lines = 3, label = "البيت")
- 
-)
-subject = gr.Interface.load(
-              "huggingface/zenkri/autotrain-Arabic_Poetry_by_Subject-920730230",
-               title="التعرف على الموضوع",
-               examples=examples,
-               description="من فضلك، أدخل البيت الشعري الذي تود التعرف عليه",
-                inputs = gr.inputs.Textbox(lines = 3, label = "البيت")
-
-)
-demo = gr.TabbedInterface([meter, rawiy, subject], ["التعرف على البحر","التعرف على الروي","التعرف على الموضوع"])
-demo.launch()
-

spaces/AkitoP/umamusume_bert_vits2/models.py

@@ -1,986 +0,0 @@
-import math
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-import commons
-import modules
-import attentions
-import monotonic_align
-
-from torch.nn import Conv1d, ConvTranspose1d, Conv2d
-from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm
-
-from commons import init_weights, get_padding
-from text import symbols, num_tones, num_languages
-
-
-class DurationDiscriminator(nn.Module):  # vits2
-    def __init__(
-        self, in_channels, filter_channels, kernel_size, p_dropout, gin_channels=0
-    ):
-        super().__init__()
-
-        self.in_channels = in_channels
-        self.filter_channels = filter_channels
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.gin_channels = gin_channels
-
-        self.drop = nn.Dropout(p_dropout)
-        self.conv_1 = nn.Conv1d(
-            in_channels, filter_channels, kernel_size, padding=kernel_size // 2
-        )
-        self.norm_1 = modules.LayerNorm(filter_channels)
-        self.conv_2 = nn.Conv1d(
-            filter_channels, filter_channels, kernel_size, padding=kernel_size // 2
-        )
-        self.norm_2 = modules.LayerNorm(filter_channels)
-        self.dur_proj = nn.Conv1d(1, filter_channels, 1)
-
-        self.pre_out_conv_1 = nn.Conv1d(
-            2 * filter_channels, filter_channels, kernel_size, padding=kernel_size // 2
-        )
-        self.pre_out_norm_1 = modules.LayerNorm(filter_channels)
-        self.pre_out_conv_2 = nn.Conv1d(
-            filter_channels, filter_channels, kernel_size, padding=kernel_size // 2
-        )
-        self.pre_out_norm_2 = modules.LayerNorm(filter_channels)
-
-        if gin_channels != 0:
-            self.cond = nn.Conv1d(gin_channels, in_channels, 1)
-
-        self.output_layer = nn.Sequential(nn.Linear(filter_channels, 1), nn.Sigmoid())
-
-    def forward_probability(self, x, x_mask, dur, g=None):
-        dur = self.dur_proj(dur)
-        x = torch.cat([x, dur], dim=1)
-        x = self.pre_out_conv_1(x * x_mask)
-        x = torch.relu(x)
-        x = self.pre_out_norm_1(x)
-        x = self.drop(x)
-        x = self.pre_out_conv_2(x * x_mask)
-        x = torch.relu(x)
-        x = self.pre_out_norm_2(x)
-        x = self.drop(x)
-        x = x * x_mask
-        x = x.transpose(1, 2)
-        output_prob = self.output_layer(x)
-        return output_prob
-
-    def forward(self, x, x_mask, dur_r, dur_hat, g=None):
-        x = torch.detach(x)
-        if g is not None:
-            g = torch.detach(g)
-            x = x + self.cond(g)
-        x = self.conv_1(x * x_mask)
-        x = torch.relu(x)
-        x = self.norm_1(x)
-        x = self.drop(x)
-        x = self.conv_2(x * x_mask)
-        x = torch.relu(x)
-        x = self.norm_2(x)
-        x = self.drop(x)
-
-        output_probs = []
-        for dur in [dur_r, dur_hat]:
-            output_prob = self.forward_probability(x, x_mask, dur, g)
-            output_probs.append(output_prob)
-
-        return output_probs
-
-
-class TransformerCouplingBlock(nn.Module):
-    def __init__(
-        self,
-        channels,
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size,
-        p_dropout,
-        n_flows=4,
-        gin_channels=0,
-        share_parameter=False,
-    ):
-        super().__init__()
-        self.channels = channels
-        self.hidden_channels = hidden_channels
-        self.kernel_size = kernel_size
-        self.n_layers = n_layers
-        self.n_flows = n_flows
-        self.gin_channels = gin_channels
-
-        self.flows = nn.ModuleList()
-
-        self.wn = (
-            attentions.FFT(
-                hidden_channels,
-                filter_channels,
-                n_heads,
-                n_layers,
-                kernel_size,
-                p_dropout,
-                isflow=True,
-                gin_channels=self.gin_channels,
-            )
-            if share_parameter
-            else None
-        )
-
-        for i in range(n_flows):
-            self.flows.append(
-                modules.TransformerCouplingLayer(
-                    channels,
-                    hidden_channels,
-                    kernel_size,
-                    n_layers,
-                    n_heads,
-                    p_dropout,
-                    filter_channels,
-                    mean_only=True,
-                    wn_sharing_parameter=self.wn,
-                    gin_channels=self.gin_channels,
-                )
-            )
-            self.flows.append(modules.Flip())
-
-    def forward(self, x, x_mask, g=None, reverse=False):
-        if not reverse:
-            for flow in self.flows:
-                x, _ = flow(x, x_mask, g=g, reverse=reverse)
-        else:
-            for flow in reversed(self.flows):
-                x = flow(x, x_mask, g=g, reverse=reverse)
-        return x
-
-
-class StochasticDurationPredictor(nn.Module):
-    def __init__(
-        self,
-        in_channels,
-        filter_channels,
-        kernel_size,
-        p_dropout,
-        n_flows=4,
-        gin_channels=0,
-    ):
-        super().__init__()
-        filter_channels = in_channels  # it needs to be removed from future version.
-        self.in_channels = in_channels
-        self.filter_channels = filter_channels
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.n_flows = n_flows
-        self.gin_channels = gin_channels
-
-        self.log_flow = modules.Log()
-        self.flows = nn.ModuleList()
-        self.flows.append(modules.ElementwiseAffine(2))
-        for i in range(n_flows):
-            self.flows.append(
-                modules.ConvFlow(2, filter_channels, kernel_size, n_layers=3)
-            )
-            self.flows.append(modules.Flip())
-
-        self.post_pre = nn.Conv1d(1, filter_channels, 1)
-        self.post_proj = nn.Conv1d(filter_channels, filter_channels, 1)
-        self.post_convs = modules.DDSConv(
-            filter_channels, kernel_size, n_layers=3, p_dropout=p_dropout
-        )
-        self.post_flows = nn.ModuleList()
-        self.post_flows.append(modules.ElementwiseAffine(2))
-        for i in range(4):
-            self.post_flows.append(
-                modules.ConvFlow(2, filter_channels, kernel_size, n_layers=3)
-            )
-            self.post_flows.append(modules.Flip())
-
-        self.pre = nn.Conv1d(in_channels, filter_channels, 1)
-        self.proj = nn.Conv1d(filter_channels, filter_channels, 1)
-        self.convs = modules.DDSConv(
-            filter_channels, kernel_size, n_layers=3, p_dropout=p_dropout
-        )
-        if gin_channels != 0:
-            self.cond = nn.Conv1d(gin_channels, filter_channels, 1)
-
-    def forward(self, x, x_mask, w=None, g=None, reverse=False, noise_scale=1.0):
-        x = torch.detach(x)
-        x = self.pre(x)
-        if g is not None:
-            g = torch.detach(g)
-            x = x + self.cond(g)
-        x = self.convs(x, x_mask)
-        x = self.proj(x) * x_mask
-
-        if not reverse:
-            flows = self.flows
-            assert w is not None
-
-            logdet_tot_q = 0
-            h_w = self.post_pre(w)
-            h_w = self.post_convs(h_w, x_mask)
-            h_w = self.post_proj(h_w) * x_mask
-            e_q = (
-                torch.randn(w.size(0), 2, w.size(2)).to(device=x.device, dtype=x.dtype)
-                * x_mask
-            )
-            z_q = e_q
-            for flow in self.post_flows:
-                z_q, logdet_q = flow(z_q, x_mask, g=(x + h_w))
-                logdet_tot_q += logdet_q
-            z_u, z1 = torch.split(z_q, [1, 1], 1)
-            u = torch.sigmoid(z_u) * x_mask
-            z0 = (w - u) * x_mask
-            logdet_tot_q += torch.sum(
-                (F.logsigmoid(z_u) + F.logsigmoid(-z_u)) * x_mask, [1, 2]
-            )
-            logq = (
-                torch.sum(-0.5 * (math.log(2 * math.pi) + (e_q**2)) * x_mask, [1, 2])
-                - logdet_tot_q
-            )
-
-            logdet_tot = 0
-            z0, logdet = self.log_flow(z0, x_mask)
-            logdet_tot += logdet
-            z = torch.cat([z0, z1], 1)
-            for flow in flows:
-                z, logdet = flow(z, x_mask, g=x, reverse=reverse)
-                logdet_tot = logdet_tot + logdet
-            nll = (
-                torch.sum(0.5 * (math.log(2 * math.pi) + (z**2)) * x_mask, [1, 2])
-                - logdet_tot
-            )
-            return nll + logq  # [b]
-        else:
-            flows = list(reversed(self.flows))
-            flows = flows[:-2] + [flows[-1]]  # remove a useless vflow
-            z = (
-                torch.randn(x.size(0), 2, x.size(2)).to(device=x.device, dtype=x.dtype)
-                * noise_scale
-            )
-            for flow in flows:
-                z = flow(z, x_mask, g=x, reverse=reverse)
-            z0, z1 = torch.split(z, [1, 1], 1)
-            logw = z0
-            return logw
-
-
-class DurationPredictor(nn.Module):
-    def __init__(
-        self, in_channels, filter_channels, kernel_size, p_dropout, gin_channels=0
-    ):
-        super().__init__()
-
-        self.in_channels = in_channels
-        self.filter_channels = filter_channels
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.gin_channels = gin_channels
-
-        self.drop = nn.Dropout(p_dropout)
-        self.conv_1 = nn.Conv1d(
-            in_channels, filter_channels, kernel_size, padding=kernel_size // 2
-        )
-        self.norm_1 = modules.LayerNorm(filter_channels)
-        self.conv_2 = nn.Conv1d(
-            filter_channels, filter_channels, kernel_size, padding=kernel_size // 2
-        )
-        self.norm_2 = modules.LayerNorm(filter_channels)
-        self.proj = nn.Conv1d(filter_channels, 1, 1)
-
-        if gin_channels != 0:
-            self.cond = nn.Conv1d(gin_channels, in_channels, 1)
-
-    def forward(self, x, x_mask, g=None):
-        x = torch.detach(x)
-        if g is not None:
-            g = torch.detach(g)
-            x = x + self.cond(g)
-        x = self.conv_1(x * x_mask)
-        x = torch.relu(x)
-        x = self.norm_1(x)
-        x = self.drop(x)
-        x = self.conv_2(x * x_mask)
-        x = torch.relu(x)
-        x = self.norm_2(x)
-        x = self.drop(x)
-        x = self.proj(x * x_mask)
-        return x * x_mask
-
-
-class TextEncoder(nn.Module):
-    def __init__(
-        self,
-        n_vocab,
-        out_channels,
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size,
-        p_dropout,
-        gin_channels=0,
-    ):
-        super().__init__()
-        self.n_vocab = n_vocab
-        self.out_channels = out_channels
-        self.hidden_channels = hidden_channels
-        self.filter_channels = filter_channels
-        self.n_heads = n_heads
-        self.n_layers = n_layers
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.gin_channels = gin_channels
-        self.emb = nn.Embedding(len(symbols), hidden_channels)
-        nn.init.normal_(self.emb.weight, 0.0, hidden_channels**-0.5)
-        self.tone_emb = nn.Embedding(num_tones, hidden_channels)
-        nn.init.normal_(self.tone_emb.weight, 0.0, hidden_channels**-0.5)
-        self.language_emb = nn.Embedding(num_languages, hidden_channels)
-        nn.init.normal_(self.language_emb.weight, 0.0, hidden_channels**-0.5)
-        self.bert_proj = nn.Conv1d(1024, hidden_channels, 1)
-        self.ja_bert_proj = nn.Conv1d(768, hidden_channels, 1)
-
-        self.encoder = attentions.Encoder(
-            hidden_channels,
-            filter_channels,
-            n_heads,
-            n_layers,
-            kernel_size,
-            p_dropout,
-            gin_channels=self.gin_channels,
-        )
-        self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
-    def forward(self, x, x_lengths, tone, language, bert, ja_bert, g=None):
-        bert_emb = self.bert_proj(bert).transpose(1, 2)
-        ja_bert_emb = self.ja_bert_proj(ja_bert).transpose(1, 2)
-        x = (
-            self.emb(x)
-            + self.tone_emb(tone)
-            + self.language_emb(language)
-            + bert_emb
-            + ja_bert_emb
-        ) * math.sqrt(
-            self.hidden_channels
-        )  # [b, t, h]
-        x = torch.transpose(x, 1, -1)  # [b, h, t]
-        x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(
-            x.dtype
-        )
-
-        x = self.encoder(x * x_mask, x_mask, g=g)
-        stats = self.proj(x) * x_mask
-
-        m, logs = torch.split(stats, self.out_channels, dim=1)
-        return x, m, logs, x_mask
-
-
-class ResidualCouplingBlock(nn.Module):
-    def __init__(
-        self,
-        channels,
-        hidden_channels,
-        kernel_size,
-        dilation_rate,
-        n_layers,
-        n_flows=4,
-        gin_channels=0,
-    ):
-        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.n_flows = n_flows
-        self.gin_channels = gin_channels
-
-        self.flows = nn.ModuleList()
-        for i in range(n_flows):
-            self.flows.append(
-                modules.ResidualCouplingLayer(
-                    channels,
-                    hidden_channels,
-                    kernel_size,
-                    dilation_rate,
-                    n_layers,
-                    gin_channels=gin_channels,
-                    mean_only=True,
-                )
-            )
-            self.flows.append(modules.Flip())
-
-    def forward(self, x, x_mask, g=None, reverse=False):
-        if not reverse:
-            for flow in self.flows:
-                x, _ = flow(x, x_mask, g=g, reverse=reverse)
-        else:
-            for flow in reversed(self.flows):
-                x = flow(x, x_mask, g=g, reverse=reverse)
-        return x
-
-
-class PosteriorEncoder(nn.Module):
-    def __init__(
-        self,
-        in_channels,
-        out_channels,
-        hidden_channels,
-        kernel_size,
-        dilation_rate,
-        n_layers,
-        gin_channels=0,
-    ):
-        super().__init__()
-        self.in_channels = in_channels
-        self.out_channels = out_channels
-        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.pre = nn.Conv1d(in_channels, hidden_channels, 1)
-        self.enc = modules.WN(
-            hidden_channels,
-            kernel_size,
-            dilation_rate,
-            n_layers,
-            gin_channels=gin_channels,
-        )
-        self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
-    def forward(self, x, x_lengths, g=None):
-        x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(
-            x.dtype
-        )
-        x = self.pre(x) * x_mask
-        x = self.enc(x, x_mask, g=g)
-        stats = self.proj(x) * x_mask
-        m, logs = torch.split(stats, self.out_channels, dim=1)
-        z = (m + torch.randn_like(m) * torch.exp(logs)) * x_mask
-        return z, m, logs, x_mask
-
-
-class Generator(torch.nn.Module):
-    def __init__(
-        self,
-        initial_channel,
-        resblock,
-        resblock_kernel_sizes,
-        resblock_dilation_sizes,
-        upsample_rates,
-        upsample_initial_channel,
-        upsample_kernel_sizes,
-        gin_channels=0,
-    ):
-        super(Generator, self).__init__()
-        self.num_kernels = len(resblock_kernel_sizes)
-        self.num_upsamples = len(upsample_rates)
-        self.conv_pre = Conv1d(
-            initial_channel, upsample_initial_channel, 7, 1, padding=3
-        )
-        resblock = modules.ResBlock1 if resblock == "1" else modules.ResBlock2
-
-        self.ups = nn.ModuleList()
-        for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)):
-            self.ups.append(
-                weight_norm(
-                    ConvTranspose1d(
-                        upsample_initial_channel // (2**i),
-                        upsample_initial_channel // (2 ** (i + 1)),
-                        k,
-                        u,
-                        padding=(k - u) // 2,
-                    )
-                )
-            )
-
-        self.resblocks = nn.ModuleList()
-        for i in range(len(self.ups)):
-            ch = upsample_initial_channel // (2 ** (i + 1))
-            for j, (k, d) in enumerate(
-                zip(resblock_kernel_sizes, resblock_dilation_sizes)
-            ):
-                self.resblocks.append(resblock(ch, k, d))
-
-        self.conv_post = Conv1d(ch, 1, 7, 1, padding=3, bias=False)
-        self.ups.apply(init_weights)
-
-        if gin_channels != 0:
-            self.cond = nn.Conv1d(gin_channels, upsample_initial_channel, 1)
-
-    def forward(self, x, g=None):
-        x = self.conv_pre(x)
-        if g is not None:
-            x = x + self.cond(g)
-
-        for i in range(self.num_upsamples):
-            x = F.leaky_relu(x, modules.LRELU_SLOPE)
-            x = self.ups[i](x)
-            xs = None
-            for j in range(self.num_kernels):
-                if xs is None:
-                    xs = self.resblocks[i * self.num_kernels + j](x)
-                else:
-                    xs += self.resblocks[i * self.num_kernels + j](x)
-            x = xs / self.num_kernels
-        x = F.leaky_relu(x)
-        x = self.conv_post(x)
-        x = torch.tanh(x)
-
-        return x
-
-    def remove_weight_norm(self):
-        print("Removing weight norm...")
-        for layer in self.ups:
-            remove_weight_norm(layer)
-        for layer in self.resblocks:
-            layer.remove_weight_norm()
-
-
-class DiscriminatorP(torch.nn.Module):
-    def __init__(self, period, kernel_size=5, stride=3, use_spectral_norm=False):
-        super(DiscriminatorP, self).__init__()
-        self.period = period
-        self.use_spectral_norm = use_spectral_norm
-        norm_f = weight_norm if use_spectral_norm is False else spectral_norm
-        self.convs = nn.ModuleList(
-            [
-                norm_f(
-                    Conv2d(
-                        1,
-                        32,
-                        (kernel_size, 1),
-                        (stride, 1),
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-                norm_f(
-                    Conv2d(
-                        32,
-                        128,
-                        (kernel_size, 1),
-                        (stride, 1),
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-                norm_f(
-                    Conv2d(
-                        128,
-                        512,
-                        (kernel_size, 1),
-                        (stride, 1),
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-                norm_f(
-                    Conv2d(
-                        512,
-                        1024,
-                        (kernel_size, 1),
-                        (stride, 1),
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-                norm_f(
-                    Conv2d(
-                        1024,
-                        1024,
-                        (kernel_size, 1),
-                        1,
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-            ]
-        )
-        self.conv_post = norm_f(Conv2d(1024, 1, (3, 1), 1, padding=(1, 0)))
-
-    def forward(self, x):
-        fmap = []
-
-        # 1d to 2d
-        b, c, t = x.shape
-        if t % self.period != 0:  # pad first
-            n_pad = self.period - (t % self.period)
-            x = F.pad(x, (0, n_pad), "reflect")
-            t = t + n_pad
-        x = x.view(b, c, t // self.period, self.period)
-
-        for layer in self.convs:
-            x = layer(x)
-            x = F.leaky_relu(x, modules.LRELU_SLOPE)
-            fmap.append(x)
-        x = self.conv_post(x)
-        fmap.append(x)
-        x = torch.flatten(x, 1, -1)
-
-        return x, fmap
-
-
-class DiscriminatorS(torch.nn.Module):
-    def __init__(self, use_spectral_norm=False):
-        super(DiscriminatorS, self).__init__()
-        norm_f = weight_norm if use_spectral_norm is False else spectral_norm
-        self.convs = nn.ModuleList(
-            [
-                norm_f(Conv1d(1, 16, 15, 1, padding=7)),
-                norm_f(Conv1d(16, 64, 41, 4, groups=4, padding=20)),
-                norm_f(Conv1d(64, 256, 41, 4, groups=16, padding=20)),
-                norm_f(Conv1d(256, 1024, 41, 4, groups=64, padding=20)),
-                norm_f(Conv1d(1024, 1024, 41, 4, groups=256, padding=20)),
-                norm_f(Conv1d(1024, 1024, 5, 1, padding=2)),
-            ]
-        )
-        self.conv_post = norm_f(Conv1d(1024, 1, 3, 1, padding=1))
-
-    def forward(self, x):
-        fmap = []
-
-        for layer in self.convs:
-            x = layer(x)
-            x = F.leaky_relu(x, modules.LRELU_SLOPE)
-            fmap.append(x)
-        x = self.conv_post(x)
-        fmap.append(x)
-        x = torch.flatten(x, 1, -1)
-
-        return x, fmap
-
-
-class MultiPeriodDiscriminator(torch.nn.Module):
-    def __init__(self, use_spectral_norm=False):
-        super(MultiPeriodDiscriminator, self).__init__()
-        periods = [2, 3, 5, 7, 11]
-
-        discs = [DiscriminatorS(use_spectral_norm=use_spectral_norm)]
-        discs = discs + [
-            DiscriminatorP(i, use_spectral_norm=use_spectral_norm) for i in periods
-        ]
-        self.discriminators = nn.ModuleList(discs)
-
-    def forward(self, y, y_hat):
-        y_d_rs = []
-        y_d_gs = []
-        fmap_rs = []
-        fmap_gs = []
-        for i, d in enumerate(self.discriminators):
-            y_d_r, fmap_r = d(y)
-            y_d_g, fmap_g = d(y_hat)
-            y_d_rs.append(y_d_r)
-            y_d_gs.append(y_d_g)
-            fmap_rs.append(fmap_r)
-            fmap_gs.append(fmap_g)
-
-        return y_d_rs, y_d_gs, fmap_rs, fmap_gs
-
-
-class ReferenceEncoder(nn.Module):
-    """
-    inputs --- [N, Ty/r, n_mels*r]  mels
-    outputs --- [N, ref_enc_gru_size]
-    """
-
-    def __init__(self, spec_channels, gin_channels=0):
-        super().__init__()
-        self.spec_channels = spec_channels
-        ref_enc_filters = [32, 32, 64, 64, 128, 128]
-        K = len(ref_enc_filters)
-        filters = [1] + ref_enc_filters
-        convs = [
-            weight_norm(
-                nn.Conv2d(
-                    in_channels=filters[i],
-                    out_channels=filters[i + 1],
-                    kernel_size=(3, 3),
-                    stride=(2, 2),
-                    padding=(1, 1),
-                )
-            )
-            for i in range(K)
-        ]
-        self.convs = nn.ModuleList(convs)
-        # self.wns = nn.ModuleList([weight_norm(num_features=ref_enc_filters[i]) for i in range(K)]) # noqa: E501
-
-        out_channels = self.calculate_channels(spec_channels, 3, 2, 1, K)
-        self.gru = nn.GRU(
-            input_size=ref_enc_filters[-1] * out_channels,
-            hidden_size=256 // 2,
-            batch_first=True,
-        )
-        self.proj = nn.Linear(128, gin_channels)
-
-    def forward(self, inputs, mask=None):
-        N = inputs.size(0)
-        out = inputs.view(N, 1, -1, self.spec_channels)  # [N, 1, Ty, n_freqs]
-        for conv in self.convs:
-            out = conv(out)
-            # out = wn(out)
-            out = F.relu(out)  # [N, 128, Ty//2^K, n_mels//2^K]
-
-        out = out.transpose(1, 2)  # [N, Ty//2^K, 128, n_mels//2^K]
-        T = out.size(1)
-        N = out.size(0)
-        out = out.contiguous().view(N, T, -1)  # [N, Ty//2^K, 128*n_mels//2^K]
-
-        self.gru.flatten_parameters()
-        memory, out = self.gru(out)  # out --- [1, N, 128]
-
-        return self.proj(out.squeeze(0))
-
-    def calculate_channels(self, L, kernel_size, stride, pad, n_convs):
-        for i in range(n_convs):
-            L = (L - kernel_size + 2 * pad) // stride + 1
-        return L
-
-
-class SynthesizerTrn(nn.Module):
-    """
-    Synthesizer for Training
-    """
-
-    def __init__(
-        self,
-        n_vocab,
-        spec_channels,
-        segment_size,
-        inter_channels,
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size,
-        p_dropout,
-        resblock,
-        resblock_kernel_sizes,
-        resblock_dilation_sizes,
-        upsample_rates,
-        upsample_initial_channel,
-        upsample_kernel_sizes,
-        n_speakers=256,
-        gin_channels=256,
-        use_sdp=True,
-        n_flow_layer=4,
-        n_layers_trans_flow=6,
-        flow_share_parameter=False,
-        use_transformer_flow=True,
-        **kwargs
-    ):
-        super().__init__()
-        self.n_vocab = n_vocab
-        self.spec_channels = spec_channels
-        self.inter_channels = inter_channels
-        self.hidden_channels = hidden_channels
-        self.filter_channels = filter_channels
-        self.n_heads = n_heads
-        self.n_layers = n_layers
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.resblock = resblock
-        self.resblock_kernel_sizes = resblock_kernel_sizes
-        self.resblock_dilation_sizes = resblock_dilation_sizes
-        self.upsample_rates = upsample_rates
-        self.upsample_initial_channel = upsample_initial_channel
-        self.upsample_kernel_sizes = upsample_kernel_sizes
-        self.segment_size = segment_size
-        self.n_speakers = n_speakers
-        self.gin_channels = gin_channels
-        self.n_layers_trans_flow = n_layers_trans_flow
-        self.use_spk_conditioned_encoder = kwargs.get(
-            "use_spk_conditioned_encoder", True
-        )
-        self.use_sdp = use_sdp
-        self.use_noise_scaled_mas = kwargs.get("use_noise_scaled_mas", False)
-        self.mas_noise_scale_initial = kwargs.get("mas_noise_scale_initial", 0.01)
-        self.noise_scale_delta = kwargs.get("noise_scale_delta", 2e-6)
-        self.current_mas_noise_scale = self.mas_noise_scale_initial
-        if self.use_spk_conditioned_encoder and gin_channels > 0:
-            self.enc_gin_channels = gin_channels
-        self.enc_p = TextEncoder(
-            n_vocab,
-            inter_channels,
-            hidden_channels,
-            filter_channels,
-            n_heads,
-            n_layers,
-            kernel_size,
-            p_dropout,
-            gin_channels=self.enc_gin_channels,
-        )
-        self.dec = Generator(
-            inter_channels,
-            resblock,
-            resblock_kernel_sizes,
-            resblock_dilation_sizes,
-            upsample_rates,
-            upsample_initial_channel,
-            upsample_kernel_sizes,
-            gin_channels=gin_channels,
-        )
-        self.enc_q = PosteriorEncoder(
-            spec_channels,
-            inter_channels,
-            hidden_channels,
-            5,
-            1,
-            16,
-            gin_channels=gin_channels,
-        )
-        if use_transformer_flow:
-            self.flow = TransformerCouplingBlock(
-                inter_channels,
-                hidden_channels,
-                filter_channels,
-                n_heads,
-                n_layers_trans_flow,
-                5,
-                p_dropout,
-                n_flow_layer,
-                gin_channels=gin_channels,
-                share_parameter=flow_share_parameter,
-            )
-        else:
-            self.flow = ResidualCouplingBlock(
-                inter_channels,
-                hidden_channels,
-                5,
-                1,
-                n_flow_layer,
-                gin_channels=gin_channels,
-            )
-        self.sdp = StochasticDurationPredictor(
-            hidden_channels, 192, 3, 0.5, 4, gin_channels=gin_channels
-        )
-        self.dp = DurationPredictor(
-            hidden_channels, 256, 3, 0.5, gin_channels=gin_channels
-        )
-
-        if n_speakers > 1:
-            self.emb_g = nn.Embedding(n_speakers, gin_channels)
-        else:
-            self.ref_enc = ReferenceEncoder(spec_channels, gin_channels)
-
-    def forward(self, x, x_lengths, y, y_lengths, sid, tone, language, bert, ja_bert):
-        if self.n_speakers > 0:
-            g = self.emb_g(sid).unsqueeze(-1)  # [b, h, 1]
-        else:
-            g = self.ref_enc(y.transpose(1, 2)).unsqueeze(-1)
-        x, m_p, logs_p, x_mask = self.enc_p(
-            x, x_lengths, tone, language, bert, ja_bert, g=g
-        )
-        z, m_q, logs_q, y_mask = self.enc_q(y, y_lengths, g=g)
-        z_p = self.flow(z, y_mask, g=g)
-
-        with torch.no_grad():
-            # negative cross-entropy
-            s_p_sq_r = torch.exp(-2 * logs_p)  # [b, d, t]
-            neg_cent1 = torch.sum(
-                -0.5 * math.log(2 * math.pi) - logs_p, [1], keepdim=True
-            )  # [b, 1, t_s]
-            neg_cent2 = torch.matmul(
-                -0.5 * (z_p**2).transpose(1, 2), s_p_sq_r
-            )  # [b, t_t, d] x [b, d, t_s] = [b, t_t, t_s]
-            neg_cent3 = torch.matmul(
-                z_p.transpose(1, 2), (m_p * s_p_sq_r)
-            )  # [b, t_t, d] x [b, d, t_s] = [b, t_t, t_s]
-            neg_cent4 = torch.sum(
-                -0.5 * (m_p**2) * s_p_sq_r, [1], keepdim=True
-            )  # [b, 1, t_s]
-            neg_cent = neg_cent1 + neg_cent2 + neg_cent3 + neg_cent4
-            if self.use_noise_scaled_mas:
-                epsilon = (
-                    torch.std(neg_cent)
-                    * torch.randn_like(neg_cent)
-                    * self.current_mas_noise_scale
-                )
-                neg_cent = neg_cent + epsilon
-
-            attn_mask = torch.unsqueeze(x_mask, 2) * torch.unsqueeze(y_mask, -1)
-            attn = (
-                monotonic_align.maximum_path(neg_cent, attn_mask.squeeze(1))
-                .unsqueeze(1)
-                .detach()
-            )
-
-        w = attn.sum(2)
-
-        l_length_sdp = self.sdp(x, x_mask, w, g=g)
-        l_length_sdp = l_length_sdp / torch.sum(x_mask)
-
-        logw_ = torch.log(w + 1e-6) * x_mask
-        logw = self.dp(x, x_mask, g=g)
-        l_length_dp = torch.sum((logw - logw_) ** 2, [1, 2]) / torch.sum(
-            x_mask
-        )  # for averaging
-
-        l_length = l_length_dp + l_length_sdp
-
-        # expand prior
-        m_p = torch.matmul(attn.squeeze(1), m_p.transpose(1, 2)).transpose(1, 2)
-        logs_p = torch.matmul(attn.squeeze(1), logs_p.transpose(1, 2)).transpose(1, 2)
-
-        z_slice, ids_slice = commons.rand_slice_segments(
-            z, y_lengths, self.segment_size
-        )
-        o = self.dec(z_slice, g=g)
-        return (
-            o,
-            l_length,
-            attn,
-            ids_slice,
-            x_mask,
-            y_mask,
-            (z, z_p, m_p, logs_p, m_q, logs_q),
-            (x, logw, logw_),
-        )
-
-    def infer(
-        self,
-        x,
-        x_lengths,
-        sid,
-        tone,
-        language,
-        bert,
-        ja_bert,
-        noise_scale=0.667,
-        length_scale=1,
-        noise_scale_w=0.8,
-        max_len=None,
-        sdp_ratio=0,
-        y=None,
-    ):
-        # x, m_p, logs_p, x_mask = self.enc_p(x, x_lengths, tone, language, bert)
-        # g = self.gst(y)
-        if self.n_speakers > 0:
-            g = self.emb_g(sid).unsqueeze(-1)  # [b, h, 1]
-        else:
-            g = self.ref_enc(y.transpose(1, 2)).unsqueeze(-1)
-        x, m_p, logs_p, x_mask = self.enc_p(
-            x, x_lengths, tone, language, bert, ja_bert, g=g
-        )
-        logw = self.sdp(x, x_mask, g=g, reverse=True, noise_scale=noise_scale_w) * (
-            sdp_ratio
-        ) + self.dp(x, x_mask, g=g) * (1 - sdp_ratio)
-        w = torch.exp(logw) * x_mask * length_scale
-        w_ceil = torch.ceil(w)
-        y_lengths = torch.clamp_min(torch.sum(w_ceil, [1, 2]), 1).long()
-        y_mask = torch.unsqueeze(commons.sequence_mask(y_lengths, None), 1).to(
-            x_mask.dtype
-        )
-        attn_mask = torch.unsqueeze(x_mask, 2) * torch.unsqueeze(y_mask, -1)
-        attn = commons.generate_path(w_ceil, attn_mask)
-
-        m_p = torch.matmul(attn.squeeze(1), m_p.transpose(1, 2)).transpose(
-            1, 2
-        )  # [b, t', t], [b, t, d] -> [b, d, t']
-        logs_p = torch.matmul(attn.squeeze(1), logs_p.transpose(1, 2)).transpose(
-            1, 2
-        )  # [b, t', t], [b, t, d] -> [b, d, t']
-
-        z_p = m_p + torch.randn_like(m_p) * torch.exp(logs_p) * noise_scale
-        z = self.flow(z_p, y_mask, g=g, reverse=True)
-        o = self.dec((z * y_mask)[:, :, :max_len], g=g)
-        return o, attn, y_mask, (z, z_p, m_p, logs_p)

spaces/Akshat231/super_space/app.py

@@ -1,122 +0,0 @@
-##THIS IS FOR SUPER-RESOLUTION\
-
-import gradio as gr
-from PIL import Image
-import tensorflow as tf
-import tensorflow_hub as hub
-import numpy as np
-import requests
-import cv2
-from tensorflow.python.keras.layers import Add, Conv2D, Input, Lambda
-from tensorflow.python.keras.models import Model
-
-
-super_resolution='./weights.h5'
-
-
-pre_mean = np.array([0.4488, 0.4371, 0.4040]) * 255
-
-
-#HELPER FUN
-def normalize(x, rgb_mean=pre_mean):
-    return (x - rgb_mean) / 127.5
-
-#HELPER FUN
-def pixel_shuffle(scale):
-    return lambda x: tf.nn.depth_to_space(x, scale)
-
-#HELPER FUN
-def denormalize(x, rgb_mean=pre_mean):
-    return x * 127.5 + rgb_mean
-
-
-#MAIN FUN
-def res_block(x_in, filters, scaling):
-    x = Conv2D(filters, 3, padding='same', activation='relu')(x_in)
-    x = Conv2D(filters, 3, padding='same')(x)
-    x =tf.keras.layers.LeakyReLU(alpha = 0.01)(x)
-    x = tf.keras.layers.BatchNormalization()(x)
-    if scaling:
-        x = Lambda(lambda t: t * scaling)(x)
-    x = Add()([x_in, x])
-    return x
-
-
-
-#HELPER FUN
-def upsample(x, scale, num_filters):
-    def upsample_1(x, factor, **kwargs):
-        x = Conv2D(num_filters * (factor ** 2), 3, padding='same', **kwargs)(x)
-        return Lambda(pixel_shuffle(scale=factor))(x)
-
-    if scale == 2:
-        x = upsample_1(x, 2, name='conv2d_1_scale_2')
-    elif scale == 3:
-        x = upsample_1(x, 3, name='conv2d_1_scale_3')
-    elif scale == 4:
-        x = upsample_1(x, 2, name='conv2d_1_scale_2')
-        x = upsample_1(x, 2, name='conv2d_2_scale_2')
-
-    return x
-
-#MAIN FUN
-def super_res(scale, num_filters=64, num_res_blocks=8, res_block_scaling=None):
-    x_in = Input(shape=(None, None, 3))
-    x = Lambda(normalize)(x_in)
-    x = b = Conv2D(num_filters, 3, padding='same')(x)
-    
-    for i in range(num_res_blocks):
-        b = res_block(b, num_filters, res_block_scaling)
-    b = Conv2D(num_filters, 3, padding='same')(b)
-    x = Add()([x, b])
-
-    x = upsample(x, scale, num_filters)
-    x = Conv2D(3, 3, padding='same')(x)
-
-    x = Lambda(denormalize)(x)
-    return Model(x_in, x, name="super_res")
-
-
-
-
-def load_image(path):
-    return np.array(path)
-
-    
-    
-    
-def resolve(model, lr_batch):
-    lr_batch = tf.cast(lr_batch, tf.float32)
-    sr_batch = model(lr_batch)
-    sr_batch = tf.clip_by_value(sr_batch, 0, 255)
-    sr_batch = tf.round(sr_batch)
-    sr_batch = tf.cast(sr_batch, tf.uint8)
-    return sr_batch
-
-
-
-def resolve_single(model, lr):
-    return resolve(model, tf.expand_dims(lr, axis=0))[0]
-
-
-
-model=super_res(scale=4, num_res_blocks=16)
-
-
-model.load_weights(super_resolution)
-
-
-def predict_image(image):
-    lr=load_image(image)
-    sr = resolve_single(model, lr)
-    numpy_array = sr.numpy()
-    ima = Image.fromarray(numpy_array)
-    return ima
-
-
-
-image=gr.inputs.Image()
-
-irface=gr.Interface(fn=predict_image, inputs=image, outputs=image,interpretation='default')
-
-irface.launch() 

spaces/AkshayKollimarala/MYAIVOICESPEECH/app.py

@@ -1,164 +0,0 @@
-import os
-import re
-import requests
-import json
-import gradio as gr
-from langchain.chat_models import ChatOpenAI
-from langchain import LLMChain, PromptTemplate
-from langchain.memory import ConversationBufferMemory
-
-OPENAI_API_KEY=os.getenv('OPENAI_API_KEY')
-PLAY_HT_API_KEY=os.getenv('PLAY_HT_API_KEY')
-PLAY_HT_USER_ID=os.getenv('PLAY_HT_USER_ID')
-
-PLAY_HT_VOICE_ID=os.getenv('PLAY_HT_VOICE_ID')
-play_ht_api_get_audio_url = "https://play.ht/api/v2/tts"
-
-
-template = """You are a helpful assistant to answer user queries.
-{chat_history}
-User: {user_message}
-Chatbot:"""
-
-prompt = PromptTemplate(
-    input_variables=["chat_history", "user_message"], template=template
-)
-
-memory = ConversationBufferMemory(memory_key="chat_history")
-
-llm_chain = LLMChain(
-    llm=ChatOpenAI(temperature='0.5', model_name="gpt-3.5-turbo"),
-    prompt=prompt,
-    verbose=True,
-    memory=memory,
-)
-
-headers = {
-      "accept": "text/event-stream",
-      "content-type": "application/json",
-      "AUTHORIZATION": "Bearer "+ PLAY_HT_API_KEY,
-      "X-USER-ID": PLAY_HT_USER_ID
-}
-
-
-def get_payload(text):
-  return {
-    "text": text,
-    "voice": PLAY_HT_VOICE_ID,
-    "quality": "medium",
-    "output_format": "mp3",
-    "speed": 1,
-    "sample_rate": 24000,
-    "seed": None,
-    "temperature": None
-  }
-
-def get_generated_audio(text):
-  payload = get_payload(text)
-  generated_response = {}
-  try:
-      response = requests.post(play_ht_api_get_audio_url, json=payload, headers=headers)
-      response.raise_for_status()
-      generated_response["type"]= 'SUCCESS'
-      generated_response["response"] = response.text
-  except requests.exceptions.RequestException as e:
-      generated_response["type"]= 'ERROR'
-      try:
-        response_text = json.loads(response.text)
-        if response_text['error_message']:
-          generated_response["response"] = response_text['error_message']
-        else:
-          generated_response["response"] = response.text
-      except Exception as e:
-        generated_response["response"] = response.text
-  except Exception as e:
-    generated_response["type"]= 'ERROR'
-    generated_response["response"] = response.text
-  return generated_response
-
-def extract_urls(text):
-    # Define the regex pattern for URLs
-    url_pattern = r'https?://(?:[-\w.]|(?:%[\da-fA-F]{2}))+[/\w\.-]*'
-
-    # Find all occurrences of URLs in the text
-    urls = re.findall(url_pattern, text)
-
-    return urls
-
-def get_audio_reply_for_question(text):
-  generated_audio_event = get_generated_audio(text)
-  #From get_generated_audio, you will get events in a string format, from that we need to extract the url
-  final_response = {
-      "audio_url": '',
-      "message": ''
-  }
-  if generated_audio_event["type"] == 'SUCCESS':
-    audio_urls = extract_urls(generated_audio_event["response"])
-    if len(audio_urls) == 0:
-      final_response['message'] = "No audio file link found in generated event"
-    else:
-      final_response['audio_url'] = audio_urls[-1]
-  else:
-    final_response['message'] = generated_audio_event['response']
-  return final_response
-
-def download_url(url):
-    try:
-        # Send a GET request to the URL to fetch the content
-        final_response = {
-            'content':'',
-            'error':''
-        }
-        response = requests.get(url)
-        # Check if the request was successful (status code 200)
-        if response.status_code == 200:
-            final_response['content'] = response.content
-        else:
-            final_response['error'] = f"Failed to download the URL. Status code: {response.status_code}"
-    except Exception as e:
-        final_response['error'] = f"Failed to download the URL. Error: {e}"
-    return final_response
-
-def get_filename_from_url(url):
-    # Use os.path.basename() to extract the file name from the URL
-    file_name = os.path.basename(url)
-    return file_name
-
-def get_text_response(user_message):
-    response = llm_chain.predict(user_message = user_message)
-    return response
-
-def get_text_response_and_audio_response(user_message):
-    response = get_text_response(user_message) # Getting the reply from Open AI
-    audio_reply_for_question_response = get_audio_reply_for_question(response)
-    final_response = {
-        'output_file_path': '',
-        'message':''
-    }
-    audio_url = audio_reply_for_question_response['audio_url']
-    if audio_url:
-      output_file_path=get_filename_from_url(audio_url)
-      download_url_response = download_url(audio_url)
-      audio_content = download_url_response['content']
-      if audio_content:
-        with open(output_file_path, "wb") as audio_file:
-          audio_file.write(audio_content)
-          final_response['output_file_path'] = output_file_path
-      else:
-          final_response['message'] = download_url_response['error']
-    else:
-      final_response['message'] = audio_reply_for_question_response['message']
-    return final_response
-
-def chat_bot_response(message, history):
-    text_and_audio_response = get_text_response_and_audio_response(message)
-    output_file_path = text_and_audio_response['output_file_path']
-    if output_file_path:
-      return (text_and_audio_response['output_file_path'],)
-    else:
-      return text_and_audio_response['message']
-
-demo = gr.ChatInterface(chat_bot_response,examples=["How are you doing?","What are your interests?","Which places do you like to visit?"])
-
-if __name__ == "__main__":
-    demo.launch() #To create a public link, set `share=True` in `launch()`. To enable errors and logs, set `debug=True` in `launch()`.

spaces/Andy1621/uniformer_image_segmentation/configs/deeplabv3/deeplabv3_r50-d8_769x769_80k_cityscapes.py

@@ -1,9 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3_r50-d8.py',
-    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-model = dict(
-    decode_head=dict(align_corners=True),
-    auxiliary_head=dict(align_corners=True),
-    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))

spaces/Araby/BRATArA/app.py

@@ -1,43 +0,0 @@
-import streamlit as st
-from transformers import GPT2TokenizerFast, AutoModelForCausalLM
-from arabert.preprocess import ArabertPreprocessor
-
-# Load model and tokenizer and the model
-
-model_name = "malmarjeh/gpt2"
-tokenizer = GPT2TokenizerFast.from_pretrained("aubmindlab/aragpt2-base")
-model = AutoModelForCausalLM.from_pretrained(model_name)
-preprocessor = ArabertPreprocessor(model_name=model_name)
-
-# Streamlit UI
-st.title('Arabic Text Summarizer | By M.Araby')
-text = st.text_area("Paste your Arabic text here:")
-
-if st.button('Summarize'):
-    if text:
-        # Preprocess and tokenize input text
-        processed_text = preprocessor.preprocess(text)
-        formatted_text = '\n النص: ' + processed_text + ' \n الملخص: \n '
-        tokenizer.add_special_tokens({'pad_token': '<pad>'})
-        tokens = tokenizer.batch_encode_plus([formatted_text], return_tensors='pt', padding='max_length',
-                                             max_length=150)
-
-        # Generate summary
-        output = model.generate(
-            input_ids=tokens['input_ids'],
-            repetition_penalty=2.0,
-            num_beams=5,
-            max_length=600,
-            pad_token_id=tokenizer.pad_token_id,
-            eos_token_id=tokenizer.eos_token_id,
-            bos_token_id=tokenizer.bos_token_id,
-        )
-
-        # Decode and display the summarized text
-        result = tokenizer.decode(output[0][150:], skip_special_tokens=True).strip()
-        st.subheader("Original Text Input")
-        st.write(text)
-        st.subheader("Summarized Text Idea")
-        st.write(result)
-    else:
-        st.warning("Please enter Arabic text to summarize.")

spaces/Arijit-hazra/my-image-captioner/app.py

@@ -1,50 +0,0 @@
-import re
-import string
-import gradio as gr
-import tensorflow as tf
-from load_model import build
-
-IMG_SHAPE = (224,224,3)
-
-
-def custom_standardization(s):
-    s = tf.strings.lower(s)
-    s = tf.strings.regex_replace(s, f'[{re.escape(string.punctuation)}]', '')
-    s = tf.strings.join(['[START]', s, '[END]'], separator=' ')
-    return s
-    
-model = build()
-
-rescale = lambda image : tf.image.resize(tf.convert_to_tensor(image), IMG_SHAPE[:-1])
-
-def single_img_transcribe(image, temperature=1):
-    initial = model.word_to_index([['[START]']]) # (batch, sequence)
-    img_features = model.feature_extractor(rescale(image)[tf.newaxis, ...])
-
-    tokens = initial # (batch, sequence)
-    for n in range(50):
-        preds = model((img_features, tokens)).numpy()  # (batch, sequence, vocab)
-        preds = preds[:,-1, :]  #(batch, vocab)
-        if temperature==0:
-            next = tf.argmax(preds, axis=-1)[:, tf.newaxis]  # (batch, 1)
-        else:
-            next = tf.random.categorical(preds/temperature, num_samples=1)  # (batch, 1)
-        tokens = tf.concat([tokens, next], axis=1) # (batch, sequence) 
-
-        if next[0] == model.word_to_index('[END]'):
-            break
-            
-    words = model.index_to_word(tokens[0, 1:-1])
-    result = tf.strings.reduce_join(words, axis=-1, separator=' ')
-    return result.numpy().decode()
-
-def img_transcribes(image):
-    result = []
-    for t in [0,0.5,1]:
-        result.append(single_img_transcribe(image, t))
-    return result
-    
-gr.Interface(fn=img_transcribes, 
-             inputs=gr.Image(type="pil"),
-             outputs=["text","text","text"]
-            ).launch()

spaces/Armandoliv/t5-summarize-app-scitldr/README.md

@@ -1,12 +0,0 @@
----
-title: T5 Summarize App Scitldr
-emoji: 💻
-colorFrom: red
-colorTo: green
-sdk: gradio
-sdk_version: 3.2
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/Arulkumar03/GroundingDINO_SOTA_Zero_Shot_Model/app.py

@@ -1,129 +0,0 @@
-import argparse
-from functools import partial
-import cv2
-import requests
-import os
-from io import BytesIO
-from PIL import Image
-import numpy as np
-from pathlib import Path
-import gradio as gr
-
-import warnings
-
-import torch
-
-os.system("python setup.py build develop --user")
-os.system("pip install packaging==21.3")
-warnings.filterwarnings("ignore")
-
-
-from groundingdino.models import build_model
-from groundingdino.util.slconfig import SLConfig
-from groundingdino.util.utils import clean_state_dict
-from groundingdino.util.inference import annotate, load_image, predict
-import groundingdino.datasets.transforms as T
-
-from huggingface_hub import hf_hub_download
-
-
-
-# Use this command for evaluate the GLIP-T model
-config_file = "groundingdino/config/GroundingDINO_SwinT_OGC.py"
-ckpt_repo_id = "ShilongLiu/GroundingDINO"
-ckpt_filenmae = "groundingdino_swint_ogc.pth"
-
-
-def load_model_hf(model_config_path, repo_id, filename, device='cpu'):
-    args = SLConfig.fromfile(model_config_path) 
-    model = build_model(args)
-    args.device = device
-
-    cache_file = hf_hub_download(repo_id=repo_id, filename=filename)
-    checkpoint = torch.load(cache_file, map_location='cpu')
-    log = model.load_state_dict(clean_state_dict(checkpoint['model']), strict=False)
-    print("Model loaded from {} \n => {}".format(cache_file, log))
-    _ = model.eval()
-    return model    
-
-def image_transform_grounding(init_image):
-    transform = T.Compose([
-        T.RandomResize([800], max_size=1333),
-        T.ToTensor(),
-        T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
-    ])
-    image, _ = transform(init_image, None) # 3, h, w
-    return init_image, image
-
-def image_transform_grounding_for_vis(init_image):
-    transform = T.Compose([
-        T.RandomResize([800], max_size=1333),
-    ])
-    image, _ = transform(init_image, None) # 3, h, w
-    return image
-
-model = load_model_hf(config_file, ckpt_repo_id, ckpt_filenmae)
-
-def run_grounding(input_image, grounding_caption, box_threshold, text_threshold):
-    init_image = input_image.convert("RGB")
-    original_size = init_image.size
-
-    _, image_tensor = image_transform_grounding(init_image)
-    image_pil: Image = image_transform_grounding_for_vis(init_image)
-
-    # run grounidng
-    boxes, logits, phrases = predict(model, image_tensor, grounding_caption, box_threshold, text_threshold, device='cpu')
-    annotated_frame = annotate(image_source=np.asarray(image_pil), boxes=boxes, logits=logits, phrases=phrases)
-    image_with_box = Image.fromarray(cv2.cvtColor(annotated_frame, cv2.COLOR_BGR2RGB))
-
-
-    return image_with_box
-
-if __name__ == "__main__":
-  
-    css = """
-  #mkd {
-    height: 500px; 
-    overflow: auto; 
-    border: 1px solid #ccc; 
-  }
-"""
-    block = gr.Blocks(css=css).queue()
-    with block:
-        gr.Markdown("<h1><center>Grounding DINO<h1><center>")
-        gr.Markdown("<h3><center>Open-World Detection with <a href='https://github.com/Arulkumar03/SOTA-Grounding-DINO.ipynb'>Grounding DINO</a><h3><center>")
-        gr.Markdown("<h3><center>Note the model runs on CPU, so it may take a while to run the model.<h3><center>")
-
-        with gr.Row():
-            with gr.Column():
-                input_image = gr.Image(source='upload', type="pil")
-                grounding_caption = gr.Textbox(label="Detection Prompt")
-                run_button = gr.Button(label="Run")
-                with gr.Accordion("Advanced options", open=False):
-                    box_threshold = gr.Slider(
-                        label="Box Threshold", minimum=0.0, maximum=1.0, value=0.25, step=0.001
-                    )
-                    text_threshold = gr.Slider(
-                        label="Text Threshold", minimum=0.0, maximum=1.0, value=0.25, step=0.001
-                    )
-
-            with gr.Column():
-                gallery = gr.outputs.Image(
-                    type="pil",
-                    # label="grounding results"
-                ).style(full_width=True, full_height=True)
-                # gallery = gr.Gallery(label="Generated images", show_label=False).style(
-                #         grid=[1], height="auto", container=True, full_width=True, full_height=True)
-
-        run_button.click(fn=run_grounding, inputs=[
-                        input_image, grounding_caption, box_threshold, text_threshold], outputs=[gallery])
-        gr.Examples(
-          [["watermelon.jpg", "watermelon", 0.25, 0.25]],
-          inputs = [input_image, grounding_caption, box_threshold, text_threshold],
-          outputs = [gallery],
-          fn=run_grounding,
-          cache_examples=True,
-          label='Try this example input!'
-      )
-    block.launch(share=True, show_api=False, show_error=True)
-

spaces/Audio-AGI/WavJourney/README.md

@@ -1,111 +0,0 @@
----
-title: WavJourney
-emoji: 🔥
-colorFrom: blue
-colorTo: purple
-sdk: docker
-pinned: false
-license: cc-by-nc-4.0
----
-# <span style="color: blue;">🎵</span> WavJourney: Compositional Audio Creation with LLMs
-[![arXiv](https://img.shields.io/badge/arXiv-Paper-<COLOR>.svg)](https://arxiv.org/abs/2307.14335) [![GitHub Stars](https://img.shields.io/github/stars/Audio-AGI/WavJourney?style=social)](https://github.com/Audio-AGI/WavJourney/) [![githubio](https://img.shields.io/badge/GitHub.io-Demo_Page-blue?logo=Github&style=flat-square)](https://audio-agi.github.io/WavJourney_demopage/) [![Hugging Face Spaces](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue)](https://huggingface.co/spaces/Audio-AGI/WavJourney)  
-
-
-This repository contains the official implementation of ["WavJourney: Compositional Audio Creation with Large Language Models"](https://audio-agi.github.io/WavJourney_demopage/WavJourney_arXiv.pdf).
-
-Starting with a text prompt, WavJourney can create audio content with engaging storylines encompassing personalized speakers, lifelike speech in context, emotionally resonant music compositions, and impactful sound effects that enhance the auditory experience. Check the audio examples in the [Project Page](https://audio-agi.github.io/WavJourney_demopage/)!
-
-<!-- <p align="center">
-  <img align="middle" width="800" src="assets/WavJourney.png"/>
-</p> -->
-
-<hr>
-
-
-## Preliminaries
-1. Install the environment:
-```bash
-bash ./scripts/EnvsSetup.sh
-```
-2. Activate the conda environment:
-```bash
-conda activate WavJourney
-```
-
-3. (Optional) You can modify the default configuration in `config.yaml`, check the details described in the configuration file. 
-4. Pre-download the models (might take some time):
-```bash
-python scripts/download_models.py
-```
-
-5. Set the WAVJOURNEY_OPENAI_KEY in the environment variable for accessing [GPT-4 API](https://platform.openai.com/account/api-keys) [[Guidance](https://help.openai.com/en/articles/7102672-how-can-i-access-gpt-4)]
-```bash
-export WAVJOURNEY_OPENAI_KEY=your_openai_key_here
-```
-
-6. Set environment variables for using API services
-```bash
-# Set the port for the WAVJOURNEY service to 8021
-export WAVJOURNEY_SERVICE_PORT=8021
-
-# Set the URL for the WAVJOURNEY service to 127.0.0.1
-export WAVJOURNEY_SERVICE_URL=127.0.0.1
-
-# Limit the maximum script lines for WAVJOURNEY to 999
-export WAVJOURNEY_MAX_SCRIPT_LINES=999
-```
-
-
-7. Start Python API services (e.g., Text-to-Speech, Text-to-Audio)
-```bash
-bash scripts/start_services.sh
-```
-
-## Web APP
- ```bash
-bash scripts/start_ui.sh
-  ```
-
-## Commandline Usage
- ```bash
- python wavjourney_cli.py -f --input-text "Generate a one-minute introduction to quantum mechanics" 
- ```
-
-
-## Kill the services
-You can kill the running services via this command:
- ```bash
-python scripts/kill_services.py
-  ```
-  
-## (Advanced features) Speaker customization 
-You can add voice presets to WavJourney to customize the voice actors. Simply provide the voice id, the description and a sample wav file, and WavJourney will pick the voice automatically based on the audio script. Predefined system voice presets are in `data/voice_presets`.
-
-You can manage voice presets via UI. Specifically, if you want to add voice to voice presets. Run the script via command line below:
-```bash
-python add_voice_preset.py --id "id" --desc "description" --wav-path path/to/wav --session-id ''
-```
-What makes for good voice prompt? See detailed instructions <a href="https://github.com/gitmylo/bark-voice-cloning-HuBERT-quantizer">here</a>. 
-## Hardware requirement
-- The VRAM of the GPU in the default configuration should be greater than 16 GB.
-- Operation system: Linux.
-
-## Citation
-If you find this work useful, you can cite the paper below:
-
-    @article{liu2023wavjourney,
-        title   = {WavJourney: Compositional Audio Creation with Large Language Models},
-        author  = {Liu, Xubo and Zhu, Zhongkai and Liu, Haohe and Yuan, Yi and Huang, Qiushi and Liang, Jinhua and Cao, Yin and Kong, Qiuqiang and Plumbley, Mark D and Wang, Wenwu},
-        journal = {arXiv preprint arXiv:2307.14335},
-        year    = {2023}
-    }
-
-[!["Buy Me A Coffee"](https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png)](https://www.buymeacoffee.com/liuxubo)
-
-## Appreciation
-- [Bark](https://github.com/suno-ai/bark) for a zero-shot text-to-speech synthesis model.
-- [AudioCraft](https://github.com/facebookresearch/audiocraft) for state-of-the-art audio generation models.
-
-## Disclaimer
-We are not responsible for audio generated using semantics created by this model. Just don't use it for illegal purposes.
-

spaces/AutoLLM/AutoAgents/autoagents/spaces/app.py

@@ -1,153 +0,0 @@
-import os
-import asyncio
-import random
-from datetime import date, datetime, timezone, timedelta
-from ast import literal_eval
-
-import streamlit as st
-import openai
-
-from autoagents.utils.constants import MAIN_HEADER, MAIN_CAPTION, SAMPLE_QUESTIONS
-from autoagents.agents.search import ActionRunner
-
-from langchain.chat_models import ChatOpenAI
-
-
-async def run():
-    output_acc = ""
-    st.session_state["random"] = random.randint(0, 99)
-    if "task" not in st.session_state:
-        st.session_state.task = None
-    if "model_name" not in st.session_state:
-        st.session_state.model_name = "gpt-3.5-turbo"
-
-    st.set_page_config(
-        page_title="Search Agent",
-        page_icon="🤖",
-        layout="wide",
-        initial_sidebar_state="expanded",
-    )
-
-    st.title(MAIN_HEADER)
-    st.caption(MAIN_CAPTION)
-
-    with st.form("my_form", clear_on_submit=False):
-        st.markdown("<style> .inter { white-space: pre-line; } </style>", unsafe_allow_html=True)
-        user_input = st.text_input(
-            "You: ",
-            key="input",
-            placeholder="Ask me anything ...",
-            label_visibility="hidden",
-        )
-
-        submitted = st.form_submit_button(
-            "Search", help="Hit to submit the search query."
-        )
-
-        # Ask the user to enter their OpenAI API key
-        if (api_key := st.sidebar.text_input("OpenAI api-key", type="password")):
-            api_org = None
-        else:
-            api_key, api_org = os.getenv("OPENAI_API_KEY"), os.getenv("OPENAI_API_ORG")
-        with st.sidebar:
-            model_dict = {
-                "gpt-3.5-turbo": "GPT-3.5-turbo",
-                "gpt-4": "GPT-4 (Better but slower)",
-            }
-            st.radio(
-                "OpenAI model",
-                model_dict.keys(),
-                key="model_name",
-                format_func=lambda x: model_dict[x],
-            )
-
-            time_zone = str(datetime.now(timezone(timedelta(0))).astimezone().tzinfo)
-            st.markdown(f"**The system time zone is {time_zone} and the date is {date.today()}**")
-
-            st.markdown("**Example Queries:**")
-            for q in SAMPLE_QUESTIONS:
-                st.markdown(f"*{q}*")
-
-        if not api_key:
-            st.warning(
-                "API key required to try this app. The API key is not stored in any form. [This](https://help.openai.com/en/articles/4936850-where-do-i-find-my-secret-api-key) might help."
-            )
-        elif api_org and st.session_state.model_name == "gpt-4":
-            st.warning(
-                "The free API key does not support GPT-4. Please switch to GPT-3.5-turbo or input your own API key."
-            )
-        else:
-            outputq = asyncio.Queue()
-            runner = ActionRunner(outputq,
-                                  ChatOpenAI(openai_api_key=api_key,
-                                             openai_organization=api_org,
-                                             temperature=0,
-                                             model_name=st.session_state.model_name),
-                                  persist_logs=True)  # log to HF-dataset
-
-            async def cleanup(e):
-                st.error(e)
-                await st.session_state.task
-                st.session_state.task = None
-                st.stop()
-
-            placeholder = st.empty()
-
-            if user_input and submitted:
-                if st.session_state.task is not None:
-                    with placeholder.container():
-                        st.session_state.task.cancel()
-                        st.warning("Previous search aborted", icon="⚠️")
-
-                st.session_state.task = asyncio.create_task(
-                    runner.run(user_input, outputq)
-                )
-                iterations = 0
-                with st.expander("Search Results", expanded=True):
-                    while True:
-                        with st.spinner("Wait for it..."):
-                            output = await outputq.get()
-                            placeholder.empty()
-                            if isinstance(output, Exception):
-                                if isinstance(output, openai.error.AuthenticationError):
-                                    await cleanup(f"AuthenticationError: Invalid OpenAI API key.")
-                                elif isinstance(output, openai.error.InvalidRequestError) \
-                                      and output._message == "The model: `gpt-4` does not exist":
-                                    await cleanup(f"The free API key does not support GPT-4. Please switch to GPT-3.5-turbo or input your own API key.")
-                                elif isinstance(output, openai.error.OpenAIError):
-                                    await cleanup(output)
-                                elif isinstance(output, RuntimeWarning):
-                                    st.warning(output)
-                                    continue
-                                else:
-                                    await cleanup("Something went wrong. Please try searching again.")
-                                return
-                            try:
-                                output_fmt = literal_eval(output)
-                                st.json(output_fmt, expanded=False)
-                                st.write("---")
-                                iterations += 1
-                            except:
-                                output_acc += "\n" + output
-                                st.markdown(f"<div class=\"inter\"> {output} </div>",
-                                            unsafe_allow_html=True)
-                            if iterations >= runner.agent_executor.max_iterations:
-                                await cleanup(
-                                    f"Maximum iterations ({iterations}) exceeded. You can try running the search again or try a variation of the query."
-                                )
-                                return
-                            if "Final Answer:" in output:
-                                break
-                # Found the answer
-                final_answer = await st.session_state.task
-                final_answer = final_answer.replace("$", "\$")
-                # st.success accepts md
-                st.success(final_answer, icon="✅")
-                st.balloons()
-                st.session_state.task = None
-                st.stop()
-
-if __name__ == "__main__":
-    loop = asyncio.new_event_loop()
-    loop.set_debug(enabled=False)
-    loop.run_until_complete(run())

spaces/BAAI/vid2vid-zero/Dockerfile

@@ -1,57 +0,0 @@
-FROM nvidia/cuda:11.7.1-cudnn8-devel-ubuntu22.04
-ENV DEBIAN_FRONTEND=noninteractive
-RUN apt-get update && \
-    apt-get upgrade -y && \
-    apt-get install -y --no-install-recommends \
-    git \
-    git-lfs \
-    wget \
-    curl \
-    # ffmpeg \
-    ffmpeg \
-    x264 \
-    # python build dependencies \
-    build-essential \
-    libssl-dev \
-    zlib1g-dev \
-    libbz2-dev \
-    libreadline-dev \
-    libsqlite3-dev \
-    libncursesw5-dev \
-    xz-utils \
-    tk-dev \
-    libxml2-dev \
-    libxmlsec1-dev \
-    libffi-dev \
-    liblzma-dev && \
-    apt-get clean && \
-    rm -rf /var/lib/apt/lists/*
-
-RUN useradd -m -u 1000 user
-USER user
-ENV HOME=/home/user \
-    PATH=/home/user/.local/bin:${PATH}
-WORKDIR ${HOME}/app
-
-RUN curl https://pyenv.run | bash
-ENV PATH=${HOME}/.pyenv/shims:${HOME}/.pyenv/bin:${PATH}
-ENV PYTHON_VERSION=3.10.9
-RUN pyenv install ${PYTHON_VERSION} && \
-    pyenv global ${PYTHON_VERSION} && \
-    pyenv rehash && \
-    pip install --no-cache-dir -U pip setuptools wheel
-
-RUN pip install --no-cache-dir -U torch==1.13.1 torchvision==0.14.1
-COPY --chown=1000 requirements.txt /tmp/requirements.txt
-RUN pip install --no-cache-dir -U -r /tmp/requirements.txt
-
-COPY --chown=1000 . ${HOME}/app
-# RUN cd Tune-A-Video && patch -p1 < ../patch
-ENV PYTHONPATH=${HOME}/app \
-    PYTHONUNBUFFERED=1 \
-    GRADIO_ALLOW_FLAGGING=never \
-    GRADIO_NUM_PORTS=1 \
-    GRADIO_SERVER_NAME=0.0.0.0 \
-    GRADIO_THEME=huggingface \
-    SYSTEM=spaces
-CMD ["python", "app.py"]

spaces/Bala2-03-2003/MygenvioceAI/app.py

@@ -1,164 +0,0 @@
-import os
-import re
-import requests
-import json
-import gradio as gr
-from langchain.chat_models import ChatOpenAI
-from langchain import LLMChain, PromptTemplate
-from langchain.memory import ConversationBufferMemory
-
-OPENAI_API_KEY=os.getenv('OPENAI_API_KEY')
-PLAY_HT_API_KEY=os.getenv('PLAY_HT_API_KEY')
-PLAY_HT_USER_ID=os.getenv('PLAY_HT_USER_ID')
-
-PLAY_HT_VOICE_ID=os.getenv('PLAY_HT_VOICE_ID')
-play_ht_api_get_audio_url = "https://play.ht/api/v2/tts"
-
-
-template = """You are a helpful assistant to answer user queries.
-{chat_history}
-User: {user_message}
-Chatbot:"""
-
-prompt = PromptTemplate(
-    input_variables=["chat_history", "user_message"], template=template
-)
-
-memory = ConversationBufferMemory(memory_key="chat_history")
-
-llm_chain = LLMChain(
-    llm=ChatOpenAI(temperature='0.5', model_name="gpt-3.5-turbo"),
-    prompt=prompt,
-    verbose=True,
-    memory=memory,
-)
-
-headers = {
-      "accept": "text/event-stream",
-      "content-type": "application/json",
-      "AUTHORIZATION": "Bearer "+ PLAY_HT_API_KEY,
-      "X-USER-ID": PLAY_HT_USER_ID
-}
-
-
-def get_payload(text):
-  return {
-    "text": text,
-    "voice": PLAY_HT_VOICE_ID,
-    "quality": "medium",
-    "output_format": "mp3",
-    "speed": 1,
-    "sample_rate": 24000,
-    "seed": None,
-    "temperature": None
-  }
-
-def get_generated_audio(text):
-  payload = get_payload(text)
-  generated_response = {}
-  try:
-      response = requests.post(play_ht_api_get_audio_url, json=payload, headers=headers)
-      response.raise_for_status()
-      generated_response["type"]= 'SUCCESS'
-      generated_response["response"] = response.text
-  except requests.exceptions.RequestException as e:
-      generated_response["type"]= 'ERROR'
-      try:
-        response_text = json.loads(response.text)
-        if response_text['error_message']:
-          generated_response["response"] = response_text['error_message']
-        else:
-          generated_response["response"] = response.text
-      except Exception as e:
-        generated_response["response"] = response.text
-  except Exception as e:
-    generated_response["type"]= 'ERROR'
-    generated_response["response"] = response.text
-  return generated_response
-
-def extract_urls(text):
-    # Define the regex pattern for URLs
-    url_pattern = r'https?://(?:[-\w.]|(?:%[\da-fA-F]{2}))+[/\w\.-]*'
-
-    # Find all occurrences of URLs in the text
-    urls = re.findall(url_pattern, text)
-
-    return urls
-
-def get_audio_reply_for_question(text):
-  generated_audio_event = get_generated_audio(text)
-  #From get_generated_audio, you will get events in a string format, from that we need to extract the url
-  final_response = {
-      "audio_url": '',
-      "message": ''
-  }
-  if generated_audio_event["type"] == 'SUCCESS':
-    audio_urls = extract_urls(generated_audio_event["response"])
-    if len(audio_urls) == 0:
-      final_response['message'] = "No audio file link found in generated event"
-    else:
-      final_response['audio_url'] = audio_urls[-1]
-  else:
-    final_response['message'] = generated_audio_event['response']
-  return final_response
-
-def download_url(url):
-    try:
-        # Send a GET request to the URL to fetch the content
-        final_response = {
-            'content':'',
-            'error':''
-        }
-        response = requests.get(url)
-        # Check if the request was successful (status code 200)
-        if response.status_code == 200:
-            final_response['content'] = response.content
-        else:
-            final_response['error'] = f"Failed to download the URL. Status code: {response.status_code}"
-    except Exception as e:
-        final_response['error'] = f"Failed to download the URL. Error: {e}"
-    return final_response
-
-def get_filename_from_url(url):
-    # Use os.path.basename() to extract the file name from the URL
-    file_name = os.path.basename(url)
-    return file_name
-
-def get_text_response(user_message):
-    response = llm_chain.predict(user_message = user_message)
-    return response
-
-def get_text_response_and_audio_response(user_message):
-    response = get_text_response(user_message) # Getting the reply from Open AI
-    audio_reply_for_question_response = get_audio_reply_for_question(response)
-    final_response = {
-        'output_file_path': '',
-        'message':''
-    }
-    audio_url = audio_reply_for_question_response['audio_url']
-    if audio_url:
-      output_file_path=get_filename_from_url(audio_url)
-      download_url_response = download_url(audio_url)
-      audio_content = download_url_response['content']
-      if audio_content:
-        with open(output_file_path, "wb") as audio_file:
-          audio_file.write(audio_content)
-          final_response['output_file_path'] = output_file_path
-      else:
-          final_response['message'] = download_url_response['error']
-    else:
-      final_response['message'] = audio_reply_for_question_response['message']
-    return final_response
-
-def chat_bot_response(message, history):
-    text_and_audio_response = get_text_response_and_audio_response(message)
-    output_file_path = text_and_audio_response['output_file_path']
-    if output_file_path:
-      return (text_and_audio_response['output_file_path'],)
-    else:
-      return text_and_audio_response['message']
-
-demo = gr.ChatInterface(chat_bot_response,examples=["How are you doing?","What are your interests?","Which places do you like to visit?"])
-
-if __name__ == "__main__":
-    demo.launch() #To create a public link, set `share=True` in `launch()`. To enable errors and logs, set `debug=True` in `launch()`.

spaces/BartPoint/VoiceChange/app_multi.py

@@ -1,469 +0,0 @@
-from typing import Union
-
-from argparse import ArgumentParser
-
-import asyncio
-import json
-import hashlib
-from os import path, getenv
-
-import gradio as gr
-
-import torch
-
-import numpy as np
-import librosa
-
-import edge_tts
-
-import config
-import util
-from infer_pack.models import (
-    SynthesizerTrnMs768NSFsid,
-    SynthesizerTrnMs768NSFsid_nono
-)
-from vc_infer_pipeline import VC
-    
-# Reference: https://huggingface.co/spaces/zomehwh/rvc-models/blob/main/app.py#L21  # noqa
-in_hf_space = getenv('SYSTEM') == 'spaces'
-
-# Argument parsing
-arg_parser = ArgumentParser()
-arg_parser.add_argument(
-    '--hubert',
-    default=getenv('RVC_HUBERT', 'hubert_base.pt'),
-    help='path to hubert base model (default: hubert_base.pt)'
-)
-arg_parser.add_argument(
-    '--config',
-    default=getenv('RVC_MULTI_CFG', 'multi_config.json'),
-    help='path to config file (default: multi_config.json)'
-)
-arg_parser.add_argument(
-    '--api',
-    action='store_true',
-    help='enable api endpoint'
-)
-arg_parser.add_argument(
-    '--cache-examples',
-    action='store_true',
-    help='enable example caching, please remember delete gradio_cached_examples folder when example config has been modified'  # noqa
-)
-args = arg_parser.parse_args()
-
-app_css = '''
-#model_info img {
-    max-width: 100px;
-    max-height: 100px;
-    float: right;
-}
-
-#model_info p {
-    margin: unset;
-}
-'''
-
-app = gr.Blocks(
-    theme=gr.themes.Soft(primary_hue="orange", secondary_hue="slate"),
-    css=app_css,
-    analytics_enabled=False
-)
-
-# Load hubert model
-hubert_model = util.load_hubert_model(config.device, args.hubert)
-hubert_model.eval()
-
-# Load models
-multi_cfg = json.load(open(args.config, 'r'))
-loaded_models = []
-
-for model_name in multi_cfg.get('models'):
-    print(f'Loading model: {model_name}')
-
-    # Load model info
-    model_info = json.load(
-        open(path.join('model', model_name, 'config.json'), 'r')
-    )
-
-    # Load RVC checkpoint
-    cpt = torch.load(
-        path.join('model', model_name, model_info['model']),
-        map_location='cpu'
-    )
-    tgt_sr = cpt['config'][-1]
-    cpt['config'][-3] = cpt['weight']['emb_g.weight'].shape[0]  # n_spk
-
-    if_f0 = cpt.get('f0', 1)
-    net_g: Union[SynthesizerTrnMs768NSFsid, SynthesizerTrnMs768NSFsid_nono]
-    if if_f0 == 1:
-        net_g = SynthesizerTrnMs768NSFsid(
-            *cpt['config'],
-            is_half=util.is_half(config.device)
-        )
-    else:
-        net_g = SynthesizerTrnMs768NSFsid_nono(*cpt['config'])
-
-    del net_g.enc_q
-
-    # According to original code, this thing seems necessary.
-    print(net_g.load_state_dict(cpt['weight'], strict=False))
-
-    net_g.eval().to(config.device)
-    net_g = net_g.half() if util.is_half(config.device) else net_g.float()
-
-    vc = VC(tgt_sr, config)
-    
-    loaded_models.append(dict(
-        name=model_name,
-        metadata=model_info,
-        vc=vc,
-        net_g=net_g,
-        if_f0=if_f0,
-        target_sr=tgt_sr
-    ))
-        
-print(f'Models loaded: {len(loaded_models)}')
-
-# Edge TTS speakers
-tts_speakers_list = asyncio.get_event_loop().run_until_complete(edge_tts.list_voices())  # noqa
-
-
-# https://github.com/fumiama/Retrieval-based-Voice-Conversion-WebUI/blob/main/infer-web.py#L118  # noqa
-def vc_func(
-    input_audio, model_index, pitch_adjust, f0_method, feat_ratio,
-    filter_radius, rms_mix_rate, resample_option
-):
-    if input_audio is None:
-        return (None, 'Please provide input audio.')
-
-    if model_index is None:
-        return (None, 'Please select a model.')
-
-    model = loaded_models[model_index]
-
-    # Reference: so-vits
-    (audio_samp, audio_npy) = input_audio
-
-    # https://huggingface.co/spaces/zomehwh/rvc-models/blob/main/app.py#L49
-    # Can be change well, we will see
-    if (audio_npy.shape[0] / audio_samp) > 320 and in_hf_space:
-        return (None, 'Input audio is longer than 60 secs.')
-
-    # Bloody hell: https://stackoverflow.com/questions/26921836/
-    if audio_npy.dtype != np.float32:  # :thonk:
-        audio_npy = (
-            audio_npy / np.iinfo(audio_npy.dtype).max
-        ).astype(np.float32)
-
-    if len(audio_npy.shape) > 1:
-        audio_npy = librosa.to_mono(audio_npy.transpose(1, 0))
-
-    if audio_samp != 16000:
-        audio_npy = librosa.resample(
-            audio_npy,
-            orig_sr=audio_samp,
-            target_sr=16000
-        )
-
-    pitch_int = int(pitch_adjust)
-
-    resample = (
-        0 if resample_option == 'Disable resampling'
-        else int(resample_option)
-    )
-
-    times = [0, 0, 0]
-
-    checksum = hashlib.sha512()
-    checksum.update(audio_npy.tobytes())
-
-    output_audio = model['vc'].pipeline(
-        hubert_model,
-        model['net_g'],
-        model['metadata'].get('speaker_id', 0),
-        audio_npy,
-        checksum.hexdigest(),
-        times,
-        pitch_int,
-        f0_method,
-        path.join('model', model['name'], model['metadata']['feat_index']),
-        feat_ratio,
-        model['if_f0'],
-        filter_radius,
-        model['target_sr'],
-        resample,
-        rms_mix_rate,
-        'v2'
-    )
-
-    out_sr = (
-        resample if resample >= 16000 and model['target_sr'] != resample
-        else model['target_sr']
-    )
-
-    print(f'npy: {times[0]}s, f0: {times[1]}s, infer: {times[2]}s')
-    return ((out_sr, output_audio), 'Success')
-
-
-async def edge_tts_vc_func(
-    input_text, model_index, tts_speaker, pitch_adjust, f0_method, feat_ratio,
-    filter_radius, rms_mix_rate, resample_option
-):
-    if input_text is None:
-        return (None, 'Please provide TTS text.')
-
-    if tts_speaker is None:
-        return (None, 'Please select TTS speaker.')
-
-    if model_index is None:
-        return (None, 'Please select a model.')
-
-    speaker = tts_speakers_list[tts_speaker]['ShortName']
-    (tts_np, tts_sr) = await util.call_edge_tts(speaker, input_text)
-    return vc_func(
-        (tts_sr, tts_np),
-        model_index,
-        pitch_adjust,
-        f0_method,
-        feat_ratio,
-        filter_radius,
-        rms_mix_rate,
-        resample_option
-    )
-
-
-def update_model_info(model_index):
-    if model_index is None:
-        return str(
-            '### Model info\n'
-            'Please select a model from dropdown above.'
-        )
-
-    model = loaded_models[model_index]
-    model_icon = model['metadata'].get('icon', '')
-
-    return str(
-        '### Model info\n'
-        '![model icon]({icon})'
-        '**{name}**\n\n'
-        'Author: {author}\n\n'
-        'Source: {source}\n\n'
-        '{note}'
-    ).format(
-        name=model['metadata'].get('name'),
-        author=model['metadata'].get('author', 'Anonymous'),
-        source=model['metadata'].get('source', 'Unknown'),
-        note=model['metadata'].get('note', ''),
-        icon=(
-            model_icon
-            if model_icon.startswith(('http://', 'https://'))
-            else '/file/model/%s/%s' % (model['name'], model_icon)
-        )
-    )
-
-
-def _example_vc(
-    input_audio, model_index, pitch_adjust, f0_method, feat_ratio,
-    filter_radius, rms_mix_rate, resample_option
-):
-    (audio, message) = vc_func(
-        input_audio, model_index, pitch_adjust, f0_method, feat_ratio,
-        filter_radius, rms_mix_rate, resample_option
-    )
-    return (
-        audio,
-        message,
-        update_model_info(model_index)
-    )
-
-
-async def _example_edge_tts(
-    input_text, model_index, tts_speaker, pitch_adjust, f0_method, feat_ratio,
-    filter_radius, rms_mix_rate, resample_option
-):
-    (audio, message) = await edge_tts_vc_func(
-        input_text, model_index, tts_speaker, pitch_adjust, f0_method,
-        feat_ratio, filter_radius, rms_mix_rate, resample_option
-    )
-    return (
-        audio,
-        message,
-        update_model_info(model_index)
-    )
-
-
-with app:
-    gr.Markdown(
-        '## A simplistic Web interface\n'
-        'RVC interface, project based on [RVC-WebUI](https://github.com/fumiama/Retrieval-based-Voice-Conversion-WebUI)'  # thx noqa
-        'A lot of inspiration from what\'s already out there, including [zomehwh/rvc-models](https://huggingface.co/spaces/zomehwh/rvc-models) & [DJQmUKV/rvc-inference](https://huggingface.co/spaces/DJQmUKV/rvc-inference).\n '  # thx noqa
-    )
-
-    with gr.Row():
-        with gr.Column():
-            with gr.Tab('Audio conversion'):
-                input_audio = gr.Audio(label='Input audio')
-
-                vc_convert_btn = gr.Button('Convert', variant='primary')
-
-            with gr.Tab('TTS conversion'):
-                tts_input = gr.TextArea(
-                    label='TTS input text'
-                )
-                tts_speaker = gr.Dropdown(
-                    [
-                        '%s (%s)' % (
-                            s['FriendlyName'],
-                            s['Gender']
-                        )
-                        for s in tts_speakers_list
-                    ],
-                    label='TTS speaker',
-                    type='index'
-                )
-
-                tts_convert_btn = gr.Button('Convert', variant='primary')
-
-            pitch_adjust = gr.Slider(
-                label='Pitch',
-                minimum=-24,
-                maximum=24,
-                step=1,
-                value=0
-            )
-            f0_method = gr.Radio(
-                label='f0 methods',
-                choices=['pm', 'harvest', 'crepe'],
-                value='pm',
-                interactive=True
-            )
-
-            with gr.Accordion('Advanced options', open=False):
-                feat_ratio = gr.Slider(
-                    label='Feature ratio',
-                    minimum=0,
-                    maximum=1,
-                    step=0.1,
-                    value=0.6
-                )
-                filter_radius = gr.Slider(
-                    label='Filter radius',
-                    minimum=0,
-                    maximum=7,
-                    step=1,
-                    value=3
-                )
-                rms_mix_rate = gr.Slider(
-                    label='Volume envelope mix rate',
-                    minimum=0,
-                    maximum=1,
-                    step=0.1,
-                    value=1
-                )
-                resample_rate = gr.Dropdown(
-                    [
-                        'Disable resampling',
-                        '16000',
-                        '22050',
-                        '44100',
-                        '48000'
-                    ],
-                    label='Resample rate',
-                    value='Disable resampling'
-                )
-
-        with gr.Column():
-            # Model select
-            model_index = gr.Dropdown(
-                [
-                    '%s - %s' % (
-                        m['metadata'].get('source', 'Unknown'),
-                        m['metadata'].get('name')
-                    )
-                    for m in loaded_models
-                ],
-                label='Model',
-                type='index'
-            )
-
-            # Model info
-            with gr.Box():
-                model_info = gr.Markdown(
-                    '### Model info\n'
-                    'Please select a model from dropdown above.',
-                    elem_id='model_info'
-                )
-
-            output_audio = gr.Audio(label='Output audio')
-            output_msg = gr.Textbox(label='Output message')
-
-    multi_examples = multi_cfg.get('examples')
-    if (
-        multi_examples and
-        multi_examples.get('vc') and multi_examples.get('tts_vc')
-    ):
-        with gr.Accordion('Sweet sweet examples', open=False):
-            with gr.Row():
-                # VC Example
-                if multi_examples.get('vc'):
-                    gr.Examples(
-                        label='Audio conversion examples',
-                        examples=multi_examples.get('vc'),
-                        inputs=[
-                            input_audio, model_index, pitch_adjust, f0_method,
-                            feat_ratio
-                        ],
-                        outputs=[output_audio, output_msg, model_info],
-                        fn=_example_vc,
-                        cache_examples=args.cache_examples,
-                        run_on_click=args.cache_examples
-                    )
-
-                # Edge TTS Example
-                if multi_examples.get('tts_vc'):
-                    gr.Examples(
-                        label='TTS conversion examples',
-                        examples=multi_examples.get('tts_vc'),
-                        inputs=[
-                            tts_input, model_index, tts_speaker, pitch_adjust,
-                            f0_method, feat_ratio
-                        ],
-                        outputs=[output_audio, output_msg, model_info],
-                        fn=_example_edge_tts,
-                        cache_examples=args.cache_examples,
-                        run_on_click=args.cache_examples
-                    )
-
-    vc_convert_btn.click(
-        vc_func,
-        [
-            input_audio, model_index, pitch_adjust, f0_method, feat_ratio,
-            filter_radius, rms_mix_rate, resample_rate
-        ],
-        [output_audio, output_msg],
-        api_name='audio_conversion'
-    )
-
-    tts_convert_btn.click(
-        edge_tts_vc_func,
-        [
-            tts_input, model_index, tts_speaker, pitch_adjust, f0_method,
-            feat_ratio, filter_radius, rms_mix_rate, resample_rate
-        ],
-        [output_audio, output_msg],
-        api_name='tts_conversion'
-    )
-
-    model_index.change(
-        update_model_info,
-        inputs=[model_index],
-        outputs=[model_info],
-        show_progress=False,
-        queue=False
-    )
-
-app.queue(
-    concurrency_count=1,
-    max_size=20,
-    api_open=args.api
-).launch()

spaces/Benson/text-generation/Examples/Aparcamiento De Coches Multijugador Sudfrica Edicin Apk Descargar.md

@@ -1,134 +0,0 @@
-
-<h1>Aparcamiento de coches multijugador Sudáfrica Edición APK Descargar: Una guía para los usuarios de Android</h1>
- <p>Si usted está buscando un juego de estacionamiento de coches realista y divertido que ofrece más que solo estacionamiento, es posible que desee echa un vistazo a Parking Multijugador. Y si usted está en Sudáfrica o desea experimentar la cultura del automóvil de Sudáfrica, es posible que desee probar el Aparcamiento Multijugador South áfrica Edition APK. En este artículo, te diremos qué es el Car Parking Multiplayer, qué hace que South áfrica Edition sea diferente, cómo descargarlo e instalarlo en tu dispositivo Android, y algunos consejos y trucos para jugarlo. </p>
- <h2>¿Qué es el Aparcamiento Multijugador? </h2>
- <p>Car Parking Multiplayer es un juego que puede engañarte con su nombre bastante engañoso. Pero, es mucho más que solo estar aparcando tu coche. Es una experiencia de mundo abierto donde se puede conducir gratis y sí, todavía trabajar en ese aparcamiento si lo desea. Incluso puedes saltar de tu coche y caminar. Hay diferentes áreas que se pueden explorar en el juego. Cada una es como su propio mundo abierto. Puedes optar por jugar en modo de un solo jugador o en modo online si quieres una escena más caótica (de forma divertida) . </p>
-<h2>aparcamiento de coches multijugador sudáfrica edición apk descargar</h2><br /><p><b><b>DOWNLOAD</b> === <a href="https://bltlly.com/2v6IE9">https://bltlly.com/2v6IE9</a></b></p><br /><br />
- <h3>Características de Aparcamiento Multijugador</h3>
- <p>Aparcamiento de coches multijugador tiene las siguientes características  :</p>
-<ul>
-<li>Modo multijugador de mundo abierto   <ul>
-    <li>Caminar libremente</li>
-    <li>Mundo abierto libre con gasolineras reales y servicios de automóviles</li>
-    <li>Compite contra jugadores reales en las carreras multijugador</li>
-    <li>Intercambiar coches con jugadores reales</li>
-    <li>Miles de jugadores reales cada día</li>
-    <li>Lista de amigos</li>
-    <li>Chat de voz</li>
-    <li>Modo de policía</li>
-  </ul>
-</li>
-<li>Personalización del coche   <ul>
-    <li>Suspensión ajustable, ángulo de rueda y más</li>
-    <li>Ajuste del motor: motor de intercambio, turbo, caja de cambios y escape</li>
-    <li>Visual auto tungs: Vynils dinámico, partes del cuerpo del coche</li>
-  </ul>
-</li>
-<li>Mundo abierto de alta calidad   <ul>
-
-    <li>100 coches con el interior real</li>
-    <li>16 pieles de jugador</li>
-    <li>Edificios con interior</li>
-  </ul>
-</li>
-<li>Juego interesante   <ul>
-    <li>82 desafíos de estacionamiento y conducción en la vida real</li>
-    <li>Diferentes vehículos: Grúa, camioneta, camiones, coches deportivos y clásicos</li>
-  </ul>
-</li>
-</ul>
- <h3>Opiniones de Aparcamiento multijugador</h3>
- <p>Aparcamiento de coches multijugador ha recibido en su mayoría críticas positivas de los usuarios en Google Play Store y App Store. Tiene una calificación de 4.4 de 5 estrellas en Google Play Store y una calificación de 4.3 de 5 estrellas en App Store . Estos son algunos de los comentarios de los usuarios:</p>
- <blockquote><p>"Increíble juego! No hay errores en este juego o retrasos ect. (base en el dispositivo que utiliza) Me encantan los gráficos y los coches. Los coches son tan realistas y los sonidos son increíbles. Me encanta cómo puedes personalizar tu coche y hacer que se vea genial. El modo multijugador es increíble. Puedes chatear con otros jugadores y competir con ellos. También puedes unirte a un clan o crear tu propio clan. Este juego es muy divertido y adictivo. Recomiendo este juego a todos los que aman los coches y los juegos de estacionamiento." </p></blockquote>
- <blockquote><p>"Este juego es muy bueno pero necesita algunas mejoras como agregar más coches, más mapas, más personalizaciones, más modos de juego, más desafíos, etc. Además, el juego se bloquea a veces y los controles no son muy suaves. Los gráficos son agradables, pero pueden ser mejores. El juego es divertido de jugar con amigos, pero se vuelve aburrido después de un tiempo. Espero que los desarrolladores actualicen el juego pronto y lo hagan más agradable." </p></blockquote>
-
- <h2>¿Qué es el aparcamiento multijugador South áfrica Edition? </h2>
- <p>Car Parking Multijugador South áfrica Edition es una versión modificada de Car Parking Multijugador que está especialmente diseñado para los usuarios sudafricanos o los fans de la cultura del coche de Sudáfrica. No es una versión oficial del juego, sino un archivo APK hecho por fans que se puede descargar e instalar en dispositivos Android . </p>
- <h3>Diferencias entre Aparcamiento de coches multijugador y Aparcamiento de coches multijugador Sudáfrica Edición</h3>
- <p>Car Parking Multijugador South áfrica Edition tiene algunas diferencias con el juego original Car Parking Multijugador, como   :</p>
-<ul>
-<li>Más coches que son populares en Sudáfrica, como BMW E30, VW Golf Mk1, Toyota Corolla, Nissan 1400, etc.</li>
-<li>Más personalizaciones que reflejan la cultura del automóvil sudafricano, como llantas giratorias, escapes fuertes, pegatinas, banderas, etc.</li>
-<li>Más mapas que se basan en ubicaciones reales en Sudáfrica, como Ciudad del Cabo, Johannesburgo, Durban, etc.</li>
-<li>Más música inspirada en la escena musical sudafricana, como kwaito, gqom, amapiano, etc.</li>
-<li>Más idiomas que se hablan en Sudáfrica, como afrikaans, zulú, xhosa, etc.</li>
-</ul>
- <h3>Beneficios de Aparcamiento Multijugador South áfrica Edition</h3>
- <p>Car Parking Multijugador South áfrica Edition tiene algunos beneficios para los usuarios que quieren disfrutar del juego con un toque sudafricano, como   :</p>
-<ul>
-<li>Más variedad y diversidad en términos de coches, personalizaciones, mapas, música e idiomas</li>
-<li>Más diversión y emoción en términos de jugabilidad, gráficos, efectos de sonido e interacciones</li>
-<li>Más conexión y comunidad con otros jugadores que comparten el mismo interés y pasión por la cultura del automóvil de Sudáfrica</li>
-<li>Más soporte y actualizaciones de los desarrolladores que se dedican a mejorar el juego y agregar nuevas características</li>
-</ul>
- <h2>Cómo descargar e instalar el estacionamiento de coches multijugador South áfrica Edition APK en dispositivos Android? </h2>
-
- <h3>Requisitos para descargar e instalar el estacionamiento de coches multijugador South áfrica Edition APK</h3>
- <p>Para descargar e instalar Aparcamiento Multijugador South áfrica Edition APK en su dispositivo Android, es necesario tener  :</p>
-<p></p>
-<ul>
-<li>Un dispositivo Android que se ejecuta en Android 4.1 o superior</li>
-<li>Una conexión a Internet estable</li>
-<li>Una aplicación de administrador de archivos que puede acceder al archivo APK</li>
-<li>Una cantidad suficiente de espacio de almacenamiento en su dispositivo</li>
-<li>Un permiso para instalar aplicaciones de fuentes desconocidas en la configuración del dispositivo</li>
-</ul>
- <h3>Pasos para Descargar e Instalar Aparcamiento Multijugador South áfrica Edition APK</h3>
- <p>Para descargar e instalar Aparcamiento Multijugador South áfrica Edition APK en su dispositivo Android, es necesario seguir estos pasos :</p>
-<ol>
-<li>Ir a un sitio web de confianza que proporciona el enlace para descargar Car Parking Multi jugador South áfrica Edition APK. Por ejemplo, puede visitar [este sitio web]  para obtener la última versión del archivo APK. </li>
-<li>Haga clic en el botón de descarga y espere a que el archivo APK se descargue en su dispositivo. </li>
-<li>Una vez que se complete la descarga, localizar el archivo APK en su dispositivo utilizando una aplicación de administrador de archivos. Puede encontrarlo en la carpeta Descargas o en cualquier otra carpeta donde lo haya guardado. </li>
-<li>Toque en el archivo APK y seleccione Instalar. Es posible que vea un mensaje de advertencia que dice "Para su seguridad, el teléfono no está permitido instalar aplicaciones desconocidas de esta fuente". Si ves este mensaje, ve a la configuración del dispositivo y habilita la opción de instalar aplicaciones de fuentes desconocidas. Esta opción puede estar en Seguridad, Privacidad o Aplicaciones dependiendo del modelo de dispositivo y la versión de Android. </li>
-
-<li>Espere a que termine el proceso de instalación. Puede tardar unos minutos dependiendo del rendimiento del dispositivo y la velocidad de Internet. </li>
-<li>Una vez que se hace la instalación, se puede abrir el juego y disfrutar de aparcamiento multijugador South áfrica Edition en su dispositivo Android. </li>
-</ol>
- <h2>Consejos y Trucos para Jugar Aparcamiento Multijugador South áfrica Edition</h2>
- <p>Ahora que ha descargado e instalado Car Parking Multiplayer South áfrica Edition en su dispositivo Android, es posible que desee conocer algunos consejos y trucos para jugarlo. Estos son algunos de ellos:</p>
- <h3>Cómo seleccionar un coche y un jugador</h3>
- <p>Para seleccionar un coche y un jugador en Car Parking Multiplayer South áfrica Edition, debe hacer lo siguiente:</p>
-<ul>
-<li>Toque en el icono de menú en la esquina superior izquierda de la pantalla. </li>
-<li>Toque en Garaje para ver la lista de coches que usted posee o puede comprar. </li>
-<li>Toque en el coche que desea utilizar y luego toque en Select.</li>
-<li>Toque en Volver para volver al menú.</li>
-<li>Toque en Perfil para ver la lista de jugadores entre los que puede elegir. </li>
-<li>Toque en el reproductor que desea utilizar y luego toque en Select.</li>
-<li>Toque en Volver para volver al menú.</li>
-<li>Toque en Jugar para comenzar a jugar el juego con el coche y el jugador seleccionado. </li>
-</ul>
- <h3> Cómo ajustar su coche y ajustar su relación de engranajes</h3>
- <p>Para afinar su coche y ajustar su relación de engranajes en Car Parking Multiplayer South áfrica Edition, debe hacer lo siguiente:</p>
-<ul>
-<li>Toque en el icono de menú en la esquina superior izquierda de la pantalla. </li>
-<li>Toque en Garaje para ver la lista de coches que usted posee o puede comprar. </li>
-<li>Toque en el coche que desea sintonizar y luego toque en Tune.</li>
-<li>Verá cuatro pestañas: Motor, Suspensión, Ruedas y Cuerpo. Puede deslizar hacia la izquierda o hacia la derecha para cambiar entre ellas. </li>
-
-<li>Para ajustar su relación de cambios, toque en Caja de cambios en la pestaña Motor. Verá un gráfico que muestra cómo cambia su velocidad con diferentes marchas. Puede arrastrar los puntos en el gráfico para cambiar la relación de transmisión para cada marcha. También puede pulsar en Auto o Manual para cambiar entre modos de transmisión automática o manual. </li>
-<li>Una vez que haya terminado de ajustar su coche, toque en Guardar para aplicar los cambios. </li>
-</ul>
- <h3> Cómo Deriva, Donut, y Burnout</h3>
- <p>Para la deriva, donut, y burnout en el estacionamiento de coches multijugador South áfrica Edition, es necesario hacer lo siguiente:</p>
-<ul>
-<li>Para la deriva, debe usar una combinación de dirección, acelerador, freno y freno de mano. Puede usar los controles de inclinación o táctiles para la dirección. Para iniciar la deriva, es necesario acelerar y girar bruscamente en una esquina. Luego, debe aplicar el freno de mano brevemente para hacer que sus ruedas traseras pierdan tracción. Después de eso, debe equilibrar el acelerador y la dirección para mantener el ángulo de deriva y la dirección. También puede utilizar el freno de mano o freno de mano de nuevo si necesita ajustar su deriva. Para terminar con la deriva, es necesario soltar el acelerador y la dirección y enderezar el coche. </li>
-<li>Para la rosquilla, debe usar una combinación de dirección, acelerador y freno de mano. Puede usar controles de inclinación o táctiles para la dirección. Para comenzar a donar, debe acelerar y girar bruscamente en una dirección. Entonces, es necesario aplicar el freno de mano para hacer que su coche gire alrededor de su centro. Después de eso, es necesario mantener el acelerador y la dirección constante para mantener el círculo de la dona. También puede cambiar la dirección de su dona cambiando la dirección. Para terminar donuting, es necesario soltar el acelerador y el freno de mano y enderezar su coche. </li>
-
-</ul>
- <h2>Conclusión</h2>
- <p>Car Parking Multijugador South áfrica Edition es un juego que ofrece una experiencia de aparcamiento realista y divertido con un toque sudafricano. Tiene más coches, personalizaciones, mapas, música e idiomas que reflejan la cultura del automóvil sudafricano. También tiene un modo de mundo abierto, un modo de ajuste de coche, y un modo multijugador que hacen el juego más agradable y emocionante. Puede descargar e instalar Parking Multijugador South áfrica Edition APK en su dispositivo Android siguiendo los pasos en este artículo. También puedes usar los consejos y trucos de este artículo para mejorar tu juego y divertirte más. </p>
- <h2>Preguntas frecuentes</h2>
- <p>Aquí están algunas de las preguntas más frecuentes sobre Car Parking Multiplayer South áfrica Edition:</p>
- <h3>¿Es gratis Car Parking Multijugador South áfrica Edition? </h3>
- <p>Sí, Parking Multijugador South áfrica Edition es gratis para descargar y jugar. Sin embargo, puede contener algunas compras en la aplicación que requieren dinero real. </p>
- <h3>¿Es seguro el aparcamiento multijugador South áfrica Edition? </h3>
- <p>Sí, Parking Multijugador South áfrica Edition es seguro, siempre y cuando se descarga desde un sitio web de confianza. Sin embargo, siempre debe tener cuidado al descargar e instalar aplicaciones de fuentes desconocidas, ya que pueden contener virus o malware que pueden dañar su dispositivo. </p>
- <h3>¿Es compatible Car Parking Multiplayer South áfrica Edition con mi dispositivo? </h3>
- <p>Car Parking Multijugador South áfrica Edition es compatible con la mayoría de los dispositivos Android que se ejecutan en Android 4.1 o superior. Sin embargo, algunos dispositivos pueden tener diferentes especificaciones o problemas de rendimiento que pueden afectar la calidad o funcionalidad del juego. </p>
- <h3>¿Cómo puedo actualizar Car Parking Multijugador South áfrica Edition? </h3>
-
- <h3>¿Cómo puedo contactar a los desarrolladores de Car Parking Multiplayer South áfrica Edition? </h3>
- <p>Para contactar a los desarrolladores de Car Parking Multiplayer South áfrica Edition, puedes visitar su página de Facebook o su canal de YouTube y dejar un comentario o un mensaje. </p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Asfalto Nitro 9 Leyendas Mod Apk.md

@@ -1,76 +0,0 @@
-
-<h1>Nitro asfalto 9 leyendas Mod Apk: Una guía para los aficionados a las carreras</h1>
-<p>Si eres un fan de los juegos de carreras, es posible que hayas oído hablar de Asphalt Nitro 9 Legends, uno de los juegos más populares y emocionantes del género. Este juego le permite tomar el volante de los coches reales de gama alta de renombrados fabricantes de automóviles legendarios, como Ferrari, Porsche, Lamborghini, y W Motors, entre muchas otras marcas internacionales. Puedes conducir, impulsar y realizar acrobacias en ubicaciones dinámicas de la vida real en modo individual o multijugador. </p>
-<p>Pero ¿y si quieres disfrutar del juego sin limitaciones ni restricciones? ¿Qué pasa si quieres tener dinero ilimitado y fichas, desbloquear todos los coches y pistas, personalizar sus vehículos y actualizarlos, y competir con otros jugadores en línea o fuera de línea? Bueno, hay una manera de hacerlo. Puede descargar e instalar Asphalt Nitro 9 Leyendas Mod Apk, una versión modificada del juego que le da acceso a todas estas características y más. </p>
-<h2>asfalto nitro 9 leyendas mod apk</h2><br /><p><b><b>Download File</b> ===== <a href="https://bltlly.com/2v6LmQ">https://bltlly.com/2v6LmQ</a></b></p><br /><br />
-<p>En este artículo, le guiará a través de las características, proceso de descarga, pasos de instalación, consejos y trucos, pros y contras, y la conclusión de Asphalt Nitro 9 Leyendas Mod Apk. Sigue leyendo para saber más. </p>
- <h2>Características de Asphalt Nitro 9 Leyendas Mod Apk</h2>
-<p>Asfalto Nitro 9 Leyendas Mod Apk es una versión modificada del juego original que le da recursos ilimitados y características que mejoran su experiencia de juego. Estas son algunas de las características que puedes disfrutar con este mod apk:</p>
-<ul>
-<li><b>Dinero ilimitado y fichas:</b> Con este apk mod, nunca se quedará sin dinero o fichas para comprar nuevos coches, pistas, mejoras, o artículos. Puedes gastar todo lo que quieras sin preocuparte por tu presupuesto. </li>
-
-<li><b>Personalizar sus vehículos y actualizarlos:</b> Con este apk mod, puede personalizar sus vehículos de acuerdo a su preferencia. Puedes cambiar su color, pintura, calcomanías, ruedas, etc. También puedes mejorar su rendimiento mejorando su motor, transmisión, suspensión, frenos, nitro boost, etc.</li>
-<li><b>Disfrutar de gráficos realistas y efectos de sonido:</b> Con este apk mod, se puede disfrutar de los impresionantes gráficos y efectos de sonido del juego. El juego utiliza un motor de física realista que simula el movimiento y el comportamiento de los coches. El juego también cuenta con efectos de sonido de alta calidad que te hacen sentir como si estuvieras en una carrera real. </li>
-<li><b>Compite con otros jugadores en línea o fuera de línea:</b> Con este apk mod, puede competir con otros jugadores en línea o fuera de línea. Puedes unirte a carreras multijugador online y desafiar a tus amigos u otros jugadores de todo el mundo. También puedes jugar offline en modo carrera y completar varias misiones y desafíos. </li>
-</ul>
- <h2>Cómo descargar e instalar Asphalt Nitro 9 leyendas Mod Apk</h2>
-<p>Si desea descargar e instalar Asphalt Nitro 9 leyendas Mod Apk, es necesario seguir estos sencillos pasos:</p>
-<ol>
-<li><b>Paso 1: Descargar el archivo apk mod de una fuente de confianza. </b> Usted puede encontrar muchos sitios web que ofrecen el archivo apk mod para Asphalt Nitro 9 Leyendas, pero no todos ellos son seguros y fiables. Debes asegurarte de que el archivo que descargas esté libre de virus, malware o cualquier otro contenido dañino. Puede utilizar este enlace para descargar el archivo apk mod de forma segura. </li>
-<li><b>Paso 2: Habilitar fuentes desconocidas en la configuración del dispositivo. </b> Antes de poder instalar el archivo apk mod, debe habilitar fuentes desconocidas en la configuración de su dispositivo. Esto le permitirá instalar aplicaciones desde fuentes distintas de Google Play Store. Para hacer esto, vaya a la configuración del dispositivo, luego a la seguridad, luego a fuentes desconocidas y conéctela. </li>
-
-<li><b>Paso 4: Disfruta del juego con recursos y funciones ilimitadas. </b> Ahora que ha instalado Asphalt Nitro 9 Leyendas Mod Apk, se puede disfrutar del juego con dinero ilimitado, fichas, coches, pistas, opciones de personalización, y más. También puedes competir con otros jugadores online o offline y divertirte. </li>
-</ol>
- <h2>Consejos y trucos para jugar Asphalt Nitro 9 leyendas Mod Apk</h2>
-<p>Asfalto Nitro 9 Leyendas Mod Apk es un juego divertido y emocionante que le mantendrá entretenido durante horas. Sin embargo, si quieres mejorar tus habilidades y rendimiento en el juego, puedes seguir estos consejos y trucos:</p>
-<ul>
-<li><b>Elija el coche adecuado para cada pista y modo. </b> El juego ofrece una variedad de coches de diferentes marcas y categorías, pero no todos ellos son adecuados para cada pista o modo. Es necesario tener en cuenta la velocidad, aceleración, manejo, nitro, y otros factores de cada coche antes de elegir uno. Por ejemplo, si usted está jugando en una pista con curvas, es posible que desee elegir un coche con buen manejo y nitro. Si usted está jugando en una pista recta, es posible que desee elegir un coche con alta velocidad y aceleración. </li>
-<li><b>Utilice nitro boost sabiamente y estratégicamente. </b> Nitro boost es una de las características más importantes del juego, ya que puede darte una ventaja sobre tus oponentes. Sin embargo, necesitas usarlo sabiamente y estratégicamente. No debes usarlo todo de una vez ni desperdiciarlo en momentos innecesarios. Debes guardarlo para momentos cruciales, como adelantar a tus rivales, escapar de obstáculos o colisiones, o llegar a la meta. También debe usarlo en combinación con acrobacias y derivas para ganar más puntos y recompensas. </li>
-
-<li><b>Evitar obstáculos y colisiones con otros coches. </b> El juego cuenta con muchos obstáculos y desafíos que pueden obstaculizar su progreso o dañar su coche. Estos incluyen coches de tráfico, coches de policía, helicópteros, barricadas, picos, etc. Usted debe evitar estos obstáculos tanto como sea posible, ya que pueden ralentizar o dañar su coche. También debes evitar colisiones con otros coches, especialmente tus rivales, ya que pueden sacarte de la pista o hacerte perder tu posición. Usted debe tratar de esquivar o escapar de ellos, o utilizar su impulso nitro para alejarse de ellos. </li>
-<li><b>Utilice diferentes ángulos de cámara y controles para adaptarse a sus preferencias. </b> El juego ofrece diferentes ángulos de cámara y controles que puedes usar para jugar el juego. Puede elegir entre vista en primera persona, en tercera persona o de arriba hacia abajo, según su preferencia. También puede elegir entre los controles de inclinación, toque o toque, dependiendo de su comodidad. Puede cambiar estos ajustes en el menú de opciones del juego. </li>
-</ul>
- <h2>Pros y contras de Asphalt Nitro 9 Leyendas Mod Apk</h2>
-<p>Asfalto Nitro 9 Leyendas Mod Apk es un gran juego que ofrece muchos beneficios y ventajas para los aficionados a las carreras. Sin embargo, también tiene algunos inconvenientes y desventajas que usted debe tener en cuenta. Estos son algunos de los pros y los contras de Asphalt Nitro 9 Leyendas Mod Apk:</p>
-<tabla>
-<tr>
-<th>Pros</th>
-<th>Contras</th>
-</tr>
-<tr>
-<td><ul>
-<li>Divertido, adictivo y desafiante juego</li>
-<li>Dinero ilimitado y tokens</li>
-<li>Desbloquear todos los coches y pistas</li>
-<li>Personalizar sus vehículos y actualizarlos</li>
-<li>Disfruta de gráficos realistas y efectos de sonido</li>
-<li>Compite con otros jugadores online o offline</li>
-</ul></td>
-<td><ul>
-<li> Puede causar retraso o estrellarse en algunos dispositivos</li>
-<li>Puede no ser compatible con algunos dispositivos o versiones</li>
-<li>No se puede actualizar regularmente o con frecuencia</li>
-<li>No puede ser soportado por los desarrolladores o editores oficiales</li>
-
-<li>Puede exponer su dispositivo a riesgos o amenazas de seguridad</li>
-</ul></td>
-</tr>
-</tabla>
- <h2>Conclusión</h2>
-<p>En conclusión, Asfalto Nitro 9 Leyendas Mod Apk es un juego fantástico que le dará horas de diversión y emoción. Es una versión modificada del juego original que le da recursos ilimitados y características que mejoran su experiencia de juego. Puede descargarlo e instalarlo de forma fácil y segura siguiendo los pasos que proporcionamos en este artículo. También puedes seguir los consejos y trucos que compartimos para mejorar tus habilidades y rendimiento en el juego. Sin embargo, también debe ser consciente de los pros y los contras de Asphalt Nitro 9 Leyendas Mod Apk, y decidir si vale la pena jugar o no. </p>
-<p>Si usted es un fanático de las carreras, le recomendamos que pruebe Asphalt Nitro 9 Leyendas Mod Apk y ver por sí mismo lo increíble que es. No te arrepentirás. </p>
- <h2>Preguntas frecuentes (preguntas frecuentes)</h2>
-<p>Aquí están algunas de las preguntas y respuestas más comunes sobre Asphalt Nitro 9 Legends Mod Apk:</p>
-<p></p>
- <h3>Q: ¿Es libre de Asphalt Nitro 9 Leyendas Mod Apk? </h3>
-<p>A: Sí, Asphalt Nitro 9 Leyendas Mod Apk es gratis para descargar y jugar. Usted no necesita pagar nada para disfrutar del juego. </p>
- <h3>Q: ¿Es seguro Asphalt Nitro 9 Legends Mod Apk? </h3>
-<p>A: Sí, Asfalto Nitro 9 Leyendas Mod Apk es seguro para descargar e instalar. Sin embargo, siempre debe descargarlo de una fuente de confianza y habilitar fuentes desconocidas en la configuración del dispositivo antes de instalarlo. </p>
- <h3>Q: ¿Es legal Asphalt Nitro 9 Legends Mod Apk? </h3>
-<p>A: No, Asphalt Nitro 9 Leyendas Mod Apk no es legal. Es una versión modificada del juego original que viola los términos y condiciones de los desarrolladores y editores oficiales. También puede infringir los derechos de propiedad intelectual del juego original. </p>
- <h3>Q: Es Asphalt Nitro 9 Leyendas Mod Apk en línea o fuera de línea? </h3>
-
- <h3>Q: ¿Cómo puedo actualizar Asphalt Nitro 9 Legends Mod Apk? </h3>
-<p>A: Para actualizar Asphalt Nitro 9 leyendas Mod Apk, es necesario descargar e instalar la última versión del archivo apk mod de una fuente de confianza. Es posible que tenga que desinstalar la versión anterior del archivo apk mod antes de instalar el nuevo. </p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Camioneros De Europa 3 Apk 36.6.md

@@ -1,76 +0,0 @@
-
-<h1>Camioneros de Europa 3 APK 36.6: Un juego de simulador de camiones realista y divertido</h1>
-<p>Si eres un fan de los juegos de simuladores de camiones, es posible que hayas oído hablar de Truckers of Europe 3, un juego popular que te permite experimentar la vida de un conductor de camiones en Europa. En este artículo, te contaremos todo lo que necesitas saber sobre este juego, incluyendo qué es, cuáles son sus características, cómo descargarlo e instalarlo, cómo jugarlo y por qué deberías jugarlo. ¡Así que abróchate el cinturón y prepárate para un emocionante viaje! </p>
-<h2>Introducción</h2>
-<h3>¿Qué es Camioneros de Europa 3?</h3>
-<p>Truckers of Europe 3 es un juego de simulador de camioneros desarrollado por <a href="( 1 )">Jerryisgaming</a>, un canal de YouTube que crea videos de juegos. El juego fue lanzado en 2020 y ha sido actualizado regularmente con nuevas características y mejoras. La última versión del juego es 0.36.6, que fue lanzado el 30 de septiembre de 2021. </p>
-<h2>camioneros de europa 3 apk 36.6</h2><br /><p><b><b>Download Zip</b> &#10084;&#10084;&#10084; <a href="https://bltlly.com/2v6LwC">https://bltlly.com/2v6LwC</a></b></p><br /><br />
-<h3>¿Cuáles son las características de Camioneros de Europa 3?</h3>
-<p>Truckers of Europe 3 tiene muchas características que lo convierten en uno de los mejores juegos de simuladores de camiones en el mercado. Algunas de estas características son:</p>
-<ul>
-<li>Un gran mapa de Europa con más de 50 ciudades y países para explorar. </li>
-<li> Una variedad de camiones y remolques para elegir, cada uno con diferentes especificaciones y rendimiento. </li>
-<li>Un sistema de conducción realista con transmisión manual, volante, pedales, indicadores, espejos, luces, bocina, limpiaparabrisas, etc.</li>
-<li>Un sistema de tráfico realista con coches, autobuses, camiones, motocicletas, policía, ambulancia, etc.</li>
-<li>Un sistema meteorológico realista con ciclo de día y noche, lluvia, nieve, niebla, etc.</li>
-<li>Un sistema de daños realista con desgaste de neumáticos, consumo de combustible, sobrecalentamiento del motor, etc.</li>
-<li>Un modo de carrera con misiones, contratos, entrega de carga, ingresos, gastos, etc.</li>
-<li>Un sistema de habilidades con niveles, puntos, ventajas, etc.</li>
-<li>Un sistema de personalización con trabajos de pintura, accesorios, calcomanías, etc.</li>
-
-</ul>
-<h2>Cómo descargar e instalar camioneros de Europa 3 APK 36.6? </h2>
-<h3>Requisitos</h3>
-<p>Para descargar e instalar Camioneros de Europa 3 APK 36.6 en su dispositivo Android, es necesario cumplir con los siguientes requisitos:</p>
-<ul>
-<li>Tu dispositivo debe tener la versión de Android 4.4 o superior. </li>
-<li> Su dispositivo debe tener al menos 1 GB de RAM y 500 MB de espacio de almacenamiento libre. </li>
-<li> Su dispositivo debe tener una conexión a Internet estable. </li>
-<li>Su dispositivo debe permitir la instalación desde fuentes desconocidas. Puede habilitar esta opción yendo a Configuración > Seguridad > Fuentes desconocidas.</li>
-</ul>
-<h3>Pasos</h3>
-<p>Para descargar e instalar Camioneros de Europa 3 APK 36.6 en su dispositivo Android, debe seguir estos pasos:</p>
-<ol>
-<li>Ir a <a href="( 2 )">este enlace</a> y descargar el archivo APK. </li>
-<li>Localice el archivo descargado en el administrador de archivos de su dispositivo y toque en él para iniciar el proceso de instalación. </li>
-<li>Siga las instrucciones en la pantalla y conceda los permisos necesarios a la aplicación. </li>
-<li> Espere a que la instalación se complete y luego inicie la aplicación desde el cajón de aplicaciones o la pantalla de inicio. </li>
-<li>Disfruta jugando Camioneros de Europa 3 en tu dispositivo Android! </li>
-</ol>
-<h2>Cómo jugar Camioneros de Europa 3?</h2>
-<h3>Elige tu camión y remolque</h3>
-<p>Lo primero que tienes que hacer cuando empiezas a jugar Truckers of Europe 3 es elegir tu camión y remolque. Puede hacer esto yendo al menú del garaje y navegando a través de las opciones disponibles. También puede comprar nuevos camiones y remolques con el dinero que gana de sus misiones. Cada camión y remolque tiene diferentes atributos, como velocidad, potencia, capacidad de combustible, peso de carga, etc. Debe elegir el que se adapte a sus preferencias y necesidades. </p>
-<h3>Conduce por toda Europa y entrega carga</h3>
-
-<p>Mientras conduce, tendrá que seguir las reglas de tráfico y regulaciones, tales como límites de velocidad, semáforos, señales, etc. También tendrá que lidiar con condiciones de tráfico realistas, como automóviles, autobuses, camiones, motocicletas, policía, ambulancia, etc. También tendrá que enfrentarse a condiciones meteorológicas realistas, como lluvia, nieve, niebla, etc. También tendrá que controlar el estado de su camión, como el nivel de combustible, la temperatura del motor, la presión de los neumáticos, etc. También tendrá que prestar atención al estado de su conductor, como el nivel de fatiga, el nivel de hambre, etc. Tendrá que parar en gasolineras, áreas de descanso, restaurantes, etc. para llenar su tanque de combustible, descansar a su conductor, comer algo de comida, etc.</p>
-<p>Cuando llegue a su destino, tendrá que aparcar su camión y remolque en el lugar designado y descargar la carga. A continuación, recibirá su recompensa y comentarios sobre su rendimiento. También ganarás puntos de experiencia que te ayudarán a subir de nivel y desbloquear nuevas habilidades y beneficios. </p>
-<h3>Personaliza tu camión y mejora tus habilidades</h3>
-<p>Otro aspecto divertido de Truckers of Europe 3 es que puedes personalizar tu camión y mejorar tus habilidades. Puedes hacer esto yendo al menú del taller y gastando algo de dinero en varios artículos y servicios. Puede cambiar el color de su camión, agregar algunos accesorios, aplicar algunas calcomanías, etc. También puede reparar su camión si está dañado o afinarlo si no funciona bien. </p>
-<p>También puedes ir al menú de habilidades y gastar algunos puntos en varias habilidades y beneficios que mejorarán tus habilidades y beneficios como conductor de camión. Puede mejorar su eficiencia de combustible, manejo de carga, seguridad de conducción, habilidades de negociación, etc. También puede desbloquear nuevos tipos de carga, contratos, camiones, remolques, etc.</p>
-<p></p>
-<h2>¿Por qué deberías jugar Camioneros de Europa 3?</h2>
-<h3>Gráficos realistas y física</h3>
-
-<h3>Tráfico y clima diversos y dinámicos</h3>
-<p>Otra razón por la que deberías jugar a Truckers of Europe 3 es porque tiene un tráfico diverso y dinámico y el clima hará que tu experiencia de conducción sea más desafiante y agradable. El juego tiene un gran mapa de Europa con más de 50 ciudades y países para explorar. Cada ciudad y país tiene sus propias características únicas, tales como monumentos, edificios, carreteras, señales, etc. El juego también tiene un sistema de tráfico diverso que incluye automóviles, autobuses, camiones, motocicletas, policía, ambulancia, etc. Cada vehículo tiene su propio comportamiento, velocidad, dirección, etc. El juego también tiene un sistema de tiempo dinámico que incluye ciclo de día y noche, lluvia, nieve, niebla, etc. Cada condición climática tiene su propio efecto en la visibilidad, tracción, manejo, etc. del camión y el remolque. </p>
-<h3>Misiones y logros desafiantes y gratificantes</h3>
-<p>Otra razón por la que deberías jugar a Truckers of Europe 3 es porque tiene misiones desafiantes y gratificantes y logros que te mantendrán motivado y entretenido. El juego tiene un modo de carrera que le permite comenzar como un conductor de camión novato y trabajar su camino hasta convertirse en un camionero profesional. Puede hacerlo completando varias misiones y contratos que implican la entrega de carga a diferentes destinos en toda Europa. También puede ganar dinero de sus entregas y gastarlo en la compra de nuevos camiones y remolques o la personalización de los existentes. También puede ganar puntos de experiencia de sus entregas y gastarlos en mejorar sus habilidades y beneficios. También puedes desbloquear nuevos tipos de carga, contratos, camiones, remolques, etc. a medida que avanzas en el juego. </p>
-
-<h2>Conclusión</h2>
-<p>Truckers of Europe 3 es un juego de simulador de camiones realista y divertido que te permite experimentar la vida de un conductor de camiones en Europa. Puede elegir su camión y remolque, conducir por toda Europa y entregar carga, personalizar su camión y mejorar sus habilidades, y ganar dinero y logros. El juego tiene gráficos y física realistas, tráfico y clima diversos y dinámicos, y misiones y logros desafiantes y gratificantes. Si usted está buscando un juego de simulador de camiones que le mantendrá enganchado durante horas, definitivamente debe probar Camioneros de Europa 3 APK 36.6. </p>
-<h4>Preguntas frecuentes</h4>
-<p>Aquí hay algunas preguntas frecuentes sobre los camioneros de Europa 3:</p>
-<ul>
-<li>Q: ¿Los camioneros de Europa 3 son libres de jugar? </li>
-<li>A: Sí, Truckers of Europe 3 es gratis. Puedes descargarlo e instalarlo desde el enlace proporcionado en este artículo. Sin embargo, el juego puede contener algunas compras en la aplicación que pueden mejorar su experiencia de juego. </li>
-<li>Q: ¿Es seguro descargar e instalar Truckers of Europe 3? </li>
-<li>A: Sí, Truckers of Europe 3 es seguro para descargar e instalar. El archivo APK proporcionado en este artículo es verificado y probado por nuestro equipo. Sin embargo, siempre debe descargar e instalar archivos APK de fuentes confiables solamente. </li>
-<li>Q: ¿Es Truckers of Europe 3 compatible con mi dispositivo? </li>
-<li>A: Camioneros de Europa 3 es compatible con la mayoría de los dispositivos Android que tienen la versión Android 4.4 o superior. Sin embargo, algunos dispositivos pueden no ser compatibles con el juego debido a limitaciones de hardware o software. </li>
-<li>P: ¿Cómo puedo contactar al desarrollador de Truckers of Europe 3?</li>
-<li>A: Puedes contactar al desarrollador de Truckers of Europe 3 visitando su canal de YouTube <a href="">Jerryisgaming</a> o su página de Facebook <a href="">Jerryisgaming</a>. También puedes dejar tus comentarios, sugerencias o consultas en la sección de comentarios de sus videos o publicaciones. </li>
-<li>P: ¿Cómo puedo apoyar el desarrollo de Camioneros de Europa 3?</li>
-
-</ul></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Descargar Estrellas Pelea Hack Ios.md

@@ -1,80 +0,0 @@
-
-<h1>Cómo descargar Genshin Impact Cloud y disfrutar del juego en cualquier lugar</h1>
-<p>Genshin Impact es uno de los juegos más populares y exitosos de 2020, con millones de jugadores en todo el mundo. El juego es un RPG de acción de mundo abierto que te permite explorar un mundo vasto y hermoso llamado Teyvat, donde puedes conocer a varios personajes, luchar contra enemigos, reunir recursos y completar misiones. El juego está disponible en múltiples plataformas, como PC, PlayStation 4, PlayStation 5, iOS y Android. Sin embargo, si quieres jugar el juego en tu dispositivo móvil, puedes enfrentarte a algunos desafíos, como espacio de almacenamiento limitado, bajo rendimiento o dispositivos incompatibles. Ahí es donde entra Genshin Impact Cloud. </p>
-<h2>¿Qué es la nube de impacto Genshin y por qué debe probarlo</h2>
-<h3>Genshin Impact Cloud es un servicio que te permite jugar el juego en tu dispositivo móvil sin descargar el juego entero</h3>
-<p>Genshin Impact Cloud es una nueva característica que fue introducida por miHoYo, el desarrollador de Genshin Impact, en abril de 2021. Es un servicio de juegos en la nube que le permite transmitir el juego desde un servidor a su dispositivo móvil a través de Internet. Esto significa que no necesitas descargar o instalar el juego en tu dispositivo, lo que puede ahorrarte mucho espacio de almacenamiento. El tamaño del juego de Genshin Impact en dispositivos móviles es de alrededor de 5,2 GB, pero con Genshin Impact Cloud, solo necesitas descargar una aplicación de 56 MB de tamaño. Esto también puede ayudarle a evitar largos tiempos de carga o actualizaciones. </p>
-<h2>descargar estrellas pelea hack ios</h2><br /><p><b><b>Download</b> ===> <a href="https://bltlly.com/2v6KEj">https://bltlly.com/2v6KEj</a></b></p><br /><br />
-<h3>Genshin Impact Cloud tiene muchos beneficios, como ahorrar espacio de almacenamiento, mejorar el rendimiento y admitir cross-save</h3>
-<p>Además de ahorrar espacio de almacenamiento, Genshin Impact Cloud también tiene otras ventajas que pueden mejorar su experiencia de juego. Por ejemplo:</p>
-<ul>
-
-<li>Genshin Impact Cloud soporta cross-save y cross-play. Esto significa que puedes acceder a tu progreso y datos existentes desde otras plataformas iniciando sesión con tu cuenta miHoYo. También puedes jugar con tus amigos que usan diferentes dispositivos, como PC o PlayStation.</li>
-<li>Genshin Impact Cloud es de uso gratuito. No es necesario pagar tarifas o suscripciones adicionales para utilizar el servicio. También puede hacer compras en la aplicación como de costumbre, y disfrutar de todas las actualizaciones y eventos del juego. </li>
-</ul>
-<p>Con Genshin Impact Cloud, puede disfrutar del juego en cualquier lugar y en cualquier momento, siempre y cuando tenga una conexión a Internet estable y un dispositivo compatible. </p>
-<h2>Cómo descargar Genshin Impact Cloud en dispositivos Android</h2>
-<h3>Genshin Impact Cloud está disponible actualmente solo para usuarios de Android en Malasia y Singapur como prueba beta</h3>
-<p>Genshin Impact Cloud todavía está en sus primeras etapas de desarrollo, y todavía no está disponible para todas las regiones y plataformas. Actualmente, el servicio solo está abierto para los usuarios de Android en Malasia y Singapur como una prueba beta. Esto significa que solo un número limitado de jugadores puede acceder al servicio, y puede haber algunos errores o errores durante el juego. miHoYo no ha anunciado cuándo se ampliará el servicio a otras regiones y plataformas, pero es probable que lo hagan en el futuro. </p>
-<h3>Para descargar Genshin Impact Cloud, necesita tener una cuenta miHoYo y registrarse para la prueba beta en el sitio web oficial</h3>
-<p>Si eres un usuario de Android en Malasia o Singapur, y quieres probar Genshin Impact Cloud, debes seguir estos pasos:</p>
-<ol>
-<li>Crea una cuenta miHoYo si aún no tienes una. Puede hacer esto visitando <a href="">https://account.mihoyo.com/#/register</a> y llenando la información requerida. </li>
-<li>Visite <a href=">https://genshin.mihoyo.com/en/cloudtest</a> y regístrese para la prueba beta. Debes iniciar sesión con tu cuenta miHoYo y aceptar los términos y condiciones. </li>
-
-<li>Haga clic en el enlace en el correo electrónico y descargar la aplicación, que es solo 56 MB de tamaño. Instalar la aplicación en su dispositivo y lanzarlo. </li>
-</ol>
-<h3>Después de registrarse, recibirá un correo electrónico con un enlace para descargar la aplicación, que es solo 56 MB de tamaño</h3>
-<p>Una vez que haya descargado e instalado la aplicación, puede comenzar a jugar Genshin Impact Cloud en su dispositivo móvil. Sin embargo, hay algunas cosas que necesitas saber antes de jugar. </p>
-<p></p>
-<h2>Cómo jugar Genshin nube de impacto en su dispositivo móvil</h2>
-<h3>Para jugar Genshin Impact Cloud, es necesario tener una conexión a Internet estable y un dispositivo compatible</h3>
-<p>Genshin Impact Cloud requiere una conexión a Internet estable para transmitir el juego desde el servidor a su dispositivo. La velocidad de red recomendada es de al menos 10 Mbps para descarga y 5 Mbps para carga. Puede comprobar la velocidad de su red mediante una aplicación de prueba de velocidad o sitio web. Si su velocidad de red es demasiado baja, puede experimentar latencia, retraso o desconexión durante el juego. </p>
-<p>Genshin Impact Cloud también requiere un dispositivo compatible para funcionar sin problemas. Los requisitos mínimos de dispositivo son los siguientes:</p>
-<tabla>
-<tr><th>Sistema operativo</th><th>Android 8.0 o superior</th></tr>
-<tr><td>CPU</td><td>Snapdragon 845 o superior / Kirin 980 o superior / Exynos 9810 o superior / MediaTek Dimensity 1000+ o superior</td></tr>
-<tr><td>RAM</td><td>4 GB o superior</td></tr>
-<tr><td>Espacio de almacenamiento</td><td>Al menos 100 MB de espacio libre (excluyendo el tamaño de la aplicación)</td></tr>
-<tr><td>Nivel de batería</td><td>Al menos el 20% de la batería restante</td></tr>
-<tr><td>Resolución de pantalla</td><td>Al menos 1280 x 720 píxeles</td></tr>
-<tr><td>Frecuencia de actualización de la pantalla</td><td>Al menos 60 Hz (tasas de actualización más altas pueden causar sobrecalentamiento)</td></tr>
-<tr><td>Tipo de red</td><td </td><td>Wi-Fi o 4G/5G (se recomienda Wi-Fi para una mejor estabilidad)</td></tr>
-</tabla>
-
-<h3>Puedes usar controles táctiles o conectar un teclado/ratón o gamepad a tu dispositivo</h3>
-<p>Genshin Impact Cloud admite diferentes tipos de controles para su comodidad. Puede utilizar la pantalla táctil de su dispositivo para controlar el juego, al igual que jugar la versión móvil regular. También puede conectar un teclado/ ratón o un mando a su dispositivo a través de Bluetooth o USB, y utilizarlos para jugar el juego. Puede personalizar la asignación de claves y la configuración de sensibilidad en las opciones del juego. </p>
-<h3>Puede acceder a su progreso y datos existentes de otras plataformas iniciando sesión con su cuenta miHoYo</h3>
-<p>Genshin Impact Cloud te permite continuar tu aventura desde donde la dejaste en otras plataformas. Solo tienes que iniciar sesión con tu cuenta miHoYo y seleccionar el servidor que coincida con tu plataforma anterior. Por ejemplo, si ha jugado en el PC antes, es necesario seleccionar el servidor del PC. También puede cambiar entre diferentes servidores y plataformas en cualquier momento, siempre y cuando sean compatibles con Genshin Impact Cloud. Sin embargo, tenga en cuenta que algunos elementos y monedas no son transferibles entre servidores, como Primogems y Genesis Crystals.</p>
-<h2>¿Cuáles son las características y limitaciones de Genshin Impact Cloud</h2>
-<h3>Genshin Impact Cloud ofrece la misma experiencia que jugar en un PC estándar, con gráficos de alta calidad y una jugabilidad fluida</h3>
-<p>Genshin Impact Cloud tiene como objetivo proporcionarle la mejor experiencia de juego posible en su dispositivo móvil. Puede disfrutar de las mismas características y contenido que jugar en un PC estándar, como gráficos de alta calidad, una jugabilidad fluida, efectos de sonido ricos y líneas argumentales inmersivas. También puedes participar en todas las actualizaciones y eventos del juego, como nuevos personajes, misiones, regiones y modos. También puede hacer compras en la aplicación como de costumbre, y utilizarlos en cualquier plataforma. </p>
-<h3>Genshin Impact Cloud también soporta todas las actualizaciones y eventos del juego, así como las compras en la aplicación</h3>
-
-<ul>
-<li>Genshin Impact Cloud puede tener algunos problemas de red, como latencia, retraso o desconexión, dependiendo de la calidad y la ubicación de la red. Esto puede afectar su juego y causar frustración o molestias. También puede incurrir en cargos de datos adicionales si utiliza una red móvil en lugar de Wi-Fi.</li>
-<li>Genshin Impact Cloud puede no ser compatible con algunos dispositivos o sistemas operativos, especialmente los más antiguos o de gama baja. Esto puede impedirte jugar el juego o causar algunos errores o fallos durante el juego. También puede experimentar sobrecalentamiento o pérdida de batería si juega durante mucho tiempo. </li>
-<li>Genshin Impact Cloud puede no estar disponible para todas las regiones y plataformas en este momento, ya que todavía está en pruebas beta. Esto significa que solo un número limitado de jugadores puede acceder al servicio, y puede haber algunos errores o fallos durante el juego. miHoYo también puede cambiar o eliminar algunas características o contenido del servicio sin previo aviso. </li>
-</ul>
-<p>Por lo tanto, siempre debe comprobar el sitio web oficial y las cuentas de medios sociales de miHoYo para las últimas noticias y actualizaciones sobre Genshin Impact Cloud.</p>
-<h2>Conclusión</h2>
-<h3>Genshin Impact Cloud es una gran manera de disfrutar del juego en tu dispositivo móvil sin sacrificar la calidad o el progreso</h3>
-<p>Genshin Impact Cloud es un servicio de juegos en la nube que le permite transmitir el juego desde un servidor a su dispositivo móvil a través de Internet. Tiene muchos beneficios, como ahorrar espacio de almacenamiento, mejorar el rendimiento, soportar cross-save y cross-play, y ofrecer la misma experiencia que jugar en un PC estándar. También es de uso gratuito y soporta todas las actualizaciones y eventos del juego. </p>
-<h3>Genshin Impact Cloud está actualmente en pruebas beta para usuarios de Android en Malasia y Singapur, pero puede expandirse a otras regiones y plataformas en el futuro</h3>
-
-<h3>Si desea probar Genshin Impact Cloud, puede registrarse para la prueba beta en el sitio web oficial y descargar la aplicación desde el enlace en el correo electrónico</h3>
-<p>Genshin Impact Cloud es una gran manera de disfrutar del juego en tu dispositivo móvil sin sacrificar la calidad o el progreso. Es un servicio de juegos en la nube que le permite transmitir el juego desde un servidor a su dispositivo a través de Internet. Tiene muchos beneficios, como ahorrar espacio de almacenamiento, mejorar el rendimiento, soportar cross-save y cross-play, y ofrecer la misma experiencia que jugar en un PC estándar. También es de uso gratuito y soporta todas las actualizaciones y eventos del juego. Sin embargo, todavía está en pruebas beta para usuarios de Android en Malasia y Singapur, y puede que no esté disponible para todas las regiones y plataformas en este momento. Si quieres probarlo, necesitas tener una cuenta miHoYo y registrarte para la prueba beta en el sitio web oficial. A continuación, recibirá un correo electrónico con un enlace para descargar la aplicación, que es solo 56 MB de tamaño. Sin embargo, también es necesario tener una conexión a Internet estable y un dispositivo compatible para jugar el juego. También debe ser consciente de las limitaciones y problemas del servicio, como problemas de red, problemas de compatibilidad o restricciones de pruebas beta. Siempre debes consultar el sitio web oficial y las cuentas de redes sociales de miHoYo para obtener las últimas noticias y actualizaciones sobre Genshin Impact Cloud.</p>
-<p>Esperamos que este artículo le haya ayudado a aprender más sobre Genshin Impact Cloud y cómo descargarlo y reproducirlo en su dispositivo móvil. Si tiene alguna pregunta o comentario, no dude en dejar un comentario a continuación. ¡Feliz juego! </p>
-<h2>Preguntas frecuentes</h2>
-<h4>¿Qué es Genshin Impact Cloud? </h4>
-<p>Genshin Impact Cloud es un servicio de juegos en la nube que te permite transmitir el juego desde un servidor a tu dispositivo móvil a través de Internet. </p>
-<h4>¿Cómo puedo descargar Genshin Impact Cloud? </h4>
-
-<h4>¿Cuáles son los beneficios de Genshin Impact Cloud? </h4>
-<p>Genshin Impact Cloud tiene muchos beneficios, como ahorrar espacio de almacenamiento, mejorar el rendimiento, soportar cross-save y cross-play, y ofrecer la misma experiencia que jugar en un PC estándar.</p>
-<h4>¿Cuáles son las limitaciones de Genshin Impact Cloud? </h4>
-<p>Genshin Impact Cloud puede tener algunas limitaciones, como problemas de red, problemas de compatibilidad o restricciones de pruebas beta. </p>
-<h4>¿Qué regiones y plataformas pueden acceder a Genshin Impact Cloud? </h4>
-<p>Genshin Impact Cloud actualmente solo está disponible para usuarios de Android en Malasia y Singapur como prueba beta. Puede expandirse a otras regiones y plataformas en el futuro. </p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_internal/cli/cmdoptions.py

@@ -1,1074 +0,0 @@
-"""
-shared options and groups
-
-The principle here is to define options once, but *not* instantiate them
-globally. One reason being that options with action='append' can carry state
-between parses. pip parses general options twice internally, and shouldn't
-pass on state. To be consistent, all options will follow this design.
-"""
-
-# The following comment should be removed at some point in the future.
-# mypy: strict-optional=False
-
-import importlib.util
-import logging
-import os
-import textwrap
-from functools import partial
-from optparse import SUPPRESS_HELP, Option, OptionGroup, OptionParser, Values
-from textwrap import dedent
-from typing import Any, Callable, Dict, Optional, Tuple
-
-from pip._vendor.packaging.utils import canonicalize_name
-
-from pip._internal.cli.parser import ConfigOptionParser
-from pip._internal.exceptions import CommandError
-from pip._internal.locations import USER_CACHE_DIR, get_src_prefix
-from pip._internal.models.format_control import FormatControl
-from pip._internal.models.index import PyPI
-from pip._internal.models.target_python import TargetPython
-from pip._internal.utils.hashes import STRONG_HASHES
-from pip._internal.utils.misc import strtobool
-
-logger = logging.getLogger(__name__)
-
-
-def raise_option_error(parser: OptionParser, option: Option, msg: str) -> None:
-    """
-    Raise an option parsing error using parser.error().
-
-    Args:
-      parser: an OptionParser instance.
-      option: an Option instance.
-      msg: the error text.
-    """
-    msg = f"{option} error: {msg}"
-    msg = textwrap.fill(" ".join(msg.split()))
-    parser.error(msg)
-
-
-def make_option_group(group: Dict[str, Any], parser: ConfigOptionParser) -> OptionGroup:
-    """
-    Return an OptionGroup object
-    group  -- assumed to be dict with 'name' and 'options' keys
-    parser -- an optparse Parser
-    """
-    option_group = OptionGroup(parser, group["name"])
-    for option in group["options"]:
-        option_group.add_option(option())
-    return option_group
-
-
-def check_dist_restriction(options: Values, check_target: bool = False) -> None:
-    """Function for determining if custom platform options are allowed.
-
-    :param options: The OptionParser options.
-    :param check_target: Whether or not to check if --target is being used.
-    """
-    dist_restriction_set = any(
-        [
-            options.python_version,
-            options.platforms,
-            options.abis,
-            options.implementation,
-        ]
-    )
-
-    binary_only = FormatControl(set(), {":all:"})
-    sdist_dependencies_allowed = (
-        options.format_control != binary_only and not options.ignore_dependencies
-    )
-
-    # Installations or downloads using dist restrictions must not combine
-    # source distributions and dist-specific wheels, as they are not
-    # guaranteed to be locally compatible.
-    if dist_restriction_set and sdist_dependencies_allowed:
-        raise CommandError(
-            "When restricting platform and interpreter constraints using "
-            "--python-version, --platform, --abi, or --implementation, "
-            "either --no-deps must be set, or --only-binary=:all: must be "
-            "set and --no-binary must not be set (or must be set to "
-            ":none:)."
-        )
-
-    if check_target:
-        if dist_restriction_set and not options.target_dir:
-            raise CommandError(
-                "Can not use any platform or abi specific options unless "
-                "installing via '--target'"
-            )
-
-
-def _path_option_check(option: Option, opt: str, value: str) -> str:
-    return os.path.expanduser(value)
-
-
-def _package_name_option_check(option: Option, opt: str, value: str) -> str:
-    return canonicalize_name(value)
-
-
-class PipOption(Option):
-    TYPES = Option.TYPES + ("path", "package_name")
-    TYPE_CHECKER = Option.TYPE_CHECKER.copy()
-    TYPE_CHECKER["package_name"] = _package_name_option_check
-    TYPE_CHECKER["path"] = _path_option_check
-
-
-###########
-# options #
-###########
-
-help_: Callable[..., Option] = partial(
-    Option,
-    "-h",
-    "--help",
-    dest="help",
-    action="help",
-    help="Show help.",
-)
-
-debug_mode: Callable[..., Option] = partial(
-    Option,
-    "--debug",
-    dest="debug_mode",
-    action="store_true",
-    default=False,
-    help=(
-        "Let unhandled exceptions propagate outside the main subroutine, "
-        "instead of logging them to stderr."
-    ),
-)
-
-isolated_mode: Callable[..., Option] = partial(
-    Option,
-    "--isolated",
-    dest="isolated_mode",
-    action="store_true",
-    default=False,
-    help=(
-        "Run pip in an isolated mode, ignoring environment variables and user "
-        "configuration."
-    ),
-)
-
-require_virtualenv: Callable[..., Option] = partial(
-    Option,
-    "--require-virtualenv",
-    "--require-venv",
-    dest="require_venv",
-    action="store_true",
-    default=False,
-    help=(
-        "Allow pip to only run in a virtual environment; "
-        "exit with an error otherwise."
-    ),
-)
-
-override_externally_managed: Callable[..., Option] = partial(
-    Option,
-    "--break-system-packages",
-    dest="override_externally_managed",
-    action="store_true",
-    help="Allow pip to modify an EXTERNALLY-MANAGED Python installation",
-)
-
-python: Callable[..., Option] = partial(
-    Option,
-    "--python",
-    dest="python",
-    help="Run pip with the specified Python interpreter.",
-)
-
-verbose: Callable[..., Option] = partial(
-    Option,
-    "-v",
-    "--verbose",
-    dest="verbose",
-    action="count",
-    default=0,
-    help="Give more output. Option is additive, and can be used up to 3 times.",
-)
-
-no_color: Callable[..., Option] = partial(
-    Option,
-    "--no-color",
-    dest="no_color",
-    action="store_true",
-    default=False,
-    help="Suppress colored output.",
-)
-
-version: Callable[..., Option] = partial(
-    Option,
-    "-V",
-    "--version",
-    dest="version",
-    action="store_true",
-    help="Show version and exit.",
-)
-
-quiet: Callable[..., Option] = partial(
-    Option,
-    "-q",
-    "--quiet",
-    dest="quiet",
-    action="count",
-    default=0,
-    help=(
-        "Give less output. Option is additive, and can be used up to 3"
-        " times (corresponding to WARNING, ERROR, and CRITICAL logging"
-        " levels)."
-    ),
-)
-
-progress_bar: Callable[..., Option] = partial(
-    Option,
-    "--progress-bar",
-    dest="progress_bar",
-    type="choice",
-    choices=["on", "off"],
-    default="on",
-    help="Specify whether the progress bar should be used [on, off] (default: on)",
-)
-
-log: Callable[..., Option] = partial(
-    PipOption,
-    "--log",
-    "--log-file",
-    "--local-log",
-    dest="log",
-    metavar="path",
-    type="path",
-    help="Path to a verbose appending log.",
-)
-
-no_input: Callable[..., Option] = partial(
-    Option,
-    # Don't ask for input
-    "--no-input",
-    dest="no_input",
-    action="store_true",
-    default=False,
-    help="Disable prompting for input.",
-)
-
-keyring_provider: Callable[..., Option] = partial(
-    Option,
-    "--keyring-provider",
-    dest="keyring_provider",
-    choices=["auto", "disabled", "import", "subprocess"],
-    default="auto",
-    help=(
-        "Enable the credential lookup via the keyring library if user input is allowed."
-        " Specify which mechanism to use [disabled, import, subprocess]."
-        " (default: disabled)"
-    ),
-)
-
-proxy: Callable[..., Option] = partial(
-    Option,
-    "--proxy",
-    dest="proxy",
-    type="str",
-    default="",
-    help="Specify a proxy in the form scheme://[user:passwd@]proxy.server:port.",
-)
-
-retries: Callable[..., Option] = partial(
-    Option,
-    "--retries",
-    dest="retries",
-    type="int",
-    default=5,
-    help="Maximum number of retries each connection should attempt "
-    "(default %default times).",
-)
-
-timeout: Callable[..., Option] = partial(
-    Option,
-    "--timeout",
-    "--default-timeout",
-    metavar="sec",
-    dest="timeout",
-    type="float",
-    default=15,
-    help="Set the socket timeout (default %default seconds).",
-)
-
-
-def exists_action() -> Option:
-    return Option(
-        # Option when path already exist
-        "--exists-action",
-        dest="exists_action",
-        type="choice",
-        choices=["s", "i", "w", "b", "a"],
-        default=[],
-        action="append",
-        metavar="action",
-        help="Default action when a path already exists: "
-        "(s)witch, (i)gnore, (w)ipe, (b)ackup, (a)bort.",
-    )
-
-
-cert: Callable[..., Option] = partial(
-    PipOption,
-    "--cert",
-    dest="cert",
-    type="path",
-    metavar="path",
-    help=(
-        "Path to PEM-encoded CA certificate bundle. "
-        "If provided, overrides the default. "
-        "See 'SSL Certificate Verification' in pip documentation "
-        "for more information."
-    ),
-)
-
-client_cert: Callable[..., Option] = partial(
-    PipOption,
-    "--client-cert",
-    dest="client_cert",
-    type="path",
-    default=None,
-    metavar="path",
-    help="Path to SSL client certificate, a single file containing the "
-    "private key and the certificate in PEM format.",
-)
-
-index_url: Callable[..., Option] = partial(
-    Option,
-    "-i",
-    "--index-url",
-    "--pypi-url",
-    dest="index_url",
-    metavar="URL",
-    default=PyPI.simple_url,
-    help="Base URL of the Python Package Index (default %default). "
-    "This should point to a repository compliant with PEP 503 "
-    "(the simple repository API) or a local directory laid out "
-    "in the same format.",
-)
-
-
-def extra_index_url() -> Option:
-    return Option(
-        "--extra-index-url",
-        dest="extra_index_urls",
-        metavar="URL",
-        action="append",
-        default=[],
-        help="Extra URLs of package indexes to use in addition to "
-        "--index-url. Should follow the same rules as "
-        "--index-url.",
-    )
-
-
-no_index: Callable[..., Option] = partial(
-    Option,
-    "--no-index",
-    dest="no_index",
-    action="store_true",
-    default=False,
-    help="Ignore package index (only looking at --find-links URLs instead).",
-)
-
-
-def find_links() -> Option:
-    return Option(
-        "-f",
-        "--find-links",
-        dest="find_links",
-        action="append",
-        default=[],
-        metavar="url",
-        help="If a URL or path to an html file, then parse for links to "
-        "archives such as sdist (.tar.gz) or wheel (.whl) files. "
-        "If a local path or file:// URL that's a directory, "
-        "then look for archives in the directory listing. "
-        "Links to VCS project URLs are not supported.",
-    )
-
-
-def trusted_host() -> Option:
-    return Option(
-        "--trusted-host",
-        dest="trusted_hosts",
-        action="append",
-        metavar="HOSTNAME",
-        default=[],
-        help="Mark this host or host:port pair as trusted, even though it "
-        "does not have valid or any HTTPS.",
-    )
-
-
-def constraints() -> Option:
-    return Option(
-        "-c",
-        "--constraint",
-        dest="constraints",
-        action="append",
-        default=[],
-        metavar="file",
-        help="Constrain versions using the given constraints file. "
-        "This option can be used multiple times.",
-    )
-
-
-def requirements() -> Option:
-    return Option(
-        "-r",
-        "--requirement",
-        dest="requirements",
-        action="append",
-        default=[],
-        metavar="file",
-        help="Install from the given requirements file. "
-        "This option can be used multiple times.",
-    )
-
-
-def editable() -> Option:
-    return Option(
-        "-e",
-        "--editable",
-        dest="editables",
-        action="append",
-        default=[],
-        metavar="path/url",
-        help=(
-            "Install a project in editable mode (i.e. setuptools "
-            '"develop mode") from a local project path or a VCS url.'
-        ),
-    )
-
-
-def _handle_src(option: Option, opt_str: str, value: str, parser: OptionParser) -> None:
-    value = os.path.abspath(value)
-    setattr(parser.values, option.dest, value)
-
-
-src: Callable[..., Option] = partial(
-    PipOption,
-    "--src",
-    "--source",
-    "--source-dir",
-    "--source-directory",
-    dest="src_dir",
-    type="path",
-    metavar="dir",
-    default=get_src_prefix(),
-    action="callback",
-    callback=_handle_src,
-    help="Directory to check out editable projects into. "
-    'The default in a virtualenv is "<venv path>/src". '
-    'The default for global installs is "<current dir>/src".',
-)
-
-
-def _get_format_control(values: Values, option: Option) -> Any:
-    """Get a format_control object."""
-    return getattr(values, option.dest)
-
-
-def _handle_no_binary(
-    option: Option, opt_str: str, value: str, parser: OptionParser
-) -> None:
-    existing = _get_format_control(parser.values, option)
-    FormatControl.handle_mutual_excludes(
-        value,
-        existing.no_binary,
-        existing.only_binary,
-    )
-
-
-def _handle_only_binary(
-    option: Option, opt_str: str, value: str, parser: OptionParser
-) -> None:
-    existing = _get_format_control(parser.values, option)
-    FormatControl.handle_mutual_excludes(
-        value,
-        existing.only_binary,
-        existing.no_binary,
-    )
-
-
-def no_binary() -> Option:
-    format_control = FormatControl(set(), set())
-    return Option(
-        "--no-binary",
-        dest="format_control",
-        action="callback",
-        callback=_handle_no_binary,
-        type="str",
-        default=format_control,
-        help="Do not use binary packages. Can be supplied multiple times, and "
-        'each time adds to the existing value. Accepts either ":all:" to '
-        'disable all binary packages, ":none:" to empty the set (notice '
-        "the colons), or one or more package names with commas between "
-        "them (no colons). Note that some packages are tricky to compile "
-        "and may fail to install when this option is used on them.",
-    )
-
-
-def only_binary() -> Option:
-    format_control = FormatControl(set(), set())
-    return Option(
-        "--only-binary",
-        dest="format_control",
-        action="callback",
-        callback=_handle_only_binary,
-        type="str",
-        default=format_control,
-        help="Do not use source packages. Can be supplied multiple times, and "
-        'each time adds to the existing value. Accepts either ":all:" to '
-        'disable all source packages, ":none:" to empty the set, or one '
-        "or more package names with commas between them. Packages "
-        "without binary distributions will fail to install when this "
-        "option is used on them.",
-    )
-
-
-platforms: Callable[..., Option] = partial(
-    Option,
-    "--platform",
-    dest="platforms",
-    metavar="platform",
-    action="append",
-    default=None,
-    help=(
-        "Only use wheels compatible with <platform>. Defaults to the "
-        "platform of the running system. Use this option multiple times to "
-        "specify multiple platforms supported by the target interpreter."
-    ),
-)
-
-
-# This was made a separate function for unit-testing purposes.
-def _convert_python_version(value: str) -> Tuple[Tuple[int, ...], Optional[str]]:
-    """
-    Convert a version string like "3", "37", or "3.7.3" into a tuple of ints.
-
-    :return: A 2-tuple (version_info, error_msg), where `error_msg` is
-        non-None if and only if there was a parsing error.
-    """
-    if not value:
-        # The empty string is the same as not providing a value.
-        return (None, None)
-
-    parts = value.split(".")
-    if len(parts) > 3:
-        return ((), "at most three version parts are allowed")
-
-    if len(parts) == 1:
-        # Then we are in the case of "3" or "37".
-        value = parts[0]
-        if len(value) > 1:
-            parts = [value[0], value[1:]]
-
-    try:
-        version_info = tuple(int(part) for part in parts)
-    except ValueError:
-        return ((), "each version part must be an integer")
-
-    return (version_info, None)
-
-
-def _handle_python_version(
-    option: Option, opt_str: str, value: str, parser: OptionParser
-) -> None:
-    """
-    Handle a provided --python-version value.
-    """
-    version_info, error_msg = _convert_python_version(value)
-    if error_msg is not None:
-        msg = "invalid --python-version value: {!r}: {}".format(
-            value,
-            error_msg,
-        )
-        raise_option_error(parser, option=option, msg=msg)
-
-    parser.values.python_version = version_info
-
-
-python_version: Callable[..., Option] = partial(
-    Option,
-    "--python-version",
-    dest="python_version",
-    metavar="python_version",
-    action="callback",
-    callback=_handle_python_version,
-    type="str",
-    default=None,
-    help=dedent(
-        """\
-    The Python interpreter version to use for wheel and "Requires-Python"
-    compatibility checks. Defaults to a version derived from the running
-    interpreter. The version can be specified using up to three dot-separated
-    integers (e.g. "3" for 3.0.0, "3.7" for 3.7.0, or "3.7.3"). A major-minor
-    version can also be given as a string without dots (e.g. "37" for 3.7.0).
-    """
-    ),
-)
-
-
-implementation: Callable[..., Option] = partial(
-    Option,
-    "--implementation",
-    dest="implementation",
-    metavar="implementation",
-    default=None,
-    help=(
-        "Only use wheels compatible with Python "
-        "implementation <implementation>, e.g. 'pp', 'jy', 'cp', "
-        " or 'ip'. If not specified, then the current "
-        "interpreter implementation is used.  Use 'py' to force "
-        "implementation-agnostic wheels."
-    ),
-)
-
-
-abis: Callable[..., Option] = partial(
-    Option,
-    "--abi",
-    dest="abis",
-    metavar="abi",
-    action="append",
-    default=None,
-    help=(
-        "Only use wheels compatible with Python abi <abi>, e.g. 'pypy_41'. "
-        "If not specified, then the current interpreter abi tag is used. "
-        "Use this option multiple times to specify multiple abis supported "
-        "by the target interpreter. Generally you will need to specify "
-        "--implementation, --platform, and --python-version when using this "
-        "option."
-    ),
-)
-
-
-def add_target_python_options(cmd_opts: OptionGroup) -> None:
-    cmd_opts.add_option(platforms())
-    cmd_opts.add_option(python_version())
-    cmd_opts.add_option(implementation())
-    cmd_opts.add_option(abis())
-
-
-def make_target_python(options: Values) -> TargetPython:
-    target_python = TargetPython(
-        platforms=options.platforms,
-        py_version_info=options.python_version,
-        abis=options.abis,
-        implementation=options.implementation,
-    )
-
-    return target_python
-
-
-def prefer_binary() -> Option:
-    return Option(
-        "--prefer-binary",
-        dest="prefer_binary",
-        action="store_true",
-        default=False,
-        help="Prefer older binary packages over newer source packages.",
-    )
-
-
-cache_dir: Callable[..., Option] = partial(
-    PipOption,
-    "--cache-dir",
-    dest="cache_dir",
-    default=USER_CACHE_DIR,
-    metavar="dir",
-    type="path",
-    help="Store the cache data in <dir>.",
-)
-
-
-def _handle_no_cache_dir(
-    option: Option, opt: str, value: str, parser: OptionParser
-) -> None:
-    """
-    Process a value provided for the --no-cache-dir option.
-
-    This is an optparse.Option callback for the --no-cache-dir option.
-    """
-    # The value argument will be None if --no-cache-dir is passed via the
-    # command-line, since the option doesn't accept arguments.  However,
-    # the value can be non-None if the option is triggered e.g. by an
-    # environment variable, like PIP_NO_CACHE_DIR=true.
-    if value is not None:
-        # Then parse the string value to get argument error-checking.
-        try:
-            strtobool(value)
-        except ValueError as exc:
-            raise_option_error(parser, option=option, msg=str(exc))
-
-    # Originally, setting PIP_NO_CACHE_DIR to a value that strtobool()
-    # converted to 0 (like "false" or "no") caused cache_dir to be disabled
-    # rather than enabled (logic would say the latter).  Thus, we disable
-    # the cache directory not just on values that parse to True, but (for
-    # backwards compatibility reasons) also on values that parse to False.
-    # In other words, always set it to False if the option is provided in
-    # some (valid) form.
-    parser.values.cache_dir = False
-
-
-no_cache: Callable[..., Option] = partial(
-    Option,
-    "--no-cache-dir",
-    dest="cache_dir",
-    action="callback",
-    callback=_handle_no_cache_dir,
-    help="Disable the cache.",
-)
-
-no_deps: Callable[..., Option] = partial(
-    Option,
-    "--no-deps",
-    "--no-dependencies",
-    dest="ignore_dependencies",
-    action="store_true",
-    default=False,
-    help="Don't install package dependencies.",
-)
-
-ignore_requires_python: Callable[..., Option] = partial(
-    Option,
-    "--ignore-requires-python",
-    dest="ignore_requires_python",
-    action="store_true",
-    help="Ignore the Requires-Python information.",
-)
-
-no_build_isolation: Callable[..., Option] = partial(
-    Option,
-    "--no-build-isolation",
-    dest="build_isolation",
-    action="store_false",
-    default=True,
-    help="Disable isolation when building a modern source distribution. "
-    "Build dependencies specified by PEP 518 must be already installed "
-    "if this option is used.",
-)
-
-check_build_deps: Callable[..., Option] = partial(
-    Option,
-    "--check-build-dependencies",
-    dest="check_build_deps",
-    action="store_true",
-    default=False,
-    help="Check the build dependencies when PEP517 is used.",
-)
-
-
-def _handle_no_use_pep517(
-    option: Option, opt: str, value: str, parser: OptionParser
-) -> None:
-    """
-    Process a value provided for the --no-use-pep517 option.
-
-    This is an optparse.Option callback for the no_use_pep517 option.
-    """
-    # Since --no-use-pep517 doesn't accept arguments, the value argument
-    # will be None if --no-use-pep517 is passed via the command-line.
-    # However, the value can be non-None if the option is triggered e.g.
-    # by an environment variable, for example "PIP_NO_USE_PEP517=true".
-    if value is not None:
-        msg = """A value was passed for --no-use-pep517,
-        probably using either the PIP_NO_USE_PEP517 environment variable
-        or the "no-use-pep517" config file option. Use an appropriate value
-        of the PIP_USE_PEP517 environment variable or the "use-pep517"
-        config file option instead.
-        """
-        raise_option_error(parser, option=option, msg=msg)
-
-    # If user doesn't wish to use pep517, we check if setuptools and wheel are installed
-    # and raise error if it is not.
-    packages = ("setuptools", "wheel")
-    if not all(importlib.util.find_spec(package) for package in packages):
-        msg = (
-            f"It is not possible to use --no-use-pep517 "
-            f"without {' and '.join(packages)} installed."
-        )
-        raise_option_error(parser, option=option, msg=msg)
-
-    # Otherwise, --no-use-pep517 was passed via the command-line.
-    parser.values.use_pep517 = False
-
-
-use_pep517: Any = partial(
-    Option,
-    "--use-pep517",
-    dest="use_pep517",
-    action="store_true",
-    default=None,
-    help="Use PEP 517 for building source distributions "
-    "(use --no-use-pep517 to force legacy behaviour).",
-)
-
-no_use_pep517: Any = partial(
-    Option,
-    "--no-use-pep517",
-    dest="use_pep517",
-    action="callback",
-    callback=_handle_no_use_pep517,
-    default=None,
-    help=SUPPRESS_HELP,
-)
-
-
-def _handle_config_settings(
-    option: Option, opt_str: str, value: str, parser: OptionParser
-) -> None:
-    key, sep, val = value.partition("=")
-    if sep != "=":
-        parser.error(f"Arguments to {opt_str} must be of the form KEY=VAL")  # noqa
-    dest = getattr(parser.values, option.dest)
-    if dest is None:
-        dest = {}
-        setattr(parser.values, option.dest, dest)
-    if key in dest:
-        if isinstance(dest[key], list):
-            dest[key].append(val)
-        else:
-            dest[key] = [dest[key], val]
-    else:
-        dest[key] = val
-
-
-config_settings: Callable[..., Option] = partial(
-    Option,
-    "-C",
-    "--config-settings",
-    dest="config_settings",
-    type=str,
-    action="callback",
-    callback=_handle_config_settings,
-    metavar="settings",
-    help="Configuration settings to be passed to the PEP 517 build backend. "
-    "Settings take the form KEY=VALUE. Use multiple --config-settings options "
-    "to pass multiple keys to the backend.",
-)
-
-build_options: Callable[..., Option] = partial(
-    Option,
-    "--build-option",
-    dest="build_options",
-    metavar="options",
-    action="append",
-    help="Extra arguments to be supplied to 'setup.py bdist_wheel'.",
-)
-
-global_options: Callable[..., Option] = partial(
-    Option,
-    "--global-option",
-    dest="global_options",
-    action="append",
-    metavar="options",
-    help="Extra global options to be supplied to the setup.py "
-    "call before the install or bdist_wheel command.",
-)
-
-no_clean: Callable[..., Option] = partial(
-    Option,
-    "--no-clean",
-    action="store_true",
-    default=False,
-    help="Don't clean up build directories.",
-)
-
-pre: Callable[..., Option] = partial(
-    Option,
-    "--pre",
-    action="store_true",
-    default=False,
-    help="Include pre-release and development versions. By default, "
-    "pip only finds stable versions.",
-)
-
-disable_pip_version_check: Callable[..., Option] = partial(
-    Option,
-    "--disable-pip-version-check",
-    dest="disable_pip_version_check",
-    action="store_true",
-    default=False,
-    help="Don't periodically check PyPI to determine whether a new version "
-    "of pip is available for download. Implied with --no-index.",
-)
-
-root_user_action: Callable[..., Option] = partial(
-    Option,
-    "--root-user-action",
-    dest="root_user_action",
-    default="warn",
-    choices=["warn", "ignore"],
-    help="Action if pip is run as a root user. By default, a warning message is shown.",
-)
-
-
-def _handle_merge_hash(
-    option: Option, opt_str: str, value: str, parser: OptionParser
-) -> None:
-    """Given a value spelled "algo:digest", append the digest to a list
-    pointed to in a dict by the algo name."""
-    if not parser.values.hashes:
-        parser.values.hashes = {}
-    try:
-        algo, digest = value.split(":", 1)
-    except ValueError:
-        parser.error(
-            "Arguments to {} must be a hash name "  # noqa
-            "followed by a value, like --hash=sha256:"
-            "abcde...".format(opt_str)
-        )
-    if algo not in STRONG_HASHES:
-        parser.error(
-            "Allowed hash algorithms for {} are {}.".format(  # noqa
-                opt_str, ", ".join(STRONG_HASHES)
-            )
-        )
-    parser.values.hashes.setdefault(algo, []).append(digest)
-
-
-hash: Callable[..., Option] = partial(
-    Option,
-    "--hash",
-    # Hash values eventually end up in InstallRequirement.hashes due to
-    # __dict__ copying in process_line().
-    dest="hashes",
-    action="callback",
-    callback=_handle_merge_hash,
-    type="string",
-    help="Verify that the package's archive matches this "
-    "hash before installing. Example: --hash=sha256:abcdef...",
-)
-
-
-require_hashes: Callable[..., Option] = partial(
-    Option,
-    "--require-hashes",
-    dest="require_hashes",
-    action="store_true",
-    default=False,
-    help="Require a hash to check each requirement against, for "
-    "repeatable installs. This option is implied when any package in a "
-    "requirements file has a --hash option.",
-)
-
-
-list_path: Callable[..., Option] = partial(
-    PipOption,
-    "--path",
-    dest="path",
-    type="path",
-    action="append",
-    help="Restrict to the specified installation path for listing "
-    "packages (can be used multiple times).",
-)
-
-
-def check_list_path_option(options: Values) -> None:
-    if options.path and (options.user or options.local):
-        raise CommandError("Cannot combine '--path' with '--user' or '--local'")
-
-
-list_exclude: Callable[..., Option] = partial(
-    PipOption,
-    "--exclude",
-    dest="excludes",
-    action="append",
-    metavar="package",
-    type="package_name",
-    help="Exclude specified package from the output",
-)
-
-
-no_python_version_warning: Callable[..., Option] = partial(
-    Option,
-    "--no-python-version-warning",
-    dest="no_python_version_warning",
-    action="store_true",
-    default=False,
-    help="Silence deprecation warnings for upcoming unsupported Pythons.",
-)
-
-
-# Features that are now always on. A warning is printed if they are used.
-ALWAYS_ENABLED_FEATURES = [
-    "no-binary-enable-wheel-cache",  # always on since 23.1
-]
-
-use_new_feature: Callable[..., Option] = partial(
-    Option,
-    "--use-feature",
-    dest="features_enabled",
-    metavar="feature",
-    action="append",
-    default=[],
-    choices=[
-        "fast-deps",
-        "truststore",
-    ]
-    + ALWAYS_ENABLED_FEATURES,
-    help="Enable new functionality, that may be backward incompatible.",
-)
-
-use_deprecated_feature: Callable[..., Option] = partial(
-    Option,
-    "--use-deprecated",
-    dest="deprecated_features_enabled",
-    metavar="feature",
-    action="append",
-    default=[],
-    choices=[
-        "legacy-resolver",
-    ],
-    help=("Enable deprecated functionality, that will be removed in the future."),
-)
-
-
-##########
-# groups #
-##########
-
-general_group: Dict[str, Any] = {
-    "name": "General Options",
-    "options": [
-        help_,
-        debug_mode,
-        isolated_mode,
-        require_virtualenv,
-        python,
-        verbose,
-        version,
-        quiet,
-        log,
-        no_input,
-        keyring_provider,
-        proxy,
-        retries,
-        timeout,
-        exists_action,
-        trusted_host,
-        cert,
-        client_cert,
-        cache_dir,
-        no_cache,
-        disable_pip_version_check,
-        no_color,
-        no_python_version_warning,
-        use_new_feature,
-        use_deprecated_feature,
-    ],
-}
-
-index_group: Dict[str, Any] = {
-    "name": "Package Index Options",
-    "options": [
-        index_url,
-        extra_index_url,
-        no_index,
-        find_links,
-    ],
-}

spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/rich/markup.py

@@ -1,246 +0,0 @@
-import re
-from ast import literal_eval
-from operator import attrgetter
-from typing import Callable, Iterable, List, Match, NamedTuple, Optional, Tuple, Union
-
-from ._emoji_replace import _emoji_replace
-from .emoji import EmojiVariant
-from .errors import MarkupError
-from .style import Style
-from .text import Span, Text
-
-RE_TAGS = re.compile(
-    r"""((\\*)\[([a-z#/@][^[]*?)])""",
-    re.VERBOSE,
-)
-
-RE_HANDLER = re.compile(r"^([\w.]*?)(\(.*?\))?$")
-
-
-class Tag(NamedTuple):
-    """A tag in console markup."""
-
-    name: str
-    """The tag name. e.g. 'bold'."""
-    parameters: Optional[str]
-    """Any additional parameters after the name."""
-
-    def __str__(self) -> str:
-        return (
-            self.name if self.parameters is None else f"{self.name} {self.parameters}"
-        )
-
-    @property
-    def markup(self) -> str:
-        """Get the string representation of this tag."""
-        return (
-            f"[{self.name}]"
-            if self.parameters is None
-            else f"[{self.name}={self.parameters}]"
-        )
-
-
-_ReStringMatch = Match[str]  # regex match object
-_ReSubCallable = Callable[[_ReStringMatch], str]  # Callable invoked by re.sub
-_EscapeSubMethod = Callable[[_ReSubCallable, str], str]  # Sub method of a compiled re
-
-
-def escape(
-    markup: str,
-    _escape: _EscapeSubMethod = re.compile(r"(\\*)(\[[a-z#/@][^[]*?])").sub,
-) -> str:
-    """Escapes text so that it won't be interpreted as markup.
-
-    Args:
-        markup (str): Content to be inserted in to markup.
-
-    Returns:
-        str: Markup with square brackets escaped.
-    """
-
-    def escape_backslashes(match: Match[str]) -> str:
-        """Called by re.sub replace matches."""
-        backslashes, text = match.groups()
-        return f"{backslashes}{backslashes}\\{text}"
-
-    markup = _escape(escape_backslashes, markup)
-    return markup
-
-
-def _parse(markup: str) -> Iterable[Tuple[int, Optional[str], Optional[Tag]]]:
-    """Parse markup in to an iterable of tuples of (position, text, tag).
-
-    Args:
-        markup (str): A string containing console markup
-
-    """
-    position = 0
-    _divmod = divmod
-    _Tag = Tag
-    for match in RE_TAGS.finditer(markup):
-        full_text, escapes, tag_text = match.groups()
-        start, end = match.span()
-        if start > position:
-            yield start, markup[position:start], None
-        if escapes:
-            backslashes, escaped = _divmod(len(escapes), 2)
-            if backslashes:
-                # Literal backslashes
-                yield start, "\\" * backslashes, None
-                start += backslashes * 2
-            if escaped:
-                # Escape of tag
-                yield start, full_text[len(escapes) :], None
-                position = end
-                continue
-        text, equals, parameters = tag_text.partition("=")
-        yield start, None, _Tag(text, parameters if equals else None)
-        position = end
-    if position < len(markup):
-        yield position, markup[position:], None
-
-
-def render(
-    markup: str,
-    style: Union[str, Style] = "",
-    emoji: bool = True,
-    emoji_variant: Optional[EmojiVariant] = None,
-) -> Text:
-    """Render console markup in to a Text instance.
-
-    Args:
-        markup (str): A string containing console markup.
-        emoji (bool, optional): Also render emoji code. Defaults to True.
-
-    Raises:
-        MarkupError: If there is a syntax error in the markup.
-
-    Returns:
-        Text: A test instance.
-    """
-    emoji_replace = _emoji_replace
-    if "[" not in markup:
-        return Text(
-            emoji_replace(markup, default_variant=emoji_variant) if emoji else markup,
-            style=style,
-        )
-    text = Text(style=style)
-    append = text.append
-    normalize = Style.normalize
-
-    style_stack: List[Tuple[int, Tag]] = []
-    pop = style_stack.pop
-
-    spans: List[Span] = []
-    append_span = spans.append
-
-    _Span = Span
-    _Tag = Tag
-
-    def pop_style(style_name: str) -> Tuple[int, Tag]:
-        """Pop tag matching given style name."""
-        for index, (_, tag) in enumerate(reversed(style_stack), 1):
-            if tag.name == style_name:
-                return pop(-index)
-        raise KeyError(style_name)
-
-    for position, plain_text, tag in _parse(markup):
-        if plain_text is not None:
-            # Handle open brace escapes, where the brace is not part of a tag.
-            plain_text = plain_text.replace("\\[", "[")
-            append(emoji_replace(plain_text) if emoji else plain_text)
-        elif tag is not None:
-            if tag.name.startswith("/"):  # Closing tag
-                style_name = tag.name[1:].strip()
-
-                if style_name:  # explicit close
-                    style_name = normalize(style_name)
-                    try:
-                        start, open_tag = pop_style(style_name)
-                    except KeyError:
-                        raise MarkupError(
-                            f"closing tag '{tag.markup}' at position {position} doesn't match any open tag"
-                        ) from None
-                else:  # implicit close
-                    try:
-                        start, open_tag = pop()
-                    except IndexError:
-                        raise MarkupError(
-                            f"closing tag '[/]' at position {position} has nothing to close"
-                        ) from None
-
-                if open_tag.name.startswith("@"):
-                    if open_tag.parameters:
-                        handler_name = ""
-                        parameters = open_tag.parameters.strip()
-                        handler_match = RE_HANDLER.match(parameters)
-                        if handler_match is not None:
-                            handler_name, match_parameters = handler_match.groups()
-                            parameters = (
-                                "()" if match_parameters is None else match_parameters
-                            )
-
-                        try:
-                            meta_params = literal_eval(parameters)
-                        except SyntaxError as error:
-                            raise MarkupError(
-                                f"error parsing {parameters!r} in {open_tag.parameters!r}; {error.msg}"
-                            )
-                        except Exception as error:
-                            raise MarkupError(
-                                f"error parsing {open_tag.parameters!r}; {error}"
-                            ) from None
-
-                        if handler_name:
-                            meta_params = (
-                                handler_name,
-                                meta_params
-                                if isinstance(meta_params, tuple)
-                                else (meta_params,),
-                            )
-
-                    else:
-                        meta_params = ()
-
-                    append_span(
-                        _Span(
-                            start, len(text), Style(meta={open_tag.name: meta_params})
-                        )
-                    )
-                else:
-                    append_span(_Span(start, len(text), str(open_tag)))
-
-            else:  # Opening tag
-                normalized_tag = _Tag(normalize(tag.name), tag.parameters)
-                style_stack.append((len(text), normalized_tag))
-
-    text_length = len(text)
-    while style_stack:
-        start, tag = style_stack.pop()
-        style = str(tag)
-        if style:
-            append_span(_Span(start, text_length, style))
-
-    text.spans = sorted(spans[::-1], key=attrgetter("start"))
-    return text
-
-
-if __name__ == "__main__":  # pragma: no cover
-
-    MARKUP = [
-        "[red]Hello World[/red]",
-        "[magenta]Hello [b]World[/b]",
-        "[bold]Bold[italic] bold and italic [/bold]italic[/italic]",
-        "Click [link=https://www.willmcgugan.com]here[/link] to visit my Blog",
-        ":warning-emoji: [bold red blink] DANGER![/]",
-    ]
-
-    from pip._vendor.rich import print
-    from pip._vendor.rich.table import Table
-
-    grid = Table("Markup", "Result", padding=(0, 1))
-
-    for markup in MARKUP:
-        grid.add_row(Text(markup), markup)
-
-    print(grid)

spaces/Big-Web/MMSD/env/Scripts/deactivate.bat

@@ -1,22 +0,0 @@
-@echo off
-
-if defined _OLD_VIRTUAL_PROMPT (
-    set "PROMPT=%_OLD_VIRTUAL_PROMPT%"
-)
-set _OLD_VIRTUAL_PROMPT=
-
-if defined _OLD_VIRTUAL_PYTHONHOME (
-    set "PYTHONHOME=%_OLD_VIRTUAL_PYTHONHOME%"
-    set _OLD_VIRTUAL_PYTHONHOME=
-)
-
-if defined _OLD_VIRTUAL_PATH (
-    set "PATH=%_OLD_VIRTUAL_PATH%"
-)
-
-set _OLD_VIRTUAL_PATH=
-
-set VIRTUAL_ENV=
-set VIRTUAL_ENV_PROMPT=
-
-:END

spaces/CAMP-ViL/Xplainer/inference.py

@@ -1,116 +0,0 @@
-import argparse
-import gc
-from pathlib import Path
-
-import torch
-from torch.utils.data import DataLoader
-from tqdm import tqdm
-
-from chestxray14 import ChestXray14Dataset
-from chexpert import CheXpertDataset
-from descriptors import disease_descriptors_chexpert, disease_descriptors_chestxray14
-from model import InferenceModel
-from utils import calculate_auroc
-
-torch.multiprocessing.set_sharing_strategy('file_system')
-
-
-def inference_chexpert():
-    split = 'test'
-    dataset = CheXpertDataset(f'data/chexpert/{split}_labels.csv')  # also do test
-    dataloader = DataLoader(dataset, batch_size=1, shuffle=False, collate_fn=lambda x: x, num_workers=0)
-    inference_model = InferenceModel()
-    all_descriptors = inference_model.get_all_descriptors(disease_descriptors_chexpert)
-
-    all_labels = []
-    all_probs_neg = []
-
-    for batch in tqdm(dataloader):
-        batch = batch[0]
-        image_paths, labels, keys = batch
-        image_paths = [Path(image_path) for image_path in image_paths]
-        agg_probs = []
-        agg_negative_probs = []
-        for image_path in image_paths:
-            probs, negative_probs = inference_model.get_descriptor_probs(image_path, descriptors=all_descriptors)
-            agg_probs.append(probs)
-            agg_negative_probs.append(negative_probs)
-        probs = {}  # Aggregated
-        negative_probs = {}  # Aggregated
-        for key in agg_probs[0].keys():
-            probs[key] = sum([p[key] for p in agg_probs]) / len(agg_probs)  # Mean Aggregation
-
-        for key in agg_negative_probs[0].keys():
-            negative_probs[key] = sum([p[key] for p in agg_negative_probs]) / len(agg_negative_probs)  # Mean Aggregation
-
-        disease_probs, negative_disease_probs = inference_model.get_diseases_probs(disease_descriptors_chexpert, pos_probs=probs,
-                                                                                   negative_probs=negative_probs)
-        predicted_diseases, prob_vector_neg_prompt = inference_model.get_predictions_bin_prompting(disease_descriptors_chexpert,
-                                                                                                   disease_probs=disease_probs,
-                                                                                                   negative_disease_probs=negative_disease_probs,
-                                                                                                   keys=keys)
-        all_labels.append(labels)
-        all_probs_neg.append(prob_vector_neg_prompt)
-
-    all_labels = torch.stack(all_labels)
-    all_probs_neg = torch.stack(all_probs_neg)
-
-    # evaluation
-    existing_mask = sum(all_labels, 0) > 0
-    all_labels_clean = all_labels[:, existing_mask]
-    all_probs_neg_clean = all_probs_neg[:, existing_mask]
-    all_keys_clean = [key for idx, key in enumerate(keys) if existing_mask[idx]]
-
-    overall_auroc, per_disease_auroc = calculate_auroc(all_probs_neg_clean, all_labels_clean)
-    print(f"AUROC: {overall_auroc:.5f}\n")
-    for idx, key in enumerate(all_keys_clean):
-        print(f'{key}: {per_disease_auroc[idx]:.5f}')
-
-
-def inference_chestxray14():
-    dataset = ChestXray14Dataset(f'data/chestxray14/Data_Entry_2017_v2020_modified.csv')
-    dataloader = DataLoader(dataset, batch_size=1, shuffle=False, collate_fn=lambda x: x, num_workers=1)
-    inference_model = InferenceModel()
-    all_descriptors = inference_model.get_all_descriptors(disease_descriptors_chestxray14)
-
-    all_labels = []
-    all_probs_neg = []
-    for batch in tqdm(dataloader):
-        batch = batch[0]
-        image_path, labels, keys = batch
-        image_path = Path(image_path)
-        probs, negative_probs = inference_model.get_descriptor_probs(image_path, descriptors=all_descriptors)
-        disease_probs, negative_disease_probs = inference_model.get_diseases_probs(disease_descriptors_chestxray14, pos_probs=probs,
-                                                                                   negative_probs=negative_probs)
-        predicted_diseases, prob_vector_neg_prompt = inference_model.get_predictions_bin_prompting(disease_descriptors_chestxray14,
-                                                                                                   disease_probs=disease_probs,
-                                                                                                   negative_disease_probs=negative_disease_probs,
-                                                                                                   keys=keys)
-        all_labels.append(labels)
-        all_probs_neg.append(prob_vector_neg_prompt)
-        gc.collect()
-
-    all_labels = torch.stack(all_labels)
-    all_probs_neg = torch.stack(all_probs_neg)
-
-    existing_mask = sum(all_labels, 0) > 0
-    all_labels_clean = all_labels[:, existing_mask]
-    all_probs_neg_clean = all_probs_neg[:, existing_mask]
-    all_keys_clean = [key for idx, key in enumerate(keys) if existing_mask[idx]]
-
-    overall_auroc, per_disease_auroc = calculate_auroc(all_probs_neg_clean[:, 1:], all_labels_clean[:, 1:])
-    print(f"AUROC: {overall_auroc:.5f}\n")
-    for idx, key in enumerate(all_keys_clean[1:]):
-        print(f'{key}: {per_disease_auroc[idx]:.5f}')
-
-
-if __name__ == '__main__':
-    # add argument parser
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--dataset', type=str, default='chexpert', help='chexpert or chestxray14')
-    args = parser.parse_args()
-
-    if args.dataset == 'chexpert':
-        inference_chexpert()
-    elif args.dataset == 'chestxray14':
-        inference_chestxray14()

spaces/CVPR/LIVE/thrust/thrust/iterator/detail/iterator_facade_category.h

@@ -1,253 +0,0 @@
-/*
- *  Copyright 2008-2013 NVIDIA Corporation
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-#pragma once
-
-#include <thrust/detail/config.h>
-#include <thrust/detail/type_traits.h>
-#include <thrust/iterator/detail/host_system_tag.h>
-#include <thrust/iterator/detail/device_system_tag.h>
-#include <thrust/iterator/detail/any_system_tag.h>
-#include <thrust/iterator/iterator_categories.h>
-#include <thrust/iterator/detail/iterator_traversal_tags.h>
-#include <thrust/iterator/detail/is_iterator_category.h>
-#include <thrust/iterator/detail/iterator_category_with_system_and_traversal.h>
-#include <thrust/iterator/detail/iterator_category_to_traversal.h>
-
-namespace thrust
-{
-
-namespace detail
-{
-
-
-// adapted from http://www.boost.org/doc/libs/1_37_0/libs/iterator/doc/iterator_facade.html#iterator-category
-//
-// in our implementation, R need not be a reference type to result in a category
-// derived from forward_XXX_iterator_tag
-//
-// iterator-category(T,V,R) :=
-//   if(T is convertible to input_host_iterator_tag
-//      || T is convertible to output_host_iterator_tag
-//      || T is convertible to input_device_iterator_tag
-//      || T is convertible to output_device_iterator_tag
-//   )
-//     return T
-//
-//   else if (T is not convertible to incrementable_traversal_tag)
-//     the program is ill-formed
-//
-//   else return a type X satisfying the following two constraints:
-//
-//     1. X is convertible to X1, and not to any more-derived
-//        type, where X1 is defined by:
-//
-//        if (T is convertible to forward_traversal_tag)
-//        {
-//          if (T is convertible to random_access_traversal_tag)
-//            X1 = random_access_host_iterator_tag
-//          else if (T is convertible to bidirectional_traversal_tag)
-//            X1 = bidirectional_host_iterator_tag
-//          else
-//            X1 = forward_host_iterator_tag
-//        }
-//        else
-//        {
-//          if (T is convertible to single_pass_traversal_tag
-//              && R is convertible to V)
-//            X1 = input_host_iterator_tag
-//          else
-//            X1 = T
-//        }
-//
-//     2. category-to-traversal(X) is convertible to the most
-//        derived traversal tag type to which X is also convertible,
-//        and not to any more-derived traversal tag type.
-
-
-template<typename System, typename Traversal, typename ValueParam, typename Reference>
-  struct iterator_facade_default_category;
-
-
-// Thrust's implementation of iterator_facade_default_category is slightly
-// different from Boost's equivalent.
-// Thrust does not check is_convertible<Reference, ValueParam> because Reference
-// may not be a complete type at this point, and implementations of is_convertible
-// typically require that both types be complete.
-// Instead, it simply assumes that if is_convertible<Traversal, single_pass_traversal_tag>,
-// then the category is input_iterator_tag
-
-
-// this is the function for standard system iterators
-template<typename Traversal, typename ValueParam, typename Reference>
-  struct iterator_facade_default_category_std :
-    thrust::detail::eval_if<
-      thrust::detail::is_convertible<Traversal, thrust::forward_traversal_tag>::value,
-      thrust::detail::eval_if<
-        thrust::detail::is_convertible<Traversal, thrust::random_access_traversal_tag>::value,
-        thrust::detail::identity_<std::random_access_iterator_tag>,
-        thrust::detail::eval_if<
-          thrust::detail::is_convertible<Traversal, thrust::bidirectional_traversal_tag>::value,
-          thrust::detail::identity_<std::bidirectional_iterator_tag>,
-          thrust::detail::identity_<std::forward_iterator_tag>
-        >
-      >,
-      thrust::detail::eval_if< // XXX note we differ from Boost here
-        thrust::detail::is_convertible<Traversal, thrust::single_pass_traversal_tag>::value,
-        thrust::detail::identity_<std::input_iterator_tag>,
-        thrust::detail::identity_<Traversal>
-      >
-    >
-{
-}; // end iterator_facade_default_category_std
-
-
-// this is the function for host system iterators
-template<typename Traversal, typename ValueParam, typename Reference>
-  struct iterator_facade_default_category_host :
-    thrust::detail::eval_if<
-      thrust::detail::is_convertible<Traversal, thrust::forward_traversal_tag>::value,
-      thrust::detail::eval_if<
-        thrust::detail::is_convertible<Traversal, thrust::random_access_traversal_tag>::value,
-        thrust::detail::identity_<thrust::random_access_host_iterator_tag>,
-        thrust::detail::eval_if<
-          thrust::detail::is_convertible<Traversal, thrust::bidirectional_traversal_tag>::value,
-          thrust::detail::identity_<thrust::bidirectional_host_iterator_tag>,
-          thrust::detail::identity_<thrust::forward_host_iterator_tag>
-        >
-      >,
-      thrust::detail::eval_if< // XXX note we differ from Boost here
-        thrust::detail::is_convertible<Traversal, thrust::single_pass_traversal_tag>::value,
-        thrust::detail::identity_<thrust::input_host_iterator_tag>,
-        thrust::detail::identity_<Traversal>
-      >
-    >
-{
-}; // end iterator_facade_default_category_host
-
-
-// this is the function for device system iterators
-template<typename Traversal, typename ValueParam, typename Reference>
-  struct iterator_facade_default_category_device :
-    thrust::detail::eval_if<
-      thrust::detail::is_convertible<Traversal, thrust::forward_traversal_tag>::value,
-      thrust::detail::eval_if<
-        thrust::detail::is_convertible<Traversal, thrust::random_access_traversal_tag>::value,
-        thrust::detail::identity_<thrust::random_access_device_iterator_tag>,
-        thrust::detail::eval_if<
-          thrust::detail::is_convertible<Traversal, thrust::bidirectional_traversal_tag>::value,
-          thrust::detail::identity_<thrust::bidirectional_device_iterator_tag>,
-          thrust::detail::identity_<thrust::forward_device_iterator_tag>
-        >
-      >,
-      thrust::detail::eval_if<
-        thrust::detail::is_convertible<Traversal, thrust::single_pass_traversal_tag>::value, // XXX note we differ from Boost here
-        thrust::detail::identity_<thrust::input_device_iterator_tag>,
-        thrust::detail::identity_<Traversal>
-      >
-    >
-{
-}; // end iterator_facade_default_category_device
-
-
-// this is the function for any system iterators
-template<typename Traversal, typename ValueParam, typename Reference>
-  struct iterator_facade_default_category_any
-{
-  typedef thrust::detail::iterator_category_with_system_and_traversal<
-    typename iterator_facade_default_category_std<Traversal, ValueParam, Reference>::type,
-    thrust::any_system_tag,
-    Traversal
-  > type;
-}; // end iterator_facade_default_category_any
-
-
-template<typename System, typename Traversal, typename ValueParam, typename Reference>
-  struct iterator_facade_default_category
-      // check for any system
-    : thrust::detail::eval_if<
-        thrust::detail::is_convertible<System, thrust::any_system_tag>::value,
-        iterator_facade_default_category_any<Traversal, ValueParam, Reference>,
-
-        // check for host system
-        thrust::detail::eval_if<
-          thrust::detail::is_convertible<System, thrust::host_system_tag>::value,
-          iterator_facade_default_category_host<Traversal, ValueParam, Reference>,
-
-          // check for device system
-          thrust::detail::eval_if<
-            thrust::detail::is_convertible<System, thrust::device_system_tag>::value,
-            iterator_facade_default_category_device<Traversal, ValueParam, Reference>,
-
-            // if we don't recognize the system, get a standard iterator category
-            // and combine it with System & Traversal
-            thrust::detail::identity_<
-              thrust::detail::iterator_category_with_system_and_traversal<
-                typename iterator_facade_default_category_std<Traversal, ValueParam, Reference>::type,
-                System,
-                Traversal
-              >
-            >
-          >
-        >
-      >
-{};
-
-
-template<typename System, typename Traversal, typename ValueParam, typename Reference>
-  struct iterator_facade_category_impl
-{
-  typedef typename iterator_facade_default_category<
-    System,Traversal,ValueParam,Reference
-  >::type category;
-
-  // we must be able to deduce both Traversal & System from category
-  // otherwise, munge them all together
-  typedef typename thrust::detail::eval_if<
-    thrust::detail::and_<
-      thrust::detail::is_same<
-        Traversal,
-        typename thrust::detail::iterator_category_to_traversal<category>::type
-      >,
-      thrust::detail::is_same<
-        System,
-        typename thrust::detail::iterator_category_to_system<category>::type
-      >
-    >::value,
-    thrust::detail::identity_<category>,
-    thrust::detail::identity_<thrust::detail::iterator_category_with_system_and_traversal<category,System,Traversal> >
-  >::type type;
-}; // end iterator_facade_category_impl
-
-
-template<typename CategoryOrSystem,
-         typename CategoryOrTraversal,
-         typename ValueParam,
-         typename Reference>
-  struct iterator_facade_category
-{
-  typedef typename
-  thrust::detail::eval_if<
-    thrust::detail::is_iterator_category<CategoryOrTraversal>::value,
-    thrust::detail::identity_<CategoryOrTraversal>, // categories are fine as-is
-    iterator_facade_category_impl<CategoryOrSystem, CategoryOrTraversal, ValueParam, Reference>
-  >::type type;
-}; // end iterator_facade_category
-
-
-} // end detail
-} // end thrust
-

spaces/CVPR/WALT/mmdet/models/necks/channel_mapper.py

@@ -1,74 +0,0 @@
-import torch.nn as nn
-from mmcv.cnn import ConvModule, xavier_init
-
-from ..builder import NECKS
-
-
-@NECKS.register_module()
-class ChannelMapper(nn.Module):
-    r"""Channel Mapper to reduce/increase channels of backbone features.
-
-    This is used to reduce/increase channels of backbone features.
-
-    Args:
-        in_channels (List[int]): Number of input channels per scale.
-        out_channels (int): Number of output channels (used at each scale).
-        kernel_size (int, optional): kernel_size for reducing channels (used
-            at each scale). Default: 3.
-        conv_cfg (dict, optional): Config dict for convolution layer.
-            Default: None.
-        norm_cfg (dict, optional): Config dict for normalization layer.
-            Default: None.
-        act_cfg (dict, optional): Config dict for activation layer in
-            ConvModule. Default: dict(type='ReLU').
-
-    Example:
-        >>> import torch
-        >>> in_channels = [2, 3, 5, 7]
-        >>> scales = [340, 170, 84, 43]
-        >>> inputs = [torch.rand(1, c, s, s)
-        ...           for c, s in zip(in_channels, scales)]
-        >>> self = ChannelMapper(in_channels, 11, 3).eval()
-        >>> outputs = self.forward(inputs)
-        >>> for i in range(len(outputs)):
-        ...     print(f'outputs[{i}].shape = {outputs[i].shape}')
-        outputs[0].shape = torch.Size([1, 11, 340, 340])
-        outputs[1].shape = torch.Size([1, 11, 170, 170])
-        outputs[2].shape = torch.Size([1, 11, 84, 84])
-        outputs[3].shape = torch.Size([1, 11, 43, 43])
-    """
-
-    def __init__(self,
-                 in_channels,
-                 out_channels,
-                 kernel_size=3,
-                 conv_cfg=None,
-                 norm_cfg=None,
-                 act_cfg=dict(type='ReLU')):
-        super(ChannelMapper, self).__init__()
-        assert isinstance(in_channels, list)
-
-        self.convs = nn.ModuleList()
-        for in_channel in in_channels:
-            self.convs.append(
-                ConvModule(
-                    in_channel,
-                    out_channels,
-                    kernel_size,
-                    padding=(kernel_size - 1) // 2,
-                    conv_cfg=conv_cfg,
-                    norm_cfg=norm_cfg,
-                    act_cfg=act_cfg))
-
-    # default init_weights for conv(msra) and norm in ConvModule
-    def init_weights(self):
-        """Initialize the weights of ChannelMapper module."""
-        for m in self.modules():
-            if isinstance(m, nn.Conv2d):
-                xavier_init(m, distribution='uniform')
-
-    def forward(self, inputs):
-        """Forward function."""
-        assert len(inputs) == len(self.convs)
-        outs = [self.convs[i](inputs[i]) for i in range(len(inputs))]
-        return tuple(outs)

spaces/CVPR/regionclip-demo/datasets/README.md

@@ -1,140 +0,0 @@
-# Use Builtin Datasets
-
-A dataset can be used by accessing [DatasetCatalog](https://detectron2.readthedocs.io/modules/data.html#detectron2.data.DatasetCatalog)
-for its data, or [MetadataCatalog](https://detectron2.readthedocs.io/modules/data.html#detectron2.data.MetadataCatalog) for its metadata (class names, etc).
-This document explains how to setup the builtin datasets so they can be used by the above APIs.
-[Use Custom Datasets](https://detectron2.readthedocs.io/tutorials/datasets.html) gives a deeper dive on how to use `DatasetCatalog` and `MetadataCatalog`,
-and how to add new datasets to them.
-
-Detectron2 has builtin support for a few datasets.
-The datasets are assumed to exist in a directory specified by the environment variable
-`DETECTRON2_DATASETS`.
-Under this directory, detectron2 will look for datasets in the structure described below, if needed.
-```
-$DETECTRON2_DATASETS/
-  coco/
-  lvis/
-  cityscapes/
-  VOC20{07,12}/
-```
-
-You can set the location for builtin datasets by `export DETECTRON2_DATASETS=/path/to/datasets`.
-If left unset, the default is `./datasets` relative to your current working directory.
-
-The [model zoo](https://github.com/facebookresearch/detectron2/blob/master/MODEL_ZOO.md)
-contains configs and models that use these builtin datasets.
-
-## Expected dataset structure for [COCO instance/keypoint detection](https://cocodataset.org/#download):
-
-```
-coco/
-  annotations/
-    instances_{train,val}2017.json
-    person_keypoints_{train,val}2017.json
-  {train,val}2017/
-    # image files that are mentioned in the corresponding json
-```
-
-You can use the 2014 version of the dataset as well.
-
-Some of the builtin tests (`dev/run_*_tests.sh`) uses a tiny version of the COCO dataset,
-which you can download with `./datasets/prepare_for_tests.sh`.
-
-## Expected dataset structure for PanopticFPN:
-
-Extract panoptic annotations from [COCO website](https://cocodataset.org/#download)
-into the following structure:
-```
-coco/
-  annotations/
-    panoptic_{train,val}2017.json
-  panoptic_{train,val}2017/  # png annotations
-  panoptic_stuff_{train,val}2017/  # generated by the script mentioned below
-```
-
-Install panopticapi by:
-```
-pip install git+https://github.com/cocodataset/panopticapi.git
-```
-Then, run `python datasets/prepare_panoptic_fpn.py`, to extract semantic annotations from panoptic annotations.
-
-## Expected dataset structure for [LVIS instance segmentation](https://www.lvisdataset.org/dataset):
-```
-coco/
-  {train,val,test}2017/
-lvis/
-  lvis_v0.5_{train,val}.json
-  lvis_v0.5_image_info_test.json
-  lvis_v1_{train,val}.json
-  lvis_v1_image_info_test{,_challenge}.json
-```
-
-Install lvis-api by:
-```
-pip install git+https://github.com/lvis-dataset/lvis-api.git
-```
-
-To evaluate models trained on the COCO dataset using LVIS annotations,
-run `python datasets/prepare_cocofied_lvis.py` to prepare "cocofied" LVIS annotations.
-
-## Expected dataset structure for [cityscapes](https://www.cityscapes-dataset.com/downloads/):
-```
-cityscapes/
-  gtFine/
-    train/
-      aachen/
-        color.png, instanceIds.png, labelIds.png, polygons.json,
-        labelTrainIds.png
-      ...
-    val/
-    test/
-    # below are generated Cityscapes panoptic annotation
-    cityscapes_panoptic_train.json
-    cityscapes_panoptic_train/
-    cityscapes_panoptic_val.json
-    cityscapes_panoptic_val/
-    cityscapes_panoptic_test.json
-    cityscapes_panoptic_test/
-  leftImg8bit/
-    train/
-    val/
-    test/
-```
-Install cityscapes scripts by:
-```
-pip install git+https://github.com/mcordts/cityscapesScripts.git
-```
-
-Note: to create labelTrainIds.png, first prepare the above structure, then run cityscapesescript with:
-```
-CITYSCAPES_DATASET=/path/to/abovementioned/cityscapes python cityscapesscripts/preparation/createTrainIdLabelImgs.py
-```
-These files are not needed for instance segmentation.
-
-Note: to generate Cityscapes panoptic dataset, run cityscapesescript with:
-```
-CITYSCAPES_DATASET=/path/to/abovementioned/cityscapes python cityscapesscripts/preparation/createPanopticImgs.py
-```
-These files are not needed for semantic and instance segmentation.
-
-## Expected dataset structure for [Pascal VOC](http://host.robots.ox.ac.uk/pascal/VOC/index.html):
-```
-VOC20{07,12}/
-  Annotations/
-  ImageSets/
-    Main/
-      trainval.txt
-      test.txt
-      # train.txt or val.txt, if you use these splits
-  JPEGImages/
-```
-
-## Expected dataset structure for [ADE20k Scene Parsing](http://sceneparsing.csail.mit.edu/):
-```
-ADEChallengeData2016/
-  annotations/
-  annotations_detectron2/
-  images/
-  objectInfo150.txt
-```
-The directory `annotations_detectron2` is generated by running `python datasets/prepare_ade20k_sem_seg.py`.

spaces/CarlDennis/HYTTS/text/ger_to_ipa.py

@@ -1,397 +0,0 @@
-# -*- coding: utf-8 -*-
-import re
-from os.path import join, abspath, dirname
-from collections import defaultdict
-import epitran
-
-epi = epitran.Epitran("deu-Latn-nar")
-
-
-def mode_type(mode_in):
-    """In the case of "sql", this will return an sqlite cursor."""
-    if mode_in.lower() == "sql":
-        import sqlite3
-        conn = sqlite3.connect(join(abspath(dirname(__file__)), "./Resources/de.db"))
-        return conn.cursor()
-
-
-#TESTS
-#NUMBERS ARE TOO HARD!
-
-
-
-def preprocess(words):
-    """Returns a string of words stripped of punctuation"""
-    punct_str = '!"#$%&\'()*+,-./:;<=>/?@[\\]^_`{|}~«» '
-    return ' '.join([w.strip(punct_str).lower() for w in words.split()])
-
-
-def preserve_punc(words):
-    """converts words to IPA and finds punctuation before and after the word."""
-    words_preserved = []
-    for w in words.split():
-        punct_list = ["", preprocess(w), ""]
-        before = re.search("^([^A-Za-z0-9]+)[A-Za-z]", w)
-        after = re.search("[A-Za-z]([^A-Za-z0-9]+)$", w)
-        if before:
-            punct_list[0] = str(before.group(1))
-        if after:
-            punct_list[2] = str(after.group(1))
-        words_preserved.append(punct_list)
-    return words_preserved
-
-
-
-def apply_punct(triple, as_str=False):
-    """places surrounding punctuation back on center on a list of preserve_punc triples"""
-    if type(triple[0]) == list:
-        for i, t in enumerate(triple):
-            triple[i] = str(''.join(triple[i]))
-        if as_str:
-            return ' '.join(triple)
-        return triple
-    if as_str:
-        return str(''.join(t for t in triple))
-    return [''.join(t for t in triple)]
-
-
-def _punct_replace_word(original, transcription):
-    """Get the IPA transcription of word with the original punctuation marks"""
-    for i, trans_list in enumerate(transcription):
-        for j, item in enumerate(trans_list):
-            triple = [original[i][0]] + [item] + [original[i][2]]
-            transcription[i][j] = apply_punct(triple, as_str=True)
-    return transcription
-
-
-def fetch_words(words_in, db_type="sql"):
-    """fetches a list of words from the database"""
-    asset = mode_type(db_type)
-    f_result = []
-    if db_type.lower() == "sql":
-        for word in words_in:
-            asset.execute("SELECT Words, phonemes FROM De_words WHERE Words IN (?)", (word,))
-            result = asset.fetchall()
-            flag = True
-            try:
-                f_result.append(result.pop())
-                flag = False
-            except IndexError:
-                pass
-            if result == [] and flag is True:
-                result = epi.transliterate(word)
-                f_result.append((word, result))
-        f_result = list(filter(None,f_result))
-        f_set = set(f_result)
-        d = defaultdict(list)
-        for k, v in f_set:
-            d[k].append(v)
-        return list(d.items())
-
-def get_deu(tokens_in, db_type="sql"):
-    """query the SQL database for the words and return the phonemes in the order of user_in"""
-    result = fetch_words(tokens_in, db_type)
-    ordered = []
-    for word in tokens_in:
-        this_word = [[i[1] for i in result if i[0] == word]][0]
-        if this_word:
-            ordered.append(this_word[0])
-        else:
-            ordered.append(["__IGNORE__" + word])
-    return ordered
-
-
-def deu_to_ipa(deu_list, mark=True):
-    """converts the deu word lists into IPA transcriptions"""
-    symbols = {}
-    ipa_list = []  # the final list of IPA tokens to be returned
-    for word_list in deu_list:
-        ipa_word_list = []  # the word list for each word
-        for word in word_list:
-            if re.sub("\d*", "", word.replace("__IGNORE__", "")) == "":
-                    pass  # do not delete token if it's all numbers
-            else:
-                    word = re.sub("[0-9]", "", word)
-            ipa_form = ''
-            if word.startswith("__IGNORE__"):
-                ipa_form = word.replace("__IGNORE__", "")
-                # mark words we couldn't transliterate with an asterisk:
-
-                if mark:
-                    if not re.sub("\d*", "", ipa_form) == "":
-                        ipa_form += "*"
-            else:
-                for piece in word.split(" "):
-                    marked = False
-                    unmarked = piece
-                    if piece[0] in ["ˈ", "ˌ"] or piece[0] is None:
-                        marked = True
-                        mark = piece
-                        unmarked = piece[1:]
-
-                    if unmarked in symbols:
-                        if marked:
-                            ipa_form += mark + symbols[unmarked]
-                        else:
-                            ipa_form += symbols[unmarked]
-
-                    else:
-                        ipa_form += piece
-            swap_list = [["ˈər", "əˈr"], ["ˈie", "iˈe"]]
-            for sym in swap_list:
-                if not ipa_form.startswith(sym[0]):
-                    ipa_form = ipa_form.replace(sym[0], sym[1])
-            ipa_word_list.append(ipa_form)
-        ipa_list.append(sorted(list(set(ipa_word_list))))
-    return ipa_list
-
-
-def get_top(ipa_list):
-    """Returns only the one result for a query. If multiple entries for words are found, only the first is used."""
-    return ' '.join([word_list[-1] for word_list in ipa_list])
-
-
-def get_all(ipa_list):
-    """utilizes an algorithm to discover and return all possible combinations of IPA transcriptions"""
-    final_size = 1
-    for word_list in ipa_list:
-        final_size *= len(word_list)
-    list_all = ["" for s in range(final_size)]
-    for i in range(len(ipa_list)):
-        if i == 0:
-            swtich_rate = final_size / len(ipa_list[i])
-        else:
-            swtich_rate /= len(ipa_list[i])
-        k = 0
-        for j in range(final_size):
-            if (j+1) % int(swtich_rate) == 0:
-                k += 1
-            if k == len(ipa_list[i]):
-                k = 0
-            list_all[j] = list_all[j] + ipa_list[i][k] + " "
-    return sorted([sent[:-1] for sent in list_all])
-
-
-def ipa_list(words_in, keep_punct=True, db_type="sql"):
-    """Returns a list of all the discovered IPA transcriptions for each word."""
-    if type(words_in) == str:
-        words = [preserve_punc(w.lower())[0] for w in words_in.split()]
-    else:
-        words = [preserve_punc(w.lower())[0] for w in words_in]
-    deu = get_deu([w[1] for w in words], db_type=db_type)
-    ipa = deu_to_ipa(deu)
-    if keep_punct:
-        ipa = _punct_replace_word(words, ipa)
-    return ipa
-
-
-def isin_deu(word, db_type="sql"):
-    """checks if a word is in the deu dictionary. Doesn't strip punctuation.
-    If given more than one word, returns True only if all words are present."""
-    if type(word) == str:
-        word = [preprocess(w) for w in word.split()]
-    results = fetch_words(word, db_type)
-    as_set = list(set(t[0] for t in results))
-    return len(as_set) == len(set(word))
-
-def replace_number(text):
-    text = text.replace("1","eins ")
-    text = text.replace("2","zwei ")
-    text = text.replace("3","drei ")
-    text = text.replace("4","vier ")
-    text = text.replace("5","fünf ")
-    text = text.replace("6","sechs ")
-    text = text.replace("7","sieben ")
-    text = text.replace("8","acht ")
-    text = text.replace("9","neun ")
-    text = text.replace("0","null ")
-    return text
-
-
-
-def convert(text, retrieve_all=False, keep_punct=True, mode="sql"):
-    """takes either a string or list of German words and converts them to IPA"""
-    text = replace_number(text)
-    ipa = ipa_list(
-                   words_in=text,
-                   keep_punct=keep_punct,
-                   db_type=mode)
-    if retrieve_all:
-        return get_all(ipa)
-    return get_top(ipa)
-
-
-
-_decimal_number_re = re.compile(r'\d+\,\d+')
-_euros_pre = re.compile(r'€([0-9\,]*[0-9]+)')
-_euros_re = re.compile(r'([0-9\,]*[0-9]+)€')
-_ordinal_re = re.compile(r'(der |die |das )([0-9]+)\.')
-_clock_re=re.compile(r'\d{1,2}\:\d{2}')
-_number_re = re.compile(r'[0-9]+')
-
-def base(text):
-    text = text.replace("1", "eins ")
-    text = text.replace("2", "zwei ")
-    text = text.replace("3", "drei ")
-    text = text.replace("4", "vier ")
-    text = text.replace("5", "fünf ")
-    text = text.replace("6", "sechs ")
-    text = text.replace("7", "sieben ")
-    text = text.replace("8", "acht ")
-    text = text.replace("9", "neun ")
-    text = text.replace("0", "null ")
-    return text
-
-def tens_to_word(num):
-    tens = num[0]
-    ones = num[1]
-    ones_word = base(ones)
-
-    if num =="10":
-        return "zehn"
-    elif num=="11":
-        return "elf"
-    elif num=="12":
-        return "zwölf"
-
-    if tens == "1":
-        if ones == "6":
-            ones_word = ones_word[:-1]
-        elif ones == "7":
-            ones_word = ones_word[:-2]
-        return ones_word + "zehn"
-    else:
-        tens_word = base(tens)
-        if ones == "1":
-            ones_word = ones_word[:-1]
-        if tens == "2":
-            tens_word = "zwan"
-        elif tens == "6":
-            tens_word = tens_word[:-1]
-        elif tens == "7":
-            tens_word = tens_word[:-2]
-        if tens == "3":
-            tens_word += "ßig"
-        else:
-            tens_word += "zig"
-        if ones == "0":
-            return tens_word
-        else:
-            return ones_word + " und " + tens_word
-
-def huns_to_word(num):
-    huns = num[0]
-    tens = num[1]
-
-    if huns == "1":
-        huns_word= "hundert"
-    else:
-        huns_word = base(huns)+" hundert"
-
-    remain = num_to_word(num[1:])
-    if remain != "":
-        remain = " " + remain
-    return huns_word + remain
-
-def thos_to_word(num):
-    thos = num[0]
-    if thos == "1":
-        thos_word= "tausend"
-    else:
-        thos_word = base(thos)+" tausend"
-    remain=num_to_word(num[1:])
-    if remain!="":
-        remain=" "+remain
-    return thos_word+remain
-
-def num_to_word(num):
-    num=num.lstrip("0")
-    if num=="":
-        return("")
-    digit=len(num)
-    if digit==1:
-        return base(num)
-    elif digit==2:
-        return tens_to_word(num)
-    elif digit == 3:
-        return huns_to_word(num)
-    elif digit == 4:
-        return thos_to_word(num)
-    else:
-        return base(num)
-
-def number_to_words(m):
-    m=m.group(0).lstrip("0")
-    if m=="":
-        return"null"
-    return num_to_word(m)
-
-def _expand_ordinal(m):
-
-    pre=m.group(1)
-    m = m.group(2).lstrip("0")
-
-    if m=="":
-        return"NULL"
-    num=int(m)
-    if num<=19 & num>=1:
-        if num ==1:
-            return "erste"
-        elif num==3:
-            return "dritte"
-        elif num==7:
-            return "siebte"
-        elif num==8:
-            return "achte"
-        else:
-            return pre + num_to_word(m) + "te"
-    else:
-        return pre + num_to_word(m) + "ste"
-
-def _expand_decimal(m):
-    match=m.group(0)
-    parts = match.split(',')
-    if int(parts[0])==0:
-        return '%s komma %s' % ("null", base(parts[1]))
-    return '%s komma %s' % (num_to_word(parts[0]),base(parts[1]))
-
-def _expand_euros(m):
-    match = m.group(1)
-    parts = match.split(',')
-    if len(parts) > 2:
-        return match + ' euro'  # Unexpected format
-    euros = int(parts[0]) if parts[0] else 0
-    cents = int(parts[1])*10 if len(parts) > 1 and parts[1] else 0
-    if euros and cents:
-        return '%s euro %s' % (euros, cents)
-    elif euros:
-        return '%s euro' % (euros)
-    elif cents:
-        return '%s cent' % (cents)
-    else:
-        return 'null euro'
-
-def _expand_clock(m):
-    match = m.group(0)
-    parts = match.split(':')
-    if int(parts[0]) == 0:
-        return '%s Uhr %s' % ("null",num_to_word(parts[1]))
-    elif int(parts[0]) == 1:
-        return '%s Uhr %s' % ("ein", num_to_word(parts[1]))
-    return '%s Uhr %s' % (num_to_word(parts[0]),num_to_word(parts[1]))
-
-def normalize_numbers(text):
-    text = re.sub(_euros_pre, _expand_euros, text)
-    text = re.sub(_euros_re, _expand_euros, text)
-    text = re.sub(_clock_re, _expand_clock, text)
-    text = re.sub(_decimal_number_re, _expand_decimal, text)
-    text = re.sub(_ordinal_re, _expand_ordinal, text)
-    text = re.sub(_number_re, number_to_words, text)
-    text=text.replace("  "," ")
-    return text
-
-def collapse_whitespace(text):
-    return re.sub(r'\s+', ' ', text)
-
-def mark_dark_l(text):
-    return re.sub(r'l([^aeiouæɑɔəɛɪʊ ]*(?: |$))', lambda x: 'ɫ'+x.group(1), text)

spaces/ChrisCaviar/ControlNet-v1-1/app_normal.py

@@ -1,104 +0,0 @@
-#!/usr/bin/env python
-
-import gradio as gr
-
-from utils import randomize_seed_fn
-
-
-def create_demo(process, max_images=12, default_num_images=3):
-    with gr.Blocks() as demo:
-        with gr.Row():
-            with gr.Column():
-                image = gr.Image()
-                prompt = gr.Textbox(label='Prompt')
-                run_button = gr.Button('Run')
-                with gr.Accordion('Advanced options', open=False):
-                    preprocessor_name = gr.Radio(label='Preprocessor',
-                                                 choices=['NormalBae', 'None'],
-                                                 type='value',
-                                                 value='NormalBae')
-                    num_samples = gr.Slider(label='Images',
-                                            minimum=1,
-                                            maximum=max_images,
-                                            value=default_num_images,
-                                            step=1)
-                    image_resolution = gr.Slider(label='Image resolution',
-                                                 minimum=256,
-                                                 maximum=512,
-                                                 value=512,
-                                                 step=256)
-                    preprocess_resolution = gr.Slider(
-                        label='Preprocess resolution',
-                        minimum=128,
-                        maximum=512,
-                        value=384,
-                        step=1)
-                    num_steps = gr.Slider(label='Number of steps',
-                                          minimum=1,
-                                          maximum=100,
-                                          value=20,
-                                          step=1)
-                    guidance_scale = gr.Slider(label='Guidance scale',
-                                               minimum=0.1,
-                                               maximum=30.0,
-                                               value=9.0,
-                                               step=0.1)
-                    seed = gr.Slider(label='Seed',
-                                     minimum=0,
-                                     maximum=1000000,
-                                     step=1,
-                                     value=0,
-                                     randomize=True)
-                    randomize_seed = gr.Checkbox(label='Randomize seed',
-                                                 value=True)
-                    a_prompt = gr.Textbox(
-                        label='Additional prompt',
-                        value='best quality, extremely detailed')
-                    n_prompt = gr.Textbox(
-                        label='Negative prompt',
-                        value=
-                        'longbody, lowres, bad anatomy, bad hands, missing fingers, extra digit, fewer digits, cropped, worst quality, low quality'
-                    )
-            with gr.Column():
-                result = gr.Gallery(label='Output', show_label=False).style(
-                    columns=2, object_fit='scale-down')
-        inputs = [
-            image,
-            prompt,
-            a_prompt,
-            n_prompt,
-            num_samples,
-            image_resolution,
-            preprocess_resolution,
-            num_steps,
-            guidance_scale,
-            seed,
-            preprocessor_name,
-        ]
-        prompt.submit(
-            fn=randomize_seed_fn,
-            inputs=[seed, randomize_seed],
-            outputs=seed,
-        ).then(
-            fn=process,
-            inputs=inputs,
-            outputs=result,
-        )
-        run_button.click(
-            fn=randomize_seed_fn,
-            inputs=[seed, randomize_seed],
-            outputs=seed,
-        ).then(
-            fn=process,
-            inputs=inputs,
-            outputs=result,
-            api_name='normal',
-        )
-    return demo
-
-
-if __name__ == '__main__':
-    from model import Model
-    model = Model(task_name='NormalBae')
-    demo = create_demo(model.process_normal)
-    demo.queue().launch()

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

@@ -1,28 +0,0 @@
-from pathlib import Path
-from typing import List
-
-from PIL.Image import Image as IMG
-from pil_utils import BuildImage
-
-from meme_generator import add_meme
-from meme_generator.utils import save_gif
-
-img_dir = Path(__file__).parent / "images"
-
-
-def knock(images: List[BuildImage], texts, args):
-    img = images[0].convert("RGBA").square()
-    # fmt: off
-    locs = [(60, 308, 210, 195), (60, 308, 210, 198), (45, 330, 250, 172), (58, 320, 218, 180),
-            (60, 310, 215, 193), (40, 320, 250, 285), (48, 308, 226, 192), (51, 301, 223, 200)]
-    # fmt: on
-    frames: List[IMG] = []
-    for i in range(8):
-        frame = BuildImage.open(img_dir / f"{i}.png")
-        x, y, w, h = locs[i]
-        frame.paste(img.resize((w, h)), (x, y), below=True)
-        frames.append(frame.image)
-    return save_gif(frames, 0.04)
-
-
-add_meme("knock", knock, min_images=1, max_images=1, keywords=["敲"])

spaces/Clebersla/RVC_V2_Huggingface_Version/i18n.py

@@ -1,28 +0,0 @@
-import locale
-import json
-import os
-
-
-def load_language_list(language):
-    with open(f"./i18n/{language}.json", "r", encoding="utf-8") as f:
-        language_list = json.load(f)
-    return language_list
-
-
-class I18nAuto:
-    def __init__(self, language=None):
-        if language in ["Auto", None]:
-            language = locale.getdefaultlocale()[
-                0
-            ]  # getlocale can't identify the system's language ((None, None))
-        if not os.path.exists(f"./i18n/{language}.json"):
-            language = "en_US"
-        self.language = language
-        # print("Use Language:", language)
-        self.language_map = load_language_list(language)
-
-    def __call__(self, key):
-        return self.language_map.get(key, key)
-
-    def print(self):
-        print("Use Language:", self.language)

spaces/Codecooker/rvcapi/src/mdx.py

@@ -1,287 +0,0 @@
-import gc
-import hashlib
-import os
-import queue
-import threading
-import warnings
-
-import librosa
-import numpy as np
-import onnxruntime as ort
-import soundfile as sf
-import torch
-from tqdm import tqdm
-
-warnings.filterwarnings("ignore")
-stem_naming = {'Vocals': 'Instrumental', 'Other': 'Instruments', 'Instrumental': 'Vocals', 'Drums': 'Drumless', 'Bass': 'Bassless'}
-
-
-class MDXModel:
-    def __init__(self, device, dim_f, dim_t, n_fft, hop=1024, stem_name=None, compensation=1.000):
-        self.dim_f = dim_f
-        self.dim_t = dim_t
-        self.dim_c = 4
-        self.n_fft = n_fft
-        self.hop = hop
-        self.stem_name = stem_name
-        self.compensation = compensation
-
-        self.n_bins = self.n_fft // 2 + 1
-        self.chunk_size = hop * (self.dim_t - 1)
-        self.window = torch.hann_window(window_length=self.n_fft, periodic=True).to(device)
-
-        out_c = self.dim_c
-
-        self.freq_pad = torch.zeros([1, out_c, self.n_bins - self.dim_f, self.dim_t]).to(device)
-
-    def stft(self, x):
-        x = x.reshape([-1, self.chunk_size])
-        x = torch.stft(x, n_fft=self.n_fft, hop_length=self.hop, window=self.window, center=True, return_complex=True)
-        x = torch.view_as_real(x)
-        x = x.permute([0, 3, 1, 2])
-        x = x.reshape([-1, 2, 2, self.n_bins, self.dim_t]).reshape([-1, 4, self.n_bins, self.dim_t])
-        return x[:, :, :self.dim_f]
-
-    def istft(self, x, freq_pad=None):
-        freq_pad = self.freq_pad.repeat([x.shape[0], 1, 1, 1]) if freq_pad is None else freq_pad
-        x = torch.cat([x, freq_pad], -2)
-        # c = 4*2 if self.target_name=='*' else 2
-        x = x.reshape([-1, 2, 2, self.n_bins, self.dim_t]).reshape([-1, 2, self.n_bins, self.dim_t])
-        x = x.permute([0, 2, 3, 1])
-        x = x.contiguous()
-        x = torch.view_as_complex(x)
-        x = torch.istft(x, n_fft=self.n_fft, hop_length=self.hop, window=self.window, center=True)
-        return x.reshape([-1, 2, self.chunk_size])
-
-
-class MDX:
-    DEFAULT_SR = 44100
-    # Unit: seconds
-    DEFAULT_CHUNK_SIZE = 0 * DEFAULT_SR
-    DEFAULT_MARGIN_SIZE = 1 * DEFAULT_SR
-
-    DEFAULT_PROCESSOR = 0
-
-    def __init__(self, model_path: str, params: MDXModel, processor=DEFAULT_PROCESSOR):
-
-        # Set the device and the provider (CPU or CUDA)
-        self.device = torch.device(f'cuda:{processor}') if processor >= 0 else torch.device('cpu')
-        self.provider = ['CUDAExecutionProvider'] if processor >= 0 else ['CPUExecutionProvider']
-
-        self.model = params
-
-        # Load the ONNX model using ONNX Runtime
-        self.ort = ort.InferenceSession(model_path, providers=self.provider)
-        # Preload the model for faster performance
-        self.ort.run(None, {'input': torch.rand(1, 4, params.dim_f, params.dim_t).numpy()})
-        self.process = lambda spec: self.ort.run(None, {'input': spec.cpu().numpy()})[0]
-
-        self.prog = None
-
-    @staticmethod
-    def get_hash(model_path):
-        try:
-            with open(model_path, 'rb') as f:
-                f.seek(- 10000 * 1024, 2)
-                model_hash = hashlib.md5(f.read()).hexdigest()
-        except:
-            model_hash = hashlib.md5(open(model_path, 'rb').read()).hexdigest()
-
-        return model_hash
-
-    @staticmethod
-    def segment(wave, combine=True, chunk_size=DEFAULT_CHUNK_SIZE, margin_size=DEFAULT_MARGIN_SIZE):
-        """
-        Segment or join segmented wave array
-
-        Args:
-            wave: (np.array) Wave array to be segmented or joined
-            combine: (bool) If True, combines segmented wave array. If False, segments wave array.
-            chunk_size: (int) Size of each segment (in samples)
-            margin_size: (int) Size of margin between segments (in samples)
-
-        Returns:
-            numpy array: Segmented or joined wave array
-        """
-
-        if combine:
-            processed_wave = None  # Initializing as None instead of [] for later numpy array concatenation
-            for segment_count, segment in enumerate(wave):
-                start = 0 if segment_count == 0 else margin_size
-                end = None if segment_count == len(wave) - 1 else -margin_size
-                if margin_size == 0:
-                    end = None
-                if processed_wave is None:  # Create array for first segment
-                    processed_wave = segment[:, start:end]
-                else:  # Concatenate to existing array for subsequent segments
-                    processed_wave = np.concatenate((processed_wave, segment[:, start:end]), axis=-1)
-
-        else:
-            processed_wave = []
-            sample_count = wave.shape[-1]
-
-            if chunk_size <= 0 or chunk_size > sample_count:
-                chunk_size = sample_count
-
-            if margin_size > chunk_size:
-                margin_size = chunk_size
-
-            for segment_count, skip in enumerate(range(0, sample_count, chunk_size)):
-
-                margin = 0 if segment_count == 0 else margin_size
-                end = min(skip + chunk_size + margin_size, sample_count)
-                start = skip - margin
-
-                cut = wave[:, start:end].copy()
-                processed_wave.append(cut)
-
-                if end == sample_count:
-                    break
-
-        return processed_wave
-
-    def pad_wave(self, wave):
-        """
-        Pad the wave array to match the required chunk size
-
-        Args:
-            wave: (np.array) Wave array to be padded
-
-        Returns:
-            tuple: (padded_wave, pad, trim)
-                - padded_wave: Padded wave array
-                - pad: Number of samples that were padded
-                - trim: Number of samples that were trimmed
-        """
-        n_sample = wave.shape[1]
-        trim = self.model.n_fft // 2
-        gen_size = self.model.chunk_size - 2 * trim
-        pad = gen_size - n_sample % gen_size
-
-        # Padded wave
-        wave_p = np.concatenate((np.zeros((2, trim)), wave, np.zeros((2, pad)), np.zeros((2, trim))), 1)
-
-        mix_waves = []
-        for i in range(0, n_sample + pad, gen_size):
-            waves = np.array(wave_p[:, i:i + self.model.chunk_size])
-            mix_waves.append(waves)
-
-        mix_waves = torch.tensor(mix_waves, dtype=torch.float32).to(self.device)
-
-        return mix_waves, pad, trim
-
-    def _process_wave(self, mix_waves, trim, pad, q: queue.Queue, _id: int):
-        """
-        Process each wave segment in a multi-threaded environment
-
-        Args:
-            mix_waves: (torch.Tensor) Wave segments to be processed
-            trim: (int) Number of samples trimmed during padding
-            pad: (int) Number of samples padded during padding
-            q: (queue.Queue) Queue to hold the processed wave segments
-            _id: (int) Identifier of the processed wave segment
-
-        Returns:
-            numpy array: Processed wave segment
-        """
-        mix_waves = mix_waves.split(1)
-        with torch.no_grad():
-            pw = []
-            for mix_wave in mix_waves:
-                self.prog.update()
-                spec = self.model.stft(mix_wave)
-                processed_spec = torch.tensor(self.process(spec))
-                processed_wav = self.model.istft(processed_spec.to(self.device))
-                processed_wav = processed_wav[:, :, trim:-trim].transpose(0, 1).reshape(2, -1).cpu().numpy()
-                pw.append(processed_wav)
-        processed_signal = np.concatenate(pw, axis=-1)[:, :-pad]
-        q.put({_id: processed_signal})
-        return processed_signal
-
-    def process_wave(self, wave: np.array, mt_threads=1):
-        """
-        Process the wave array in a multi-threaded environment
-
-        Args:
-            wave: (np.array) Wave array to be processed
-            mt_threads: (int) Number of threads to be used for processing
-
-        Returns:
-            numpy array: Processed wave array
-        """
-        self.prog = tqdm(total=0)
-        chunk = wave.shape[-1] // mt_threads
-        waves = self.segment(wave, False, chunk)
-
-        # Create a queue to hold the processed wave segments
-        q = queue.Queue()
-        threads = []
-        for c, batch in enumerate(waves):
-            mix_waves, pad, trim = self.pad_wave(batch)
-            self.prog.total = len(mix_waves) * mt_threads
-            thread = threading.Thread(target=self._process_wave, args=(mix_waves, trim, pad, q, c))
-            thread.start()
-            threads.append(thread)
-        for thread in threads:
-            thread.join()
-        self.prog.close()
-
-        processed_batches = []
-        while not q.empty():
-            processed_batches.append(q.get())
-        processed_batches = [list(wave.values())[0] for wave in
-                             sorted(processed_batches, key=lambda d: list(d.keys())[0])]
-        assert len(processed_batches) == len(waves), 'Incomplete processed batches, please reduce batch size!'
-        return self.segment(processed_batches, True, chunk)
-
-
-def run_mdx(model_params, output_dir, model_path, filename, exclude_main=False, exclude_inversion=False, suffix=None, invert_suffix=None, denoise=False, keep_orig=True, m_threads=2):
-    device = torch.device('cuda:0') if torch.cuda.is_available() else torch.device('cpu')
-
-    device_properties = torch.cuda.get_device_properties(device)
-    vram_gb = device_properties.total_memory / 1024**3
-    m_threads = 1 if vram_gb < 8 else 2
-
-    model_hash = MDX.get_hash(model_path)
-    mp = model_params.get(model_hash)
-    model = MDXModel(
-        device,
-        dim_f=mp["mdx_dim_f_set"],
-        dim_t=2 ** mp["mdx_dim_t_set"],
-        n_fft=mp["mdx_n_fft_scale_set"],
-        stem_name=mp["primary_stem"],
-        compensation=mp["compensate"]
-    )
-
-    mdx_sess = MDX(model_path, model)
-    wave, sr = librosa.load(filename, mono=False, sr=44100)
-    # normalizing input wave gives better output
-    peak = max(np.max(wave), abs(np.min(wave)))
-    wave /= peak
-    if denoise:
-        wave_processed = -(mdx_sess.process_wave(-wave, m_threads)) + (mdx_sess.process_wave(wave, m_threads))
-        wave_processed *= 0.5
-    else:
-        wave_processed = mdx_sess.process_wave(wave, m_threads)
-    # return to previous peak
-    wave_processed *= peak
-    stem_name = model.stem_name if suffix is None else suffix
-
-    main_filepath = None
-    if not exclude_main:
-        main_filepath = os.path.join(output_dir, f"{os.path.basename(os.path.splitext(filename)[0])}_{stem_name}.wav")
-        sf.write(main_filepath, wave_processed.T, sr)
-
-    invert_filepath = None
-    if not exclude_inversion:
-        diff_stem_name = stem_naming.get(stem_name) if invert_suffix is None else invert_suffix
-        stem_name = f"{stem_name}_diff" if diff_stem_name is None else diff_stem_name
-        invert_filepath = os.path.join(output_dir, f"{os.path.basename(os.path.splitext(filename)[0])}_{stem_name}.wav")
-        sf.write(invert_filepath, (-wave_processed.T * model.compensation) + wave.T, sr)
-
-    if not keep_orig:
-        os.remove(filename)
-
-    del mdx_sess, wave_processed, wave
-    gc.collect()
-    return main_filepath, invert_filepath

spaces/Cvandi/remake/scripts/generate_meta_info_pairdata.py

@@ -1,49 +0,0 @@
-import argparse
-import glob
-import os
-
-
-def main(args):
-    txt_file = open(args.meta_info, 'w')
-    # sca images
-    img_paths_gt = sorted(glob.glob(os.path.join(args.input[0], '*')))
-    img_paths_lq = sorted(glob.glob(os.path.join(args.input[1], '*')))
-
-    assert len(img_paths_gt) == len(img_paths_lq), ('GT folder and LQ folder should have the same length, but got '
-                                                    f'{len(img_paths_gt)} and {len(img_paths_lq)}.')
-
-    for img_path_gt, img_path_lq in zip(img_paths_gt, img_paths_lq):
-        # get the relative paths
-        img_name_gt = os.path.relpath(img_path_gt, args.root[0])
-        img_name_lq = os.path.relpath(img_path_lq, args.root[1])
-        print(f'{img_name_gt}, {img_name_lq}')
-        txt_file.write(f'{img_name_gt}, {img_name_lq}\n')
-
-
-if __name__ == '__main__':
-    """This script is used to generate meta info (txt file) for paired images.
-    """
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        '--input',
-        nargs='+',
-        default=['datasets/DF2K/DIV2K_train_HR_sub', 'datasets/DF2K/DIV2K_train_LR_bicubic_X4_sub'],
-        help='Input folder, should be [gt_folder, lq_folder]')
-    parser.add_argument('--root', nargs='+', default=[None, None], help='Folder root, will use the ')
-    parser.add_argument(
-        '--meta_info',
-        type=str,
-        default='datasets/DF2K/meta_info/meta_info_DIV2K_sub_pair.txt',
-        help='txt path for meta info')
-    args = parser.parse_args()
-
-    assert len(args.input) == 2, 'Input folder should have two elements: gt folder and lq folder'
-    assert len(args.root) == 2, 'Root path should have two elements: root for gt folder and lq folder'
-    os.makedirs(os.path.dirname(args.meta_info), exist_ok=True)
-    for i in range(2):
-        if args.input[i].endswith('/'):
-            args.input[i] = args.input[i][:-1]
-        if args.root[i] is None:
-            args.root[i] = os.path.dirname(args.input[i])
-
-    main(args)

spaces/DEVINKofficial/Onodofthenorth-SD_PixelArt_SpriteSheet_Generator/app.py

@@ -1,3 +0,0 @@
-import gradio as gr
-
-gr.Interface.load("models/Onodofthenorth/SD_PixelArt_SpriteSheet_Generator").launch()

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/PIL/GdImageFile.py

@@ -1,97 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# GD file handling
-#
-# History:
-# 1996-04-12 fl   Created
-#
-# Copyright (c) 1997 by Secret Labs AB.
-# Copyright (c) 1996 by Fredrik Lundh.
-#
-# See the README file for information on usage and redistribution.
-#
-
-
-"""
-.. note::
-    This format cannot be automatically recognized, so the
-    class is not registered for use with :py:func:`PIL.Image.open()`.  To open a
-    gd file, use the :py:func:`PIL.GdImageFile.open()` function instead.
-
-.. warning::
-    THE GD FORMAT IS NOT DESIGNED FOR DATA INTERCHANGE.  This
-    implementation is provided for convenience and demonstrational
-    purposes only.
-"""
-
-
-from . import ImageFile, ImagePalette, UnidentifiedImageError
-from ._binary import i16be as i16
-from ._binary import i32be as i32
-
-
-class GdImageFile(ImageFile.ImageFile):
-    """
-    Image plugin for the GD uncompressed format.  Note that this format
-    is not supported by the standard :py:func:`PIL.Image.open()` function.  To use
-    this plugin, you have to import the :py:mod:`PIL.GdImageFile` module and
-    use the :py:func:`PIL.GdImageFile.open()` function.
-    """
-
-    format = "GD"
-    format_description = "GD uncompressed images"
-
-    def _open(self):
-        # Header
-        s = self.fp.read(1037)
-
-        if i16(s) not in [65534, 65535]:
-            msg = "Not a valid GD 2.x .gd file"
-            raise SyntaxError(msg)
-
-        self.mode = "L"  # FIXME: "P"
-        self._size = i16(s, 2), i16(s, 4)
-
-        true_color = s[6]
-        true_color_offset = 2 if true_color else 0
-
-        # transparency index
-        tindex = i32(s, 7 + true_color_offset)
-        if tindex < 256:
-            self.info["transparency"] = tindex
-
-        self.palette = ImagePalette.raw(
-            "XBGR", s[7 + true_color_offset + 4 : 7 + true_color_offset + 4 + 256 * 4]
-        )
-
-        self.tile = [
-            (
-                "raw",
-                (0, 0) + self.size,
-                7 + true_color_offset + 4 + 256 * 4,
-                ("L", 0, 1),
-            )
-        ]
-
-
-def open(fp, mode="r"):
-    """
-    Load texture from a GD image file.
-
-    :param fp: GD file name, or an opened file handle.
-    :param mode: Optional mode.  In this version, if the mode argument
-        is given, it must be "r".
-    :returns: An image instance.
-    :raises OSError: If the image could not be read.
-    """
-    if mode != "r":
-        msg = "bad mode"
-        raise ValueError(msg)
-
-    try:
-        return GdImageFile(fp)
-    except SyntaxError as e:
-        msg = "cannot identify this image file"
-        raise UnidentifiedImageError(msg) from e

spaces/Dana19/ImageRecognition_FaceCount/README.md

@@ -1,13 +0,0 @@
----
-title: Headcount
-emoji: 💻
-colorFrom: green
-colorTo: indigo
-sdk: gradio
-sdk_version: 3.3
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/DemoLou/moe-tts/text/thai.py

@@ -1,44 +0,0 @@
-import re
-from num_thai.thainumbers import NumThai
-
-
-num = NumThai()
-
-# List of (Latin alphabet, Thai) pairs:
-_latin_to_thai = [(re.compile('%s' % x[0], re.IGNORECASE), x[1]) for x in [
-    ('a', 'เอ'),
-    ('b','บี'),
-    ('c','ซี'),
-    ('d','ดี'),
-    ('e','อี'),
-    ('f','เอฟ'),
-    ('g','จี'),
-    ('h','เอช'),
-    ('i','ไอ'),
-    ('j','เจ'),
-    ('k','เค'),
-    ('l','แอล'),
-    ('m','เอ็ม'),
-    ('n','เอ็น'),
-    ('o','โอ'),
-    ('p','พี'),
-    ('q','คิว'),
-    ('r','แอร์'),
-    ('s','เอส'),
-    ('t','ที'),
-    ('u','ยู'),
-    ('v','วี'),
-    ('w','ดับเบิลยู'),
-    ('x','เอ็กซ์'),
-    ('y','วาย'),
-    ('z','ซี')
-]]
-
-
-def num_to_thai(text):
-    return re.sub(r'(?:\d+(?:,?\d+)?)+(?:\.\d+(?:,?\d+)?)?', lambda x: ''.join(num.NumberToTextThai(float(x.group(0).replace(',', '')))), text)
-
-def latin_to_thai(text):
-    for regex, replacement in _latin_to_thai:
-        text = re.sub(regex, replacement, text)
-    return text