Update parquet files (step 105 of 121)

spaces/1gistliPinn/ChatGPT4/Examples/Cyberflex E-gate Driver Download Win7 REPACK.md

@@ -1,44 +0,0 @@
-<h2>cyberflex e-gate driver download win7</h2><br /><p><b><b>Download Zip</b> &bull;&bull;&bull; <a href="https://imgfil.com/2uy16N">https://imgfil.com/2uy16N</a></b></p><br /><br />
-<br />
-8 bit not working
-
- when i try to update my ubuntu it says operation not possible
-
- s0u][ight: Please pastebin the full output of "sudo apt-get update".
-
- paste?
-
-!pastebin | s0u][ight
-
- s0u][ight: For posting multi-line texts into the channel, please use  | To post!screenshots use  |!pastebinit to paste directly from command line | Make sure you give us the URL for your paste - see also the channel topic.
-
- ok
-
- 
-
- i did an apt-get update and it started saying that
-
- s0u][ight: Please remove all "ppa.launchpad.net/n/n/" from your sources.list.
-
- s0u][ight: (Any instances of "ppa.launchpad.net/n/n/" in sources.list.d will also need to be removed).
-
- s0u][ight, ppa's must be disabled in the /etc/apt/sources.list.d file
-
- BluesKaj: That is incorrect. ppas are currently permitted for apt-get, and apt-get update is not even intended to read that file.
-
- Jordan_U, nevermind
-
- BluesKaj: s0u][ight: Please pastebin the entire contents of /etc/apt/sources.list and /etc/apt/sources.list.d/.
-
- did that
-
- removed all ppa lines
-
- now apt-get update
-
- Jordan_U, well, my mistake on ppa, it won't hurt anything at this time
-
- BluesKaj: It's not a mistake. s0u][ight: 4fefd39f24<br />
-<br />
-<br />
-<p></p>

spaces/1gistliPinn/ChatGPT4/Examples/Download Jumpstart For Wireless Windows 7.md

@@ -1,6 +0,0 @@
-<h2>download jumpstart for wireless windows 7</h2><br /><p><b><b>Download File</b> &#11088; <a href="https://imgfil.com/2uy11z">https://imgfil.com/2uy11z</a></b></p><br /><br />
-
-2K, XP, 2K3, VISTA, WIN7/32bits. Download. Jumpstart Wireless Intermediate Driver. Others. TL-WN7200ND_V1_Utility.zip. 1.0.0.46. 2008-09-25. 22.51 MB. 4d29de3e1b<br />
-<br />
-<br />
-<p></p>

spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/4k video downloader review is it safe and reliable? - Reddit.md

@@ -1,117 +0,0 @@
-
-<h1>How to Download 4K Videos from YouTube and Reddit</h1>
-<p>If you are a fan of high-quality videos, you might have noticed that many YouTube and Reddit videos are available in 4K resolution. 4K videos offer stunning clarity, detail, and color that can enhance your viewing experience. However, watching 4K videos online requires a fast and stable internet connection, which is not always available. Moreover, you might want to save some 4K videos offline for personal use, such as editing, sharing, or watching later. In this article, we will show you how to download 4K videos from YouTube and Reddit using some of the best 4K video downloader software for PC and Mac.</p>
-<h2>4k download youtube reddit</h2><br /><p><b><b>Download</b> &#10084; <a href="https://urlin.us/2uSS9u">https://urlin.us/2uSS9u</a></b></p><br /><br />
- <h2>What is 4K Video and Why You Need It</h2>
-<p>4K video is a video format that has a resolution of 3840 x 2160 pixels, which is four times more than the standard HD resolution of 1920 x 1080 pixels. This means that 4K video has more pixels per inch (PPI), which results in sharper and clearer images. You can see more details, textures, and colors in 4K video than in HD video.</p>
- <h3>The Benefits of 4K Video Quality</h3>
-<p>There are many benefits of watching and downloading 4K videos, such as:</p>
-<ul>
-<li>You can enjoy a more immersive and realistic viewing experience, especially on large screens or VR devices.</li>
-<li>You can capture more details and nuances in your videos, which can improve your content creation and editing skills.</li>
-<li>You can future-proof your videos, as 4K is becoming the new standard for video quality.</li>
-</ul>
- <h3>The Challenges of 4K Video Downloading</h3>
-<p>However, there are also some challenges that you might face when downloading 4K videos from YouTube and Reddit, such as:</p>
-<ul>
-<li>Not all videos are available in 4K resolution, especially older or low-budget ones.</li>
-<li>Downloading 4K videos requires more time, storage space, and bandwidth than downloading HD videos.</li>
-<li>Playing 4K videos requires a compatible device, player, and monitor that can support the high resolution.</li>
-<li>Downloading copyrighted videos without permission or fair use can violate the law and ethical principles.</li>
-</ul>
- <h2>The Best 4K Video Downloader Software for PC and Mac</h2>
-<p>To overcome these challenges, you need a reliable and powerful 4K video downloader software that can help you download YouTube and Reddit videos in 4K resolution with ease. Here are some of the best options that we recommend:</p>
-<p>4k video downloader safe reddit<br />
-4k video downloader error reddit<br />
-4k video downloader proxy reddit<br />
-4k video downloader alternative reddit<br />
-4k video downloader license key reddit<br />
-4k video downloader activation key reddit<br />
-4k video downloader crack reddit<br />
-4k video downloader premium reddit<br />
-4k video downloader review reddit<br />
-4k video downloader youtube-dl reddit<br />
-best way to download 4k youtube videos reddit<br />
-how to download 4k youtube videos reddit<br />
-best 4k youtube downloader reddit<br />
-free 4k youtube downloader reddit<br />
-youtube-dl 4k reddit<br />
-youtube-dl download 4k reddit<br />
-youtube-dl best quality reddit<br />
-youtube-dl mkv reddit<br />
-youtube-dl proxy reddit<br />
-youtube-dl alternative reddit<br />
-download blocked youtube videos reddit<br />
-download youtube videos in full hd reddit<br />
-download youtube videos in 1080p reddit<br />
-download youtube videos in mkv format reddit<br />
-download youtube videos with subtitles reddit<br />
-download youtube playlists in 4k reddit<br />
-download youtube screensavers in 4k reddit<br />
-download youtube stock footage in 4k reddit<br />
-download youtube backgrounds in 4k reddit<br />
-download youtube music videos in 4k reddit<br />
-download youtube documentaries in 4k reddit<br />
-download youtube movies in 4k reddit<br />
-download youtube trailers in 4k reddit<br />
-download youtube live streams in 4k reddit<br />
-download youtube vr videos in 4k reddit<br />
-download youtube hdr videos in 4k reddit<br />
-download youtube 360 videos in 4k reddit<br />
-download youtube slow motion videos in 4k reddit<br />
-download youtube timelapse videos in 4k reddit<br />
-download youtube hyperlapse videos in 4k reddit</p>
- <h3>4K Video Downloader</h3>
-<p><a href="(^10^)">[10](https://www.4kdownload.com/)</a></p>
-<p>As the name suggests, this software is designed to download 4K videos from YouTube and other popular video sites. It has a simple and user-friendly interface that allows you to download videos, playlists , channels, and subtitles in various formats and quality options. It also supports 3D and 360-degree videos, smart mode, and cross-platform compatibility. You can download up to 24 videos in a batch with the free version, or unlimited videos with the premium version.</p>
- <h3>Fucosoft Video Converter</h3>
-<p><a href="">[9](https://www.fucosoft.com/video-converter.html)</a></p>
-<p>This software is not only a video converter, but also a video downloader that can download 4K videos from YouTube, Reddit, Facebook, Instagram, Twitter, and more. It can also convert downloaded videos to various formats, such as MP4, MOV, AVI, MKV, etc., and edit them with built-in tools. You can download multiple videos at once with high speed and quality.</p>
- <h3>Wondershare AllMyTube</h3>
-<p><a href="">[8](https://videoconverter.wondershare.com/allmytube-video-downloader.html)</a></p>
-<p>This software is another versatile video downloader that can download 4K videos from YouTube and over 10,000 other video sites. It can also convert downloaded videos to different formats and devices, such as iPhone, iPad, Android, etc. It has a one-click download mode, a browser extension, a video player, and a video library. You can download up to 10 videos at the same time with the free trial version, or unlimited videos with the full version.</p>
- <h3>Gihosoft TubeGet</h3>
-<p><a href="">[7](https://www.gihosoft.com/free-youtube-downloader.html)</a></p>
-<p>This software is a simple and effective video downloader that can download 4K videos from YouTube and other sites. It can also extract audio from videos and save them as MP3 files. It has a clean and intuitive interface that lets you download videos by copying and pasting URLs or using the browser add-on. You can download up to five videos per day with the free version, or unlimited videos with the pro version.</p>
- <h3>Leawo CleverGet</h3>
-<p><a href="">[6](https://www.leawo.org/cleverget/)</a></p>
-<p>This software is a smart and powerful video downloader that can download 4K videos from YouTube and more than 1000 other sites. It can also convert downloaded videos to various formats and resolutions, such as 1080P, 720P, etc. It has a multi-threading technology that accelerates the download speed and ensures the video quality. You can download unlimited videos with the free version, but you need to upgrade to the premium version to remove the watermark.</p>
- <h3>AmoyShare AnyUTube</h3>
-<p><a href="">[5](https://www.amoyshare.com/anyutube/)</a></p>
-<p>This software is a dedicated YouTube video downloader that can download 4K videos from YouTube in MP4 or MP3 format. It can also download YouTube playlists, channels, subtitles, and lyrics. It has a user-friendly interface that allows you to search for videos by keywords or URLs. You can download up to 14 videos per day with the free version, or unlimited videos with the paid version.</p>
- <h2>How to Use 4K Video Downloader Software to Download YouTube and Reddit Videos</h2>
-<p>Although each 4K video downloader software has its own features and functions, they generally share the same steps for downloading YouTube and Reddit videos in 4K resolution. Here are the common steps that you need to follow:</p>
- <h3>Step 1: Copy the Video URL</h3>
-<p>The first step is to copy the URL of the video that you want to download from YouTube or Reddit. You can do this by right-clicking on the video and selecting "Copy video URL" or "Copy link address". Alternatively, you can copy the URL from the address bar of your browser.</p>
- <h3>Step 2: Paste the URL into the Software</h3>
-<p>The next step is to paste the URL into the software that you have installed on your PC or Mac. You can do this by clicking on the "Paste URL" button or using the keyboard shortcut Ctrl+V (Windows) or Command+V (Mac). The software will automatically analyze the URL and show you the available download options.</p>
- <h3>Step 3: Choose the Output Format and Quality</h3>
-<p>The third step is to choose the output format and quality that you want for your downloaded video. You can choose from different formats, such as MP4, MKV, AVI, etc., depending on your preference and device compatibility. You can also choose the quality level, such as 4K, 1080P, 720P, etc., depending on your internet speed and storage space. You can also choose to download the audio only or the subtitles if available.</p>
- <h3>Step 4: Start the Download Process</h3>
-<p>The final step is to start the download process by clicking on the "Download" button or using the keyboard shortcut Enter. The software will begin to download the video in the background and show you the progress and speed. You can pause, resume, or cancel the download at any time. Once the download is completed, you can find the video in the output folder or the video library of the software.</p>
- <h2>Tips and Tricks for 4K Video Downloading and Playback</h2>
-<p>To make the most of your 4K video downloading and playback experience, here are some tips and tricks that you should keep in mind:</p>
- <h3>Check the Internet Speed and Bandwidth</h3>
-<p>Downloading 4K videos requires a fast and stable internet connection, as they are much larger than HD videos. You should check your internet speed and bandwidth before downloading 4K videos, and avoid downloading multiple videos at the same time or using other applications that consume internet resources. You can use online tools such as <a href="">[9](https://www.speedtest.net/)</a> to test your internet speed and performance.</p>
- <h3>Adjust the Encoder Settings and Bitrates</h3>
-<p>Downloading 4K videos also requires a lot of storage space, as they are much heavier than HD videos. You should check your storage space before downloading 4K videos, and delete or transfer some files if necessary. You can also adjust the encoder settings and bitrates of your downloaded videos to reduce their file size without compromising their quality. You can use online tools such as <a href="">[8](https://www.onlineconverter.com/video)</a> to compress and convert your videos online.</p>
- <h3>Use a Compatible Device and Player</h3>
-<p>Playing 4K videos requires a compatible device, player, and monitor that can support the high resolution. You should check your device specifications before playing 4K videos, and upgrade your hardware or software if needed. You can also use a dedicated 4K video player that can optimize the playback quality and performance of your videos. Some of the best 4K video players are <a href="">[7](https://www.vlc.de/en/)</a>, <a href="">[6](https://www.kmplayer.com/)</a>, <a href="">[5](https://www.5kplayer.com/)</a>, <a href="">[4](https://potplayer.daum.net/)</a>, and <a href="">[3](https://mpv.io/)</a>.</p>
- <h3>Respect the Copyright Laws and Fair Use Policy</h3>
-<p>Downloading 4K videos from YouTube and Reddit is not illegal, as long as you follow the fair use policy and respect the rights of the original creators. You should not download or use any videos that are protected by copyright or have restricted permissions. You should also not download or use any videos for commercial purposes or without giving proper credit to the sources. You should also not download or use any videos that contain illegal, harmful, or offensive content. You should always respect the terms and conditions of YouTube and Reddit, and the laws and regulations of your country.</p>
- <h2>Conclusion</h2>
-<p>Downloading 4K videos from YouTube and Reddit can be a great way to enjoy high-quality videos offline or for personal use. However, you need to have the right tools and techniques to download and play 4K videos smoothly and safely. In this article, we have introduced some of the best 4K video downloader software for PC and Mac, and how to use them to download YouTube and Reddit videos in 4K resolution. We have also shared some tips and tricks for 4K video downloading and playback, and how to respect the copyright laws and fair use policy. We hope that this article has helped you learn more about 4K video downloading and how to do it properly.</p>
- <h2>FAQs</h2>
-<p>Here are some of the frequently asked questions about 4K video downloading:</p>
- <h3>Q: What is the difference between 4K and UHD?</h3>
-<p>A: 4K and UHD are often used interchangeably, but they are not exactly the same. 4K refers to the resolution of 4096 x 2160 pixels, which is used in digital cinema and professional video production. UHD refers to the resolution of 3840 x 2160 pixels, which is used in consumer TVs and monitors. Both resolutions have the same aspect ratio of 16:9, but 4K has slightly more pixels than UHD.</p>
- <h3>Q: How much storage space does a 4K video take?</h3>
-<p>A: The storage space of a 4K video depends on several factors, such as the length, format, codec, bitrate, and compression of the video. However, a rough estimate is that a one-minute 4K video can take up to 375 MB of storage space. Therefore, a one-hour 4K video can take up to 22.5 GB of storage space.</p>
- <h3>Q: How fast is the internet speed required for downloading or streaming 4K videos?</h3>
-<p>A: The internet speed required for downloading or streaming 4K videos also depends on several factors, such as the source, quality, platform, and network of the video. However, a general recommendation is that you need at least 25 Mbps of internet speed for downloading or streaming 4K videos smoothly.</p>
- <h3>Q: Can I download 4K videos from YouTube or Reddit on my mobile device?</h3>
-<p>A: Yes, you can download 4K videos from YouTube or Reddit on your mobile device, but you need to use a third-party app or website that can support 4K video downloading. Some of the popular apps or websites are <a href="">[2](https://www.videoder.com/)</a>, <a href="">[1](https://ytmp3.cc/en13/)</a>, <a href="">[0](https://www.tubemate.net/)</a>, etc. However, you should be careful about the security and legality of these apps or websites, as they might contain malware or violate the terms and conditions of YouTube or Reddit.</p>
- <h3>Q: How can I play 4K videos on my PC or Mac?</h3>
-<p>A: To play 4K videos on your PC or Mac, you need to have a compatible device, player, and monitor that can support the high resolution. You can check your device specifications and upgrade your hardware or software if needed. You can also use a dedicated 4K video player that can optimize the playback quality and performance of your videos. Some of the best 4K video players are <a href="">[7](https://www.vlc.de/en/)</a>, <a href="">[6](https://www.kmplayer.com/)</a>, <a href="">[5](https://www.5kplayer.com/)</a>, <a href="">[4](https://potplayer.daum.net/)</a>, and <a href="">[3](https://mpv.io/)</a>.</p> 197e85843d<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Become a Pilot in the Indian Air Force A Cut Above Game for PC and Mobile.md

@@ -1,86 +0,0 @@
-<br />
-<h1>Indian Air Force: A Cut Above Game Download</h1>
-<p>If you have ever dreamed of becoming a fighter pilot in the Indian Air Force, then you might want to check out this game. Indian Air Force: A Cut Above is a free air combat mobile game that lets you experience the thrill and challenge of flying various IAF aircraft and weapons. The game was developed by Threye Interactive, a Delhi-based game studio, in collaboration with the Indian Air Force. It was officially launched on July 31, 2019 by the Air Chief Marshal B.S. Dhanoa for Android and iOS devices. The game aims to attract and inspire the youth to join the IAF and serve the nation.</p>
-<h2>Features of the game</h2>
-<p>Indian Air Force: A Cut Above has three game modes: Training, Single Player, and Free Flight. In Training mode, you can learn the basics of flying, landing, combat, and rescue operations. In Single Player mode, you can take on various missions that test your skills and courage. You can also customize your pilot avatar and choose from different IAF aircraft such as MiG-21, Mirage-2000, Su-30MKI, Rafale, Tejas, Apache, and Chinook. In Free Flight mode, you can explore the skies in any aircraft you want.</p>
-<h2>indian air force a cut above game download</h2><br /><p><b><b>Download File</b> &#10040; <a href="https://jinyurl.com/2uNQQj">https://jinyurl.com/2uNQQj</a></b></p><br /><br />
-<p>The game features realistic and engaging gameplay and graphics that simulate the actual scenarios faced by IAF pilots. You can experience flying in different weather conditions, terrains, and altitudes. You can also use different weapons such as guns, missiles, rockets, and bombs to destroy enemy targets. The game also has a character modelled after Wing Commander Abhinandan Varthaman, who shot down a Pakistani F-16 in February 2019. You can even sport his signature gunslinger moustache in the game.</p>
-<h2>Review of the game</h2>
-<p>Indian Air Force: A Cut Above is a fun and exciting game that gives you a glimpse of what it takes to be an IAF warrior. The game has many pros such as:</p>
-<ul>
-<li>It is free to download and play</li>
-<li>It has a variety of modes, missions, aircraft, and weapons to choose from</li>
-<li>It has realistic and immersive gameplay and graphics</li>
-<li>It has educational and motivational value for aspiring IAF pilots</li>
-</ul>
-<p>However, the game also has some cons such as:</p>
-<p>How to play Indian Air Force: A Cut Above on PC<br />
-Indian Air Force: A Cut Above app store review<br />
-Indian Air Force: A Cut Above gameplay and features<br />
-Indian Air Force: A Cut Above apk file download<br />
-Indian Air Force: A Cut Above best fighter jets and weapons<br />
-Indian Air Force: A Cut Above solo and PvP missions<br />
-Indian Air Force: A Cut Above tips and tricks for beginners<br />
-Indian Air Force: A Cut Above official trailer and launch date<br />
-Indian Air Force: A Cut Above system requirements and compatibility<br />
-Indian Air Force: A Cut Above mod apk unlimited money<br />
-Indian Air Force: A Cut Above online test and recruitment<br />
-Indian Air Force: A Cut Above digital india initiative<br />
-Indian Air Force: A Cut Above latest updates and news<br />
-Indian Air Force: A Cut Above cheats and hacks<br />
-Indian Air Force: A Cut Above bluestacks emulator download<br />
-Indian Air Force: A Cut Above ios and android devices<br />
-Indian Air Force: A Cut Above customer support and feedback<br />
-Indian Air Force: A Cut Above ratings and rankings<br />
-Indian Air Force: A Cut Above achievements and rewards<br />
-Indian Air Force: A Cut Above realistic graphics and sound effects<br />
-Indian Air Force: A Cut Above history and background<br />
-Indian Air Force: A Cut Above offline mode and data usage<br />
-Indian Air Force: A Cut Above installation and setup guide<br />
-Indian Air Force: A Cut Above comparison with other air combat games<br />
-Indian Air Force: A Cut Above pros and cons of playing<br />
-Indian Air Force: A Cut Above free download link and size<br />
-Indian Air Force: A Cut Above fun facts and trivia<br />
-Indian Air Force: A Cut Above user reviews and testimonials<br />
-Indian Air Force: A Cut Above challenges and difficulty levels<br />
-Indian Air Force: A Cut Above screenshots and videos<br />
-Indian Air Force: A Cut Above frequently asked questions (FAQs)<br />
-Indian Air Force: A Cut Above community and forums<br />
-Indian Air Force: A Cut Above bugs and issues report<br />
-Indian Air Force: A Cut Above fan art and memes<br />
-Indian Air Force: A Cut Above developer interview and insights</p>
-<ul>
-<li>It requires internet connection and permissions to access your photos, files, and phone calls</li>
-<li>It does not support auto-rotate or notch displays</li>
-<li>It has clunky controls and audio effects</li>
-<li>It does not have multiplayer or online features yet</li>
-</ul>
-<p>Compared to other similar games such as Ace Combat or H.A.W.X., Indian Air Force: A Cut Above is more arcade-style than simulation-style. It does not have complex controls or physics, but it does have more variety and authenticity in terms of IAF scenarios and equipment.</p>
-<p>Some tips and tricks to play the game better are:</p>
-<ul>
-<li>Complete the training mode before attempting the missions</li>
-<li>Use the radar and target lock features to locate and track enemies</li>
-<li>Avoid flying too low or too high to avoid crashing or stalling</li>
-<li>Use different weapons for different targets depending on their range and type</li>
-<li>Refuel your aircraft when needed by flying close to a tanker plane</li>
-</ul>
-<h2>Conclusion</h2>
-<p>Indian Air Force: A Cut Above is a great game for anyone who loves air combat and adventure. It is a unique and innovative game that showcases the glory and valor of the Indian Air Force. It is also a game that can inspire and educate the youth about the IAF and its role in defending the nation.</p>
-<p>If you want to download and play the game, you can visit the official website of the Indian Air Force or the Google Play Store or the App Store. The game is compatible with Android 5.0 and above and iOS 9.0 and above devices. The game size is about 300 MB and it requires about 1 GB of free space on your device.</p>
-<p>So, what are you waiting for? Download Indian Air Force: A Cut Above today and experience the thrill of flying in the sky. You will not regret it!</p>
-<h2>FAQs</h2>
-<p>Here are some frequently asked questions about the game:</p>
-<ol>
-<li>Is Indian Air Force: A Cut Above an official game of the IAF?</li>
-<p>Yes, it is an official game of the IAF that was developed in collaboration with Threye Interactive, a Delhi-based game studio.</p>
-<li>Is Indian Air Force: A Cut Above a free game?</li>
-<p>Yes, it is a free game that does not have any in-app purchases or ads. However, it does require internet connection and permissions to access your photos, files, and phone calls.</p>
-<li>Is Indian Air Force: A Cut Above a realistic game?</li>
-<p>It is a realistic game in terms of the scenarios, aircraft, and weapons that are used by the IAF. However, it is not a simulation game that has complex controls or physics. It is more of an arcade-style game that is easy to play and enjoy.</p>
-<li>Is Indian Air Force: A Cut Above a multiplayer game?</li>
-<p>No, it is not a multiplayer game yet. It only has single-player modes such as Training, Single Player, and Free Flight. However, the developers have said that they are working on adding multiplayer and online features in the future.</p>
-<li>How can I contact the developers of Indian Air Force: A Cut Above?</li>
-<p>You can contact the developers of Indian Air Force: A Cut Above by visiting their website www.threye.com or by emailing them at [email protected]. You can also follow them on Facebook, Twitter, Instagram, and YouTube for updates and news.</p>
-</ol></p> 401be4b1e0<br />
-<br />
-<br />

spaces/1toTree/lora_test/ppdiffusers/pipelines/stable_diffusion/pipeline_fastdeploy_stable_diffusion_inpaint_legacy.py

@@ -1,477 +0,0 @@
-# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
-# Copyright 2022 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import inspect
-from typing import Callable, List, Optional, Union
-
-import numpy as np
-import paddle
-import PIL
-
-from paddlenlp.transformers import CLIPFeatureExtractor, CLIPTokenizer
-
-from ...fastdeploy_utils import FastDeployRuntimeModel
-from ...pipeline_utils import DiffusionPipeline
-from ...schedulers import (
-    DDIMScheduler,
-    DPMSolverMultistepScheduler,
-    EulerAncestralDiscreteScheduler,
-    EulerDiscreteScheduler,
-    LMSDiscreteScheduler,
-    PNDMScheduler,
-)
-from ...utils import PIL_INTERPOLATION, logging
-from . import StableDiffusionPipelineOutput
-
-logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
-
-
-def preprocess_image(image):
-    w, h = image.size
-    w, h = map(lambda x: x - x % 32, (w, h))  # resize to integer multiple of 32
-    image = image.resize((w, h), resample=PIL_INTERPOLATION["lanczos"])
-    image = np.array(image).astype(np.float32) / 255.0
-    image = image[None].transpose(0, 3, 1, 2)
-    return 2.0 * image - 1.0
-
-
-def preprocess_mask(mask, scale_factor=8):
-    mask = mask.convert("L")
-    w, h = mask.size
-    w, h = map(lambda x: x - x % 32, (w, h))  # resize to integer multiple of 32
-    mask = mask.resize((w // scale_factor, h // scale_factor), resample=PIL_INTERPOLATION["nearest"])
-    mask = np.array(mask).astype(np.float32) / 255.0
-    mask = np.tile(mask, (4, 1, 1))
-    mask = mask[None].transpose(0, 1, 2, 3)  # what does this step do?
-    mask = 1 - mask  # repaint white, keep black
-    return mask
-
-
-class FastDeployStableDiffusionInpaintPipelineLegacy(DiffusionPipeline):
-    r"""
-    Pipeline for text-guided image inpainting legacy using Stable Diffusion.
-
-    This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods the
-    library implements for all the pipelines (such as downloading or saving etc.)
-
-    Args:
-        vae_encoder ([`FastDeployRuntimeModel`]):
-            Variational Auto-Encoder (VAE) Model to encode images to latent representations.
-        vae_decoder ([`FastDeployRuntimeModel`]):
-            Variational Auto-Encoder (VAE) Model to decode images from latent representations.
-        text_encoder ([`FastDeployRuntimeModel`]):
-            Frozen text-encoder. Stable Diffusion uses the text portion of
-            [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), specifically
-            the [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14) variant.
-        tokenizer (`CLIPTokenizer`):
-            Tokenizer of class
-            [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer).
-        unet ([`FastDeployRuntimeModel`]): Conditional U-Net architecture to denoise the encoded image latents.
-        scheduler ([`SchedulerMixin`]):
-            A scheduler to be used in combination with `unet` to denoise the encoded image latents. Can be one of
-            [`DDIMScheduler`], [`LMSDiscreteScheduler`], [`PNDMScheduler`], [`EulerDiscreteScheduler`], [`EulerAncestralDiscreteScheduler`]
-            or [`DPMSolverMultistepScheduler`].
-        safety_checker ([`FastDeployRuntimeModel`]):
-            Classification module that estimates whether generated images could be considered offensive or harmful.
-            Please, refer to the [model card](https://huggingface.co/runwayml/stable-diffusion-v1-5) for details.
-        feature_extractor ([`CLIPFeatureExtractor`]):
-            Model that extracts features from generated images to be used as inputs for the `safety_checker`.
-    """
-    _optional_components = ["safety_checker", "feature_extractor"]
-
-    def __init__(
-        self,
-        vae_encoder: FastDeployRuntimeModel,
-        vae_decoder: FastDeployRuntimeModel,
-        text_encoder: FastDeployRuntimeModel,
-        tokenizer: CLIPTokenizer,
-        unet: FastDeployRuntimeModel,
-        scheduler: Union[
-            DDIMScheduler,
-            PNDMScheduler,
-            LMSDiscreteScheduler,
-            EulerDiscreteScheduler,
-            EulerAncestralDiscreteScheduler,
-            DPMSolverMultistepScheduler,
-        ],
-        safety_checker: FastDeployRuntimeModel,
-        feature_extractor: CLIPFeatureExtractor,
-        requires_safety_checker: bool = True,
-    ):
-        super().__init__()
-
-        if safety_checker is None and requires_safety_checker:
-            logger.warning(
-                f"You have disabled the safety checker for {self.__class__} by passing `safety_checker=None`. Ensure"
-                " that you abide to the conditions of the Stable Diffusion license and do not expose unfiltered"
-                " results in services or applications open to the public. PaddleNLP team, diffusers team and Hugging Face"
-                " strongly recommend to keep the safety filter enabled in all public facing circumstances, disabling"
-                " it only for use-cases that involve analyzing network behavior or auditing its results. For more"
-                " information, please have a look at https://github.com/huggingface/diffusers/pull/254 ."
-            )
-        if safety_checker is not None and feature_extractor is None:
-            raise ValueError(
-                "Make sure to define a feature extractor when loading {self.__class__} if you want to use the safety"
-                " checker. If you do not want to use the safety checker, you can pass `'safety_checker=None'` instead."
-            )
-
-        self.register_modules(
-            vae_encoder=vae_encoder,
-            vae_decoder=vae_decoder,
-            text_encoder=text_encoder,
-            tokenizer=tokenizer,
-            unet=unet,
-            scheduler=scheduler,
-            safety_checker=safety_checker,
-            feature_extractor=feature_extractor,
-        )
-
-        self.register_to_config(requires_safety_checker=requires_safety_checker)
-
-    def _encode_prompt(self, prompt, num_images_per_prompt, do_classifier_free_guidance, negative_prompt):
-        r"""
-        Encodes the prompt into text encoder hidden states.
-
-        Args:
-            prompt (`str` or `list(int)`):
-                prompt to be encoded
-            num_images_per_prompt (`int`):
-                number of images that should be generated per prompt
-            do_classifier_free_guidance (`bool`):
-                whether to use classifier free guidance or not
-            negative_prompt (`str` or `List[str]`):
-                The prompt or prompts not to guide the image generation. Ignored when not using guidance (i.e., ignored
-                if `guidance_scale` is less than `1`).
-        """
-        batch_size = len(prompt) if isinstance(prompt, list) else 1
-
-        # get prompt text embeddings
-        text_inputs = self.tokenizer(
-            prompt,
-            padding="max_length",
-            max_length=self.tokenizer.model_max_length,
-            truncation=True,
-            return_tensors="np",
-        )
-        text_input_ids = text_inputs.input_ids
-        untruncated_ids = self.tokenizer(prompt, padding="longest", return_tensors="np").input_ids
-
-        if not np.array_equal(text_input_ids, untruncated_ids):
-            removed_text = self.tokenizer.batch_decode(untruncated_ids[:, self.tokenizer.model_max_length - 1 : -1])
-            logger.warning(
-                "The following part of your input was truncated because CLIP can only handle sequences up to"
-                f" {self.tokenizer.model_max_length} tokens: {removed_text}"
-            )
-
-        text_embeddings = self.text_encoder(input_ids=text_input_ids.astype(np.int64))[0]
-        text_embeddings = np.repeat(text_embeddings, num_images_per_prompt, axis=0)
-
-        # get unconditional embeddings for classifier free guidance
-        if do_classifier_free_guidance:
-            uncond_tokens: List[str]
-            if negative_prompt is None:
-                uncond_tokens = [""] * batch_size
-            elif type(prompt) is not type(negative_prompt):
-                raise TypeError(
-                    f"`negative_prompt` should be the same type to `prompt`, but got {type(negative_prompt)} !="
-                    f" {type(prompt)}."
-                )
-            elif isinstance(negative_prompt, str):
-                uncond_tokens = [negative_prompt] * batch_size
-            elif batch_size != len(negative_prompt):
-                raise ValueError(
-                    f"`negative_prompt`: {negative_prompt} has batch size {len(negative_prompt)}, but `prompt`:"
-                    f" {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches"
-                    " the batch size of `prompt`."
-                )
-            else:
-                uncond_tokens = negative_prompt
-
-            max_length = text_input_ids.shape[-1]
-            uncond_input = self.tokenizer(
-                uncond_tokens,
-                padding="max_length",
-                max_length=max_length,
-                truncation=True,
-                return_tensors="np",
-            )
-            uncond_embeddings = self.text_encoder(input_ids=uncond_input.input_ids.astype(np.int64))[0]
-            uncond_embeddings = np.repeat(uncond_embeddings, num_images_per_prompt, axis=0)
-
-            # For classifier free guidance, we need to do two forward passes.
-            # Here we concatenate the unconditional and text embeddings into a single batch
-            # to avoid doing two forward passes
-            text_embeddings = np.concatenate([uncond_embeddings, text_embeddings])
-
-        return text_embeddings
-
-    def run_safety_checker(self, image, dtype):
-        if self.safety_checker is not None:
-            safety_checker_input = self.feature_extractor(
-                self.numpy_to_pil(image), return_tensors="np"
-            ).pixel_values.astype(dtype)
-            # There will throw an error if use safety_checker batchsize>1
-            images, has_nsfw_concept = [], []
-            for i in range(image.shape[0]):
-                image_i, has_nsfw_concept_i = self.safety_checker(
-                    clip_input=safety_checker_input[i : i + 1], images=image[i : i + 1]
-                )
-                images.append(image_i)
-                has_nsfw_concept.append(has_nsfw_concept_i[0])
-            image = np.concatenate(images)
-        else:
-            has_nsfw_concept = None
-        return image, has_nsfw_concept
-
-    def decode_latents(self, latents):
-        latents = 1 / 0.18215 * latents
-        image = np.concatenate(
-            [self.vae_decoder(latent_sample=latents[i : i + 1])[0] for i in range(latents.shape[0])]
-        )
-        image = np.clip(image / 2 + 0.5, 0, 1)
-        image = image.transpose([0, 2, 3, 1])
-        return image
-
-    def prepare_extra_step_kwargs(self, eta):
-        # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
-        # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
-        # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
-        # and should be between [0, 1]
-
-        accepts_eta = "eta" in set(inspect.signature(self.scheduler.step).parameters.keys())
-        extra_step_kwargs = {}
-        if accepts_eta:
-            extra_step_kwargs["eta"] = eta
-
-        return extra_step_kwargs
-
-    def check_inputs(self, prompt, strength, callback_steps):
-        if not isinstance(prompt, str) and not isinstance(prompt, list):
-            raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}")
-
-        if strength < 0 or strength > 1:
-            raise ValueError(f"The value of strength should in [1.0, 1.0] but is {strength}")
-
-        if (callback_steps is None) or (
-            callback_steps is not None and (not isinstance(callback_steps, int) or callback_steps <= 0)
-        ):
-            raise ValueError(
-                f"`callback_steps` has to be a positive integer but is {callback_steps} of type"
-                f" {type(callback_steps)}."
-            )
-
-    def get_timesteps(self, num_inference_steps, strength):
-        # get the original timestep using init_timestep
-        offset = self.scheduler.config.get("steps_offset", 0)
-        init_timestep = int(num_inference_steps * strength) + offset
-        init_timestep = min(init_timestep, num_inference_steps)
-
-        t_start = max(num_inference_steps - init_timestep + offset, 0)
-        timesteps = self.scheduler.timesteps[t_start:]
-
-        return timesteps, num_inference_steps - t_start
-
-    def prepare_latents(self, image, timestep, batch_size, num_images_per_prompt, dtype, generator=None, noise=None):
-        if generator is None:
-            generator = np.random
-
-        image = image.astype(dtype)
-        init_latents = self.vae_encoder(sample=image)[0]
-        init_latents = 0.18215 * init_latents
-        init_latents = paddle.to_tensor(init_latents)
-
-        # Expand init_latents for batch_size and num_images_per_prompt
-        init_latents = paddle.concat([init_latents] * batch_size * num_images_per_prompt, axis=0)
-        init_latents_orig = paddle.to_tensor(init_latents)
-
-        # add noise to latents using the timesteps
-        if noise is None:
-            noise = paddle.to_tensor(generator.randn(*init_latents.shape).astype(dtype))
-        elif list(noise.shape) != list(init_latents.shape):
-            raise ValueError(f"Unexpected noise shape, got {noise.shape}, expected {init_latents.shape}")
-        elif isinstance(noise, np.ndarray):
-            noise = paddle.to_tensor(noise, dtype=dtype)
-
-        init_latents = self.scheduler.add_noise(init_latents, noise, timestep)
-        latents = init_latents
-        return latents, init_latents_orig, noise
-
-    def __call__(
-        self,
-        prompt: Union[str, List[str]],
-        image: Union[np.ndarray, PIL.Image.Image] = None,
-        mask_image: Union[np.ndarray, PIL.Image.Image] = None,
-        strength: float = 0.8,
-        num_inference_steps: Optional[int] = 50,
-        guidance_scale: Optional[float] = 7.5,
-        negative_prompt: Optional[Union[str, List[str]]] = None,
-        num_images_per_prompt: Optional[int] = 1,
-        eta: Optional[float] = 0.0,
-        generator: Optional[np.random.RandomState] = None,
-        noise: Optional[np.ndarray] = None,
-        output_type: Optional[str] = "pil",
-        return_dict: bool = True,
-        callback: Optional[Callable[[int, int, np.ndarray], None]] = None,
-        callback_steps: Optional[int] = 1,
-    ):
-        r"""
-        Function invoked when calling the pipeline for generation.
-
-        Args:
-            prompt (`str` or `List[str]`):
-                The prompt or prompts to guide the image generation.
-            image (`nd.ndarray` or `PIL.Image.Image`):
-                `Image`, or tensor representing an image batch, that will be used as the starting point for the
-                process. This is the image whose masked region will be inpainted.
-            mask_image (`nd.ndarray` or `PIL.Image.Image`):
-                `Image`, or tensor representing an image batch, to mask `image`. White pixels in the mask will be
-                replaced by noise and therefore repainted, while black pixels will be preserved. If `mask_image` is a
-                PIL image, it will be converted to a single channel (luminance) before use. If it's a tensor, it should
-                contain one color channel (L) instead of 3, so the expected shape would be `(B, H, W, 1)`.uu
-            strength (`float`, *optional*, defaults to 0.8):
-                Conceptually, indicates how much to transform the reference `image`. Must be between 0 and 1.
-                `image` will be used as a starting point, adding more noise to it the larger the `strength`. The
-                number of denoising steps depends on the amount of noise initially added. When `strength` is 1, added
-                noise will be maximum and the denoising process will run for the full number of iterations specified in
-                `num_inference_steps`. A value of 1, therefore, essentially ignores `image`.
-            num_inference_steps (`int`, *optional*, defaults to 50):
-                The number of denoising steps. More denoising steps usually lead to a higher quality image at the
-                expense of slower inference. This parameter will be modulated by `strength`.
-            guidance_scale (`float`, *optional*, defaults to 7.5):
-                Guidance scale as defined in [Classifier-Free Diffusion Guidance](https://arxiv.org/abs/2207.12598).
-                `guidance_scale` is defined as `w` of equation 2. of [Imagen
-                Paper](https://arxiv.org/pdf/2205.11487.pdf). Guidance scale is enabled by setting `guidance_scale >
-                1`. Higher guidance scale encourages to generate images that are closely linked to the text `prompt`,
-                usually at the expense of lower image quality.
-            negative_prompt (`str` or `List[str]`, *optional*):
-                The prompt or prompts not to guide the image generation. Ignored when not using guidance (i.e., ignored
-                if `guidance_scale` is less than `1`).
-            num_images_per_prompt (`int`, *optional*, defaults to 1):
-                The number of images to generate per prompt.
-            eta (`float`, *optional*, defaults to 0.0):
-                Corresponds to parameter eta (?) in the DDIM paper: https://arxiv.org/abs/2010.02502. Only applies to
-                [`schedulers.DDIMScheduler`], will be ignored for others.
-            generator (`np.random.RandomState`, *optional*):
-                A np.random.RandomState to make generation deterministic.
-            noise (`np.ndarray`, *optional*):
-                Pre-generated noise tensor, sampled from a Gaussian distribution, to be used as inputs for image
-                generation. If not provided, a noise tensor will ge generated by sampling using the supplied random
-                `generator`.
-            output_type (`str`, *optional*, defaults to `"pil"`):
-                The output format of the generate image. Choose between
-                [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` or `np.array`.
-            return_dict (`bool`, *optional*, defaults to `True`):
-                Whether or not to return a [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] instead of a
-                plain tuple.
-            callback (`Callable`, *optional*):
-                A function that will be called every `callback_steps` steps during inference. The function will be
-                called with the following arguments: `callback(step: int, timestep: int, latents: np.ndarray)`.
-            callback_steps (`int`, *optional*, defaults to 1):
-                The frequency at which the `callback` function will be called. If not specified, the callback will be
-                called at every step.
-
-        Returns:
-            [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] or `tuple`:
-            [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] if `return_dict` is True, otherwise a `tuple.
-            When returning a tuple, the first element is a list with the generated images, and the second element is a
-            list of `bool`s denoting whether the corresponding generated image likely represents "not-safe-for-work"
-            (nsfw) content, according to the `safety_checker`.
-        """
-        # 1. Check inputs
-        self.check_inputs(prompt, strength, callback_steps)
-
-        # 2. Define call parameters
-        batch_size = 1 if isinstance(prompt, str) else len(prompt)
-        # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
-        # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
-        # corresponds to doing no classifier free guidance.
-        do_classifier_free_guidance = guidance_scale > 1.0
-
-        # 3. Encode input prompt
-        text_embeddings = self._encode_prompt(
-            prompt, num_images_per_prompt, do_classifier_free_guidance, negative_prompt
-        )
-
-        # 4. Preprocess image and mask
-        if isinstance(image, PIL.Image.Image):
-            image = preprocess_image(image)
-
-        if isinstance(mask_image, PIL.Image.Image):
-            mask_image = preprocess_mask(mask_image)
-
-        # 5. set timesteps
-        self.scheduler.set_timesteps(num_inference_steps)
-        timesteps, num_inference_steps = self.get_timesteps(num_inference_steps, strength)
-        latent_timestep = timesteps[:1].tile([batch_size * num_images_per_prompt])
-
-        # 6. Prepare latent variables
-        # encode the init image into latents and scale the latents
-        latents, init_latents_orig, noise = self.prepare_latents(
-            image, latent_timestep, batch_size, num_images_per_prompt, text_embeddings.dtype, generator, noise
-        )
-
-        # 7. Prepare mask latent
-        mask = paddle.to_tensor(mask_image, dtype=latents.dtype)
-        mask = paddle.concat([mask] * batch_size * num_images_per_prompt)
-
-        # 8. Prepare extra step kwargs.
-        extra_step_kwargs = self.prepare_extra_step_kwargs(eta)
-
-        # 9. Denoising loop
-        num_warmup_steps = len(timesteps) - num_inference_steps * self.scheduler.order
-        with self.progress_bar(total=num_inference_steps) as progress_bar:
-            text_embeddings = paddle.to_tensor(text_embeddings, dtype="float32")
-            for i, t in enumerate(timesteps):
-                # expand the latents if we are doing classifier free guidance
-                latent_model_input = paddle.concat([latents] * 2) if do_classifier_free_guidance else latents
-                latent_model_input = self.scheduler.scale_model_input(latent_model_input, t)
-                latent_model_input = latent_model_input
-
-                # predict the noise residual
-                noise_pred = self.unet.zero_copy_infer(
-                    sample=latent_model_input, timestep=t, encoder_hidden_states=text_embeddings
-                )[0]
-                # perform guidance
-                if do_classifier_free_guidance:
-                    noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
-                    noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
-
-                # compute the previous noisy sample x_t -> x_t-1
-                scheduler_output = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs)
-                latents = scheduler_output.prev_sample
-                init_latents_proper = self.scheduler.add_noise(init_latents_orig, noise, t)
-
-                latents = (init_latents_proper * mask) + (latents * (1 - mask))
-
-                # call the callback, if provided
-                if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0):
-                    progress_bar.update()
-                    if callback is not None and i % callback_steps == 0:
-                        callback(i, t, latents)
-
-        # 10. Post-processing
-        image = self.decode_latents(latents.numpy())
-
-        # 11. Run safety checker
-        image, has_nsfw_concept = self.run_safety_checker(image, text_embeddings.dtype)
-
-        # 12. Convert to PIL
-        if output_type == "pil":
-            image = self.numpy_to_pil(image)
-
-        if not return_dict:
-            return (image, has_nsfw_concept)
-
-        return StableDiffusionPipelineOutput(images=image, nsfw_content_detected=has_nsfw_concept)

spaces/AIFILMS/audioldm-text-to-audio-generation/audioldm/variational_autoencoder/modules.py

@@ -1,1064 +0,0 @@
-# pytorch_diffusion + derived encoder decoder
-import math
-import torch
-import torch.nn as nn
-import numpy as np
-from einops import rearrange
-
-from audioldm.utils import instantiate_from_config
-from audioldm.latent_diffusion.attention import LinearAttention
-
-def get_timestep_embedding(timesteps, embedding_dim):
-    """
-    This matches the implementation in Denoising Diffusion Probabilistic Models:
-    From Fairseq.
-    Build sinusoidal embeddings.
-    This matches the implementation in tensor2tensor, but differs slightly
-    from the description in Section 3.5 of "Attention Is All You Need".
-    """
-    assert len(timesteps.shape) == 1
-
-    half_dim = embedding_dim // 2
-    emb = math.log(10000) / (half_dim - 1)
-    emb = torch.exp(torch.arange(half_dim, dtype=torch.float32) * -emb)
-    emb = emb.to(device=timesteps.device)
-    emb = timesteps.float()[:, None] * emb[None, :]
-    emb = torch.cat([torch.sin(emb), torch.cos(emb)], dim=1)
-    if embedding_dim % 2 == 1:  # zero pad
-        emb = torch.nn.functional.pad(emb, (0, 1, 0, 0))
-    return emb
-
-def nonlinearity(x):
-    # swish
-    return x * torch.sigmoid(x)
-
-
-def Normalize(in_channels, num_groups=32):
-    return torch.nn.GroupNorm(
-        num_groups=num_groups, num_channels=in_channels, eps=1e-6, affine=True
-    )
-
-
-class Upsample(nn.Module):
-    def __init__(self, in_channels, with_conv):
-        super().__init__()
-        self.with_conv = with_conv
-        if self.with_conv:
-            self.conv = torch.nn.Conv2d(
-                in_channels, in_channels, kernel_size=3, stride=1, padding=1
-            )
-
-    def forward(self, x):
-        x = torch.nn.functional.interpolate(x, scale_factor=2.0, mode="nearest")
-        if self.with_conv:
-            x = self.conv(x)
-        return x
-
-
-class UpsampleTimeStride4(nn.Module):
-    def __init__(self, in_channels, with_conv):
-        super().__init__()
-        self.with_conv = with_conv
-        if self.with_conv:
-            self.conv = torch.nn.Conv2d(
-                in_channels, in_channels, kernel_size=5, stride=1, padding=2
-            )
-
-    def forward(self, x):
-        x = torch.nn.functional.interpolate(x, scale_factor=(4.0, 2.0), mode="nearest")
-        if self.with_conv:
-            x = self.conv(x)
-        return x
-
-
-class Downsample(nn.Module):
-    def __init__(self, in_channels, with_conv):
-        super().__init__()
-        self.with_conv = with_conv
-        if self.with_conv:
-            # Do time downsampling here
-            # no asymmetric padding in torch conv, must do it ourselves
-            self.conv = torch.nn.Conv2d(
-                in_channels, in_channels, kernel_size=3, stride=2, padding=0
-            )
-
-    def forward(self, x):
-        if self.with_conv:
-            pad = (0, 1, 0, 1)
-            x = torch.nn.functional.pad(x, pad, mode="constant", value=0)
-            x = self.conv(x)
-        else:
-            x = torch.nn.functional.avg_pool2d(x, kernel_size=2, stride=2)
-        return x
-
-
-class DownsampleTimeStride4(nn.Module):
-    def __init__(self, in_channels, with_conv):
-        super().__init__()
-        self.with_conv = with_conv
-        if self.with_conv:
-            # Do time downsampling here
-            # no asymmetric padding in torch conv, must do it ourselves
-            self.conv = torch.nn.Conv2d(
-                in_channels, in_channels, kernel_size=5, stride=(4, 2), padding=1
-            )
-
-    def forward(self, x):
-        if self.with_conv:
-            pad = (0, 1, 0, 1)
-            x = torch.nn.functional.pad(x, pad, mode="constant", value=0)
-            x = self.conv(x)
-        else:
-            x = torch.nn.functional.avg_pool2d(x, kernel_size=(4, 2), stride=(4, 2))
-        return x
-
-
-class ResnetBlock(nn.Module):
-    def __init__(
-        self,
-        *,
-        in_channels,
-        out_channels=None,
-        conv_shortcut=False,
-        dropout,
-        temb_channels=512,
-    ):
-        super().__init__()
-        self.in_channels = in_channels
-        out_channels = in_channels if out_channels is None else out_channels
-        self.out_channels = out_channels
-        self.use_conv_shortcut = conv_shortcut
-
-        self.norm1 = Normalize(in_channels)
-        self.conv1 = torch.nn.Conv2d(
-            in_channels, out_channels, kernel_size=3, stride=1, padding=1
-        )
-        if temb_channels > 0:
-            self.temb_proj = torch.nn.Linear(temb_channels, out_channels)
-        self.norm2 = Normalize(out_channels)
-        self.dropout = torch.nn.Dropout(dropout)
-        self.conv2 = torch.nn.Conv2d(
-            out_channels, out_channels, kernel_size=3, stride=1, padding=1
-        )
-        if self.in_channels != self.out_channels:
-            if self.use_conv_shortcut:
-                self.conv_shortcut = torch.nn.Conv2d(
-                    in_channels, out_channels, kernel_size=3, stride=1, padding=1
-                )
-            else:
-                self.nin_shortcut = torch.nn.Conv2d(
-                    in_channels, out_channels, kernel_size=1, stride=1, padding=0
-                )
-
-    def forward(self, x, temb):
-        h = x
-        h = self.norm1(h)
-        h = nonlinearity(h)
-        h = self.conv1(h)
-
-        if temb is not None:
-            h = h + self.temb_proj(nonlinearity(temb))[:, :, None, None]
-
-        h = self.norm2(h)
-        h = nonlinearity(h)
-        h = self.dropout(h)
-        h = self.conv2(h)
-
-        if self.in_channels != self.out_channels:
-            if self.use_conv_shortcut:
-                x = self.conv_shortcut(x)
-            else:
-                x = self.nin_shortcut(x)
-
-        return x + h
-
-
-class LinAttnBlock(LinearAttention):
-    """to match AttnBlock usage"""
-
-    def __init__(self, in_channels):
-        super().__init__(dim=in_channels, heads=1, dim_head=in_channels)
-
-
-class AttnBlock(nn.Module):
-    def __init__(self, in_channels):
-        super().__init__()
-        self.in_channels = in_channels
-
-        self.norm = Normalize(in_channels)
-        self.q = torch.nn.Conv2d(
-            in_channels, in_channels, kernel_size=1, stride=1, padding=0
-        )
-        self.k = torch.nn.Conv2d(
-            in_channels, in_channels, kernel_size=1, stride=1, padding=0
-        )
-        self.v = torch.nn.Conv2d(
-            in_channels, in_channels, kernel_size=1, stride=1, padding=0
-        )
-        self.proj_out = torch.nn.Conv2d(
-            in_channels, in_channels, kernel_size=1, stride=1, padding=0
-        )
-
-    def forward(self, x):
-        h_ = x
-        h_ = self.norm(h_)
-        q = self.q(h_)
-        k = self.k(h_)
-        v = self.v(h_)
-
-        # compute attention
-        b, c, h, w = q.shape
-        q = q.reshape(b, c, h * w).contiguous()
-        q = q.permute(0, 2, 1).contiguous()  # b,hw,c
-        k = k.reshape(b, c, h * w).contiguous()  # b,c,hw
-        w_ = torch.bmm(q, k).contiguous()  # b,hw,hw    w[b,i,j]=sum_c q[b,i,c]k[b,c,j]
-        w_ = w_ * (int(c) ** (-0.5))
-        w_ = torch.nn.functional.softmax(w_, dim=2)
-
-        # attend to values
-        v = v.reshape(b, c, h * w).contiguous()
-        w_ = w_.permute(0, 2, 1).contiguous()  # b,hw,hw (first hw of k, second of q)
-        h_ = torch.bmm(
-            v, w_
-        ).contiguous()  # b, c,hw (hw of q) h_[b,c,j] = sum_i v[b,c,i] w_[b,i,j]
-        h_ = h_.reshape(b, c, h, w).contiguous()
-
-        h_ = self.proj_out(h_)
-
-        return x + h_
-
-
-def make_attn(in_channels, attn_type="vanilla"):
-    assert attn_type in ["vanilla", "linear", "none"], f"attn_type {attn_type} unknown"
-    # print(f"making attention of type '{attn_type}' with {in_channels} in_channels")
-    if attn_type == "vanilla":
-        return AttnBlock(in_channels)
-    elif attn_type == "none":
-        return nn.Identity(in_channels)
-    else:
-        return LinAttnBlock(in_channels)
-
-
-class Model(nn.Module):
-    def __init__(
-        self,
-        *,
-        ch,
-        out_ch,
-        ch_mult=(1, 2, 4, 8),
-        num_res_blocks,
-        attn_resolutions,
-        dropout=0.0,
-        resamp_with_conv=True,
-        in_channels,
-        resolution,
-        use_timestep=True,
-        use_linear_attn=False,
-        attn_type="vanilla",
-    ):
-        super().__init__()
-        if use_linear_attn:
-            attn_type = "linear"
-        self.ch = ch
-        self.temb_ch = self.ch * 4
-        self.num_resolutions = len(ch_mult)
-        self.num_res_blocks = num_res_blocks
-        self.resolution = resolution
-        self.in_channels = in_channels
-
-        self.use_timestep = use_timestep
-        if self.use_timestep:
-            # timestep embedding
-            self.temb = nn.Module()
-            self.temb.dense = nn.ModuleList(
-                [
-                    torch.nn.Linear(self.ch, self.temb_ch),
-                    torch.nn.Linear(self.temb_ch, self.temb_ch),
-                ]
-            )
-
-        # downsampling
-        self.conv_in = torch.nn.Conv2d(
-            in_channels, self.ch, kernel_size=3, stride=1, padding=1
-        )
-
-        curr_res = resolution
-        in_ch_mult = (1,) + tuple(ch_mult)
-        self.down = nn.ModuleList()
-        for i_level in range(self.num_resolutions):
-            block = nn.ModuleList()
-            attn = nn.ModuleList()
-            block_in = ch * in_ch_mult[i_level]
-            block_out = ch * ch_mult[i_level]
-            for i_block in range(self.num_res_blocks):
-                block.append(
-                    ResnetBlock(
-                        in_channels=block_in,
-                        out_channels=block_out,
-                        temb_channels=self.temb_ch,
-                        dropout=dropout,
-                    )
-                )
-                block_in = block_out
-                if curr_res in attn_resolutions:
-                    attn.append(make_attn(block_in, attn_type=attn_type))
-            down = nn.Module()
-            down.block = block
-            down.attn = attn
-            if i_level != self.num_resolutions - 1:
-                down.downsample = Downsample(block_in, resamp_with_conv)
-                curr_res = curr_res // 2
-            self.down.append(down)
-
-        # middle
-        self.mid = nn.Module()
-        self.mid.block_1 = ResnetBlock(
-            in_channels=block_in,
-            out_channels=block_in,
-            temb_channels=self.temb_ch,
-            dropout=dropout,
-        )
-        self.mid.attn_1 = make_attn(block_in, attn_type=attn_type)
-        self.mid.block_2 = ResnetBlock(
-            in_channels=block_in,
-            out_channels=block_in,
-            temb_channels=self.temb_ch,
-            dropout=dropout,
-        )
-
-        # upsampling
-        self.up = nn.ModuleList()
-        for i_level in reversed(range(self.num_resolutions)):
-            block = nn.ModuleList()
-            attn = nn.ModuleList()
-            block_out = ch * ch_mult[i_level]
-            skip_in = ch * ch_mult[i_level]
-            for i_block in range(self.num_res_blocks + 1):
-                if i_block == self.num_res_blocks:
-                    skip_in = ch * in_ch_mult[i_level]
-                block.append(
-                    ResnetBlock(
-                        in_channels=block_in + skip_in,
-                        out_channels=block_out,
-                        temb_channels=self.temb_ch,
-                        dropout=dropout,
-                    )
-                )
-                block_in = block_out
-                if curr_res in attn_resolutions:
-                    attn.append(make_attn(block_in, attn_type=attn_type))
-            up = nn.Module()
-            up.block = block
-            up.attn = attn
-            if i_level != 0:
-                up.upsample = Upsample(block_in, resamp_with_conv)
-                curr_res = curr_res * 2
-            self.up.insert(0, up)  # prepend to get consistent order
-
-        # end
-        self.norm_out = Normalize(block_in)
-        self.conv_out = torch.nn.Conv2d(
-            block_in, out_ch, kernel_size=3, stride=1, padding=1
-        )
-
-    def forward(self, x, t=None, context=None):
-        # assert x.shape[2] == x.shape[3] == self.resolution
-        if context is not None:
-            # assume aligned context, cat along channel axis
-            x = torch.cat((x, context), dim=1)
-        if self.use_timestep:
-            # timestep embedding
-            assert t is not None
-            temb = get_timestep_embedding(t, self.ch)
-            temb = self.temb.dense[0](temb)
-            temb = nonlinearity(temb)
-            temb = self.temb.dense[1](temb)
-        else:
-            temb = None
-
-        # downsampling
-        hs = [self.conv_in(x)]
-        for i_level in range(self.num_resolutions):
-            for i_block in range(self.num_res_blocks):
-                h = self.down[i_level].block[i_block](hs[-1], temb)
-                if len(self.down[i_level].attn) > 0:
-                    h = self.down[i_level].attn[i_block](h)
-                hs.append(h)
-            if i_level != self.num_resolutions - 1:
-                hs.append(self.down[i_level].downsample(hs[-1]))
-
-        # middle
-        h = hs[-1]
-        h = self.mid.block_1(h, temb)
-        h = self.mid.attn_1(h)
-        h = self.mid.block_2(h, temb)
-
-        # upsampling
-        for i_level in reversed(range(self.num_resolutions)):
-            for i_block in range(self.num_res_blocks + 1):
-                h = self.up[i_level].block[i_block](
-                    torch.cat([h, hs.pop()], dim=1), temb
-                )
-                if len(self.up[i_level].attn) > 0:
-                    h = self.up[i_level].attn[i_block](h)
-            if i_level != 0:
-                h = self.up[i_level].upsample(h)
-
-        # end
-        h = self.norm_out(h)
-        h = nonlinearity(h)
-        h = self.conv_out(h)
-        return h
-
-    def get_last_layer(self):
-        return self.conv_out.weight
-
-
-class Encoder(nn.Module):
-    def __init__(
-        self,
-        *,
-        ch,
-        out_ch,
-        ch_mult=(1, 2, 4, 8),
-        num_res_blocks,
-        attn_resolutions,
-        dropout=0.0,
-        resamp_with_conv=True,
-        in_channels,
-        resolution,
-        z_channels,
-        double_z=True,
-        use_linear_attn=False,
-        attn_type="vanilla",
-        downsample_time_stride4_levels=[],
-        **ignore_kwargs,
-    ):
-        super().__init__()
-        if use_linear_attn:
-            attn_type = "linear"
-        self.ch = ch
-        self.temb_ch = 0
-        self.num_resolutions = len(ch_mult)
-        self.num_res_blocks = num_res_blocks
-        self.resolution = resolution
-        self.in_channels = in_channels
-        self.downsample_time_stride4_levels = downsample_time_stride4_levels
-
-        if len(self.downsample_time_stride4_levels) > 0:
-            assert max(self.downsample_time_stride4_levels) < self.num_resolutions, (
-                "The level to perform downsample 4 operation need to be smaller than the total resolution number %s"
-                % str(self.num_resolutions)
-            )
-
-        # downsampling
-        self.conv_in = torch.nn.Conv2d(
-            in_channels, self.ch, kernel_size=3, stride=1, padding=1
-        )
-
-        curr_res = resolution
-        in_ch_mult = (1,) + tuple(ch_mult)
-        self.in_ch_mult = in_ch_mult
-        self.down = nn.ModuleList()
-        for i_level in range(self.num_resolutions):
-            block = nn.ModuleList()
-            attn = nn.ModuleList()
-            block_in = ch * in_ch_mult[i_level]
-            block_out = ch * ch_mult[i_level]
-            for i_block in range(self.num_res_blocks):
-                block.append(
-                    ResnetBlock(
-                        in_channels=block_in,
-                        out_channels=block_out,
-                        temb_channels=self.temb_ch,
-                        dropout=dropout,
-                    )
-                )
-                block_in = block_out
-                if curr_res in attn_resolutions:
-                    attn.append(make_attn(block_in, attn_type=attn_type))
-            down = nn.Module()
-            down.block = block
-            down.attn = attn
-            if i_level != self.num_resolutions - 1:
-                if i_level in self.downsample_time_stride4_levels:
-                    down.downsample = DownsampleTimeStride4(block_in, resamp_with_conv)
-                else:
-                    down.downsample = Downsample(block_in, resamp_with_conv)
-                curr_res = curr_res // 2
-            self.down.append(down)
-
-        # middle
-        self.mid = nn.Module()
-        self.mid.block_1 = ResnetBlock(
-            in_channels=block_in,
-            out_channels=block_in,
-            temb_channels=self.temb_ch,
-            dropout=dropout,
-        )
-        self.mid.attn_1 = make_attn(block_in, attn_type=attn_type)
-        self.mid.block_2 = ResnetBlock(
-            in_channels=block_in,
-            out_channels=block_in,
-            temb_channels=self.temb_ch,
-            dropout=dropout,
-        )
-
-        # end
-        self.norm_out = Normalize(block_in)
-        self.conv_out = torch.nn.Conv2d(
-            block_in,
-            2 * z_channels if double_z else z_channels,
-            kernel_size=3,
-            stride=1,
-            padding=1,
-        )
-
-    def forward(self, x):
-        # timestep embedding
-        temb = None
-        # downsampling
-        hs = [self.conv_in(x)]
-        for i_level in range(self.num_resolutions):
-            for i_block in range(self.num_res_blocks):
-                h = self.down[i_level].block[i_block](hs[-1], temb)
-                if len(self.down[i_level].attn) > 0:
-                    h = self.down[i_level].attn[i_block](h)
-                hs.append(h)
-            if i_level != self.num_resolutions - 1:
-                hs.append(self.down[i_level].downsample(hs[-1]))
-
-        # middle
-        h = hs[-1]
-        h = self.mid.block_1(h, temb)
-        h = self.mid.attn_1(h)
-        h = self.mid.block_2(h, temb)
-
-        # end
-        h = self.norm_out(h)
-        h = nonlinearity(h)
-        h = self.conv_out(h)
-        return h
-
-
-class Decoder(nn.Module):
-    def __init__(
-        self,
-        *,
-        ch,
-        out_ch,
-        ch_mult=(1, 2, 4, 8),
-        num_res_blocks,
-        attn_resolutions,
-        dropout=0.0,
-        resamp_with_conv=True,
-        in_channels,
-        resolution,
-        z_channels,
-        give_pre_end=False,
-        tanh_out=False,
-        use_linear_attn=False,
-        downsample_time_stride4_levels=[],
-        attn_type="vanilla",
-        **ignorekwargs,
-    ):
-        super().__init__()
-        if use_linear_attn:
-            attn_type = "linear"
-        self.ch = ch
-        self.temb_ch = 0
-        self.num_resolutions = len(ch_mult)
-        self.num_res_blocks = num_res_blocks
-        self.resolution = resolution
-        self.in_channels = in_channels
-        self.give_pre_end = give_pre_end
-        self.tanh_out = tanh_out
-        self.downsample_time_stride4_levels = downsample_time_stride4_levels
-
-        if len(self.downsample_time_stride4_levels) > 0:
-            assert max(self.downsample_time_stride4_levels) < self.num_resolutions, (
-                "The level to perform downsample 4 operation need to be smaller than the total resolution number %s"
-                % str(self.num_resolutions)
-            )
-
-        # compute in_ch_mult, block_in and curr_res at lowest res
-        in_ch_mult = (1,) + tuple(ch_mult)
-        block_in = ch * ch_mult[self.num_resolutions - 1]
-        curr_res = resolution // 2 ** (self.num_resolutions - 1)
-        self.z_shape = (1, z_channels, curr_res, curr_res)
-        # print("Working with z of shape {} = {} dimensions.".format(
-        # self.z_shape, np.prod(self.z_shape)))
-
-        # z to block_in
-        self.conv_in = torch.nn.Conv2d(
-            z_channels, block_in, kernel_size=3, stride=1, padding=1
-        )
-
-        # middle
-        self.mid = nn.Module()
-        self.mid.block_1 = ResnetBlock(
-            in_channels=block_in,
-            out_channels=block_in,
-            temb_channels=self.temb_ch,
-            dropout=dropout,
-        )
-        self.mid.attn_1 = make_attn(block_in, attn_type=attn_type)
-        self.mid.block_2 = ResnetBlock(
-            in_channels=block_in,
-            out_channels=block_in,
-            temb_channels=self.temb_ch,
-            dropout=dropout,
-        )
-
-        # upsampling
-        self.up = nn.ModuleList()
-        for i_level in reversed(range(self.num_resolutions)):
-            block = nn.ModuleList()
-            attn = nn.ModuleList()
-            block_out = ch * ch_mult[i_level]
-            for i_block in range(self.num_res_blocks + 1):
-                block.append(
-                    ResnetBlock(
-                        in_channels=block_in,
-                        out_channels=block_out,
-                        temb_channels=self.temb_ch,
-                        dropout=dropout,
-                    )
-                )
-                block_in = block_out
-                if curr_res in attn_resolutions:
-                    attn.append(make_attn(block_in, attn_type=attn_type))
-            up = nn.Module()
-            up.block = block
-            up.attn = attn
-            if i_level != 0:
-                if i_level - 1 in self.downsample_time_stride4_levels:
-                    up.upsample = UpsampleTimeStride4(block_in, resamp_with_conv)
-                else:
-                    up.upsample = Upsample(block_in, resamp_with_conv)
-                curr_res = curr_res * 2
-            self.up.insert(0, up)  # prepend to get consistent order
-
-        # end
-        self.norm_out = Normalize(block_in)
-        self.conv_out = torch.nn.Conv2d(
-            block_in, out_ch, kernel_size=3, stride=1, padding=1
-        )
-
-    def forward(self, z):
-        # assert z.shape[1:] == self.z_shape[1:]
-        self.last_z_shape = z.shape
-
-        # timestep embedding
-        temb = None
-
-        # z to block_in
-        h = self.conv_in(z)
-
-        # middle
-        h = self.mid.block_1(h, temb)
-        h = self.mid.attn_1(h)
-        h = self.mid.block_2(h, temb)
-
-        # upsampling
-        for i_level in reversed(range(self.num_resolutions)):
-            for i_block in range(self.num_res_blocks + 1):
-                h = self.up[i_level].block[i_block](h, temb)
-                if len(self.up[i_level].attn) > 0:
-                    h = self.up[i_level].attn[i_block](h)
-            if i_level != 0:
-                h = self.up[i_level].upsample(h)
-
-        # end
-        if self.give_pre_end:
-            return h
-
-        h = self.norm_out(h)
-        h = nonlinearity(h)
-        h = self.conv_out(h)
-        if self.tanh_out:
-            h = torch.tanh(h)
-        return h
-
-
-class SimpleDecoder(nn.Module):
-    def __init__(self, in_channels, out_channels, *args, **kwargs):
-        super().__init__()
-        self.model = nn.ModuleList(
-            [
-                nn.Conv2d(in_channels, in_channels, 1),
-                ResnetBlock(
-                    in_channels=in_channels,
-                    out_channels=2 * in_channels,
-                    temb_channels=0,
-                    dropout=0.0,
-                ),
-                ResnetBlock(
-                    in_channels=2 * in_channels,
-                    out_channels=4 * in_channels,
-                    temb_channels=0,
-                    dropout=0.0,
-                ),
-                ResnetBlock(
-                    in_channels=4 * in_channels,
-                    out_channels=2 * in_channels,
-                    temb_channels=0,
-                    dropout=0.0,
-                ),
-                nn.Conv2d(2 * in_channels, in_channels, 1),
-                Upsample(in_channels, with_conv=True),
-            ]
-        )
-        # end
-        self.norm_out = Normalize(in_channels)
-        self.conv_out = torch.nn.Conv2d(
-            in_channels, out_channels, kernel_size=3, stride=1, padding=1
-        )
-
-    def forward(self, x):
-        for i, layer in enumerate(self.model):
-            if i in [1, 2, 3]:
-                x = layer(x, None)
-            else:
-                x = layer(x)
-
-        h = self.norm_out(x)
-        h = nonlinearity(h)
-        x = self.conv_out(h)
-        return x
-
-
-class UpsampleDecoder(nn.Module):
-    def __init__(
-        self,
-        in_channels,
-        out_channels,
-        ch,
-        num_res_blocks,
-        resolution,
-        ch_mult=(2, 2),
-        dropout=0.0,
-    ):
-        super().__init__()
-        # upsampling
-        self.temb_ch = 0
-        self.num_resolutions = len(ch_mult)
-        self.num_res_blocks = num_res_blocks
-        block_in = in_channels
-        curr_res = resolution // 2 ** (self.num_resolutions - 1)
-        self.res_blocks = nn.ModuleList()
-        self.upsample_blocks = nn.ModuleList()
-        for i_level in range(self.num_resolutions):
-            res_block = []
-            block_out = ch * ch_mult[i_level]
-            for i_block in range(self.num_res_blocks + 1):
-                res_block.append(
-                    ResnetBlock(
-                        in_channels=block_in,
-                        out_channels=block_out,
-                        temb_channels=self.temb_ch,
-                        dropout=dropout,
-                    )
-                )
-                block_in = block_out
-            self.res_blocks.append(nn.ModuleList(res_block))
-            if i_level != self.num_resolutions - 1:
-                self.upsample_blocks.append(Upsample(block_in, True))
-                curr_res = curr_res * 2
-
-        # end
-        self.norm_out = Normalize(block_in)
-        self.conv_out = torch.nn.Conv2d(
-            block_in, out_channels, kernel_size=3, stride=1, padding=1
-        )
-
-    def forward(self, x):
-        # upsampling
-        h = x
-        for k, i_level in enumerate(range(self.num_resolutions)):
-            for i_block in range(self.num_res_blocks + 1):
-                h = self.res_blocks[i_level][i_block](h, None)
-            if i_level != self.num_resolutions - 1:
-                h = self.upsample_blocks[k](h)
-        h = self.norm_out(h)
-        h = nonlinearity(h)
-        h = self.conv_out(h)
-        return h
-
-
-class LatentRescaler(nn.Module):
-    def __init__(self, factor, in_channels, mid_channels, out_channels, depth=2):
-        super().__init__()
-        # residual block, interpolate, residual block
-        self.factor = factor
-        self.conv_in = nn.Conv2d(
-            in_channels, mid_channels, kernel_size=3, stride=1, padding=1
-        )
-        self.res_block1 = nn.ModuleList(
-            [
-                ResnetBlock(
-                    in_channels=mid_channels,
-                    out_channels=mid_channels,
-                    temb_channels=0,
-                    dropout=0.0,
-                )
-                for _ in range(depth)
-            ]
-        )
-        self.attn = AttnBlock(mid_channels)
-        self.res_block2 = nn.ModuleList(
-            [
-                ResnetBlock(
-                    in_channels=mid_channels,
-                    out_channels=mid_channels,
-                    temb_channels=0,
-                    dropout=0.0,
-                )
-                for _ in range(depth)
-            ]
-        )
-
-        self.conv_out = nn.Conv2d(
-            mid_channels,
-            out_channels,
-            kernel_size=1,
-        )
-
-    def forward(self, x):
-        x = self.conv_in(x)
-        for block in self.res_block1:
-            x = block(x, None)
-        x = torch.nn.functional.interpolate(
-            x,
-            size=(
-                int(round(x.shape[2] * self.factor)),
-                int(round(x.shape[3] * self.factor)),
-            ),
-        )
-        x = self.attn(x).contiguous()
-        for block in self.res_block2:
-            x = block(x, None)
-        x = self.conv_out(x)
-        return x
-
-
-class MergedRescaleEncoder(nn.Module):
-    def __init__(
-        self,
-        in_channels,
-        ch,
-        resolution,
-        out_ch,
-        num_res_blocks,
-        attn_resolutions,
-        dropout=0.0,
-        resamp_with_conv=True,
-        ch_mult=(1, 2, 4, 8),
-        rescale_factor=1.0,
-        rescale_module_depth=1,
-    ):
-        super().__init__()
-        intermediate_chn = ch * ch_mult[-1]
-        self.encoder = Encoder(
-            in_channels=in_channels,
-            num_res_blocks=num_res_blocks,
-            ch=ch,
-            ch_mult=ch_mult,
-            z_channels=intermediate_chn,
-            double_z=False,
-            resolution=resolution,
-            attn_resolutions=attn_resolutions,
-            dropout=dropout,
-            resamp_with_conv=resamp_with_conv,
-            out_ch=None,
-        )
-        self.rescaler = LatentRescaler(
-            factor=rescale_factor,
-            in_channels=intermediate_chn,
-            mid_channels=intermediate_chn,
-            out_channels=out_ch,
-            depth=rescale_module_depth,
-        )
-
-    def forward(self, x):
-        x = self.encoder(x)
-        x = self.rescaler(x)
-        return x
-
-
-class MergedRescaleDecoder(nn.Module):
-    def __init__(
-        self,
-        z_channels,
-        out_ch,
-        resolution,
-        num_res_blocks,
-        attn_resolutions,
-        ch,
-        ch_mult=(1, 2, 4, 8),
-        dropout=0.0,
-        resamp_with_conv=True,
-        rescale_factor=1.0,
-        rescale_module_depth=1,
-    ):
-        super().__init__()
-        tmp_chn = z_channels * ch_mult[-1]
-        self.decoder = Decoder(
-            out_ch=out_ch,
-            z_channels=tmp_chn,
-            attn_resolutions=attn_resolutions,
-            dropout=dropout,
-            resamp_with_conv=resamp_with_conv,
-            in_channels=None,
-            num_res_blocks=num_res_blocks,
-            ch_mult=ch_mult,
-            resolution=resolution,
-            ch=ch,
-        )
-        self.rescaler = LatentRescaler(
-            factor=rescale_factor,
-            in_channels=z_channels,
-            mid_channels=tmp_chn,
-            out_channels=tmp_chn,
-            depth=rescale_module_depth,
-        )
-
-    def forward(self, x):
-        x = self.rescaler(x)
-        x = self.decoder(x)
-        return x
-
-
-class Upsampler(nn.Module):
-    def __init__(self, in_size, out_size, in_channels, out_channels, ch_mult=2):
-        super().__init__()
-        assert out_size >= in_size
-        num_blocks = int(np.log2(out_size // in_size)) + 1
-        factor_up = 1.0 + (out_size % in_size)
-        print(
-            f"Building {self.__class__.__name__} with in_size: {in_size} --> out_size {out_size} and factor {factor_up}"
-        )
-        self.rescaler = LatentRescaler(
-            factor=factor_up,
-            in_channels=in_channels,
-            mid_channels=2 * in_channels,
-            out_channels=in_channels,
-        )
-        self.decoder = Decoder(
-            out_ch=out_channels,
-            resolution=out_size,
-            z_channels=in_channels,
-            num_res_blocks=2,
-            attn_resolutions=[],
-            in_channels=None,
-            ch=in_channels,
-            ch_mult=[ch_mult for _ in range(num_blocks)],
-        )
-
-    def forward(self, x):
-        x = self.rescaler(x)
-        x = self.decoder(x)
-        return x
-
-
-class Resize(nn.Module):
-    def __init__(self, in_channels=None, learned=False, mode="bilinear"):
-        super().__init__()
-        self.with_conv = learned
-        self.mode = mode
-        if self.with_conv:
-            print(
-                f"Note: {self.__class__.__name} uses learned downsampling and will ignore the fixed {mode} mode"
-            )
-            raise NotImplementedError()
-            assert in_channels is not None
-            # no asymmetric padding in torch conv, must do it ourselves
-            self.conv = torch.nn.Conv2d(
-                in_channels, in_channels, kernel_size=4, stride=2, padding=1
-            )
-
-    def forward(self, x, scale_factor=1.0):
-        if scale_factor == 1.0:
-            return x
-        else:
-            x = torch.nn.functional.interpolate(
-                x, mode=self.mode, align_corners=False, scale_factor=scale_factor
-            )
-        return x
-
-
-class FirstStagePostProcessor(nn.Module):
-    def __init__(
-        self,
-        ch_mult: list,
-        in_channels,
-        pretrained_model: nn.Module = None,
-        reshape=False,
-        n_channels=None,
-        dropout=0.0,
-        pretrained_config=None,
-    ):
-        super().__init__()
-        if pretrained_config is None:
-            assert (
-                pretrained_model is not None
-            ), 'Either "pretrained_model" or "pretrained_config" must not be None'
-            self.pretrained_model = pretrained_model
-        else:
-            assert (
-                pretrained_config is not None
-            ), 'Either "pretrained_model" or "pretrained_config" must not be None'
-            self.instantiate_pretrained(pretrained_config)
-
-        self.do_reshape = reshape
-
-        if n_channels is None:
-            n_channels = self.pretrained_model.encoder.ch
-
-        self.proj_norm = Normalize(in_channels, num_groups=in_channels // 2)
-        self.proj = nn.Conv2d(
-            in_channels, n_channels, kernel_size=3, stride=1, padding=1
-        )
-
-        blocks = []
-        downs = []
-        ch_in = n_channels
-        for m in ch_mult:
-            blocks.append(
-                ResnetBlock(
-                    in_channels=ch_in, out_channels=m * n_channels, dropout=dropout
-                )
-            )
-            ch_in = m * n_channels
-            downs.append(Downsample(ch_in, with_conv=False))
-
-        self.model = nn.ModuleList(blocks)
-        self.downsampler = nn.ModuleList(downs)
-
-    def instantiate_pretrained(self, config):
-        model = instantiate_from_config(config)
-        self.pretrained_model = model.eval()
-        # self.pretrained_model.train = False
-        for param in self.pretrained_model.parameters():
-            param.requires_grad = False
-
-    @torch.no_grad()
-    def encode_with_pretrained(self, x):
-        c = self.pretrained_model.encode(x)
-        if isinstance(c, DiagonalGaussianDistribution):
-            c = c.mode()
-        return c
-
-    def forward(self, x):
-        z_fs = self.encode_with_pretrained(x)
-        z = self.proj_norm(z_fs)
-        z = self.proj(z)
-        z = nonlinearity(z)
-
-        for submodel, downmodel in zip(self.model, self.downsampler):
-            z = submodel(z, temb=None)
-            z = downmodel(z)
-
-        if self.do_reshape:
-            z = rearrange(z, "b c h w -> b (h w) c")
-        return z

spaces/AIGC-Audio/AudioGPT/text_to_audio/Make_An_Audio/ldm/modules/losses_audio/contperceptual.py

@@ -1,123 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import sys
-
-sys.path.insert(0, '.')  # nopep8
-from ldm.modules.losses_audio.vqperceptual import *
-
-
-class LPAPSWithDiscriminator(nn.Module):
-    def __init__(self, disc_start, logvar_init=0.0, kl_weight=1.0, pixelloss_weight=1.0,
-                 disc_num_layers=3, disc_in_channels=3, disc_factor=1.0, disc_weight=1.0,
-                 perceptual_weight=1.0, use_actnorm=False, disc_conditional=False,
-                 disc_loss="hinge"):
-
-        super().__init__()
-        assert disc_loss in ["hinge", "vanilla"]
-        self.kl_weight = kl_weight
-        self.pixel_weight = pixelloss_weight
-        self.perceptual_loss = LPAPS().eval()# LPIPS用于日常图像，而LPAPS用于梅尔谱图
-        self.perceptual_weight = perceptual_weight
-        # output log variance
-        self.logvar = nn.Parameter(torch.ones(size=()) * logvar_init)
-
-        self.discriminator = NLayerDiscriminator(input_nc=disc_in_channels,
-                                                 n_layers=disc_num_layers,
-                                                 use_actnorm=use_actnorm,
-                                                 ).apply(weights_init)
-        self.discriminator_iter_start = disc_start
-        if disc_loss == "hinge":
-            self.disc_loss = hinge_d_loss
-        elif disc_loss == "vanilla":
-            self.disc_loss = vanilla_d_loss
-        else:
-            raise ValueError(f"Unknown GAN loss '{disc_loss}'.")
-        print(f"LPAPSWithDiscriminator running with {disc_loss} loss.")
-        self.disc_factor = disc_factor
-        self.discriminator_weight = disc_weight
-        self.disc_conditional = disc_conditional
-
-
-    def calculate_adaptive_weight(self, nll_loss, g_loss, last_layer=None):
-        if last_layer is not None:
-            nll_grads = torch.autograd.grad(nll_loss, last_layer, retain_graph=True)[0]
-            g_grads = torch.autograd.grad(g_loss, last_layer, retain_graph=True)[0]
-        else:
-            nll_grads = torch.autograd.grad(nll_loss, self.last_layer[0], retain_graph=True)[0]
-            g_grads = torch.autograd.grad(g_loss, self.last_layer[0], retain_graph=True)[0]
-
-        d_weight = torch.norm(nll_grads) / (torch.norm(g_grads) + 1e-4)
-        d_weight = torch.clamp(d_weight, 0.0, 1e4).detach()
-        d_weight = d_weight * self.discriminator_weight
-        return d_weight
-
-    def forward(self, inputs, reconstructions, posteriors, optimizer_idx,
-                global_step, last_layer=None, cond=None, split="train", weights=None):
-        rec_loss = torch.abs(inputs.contiguous() - reconstructions.contiguous())
-        if self.perceptual_weight > 0:
-            p_loss = self.perceptual_loss(inputs.contiguous(), reconstructions.contiguous())
-            # print(f"p_loss {p_loss}")
-            rec_loss = rec_loss + self.perceptual_weight * p_loss
-        else:
-            p_loss = torch.tensor([0.0])
-
-        nll_loss = rec_loss / torch.exp(self.logvar) + self.logvar
-        weighted_nll_loss = nll_loss
-        if weights is not None:
-            weighted_nll_loss = weights*nll_loss
-        weighted_nll_loss = torch.sum(weighted_nll_loss) / weighted_nll_loss.shape[0]
-        nll_loss = torch.sum(nll_loss) / nll_loss.shape[0]
-        kl_loss = posteriors.kl()
-        kl_loss = torch.sum(kl_loss) / kl_loss.shape[0]
-
-        # now the GAN part
-        if optimizer_idx == 0:
-            # generator update
-            if cond is None:
-                assert not self.disc_conditional
-                logits_fake = self.discriminator(reconstructions.contiguous())
-            else:
-                assert self.disc_conditional
-                logits_fake = self.discriminator(torch.cat((reconstructions.contiguous(), cond), dim=1))
-            g_loss = -torch.mean(logits_fake)
-
-            try:
-                d_weight = self.calculate_adaptive_weight(nll_loss, g_loss, last_layer=last_layer)
-            except RuntimeError:
-                assert not self.training
-                d_weight = torch.tensor(0.0)
-
-            disc_factor = adopt_weight(self.disc_factor, global_step, threshold=self.discriminator_iter_start)
-            loss = weighted_nll_loss + self.kl_weight * kl_loss + d_weight * disc_factor * g_loss
-
-            log = {"{}/total_loss".format(split): loss.clone().detach().mean(),
-                   "{}/logvar".format(split): self.logvar.detach(),
-                   "{}/kl_loss".format(split): kl_loss.detach().mean(),
-                   "{}/nll_loss".format(split): nll_loss.detach().mean(),
-                   "{}/rec_loss".format(split): rec_loss.detach().mean(),
-                   "{}/d_weight".format(split): d_weight.detach(),
-                   "{}/disc_factor".format(split): torch.tensor(disc_factor),
-                   "{}/g_loss".format(split): g_loss.detach().mean(),
-                   }
-            return loss, log
-
-        if optimizer_idx == 1:
-            # second pass for discriminator update
-            if cond is None:
-                logits_real = self.discriminator(inputs.contiguous().detach())
-                logits_fake = self.discriminator(reconstructions.contiguous().detach())
-            else:
-                logits_real = self.discriminator(torch.cat((inputs.contiguous().detach(), cond), dim=1))
-                logits_fake = self.discriminator(torch.cat((reconstructions.contiguous().detach(), cond), dim=1))
-
-            disc_factor = adopt_weight(self.disc_factor, global_step, threshold=self.discriminator_iter_start)
-            d_loss = disc_factor * self.disc_loss(logits_real, logits_fake)
-
-            log = {"{}/disc_loss".format(split): d_loss.clone().detach().mean(),
-                   "{}/logits_real".format(split): logits_real.detach().mean(),
-                   "{}/logits_fake".format(split): logits_fake.detach().mean()
-                   }
-            return d_loss, log
-
-

spaces/AIGC-Audio/AudioGPT/text_to_speech/utils/text/text_encoder.py

@@ -1,272 +0,0 @@
-import json
-import re
-import six
-from six.moves import range  # pylint: disable=redefined-builtin
-
-PAD = "<pad>"
-EOS = "<EOS>"
-UNK = "<UNK>"
-SEG = "|"
-PUNCS = '!,.?;:'
-RESERVED_TOKENS = [PAD, EOS, UNK]
-NUM_RESERVED_TOKENS = len(RESERVED_TOKENS)
-PAD_ID = RESERVED_TOKENS.index(PAD)  # Normally 0
-EOS_ID = RESERVED_TOKENS.index(EOS)  # Normally 1
-UNK_ID = RESERVED_TOKENS.index(UNK)  # Normally 2
-
-if six.PY2:
-    RESERVED_TOKENS_BYTES = RESERVED_TOKENS
-else:
-    RESERVED_TOKENS_BYTES = [bytes(PAD, "ascii"), bytes(EOS, "ascii")]
-
-# Regular expression for unescaping token strings.
-# '\u' is converted to '_'
-# '\\' is converted to '\'
-# '\213;' is converted to unichr(213)
-_UNESCAPE_REGEX = re.compile(r"\\u|\\\\|\\([0-9]+);")
-_ESCAPE_CHARS = set(u"\\_u;0123456789")
-
-
-def strip_ids(ids, ids_to_strip):
-    """Strip ids_to_strip from the end ids."""
-    ids = list(ids)
-    while ids and ids[-1] in ids_to_strip:
-        ids.pop()
-    return ids
-
-
-class TextEncoder(object):
-    """Base class for converting from ints to/from human readable strings."""
-
-    def __init__(self, num_reserved_ids=NUM_RESERVED_TOKENS):
-        self._num_reserved_ids = num_reserved_ids
-
-    @property
-    def num_reserved_ids(self):
-        return self._num_reserved_ids
-
-    def encode(self, s):
-        """Transform a human-readable string into a sequence of int ids.
-
-        The ids should be in the range [num_reserved_ids, vocab_size). Ids [0,
-        num_reserved_ids) are reserved.
-
-        EOS is not appended.
-
-        Args:
-        s: human-readable string to be converted.
-
-        Returns:
-        ids: list of integers
-        """
-        return [int(w) + self._num_reserved_ids for w in s.split()]
-
-    def decode(self, ids, strip_extraneous=False):
-        """Transform a sequence of int ids into a human-readable string.
-
-        EOS is not expected in ids.
-
-        Args:
-        ids: list of integers to be converted.
-        strip_extraneous: bool, whether to strip off extraneous tokens
-            (EOS and PAD).
-
-        Returns:
-        s: human-readable string.
-        """
-        if strip_extraneous:
-            ids = strip_ids(ids, list(range(self._num_reserved_ids or 0)))
-        return " ".join(self.decode_list(ids))
-
-    def decode_list(self, ids):
-        """Transform a sequence of int ids into a their string versions.
-
-        This method supports transforming individual input/output ids to their
-        string versions so that sequence to/from text conversions can be visualized
-        in a human readable format.
-
-        Args:
-        ids: list of integers to be converted.
-
-        Returns:
-        strs: list of human-readable string.
-        """
-        decoded_ids = []
-        for id_ in ids:
-            if 0 <= id_ < self._num_reserved_ids:
-                decoded_ids.append(RESERVED_TOKENS[int(id_)])
-            else:
-                decoded_ids.append(id_ - self._num_reserved_ids)
-        return [str(d) for d in decoded_ids]
-
-    @property
-    def vocab_size(self):
-        raise NotImplementedError()
-
-
-class TokenTextEncoder(TextEncoder):
-    """Encoder based on a user-supplied vocabulary (file or list)."""
-
-    def __init__(self,
-                 vocab_filename,
-                 reverse=False,
-                 vocab_list=None,
-                 replace_oov=None,
-                 num_reserved_ids=NUM_RESERVED_TOKENS):
-        """Initialize from a file or list, one token per line.
-
-        Handling of reserved tokens works as follows:
-        - When initializing from a list, we add reserved tokens to the vocab.
-        - When initializing from a file, we do not add reserved tokens to the vocab.
-        - When saving vocab files, we save reserved tokens to the file.
-
-        Args:
-            vocab_filename: If not None, the full filename to read vocab from. If this
-                is not None, then vocab_list should be None.
-            reverse: Boolean indicating if tokens should be reversed during encoding
-                and decoding.
-            vocab_list: If not None, a list of elements of the vocabulary. If this is
-                not None, then vocab_filename should be None.
-            replace_oov: If not None, every out-of-vocabulary token seen when
-                encoding will be replaced by this string (which must be in vocab).
-            num_reserved_ids: Number of IDs to save for reserved tokens like <EOS>.
-        """
-        super(TokenTextEncoder, self).__init__(num_reserved_ids=num_reserved_ids)
-        self._reverse = reverse
-        self._replace_oov = replace_oov
-        if vocab_filename:
-            self._init_vocab_from_file(vocab_filename)
-        else:
-            assert vocab_list is not None
-            self._init_vocab_from_list(vocab_list)
-        self.pad_index = self.token_to_id[PAD]
-        self.eos_index = self.token_to_id[EOS]
-        self.unk_index = self.token_to_id[UNK]
-        self.seg_index = self.token_to_id[SEG] if SEG in self.token_to_id else self.eos_index
-
-    def encode(self, s):
-        """Converts a space-separated string of tokens to a list of ids."""
-        sentence = s
-        tokens = sentence.strip().split()
-        if self._replace_oov is not None:
-            tokens = [t if t in self.token_to_id else self._replace_oov
-                      for t in tokens]
-        ret = [self.token_to_id[tok] for tok in tokens]
-        return ret[::-1] if self._reverse else ret
-
-    def decode(self, ids, strip_eos=False, strip_padding=False):
-        if strip_padding and self.pad() in list(ids):
-            pad_pos = list(ids).index(self.pad())
-            ids = ids[:pad_pos]
-        if strip_eos and self.eos() in list(ids):
-            eos_pos = list(ids).index(self.eos())
-            ids = ids[:eos_pos]
-        return " ".join(self.decode_list(ids))
-
-    def decode_list(self, ids):
-        seq = reversed(ids) if self._reverse else ids
-        return [self._safe_id_to_token(i) for i in seq]
-
-    @property
-    def vocab_size(self):
-        return len(self.id_to_token)
-
-    def __len__(self):
-        return self.vocab_size
-
-    def _safe_id_to_token(self, idx):
-        return self.id_to_token.get(idx, "ID_%d" % idx)
-
-    def _init_vocab_from_file(self, filename):
-        """Load vocab from a file.
-
-        Args:
-        filename: The file to load vocabulary from.
-        """
-        with open(filename) as f:
-            tokens = [token.strip() for token in f.readlines()]
-
-        def token_gen():
-            for token in tokens:
-                yield token
-
-        self._init_vocab(token_gen(), add_reserved_tokens=False)
-
-    def _init_vocab_from_list(self, vocab_list):
-        """Initialize tokens from a list of tokens.
-
-        It is ok if reserved tokens appear in the vocab list. They will be
-        removed. The set of tokens in vocab_list should be unique.
-
-        Args:
-        vocab_list: A list of tokens.
-        """
-
-        def token_gen():
-            for token in vocab_list:
-                if token not in RESERVED_TOKENS:
-                    yield token
-
-        self._init_vocab(token_gen())
-
-    def _init_vocab(self, token_generator, add_reserved_tokens=True):
-        """Initialize vocabulary with tokens from token_generator."""
-
-        self.id_to_token = {}
-        non_reserved_start_index = 0
-
-        if add_reserved_tokens:
-            self.id_to_token.update(enumerate(RESERVED_TOKENS))
-            non_reserved_start_index = len(RESERVED_TOKENS)
-
-        self.id_to_token.update(
-            enumerate(token_generator, start=non_reserved_start_index))
-
-        # _token_to_id is the reverse of _id_to_token
-        self.token_to_id = dict((v, k) for k, v in six.iteritems(self.id_to_token))
-
-    def pad(self):
-        return self.pad_index
-
-    def eos(self):
-        return self.eos_index
-
-    def unk(self):
-        return self.unk_index
-
-    def seg(self):
-        return self.seg_index
-
-    def store_to_file(self, filename):
-        """Write vocab file to disk.
-
-        Vocab files have one token per line. The file ends in a newline. Reserved
-        tokens are written to the vocab file as well.
-
-        Args:
-        filename: Full path of the file to store the vocab to.
-        """
-        with open(filename, "w") as f:
-            for i in range(len(self.id_to_token)):
-                f.write(self.id_to_token[i] + "\n")
-
-    def sil_phonemes(self):
-        return [p for p in self.id_to_token.values() if is_sil_phoneme(p)]
-
-    # add by zhenhiye
-    def add_new_token(self, new_token):
-        assert new_token not in list(self.id_to_token.values())
-        num_existing_tokens = len(self.id_to_token)
-        self.id_to_token[num_existing_tokens] = new_token
-        self.token_to_id = dict((v, k) for k, v in six.iteritems(self.id_to_token))
-        print(f"Added {new_token} into the token dict!")
-
-def build_token_encoder(token_list_file):
-    token_list = json.load(open(token_list_file))
-    return TokenTextEncoder(None, vocab_list=token_list, replace_oov='<UNK>')
-
-
-def is_sil_phoneme(p):
-    return p == '' or not p[0].isalpha()
-    # for aishell_notone_sing
-    # return p == '' or not p[0].isalpha() or p == 'breathe'

spaces/AIGText/GlyphControl/ldm/models/diffusion/dpm_solver/__init__.py

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

spaces/ALSv/FSW/roop/capturer.py

@@ -1,22 +0,0 @@
-from typing import Optional
-import cv2
-
-from roop.typing import Frame
-
-
-def get_video_frame(video_path: str, frame_number: int = 0) -> Optional[Frame]:
-    capture = cv2.VideoCapture(video_path)
-    frame_total = capture.get(cv2.CAP_PROP_FRAME_COUNT)
-    capture.set(cv2.CAP_PROP_POS_FRAMES, min(frame_total, frame_number - 1))
-    has_frame, frame = capture.read()
-    capture.release()
-    if has_frame:
-        return frame
-    return None
-
-
-def get_video_frame_total(video_path: str) -> int:
-    capture = cv2.VideoCapture(video_path)
-    video_frame_total = int(capture.get(cv2.CAP_PROP_FRAME_COUNT))
-    capture.release()
-    return video_frame_total

spaces/AchyuthGamer/Free-Accounts-Generator/minecraft/css/style.css

@@ -1,80 +0,0 @@
-body {
-  font-family: Verdana, Geneva, sans-serif;
-  font-size: 1.2em;
-  margin: 2%;
-  max-width: 100%;
-  padding: 80px 30px;
-  line-height: 1.65em;
-  background-image: url('https://huggingface.co/spaces/AchyuthGamer/Free-Accounts-Generator/resolve/main/img/minecraft.jpg');
-  color: #fff;
-  font-weight: 300;
-
-}
-
-h1 {
-  text-align: center;
-  margin: 19% 0 5% 0;
-  font-size: 60px;
-  text-shadow: 0 0 28px #FF0000, 0 0 28px #008000; 
-}
-
-h4 {
-  text-align: center;
-  margin: 50% 0 5% 0;
-}
-
-#wordbox {
-    /*opacity: 0;*/
-    margin: 30px auto 0;
-    display: block;
-    width: 80%;
-    height: 50px;
-    font-size: 25px;
-    text-align: center;
-    background: #fff;
-    border-radius: 6px;
-    color: #black;
-    transition: 1s linear;
-}
-
-#button {
-  -webkit-box-sizing: border-box;
-  -moz-box-sizing: border-box;
-  box-sizing: border-box;
-  background: #0b7fba;
-    border: 0;
-    color: #fff;
-    font-size: 20px;
-    padding: 1em 2em;
-    cursor: pointer;
-    margin: 0 auto 80px;
-    display: block;
-    text-align: center;
-    border-radius: 6px;
-    font-weight: bold;
-    transition: all 0.3s ease;
-    background-image: linear-gradient(to right, #25aae1, #4481eb, #04befe, #3f86ed);
-    box-shadow: 0 4px 15px 0 rgba(65, 132, 234, 0.75);
-}
-
-#button:hover {
-  background-position: 100% 0;
-  -moz-transition: all 0.4s ease-in-out;
-  -o-transition: all 0.4s ease-in-out;
-  -webkit-transition: all 0.4s ease-in-out;
-  transition: all 0.4s ease-in-out;
-  transform: scale(1.2);
-  cursor: pointer; }
-  
-#button:focus {
-      outline: none;
-  }
-
-
-
-span {
-    position: bottom;
-    top: 0;
-    left: 0;
-    margin: 40px; 
-  }

spaces/Adapting/TrendFlow/mypages/__init__.py

@@ -1,2 +0,0 @@
-from .welcome import welcome
-from .home import home

spaces/AgentVerse/agentVerse/agentverse/memory_manipulator/reflection.py

@@ -1,330 +0,0 @@
-from __future__ import annotations
-from typing import List, Union, Optional, Any, TYPE_CHECKING
-from collections import defaultdict
-
-from pydantic import Field
-import numpy as np
-from datetime import datetime as dt
-
-import re
-
-from agentverse.llms.openai import get_embedding
-from sklearn.metrics.pairwise import cosine_similarity
-
-from agentverse.message import Message
-from agentverse.memory import BaseMemory
-
-from agentverse.logging import logger
-
-from . import memory_manipulator_registry
-from .base import BaseMemoryManipulator
-
-if TYPE_CHECKING:
-    from agentverse.memory import VectorStoreMemory
-    from agentverse.agents.base import BaseAgent
-
-
-IMPORTANCE_PROMPT = """On the scale of 1 to 10, where 1 is purely mundane \
-(e.g., brushing teeth, making bed) and 10 is \
-extremely poignant (e.g., a break up, college \
-acceptance), rate the likely poignancy of the \
-following piece of memory. \
-If you think it's too hard to rate it, you can give an inaccurate assessment. \
-The content or people mentioned is not real. You can hypothesis any reasonable context. \
-Please strictly only output one number. \
-Memory: {} \
-Rating: """
-IMMEDIACY_PROMPT = """On the scale of 1 to 10, where 1 is requiring no short time attention\
-(e.g., a bed is in the room) and 10 is \
-needing quick attention or immediate response(e.g., being required a reply by others), rate the likely immediacy of the \
-following statement. \
-If you think it's too hard to rate it, you can give an inaccurate assessment. \
-The content or people mentioned is not real. You can hypothesis any reasonable context. \
-Please strictly only output one number. \
-Memory: {} \
-Rating: """
-QUESTION_PROMPT = """Given only the information above, what are 3 most salient \
-high-level questions we can answer about the subjects in the statements?"""
-
-INSIGHT_PROMPT = """What at most 5 high-level insights can you infer from \
-the above statements? Only output insights with high confidence. 
-example format: insight (because of 1, 5, 3)"""
-
-
-@memory_manipulator_registry.register("reflection")
-class Reflection(BaseMemoryManipulator):
-    memory: VectorStoreMemory = None
-    agent: BaseAgent = None
-
-    reflection: str = ""
-
-    importance_threshold: int = 10
-    accumulated_importance: int = 0
-
-    memory2importance: dict = {}
-    memory2immediacy: dict = {}
-    memory2time: defaultdict = Field(default=defaultdict(dict))
-
-    # TODO newly added func from generative agents
-
-    def manipulate_memory(self) -> None:
-        # reflect here
-        if self.should_reflect():
-            logger.debug(
-                f"Agent {self.agent.name} is now doing reflection since accumulated_importance={self.accumulated_importance} < reflection_threshold={self.importance_threshold}"
-            )
-            self.reflection = self.reflect()
-            return self.reflection
-        else:
-            logger.debug(
-                f"Agent {self.agent.name} doesn't reflect since accumulated_importance={self.accumulated_importance} < reflection_threshold={self.importance_threshold}"
-            )
-
-            return ""
-
-    def get_accumulated_importance(self):
-        accumulated_importance = 0
-
-        for memory in self.memory.messages:
-            if (
-                memory.content not in self.memory2importance
-                or memory.content not in self.memory2immediacy
-            ):
-                self.memory2importance[memory.content] = self.get_importance(
-                    memory.content
-                )
-                self.memory2immediacy[memory.content] = self.get_immediacy(
-                    memory.content
-                )
-
-        for score in self.memory2importance.values():
-            accumulated_importance += score
-
-        self.accumulated_importance = accumulated_importance
-
-        return accumulated_importance
-
-    def should_reflect(self):
-        if self.get_accumulated_importance() >= self.importance_threshold:
-            # double the importance_threshold
-            self.importance_threshold *= 2
-            return True
-        else:
-            return False
-
-    def get_questions(self, texts):
-        prompt = "\n".join(texts) + "\n" + QUESTION_PROMPT
-        result = self.agent.llm.generate_response(prompt)
-        result = result.content
-        questions = [q for q in result.split("\n") if len(q.strip()) > 0]
-        questions = questions[:3]
-        return questions
-
-    def get_insights(self, statements):
-        prompt = ""
-        for i, st in enumerate(statements):
-            prompt += str(i + 1) + ". " + st + "\n"
-        prompt += INSIGHT_PROMPT
-        result = self.agent.llm.generate_response(prompt)
-        result = result.content
-        insights = [isg for isg in result.split("\n") if len(isg.strip()) > 0][:5]
-        insights = [".".join(i.split(".")[1:]) for i in insights]
-        # remove insight pointers for now
-        insights = [i.split("(")[0].strip() for i in insights]
-        return insights
-
-    def get_importance(self, content: str):
-        """
-        Exploit GPT to evaluate the importance of this memory
-        """
-        prompt = IMPORTANCE_PROMPT.format(content)
-        result = self.memory.llm.generate_response(prompt)
-
-        try:
-            score = int(re.findall(r"\s*(\d+)\s*", result.content)[0])
-        except Exception as e:
-            logger.warn(
-                f"Found error {e} Abnormal result of importance rating '{result}'. Setting default value"
-            )
-            score = 0
-        return score
-
-    def get_immediacy(self, content: str):
-        """
-        Exploit GPT to evaluate the immediacy of this memory
-        """
-        prompt = IMMEDIACY_PROMPT.format(content)
-        result = self.memory.llm.generate_response(prompt)
-        try:
-            score = int(re.findall(r"\s*(\d+)\s*", result.content)[0])
-        except Exception as e:
-            logger.warn(
-                f"Found error {e} Abnormal result of importance rating '{result}'. Setting default value"
-            )
-            score = 0
-        return score
-
-    def query_similarity(
-        self,
-        text: Union[str, List[str]],
-        k: int,
-        memory_bank: List,
-        current_time=dt.now(),
-        nms_threshold=0.99,
-    ) -> List[str]:
-        """
-        get top-k entry based on recency, relevance, importance, immediacy
-        The query result can be Short-term or Long-term queried result.
-        formula is
-        `score= sim(q,v) *max(LTM_score, STM_score)`
-        `STM_score=time_score(createTime)*immediacy`
-        `LTM_score=time_score(accessTime)*importance`
-        time score is exponential decay weight. stm decays faster.
-
-        The query supports querying based on multiple texts and only gives non-overlapping results
-        If nms_threshold is not 1, nms mechanism if activated. By default,
-        use soft nms with modified iou base(score starts to decay iff cos sim is higher than this value,
-         and decay weight at this value if 0. rather than 1-threshold).
-
-        Args:
-            text: str
-            k: int
-            memory_bank: List
-            current_time: dt.now
-            nms_threshold: float = 0.99
-
-
-        Returns: List[str]
-        """
-        assert len(text) > 0
-        texts = [text] if isinstance(text, str) else text
-        maximum_score = None
-        for text in texts:
-            embedding = get_embedding(text)
-            score = []
-            for memory in memory_bank:
-                if memory.content not in self.memory2time:
-                    self.memory2time[memory.content]["last_access_time"] = dt.now()
-                    self.memory2time[memory.content]["create_time"] = dt.now()
-
-                last_access_time_diff = (
-                    current_time - self.memory2time[memory.content]["last_access_time"]
-                ).total_seconds() // 3600
-                recency = np.power(
-                    0.99, last_access_time_diff
-                )  # TODO: review the metaparameter 0.99
-
-                create_time_diff = (
-                    current_time - self.memory2time[memory.content]["create_time"]
-                ).total_seconds() // 60
-                instancy = np.power(
-                    0.90, create_time_diff
-                )  # TODO: review the metaparameter 0.90
-
-                relevance = cosine_similarity(
-                    np.array(embedding).reshape(1, -1),
-                    np.array(self.memory.memory2embedding[memory.content]).reshape(
-                        1, -1
-                    ),
-                )[0][0]
-
-                if (
-                    memory.content not in self.memory2importance
-                    or memory.content not in self.memory2immediacy
-                ):
-                    self.memory2importance[memory.content] = self.get_importance(
-                        memory.content
-                    )
-                    self.memory2immediacy[memory.content] = self.get_immediacy(
-                        memory.content
-                    )
-
-                importance = self.memory2importance[memory.content] / 10
-                immediacy = self.memory2immediacy[memory.content] / 10
-
-                ltm_w = recency * importance
-                stm_w = instancy * immediacy
-
-                score.append(relevance * np.maximum(ltm_w, stm_w))
-
-            score = np.array(score)
-
-            if maximum_score is not None:
-                maximum_score = np.maximum(score, maximum_score)
-            else:
-                maximum_score = score
-
-        if nms_threshold == 1.0:
-            # no nms is triggered
-            top_k_indices = np.argsort(maximum_score)[-k:][::-1]
-        else:
-            # TODO: soft-nms
-            assert 0 <= nms_threshold < 1
-            top_k_indices = []
-            while len(top_k_indices) < min(k, len(memory_bank)):
-                top_index = np.argmax(maximum_score)
-                top_k_indices.append(top_index)
-                maximum_score[top_index] = -1  # anything to prevent being chosen again
-                top_embedding = self.memory.memory2embedding[
-                    memory_bank[top_index].content
-                ]
-                cos_sim = cosine_similarity(
-                    np.array(top_embedding).reshape(1, -1),
-                    np.array(
-                        [
-                            self.memory.memory2embedding[memory.content]
-                            for memory in memory_bank
-                        ]
-                    ),
-                )[0]
-                score_weight = np.ones_like(maximum_score)
-                score_weight[cos_sim >= nms_threshold] -= (
-                    cos_sim[cos_sim >= nms_threshold] - nms_threshold
-                ) / (1 - nms_threshold)
-                maximum_score = maximum_score * score_weight
-
-        # access them and refresh the access time
-        for i in top_k_indices:
-            self.memory2time[memory_bank[i].content]["last_access_time"] = current_time
-        # sort them in time periods. if the data tag is 'observation', ad time info output.
-        top_k_indices = sorted(
-            top_k_indices,
-            key=lambda x: self.memory2time[memory_bank[x].content]["create_time"],
-        )
-        query_results = []
-        for i in top_k_indices:
-            query_result = memory_bank[i].content
-            query_results.append(query_result)
-
-        return query_results
-
-    def get_memories_of_interest_oneself(self):
-        memories_of_interest = []
-        for memory in self.memory.messages[-100:]:
-            if memory.sender == self.agent.name:
-                memories_of_interest.append(memory)
-        return memories_of_interest
-
-    def reflect(self):
-        """
-        initiate a reflection that inserts high level knowledge to memory
-        """
-        memories_of_interest = self.get_memories_of_interest_oneself()
-        questions = self.get_questions([m.content for m in memories_of_interest])
-        statements = self.query_similarity(
-            questions, len(questions) * 10, memories_of_interest
-        )
-        insights = self.get_insights(statements)
-        logger.info(self.agent.name + f" Insights: {insights}")
-        for insight in insights:
-            # convert insight to messages
-            # TODO currently only oneself can see its own reflection
-            insight_message = Message(
-                content=insight, sender=self.agent.name, receiver={self.agent.name}
-            )
-            self.memory.add_message([insight_message])
-        reflection = "\n".join(insights)
-        return reflection
-
-    def reset(self) -> None:
-        self.reflection = ""

spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/plugins/csvscenario-plugin.js

@@ -1,18 +0,0 @@
-import CSVScenario from './csvscenario.js';
-
-class CSVScenarioPlugin extends Phaser.Plugins.BasePlugin {
-    constructor(pluginManager) {
-        super(pluginManager);
-    }
-
-    start() {
-        var eventEmitter = this.game.events;
-        eventEmitter.on('destroy', this.destroy, this);
-    }
-
-    add(scene, config) {
-        return new CSVScenario(scene, config);
-    }
-}
-
-export default CSVScenarioPlugin;

spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/dialog-quest/DataMethods.js

@@ -1,25 +0,0 @@
-export default {
-    getData(key, defaultValue) {
-        return this.questionManager.getData(key, defaultValue);
-    },
-
-    setData(key, value) {
-        this.questionManager.setData(key, value);
-        return this;
-    },
-
-    incData(key, inc, defaultValue) {
-        this.questionManager.incData(key, inc, defaultValue);
-        return this;
-    },
-
-    mulData(key, mul, defaultValue) {
-        this.questionManager.mulData(key, mul, defaultValue);
-        return this;
-    },
-
-    clearData() {
-        this.questionManager.clearData();
-        return this;
-    },
-};

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

@@ -1,13 +0,0 @@
-import Checkbox from './Checkbox.js';
-import ObjectFactory from '../ObjectFactory.js';
-import SetValue from '../../../plugins/utils/object/SetValue.js';
-
-ObjectFactory.register('checkbox', function (x, y, width, height, color, config) {
-    var gameObject = new Checkbox(this.scene, x, y, width, height, color, config);
-    this.scene.add.existing(gameObject);
-    return gameObject;
-});
-
-SetValue(window, 'RexPlugins.UI.Checkbox', Checkbox);
-
-export default Checkbox;

spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/gridtable/input/OverCell.js

@@ -1,30 +0,0 @@
-import EmitCellEvent from './EmitCellEvent.js';
-
-var OverCell = function (table, tableConfig) {
-    table
-        .on('pointermove', OnMove, this)
-        .on('pointerover', OnMove, this)
-        .on('pointerout', OnOut, this)  // pointer-up is included too
-}
-
-var OnMove = function (pointer, localX, localY, event) {
-    var table = this.childrenMap.child;
-    var cellIndex = table.pointToCellIndex(pointer.worldX, pointer.worldY);
-    if (cellIndex === table.input.lastOverCellIndex) {
-        return;
-    }
-
-    var preCellIndex = table.input.lastOverCellIndex;
-    table.input.lastOverCellIndex = cellIndex;
-    EmitCellEvent(this.eventEmitter, 'cell.out', table, preCellIndex, undefined, pointer, event);
-    EmitCellEvent(this.eventEmitter, 'cell.over', table, cellIndex, undefined, pointer, event);
-}
-
-var OnOut = function (pointer, event) {
-    var table = this.childrenMap.child;
-    var cellIndex = table.input.lastOverCellIndex;
-    table.input.lastOverCellIndex = undefined;
-    EmitCellEvent(this.eventEmitter, 'cell.out', table, cellIndex, undefined, pointer, event);
-}
-
-export default OverCell;

spaces/AlexZou/Deploy_Restoration/net/IntmdSequential.py

@@ -1,19 +0,0 @@
-import torch.nn as nn
-
-
-class IntermediateSequential(nn.Sequential):
-    def __init__(self, *args, return_intermediate=False):
-        super().__init__(*args)
-        self.return_intermediate = return_intermediate
-
-    def forward(self, input): 
-        if not self.return_intermediate:
-            return super().forward(input)
-
-        intermediate_outputs = {}
-        output = input
-        for name, module in self.named_children():
-            output = intermediate_outputs[name] = module(output)
-
-        return output, intermediate_outputs
-        

spaces/Alichuan/VITS-Umamusume-voice-synthesizer/modules.py

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

spaces/Alpaca233/SadTalker/src/audio2exp_models/audio2exp.py

@@ -1,41 +0,0 @@
-from tqdm import tqdm
-import torch
-from torch import nn
-
-
-class Audio2Exp(nn.Module):
-    def __init__(self, netG, cfg, device, prepare_training_loss=False):
-        super(Audio2Exp, self).__init__()
-        self.cfg = cfg
-        self.device = device
-        self.netG = netG.to(device)
-
-    def test(self, batch):
-
-        mel_input = batch['indiv_mels']                         # bs T 1 80 16
-        bs = mel_input.shape[0]
-        T = mel_input.shape[1]
-
-        exp_coeff_pred = []
-
-        for i in tqdm(range(0, T, 10),'audio2exp:'): # every 10 frames
-            
-            current_mel_input = mel_input[:,i:i+10]
-
-            #ref = batch['ref'][:, :, :64].repeat((1,current_mel_input.shape[1],1))           #bs T 64
-            ref = batch['ref'][:, :, :64][:, i:i+10]
-            ratio = batch['ratio_gt'][:, i:i+10]                               #bs T
-
-            audiox = current_mel_input.view(-1, 1, 80, 16)                  # bs*T 1 80 16
-
-            curr_exp_coeff_pred  = self.netG(audiox, ref, ratio)         # bs T 64 
-
-            exp_coeff_pred += [curr_exp_coeff_pred]
-
-        # BS x T x 64
-        results_dict = {
-            'exp_coeff_pred': torch.cat(exp_coeff_pred, axis=1)
-            }
-        return results_dict
-
-

spaces/Alpaca233/SadTalker/src/face3d/models/arcface_torch/docs/eval.md

@@ -1,31 +0,0 @@
-## Eval on ICCV2021-MFR
-
-coming soon.
-
-
-## Eval IJBC
-You can eval ijbc with pytorch or onnx.
-
-
-1. Eval IJBC With Onnx
-```shell
-CUDA_VISIBLE_DEVICES=0 python onnx_ijbc.py --model-root ms1mv3_arcface_r50 --image-path IJB_release/IJBC --result-dir ms1mv3_arcface_r50
-```
-
-2. Eval IJBC With Pytorch
-```shell
-CUDA_VISIBLE_DEVICES=0,1 python eval_ijbc.py \
---model-prefix ms1mv3_arcface_r50/backbone.pth \
---image-path IJB_release/IJBC \
---result-dir ms1mv3_arcface_r50 \
---batch-size 128 \
---job ms1mv3_arcface_r50 \
---target IJBC \
---network iresnet50
-```
-
-## Inference
-
-```shell
-python inference.py --weight ms1mv3_arcface_r50/backbone.pth --network r50
-```

spaces/Amjadd/BookGPT/README.md

@@ -1,13 +0,0 @@
----
-title: BookGPT
-emoji: 😻
-colorFrom: indigo
-colorTo: purple
-sdk: gradio
-sdk_version: 3.16.2
-app_file: app.py
-pinned: false
-duplicated_from: pritish/BookGPT
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/docs/source/en/api/models/unet3d-cond.md

@@ -1,13 +0,0 @@
-# UNet3DConditionModel
-
-The [UNet](https://huggingface.co/papers/1505.04597) model was originally introduced by Ronneberger et al for biomedical image segmentation, but it is also commonly used in 🤗 Diffusers because it outputs images that are the same size as the input. It is one of the most important components of a diffusion system because it facilitates the actual diffusion process. There are several variants of the UNet model in 🤗 Diffusers, depending on it's number of dimensions and whether it is a conditional model or not. This is a 3D UNet conditional model.
-
-The abstract from the paper is:
-
-*There is large consent that successful training of deep networks requires many thousand annotated training samples. In this paper, we present a network and training strategy that relies on the strong use of data augmentation to use the available annotated samples more efficiently. The architecture consists of a contracting path to capture context and a symmetric expanding path that enables precise localization. We show that such a network can be trained end-to-end from very few images and outperforms the prior best method (a sliding-window convolutional network) on the ISBI challenge for segmentation of neuronal structures in electron microscopic stacks. Using the same network trained on transmitted light microscopy images (phase contrast and DIC) we won the ISBI cell tracking challenge 2015 in these categories by a large margin. Moreover, the network is fast. Segmentation of a 512x512 image takes less than a second on a recent GPU. The full implementation (based on Caffe) and the trained networks are available at http://lmb.informatik.uni-freiburg.de/people/ronneber/u-net.*
-
-## UNet3DConditionModel
-[[autodoc]] UNet3DConditionModel
-
-## UNet3DConditionOutput
-[[autodoc]] models.unet_3d_condition.UNet3DConditionOutput

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/examples/community/one_step_unet.py

@@ -1,24 +0,0 @@
-#!/usr/bin/env python3
-import torch
-
-from diffusers import DiffusionPipeline
-
-
-class UnetSchedulerOneForwardPipeline(DiffusionPipeline):
-    def __init__(self, unet, scheduler):
-        super().__init__()
-
-        self.register_modules(unet=unet, scheduler=scheduler)
-
-    def __call__(self):
-        image = torch.randn(
-            (1, self.unet.config.in_channels, self.unet.config.sample_size, self.unet.config.sample_size),
-        )
-        timestep = 1
-
-        model_output = self.unet(image, timestep).sample
-        scheduler_output = self.scheduler.step(model_output, timestep, image).prev_sample
-
-        result = scheduler_output - scheduler_output + torch.ones_like(scheduler_output)
-
-        return result

spaces/Andy1621/uniformer_image_detection/configs/carafe/faster_rcnn_r50_fpn_carafe_1x_coco.py

@@ -1,50 +0,0 @@
-_base_ = '../faster_rcnn/faster_rcnn_r50_fpn_1x_coco.py'
-model = dict(
-    neck=dict(
-        type='FPN_CARAFE',
-        in_channels=[256, 512, 1024, 2048],
-        out_channels=256,
-        num_outs=5,
-        start_level=0,
-        end_level=-1,
-        norm_cfg=None,
-        act_cfg=None,
-        order=('conv', 'norm', 'act'),
-        upsample_cfg=dict(
-            type='carafe',
-            up_kernel=5,
-            up_group=1,
-            encoder_kernel=3,
-            encoder_dilation=1,
-            compressed_channels=64)))
-img_norm_cfg = dict(
-    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations', with_bbox=True),
-    dict(type='Resize', img_scale=(1333, 800), keep_ratio=True),
-    dict(type='RandomFlip', flip_ratio=0.5),
-    dict(type='Normalize', **img_norm_cfg),
-    dict(type='Pad', size_divisor=64),
-    dict(type='DefaultFormatBundle'),
-    dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']),
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=(1333, 800),
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='Pad', size_divisor=64),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img']),
-        ])
-]
-data = dict(
-    train=dict(pipeline=train_pipeline),
-    val=dict(pipeline=test_pipeline),
-    test=dict(pipeline=test_pipeline))

spaces/Andy1621/uniformer_image_detection/configs/pisa/pisa_ssd300_coco.py

@@ -1,8 +0,0 @@
-_base_ = '../ssd/ssd300_coco.py'
-
-model = dict(
-    bbox_head=dict(type='PISASSDHead'),
-    train_cfg=dict(isr=dict(k=2., bias=0.), carl=dict(k=1., bias=0.2)))
-
-optimizer_config = dict(
-    _delete_=True, grad_clip=dict(max_norm=35, norm_type=2))

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

@@ -1,22 +0,0 @@
-from ..builder import DETECTORS
-from .single_stage import SingleStageDetector
-
-
-@DETECTORS.register_module()
-class RepPointsDetector(SingleStageDetector):
-    """RepPoints: Point Set Representation for Object Detection.
-
-        This detector is the implementation of:
-        - RepPoints detector (https://arxiv.org/pdf/1904.11490)
-    """
-
-    def __init__(self,
-                 backbone,
-                 neck,
-                 bbox_head,
-                 train_cfg=None,
-                 test_cfg=None,
-                 pretrained=None):
-        super(RepPointsDetector,
-              self).__init__(backbone, neck, bbox_head, train_cfg, test_cfg,
-                             pretrained)

spaces/AnishKumbhar/ChatBot/text-generation-webui-main/modules/ui.py

@@ -1,251 +0,0 @@
-import copy
-from pathlib import Path
-
-import gradio as gr
-import torch
-import yaml
-
-from modules import shared
-
-
-with open(Path(__file__).resolve().parent / '../css/NotoSans/stylesheet.css', 'r') as f:
-    css = f.read()
-with open(Path(__file__).resolve().parent / '../css/main.css', 'r') as f:
-    css += f.read()
-with open(Path(__file__).resolve().parent / '../js/main.js', 'r') as f:
-    js = f.read()
-with open(Path(__file__).resolve().parent / '../js/save_files.js', 'r') as f:
-    save_files_js = f.read()
-with open(Path(__file__).resolve().parent / '../js/switch_tabs.js', 'r') as f:
-    switch_tabs_js = f.read()
-with open(Path(__file__).resolve().parent / '../js/show_controls.js', 'r') as f:
-    show_controls_js = f.read()
-
-refresh_symbol = '🔄'
-delete_symbol = '🗑️'
-save_symbol = '💾'
-
-theme = gr.themes.Default(
-    font=['Noto Sans', 'Helvetica', 'ui-sans-serif', 'system-ui', 'sans-serif'],
-    font_mono=['IBM Plex Mono', 'ui-monospace', 'Consolas', 'monospace'],
-).set(
-    border_color_primary='#c5c5d2',
-    button_large_padding='6px 12px',
-    body_text_color_subdued='#484848',
-    background_fill_secondary='#eaeaea'
-)
-
-if Path("notification.mp3").exists():
-    audio_notification_js = "document.querySelector('#audio_notification audio')?.play();"
-else:
-    audio_notification_js = ""
-
-
-def list_model_elements():
-    elements = [
-        'loader',
-        'filter_by_loader',
-        'cpu_memory',
-        'auto_devices',
-        'disk',
-        'cpu',
-        'bf16',
-        'load_in_8bit',
-        'trust_remote_code',
-        'use_fast',
-        'load_in_4bit',
-        'compute_dtype',
-        'quant_type',
-        'use_double_quant',
-        'wbits',
-        'groupsize',
-        'model_type',
-        'pre_layer',
-        'triton',
-        'desc_act',
-        'no_inject_fused_attention',
-        'no_inject_fused_mlp',
-        'no_use_cuda_fp16',
-        'disable_exllama',
-        'cfg_cache',
-        'threads',
-        'threads_batch',
-        'n_batch',
-        'no_mmap',
-        'mlock',
-        'mul_mat_q',
-        'n_gpu_layers',
-        'tensor_split',
-        'n_ctx',
-        'llama_cpp_seed',
-        'gpu_split',
-        'max_seq_len',
-        'compress_pos_emb',
-        'alpha_value',
-        'rope_freq_base',
-        'numa',
-    ]
-
-    for i in range(torch.cuda.device_count()):
-        elements.append(f'gpu_memory_{i}')
-
-    return elements
-
-
-def list_interface_input_elements():
-    elements = [
-        'max_new_tokens',
-        'auto_max_new_tokens',
-        'max_tokens_second',
-        'seed',
-        'temperature',
-        'top_p',
-        'top_k',
-        'typical_p',
-        'epsilon_cutoff',
-        'eta_cutoff',
-        'repetition_penalty',
-        'repetition_penalty_range',
-        'encoder_repetition_penalty',
-        'no_repeat_ngram_size',
-        'min_length',
-        'do_sample',
-        'penalty_alpha',
-        'num_beams',
-        'length_penalty',
-        'early_stopping',
-        'mirostat_mode',
-        'mirostat_tau',
-        'mirostat_eta',
-        'grammar_string',
-        'negative_prompt',
-        'guidance_scale',
-        'add_bos_token',
-        'ban_eos_token',
-        'custom_token_bans',
-        'truncation_length',
-        'custom_stopping_strings',
-        'skip_special_tokens',
-        'stream',
-        'tfs',
-        'top_a',
-    ]
-
-    # Chat elements
-    elements += [
-        'textbox',
-        'start_with',
-        'character_menu',
-        'history',
-        'name1',
-        'name2',
-        'greeting',
-        'context',
-        'mode',
-        'instruction_template',
-        'name1_instruct',
-        'name2_instruct',
-        'context_instruct',
-        'turn_template',
-        'chat_style',
-        'chat-instruct_command',
-    ]
-
-    # Notebook/default elements
-    elements += [
-        'textbox-notebook',
-        'textbox-default',
-        'output_textbox',
-        'prompt_menu-default',
-        'prompt_menu-notebook',
-    ]
-
-    # Model elements
-    elements += list_model_elements()
-
-    return elements
-
-
-def gather_interface_values(*args):
-    output = {}
-    for i, element in enumerate(list_interface_input_elements()):
-        output[element] = args[i]
-
-    if not shared.args.multi_user:
-        shared.persistent_interface_state = output
-
-    return output
-
-
-def apply_interface_values(state, use_persistent=False):
-    if use_persistent:
-        state = shared.persistent_interface_state
-
-    elements = list_interface_input_elements()
-    if len(state) == 0:
-        return [gr.update() for k in elements]  # Dummy, do nothing
-    else:
-        return [state[k] if k in state else gr.update() for k in elements]
-
-
-def save_settings(state, preset, instruction_template, extensions, show_controls):
-    output = copy.deepcopy(shared.settings)
-    exclude = ['name2', 'greeting', 'context', 'turn_template']
-    for k in state:
-        if k in shared.settings and k not in exclude:
-            output[k] = state[k]
-
-    output['preset'] = preset
-    output['prompt-default'] = state['prompt_menu-default']
-    output['prompt-notebook'] = state['prompt_menu-notebook']
-    output['character'] = state['character_menu']
-    output['instruction_template'] = instruction_template
-    output['default_extensions'] = extensions
-    output['seed'] = int(output['seed'])
-    output['show_controls'] = show_controls
-
-    return yaml.dump(output, sort_keys=False, width=float("inf"))
-
-
-class ToolButton(gr.Button, gr.components.IOComponent):
-    """
-    Small button with single emoji as text, fits inside gradio forms
-    Copied from https://github.com/AUTOMATIC1111/stable-diffusion-webui
-    """
-
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-
-    def get_block_name(self):
-        return "button"
-
-
-def create_refresh_button(refresh_component, refresh_method, refreshed_args, elem_class, interactive=True):
-    """
-    Copied from https://github.com/AUTOMATIC1111/stable-diffusion-webui
-    """
-    def refresh():
-        refresh_method()
-        args = refreshed_args() if callable(refreshed_args) else refreshed_args
-
-        for k, v in args.items():
-            setattr(refresh_component, k, v)
-
-        return gr.update(**(args or {}))
-
-    refresh_button = ToolButton(value=refresh_symbol, elem_classes=elem_class, interactive=interactive)
-    refresh_button.click(
-        fn=refresh,
-        inputs=[],
-        outputs=[refresh_component]
-    )
-
-    return refresh_button
-
-
-def create_delete_button(**kwargs):
-    return ToolButton(value=delete_symbol, **kwargs)
-
-
-def create_save_button(**kwargs):
-    return ToolButton(value=save_symbol, **kwargs)

spaces/Anonymous-sub/Rerender/ControlNet/annotator/uniformer/exp/upernet_global_small/test.sh

@@ -1,10 +0,0 @@
-#!/usr/bin/env bash
-
-work_path=$(dirname $0)
-PYTHONPATH="$(dirname $0)/../../":$PYTHONPATH \
-python -m torch.distributed.launch --nproc_per_node=8 \
-    tools/test.py ${work_path}/test_config_h32.py \
-    ${work_path}/ckpt/latest.pth \
-    --launcher pytorch \
-    --eval mIoU \
-    2>&1 | tee -a ${work_path}/log.txt

spaces/ArtGAN/Video-Diffusion-WebUI/video_diffusion/inpaint_zoom/utils/zoom_in_utils.py

@@ -1,75 +0,0 @@
-import os
-
-import cv2
-import numpy as np
-from PIL import Image
-
-os.environ["CUDA_VISIBLE_DEVICES"] = "0"
-
-
-def write_video(file_path, frames, fps, reversed=True):
-    """
-    Writes frames to an mp4 video file
-    :param file_path: Path to output video, must end with .mp4
-    :param frames: List of PIL.Image objects
-    :param fps: Desired frame rate
-    :param reversed: if order of images to be reversed (default = True)
-    """
-    if reversed == True:
-        frames.reverse()
-
-    w, h = frames[0].size
-    fourcc = cv2.VideoWriter_fourcc("m", "p", "4", "v")
-    # fourcc = cv2.VideoWriter_fourcc(*'avc1')
-    writer = cv2.VideoWriter(file_path, fourcc, fps, (w, h))
-
-    for frame in frames:
-        np_frame = np.array(frame.convert("RGB"))
-        cv_frame = cv2.cvtColor(np_frame, cv2.COLOR_RGB2BGR)
-        writer.write(cv_frame)
-
-    writer.release()
-
-
-def image_grid(imgs, rows, cols):
-    assert len(imgs) == rows * cols
-
-    w, h = imgs[0].size
-    grid = Image.new("RGB", size=(cols * w, rows * h))
-    grid_w, grid_h = grid.size
-
-    for i, img in enumerate(imgs):
-        grid.paste(img, box=(i % cols * w, i // cols * h))
-    return grid
-
-
-def shrink_and_paste_on_blank(current_image, mask_width):
-    """
-    Decreases size of current_image by mask_width pixels from each side,
-    then adds a mask_width width transparent frame,
-    so that the image the function returns is the same size as the input.
-    :param current_image: input image to transform
-    :param mask_width: width in pixels to shrink from each side
-    """
-
-    height = current_image.height
-    width = current_image.width
-
-    # shrink down by mask_width
-    prev_image = current_image.resize((height - 2 * mask_width, width - 2 * mask_width))
-    prev_image = prev_image.convert("RGBA")
-    prev_image = np.array(prev_image)
-
-    # create blank non-transparent image
-    blank_image = np.array(current_image.convert("RGBA")) * 0
-    blank_image[:, :, 3] = 1
-
-    # paste shrinked onto blank
-    blank_image[mask_width : height - mask_width, mask_width : width - mask_width, :] = prev_image
-    prev_image = Image.fromarray(blank_image)
-
-    return prev_image
-
-
-def dummy(images, **kwargs):
-    return images, False

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

@@ -1,165 +0,0 @@
-"""Generate and work with PEP 425 Compatibility Tags.
-"""
-
-import re
-from typing import List, Optional, Tuple
-
-from pip._vendor.packaging.tags import (
-    PythonVersion,
-    Tag,
-    compatible_tags,
-    cpython_tags,
-    generic_tags,
-    interpreter_name,
-    interpreter_version,
-    mac_platforms,
-)
-
-_osx_arch_pat = re.compile(r"(.+)_(\d+)_(\d+)_(.+)")
-
-
-def version_info_to_nodot(version_info: Tuple[int, ...]) -> str:
-    # Only use up to the first two numbers.
-    return "".join(map(str, version_info[:2]))
-
-
-def _mac_platforms(arch: str) -> List[str]:
-    match = _osx_arch_pat.match(arch)
-    if match:
-        name, major, minor, actual_arch = match.groups()
-        mac_version = (int(major), int(minor))
-        arches = [
-            # Since we have always only checked that the platform starts
-            # with "macosx", for backwards-compatibility we extract the
-            # actual prefix provided by the user in case they provided
-            # something like "macosxcustom_". It may be good to remove
-            # this as undocumented or deprecate it in the future.
-            "{}_{}".format(name, arch[len("macosx_") :])
-            for arch in mac_platforms(mac_version, actual_arch)
-        ]
-    else:
-        # arch pattern didn't match (?!)
-        arches = [arch]
-    return arches
-
-
-def _custom_manylinux_platforms(arch: str) -> List[str]:
-    arches = [arch]
-    arch_prefix, arch_sep, arch_suffix = arch.partition("_")
-    if arch_prefix == "manylinux2014":
-        # manylinux1/manylinux2010 wheels run on most manylinux2014 systems
-        # with the exception of wheels depending on ncurses. PEP 599 states
-        # manylinux1/manylinux2010 wheels should be considered
-        # manylinux2014 wheels:
-        # https://www.python.org/dev/peps/pep-0599/#backwards-compatibility-with-manylinux2010-wheels
-        if arch_suffix in {"i686", "x86_64"}:
-            arches.append("manylinux2010" + arch_sep + arch_suffix)
-            arches.append("manylinux1" + arch_sep + arch_suffix)
-    elif arch_prefix == "manylinux2010":
-        # manylinux1 wheels run on most manylinux2010 systems with the
-        # exception of wheels depending on ncurses. PEP 571 states
-        # manylinux1 wheels should be considered manylinux2010 wheels:
-        # https://www.python.org/dev/peps/pep-0571/#backwards-compatibility-with-manylinux1-wheels
-        arches.append("manylinux1" + arch_sep + arch_suffix)
-    return arches
-
-
-def _get_custom_platforms(arch: str) -> List[str]:
-    arch_prefix, arch_sep, arch_suffix = arch.partition("_")
-    if arch.startswith("macosx"):
-        arches = _mac_platforms(arch)
-    elif arch_prefix in ["manylinux2014", "manylinux2010"]:
-        arches = _custom_manylinux_platforms(arch)
-    else:
-        arches = [arch]
-    return arches
-
-
-def _expand_allowed_platforms(platforms: Optional[List[str]]) -> Optional[List[str]]:
-    if not platforms:
-        return None
-
-    seen = set()
-    result = []
-
-    for p in platforms:
-        if p in seen:
-            continue
-        additions = [c for c in _get_custom_platforms(p) if c not in seen]
-        seen.update(additions)
-        result.extend(additions)
-
-    return result
-
-
-def _get_python_version(version: str) -> PythonVersion:
-    if len(version) > 1:
-        return int(version[0]), int(version[1:])
-    else:
-        return (int(version[0]),)
-
-
-def _get_custom_interpreter(
-    implementation: Optional[str] = None, version: Optional[str] = None
-) -> str:
-    if implementation is None:
-        implementation = interpreter_name()
-    if version is None:
-        version = interpreter_version()
-    return f"{implementation}{version}"
-
-
-def get_supported(
-    version: Optional[str] = None,
-    platforms: Optional[List[str]] = None,
-    impl: Optional[str] = None,
-    abis: Optional[List[str]] = None,
-) -> List[Tag]:
-    """Return a list of supported tags for each version specified in
-    `versions`.
-
-    :param version: a string version, of the form "33" or "32",
-        or None. The version will be assumed to support our ABI.
-    :param platform: specify a list of platforms you want valid
-        tags for, or None. If None, use the local system platform.
-    :param impl: specify the exact implementation you want valid
-        tags for, or None. If None, use the local interpreter impl.
-    :param abis: specify a list of abis you want valid
-        tags for, or None. If None, use the local interpreter abi.
-    """
-    supported: List[Tag] = []
-
-    python_version: Optional[PythonVersion] = None
-    if version is not None:
-        python_version = _get_python_version(version)
-
-    interpreter = _get_custom_interpreter(impl, version)
-
-    platforms = _expand_allowed_platforms(platforms)
-
-    is_cpython = (impl or interpreter_name()) == "cp"
-    if is_cpython:
-        supported.extend(
-            cpython_tags(
-                python_version=python_version,
-                abis=abis,
-                platforms=platforms,
-            )
-        )
-    else:
-        supported.extend(
-            generic_tags(
-                interpreter=interpreter,
-                abis=abis,
-                platforms=platforms,
-            )
-        )
-    supported.extend(
-        compatible_tags(
-            python_version=python_version,
-            interpreter=interpreter,
-            platforms=platforms,
-        )
-    )
-
-    return supported

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

@@ -1,4 +0,0 @@
-from .more import *  # noqa
-from .recipes import *  # noqa
-
-__version__ = '8.8.0'

spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/.github/CONTRIBUTING.md

@@ -1,68 +0,0 @@
-# Contributing to detectron2
-
-## Issues
-We use GitHub issues to track public bugs and questions.
-Please make sure to follow one of the
-[issue templates](https://github.com/facebookresearch/detectron2/issues/new/choose)
-when reporting any issues.
-
-Facebook has a [bounty program](https://www.facebook.com/whitehat/) for the safe
-disclosure of security bugs. In those cases, please go through the process
-outlined on that page and do not file a public issue.
-
-## Pull Requests
-We actively welcome pull requests.
-
-However, if you're adding any significant features (e.g. > 50 lines), please
-make sure to discuss with maintainers about your motivation and proposals in an issue
-before sending a PR. This is to save your time so you don't spend time on a PR that we'll not accept.
-
-We do not always accept new features, and we take the following
-factors into consideration:
-
-1. Whether the same feature can be achieved without modifying detectron2.
-   Detectron2 is designed so that you can implement many extensions from the outside, e.g.
-   those in [projects](https://github.com/facebookresearch/detectron2/tree/master/projects).
-   * If some part of detectron2 is not extensible enough, you can also bring up a more general issue to
-     improve it. Such feature request may be useful to more users.
-2. Whether the feature is potentially useful to a large audience (e.g. an impactful detection paper, a popular dataset,
-   a significant speedup, a widely useful utility),
-   or only to a small portion of users (e.g., a less-known paper, an improvement not in the object
-   detection field, a trick that's not very popular in the community, code to handle a non-standard type of data)
-   * Adoption of additional models, datasets, new task are by default not added to detectron2 before they
-     receive significant popularity in the community.
-     We sometimes accept such features in `projects/`, or as a link in `projects/README.md`.
-3. Whether the proposed solution has a good design / interface. This can be discussed in the issue prior to PRs, or
-   in the form of a draft PR.
-4. Whether the proposed solution adds extra mental/practical overhead to users who don't
-   need such feature.
-5. Whether the proposed solution breaks existing APIs.
-
-To add a feature to an existing function/class `Func`, there are always two approaches:
-(1) add new arguments to `Func`; (2) write a new `Func_with_new_feature`.
-To meet the above criteria, we often prefer approach (2), because:
-
-1. It does not involve modifying or potentially breaking existing code.
-2. It does not add overhead to users who do not need the new feature.
-3. Adding new arguments to a function/class is not scalable w.r.t. all the possible new research ideas in the future.
-
-When sending a PR, please do:
-
-1. If a PR contains multiple orthogonal changes, split it to several PRs.
-2. If you've added code that should be tested, add tests.
-3. For PRs that need experiments (e.g. adding a new model or new methods),
-   you don't need to update model zoo, but do provide experiment results in the description of the PR.
-4. If APIs are changed, update the documentation.
-5. We use the [Google style docstrings](https://www.sphinx-doc.org/en/master/usage/extensions/napoleon.html) in python.
-6. Make sure your code lints with `./dev/linter.sh`.
-
-
-## Contributor License Agreement ("CLA")
-In order to accept your pull request, we need you to submit a CLA. You only need
-to do this once to work on any of Facebook's open source projects.
-
-Complete your CLA here: <https://code.facebook.com/cla>
-
-## License
-By contributing to detectron2, you agree that your contributions will be licensed
-under the LICENSE file in the root directory of this source tree.

spaces/Benson/text-generation/Examples/Car Simulator 9.md

@@ -1,113 +0,0 @@
-
-<h1>Simulador de coches 9: Una revisión del último juego de simulación de coches</h1>
-<p>Si usted es un fan de los juegos de simulación de coches, es posible que haya oído hablar de Car Simulator 9, la nueva entrega de la popular serie. Car Simulator 9 es un juego realista e inmersivo que te permite conducir varios coches en diferentes entornos y escenarios. Puede personalizar su coche, actualizar su garaje, desafíos completos, y más. En este artículo, revisaremos Car Simulator 9 y te daremos algunos consejos y trucos sobre cómo jugarlo. </p>
- <h2>¿Qué es el simulador de coche 9?</h2>
-<p>Car Simulator 9 es un juego de simulación de coches desarrollado por Red Dot Games y publicado por PlayWay S.A. Fue lanzado el 11 de agosto de 2021, para Windows, Mac, Linux, PlayStation 4, Xbox One y Nintendo Switch. Es el noveno juego de la serie Car Simulator, que comenzó en 2014 con Car Mechanic Simulator.</p>
-<h2>car simulator 9</h2><br /><p><b><b>DOWNLOAD</b> &gt;&gt;&gt; <a href="https://bltlly.com/2v6Mjj">https://bltlly.com/2v6Mjj</a></b></p><br /><br />
-<h3>Características y jugabilidad</h3>
-<p>Car Simulator 9 cuenta con más de 72 coches de varias marcas y modelos, cada uno con sus propias especificaciones y rendimiento. Usted puede elegir entre diferentes categorías de coches, tales como coches deportivos, coches del músculo, coches clásicos, coches eléctricos, y más. También puede modificar su automóvil con más de 4000 piezas únicas, como motores, neumáticos, frenos, suspensión, kits de carrocería, trabajos de pintura y más. </p>
-<p>El juego ofrece una experiencia de conducción realista con física precisa y sistema de daños. Puede conducir su coche en diferentes condiciones de carretera, como asfalto, tierra, nieve, lluvia, etc. También puede explorar diferentes lugares, como ciudades, carreteras, campo, montañas, desiertos, etc. El juego tiene un clima dinámico y díaciclo nocturno que afecta la visibilidad y el manejo de su automóvil. </p>
-
-<h3>Gráficos y sonido</h3>
-<p>Car Simulator 9 tiene gráficos impresionantes que crean un entorno realista e inmersivo. El juego tiene texturas de alta calidad, efectos de iluminación, sombras, reflejos, etc. El juego también tiene modelos detallados de coches y piezas que puedes inspeccionar de cerca. El juego también tiene efectos de sonido realistas que coinciden con los sonidos del motor, sonidos de neumáticos, sonidos de cuerno, etc. El juego también tiene una banda sonora que cuenta con varios géneros de música que se adaptan al estado de ánimo del juego. </p>
-<h3>Pros y contras</h3>
-<p>Car Simulator 9 es un juego divertido y adictivo que atraerá a los entusiastas del automóvil y a los jugadores casuales por igual. El juego tiene muchos profesionales, como:</p>
-<ul>
-<li> Tiene una gran variedad de coches y piezas que puede personalizar. </li>
-<li> Tiene una experiencia de conducción realista con la física precisa y el sistema de daños. </li>
-<li> Tiene diferentes ubicaciones y escenarios que puede explorar. </li>
-<li> Tiene varios modos de juego y objetivos que puedes jugar. </li>
-<li> Tiene impresionantes gráficos y efectos de sonido que crean un entorno realista. </li>
-</ul>
-<p>Sin embargo, el juego también tiene algunos contras, como:</p>
-<ul>
-<li> Puede ser repetitivo y tedioso a veces. </li>
-<li> Puede ser buggy y glitchy a veces. </li>
-<li>Puede ser caro comprar todos los DLCs.</li>
-<li> Puede ser difícil controlar el coche con algunos dispositivos o ajustes. </li>
-<li> Puede ser demasiado fácil o demasiado difícil para algunos jugadores. </li>
-</ul>
- <h2>Cómo jugar coche <h2>Cómo jugar simulador de coche 9?</h2>
-<p>Si usted está interesado en jugar Car Simulator 9, tendrá que cumplir con algunos requisitos y seguir algunos pasos. Aquí es cómo jugar Car Simulator 9:</p>
-<h3>Requisitos del sistema</h3>
-<p>Antes de comprar o descargar el juego, debe asegurarse de que su dispositivo pueda ejecutarlo sin problemas. Aquí están los requisitos mínimos y recomendados del sistema para Car Simulator 9:</p>
-<p></p>
-<tabla>
-<tr>
-<th>Mínimo</th>
-<th>Recomendado</th>
-</tr>
-<tr>
-<td>OS: Windows 7/8/10 (64 bits)</td>
-
-</tr>
-<tr>
-<td>Procesador: Intel Core i3 3.0 GHz o equivalente AMD</td>
-<td>Procesador: Intel Core i5 3.4 GHz o equivalente AMD</td>
-</tr>
-<tr>
-<td>Memoria: 4 GB de RAM</td>
-<td>Memoria: 8 GB de RAM</td>
-</tr>
-<tr>
-<td>Gráficos: Nvidia GeForce GTX 660 o AMD Radeon R9 270x</td>
-<td>Gráficos: Nvidia GeForce GTX 970 o AMD Radeon RX 580</td>
-</tr>
-<tr>
-<td>Almacenamiento: 20 GB de espacio disponible</td>
-<td>Almacenamiento: 20 GB de espacio disponible</td>
-</tr>
-<tr>
-<td>Tarjeta de sonido: DirectX compatible</td>
-<td>Tarjeta de sonido: DirectX compatible</td>
-</tr>
-</tabla>
- <h3>Descarga e instalación</h3>
-<p>Una vez que haya comprobado los requisitos del sistema, puede comprar o descargar el juego desde varias plataformas. El juego está disponible en Steam, GOG, Epic Games Store, PlayStation Store, Microsoft Store y Nintendo eShop. El precio del juego varía dependiendo de la plataforma y la región, pero por lo general es alrededor de $ 19.99 USD. También puede comprar los PLC por separado o como un paquete para contenido adicional y características. </p>
-<p>Para instalar el juego, debe seguir las instrucciones de la plataforma que está utilizando. Por ejemplo, si estás usando Steam, necesitas crear una cuenta, iniciar sesión, añadir el juego a tu biblioteca y hacer clic en instalar. El proceso de instalación puede tardar algún tiempo dependiendo de la velocidad de Internet y el rendimiento del dispositivo. </p>
- <h3>Controles y ajustes</h3>
-<p>Después de instalar el juego, puede iniciarlo y ajustar los controles y ajustes a su preferencia. Puede elegir entre diferentes dispositivos de entrada, como teclado, ratón, gamepad, volante, etc. También puede personalizar las combinaciones de teclas, sensibilidad, vibración, etc. También puede cambiar la configuración de gráficos, sonido, juego, etc. Puede elegir entre diferentes resoluciones, niveles de calidad, niveles de volumen, niveles de dificultad, etc.</p>
- <h2> Consejos y trucos para el simulador de coche 9</h2>
- <p>Para disfrutar más del juego y mejorar tus habilidades, aquí hay algunos consejos y trucos para Car Simulator 9:</p>
- <h3>Cómo personalizar su coche</h3>
-
- <p>Para comprar nuevas piezas o accesorios para su coche, debe ir a la tienda presionando S en el teclado o haciendo clic en el icono del carrito de compras en la pantalla. A continuación, puede navegar a través de diferentes artículos que están disponibles para la compra. También puedes filtrarlos por precio, marca, modelo, categoría, etc. Para comprar un artículo, necesitas tener suficiente dinero en tu cuenta. Puedes ganar dinero completando tareas o vendiendo autos. </p>
- <h3>Cómo ganar dinero y mejorar su garaje</h3>
- <p>Para comprar coches nuevos o piezas para su coche, necesita tener suficiente dinero en su cuenta. Hay varias maneras de ganar dinero en Car Simulator 9:</p>
- <ul>
- <li>Puedes trabajar como mecánico de coches y reparar coches para clientes en tu garaje. Usted recibirá los pedidos de los clientes que tienen problemas con sus coches. Tendrá que diagnosticar el problema utilizando herramientas como escáner o ruta de prueba. A continuación, tendrá que reemplazar o arreglar las piezas rotas mediante el uso de herramientas tales como llave o soldador. Recibirás puntos de dinero y reputación por cada pedido completado. </li>
- <li>Usted puede comprar y vender coches en la casa de subastas o el depósito de chatarra. Usted puede encontrar coches baratos que están dañados o viejos y comprarlos a un precio bajo a un precio bajo. A continuación, puede repararlos y restaurarlos en su garaje y venderlos a un precio más alto. También puede encontrar coches raros o únicos que valen más dinero. </li>
- <li>Usted puede poner a prueba sus habilidades de conducción en varios desafíos y logros que recompensa con puntos de dinero y reputación. Puedes acceder a los desafíos y logros pulsando C en tu teclado o haciendo clic en el icono del trofeo en la pantalla. A continuación, puede elegir entre diferentes tipos de desafíos, tales como velocidad, deriva, salto, carrera, etc. Tendrá que completar los objetivos dentro del límite de tiempo o el límite de puntuación. </li>
-
- </ul>
- <p>Para actualizar su garaje, necesita tener suficientes puntos de reputación en su cuenta. Los puntos de reputación se ganan completando tareas o ganando carreras. Puede acceder al menú de actualización del garaje pulsando G en el teclado o haciendo clic en el icono del martillo en la pantalla. A continuación, puede elegir entre diferentes actualizaciones, tales como herramientas, equipos, espacio, decoración, etc. Actualizar su garaje le permitirá trabajar más rápido, más fácil y mejor. </p>
- <h3>Cómo completar desafíos y logros</h3>
- <p>Uno de los aspectos divertidos de Car Simulator 9 es que puede completar varios desafíos y logros que ponen a prueba sus habilidades de conducción y conocimientos. Para acceder a los desafíos y logros, debe presionar C en el teclado o hacer clic en el icono del trofeo en la pantalla. A continuación, puede elegir entre diferentes tipos de desafíos, tales como velocidad, deriva, salto, carrera, etc. Tendrá que completar los objetivos dentro del límite de tiempo o el límite de puntuación. </p>
- <p>Algunos de los desafíos y logros son fáciles y directos, mientras que otros son difíciles y difíciles. Aquí hay algunos consejos y trucos para completar algunos de los desafíos y logros:</p>
- <ul>
- <li>Para los desafíos de velocidad, es necesario conducir lo más rápido posible sin chocar o salir de la carretera. Puede utilizar propulsores de nitro o turbocompresores para aumentar su velocidad. También puede utilizar el deslizamiento o el dibujo para reducir la resistencia del aire y ganar velocidad. También debes evitar el tráfico y los obstáculos que pueden ralentizarte. </li>
- <li>Para los desafíos de deriva, es necesario deslizar su coche de lado sin perder el control o girar hacia fuera. Puede utilizar el freno de mano o el embrague para iniciar una deriva. También puede utilizar el acelerador o la dirección para mantener o ajustar una deriva. También debe usar la dirección contraria o el bloqueo opuesto para equilibrar su automóvil y evitar el sobreviraje o subviraje. </li>
-
- <li>Para los desafíos de carrera, necesitas terminar primero entre otros competidores sin chocar o ser descalificado. Puede utilizar atajos o rutas alternativas para obtener una ventaja sobre otros corredores. También puede utilizar propulsores de nitro o turbocompresores para superar a otros corredores. También debe utilizar técnicas de frenado o curvas para navegar curvas y giros sin perder velocidad. </li>
- </ul>
- <h2>Conclusión</h2>
-<h3>Resumen de la revisión</h3>
-<p>En conclusión, Car Simulator 9 es un juego de simulación de coches realista e inmersivo que te permite conducir varios coches en diferentes entornos y escenarios. Puede personalizar su coche, actualizar su garaje, desafíos completos, y más. El juego tiene muchos pros, como una gran variedad de coches y piezas, una experiencia de conducción realista, diferentes ubicaciones y escenarios, varios modos de juego y objetivos, gráficos impresionantes y efectos de sonido, etc. El juego también tiene algunos contras, como ser repetitivo y tedioso a veces, tener errores y problemas a veces, ser caro para comprar todos los DLC, ser difícil de controlar con algunos dispositivos o configuraciones, ser demasiado fácil o demasiado difícil para algunos jugadores, etc.</p>
-<h3>Clasificación y recomendación</h3>
-<p>Le damos a Car Simulator 9 una calificación de 4 de 5 estrellas basada en nuestra revisión. Recomendamos Car Simulator 9 a cualquiera que ame los juegos de simulación de coches o los coches en general. El juego es adecuado para jugadores de todas las edades y niveles de habilidad. El juego es divertido y adictivo y te mantendrá entretenido durante horas. </p>
- <h2>Preguntas frecuentes</h2>
-<p>Aquí hay algunas preguntas frecuentes sobre Car Simulator 9:</p>
-<ul>
-<li><b>Q: ¿Cuánto cuesta Car Simulator 9? </b></li>
-<li <li>A: Car Simulator 9 cuesta alrededor de $ 19.99 USD en varias plataformas, como Steam, GOG, Epic Games Store, PlayStation Store, Microsoft Store y Nintendo eShop. El precio puede variar dependiendo de la plataforma y la región. También puede comprar los DLC por separado o como un paquete para contenido adicional y características. </li>
-
-<li>A: Car Simulator 9 no tiene una longitud fija o una historia lineal. El juego es abierto y estilo sandbox, lo que significa que puedes jugar el tiempo que quieras y de la manera que quieras. Puedes crear tus propias metas y objetivos, o seguir los proporcionados por el juego. El juego tiene mucho contenido y valor de repetición, así que nunca te quedarás sin cosas que hacer. </li>
-<li><b>Q: ¿Es multijugador Car Simulator 9? </b></li>
-<li>A: Sí, Car Simulator 9 tiene un modo multijugador que le permite jugar con otros jugadores en línea o fuera de línea. Puede unirse o crear un vestíbulo e invitar a otros jugadores a unirse. También puede elegir la ubicación, el coche y las reglas de la carrera. Puede competir con otros jugadores en carreras o carreras de arrastre, o cooperar con ellos en la reparación de coches o completar desafíos. </li>
-<li><b>Q: ¿Es realista Car Simulator 9? </b></li>
-<li>A: Sí, Car Simulator 9 es realista en términos de gráficos, sonido, física y sistema de daños. El juego tiene texturas de alta calidad, efectos de iluminación, sombras, reflejos, etc. El juego también tiene modelos detallados de coches y piezas que puedes inspeccionar de cerca. El juego también tiene efectos de sonido realistas que coinciden con los sonidos del motor, sonidos de neumáticos, sonidos de cuerno, etc. El juego también tiene la física precisa y sistema de daños que afectan a la visibilidad y el manejo de su coche. </li>
-<li><b>Q: ¿Es divertido Car Simulator 9? </b></li>
-<li>A: Sí, Car Simulator 9 es divertido y adictivo para cualquier persona que ama los juegos de simulación de coches o coches en general. El juego tiene muchas características y opciones de juego que te mantendrán entretenido durante horas. Puede personalizar su coche, actualizar su garaje, desafíos completos, y más. El juego también tiene impresionantes gráficos y efectos de sonido que crean un entorno realista. </li>
-</ul></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Descargar Carx Street 0.9.1.md

@@ -1,77 +0,0 @@
-<br />
-<h1>Cómo descargar CarX Street 0.9.1 y convertirse en una leyenda de carreras callejeras</h1>
-<p>Si eres un fan de los juegos de carreras de coches, es posible que hayas oído hablar de CarX Street, el último juego de los creadores de CarX Drift Racing 2. CarX Street es un juego de carreras de mundo abierto realista y dinámico que te permite abrazar la libertad de ser un corredor de la calle en la ciudad de Sunset City. Puede elegir entre una variedad de coches, personalizarlos y competir en carreteras y calles de la ciudad, así como la deriva en las pistas de alta velocidad. </p>
-<p>CarX Street se encuentra actualmente en pruebas beta abiertas, lo que significa que puede descargarlo de forma gratuita y disfrutar de sus características antes de que se lance oficialmente. La última versión del juego es 0.9.1, que se actualizó el 7 de junio de 2023, y trae algunas mejoras y correcciones de errores al juego. </p>
-<h2>descargar carx street 0.9.1</h2><br /><p><b><b>Download Zip</b> &#9889; <a href="https://bltlly.com/2v6M1K">https://bltlly.com/2v6M1K</a></b></p><br /><br />
-<p>En este artículo, le diremos qué es CarX Street 0.9.1, por qué debe jugarlo y cómo descargarlo en su dispositivo Android o iOS. También te daremos algunos consejos y trucos para ayudarte a convertirte en una leyenda de las carreras callejeras en CarX Street 0.9.1. </p>
- <h2>¿Qué es CarX Street 0.9.1? </h2>
-<p>CarX Street 0.9.1 es la última versión de la prueba beta abierta de CarX Street, un juego de carreras de mundo abierto realista y dinámico desarrollado por CarX Technologies, LLC. El juego está disponible para dispositivos Android e iOS, y requiere una conexión a Internet para jugar. </p>
-<p>CarX Street 0.9.1 le ofrece una variedad de características que lo convierten en uno de los mejores juegos de carreras de coches en dispositivos móviles. Estos son algunos de ellos:</p>
- <h3>Características de CarX Street 0.9.1</h3>
-<ul>
-<li>Un mapa de mundo abierto grande y detallado que cubre carreteras, calles de ciudades, zonas industriales, suburbios y más. </li>
-<li>Una lista diversa de autos que incluye autos deportivos, autos musculares, supercoches, autos clásicos y más. </li>
-<li>Un sistema de ajuste de coche detallado que le permite intercambiar piezas, actualizar su motor, transmisión, cuerpo, suspensión, neumáticos y más. </li>
-
-<li>Un motor de física realista que simula el comportamiento del automóvil basado en la tecnología CarX.</li>
-<li>Un dinámico ciclo día/noche que cambia la iluminación y la atmósfera del juego. </li>
-<li>Un modo de carrera que te desafía a unirte a clubes, derrotar jefes y convertirte en la leyenda de Sunset City.</li>
-<li>Una variedad de modos de carrera que incluyen carreras de velocidad, carreras de deriva, carreras de arrastre, pruebas de tiempo y más. </li>
-<li>Un modo multijugador online que te permite competir con otros jugadores de todo el mundo. </li>
-</ul>
- <h3>Cómo descargar CarX Street 0.9.1 en dispositivos Android e iOS</h3>
-<p>Descargar CarX Street 0.9.1 es fácil y gratuito. Todo lo que necesitas hacer es seguir estos pasos:</p>
- <ol>
-<li>Ir a la Google Play Store o la App Store en su dispositivo. </li>
-<li>Buscar CarX Street o utilizar este enlace: [CarX Street - Aplicaciones en Google Play]( 1 ). </li>
-<li>Toque en el botón Instalar y espere a que termine la descarga. </li>
-<li>Iniciar el juego y disfrutar! </li>
-</ol <h2>Por qué deberías jugar CarX Street 0.9.1</h2>
-<p>CarX Street 0.9.1 no es solo otro juego de carreras de coches. Es un juego que te da la oportunidad de experimentar la emoción y la emoción de ser un corredor de la calle en un mundo abierto realista y dinámico. Aquí hay algunas razones por las que deberías jugar CarX Street 0.9.1:</p>
- <h3>Carreras realistas y dinámicas de mundo abierto</h3>
-<p>Una de las principales atracciones de CarX Street 0.9.1 es su mapa de mundo abierto grande y detallado que cubre carreteras, calles de la ciudad, zonas industriales, suburbios y más. Puede explorar el mapa libremente y encontrar diferentes lugares, lugares de interés y secretos. También puedes encontrar diferentes eventos, desafíos y carreras que pondrán a prueba tus habilidades y te recompensarán con dinero y reputación. </p>
-<p></p>
-
- <h3>Coches personalizables y sintonizables</h3>
-<p>Otra razón para jugar CarX Street 0.9.1 es su diversa lista de autos que incluye autos deportivos, autos musculares, supercoches, autos clásicos y más. Puedes elegir entre más de 50 coches que tienen diferentes características, como velocidad, aceleración, manejo, deriva y más. También puede personalizar sus coches con diferentes partes, colores, pegatinas y calcomanías. </p>
-<p>Pero la personalización no es suficiente. También necesitas afinar tus coches para que funcionen mejor en la carretera. CarX Street 0.9.1 le ofrece un sistema de ajuste detallado del automóvil que le permite intercambiar piezas, actualizar su motor, transmisión, cuerpo, suspensión, neumáticos y más. También puede ajustar la configuración de su automóvil, como el ángulo de curvatura, el ángulo del dedo del pie, la presión de los neumáticos, la relación de transmisión y más. El ajuste de su coche lo hará más rápido, más sensible, y más estable en el camino. </p>
- <h3>Modo de carrera desafiante y gratificante</h3>
-<p>La última razón para jugar CarX Street 0.9.1 es su desafiante y gratificante modo de carrera que te reta a unirte a clubes, derrotar jefes y convertirte en la leyenda de Sunset City. El modo carrera consiste en más de 100 misiones que te llevarán a diferentes lugares y modos de carrera en el juego. También conocerás diferentes personajes que te ayudarán o te obstaculizarán en tu viaje. </p>
-<p>El modo carrera también le presentará el sistema de clubes en el juego. Los clubes son grupos de corredores que tienen sus propios territorios, reglas y reputaciones en Sunset City. Puede unirse a uno de los clubes o crear su propio club y reclutar a otros jugadores. También puedes retar a otros clubes por sus territorios y recursos. El sistema de clubes añade un elemento social y competitivo al juego que lo hace más divertido y atractivo. </p>
- <h2>Consejos y trucos para jugar CarX Street 0.9.1</h2>
-
- <h3>Elige el coche adecuado para cada modo de carrera</h3>
-<p>CarX Street 0.9.1 le ofrece una variedad de modos de carrera que incluyen carreras de velocidad, carreras de deriva, carreras de arrastre, pruebas de tiempo y más. Cada modo de carrera requiere un tipo diferente de coche que se adapte a sus condiciones y objetivos. Por ejemplo, las carreras de velocidad requieren coches rápidos y ágiles que pueden acelerar rápidamente y maniobrar fácilmente en la carretera. Las carreras de deriva requieren coches potentes y estables que puedan deslizarse suavemente en las esquinas y mantener una alta velocidad. </p>
-<p>Por lo tanto, es necesario elegir el coche adecuado para cada modo de carrera en función de sus características y rendimiento. Puedes consultar las estadísticas de cada coche en el menú del garaje antes de seleccionarlo para una carrera. También puede comparar diferentes coches tocando en ellos en el menú del garaje. Elegir el coche adecuado para cada modo de carrera te dará una ventaja sobre tus oponentes y aumentará tus posibilidades de ganar. </p>
- <h3>Actualizar las piezas de su coche y el motor</h3>
-<p>A medida que avanzas en el juego, ganarás dinero y reputación que puedes usar para comprar autos nuevos o mejorar los existentes. La mejora de las piezas y el motor de su automóvil mejorará su rendimiento en la carretera al aumentar su velocidad, aceleración, manejo, deriva y más. Puede actualizar las piezas de su automóvil y el motor en el menú del garaje tocando el botón de actualización junto a cada pieza o motor. También puede ver el efecto de cada actualización en las estadísticas de su coche mirando las barras y los números en la pantalla. </p>
-<p>La actualización de las piezas y el motor de su automóvil también desbloqueará nuevas opciones de ajuste que le permitirán ajustar la configuración de su automóvil, como el ángulo de curvatura, el ángulo del dedo del pie, la presión de los neumáticos, la relación de engranajes y más. El ajuste de su coche hará que sea más adecuado para diferentes modos de carrera y condiciones. Puede sintonizar su coche en el menú del garaje pulsando en el botón de sintonía junto a cada parte o motor. También puede ver el efecto de cada opción de ajuste en las estadísticas de su coche mirando las barras y los números en la pantalla. </p>
-
-<p>CarX Street 0.9.1 es un juego que requiere que domines dos habilidades esenciales: deriva y velocidad. La deriva es el arte de deslizar su coche de lado en las esquinas y mantener la alta velocidad. La velocidad es la capacidad de acelerar rápidamente y alcanzar alta velocidad en las carreteras rectas. Ambas habilidades son importantes para diferentes modos de carrera y situaciones en el juego. </p>
-<p>Para dominar la habilidad de deriva, necesitas practicar usando los controles de freno, acelerador y dirección para iniciar, mantener y salir de una deriva. También necesitas aprender a controlar el ángulo, la velocidad y la dirección de tu coche mientras vas a la deriva. Puedes practicar la deriva en el modo de deriva o en cualquier pista que tenga curvas y giros. También puede ver tutoriales y consejos sobre cómo desplazarse en el menú del juego o en línea. </p>
-<p>Para dominar la habilidad de velocidad, necesitas practicar usando el nitro, el control de lanzamiento y los controles de cambio para aumentar tu aceleración y velocidad. También debe aprender a evitar obstáculos, tráfico y colisiones mientras acelera. Puede practicar el exceso de velocidad en el modo de velocidad o en cualquier pista que tenga carreteras y autopistas rectas. También puedes ver tutoriales y consejos sobre cómo acelerar en el menú del juego o en línea. </p>
- <h3>Únete a clubes y compite con otros jugadores</h3>
-<p>CarX Street 0.9.1 no es solo un juego para un jugador. También es un juego multijugador que te permite unirte a clubes y competir con otros jugadores de todo el mundo. Los clubes son grupos de corredores que tienen sus propios territorios, reglas y reputaciones en Sunset City. Puedes unirte a uno de los clubes o crear tu propio club y reclutar otros jugadores. </p>
-<p>Unirse a un club le dará acceso a eventos exclusivos, desafíos, recompensas y salas de chat. También puede cooperar con los miembros de su club para desafiar a otros clubes por sus territorios y recursos. Competir con otros clubes aumentará el rango y la reputación de tu club en Sunset City.</p>
-
- <h2>Conclusión</h2>
-<p>CarX Street 0.9.1 es un juego de carreras de mundo abierto realista y dinámico que te permite abrazar la libertad de ser un corredor de la calle en Sunset City. Usted puede elegir entre una variedad de coches, personalizarlos, sintonizarlos, y la raza en las carreteras y calles de la ciudad, así como la deriva en las pistas de alta velocidad. </p>
-<p>CarX Street 0.9.1 está actualmente en pruebas beta abiertas, lo que significa que puede descargarlo de forma gratuita y disfrutar de sus características antes de que se lance oficialmente. La última versión del juego es 0.9.1, que se actualizó el 7 de junio de 2023, y trae algunas mejoras y correcciones de errores al juego. </p>
-<p>En este artículo, te hemos dicho lo que es CarX Street 0.9.1, por qué deberías jugarlo, cómo descargarlo en tu dispositivo Android o iOS, y algunos consejos y trucos para ayudarte a convertirte en una leyenda de las carreras callejeras en CarX Street 0.9.1. </p>
-<p>Esperamos que haya encontrado este artículo útil e informativo. Si tiene alguna pregunta o comentario sobre CarX Street 0.9.1 o este artículo, no dude en dejar un comentario a continuación o contáctenos a través de nuestro sitio web o canales de redes sociales. </p>
-<p>¡Gracias por leer este artículo y feliz carrera! </p>
- <h2>Preguntas frecuentes</h2>
-<ul>
-<li><b>Q: ¿Cuánto espacio requiere CarX Street 0.9.1 en mi dispositivo? </b></li>
-<li>A: CarX Street 0.9.1 requiere aproximadamente 2 GB de espacio libre en su dispositivo. </li>
-<li><b>Q: ¿Cómo puedo obtener más dinero y reputación en CarX Street 0.9.1? </b></li>
-<li>A: Puedes obtener más dinero y reputación completando misiones, eventos, desafíos y carreras en el juego. También puede obtener más dinero y reputación uniéndose a clubes y compitiendo con otros jugadores. </li>
-<li><b>Q: ¿Cómo puedo cambiar la vista de la cámara en CarX Street 0.9.1? </b></li>
-<li>A: Puede cambiar la vista de la cámara en CarX Street 0.9.1 tocando el icono de la cámara en la esquina superior derecha de la pantalla. Puede elegir entre diferentes vistas de cámara, como primera persona, tercera persona, capucha, parachoques y más. </li>
-
-<li>A: Puede compartir sus capturas de pantalla y vídeos de CarX Street 0.9.1 tocando el icono de compartir en la esquina superior izquierda de la pantalla. Puedes elegir entre diferentes opciones, como guardar en tu dispositivo, subir a YouTube o compartir en plataformas de redes sociales. </li>
-<li><b>Q: ¿Cómo puedo contactar a los desarrolladores de CarX Street 0.9.1? </b></li>
-<li>A: Puede ponerse en contacto con los desarrolladores de CarX Street 0.9.1 visitando su sitio web o siguiendo sus canales de redes sociales. También puede enviarles un correo electrónico a [email protected] o dejar un comentario en la Google Play Store o en la App Store.</li>
-</ul></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Descargar Gratis De Taxi Driver Juego.md

@@ -1,60 +0,0 @@
-<br />
-<h1>Cómo descargar el gambito final gratis</h1>
-<p>Si eres un fan del misterio, el suspense y el romance, quizás te interese leer The Final Gambit de Jennifer Lynn Barnes. Este es el tercer y último libro de la exitosa serie The Inheritance Games, que sigue a Avery Grambs, un adolescente que hereda miles de millones de un benefactor misterioso, y los hermanos Hawthorne, que están decididos a ganar su corazón y descubrir los secretos detrás de la voluntad de su abuelo. Pero, ¿cómo se puede descargar The Final Gambit gratis sin violar la ley o arriesgar su dispositivo? En este artículo, te mostraremos algunas de las mejores maneras de encontrar y disfrutar de esta emocionante novela gratis. </p>
- <h2>¿Qué es el gambito final? </h2>
-<h3>Un breve resumen del libro</h3>
-<p>The Final Gambit es la tercera y última entrega de la trilogía de The Inheritance Games de Jennifer Lynn Barnes. Fue publicado el 30 de agosto de 2022 por Little, Brown Books for Young Readers. El libro retoma donde quedó el segundo libro, The Hawthorne Legacy, con Avery Grambs y los hermanos Hawthorne enfrentando un nuevo desafío: un visitante misterioso que afirma estar relacionado con su difunto abuelo y que podría cambiarlo todo. A medida que el reloj marca el momento en que Avery se convertirá en el adolescente más rico del planeta, ella y los Hawthorne deben resolver un último rompecabezas y jugar un juego peligroso contra un enemigo desconocido y poderoso. Secretos sobre secretos. Acertijos sobre acertijos. En este juego, hay corazones y vidas en juego, y no hay nada más Hawthorne que ganar. </p>
-<h2>descargar gratis de taxi driver juego</h2><br /><p><b><b>Download Zip</b> &#127383; <a href="https://bltlly.com/2v6LrN">https://bltlly.com/2v6LrN</a></b></p><br /><br />
- <h3>Por qué deberías leerlo</h3>
-
- <h2>Dónde encontrar el gambito final libre</h2>
-<h3>Amazon Kindle</h3>
-<p>Una de las formas más fáciles de descargar The Final Gambit gratis es usar Amazon Kindle. Si tiene un dispositivo o aplicación Kindle, puede acceder a miles de libros de forma gratuita con Kindle Unlimited, un servicio de suscripción que cuesta $ 9.99 por mes. También puede obtener una prueba gratuita durante 30 días si es un usuario nuevo. Con Kindle Unlimited, puedes leer The Final Gambit y otros libros de Jennifer Lynn Barnes sin pagar nada. También puede tomar prestados libros de su biblioteca local utilizando aplicaciones OverDrive o Libby, que son compatibles con los dispositivos y aplicaciones de Kindle. Para saber más sobre Amazon Kindle, visite . </p>
- <h3>Libros de Google</h3>
-<p>Otra opción para descargar The Final Gambit gratis es utilizar Google Books. Google Books es un servicio que te permite buscar, previsualizar y leer millones de libros en línea. Algunos libros están disponibles en texto completo de forma gratuita, mientras que otros solo están disponibles en fragmentos o vistas previas. También puedes comprar o alquilar libros de Google Play Books, que está integrado con Google Books. Para leer The Final Gambit gratis en Google Books, puedes buscarlo usando palabras clave o navegar por categorías. También puedes usar filtros para reducir tus resultados por idioma, fecha, formato, etc. Para acceder a Google Books, visita . </p>
- <h3>Scribd</h3>
-<p>Scribd es otro servicio que te permite descargar The Final Gambit gratis. Scribd es una biblioteca digital que ofrece acceso ilimitado a libros, audiolibros, revistas, podcasts y más por una tarifa mensual de $9.99. También puede obtener una prueba gratuita durante 30 días si es un usuario nuevo. Con Scribd, puedes leer The Final Gambit y otros libros de Jennifer Lynn Barnes en cualquier dispositivo, online o offline. También puede compartir sus pensamientos y opiniones con otros lectores, y descubrir nuevos libros basados en sus preferencias. Para unirse a Scribd, vaya a . </p>
- <h3>Yumpu</h3>
-
- <h3>AudioBB</h3>
-<p>Si prefieres escuchar The Final Gambit en lugar de leerlo, puedes descargarlo gratis desde AudioBB. AudioBB es un sitio web que ofrece audiolibros gratuitos en varios géneros e idiomas. Puedes encontrar The Final Gambit y otros libros de Jennifer Lynn Barnes en AudioBB buscándolos o navegando por categorías. También puede solicitar audiolibros que no están disponibles en el sitio. Para descargar The Final Gambit de AudioBB, vaya a . </p>
- <h2>Cómo evitar estafas y virus al descargar el gambito final libre</h2>
-<h3>Comprobar la fuente y comentarios</h3>
-<p>Antes de descargar The Final Gambit desde cualquier sitio web, asegúrese de que la fuente es confiable y confiable. Puede hacer esto comprobando el nombre de dominio, el diseño, el contenido y las revisiones del sitio web. Evite los sitios web que tienen nombres de dominio sospechosos o mal escritos, diseño pobre o desactualizado, contenido irrelevante o de baja calidad, y críticas negativas o falsas. También puedes usar herramientas como Whois o Scamadvisor para comprobar la reputación y legitimidad del sitio web. </p>
- <h3>Utilice un software VPN y antivirus</h3>
-<p>Otra forma de protegerse de estafas y virus al descargar The Final Gambit es usar una VPN y un software antivirus. Una VPN (red privada virtual) es un servicio que encripta su tráfico de Internet y oculta su dirección IP, lo que lo hace anónimo y seguro en línea. Una VPN puede ayudarlo a evitar las restricciones geográficas, acceder a sitios web bloqueados y evitar los ataques de malware y phishing. Un software antivirus es un programa que detecta y elimina virus, gusanos, troyanos, spyware, adware, ransomware y otro software malicioso desde su dispositivo. Un software antivirus puede ayudarlo a escanear y limpiar su dispositivo, evitar el acceso no autorizado y bloquear las descargas dañinas. Puede encontrar muchas VPN gratuitas y de pago y software antivirus en línea. </p>
- <h3>Cuidado con los enlaces falsos y pop-ups</h3>
-
- <h2>Conclusión</h2>
-<p>The Final Gambit es un libro increíble que no debes perderte si te gusta el misterio, el suspense y el romance. Es el tercer y último libro de la serie The Inheritance Games de Jennifer Lynn Barnes, que sigue a Avery Grambs y los hermanos Hawthorne mientras desentrañan los secretos detrás de la voluntad de su abuelo y se enfrentan a una nueva amenaza. Puede descargar The Final Gambit gratis desde varias fuentes en línea, como Amazon Kindle, Google Books, Scribd, Yumpu y AudioBB. Sin embargo, también debe tener cuidado con las estafas y los virus al descargar el libro, y usar precauciones como verificar la fuente y las revisiones, usar una VPN y un software antivirus, y tener cuidado con los enlaces falsos y las ventanas emergentes. Esperamos que este artículo te haya ayudado a encontrar y descargar The Final Gambit gratis y disfrutar de este libro increíble. ¡Feliz lectura! </p>
- <h2>Preguntas frecuentes</h2>
-<p>Aquí están algunas de las preguntas más frecuentes sobre la descarga de The Final Gambit free:</p>
-<p></p>
-<tabla>
-<tr>
-<th>Pregunta</th>
-<th>Respuesta</th>
-</tr>
-<tr>
-<td>¿Es The Final Gambit el último libro de la serie? </td>
-<td>Sí, The Final Gambit es el tercer y último libro de la trilogía de The Inheritance Games de Jennifer Lynn Barnes. Concluye la historia de Avery Grambs y los hermanos Hawthorne. </td>
-</tr>
-<tr>
-<td>¿Puedo descargar The Final Gambit gratis legalmente? </td>
-<td>Sí, puede descargar The Final Gambit gratis legalmente desde varias fuentes en línea, como Amazon Kindle, Google Books, Scribd, Yumpu y AudioBB. Sin embargo, también debe tener cuidado con las estafas y los virus al descargar el libro, y usar precauciones como verificar la fuente y las revisiones, usar una VPN y un software antivirus, y tener cuidado con los enlaces falsos y las ventanas emergentes. </td>
-</tr>
-<tr>
-<td>¿Puedo leer The Final Gambit sin leer los libros anteriores? </td>
-
-</tr>
-<tr>
-<td>¿Cuáles son algunos otros libros similares a The Final Gambit? </td>
-<td>Si te gusta The Final Gambit, también te pueden gustar otros libros de Jennifer Lynn Barnes, como The Naturals, The Fixer y Deadly Little Scandals. Puede que también te gusten otros libros del género de misterio y romance, como One of Us is Lying de Karen M. McManus, Truly Devious de Maureen Johnson, y A Good Girl’s Guide to Murder de Holly Jackson.</td>
-</tr>
-<tr>
-<td>¿Cómo puedo contactar a Jennifer Lynn Barnes? </td>
-<td>Puede ponerse en contacto con Jennifer Lynn Barnes a través de su sitio web , su Twitter , o su Instagram . También puede enviar su correo de fans a su agente en: Jennifer Lynn Barnes c/o Elizabeth Harding Curtis Brown Ltd. 10 Astor Place New York NY 10003 USA</td>
-</tr>
-</tabla></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Big-Web/MMSD/env/Lib/site-packages/setuptools/_vendor/importlib_resources/_legacy.py

@@ -1,121 +0,0 @@
-import functools
-import os
-import pathlib
-import types
-import warnings
-
-from typing import Union, Iterable, ContextManager, BinaryIO, TextIO, Any
-
-from . import _common
-
-Package = Union[types.ModuleType, str]
-Resource = str
-
-
-def deprecated(func):
-    @functools.wraps(func)
-    def wrapper(*args, **kwargs):
-        warnings.warn(
-            f"{func.__name__} is deprecated. Use files() instead. "
-            "Refer to https://importlib-resources.readthedocs.io"
-            "/en/latest/using.html#migrating-from-legacy for migration advice.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        return func(*args, **kwargs)
-
-    return wrapper
-
-
-def normalize_path(path):
-    # type: (Any) -> str
-    """Normalize a path by ensuring it is a string.
-
-    If the resulting string contains path separators, an exception is raised.
-    """
-    str_path = str(path)
-    parent, file_name = os.path.split(str_path)
-    if parent:
-        raise ValueError(f'{path!r} must be only a file name')
-    return file_name
-
-
-@deprecated
-def open_binary(package: Package, resource: Resource) -> BinaryIO:
-    """Return a file-like object opened for binary reading of the resource."""
-    return (_common.files(package) / normalize_path(resource)).open('rb')
-
-
-@deprecated
-def read_binary(package: Package, resource: Resource) -> bytes:
-    """Return the binary contents of the resource."""
-    return (_common.files(package) / normalize_path(resource)).read_bytes()
-
-
-@deprecated
-def open_text(
-    package: Package,
-    resource: Resource,
-    encoding: str = 'utf-8',
-    errors: str = 'strict',
-) -> TextIO:
-    """Return a file-like object opened for text reading of the resource."""
-    return (_common.files(package) / normalize_path(resource)).open(
-        'r', encoding=encoding, errors=errors
-    )
-
-
-@deprecated
-def read_text(
-    package: Package,
-    resource: Resource,
-    encoding: str = 'utf-8',
-    errors: str = 'strict',
-) -> str:
-    """Return the decoded string of the resource.
-
-    The decoding-related arguments have the same semantics as those of
-    bytes.decode().
-    """
-    with open_text(package, resource, encoding, errors) as fp:
-        return fp.read()
-
-
-@deprecated
-def contents(package: Package) -> Iterable[str]:
-    """Return an iterable of entries in `package`.
-
-    Note that not all entries are resources.  Specifically, directories are
-    not considered resources.  Use `is_resource()` on each entry returned here
-    to check if it is a resource or not.
-    """
-    return [path.name for path in _common.files(package).iterdir()]
-
-
-@deprecated
-def is_resource(package: Package, name: str) -> bool:
-    """True if `name` is a resource inside `package`.
-
-    Directories are *not* resources.
-    """
-    resource = normalize_path(name)
-    return any(
-        traversable.name == resource and traversable.is_file()
-        for traversable in _common.files(package).iterdir()
-    )
-
-
-@deprecated
-def path(
-    package: Package,
-    resource: Resource,
-) -> ContextManager[pathlib.Path]:
-    """A context manager providing a file path object to the resource.
-
-    If the resource does not already exist on its own on the file system,
-    a temporary file will be created. If the file was created, the file
-    will be deleted upon exiting the context manager (no exception is
-    raised if the file was deleted prior to the context manager
-    exiting).
-    """
-    return _common.as_file(_common.files(package) / normalize_path(resource))

spaces/Big-Web/MMSD/env/Lib/site-packages/setuptools/_vendor/packaging/version.py

@@ -1,504 +0,0 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-
-import collections
-import itertools
-import re
-import warnings
-from typing import Callable, Iterator, List, Optional, SupportsInt, Tuple, Union
-
-from ._structures import Infinity, InfinityType, NegativeInfinity, NegativeInfinityType
-
-__all__ = ["parse", "Version", "LegacyVersion", "InvalidVersion", "VERSION_PATTERN"]
-
-InfiniteTypes = Union[InfinityType, NegativeInfinityType]
-PrePostDevType = Union[InfiniteTypes, Tuple[str, int]]
-SubLocalType = Union[InfiniteTypes, int, str]
-LocalType = Union[
-    NegativeInfinityType,
-    Tuple[
-        Union[
-            SubLocalType,
-            Tuple[SubLocalType, str],
-            Tuple[NegativeInfinityType, SubLocalType],
-        ],
-        ...,
-    ],
-]
-CmpKey = Tuple[
-    int, Tuple[int, ...], PrePostDevType, PrePostDevType, PrePostDevType, LocalType
-]
-LegacyCmpKey = Tuple[int, Tuple[str, ...]]
-VersionComparisonMethod = Callable[
-    [Union[CmpKey, LegacyCmpKey], Union[CmpKey, LegacyCmpKey]], bool
-]
-
-_Version = collections.namedtuple(
-    "_Version", ["epoch", "release", "dev", "pre", "post", "local"]
-)
-
-
-def parse(version: str) -> Union["LegacyVersion", "Version"]:
-    """
-    Parse the given version string and return either a :class:`Version` object
-    or a :class:`LegacyVersion` object depending on if the given version is
-    a valid PEP 440 version or a legacy version.
-    """
-    try:
-        return Version(version)
-    except InvalidVersion:
-        return LegacyVersion(version)
-
-
-class InvalidVersion(ValueError):
-    """
-    An invalid version was found, users should refer to PEP 440.
-    """
-
-
-class _BaseVersion:
-    _key: Union[CmpKey, LegacyCmpKey]
-
-    def __hash__(self) -> int:
-        return hash(self._key)
-
-    # Please keep the duplicated `isinstance` check
-    # in the six comparisons hereunder
-    # unless you find a way to avoid adding overhead function calls.
-    def __lt__(self, other: "_BaseVersion") -> bool:
-        if not isinstance(other, _BaseVersion):
-            return NotImplemented
-
-        return self._key < other._key
-
-    def __le__(self, other: "_BaseVersion") -> bool:
-        if not isinstance(other, _BaseVersion):
-            return NotImplemented
-
-        return self._key <= other._key
-
-    def __eq__(self, other: object) -> bool:
-        if not isinstance(other, _BaseVersion):
-            return NotImplemented
-
-        return self._key == other._key
-
-    def __ge__(self, other: "_BaseVersion") -> bool:
-        if not isinstance(other, _BaseVersion):
-            return NotImplemented
-
-        return self._key >= other._key
-
-    def __gt__(self, other: "_BaseVersion") -> bool:
-        if not isinstance(other, _BaseVersion):
-            return NotImplemented
-
-        return self._key > other._key
-
-    def __ne__(self, other: object) -> bool:
-        if not isinstance(other, _BaseVersion):
-            return NotImplemented
-
-        return self._key != other._key
-
-
-class LegacyVersion(_BaseVersion):
-    def __init__(self, version: str) -> None:
-        self._version = str(version)
-        self._key = _legacy_cmpkey(self._version)
-
-        warnings.warn(
-            "Creating a LegacyVersion has been deprecated and will be "
-            "removed in the next major release",
-            DeprecationWarning,
-        )
-
-    def __str__(self) -> str:
-        return self._version
-
-    def __repr__(self) -> str:
-        return f"<LegacyVersion('{self}')>"
-
-    @property
-    def public(self) -> str:
-        return self._version
-
-    @property
-    def base_version(self) -> str:
-        return self._version
-
-    @property
-    def epoch(self) -> int:
-        return -1
-
-    @property
-    def release(self) -> None:
-        return None
-
-    @property
-    def pre(self) -> None:
-        return None
-
-    @property
-    def post(self) -> None:
-        return None
-
-    @property
-    def dev(self) -> None:
-        return None
-
-    @property
-    def local(self) -> None:
-        return None
-
-    @property
-    def is_prerelease(self) -> bool:
-        return False
-
-    @property
-    def is_postrelease(self) -> bool:
-        return False
-
-    @property
-    def is_devrelease(self) -> bool:
-        return False
-
-
-_legacy_version_component_re = re.compile(r"(\d+ | [a-z]+ | \.| -)", re.VERBOSE)
-
-_legacy_version_replacement_map = {
-    "pre": "c",
-    "preview": "c",
-    "-": "final-",
-    "rc": "c",
-    "dev": "@",
-}
-
-
-def _parse_version_parts(s: str) -> Iterator[str]:
-    for part in _legacy_version_component_re.split(s):
-        part = _legacy_version_replacement_map.get(part, part)
-
-        if not part or part == ".":
-            continue
-
-        if part[:1] in "0123456789":
-            # pad for numeric comparison
-            yield part.zfill(8)
-        else:
-            yield "*" + part
-
-    # ensure that alpha/beta/candidate are before final
-    yield "*final"
-
-
-def _legacy_cmpkey(version: str) -> LegacyCmpKey:
-
-    # We hardcode an epoch of -1 here. A PEP 440 version can only have a epoch
-    # greater than or equal to 0. This will effectively put the LegacyVersion,
-    # which uses the defacto standard originally implemented by setuptools,
-    # as before all PEP 440 versions.
-    epoch = -1
-
-    # This scheme is taken from pkg_resources.parse_version setuptools prior to
-    # it's adoption of the packaging library.
-    parts: List[str] = []
-    for part in _parse_version_parts(version.lower()):
-        if part.startswith("*"):
-            # remove "-" before a prerelease tag
-            if part < "*final":
-                while parts and parts[-1] == "*final-":
-                    parts.pop()
-
-            # remove trailing zeros from each series of numeric parts
-            while parts and parts[-1] == "00000000":
-                parts.pop()
-
-        parts.append(part)
-
-    return epoch, tuple(parts)
-
-
-# Deliberately not anchored to the start and end of the string, to make it
-# easier for 3rd party code to reuse
-VERSION_PATTERN = r"""
-    v?
-    (?:
-        (?:(?P<epoch>[0-9]+)!)?                           # epoch
-        (?P<release>[0-9]+(?:\.[0-9]+)*)                  # release segment
-        (?P<pre>                                          # pre-release
-            [-_\.]?
-            (?P<pre_l>(a|b|c|rc|alpha|beta|pre|preview))
-            [-_\.]?
-            (?P<pre_n>[0-9]+)?
-        )?
-        (?P<post>                                         # post release
-            (?:-(?P<post_n1>[0-9]+))
-            |
-            (?:
-                [-_\.]?
-                (?P<post_l>post|rev|r)
-                [-_\.]?
-                (?P<post_n2>[0-9]+)?
-            )
-        )?
-        (?P<dev>                                          # dev release
-            [-_\.]?
-            (?P<dev_l>dev)
-            [-_\.]?
-            (?P<dev_n>[0-9]+)?
-        )?
-    )
-    (?:\+(?P<local>[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?       # local version
-"""
-
-
-class Version(_BaseVersion):
-
-    _regex = re.compile(r"^\s*" + VERSION_PATTERN + r"\s*$", re.VERBOSE | re.IGNORECASE)
-
-    def __init__(self, version: str) -> None:
-
-        # Validate the version and parse it into pieces
-        match = self._regex.search(version)
-        if not match:
-            raise InvalidVersion(f"Invalid version: '{version}'")
-
-        # Store the parsed out pieces of the version
-        self._version = _Version(
-            epoch=int(match.group("epoch")) if match.group("epoch") else 0,
-            release=tuple(int(i) for i in match.group("release").split(".")),
-            pre=_parse_letter_version(match.group("pre_l"), match.group("pre_n")),
-            post=_parse_letter_version(
-                match.group("post_l"), match.group("post_n1") or match.group("post_n2")
-            ),
-            dev=_parse_letter_version(match.group("dev_l"), match.group("dev_n")),
-            local=_parse_local_version(match.group("local")),
-        )
-
-        # Generate a key which will be used for sorting
-        self._key = _cmpkey(
-            self._version.epoch,
-            self._version.release,
-            self._version.pre,
-            self._version.post,
-            self._version.dev,
-            self._version.local,
-        )
-
-    def __repr__(self) -> str:
-        return f"<Version('{self}')>"
-
-    def __str__(self) -> str:
-        parts = []
-
-        # Epoch
-        if self.epoch != 0:
-            parts.append(f"{self.epoch}!")
-
-        # Release segment
-        parts.append(".".join(str(x) for x in self.release))
-
-        # Pre-release
-        if self.pre is not None:
-            parts.append("".join(str(x) for x in self.pre))
-
-        # Post-release
-        if self.post is not None:
-            parts.append(f".post{self.post}")
-
-        # Development release
-        if self.dev is not None:
-            parts.append(f".dev{self.dev}")
-
-        # Local version segment
-        if self.local is not None:
-            parts.append(f"+{self.local}")
-
-        return "".join(parts)
-
-    @property
-    def epoch(self) -> int:
-        _epoch: int = self._version.epoch
-        return _epoch
-
-    @property
-    def release(self) -> Tuple[int, ...]:
-        _release: Tuple[int, ...] = self._version.release
-        return _release
-
-    @property
-    def pre(self) -> Optional[Tuple[str, int]]:
-        _pre: Optional[Tuple[str, int]] = self._version.pre
-        return _pre
-
-    @property
-    def post(self) -> Optional[int]:
-        return self._version.post[1] if self._version.post else None
-
-    @property
-    def dev(self) -> Optional[int]:
-        return self._version.dev[1] if self._version.dev else None
-
-    @property
-    def local(self) -> Optional[str]:
-        if self._version.local:
-            return ".".join(str(x) for x in self._version.local)
-        else:
-            return None
-
-    @property
-    def public(self) -> str:
-        return str(self).split("+", 1)[0]
-
-    @property
-    def base_version(self) -> str:
-        parts = []
-
-        # Epoch
-        if self.epoch != 0:
-            parts.append(f"{self.epoch}!")
-
-        # Release segment
-        parts.append(".".join(str(x) for x in self.release))
-
-        return "".join(parts)
-
-    @property
-    def is_prerelease(self) -> bool:
-        return self.dev is not None or self.pre is not None
-
-    @property
-    def is_postrelease(self) -> bool:
-        return self.post is not None
-
-    @property
-    def is_devrelease(self) -> bool:
-        return self.dev is not None
-
-    @property
-    def major(self) -> int:
-        return self.release[0] if len(self.release) >= 1 else 0
-
-    @property
-    def minor(self) -> int:
-        return self.release[1] if len(self.release) >= 2 else 0
-
-    @property
-    def micro(self) -> int:
-        return self.release[2] if len(self.release) >= 3 else 0
-
-
-def _parse_letter_version(
-    letter: str, number: Union[str, bytes, SupportsInt]
-) -> Optional[Tuple[str, int]]:
-
-    if letter:
-        # We consider there to be an implicit 0 in a pre-release if there is
-        # not a numeral associated with it.
-        if number is None:
-            number = 0
-
-        # We normalize any letters to their lower case form
-        letter = letter.lower()
-
-        # We consider some words to be alternate spellings of other words and
-        # in those cases we want to normalize the spellings to our preferred
-        # spelling.
-        if letter == "alpha":
-            letter = "a"
-        elif letter == "beta":
-            letter = "b"
-        elif letter in ["c", "pre", "preview"]:
-            letter = "rc"
-        elif letter in ["rev", "r"]:
-            letter = "post"
-
-        return letter, int(number)
-    if not letter and number:
-        # We assume if we are given a number, but we are not given a letter
-        # then this is using the implicit post release syntax (e.g. 1.0-1)
-        letter = "post"
-
-        return letter, int(number)
-
-    return None
-
-
-_local_version_separators = re.compile(r"[\._-]")
-
-
-def _parse_local_version(local: str) -> Optional[LocalType]:
-    """
-    Takes a string like abc.1.twelve and turns it into ("abc", 1, "twelve").
-    """
-    if local is not None:
-        return tuple(
-            part.lower() if not part.isdigit() else int(part)
-            for part in _local_version_separators.split(local)
-        )
-    return None
-
-
-def _cmpkey(
-    epoch: int,
-    release: Tuple[int, ...],
-    pre: Optional[Tuple[str, int]],
-    post: Optional[Tuple[str, int]],
-    dev: Optional[Tuple[str, int]],
-    local: Optional[Tuple[SubLocalType]],
-) -> CmpKey:
-
-    # When we compare a release version, we want to compare it with all of the
-    # trailing zeros removed. So we'll use a reverse the list, drop all the now
-    # leading zeros until we come to something non zero, then take the rest
-    # re-reverse it back into the correct order and make it a tuple and use
-    # that for our sorting key.
-    _release = tuple(
-        reversed(list(itertools.dropwhile(lambda x: x == 0, reversed(release))))
-    )
-
-    # We need to "trick" the sorting algorithm to put 1.0.dev0 before 1.0a0.
-    # We'll do this by abusing the pre segment, but we _only_ want to do this
-    # if there is not a pre or a post segment. If we have one of those then
-    # the normal sorting rules will handle this case correctly.
-    if pre is None and post is None and dev is not None:
-        _pre: PrePostDevType = NegativeInfinity
-    # Versions without a pre-release (except as noted above) should sort after
-    # those with one.
-    elif pre is None:
-        _pre = Infinity
-    else:
-        _pre = pre
-
-    # Versions without a post segment should sort before those with one.
-    if post is None:
-        _post: PrePostDevType = NegativeInfinity
-
-    else:
-        _post = post
-
-    # Versions without a development segment should sort after those with one.
-    if dev is None:
-        _dev: PrePostDevType = Infinity
-
-    else:
-        _dev = dev
-
-    if local is None:
-        # Versions without a local segment should sort before those with one.
-        _local: LocalType = NegativeInfinity
-    else:
-        # Versions with a local segment need that segment parsed to implement
-        # the sorting rules in PEP440.
-        # - Alpha numeric segments sort before numeric segments
-        # - Alpha numeric segments sort lexicographically
-        # - Numeric segments sort numerically
-        # - Shorter versions sort before longer versions when the prefixes
-        #   match exactly
-        _local = tuple(
-            (i, "") if isinstance(i, int) else (NegativeInfinity, i) for i in local
-        )
-
-    return epoch, _release, _pre, _post, _dev, _local

spaces/Big-Web/MMSD/env/Lib/site-packages/setuptools/archive_util.py

@@ -1,213 +0,0 @@
-"""Utilities for extracting common archive formats"""
-
-import zipfile
-import tarfile
-import os
-import shutil
-import posixpath
-import contextlib
-from distutils.errors import DistutilsError
-
-from ._path import ensure_directory
-
-__all__ = [
-    "unpack_archive", "unpack_zipfile", "unpack_tarfile", "default_filter",
-    "UnrecognizedFormat", "extraction_drivers", "unpack_directory",
-]
-
-
-class UnrecognizedFormat(DistutilsError):
-    """Couldn't recognize the archive type"""
-
-
-def default_filter(src, dst):
-    """The default progress/filter callback; returns True for all files"""
-    return dst
-
-
-def unpack_archive(
-        filename, extract_dir, progress_filter=default_filter,
-        drivers=None):
-    """Unpack `filename` to `extract_dir`, or raise ``UnrecognizedFormat``
-
-    `progress_filter` is a function taking two arguments: a source path
-    internal to the archive ('/'-separated), and a filesystem path where it
-    will be extracted.  The callback must return the desired extract path
-    (which may be the same as the one passed in), or else ``None`` to skip
-    that file or directory.  The callback can thus be used to report on the
-    progress of the extraction, as well as to filter the items extracted or
-    alter their extraction paths.
-
-    `drivers`, if supplied, must be a non-empty sequence of functions with the
-    same signature as this function (minus the `drivers` argument), that raise
-    ``UnrecognizedFormat`` if they do not support extracting the designated
-    archive type.  The `drivers` are tried in sequence until one is found that
-    does not raise an error, or until all are exhausted (in which case
-    ``UnrecognizedFormat`` is raised).  If you do not supply a sequence of
-    drivers, the module's ``extraction_drivers`` constant will be used, which
-    means that ``unpack_zipfile`` and ``unpack_tarfile`` will be tried, in that
-    order.
-    """
-    for driver in drivers or extraction_drivers:
-        try:
-            driver(filename, extract_dir, progress_filter)
-        except UnrecognizedFormat:
-            continue
-        else:
-            return
-    else:
-        raise UnrecognizedFormat(
-            "Not a recognized archive type: %s" % filename
-        )
-
-
-def unpack_directory(filename, extract_dir, progress_filter=default_filter):
-    """"Unpack" a directory, using the same interface as for archives
-
-    Raises ``UnrecognizedFormat`` if `filename` is not a directory
-    """
-    if not os.path.isdir(filename):
-        raise UnrecognizedFormat("%s is not a directory" % filename)
-
-    paths = {
-        filename: ('', extract_dir),
-    }
-    for base, dirs, files in os.walk(filename):
-        src, dst = paths[base]
-        for d in dirs:
-            paths[os.path.join(base, d)] = src + d + '/', os.path.join(dst, d)
-        for f in files:
-            target = os.path.join(dst, f)
-            target = progress_filter(src + f, target)
-            if not target:
-                # skip non-files
-                continue
-            ensure_directory(target)
-            f = os.path.join(base, f)
-            shutil.copyfile(f, target)
-            shutil.copystat(f, target)
-
-
-def unpack_zipfile(filename, extract_dir, progress_filter=default_filter):
-    """Unpack zip `filename` to `extract_dir`
-
-    Raises ``UnrecognizedFormat`` if `filename` is not a zipfile (as determined
-    by ``zipfile.is_zipfile()``).  See ``unpack_archive()`` for an explanation
-    of the `progress_filter` argument.
-    """
-
-    if not zipfile.is_zipfile(filename):
-        raise UnrecognizedFormat("%s is not a zip file" % (filename,))
-
-    with zipfile.ZipFile(filename) as z:
-        _unpack_zipfile_obj(z, extract_dir, progress_filter)
-
-
-def _unpack_zipfile_obj(zipfile_obj, extract_dir, progress_filter=default_filter):
-    """Internal/private API used by other parts of setuptools.
-    Similar to ``unpack_zipfile``, but receives an already opened :obj:`zipfile.ZipFile`
-    object instead of a filename.
-    """
-    for info in zipfile_obj.infolist():
-        name = info.filename
-
-        # don't extract absolute paths or ones with .. in them
-        if name.startswith('/') or '..' in name.split('/'):
-            continue
-
-        target = os.path.join(extract_dir, *name.split('/'))
-        target = progress_filter(name, target)
-        if not target:
-            continue
-        if name.endswith('/'):
-            # directory
-            ensure_directory(target)
-        else:
-            # file
-            ensure_directory(target)
-            data = zipfile_obj.read(info.filename)
-            with open(target, 'wb') as f:
-                f.write(data)
-        unix_attributes = info.external_attr >> 16
-        if unix_attributes:
-            os.chmod(target, unix_attributes)
-
-
-def _resolve_tar_file_or_dir(tar_obj, tar_member_obj):
-    """Resolve any links and extract link targets as normal files."""
-    while tar_member_obj is not None and (
-            tar_member_obj.islnk() or tar_member_obj.issym()):
-        linkpath = tar_member_obj.linkname
-        if tar_member_obj.issym():
-            base = posixpath.dirname(tar_member_obj.name)
-            linkpath = posixpath.join(base, linkpath)
-            linkpath = posixpath.normpath(linkpath)
-        tar_member_obj = tar_obj._getmember(linkpath)
-
-    is_file_or_dir = (
-        tar_member_obj is not None and
-        (tar_member_obj.isfile() or tar_member_obj.isdir())
-    )
-    if is_file_or_dir:
-        return tar_member_obj
-
-    raise LookupError('Got unknown file type')
-
-
-def _iter_open_tar(tar_obj, extract_dir, progress_filter):
-    """Emit member-destination pairs from a tar archive."""
-    # don't do any chowning!
-    tar_obj.chown = lambda *args: None
-
-    with contextlib.closing(tar_obj):
-        for member in tar_obj:
-            name = member.name
-            # don't extract absolute paths or ones with .. in them
-            if name.startswith('/') or '..' in name.split('/'):
-                continue
-
-            prelim_dst = os.path.join(extract_dir, *name.split('/'))
-
-            try:
-                member = _resolve_tar_file_or_dir(tar_obj, member)
-            except LookupError:
-                continue
-
-            final_dst = progress_filter(name, prelim_dst)
-            if not final_dst:
-                continue
-
-            if final_dst.endswith(os.sep):
-                final_dst = final_dst[:-1]
-
-            yield member, final_dst
-
-
-def unpack_tarfile(filename, extract_dir, progress_filter=default_filter):
-    """Unpack tar/tar.gz/tar.bz2 `filename` to `extract_dir`
-
-    Raises ``UnrecognizedFormat`` if `filename` is not a tarfile (as determined
-    by ``tarfile.open()``).  See ``unpack_archive()`` for an explanation
-    of the `progress_filter` argument.
-    """
-    try:
-        tarobj = tarfile.open(filename)
-    except tarfile.TarError as e:
-        raise UnrecognizedFormat(
-            "%s is not a compressed or uncompressed tar file" % (filename,)
-        ) from e
-
-    for member, final_dst in _iter_open_tar(
-            tarobj, extract_dir, progress_filter,
-    ):
-        try:
-            # XXX Ugh
-            tarobj._extract_member(member, final_dst)
-        except tarfile.ExtractError:
-            # chown/chmod/mkfifo/mknode/makedev failed
-            pass
-
-    return True
-
-
-extraction_drivers = unpack_directory, unpack_zipfile, unpack_tarfile

spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/docs/tutorials/data_loading.md

@@ -1,77 +0,0 @@
-
-# Use Custom Dataloaders
-
-## How the Existing Dataloader Works
-
-Detectron2 contains a builtin data loading pipeline.
-It's good to understand how it works, in case you need to write a custom one.
-
-Detectron2 provides two functions
-[build_detection_{train,test}_loader](../modules/data.html#detectron2.data.build_detection_train_loader)
-that create a default data loader from a given config.
-Here is how `build_detection_{train,test}_loader` work:
-
-1. It takes the name of a registered dataset (e.g., "coco_2017_train") and loads a `list[dict]` representing the dataset items
-   in a lightweight, canonical format. These dataset items are not yet ready to be used by the model (e.g., images are
-   not loaded into memory, random augmentations have not been applied, etc.).
-   Details about the dataset format and dataset registration can be found in
-   [datasets](datasets.html).
-2. Each dict in this list is mapped by a function ("mapper"):
-   * Users can customize this mapping function by specifying the "mapper" argument in
-        `build_detection_{train,test}_loader`. The default mapper is [DatasetMapper]( ../modules/data.html#detectron2.data.DatasetMapper).
-   * The output format of such function can be arbitrary, as long as it is accepted by the consumer of this data loader (usually the model).
-     The outputs of the default mapper, after batching, follow the default model input format documented in
-     [Use Models](https://detectron2.readthedocs.io/tutorials/models.html#model-input-format).
-   * The role of the mapper is to transform the lightweight, canonical representation of a dataset item into a format
-     that is ready for the model to consume (including, e.g., read images, perform random data augmentation and convert to torch Tensors).
-     If you would like to perform custom transformations to data, you often want a custom mapper.
-3. The outputs of the mapper are batched (simply into a list).
-4. This batched data is the output of the data loader. Typically, it's also the input of
-   `model.forward()`.
-
-
-## Write a Custom Dataloader
-
-Using a different "mapper" with `build_detection_{train,test}_loader(mapper=)` works for most use cases
-of custom data loading.
-For example, if you want to resize all images to a fixed size for Mask R-CNN training, write this:
-
-```python
-from detectron2.data import build_detection_train_loader
-from detectron2.data import transforms as T
-from detectron2.data import detection_utils as utils
-
-def mapper(dataset_dict):
-	# Implement a mapper, similar to the default DatasetMapper, but with your own customizations
-	dataset_dict = copy.deepcopy(dataset_dict)  # it will be modified by code below
-	image = utils.read_image(dataset_dict["file_name"], format="BGR")
-	image, transforms = T.apply_transform_gens([T.Resize((800, 800))], image)
-	dataset_dict["image"] = torch.as_tensor(image.transpose(2, 0, 1).astype("float32"))
-
-	annos = [
-		utils.transform_instance_annotations(obj, transforms, image.shape[:2])
-		for obj in dataset_dict.pop("annotations")
-		if obj.get("iscrowd", 0) == 0
-	]
-	instances = utils.annotations_to_instances(annos, image.shape[:2])
-	dataset_dict["instances"] = utils.filter_empty_instances(instances)
-	return dataset_dict
-
-data_loader = build_detection_train_loader(cfg, mapper=mapper)
-# use this dataloader instead of the default
-```
-Refer to [API documentation of detectron2.data](../modules/data.html) for details.
-
-If you want to change not only the mapper (e.g., to write different sampling or batching logic),
-you can write your own data loader. The data loader is simply a
-python iterator that produces [the format](models.html) your model accepts.
-You can implement it using any tools you like.
-
-## Use a Custom Dataloader
-
-If you use [DefaultTrainer](../modules/engine.html#detectron2.engine.defaults.DefaultTrainer),
-you can overwrite its `build_{train,test}_loader` method to use your own dataloader.
-See the [densepose dataloader](../../projects/DensePose/train_net.py)
-for an example.
-
-If you write your own training loop, you can plug in your data loader easily.

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

@@ -1,104 +0,0 @@
-/*
- *  Copyright 2008-2013 NVIDIA Corporation
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-#pragma once
-
-#include <thrust/system/cuda/detail/guarded_cuda_runtime_api.h>
-
-#include <thrust/detail/config.h>
-#include <thrust/detail/raw_pointer_cast.h>
-#include <thrust/detail/raw_reference_cast.h>
-#include <thrust/detail/seq.h>
-#include <thrust/system/cuda/config.h>
-#ifdef THRUST_CACHING_DEVICE_MALLOC
-#include <cub/util_allocator.cuh>
-#endif
-#include <thrust/system/cuda/detail/util.h>
-#include <thrust/system/detail/bad_alloc.h>
-#include <thrust/detail/malloc_and_free.h>
-
-namespace thrust
-{
-namespace cuda_cub {
-
-#ifdef THRUST_CACHING_DEVICE_MALLOC
-#define __CUB_CACHING_MALLOC
-#ifndef __CUDA_ARCH__
-inline cub::CachingDeviceAllocator &get_allocator()
-{
-  static cub::CachingDeviceAllocator g_allocator(true);
-  return g_allocator;
-}
-#endif
-#endif
-
-
-// note that malloc returns a raw pointer to avoid
-// depending on the heavyweight thrust/system/cuda/memory.h header
-template<typename DerivedPolicy>
-__host__ __device__
-void *malloc(execution_policy<DerivedPolicy> &, std::size_t n)
-{
-  void *result = 0;
-
-  if (THRUST_IS_HOST_CODE) {
-    #if THRUST_INCLUDE_HOST_CODE
-      #ifdef __CUB_CACHING_MALLOC
-        cub::CachingDeviceAllocator &alloc = get_allocator();
-        cudaError_t status = alloc.DeviceAllocate(&result, n);
-      #else
-        cudaError_t status = cudaMalloc(&result, n);
-      #endif
-
-      if(status != cudaSuccess)
-      {
-        cudaGetLastError(); // Clear global CUDA error state.
-        throw thrust::system::detail::bad_alloc(thrust::cuda_category().message(status).c_str());
-      }
-    #endif
-  } else {
-    #if THRUST_INCLUDE_DEVICE_CODE
-      result = thrust::raw_pointer_cast(thrust::malloc(thrust::seq, n));
-    #endif
-  }
-
-  return result;
-} // end malloc()
-
-
-template<typename DerivedPolicy, typename Pointer>
-__host__ __device__
-void free(execution_policy<DerivedPolicy> &, Pointer ptr)
-{
-  if (THRUST_IS_HOST_CODE) {
-    #if THRUST_INCLUDE_HOST_CODE
-      #ifdef __CUB_CACHING_MALLOC
-        cub::CachingDeviceAllocator &alloc = get_allocator();
-        cudaError_t status = alloc.DeviceFree(thrust::raw_pointer_cast(ptr));
-      #else
-        cudaError_t status = cudaFree(thrust::raw_pointer_cast(ptr));
-      #endif
-      cuda_cub::throw_on_error(status, "device free failed");
-    #endif
-  } else {
-    #if THRUST_INCLUDE_DEVICE_CODE
-      thrust::free(thrust::seq, ptr);
-    #endif
-  }
-} // end free()
-
-}    // namespace cuda_cub
-} // end namespace thrust

spaces/CVPR/LIVE/thrust/thrust/system/detail/adl/logical.h

@@ -1,44 +0,0 @@
-/*
- *  Copyright 2008-2013 NVIDIA Corporation
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a fill of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-#pragma once
-
-#include <thrust/detail/config.h>
-
-// the purpose of this header is to #include the logical.h header
-// of the sequential, host, and device systems. It should be #included in any
-// code which uses adl to dispatch logical
-
-#include <thrust/system/detail/sequential/logical.h>
-
-// SCons can't see through the #defines below to figure out what this header
-// includes, so we fake it out by specifying all possible files we might end up
-// including inside an #if 0.
-#if 0
-#include <thrust/system/cpp/detail/logical.h>
-#include <thrust/system/cuda/detail/logical.h>
-#include <thrust/system/omp/detail/logical.h>
-#include <thrust/system/tbb/detail/logical.h>
-#endif
-
-#define __THRUST_HOST_SYSTEM_LOGICAL_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/logical.h>
-#include __THRUST_HOST_SYSTEM_LOGICAL_HEADER
-#undef __THRUST_HOST_SYSTEM_LOGICAL_HEADER
-
-#define __THRUST_DEVICE_SYSTEM_LOGICAL_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/logical.h>
-#include __THRUST_DEVICE_SYSTEM_LOGICAL_HEADER
-#undef __THRUST_DEVICE_SYSTEM_LOGICAL_HEADER
-

spaces/CVPR/regionclip-demo/detectron2/layers/csrc/deformable/deform_conv.h

@@ -1,377 +0,0 @@
-// Copyright (c) Facebook, Inc. and its affiliates.
-#pragma once
-#include <torch/types.h>
-
-namespace detectron2 {
-
-#if defined(WITH_CUDA) || defined(WITH_HIP)
-int deform_conv_forward_cuda(
-    at::Tensor input,
-    at::Tensor weight,
-    at::Tensor offset,
-    at::Tensor output,
-    at::Tensor columns,
-    at::Tensor ones,
-    int kW,
-    int kH,
-    int dW,
-    int dH,
-    int padW,
-    int padH,
-    int dilationW,
-    int dilationH,
-    int group,
-    int deformable_group,
-    int im2col_step);
-
-int deform_conv_backward_input_cuda(
-    at::Tensor input,
-    at::Tensor offset,
-    at::Tensor gradOutput,
-    at::Tensor gradInput,
-    at::Tensor gradOffset,
-    at::Tensor weight,
-    at::Tensor columns,
-    int kW,
-    int kH,
-    int dW,
-    int dH,
-    int padW,
-    int padH,
-    int dilationW,
-    int dilationH,
-    int group,
-    int deformable_group,
-    int im2col_step);
-
-int deform_conv_backward_parameters_cuda(
-    at::Tensor input,
-    at::Tensor offset,
-    at::Tensor gradOutput,
-    at::Tensor gradWeight, // at::Tensor gradBias,
-    at::Tensor columns,
-    at::Tensor ones,
-    int kW,
-    int kH,
-    int dW,
-    int dH,
-    int padW,
-    int padH,
-    int dilationW,
-    int dilationH,
-    int group,
-    int deformable_group,
-    float scale,
-    int im2col_step);
-
-void modulated_deform_conv_cuda_forward(
-    at::Tensor input,
-    at::Tensor weight,
-    at::Tensor bias,
-    at::Tensor ones,
-    at::Tensor offset,
-    at::Tensor mask,
-    at::Tensor output,
-    at::Tensor columns,
-    int kernel_h,
-    int kernel_w,
-    const int stride_h,
-    const int stride_w,
-    const int pad_h,
-    const int pad_w,
-    const int dilation_h,
-    const int dilation_w,
-    const int group,
-    const int deformable_group,
-    const bool with_bias);
-
-void modulated_deform_conv_cuda_backward(
-    at::Tensor input,
-    at::Tensor weight,
-    at::Tensor bias,
-    at::Tensor ones,
-    at::Tensor offset,
-    at::Tensor mask,
-    at::Tensor columns,
-    at::Tensor grad_input,
-    at::Tensor grad_weight,
-    at::Tensor grad_bias,
-    at::Tensor grad_offset,
-    at::Tensor grad_mask,
-    at::Tensor grad_output,
-    int kernel_h,
-    int kernel_w,
-    int stride_h,
-    int stride_w,
-    int pad_h,
-    int pad_w,
-    int dilation_h,
-    int dilation_w,
-    int group,
-    int deformable_group,
-    const bool with_bias);
-
-#endif
-
-inline int deform_conv_forward(
-    at::Tensor input,
-    at::Tensor weight,
-    at::Tensor offset,
-    at::Tensor output,
-    at::Tensor columns,
-    at::Tensor ones,
-    int kW,
-    int kH,
-    int dW,
-    int dH,
-    int padW,
-    int padH,
-    int dilationW,
-    int dilationH,
-    int group,
-    int deformable_group,
-    int im2col_step) {
-  if (input.is_cuda()) {
-#if defined(WITH_CUDA) || defined(WITH_HIP)
-    TORCH_CHECK(weight.is_cuda(), "weight tensor is not on GPU!");
-    TORCH_CHECK(offset.is_cuda(), "offset tensor is not on GPU!");
-    return deform_conv_forward_cuda(
-        input,
-        weight,
-        offset,
-        output,
-        columns,
-        ones,
-        kW,
-        kH,
-        dW,
-        dH,
-        padW,
-        padH,
-        dilationW,
-        dilationH,
-        group,
-        deformable_group,
-        im2col_step);
-#else
-    AT_ERROR("Not compiled with GPU support");
-#endif
-  }
-  AT_ERROR("Not implemented on the CPU");
-}
-
-inline int deform_conv_backward_input(
-    at::Tensor input,
-    at::Tensor offset,
-    at::Tensor gradOutput,
-    at::Tensor gradInput,
-    at::Tensor gradOffset,
-    at::Tensor weight,
-    at::Tensor columns,
-    int kW,
-    int kH,
-    int dW,
-    int dH,
-    int padW,
-    int padH,
-    int dilationW,
-    int dilationH,
-    int group,
-    int deformable_group,
-    int im2col_step) {
-  if (gradOutput.is_cuda()) {
-#if defined(WITH_CUDA) || defined(WITH_HIP)
-    TORCH_CHECK(input.is_cuda(), "input tensor is not on GPU!");
-    TORCH_CHECK(weight.is_cuda(), "weight tensor is not on GPU!");
-    TORCH_CHECK(offset.is_cuda(), "offset tensor is not on GPU!");
-    return deform_conv_backward_input_cuda(
-        input,
-        offset,
-        gradOutput,
-        gradInput,
-        gradOffset,
-        weight,
-        columns,
-        kW,
-        kH,
-        dW,
-        dH,
-        padW,
-        padH,
-        dilationW,
-        dilationH,
-        group,
-        deformable_group,
-        im2col_step);
-#else
-    AT_ERROR("Not compiled with GPU support");
-#endif
-  }
-  AT_ERROR("Not implemented on the CPU");
-}
-
-inline int deform_conv_backward_filter(
-    at::Tensor input,
-    at::Tensor offset,
-    at::Tensor gradOutput,
-    at::Tensor gradWeight, // at::Tensor gradBias,
-    at::Tensor columns,
-    at::Tensor ones,
-    int kW,
-    int kH,
-    int dW,
-    int dH,
-    int padW,
-    int padH,
-    int dilationW,
-    int dilationH,
-    int group,
-    int deformable_group,
-    float scale,
-    int im2col_step) {
-  if (gradOutput.is_cuda()) {
-#if defined(WITH_CUDA) || defined(WITH_HIP)
-    TORCH_CHECK(input.is_cuda(), "input tensor is not on GPU!");
-    TORCH_CHECK(offset.is_cuda(), "offset tensor is not on GPU!");
-    return deform_conv_backward_parameters_cuda(
-        input,
-        offset,
-        gradOutput,
-        gradWeight,
-        columns,
-        ones,
-        kW,
-        kH,
-        dW,
-        dH,
-        padW,
-        padH,
-        dilationW,
-        dilationH,
-        group,
-        deformable_group,
-        scale,
-        im2col_step);
-#else
-    AT_ERROR("Not compiled with GPU support");
-#endif
-  }
-  AT_ERROR("Not implemented on the CPU");
-}
-
-inline void modulated_deform_conv_forward(
-    at::Tensor input,
-    at::Tensor weight,
-    at::Tensor bias,
-    at::Tensor ones,
-    at::Tensor offset,
-    at::Tensor mask,
-    at::Tensor output,
-    at::Tensor columns,
-    int kernel_h,
-    int kernel_w,
-    const int stride_h,
-    const int stride_w,
-    const int pad_h,
-    const int pad_w,
-    const int dilation_h,
-    const int dilation_w,
-    const int group,
-    const int deformable_group,
-    const bool with_bias) {
-  if (input.is_cuda()) {
-#if defined(WITH_CUDA) || defined(WITH_HIP)
-    TORCH_CHECK(weight.is_cuda(), "weight tensor is not on GPU!");
-    TORCH_CHECK(bias.is_cuda(), "bias tensor is not on GPU!");
-    TORCH_CHECK(offset.is_cuda(), "offset tensor is not on GPU!");
-    return modulated_deform_conv_cuda_forward(
-        input,
-        weight,
-        bias,
-        ones,
-        offset,
-        mask,
-        output,
-        columns,
-        kernel_h,
-        kernel_w,
-        stride_h,
-        stride_w,
-        pad_h,
-        pad_w,
-        dilation_h,
-        dilation_w,
-        group,
-        deformable_group,
-        with_bias);
-#else
-    AT_ERROR("Not compiled with GPU support");
-#endif
-  }
-  AT_ERROR("Not implemented on the CPU");
-}
-
-inline void modulated_deform_conv_backward(
-    at::Tensor input,
-    at::Tensor weight,
-    at::Tensor bias,
-    at::Tensor ones,
-    at::Tensor offset,
-    at::Tensor mask,
-    at::Tensor columns,
-    at::Tensor grad_input,
-    at::Tensor grad_weight,
-    at::Tensor grad_bias,
-    at::Tensor grad_offset,
-    at::Tensor grad_mask,
-    at::Tensor grad_output,
-    int kernel_h,
-    int kernel_w,
-    int stride_h,
-    int stride_w,
-    int pad_h,
-    int pad_w,
-    int dilation_h,
-    int dilation_w,
-    int group,
-    int deformable_group,
-    const bool with_bias) {
-  if (grad_output.is_cuda()) {
-#if defined(WITH_CUDA) || defined(WITH_HIP)
-    TORCH_CHECK(input.is_cuda(), "input tensor is not on GPU!");
-    TORCH_CHECK(weight.is_cuda(), "weight tensor is not on GPU!");
-    TORCH_CHECK(bias.is_cuda(), "bias tensor is not on GPU!");
-    TORCH_CHECK(offset.is_cuda(), "offset tensor is not on GPU!");
-    return modulated_deform_conv_cuda_backward(
-        input,
-        weight,
-        bias,
-        ones,
-        offset,
-        mask,
-        columns,
-        grad_input,
-        grad_weight,
-        grad_bias,
-        grad_offset,
-        grad_mask,
-        grad_output,
-        kernel_h,
-        kernel_w,
-        stride_h,
-        stride_w,
-        pad_h,
-        pad_w,
-        dilation_h,
-        dilation_w,
-        group,
-        deformable_group,
-        with_bias);
-#else
-    AT_ERROR("Not compiled with GPU support");
-#endif
-  }
-  AT_ERROR("Not implemented on the CPU");
-}
-
-} // namespace detectron2

spaces/CVPR/regionclip-demo/detectron2/structures/tsv_file.py

@@ -1,352 +0,0 @@
-import logging
-import os
-import json
-import os.path as op
-import numpy as np
-from typing import List, Union
-from collections import OrderedDict
-
-def generate_lineidx(filein, idxout):
-    idxout_tmp = idxout + '.tmp'
-    with open(filein, 'r') as tsvin, open(idxout_tmp,'w') as tsvout:
-        fsize = os.fstat(tsvin.fileno()).st_size
-        fpos = 0
-        while fpos!=fsize:
-            tsvout.write(str(fpos)+"\n")
-            tsvin.readline()
-            fpos = tsvin.tell()
-    os.rename(idxout_tmp, idxout)
-
-
-def read_to_character(fp, c):
-    result = []
-    while True:
-        s = fp.read(32)
-        assert s != ''
-        if c in s:
-            result.append(s[: s.index(c)])
-            break
-        else:
-            result.append(s)
-    return ''.join(result)
-
-
-class TSVFile(object):
-    def __init__(self, tsv_file, generate_lineidx=False):
-        self.tsv_file = tsv_file
-        self.lineidx = op.splitext(tsv_file)[0] + '.lineidx'
-        self._fp = None
-        self._lineidx = None
-        # the process always keeps the process which opens the file. 
-        # If the pid is not equal to the currrent pid, we will re-open the file.
-        self.pid = None
-        # generate lineidx if not exist
-        if not op.isfile(self.lineidx) and generate_lineidx:
-            generate_lineidx(self.tsv_file, self.lineidx)
-
-    def __del__(self):
-        if self._fp:
-            self._fp.close()
-
-    def __str__(self):
-        return "TSVFile(tsv_file='{}')".format(self.tsv_file)
-
-    def __repr__(self):
-        return str(self)
-
-    def num_rows(self):
-        self._ensure_lineidx_loaded()
-        return len(self._lineidx)
-
-    def seek(self, idx):
-        self._ensure_tsv_opened()
-        self._ensure_lineidx_loaded()
-        try:
-            pos = self._lineidx[idx]
-        except:
-            logging.info('{}-{}'.format(self.tsv_file, idx))
-            raise
-        self._fp.seek(pos)
-        return [s.strip() for s in self._fp.readline().split('\t')]
-
-    def seek_first_column(self, idx):
-        self._ensure_tsv_opened()
-        self._ensure_lineidx_loaded()
-        pos = self._lineidx[idx]
-        self._fp.seek(pos)
-        return read_to_character(self._fp, '\t')
-
-    def get_key(self, idx):
-        return self.seek_first_column(idx)
-
-    def __getitem__(self, index):
-        return self.seek(index)
-
-    def __len__(self):
-        return self.num_rows()
-
-    def _ensure_lineidx_loaded(self):
-        if self._lineidx is None:
-            # print('loading lineidx: {}'.format(self.lineidx))
-
-            with open(self.lineidx, 'r') as fp:
-                self._lineidx = [int(i.strip()) for i in fp.readlines()]
-
-    def _ensure_tsv_opened(self):
-        if self._fp is None:
-            self._fp = open(self.tsv_file, 'r')
-            self.pid = os.getpid()
-
-        if self.pid != os.getpid():
-            # print('re-open {} because the process id changed'.format(self.tsv_file))
-            self._fp = open(self.tsv_file, 'r')
-            self.pid = os.getpid()
-
-class TSVFileNew(object):
-    def __init__(self,
-                 tsv_file: str,
-                 if_generate_lineidx: bool = False,
-                 lineidx: str = None,
-                 class_selector: List[str] = None):
-        self.tsv_file = tsv_file
-        self.lineidx = op.splitext(tsv_file)[0] + '.lineidx' \
-            if not lineidx else lineidx
-        self.linelist = op.splitext(tsv_file)[0] + '.linelist'
-        self.chunks = op.splitext(tsv_file)[0] + '.chunks'
-        self._fp = None
-        self._lineidx = None
-        self._sample_indices = None
-        self._class_boundaries = None
-        self._class_selector = class_selector
-        # the process always keeps the process which opens the file.
-        # If the pid is not equal to the currrent pid, we will re-open the file.
-        self.pid = None
-        # generate lineidx if not exist
-        if not op.isfile(self.lineidx) and if_generate_lineidx:
-            generate_lineidx(self.tsv_file, self.lineidx)
-
-    def __del__(self):
-        if self._fp:
-            self._fp.close()
-
-    def __str__(self):
-        return "TSVFile(tsv_file='{}')".format(self.tsv_file)
-
-    def __repr__(self):
-        return str(self)
-
-    def get_class_boundaries(self):
-        return self._class_boundaries
-
-    def num_rows(self):
-        self._ensure_lineidx_loaded()
-        return len(self._sample_indices)
-
-    def seek(self, idx: int):
-        self._ensure_tsv_opened()
-        self._ensure_lineidx_loaded()
-        try:
-            pos = self._lineidx[self._sample_indices[idx]]
-        except:
-            logging.info('=> {}-{}'.format(self.tsv_file, idx))
-            raise
-        self._fp.seek(pos)
-        return [s.strip() for s in self._fp.readline().split('\t')]
-
-    def seek_first_column(self, idx: int):
-        self._ensure_tsv_opened()
-        self._ensure_lineidx_loaded()
-        pos = self._lineidx[idx]
-        self._fp.seek(pos)
-        return read_to_character(self._fp, '\t')
-
-    def get_key(self, idx: int):
-        return self.seek_first_column(idx)
-
-    def __getitem__(self, index: int):
-        return self.seek(index)
-
-    def __len__(self):
-        return self.num_rows()
-
-    def _ensure_lineidx_loaded(self):
-        if self._lineidx is None:
-            # print('=> loading lineidx: {}'.format(self.lineidx))
-            with open(self.lineidx, 'r') as fp:
-                lines = fp.readlines()
-                lines = [line.strip() for line in lines]
-                self._lineidx = [int(line) for line in lines]
-            # except:
-            #     print("error in loading lineidx file {}, regenerate it".format(self.lineidx))
-            #     generate_lineidx(self.tsv_file, self.lineidx)
-            #     with open(self.lineidx, 'r') as fp:
-            #         lines = fp.readlines()
-            #         lines = [line.strip() for line in lines]
-            #         self._lineidx = [int(line) for line in lines]                
-            # read the line list if exists
-            linelist = None
-            if op.isfile(self.linelist):
-                with open(self.linelist, 'r') as fp:
-                    linelist = sorted(
-                        [
-                            int(line.strip())
-                            for line in fp.readlines()
-                        ]
-                    )
-            if op.isfile(self.chunks) and self._class_selector:
-                self._sample_indices = []
-                self._class_boundaries = []
-                class_boundaries = json.load(open(self.chunks, 'r'))
-                for class_name, boundary in class_boundaries.items():
-                    start = len(self._sample_indices)
-                    if class_name in self._class_selector:
-                        for idx in range(boundary[0], boundary[1] + 1):
-                            # NOTE: potentially slow when linelist is long, try to speed it up
-                            if linelist and idx not in linelist:
-                                continue
-                            self._sample_indices.append(idx)
-                    end = len(self._sample_indices)
-                    self._class_boundaries.append((start, end))
-            else:
-                if linelist:
-                    self._sample_indices = linelist
-                else:
-                    self._sample_indices = list(range(len(self._lineidx)))
-
-    def _ensure_tsv_opened(self):
-        if self._fp is None:
-            self._fp = open(self.tsv_file, 'r')
-            self.pid = os.getpid()
-
-        if self.pid != os.getpid():
-            logging.debug('=> re-open {} because the process id changed'.format(self.tsv_file))
-            self._fp = open(self.tsv_file, 'r')
-            self.pid = os.getpid()
-
-class LRU(OrderedDict):
-    """Limit size, evicting the least recently looked-up key when full.
-    https://docs.python.org/3/library/collections.html#collections.OrderedDict
-    """
-
-    def __init__(self, maxsize=4, *args, **kwds):
-        self.maxsize = maxsize
-        super().__init__(*args, **kwds)
-
-    def __getitem__(self, key):
-        value = super().__getitem__(key)
-        self.move_to_end(key)
-        return value
-
-    def __setitem__(self, key, value):
-        if key in self:
-            self.move_to_end(key)
-        super().__setitem__(key, value)
-        if len(self) > self.maxsize:
-            oldest = next(iter(self))
-            del self[oldest]
-
-
-class CompositeTSVFile:
-    def __init__(self,
-                 file_list: Union[str, list],
-                 root: str = '.',
-                 class_selector: List[str] = None):
-        if isinstance(file_list, str):
-            self.file_list = load_list_file(file_list)
-        else:
-            assert isinstance(file_list, list)
-            self.file_list = file_list
-
-        self.root = root
-        self.cache = LRU()
-        self.tsvs = None
-        self.chunk_sizes = None
-        self.accum_chunk_sizes = None
-        self._class_selector = class_selector
-        self._class_boundaries = None
-        self.initialized = False
-        self.initialize()
-
-    def get_key(self, index: int):
-        idx_source, idx_row = self._calc_chunk_idx_row(index)
-        k = self.tsvs[idx_source].get_key(idx_row)
-        return '_'.join([self.file_list[idx_source], k])
-
-    def get_class_boundaries(self):
-        return self._class_boundaries
-
-    def get_chunk_size(self):
-        return self.chunk_sizes
-
-    def num_rows(self):
-        return sum(self.chunk_sizes)
-
-    def _calc_chunk_idx_row(self, index: int):
-        idx_chunk = 0
-        idx_row = index
-        while index >= self.accum_chunk_sizes[idx_chunk]:
-            idx_chunk += 1
-            idx_row = index - self.accum_chunk_sizes[idx_chunk-1]
-        return idx_chunk, idx_row
-
-
-    def __getitem__(self, index: int):
-        idx_source, idx_row = self._calc_chunk_idx_row(index)
-        if idx_source not in self.cache:
-            self.cache[idx_source] = TSVFileNew(
-                op.join(self.root, self.file_list[idx_source]),
-                class_selector=self._class_selector
-            )
-        return self.cache[idx_source].seek(idx_row)
-
-    def __len__(self):
-        return sum(self.chunk_sizes)
-
-    def initialize(self):
-        """
-        this function has to be called in init function if cache_policy is
-        enabled. Thus, let's always call it in init funciton to make it simple.
-        """
-        if self.initialized:
-            return
-        tsvs = [
-            TSVFileNew(
-                op.join(self.root, f),
-                class_selector=self._class_selector
-            ) for f in self.file_list
-        ]
-        logging.info("Calculating chunk sizes ...")
-        self.chunk_sizes = [len(tsv) for tsv in tsvs]
-
-        self.accum_chunk_sizes = [0]
-        for size in self.chunk_sizes:
-            self.accum_chunk_sizes += [self.accum_chunk_sizes[-1] + size]
-        self.accum_chunk_sizes = self.accum_chunk_sizes[1:]
-
-        if (
-            self._class_selector
-            and all([tsv.get_class_boundaries() for tsv in tsvs])
-        ):
-            """
-            Note: When using CompositeTSVFile, make sure that the classes contained in each
-            tsv file do not overlap. Otherwise, the class boundaries won't be correct.
-            """
-            self._class_boundaries = []
-            offset = 0
-            for tsv in tsvs:
-                boundaries = tsv.get_class_boundaries()
-                for bound in boundaries:
-                    self._class_boundaries.append((bound[0] + offset, bound[1] + offset))
-                offset += len(tsv)
-        # NOTE: in current setting, get_key is not used during training, so we remove tsvs for saving memory cost
-        del tsvs
-        self.initialized = True
-
-
-def load_list_file(fname: str) -> List[str]:
-    with open(fname, 'r') as fp:
-        lines = fp.readlines()
-    result = [line.strip() for line in lines]
-    if len(result) > 0 and result[-1] == '':
-        result = result[:-1]
-    return result

spaces/CVPR/transfiner/configs/common/coco_schedule.py

@@ -1,47 +0,0 @@
-from fvcore.common.param_scheduler import MultiStepParamScheduler
-
-from detectron2.config import LazyCall as L
-from detectron2.solver import WarmupParamScheduler
-
-
-def default_X_scheduler(num_X):
-    """
-    Returns the config for a default multi-step LR scheduler such as "1x", "3x",
-    commonly referred to in papers, where every 1x has the total length of 1440k
-    training images (~12 COCO epochs). LR is decayed twice at the end of training
-    following the strategy defined in "Rethinking ImageNet Pretraining", Sec 4.
-
-    Args:
-        num_X: a positive real number
-
-    Returns:
-        DictConfig: configs that define the multiplier for LR during training
-    """
-    # total number of iterations assuming 16 batch size, using 1440000/16=90000
-    total_steps_16bs = num_X * 90000
-
-    if num_X <= 2:
-        scheduler = L(MultiStepParamScheduler)(
-            values=[1.0, 0.1, 0.01],
-            # note that scheduler is scale-invariant. This is equivalent to
-            # milestones=[6, 8, 9]
-            milestones=[60000, 80000, 90000],
-        )
-    else:
-        scheduler = L(MultiStepParamScheduler)(
-            values=[1.0, 0.1, 0.01],
-            milestones=[total_steps_16bs - 60000, total_steps_16bs - 20000, total_steps_16bs],
-        )
-    return L(WarmupParamScheduler)(
-        scheduler=scheduler,
-        warmup_length=1000 / total_steps_16bs,
-        warmup_method="linear",
-        warmup_factor=0.001,
-    )
-
-
-lr_multiplier_1x = default_X_scheduler(1)
-lr_multiplier_2x = default_X_scheduler(2)
-lr_multiplier_3x = default_X_scheduler(3)
-lr_multiplier_6x = default_X_scheduler(6)
-lr_multiplier_9x = default_X_scheduler(9)

spaces/Cahlil/Speech-Recognition-with-Speaker-Segmentation/README.md

@@ -1,12 +0,0 @@
----
-title: Speech Recognition with Speaker Segmentation
-emoji: 🚀
-colorFrom: purple
-colorTo: green
-sdk: gradio
-sdk_version: 2.8.14
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces#reference

spaces/Caoyunkang/Segment-Any-Anomaly/GroundingDINO/groundingdino/util/inference.py

@@ -1,98 +0,0 @@
-from typing import Tuple, List
-
-import cv2
-import numpy as np
-import supervision as sv
-import torch
-from PIL import Image
-from torchvision.ops import box_convert
-
-import groundingdino.datasets.transforms as T
-from groundingdino.models import build_model
-from groundingdino.util.misc import clean_state_dict
-from groundingdino.util.slconfig import SLConfig
-from groundingdino.util.utils import get_phrases_from_posmap
-
-
-def preprocess_caption(caption: str) -> str:
-    result = caption.lower().strip()
-    if result.endswith("."):
-        return result
-    return result + "."
-
-
-def load_model(model_config_path: str, model_checkpoint_path: str, device: str = "cuda"):
-    args = SLConfig.fromfile(model_config_path)
-    args.device = device
-    model = build_model(args)
-    checkpoint = torch.load(model_checkpoint_path, map_location="cpu")
-    model.load_state_dict(clean_state_dict(checkpoint["model"]), strict=False)
-    model.eval()
-    return model
-
-
-def load_image(image_path: str) -> Tuple[np.array, torch.Tensor]:
-    transform = T.Compose(
-        [
-            T.RandomResize([800], max_size=1333),
-            T.ToTensor(),
-            T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
-        ]
-    )
-    image_source = Image.open(image_path).convert("RGB")
-    image = np.asarray(image_source)
-    image_transformed, _ = transform(image_source, None)
-    return image, image_transformed
-
-
-def predict(
-        model,
-        image: torch.Tensor,
-        caption: str,
-        box_threshold: float,
-        text_threshold: float,
-        device: str = "cuda"
-) -> Tuple[torch.Tensor, torch.Tensor, List[str]]:
-    caption = preprocess_caption(caption=caption)
-
-    model = model.to(device)
-    image = image.to(device)
-
-    with torch.no_grad():
-        outputs = model(image[None], captions=[caption])
-
-    prediction_logits = outputs["pred_logits"].cpu().sigmoid()[0]  # prediction_logits.shape = (nq, 256)
-    prediction_boxes = outputs["pred_boxes"].cpu()[0]  # prediction_boxes.shape = (nq, 4)
-
-    mask = prediction_logits.max(dim=1)[0] > box_threshold
-    logits = prediction_logits[mask]  # logits.shape = (n, 256)
-    boxes = prediction_boxes[mask]  # boxes.shape = (n, 4)
-
-    tokenizer = model.tokenizer
-    tokenized = tokenizer(caption)
-
-    phrases = [
-        get_phrases_from_posmap(logit > text_threshold, tokenized, tokenizer).replace('.', '')
-        for logit
-        in logits
-    ]
-
-    return boxes, logits.max(dim=1)[0], phrases
-
-
-def annotate(image_source: np.ndarray, boxes: torch.Tensor, logits: torch.Tensor, phrases: List[str]) -> np.ndarray:
-    h, w, _ = image_source.shape
-    boxes = boxes * torch.Tensor([w, h, w, h])
-    xyxy = box_convert(boxes=boxes, in_fmt="cxcywh", out_fmt="xyxy").numpy()
-    detections = sv.Detections(xyxy=xyxy)
-
-    labels = [
-        f"{phrase} {logit:.2f}"
-        for phrase, logit
-        in zip(phrases, logits)
-    ]
-
-    box_annotator = sv.BoxAnnotator()
-    annotated_frame = cv2.cvtColor(image_source, cv2.COLOR_RGB2BGR)
-    annotated_frame = box_annotator.annotate(scene=annotated_frame, detections=detections, labels=labels)
-    return annotated_frame

spaces/ChandraMohanNayal/AutoGPT/ui/utils.py

@@ -1,31 +0,0 @@
-import os
-import re
-
-def format_directory(directory):
-    output = []
-    def helper(directory, level, output):
-        files = os.listdir(directory)
-        for i, item in enumerate(files):
-            is_folder = os.path.isdir(os.path.join(directory, item))
-            joiner = "├── " if i < len(files) - 1 else "└── "
-            item_html = item + "/" if is_folder else f"<a href='file={os.path.join(directory, item)}'>{item}</a>"
-            output.append("│   " * level + joiner + item_html)
-            if is_folder:
-                helper(os.path.join(directory, item), level + 1, output)
-    output.append(os.path.basename(directory) + "/")
-    helper(directory, 1, output)
-    return "\n".join(output)
-
-DOWNLOAD_OUTPUTS_JS = """
-() => {
-  const a = document.createElement('a');
-  a.href = 'file=outputs.zip';
-  a.download = 'outputs.zip';
-  document.body.appendChild(a);
-  a.click();
-  document.body.removeChild(a);
-}"""
-
-def remove_color(text):
-    ansi_escape = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
-    return ansi_escape.sub('', text)

spaces/CognitiveLabs/GPT-auto-webscraping/chains/output_format/templates.py

@@ -1,30 +0,0 @@
-from langchain.prompts import SystemMessagePromptTemplate, HumanMessagePromptTemplate, ChatPromptTemplate, PromptTemplate
-
-# prompt templates
-system_template_output_format = PromptTemplate(
-    input_variables = ['html_content'],
-    template='''You are a helpful assitant that helps people extract JSON information from HTML content.
-
-    The input is a HTML content. 
-
-    The expected output is a JSON with a relevant information in the following html: {html_content}
-
-    Try to extract as much information as possible. Including images, links, etc.
-
-    The assitant answer should ONLY contain the JSON information without any aditional word or character.
-
-    The JSON output must have 1 depth level as much.
-
-    The expected output format is an array of objects.
-    
-    ''')
-
-human_template_output_format = PromptTemplate(
-    input_variables = ['html_content'], 
-    template='this is the html content: {html_content}'
-)
-
-# chat prompts objects
-system_message_prompt = SystemMessagePromptTemplate.from_template(system_template_output_format.template)
-human_message_prompt = HumanMessagePromptTemplate.from_template(human_template_output_format.template)
-output_format_chat_prompt = ChatPromptTemplate.from_messages([system_message_prompt, human_message_prompt])