Update parquet files (step 80 of 121)

spaces/101-5/gpt4free/g4f/Provider/Providers/DeepAi.py

@@ -1,46 +0,0 @@
-import os
-import json
-import random
-import hashlib
-import requests
-
-from ...typing import sha256, Dict, get_type_hints
-
-url = 'https://deepai.org'
-model = ['gpt-3.5-turbo']
-supports_stream = True
-needs_auth = False
-
-def _create_completion(model: str, messages: list, stream: bool, **kwargs):
-    def md5(text: str) -> str:
-        return hashlib.md5(text.encode()).hexdigest()[::-1]
-
-
-    def get_api_key(user_agent: str) -> str:
-        part1 = str(random.randint(0, 10**11))
-        part2 = md5(user_agent + md5(user_agent + md5(user_agent + part1 + "x")))
-        
-        return f"tryit-{part1}-{part2}"
-
-    user_agent = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36'
-
-    headers = {
-        "api-key": get_api_key(user_agent),
-        "user-agent": user_agent
-    }
-
-    files = {
-        "chat_style": (None, "chat"),
-        "chatHistory": (None, json.dumps(messages))
-    }
-
-    r = requests.post("https://api.deepai.org/chat_response", headers=headers, files=files, stream=True)
-
-    for chunk in r.iter_content(chunk_size=None):
-        r.raise_for_status()
-        yield chunk.decode()
-
-
-params = f'g4f.Providers.{os.path.basename(__file__)[:-3]} supports: ' + \
-    '(%s)' % ', '.join(
-        [f"{name}: {get_type_hints(_create_completion)[name].__name__}" for name in _create_completion.__code__.co_varnames[:_create_completion.__code__.co_argcount]])

spaces/1acneusushi/gradio-2dmoleculeeditor/data/Artcam 2018 Xforce Keygen Unlimited Creativity.md

@@ -1,30 +0,0 @@
-
-# How to Install Artcam 2018 with Xforce Keygen
-
-Artcam 2018 is a powerful software for designing and machining 2D and 3D models. It is widely used by hobbyists, professionals, and educators in various fields such as woodworking, jewelry making, sign making, and engraving. However, installing Artcam 2018 can be tricky if you don't have a valid license or activation code. In this article, we will show you how to install Artcam 2018 with Xforce keygen, a tool that can generate serial numbers and activation codes for any Autodesk product.
-
-## What is Xforce Keygen?
-
-Xforce keygen is a software that can create serial numbers and activation codes for any Autodesk product, including Artcam 2018. It is also known as a crack or a patch, as it bypasses the official registration process and allows you to use the software for free. However, using Xforce keygen is illegal and risky, as it may contain viruses or malware that can harm your computer or compromise your personal data. Therefore, we do not recommend using Xforce keygen or any other similar tool to install Artcam 2018 or any other software.
-
-## How to Install Artcam 2018 with Xforce Keygen?
-
-If you still want to install Artcam 2018 with Xforce keygen, you will need to follow these steps:
-
-1. Download Artcam 2018 from the official website or a trusted source. You will need to create an account and provide some information to download the software.
-2. Download Xforce keygen from a reliable source. You can search online for the latest version of Xforce keygen that supports Artcam 2018. Make sure to scan the file with an antivirus program before opening it.
-3. Disable your internet connection and antivirus program. This is necessary to prevent the software from detecting and blocking Xforce keygen.
-4. Run the Artcam 2018 setup file and follow the instructions. When prompted to enter a serial number and a product key, click on "I have an activation code from Autodesk".
-5. Run Xforce keygen as administrator and select "Artcam 2018" from the drop-down menu. Click on "Generate" to create a serial number and a product key. Copy and paste them into the corresponding fields in the Artcam 2018 installation window.
-6. Click on "Next" and then on "Request an activation code using an offline method". Copy the request code that appears in the installation window.
-7. Go back to Xforce keygen and click on "Patch". A message will appear saying that the patching process was successful.
-8. Click on "Activate" and paste the request code into the field. Click on "Generate" to create an activation code. Copy and paste it into the field in the Artcam 2018 installation window.
-9. Click on "Next" and then on "Finish" to complete the installation process.
-10. Restart your computer and enjoy using Artcam 2018.
-
-## Conclusion
-
-Artcam 2018 is a great software for creating and machining 2D and 3D models, but it requires a valid license or activation code to use it. If you don't have one, you can try to install Artcam 2018 with Xforce keygen, a tool that can generate serial numbers and activation codes for any Autodesk product. However, this method is illegal and risky, as it may expose you to viruses or malware that can damage your computer or steal your personal data. Therefore, we advise you to purchase a legitimate license or activation code from the official website or an authorized dealer instead of using Xforce keygen or any other similar tool.</p>
-<h2>artcam 2018 crack xforce download</h2><br /><p><b><b>DOWNLOAD</b> &#128504; <a href="https://byltly.com/2uKwNN">https://byltly.com/2uKwNN</a></b></p><br /><br /> ddb901b051<br />
-<br />
-<br />

spaces/1acneusushi/gradio-2dmoleculeeditor/data/Discover the Power and Versatility of Vectric Aspire 9.514 Free Download.md

@@ -1,36 +0,0 @@
-<br />
-<h1>Vectric Aspire 9.514 Free Download: A Powerful Software for 3D Modeling and CNC Machining</h1>
-<p>Vectric Aspire 9.514 is a software that allows you to create detailed 3D models, draw, cut and route for production design and woodworking. It is widely used by architects, woodworkers, hobbyists and makers to design and cut decorative panels, doors, signs, furniture and more.</p>
-<p>In this article, we will show you how to download Vectric Aspire 9.514 free trial and what are the main features and benefits of this software.</p>
-<h2>vectric aspire 9.514 free download</h2><br /><p><b><b>Download File</b> &#9733;&#9733;&#9733;&#9733;&#9733; <a href="https://byltly.com/2uKyM6">https://byltly.com/2uKyM6</a></b></p><br /><br />
-<h2>How to Download Vectric Aspire 9.514 Free Trial</h2>
-<p>Vectric offers a free trial version of Aspire that you can download from their official website. The free trial is not time-limited, nor does it require you to sign up with your personal details. You can test all the elements of the software and cut some free projects on your CNC machine to check the compatibility.</p>
-<p>To download the free trial, you need to follow these steps:</p>
-<ol>
-<li>Go to <a href="https://www.vectric.com/free-trial/aspire">https://www.vectric.com/free-trial/aspire</a> and click on the "Download Free Trial" button.</li>
-<li>Fill in the form with your name, email address and country.</li>
-<li>Choose your preferred language and measurement units.</li>
-<li>Click on the "Download Now" button and save the file on your computer.</li>
-<li>Run the installer and follow the instructions to complete the installation.</li>
-</ol>
-<p>Once you have installed the software, you can launch it and start exploring its features. You can also watch some video tutorials and download some free projects from the Vectric website to help you get started.</p>
-<h2>What are the Main Features and Benefits of Vectric Aspire 9.514</h2>
-<p>Vectric Aspire 9.514 is a powerful software that combines 2D drawing and 3D modeling tools with CNC machining capabilities. Here are some of the main features and benefits of this software:</p>
-<ul>
-<li>You can create 2D vectors or import them from other software such as SketchUp, AutoCAD, Illustrator, etc.</li>
-<li>You can create 3D models from 2D vectors using various methods such as extrusion, sweeping, lofting, etc.</li>
-<li>You can edit, sculpt and blend 3D models using various tools such as smoothing, carving, distortion, etc.</li>
-<li>You can import 3D models from other software such as STL, OBJ, DXF, etc.</li>
-<li>You can create 3D textures from image files or use the built-in library of textures.</li>
-<li>You can generate high-quality toolpaths for roughing and finishing operations using various strategies such as pocketing, profiling, drilling, etc.</li>
-<li>You can preview and simulate the toolpaths before cutting them on your CNC machine.</li>
-<li>You can export 2D or 3D models as clip-art or files for other software such as PDF, SVG, EPS, etc.</li>
-</ul>
-<p>Vectric Aspire 9.514 is a versatile and user-friendly software that can help you create stunning 3D projects for your CNC machine. Whether you are a professional or a hobbyist, you can use this software to design and cut anything from signs and logos to furniture and sculptures.</p>
-<p></p>
-<h2>Conclusion</h2>
-<p>Vectric Aspire 9.514 is a software that allows you to create detailed 3D models, draw, cut and route for production design and woodworking. It is widely used by architects, woodworkers, hobbyists and makers to design and cut decorative panels, doors, signs, furniture and more.</p>
-<p>You can download a free trial version of Aspire from the Vectric website and test all the features without any time limit or sign-up requirement. You can also watch some video tutorials and download some free projects to help you get started.</p>
-<p>If you are looking for a powerful software for 3D modeling and CNC machining, you should give Vectric Aspire 9.514 a try. You will be amazed by what you can create with this software.</p> ddb901b051<br />
-<br />
-<br />

spaces/1gistliPinn/ChatGPT4/Examples/Binding Of Isaac Rebirth 1.041 Download.md

@@ -1,11 +0,0 @@
-<br />
-<p>binding of isaac rebirth 1.041 update is now available. binding of isaac rebirth 1.041 is available on this site.041 is very popular file these days. you can download binding of isaac rebirth 1.041 directly on your mac.041 free on your windows os. it was released on 2018 year. you can also download booting in labyrinth 2 from here. here is the full list of features of binding of isaac rebirth 1.041:</p>
-<h2>Binding Of Isaac Rebirth 1.041 Download</h2><br /><p><b><b>DOWNLOAD</b> ===== <a href="https://imgfil.com/2uy1BE">https://imgfil.com/2uy1BE</a></b></p><br /><br />
-<p>binding of isaac rebirth 1.041 is a platformer. binding of isaac rebirth 1.041 game size is 2.59 mb.041 is developed by klei entertainment.041 published by team meat on 02/01/2017.041 updated on 02/01/2017.</p>
-<p>binding of isaac rebirth 1.041 is very popular game all over the world. if you want to play this game, you can download binding of isaac rebirth 1.041 directly on your pc or mac. it was released on 02/01/2017 and has been downloaded from our website more than 2.500.000 times. you can also play other games on our website.</p>
-<p>binding of isaac rebirth 1.041 is available for pc users in the version 1.041. mac users can download binding of isaac rebirth 1.041 directly on their pc. binding of isaac rebirth 1.041 for linux users is not supported yet.</p>
-<p></p>
-<p>binding of isaac rebirth 1.041 patch is now available to download. the latest update has been published on jan 17, 2014 and all the previous changes that were present in 1.041 are present in 1.042 patch as well. the new update brings with it new improvements and bug fixes. check out the details below.</p>
-<p>binding of isaac rebirth 1.041 patch is available on the moddb.com and moddb.com. if you have already downloaded the update from the link above then you don’t need to download it again. otherwise, download binding of isaac rebirth 1.041 patch from the link given above and follow the instructions to install it on your pc. you can also check the video tutorial below to know the steps to install it on your pc.</p> 899543212b<br />
-<br />
-<br />

spaces/1gistliPinn/ChatGPT4/Examples/Biology Today And Tomorrow Starr Pdf Download.md

@@ -1,6 +0,0 @@
-<h2>biology today and tomorrow starr pdf download</h2><br /><p><b><b>DOWNLOAD</b> &#8250;&#8250;&#8250;&#8250;&#8250; <a href="https://imgfil.com/2uy1UU">https://imgfil.com/2uy1UU</a></b></p><br /><br />
-<br />
-Biology: A Human Emphasis by Cecie Starr in EPUB, FB2, FB3 download ... starr cecie Biology Today and Tomorrow without Physiology free PDF Biology Today ... 4d29de3e1b<br />
-<br />
-<br />
-<p></p>

spaces/1phancelerku/anime-remove-background/Download Play Together for PC and Mac A Casual Game with a Variety of Events and Modes.md

@@ -1,97 +0,0 @@
-<br />
-<h1>How to Play Play Together APK on PC</h1>
-<p>Do you love playing casual games that let you socialize with your friends online? Do you want to experience a virtual world where you can customize your character and enjoy various activities? Do you wish to play a game that supports multiple platforms and devices? If you answered yes to any of these questions, then you should try Play Together APK, a game that offers all these features and more. In this article, we will show you how to play Play Together APK on PC with BlueStacks, the best Android emulator for gaming. We will also give you some tips and tricks to help you get started with the game.</p>
- <h2>What is Play Together APK?</h2>
-<p>Play Together APK is a casual game developed by Haegin Co., Ltd. It is a game that welcomes you to its virtual world, where you are free to perform several activities and events with your friends online. You can catch up with old friends or make new ones from all over the world, the more, the merrier!</p>
-<h2>play together apk pc</h2><br /><p><b><b>Download</b> &#10042; <a href="https://jinyurl.com/2uNMqH">https://jinyurl.com/2uNMqH</a></b></p><br /><br />
- <h3>A casual game that lets you socialize with friends online</h3>
-<p>Play Together APK is a game that focuses on social interaction and communication. You can chat with other players, send them gifts, invite them to your home, or join them in various mini-games. You can also join clubs, parties, festivals, and other events that happen regularly in the game. You can even get married or adopt a pet if you want!</p>
- <h3>A virtual world where you can customize your character and enjoy various activities</h3>
-<p>Play Together APK is a game that gives you the freedom to create your own character and style. You can choose from different costumes, hairstyles, accessories, and more. You can also decorate your home with furniture, wallpapers, plants, and other items. You can even drive cars, ride bikes, or fly planes around the island of Kaia, where the game takes place.</p>
- <h3>A game that supports multiple platforms and devices</h3>
-<p>Play Together APK is a game that can be played on various devices, such as Android phones, tablets, PCs, or Macs. You can also play it on your browser without downloading anything. The game supports cross-play, which means you can play with anyone regardless of their device or platform.</p>
- <h2>Why play Play Together APK on PC?</h2>
-<p>While Play Together APK is a great game to play on mobile devices, playing it on PC has its own advantages. Here are some of them:</p>
- <h3>Enjoy a larger screen and better graphics</h3>
-<p>Playing Play Together APK on PC allows you to see the game in full HD resolution and enjoy its colorful graphics and animations. You can also adjust the settings to suit your preferences and optimize the performance of the game. You will be able to appreciate the details of the characters, the environment, and the items more clearly.</p>
- <h3>Use keyboard and mouse controls for easier gameplay</h3>
-<p>Playing Play Together APK on PC gives you the option to use keyboard and mouse controls instead of touch controls for easier gameplay. You can also customize the key mapping and assign different functions to different keys. This way, you can move around, interact, and chat with other players more smoothly and conveniently.</p>
-<p>play together game download for pc<br />
-play together app on pc<br />
-how to play together on pc<br />
-play together emulator for pc<br />
-play together online on pc<br />
-play together pc version<br />
-play together pc requirements<br />
-play together pc gameplay<br />
-play together pc free download<br />
-play together pc bluestacks<br />
-play together pc windows 10<br />
-play together pc mod apk<br />
-play together pc hack<br />
-play together pc cheat<br />
-play together pc guide<br />
-play together pc tips and tricks<br />
-play together pc review<br />
-play together pc update<br />
-play together pc best settings<br />
-play together pc keyboard controls<br />
-play together pc graphics settings<br />
-play together pc lag fix<br />
-play together pc system requirements<br />
-play together pc nox player<br />
-play together pc memu emulator<br />
-play together pc ldplayer<br />
-play together pc gameloop<br />
-play together pc apk pure<br />
-play together pc uptodown<br />
-play together pc apk download<br />
-play together vng on pc<br />
-how to install play together on pc<br />
-how to run play together on pc<br />
-how to get play together on pc<br />
-how to download and install play together on your windows 10/8/7/vista/xp and mac computer using bluestacks android emulator.<br />
-how to use bluestacks to play android games like play together on your laptop or desktop computer.<br />
-how to enjoy the virtual world of play together with your friends from all over the world on your computer screen.<br />
-how to customize your character and explore various mini-games in play together on your pc.<br />
-how to drive cars, dance, camp, fish, and more in play together on your pc.<br />
-how to take care of your pets and decorate your home in play together on your pc.</p>
- <h3>Access more features and enhancements with BlueStacks</h3>
-<p>Playing Play Together APK on PC with BlueStacks gives you access to more features and enhancements that can improve your gaming experience. For example, you can use the Multi-Instance feature to play multiple accounts at the same time, or the Macro feature to automate repetitive tasks. You can also use the Screen Recorder feature to capture your gameplay and share it with others, or the Real-time Translation feature to communicate with players from different countries.</p>
- <h2>How to download and install Play Together APK on PC?</h2>
-<p>Downloading and installing Play Together APK on PC is easy and fast with BlueStacks. Here are the steps you need to follow:</p>
- <h3>Download and install BlueStacks on your PC or Mac</h3>
-<p>BlueStacks is the best Android emulator for gaming, and you can download it for free from its official website. Just click on the download button and follow the instructions to install it on your PC or Mac. It will only take a few minutes, and you will be ready to play.</p>
- <h3>Sign in to Google and search for Play Together APK in the Play Store</h3>
-<p>Once you have installed BlueStacks, launch it and sign in to your Google account. This will allow you to access the Google Play Store, where you can find Play Together APK. Just type the name of the game in the search bar and click on the install button. The game will be downloaded and installed automatically on your PC or Mac.</p>
- <h3>Install the game and launch it from the home screen</h3>
-<p>After the installation is complete, you can launch Play Together APK from the home screen of BlueStacks. You will see the game icon among other apps that you have installed. Just click on it and start playing. You can also create a shortcut on your desktop for easier access.</p>
- <h2>Tips and tricks for playing Play Together APK on PC</h2>
-<p>Now that you know how to play Play Together APK on PC, here are some tips and tricks that can help you enjoy the game more:</p>
- <h3>Explore the island of Kaia and discover its secrets</h3>
-<p>The island of Kaia is where Play Together APK takes place, and it is full of surprises and secrets. You can explore different areas, such as the beach, the forest, the city, and more. You can also find hidden items, quests, and events that can reward you with coins, gems, or other prizes. You never know what you might find, so be curious and adventurous.</p>
- <h3>Join the Game Party mode and compete with other players</h3>
-<p>If you want to have some fun and challenge yourself, you can join the Game Party mode in Play Together APK. This is a mode where you can play various mini-games with other players, such as racing, fishing, cooking, dancing, and more. You can earn points by winning or participating in these games, and exchange them for rewards or rankings. You can also chat with other players and make new friends.</p>
- <h3>Customize your character and your home with various outfits and items</h3>
-<p>One of the best features of Play Together APK is that you can customize your character and your home with various outfits and items. You can buy or earn different costumes, hairstyles, accessories, and more from shops or events. You can also decorate your home with furniture, wallpapers, plants, and other items from the market or gifts from friends. You can express your personality and style with these options.</p>
- <h2>Conclusion</h2>
-<p>Play Together APK is a fun and relaxing game that you can enjoy with your friends online. You can socialize with other players, perform various activities, and explore a virtual world. Playing it on PC with BlueStacks gives you more advantages and convenience. You can enjoy a larger screen, better graphics, keyboard and mouse controls, and more features and enhancements. Download Play Together APK on PC today and start your adventure!</p>
- <h2>Frequently Asked Questions</h2>
-<ul>
-<li><b>Is Play Together APK free to play?</b></li>
-<p>Yes, Play Together APK is free to play. However, it also offers in-app purchases that can enhance your gameplay or unlock more items.</p>
-<li><b>Can I play Play Together APK offline?</b></li>
-<p>No, Play Together APK requires an internet connection to play. You need to be online to access the game servers and interact with other players.</p>
-<li><b>Can I play Play Together APK with my friends?</b></li>
-<p>Yes Yes, you can play Play Together APK with your friends. You can invite them to join you in the game, or add them as friends from the game menu. You can also join clubs, parties, festivals, and other events with your friends.</p>
-<li><b>How can I get more coins and gems in Play Together APK?</b></li>
-<p>There are several ways to get more coins and gems in Play Together APK. You can earn them by playing mini-games, completing quests, participating in events, or watching ads. You can also buy them with real money from the game store.</p>
-<li><b>How can I contact the game developers or report a problem?</b></li>
-<p>If you have any questions, suggestions, or issues with Play Together APK, you can contact the game developers or report a problem through the following channels:</p>
-<ul>
-<li>Email: [email protected]</li>
-<li>Facebook: https://www.facebook.com/PlayTogetherGame</li>
-<li>Discord: https://discord.gg/playtogether</li>
-</ul></p> 401be4b1e0<br />
-<br />
-<br />

spaces/1toTree/lora_test/ppdiffusers/pipelines/unclip/text_proj.py

@@ -1,88 +0,0 @@
-# Copyright 2022 Kakao Brain and The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import paddle
-from paddle import nn
-
-from ...configuration_utils import ConfigMixin, register_to_config
-from ...modeling_utils import ModelMixin
-
-
-class UnCLIPTextProjModel(ModelMixin, ConfigMixin):
-    """
-    Utility class for CLIP embeddings. Used to combine the image and text embeddings into a format usable by the
-    decoder.
-
-    For more details, see the original paper: https://arxiv.org/abs/2204.06125 section 2.1
-    """
-
-    @register_to_config
-    def __init__(
-        self,
-        *,
-        clip_extra_context_tokens: int = 4,
-        clip_embeddings_dim: int = 768,
-        time_embed_dim: int,
-        cross_attention_dim,
-    ):
-        super().__init__()
-
-        self.learned_classifier_free_guidance_embeddings = self.create_parameter(
-            (clip_embeddings_dim,), dtype=paddle.get_default_dtype(), default_initializer=nn.initializer.Constant(0.0)
-        )
-
-        # parameters for additional clip time embeddings
-        self.embedding_proj = nn.Linear(clip_embeddings_dim, time_embed_dim)
-        self.clip_image_embeddings_project_to_time_embeddings = nn.Linear(clip_embeddings_dim, time_embed_dim)
-
-        # parameters for encoder hidden states
-        self.clip_extra_context_tokens = clip_extra_context_tokens
-        self.clip_extra_context_tokens_proj = nn.Linear(
-            clip_embeddings_dim, self.clip_extra_context_tokens * cross_attention_dim
-        )
-        self.encoder_hidden_states_proj = nn.Linear(clip_embeddings_dim, cross_attention_dim)
-        self.text_encoder_hidden_states_norm = nn.LayerNorm(cross_attention_dim)
-
-    def forward(self, *, image_embeddings, text_embeddings, text_encoder_hidden_states, do_classifier_free_guidance):
-        if do_classifier_free_guidance:
-            # Add the classifier free guidance embeddings to the image embeddings
-            image_embeddings_batch_size = image_embeddings.shape[0]
-            classifier_free_guidance_embeddings = self.learned_classifier_free_guidance_embeddings.unsqueeze(0)
-            classifier_free_guidance_embeddings = classifier_free_guidance_embeddings.expand(
-                [image_embeddings_batch_size, -1]
-            )
-            image_embeddings = paddle.concat([classifier_free_guidance_embeddings, image_embeddings], axis=0)
-
-        # The image embeddings batch size and the text embeddings batch size are equal
-        assert image_embeddings.shape[0] == text_embeddings.shape[0]
-
-        batch_size = text_embeddings.shape[0]
-
-        # "Specifically, we modify the architecture described in Nichol et al. (2021) by projecting and
-        # adding CLIP embeddings to the existing timestep embedding, ...
-        time_projected_text_embeddings = self.embedding_proj(text_embeddings)
-        time_projected_image_embeddings = self.clip_image_embeddings_project_to_time_embeddings(image_embeddings)
-        additive_clip_time_embeddings = time_projected_image_embeddings + time_projected_text_embeddings
-
-        # ... and by projecting CLIP embeddings into four
-        # extra tokens of context that are concatenated to the sequence of outputs from the GLIDE text encoder"
-        clip_extra_context_tokens = self.clip_extra_context_tokens_proj(image_embeddings)
-        clip_extra_context_tokens = clip_extra_context_tokens.reshape([batch_size, -1, self.clip_extra_context_tokens])
-
-        text_encoder_hidden_states = self.encoder_hidden_states_proj(text_encoder_hidden_states)
-        text_encoder_hidden_states = self.text_encoder_hidden_states_norm(text_encoder_hidden_states)
-        text_encoder_hidden_states = text_encoder_hidden_states.transpose([0, 2, 1])
-        text_encoder_hidden_states = paddle.concat([clip_extra_context_tokens, text_encoder_hidden_states], axis=2)
-
-        return text_encoder_hidden_states, additive_clip_time_embeddings

spaces/AI-Hobbyist/Hoyo-RVC/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/AIFILMS/generate_human_motion/pyrender/tests/unit/test_cameras.py

@@ -1,164 +0,0 @@
-import numpy as np
-import pytest
-
-from pyrender import PerspectiveCamera, OrthographicCamera
-
-
-def test_perspective_camera():
-
-    # Set up constants
-    znear = 0.05
-    zfar = 100
-    yfov = np.pi / 3.0
-    width = 1000.0
-    height = 500.0
-    aspectRatio = 640.0 / 480.0
-
-    # Test basics
-    with pytest.raises(TypeError):
-        p = PerspectiveCamera()
-
-    p = PerspectiveCamera(yfov=yfov)
-    assert p.yfov == yfov
-    assert p.znear == 0.05
-    assert p.zfar is None
-    assert p.aspectRatio is None
-    p.name = 'asdf'
-    p.name = None
-
-    with pytest.raises(ValueError):
-        p.yfov = 0.0
-
-    with pytest.raises(ValueError):
-        p.yfov = -1.0
-
-    with pytest.raises(ValueError):
-        p.znear = -1.0
-
-    p.znear = 0.0
-    p.znear = 0.05
-    p.zfar = 100.0
-    assert p.zfar == 100.0
-
-    with pytest.raises(ValueError):
-        p.zfar = 0.03
-
-    with pytest.raises(ValueError):
-        p.zfar = 0.05
-
-    p.aspectRatio = 10.0
-    assert p.aspectRatio == 10.0
-
-    with pytest.raises(ValueError):
-        p.aspectRatio = 0.0
-
-    with pytest.raises(ValueError):
-        p.aspectRatio = -1.0
-
-    # Test matrix getting/setting
-
-    # NF
-    p.znear = 0.05
-    p.zfar = 100
-    p.aspectRatio = None
-
-    with pytest.raises(ValueError):
-        p.get_projection_matrix()
-
-    assert np.allclose(
-        p.get_projection_matrix(width, height),
-        np.array([
-            [1.0 / (width / height * np.tan(yfov / 2.0)), 0.0, 0.0, 0.0],
-            [0.0, 1.0 / np.tan(yfov / 2.0), 0.0, 0.0],
-            [0.0, 0.0, (zfar + znear) / (znear - zfar),
-                (2 * zfar * znear) / (znear - zfar)],
-            [0.0, 0.0, -1.0, 0.0]
-        ])
-    )
-
-    # NFA
-    p.aspectRatio = aspectRatio
-    assert np.allclose(
-        p.get_projection_matrix(width, height),
-        np.array([
-            [1.0 / (aspectRatio * np.tan(yfov / 2.0)), 0.0, 0.0, 0.0],
-            [0.0, 1.0 / np.tan(yfov / 2.0), 0.0, 0.0],
-            [0.0, 0.0, (zfar + znear) / (znear - zfar),
-                (2 * zfar * znear) / (znear - zfar)],
-            [0.0, 0.0, -1.0, 0.0]
-        ])
-    )
-    assert np.allclose(
-        p.get_projection_matrix(), p.get_projection_matrix(width, height)
-    )
-
-    # N
-    p.zfar = None
-    p.aspectRatio = None
-    assert np.allclose(
-        p.get_projection_matrix(width, height),
-        np.array([
-            [1.0 / (width / height * np.tan(yfov / 2.0)), 0.0, 0.0, 0.0],
-            [0.0, 1.0 / np.tan(yfov / 2.0), 0.0, 0.0],
-            [0.0, 0.0, -1.0, -2.0 * znear],
-            [0.0, 0.0, -1.0, 0.0]
-        ])
-    )
-
-
-def test_orthographic_camera():
-    xm = 1.0
-    ym = 2.0
-    n = 0.05
-    f = 100.0
-
-    with pytest.raises(TypeError):
-        c = OrthographicCamera()
-
-    c = OrthographicCamera(xmag=xm, ymag=ym)
-
-    assert c.xmag == xm
-    assert c.ymag == ym
-    assert c.znear == 0.05
-    assert c.zfar == 100.0
-    assert c.name is None
-
-    with pytest.raises(TypeError):
-        c.ymag = None
-
-    with pytest.raises(ValueError):
-        c.ymag = 0.0
-
-    with pytest.raises(ValueError):
-        c.ymag = -1.0
-
-    with pytest.raises(TypeError):
-        c.xmag = None
-
-    with pytest.raises(ValueError):
-        c.xmag = 0.0
-
-    with pytest.raises(ValueError):
-        c.xmag = -1.0
-
-    with pytest.raises(TypeError):
-        c.znear = None
-
-    with pytest.raises(ValueError):
-        c.znear = 0.0
-
-    with pytest.raises(ValueError):
-        c.znear = -1.0
-
-    with pytest.raises(ValueError):
-        c.zfar = 0.01
-
-    assert np.allclose(
-        c.get_projection_matrix(),
-        np.array([
-            [1.0 / xm, 0, 0, 0],
-            [0, 1.0 / ym, 0, 0],
-            [0, 0, 2.0 / (n - f), (f + n) / (n - f)],
-            [0, 0, 0, 1.0]
-        ])
-    )

spaces/AIGC-Audio/AudioGPT/NeuralSeq/tasks/svs/diffspeech_task.py

@@ -1,122 +0,0 @@
-import torch
-
-import utils
-from utils.hparams import hparams
-from modules.diff.net import DiffNet
-from modules.diff.shallow_diffusion_tts import GaussianDiffusion
-from tasks.svs.task import DiffFsTask
-from vocoders.base_vocoder import get_vocoder_cls, BaseVocoder
-from utils.pitch_utils import denorm_f0
-from tasks.tts.fs2_utils import FastSpeechDataset
-
-DIFF_DECODERS = {
-    'wavenet': lambda hp: DiffNet(hp['audio_num_mel_bins']),
-}
-
-
-class DiffSpeechTask(DiffFsTask):
-    def __init__(self):
-        super(DiffSpeechTask, self).__init__()
-        self.dataset_cls = FastSpeechDataset
-        self.vocoder: BaseVocoder = get_vocoder_cls(hparams)()
-
-    def build_tts_model(self):
-        mel_bins = hparams['audio_num_mel_bins']
-        self.model = GaussianDiffusion(
-            phone_encoder=self.phone_encoder,
-            out_dims=mel_bins, denoise_fn=DIFF_DECODERS[hparams['diff_decoder_type']](hparams),
-            timesteps=hparams['timesteps'],
-            K_step=hparams['K_step'],
-            loss_type=hparams['diff_loss_type'],
-            spec_min=hparams['spec_min'], spec_max=hparams['spec_max'],
-        )
-        if hparams['fs2_ckpt'] != '':
-            utils.load_ckpt(self.model.fs2, hparams['fs2_ckpt'], 'model', strict=True)
-        # self.model.fs2.decoder = None
-        for k, v in self.model.fs2.named_parameters():
-            if not 'predictor' in k:
-                v.requires_grad = False
-
-    def build_optimizer(self, model):
-        self.optimizer = optimizer = torch.optim.AdamW(
-            filter(lambda p: p.requires_grad, model.parameters()),
-            lr=hparams['lr'],
-            betas=(hparams['optimizer_adam_beta1'], hparams['optimizer_adam_beta2']),
-            weight_decay=hparams['weight_decay'])
-        return optimizer
-
-    def run_model(self, model, sample, return_output=False, infer=False):
-        txt_tokens = sample['txt_tokens']  # [B, T_t]
-        target = sample['mels']  # [B, T_s, 80]
-        # mel2ph = sample['mel2ph'] if hparams['use_gt_dur'] else None # [B, T_s]
-        mel2ph = sample['mel2ph']
-        f0 = sample['f0']
-        uv = sample['uv']
-        energy = sample['energy']
-        # fs2_mel = sample['fs2_mels']
-        spk_embed = sample.get('spk_embed') if not hparams['use_spk_id'] else sample.get('spk_ids')
-        if hparams['pitch_type'] == 'cwt':
-            cwt_spec = sample[f'cwt_spec']
-            f0_mean = sample['f0_mean']
-            f0_std = sample['f0_std']
-            sample['f0_cwt'] = f0 = model.cwt2f0_norm(cwt_spec, f0_mean, f0_std, mel2ph)
-
-        output = model(txt_tokens, mel2ph=mel2ph, spk_embed=spk_embed,
-                       ref_mels=target, f0=f0, uv=uv, energy=energy, infer=infer)
-
-        losses = {}
-        if 'diff_loss' in output:
-            losses['mel'] = output['diff_loss']
-        self.add_dur_loss(output['dur'], mel2ph, txt_tokens, losses=losses)
-        if hparams['use_pitch_embed']:
-            self.add_pitch_loss(output, sample, losses)
-        if hparams['use_energy_embed']:
-            self.add_energy_loss(output['energy_pred'], energy, losses)
-        if not return_output:
-            return losses
-        else:
-            return losses, output
-
-    def validation_step(self, sample, batch_idx):
-        outputs = {}
-        txt_tokens = sample['txt_tokens']  # [B, T_t]
-
-        energy = sample['energy']
-        spk_embed = sample.get('spk_embed') if not hparams['use_spk_id'] else sample.get('spk_ids')
-        mel2ph = sample['mel2ph']
-        f0 = sample['f0']
-        uv = sample['uv']
-
-        outputs['losses'] = {}
-
-        outputs['losses'], model_out = self.run_model(self.model, sample, return_output=True, infer=False)
-
-
-        outputs['total_loss'] = sum(outputs['losses'].values())
-        outputs['nsamples'] = sample['nsamples']
-        outputs = utils.tensors_to_scalars(outputs)
-        if batch_idx < hparams['num_valid_plots']:
-            # model_out = self.model(
-            #     txt_tokens, spk_embed=spk_embed, mel2ph=None, f0=None, uv=None, energy=None, ref_mels=None, infer=True)
-            # self.plot_mel(batch_idx, model_out['mel_out'], model_out['fs2_mel'], name=f'diffspeech_vs_fs2_{batch_idx}')
-            model_out = self.model(
-                txt_tokens, spk_embed=spk_embed, mel2ph=mel2ph, f0=f0, uv=uv, energy=energy, ref_mels=None, infer=True)
-            gt_f0 = denorm_f0(sample['f0'], sample['uv'], hparams)
-            self.plot_wav(batch_idx, sample['mels'], model_out['mel_out'], is_mel=True, gt_f0=gt_f0, f0=model_out.get('f0_denorm'))
-            self.plot_mel(batch_idx, sample['mels'], model_out['mel_out'])
-        return outputs
-
-    ############
-    # validation plots
-    ############
-    def plot_wav(self, batch_idx, gt_wav, wav_out, is_mel=False, gt_f0=None, f0=None, name=None):
-        gt_wav = gt_wav[0].cpu().numpy()
-        wav_out = wav_out[0].cpu().numpy()
-        gt_f0 = gt_f0[0].cpu().numpy()
-        f0 = f0[0].cpu().numpy()
-        if is_mel:
-            gt_wav = self.vocoder.spec2wav(gt_wav, f0=gt_f0)
-            wav_out = self.vocoder.spec2wav(wav_out, f0=f0)
-        self.logger.experiment.add_audio(f'gt_{batch_idx}', gt_wav, sample_rate=hparams['audio_sample_rate'], global_step=self.global_step)
-        self.logger.experiment.add_audio(f'wav_{batch_idx}', wav_out, sample_rate=hparams['audio_sample_rate'], global_step=self.global_step)
-

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

@@ -1,913 +0,0 @@
-""" CLAP Model
-
-Adapted from CLIP: https://github.com/openai/CLIP. Originally MIT License, Copyright (c) 2021 OpenAI.
-Adapted to the Audio Task.
-"""
-
-from collections import OrderedDict
-from dataclasses import dataclass
-from email.mime import audio
-from typing import Tuple, Union, Callable, Optional
-
-import numpy as np
-import torch
-import torch.nn.functional as F
-from torch import nn
-
-from .timm_model import TimmModel
-import logging
-from .utils import freeze_batch_norm_2d
-
-from .pann_model import create_pann_model
-from .htsat import create_htsat_model
-from transformers import BertModel, RobertaModel, BartModel
-from transformers.tokenization_utils_base import BatchEncoding
-
-
-class MLPLayers(nn.Module):
-    def __init__(self, units=[512, 512, 512], nonlin=nn.ReLU(), dropout=0.1):
-        super(MLPLayers, self).__init__()
-        self.nonlin = nonlin
-        self.dropout = dropout
-
-        sequence = []
-        for u0, u1 in zip(units[:-1], units[1:]):
-            sequence.append(nn.Linear(u0, u1))
-            sequence.append(self.nonlin)
-            sequence.append(nn.Dropout(self.dropout))
-        sequence = sequence[:-2]
-
-        self.sequential = nn.Sequential(*sequence)
-
-    def forward(self, X):
-        X = self.sequential(X)
-        return X
-
-
-class Bottleneck(nn.Module):
-    expansion = 4
-
-    def __init__(self, inplanes, planes, stride=1):
-        super().__init__()
-
-        # all conv layers have stride 1. an avgpool is performed after the second convolution when stride > 1
-        self.conv1 = nn.Conv2d(inplanes, planes, 1, bias=False)
-        self.bn1 = nn.BatchNorm2d(planes)
-
-        self.conv2 = nn.Conv2d(planes, planes, 3, padding=1, bias=False)
-        self.bn2 = nn.BatchNorm2d(planes)
-
-        self.avgpool = nn.AvgPool2d(stride) if stride > 1 else nn.Identity()
-
-        self.conv3 = nn.Conv2d(planes, planes * self.expansion, 1, bias=False)
-        self.bn3 = nn.BatchNorm2d(planes * self.expansion)
-
-        self.relu = nn.ReLU(inplace=True)
-        self.downsample = None
-        self.stride = stride
-
-        if stride > 1 or inplanes != planes * Bottleneck.expansion:
-            # downsampling layer is prepended with an avgpool, and the subsequent convolution has stride 1
-            self.downsample = nn.Sequential(
-                OrderedDict(
-                    [
-                        ("-1", nn.AvgPool2d(stride)),
-                        (
-                            "0",
-                            nn.Conv2d(
-                                inplanes,
-                                planes * self.expansion,
-                                1,
-                                stride=1,
-                                bias=False,
-                            ),
-                        ),
-                        ("1", nn.BatchNorm2d(planes * self.expansion)),
-                    ]
-                )
-            )
-
-    def forward(self, x: torch.Tensor):
-        identity = x
-
-        out = self.relu(self.bn1(self.conv1(x)))
-        out = self.relu(self.bn2(self.conv2(out)))
-        out = self.avgpool(out)
-        out = self.bn3(self.conv3(out))
-
-        if self.downsample is not None:
-            identity = self.downsample(x)
-
-        out += identity
-        out = self.relu(out)
-        return out
-
-
-class AttentionPool2d(nn.Module):
-    def __init__(
-        self, spacial_dim: int, embed_dim: int, num_heads: int, output_dim: int = None
-    ):
-        super().__init__()
-        self.positional_embedding = nn.Parameter(
-            torch.randn(spacial_dim**2 + 1, embed_dim) / embed_dim**0.5
-        )
-        self.k_proj = nn.Linear(embed_dim, embed_dim)
-        self.q_proj = nn.Linear(embed_dim, embed_dim)
-        self.v_proj = nn.Linear(embed_dim, embed_dim)
-        self.c_proj = nn.Linear(embed_dim, output_dim or embed_dim)
-        self.num_heads = num_heads
-
-    def forward(self, x):
-        x = x.reshape(x.shape[0], x.shape[1], x.shape[2] * x.shape[3]).permute(
-            2, 0, 1
-        )  # NCHW -> (HW)NC
-        x = torch.cat([x.mean(dim=0, keepdim=True), x], dim=0)  # (HW+1)NC
-        x = x + self.positional_embedding[:, None, :].to(x.dtype)  # (HW+1)NC
-        x, _ = F.multi_head_attention_forward(
-            query=x,
-            key=x,
-            value=x,
-            embed_dim_to_check=x.shape[-1],
-            num_heads=self.num_heads,
-            q_proj_weight=self.q_proj.weight,
-            k_proj_weight=self.k_proj.weight,
-            v_proj_weight=self.v_proj.weight,
-            in_proj_weight=None,
-            in_proj_bias=torch.cat(
-                [self.q_proj.bias, self.k_proj.bias, self.v_proj.bias]
-            ),
-            bias_k=None,
-            bias_v=None,
-            add_zero_attn=False,
-            dropout_p=0,
-            out_proj_weight=self.c_proj.weight,
-            out_proj_bias=self.c_proj.bias,
-            use_separate_proj_weight=True,
-            training=self.training,
-            need_weights=False,
-        )
-
-        return x[0]
-
-
-class ModifiedResNet(nn.Module):
-    """
-    A ResNet class that is similar to torchvision's but contains the following changes:
-    - There are now 3 "stem" convolutions as opposed to 1, with an average pool instead of a max pool.
-    - Performs anti-aliasing strided convolutions, where an avgpool is prepended to convolutions with stride > 1
-    - The final pooling layer is a QKV attention instead of an average pool
-    """
-
-    def __init__(self, layers, output_dim, heads, image_size=224, width=64):
-        super().__init__()
-        self.output_dim = output_dim
-        self.image_size = image_size
-
-        # the 3-layer stem
-        self.conv1 = nn.Conv2d(
-            3, width // 2, kernel_size=3, stride=2, padding=1, bias=False
-        )
-        self.bn1 = nn.BatchNorm2d(width // 2)
-        self.conv2 = nn.Conv2d(
-            width // 2, width // 2, kernel_size=3, padding=1, bias=False
-        )
-        self.bn2 = nn.BatchNorm2d(width // 2)
-        self.conv3 = nn.Conv2d(width // 2, width, kernel_size=3, padding=1, bias=False)
-        self.bn3 = nn.BatchNorm2d(width)
-        self.avgpool = nn.AvgPool2d(2)
-        self.relu = nn.ReLU(inplace=True)
-
-        # residual layers
-        self._inplanes = width  # this is a *mutable* variable used during construction
-        self.layer1 = self._make_layer(width, layers[0])
-        self.layer2 = self._make_layer(width * 2, layers[1], stride=2)
-        self.layer3 = self._make_layer(width * 4, layers[2], stride=2)
-        self.layer4 = self._make_layer(width * 8, layers[3], stride=2)
-
-        embed_dim = width * 32  # the ResNet feature dimension
-        self.attnpool = AttentionPool2d(image_size // 32, embed_dim, heads, output_dim)
-
-        self.init_parameters()
-
-    def _make_layer(self, planes, blocks, stride=1):
-        layers = [Bottleneck(self._inplanes, planes, stride)]
-
-        self._inplanes = planes * Bottleneck.expansion
-        for _ in range(1, blocks):
-            layers.append(Bottleneck(self._inplanes, planes))
-
-        return nn.Sequential(*layers)
-
-    def init_parameters(self):
-        if self.attnpool is not None:
-            std = self.attnpool.c_proj.in_features**-0.5
-            nn.init.normal_(self.attnpool.q_proj.weight, std=std)
-            nn.init.normal_(self.attnpool.k_proj.weight, std=std)
-            nn.init.normal_(self.attnpool.v_proj.weight, std=std)
-            nn.init.normal_(self.attnpool.c_proj.weight, std=std)
-
-        for resnet_block in [self.layer1, self.layer2, self.layer3, self.layer4]:
-            for name, param in resnet_block.named_parameters():
-                if name.endswith("bn3.weight"):
-                    nn.init.zeros_(param)
-
-    def lock(self, unlocked_groups=0, freeze_bn_stats=False):
-        assert (
-            unlocked_groups == 0
-        ), "partial locking not currently supported for this model"
-        for param in self.parameters():
-            param.requires_grad = False
-        if freeze_bn_stats:
-            freeze_batch_norm_2d(self)
-
-    def stem(self, x):
-        for conv, bn in [
-            (self.conv1, self.bn1),
-            (self.conv2, self.bn2),
-            (self.conv3, self.bn3),
-        ]:
-            x = self.relu(bn(conv(x)))
-        x = self.avgpool(x)
-        return x
-
-    def forward(self, x):
-        x = self.stem(x)
-        x = self.layer1(x)
-        x = self.layer2(x)
-        x = self.layer3(x)
-        x = self.layer4(x)
-        x = self.attnpool(x)
-
-        return x
-
-
-class LayerNorm(nn.LayerNorm):
-    """Subclass torch's LayerNorm to handle fp16."""
-
-    def forward(self, x: torch.Tensor):
-        orig_type = x.dtype
-        x = F.layer_norm(x, self.normalized_shape, self.weight, self.bias, self.eps)
-        return x.to(orig_type)
-
-
-class QuickGELU(nn.Module):
-    # NOTE This is slower than nn.GELU or nn.SiLU and uses more GPU memory
-    def forward(self, x: torch.Tensor):
-        return x * torch.sigmoid(1.702 * x)
-
-
-class ResidualAttentionBlock(nn.Module):
-    def __init__(self, d_model: int, n_head: int, act_layer: Callable = nn.GELU):
-        super().__init__()
-
-        self.attn = nn.MultiheadAttention(d_model, n_head)
-        self.ln_1 = LayerNorm(d_model)
-        self.mlp = nn.Sequential(
-            OrderedDict(
-                [
-                    ("c_fc", nn.Linear(d_model, d_model * 4)),
-                    ("gelu", act_layer()),
-                    ("c_proj", nn.Linear(d_model * 4, d_model)),
-                ]
-            )
-        )
-        self.ln_2 = LayerNorm(d_model)
-
-    def attention(self, x: torch.Tensor, attn_mask: Optional[torch.Tensor] = None):
-        return self.attn(x, x, x, need_weights=False, attn_mask=attn_mask)[0]
-
-    def forward(self, x: torch.Tensor, attn_mask: Optional[torch.Tensor] = None):
-        x = x + self.attention(self.ln_1(x), attn_mask=attn_mask)
-        x = x + self.mlp(self.ln_2(x))
-        return x
-
-
-class Transformer(nn.Module):
-    def __init__(
-        self, width: int, layers: int, heads: int, act_layer: Callable = nn.GELU
-    ):
-        super().__init__()
-        self.width = width
-        self.layers = layers
-        self.resblocks = nn.ModuleList(
-            [
-                ResidualAttentionBlock(width, heads, act_layer=act_layer)
-                for _ in range(layers)
-            ]
-        )
-
-    def forward(self, x: torch.Tensor, attn_mask: Optional[torch.Tensor] = None):
-        for r in self.resblocks:
-            x = r(x, attn_mask=attn_mask)
-        return x
-
-
-class VisualTransformer(nn.Module):
-    def __init__(
-        self,
-        image_size: int,
-        patch_size: int,
-        width: int,
-        layers: int,
-        heads: int,
-        output_dim: int,
-        act_layer: Callable = nn.GELU,
-    ):
-        super().__init__()
-        self.image_size = image_size
-        self.output_dim = output_dim
-        self.conv1 = nn.Conv2d(
-            in_channels=3,
-            out_channels=width,
-            kernel_size=patch_size,
-            stride=patch_size,
-            bias=False,
-        )
-
-        scale = width**-0.5
-        self.class_embedding = nn.Parameter(scale * torch.randn(width))
-        self.positional_embedding = nn.Parameter(
-            scale * torch.randn((image_size // patch_size) ** 2 + 1, width)
-        )
-        self.ln_pre = LayerNorm(width)
-
-        self.text_branch = Transformer(width, layers, heads, act_layer=act_layer)
-
-        self.ln_post = LayerNorm(width)
-        self.proj = nn.Parameter(scale * torch.randn(width, output_dim))
-
-    def lock(self, unlocked_groups=0, freeze_bn_stats=False):
-        assert (
-            unlocked_groups == 0
-        ), "partial locking not currently supported for this model"
-        for param in self.parameters():
-            param.requires_grad = False
-
-    def forward(self, x: torch.Tensor):
-        x = self.conv1(x)  # shape = [*, width, grid, grid]
-        x = x.reshape(x.shape[0], x.shape[1], -1)  # shape = [*, width, grid ** 2]
-        x = x.permute(0, 2, 1)  # shape = [*, grid ** 2, width]
-        x = torch.cat(
-            [
-                self.class_embedding.to(x.dtype)
-                + torch.zeros(
-                    x.shape[0], 1, x.shape[-1], dtype=x.dtype, device=x.device
-                ),
-                x,
-            ],
-            dim=1,
-        )  # shape = [*, grid ** 2 + 1, width]
-        x = x + self.positional_embedding.to(x.dtype)
-        x = self.ln_pre(x)
-
-        x = x.permute(1, 0, 2)  # NLD -> LND
-        x = self.text_branch(x)
-        x = x.permute(1, 0, 2)  # LND -> NLD
-
-        x = self.ln_post(x[:, 0, :])
-
-        if self.proj is not None:
-            x = x @ self.proj
-
-        return x
-
-
-@dataclass
-class CLAPVisionCfg:
-    layers: Union[Tuple[int, int, int, int], int] = 12
-    width: int = 768
-    patch_size: int = 16
-    image_size: Union[Tuple[int, int], int] = 224
-    timm_model_name: str = (
-        None  # a valid model name overrides layers, width, patch_size
-    )
-    timm_model_pretrained: bool = (
-        False  # use (imagenet) pretrained weights for named model
-    )
-    timm_pool: str = (
-        "avg"  # feature pooling for timm model ('abs_attn', 'rot_attn', 'avg', '')
-    )
-    timm_proj: str = (
-        "linear"  # linear projection for timm model output ('linear', 'mlp', '')
-    )
-
-
-# Audio Config Class
-@dataclass
-class CLAPAudioCfp:
-    model_type: str = "PANN"
-    model_name: str = "Cnn14"
-    sample_rate: int = 48000
-    # Param
-    audio_length: int = 1024
-    window_size: int = 1024
-    hop_size: int = 1024
-    fmin: int = 50
-    fmax: int = 14000
-    class_num: int = 527
-    mel_bins: int = 64
-    clip_samples: int = 480000
-
-
-@dataclass
-class CLAPTextCfg:
-    context_length: int
-    vocab_size: int
-    width: int
-    heads: int
-    layers: int
-    model_type: str
-
-
-class CLAP(nn.Module):
-    def __init__(
-        self,
-        embed_dim: int,
-        audio_cfg: CLAPAudioCfp,
-        text_cfg: CLAPTextCfg,
-        quick_gelu: bool = False,
-        enable_fusion: bool = False,
-        fusion_type: str = 'None',
-        joint_embed_shape: int = 512,
-        mlp_act: str = 'relu',
-    ):
-        super().__init__()
-        if isinstance(audio_cfg, dict):
-            audio_cfg = CLAPAudioCfp(**audio_cfg)
-        if isinstance(text_cfg, dict):
-            text_cfg = CLAPTextCfg(**text_cfg)
-
-        self.audio_cfg = audio_cfg
-        self.text_cfg = text_cfg
-        self.enable_fusion = enable_fusion
-        self.fusion_type = fusion_type
-        self.joint_embed_shape = joint_embed_shape
-        self.mlp_act = mlp_act
-
-
-        self.context_length = text_cfg.context_length
-
-        # OpenAI models are pretrained w/ QuickGELU but native nn.GELU is both faster and more
-        # memory efficient in recent PyTorch releases (>= 1.10).
-        # NOTE: timm models always use native GELU regardless of quick_gelu flag.
-        act_layer = QuickGELU if quick_gelu else nn.GELU
-
-        if mlp_act == 'relu':
-            mlp_act_layer = nn.ReLU()
-        elif mlp_act == 'gelu':
-            mlp_act_layer = nn.GELU()
-        else:
-            raise NotImplementedError
-
-        # audio branch
-        # audio branch parameters
-        if audio_cfg.model_type == "PANN":
-            self.audio_branch = create_pann_model(audio_cfg, enable_fusion, fusion_type)
-        elif audio_cfg.model_type == "HTSAT":
-            self.audio_branch = create_htsat_model(audio_cfg, enable_fusion, fusion_type)
-        else:
-            logging.error(f"Model config for {audio_cfg.model_type} not found")
-            raise RuntimeError(f"Model config for {audio_cfg.model_type} not found.")
-
-
-        # text branch
-        # text branch parameters
-        if text_cfg.model_type == "transformer":
-            self.text_branch = Transformer(
-                width=text_cfg.width,
-                layers=text_cfg.layers,
-                heads=text_cfg.heads,
-                act_layer=act_layer,
-            )
-            self.vocab_size = text_cfg.vocab_size
-            self.token_embedding = nn.Embedding(text_cfg.vocab_size, text_cfg.width)
-            self.positional_embedding = nn.Parameter(
-                torch.empty(self.context_length, text_cfg.width)
-            )
-            self.ln_final = LayerNorm(text_cfg.width)
-            self.text_transform = MLPLayers(units=[self.joint_embed_shape,
-                                                   self.joint_embed_shape,
-                                                   self.joint_embed_shape], dropout=0.1)
-            self.text_projection = nn.Sequential(
-                nn.Linear(text_cfg.width, self.joint_embed_shape),
-                mlp_act_layer,
-                nn.Linear(self.joint_embed_shape, self.joint_embed_shape)
-            )
-        elif text_cfg.model_type == "bert":
-            self.text_branch = BertModel.from_pretrained("bert-base-uncased")
-            self.text_transform = MLPLayers(units=[self.joint_embed_shape,
-                                                   self.joint_embed_shape,
-                                                   self.joint_embed_shape], dropout=0.1)
-            self.text_projection = nn.Sequential(
-                nn.Linear(768, self.joint_embed_shape),
-                mlp_act_layer,
-                nn.Linear(self.joint_embed_shape, self.joint_embed_shape)
-            )
-        elif text_cfg.model_type == "roberta":
-            self.text_branch = RobertaModel.from_pretrained('roberta-base')
-            self.text_transform = MLPLayers(units=[self.joint_embed_shape,
-                                                   self.joint_embed_shape,
-                                                   self.joint_embed_shape], dropout=0.1)
-            self.text_projection = nn.Sequential(
-                nn.Linear(768, self.joint_embed_shape),
-                mlp_act_layer,
-                nn.Linear(self.joint_embed_shape, self.joint_embed_shape)
-            )
-        elif text_cfg.model_type == "bart":
-            self.text_branch = BartModel.from_pretrained('facebook/bart-base')
-            self.text_transform = MLPLayers(units=[self.joint_embed_shape,
-                                                   self.joint_embed_shape,
-                                                   self.joint_embed_shape], dropout=0.1)
-            self.text_projection = nn.Sequential(
-                nn.Linear(768, self.joint_embed_shape),
-                mlp_act_layer,
-                nn.Linear(self.joint_embed_shape, self.joint_embed_shape)
-            )
-        else:
-            logging.error(f"Model config for {text_cfg.model_type} not found")
-            raise RuntimeError(f"Model config for {text_cfg.model_type} not found.")
-        self.text_branch_type = text_cfg.model_type
-        # text branch parameters
-
-        # audio branch parameters
-        self.audio_transform = MLPLayers(units=[self.joint_embed_shape,
-                                                self.joint_embed_shape,
-                                                self.joint_embed_shape], dropout=0.1)
-
-        # below here is text branch parameters
-
-        # ============================================================================================================
-        self.audio_projection = nn.Sequential(
-                nn.Linear(embed_dim, self.joint_embed_shape),
-                mlp_act_layer,
-                nn.Linear(self.joint_embed_shape, self.joint_embed_shape)
-            )
-
-        self.logit_scale_a = nn.Parameter(torch.ones([]) * np.log(1 / 0.07))
-        self.logit_scale_t = nn.Parameter(torch.ones([]) * np.log(1 / 0.07))
-        self.register_buffer("attn_mask", self.build_attention_mask(), persistent=False)
-
-        self.init_text_branch_parameters()
-
-    def init_text_branch_parameters(self):
-        if self.text_branch_type == "transformer":
-            nn.init.normal_(self.token_embedding.weight, std=0.02)
-            nn.init.normal_(self.positional_embedding, std=0.01)
-            proj_std = (self.text_branch.width**-0.5) * (
-                (2 * self.text_branch.layers) ** -0.5
-            )
-            attn_std = self.text_branch.width**-0.5
-            fc_std = (2 * self.text_branch.width) ** -0.5
-            for block in self.text_branch.resblocks:
-                nn.init.normal_(block.attn.in_proj_weight, std=attn_std)
-                nn.init.normal_(block.attn.out_proj.weight, std=proj_std)
-                nn.init.normal_(block.mlp.c_fc.weight, std=fc_std)
-                nn.init.normal_(block.mlp.c_proj.weight, std=proj_std)
-        if self.text_branch_type == "bert" or self.text_branch_type == "roberta":
-            width = self.text_branch.embeddings.word_embeddings.weight.shape[-1]
-        elif self.text_branch_type == "bart":
-            width = self.text_branch.shared.weight.shape[-1]
-        else:
-            width = self.text_branch.width
-        nn.init.constant_(self.logit_scale_a, np.log(1 / 0.07))
-        nn.init.constant_(self.logit_scale_t, np.log(1 / 0.07))
-
-        # deprecated
-        # if hasattr(self.visual, 'init_parameters'):
-        # self.visual.init_parameters()
-
-        # if self.text_projection is not None:
-        #     nn.init.normal_(self.text_projection, std=width**-0.5)
-
-    def build_attention_mask(self):
-        # lazily create causal attention mask, with full attention between the vision tokens
-        # pytorch uses additive attention mask; fill with -inf
-        mask = torch.empty(self.context_length, self.context_length)
-        mask.fill_(float("-inf"))
-        mask.triu_(1)  # zero out the lower diagonal
-        return mask
-
-    def encode_audio(self, audio, device):
-        return self.audio_branch(audio, mixup_lambda=None, device=device)  # mix lambda needs to add
-
-    # def list_of_dict_of_tensor2dict_of_tensor(self, x, device):
-    #     tmp = {}
-    #     for k in x[0].keys():
-    #         tmp[k] = []
-    #         for i in range(len(x)):
-    #             tmp[k].append(x[i][k][:77])
-    #     for k in x[0].keys():
-    #         tmp[k] = torch.tensor(tmp[k]).to(device=device, non_blocking=True)
-    #     return tmp
-
-    def encode_text(self, text, device):
-        if self.text_branch_type == "transformer":
-            text = text.to(device=device, non_blocking=True)
-            x = self.token_embedding(text)  # [batch_size, n_ctx, d_model]
-
-            x = x + self.positional_embedding
-            x = x.permute(1, 0, 2)  # NLD -> LND
-            x = self.text_branch(x, attn_mask=self.attn_mask)
-            x = x.permute(1, 0, 2)  # LND -> NLD
-            x = self.ln_final(x)
-
-            # x.shape = [batch_size, n_ctx, transformer.width]
-            # take features from the eot embedding (eot_token is the highest number in each sequence)
-            x = self.text_projection(x[torch.arange(x.shape[0]), text.argmax(dim=-1)])
-        elif self.text_branch_type == "bert":
-            # text = self.list_of_dict_of_tensor2dict_of_tensor(text, device)
-            # text = BatchEncoding(text)
-            x = self.text_branch(
-                input_ids=text["input_ids"].to(device=device, non_blocking=True),
-                attention_mask=text["attention_mask"].to(
-                    device=device, non_blocking=True
-                ),
-                token_type_ids=text["token_type_ids"].to(
-                    device=device, non_blocking=True
-                ),
-            )["pooler_output"]
-            x = self.text_projection(x)
-        elif self.text_branch_type == "roberta":
-            x = self.text_branch(
-                input_ids=text["input_ids"].to(device=device, non_blocking=True),
-                attention_mask=text["attention_mask"].to(
-                    device=device, non_blocking=True
-                ),
-            )["pooler_output"]
-
-            x = self.text_projection(x)
-        elif self.text_branch_type == "bart":
-            x = torch.mean(self.text_branch(
-                input_ids=text["input_ids"].to(device=device, non_blocking=True),
-                attention_mask=text["attention_mask"].to(
-                    device=device, non_blocking=True
-                ),
-            )["encoder_last_hidden_state"],axis=1)
-            x = self.text_projection(x)
-        else:
-            logging.error(f"Model type {self.text_branch_type} not found")
-            raise RuntimeError(f"Model type {self.text_branch_type} not found.")
-        return x
-
-    def forward(self, audio, text, device=None):
-        """Forward audio and text into the CLAP
-
-        Parameters
-        ----------
-        audio: torch.Tensor (batch_size, audio_length)
-            the time-domain audio input / the batch of mel_spec and longer list.
-        text: torch.Tensor () // need to add
-            the text token input
-        """
-        if device is None:
-            if audio is not None:
-                device = audio.device
-            elif text is not None:
-                device = text.device
-        if audio is None and text is None:
-            # a hack to get the logit scale
-            return self.logit_scale_a.exp(), self.logit_scale_t.exp()
-        elif audio is None:
-            return self.encode_text(text, device=device)
-        elif text is None:
-            return self.audio_projection(self.encode_audio(audio, device=device)["embedding"])
-        audio_features = self.audio_projection(self.encode_audio(audio, device=device)["embedding"])
-        audio_features = F.normalize(audio_features, dim=-1)
-
-        text_features = self.encode_text(
-            text, device=device
-        )
-        # print("text_features", text_features)
-        # print("text_features.shape", text_features.shape)
-        # print("text_features.type", type(text_features))
-        text_features = F.normalize(text_features, dim=-1)
-
-        audio_features_mlp = self.audio_transform(audio_features)
-        text_features_mlp = self.text_transform(text_features)
-        # Four outputs: audio features (basic & MLP), text features (basic & MLP)
-        return (
-            audio_features,
-            text_features,
-            audio_features_mlp,
-            text_features_mlp,
-            self.logit_scale_a.exp(),
-            self.logit_scale_t.exp(),
-        )
-
-    def get_logit_scale(self):
-        return self.logit_scale_a.exp(), self.logit_scale_t.exp()
-
-    def get_textual_embedding(self, data):
-
-        device = next(self.parameters()).device
-        for k in data:
-            data[k] = data[k].to(device)
-
-        # if self.text_branch_type == "roberta":
-        text_embeds = self.text_branch(
-                input_ids=data["input_ids"].to(device=device, non_blocking=True),
-                attention_mask=data["attention_mask"].to(device=device, non_blocking=True),
-            )["last_hidden_state"]
-
-        text_embeds = self.text_projection(text_embeds)
-
-        text_embeds = F.normalize(text_embeds, dim=-1)
-
-        return text_embeds
-
-    def get_text_embedding(self, data):
-        """Get the text embedding from the model
-
-        Parameters
-        ----------
-        data: torch.Tensor 
-            a tensor of text embedding
-
-        Returns
-        ----------
-        text_embed: torch.Tensor
-            a tensor of text_embeds (N, D)
-
-        """
-        device = next(self.parameters()).device
-        for k in data:
-            data[k] = data[k].to(device)
-        text_embeds = self.encode_text(data, device=device)
-        text_embeds = F.normalize(text_embeds, dim=-1)
-        
-        return text_embeds
-
-    def get_audio_embedding(self, data):
-        """Get the audio embedding from the model
-
-        Parameters
-        ----------
-        data: a list of dict
-            the audio input dict list from 'get_audio_feature' method
-
-        Returns
-        ----------
-        audio_embed: torch.Tensor
-            a tensor of audio_embeds (N, D)
-
-        """
-        device = next(self.parameters()).device
-        input_dict = {}
-        keys = data[0].keys()
-        for k in keys:
-            input_dict[k] = torch.cat([d[k].unsqueeze(0) for d in data], dim=0).to(device)
-        
-        audio_embeds = self.audio_projection(self.encode_audio(input_dict, device=device)["embedding"])
-        audio_embeds = F.normalize(audio_embeds, dim=-1)
-        
-        return audio_embeds
-
-            
-
-    def audio_infer(self, audio, hopsize=None, device=None):
-        """Forward one audio and produce the audio embedding
-
-        Parameters
-        ----------
-        audio:  (audio_length)
-            the time-domain audio input, notice that it must be only one input
-        hopsize: int
-            the overlap hopsize as the sliding window
-
-        Returns
-        ----------
-        output_dict: {
-            key: [n, (embedding_shape)] if "HTS-AT"
-            or
-            key: [(embedding_shape)] if "PANN"
-        }
-            the list of key values of the audio branch
-
-        """
-
-        assert not self.training, "the inference mode must be run at eval stage"
-        output_dict = {}
-        # PANN
-        if self.audio_cfg.model_type == "PANN":
-            audio_input = audio.unsqueeze(dim=0)
-            output_dict[key] = self.encode_audio(audio_input, device=device)[key].squeeze(dim=0)
-        elif self.audio_cfg.model_type == "HTSAT":
-            # repeat
-            audio_len = len(audio)
-            k = self.audio_cfg.clip_samples // audio_len
-            if k > 1:
-                audio = audio.repeat(k)
-                audio_len = len(audio)
-
-            if hopsize is None:
-                hopsize = min(hopsize, audio_len)
-
-            if audio_len > self.audio_cfg.clip_samples:
-                audio_input = [
-                    audio[pos : pos + self.audio_cfg.clip_samples].clone()
-                    for pos in range(
-                        0, audio_len - self.audio_cfg.clip_samples, hopsize
-                    )
-                ]
-                audio_input.append(audio[-self.audio_cfg.clip_samples :].clone())
-                audio_input = torch.stack(audio_input)
-                output_dict[key] = self.encode_audio(audio_input, device=device)[key]
-            else:
-                audio_input = audio.unsqueeze(dim=0)
-                output_dict[key] = self.encode_audio(audio_input, device=device)[key].squeeze(dim=0)
-
-        return output_dict
-
-
-def convert_weights_to_fp16(model: nn.Module):
-    """Convert applicable model parameters to fp16"""
-
-    def _convert_weights_to_fp16(l):
-        if isinstance(l, (nn.Conv1d, nn.Conv2d, nn.Linear)):
-            l.weight.data = l.weight.data.half()
-            if l.bias is not None:
-                l.bias.data = l.bias.data.half()
-
-        if isinstance(l, nn.MultiheadAttention):
-            for attr in [
-                *[f"{s}_proj_weight" for s in ["in", "q", "k", "v"]],
-                "in_proj_bias",
-                "bias_k",
-                "bias_v",
-            ]:
-                tensor = getattr(l, attr)
-                if tensor is not None:
-                    tensor.data = tensor.data.half()
-
-        for name in ["text_projection", "proj"]:
-            if hasattr(l, name):
-                attr = getattr(l, name)
-                if attr is not None:
-                    attr.data = attr.data.half()
-
-    model.apply(_convert_weights_to_fp16)
-
-
-# Ignore the state dict of the vision part
-def build_model_from_openai_state_dict(state_dict: dict, model_cfg, enable_fusion: bool = False, fusion_type: str = 'None'):
-
-    embed_dim = model_cfg["embed_dim"]
-    audio_cfg = model_cfg["audio_cfg"]
-    text_cfg = model_cfg["text_cfg"]
-    context_length = state_dict["positional_embedding"].shape[0]
-    vocab_size = state_dict["token_embedding.weight"].shape[0]
-    transformer_width = state_dict["ln_final.weight"].shape[0]
-    transformer_heads = transformer_width // 64
-    transformer_layers = len(
-        set(
-            k.split(".")[2]
-            for k in state_dict
-            if k.startswith(f"transformer.resblocks")
-        )
-    )
-
-    audio_cfg = CLAPAudioCfp(**audio_cfg)
-    text_cfg = CLAPTextCfg(**text_cfg)
-
-    model = CLAP(
-        embed_dim,
-        audio_cfg=audio_cfg,
-        text_cfg=text_cfg,
-        quick_gelu=True,  # OpenAI models were trained with QuickGELU
-        enable_fusion=enable_fusion,
-        fusion_type=fusion_type
-    )
-    state_dict["logit_scale_a"] = state_dict["logit_scale"]
-    state_dict["logit_scale_t"] = state_dict["logit_scale"]
-    pop_keys = list(state_dict.keys())[::]
-    # pop the visual branch saved weights
-    for key in pop_keys:
-        if key.startswith("visual."):
-            state_dict.pop(key, None)
-
-    for key in ["logit_scale", "input_resolution", "context_length", "vocab_size"]:
-        state_dict.pop(key, None)
-
-    # not use fp16
-    # convert_weights_to_fp16(model)
-    model.load_state_dict(state_dict, strict=False)
-    return model.eval()
-
-
-def trace_model(model, batch_size=256, device=torch.device("cpu")):
-    model.eval()
-    audio_length = model.audio_cfg.audio_length
-    example_audio = torch.ones((batch_size, audio_length), device=device)
-    example_text = torch.zeros(
-        (batch_size, model.context_length), dtype=torch.int, device=device
-    )
-    model = torch.jit.trace_module(
-        model,
-        inputs=dict(
-            forward=(example_audio, example_text),
-            encode_text=(example_text,),
-            encode_image=(example_audio,),
-        ),
-    )
-    model.audio_cfg.audio_length = audio_length  # Question: what does this do?
-    return model

spaces/AIGC-Audio/AudioGPT/text_to_speech/data_gen/tts/runs/preprocess.py

@@ -1,17 +0,0 @@
-import utils.commons.single_thread_env  # NOQA
-from text_to_speech.utils.commons.hparams import hparams, set_hparams
-import importlib
-
-
-def preprocess():
-    assert hparams['preprocess_cls'] != ''
-
-    pkg = ".".join(hparams["preprocess_cls"].split(".")[:-1])
-    cls_name = hparams["preprocess_cls"].split(".")[-1]
-    process_cls = getattr(importlib.import_module(pkg), cls_name)
-    process_cls().process()
-
-
-if __name__ == '__main__':
-    set_hparams()
-    preprocess()

spaces/AIhackrOrg/README/README.md

@@ -1,10 +0,0 @@
----
-title: README
-emoji: 🔥
-colorFrom: yellow
-colorTo: indigo
-sdk: static
-pinned: false
----
-
-Edit this `README.md` markdown file to author your organization card 🔥

spaces/AbandonedMuse/UnlimitedMusicGen/audiocraft/modules/streaming.py

@@ -1,135 +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.
-
-"""
-Streaming module API that should be implemented by all Streaming components,
-"""
-
-from contextlib import contextmanager
-import typing as tp
-from torch import nn
-import torch
-
-
-State = tp.Dict[str, torch.Tensor]
-
-
-class StreamingModule(nn.Module):
-    """Common API for streaming components.
-
-    Each streaming component has a streaming state, which is just a dict[str, Tensor].
-    By convention, the first dim of each tensor must be the batch size.
-    Don't use dots in the key names, as this would clash with submodules
-    (like in state_dict).
-
-    If `self._is_streaming` is True, the component should use and remember
-    the proper state inside `self._streaming_state`.
-
-    To set a streaming component in streaming state, use
-
-        with module.streaming():
-            ...
-
-    This will automatically reset the streaming state when exiting the context manager.
-    This also automatically propagates to all streaming children module.
-
-    Some module might also implement the `StreamingModule.flush` method, although
-    this one is trickier, as all parents module must be StreamingModule and implement
-    it as well for it to work properly. See `StreamingSequential` after.
-    """
-    def __init__(self) -> None:
-        super().__init__()
-        self._streaming_state: State = {}
-        self._is_streaming = False
-
-    def _apply_named_streaming(self, fn: tp.Any):
-        for name, module in self.named_modules():
-            if isinstance(module, StreamingModule):
-                fn(name, module)
-
-    def _set_streaming(self, streaming: bool):
-        def _set_streaming(name, module):
-            module._is_streaming = streaming
-        self._apply_named_streaming(_set_streaming)
-
-    @contextmanager
-    def streaming(self):
-        """Context manager to enter streaming mode. Reset streaming state on exit.
-        """
-        self._set_streaming(True)
-        try:
-            yield
-        finally:
-            self._set_streaming(False)
-            self.reset_streaming()
-
-    def reset_streaming(self):
-        """Reset the streaming state.
-        """
-        def _reset(name: str, module: StreamingModule):
-            module._streaming_state.clear()
-
-        self._apply_named_streaming(_reset)
-
-    def get_streaming_state(self) -> State:
-        """Return the streaming state, including that of sub-modules.
-        """
-        state: State = {}
-
-        def _add(name: str, module: StreamingModule):
-            if name:
-                name += "."
-            for key, value in module._streaming_state.items():
-                state[name + key] = value
-
-        self._apply_named_streaming(_add)
-        return state
-
-    def set_streaming_state(self, state: State):
-        """Set the streaming state, including that of sub-modules.
-        """
-        state = dict(state)
-
-        def _set(name: str, module: StreamingModule):
-            if name:
-                name += "."
-            module._streaming_state.clear()
-            for key, value in list(state.items()):
-                # complexity is not ideal here, but probably fine.
-                if key.startswith(name):
-                    local_key = key[len(name):]
-                    if '.' not in local_key:
-                        module._streaming_state[local_key] = value
-                        del state[key]
-
-        self._apply_named_streaming(_set)
-        assert len(state) == 0, list(state.keys())
-
-    def flush(self, x: tp.Optional[torch.Tensor] = None):
-        """Flush any remaining outputs that were waiting for completion.
-        Typically, for convolutions, this will add the final padding
-        and process the last buffer.
-
-        This should take an optional argument `x`, which will be provided
-        if a module before this one in the streaming pipeline has already
-        spitted out a flushed out buffer.
-        """
-        if x is None:
-            return None
-        else:
-            return self(x)
-
-
-class StreamingSequential(StreamingModule, nn.Sequential):
-    """A streaming compatible alternative of `nn.Sequential`.
-    """
-    def flush(self, x: tp.Optional[torch.Tensor] = None):
-        for module in self:
-            if isinstance(module, StreamingModule):
-                x = module.flush(x)
-            elif x is not None:
-                x = module(x)
-        return x

spaces/AbdoulGafar/woodsound/app.py

@@ -1,73 +0,0 @@
-import gradio as gr
-from fastai.vision.all import *
-from PIL import Image
-import tempfile
-import os
-
-import rarfile
-import librosa
-import librosa.display
-import matplotlib.pyplot as plt
-
-# Chargez votre modèle Fastai 
-learn = load_learner('woodsound')
-
-# Fonction pour effectuer la prédiction à partir d'un fichier audio
-def predict_audio(audio_file):
-
-    # Charger le fichier audio
-    samples, sample_rate = librosa.load(audio_file)
-
-    # Créez un répertoire temporaire pour stocker l'image temporaire
-    with tempfile.TemporaryDirectory() as temp_dir:
-
-        # Créer le nom de fichier pour le spectrogramme
-        spectrogram_filename = os.path.splitext(os.path.basename(audio_file))[0] + ".png"
-        temp_image_path = os.path.join(temp_dir, spectrogram_filename)
-
-        # Créer et enregistrer le spectrogramme
-        plt.figure(figsize=(0.72, 0.72))
-        ax = plt.subplot(111)
-        ax.axes.get_xaxis().set_visible(False)
-        ax.axes.get_yaxis().set_visible(False)
-        ax.set_frame_on(False)
-        S = librosa.feature.melspectrogram(y=samples, sr=sample_rate)
-        librosa.display.specshow(librosa.power_to_db(S, ref=np.max))
-        plt.savefig(temp_image_path, dpi=400, bbox_inches='tight', pad_inches=0)
-        plt.close()
-
-        # Effectuez la prédiction avec le modèle en utilisant l'image temporaire
-        probabilities = predict_with_probabilities(temp_image_path, learn)
-
-    return probabilities
-
-
-
-# Fonction pour effectuer la prédiction avec le modèle Fastai
-def predict_with_probabilities(image_path, learn):
-
-    # Chargez l'image
-    img = Image.open(image_path).convert('RGB')
-
-    # Redimensionnez l'image à 224x224
-    img = img.resize((224, 224))
-
-    # Convertissez l'image en un format que Fastai peut utiliser (PILImage)
-    img = PILImage(img)
-
-    # Faites la prédiction sur l'image redimensionnée
-    pred,idx,prob = learn.predict(img)
-
-    # Obtenez les noms des catégories
-    categories = ('ache', 'scie_electrique', 'oiseaux', 'arme_a_feu', 'scie_manuelle')
-
-    return dict(zip(categories,map(float,prob)))
-
-# Créez l'interface Gradio
-examples_files = [
-    ["song_1.wav"],
-    ["song_2.mp3"],
-]
-audio_input = gr.Audio(source='upload', type='filepath', label="Sélectionnez un fichier audio (wav, mp3, etc.)", )
-output_component = gr.Label(num_top_classes= 5)
-gr.Interface(fn=predict_audio, inputs=audio_input, outputs=output_component, examples=examples_files).launch(share=True)

spaces/Adapter/CoAdapter/ldm/models/diffusion/dpm_solver/__init__.py

@@ -1 +0,0 @@
-from .sampler import DPMSolverSampler

spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/fullwindowrectangle/Factory.js

@@ -1,13 +0,0 @@
-import FullWindowRectangle from './FullWindowRectangle.js';
-import ObjectFactory from '../ObjectFactory.js';
-import SetValue from '../../../plugins/utils/object/SetValue.js';
-
-ObjectFactory.register('fullWindowRectangle', function (fillColor, fillAlpha) {
-    var gameObject = new FullWindowRectangle(this.scene, fillColor, fillAlpha);
-    this.scene.add.existing(gameObject);
-    return gameObject;
-});
-
-SetValue(window, 'RexPlugins.UI.FullWindowRectangle', FullWindowRectangle);
-
-export default FullWindowRectangle;

spaces/AlexWang/lama/saicinpainting/evaluation/masks/countless/README.md

@@ -1,25 +0,0 @@
-[![Build Status](https://travis-ci.org/william-silversmith/countless.svg?branch=master)](https://travis-ci.org/william-silversmith/countless)
-
-Python COUNTLESS Downsampling
-=============================
-
-To install:  
-
-`pip install -r requirements.txt`  
-
-To test:
-
-`python test.py`  
-
-To benchmark countless2d:
-
-`python python/countless2d.py python/images/gray_segmentation.png`
-
-To benchmark countless3d:
-
-`python python/countless3d.py`
-
-Adjust N and the list of algorithms inside each script to modify the run parameters.
-
-
-Python3 is slightly faster than Python2.

spaces/Androidonnxfork/CivitAi-to-Diffusers/README.md

@@ -1,13 +0,0 @@
----
-title: CivitAi To Diffusers
-emoji: ©️➡️🧨
-colorFrom: orange
-colorTo: cyan
-sdk: gradio
-sdk_version: 3.31.0
-app_file: app1.py
-pinned: true
-duplicated_from: Androidonnxfork/sd-to-diffuserscustom
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/Makefile

@@ -1,96 +0,0 @@
-.PHONY: deps_table_update modified_only_fixup extra_style_checks quality style fixup fix-copies test test-examples
-
-# make sure to test the local checkout in scripts and not the pre-installed one (don't use quotes!)
-export PYTHONPATH = src
-
-check_dirs := examples scripts src tests utils
-
-modified_only_fixup:
-	$(eval modified_py_files := $(shell python utils/get_modified_files.py $(check_dirs)))
-	@if test -n "$(modified_py_files)"; then \
-		echo "Checking/fixing $(modified_py_files)"; \
-		black $(modified_py_files); \
-		ruff $(modified_py_files); \
-	else \
-		echo "No library .py files were modified"; \
-	fi
-
-# Update src/diffusers/dependency_versions_table.py
-
-deps_table_update:
-	@python setup.py deps_table_update
-
-deps_table_check_updated:
-	@md5sum src/diffusers/dependency_versions_table.py > md5sum.saved
-	@python setup.py deps_table_update
-	@md5sum -c --quiet md5sum.saved || (printf "\nError: the version dependency table is outdated.\nPlease run 'make fixup' or 'make style' and commit the changes.\n\n" && exit 1)
-	@rm md5sum.saved
-
-# autogenerating code
-
-autogenerate_code: deps_table_update
-
-# Check that the repo is in a good state
-
-repo-consistency:
-	python utils/check_dummies.py
-	python utils/check_repo.py
-	python utils/check_inits.py
-
-# this target runs checks on all files
-
-quality:
-	black --check $(check_dirs)
-	ruff $(check_dirs)
-	doc-builder style src/diffusers docs/source --max_len 119 --check_only --path_to_docs docs/source
-	python utils/check_doc_toc.py
-
-# Format source code automatically and check is there are any problems left that need manual fixing
-
-extra_style_checks:
-	python utils/custom_init_isort.py
-	doc-builder style src/diffusers docs/source --max_len 119 --path_to_docs docs/source
-	python utils/check_doc_toc.py --fix_and_overwrite
-
-# this target runs checks on all files and potentially modifies some of them
-
-style:
-	black $(check_dirs)
-	ruff $(check_dirs) --fix
-	${MAKE} autogenerate_code
-	${MAKE} extra_style_checks
-
-# Super fast fix and check target that only works on relevant modified files since the branch was made
-
-fixup: modified_only_fixup extra_style_checks autogenerate_code repo-consistency
-
-# Make marked copies of snippets of codes conform to the original
-
-fix-copies:
-	python utils/check_copies.py --fix_and_overwrite
-	python utils/check_dummies.py --fix_and_overwrite
-
-# Run tests for the library
-
-test:
-	python -m pytest -n auto --dist=loadfile -s -v ./tests/
-
-# Run tests for examples
-
-test-examples:
-	python -m pytest -n auto --dist=loadfile -s -v ./examples/pytorch/
-
-
-# Release stuff
-
-pre-release:
-	python utils/release.py
-
-pre-patch:
-	python utils/release.py --patch
-
-post-release:
-	python utils/release.py --post_release
-
-post-patch:
-	python utils/release.py --post_release --patch

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/docs/source/en/api/pipelines/audioldm.md

@@ -1,51 +0,0 @@
-<!--Copyright 2023 The HuggingFace Team. All rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
-the License. You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
-an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
-specific language governing permissions and limitations under the License.
--->
-
-# AudioLDM
-
-AudioLDM was proposed in [AudioLDM: Text-to-Audio Generation with Latent Diffusion Models](https://huggingface.co/papers/2301.12503) by Haohe Liu et al. Inspired by [Stable Diffusion](https://huggingface.co/docs/diffusers/api/pipelines/stable_diffusion/overview), AudioLDM
-is a text-to-audio _latent diffusion model (LDM)_ that learns continuous audio representations from [CLAP](https://huggingface.co/docs/transformers/main/model_doc/clap)
-latents. AudioLDM takes a text prompt as input and predicts the corresponding audio. It can generate text-conditional
-sound effects, human speech and music.
-
-The abstract from the paper is:
-
-*Text-to-audio (TTA) system has recently gained attention for its ability to synthesize general audio based on text descriptions. However, previous studies in TTA have limited generation quality with high computational costs. In this study, we propose AudioLDM, a TTA system that is built on a latent space to learn the continuous audio representations from contrastive language-audio pretraining (CLAP) latents. The pretrained CLAP models enable us to train LDMs with audio embedding while providing text embedding as a condition during sampling. By learning the latent representations of audio signals and their compositions without modeling the cross-modal relationship, AudioLDM is advantageous in both generation quality and computational efficiency. Trained on AudioCaps with a single GPU, AudioLDM achieves state-of-the-art TTA performance measured by both objective and subjective metrics (e.g., frechet distance). Moreover, AudioLDM is the first TTA system that enables various text-guided audio manipulations (e.g., style transfer) in a zero-shot fashion. Our implementation and demos are available at https://audioldm.github.io.*
-
-The original codebase can be found at [haoheliu/AudioLDM](https://github.com/haoheliu/AudioLDM). 
-
-## Tips
-
-When constructing a prompt, keep in mind:
-
-* Descriptive prompt inputs work best; you can use adjectives to describe the sound (for example, "high quality" or "clear") and make the prompt context specific (for example, "water stream in a forest" instead of "stream").
-* It's best to use general terms like "cat" or "dog" instead of specific names or abstract objects the model may not be familiar with.
-
-During inference:
-
-* The _quality_ of the predicted audio sample can be controlled by the `num_inference_steps` argument; higher steps give higher quality audio at the expense of slower inference.
-* The _length_ of the predicted audio sample can be controlled by varying the `audio_length_in_s` argument.
-
-<Tip>
-
-Make sure to check out the Schedulers [guide](/using-diffusers/schedulers) to learn how to explore the tradeoff between scheduler speed and quality, and see the [reuse components across pipelines](/using-diffusers/loading#reuse-components-across-pipelines) section to learn how to efficiently load the same components into multiple pipelines.
-
-</Tip>
-
-## AudioLDMPipeline
-[[autodoc]] AudioLDMPipeline
-	- all
-	- __call__
-
-## StableDiffusionPipelineOutput
-
-[[autodoc]] pipelines.stable_diffusion.StableDiffusionPipelineOutput

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/docs/source/en/api/schedulers/dpm_discrete.md

@@ -1,22 +0,0 @@
-<!--Copyright 2023 The HuggingFace Team. All rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
-the License. You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
-an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
-specific language governing permissions and limitations under the License.
--->
-
-# DPM Discrete Scheduler inspired by Karras et. al paper
-
-## Overview
-
-Inspired by [Karras et. al](https://arxiv.org/abs/2206.00364). Scheduler ported from @crowsonkb's https://github.com/crowsonkb/k-diffusion library:
-
-All credit for making this scheduler work goes to [Katherine Crowson](https://github.com/crowsonkb/)
-
-## KDPM2DiscreteScheduler
-[[autodoc]] KDPM2DiscreteScheduler

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/scripts/convert_ddpm_original_checkpoint_to_diffusers.py

@@ -1,431 +0,0 @@
-import argparse
-import json
-
-import torch
-
-from diffusers import AutoencoderKL, DDPMPipeline, DDPMScheduler, UNet2DModel, VQModel
-
-
-def shave_segments(path, n_shave_prefix_segments=1):
-    """
-    Removes segments. Positive values shave the first segments, negative shave the last segments.
-    """
-    if n_shave_prefix_segments >= 0:
-        return ".".join(path.split(".")[n_shave_prefix_segments:])
-    else:
-        return ".".join(path.split(".")[:n_shave_prefix_segments])
-
-
-def renew_resnet_paths(old_list, n_shave_prefix_segments=0):
-    mapping = []
-    for old_item in old_list:
-        new_item = old_item
-        new_item = new_item.replace("block.", "resnets.")
-        new_item = new_item.replace("conv_shorcut", "conv1")
-        new_item = new_item.replace("in_shortcut", "conv_shortcut")
-        new_item = new_item.replace("temb_proj", "time_emb_proj")
-
-        new_item = shave_segments(new_item, n_shave_prefix_segments=n_shave_prefix_segments)
-
-        mapping.append({"old": old_item, "new": new_item})
-
-    return mapping
-
-
-def renew_attention_paths(old_list, n_shave_prefix_segments=0, in_mid=False):
-    mapping = []
-    for old_item in old_list:
-        new_item = old_item
-
-        # In `model.mid`, the layer is called `attn`.
-        if not in_mid:
-            new_item = new_item.replace("attn", "attentions")
-        new_item = new_item.replace(".k.", ".key.")
-        new_item = new_item.replace(".v.", ".value.")
-        new_item = new_item.replace(".q.", ".query.")
-
-        new_item = new_item.replace("proj_out", "proj_attn")
-        new_item = new_item.replace("norm", "group_norm")
-
-        new_item = shave_segments(new_item, n_shave_prefix_segments=n_shave_prefix_segments)
-        mapping.append({"old": old_item, "new": new_item})
-
-    return mapping
-
-
-def assign_to_checkpoint(
-    paths, checkpoint, old_checkpoint, attention_paths_to_split=None, additional_replacements=None, config=None
-):
-    assert isinstance(paths, list), "Paths should be a list of dicts containing 'old' and 'new' keys."
-
-    if attention_paths_to_split is not None:
-        if config is None:
-            raise ValueError("Please specify the config if setting 'attention_paths_to_split' to 'True'.")
-
-        for path, path_map in attention_paths_to_split.items():
-            old_tensor = old_checkpoint[path]
-            channels = old_tensor.shape[0] // 3
-
-            target_shape = (-1, channels) if len(old_tensor.shape) == 3 else (-1)
-
-            num_heads = old_tensor.shape[0] // config.get("num_head_channels", 1) // 3
-
-            old_tensor = old_tensor.reshape((num_heads, 3 * channels // num_heads) + old_tensor.shape[1:])
-            query, key, value = old_tensor.split(channels // num_heads, dim=1)
-
-            checkpoint[path_map["query"]] = query.reshape(target_shape).squeeze()
-            checkpoint[path_map["key"]] = key.reshape(target_shape).squeeze()
-            checkpoint[path_map["value"]] = value.reshape(target_shape).squeeze()
-
-    for path in paths:
-        new_path = path["new"]
-
-        if attention_paths_to_split is not None and new_path in attention_paths_to_split:
-            continue
-
-        new_path = new_path.replace("down.", "down_blocks.")
-        new_path = new_path.replace("up.", "up_blocks.")
-
-        if additional_replacements is not None:
-            for replacement in additional_replacements:
-                new_path = new_path.replace(replacement["old"], replacement["new"])
-
-        if "attentions" in new_path:
-            checkpoint[new_path] = old_checkpoint[path["old"]].squeeze()
-        else:
-            checkpoint[new_path] = old_checkpoint[path["old"]]
-
-
-def convert_ddpm_checkpoint(checkpoint, config):
-    """
-    Takes a state dict and a config, and returns a converted checkpoint.
-    """
-    new_checkpoint = {}
-
-    new_checkpoint["time_embedding.linear_1.weight"] = checkpoint["temb.dense.0.weight"]
-    new_checkpoint["time_embedding.linear_1.bias"] = checkpoint["temb.dense.0.bias"]
-    new_checkpoint["time_embedding.linear_2.weight"] = checkpoint["temb.dense.1.weight"]
-    new_checkpoint["time_embedding.linear_2.bias"] = checkpoint["temb.dense.1.bias"]
-
-    new_checkpoint["conv_norm_out.weight"] = checkpoint["norm_out.weight"]
-    new_checkpoint["conv_norm_out.bias"] = checkpoint["norm_out.bias"]
-
-    new_checkpoint["conv_in.weight"] = checkpoint["conv_in.weight"]
-    new_checkpoint["conv_in.bias"] = checkpoint["conv_in.bias"]
-    new_checkpoint["conv_out.weight"] = checkpoint["conv_out.weight"]
-    new_checkpoint["conv_out.bias"] = checkpoint["conv_out.bias"]
-
-    num_down_blocks = len({".".join(layer.split(".")[:2]) for layer in checkpoint if "down" in layer})
-    down_blocks = {
-        layer_id: [key for key in checkpoint if f"down.{layer_id}" in key] for layer_id in range(num_down_blocks)
-    }
-
-    num_up_blocks = len({".".join(layer.split(".")[:2]) for layer in checkpoint if "up" in layer})
-    up_blocks = {layer_id: [key for key in checkpoint if f"up.{layer_id}" in key] for layer_id in range(num_up_blocks)}
-
-    for i in range(num_down_blocks):
-        block_id = (i - 1) // (config["layers_per_block"] + 1)
-
-        if any("downsample" in layer for layer in down_blocks[i]):
-            new_checkpoint[f"down_blocks.{i}.downsamplers.0.conv.weight"] = checkpoint[
-                f"down.{i}.downsample.op.weight"
-            ]
-            new_checkpoint[f"down_blocks.{i}.downsamplers.0.conv.bias"] = checkpoint[f"down.{i}.downsample.op.bias"]
-        #            new_checkpoint[f'down_blocks.{i}.downsamplers.0.op.weight'] = checkpoint[f'down.{i}.downsample.conv.weight']
-        #            new_checkpoint[f'down_blocks.{i}.downsamplers.0.op.bias'] = checkpoint[f'down.{i}.downsample.conv.bias']
-
-        if any("block" in layer for layer in down_blocks[i]):
-            num_blocks = len(
-                {".".join(shave_segments(layer, 2).split(".")[:2]) for layer in down_blocks[i] if "block" in layer}
-            )
-            blocks = {
-                layer_id: [key for key in down_blocks[i] if f"block.{layer_id}" in key]
-                for layer_id in range(num_blocks)
-            }
-
-            if num_blocks > 0:
-                for j in range(config["layers_per_block"]):
-                    paths = renew_resnet_paths(blocks[j])
-                    assign_to_checkpoint(paths, new_checkpoint, checkpoint)
-
-        if any("attn" in layer for layer in down_blocks[i]):
-            num_attn = len(
-                {".".join(shave_segments(layer, 2).split(".")[:2]) for layer in down_blocks[i] if "attn" in layer}
-            )
-            attns = {
-                layer_id: [key for key in down_blocks[i] if f"attn.{layer_id}" in key]
-                for layer_id in range(num_blocks)
-            }
-
-            if num_attn > 0:
-                for j in range(config["layers_per_block"]):
-                    paths = renew_attention_paths(attns[j])
-                    assign_to_checkpoint(paths, new_checkpoint, checkpoint, config=config)
-
-    mid_block_1_layers = [key for key in checkpoint if "mid.block_1" in key]
-    mid_block_2_layers = [key for key in checkpoint if "mid.block_2" in key]
-    mid_attn_1_layers = [key for key in checkpoint if "mid.attn_1" in key]
-
-    # Mid new 2
-    paths = renew_resnet_paths(mid_block_1_layers)
-    assign_to_checkpoint(
-        paths,
-        new_checkpoint,
-        checkpoint,
-        additional_replacements=[{"old": "mid.", "new": "mid_new_2."}, {"old": "block_1", "new": "resnets.0"}],
-    )
-
-    paths = renew_resnet_paths(mid_block_2_layers)
-    assign_to_checkpoint(
-        paths,
-        new_checkpoint,
-        checkpoint,
-        additional_replacements=[{"old": "mid.", "new": "mid_new_2."}, {"old": "block_2", "new": "resnets.1"}],
-    )
-
-    paths = renew_attention_paths(mid_attn_1_layers, in_mid=True)
-    assign_to_checkpoint(
-        paths,
-        new_checkpoint,
-        checkpoint,
-        additional_replacements=[{"old": "mid.", "new": "mid_new_2."}, {"old": "attn_1", "new": "attentions.0"}],
-    )
-
-    for i in range(num_up_blocks):
-        block_id = num_up_blocks - 1 - i
-
-        if any("upsample" in layer for layer in up_blocks[i]):
-            new_checkpoint[f"up_blocks.{block_id}.upsamplers.0.conv.weight"] = checkpoint[
-                f"up.{i}.upsample.conv.weight"
-            ]
-            new_checkpoint[f"up_blocks.{block_id}.upsamplers.0.conv.bias"] = checkpoint[f"up.{i}.upsample.conv.bias"]
-
-        if any("block" in layer for layer in up_blocks[i]):
-            num_blocks = len(
-                {".".join(shave_segments(layer, 2).split(".")[:2]) for layer in up_blocks[i] if "block" in layer}
-            )
-            blocks = {
-                layer_id: [key for key in up_blocks[i] if f"block.{layer_id}" in key] for layer_id in range(num_blocks)
-            }
-
-            if num_blocks > 0:
-                for j in range(config["layers_per_block"] + 1):
-                    replace_indices = {"old": f"up_blocks.{i}", "new": f"up_blocks.{block_id}"}
-                    paths = renew_resnet_paths(blocks[j])
-                    assign_to_checkpoint(paths, new_checkpoint, checkpoint, additional_replacements=[replace_indices])
-
-        if any("attn" in layer for layer in up_blocks[i]):
-            num_attn = len(
-                {".".join(shave_segments(layer, 2).split(".")[:2]) for layer in up_blocks[i] if "attn" in layer}
-            )
-            attns = {
-                layer_id: [key for key in up_blocks[i] if f"attn.{layer_id}" in key] for layer_id in range(num_blocks)
-            }
-
-            if num_attn > 0:
-                for j in range(config["layers_per_block"] + 1):
-                    replace_indices = {"old": f"up_blocks.{i}", "new": f"up_blocks.{block_id}"}
-                    paths = renew_attention_paths(attns[j])
-                    assign_to_checkpoint(paths, new_checkpoint, checkpoint, additional_replacements=[replace_indices])
-
-    new_checkpoint = {k.replace("mid_new_2", "mid_block"): v for k, v in new_checkpoint.items()}
-    return new_checkpoint
-
-
-def convert_vq_autoenc_checkpoint(checkpoint, config):
-    """
-    Takes a state dict and a config, and returns a converted checkpoint.
-    """
-    new_checkpoint = {}
-
-    new_checkpoint["encoder.conv_norm_out.weight"] = checkpoint["encoder.norm_out.weight"]
-    new_checkpoint["encoder.conv_norm_out.bias"] = checkpoint["encoder.norm_out.bias"]
-
-    new_checkpoint["encoder.conv_in.weight"] = checkpoint["encoder.conv_in.weight"]
-    new_checkpoint["encoder.conv_in.bias"] = checkpoint["encoder.conv_in.bias"]
-    new_checkpoint["encoder.conv_out.weight"] = checkpoint["encoder.conv_out.weight"]
-    new_checkpoint["encoder.conv_out.bias"] = checkpoint["encoder.conv_out.bias"]
-
-    new_checkpoint["decoder.conv_norm_out.weight"] = checkpoint["decoder.norm_out.weight"]
-    new_checkpoint["decoder.conv_norm_out.bias"] = checkpoint["decoder.norm_out.bias"]
-
-    new_checkpoint["decoder.conv_in.weight"] = checkpoint["decoder.conv_in.weight"]
-    new_checkpoint["decoder.conv_in.bias"] = checkpoint["decoder.conv_in.bias"]
-    new_checkpoint["decoder.conv_out.weight"] = checkpoint["decoder.conv_out.weight"]
-    new_checkpoint["decoder.conv_out.bias"] = checkpoint["decoder.conv_out.bias"]
-
-    num_down_blocks = len({".".join(layer.split(".")[:3]) for layer in checkpoint if "down" in layer})
-    down_blocks = {
-        layer_id: [key for key in checkpoint if f"down.{layer_id}" in key] for layer_id in range(num_down_blocks)
-    }
-
-    num_up_blocks = len({".".join(layer.split(".")[:3]) for layer in checkpoint if "up" in layer})
-    up_blocks = {layer_id: [key for key in checkpoint if f"up.{layer_id}" in key] for layer_id in range(num_up_blocks)}
-
-    for i in range(num_down_blocks):
-        block_id = (i - 1) // (config["layers_per_block"] + 1)
-
-        if any("downsample" in layer for layer in down_blocks[i]):
-            new_checkpoint[f"encoder.down_blocks.{i}.downsamplers.0.conv.weight"] = checkpoint[
-                f"encoder.down.{i}.downsample.conv.weight"
-            ]
-            new_checkpoint[f"encoder.down_blocks.{i}.downsamplers.0.conv.bias"] = checkpoint[
-                f"encoder.down.{i}.downsample.conv.bias"
-            ]
-
-        if any("block" in layer for layer in down_blocks[i]):
-            num_blocks = len(
-                {".".join(shave_segments(layer, 3).split(".")[:3]) for layer in down_blocks[i] if "block" in layer}
-            )
-            blocks = {
-                layer_id: [key for key in down_blocks[i] if f"block.{layer_id}" in key]
-                for layer_id in range(num_blocks)
-            }
-
-            if num_blocks > 0:
-                for j in range(config["layers_per_block"]):
-                    paths = renew_resnet_paths(blocks[j])
-                    assign_to_checkpoint(paths, new_checkpoint, checkpoint)
-
-        if any("attn" in layer for layer in down_blocks[i]):
-            num_attn = len(
-                {".".join(shave_segments(layer, 3).split(".")[:3]) for layer in down_blocks[i] if "attn" in layer}
-            )
-            attns = {
-                layer_id: [key for key in down_blocks[i] if f"attn.{layer_id}" in key]
-                for layer_id in range(num_blocks)
-            }
-
-            if num_attn > 0:
-                for j in range(config["layers_per_block"]):
-                    paths = renew_attention_paths(attns[j])
-                    assign_to_checkpoint(paths, new_checkpoint, checkpoint, config=config)
-
-    mid_block_1_layers = [key for key in checkpoint if "mid.block_1" in key]
-    mid_block_2_layers = [key for key in checkpoint if "mid.block_2" in key]
-    mid_attn_1_layers = [key for key in checkpoint if "mid.attn_1" in key]
-
-    # Mid new 2
-    paths = renew_resnet_paths(mid_block_1_layers)
-    assign_to_checkpoint(
-        paths,
-        new_checkpoint,
-        checkpoint,
-        additional_replacements=[{"old": "mid.", "new": "mid_new_2."}, {"old": "block_1", "new": "resnets.0"}],
-    )
-
-    paths = renew_resnet_paths(mid_block_2_layers)
-    assign_to_checkpoint(
-        paths,
-        new_checkpoint,
-        checkpoint,
-        additional_replacements=[{"old": "mid.", "new": "mid_new_2."}, {"old": "block_2", "new": "resnets.1"}],
-    )
-
-    paths = renew_attention_paths(mid_attn_1_layers, in_mid=True)
-    assign_to_checkpoint(
-        paths,
-        new_checkpoint,
-        checkpoint,
-        additional_replacements=[{"old": "mid.", "new": "mid_new_2."}, {"old": "attn_1", "new": "attentions.0"}],
-    )
-
-    for i in range(num_up_blocks):
-        block_id = num_up_blocks - 1 - i
-
-        if any("upsample" in layer for layer in up_blocks[i]):
-            new_checkpoint[f"decoder.up_blocks.{block_id}.upsamplers.0.conv.weight"] = checkpoint[
-                f"decoder.up.{i}.upsample.conv.weight"
-            ]
-            new_checkpoint[f"decoder.up_blocks.{block_id}.upsamplers.0.conv.bias"] = checkpoint[
-                f"decoder.up.{i}.upsample.conv.bias"
-            ]
-
-        if any("block" in layer for layer in up_blocks[i]):
-            num_blocks = len(
-                {".".join(shave_segments(layer, 3).split(".")[:3]) for layer in up_blocks[i] if "block" in layer}
-            )
-            blocks = {
-                layer_id: [key for key in up_blocks[i] if f"block.{layer_id}" in key] for layer_id in range(num_blocks)
-            }
-
-            if num_blocks > 0:
-                for j in range(config["layers_per_block"] + 1):
-                    replace_indices = {"old": f"up_blocks.{i}", "new": f"up_blocks.{block_id}"}
-                    paths = renew_resnet_paths(blocks[j])
-                    assign_to_checkpoint(paths, new_checkpoint, checkpoint, additional_replacements=[replace_indices])
-
-        if any("attn" in layer for layer in up_blocks[i]):
-            num_attn = len(
-                {".".join(shave_segments(layer, 3).split(".")[:3]) for layer in up_blocks[i] if "attn" in layer}
-            )
-            attns = {
-                layer_id: [key for key in up_blocks[i] if f"attn.{layer_id}" in key] for layer_id in range(num_blocks)
-            }
-
-            if num_attn > 0:
-                for j in range(config["layers_per_block"] + 1):
-                    replace_indices = {"old": f"up_blocks.{i}", "new": f"up_blocks.{block_id}"}
-                    paths = renew_attention_paths(attns[j])
-                    assign_to_checkpoint(paths, new_checkpoint, checkpoint, additional_replacements=[replace_indices])
-
-    new_checkpoint = {k.replace("mid_new_2", "mid_block"): v for k, v in new_checkpoint.items()}
-    new_checkpoint["quant_conv.weight"] = checkpoint["quant_conv.weight"]
-    new_checkpoint["quant_conv.bias"] = checkpoint["quant_conv.bias"]
-    if "quantize.embedding.weight" in checkpoint:
-        new_checkpoint["quantize.embedding.weight"] = checkpoint["quantize.embedding.weight"]
-    new_checkpoint["post_quant_conv.weight"] = checkpoint["post_quant_conv.weight"]
-    new_checkpoint["post_quant_conv.bias"] = checkpoint["post_quant_conv.bias"]
-
-    return new_checkpoint
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-
-    parser.add_argument(
-        "--checkpoint_path", default=None, type=str, required=True, help="Path to the checkpoint to convert."
-    )
-
-    parser.add_argument(
-        "--config_file",
-        default=None,
-        type=str,
-        required=True,
-        help="The config json file corresponding to the architecture.",
-    )
-
-    parser.add_argument("--dump_path", default=None, type=str, required=True, help="Path to the output model.")
-
-    args = parser.parse_args()
-    checkpoint = torch.load(args.checkpoint_path)
-
-    with open(args.config_file) as f:
-        config = json.loads(f.read())
-
-    # unet case
-    key_prefix_set = {key.split(".")[0] for key in checkpoint.keys()}
-    if "encoder" in key_prefix_set and "decoder" in key_prefix_set:
-        converted_checkpoint = convert_vq_autoenc_checkpoint(checkpoint, config)
-    else:
-        converted_checkpoint = convert_ddpm_checkpoint(checkpoint, config)
-
-    if "ddpm" in config:
-        del config["ddpm"]
-
-    if config["_class_name"] == "VQModel":
-        model = VQModel(**config)
-        model.load_state_dict(converted_checkpoint)
-        model.save_pretrained(args.dump_path)
-    elif config["_class_name"] == "AutoencoderKL":
-        model = AutoencoderKL(**config)
-        model.load_state_dict(converted_checkpoint)
-        model.save_pretrained(args.dump_path)
-    else:
-        model = UNet2DModel(**config)
-        model.load_state_dict(converted_checkpoint)
-
-        scheduler = DDPMScheduler.from_config("/".join(args.checkpoint_path.split("/")[:-1]))
-
-        pipe = DDPMPipeline(unet=model, scheduler=scheduler)
-        pipe.save_pretrained(args.dump_path)

spaces/Andy1621/uniformer_image_detection/mmdet/models/detectors/faster_rcnn.py

@@ -1,24 +0,0 @@
-from ..builder import DETECTORS
-from .two_stage import TwoStageDetector
-
-
-@DETECTORS.register_module()
-class FasterRCNN(TwoStageDetector):
-    """Implementation of `Faster R-CNN <https://arxiv.org/abs/1506.01497>`_"""
-
-    def __init__(self,
-                 backbone,
-                 rpn_head,
-                 roi_head,
-                 train_cfg,
-                 test_cfg,
-                 neck=None,
-                 pretrained=None):
-        super(FasterRCNN, self).__init__(
-            backbone=backbone,
-            neck=neck,
-            rpn_head=rpn_head,
-            roi_head=roi_head,
-            train_cfg=train_cfg,
-            test_cfg=test_cfg,
-            pretrained=pretrained)

spaces/Anonymous-123/ImageNet-Editing/object_removal/TFill/options/train_options.py

@@ -1,30 +0,0 @@
-from .base_options import BaseOptions
-
-
-class TrainOptions(BaseOptions):
-    def initialize(self, parser):
-        parser = BaseOptions.initialize(self, parser)
-
-        # training parameters
-        parser.add_argument('--iter_count', type=int, default=0, help='the starting epoch count')
-        parser.add_argument('--n_iter', type=int, default=20000000, help='# of iter with initial learning rate')
-        parser.add_argument('--n_iter_decay', type=int, default=00000000, help='# of iter to decay learning rate to zero')
-        parser.add_argument('--continue_train', action='store_true', help='continue training: load the latest model')
-        # learning rate and loss weight
-        parser.add_argument('--lr_policy', type=str, default='linear', help='learning rate policy[lambda|step|plateau]')
-        parser.add_argument('--lr', type=float, default=1e-4, help='initial learning rate for adam')
-        parser.add_argument('--beta1', type=float, default=0.5, help='momentum term of adam')
-        parser.add_argument('--beta2', type=float, default=0.9, help='momentum term of adam')
-        parser.add_argument('--gan_mode', type=str, default='nonsaturating', choices=['hinge', 'lsgan', 'standard', 'wgan-gp', 'nonsaturating'])
-        # display the results
-        parser.add_argument('--display_freq', type=int, default=1000, help='frequency of showing training results on screen')
-        parser.add_argument('--display_ncols', type=int, default=3, help='if positive, display all examples in a single visdom web panel with certain number of examples per row.')
-        parser.add_argument('--print_freq', type=int, default=1000, help='frequency of showing training results on console')
-        parser.add_argument('--update_html_freq', type=int, default=1000, help='frequency of saving training results to html')
-        parser.add_argument('--save_latest_freq', type=int, default=1000, help='frequency of saving the latest results')
-        parser.add_argument('--save_iters_freq', type=int, default=100000, help='frequency of saving checkpoints at the end of epochs')
-        parser.add_argument('--no_html', action='store_true', help='do not save intermediate training results')
-
-        self.isTrain = True
-
-        return parser

spaces/ArchitSharma/Digital-Photo-Color-Restoration/src/deoldify/save.py

@@ -1,29 +0,0 @@
-from fastai.basic_train import Learner, LearnerCallback
-from fastai.vision.gan import GANLearner
-
-
-class GANSaveCallback(LearnerCallback):
-    """A `LearnerCallback` that saves history of metrics while training `learn` into CSV `filename`."""
-
-    def __init__(
-        self,
-        learn: GANLearner,
-        learn_gen: Learner,
-        filename: str,
-        save_iters: int = 1000,
-    ):
-        super().__init__(learn)
-        self.learn_gen = learn_gen
-        self.filename = filename
-        self.save_iters = save_iters
-
-    def on_batch_end(self, iteration: int, epoch: int, **kwargs) -> None:
-        if iteration == 0:
-            return
-
-        if iteration % self.save_iters == 0:
-            self._save_gen_learner(iteration=iteration, epoch=epoch)
-
-    def _save_gen_learner(self, iteration: int, epoch: int):
-        filename = '{}_{}_{}'.format(self.filename, epoch, iteration)
-        self.learn_gen.save(filename)

spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_internal/index/package_finder.py

@@ -1,1029 +0,0 @@
-"""Routines related to PyPI, indexes"""
-
-import enum
-import functools
-import itertools
-import logging
-import re
-from typing import TYPE_CHECKING, FrozenSet, Iterable, List, Optional, Set, Tuple, Union
-
-from pip._vendor.packaging import specifiers
-from pip._vendor.packaging.tags import Tag
-from pip._vendor.packaging.utils import canonicalize_name
-from pip._vendor.packaging.version import _BaseVersion
-from pip._vendor.packaging.version import parse as parse_version
-
-from pip._internal.exceptions import (
-    BestVersionAlreadyInstalled,
-    DistributionNotFound,
-    InvalidWheelFilename,
-    UnsupportedWheel,
-)
-from pip._internal.index.collector import LinkCollector, parse_links
-from pip._internal.models.candidate import InstallationCandidate
-from pip._internal.models.format_control import FormatControl
-from pip._internal.models.link import Link
-from pip._internal.models.search_scope import SearchScope
-from pip._internal.models.selection_prefs import SelectionPreferences
-from pip._internal.models.target_python import TargetPython
-from pip._internal.models.wheel import Wheel
-from pip._internal.req import InstallRequirement
-from pip._internal.utils._log import getLogger
-from pip._internal.utils.filetypes import WHEEL_EXTENSION
-from pip._internal.utils.hashes import Hashes
-from pip._internal.utils.logging import indent_log
-from pip._internal.utils.misc import build_netloc
-from pip._internal.utils.packaging import check_requires_python
-from pip._internal.utils.unpacking import SUPPORTED_EXTENSIONS
-
-if TYPE_CHECKING:
-    from pip._vendor.typing_extensions import TypeGuard
-
-__all__ = ["FormatControl", "BestCandidateResult", "PackageFinder"]
-
-
-logger = getLogger(__name__)
-
-BuildTag = Union[Tuple[()], Tuple[int, str]]
-CandidateSortingKey = Tuple[int, int, int, _BaseVersion, Optional[int], BuildTag]
-
-
-def _check_link_requires_python(
-    link: Link,
-    version_info: Tuple[int, int, int],
-    ignore_requires_python: bool = False,
-) -> bool:
-    """
-    Return whether the given Python version is compatible with a link's
-    "Requires-Python" value.
-
-    :param version_info: A 3-tuple of ints representing the Python
-        major-minor-micro version to check.
-    :param ignore_requires_python: Whether to ignore the "Requires-Python"
-        value if the given Python version isn't compatible.
-    """
-    try:
-        is_compatible = check_requires_python(
-            link.requires_python,
-            version_info=version_info,
-        )
-    except specifiers.InvalidSpecifier:
-        logger.debug(
-            "Ignoring invalid Requires-Python (%r) for link: %s",
-            link.requires_python,
-            link,
-        )
-    else:
-        if not is_compatible:
-            version = ".".join(map(str, version_info))
-            if not ignore_requires_python:
-                logger.verbose(
-                    "Link requires a different Python (%s not in: %r): %s",
-                    version,
-                    link.requires_python,
-                    link,
-                )
-                return False
-
-            logger.debug(
-                "Ignoring failed Requires-Python check (%s not in: %r) for link: %s",
-                version,
-                link.requires_python,
-                link,
-            )
-
-    return True
-
-
-class LinkType(enum.Enum):
-    candidate = enum.auto()
-    different_project = enum.auto()
-    yanked = enum.auto()
-    format_unsupported = enum.auto()
-    format_invalid = enum.auto()
-    platform_mismatch = enum.auto()
-    requires_python_mismatch = enum.auto()
-
-
-class LinkEvaluator:
-
-    """
-    Responsible for evaluating links for a particular project.
-    """
-
-    _py_version_re = re.compile(r"-py([123]\.?[0-9]?)$")
-
-    # Don't include an allow_yanked default value to make sure each call
-    # site considers whether yanked releases are allowed. This also causes
-    # that decision to be made explicit in the calling code, which helps
-    # people when reading the code.
-    def __init__(
-        self,
-        project_name: str,
-        canonical_name: str,
-        formats: FrozenSet[str],
-        target_python: TargetPython,
-        allow_yanked: bool,
-        ignore_requires_python: Optional[bool] = None,
-    ) -> None:
-        """
-        :param project_name: The user supplied package name.
-        :param canonical_name: The canonical package name.
-        :param formats: The formats allowed for this package. Should be a set
-            with 'binary' or 'source' or both in it.
-        :param target_python: The target Python interpreter to use when
-            evaluating link compatibility. This is used, for example, to
-            check wheel compatibility, as well as when checking the Python
-            version, e.g. the Python version embedded in a link filename
-            (or egg fragment) and against an HTML link's optional PEP 503
-            "data-requires-python" attribute.
-        :param allow_yanked: Whether files marked as yanked (in the sense
-            of PEP 592) are permitted to be candidates for install.
-        :param ignore_requires_python: Whether to ignore incompatible
-            PEP 503 "data-requires-python" values in HTML links. Defaults
-            to False.
-        """
-        if ignore_requires_python is None:
-            ignore_requires_python = False
-
-        self._allow_yanked = allow_yanked
-        self._canonical_name = canonical_name
-        self._ignore_requires_python = ignore_requires_python
-        self._formats = formats
-        self._target_python = target_python
-
-        self.project_name = project_name
-
-    def evaluate_link(self, link: Link) -> Tuple[LinkType, str]:
-        """
-        Determine whether a link is a candidate for installation.
-
-        :return: A tuple (result, detail), where *result* is an enum
-            representing whether the evaluation found a candidate, or the reason
-            why one is not found. If a candidate is found, *detail* will be the
-            candidate's version string; if one is not found, it contains the
-            reason the link fails to qualify.
-        """
-        version = None
-        if link.is_yanked and not self._allow_yanked:
-            reason = link.yanked_reason or "<none given>"
-            return (LinkType.yanked, f"yanked for reason: {reason}")
-
-        if link.egg_fragment:
-            egg_info = link.egg_fragment
-            ext = link.ext
-        else:
-            egg_info, ext = link.splitext()
-            if not ext:
-                return (LinkType.format_unsupported, "not a file")
-            if ext not in SUPPORTED_EXTENSIONS:
-                return (
-                    LinkType.format_unsupported,
-                    f"unsupported archive format: {ext}",
-                )
-            if "binary" not in self._formats and ext == WHEEL_EXTENSION:
-                reason = f"No binaries permitted for {self.project_name}"
-                return (LinkType.format_unsupported, reason)
-            if "macosx10" in link.path and ext == ".zip":
-                return (LinkType.format_unsupported, "macosx10 one")
-            if ext == WHEEL_EXTENSION:
-                try:
-                    wheel = Wheel(link.filename)
-                except InvalidWheelFilename:
-                    return (
-                        LinkType.format_invalid,
-                        "invalid wheel filename",
-                    )
-                if canonicalize_name(wheel.name) != self._canonical_name:
-                    reason = f"wrong project name (not {self.project_name})"
-                    return (LinkType.different_project, reason)
-
-                supported_tags = self._target_python.get_tags()
-                if not wheel.supported(supported_tags):
-                    # Include the wheel's tags in the reason string to
-                    # simplify troubleshooting compatibility issues.
-                    file_tags = ", ".join(wheel.get_formatted_file_tags())
-                    reason = (
-                        f"none of the wheel's tags ({file_tags}) are compatible "
-                        f"(run pip debug --verbose to show compatible tags)"
-                    )
-                    return (LinkType.platform_mismatch, reason)
-
-                version = wheel.version
-
-        # This should be up by the self.ok_binary check, but see issue 2700.
-        if "source" not in self._formats and ext != WHEEL_EXTENSION:
-            reason = f"No sources permitted for {self.project_name}"
-            return (LinkType.format_unsupported, reason)
-
-        if not version:
-            version = _extract_version_from_fragment(
-                egg_info,
-                self._canonical_name,
-            )
-        if not version:
-            reason = f"Missing project version for {self.project_name}"
-            return (LinkType.format_invalid, reason)
-
-        match = self._py_version_re.search(version)
-        if match:
-            version = version[: match.start()]
-            py_version = match.group(1)
-            if py_version != self._target_python.py_version:
-                return (
-                    LinkType.platform_mismatch,
-                    "Python version is incorrect",
-                )
-
-        supports_python = _check_link_requires_python(
-            link,
-            version_info=self._target_python.py_version_info,
-            ignore_requires_python=self._ignore_requires_python,
-        )
-        if not supports_python:
-            reason = f"{version} Requires-Python {link.requires_python}"
-            return (LinkType.requires_python_mismatch, reason)
-
-        logger.debug("Found link %s, version: %s", link, version)
-
-        return (LinkType.candidate, version)
-
-
-def filter_unallowed_hashes(
-    candidates: List[InstallationCandidate],
-    hashes: Optional[Hashes],
-    project_name: str,
-) -> List[InstallationCandidate]:
-    """
-    Filter out candidates whose hashes aren't allowed, and return a new
-    list of candidates.
-
-    If at least one candidate has an allowed hash, then all candidates with
-    either an allowed hash or no hash specified are returned.  Otherwise,
-    the given candidates are returned.
-
-    Including the candidates with no hash specified when there is a match
-    allows a warning to be logged if there is a more preferred candidate
-    with no hash specified.  Returning all candidates in the case of no
-    matches lets pip report the hash of the candidate that would otherwise
-    have been installed (e.g. permitting the user to more easily update
-    their requirements file with the desired hash).
-    """
-    if not hashes:
-        logger.debug(
-            "Given no hashes to check %s links for project %r: "
-            "discarding no candidates",
-            len(candidates),
-            project_name,
-        )
-        # Make sure we're not returning back the given value.
-        return list(candidates)
-
-    matches_or_no_digest = []
-    # Collect the non-matches for logging purposes.
-    non_matches = []
-    match_count = 0
-    for candidate in candidates:
-        link = candidate.link
-        if not link.has_hash:
-            pass
-        elif link.is_hash_allowed(hashes=hashes):
-            match_count += 1
-        else:
-            non_matches.append(candidate)
-            continue
-
-        matches_or_no_digest.append(candidate)
-
-    if match_count:
-        filtered = matches_or_no_digest
-    else:
-        # Make sure we're not returning back the given value.
-        filtered = list(candidates)
-
-    if len(filtered) == len(candidates):
-        discard_message = "discarding no candidates"
-    else:
-        discard_message = "discarding {} non-matches:\n  {}".format(
-            len(non_matches),
-            "\n  ".join(str(candidate.link) for candidate in non_matches),
-        )
-
-    logger.debug(
-        "Checked %s links for project %r against %s hashes "
-        "(%s matches, %s no digest): %s",
-        len(candidates),
-        project_name,
-        hashes.digest_count,
-        match_count,
-        len(matches_or_no_digest) - match_count,
-        discard_message,
-    )
-
-    return filtered
-
-
-class CandidatePreferences:
-
-    """
-    Encapsulates some of the preferences for filtering and sorting
-    InstallationCandidate objects.
-    """
-
-    def __init__(
-        self,
-        prefer_binary: bool = False,
-        allow_all_prereleases: bool = False,
-    ) -> None:
-        """
-        :param allow_all_prereleases: Whether to allow all pre-releases.
-        """
-        self.allow_all_prereleases = allow_all_prereleases
-        self.prefer_binary = prefer_binary
-
-
-class BestCandidateResult:
-    """A collection of candidates, returned by `PackageFinder.find_best_candidate`.
-
-    This class is only intended to be instantiated by CandidateEvaluator's
-    `compute_best_candidate()` method.
-    """
-
-    def __init__(
-        self,
-        candidates: List[InstallationCandidate],
-        applicable_candidates: List[InstallationCandidate],
-        best_candidate: Optional[InstallationCandidate],
-    ) -> None:
-        """
-        :param candidates: A sequence of all available candidates found.
-        :param applicable_candidates: The applicable candidates.
-        :param best_candidate: The most preferred candidate found, or None
-            if no applicable candidates were found.
-        """
-        assert set(applicable_candidates) <= set(candidates)
-
-        if best_candidate is None:
-            assert not applicable_candidates
-        else:
-            assert best_candidate in applicable_candidates
-
-        self._applicable_candidates = applicable_candidates
-        self._candidates = candidates
-
-        self.best_candidate = best_candidate
-
-    def iter_all(self) -> Iterable[InstallationCandidate]:
-        """Iterate through all candidates."""
-        return iter(self._candidates)
-
-    def iter_applicable(self) -> Iterable[InstallationCandidate]:
-        """Iterate through the applicable candidates."""
-        return iter(self._applicable_candidates)
-
-
-class CandidateEvaluator:
-
-    """
-    Responsible for filtering and sorting candidates for installation based
-    on what tags are valid.
-    """
-
-    @classmethod
-    def create(
-        cls,
-        project_name: str,
-        target_python: Optional[TargetPython] = None,
-        prefer_binary: bool = False,
-        allow_all_prereleases: bool = False,
-        specifier: Optional[specifiers.BaseSpecifier] = None,
-        hashes: Optional[Hashes] = None,
-    ) -> "CandidateEvaluator":
-        """Create a CandidateEvaluator object.
-
-        :param target_python: The target Python interpreter to use when
-            checking compatibility. If None (the default), a TargetPython
-            object will be constructed from the running Python.
-        :param specifier: An optional object implementing `filter`
-            (e.g. `packaging.specifiers.SpecifierSet`) to filter applicable
-            versions.
-        :param hashes: An optional collection of allowed hashes.
-        """
-        if target_python is None:
-            target_python = TargetPython()
-        if specifier is None:
-            specifier = specifiers.SpecifierSet()
-
-        supported_tags = target_python.get_tags()
-
-        return cls(
-            project_name=project_name,
-            supported_tags=supported_tags,
-            specifier=specifier,
-            prefer_binary=prefer_binary,
-            allow_all_prereleases=allow_all_prereleases,
-            hashes=hashes,
-        )
-
-    def __init__(
-        self,
-        project_name: str,
-        supported_tags: List[Tag],
-        specifier: specifiers.BaseSpecifier,
-        prefer_binary: bool = False,
-        allow_all_prereleases: bool = False,
-        hashes: Optional[Hashes] = None,
-    ) -> None:
-        """
-        :param supported_tags: The PEP 425 tags supported by the target
-            Python in order of preference (most preferred first).
-        """
-        self._allow_all_prereleases = allow_all_prereleases
-        self._hashes = hashes
-        self._prefer_binary = prefer_binary
-        self._project_name = project_name
-        self._specifier = specifier
-        self._supported_tags = supported_tags
-        # Since the index of the tag in the _supported_tags list is used
-        # as a priority, precompute a map from tag to index/priority to be
-        # used in wheel.find_most_preferred_tag.
-        self._wheel_tag_preferences = {
-            tag: idx for idx, tag in enumerate(supported_tags)
-        }
-
-    def get_applicable_candidates(
-        self,
-        candidates: List[InstallationCandidate],
-    ) -> List[InstallationCandidate]:
-        """
-        Return the applicable candidates from a list of candidates.
-        """
-        # Using None infers from the specifier instead.
-        allow_prereleases = self._allow_all_prereleases or None
-        specifier = self._specifier
-        versions = {
-            str(v)
-            for v in specifier.filter(
-                # We turn the version object into a str here because otherwise
-                # when we're debundled but setuptools isn't, Python will see
-                # packaging.version.Version and
-                # pkg_resources._vendor.packaging.version.Version as different
-                # types. This way we'll use a str as a common data interchange
-                # format. If we stop using the pkg_resources provided specifier
-                # and start using our own, we can drop the cast to str().
-                (str(c.version) for c in candidates),
-                prereleases=allow_prereleases,
-            )
-        }
-
-        # Again, converting version to str to deal with debundling.
-        applicable_candidates = [c for c in candidates if str(c.version) in versions]
-
-        filtered_applicable_candidates = filter_unallowed_hashes(
-            candidates=applicable_candidates,
-            hashes=self._hashes,
-            project_name=self._project_name,
-        )
-
-        return sorted(filtered_applicable_candidates, key=self._sort_key)
-
-    def _sort_key(self, candidate: InstallationCandidate) -> CandidateSortingKey:
-        """
-        Function to pass as the `key` argument to a call to sorted() to sort
-        InstallationCandidates by preference.
-
-        Returns a tuple such that tuples sorting as greater using Python's
-        default comparison operator are more preferred.
-
-        The preference is as follows:
-
-        First and foremost, candidates with allowed (matching) hashes are
-        always preferred over candidates without matching hashes. This is
-        because e.g. if the only candidate with an allowed hash is yanked,
-        we still want to use that candidate.
-
-        Second, excepting hash considerations, candidates that have been
-        yanked (in the sense of PEP 592) are always less preferred than
-        candidates that haven't been yanked. Then:
-
-        If not finding wheels, they are sorted by version only.
-        If finding wheels, then the sort order is by version, then:
-          1. existing installs
-          2. wheels ordered via Wheel.support_index_min(self._supported_tags)
-          3. source archives
-        If prefer_binary was set, then all wheels are sorted above sources.
-
-        Note: it was considered to embed this logic into the Link
-              comparison operators, but then different sdist links
-              with the same version, would have to be considered equal
-        """
-        valid_tags = self._supported_tags
-        support_num = len(valid_tags)
-        build_tag: BuildTag = ()
-        binary_preference = 0
-        link = candidate.link
-        if link.is_wheel:
-            # can raise InvalidWheelFilename
-            wheel = Wheel(link.filename)
-            try:
-                pri = -(
-                    wheel.find_most_preferred_tag(
-                        valid_tags, self._wheel_tag_preferences
-                    )
-                )
-            except ValueError:
-                raise UnsupportedWheel(
-                    "{} is not a supported wheel for this platform. It "
-                    "can't be sorted.".format(wheel.filename)
-                )
-            if self._prefer_binary:
-                binary_preference = 1
-            if wheel.build_tag is not None:
-                match = re.match(r"^(\d+)(.*)$", wheel.build_tag)
-                assert match is not None, "guaranteed by filename validation"
-                build_tag_groups = match.groups()
-                build_tag = (int(build_tag_groups[0]), build_tag_groups[1])
-        else:  # sdist
-            pri = -(support_num)
-        has_allowed_hash = int(link.is_hash_allowed(self._hashes))
-        yank_value = -1 * int(link.is_yanked)  # -1 for yanked.
-        return (
-            has_allowed_hash,
-            yank_value,
-            binary_preference,
-            candidate.version,
-            pri,
-            build_tag,
-        )
-
-    def sort_best_candidate(
-        self,
-        candidates: List[InstallationCandidate],
-    ) -> Optional[InstallationCandidate]:
-        """
-        Return the best candidate per the instance's sort order, or None if
-        no candidate is acceptable.
-        """
-        if not candidates:
-            return None
-        best_candidate = max(candidates, key=self._sort_key)
-        return best_candidate
-
-    def compute_best_candidate(
-        self,
-        candidates: List[InstallationCandidate],
-    ) -> BestCandidateResult:
-        """
-        Compute and return a `BestCandidateResult` instance.
-        """
-        applicable_candidates = self.get_applicable_candidates(candidates)
-
-        best_candidate = self.sort_best_candidate(applicable_candidates)
-
-        return BestCandidateResult(
-            candidates,
-            applicable_candidates=applicable_candidates,
-            best_candidate=best_candidate,
-        )
-
-
-class PackageFinder:
-    """This finds packages.
-
-    This is meant to match easy_install's technique for looking for
-    packages, by reading pages and looking for appropriate links.
-    """
-
-    def __init__(
-        self,
-        link_collector: LinkCollector,
-        target_python: TargetPython,
-        allow_yanked: bool,
-        format_control: Optional[FormatControl] = None,
-        candidate_prefs: Optional[CandidatePreferences] = None,
-        ignore_requires_python: Optional[bool] = None,
-    ) -> None:
-        """
-        This constructor is primarily meant to be used by the create() class
-        method and from tests.
-
-        :param format_control: A FormatControl object, used to control
-            the selection of source packages / binary packages when consulting
-            the index and links.
-        :param candidate_prefs: Options to use when creating a
-            CandidateEvaluator object.
-        """
-        if candidate_prefs is None:
-            candidate_prefs = CandidatePreferences()
-
-        format_control = format_control or FormatControl(set(), set())
-
-        self._allow_yanked = allow_yanked
-        self._candidate_prefs = candidate_prefs
-        self._ignore_requires_python = ignore_requires_python
-        self._link_collector = link_collector
-        self._target_python = target_python
-
-        self.format_control = format_control
-
-        # These are boring links that have already been logged somehow.
-        self._logged_links: Set[Tuple[Link, LinkType, str]] = set()
-
-    # Don't include an allow_yanked default value to make sure each call
-    # site considers whether yanked releases are allowed. This also causes
-    # that decision to be made explicit in the calling code, which helps
-    # people when reading the code.
-    @classmethod
-    def create(
-        cls,
-        link_collector: LinkCollector,
-        selection_prefs: SelectionPreferences,
-        target_python: Optional[TargetPython] = None,
-    ) -> "PackageFinder":
-        """Create a PackageFinder.
-
-        :param selection_prefs: The candidate selection preferences, as a
-            SelectionPreferences object.
-        :param target_python: The target Python interpreter to use when
-            checking compatibility. If None (the default), a TargetPython
-            object will be constructed from the running Python.
-        """
-        if target_python is None:
-            target_python = TargetPython()
-
-        candidate_prefs = CandidatePreferences(
-            prefer_binary=selection_prefs.prefer_binary,
-            allow_all_prereleases=selection_prefs.allow_all_prereleases,
-        )
-
-        return cls(
-            candidate_prefs=candidate_prefs,
-            link_collector=link_collector,
-            target_python=target_python,
-            allow_yanked=selection_prefs.allow_yanked,
-            format_control=selection_prefs.format_control,
-            ignore_requires_python=selection_prefs.ignore_requires_python,
-        )
-
-    @property
-    def target_python(self) -> TargetPython:
-        return self._target_python
-
-    @property
-    def search_scope(self) -> SearchScope:
-        return self._link_collector.search_scope
-
-    @search_scope.setter
-    def search_scope(self, search_scope: SearchScope) -> None:
-        self._link_collector.search_scope = search_scope
-
-    @property
-    def find_links(self) -> List[str]:
-        return self._link_collector.find_links
-
-    @property
-    def index_urls(self) -> List[str]:
-        return self.search_scope.index_urls
-
-    @property
-    def trusted_hosts(self) -> Iterable[str]:
-        for host_port in self._link_collector.session.pip_trusted_origins:
-            yield build_netloc(*host_port)
-
-    @property
-    def allow_all_prereleases(self) -> bool:
-        return self._candidate_prefs.allow_all_prereleases
-
-    def set_allow_all_prereleases(self) -> None:
-        self._candidate_prefs.allow_all_prereleases = True
-
-    @property
-    def prefer_binary(self) -> bool:
-        return self._candidate_prefs.prefer_binary
-
-    def set_prefer_binary(self) -> None:
-        self._candidate_prefs.prefer_binary = True
-
-    def requires_python_skipped_reasons(self) -> List[str]:
-        reasons = {
-            detail
-            for _, result, detail in self._logged_links
-            if result == LinkType.requires_python_mismatch
-        }
-        return sorted(reasons)
-
-    def make_link_evaluator(self, project_name: str) -> LinkEvaluator:
-        canonical_name = canonicalize_name(project_name)
-        formats = self.format_control.get_allowed_formats(canonical_name)
-
-        return LinkEvaluator(
-            project_name=project_name,
-            canonical_name=canonical_name,
-            formats=formats,
-            target_python=self._target_python,
-            allow_yanked=self._allow_yanked,
-            ignore_requires_python=self._ignore_requires_python,
-        )
-
-    def _sort_links(self, links: Iterable[Link]) -> List[Link]:
-        """
-        Returns elements of links in order, non-egg links first, egg links
-        second, while eliminating duplicates
-        """
-        eggs, no_eggs = [], []
-        seen: Set[Link] = set()
-        for link in links:
-            if link not in seen:
-                seen.add(link)
-                if link.egg_fragment:
-                    eggs.append(link)
-                else:
-                    no_eggs.append(link)
-        return no_eggs + eggs
-
-    def _log_skipped_link(self, link: Link, result: LinkType, detail: str) -> None:
-        entry = (link, result, detail)
-        if entry not in self._logged_links:
-            # Put the link at the end so the reason is more visible and because
-            # the link string is usually very long.
-            logger.debug("Skipping link: %s: %s", detail, link)
-            self._logged_links.add(entry)
-
-    def get_install_candidate(
-        self, link_evaluator: LinkEvaluator, link: Link
-    ) -> Optional[InstallationCandidate]:
-        """
-        If the link is a candidate for install, convert it to an
-        InstallationCandidate and return it. Otherwise, return None.
-        """
-        result, detail = link_evaluator.evaluate_link(link)
-        if result != LinkType.candidate:
-            self._log_skipped_link(link, result, detail)
-            return None
-
-        return InstallationCandidate(
-            name=link_evaluator.project_name,
-            link=link,
-            version=detail,
-        )
-
-    def evaluate_links(
-        self, link_evaluator: LinkEvaluator, links: Iterable[Link]
-    ) -> List[InstallationCandidate]:
-        """
-        Convert links that are candidates to InstallationCandidate objects.
-        """
-        candidates = []
-        for link in self._sort_links(links):
-            candidate = self.get_install_candidate(link_evaluator, link)
-            if candidate is not None:
-                candidates.append(candidate)
-
-        return candidates
-
-    def process_project_url(
-        self, project_url: Link, link_evaluator: LinkEvaluator
-    ) -> List[InstallationCandidate]:
-        logger.debug(
-            "Fetching project page and analyzing links: %s",
-            project_url,
-        )
-        index_response = self._link_collector.fetch_response(project_url)
-        if index_response is None:
-            return []
-
-        page_links = list(parse_links(index_response))
-
-        with indent_log():
-            package_links = self.evaluate_links(
-                link_evaluator,
-                links=page_links,
-            )
-
-        return package_links
-
-    @functools.lru_cache(maxsize=None)
-    def find_all_candidates(self, project_name: str) -> List[InstallationCandidate]:
-        """Find all available InstallationCandidate for project_name
-
-        This checks index_urls and find_links.
-        All versions found are returned as an InstallationCandidate list.
-
-        See LinkEvaluator.evaluate_link() for details on which files
-        are accepted.
-        """
-        link_evaluator = self.make_link_evaluator(project_name)
-
-        collected_sources = self._link_collector.collect_sources(
-            project_name=project_name,
-            candidates_from_page=functools.partial(
-                self.process_project_url,
-                link_evaluator=link_evaluator,
-            ),
-        )
-
-        page_candidates_it = itertools.chain.from_iterable(
-            source.page_candidates()
-            for sources in collected_sources
-            for source in sources
-            if source is not None
-        )
-        page_candidates = list(page_candidates_it)
-
-        file_links_it = itertools.chain.from_iterable(
-            source.file_links()
-            for sources in collected_sources
-            for source in sources
-            if source is not None
-        )
-        file_candidates = self.evaluate_links(
-            link_evaluator,
-            sorted(file_links_it, reverse=True),
-        )
-
-        if logger.isEnabledFor(logging.DEBUG) and file_candidates:
-            paths = []
-            for candidate in file_candidates:
-                assert candidate.link.url  # we need to have a URL
-                try:
-                    paths.append(candidate.link.file_path)
-                except Exception:
-                    paths.append(candidate.link.url)  # it's not a local file
-
-            logger.debug("Local files found: %s", ", ".join(paths))
-
-        # This is an intentional priority ordering
-        return file_candidates + page_candidates
-
-    def make_candidate_evaluator(
-        self,
-        project_name: str,
-        specifier: Optional[specifiers.BaseSpecifier] = None,
-        hashes: Optional[Hashes] = None,
-    ) -> CandidateEvaluator:
-        """Create a CandidateEvaluator object to use."""
-        candidate_prefs = self._candidate_prefs
-        return CandidateEvaluator.create(
-            project_name=project_name,
-            target_python=self._target_python,
-            prefer_binary=candidate_prefs.prefer_binary,
-            allow_all_prereleases=candidate_prefs.allow_all_prereleases,
-            specifier=specifier,
-            hashes=hashes,
-        )
-
-    @functools.lru_cache(maxsize=None)
-    def find_best_candidate(
-        self,
-        project_name: str,
-        specifier: Optional[specifiers.BaseSpecifier] = None,
-        hashes: Optional[Hashes] = None,
-    ) -> BestCandidateResult:
-        """Find matches for the given project and specifier.
-
-        :param specifier: An optional object implementing `filter`
-            (e.g. `packaging.specifiers.SpecifierSet`) to filter applicable
-            versions.
-
-        :return: A `BestCandidateResult` instance.
-        """
-        candidates = self.find_all_candidates(project_name)
-        candidate_evaluator = self.make_candidate_evaluator(
-            project_name=project_name,
-            specifier=specifier,
-            hashes=hashes,
-        )
-        return candidate_evaluator.compute_best_candidate(candidates)
-
-    def find_requirement(
-        self, req: InstallRequirement, upgrade: bool
-    ) -> Optional[InstallationCandidate]:
-        """Try to find a Link matching req
-
-        Expects req, an InstallRequirement and upgrade, a boolean
-        Returns a InstallationCandidate if found,
-        Raises DistributionNotFound or BestVersionAlreadyInstalled otherwise
-        """
-        hashes = req.hashes(trust_internet=False)
-        best_candidate_result = self.find_best_candidate(
-            req.name,
-            specifier=req.specifier,
-            hashes=hashes,
-        )
-        best_candidate = best_candidate_result.best_candidate
-
-        installed_version: Optional[_BaseVersion] = None
-        if req.satisfied_by is not None:
-            installed_version = req.satisfied_by.version
-
-        def _format_versions(cand_iter: Iterable[InstallationCandidate]) -> str:
-            # This repeated parse_version and str() conversion is needed to
-            # handle different vendoring sources from pip and pkg_resources.
-            # If we stop using the pkg_resources provided specifier and start
-            # using our own, we can drop the cast to str().
-            return (
-                ", ".join(
-                    sorted(
-                        {str(c.version) for c in cand_iter},
-                        key=parse_version,
-                    )
-                )
-                or "none"
-            )
-
-        if installed_version is None and best_candidate is None:
-            logger.critical(
-                "Could not find a version that satisfies the requirement %s "
-                "(from versions: %s)",
-                req,
-                _format_versions(best_candidate_result.iter_all()),
-            )
-
-            raise DistributionNotFound(
-                "No matching distribution found for {}".format(req)
-            )
-
-        def _should_install_candidate(
-            candidate: Optional[InstallationCandidate],
-        ) -> "TypeGuard[InstallationCandidate]":
-            if installed_version is None:
-                return True
-            if best_candidate is None:
-                return False
-            return best_candidate.version > installed_version
-
-        if not upgrade and installed_version is not None:
-            if _should_install_candidate(best_candidate):
-                logger.debug(
-                    "Existing installed version (%s) satisfies requirement "
-                    "(most up-to-date version is %s)",
-                    installed_version,
-                    best_candidate.version,
-                )
-            else:
-                logger.debug(
-                    "Existing installed version (%s) is most up-to-date and "
-                    "satisfies requirement",
-                    installed_version,
-                )
-            return None
-
-        if _should_install_candidate(best_candidate):
-            logger.debug(
-                "Using version %s (newest of versions: %s)",
-                best_candidate.version,
-                _format_versions(best_candidate_result.iter_applicable()),
-            )
-            return best_candidate
-
-        # We have an existing version, and its the best version
-        logger.debug(
-            "Installed version (%s) is most up-to-date (past versions: %s)",
-            installed_version,
-            _format_versions(best_candidate_result.iter_applicable()),
-        )
-        raise BestVersionAlreadyInstalled
-
-
-def _find_name_version_sep(fragment: str, canonical_name: str) -> int:
-    """Find the separator's index based on the package's canonical name.
-
-    :param fragment: A <package>+<version> filename "fragment" (stem) or
-        egg fragment.
-    :param canonical_name: The package's canonical name.
-
-    This function is needed since the canonicalized name does not necessarily
-    have the same length as the egg info's name part. An example::
-
-    >>> fragment = 'foo__bar-1.0'
-    >>> canonical_name = 'foo-bar'
-    >>> _find_name_version_sep(fragment, canonical_name)
-    8
-    """
-    # Project name and version must be separated by one single dash. Find all
-    # occurrences of dashes; if the string in front of it matches the canonical
-    # name, this is the one separating the name and version parts.
-    for i, c in enumerate(fragment):
-        if c != "-":
-            continue
-        if canonicalize_name(fragment[:i]) == canonical_name:
-            return i
-    raise ValueError(f"{fragment} does not match {canonical_name}")
-
-
-def _extract_version_from_fragment(fragment: str, canonical_name: str) -> Optional[str]:
-    """Parse the version string from a <package>+<version> filename
-    "fragment" (stem) or egg fragment.
-
-    :param fragment: The string to parse. E.g. foo-2.1
-    :param canonical_name: The canonicalized name of the package this
-        belongs to.
-    """
-    try:
-        version_start = _find_name_version_sep(fragment, canonical_name) + 1
-    except ValueError:
-        return None
-    version = fragment[version_start:]
-    if not version:
-        return None
-    return version

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

@@ -1,33 +0,0 @@
-from abc import ABC
-
-
-class RichRenderable(ABC):
-    """An abstract base class for Rich renderables.
-
-    Note that there is no need to extend this class, the intended use is to check if an
-    object supports the Rich renderable protocol. For example::
-
-        if isinstance(my_object, RichRenderable):
-            console.print(my_object)
-
-    """
-
-    @classmethod
-    def __subclasshook__(cls, other: type) -> bool:
-        """Check if this class supports the rich render protocol."""
-        return hasattr(other, "__rich_console__") or hasattr(other, "__rich__")
-
-
-if __name__ == "__main__":  # pragma: no cover
-    from pip._vendor.rich.text import Text
-
-    t = Text()
-    print(isinstance(Text, RichRenderable))
-    print(isinstance(t, RichRenderable))
-
-    class Foo:
-        pass
-
-    f = Foo()
-    print(isinstance(f, RichRenderable))
-    print(isinstance("", RichRenderable))

spaces/Audio-AGI/WavJourney/scripts/kill_services.py

@@ -1,11 +0,0 @@
-import os
-
-# Extract values for each application
-service_port = os.environ.get('WAVJOURNEY_SERVICE_PORT')
-
-# Execute the commands 
-os.system(f'kill $(lsof -t -i :{service_port})')
-
-
-
-

spaces/Audio-AGI/WavJourney/share_btn.py

@@ -1,74 +0,0 @@
-community_icon_html = """<svg id="share-btn-share-icon" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" focusable="false" role="img" width="1em" height="1em" preserveAspectRatio="xMidYMid meet" viewBox="0 0 32 32">
-    <path d="M20.6081 3C21.7684 3 22.8053 3.49196 23.5284 4.38415C23.9756 4.93678 24.4428 5.82749 24.4808 7.16133C24.9674 7.01707 25.4353 6.93643 25.8725 6.93643C26.9833 6.93643 27.9865 7.37587 28.696 8.17411C29.6075 9.19872 30.0124 10.4579 29.8361 11.7177C29.7523 12.3177 29.5581 12.8555 29.2678 13.3534C29.8798 13.8646 30.3306 14.5763 30.5485 15.4322C30.719 16.1032 30.8939 17.5006 29.9808 18.9403C30.0389 19.0342 30.0934 19.1319 30.1442 19.2318C30.6932 20.3074 30.7283 21.5229 30.2439 22.6548C29.5093 24.3704 27.6841 25.7219 24.1397 27.1727C21.9347 28.0753 19.9174 28.6523 19.8994 28.6575C16.9842 29.4379 14.3477 29.8345 12.0653 29.8345C7.87017 29.8345 4.8668 28.508 3.13831 25.8921C0.356375 21.6797 0.754104 17.8269 4.35369 14.1131C6.34591 12.058 7.67023 9.02782 7.94613 8.36275C8.50224 6.39343 9.97271 4.20438 12.4172 4.20438H12.4179C12.6236 4.20438 12.8314 4.2214 13.0364 4.25468C14.107 4.42854 15.0428 5.06476 15.7115 6.02205C16.4331 5.09583 17.134 4.359 17.7682 3.94323C18.7242 3.31737 19.6794 3 20.6081 3ZM20.6081 5.95917C20.2427 5.95917 19.7963 6.1197 19.3039 6.44225C17.7754 7.44319 14.8258 12.6772 13.7458 14.7131C13.3839 15.3952 12.7655 15.6837 12.2086 15.6837C11.1036 15.6837 10.2408 14.5497 12.1076 13.1085C14.9146 10.9402 13.9299 7.39584 12.5898 7.1776C12.5311 7.16799 12.4731 7.16355 12.4172 7.16355C11.1989 7.16355 10.6615 9.33114 10.6615 9.33114C10.6615 9.33114 9.0863 13.4148 6.38031 16.206C3.67434 18.998 3.5346 21.2388 5.50675 24.2246C6.85185 26.2606 9.42666 26.8753 12.0653 26.8753C14.8021 26.8753 17.6077 26.2139 19.1799 25.793C19.2574 25.7723 28.8193 22.984 27.6081 20.6107C27.4046 20.212 27.0693 20.0522 26.6471 20.0522C24.9416 20.0522 21.8393 22.6726 20.5057 22.6726C20.2076 22.6726 19.9976 22.5416 19.9116 22.222C19.3433 20.1173 28.552 19.2325 27.7758 16.1839C27.639 15.6445 27.2677 15.4256 26.746 15.4263C24.4923 15.4263 19.4358 19.5181 18.3759 19.5181C18.2949 19.5181 18.2368 19.4937 18.2053 19.4419C17.6743 18.557 17.9653 17.9394 21.7082 15.6009C25.4511 13.2617 28.0783 11.8545 26.5841 10.1752C26.4121 9.98141 26.1684 9.8956 25.8725 9.8956C23.6001 9.89634 18.2311 14.9403 18.2311 14.9403C18.2311 14.9403 16.7821 16.496 15.9057 16.496C15.7043 16.496 15.533 16.4139 15.4169 16.2112C14.7956 15.1296 21.1879 10.1286 21.5484 8.06535C21.7928 6.66715 21.3771 5.95917 20.6081 5.95917Z" fill="#FF9D00"></path>
-    <path d="M5.50686 24.2246C3.53472 21.2387 3.67446 18.9979 6.38043 16.206C9.08641 13.4147 10.6615 9.33111 10.6615 9.33111C10.6615 9.33111 11.2499 6.95933 12.59 7.17757C13.93 7.39581 14.9139 10.9401 12.1069 13.1084C9.29997 15.276 12.6659 16.7489 13.7459 14.713C14.8258 12.6772 17.7747 7.44316 19.304 6.44221C20.8326 5.44128 21.9089 6.00204 21.5484 8.06532C21.188 10.1286 14.795 15.1295 15.4171 16.2118C16.0391 17.2934 18.2312 14.9402 18.2312 14.9402C18.2312 14.9402 25.0907 8.49588 26.5842 10.1752C28.0776 11.8545 25.4512 13.2616 21.7082 15.6008C17.9646 17.9393 17.6744 18.557 18.2054 19.4418C18.7372 20.3266 26.9998 13.1351 27.7759 16.1838C28.5513 19.2324 19.3434 20.1173 19.9117 22.2219C20.48 24.3274 26.3979 18.2382 27.6082 20.6107C28.8193 22.9839 19.2574 25.7722 19.18 25.7929C16.0914 26.62 8.24723 28.3726 5.50686 24.2246Z" fill="#FFD21E"></path>
-</svg>"""
-
-loading_icon_html = """<svg id="share-btn-loading-icon" style="display:none;" class="animate-spin"
-   style="color: #ffffff; 
-"
-   xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" fill="none" focusable="false" role="img" width="1em" height="1em" preserveAspectRatio="xMidYMid meet" viewBox="0 0 24 24"><circle style="opacity: 0.25;" cx="12" cy="12" r="10" stroke="white" stroke-width="4"></circle><path style="opacity: 0.75;" fill="white" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path></svg>"""
-
-share_js = """async () => {
-	async function uploadFile(file){
-		const UPLOAD_URL = 'https://huggingface.co/uploads';
-		const response = await fetch(UPLOAD_URL, {
-			method: 'POST',
-			headers: {
-				'Content-Type': file.type,
-				'X-Requested-With': 'XMLHttpRequest',
-			},
-			body: file, /// <- File inherits from Blob
-		});
-		const url = await response.text();
-		return url;
-	}
-    async function getInputVideoFile(videoEl){
-        const res = await fetch(videoEl.src);
-        const blob = await res.blob();
-        const videoId = Date.now() % 200;
-        const fileName = `sd-perception-${videoId}.mp4`;
-        return new File([blob], fileName, { type: 'video/mp4' }); 
-	}
-    
-    async function audioToBase64(audioFile) {
-        return new Promise((resolve, reject) => {
-            let reader = new FileReader();
-            reader.readAsDataURL(audioFile);
-            reader.onload = () => resolve(reader.result);
-            reader.onerror = error => reject(error);
-          
-        });
-      }
-    const gradioEl = document.querySelector("gradio-app").shadowRoot || document.querySelector('body > gradio-app');
-    const inputPromptEl = gradioEl.querySelector('#prompt-in textarea').value;
-    const outputVideoEl = gradioEl.querySelector('#output-video video');
-    
-    let titleTxt = `WavJourney: ${inputPromptEl}`;
-
-    const shareBtnEl = gradioEl.querySelector('#share-btn');
-    const shareIconEl = gradioEl.querySelector('#share-btn-share-icon');
-    const loadingIconEl = gradioEl.querySelector('#share-btn-loading-icon');
-    if(!outputVideoEl){
-        return;
-    };
-    shareBtnEl.style.pointerEvents = 'none';
-    shareIconEl.style.display = 'none';
-    loadingIconEl.style.removeProperty('display');
-    const outputVideo = await getInputVideoFile(outputVideoEl);
-    const urlOutputVideo = await uploadFile(outputVideo);
-    
-    const descriptionMd = `
-##### ${inputPromptEl}
-    
-${urlOutputVideo}
-`;
-    const params = new URLSearchParams({
-        title: titleTxt,
-        description: descriptionMd,
-    });
-	const paramsStr = params.toString();
-	window.open(`https://huggingface.co/spaces/Audio-AGI/WavJourney/discussions/new?${paramsStr}`, '_blank');
-    shareBtnEl.style.removeProperty('pointer-events');
-    shareIconEl.style.removeProperty('display');
-    loadingIconEl.style.display = 'none';
-}"""

spaces/Awesimo/jojogan/e4e/criteria/lpips/utils.py

@@ -1,30 +0,0 @@
-from collections import OrderedDict
-
-import torch
-
-
-def normalize_activation(x, eps=1e-10):
-    norm_factor = torch.sqrt(torch.sum(x ** 2, dim=1, keepdim=True))
-    return x / (norm_factor + eps)
-
-
-def get_state_dict(net_type: str = 'alex', version: str = '0.1'):
-    # build url
-    url = 'https://raw.githubusercontent.com/richzhang/PerceptualSimilarity/' \
-        + f'master/lpips/weights/v{version}/{net_type}.pth'
-
-    # download
-    old_state_dict = torch.hub.load_state_dict_from_url(
-        url, progress=True,
-        map_location=None if torch.cuda.is_available() else torch.device('cpu')
-    )
-
-    # rename keys
-    new_state_dict = OrderedDict()
-    for key, val in old_state_dict.items():
-        new_key = key
-        new_key = new_key.replace('lin', '')
-        new_key = new_key.replace('model.', '')
-        new_state_dict[new_key] = val
-
-    return new_state_dict

spaces/Bart92/RVC_HF/julius/fftconv.py

@@ -1,183 +0,0 @@
-# File under the MIT license, see https://github.com/adefossez/julius/LICENSE for details.
-# Author: adefossez, 2020
-
-"""
-Implementation of a FFT based 1D convolution in PyTorch.
-While FFT is used in CUDNN for small kernel sizes, it is not the case for long ones, e.g. 512.
-This module implements efficient FFT based convolutions for such convolutions. A typical
-application is for evaluationg FIR filters with a long receptive field, typically
-evaluated with a stride of 1.
-"""
-from typing import Optional
-
-import torch
-try:
-    import torch.fft as new_fft
-except ImportError:
-    new_fft = None  # type: ignore
-from torch.nn import functional as F
-
-from .core import pad_to, unfold
-from .utils import simple_repr
-
-
-# This is quite verbose, but sadly needed to make TorchScript happy.
-def _new_rfft(x: torch.Tensor):
-    z = new_fft.rfft(x, dim=-1)
-    return torch.view_as_real(z)
-
-
-def _old_rfft(x: torch.Tensor):
-    return torch.rfft(x, 1)  # type: ignore
-
-
-def _old_irfft(x: torch.Tensor, length: int):
-    result = torch.irfft(x, 1, signal_sizes=(length,))  # type: ignore
-    return result
-
-
-def _new_irfft(x: torch.Tensor, length: int):
-    x = torch.view_as_complex(x)
-    return new_fft.irfft(x, length, dim=-1)
-
-
-if new_fft is None:
-    _rfft = _old_rfft
-    _irfft = _old_irfft
-else:
-    _rfft = _new_rfft
-    _irfft = _new_irfft
-
-
-def _compl_mul_conjugate(a: torch.Tensor, b: torch.Tensor):
-    """
-    Given a and b two tensors of dimension 4
-    with the last dimension being the real and imaginary part,
-    returns a multiplied by the conjugate of b, the multiplication
-    being with respect to the second dimension.
-
-    """
-    # PyTorch 1.7 supports complex number, but not for all operations.
-    # Once the support is widespread, this can likely go away.
-
-    op = "bcft,dct->bdft"
-    return torch.stack([
-        torch.einsum(op, a[..., 0], b[..., 0]) + torch.einsum(op, a[..., 1], b[..., 1]),
-        torch.einsum(op, a[..., 1], b[..., 0]) - torch.einsum(op, a[..., 0], b[..., 1])
-    ],
-                       dim=-1)
-
-
-def fft_conv1d(
-        input: torch.Tensor, weight: torch.Tensor,
-        bias: Optional[torch.Tensor] = None, stride: int = 1, padding: int = 0,
-        block_ratio: float = 5):
-    """
-    Same as `torch.nn.functional.conv1d` but using FFT for the convolution.
-    Please check PyTorch documentation for more information.
-
-    Args:
-        input (Tensor): input signal of shape `[B, C, T]`.
-        weight (Tensor): weight of the convolution `[D, C, K]` with `D` the number
-            of output channels.
-        bias (Tensor or None): if not None, bias term for the convolution.
-        stride (int): stride of convolution.
-        padding (int): padding to apply to the input.
-        block_ratio (float): can be tuned for speed. The input is splitted in chunks
-            with a size of `int(block_ratio * kernel_size)`.
-
-    Shape:
-
-        - Inputs: `input` is `[B, C, T]`, `weight` is `[D, C, K]` and bias is `[D]`.
-        - Output: `(*, T)`
-
-
-    ..note::
-        This function is faster than `torch.nn.functional.conv1d` only in specific cases.
-        Typically, the kernel size should be of the order of 256 to see any real gain,
-        for a stride of 1.
-
-    ..Warning::
-        Dilation and groups are not supported at the moment. This function might use
-        more memory than the default Conv1d implementation.
-    """
-    input = F.pad(input, (padding, padding))
-    batch, channels, length = input.shape
-    out_channels, _, kernel_size = weight.shape
-
-    if length < kernel_size:
-        raise RuntimeError(f"Input should be at least as large as the kernel size {kernel_size}, "
-                           f"but it is only {length} samples long.")
-    if block_ratio < 1:
-        raise RuntimeError("Block ratio must be greater than 1.")
-
-    # We are going to process the input blocks by blocks, as for some reason it is faster
-    # and less memory intensive (I think the culprit is `torch.einsum`.
-    block_size: int = min(int(kernel_size * block_ratio), length)
-    fold_stride = block_size - kernel_size + 1
-    weight = pad_to(weight, block_size)
-    weight_z = _rfft(weight)
-
-    # We pad the input and get the different frames, on which
-    frames = unfold(input, block_size, fold_stride)
-
-    frames_z = _rfft(frames)
-    out_z = _compl_mul_conjugate(frames_z, weight_z)
-    out = _irfft(out_z, block_size)
-    # The last bit is invalid, because FFT will do a circular convolution.
-    out = out[..., :-kernel_size + 1]
-    out = out.reshape(batch, out_channels, -1)
-    out = out[..., ::stride]
-    target_length = (length - kernel_size) // stride + 1
-    out = out[..., :target_length]
-    if bias is not None:
-        out += bias[:, None]
-    return out
-
-
-class FFTConv1d(torch.nn.Module):
-    """
-    Same as `torch.nn.Conv1d` but based on `fft_conv1d`.
-    Please check PyTorch documentation for more information.
-
-    Args:
-        in_channels (int): number of input channels.
-        out_channels (int): number of output channels.
-        kernel_size (int): kernel size of convolution.
-        stride (int): stride of convolution.
-        padding (int): padding to apply to the input.
-        bias (bool): if True, use a bias term.
-
-    ..note::
-        This module is faster than `torch.nn.Conv1d` only in specific cases.
-        Typically, `kernel_size` should be of the order of 256 to see any real gain,
-        for a stride of 1.
-
-    ..warning::
-        Dilation and groups are not supported at the moment. This module might use
-        more memory than the default Conv1d implementation.
-
-    >>> fftconv = FFTConv1d(12, 24, 128, 4)
-    >>> x = torch.randn(4, 12, 1024)
-    >>> print(list(fftconv(x).shape))
-    [4, 24, 225]
-    """
-    def __init__(self, in_channels: int, out_channels: int, kernel_size: int,
-                 stride: int = 1, padding: int = 0, bias: bool = True):
-        super().__init__()
-        self.in_channels = in_channels
-        self.out_channels = out_channels
-        self.kernel_size = kernel_size
-        self.stride = stride
-        self.padding = padding
-
-        conv = torch.nn.Conv1d(in_channels, out_channels, kernel_size, bias=bias)
-        self.weight = conv.weight
-        self.bias = conv.bias
-
-    def forward(self, input: torch.Tensor):
-        return fft_conv1d(
-            input, self.weight, self.bias, self.stride, self.padding)
-
-    def __repr__(self):
-        return simple_repr(self, overrides={"bias": self.bias is not None})

spaces/Benson/text-generation/Examples/Aqu Vamos Apk Versin Antigua.md

@@ -1,107 +0,0 @@
-
-<h1>Go Navigation APK: Una aplicación complementaria para Google Maps Go</h1>
-<p>Si usted está buscando una aplicación de navegación ligera y rápida para su dispositivo Android, es posible que desee echa un vistazo a Go Navigation APK. Esta es una aplicación complementaria que funciona con Google Maps Go, una versión web de Google Maps que está diseñada para dispositivos de gama baja y conexiones a Internet lentas. En este artículo, explicaremos lo que es Go Navigation APK, cómo descargarlo e instalarlo, cómo usarlo con Google Maps Go, y qué beneficios ofrece. También lo compararemos con otras aplicaciones de navegación populares y responderemos algunas preguntas frecuentes al respecto. </p>
- <h2>¿Qué es Go Navigation APK? </h2>
-<p>Go Navigation APK es una aplicación que proporciona en tiempo real, giro a giro de navegación para Google Maps Go. No es una aplicación independiente, sino una aplicación complementaria que funciona junto con Google Maps Go. Puede usarlo para obtener indicaciones y guía de voz para conducir, caminar, andar en bicicleta o en transporte público. También es compatible con mapas fuera de línea y direcciones, por lo que puede navegar sin conexión a Internet. </p>
-<h2>aquí vamos apk versión antigua</h2><br /><p><b><b>Download File</b> >>> <a href="https://bltlly.com/2v6LLw">https://bltlly.com/2v6LLw</a></b></p><br /><br />
- <h3>Características de Go Navigation APK</h3>
-<p>Algunas de las características de Go Navigation APK son:</p>
-<ul>
-<li>Es pequeño en tamaño y consume menos datos y batería que la aplicación completa de Google Maps. </li>
-<li>Soporta múltiples idiomas y regiones. </li>
-<li> Proporciona información y alertas de tráfico precisas y actualizadas. </li>
-<li>Le permite personalizar sus preferencias de ruta, como evitar peajes, autopistas o transbordadores. </li>
-<li>Muestra lugares de interés cercanos, como gasolineras, restaurantes u hoteles. </li>
-<li>Se integra con otros servicios de Google, como Google Assistant, Google Calendar o Contactos de Google.</li>
-</ul>
- <h3>Cómo descargar e instalar Ir navegación APK</h3>
-<p>Para descargar e instalar Go Navigation APK en su dispositivo Android, debe seguir estos pasos:</p>
-<ol>
-
-<li>Descargar el archivo APK Go Navigation de una fuente de confianza, como <a href="">APKPure</a>. </li>
-<li>Habilitar la instalación de aplicaciones de fuentes desconocidas en la configuración del dispositivo. </li>
-<li>Busque el archivo APK descargado en su dispositivo y toque en él para instalarlo. </li>
-<li>Inicie la aplicación y otorgue los permisos necesarios para acceder a su ubicación, micrófono y almacenamiento. </li>
-</ol>
- <h3> Cómo utilizar Go navegación APK con Google Maps Go</h3>
-<p>Para utilizar Go Navigation APK con Google Maps Go, debe seguir estos pasos:</p>
-<ol>
-<li>Abrir Google Maps Vaya en su dispositivo y busque su destino. </li>
-<li>Toque en el botón Direcciones en la parte inferior de la pantalla. </li>
-<li>Seleccione su modo de transporte (coche, bicicleta, a pie o de tránsito). </li>
-<li> Toque en el botón de navegación en la esquina superior derecha de la pantalla. </li>
-<li>Esto iniciará la aplicación Go Navigation y comenzará a guiarlo a su destino con instrucciones de voz y señales visuales. </li>
-<li>También puede acceder a otras opciones, como silenciar la guía de voz, cambiar la vista del mapa o cancelar la navegación. </li>
-</ol>
- <h2>Beneficios de usar Go Navigation APK</h2>
-<p>Usando Go Navigation APK tiene varios beneficios sobre el uso de otras aplicaciones de navegación o la aplicación completa de Google Maps. Algunos de estos beneficios son:</p>
- <h3>Guardar datos y espacio de almacenamiento</h3>
-<p>Go Navigation APK está diseñado para ser ligero y eficiente. Solo ocupa unos 7 MB de espacio de almacenamiento en su dispositivo, en comparación con la aplicación completa de Google Maps que ocupa unos 200 MB. También utiliza menos datos que la aplicación completa de Google Maps, ya que solo descarga los datos esenciales del mapa y la guía de voz. Esto puede ayudarle a ahorrar dinero en su plan de datos y evitar quedarse sin datos cuando más lo necesita. </p>
- <h3>Obtener navegación en tiempo real, giro a giro</h3>
-
- <h3>Acceder a mapas offline y direcciones</h3>
-<p>Una de las mejores características de Go Navigation APK es que le permite acceder a mapas fuera de línea y direcciones. Esto significa que puede navegar sin conexión a Internet, lo que puede ser muy útil en áreas con poca o ninguna cobertura de red, o cuando desea ahorrar datos o batería. Puede descargar mapas sin conexión para cualquier región o país que desee, y se almacenarán en su dispositivo durante un máximo de 30 días. También puedes obtener instrucciones fuera de línea para conducir, caminar o andar en bicicleta, siempre y cuando las hayas buscado antes de desconectarte. </p>
-<p></p>
- <h2>Comparación de Go Navigation APK con otras aplicaciones de navegación</h2>
-<p>Hay muchas otras aplicaciones de navegación disponibles para dispositivos Android, como Google Maps, Waze o HERE WeGo. ¿Cómo se compara Go Navigation APK con ellos? Aquí hay una tabla que resume algunas de las principales diferencias y similitudes entre estas aplicaciones:</p>
- <tabla>
-<tr>
-<th>Aplicación</th>
-<th>Tamaño</th>
-<th>Uso de datos</th>
-<th>Mapas offline</th>
-<th>Información de tráfico</th>
-<th>Guía de voz</th>
-<th>Otras características</th>
-</tr>
-<tr>
-<td>Ir navegación APK</td>
-<td>7 MB</td>
-<td>Baja</td>
-<td>Sí</td>
-<td>Sí</td>
-<td>Sí</td>
-<td>Funciona con Google Maps Go, soporta múltiples idiomas y regiones, se integra con otros servicios de Google. </td>
-</tr>
-<tr>
-<td>Google Maps</td>
-<td>200 MB</td>
-<td>Alta</td>
-<td>Sí</td>
-<td>Sí</td>
-<td>Sí</td>
-<td>Ofrece vista a la calle, vista satélite, mapas interiores, vista en vivo, horarios de tránsito, rutas de bicicletas, etc.</td>
-</tr>
-<tr>
-<td>Waze</td>
-<td>80 MB</td>
-<td>Medio</td>
-<td>No</td>
-<td>Sí</td>
-<td>Sí</td>
-<td>Le permite informar y ver los peligros de la carretera, la presencia de la policía, los accidentes, etc., ofrece características sociales, tales como compartir el coche, chat o puntos. </td>
-</tr>
-<tr>
-<td>AQUÍ WeGo</td>
-<td>40 MB</td <td>Baja</td <td>Sí</td>
-<td>Sí</td>
-<td>Sí</td>
-<td>Incluye información de transporte público, tarifas de taxi, opciones para compartir autos, rutas de bicicletas, etc.</td>
-</tr>
-
- <p>Si tiene alguna pregunta sobre Go Navigation APK, puede encontrar las respuestas a continuación:</p>
- <h3>Es Go Navigation APK seguro de usar? </h3>
- <p>Sí, Ir navegación APK es seguro de usar, siempre y cuando se descarga desde una fuente de confianza. No contiene ningún malware o virus que pueda dañar su dispositivo o comprometer su privacidad. Tampoco requiere permisos innecesarios o acceso a sus datos personales. </p>
- <h3>¿Es Go Navigation APK libre de usar? </h3>
- <p>Sí, Go Navigation APK es de uso gratuito y no tiene ninguna compra en la aplicación o anuncios. Sin embargo, es posible que incurra en algunos cargos de datos de su proveedor de red al usar la aplicación en línea. Puedes evitar esto usando mapas y direcciones offline siempre que sea posible. </p>
- <h3>¿Funciona Go Navigation APK en cualquier dispositivo Android? </h3>
- <p>No, Go Navigation APK solo funciona en dispositivos Android que tienen instalado Google Maps Go. Esto se debe a que es una aplicación complementaria que se basa en Google Maps Go para su funcionalidad. Google Maps Go es compatible con dispositivos Android que se ejecutan en Android 4.4 KitKat o superior y tienen al menos 512 MB de RAM.</p>
- <h3>¿Puedo usar Go navegación APK sin Google Maps Go? </h3>
- <p>No, no se puede utilizar Go Navigation APK sin Google Maps Go. Necesitas tener ambas aplicaciones instaladas en tu dispositivo y usarlas juntas para obtener servicios de navegación. Si intenta utilizar Go Navigation APK sin Google Maps Go, obtendrá un mensaje de error que dice "Por favor, instalar Google Maps Go primero". </p>
- <h3>¿Cómo puedo actualizar Go Navigation APK? </h3>
- <p>Puede actualizar Go Navigation APK siguiendo los mismos pasos que lo hizo para descargar e instalar. Es necesario descargar la última versión del archivo APK de una fuente de confianza e instalarlo en su dispositivo. También puedes recibir notificaciones cuando haya una nueva actualización disponible para la aplicación. </p>
- <h2>Conclusión</h2>
-
- <p>Espero que hayas encontrado este artículo útil e informativo. Si tienes algún comentario o preguntas, por favor no dudes en dejar un comentario a continuación. ¡Gracias por leer! </p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Descargar El Juego Growtopia Mod Apk.md

@@ -1,62 +0,0 @@
-<br />
-<h1>Descargar juego Growtopia Mod Apk: Una guía para principiantes</h1>
-<p>Si usted está buscando un juego divertido y creativo que le permite construir su propio mundo, entonces es posible que desee probar Growtopia. Growtopia es un popular sandbox MMO juego que tiene millones de jugadores en todo el mundo. Pero lo que si quieres disfrutar del juego sin gastar dinero real o enfrentar limitaciones? Ahí es donde Growtopia Mod Apk entra en juego. En este artículo, le diremos todo lo que necesita saber sobre Growtopia Mod Apk, incluyendo lo que es, cómo descargar e instalar, ¿cuáles son sus beneficios y riesgos, y más. Así que, vamos a empezar! </p>
-<h2>¿Qué es Growtopia? </h2>
-<h3>Un juego de MMO con un sinfín de posibilidades</h3>
-<p>Growtopia es un juego que te permite crear y explorar todo lo que puedas imaginar. Puedes construir tu propio mundo, desde castillos y mazmorras hasta naves espaciales y rascacielos. También puedes colaborar con otros jugadores, intercambiar artículos, jugar minijuegos, participar en eventos y competir en tablas de clasificación. No hay reglas ni límites en Growtopia, solo tu imaginación. </p>
-<h2>descargar el juego growtopia mod apk</h2><br /><p><b><b>DOWNLOAD</b> ->>->>->> <a href="https://bltlly.com/2v6L2z">https://bltlly.com/2v6L2z</a></b></p><br /><br />
-<h3>Una plataforma creativa y social con millones de jugadores</h3>
-<p>Growtopia no es solo un juego, sino también una comunidad de jugadores apasionados y amigables. Puedes chatear con otros jugadores, hacer amigos, unirte a gremios e incluso crear tu propio contenido. También puedes visitar mundos de otros jugadores, admirar sus creaciones y aprender de ellas. Growtopia es un lugar donde puedes expresarte, compartir tus ideas y divertirte. </p>
-<h2>¿Qué es Growtopia Mod Apk? </h2>
-<h3>Una versión modificada del juego original con características adicionales</h3>
-<p>Growtopia Mod Apk es una versión del juego que ha sido modificada por algunos desarrolladores para agregar características adicionales que no están disponibles en el juego original. Estas características pueden incluir gemas ilimitadas, recursos, objetos, mundos y más. Con Growtopia Mod Apk, se puede disfrutar del juego sin restricciones o limitaciones. </p>
-<h3>Una manera de disfrutar del juego sin gastar dinero real</h3>
-
-<h2>Cómo descargar e instalar Growtopia Mod Apk? </h2>
-<h3>Paso 1: Encontrar una fuente confiable para el archivo apk mod</h3>
-<p>El primer paso para descargar Growtopia Mod Apk es encontrar una fuente confiable para el archivo apk mod. Hay muchos sitios web que ofrecen archivos apk mod para varios juegos, pero no todos ellos son seguros y de confianza. <p>Antes de descargar cualquier archivo apk mod, siempre debe comprobar su seguridad y seguridad. Hay muchas maneras de hacerlo, pero estas son algunas de las más comunes y confiables:</p>
-<h3>Paso 1: Encontrar una fuente confiable para el archivo apk mod</h3>
-<p>El primer paso para descargar Growtopia Mod Apk es encontrar una fuente confiable para el archivo apk mod. Hay muchos sitios web que ofrecen archivos apk mod para varios juegos, pero no todos ellos son seguros y de confianza. Algunos de ellos pueden contener malware, virus o archivos falsos que pueden dañar su dispositivo o robar sus datos. Para evitar estos riesgos, solo debe descargar archivos apk mod de sitios de buena reputación y verificados. Algunos de los mejores sitios para las descargas seguras de Android APK son APKMirror, APKPure, y Apkmonk. Estos sitios tienen políticas y procedimientos estrictos para asegurar que los archivos apk mod que proporcionan están libres de cualquier código o contenido malicioso. También actualizan sus archivos regularmente para que coincidan con las últimas versiones de los juegos. </p>
-<h3>Paso 2: Compruebe el hash del archivo apk mod</h3>
-<p>El segundo paso para descargar Growtopia Mod Apk es comprobar el hash del archivo mod apk. El hash es un tipo de huella digital que garantiza que el archivo no se modifique o manipule. Puede utilizar una herramienta como Hash Droid para comprobar y comparar los hashes del archivo apk mod que descargó y el archivo de juego original de Google Play. Si los hashes coinciden, significa que el archivo apk mod es auténtico y seguro. Si no coinciden, significa que el archivo apk mod ha sido alterado o dañado y puede contener elementos dañinos. </p>
-<h3>Paso 3: Escanear el archivo apk mod con una aplicación antivirus</h3>
-
-<p>El cuarto y último paso para descargar Growtopia Mod Apk es descargar e instalar el archivo mod apk en su dispositivo. Una vez que haya verificado que el archivo apk mod es seguro, puede proceder a descargarlo e instalarlo. Estos son los pasos para hacerlo:</p>
-<ul>
-<li>Ir a la página web donde se descargó el archivo apk mod y toque en el botón de descarga. </li>
-<li>Esperar a que la descarga se complete y luego localizar el archivo apk mod en el almacenamiento de su dispositivo. </li>
-<li>Toque en el archivo apk mod y seleccione "Instalar". Es posible que tenga que conceder algunos permisos para permitir la instalación. </li>
-<li>Espera a que la instalación termine y luego toca "Abrir". </li>
-<li> Iniciar el juego y disfrutar de las características de mod. </li>
-</ul>
-<h2>¿Cuáles son los beneficios de Growtopia Mod Apk? </h2>
-<p>Ahora que usted sabe cómo descargar e instalar Growtopia Mod Apk, es posible que se pregunte cuáles son los beneficios de su uso. Bueno, hay muchos beneficios de usar Growtopia Mod Apk, pero aquí están algunos de los más notables:</p>
-<h3>Gemas y recursos ilimitados para construir lo que quieras</h3>
-<p>Uno de los principales beneficios de Growtopia Mod Apk es que le da gemas ilimitadas y recursos para construir lo que quieras. Las gemas son la moneda principal en Growtopia, y se utilizan para comprar artículos, acceder a mundos premium, desbloquear funciones y más. Los recursos son los materiales que utiliza para crear su propio mundo, tales como bloques, semillas, herramientas, etc. Con Growtopia Mod Apk, usted no tiene que preocuparse por quedarse sin gemas o recursos. Puedes conseguir tantos como quieras gratis y usarlos para construir tu mundo de ensueño. </p>
-<p></p>
-<h3>Acceso a artículos y mundos premium sin restricciones</h3>
-
-<p>Un tercer beneficio de Growtopia Mod Apk es que mejora la jugabilidad y los gráficos para una mejor experiencia. Growtopia Mod Apk tiene algunas características que mejoran el rendimiento y la calidad del juego, tales como una carga más rápida, controles más suaves, mayor resolución, etc. Estas características hacen el juego más agradable y envolvente. También puedes personalizar la configuración del juego para adaptarla a tus preferencias, como ajustar el sonido, el brillo, el idioma, etc.</p>
-<h2>¿Cuáles son los riesgos de crecimiento Mod Apk? </h2>
-<p>Mientras que Growtopia Mod Apk tiene muchos beneficios, también tiene algunos riesgos que usted debe ser consciente de. El uso de Growtopia Mod Apk puede exponer a algunos peligros y consecuencias, tales como:</p>
-<h3>Malware y virus potenciales de fuentes no confiables</h3>
-<p>Uno de los riesgos de Growtopia Mod Apk es que puede contener malware y virus de fuentes no confiables. Como mencionamos anteriormente, no todos los sitios web que ofrecen archivos apk mod son seguros y confiables. Algunos de ellos pueden tener malware y virus ocultos que pueden infectar su dispositivo o robar sus datos. Estos malware y virus pueden causar graves daños a su dispositivo, como ralentizarlo, agotar la batería, eliminar archivos, etc. También pueden comprometer su privacidad y seguridad, como acceder a sus contactos, mensajes, fotos, etc. Para evitar este riesgo, siempre debe descargar archivos apk mod de sitios de buena reputación y verificados, comprobar sus hashes, y escanearlos con una aplicación antivirus. </p>
-<h3>Posible prohibición de cuenta o suspensión de los desarrolladores de juegos</h3>
-
-<p>Un tercer riesgo de Growtopia Mod Apk es que puede causar que pierda su progreso y los datos si el apk mod no se actualiza regularmente. Growtopia Mod Apk no es una versión oficial del juego, y puede no ser compatible con las últimas actualizaciones y parches de los desarrolladores de juegos. Si utiliza un archivo apk mod obsoleto o incompatible, puede encontrar algunos errores o fallos en el juego, tales como estrellarse, congelación, retraso, etc. También puede perder su progreso y los datos si el archivo apk mod está dañado o eliminado. Para evitar este riesgo, siempre debe comprobar para la última versión de Growtopia Mod Apk y actualizarlo en consecuencia. </p>
-<h2>Conclusión</h2>
-<p>Growtopia es un juego divertido y creativo que te permite construir tu propio mundo y explorar los mundos de otros jugadores. Sin embargo, si quieres disfrutar del juego sin gastar dinero real o enfrentar limitaciones, es posible que desee probar Growtopia Mod Apk. Growtopia Mod Apk es una versión modificada del juego que le da gemas ilimitadas, recursos, objetos, mundos y más. También mejora la jugabilidad y los gráficos para una mejor experiencia. Sin embargo, Growtopia Mod Apk también tiene algunos riesgos que usted debe ser consciente de, tales como malware potencial y virus, posible prohibición de cuenta o suspensión, y la pérdida de progreso y datos. Por lo tanto, siempre debe descargar e instalar Growtopia Mod Apk de fuentes fiables, comprobar su seguridad y seguridad, y utilizarlo a su discreción y responsabilidad. </p>
-<h2>Preguntas frecuentes</h2>
-<p>Aquí están algunas de las preguntas más frecuentes sobre Growtopia Mod Apk:</p>
-<h3>Q: ¿Es Growtopia Mod Apk legal? </h3>
-<p>A: Growtopia Mod Apk no es legal, ya que viola los términos y condiciones de los desarrolladores de juegos. Usando Growtopia Mod Apk se considera una forma de engaño o piratería, y puede resultar en una prohibición de cuenta o suspensión. </p>
-<h3>Q: ¿Es seguro Growtopia Mod Apk? </h3>
-
-<h3>Q: ¿Cómo puedo actualizar Growtopia Mod Apk? </h3>
-<p>A: Para actualizar Growtopia Mod Apk, siempre debe comprobar la última versión del archivo apk mod desde el sitio web donde lo descargó. También debe comprobar si el archivo apk mod es compatible con la última versión del juego original de Google Play. Si hay una nueva versión disponible, debería descargarla e instalarla siguiendo los mismos pasos que antes. </p>
-<h3>Q: ¿Puedo jugar Growtopia Mod Apk en línea con otros jugadores? </h3>
-<p>A: Sí, usted puede jugar Growtopia Mod Apk en línea con otros jugadores que también están utilizando el archivo apk mod. Sin embargo, es posible que no puedas jugar con jugadores que estén usando el archivo de juego original de Google Play. También puede enfrentar algunos problemas o errores al jugar en línea, como retraso, desconexión, etc.</p>
-<h3>Q: ¿Puedo usar Growtopia Mod Apk en dispositivos iOS? </h3>
-<p>A: No, no se puede utilizar Growtopia Mod Apk en dispositivos iOS, ya que solo es compatible con dispositivos Android. Si quieres jugar a Growtopia en dispositivos iOS, tienes que descargar el archivo original del juego desde la App Store.</p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Descargar Facebook Lite Mod Apk 2020.md

@@ -1,95 +0,0 @@
-<br />
-<h1>Instagram + APK Indir: Cómo descargar e instalar Instagram en su dispositivo Android</h1>
-<p>Instagram es una de las plataformas de redes sociales más populares del mundo, con más de 1 mil millones de usuarios. Te permite crear y compartir tus fotos, historias, carretes y videos con los amigos y seguidores que te importan. También puedes explorar la comunidad, descubrir nuevos contenidos y conectarte con tus marcas y celebridades favoritas. </p>
-<h2>descargar facebook lite mod apk 2020</h2><br /><p><b><b>Download File</b> &#10004; <a href="https://bltlly.com/2v6JW9">https://bltlly.com/2v6JW9</a></b></p><br /><br />
-<p>Pero ¿qué pasa si desea descargar e instalar Instagram en su dispositivo Android sin usar la Google Play Store? Tal vez desee acceder a las últimas funciones, evitar las restricciones regionales o ahorrar datos y espacio de almacenamiento. En ese caso, es necesario descargar e instalar Instagram APK en su dispositivo. </p>
-<p>En este artículo, vamos a explicar lo que Instagram y APK son, ¿por qué debe utilizarlos, y cómo descargar e instalar Instagram APK en su dispositivo Android. ¡Vamos a empezar! </p>
- <h2>¿Qué es Instagram y por qué debe usarlo</h2>
-<p>Instagram es una aplicación de redes sociales que te permite crear y compartir tus fotos, historias, carretes y videos con los amigos y seguidores que te importan. También puede ver, como, comentar y compartir videos de carretes en un espacio dedicado en la pestaña Carretes. Los carretes son clips cortos de hasta 30 segundos de duración que puede agregar efectos especiales, música de fondo, filtros faciales, emojis y pegatinas a. </p>
-<p>Instagram también te permite enviar mensajes a tus amigos en directo, chatear con ellos, compartir memes de forma privada, y recibir notificaciones cuando alguien le gusta o comentarios en tu publicación. También puedes publicar fotos y videos en tu feed que quieras mostrar en tu perfil, o agregarlos a tu historia que desaparecen después de 24 horas. </p>
- <h3>Características de Instagram</h3>
-<p>Algunas de las características de Instagram son:</p>
-<ul>
-<li>Crea y comparte fotos, historias, carretes y videos con tus amigos y seguidores</li>
-<li>Ver, como, comentar y compartir videos de carretes en un espacio dedicado</li>
-
-<li>Publicar fotos y vídeos a su feed o historia</li>
-<li>Explora la comunidad y descubre nuevos contenidos</li>
-<li>Sigue a tus bandas favoritas, celebridades, actores, atletas, cantantes y más</li>
-<li>Echa un vistazo a IGTV para vídeos más largos de tus creadores favoritos</li>
-<li>Descubre marcas y conéctate con pequeñas empresas locales</li>
-<li>Compra productos que complementan tu estilo personal</li>
-</ul>
- <h3>Beneficios de usar Instagram</h3>
-<p>Algunos de los beneficios de usar Instagram son:</p>
-<p></p>
-<ul>
-<li>Puedes expresarte creativa y auténticamente</li>
-<li>Puedes conectarte con personas que comparten tus intereses y pasiones</li>
-<li>Puedes aprender cosas nuevas e inspirarte por otros</li>
-<li>Puedes hacer crecer tu marca personal o profesional</li>
-<li>Puedes divertirte y disfrutar</li>
-</ul>
- <h2>¿Qué es APK y por qué debe descargarlo</h2>
-<p>APK significa Android Package Kit. Es un formato de archivo que contiene todos los elementos necesarios para instalar una aplicación en un dispositivo Android. Los archivos APK generalmente se descargan desde Google Play Store u otras fuentes oficiales. Sin embargo, a veces es posible que desee descargar un archivo APK de una fuente de terceros por varias razones. </p>
- <h3>Definición de APK</h3>
-<p>Un archivo APK es un archivo comprimido que contiene todos los elementos necesarios para instalar una aplicación en un dispositivo Android. Incluye:</p>
-<ul>
-<li>El código de la aplicación (en Java o Kotlin)</li>
-<li>Recursos de la aplicación (como imágenes, sonidos, fuentes, etc.)</li>
-<li>Las <h3>Ventajas de descargar APK</h3>
-<p>Algunas de las ventajas de descargar APK son:</p>
-<ul>
-<li> Puede acceder a las últimas características y actualizaciones de una aplicación antes de que estén disponibles en Google Play Store</li>
-<li> Puede evitar las restricciones regionales y las aplicaciones de acceso que no están disponibles en su país</li>
-<li> Puede ahorrar datos y espacio de almacenamiento descargando una versión más pequeña o optimizada de una aplicación</li>
-<li>Puede personalizar y modificar una aplicación según sus preferencias</li>
-
-</ul>
- <h2> Cómo descargar e instalar Instagram APK en su dispositivo Android</h2>
-<p>Si desea descargar e instalar Instagram APK en su dispositivo Android, es necesario seguir estos pasos:</p>
- <h3>Paso 1: Habilitar fuentes desconocidas</h3>
-<p>Antes de que pueda instalar un archivo APK en su dispositivo, debe habilitar la opción para permitir la instalación desde fuentes desconocidas. Esta es una medida de seguridad que evita que las aplicaciones maliciosas dañen su dispositivo. Para habilitar esta opción, debe:</p>
-<ol>
-<li>Ir a la configuración de su dispositivo y toque en Seguridad o Privacidad</li>
-<li>Encontrar la opción que dice Fuentes desconocidas o Instalar aplicaciones desconocidas y alternar en</li>
-<li>Confirma tu elección tocando OK o Permitir</li>
-</ol>
- <h3>Paso 2: Descargar Instagram APK de una fuente de confianza</h3>
-<p>Siguiente, es necesario descargar el archivo APK de Instagram de una fuente de confianza. Hay muchos sitios web que ofrecen archivos APK, pero algunos de ellos pueden contener virus o malware que pueden dañar su dispositivo. Por lo tanto, es necesario tener cuidado y elegir una fuente de buena reputación. Algunas de las fuentes de confianza para descargar Instagram APK son:</p>
-<ul>
-<li>[APKPure]</li>
-<li>[APKMirror]</li>
-<li>[Uptodown]</li>
-</ul>
-<p>Para descargar el archivo APK de Instagram de una de estas fuentes, es necesario:</p>
-<ol>
-<li>Abra su navegador y vaya al sitio web de su elección</li>
-<li>Busca Instagram o encuéntralo en las categorías o rankings</li>
-<li>Seleccione la versión de Instagram que desea descargar y toque en Descargar o Instalar</li>
-<li>Espere a que la descarga termine y localice el archivo en su carpeta de descargas o barra de notificaciones</li>
-</ol>
- <h3>Paso 3: Instalar Instagram APK en su dispositivo</h3>
-<p>Después de haber descargado el archivo APK de Instagram, es necesario instalarlo en su dispositivo. Para hacer esto, es necesario:</p>
-<ol>
-<li>Toque en el archivo o abrirlo con una aplicación de administrador de archivos</li>
-<li>Si se le solicita, toque en Instalar o Siguiente para iniciar el proceso de instalación</li>
-
-</ol>
- <h3>Paso 4: Lanza Instagram y disfruta</h3>
-<p>Felicidades! Usted ha descargado e instalado con éxito Instagram APK en su dispositivo Android. Ahora puede iniciar la aplicación y disfrutar de sus funciones. Puede iniciar sesión con su cuenta existente o crear una nueva. También puedes sincronizar tus contactos y amigos de Facebook para encontrar gente a la que seguir. </p>
- <h2>Conclusión</h2>
-<p>En este artículo, hemos explicado lo que Instagram y APK son, ¿por qué debe utilizarlos, y cómo descargar e instalar Instagram APK en su dispositivo Android. Esperamos que esta guía te haya ayudado a disfrutar más de Instagram y acceder a sus últimas funciones. Si tiene alguna pregunta o comentario, háganoslo saber en los comentarios a continuación. </p>
- <h2>Preguntas frecuentes</h2>
-<p>Aquí hay algunas preguntas frecuentes sobre Instagram y APK:</p>
- <h4>Q: ¿Es seguro descargar e instalar Instagram APK? </h4>
-<p>A: Sí, es seguro para descargar e instalar Instagram APK siempre y cuando se utiliza una fuente de confianza y permitir fuentes desconocidas en su dispositivo. Sin embargo, siempre debe tener cuidado y escanear el archivo en busca de virus o malware antes de instalarlo. </p>
- <h4>Q: ¿Perderé mis datos o cuenta si descargo e instalo Instagram APK? </h4>
-<p>A: No, no perderá sus datos o cuenta si descarga e instala Instagram APK. Puede iniciar sesión con su cuenta existente o crear una nueva. También puede realizar copias de seguridad de sus datos con Google Drive u otros servicios en la nube. </p>
- <h4>Q: ¿Cuáles son las diferencias entre Instagram APK e Instagram de la Google Play Store? </h4>
-<p>A: La principal diferencia entre Instagram APK e Instagram de la Google Play Store es que el primero puede tener nuevas características, actualizaciones, o correcciones de errores que aún no están disponibles en el último. El primero también puede tener diferentes versiones, tamaños o idiomas que el segundo. </p> <h4>Q: ¿Cómo puedo actualizar Instagram APK? </h4>
-
- <h4>Q: ¿Puedo usar Instagram APK en otros dispositivos además de Android? </h4>
-<p>A: No, no se puede utilizar Instagram APK en otros dispositivos además de Android. Los archivos APK solo son compatibles con dispositivos Android. Si desea usar Instagram en otros dispositivos, como iOS, Windows o Mac, debe descargar la aplicación desde las respectivas tiendas de aplicaciones o sitios web. </p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Descargar Fr Leyendas Hiace Mod Apk.md

@@ -1,49 +0,0 @@
-<br />
-<h1>Descargar FR Leyendas Hiace Mod Apk: Una guía para los fans de la deriva</h1>
- <p>Si eres un fanático de los juegos de deriva, es posible que hayas oído hablar de <strong>FR Legends</strong>, un juego móvil que te permite conducir coches de deriva legendarios FR (motor delantero, tracción trasera) en los circuitos más icónicos del mundo, personalizar todo en tu coche, incluidos los cambios de motor y anchokits de cuerpo, y tienen batallas de deriva en tándem con los conductores de IA u otros jugadores en línea. </p>
-<h2>descargar fr leyendas hiace mod apk</h2><br /><p><b><b>Download File</b> &mdash;&mdash;&mdash; <a href="https://bltlly.com/2v6JNk">https://bltlly.com/2v6JNk</a></b></p><br /><br />
- <p>FR Legends es uno de los juegos de deriva más realistas y divertidos en dispositivos Android e iOS, con gráficos estilizados, controles intuitivos y sistemas de puntuación únicos basados en las reglas de la competencia del mundo real. El juego ha recibido excelentes críticas de jugadores y críticos por igual, con más de 10 millones de descargas y 4.4 estrellas en Google Play Store y App Store.</p>
- <p>Pero ¿qué pasa si desea darle vida a su experiencia de deriva con algunos nuevos coches y características? Bueno, ahí es donde el <strong>hiace mod apk</strong> entra en juego. Esta es una versión modificada del juego que añade una furgoneta Toyota Hiace como un coche manejable, junto con algunos otros ajustes y mejoras. En este artículo, le mostraremos cómo descargar e instalar el apk mod hiace en su dispositivo Android, y le dará algunos consejos y trucos para jugar leyendas FR con este mod. </p>
- <h2>¿Cuál es la apk mod hiace y qué características ofrece? </h2>
- <p>La apk hiace mod es una versión modificada de FR Legends que fue creada por NimoCustom, un modder que se especializa en la adición de nuevos coches y libreas para el juego. El mod añade un Toyota Hiace van como una nueva opción de coche en el juego, que es un vehículo popular para la deriva en Japón. La furgoneta tiene un modelo realista, sonido y física, y se puede personalizar con diferentes partes y colores. </p>
-<p></p>
- <p>El apk mod hiace también ofrece algunas otras características que mejoran la jugabilidad de FR Legends, tales como:</p>
- <ul>
-<li>Una nueva pista llamada Rampage Customs, que se basa en un circuito de deriva de la vida real en Indonesia.</li>
-
-<li>Un nuevo ángulo de cámara que le da una mejor vista de su coche y la pista. </li>
-<li>Una nueva interfaz de menú que es más fácil de usar y elegante. </li>
-<li>Una nueva lista de reproducción de música que añade algunas melodías optimistas al juego. </li>
-</ul>
- <h2>Cómo descargar e instalar el apk mod hiace en dispositivos Android? </h2>
- <p>Si desea probar el apk mod hiace en su dispositivo Android, tendrá que seguir estos pasos:</p>
- <ol>
-<li>En primer lugar, tendrá que habilitar fuentes desconocidas en la configuración del dispositivo. Esto le permitirá instalar aplicaciones desde fuentes distintas de Google Play Store. Para ello, vaya a Configuración > Aplicaciones y notificaciones > Acceso especial > Instalar aplicaciones desconocidas > Chrome (o cualquier navegador que utilice) > Permitir desde esta fuente. </li>
-<li>Siguiente, tendrá que descargar el archivo apk mod hiace de un sitio web confiable. Puedes encontrar el enlace a la última versión del mod en el canal de YouTube de NimoCustom, o buscarlo en Google. Asegúrese de descargar el archivo desde una fuente confiable y escanearlo en busca de virus antes de abrirlo. </li>
-<li>Una vez que haya descargado el archivo, tendrá que abrirlo con una aplicación de administrador de archivos (como Cx File Explorer o Administrador de archivos) y pulse Instalar. Siga las instrucciones de la pantalla para completar el proceso de instalación. </li>
-<li>Después de instalar la aplicación, puede iniciarla desde el cajón de la aplicación o la pantalla de inicio. Verá un nuevo icono para FR Legends con un fondo rojo. Toque para empezar a jugar el juego con el apk mod hiace. </li>
-</ol>
- <h2>Consejos y trucos para jugar FR Leyendas con el apk mod hiace</h <h2>Consejos y trucos para jugar FR Leyendas con el apk mod hiace</h2>
- <p>Ahora que ha instalado el apk mod hiace en su dispositivo Android, es posible que se pregunte cómo aprovechar al máximo. Aquí hay algunos consejos y trucos que te ayudarán a disfrutar aún más del juego:</p>
- <ul>
-
-<li>Experimenta con el nuevo editor de librea, que te permite crear tus propios diseños para tus coches. Puede acceder a ella desde el menú Garaje, en la pestaña Librea. Puede elegir entre diferentes colores, pegatinas, calcomanías y patrones, y guardar sus creaciones para su uso posterior. </li>
-<li>Cambiar al nuevo ángulo de la cámara, que le da una mejor vista de su coche y la pista. Puede cambiar el ángulo de la cámara pulsando el icono de la cámara en la esquina superior derecha de la pantalla. También puede hacer zoom hacia dentro y hacia fuera pellizcando la pantalla. </li>
-<li>Escuchar la nueva lista de reproducción de música, que añade algunas melodías optimistas para el juego. Puede ajustar el volumen y omitir pistas tocando el icono de música en la esquina superior izquierda de la pantalla. También puede apagar la música si lo prefiere. </li>
-<li>Diviértete con el Toyota Hiace van, que es un coche único e hilarante a la deriva con. Puede personalizarlo con diferentes partes y colores, y ver cómo se maneja en diferentes pistas. También puede desafiar a otros jugadores en línea o fuera de línea con este coche, y ver quién puede derivar mejor con una furgoneta. </li>
-</ul>
- <h2>Conclusión: Resuma los puntos principales e invite a los lectores a probar el juego</h2>
- <p>En conclusión, FR Legends es un fantástico juego de deriva que te permite conducir legendarios coches de deriva FR en los circuitos más icónicos del mundo, personalizar todo en su coche incluyendo cambios de motor y kits de cuerpo ancho, y tener batallas de deriva en tándem con conductores de IA u otros jugadores en línea. </p>
- <p>Si desea darle vida a su experiencia a la deriva con algunos nuevos coches y características, usted debe probar la apk mod hiace, que añade un Toyota Hiace van como un coche manejable, junto con algunos otros ajustes y mejoras. El mod es fácil de descargar e instalar en tu dispositivo Android, y te dará horas de diversión y risas. </p>
- <p>Entonces, ¿qué estás esperando? Descargar FR Leyendas hiace mod apk hoy y disfrutar de la deriva como nunca antes! </p>
- <h2>Preguntas frecuentes: Responde algunas preguntas comunes sobre el juego y el mod</h2>
- <tabla>
-
-<tr><td>Es FR leyendas hiace mod apk seguro de usar? </td><td>Sí, siempre y cuando lo descargue de un sitio web confiable y lo escanee en busca de virus antes de abrirlo. Sin embargo, debes tener en cuenta que el uso de mods puede afectar el rendimiento o la compatibilidad de tu juego, y puede que no sean compatibles con los desarrolladores oficiales. Use mods bajo su propio riesgo. </td></tr>
-<tr><td>Es FR leyendas hiace mod apk compatible con dispositivos iOS? </td><td>No, por desgracia, el apk mod hiace solo está disponible para dispositivos Android. Si tienes un dispositivo iOS, tendrás que jugar la versión original de FR Legends sin mods. </td></tr>
-<tr><td>¿Puedo jugar FR Legends hiace mod apk offline? </td><td>Sí, puedes jugar FR Legends hiace mod apk offline sin conexión a Internet. Sin embargo, no podrá acceder a algunas funciones como el modo multijugador en línea o el almacenamiento en la nube. </td></tr>
-<tr><td>¿Puedo jugar FR Legends hiace mod apk con mis amigos? </td><td>Sí, puedes jugar FR Legends mod apk hiace con tus amigos en línea o fuera de línea. Para jugar en línea, tendrá que crear o unirse a una sala desde el menú en línea. Para jugar sin conexión, tendrá que conectar sus dispositivos a través de Bluetooth o Wi-Fi desde el menú local. </td></tr>
-<tr><td>Puedo actualizar FR leyendas hiace mod apk? </td><td>Sí, puede actualizar FR Leyendas hiace mod apk cada vez que hay una nueva versión disponible en el canal de NimoCustom YouTube u otras fuentes. Sin embargo, debes hacer una copia de seguridad de los datos del juego antes de actualizarlo, ya que la actualización puede borrar tu progreso o causar problemas de compatibilidad. </td></tr>
-</tabla></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/BernardoOlisan/vqganclip/taming-transformers/taming/data/sflckr.py

@@ -1,91 +0,0 @@
-import os
-import numpy as np
-import cv2
-import albumentations
-from PIL import Image
-from torch.utils.data import Dataset
-
-
-class SegmentationBase(Dataset):
-    def __init__(self,
-                 data_csv, data_root, segmentation_root,
-                 size=None, random_crop=False, interpolation="bicubic",
-                 n_labels=182, shift_segmentation=False,
-                 ):
-        self.n_labels = n_labels
-        self.shift_segmentation = shift_segmentation
-        self.data_csv = data_csv
-        self.data_root = data_root
-        self.segmentation_root = segmentation_root
-        with open(self.data_csv, "r") as f:
-            self.image_paths = f.read().splitlines()
-        self._length = len(self.image_paths)
-        self.labels = {
-            "relative_file_path_": [l for l in self.image_paths],
-            "file_path_": [os.path.join(self.data_root, l)
-                           for l in self.image_paths],
-            "segmentation_path_": [os.path.join(self.segmentation_root, l.replace(".jpg", ".png"))
-                                   for l in self.image_paths]
-        }
-
-        size = None if size is not None and size<=0 else size
-        self.size = size
-        if self.size is not None:
-            self.interpolation = interpolation
-            self.interpolation = {
-                "nearest": cv2.INTER_NEAREST,
-                "bilinear": cv2.INTER_LINEAR,
-                "bicubic": cv2.INTER_CUBIC,
-                "area": cv2.INTER_AREA,
-                "lanczos": cv2.INTER_LANCZOS4}[self.interpolation]
-            self.image_rescaler = albumentations.SmallestMaxSize(max_size=self.size,
-                                                                 interpolation=self.interpolation)
-            self.segmentation_rescaler = albumentations.SmallestMaxSize(max_size=self.size,
-                                                                        interpolation=cv2.INTER_NEAREST)
-            self.center_crop = not random_crop
-            if self.center_crop:
-                self.cropper = albumentations.CenterCrop(height=self.size, width=self.size)
-            else:
-                self.cropper = albumentations.RandomCrop(height=self.size, width=self.size)
-            self.preprocessor = self.cropper
-
-    def __len__(self):
-        return self._length
-
-    def __getitem__(self, i):
-        example = dict((k, self.labels[k][i]) for k in self.labels)
-        image = Image.open(example["file_path_"])
-        if not image.mode == "RGB":
-            image = image.convert("RGB")
-        image = np.array(image).astype(np.uint8)
-        if self.size is not None:
-            image = self.image_rescaler(image=image)["image"]
-        segmentation = Image.open(example["segmentation_path_"])
-        assert segmentation.mode == "L", segmentation.mode
-        segmentation = np.array(segmentation).astype(np.uint8)
-        if self.shift_segmentation:
-            # used to support segmentations containing unlabeled==255 label
-            segmentation = segmentation+1
-        if self.size is not None:
-            segmentation = self.segmentation_rescaler(image=segmentation)["image"]
-        if self.size is not None:
-            processed = self.preprocessor(image=image,
-                                          mask=segmentation
-                                          )
-        else:
-            processed = {"image": image,
-                         "mask": segmentation
-                         }
-        example["image"] = (processed["image"]/127.5 - 1.0).astype(np.float32)
-        segmentation = processed["mask"]
-        onehot = np.eye(self.n_labels)[segmentation]
-        example["segmentation"] = onehot
-        return example
-
-
-class Examples(SegmentationBase):
-    def __init__(self, size=None, random_crop=False, interpolation="bicubic"):
-        super().__init__(data_csv="data/sflckr_examples.txt",
-                         data_root="data/sflckr_images",
-                         segmentation_root="data/sflckr_segmentations",
-                         size=size, random_crop=random_crop, interpolation=interpolation)

spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/pyparsing/results.py

@@ -1,760 +0,0 @@
-# results.py
-from collections.abc import MutableMapping, Mapping, MutableSequence, Iterator
-import pprint
-from weakref import ref as wkref
-from typing import Tuple, Any
-
-str_type: Tuple[type, ...] = (str, bytes)
-_generator_type = type((_ for _ in ()))
-
-
-class _ParseResultsWithOffset:
-    __slots__ = ["tup"]
-
-    def __init__(self, p1, p2):
-        self.tup = (p1, p2)
-
-    def __getitem__(self, i):
-        return self.tup[i]
-
-    def __getstate__(self):
-        return self.tup
-
-    def __setstate__(self, *args):
-        self.tup = args[0]
-
-
-class ParseResults:
-    """Structured parse results, to provide multiple means of access to
-    the parsed data:
-
-    - as a list (``len(results)``)
-    - by list index (``results[0], results[1]``, etc.)
-    - by attribute (``results.<results_name>`` - see :class:`ParserElement.set_results_name`)
-
-    Example::
-
-        integer = Word(nums)
-        date_str = (integer.set_results_name("year") + '/'
-                    + integer.set_results_name("month") + '/'
-                    + integer.set_results_name("day"))
-        # equivalent form:
-        # date_str = (integer("year") + '/'
-        #             + integer("month") + '/'
-        #             + integer("day"))
-
-        # parse_string returns a ParseResults object
-        result = date_str.parse_string("1999/12/31")
-
-        def test(s, fn=repr):
-            print("{} -> {}".format(s, fn(eval(s))))
-        test("list(result)")
-        test("result[0]")
-        test("result['month']")
-        test("result.day")
-        test("'month' in result")
-        test("'minutes' in result")
-        test("result.dump()", str)
-
-    prints::
-
-        list(result) -> ['1999', '/', '12', '/', '31']
-        result[0] -> '1999'
-        result['month'] -> '12'
-        result.day -> '31'
-        'month' in result -> True
-        'minutes' in result -> False
-        result.dump() -> ['1999', '/', '12', '/', '31']
-        - day: '31'
-        - month: '12'
-        - year: '1999'
-    """
-
-    _null_values: Tuple[Any, ...] = (None, [], "", ())
-
-    __slots__ = [
-        "_name",
-        "_parent",
-        "_all_names",
-        "_modal",
-        "_toklist",
-        "_tokdict",
-        "__weakref__",
-    ]
-
-    class List(list):
-        """
-        Simple wrapper class to distinguish parsed list results that should be preserved
-        as actual Python lists, instead of being converted to :class:`ParseResults`:
-
-            LBRACK, RBRACK = map(pp.Suppress, "[]")
-            element = pp.Forward()
-            item = ppc.integer
-            element_list = LBRACK + pp.delimited_list(element) + RBRACK
-
-            # add parse actions to convert from ParseResults to actual Python collection types
-            def as_python_list(t):
-                return pp.ParseResults.List(t.as_list())
-            element_list.add_parse_action(as_python_list)
-
-            element <<= item | element_list
-
-            element.run_tests('''
-                100
-                [2,3,4]
-                [[2, 1],3,4]
-                [(2, 1),3,4]
-                (2,3,4)
-                ''', post_parse=lambda s, r: (r[0], type(r[0])))
-
-        prints:
-
-            100
-            (100, <class 'int'>)
-
-            [2,3,4]
-            ([2, 3, 4], <class 'list'>)
-
-            [[2, 1],3,4]
-            ([[2, 1], 3, 4], <class 'list'>)
-
-        (Used internally by :class:`Group` when `aslist=True`.)
-        """
-
-        def __new__(cls, contained=None):
-            if contained is None:
-                contained = []
-
-            if not isinstance(contained, list):
-                raise TypeError(
-                    "{} may only be constructed with a list,"
-                    " not {}".format(cls.__name__, type(contained).__name__)
-                )
-
-            return list.__new__(cls)
-
-    def __new__(cls, toklist=None, name=None, **kwargs):
-        if isinstance(toklist, ParseResults):
-            return toklist
-        self = object.__new__(cls)
-        self._name = None
-        self._parent = None
-        self._all_names = set()
-
-        if toklist is None:
-            self._toklist = []
-        elif isinstance(toklist, (list, _generator_type)):
-            self._toklist = (
-                [toklist[:]]
-                if isinstance(toklist, ParseResults.List)
-                else list(toklist)
-            )
-        else:
-            self._toklist = [toklist]
-        self._tokdict = dict()
-        return self
-
-    # Performance tuning: we construct a *lot* of these, so keep this
-    # constructor as small and fast as possible
-    def __init__(
-        self, toklist=None, name=None, asList=True, modal=True, isinstance=isinstance
-    ):
-        self._modal = modal
-        if name is not None and name != "":
-            if isinstance(name, int):
-                name = str(name)
-            if not modal:
-                self._all_names = {name}
-            self._name = name
-            if toklist not in self._null_values:
-                if isinstance(toklist, (str_type, type)):
-                    toklist = [toklist]
-                if asList:
-                    if isinstance(toklist, ParseResults):
-                        self[name] = _ParseResultsWithOffset(
-                            ParseResults(toklist._toklist), 0
-                        )
-                    else:
-                        self[name] = _ParseResultsWithOffset(
-                            ParseResults(toklist[0]), 0
-                        )
-                    self[name]._name = name
-                else:
-                    try:
-                        self[name] = toklist[0]
-                    except (KeyError, TypeError, IndexError):
-                        if toklist is not self:
-                            self[name] = toklist
-                        else:
-                            self._name = name
-
-    def __getitem__(self, i):
-        if isinstance(i, (int, slice)):
-            return self._toklist[i]
-        else:
-            if i not in self._all_names:
-                return self._tokdict[i][-1][0]
-            else:
-                return ParseResults([v[0] for v in self._tokdict[i]])
-
-    def __setitem__(self, k, v, isinstance=isinstance):
-        if isinstance(v, _ParseResultsWithOffset):
-            self._tokdict[k] = self._tokdict.get(k, list()) + [v]
-            sub = v[0]
-        elif isinstance(k, (int, slice)):
-            self._toklist[k] = v
-            sub = v
-        else:
-            self._tokdict[k] = self._tokdict.get(k, list()) + [
-                _ParseResultsWithOffset(v, 0)
-            ]
-            sub = v
-        if isinstance(sub, ParseResults):
-            sub._parent = wkref(self)
-
-    def __delitem__(self, i):
-        if isinstance(i, (int, slice)):
-            mylen = len(self._toklist)
-            del self._toklist[i]
-
-            # convert int to slice
-            if isinstance(i, int):
-                if i < 0:
-                    i += mylen
-                i = slice(i, i + 1)
-            # get removed indices
-            removed = list(range(*i.indices(mylen)))
-            removed.reverse()
-            # fixup indices in token dictionary
-            for name, occurrences in self._tokdict.items():
-                for j in removed:
-                    for k, (value, position) in enumerate(occurrences):
-                        occurrences[k] = _ParseResultsWithOffset(
-                            value, position - (position > j)
-                        )
-        else:
-            del self._tokdict[i]
-
-    def __contains__(self, k) -> bool:
-        return k in self._tokdict
-
-    def __len__(self) -> int:
-        return len(self._toklist)
-
-    def __bool__(self) -> bool:
-        return not not (self._toklist or self._tokdict)
-
-    def __iter__(self) -> Iterator:
-        return iter(self._toklist)
-
-    def __reversed__(self) -> Iterator:
-        return iter(self._toklist[::-1])
-
-    def keys(self):
-        return iter(self._tokdict)
-
-    def values(self):
-        return (self[k] for k in self.keys())
-
-    def items(self):
-        return ((k, self[k]) for k in self.keys())
-
-    def haskeys(self) -> bool:
-        """
-        Since ``keys()`` returns an iterator, this method is helpful in bypassing
-        code that looks for the existence of any defined results names."""
-        return bool(self._tokdict)
-
-    def pop(self, *args, **kwargs):
-        """
-        Removes and returns item at specified index (default= ``last``).
-        Supports both ``list`` and ``dict`` semantics for ``pop()``. If
-        passed no argument or an integer argument, it will use ``list``
-        semantics and pop tokens from the list of parsed tokens. If passed
-        a non-integer argument (most likely a string), it will use ``dict``
-        semantics and pop the corresponding value from any defined results
-        names. A second default return value argument is supported, just as in
-        ``dict.pop()``.
-
-        Example::
-
-            numlist = Word(nums)[...]
-            print(numlist.parse_string("0 123 321")) # -> ['0', '123', '321']
-
-            def remove_first(tokens):
-                tokens.pop(0)
-            numlist.add_parse_action(remove_first)
-            print(numlist.parse_string("0 123 321")) # -> ['123', '321']
-
-            label = Word(alphas)
-            patt = label("LABEL") + Word(nums)[1, ...]
-            print(patt.parse_string("AAB 123 321").dump())
-
-            # Use pop() in a parse action to remove named result (note that corresponding value is not
-            # removed from list form of results)
-            def remove_LABEL(tokens):
-                tokens.pop("LABEL")
-                return tokens
-            patt.add_parse_action(remove_LABEL)
-            print(patt.parse_string("AAB 123 321").dump())
-
-        prints::
-
-            ['AAB', '123', '321']
-            - LABEL: 'AAB'
-
-            ['AAB', '123', '321']
-        """
-        if not args:
-            args = [-1]
-        for k, v in kwargs.items():
-            if k == "default":
-                args = (args[0], v)
-            else:
-                raise TypeError(
-                    "pop() got an unexpected keyword argument {!r}".format(k)
-                )
-        if isinstance(args[0], int) or len(args) == 1 or args[0] in self:
-            index = args[0]
-            ret = self[index]
-            del self[index]
-            return ret
-        else:
-            defaultvalue = args[1]
-            return defaultvalue
-
-    def get(self, key, default_value=None):
-        """
-        Returns named result matching the given key, or if there is no
-        such name, then returns the given ``default_value`` or ``None`` if no
-        ``default_value`` is specified.
-
-        Similar to ``dict.get()``.
-
-        Example::
-
-            integer = Word(nums)
-            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
-
-            result = date_str.parse_string("1999/12/31")
-            print(result.get("year")) # -> '1999'
-            print(result.get("hour", "not specified")) # -> 'not specified'
-            print(result.get("hour")) # -> None
-        """
-        if key in self:
-            return self[key]
-        else:
-            return default_value
-
-    def insert(self, index, ins_string):
-        """
-        Inserts new element at location index in the list of parsed tokens.
-
-        Similar to ``list.insert()``.
-
-        Example::
-
-            numlist = Word(nums)[...]
-            print(numlist.parse_string("0 123 321")) # -> ['0', '123', '321']
-
-            # use a parse action to insert the parse location in the front of the parsed results
-            def insert_locn(locn, tokens):
-                tokens.insert(0, locn)
-            numlist.add_parse_action(insert_locn)
-            print(numlist.parse_string("0 123 321")) # -> [0, '0', '123', '321']
-        """
-        self._toklist.insert(index, ins_string)
-        # fixup indices in token dictionary
-        for name, occurrences in self._tokdict.items():
-            for k, (value, position) in enumerate(occurrences):
-                occurrences[k] = _ParseResultsWithOffset(
-                    value, position + (position > index)
-                )
-
-    def append(self, item):
-        """
-        Add single element to end of ``ParseResults`` list of elements.
-
-        Example::
-
-            numlist = Word(nums)[...]
-            print(numlist.parse_string("0 123 321")) # -> ['0', '123', '321']
-
-            # use a parse action to compute the sum of the parsed integers, and add it to the end
-            def append_sum(tokens):
-                tokens.append(sum(map(int, tokens)))
-            numlist.add_parse_action(append_sum)
-            print(numlist.parse_string("0 123 321")) # -> ['0', '123', '321', 444]
-        """
-        self._toklist.append(item)
-
-    def extend(self, itemseq):
-        """
-        Add sequence of elements to end of ``ParseResults`` list of elements.
-
-        Example::
-
-            patt = Word(alphas)[1, ...]
-
-            # use a parse action to append the reverse of the matched strings, to make a palindrome
-            def make_palindrome(tokens):
-                tokens.extend(reversed([t[::-1] for t in tokens]))
-                return ''.join(tokens)
-            patt.add_parse_action(make_palindrome)
-            print(patt.parse_string("lskdj sdlkjf lksd")) # -> 'lskdjsdlkjflksddsklfjkldsjdksl'
-        """
-        if isinstance(itemseq, ParseResults):
-            self.__iadd__(itemseq)
-        else:
-            self._toklist.extend(itemseq)
-
-    def clear(self):
-        """
-        Clear all elements and results names.
-        """
-        del self._toklist[:]
-        self._tokdict.clear()
-
-    def __getattr__(self, name):
-        try:
-            return self[name]
-        except KeyError:
-            if name.startswith("__"):
-                raise AttributeError(name)
-            return ""
-
-    def __add__(self, other) -> "ParseResults":
-        ret = self.copy()
-        ret += other
-        return ret
-
-    def __iadd__(self, other) -> "ParseResults":
-        if other._tokdict:
-            offset = len(self._toklist)
-            addoffset = lambda a: offset if a < 0 else a + offset
-            otheritems = other._tokdict.items()
-            otherdictitems = [
-                (k, _ParseResultsWithOffset(v[0], addoffset(v[1])))
-                for k, vlist in otheritems
-                for v in vlist
-            ]
-            for k, v in otherdictitems:
-                self[k] = v
-                if isinstance(v[0], ParseResults):
-                    v[0]._parent = wkref(self)
-
-        self._toklist += other._toklist
-        self._all_names |= other._all_names
-        return self
-
-    def __radd__(self, other) -> "ParseResults":
-        if isinstance(other, int) and other == 0:
-            # useful for merging many ParseResults using sum() builtin
-            return self.copy()
-        else:
-            # this may raise a TypeError - so be it
-            return other + self
-
-    def __repr__(self) -> str:
-        return "{}({!r}, {})".format(type(self).__name__, self._toklist, self.as_dict())
-
-    def __str__(self) -> str:
-        return (
-            "["
-            + ", ".join(
-                [
-                    str(i) if isinstance(i, ParseResults) else repr(i)
-                    for i in self._toklist
-                ]
-            )
-            + "]"
-        )
-
-    def _asStringList(self, sep=""):
-        out = []
-        for item in self._toklist:
-            if out and sep:
-                out.append(sep)
-            if isinstance(item, ParseResults):
-                out += item._asStringList()
-            else:
-                out.append(str(item))
-        return out
-
-    def as_list(self) -> list:
-        """
-        Returns the parse results as a nested list of matching tokens, all converted to strings.
-
-        Example::
-
-            patt = Word(alphas)[1, ...]
-            result = patt.parse_string("sldkj lsdkj sldkj")
-            # even though the result prints in string-like form, it is actually a pyparsing ParseResults
-            print(type(result), result) # -> <class 'pyparsing.ParseResults'> ['sldkj', 'lsdkj', 'sldkj']
-
-            # Use as_list() to create an actual list
-            result_list = result.as_list()
-            print(type(result_list), result_list) # -> <class 'list'> ['sldkj', 'lsdkj', 'sldkj']
-        """
-        return [
-            res.as_list() if isinstance(res, ParseResults) else res
-            for res in self._toklist
-        ]
-
-    def as_dict(self) -> dict:
-        """
-        Returns the named parse results as a nested dictionary.
-
-        Example::
-
-            integer = Word(nums)
-            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
-
-            result = date_str.parse_string('12/31/1999')
-            print(type(result), repr(result)) # -> <class 'pyparsing.ParseResults'> (['12', '/', '31', '/', '1999'], {'day': [('1999', 4)], 'year': [('12', 0)], 'month': [('31', 2)]})
-
-            result_dict = result.as_dict()
-            print(type(result_dict), repr(result_dict)) # -> <class 'dict'> {'day': '1999', 'year': '12', 'month': '31'}
-
-            # even though a ParseResults supports dict-like access, sometime you just need to have a dict
-            import json
-            print(json.dumps(result)) # -> Exception: TypeError: ... is not JSON serializable
-            print(json.dumps(result.as_dict())) # -> {"month": "31", "day": "1999", "year": "12"}
-        """
-
-        def to_item(obj):
-            if isinstance(obj, ParseResults):
-                return obj.as_dict() if obj.haskeys() else [to_item(v) for v in obj]
-            else:
-                return obj
-
-        return dict((k, to_item(v)) for k, v in self.items())
-
-    def copy(self) -> "ParseResults":
-        """
-        Returns a new copy of a :class:`ParseResults` object.
-        """
-        ret = ParseResults(self._toklist)
-        ret._tokdict = self._tokdict.copy()
-        ret._parent = self._parent
-        ret._all_names |= self._all_names
-        ret._name = self._name
-        return ret
-
-    def get_name(self):
-        r"""
-        Returns the results name for this token expression. Useful when several
-        different expressions might match at a particular location.
-
-        Example::
-
-            integer = Word(nums)
-            ssn_expr = Regex(r"\d\d\d-\d\d-\d\d\d\d")
-            house_number_expr = Suppress('#') + Word(nums, alphanums)
-            user_data = (Group(house_number_expr)("house_number")
-                        | Group(ssn_expr)("ssn")
-                        | Group(integer)("age"))
-            user_info = user_data[1, ...]
-
-            result = user_info.parse_string("22 111-22-3333 #221B")
-            for item in result:
-                print(item.get_name(), ':', item[0])
-
-        prints::
-
-            age : 22
-            ssn : 111-22-3333
-            house_number : 221B
-        """
-        if self._name:
-            return self._name
-        elif self._parent:
-            par = self._parent()
-
-            def find_in_parent(sub):
-                return next(
-                    (
-                        k
-                        for k, vlist in par._tokdict.items()
-                        for v, loc in vlist
-                        if sub is v
-                    ),
-                    None,
-                )
-
-            return find_in_parent(self) if par else None
-        elif (
-            len(self) == 1
-            and len(self._tokdict) == 1
-            and next(iter(self._tokdict.values()))[0][1] in (0, -1)
-        ):
-            return next(iter(self._tokdict.keys()))
-        else:
-            return None
-
-    def dump(self, indent="", full=True, include_list=True, _depth=0) -> str:
-        """
-        Diagnostic method for listing out the contents of
-        a :class:`ParseResults`. Accepts an optional ``indent`` argument so
-        that this string can be embedded in a nested display of other data.
-
-        Example::
-
-            integer = Word(nums)
-            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
-
-            result = date_str.parse_string('1999/12/31')
-            print(result.dump())
-
-        prints::
-
-            ['1999', '/', '12', '/', '31']
-            - day: '31'
-            - month: '12'
-            - year: '1999'
-        """
-        out = []
-        NL = "\n"
-        out.append(indent + str(self.as_list()) if include_list else "")
-
-        if full:
-            if self.haskeys():
-                items = sorted((str(k), v) for k, v in self.items())
-                for k, v in items:
-                    if out:
-                        out.append(NL)
-                    out.append("{}{}- {}: ".format(indent, ("  " * _depth), k))
-                    if isinstance(v, ParseResults):
-                        if v:
-                            out.append(
-                                v.dump(
-                                    indent=indent,
-                                    full=full,
-                                    include_list=include_list,
-                                    _depth=_depth + 1,
-                                )
-                            )
-                        else:
-                            out.append(str(v))
-                    else:
-                        out.append(repr(v))
-            if any(isinstance(vv, ParseResults) for vv in self):
-                v = self
-                for i, vv in enumerate(v):
-                    if isinstance(vv, ParseResults):
-                        out.append(
-                            "\n{}{}[{}]:\n{}{}{}".format(
-                                indent,
-                                ("  " * (_depth)),
-                                i,
-                                indent,
-                                ("  " * (_depth + 1)),
-                                vv.dump(
-                                    indent=indent,
-                                    full=full,
-                                    include_list=include_list,
-                                    _depth=_depth + 1,
-                                ),
-                            )
-                        )
-                    else:
-                        out.append(
-                            "\n%s%s[%d]:\n%s%s%s"
-                            % (
-                                indent,
-                                ("  " * (_depth)),
-                                i,
-                                indent,
-                                ("  " * (_depth + 1)),
-                                str(vv),
-                            )
-                        )
-
-        return "".join(out)
-
-    def pprint(self, *args, **kwargs):
-        """
-        Pretty-printer for parsed results as a list, using the
-        `pprint <https://docs.python.org/3/library/pprint.html>`_ module.
-        Accepts additional positional or keyword args as defined for
-        `pprint.pprint <https://docs.python.org/3/library/pprint.html#pprint.pprint>`_ .
-
-        Example::
-
-            ident = Word(alphas, alphanums)
-            num = Word(nums)
-            func = Forward()
-            term = ident | num | Group('(' + func + ')')
-            func <<= ident + Group(Optional(delimited_list(term)))
-            result = func.parse_string("fna a,b,(fnb c,d,200),100")
-            result.pprint(width=40)
-
-        prints::
-
-            ['fna',
-             ['a',
-              'b',
-              ['(', 'fnb', ['c', 'd', '200'], ')'],
-              '100']]
-        """
-        pprint.pprint(self.as_list(), *args, **kwargs)
-
-    # add support for pickle protocol
-    def __getstate__(self):
-        return (
-            self._toklist,
-            (
-                self._tokdict.copy(),
-                self._parent is not None and self._parent() or None,
-                self._all_names,
-                self._name,
-            ),
-        )
-
-    def __setstate__(self, state):
-        self._toklist, (self._tokdict, par, inAccumNames, self._name) = state
-        self._all_names = set(inAccumNames)
-        if par is not None:
-            self._parent = wkref(par)
-        else:
-            self._parent = None
-
-    def __getnewargs__(self):
-        return self._toklist, self._name
-
-    def __dir__(self):
-        return dir(type(self)) + list(self.keys())
-
-    @classmethod
-    def from_dict(cls, other, name=None) -> "ParseResults":
-        """
-        Helper classmethod to construct a ``ParseResults`` from a ``dict``, preserving the
-        name-value relations as results names. If an optional ``name`` argument is
-        given, a nested ``ParseResults`` will be returned.
-        """
-
-        def is_iterable(obj):
-            try:
-                iter(obj)
-            except Exception:
-                return False
-            else:
-                return not isinstance(obj, str_type)
-
-        ret = cls([])
-        for k, v in other.items():
-            if isinstance(v, Mapping):
-                ret += cls.from_dict(v, name=k)
-            else:
-                ret += cls([v], name=k, asList=is_iterable(v))
-        if name is not None:
-            ret = cls([ret], name=name)
-        return ret
-
-    asList = as_list
-    asDict = as_dict
-    getName = get_name
-
-
-MutableMapping.register(ParseResults)
-MutableSequence.register(ParseResults)

spaces/CVPR/LIVE/thrust/thrust/system/cuda/detail/count.h

@@ -1,80 +0,0 @@
-/******************************************************************************
- * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the NVIDIA CORPORATION nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- ******************************************************************************/
-#pragma once
-
-
-#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
-#include <thrust/system/cuda/config.h>
-
-#include <thrust/system/cuda/detail/util.h>
-#include <thrust/system/cuda/detail/reduce.h>
-#include <thrust/distance.h>
-
-namespace thrust
-{
-namespace cuda_cub {
-
-template <class Derived,
-          class InputIt,
-          class UnaryPred>
-typename iterator_traits<InputIt>::difference_type __host__ __device__
-count_if(execution_policy<Derived> &policy,
-         InputIt                    first,
-         InputIt                    last,
-         UnaryPred                  unary_pred)
-{
-  typedef typename iterator_traits<InputIt>::difference_type size_type;
-  typedef transform_input_iterator_t<size_type,
-                                     InputIt,
-                                     UnaryPred>
-      flag_iterator_t;
-
-  return cuda_cub::reduce_n(policy,
-                            flag_iterator_t(first, unary_pred),
-                            thrust::distance(first, last),
-                            size_type(0),
-                            plus<size_type>());
-}
-
-template <class Derived,
-          class InputIt,
-          class Value>
-typename iterator_traits<InputIt>::difference_type __host__ __device__
-count(execution_policy<Derived> &policy,
-      InputIt                    first,
-      InputIt                    last,
-      Value const &              value)
-{
-  return cuda_cub::count_if(policy,
-                            first,
-                            last,
-                            thrust::detail::equal_to_value<Value>(value));
-}
-
-} // namespace cuda_cub
-} // end namespace thrust
-#endif

spaces/CVPR/LIVE/thrust/thrust/system/cuda/detail/transform_reduce.h

@@ -1,68 +0,0 @@
-/******************************************************************************
- * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the NVIDIA CORPORATION nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- ******************************************************************************/
-#pragma once
-
-
-#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
-#include <iterator>
-#include <thrust/system/cuda/detail/reduce.h>
-#include <thrust/distance.h>
-
-namespace thrust
-{
-namespace cuda_cub {
-
-template <class Derived,
-          class InputIt,
-          class TransformOp,
-          class T,
-          class ReduceOp>
-T __host__ __device__
-transform_reduce(execution_policy<Derived> &policy,
-                 InputIt                    first,
-                 InputIt                    last,
-                 TransformOp                transform_op,
-                 T                          init,
-                 ReduceOp                   reduce_op)
-{
-  typedef typename iterator_traits<InputIt>::difference_type size_type;
-  size_type num_items = static_cast<size_type>(thrust::distance(first, last));
-  typedef transform_input_iterator_t<T,
-                                     InputIt,
-                                     TransformOp>
-      transformed_iterator_t;
-
-  return cuda_cub::reduce_n(policy,
-                            transformed_iterator_t(first, transform_op),
-                            num_items,
-                            init,
-                            reduce_op);
-}
-
-}    // namespace cuda_cub
-} // end namespace thrust
-#endif

spaces/CVPR/monoscene_lite/monoscene/app.py

@@ -1,138 +0,0 @@
-from pytorch_lightning import Trainer
-from monoscene.models.monoscene import MonoScene
-from monoscene.data.NYU.nyu_dm import NYUDataModule
-from monoscene.data.semantic_kitti.kitti_dm import KittiDataModule
-from monoscene.data.kitti_360.kitti_360_dm import Kitti360DataModule
-# import hydra
-from omegaconf import DictConfig
-import torch
-import numpy as np
-import os
-from hydra.utils import get_original_cwd
-import gradio as gr
-import numpy as np
-import plotly.express as px
-import pandas as pd
-    
-
-# @hydra.main(config_name="../config/monoscene.yaml")
-def plot(input_img):
-    torch.set_grad_enabled(False)
-
-    # Setup dataloader
-    # if config.dataset == "kitti" or config.dataset == "kitti_360":
-    feature = 64
-    project_scale = 2
-    full_scene_size = (256, 256, 32)
-
-    #     if config.dataset == "kitti":
-    #         data_module = KittiDataModule(
-    #             root=config.kitti_root,
-    #             preprocess_root=config.kitti_preprocess_root,
-    #             frustum_size=config.frustum_size,
-    #             batch_size=int(config.batch_size / config.n_gpus),
-    #             num_workers=int(config.num_workers_per_gpu * config.n_gpus),
-    #         )
-    #         data_module.setup()
-    #         data_loader = data_module.val_dataloader()
-    #         # data_loader = data_module.test_dataloader() # use this if you want to infer on test set
-    #     else:
-    #         data_module = Kitti360DataModule(
-    #             root=config.kitti_360_root,
-    #             sequences=[config.kitti_360_sequence],
-    #             n_scans=2000,
-    #             batch_size=1,
-    #             num_workers=3,
-    #         )
-    #         data_module.setup()
-    #         data_loader = data_module.dataloader()
-
-    # elif config.dataset == "NYU":
-    #     project_scale = 1
-    #     feature = 200
-    #     full_scene_size = (60, 36, 60)
-    #     data_module = NYUDataModule(
-    #         root=config.NYU_root,
-    #         preprocess_root=config.NYU_preprocess_root,
-    #         n_relations=config.n_relations,
-    #         frustum_size=config.frustum_size,
-    #         batch_size=int(config.batch_size / config.n_gpus),
-    #         num_workers=int(config.num_workers_per_gpu * config.n_gpus),
-    #     )
-    #     data_module.setup()
-    #     data_loader = data_module.val_dataloader()
-    #     # data_loader = data_module.test_dataloader() # use this if you want to infer on test set
-    # else:
-    #     print("dataset not support")
-
-    # Load pretrained models
-    # if config.dataset == "NYU":
-    #     model_path = os.path.join(
-    #         get_original_cwd(), "trained_models", "monoscene_nyu.ckpt"
-    #     )
-    # else:
-    # model_path = os.path.join(
-    #     get_original_cwd(), "trained_models", "monoscene_kitti.ckpt"
-    # )
-    model_path = "trained_models/monoscene_kitti.ckpt"
-
-    model = MonoScene.load_from_checkpoint(
-        model_path,
-        feature=feature,
-        project_scale=project_scale,
-        fp_loss=False,
-        full_scene_size=full_scene_size,
-    )
-    model.cuda()
-    model.eval()
-
-    print(input_img.shape)
-    
-    x = np.arange(12).reshape(4, 3) / 12
-    data = pd.DataFrame(data=x, columns=['x', 'y', 'z'])
-    fig = px.scatter_3d(data, x="x", y="y", z="z")
-    return fig
-
-demo = gr.Interface(plot, gr.Image(shape=(200, 200)), gr.Plot())
-demo.launch()
-
-    
-
-    # Save prediction and additional data 
-    # to draw the viewing frustum and remove scene outside the room for NYUv2
-    # output_path = os.path.join(config.output_path, config.dataset)
-    # with torch.no_grad():
-    #     for batch in tqdm(data_loader):
-    #         batch["img"] = batch["img"].cuda()
-    #         pred = model(batch)
-    #         y_pred = torch.softmax(pred["ssc_logit"], dim=1).detach().cpu().numpy()
-    #         y_pred = np.argmax(y_pred, axis=1)
-    #         for i in range(config.batch_size):
-    #             out_dict = {"y_pred": y_pred[i].astype(np.uint16)}
-    #             if "target" in batch:
-    #                 out_dict["target"] = (
-    #                     batch["target"][i].detach().cpu().numpy().astype(np.uint16)
-    #                 )
-
-    #             if config.dataset == "NYU":
-    #                 write_path = output_path
-    #                 filepath = os.path.join(write_path, batch["name"][i] + ".pkl")
-    #                 out_dict["cam_pose"] = batch["cam_pose"][i].detach().cpu().numpy()
-    #                 out_dict["vox_origin"] = (
-    #                     batch["vox_origin"][i].detach().cpu().numpy()
-    #                 )
-    #             else:
-    #                 write_path = os.path.join(output_path, batch["sequence"][i])
-    #                 filepath = os.path.join(write_path, batch["frame_id"][i] + ".pkl")
-    #                 out_dict["fov_mask_1"] = (
-    #                     batch["fov_mask_1"][i].detach().cpu().numpy()
-    #                 )
-    #                 out_dict["cam_k"] = batch["cam_k"][i].detach().cpu().numpy()
-    #                 out_dict["T_velo_2_cam"] = (
-    #                     batch["T_velo_2_cam"][i].detach().cpu().numpy()
-    #                 )
-
-    #             os.makedirs(write_path, exist_ok=True)
-    #             with open(filepath, "wb") as handle:
-    #                 pickle.dump(out_dict, handle)
-    #                 print("wrote to", filepath)

spaces/CVPR/transfiner/configs/new_baselines/mask_rcnn_regnetx_4gf_dds_FPN_100ep_LSJ.py

@@ -1,29 +0,0 @@
-from .mask_rcnn_R_50_FPN_100ep_LSJ import (
-    dataloader,
-    lr_multiplier,
-    model,
-    optimizer,
-    train,
-)
-from detectron2.config import LazyCall as L
-from detectron2.modeling.backbone import RegNet
-from detectron2.modeling.backbone.regnet import SimpleStem, ResBottleneckBlock
-
-# Config source:
-# https://github.com/facebookresearch/detectron2/blob/master/configs/COCO-InstanceSegmentation/mask_rcnn_regnetx_4gf_dds_fpn_1x.py  # noqa
-model.backbone.bottom_up = L(RegNet)(
-    stem_class=SimpleStem,
-    stem_width=32,
-    block_class=ResBottleneckBlock,
-    depth=23,
-    w_a=38.65,
-    w_0=96,
-    w_m=2.43,
-    group_width=40,
-    norm="SyncBN",
-    out_features=["s1", "s2", "s3", "s4"],
-)
-model.pixel_std = [57.375, 57.120, 58.395]
-
-# RegNets benefit from enabling cudnn benchmark mode
-train.cudnn_benchmark = True

spaces/ChihChiu29/mychatbot/Dockerfile

@@ -1,24 +0,0 @@
-FROM python:3.9
-
-WORKDIR /code
-
-COPY ./requirements.txt /code/requirements.txt
-
-# For hugging face
-RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
-
-# For gpt4free
-RUN pip install gpt4free
-
-RUN useradd -m -u 1000 user
-
-USER user
-
-ENV HOME=/home/user \
-  PATH=/home/user/.local/bin:$PATH
-
-WORKDIR $HOME/app
-
-COPY --chown=user . $HOME/app
-
-CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

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

@@ -1,50 +0,0 @@
-from pathlib import Path
-from typing import List
-
-from pil_utils import BuildImage, Text2Image
-
-from meme_generator import MemeArgsModel, add_meme
-from meme_generator.exception import TextOrNameNotEnough, TextOverLength
-
-img_dir = Path(__file__).parent / "images"
-
-
-def make_friend(images: List[BuildImage], texts: List[str], args: MemeArgsModel):
-    img = images[0].convert("RGBA")
-
-    if not texts and not args.user_infos:
-        raise TextOrNameNotEnough("make_friend")
-    name = texts[0] if texts else args.user_infos[0].name
-
-    bg = BuildImage.open(img_dir / "0.png")
-    frame = img.resize_width(1000)
-    frame.paste(
-        img.resize_width(250).rotate(9, expand=True),
-        (743, frame.height - 155),
-        alpha=True,
-    )
-    frame.paste(
-        img.square().resize((55, 55)).rotate(9, expand=True),
-        (836, frame.height - 278),
-        alpha=True,
-    )
-    frame.paste(bg, (0, frame.height - 1000), alpha=True)
-
-    text_img = Text2Image.from_text(name, 20, fill="white").to_image()
-    if text_img.width > 230:
-        raise TextOverLength(name)
-
-    text_img = BuildImage(text_img).rotate(9, expand=True)
-    frame.paste(text_img, (710, frame.height - 308), alpha=True)
-    return frame.save_jpg()
-
-
-add_meme(
-    "make_friend",
-    make_friend,
-    min_images=1,
-    max_images=1,
-    min_texts=0,
-    max_texts=1,
-    keywords=["交个朋友"],
-)

spaces/CofAI/chat.b4/g4f/Provider/Provider.py

@@ -1,16 +0,0 @@
-import os
-from ..typing import sha256, Dict, get_type_hints
-
-url = None
-model = None
-supports_stream = False
-needs_auth = False
-
-
-def _create_completion(model: str, messages: list, stream: bool, **kwargs):
-    return
-
-
-params = f'g4f.Providers.{os.path.basename(__file__)[:-3]} supports: ' + \
-    '(%s)' % ', '.join(
-        [f"{name}: {get_type_hints(_create_completion)[name].__name__}" for name in _create_completion.__code__.co_varnames[:_create_completion.__code__.co_argcount]])

spaces/CofAI/sd-2.1/sd-2-1.py

@@ -1,16 +0,0 @@
-#import
-import gradio as gr
-import torch
-
-DESCRIPTION = '# Kandinsky 2.1'
-if not torch.cuda.is_available():
-    DESCRIPTION += '\n<p>Running on CPU 🥶 This demo does not work on CPU.</p>'
-
-#description
-description = """<div>
-                CofAI.SD
-              </div>
-              """
-
-#model
-gr.Interface.load("models/stabilityai/stable-diffusion-2-1", description=description).launch()

spaces/Cropinky/hana_hanak_houses/realesrgan/data/__init__.py

@@ -1,10 +0,0 @@
-import importlib
-from basicsr.utils import scandir
-from os import path as osp
-
-# automatically scan and import dataset modules for registry
-# scan all the files that end with '_dataset.py' under the data folder
-data_folder = osp.dirname(osp.abspath(__file__))
-dataset_filenames = [osp.splitext(osp.basename(v))[0] for v in scandir(data_folder) if v.endswith('_dataset.py')]
-# import all the dataset modules
-_dataset_modules = [importlib.import_module(f'realesrgan.data.{file_name}') for file_name in dataset_filenames]

spaces/Cyril666/ContourNet-ABI/maskrcnn_benchmark/modeling/rpn/loss.py

@@ -1,153 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
-"""
-This file contains specific functions for computing losses on the RPN
-file
-"""
-
-import torch
-from torch.nn import functional as F
-from maskrcnn_benchmark.config import cfg
-
-from .utils import concat_box_prediction_layers
-
-from ..balanced_positive_negative_sampler import BalancedPositiveNegativeSampler
-from ..utils import cat
-
-from maskrcnn_benchmark.layers import smooth_l1_loss
-from maskrcnn_benchmark.layers import iou_regress
-from maskrcnn_benchmark.modeling.matcher import Matcher
-from maskrcnn_benchmark.structures.boxlist_ops import boxlist_iou
-from maskrcnn_benchmark.structures.boxlist_ops import cat_boxlist
-
-
-class RPNLossComputation(object):
-    """
-    This class computes the RPN loss.
-    """
-
-    def __init__(self, proposal_matcher, fg_bg_sampler, box_coder,
-                 generate_labels_func):
-        """
-        Arguments:
-            proposal_matcher (Matcher)
-            fg_bg_sampler (BalancedPositiveNegativeSampler)
-            box_coder (BoxCoder)
-        """
-        self.proposal_matcher = proposal_matcher
-        self.fg_bg_sampler = fg_bg_sampler
-        self.box_coder = box_coder
-        self.copied_fields = []
-        self.generate_labels_func = generate_labels_func
-        self.discard_cases = ['not_visibility', 'between_thresholds']
-
-    def match_targets_to_anchors(self, anchor, target, copied_fields=[]):
-
-        match_quality_matrix = boxlist_iou(target, anchor)
-        matched_idxs = self.proposal_matcher(match_quality_matrix)
-        # RPN doesn't need any fields from target for creating the labels, so clear them all
-        target = target.copy_with_fields(copied_fields)
-        # get the targets corresponding GT for each anchor
-        # NB: need to clamp the indices because we can have a single
-        # GT in the image, and matched_idxs can be -2, which goes
-        # out of bounds
-        matched_targets = target[matched_idxs.clamp(min=0)]
-        matched_targets.add_field("matched_idxs", matched_idxs)
-        return matched_targets
-
-    def prepare_targets(self, anchors, targets):
-        labels = []
-        regression_targets = []
-
-        for anchors_per_image, targets_per_image in zip(anchors, targets):
-            matched_targets = self.match_targets_to_anchors(
-                anchors_per_image, targets_per_image, self.copied_fields
-            )
-
-            matched_idxs = matched_targets.get_field("matched_idxs")
-            labels_per_image = self.generate_labels_func(matched_targets)
-            labels_per_image = labels_per_image.to(dtype=torch.float32)
-
-            # Background (negative examples)
-            bg_indices = matched_idxs == Matcher.BELOW_LOW_THRESHOLD
-            labels_per_image[bg_indices] = 0
-
-            # discard anchors that go out of the boundaries of the image
-            if "not_visibility" in self.discard_cases:
-                labels_per_image[~anchors_per_image.get_field("visibility")] = -1
-
-            # discard indices that are between thresholds
-            if "between_thresholds" in self.discard_cases:
-                inds_to_discard = matched_idxs == Matcher.BETWEEN_THRESHOLDS
-                labels_per_image[inds_to_discard] = -1
-            regression_targets_per_image = matched_targets.bbox
-            labels.append(labels_per_image)
-            regression_targets.append(regression_targets_per_image)
-
-        return labels, regression_targets
-
-
-    def __call__(self, anchors, objectness, box_regression, targets):
-        """
-        Arguments:
-            anchors (list[BoxList])
-            objectness (list[Tensor])
-            box_regression (list[Tensor])
-            targets (list[BoxList])
-
-        Returns:
-            objectness_loss (Tensor)
-            box_loss (Tensor
-        """
-        anchors = [cat_boxlist(anchors_per_image) for anchors_per_image in anchors]
-
-        labels, regression_targets = self.prepare_targets(anchors, targets)
-        sampled_pos_inds, sampled_neg_inds = self.fg_bg_sampler(labels)
-        sampled_pos_inds = torch.nonzero(torch.cat(sampled_pos_inds, dim=0)).squeeze(1)
-        sampled_neg_inds = torch.nonzero(torch.cat(sampled_neg_inds, dim=0)).squeeze(1)
-
-        sampled_inds = torch.cat([sampled_pos_inds, sampled_neg_inds], dim=0)
-        objectness, box_regression = \
-                concat_box_prediction_layers(objectness, box_regression)
-        objectness = objectness.squeeze()   # [1041820]
-        labels = torch.cat(labels, dim=0)
-        regression_targets = torch.cat(regression_targets, dim=0)
-
-        box_loss = iou_regress(
-            box_regression[sampled_pos_inds],
-            regression_targets[sampled_pos_inds],
-            beta=1.0 / 9,
-            size_average=False,
-        ) / (sampled_inds.numel())
-
-        box_loss *= cfg.MODEL.ROI_BOUNDARY_HEAD.Loss_balance
-
-        objectness_loss = F.binary_cross_entropy_with_logits(
-            objectness[sampled_inds], labels[sampled_inds]
-        )
-        return objectness_loss, box_loss
-
-# This function should be overwritten in RetinaNet 11
-def generate_rpn_labels(matched_targets):
-    matched_idxs = matched_targets.get_field("matched_idxs")
-    labels_per_image = matched_idxs >= 0
-    return labels_per_image
-
-
-def make_rpn_loss_evaluator(cfg, box_coder):
-    matcher = Matcher(
-        cfg.MODEL.RPN.FG_IOU_THRESHOLD,
-        cfg.MODEL.RPN.BG_IOU_THRESHOLD,
-        allow_low_quality_matches=True,
-    )
-
-    fg_bg_sampler = BalancedPositiveNegativeSampler(
-        cfg.MODEL.RPN.BATCH_SIZE_PER_IMAGE, cfg.MODEL.RPN.POSITIVE_FRACTION
-    )
-
-    loss_evaluator = RPNLossComputation(
-        matcher,
-        fg_bg_sampler,
-        box_coder,
-        generate_rpn_labels
-    )
-    return loss_evaluator