Update parquet files (step 10 of 121)

spaces/1368565466ki/Satdia/transforms.py

@@ -1,193 +0,0 @@
-import torch
-from torch.nn import functional as F
-
-import numpy as np
-
-
-DEFAULT_MIN_BIN_WIDTH = 1e-3
-DEFAULT_MIN_BIN_HEIGHT = 1e-3
-DEFAULT_MIN_DERIVATIVE = 1e-3
-
-
-def piecewise_rational_quadratic_transform(inputs, 
-                                           unnormalized_widths,
-                                           unnormalized_heights,
-                                           unnormalized_derivatives,
-                                           inverse=False,
-                                           tails=None, 
-                                           tail_bound=1.,
-                                           min_bin_width=DEFAULT_MIN_BIN_WIDTH,
-                                           min_bin_height=DEFAULT_MIN_BIN_HEIGHT,
-                                           min_derivative=DEFAULT_MIN_DERIVATIVE):
-
-    if tails is None:
-        spline_fn = rational_quadratic_spline
-        spline_kwargs = {}
-    else:
-        spline_fn = unconstrained_rational_quadratic_spline
-        spline_kwargs = {
-            'tails': tails,
-            'tail_bound': tail_bound
-        }
-
-    outputs, logabsdet = spline_fn(
-            inputs=inputs,
-            unnormalized_widths=unnormalized_widths,
-            unnormalized_heights=unnormalized_heights,
-            unnormalized_derivatives=unnormalized_derivatives,
-            inverse=inverse,
-            min_bin_width=min_bin_width,
-            min_bin_height=min_bin_height,
-            min_derivative=min_derivative,
-            **spline_kwargs
-    )
-    return outputs, logabsdet
-
-
-def searchsorted(bin_locations, inputs, eps=1e-6):
-    bin_locations[..., -1] += eps
-    return torch.sum(
-        inputs[..., None] >= bin_locations,
-        dim=-1
-    ) - 1
-
-
-def unconstrained_rational_quadratic_spline(inputs,
-                                            unnormalized_widths,
-                                            unnormalized_heights,
-                                            unnormalized_derivatives,
-                                            inverse=False,
-                                            tails='linear',
-                                            tail_bound=1.,
-                                            min_bin_width=DEFAULT_MIN_BIN_WIDTH,
-                                            min_bin_height=DEFAULT_MIN_BIN_HEIGHT,
-                                            min_derivative=DEFAULT_MIN_DERIVATIVE):
-    inside_interval_mask = (inputs >= -tail_bound) & (inputs <= tail_bound)
-    outside_interval_mask = ~inside_interval_mask
-
-    outputs = torch.zeros_like(inputs)
-    logabsdet = torch.zeros_like(inputs)
-
-    if tails == 'linear':
-        unnormalized_derivatives = F.pad(unnormalized_derivatives, pad=(1, 1))
-        constant = np.log(np.exp(1 - min_derivative) - 1)
-        unnormalized_derivatives[..., 0] = constant
-        unnormalized_derivatives[..., -1] = constant
-
-        outputs[outside_interval_mask] = inputs[outside_interval_mask]
-        logabsdet[outside_interval_mask] = 0
-    else:
-        raise RuntimeError('{} tails are not implemented.'.format(tails))
-
-    outputs[inside_interval_mask], logabsdet[inside_interval_mask] = rational_quadratic_spline(
-        inputs=inputs[inside_interval_mask],
-        unnormalized_widths=unnormalized_widths[inside_interval_mask, :],
-        unnormalized_heights=unnormalized_heights[inside_interval_mask, :],
-        unnormalized_derivatives=unnormalized_derivatives[inside_interval_mask, :],
-        inverse=inverse,
-        left=-tail_bound, right=tail_bound, bottom=-tail_bound, top=tail_bound,
-        min_bin_width=min_bin_width,
-        min_bin_height=min_bin_height,
-        min_derivative=min_derivative
-    )
-
-    return outputs, logabsdet
-
-def rational_quadratic_spline(inputs,
-                              unnormalized_widths,
-                              unnormalized_heights,
-                              unnormalized_derivatives,
-                              inverse=False,
-                              left=0., right=1., bottom=0., top=1.,
-                              min_bin_width=DEFAULT_MIN_BIN_WIDTH,
-                              min_bin_height=DEFAULT_MIN_BIN_HEIGHT,
-                              min_derivative=DEFAULT_MIN_DERIVATIVE):
-    if torch.min(inputs) < left or torch.max(inputs) > right:
-        raise ValueError('Input to a transform is not within its domain')
-
-    num_bins = unnormalized_widths.shape[-1]
-
-    if min_bin_width * num_bins > 1.0:
-        raise ValueError('Minimal bin width too large for the number of bins')
-    if min_bin_height * num_bins > 1.0:
-        raise ValueError('Minimal bin height too large for the number of bins')
-
-    widths = F.softmax(unnormalized_widths, dim=-1)
-    widths = min_bin_width + (1 - min_bin_width * num_bins) * widths
-    cumwidths = torch.cumsum(widths, dim=-1)
-    cumwidths = F.pad(cumwidths, pad=(1, 0), mode='constant', value=0.0)
-    cumwidths = (right - left) * cumwidths + left
-    cumwidths[..., 0] = left
-    cumwidths[..., -1] = right
-    widths = cumwidths[..., 1:] - cumwidths[..., :-1]
-
-    derivatives = min_derivative + F.softplus(unnormalized_derivatives)
-
-    heights = F.softmax(unnormalized_heights, dim=-1)
-    heights = min_bin_height + (1 - min_bin_height * num_bins) * heights
-    cumheights = torch.cumsum(heights, dim=-1)
-    cumheights = F.pad(cumheights, pad=(1, 0), mode='constant', value=0.0)
-    cumheights = (top - bottom) * cumheights + bottom
-    cumheights[..., 0] = bottom
-    cumheights[..., -1] = top
-    heights = cumheights[..., 1:] - cumheights[..., :-1]
-
-    if inverse:
-        bin_idx = searchsorted(cumheights, inputs)[..., None]
-    else:
-        bin_idx = searchsorted(cumwidths, inputs)[..., None]
-
-    input_cumwidths = cumwidths.gather(-1, bin_idx)[..., 0]
-    input_bin_widths = widths.gather(-1, bin_idx)[..., 0]
-
-    input_cumheights = cumheights.gather(-1, bin_idx)[..., 0]
-    delta = heights / widths
-    input_delta = delta.gather(-1, bin_idx)[..., 0]
-
-    input_derivatives = derivatives.gather(-1, bin_idx)[..., 0]
-    input_derivatives_plus_one = derivatives[..., 1:].gather(-1, bin_idx)[..., 0]
-
-    input_heights = heights.gather(-1, bin_idx)[..., 0]
-
-    if inverse:
-        a = (((inputs - input_cumheights) * (input_derivatives
-                                             + input_derivatives_plus_one
-                                             - 2 * input_delta)
-              + input_heights * (input_delta - input_derivatives)))
-        b = (input_heights * input_derivatives
-             - (inputs - input_cumheights) * (input_derivatives
-                                              + input_derivatives_plus_one
-                                              - 2 * input_delta))
-        c = - input_delta * (inputs - input_cumheights)
-
-        discriminant = b.pow(2) - 4 * a * c
-        assert (discriminant >= 0).all()
-
-        root = (2 * c) / (-b - torch.sqrt(discriminant))
-        outputs = root * input_bin_widths + input_cumwidths
-
-        theta_one_minus_theta = root * (1 - root)
-        denominator = input_delta + ((input_derivatives + input_derivatives_plus_one - 2 * input_delta)
-                                     * theta_one_minus_theta)
-        derivative_numerator = input_delta.pow(2) * (input_derivatives_plus_one * root.pow(2)
-                                                     + 2 * input_delta * theta_one_minus_theta
-                                                     + input_derivatives * (1 - root).pow(2))
-        logabsdet = torch.log(derivative_numerator) - 2 * torch.log(denominator)
-
-        return outputs, -logabsdet
-    else:
-        theta = (inputs - input_cumwidths) / input_bin_widths
-        theta_one_minus_theta = theta * (1 - theta)
-
-        numerator = input_heights * (input_delta * theta.pow(2)
-                                     + input_derivatives * theta_one_minus_theta)
-        denominator = input_delta + ((input_derivatives + input_derivatives_plus_one - 2 * input_delta)
-                                     * theta_one_minus_theta)
-        outputs = input_cumheights + numerator / denominator
-
-        derivative_numerator = input_delta.pow(2) * (input_derivatives_plus_one * theta.pow(2)
-                                                     + 2 * input_delta * theta_one_minus_theta
-                                                     + input_derivatives * (1 - theta).pow(2))
-        logabsdet = torch.log(derivative_numerator) - 2 * torch.log(denominator)
-
-        return outputs, logabsdet

spaces/17TheWord/vits-models/utils.py

@@ -1,225 +0,0 @@
-import os
-import sys
-import argparse
-import logging
-import json
-import subprocess
-import numpy as np
-import librosa
-import torch
-
-MATPLOTLIB_FLAG = False
-
-logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)
-logger = logging
-
-
-def load_checkpoint(checkpoint_path, model, optimizer=None):
-  assert os.path.isfile(checkpoint_path)
-  checkpoint_dict = torch.load(checkpoint_path, map_location='cpu')
-  iteration = checkpoint_dict['iteration']
-  learning_rate = checkpoint_dict['learning_rate']
-  if optimizer is not None:
-    optimizer.load_state_dict(checkpoint_dict['optimizer'])
-  saved_state_dict = checkpoint_dict['model']
-  if hasattr(model, 'module'):
-    state_dict = model.module.state_dict()
-  else:
-    state_dict = model.state_dict()
-  new_state_dict= {}
-  for k, v in state_dict.items():
-    try:
-      new_state_dict[k] = saved_state_dict[k]
-    except:
-      logger.info("%s is not in the checkpoint" % k)
-      new_state_dict[k] = v
-  if hasattr(model, 'module'):
-    model.module.load_state_dict(new_state_dict)
-  else:
-    model.load_state_dict(new_state_dict)
-  logger.info("Loaded checkpoint '{}' (iteration {})" .format(
-    checkpoint_path, iteration))
-  return model, optimizer, learning_rate, iteration
-
-
-def plot_spectrogram_to_numpy(spectrogram):
-  global MATPLOTLIB_FLAG
-  if not MATPLOTLIB_FLAG:
-    import matplotlib
-    matplotlib.use("Agg")
-    MATPLOTLIB_FLAG = True
-    mpl_logger = logging.getLogger('matplotlib')
-    mpl_logger.setLevel(logging.WARNING)
-  import matplotlib.pylab as plt
-  import numpy as np
-
-  fig, ax = plt.subplots(figsize=(10,2))
-  im = ax.imshow(spectrogram, aspect="auto", origin="lower",
-                  interpolation='none')
-  plt.colorbar(im, ax=ax)
-  plt.xlabel("Frames")
-  plt.ylabel("Channels")
-  plt.tight_layout()
-
-  fig.canvas.draw()
-  data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep='')
-  data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,))
-  plt.close()
-  return data
-
-
-def plot_alignment_to_numpy(alignment, info=None):
-  global MATPLOTLIB_FLAG
-  if not MATPLOTLIB_FLAG:
-    import matplotlib
-    matplotlib.use("Agg")
-    MATPLOTLIB_FLAG = True
-    mpl_logger = logging.getLogger('matplotlib')
-    mpl_logger.setLevel(logging.WARNING)
-  import matplotlib.pylab as plt
-  import numpy as np
-
-  fig, ax = plt.subplots(figsize=(6, 4))
-  im = ax.imshow(alignment.transpose(), aspect='auto', origin='lower',
-                  interpolation='none')
-  fig.colorbar(im, ax=ax)
-  xlabel = 'Decoder timestep'
-  if info is not None:
-      xlabel += '\n\n' + info
-  plt.xlabel(xlabel)
-  plt.ylabel('Encoder timestep')
-  plt.tight_layout()
-
-  fig.canvas.draw()
-  data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep='')
-  data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,))
-  plt.close()
-  return data
-
-
-def load_audio_to_torch(full_path, target_sampling_rate):
-  audio, sampling_rate = librosa.load(full_path, sr=target_sampling_rate, mono=True)
-  return torch.FloatTensor(audio.astype(np.float32))
-
-
-def load_filepaths_and_text(filename, split="|"):
-  with open(filename, encoding='utf-8') as f:
-    filepaths_and_text = [line.strip().split(split) for line in f]
-  return filepaths_and_text
-
-
-def get_hparams(init=True):
-  parser = argparse.ArgumentParser()
-  parser.add_argument('-c', '--config', type=str, default="./configs/base.json",
-                      help='JSON file for configuration')
-  parser.add_argument('-m', '--model', type=str, required=True,
-                      help='Model name')
-
-  args = parser.parse_args()
-  model_dir = os.path.join("./logs", args.model)
-
-  if not os.path.exists(model_dir):
-    os.makedirs(model_dir)
-
-  config_path = args.config
-  config_save_path = os.path.join(model_dir, "config.json")
-  if init:
-    with open(config_path, "r") as f:
-      data = f.read()
-    with open(config_save_path, "w") as f:
-      f.write(data)
-  else:
-    with open(config_save_path, "r") as f:
-      data = f.read()
-  config = json.loads(data)
-
-  hparams = HParams(**config)
-  hparams.model_dir = model_dir
-  return hparams
-
-
-def get_hparams_from_dir(model_dir):
-  config_save_path = os.path.join(model_dir, "config.json")
-  with open(config_save_path, "r") as f:
-    data = f.read()
-  config = json.loads(data)
-
-  hparams =HParams(**config)
-  hparams.model_dir = model_dir
-  return hparams
-
-
-def get_hparams_from_file(config_path):
-  with open(config_path, "r") as f:
-    data = f.read()
-  config = json.loads(data)
-
-  hparams =HParams(**config)
-  return hparams
-
-
-def check_git_hash(model_dir):
-  source_dir = os.path.dirname(os.path.realpath(__file__))
-  if not os.path.exists(os.path.join(source_dir, ".git")):
-    logger.warn("{} is not a git repository, therefore hash value comparison will be ignored.".format(
-      source_dir
-    ))
-    return
-
-  cur_hash = subprocess.getoutput("git rev-parse HEAD")
-
-  path = os.path.join(model_dir, "githash")
-  if os.path.exists(path):
-    saved_hash = open(path).read()
-    if saved_hash != cur_hash:
-      logger.warn("git hash values are different. {}(saved) != {}(current)".format(
-        saved_hash[:8], cur_hash[:8]))
-  else:
-    open(path, "w").write(cur_hash)
-
-
-def get_logger(model_dir, filename="train.log"):
-  global logger
-  logger = logging.getLogger(os.path.basename(model_dir))
-  logger.setLevel(logging.DEBUG)
-
-  formatter = logging.Formatter("%(asctime)s\t%(name)s\t%(levelname)s\t%(message)s")
-  if not os.path.exists(model_dir):
-    os.makedirs(model_dir)
-  h = logging.FileHandler(os.path.join(model_dir, filename))
-  h.setLevel(logging.DEBUG)
-  h.setFormatter(formatter)
-  logger.addHandler(h)
-  return logger
-
-
-class HParams():
-  def __init__(self, **kwargs):
-    for k, v in kwargs.items():
-      if type(v) == dict:
-        v = HParams(**v)
-      self[k] = v
-
-  def keys(self):
-    return self.__dict__.keys()
-
-  def items(self):
-    return self.__dict__.items()
-
-  def values(self):
-    return self.__dict__.values()
-
-  def __len__(self):
-    return len(self.__dict__)
-
-  def __getitem__(self, key):
-    return getattr(self, key)
-
-  def __setitem__(self, key, value):
-    return setattr(self, key, value)
-
-  def __contains__(self, key):
-    return key in self.__dict__
-
-  def __repr__(self):
-    return self.__dict__.__repr__()

spaces/1gistliPinn/ChatGPT4/Examples/Chak De India Telugu Movie Free Torrent Download !!TOP!!.md

@@ -1,38 +0,0 @@
-<br />
-<h1>How to Watch Chak De India in Telugu for Free</h1>
-<p>Chak De India is a 2007 Bollywood sports drama film starring Shah Rukh Khan as a former hockey player who coaches the Indian women's national hockey team. The film was a critical and commercial success, winning several awards and inspiring many people with its patriotic and empowering message.</p>
-<p>If you are a fan of Chak De India and want to watch it in Telugu, you might be wondering how to do that without paying any money. Well, there are some ways to download or stream the movie for free using torrent sites or online platforms. However, you should be aware of the risks and legal issues involved in doing so.</p>
-<h2>Chak De India Telugu Movie Free Torrent Download</h2><br /><p><b><b>Download File</b> &#10042; <a href="https://imgfil.com/2uy0X9">https://imgfil.com/2uy0X9</a></b></p><br /><br />
-<h2>Using Torrent Sites</h2>
-<p>Torrent sites are websites that allow users to share files using peer-to-peer (P2P) technology. You can find almost any movie or show on torrent sites, including Chak De India in Telugu. However, you need to have a torrent client software installed on your device to download the files. Some of the popular torrent clients are uTorrent, BitTorrent, qBittorrent, etc.</p>
-<p>To use torrent sites, you need to follow these steps:</p>
-<ol>
-<li>Search for "Chak De India Telugu Movie Free Torrent Download" on any torrent site. Some of the popular torrent sites are The Pirate Bay, 1337x, RARBG, etc.</li>
-<li>Select a torrent file that has good quality and seeders. Seeders are users who have the complete file and are sharing it with others. The more seeders a torrent has, the faster it will download.</li>
-<li>Download the torrent file and open it with your torrent client. The torrent client will start downloading the movie from other users.</li>
-<li>Once the download is complete, you can watch the movie using any media player that supports subtitles.</li>
-</ol>
-<p>However, using torrent sites has some disadvantages and risks. For example:</p>
-<ul>
-<li>Torrent sites are illegal in many countries and regions. You might face legal action or fines if you are caught downloading or sharing copyrighted content.</li>
-<li>Torrent sites are often infected with malware or viruses that can harm your device or steal your personal information.</li>
-<li>Torrent sites are unreliable and unregulated. You might not find the movie you want or get a fake or corrupted file instead.</li>
-<li>Torrent sites can expose your IP address and location to other users or hackers who can track your online activity or attack your network.</li>
-</ul>
-<h2>Using Online Platforms</h2>
-<p>Online platforms are websites or apps that allow users to watch movies or shows online for free or with a subscription. You can find many online platforms that offer Chak De India in Telugu, such as Zee5, MX Player, YouTube, etc.</p>
-<p>To use online platforms, you need to follow these steps:</p>
-<ol>
-<li>Search for "Chak De India Telugu Movie Free Online" on any online platform. Some of the popular online platforms are Zee5[^1^], MX Player[^2^], YouTube[^3^], etc.</li>
-<li>Select the movie and click on play. You might need to create an account or sign in with your existing account to access some online platforms.</li>
-<li>Enjoy watching the movie online for free or with a subscription.</li>
-</ol>
-<p>However, using online platforms has some disadvantages and risks as well. For example:</p>
-<ul>
-<li>Online platforms might not have the movie you want or have it in low quality or with ads.</li>
-<li>Online platforms might require you to pay a subscription fee or register with your personal information to access some content.</li>
-<li>Online platforms might not be available in your region or country due to geo-restrictions or licensing issues.</li>
-<li>Online platforms might violate the copyrights of the original creators or distributors of the movie and face legal action or removal.</li>
-</ul></p> d5da3c52bf<br />
-<br />
-<br />

spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/DJ Studio 5 APK - The Ultimate Music Mixer App for Android Devices.md

@@ -1,102 +0,0 @@
-
-<h1>Download DJ Studio 5 APK: A Free Music Mixer for Android</h1>
-<p>Do you love mixing music and creating your own beats? Do you want to turn your Android device into a virtual DJ station? If yes, then you should download DJ Studio 5 APK, a free music mixer app that lets you manipulate music in the palm of your hands. In this article, we will tell you what DJ Studio 5 APK is, what features it has, what are its pros and cons, how to download and install it on your Android device, and how to use it to mix music like a pro.</p>
- <h2>What is DJ Studio 5 APK?</h2>
-<p>DJ Studio 5 APK is a mobile DJ app that allows you to mix, remix, scratch, loop, or pitch your music. The app and all of its functions are completely free, unlike previous versions, which required an in-app purchase to unlock unlimited playback. DJ Studio 5 APK is designed to be user friendly, social, and responsive. You can access and browse your mp3 music library by folder, artist, album, or name. You can edit and re-order your playlist. You can also record your mixes live and share them on SoundCloud or other social networks.</p>
-<h2>download dj studio 5 apk</h2><br /><p><b><b>DOWNLOAD</b> &middot;&middot;&middot; <a href="https://urlin.us/2uT2pV">https://urlin.us/2uT2pV</a></b></p><br /><br />
- <h3>Features of DJ Studio 5 APK</h3>
-<p>Some of the key features of DJ Studio 5 APK are:</p>
-<ul>
-<li>Wide compatibility: Android 2.3 and more</li>
-<li>2 virtual turntables with cross fader</li>
-<li>Customize your decks with up to 7 skins</li>
-<li>Unique scratch engine and disc physics</li>
-<li>8 sound effects: Flanger, Phaser, Gate, Reverb, Bit crusher, 3D, Brake, and FlippingDouble</li>
-<li>3-bands equalizer for each deck</li>
-<li>10 customizable sample pads</li>
-<li>One CUE/RECALL point per deck</li>
-<li>IN/OUT and beat based loops</li>
-<li>Pre-Cueing with headphones or Y-cable</li>
-<li>Automatic landscape and portrait mode</li>
-<li>Live sound spectrum view with beats detection and zoom</li>
-<li>No registration fee, no limitation, no watermark, no trackers, no stealing data, no popups everywhere, everyday</li>
-<li>Only optional paid skins to support the developers' work</li>
-</ul>
- <h3>Pros and Cons of DJ Studio 5 APK</h3>
-<p>Like any other app, DJ Studio 5 APK has its pros and cons. Here are some of them:</p>
- <table>
-<tr><th>Pros</th><th>Cons</th></tr>
-<tr><td>Fully fledged mobile mixer</td><td>Steep learning curve for beginners</td></tr>
-<tr><td>Free and comprehensive</td><td>Some compatibility issues on smaller devices</td></tr>
-<tr><td>Social and responsive</td><td>No effects other than the ones provided</td></tr>
-<tr><td>Lots of options and customization</td><td>No support for external controllers or MIDI devices</td></tr>
-<tr><td>Frequent updates and improvements</td><td>No offline mode or backup option</td></tr>
-</table>
- <h2>How to Download and Install DJ Studio 5 APK on Android?</h2>
-<p>If you want to download and install DJ Studio 5 APK on your Android device, you need to follow these steps:</p>
- <h3>Step 1: Enable Unknown Sources</h3>
-<p>Since DJ Studio 5 APK is not available on the Google Play Store, you need to enable the installation of apps from unknown sources on your device. To do this, go to your device's settings, then security, and then toggle on the option that says "Unknown sources". This will allow you to install apps that are not from the official app store.</p>
- <h3>Step 2: Download DJ Studio 5 APK File</h3>
-<p>Next, you need to download the DJ Studio 5 APK file from a reliable source. You can use the link below to download the latest version of the app. The file size is about 13 MB and it is virus-free and safe to download.</p>
-<p><a href="">Download DJ Studio 5 APK</a></p>
-<p>Download DJ Studio 5 - Free music mixer for Android<br />
-How to install DJ Studio 5 APK on your device<br />
-DJ Studio 5 - Music mixer app review and features<br />
-Best alternatives to DJ Studio 5 for Android<br />
-DJ Studio 5 - Free music mixer tips and tricks<br />
-Download DJ Studio 5 mod APK with premium features<br />
-DJ Studio 5 - Music mixer latest version update<br />
-How to use DJ Studio 5 to mix, remix, scratch, loop or pitch your music<br />
-DJ Studio 5 - Free music mixer vs other DJ apps for Android<br />
-Download DJ Studio 5 APK from FileHippo<br />
-How to uninstall DJ Studio 5 from your device<br />
-DJ Studio 5 - Music mixer user feedback and ratings<br />
-Download DJ Studio 5 APK from Softonic<br />
-How to fix DJ Studio 5 errors and issues<br />
-DJ Studio 5 - Free music mixer tutorial and guide<br />
-Download DJ Studio 5 APK from Google Play Store<br />
-How to customize DJ Studio 5 settings and preferences<br />
-DJ Studio 5 - Music mixer FAQs and answers<br />
-Download DJ Studio 5 APK from APKPure<br />
-How to backup and restore DJ Studio 5 data<br />
-DJ Studio 5 - Free music mixer pros and cons<br />
-Download DJ Studio 5 APK from APKMirror<br />
-How to connect DJ Studio 5 to external devices and speakers<br />
-DJ Studio 5 - Music mixer best practices and recommendations<br />
-Download DJ Studio 5 APK from Uptodown<br />
-How to share your DJ Studio 5 mixes on Soundcloud<br />
-DJ Studio 5 - Free music mixer supported formats and devices<br />
-Download DJ Studio 5 APK from Aptoide<br />
-How to record your DJ Studio 5 sessions and save them as MP3 files<br />
-DJ Studio 5 - Music mixer compatible headphones and controllers</p>
- <h3>Step 3: Install DJ Studio 5 APK File</h3>
-<p>Once you have downloaded the DJ Studio 5 APK file, you need to locate it on your device and tap on it to start the installation process. You may see a warning message that says "This type of file can harm your device. Do you want to keep DJStudio5.apk anyway?". Just tap on "OK" and proceed. Then, you will see another message that says "Do you want to install this application? It does not require any special access". Tap on "Install" and wait for the installation to finish. You may also see a message that says "App installed". Tap on "Open" to launch the app or "Done" to exit.</p>
- <h2>How to Use DJ Studio 5 APK to Mix Music?</h2>
-<p>Now that you have installed DJ Studio 5 APK on your Android device, you are ready to mix music like a DJ. Here are some tips on how to use the app:</p>
- <h3>Choose Your Decks and Skins</h3>
-<p>When you open the app, you will see two virtual turntables with a cross fader in between. You can swipe left or right to switch between different decks and skins. You can also tap on the menu icon at the top left corner and select "Decks & Skins" to customize your decks with up to 7 skins. You can choose from classic, gold, neon, metal, diamond, platinum, or wood skins.</p>
- <h3>Load Your Music and Adjust the Settings</h3>
-<p>To load your music, tap on the music icon at the top right corner and browse your mp3 music library by folder, artist, album, or name. You can also search for a specific song using the search bar. To load a song onto a deck, just drag and drop it onto the turntable. You can also edit and re-order your playlist by tapping on the playlist icon at the bottom right corner.</p>
-<p>To adjust the settings, tap on the gear icon at the top right corner and select "Settings". Here you can change various options such as sound quality, pitch range, cue mode, auto sync mode, sound effects, equalizer, sample pads, loop mode, pre-cueing mode, and more. You can also access the help section and rate the app from here.</p>
- <h3>Mix, Scratch, Loop, and Pitch Your Music</h3>
-<p>To mix your music, use the cross fader to blend the sounds from both decks. You can also use the volume sliders to adjust the volume of each deck individually. To scratch your music, swipe your finger on the turntable as if you were using a real vinyl record. To loop your music, tap on the loop icon at the bottom left corner and select a loop length from 1/32 to 32 beats. To pitch your music, use the pitch slider at the bottom of each deck to change the speed and tone of the music.</p>
-<p>To add some sound effects to your mix, tap on the FX icon at the bottom left corner and select one of the 8 sound effects: Flanger, Phaser, Gate, Reverb, Bit crusher, 3D, Brake, or FlippingDouble. You can also adjust the intensity of each effect by using the knob below it. To add some samples to your mix, tap on the pad icon at the bottom right corner and select one of the 10 customizable sample pads. You can also record your own samples by tapping and holding on an empty pad.</p>
-<p>To record your mix live, tap on the record icon at the top right corner and select "Record". The app will start recording your mix as an mp3 file in your device's storage. To stop recording, tap on the record icon again and select "Stop". You can also listen to your recorded mixes by tapping on the record icon and selecting "My recordings". To share your mixes with others, tap on the share icon at the top right corner and select one of the available options: SoundCloud, Facebook, Twitter, Google+, or Email.</p>
- <h2>Conclusion</h2>
-<p>DJ Studio 5 APK is a free music mixer app that lets you mix, remix, scratch, loop, or pitch your music on your Android device. It has a lot of features and options to customize your decks and your mix. It is also social and responsive, allowing you to record and share your mixes with others. DJ Studio 5 APK is a great app for music lovers and aspiring DJs who want to have fun and create their own beats.</p>
- <h2>FAQs</h2>
-<p>Here are some frequently asked questions about DJ Studio 5 APK:</p>
-<ul>
-<li><b>Q: Is DJ Studio 5 APK safe to download and use?</b></li>
-<li>A: Yes, DJ Studio 5 APK is safe to download and use. It does not contain any viruses, malware, or trackers. It also does not require any special access or permissions on your device.</li>
-<li><b>Q: How can I update DJ Studio 5 APK to the latest version?</b></li>
-<li>A: You can update DJ Studio 5 APK by downloading and installing the latest version of the app from the same source that you downloaded it from. You can also check for updates by tapping on the menu icon at the top left corner and selecting "Check for updates".</li>
-<li><b>Q: How can I support the developers of DJ Studio 5 APK?</b></li>
-<li>A: You can support the developers of DJ Studio 5 APK by rating and reviewing the app on the source that you downloaded it from. You can also purchase some optional paid skins to enhance your decks and support their work.</li>
-<li><b>Q: How can I contact the developers of DJ Studio 5 APK?</b></li>
-<li>A: You can contact the developers of DJ Studio 5 APK by sending them an email at [email protected]. You can also visit their website at www.beatronik.com or follow them on Facebook at www.facebook.com/beatronik.</li>
-<li><b>Q: How can I learn more about DJ Studio 5 APK?</b></li>
-<li>A: You can learn more about DJ Studio 5 APK by reading the help section in the app. To access it, tap on the gear icon at the top right corner and select "Help". You can also watch some tutorial videos on YouTube by searching for "DJ Studio 5 tutorial".</li>
-</ul></p> 197e85843d<br />
-<br />
-<br />

spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/Descubre Clash Mini APK el juego de batallas automticas en tiempo real con los personajes de Clash.md

@@ -1,131 +0,0 @@
-<br />
-<h1>Clash Mini APK Ultima Version 2022: A Fun and Strategy-Packed Board Game</h1>
-<p>If you are a fan of the Clash Universe, you will love Clash Mini, a new game from Supercell that combines fun, strategy, and board game elements. In this game, you will collect, summon, and upgrade your army of Minis, which are cute versions of your favorite Clash characters. You will also duel and Rumble with other players in real-time auto battles, where you will have to predict your opponent's moves and assemble your winning strategy and formation. Clash Mini is a game of choices, where every decision matters.</p>
-<p>In this article, we will show you how to download and install Clash Mini APK Ultima Version 2022 on your Android device, how to play Clash Mini and win battles, what's new in Clash Mini APK Ultima Version 2022, and the pros and cons of this game. We will also answer some frequently asked questions about Clash Mini APK Ultima Version 2022. So, let's get started!</p>
-<h2>clash mini apk ultima version 2022</h2><br /><p><b><b>Download Zip</b> &raquo;&raquo;&raquo; <a href="https://urlin.us/2uSXo8">https://urlin.us/2uSXo8</a></b></p><br /><br />
- <h2>How to Download and Install Clash Mini APK on Your Android Device</h2>
-<p>Clash Mini is not yet available on Google Play Store, but you can download it from the official website of Clash Mini or use one of the links below:</p>
-<ul>
-<li><a href="(^1^)">Clash Mini APK (Android Game) - Free Download - APKCombo</a></li>
-<li><a href="(^2^)">Descargar Clash Mini APK - Última Versión 2023 - APKCombo</a></li>
-</ul>
-<p>Here are the steps to download and install Clash Mini APK on your Android device:</p>
-<ol>
-<li>Go to the official website of Clash Mini or use one of the links above.</li>
-<li>Tap on the download button and wait for the APK file to be downloaded.</li>
-<li>Enable unknown sources in your device settings if you haven't done so already. This will allow you to install apps from sources other than Google Play Store.</li>
-<li>Locate the downloaded APK file and tap on it to start the installation process.</li>
-<li>Follow the on-screen instructions and grant the necessary permissions to the app.</li>
-<li>Launch the app and enjoy playing Clash Mini on your Android device.</li>
-</ol>
- <h2>How to Play Clash Mini and Win Battles</h2>
-<p>Clash Mini is a game of choices, where you will have to make smart decisions before and during each battle. <h2>How to Play Clash Mini and Win Battles</h2>
-<p>Clash Mini is a game of choices, where you will have to make smart decisions before and during each battle. Here are some tips and tricks to help you play Clash Mini and win battles:</p>
-<ul>
-<li><b>Choosing the Right Characters:</b> Not all characters are created equal. Each character has its strengths and weaknesses, as well as a special ability that can be activated once per battle. You will have to choose your characters wisely, based on their roles, abilities, and synergies. For example, some characters are good at dealing damage, some are good at tanking damage, some are good at healing or buffing allies, and some are good at disrupting or debuffing enemies. You will also have to consider the cost of each character, as you will have a limited amount of gold to spend on each round.</li>
-<li><b>Positioning on the Battlefield:</b> The positioning of your characters on the battlefield plays a crucial role in determining the outcome of the game. You will have to place your characters strategically, based on their range, direction, and area of effect. For example, some characters can attack from a distance, some can attack in a straight line, some can attack in a cone shape, and some can attack in an area around them. You will also have to consider the terrain of the board, as some tiles can provide bonuses or penalties to your characters. For example, some tiles can increase or decrease the damage or health of your characters, some tiles can block or allow movement, and some tiles can trigger special effects.</li>
-<li><b>Utilizing Special Abilities:</b> Each character in Clash Mini has a special ability that can be activated once per battle. These abilities can make a huge difference in the game, as they can provide powerful effects such as healing, shielding, stunning, freezing, burning, or summoning. You will have to use your special abilities wisely, based on the situation and timing of the battle. For example, some abilities are best used at the beginning of the battle, some are best used in the middle of the battle, and some are best used at the end of the battle. You will also have to consider the cooldown and duration of each ability, as well as the interaction with other abilities.</li>
-<li><b>Participating in Duels and Rumbles:</b> Clash Mini offers two modes of play: Duels and Rumbles. In Duels, you will face one opponent at a time in a best-of-three match. In Rumbles, you will face seven opponents at once in a free-for-all match. Both modes offer different challenges and rewards. In Duels, you will have to adapt to your opponent's strategy and formation, as well as use your gold efficiently. In Rumbles, you will have to survive against multiple enemies and use your abilities effectively. Both modes offer trophies that can increase your league ranking and unlock new rewards.</li>
-</ul>
- <h2>What's New in Clash Mini APK Ultima Version 2022</h2>
-<p>Clash Mini APK Ultima Version 2022 is the latest update of Clash Mini that includes new features, improvements, and bug fixes. Here are some of the highlights of Clash Mini APK Ultima Version 2022:</p>
-<ul>
-<li><b>New Minis:</b> Clash Mini APK Ultima Version 2022 introduces four new Minis to the game: Lumberjack, Ice Wizard, Electro Dragon, and Princess. Each new Mini has a unique ability and role that can add more variety and fun to your battles.</li>
-<li><b>New Boards:</b> Clash Mini APK Ultima Version 2022 adds two new boards to the game: Frozen Peak and Electro Valley. Each new board has a different theme and terrain that can affect your strategy and formation.</li>
-<li><b>New Skins:</b> Clash Mini APK Ultima Version 2022 brings new skins for your Heroes and Minis that can customize their appearance and style. You can unlock new skins by completing quests or purchasing them with gems.</li>
-<li><b>New Features:</b> Clash Mini APK Ultima Version 2022 also adds new features such as chat system, clan system, replay system, leaderboard system, achievement system, and more. These features can enhance your social and competitive experience in Clash Mini.</li>
-<li><b>Bug Fixes and Performance Improvements:</b> Clash Mini APK Ultima Version 2022 also fixes some bugs and improves the performance of the game. These changes can make your gameplay smoother and more enjoyable.</li>
-</ul>
- <h2>Pros and Cons of Clash Mini APK Ultima Version 2022</h2>
-<p>Clash Mini APK Ultima Version 2022 is a fun and strategy-packed board game that offers many advantages and disadvantages. Here is a table comparing the pros and <h2>Pros and Cons of Clash Mini APK Ultima Version 2022</h2>
-<p>Clash Mini APK Ultima Version 2022 is a fun and strategy-packed board game that offers many advantages and disadvantages. Here is a table comparing the pros and cons of Clash Mini APK Ultima Version 2022:</p>
-<p>clash mini apk download latest version 2022<br />
-clash mini apk mod ultima version 2022<br />
-clash mini apk android game free download<br />
-clash mini apk ultima version 2022 para pc<br />
-clash mini apk ultima version 2022 sin conexion<br />
-clash mini apk ultima version 2022 actualizada<br />
-clash mini apk ultima version 2022 mega<br />
-clash mini apk ultima version 2022 mediafire<br />
-clash mini apk ultima version 2022 hackeada<br />
-clash mini apk ultima version 2022 full<br />
-clash mini apk ultima version 2022 gratis<br />
-clash mini apk ultima version 2022 premium<br />
-clash mini apk ultima version 2022 pro<br />
-clash mini apk ultima version 2022 unlocked<br />
-clash mini apk ultima version 2022 unlimited<br />
-clash mini apk ultima version 2022 offline<br />
-clash mini apk ultima version 2022 online<br />
-clash mini apk ultima version 2022 no root<br />
-clash mini apk ultima version 2022 sin publicidad<br />
-clash mini apk ultima version 2022 con todo desbloqueado<br />
-clash mini apk ultima version 2022 con gemas infinitas<br />
-clash mini apk ultima version 2022 con monedas ilimitadas<br />
-clash mini apk ultima version 2022 con todos los personajes<br />
-clash mini apk ultima version 2022 con todos los niveles<br />
-clash mini apk ultima version 2022 con todos los modos de juego<br />
-clash mini apk ultima version 2022 con graficos mejorados<br />
-clash mini apk ultima version 2022 con sonido optimizado<br />
-clash mini apk ultima version 2022 con controles personalizados<br />
-clash mini apk ultima version 2022 con soporte para gamepad<br />
-clash mini apk ultima version 2022 con compatibilidad para android tv y tablet<br />
-clash mini apk ultima version 2022 review y gameplay<br />
-clash mini apk ultima version 2022 tutorial y guia<br />
-clash mini apk ultima version 2022 trucos y consejos<br />
-clash mini apk ultima version 2022 codigos y regalos<br />
-clash mini apk ultima version 2022 noticias y novedades<br />
-clash mini apk ultima version 2022 requisitos y especificaciones<br />
-clash mini apk ultima version 2022 instalacion y configuracion<br />
-clash mini apk ultima version 2022 opiniones y valoraciones<br />
-clash mini apk ultima version 2022 comparacion y diferencias<br />
-clash mini apk ultima version 2022 ventajas y desventajas</p>
- <table>
-<tr>
-<th>Pros</th>
-<th>Cons</th>
-</tr>
-<tr>
-<td>- Easy to download and install on your Android device</td>
-<td>- Not available on Google Play Store or other platforms</td>
-</tr>
-<tr>
-<td>- Simple and intuitive gameplay with a lot of choices and depth</td>
-<td>- Requires internet connection and may consume data or battery</td>
-</tr>
-<tr>
-<td>- Cute and colorful graphics and animations with a Clash Universe theme</td>
-<td>- May have some bugs or glitches that affect the performance or experience</td>
-</tr>
-<tr>
-<td>- A variety of characters, boards, skins, and features to unlock and enjoy</td>
-<td>- Some items or features may require gems or real money to purchase or access</td>
-</tr>
-<tr>
-<td>- A social and competitive mode with duels, rumbles, chat, clan, leaderboard, and more</td>
-<td>- May encounter some toxic or unfair players or situations in the game</td>
-</tr>
-</table>
- <h2>Conclusion and FAQs</h2>
-<p>Clash Mini APK Ultima Version 2022 is a fun and strategy-packed board game that you can play on your Android device. It is a game of choices, where you will have to collect, summon, and upgrade your army of Minis, as well as duel and Rumble with other players in real-time auto battles. Clash Mini APK Ultima Version 2022 also offers new Minis, boards, skins, and features that can enhance your gameplay. However, Clash Mini APK Ultima Version 2022 also has some drawbacks, such as not being available on Google Play Store or other platforms, requiring internet connection, having some bugs or glitches, requiring gems or real money for some items or features, and encountering some toxic or unfair players or situations.</p>
- <p>If you are interested in playing Clash Mini APK Ultima Version 2022, you can download it from the official website of Clash Mini or use one of the links below:</p>
- <ul>
-<li><a href="">Clash Mini APK (Android Game) - Free Download - APKCombo</a></li>
-<li><a href="">Descargar Clash Mini APK - Última Versión 2023 - APKCombo</a></li>
-</ul>
- <p>We hope this article has helped you learn more about Clash Mini APK Ultima Version 2022. If you have any questions about Clash Mini APK Ultima Version 2022, you can check out the FAQs below or leave a comment. Thank you for reading!</p>
- <h3>FAQs</h3>
- <ol>
-<li><b>What is Clash Mini?</b></li>
-<p>Clash Mini is a new game from Supercell that combines fun, strategy, and board game elements. It is set in the Clash Universe, where you will collect, summon, and upgrade your army of Minis, which are cute versions of your favorite Clash characters. You will also duel and Rumble with other players in real-time auto battles, where you will have to predict your opponent's moves and assemble your winning strategy and formation.</p>
- <li><b>Is Clash Mini free to play?</b></li>
-<p>Yes, Clash Mini is free to play. You can download and install it on your Android device without paying anything. However, some items or features in the game may require gems or real money to purchase or access. You can earn gems by completing quests or watching ads, or you can buy them with real money. You can also disable in-app purchases in your device settings if you don't want to spend any money on the game.</p>
- <li><b>Is Clash Mini safe to download and install?</b></li>
-<p>Yes, Clash Mini is safe to download and install. It is developed by Supercell, a reputable game company that has created other popular games such as Clash of Clans, Clash Royale, Brawl Stars, and Hay Day. The APK file of Clash Mini is also scanned for viruses and malware before being uploaded to the official website of Clash Mini or other sources. However, you should always be careful when downloading and installing apps from unknown sources. You should only download and install apps from trusted sources such as the official website of the app developer or Google Play Store.</p>
- <li><b>How can I update Clash Mini to the latest version?</b></li>
-<p>You can update Clash Mini to the latest version by following the same steps as downloading and installing it. You will <li><b>How can I update Clash Mini to the latest version?</b></li>
-<p>You can update Clash Mini to the latest version by following the same steps as downloading and installing it. You will have to go to the official website of Clash Mini or use one of the links above, and download the latest APK file of Clash Mini. Then, you will have to install it on your device, replacing the old version. You may also receive a notification in the game when a new update is available, and you can tap on it to update the game.</p>
- <li><b>Can I play Clash Mini with my friends?</b></li>
-<p>Yes, you can play Clash Mini with your friends. You can join or create a clan with your friends, and chat, share, and battle with them. You can also invite your friends to join your Rumble or Duel, and compete with them or against them. You can also add your friends as contacts in the game, and see their online status, profile, and trophies.</p>
-</ol></p> 197e85843d<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Download Video TikTok Without Watermark - Fast Easy and Free - Online TikTok Video Download.md

@@ -1,144 +0,0 @@
-<br />
-<h1>How to Download Online from TikTok</h1>
-<p>TikTok is one of the most popular social media apps in the world, with over 1 billion active users. It allows users to create and share short videos with music and effects, covering various topics such as comedy, education, beauty, sports, and more. But what if you want to download online from TikTok and save your favorite videos for offline viewing or sharing? In this article, we will show you how to download online from TikTok with or without a watermark, as well as some of the benefits of doing so.</p>
- <h2>What Is TikTok and Why Download Videos from It?</h2>
-<h3>TikTok is a popular social media app that allows users to create and share short videos with music and effects.</h3>
-<p>TikTok was launched in 2016 as a global version of Douyin, a Chinese video-sharing app. It has since grown into one of the most downloaded apps in the world, surpassing Facebook, Instagram, YouTube, and Snapchat. Users can create videos up to 60 seconds long using various filters, stickers, transitions, and soundtracks. They can also browse through millions of videos uploaded by other users in different categories such as For You, Following, Trending, Discover, etc.</p>
-<h2>download online from tiktok</h2><br /><p><b><b>Download</b> &#128505; <a href="https://jinyurl.com/2uNJjo">https://jinyurl.com/2uNJjo</a></b></p><br /><br />
- <h3>Downloading videos from TikTok can help you save your favorite content, share it with others, or use it for other purposes.</h3>
-<p>There are many reasons why you might want to download online from TikTok and save the videos on your device. For example, you might want to:</p>
-<ul>
-<li>Watch your favorite videos offline without internet connection or data usage.</li>
-<li>Edit your downloaded videos with other apps or software and create new content.</li>
-<li>Share your downloaded videos with your friends or family on other platforms or channels, such as WhatsApp, Facebook, Instagram, YouTube, etc.</li>
-<li>Use your downloaded videos for educational, personal, or professional purposes, such as learning new skills, making presentations, creating portfolios, etc.</li>
-</ul>
-<p>Downloading online from TikTok can also help you avoid losing your favorite videos if they are deleted by the creator or the platform for some reason. You can always have a backup of your favorite content on your device.</p>
-<p>How to download TikTok videos without watermark<br />
-TikTok video downloader no logo online<br />
-Save TikTok videos in HD quality MP4 format<br />
-Download TikTok videos on mobile phone or PC<br />
-TikTok video download without watermark app<br />
-TikTok downloader without watermark - ssstik.io<br />
-TikTok downloader - SnapTik.App<br />
-Download video tiktok without a watermark for free<br />
-TikTok video download without watermark - SnapTik<br />
-How to get the TikTok video download link<br />
-Download TikTok videos (Musically) without logo online<br />
-Save non watermarked TikTok videos<br />
-Remove watermark from TikTok videos<br />
-Download TikTok videos with no trademark<br />
-TikTok video download at high speed<br />
-Save TikTok video without watermark in mp4 or mp3 online<br />
-TikTok downloader works in every browser and operating system<br />
-Download TikTok video on mobile phone using TT app<br />
-Save TikTok without watermark on PC, laptop, Mac, or Linux<br />
-Download by using your browsers - no need to install any software<br />
-Download TikTok videos unlimited - no limits or any other restrictions<br />
-Download SnapTik Android App for downloading TikTok videos<br />
-How to use the TikTok video downloader without watermark app<br />
-Download TikTok photo slide show as Mp4 Video format<br />
-Download each image in the slide show to your computer right away<br />
-How to download video tiktok no watermark using SnapTik.App<br />
-How to save TikTok videos or remove TikTok watermark on Android phones<br />
-How to download TikTok without watermark using sssTik.io<br />
-How to save non watermarked TikTok videos on iPhone or iPad<br />
-How to download TikTok videos on Windows 10, 8, 7, XP, Vista, or Mac OS X<br />
-How to download TikTok videos with sound or music<br />
-How to download private or live TikTok videos without watermark<br />
-How to download multiple or bulk TikTok videos at once<br />
-How to download TikTok videos by username or hashtag<br />
-How to download trending or viral TikTok videos without watermark<br />
-How to edit or trim downloaded TikTok videos without watermark<br />
-How to convert downloaded TikTok videos to GIFs or memes<br />
-How to upload downloaded TikTok videos to Instagram, YouTube, Facebook, or Twitter<br />
-How to watch downloaded TikTok videos offline or without internet connection<br />
-How to download high-quality or 4K resolution TikTok videos without watermark</p>
- <h2>How to Download TikTok Videos with the Watermark</h2>
-<h3>The easiest way to download TikTok videos is to use the built-in save option in the app or the website.</h3>
-<p>If you want to download online from TikTok in a simple and quick way, you can use the save option that is available in the app or the website. Here are the steps to follow:</p>
-<ol>
-<li>Open the TikTok app or website and find the video that you want to download.</li>
-<li>Tap on the share icon at the bottom right corner of the video screen.</li>
-<li>Select Save video from the list of options that appear.</li>
-<li>Wait for the video to be downloaded and saved on your device.</li>
-</ol>
-<p>You can find your downloaded videos in your device's gallery or camera roll. You can also access them from the app by tapping on Me > Saved videos.</p>
- <h3>However, this method will leave a watermark with the TikTok logo and the creator's name on the video.</h3>
-<p>One drawback of using the save option is that it will leave a watermark on the downloaded video. The watermark will show the TikTok logo and the username of the creator at the top left corner of the video. This can be annoying or distracting for some users who want to enjoy or use the video without any logo. It can also affect the quality or appearance of the video. If you want to download online from TikTok without a watermark, you need to use other methods that we will discuss in the next section.</p>
- <h2>How to Download TikTok Videos without the Watermark</h2>
-<h3>To remove the watermark from TikTok videos, you need to use third-party tools that can download videos without the logo.</h3>
-<p>Fortunately, there are many tools available online that can help you download online from TikTok without a watermark. These tools are usually websites or apps that allow you to paste the link of the TikTok video and download it in MP4 or MP3 format without any logo. Some of these tools also offer other features such as downloading multiple videos at once, choosing different resolutions or qualities, cropping or trimming the video, etc.</p>
- <h3>Some of the best tools for downloading online from TikTok are SSSTik.io, SnapTik.App, TTVDL, and TikFast.</h3>
-<p>We have tested and reviewed some of the most popular and reliable tools for downloading online from TikTok without a watermark. Here are our top picks and how to use them:</p>
- <h4>SSSTik.io</h4>
-<h5>A free tool that helps you download TikTok videos without logo online in MP4 or MP3 format.</h5>
-<p>To use SSSTik.io, follow these steps:</p>
-<ol>
-<li>Open SSSTik.io website on your browser.</li>
-<li>Copy and paste the link of the TikTok video that you want to download in the text field on the website and tap on the save button.</li>
-<li>Choose the format that you want to download, either MP4 or MP3.</li>
-<li>Tap on the download button and wait for the video to be downloaded and saved on your device.</li>
-</ol>
-<p>You can also use SSSTik.io to download TikTok videos by adding "sss" before "tiktok.com" in the video link. For example, if the video link is https://www.tiktok.com/@user/video/123456789, you can change it to https://www.ssstiktok.com/@user/video/123456789 and paste it in the text field on the website.</p>
- <h4>SnapTik.App</h4>
-<h5>One of the best TikTok downloaders available online that allows you to download video tiktok without a watermark.</h5>
-<p>To use SnapTik.App, follow these steps:</p>
-<ol>
-<li>Open SnapTik.App website on your browser.</li>
-<li>Copy and paste the link of the TikTok video that you want to download in the input field on the website and click on the download button.</li>
-<li>Choose the quality that you want to download, either high quality or low quality.</li>
-<li>Click on the download button and wait for the video to be downloaded and saved on your device.</li>
-</ol>
-<p>You can also use SnapTik.App to download TikTok videos by adding "snaptik" before "app" in the video link. For example, if the video link is https://www.tiktok.com/@user/video/123456789, you can change it to https://www.snaptik.app/@user/video/123456789 and paste it in the input field on the website.</p>
- <h4>TTVDL</h4>
-<h5>A TikTok video downloader that downloads TikTok MP4 videos without a watermark or logo.</h5>
-<p>To use TTVDL, follow these steps:</p>
-<ol>
-<li>Open TTVDL website on your browser.</li>
-<li>Copy and paste the link of the TikTok video that you want to download in the input field on the website and hit enter or click download button.</li>
-<li>Choose the resolution that you want to download, either 720p or 360p.</li>
-<li>Click on the download button and wait for the video to be downloaded and saved on your device.</li>
-</ol>
- <h4>TikFast</h4>
-<h5>A tool that allows you to download Tik-Tok videos from tiktok.com in high quality without any trademark.</h5>
-<p>To use TikFast, follow these steps:</p>
-<ol>
-<li>Open TikFast website on your browser.</li>
-<li>Copy and paste the link of the TikTok video that you want to download in the input field on the website and hit enter or click download button.</li>
-<li>Choose the quality that you want to download, either original or compressed.</li>
-<li>Click on the download button and wait for the video to be downloaded and saved on your device.</li>
-</ol>
- <h2>Benefits of Downloading Online from TikTok</h2>
-<h3>Downloading online from TikTok can offer you many benefits, such as:</h3>
-<ul>
-<li><h4>Saving your favorite content for offline viewing or editing.</h4>
-<p>By downloading online from TikTok, you can save your favorite videos on your device and watch them anytime, anywhere, without internet connection or data usage. You can also edit your downloaded videos with other apps or software and create new content according to your preferences.</p></li>
-<li><h4>Sharing your downloaded videos with others on different platforms or channels.</h4>
-<p>By downloading online from TikTok, you can share your favorite videos with your friends or family on other platforms or channels, such as WhatsApp, Facebook, Instagram, YouTube, etc. You can also use your downloaded videos for educational, personal, or professional purposes, such as making presentations, creating portfolios, etc.</p></li>
-<li><h4>Learning new skills, recipes, dances, or trends from TikTok videos.</h4>
-<p>By downloading online from TikTok, you can learn new skills, recipes, dances, or trends from TikTok videos. You can follow the instructions or tips from the creators and improve your knowledge or abilities. You can also practice or perform the skills, recipes, dances, or trends that you learned from TikTok videos.</p></li>
-<li><h4>Enjoying funny, creative, and entertaining content from TikTok creators.</h4>
-<p>By downloading online from TikTok, you can enjoy funny, creative, and entertaining content from TikTok creators. You can watch the videos that make you laugh, inspire you, amaze you, or touch you. You can also appreciate the talent and effort of the creators and support them by liking or commenting on their videos.</p></li>
-</ul>
- <h2>Conclusion</h2>
-<h3>TikTok is a great app for creating and watching short videos with music and effects.</h3>
-<p>TikTok is one of the most popular social media apps in the world that allows users to create and share short videos with music and effects. It covers various topics such as comedy, education, beauty, sports, and more. It has over 1 billion active users who upload millions of videos every day.</p>
- <h3>If you want to download online from TikTok, you can use the built-in save option or third-party tools that can remove the watermark from the videos.</h3>
-<p>If you want to download online from TikTok and save your favorite videos for offline viewing or sharing, you can use the save option that is available in the app or the website. However, this method will leave a watermark with the TikTok logo and the creator's name on the video. If you want to remove the watermark from TikTok videos, you need to use third-party tools that can download videos without the logo. Some of the best tools for downloading online from TikTok are SSSTik.io, SnapTik.App, TTVDL, and TikFast. These tools are easy to use and can download TikTok videos in high quality without any trademark.</p>
- <h3>Downloading online from TikTok can help you save, share, or use your favorite content for various purposes.</h3>
-<p>Downloading online from TikTok can offer you many benefits, such as saving your favorite content for offline viewing or editing, sharing your downloaded videos with others on different platforms or channels, learning new skills, recipes, dances, or trends from TikTok videos, and enjoying funny, creative, and entertaining content from TikTok creators. You can also avoid losing your favorite videos if they are deleted by the creator or the platform for some reason.</p>
- <p>We hope this article has helped you learn how to download online from TikTok with or without a watermark. If you have any questions or feedback, please feel free to leave a comment below. Happy downloading!</p>
- <h2>FAQs</h2>
-<h3>Q: Is it legal to download online from TikTok?</h3>
-<p>A: It depends on the terms and conditions of the app and the website, as well as the copyright laws of your country. Generally, it is legal to download online from TikTok for personal use only, as long as you do not violate the rights of the creators or the platform. However, it is illegal to download online from TikTok for commercial use or distribution without the permission of the creators or the platform.</p>
- <h3>Q: How can I download online from TikTok on my iPhone or iPad?</h3>
-<p>A: You can use the same methods that we have mentioned in this article to download online from TikTok on your iPhone or iPad. However, you might need to install a file manager app such as Documents by Readdle or Files by Apple to access and manage your downloaded videos on your device.</p>
- <h3>Q: How can I download online from TikTok on my Android phone or tablet?</h3>
-<p>A: You can use the same methods that we have mentioned in this article to download online from TikTok on your Android phone or tablet. However, you might need to enable unknown sources in your device settings to install some of the third-party apps that we have recommended.</p>
- <h3>Q: How can I download online from TikTok on my PC or Mac?</h3>
-<p>A: You can use the same methods that we have mentioned in this article to download online from TikTok on your PC or Mac. However, you might need to install a video player app such as VLC Media Player or QuickTime Player to play your downloaded videos on your computer.</p>
- <h3>Q: How can I download online from TikTok with sound?</h3>
-<p>A: You can use any of the methods that we have mentioned in this article to download online from TikTok with sound. However, some of the tools might offer you an option to download only the video without sound or only the sound without video. In that case, you need to choose the option that includes both video and sound.</p> 401be4b1e0<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Download the Word Game that Keeps You on Your Toes Word Blitz.md

@@ -1,106 +0,0 @@
-<br />
-<h1>How to Download the Best Word Games for Android and iOS</h1>
-<p>Do you love playing with words and letters? Do you want to improve your vocabulary, spelling, memory, focus, and brain health? If you answered yes to these questions, then you should try playing word games on your mobile device. Word games are fun and challenging puzzles that involve forming, finding, or guessing words according to certain rules. They can also help you relax, unwind, and learn something new every day.</p>
-<h2>download the word game</h2><br /><p><b><b>Download Zip</b> &bull;&bull;&bull; <a href="https://jinyurl.com/2uNKW0">https://jinyurl.com/2uNKW0</a></b></p><br /><br />
-<p>In this article, we will show you how to download word games for your Android or iOS device. We will also recommend some of the best word games that you can play on your phone or tablet. Whether you prefer crossword puzzles, anagrams, word searches, or picture clues, there is a word game for everyone. So, let's get started!</p>
- <h2>What are word games and why should you play them?</h2>
-<h3>Word games are fun and challenging puzzles that involve words and letters</h3>
-<p>Word games are a type of puzzle game that requires you to use your language skills to solve them. There are many kinds of word games, such as letter arrangement games, paper and pencil games, semantic games, modern word games, and more. Some examples of word games are Scrabble, Boggle, Hangman, Crosswords, Wordament, etc.</p>
-<p>Word games can be played alone or with others, online or offline, on a board or on a screen. They can also vary in difficulty, theme, genre, and style. Some word games are based on logic, some on creativity, some on trivia, some on humor, and some on strategy. No matter what kind of word game you choose, you will always have a good time playing it.</p>
- <h3>Word games can improve your vocabulary, spelling, memory, focus, and brain health</h3>
-<p>Playing word games is not only fun but also beneficial for your mind and body. Word games can help you improve your vocabulary by exposing you to new words and their meanings. They can also help you improve your spelling by making you pay attention to the correct order of letters. They can also help you improve your memory by making you recall words that you have learned before. They can also help you improve your focus by making you concentrate on finding or forming words within a limited time or space.</p>
-<p>Moreover, playing word games can boost your brain health by stimulating your cognitive abilities. Research has shown that playing word games can reduce the risk of dementia , enhance your verbal skills , increase your creativity , and release dopamine , which is a neurotransmitter that makes you feel good. Playing word games can also relieve stress , improve your social skills , enhance your concentration , and increase your confidence .</p>
-<p>download the best word game for free<br />
-how to download the word game on your device<br />
-download the word game and challenge your friends<br />
-download the word game with the most levels<br />
-download the word game that improves your vocabulary<br />
-download the word game that is fun and educational<br />
-download the word game that works offline<br />
-download the word game that has no ads<br />
-download the word game that supports multiple languages<br />
-download the word game that is easy to play<br />
-download the word game that is addictive and engaging<br />
-download the word game that is suitable for all ages<br />
-download the word game that has a leaderboard and achievements<br />
-download the word game that has daily puzzles and rewards<br />
-download the word game that has a variety of modes and themes<br />
-download the word game that is updated regularly<br />
-download the word game that has a user-friendly interface<br />
-download the word game that has a high rating and positive reviews<br />
-download the word game that is compatible with your device<br />
-download the word game that is secure and safe<br />
-download the word game that is fast and smooth<br />
-download the word game that is developed by a reputable company<br />
-download the word game that is featured on the app store<br />
-download the word game that is recommended by experts<br />
-download the word game that is popular and trending<br />
-download the new version of the word game<br />
-download the latest update of the word game<br />
-download the premium version of the word game<br />
-download the pro version of the word game<br />
-download the full version of the word game<br />
-download the modded version of the word game<br />
-download the hacked version of the word game<br />
-download the cracked version of the word game<br />
-download the unlocked version of the word game<br />
-download the cheat codes for the word game<br />
-download the tips and tricks for the word game<br />
-download the guide and walkthrough for the word game<br />
-download the solutions and answers for the word game<br />
-download the hints and clues for the word game<br />
-download the bonus content for the word game</p>
- <h2>How to download word games for your mobile device?</h2>
-<h3>Choose a word game that suits your preference and skill level</h3>
-<p>The first step to downloading a word game for your mobile device is to choose one that suits your preference and skill level <li>Tap on the app icon and then tap on the install button.</li>
-<li>Wait for the app to download and install on your device.</li>
-<li>Tap on the open button or find the app icon on your home screen and tap on it.</li>
-</ol>
-<p>To install an app from the web , you should follow these steps:</p>
-<ol>
-<li>Open the web browser on your device.</li>
-<li>Go to the website of the word game that you want to download.</li>
-<li>Look for the download link or button and tap on it.</li>
-<li>Wait for the app to download on your device.</li>
-<li>Go to your device settings and enable the option to install apps from unknown sources.</li>
-<li>Find the downloaded file on your device and tap on it.</li>
-<li>Follow the instructions to install and launch the app.</li>
-</ol>
-<p>To launch an app , you should follow these steps:</p>
-<ol>
-<li>Find the app icon on your home screen or app drawer and tap on it.</li>
-<li>Wait for the app to load and display its main screen.</li>
-<li>Follow the instructions or prompts to start playing the word game.</li>
-</ol>
- <h2>What are some of the best word games for Android and iOS?</h2>
-<h3>Wordscapes: A relaxing and addictive crossword puzzle game</h3>
-<p>If you love crossword puzzles, you will love Wordscapes. Wordscapes is a word game that combines the best of crossword and word search games. You have to swipe letters to form words that fit into a crossword grid. You can also use hints, shuffles, or coins to help you solve the puzzles. Wordscapes has over 10,000 levels with beautiful backgrounds and themes. You can also play daily puzzles and challenges to earn rewards and bonuses. Wordscapes is a relaxing and addictive word game that will keep you entertained for hours.</p>
- <h3>Wordalot: A unique and challenging word game with pictures</h3>
-<p>If you love picture clues, you will love Wordalot. Wordalot is a word game that challenges you to find words hidden in pictures. You have to look at the picture carefully and use your imagination and logic to figure out the words. You can also use hints or coins to reveal letters or words. Wordalot has over 1,000 levels with stunning graphics and animations. You can also play with friends and compare your scores and progress. Wordalot is a unique and challenging word game that will test your visual and verbal skills.</p>
- <h3>Pictoword: A fun and creative word game that combines two images</h3>
-<p>If you love word association, you will love Pictoword. Pictoword is a word game that asks you to guess a word or phrase based on two images. You have to look at the images and think of how they can be combined to form a new word or phrase. For example, if you see a picture of a sand and a witch, you can guess the word "sandwich". You can also use hints or coins to reveal letters or words. Pictoword has over 300 levels with different categories, such as celebrities, movies, brands, etc. You can also play with friends and family in multiplayer mode or create your own puzzles. Pictoword is a fun and creative word game that will make you think outside the box.</p>
- <h3>Bonza Word Puzzle: A clever and original word game that mixes crossword and jigsaw</h3>
-<p>If you love jigsaw puzzles, you will love Bonza Word Puzzle. Bonza Word Puzzle is a word game that blends crossword and jigsaw puzzles. You have to arrange fragments of words to form a complete crossword puzzle. You can also rotate, move, or zoom in on the fragments to fit them better. Bonza Word Puzzle has hundreds of levels with different themes, such as animals, music, food, etc. You can also play daily puzzles and challenges to earn coins and badges. You can also create your own puzzles and share them with other players. Bonza Word Puzzle is a clever and original word game that will challenge your brain and vocabulary.</p>
- <h3>Words with Friends: A popular and social word game that lets you play with friends online</h3>
-<p>If you love Scrabble, you will love Words with Friends. Words with Friends is a word game that lets you play with friends online. You have to form words on a board using letter tiles. You can also use special tiles, such as blanks, double letters, triple words, etc., to score more points. Words with Friends has millions of players around the world that you can chat and compete with. You can also play solo games against the computer or join tournaments and events. Words with Friends is a popular and social word game that will connect you with other word lovers.</p>
- <h2>Conclusion</h2>
-<h3>Word games are a great way to have fun and learn new words on your mobile device</h3>
-<p>Word games are one of the most popular and enjoyable genres of games that you can play on your mobile device. They are fun and challenging puzzles that involve words and letters. They can also help you improve your vocabulary, spelling, memory, focus, and brain health. They can also help you relax, unwind, and learn something new every day.</p>
- <h3>You can download word games easily from the app store or the web</h3>
-<p>Downloading word games for your mobile device is easy and convenient. You can download word games from the app store or the web. You just need to choose a word game that suits your preference and skill level, check its compatibility, ratings, reviews, and permissions, and follow the instructions to install and launch it. You can also update, delete, or reinstall the app anytime you want.</p>
- <h3>You can choose from a variety of word games that suit your taste and skill level</h3>
-<p>There are hundreds of word games available on the app store or the web, so you have plenty of options to choose from. You can choose from different kinds of word games, such as crossword puzzles, anagrams, word searches, picture clues, etc. You can also choose from different levels of difficulty, themes, genres, and styles. You can also play with friends or strangers online or offline. You can also create your own puzzles or play puzzles created by other players.</p>
-<p>Some of the best word games for Android and iOS are Wordscapes, Wordalot, Pictoword, Bonza Word Puzzle, and Words with Friends. These word games are fun, addictive, unique, challenging, and social. They will keep you entertained for hours and make you fall in love with words.</p>
- <h2>FAQs</h2>
-<h4>Q: How do I download word games for free?</h4>
-<p>A: Most word games are free to download from the app store or the web. However, some word games may have in-app purchases or ads that require you to pay money to access certain features or functions. You can also look for word games that offer free trials or discounts.</p>
- <h4>Q: How do I play word games offline?</h4>
-<p>A: Some word games can be played offline without an internet connection. However, some word games may require an internet connection to access certain features or functions, such as multiplayer modes, daily puzzles, updates, etc. You can check the description or settings of the app to see if it supports offline mode.</p>
- <h4>Q: How do I improve my word game skills?</h4>
-<p>A: The best way to improve your word game skills is to practice regularly and learn from your mistakes. You can also use hints or coins to help you solve difficult puzzles. You can also read books, magazines, newspapers, or websites to expand your vocabulary and knowledge. You can also play with friends or other players online to learn from their strategies and tips.</p>
- <h4>Q: How do I find new word games to play?</h4>
-<p>A: The easiest way to find new word games to play is to browse through the app store or the web. You can also search for keywords or categories that interest you. You can also read reviews or recommendations from other users or experts. You can also join online communities or forums that discuss word games.</p>
- <h4>Q: How do I create my own word game puzzles?</h4>
-<p>A: Some word games allow you to create your own puzzles and share them with other players. You can use your creativity and imagination to come up with interesting words and clues. You can also use online tools or generators to help you create puzzles. You can also edit or customize existing puzzles to make them more challenging or fun.</p> 197e85843d<br />
-<br />
-<br />

spaces/AIGC-Audio/AudioGPT/NeuralSeq/inference/tts/GenerSpeech.py

@@ -1,123 +0,0 @@
-import torch
-import os
-import importlib
-from inference.tts.base_tts_infer import BaseTTSInfer
-from utils.ckpt_utils import load_ckpt, get_last_checkpoint
-from modules.GenerSpeech.model.generspeech import GenerSpeech
-from data_gen.tts.emotion import inference as EmotionEncoder
-from data_gen.tts.emotion.inference import embed_utterance as Embed_utterance
-from data_gen.tts.emotion.inference import preprocess_wav
-from data_gen.tts.data_gen_utils import is_sil_phoneme
-from resemblyzer import VoiceEncoder
-from utils import audio
-class GenerSpeechInfer(BaseTTSInfer):
-    def build_model(self):
-        model = GenerSpeech(self.ph_encoder)
-        model.eval()
-        load_ckpt(model, self.hparams['work_dir'], 'model')
-        return model
-
-    def preprocess_input(self, inp):
-        """
-        :param inp: {'text': str, 'item_name': (str, optional), 'spk_name': (str, optional)}
-        :return:
-        """
-        # processed text
-        preprocessor, preprocess_args = self.preprocessor, self.preprocess_args
-        text_raw = inp['text']
-        item_name = inp.get('item_name', '<ITEM_NAME>')
-        ph, txt, word, ph2word, ph_gb_word = preprocessor.txt_to_ph(preprocessor.txt_processor, text_raw, preprocess_args)
-        ph_token = self.ph_encoder.encode(ph)
-
-        # processed ref audio
-        ref_audio = inp['ref_audio']
-        processed_ref_audio = 'example/temp.wav'
-        voice_encoder = VoiceEncoder().cuda()
-        encoder = [self.ph_encoder, self.word_encoder]
-        EmotionEncoder.load_model(self.hparams['emotion_encoder_path'])
-        binarizer_cls = self.hparams.get("binarizer_cls", 'data_gen.tts.base_binarizerr.BaseBinarizer')
-        pkg = ".".join(binarizer_cls.split(".")[:-1])
-        cls_name = binarizer_cls.split(".")[-1]
-        binarizer_cls = getattr(importlib.import_module(pkg), cls_name)
-
-        ref_audio_raw, ref_text_raw = self.asr(ref_audio)  # prepare text
-        ph_ref, txt_ref, word_ref, ph2word_ref, ph_gb_word_ref = preprocessor.txt_to_ph(preprocessor.txt_processor, ref_text_raw, preprocess_args)
-        ph_gb_word_nosil = ["_".join([p for p in w.split("_") if not is_sil_phoneme(p)]) for w in ph_gb_word_ref.split(" ") if not is_sil_phoneme(w)]
-        phs_for_align = ['SIL'] + ph_gb_word_nosil + ['SIL']
-        phs_for_align = " ".join(phs_for_align)
-
-        # prepare files for alignment
-        os.system('rm -r example/; mkdir example/')
-        audio.save_wav(ref_audio_raw, processed_ref_audio, self.hparams['audio_sample_rate'])
-        with open(f'example/temp.lab', 'w') as f_txt:
-            f_txt.write(phs_for_align)
-        os.system(f'mfa align example/ {self.hparams["binary_data_dir"]}/mfa_dict.txt {self.hparams["binary_data_dir"]}/mfa_model.zip example/textgrid/  --clean')
-        item2tgfn = 'example/textgrid/temp.TextGrid'  # prepare textgrid alignment
-
-        item = binarizer_cls.process_item(item_name, ph_ref, txt_ref, item2tgfn, processed_ref_audio, 0, 0, encoder, self.hparams['binarization_args'])
-        item['emo_embed'] = Embed_utterance(preprocess_wav(item['wav_fn']))
-        item['spk_embed'] = voice_encoder.embed_utterance(item['wav'])
-
-        item.update({
-            'ref_ph': item['ph'],
-            'ph': ph,
-            'ph_token': ph_token,
-            'text': txt
-        })
-        return item
-
-    def input_to_batch(self, item):
-        item_names = [item['item_name']]
-        text = [item['text']]
-        ph = [item['ph']]
-
-        txt_tokens = torch.LongTensor(item['ph_token'])[None, :].to(self.device)
-        txt_lengths = torch.LongTensor([txt_tokens.shape[1]]).to(self.device)
-        mels = torch.FloatTensor(item['mel'])[None, :].to(self.device)
-        f0 = torch.FloatTensor(item['f0'])[None, :].to(self.device)
-        # uv = torch.FloatTensor(item['uv']).to(self.device)
-        mel2ph = torch.LongTensor(item['mel2ph'])[None, :].to(self.device)
-        spk_embed = torch.FloatTensor(item['spk_embed'])[None, :].to(self.device)
-        emo_embed = torch.FloatTensor(item['emo_embed'])[None, :].to(self.device)
-
-        ph2word = torch.LongTensor(item['ph2word'])[None, :].to(self.device)
-        mel2word = torch.LongTensor(item['mel2word'])[None, :].to(self.device)
-        word_tokens = torch.LongTensor(item['word_tokens'])[None, :].to(self.device)
-
-        batch = {
-            'item_name': item_names,
-            'text': text,
-            'ph': ph,
-            'mels': mels,
-            'f0': f0,
-            'txt_tokens': txt_tokens,
-            'txt_lengths': txt_lengths,
-            'spk_embed': spk_embed,
-            'emo_embed': emo_embed,
-            'mel2ph': mel2ph,
-            'ph2word': ph2word,
-            'mel2word': mel2word,
-            'word_tokens': word_tokens,
-        }
-        return batch
-
-    def forward_model(self, inp):
-        sample = self.input_to_batch(inp)
-        txt_tokens = sample['txt_tokens']  # [B, T_t]
-        with torch.no_grad():
-            output = self.model(txt_tokens, ref_mel2ph=sample['mel2ph'], ref_mel2word=sample['mel2word'], ref_mels=sample['mels'],
-                                spk_embed=sample['spk_embed'], emo_embed=sample['emo_embed'], global_steps=300000, infer=True)
-            mel_out = output['mel_out']
-            wav_out = self.run_vocoder(mel_out)
-        wav_out = wav_out.squeeze().cpu().numpy()
-        return wav_out
-
-
-
-
-if __name__ == '__main__':
-    inp = {
-        'text': 'here we go',
-        'ref_audio': 'assets/0011_001570.wav'
-    }
-    GenerSpeechInfer.example_run(inp)

spaces/AIGC-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/AIGText/GlyphControl/ldm/modules/midas/api.py

@@ -1,170 +0,0 @@
-# based on https://github.com/isl-org/MiDaS
-
-import cv2
-import torch
-import torch.nn as nn
-from torchvision.transforms import Compose
-
-from ldm.modules.midas.midas.dpt_depth import DPTDepthModel
-from ldm.modules.midas.midas.midas_net import MidasNet
-from ldm.modules.midas.midas.midas_net_custom import MidasNet_small
-from ldm.modules.midas.midas.transforms import Resize, NormalizeImage, PrepareForNet
-
-
-ISL_PATHS = {
-    "dpt_large": "midas_models/dpt_large-midas-2f21e586.pt",
-    "dpt_hybrid": "midas_models/dpt_hybrid-midas-501f0c75.pt",
-    "midas_v21": "",
-    "midas_v21_small": "",
-}
-
-
-def disabled_train(self, mode=True):
-    """Overwrite model.train with this function to make sure train/eval mode
-    does not change anymore."""
-    return self
-
-
-def load_midas_transform(model_type):
-    # https://github.com/isl-org/MiDaS/blob/master/run.py
-    # load transform only
-    if model_type == "dpt_large":  # DPT-Large
-        net_w, net_h = 384, 384
-        resize_mode = "minimal"
-        normalization = NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
-
-    elif model_type == "dpt_hybrid":  # DPT-Hybrid
-        net_w, net_h = 384, 384
-        resize_mode = "minimal"
-        normalization = NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
-
-    elif model_type == "midas_v21":
-        net_w, net_h = 384, 384
-        resize_mode = "upper_bound"
-        normalization = NormalizeImage(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
-
-    elif model_type == "midas_v21_small":
-        net_w, net_h = 256, 256
-        resize_mode = "upper_bound"
-        normalization = NormalizeImage(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
-
-    else:
-        assert False, f"model_type '{model_type}' not implemented, use: --model_type large"
-
-    transform = Compose(
-        [
-            Resize(
-                net_w,
-                net_h,
-                resize_target=None,
-                keep_aspect_ratio=True,
-                ensure_multiple_of=32,
-                resize_method=resize_mode,
-                image_interpolation_method=cv2.INTER_CUBIC,
-            ),
-            normalization,
-            PrepareForNet(),
-        ]
-    )
-
-    return transform
-
-
-def load_model(model_type):
-    # https://github.com/isl-org/MiDaS/blob/master/run.py
-    # load network
-    model_path = ISL_PATHS[model_type]
-    if model_type == "dpt_large":  # DPT-Large
-        model = DPTDepthModel(
-            path=model_path,
-            backbone="vitl16_384",
-            non_negative=True,
-        )
-        net_w, net_h = 384, 384
-        resize_mode = "minimal"
-        normalization = NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
-
-    elif model_type == "dpt_hybrid":  # DPT-Hybrid
-        model = DPTDepthModel(
-            path=model_path,
-            backbone="vitb_rn50_384",
-            non_negative=True,
-        )
-        net_w, net_h = 384, 384
-        resize_mode = "minimal"
-        normalization = NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
-
-    elif model_type == "midas_v21":
-        model = MidasNet(model_path, non_negative=True)
-        net_w, net_h = 384, 384
-        resize_mode = "upper_bound"
-        normalization = NormalizeImage(
-            mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
-        )
-
-    elif model_type == "midas_v21_small":
-        model = MidasNet_small(model_path, features=64, backbone="efficientnet_lite3", exportable=True,
-                               non_negative=True, blocks={'expand': True})
-        net_w, net_h = 256, 256
-        resize_mode = "upper_bound"
-        normalization = NormalizeImage(
-            mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
-        )
-
-    else:
-        print(f"model_type '{model_type}' not implemented, use: --model_type large")
-        assert False
-
-    transform = Compose(
-        [
-            Resize(
-                net_w,
-                net_h,
-                resize_target=None,
-                keep_aspect_ratio=True,
-                ensure_multiple_of=32,
-                resize_method=resize_mode,
-                image_interpolation_method=cv2.INTER_CUBIC,
-            ),
-            normalization,
-            PrepareForNet(),
-        ]
-    )
-
-    return model.eval(), transform
-
-
-class MiDaSInference(nn.Module):
-    MODEL_TYPES_TORCH_HUB = [
-        "DPT_Large",
-        "DPT_Hybrid",
-        "MiDaS_small"
-    ]
-    MODEL_TYPES_ISL = [
-        "dpt_large",
-        "dpt_hybrid",
-        "midas_v21",
-        "midas_v21_small",
-    ]
-
-    def __init__(self, model_type):
-        super().__init__()
-        assert (model_type in self.MODEL_TYPES_ISL)
-        model, _ = load_model(model_type)
-        self.model = model
-        self.model.train = disabled_train
-
-    def forward(self, x):
-        # x in 0..1 as produced by calling self.transform on a 0..1 float64 numpy array
-        # NOTE: we expect that the correct transform has been called during dataloading.
-        with torch.no_grad():
-            prediction = self.model(x)
-            prediction = torch.nn.functional.interpolate(
-                prediction.unsqueeze(1),
-                size=x.shape[2:],
-                mode="bicubic",
-                align_corners=False,
-            )
-        assert prediction.shape == (x.shape[0], 1, x.shape[2], x.shape[3])
-        return prediction
-

spaces/AISuperheroes/01ST-CSV-Dataset-Analyzer/app.py

@@ -1,83 +0,0 @@
-import streamlit as st
-import pandas as pd
-import traceback
-import sys
-
-from st_aggrid import AgGrid
-from st_aggrid.grid_options_builder import GridOptionsBuilder
-from st_aggrid.shared import JsCode
-from download import download_button
-from st_aggrid import GridUpdateMode, DataReturnMode
-
-# Page config is set once with icon title and display style.  Wide mode since we want screen real estate for wide CSV files
-st.set_page_config(page_icon="📝", page_title="📝CSV Data Analyzer📊", layout="wide")
-
-# Style
-def _max_width_():
-    max_width_str = f"max-width: 1800px;"
-    st.markdown(
-        f"""
-    <style>
-    .reportview-container .main .block-container{{
-        {max_width_str}
-    }}
-    </style>    
-    """,
-        unsafe_allow_html=True,
-    )
-    
-# Title Bar with Images and Icons
-col1, col2, col3 = st.columns([1,6,1])
-with col1:
-    st.image("https://cdnb.artstation.com/p/assets/images/images/054/910/875/large/aaron-wacker-cyberpunk-computer-brain-design.jpg?1665656558",width=128,)
-with col2:
-    st.title("📝 CSV Data Analyzer 📊")
-with col3:
-    st.image("https://cdna.artstation.com/p/assets/images/images/054/910/878/large/aaron-wacker-cyberpunk-computer-devices-iot.jpg?1665656564",width=128,)
-    
-# Upload
-c29, c30, c31 = st.columns([1, 6, 1])
-with c30:
-    uploaded_file = st.file_uploader("", key="1", help="To activate 'wide mode', go to the menu > Settings > turn on 'wide mode'",)
-    if uploaded_file is not None:
-        file_container = st.expander("Check your uploaded .csv")
-        #try:
-        shows = pd.read_csv(uploaded_file)
-        #except:
-        #    print(sys.exc_info()[2])
-            
-        uploaded_file.seek(0)
-        file_container.write(shows)
-    else:
-        st.info(f"""⬆️Upload a 📝.CSV file.  Examples: [Chatbot](https://huggingface.co/datasets/awacke1/Carddata.csv)  [Mindfulness](https://huggingface.co/datasets/awacke1/MindfulStory.csv)  [Wikipedia](https://huggingface.co/datasets/awacke1/WikipediaSearch)""")
-        st.stop()
-
-# DisplayGrid
-gb = GridOptionsBuilder.from_dataframe(shows)
-gb.configure_default_column(enablePivot=True, enableValue=True, enableRowGroup=True)
-gb.configure_selection(selection_mode="multiple", use_checkbox=True)
-gb.configure_side_bar()
-gridOptions = gb.build()
-st.success(f"""💡 Tip! Hold shift key when selecting rows to select multiple rows at once.""")
-response = AgGrid(
-    shows,
-    gridOptions=gridOptions,
-    enable_enterprise_modules=True,
-    update_mode=GridUpdateMode.MODEL_CHANGED,
-    data_return_mode=DataReturnMode.FILTERED_AND_SORTED,
-    fit_columns_on_grid_load=False,
-)
-
-# Filters
-df = pd.DataFrame(response["selected_rows"])
-st.subheader("Filtered data will appear below 📊 ")
-st.text("")
-st.table(df)
-st.text("")
-
-# Download
-c29, c30, c31 = st.columns([1, 1, 2])
-with c29:
-    CSVButton = download_button(df,"Dataset.csv","Download CSV file",)
-with c30:
-    CSVButton = download_button(df,"Dataset.txt","Download TXT file",)

spaces/AIZero2HeroBootcamp/Memory/README.md

@@ -1,12 +0,0 @@
----
-title: Memory
-emoji: 📚
-colorFrom: pink
-colorTo: indigo
-sdk: streamlit
-sdk_version: 1.21.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/Acapellas/vocalinstrumentalremover/app.py

@@ -1,25 +0,0 @@
-import os
-import gradio as gr
-from scipy.io.wavfile import write
-
-
-def inference(audio):
-  os.makedirs("out", exist_ok=True)
-  write('test.wav', audio[0], audio[1])
-  os.system("python3 -m demucs.separate -n htdemucs --two-stems=vocals -d cpu test.wav -o out")
-  return "./out/htdemucs/test/vocals.wav","./out/htdemucs/test/no_vocals.wav"
-    
-title = ""
-description = ""
-article = ""
-
-examples=[['test.mp3']]
-gr.Interface(
-    inference, 
-    gr.Audio(type="numpy", label="Input"),
-    [gr.Audio(type="filepath", label="Vocals"),gr.Audio(type="filepath", label="No Vocals / Instrumental")],
-    title=title,
-    description=description,
-    article=article,
-    examples=examples
-    ).launch(enable_queue=True,debug=True)

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

@@ -1,20 +0,0 @@
-import Tap from '../../tap/Tap.js';
-import EmitCellEvent from './EmitCellEvent.js';
-
-const GetValue = Phaser.Utils.Objects.GetValue;
-
-var TapCell = function (table, tableConfig) {
-    var tapConfig = GetValue(tableConfig, 'tap', undefined);
-    if (tapConfig === false) {
-        return;
-    }
-
-    table._tap = new Tap(table, tapConfig);
-    table._tap
-        .on('tap', function (tap, gameObject, lastPointer) {
-            var eventName = `cell.${tap.tapsCount}tap`
-            EmitCellEvent(this.eventEmitter, eventName, tap.gameObject, tap.worldX, tap.worldY, lastPointer);
-        }, this)
-};
-
-export default TapCell;

spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/menu/Menu.d.ts

@@ -1,49 +0,0 @@
-// import * as Phaser from 'phaser';
-import Buttons from '../buttons/Buttons';
-
-
-export default Menu;
-
-declare namespace Menu {
-
-    type EaseConfigTypes = number |
-    {
-        duration?: number,
-        orientation?: 0 | 1 | 'x' | 'y' | 'h' | 'v',
-        ease?: string
-    }
-
-    type ExpandEventTypes = 'button.click' | 'button.over';
-
-    type SubMenuSideTypes = 0 | 1 | 2 | 3 | 'right' | 'down' | 'left' | 'up';
-
-    interface IConfig extends Buttons.IConfig {
-        items: any[],
-
-        createBackgroundCallback?: (items: any[]) => Phaser.GameObjects.GameObject,
-
-        createBackgroundCallbackScope?: object,
-
-        createButtonCallback?: (item: any, index: number, items: any[]) => Phaser.GameObjects.GameObject,
-
-        createButtonCallbackScope?: object,
-
-        easeIn?: EaseConfigTypes,
-        easeOut?: EaseConfigTypes,
-
-        expandEvent?: ExpandEventTypes,
-
-        subMenuSide?: SubMenuSideTypes,
-    }
-}
-
-declare class Menu extends Buttons {
-    constructor(
-        scene: Phaser.Scene,
-        config?: Menu.IConfig
-    );
-
-    collapse(): this;
-
-    collapseSubMenu(): this;
-}

spaces/Ameaou/academic-chatgpt3.1/crazy_functions/代码重写为全英文_多线程.py

@@ -1,138 +0,0 @@
-import threading
-from request_llm.bridge_all import predict_no_ui_long_connection
-from toolbox import update_ui
-from toolbox import CatchException, write_results_to_file, report_execption
-from .crazy_utils import breakdown_txt_to_satisfy_token_limit
-
-def extract_code_block_carefully(txt):
-    splitted = txt.split('```')
-    n_code_block_seg = len(splitted) - 1
-    if n_code_block_seg <= 1: return txt
-    # 剩下的情况都开头除去 ``` 结尾除去一次 ```
-    txt_out = '```'.join(splitted[1:-1])
-    return txt_out
-
-
-
-def break_txt_into_half_at_some_linebreak(txt):
-    lines = txt.split('\n')
-    n_lines = len(lines)
-    pre = lines[:(n_lines//2)]
-    post = lines[(n_lines//2):]
-    return "\n".join(pre), "\n".join(post)
-
-
-@CatchException
-def 全项目切换英文(txt, llm_kwargs, plugin_kwargs, chatbot, history, sys_prompt, web_port):
-    # 第1步：清空历史，以免输入溢出
-    history = []
-
-    # 第2步：尝试导入依赖，如果缺少依赖，则给出安装建议
-    try:
-        import tiktoken
-    except:
-        report_execption(chatbot, history, 
-            a = f"解析项目: {txt}", 
-            b = f"导入软件依赖失败。使用该模块需要额外依赖，安装方法```pip install --upgrade tiktoken```。")
-        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-        return
-
-    # 第3步：集合文件
-    import time, glob, os, shutil, re
-    os.makedirs('gpt_log/generated_english_version', exist_ok=True)
-    os.makedirs('gpt_log/generated_english_version/crazy_functions', exist_ok=True)
-    file_manifest = [f for f in glob.glob('./*.py') if ('test_project' not in f) and ('gpt_log' not in f)] + \
-                    [f for f in glob.glob('./crazy_functions/*.py') if ('test_project' not in f) and ('gpt_log' not in f)]
-    # file_manifest = ['./toolbox.py']
-    i_say_show_user_buffer = []
-
-    # 第4步：随便显示点什么防止卡顿的感觉
-    for index, fp in enumerate(file_manifest):
-        # if 'test_project' in fp: continue
-        with open(fp, 'r', encoding='utf-8', errors='replace') as f:
-            file_content = f.read()
-        i_say_show_user =f'[{index}/{len(file_manifest)}] 接下来请将以下代码中包含的所有中文转化为英文，只输出转化后的英文代码，请用代码块输出代码: {os.path.abspath(fp)}'
-        i_say_show_user_buffer.append(i_say_show_user)
-        chatbot.append((i_say_show_user, "[Local Message] 等待多线程操作，中间过程不予显示."))
-        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-
-
-    # 第5步：Token限制下的截断与处理
-    MAX_TOKEN = 3000
-    from request_llm.bridge_all import model_info
-    enc = model_info["gpt-3.5-turbo"]['tokenizer']
-    def get_token_fn(txt): return len(enc.encode(txt, disallowed_special=()))
-
-
-    # 第6步：任务函数
-    mutable_return = [None for _ in file_manifest]
-    observe_window = [[""] for _ in file_manifest]
-    def thread_worker(fp,index):
-        if index > 10: 
-            time.sleep(60)
-            print('Openai 限制免费用户每分钟20次请求，降低请求频率中。')
-        with open(fp, 'r', encoding='utf-8', errors='replace') as f:
-            file_content = f.read()
-        i_say_template = lambda fp, file_content: f'接下来请将以下代码中包含的所有中文转化为英文，只输出代码，文件名是{fp}，文件代码是 ```{file_content}```'
-        try:
-            gpt_say = ""
-            # 分解代码文件
-            file_content_breakdown = breakdown_txt_to_satisfy_token_limit(file_content, get_token_fn, MAX_TOKEN)
-            for file_content_partial in file_content_breakdown:
-                i_say = i_say_template(fp, file_content_partial)
-                # # ** gpt request **
-                gpt_say_partial = predict_no_ui_long_connection(inputs=i_say, llm_kwargs=llm_kwargs, history=[], sys_prompt=sys_prompt, observe_window=observe_window[index])
-                gpt_say_partial = extract_code_block_carefully(gpt_say_partial)
-                gpt_say += gpt_say_partial
-            mutable_return[index] = gpt_say
-        except ConnectionAbortedError as token_exceed_err:
-            print('至少一个线程任务Token溢出而失败', e)
-        except Exception as e:
-            print('至少一个线程任务意外失败', e)
-
-    # 第7步：所有线程同时开始执行任务函数
-    handles = [threading.Thread(target=thread_worker, args=(fp,index)) for index, fp in enumerate(file_manifest)]
-    for h in handles:
-        h.daemon = True
-        h.start()
-    chatbot.append(('开始了吗？', f'多线程操作已经开始'))
-    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-
-    # 第8步：循环轮询各个线程是否执行完毕
-    cnt = 0
-    while True:
-        cnt += 1
-        time.sleep(0.2)
-        th_alive = [h.is_alive() for h in handles]
-        if not any(th_alive): break
-        # 更好��UI视觉效果
-        observe_win = []
-        for thread_index, alive in enumerate(th_alive): 
-            observe_win.append("[ ..."+observe_window[thread_index][0][-60:].replace('\n','').replace('```','...').replace(' ','.').replace('<br/>','.....').replace('$','.')+"... ]")
-        stat = [f'执行中: {obs}\n\n' if alive else '已完成\n\n' for alive, obs in zip(th_alive, observe_win)]
-        stat_str = ''.join(stat)
-        chatbot[-1] = (chatbot[-1][0], f'多线程操作已经开始，完成情况: \n\n{stat_str}' + ''.join(['.']*(cnt%10+1)))
-        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-
-    # 第9步：把结果写入文件
-    for index, h in enumerate(handles):
-        h.join() # 这里其实不需要join了，肯定已经都结束了
-        fp = file_manifest[index]
-        gpt_say = mutable_return[index]
-        i_say_show_user = i_say_show_user_buffer[index]
-
-        where_to_relocate = f'gpt_log/generated_english_version/{fp}'
-        if gpt_say is not None:
-            with open(where_to_relocate, 'w+', encoding='utf-8') as f:  
-                f.write(gpt_say)
-        else:  # 失败
-            shutil.copyfile(file_manifest[index], where_to_relocate)
-        chatbot.append((i_say_show_user, f'[Local Message] 已完成{os.path.abspath(fp)}的转化，\n\n存入{os.path.abspath(where_to_relocate)}'))
-        history.append(i_say_show_user); history.append(gpt_say)
-        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-        time.sleep(1)
-
-    # 第10步：备份一个文件
-    res = write_results_to_file(history)
-    chatbot.append(("生成一份任务执行报告", res))
-    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面

spaces/Amrrs/DragGan-Inversion/PTI/models/e4e/encoders/model_irse.py

@@ -1,84 +0,0 @@
-from torch.nn import Linear, Conv2d, BatchNorm1d, BatchNorm2d, PReLU, Dropout, Sequential, Module
-from encoder4editing.models.encoders.helpers import get_blocks, Flatten, bottleneck_IR, bottleneck_IR_SE, l2_norm
-
-"""
-Modified Backbone implementation from [TreB1eN](https://github.com/TreB1eN/InsightFace_Pytorch)
-"""
-
-
-class Backbone(Module):
-    def __init__(self, input_size, num_layers, mode='ir', drop_ratio=0.4, affine=True):
-        super(Backbone, self).__init__()
-        assert input_size in [112, 224], "input_size should be 112 or 224"
-        assert num_layers in [50, 100, 152], "num_layers should be 50, 100 or 152"
-        assert mode in ['ir', 'ir_se'], "mode should be ir or ir_se"
-        blocks = get_blocks(num_layers)
-        if mode == 'ir':
-            unit_module = bottleneck_IR
-        elif mode == 'ir_se':
-            unit_module = bottleneck_IR_SE
-        self.input_layer = Sequential(Conv2d(3, 64, (3, 3), 1, 1, bias=False),
-                                      BatchNorm2d(64),
-                                      PReLU(64))
-        if input_size == 112:
-            self.output_layer = Sequential(BatchNorm2d(512),
-                                           Dropout(drop_ratio),
-                                           Flatten(),
-                                           Linear(512 * 7 * 7, 512),
-                                           BatchNorm1d(512, affine=affine))
-        else:
-            self.output_layer = Sequential(BatchNorm2d(512),
-                                           Dropout(drop_ratio),
-                                           Flatten(),
-                                           Linear(512 * 14 * 14, 512),
-                                           BatchNorm1d(512, affine=affine))
-
-        modules = []
-        for block in blocks:
-            for bottleneck in block:
-                modules.append(unit_module(bottleneck.in_channel,
-                                           bottleneck.depth,
-                                           bottleneck.stride))
-        self.body = Sequential(*modules)
-
-    def forward(self, x):
-        x = self.input_layer(x)
-        x = self.body(x)
-        x = self.output_layer(x)
-        return l2_norm(x)
-
-
-def IR_50(input_size):
-    """Constructs a ir-50 model."""
-    model = Backbone(input_size, num_layers=50, mode='ir', drop_ratio=0.4, affine=False)
-    return model
-
-
-def IR_101(input_size):
-    """Constructs a ir-101 model."""
-    model = Backbone(input_size, num_layers=100, mode='ir', drop_ratio=0.4, affine=False)
-    return model
-
-
-def IR_152(input_size):
-    """Constructs a ir-152 model."""
-    model = Backbone(input_size, num_layers=152, mode='ir', drop_ratio=0.4, affine=False)
-    return model
-
-
-def IR_SE_50(input_size):
-    """Constructs a ir_se-50 model."""
-    model = Backbone(input_size, num_layers=50, mode='ir_se', drop_ratio=0.4, affine=False)
-    return model
-
-
-def IR_SE_101(input_size):
-    """Constructs a ir_se-101 model."""
-    model = Backbone(input_size, num_layers=100, mode='ir_se', drop_ratio=0.4, affine=False)
-    return model
-
-
-def IR_SE_152(input_size):
-    """Constructs a ir_se-152 model."""
-    model = Backbone(input_size, num_layers=152, mode='ir_se', drop_ratio=0.4, affine=False)
-    return model

spaces/Amrrs/DragGan-Inversion/stylegan_human/pti/pti_configs/hyperparameters.py

@@ -1,28 +0,0 @@
-# Architechture
-lpips_type = 'alex'
-first_inv_type = 'w+'  # 'w+'
-optim_type = 'adam'
-
-# Locality regularization
-latent_ball_num_of_samples = 1
-locality_regularization_interval = 1
-use_locality_regularization = False
-regulizer_l2_lambda = 0.1
-regulizer_lpips_lambda = 0.1
-regulizer_alpha = 30
-
-# Loss
-pt_l2_lambda = 1
-pt_lpips_lambda = 1
-
-# Steps
-LPIPS_value_threshold = 0.04
-max_pti_steps = 350
-first_inv_steps = 450
-max_images_to_invert = 30
-
-# Optimization
-pti_learning_rate = 5e-4
-first_inv_lr = 8e-3
-train_batch_size = 1
-use_last_w_pivots = False

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/pipelines/stable_diffusion/pipeline_flax_stable_diffusion.py

@@ -1,473 +0,0 @@
-# Copyright 2023 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import warnings
-from functools import partial
-from typing import Dict, List, Optional, Union
-
-import jax
-import jax.numpy as jnp
-import numpy as np
-from flax.core.frozen_dict import FrozenDict
-from flax.jax_utils import unreplicate
-from flax.training.common_utils import shard
-from packaging import version
-from PIL import Image
-from transformers import CLIPImageProcessor, CLIPTokenizer, FlaxCLIPTextModel
-
-from ...models import FlaxAutoencoderKL, FlaxUNet2DConditionModel
-from ...schedulers import (
-    FlaxDDIMScheduler,
-    FlaxDPMSolverMultistepScheduler,
-    FlaxLMSDiscreteScheduler,
-    FlaxPNDMScheduler,
-)
-from ...utils import deprecate, logging, replace_example_docstring
-from ..pipeline_flax_utils import FlaxDiffusionPipeline
-from . import FlaxStableDiffusionPipelineOutput
-from .safety_checker_flax import FlaxStableDiffusionSafetyChecker
-
-
-logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
-
-# Set to True to use python for loop instead of jax.fori_loop for easier debugging
-DEBUG = False
-
-EXAMPLE_DOC_STRING = """
-    Examples:
-        ```py
-        >>> import jax
-        >>> import numpy as np
-        >>> from flax.jax_utils import replicate
-        >>> from flax.training.common_utils import shard
-
-        >>> from diffusers import FlaxStableDiffusionPipeline
-
-        >>> pipeline, params = FlaxStableDiffusionPipeline.from_pretrained(
-        ...     "runwayml/stable-diffusion-v1-5", revision="bf16", dtype=jax.numpy.bfloat16
-        ... )
-
-        >>> prompt = "a photo of an astronaut riding a horse on mars"
-
-        >>> prng_seed = jax.random.PRNGKey(0)
-        >>> num_inference_steps = 50
-
-        >>> num_samples = jax.device_count()
-        >>> prompt = num_samples * [prompt]
-        >>> prompt_ids = pipeline.prepare_inputs(prompt)
-        # shard inputs and rng
-
-        >>> params = replicate(params)
-        >>> prng_seed = jax.random.split(prng_seed, jax.device_count())
-        >>> prompt_ids = shard(prompt_ids)
-
-        >>> images = pipeline(prompt_ids, params, prng_seed, num_inference_steps, jit=True).images
-        >>> images = pipeline.numpy_to_pil(np.asarray(images.reshape((num_samples,) + images.shape[-3:])))
-        ```
-"""
-
-
-class FlaxStableDiffusionPipeline(FlaxDiffusionPipeline):
-    r"""
-    Flax-based pipeline for text-to-image generation using Stable Diffusion.
-
-    This model inherits from [`FlaxDiffusionPipeline`]. Check the superclass documentation for the generic methods
-    implemented for all pipelines (downloading, saving, running on a particular device, etc.).
-
-    Args:
-        vae ([`FlaxAutoencoderKL`]):
-            Variational Auto-Encoder (VAE) model to encode and decode images to and from latent representations.
-        text_encoder ([`~transformers.FlaxCLIPTextModel`]):
-            Frozen text-encoder ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)).
-        tokenizer ([`~transformers.CLIPTokenizer`]):
-            A `CLIPTokenizer` to tokenize text.
-        unet ([`FlaxUNet2DConditionModel`]):
-            A `FlaxUNet2DConditionModel` 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
-            [`FlaxDDIMScheduler`], [`FlaxLMSDiscreteScheduler`], [`FlaxPNDMScheduler`], or
-            [`FlaxDPMSolverMultistepScheduler`].
-        safety_checker ([`FlaxStableDiffusionSafetyChecker`]):
-            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 more details
-            about a model's potential harms.
-        feature_extractor ([`~transformers.CLIPImageProcessor`]):
-            A `CLIPImageProcessor` to extract features from generated images; used as inputs to the `safety_checker`.
-    """
-
-    def __init__(
-        self,
-        vae: FlaxAutoencoderKL,
-        text_encoder: FlaxCLIPTextModel,
-        tokenizer: CLIPTokenizer,
-        unet: FlaxUNet2DConditionModel,
-        scheduler: Union[
-            FlaxDDIMScheduler, FlaxPNDMScheduler, FlaxLMSDiscreteScheduler, FlaxDPMSolverMultistepScheduler
-        ],
-        safety_checker: FlaxStableDiffusionSafetyChecker,
-        feature_extractor: CLIPImageProcessor,
-        dtype: jnp.dtype = jnp.float32,
-    ):
-        super().__init__()
-        self.dtype = dtype
-
-        if safety_checker is None:
-            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. Both the 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 ."
-            )
-
-        is_unet_version_less_0_9_0 = hasattr(unet.config, "_diffusers_version") and version.parse(
-            version.parse(unet.config._diffusers_version).base_version
-        ) < version.parse("0.9.0.dev0")
-        is_unet_sample_size_less_64 = hasattr(unet.config, "sample_size") and unet.config.sample_size < 64
-        if is_unet_version_less_0_9_0 and is_unet_sample_size_less_64:
-            deprecation_message = (
-                "The configuration file of the unet has set the default `sample_size` to smaller than"
-                " 64 which seems highly unlikely .If you're checkpoint is a fine-tuned version of any of the"
-                " following: \n- CompVis/stable-diffusion-v1-4 \n- CompVis/stable-diffusion-v1-3 \n-"
-                " CompVis/stable-diffusion-v1-2 \n- CompVis/stable-diffusion-v1-1 \n- runwayml/stable-diffusion-v1-5"
-                " \n- runwayml/stable-diffusion-inpainting \n you should change 'sample_size' to 64 in the"
-                " configuration file. Please make sure to update the config accordingly as leaving `sample_size=32`"
-                " in the config might lead to incorrect results in future versions. If you have downloaded this"
-                " checkpoint from the Hugging Face Hub, it would be very nice if you could open a Pull request for"
-                " the `unet/config.json` file"
-            )
-            deprecate("sample_size<64", "1.0.0", deprecation_message, standard_warn=False)
-            new_config = dict(unet.config)
-            new_config["sample_size"] = 64
-            unet._internal_dict = FrozenDict(new_config)
-
-        self.register_modules(
-            vae=vae,
-            text_encoder=text_encoder,
-            tokenizer=tokenizer,
-            unet=unet,
-            scheduler=scheduler,
-            safety_checker=safety_checker,
-            feature_extractor=feature_extractor,
-        )
-        self.vae_scale_factor = 2 ** (len(self.vae.config.block_out_channels) - 1)
-
-    def prepare_inputs(self, prompt: Union[str, List[str]]):
-        if not isinstance(prompt, (str, list)):
-            raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}")
-
-        text_input = self.tokenizer(
-            prompt,
-            padding="max_length",
-            max_length=self.tokenizer.model_max_length,
-            truncation=True,
-            return_tensors="np",
-        )
-        return text_input.input_ids
-
-    def _get_has_nsfw_concepts(self, features, params):
-        has_nsfw_concepts = self.safety_checker(features, params)
-        return has_nsfw_concepts
-
-    def _run_safety_checker(self, images, safety_model_params, jit=False):
-        # safety_model_params should already be replicated when jit is True
-        pil_images = [Image.fromarray(image) for image in images]
-        features = self.feature_extractor(pil_images, return_tensors="np").pixel_values
-
-        if jit:
-            features = shard(features)
-            has_nsfw_concepts = _p_get_has_nsfw_concepts(self, features, safety_model_params)
-            has_nsfw_concepts = unshard(has_nsfw_concepts)
-            safety_model_params = unreplicate(safety_model_params)
-        else:
-            has_nsfw_concepts = self._get_has_nsfw_concepts(features, safety_model_params)
-
-        images_was_copied = False
-        for idx, has_nsfw_concept in enumerate(has_nsfw_concepts):
-            if has_nsfw_concept:
-                if not images_was_copied:
-                    images_was_copied = True
-                    images = images.copy()
-
-                images[idx] = np.zeros(images[idx].shape, dtype=np.uint8)  # black image
-
-            if any(has_nsfw_concepts):
-                warnings.warn(
-                    "Potential NSFW content was detected in one or more images. A black image will be returned"
-                    " instead. Try again with a different prompt and/or seed."
-                )
-
-        return images, has_nsfw_concepts
-
-    def _generate(
-        self,
-        prompt_ids: jnp.array,
-        params: Union[Dict, FrozenDict],
-        prng_seed: jax.random.KeyArray,
-        num_inference_steps: int,
-        height: int,
-        width: int,
-        guidance_scale: float,
-        latents: Optional[jnp.array] = None,
-        neg_prompt_ids: Optional[jnp.array] = None,
-    ):
-        if height % 8 != 0 or width % 8 != 0:
-            raise ValueError(f"`height` and `width` have to be divisible by 8 but are {height} and {width}.")
-
-        # get prompt text embeddings
-        prompt_embeds = self.text_encoder(prompt_ids, params=params["text_encoder"])[0]
-
-        # TODO: currently it is assumed `do_classifier_free_guidance = guidance_scale > 1.0`
-        # implement this conditional `do_classifier_free_guidance = guidance_scale > 1.0`
-        batch_size = prompt_ids.shape[0]
-
-        max_length = prompt_ids.shape[-1]
-
-        if neg_prompt_ids is None:
-            uncond_input = self.tokenizer(
-                [""] * batch_size, padding="max_length", max_length=max_length, return_tensors="np"
-            ).input_ids
-        else:
-            uncond_input = neg_prompt_ids
-        negative_prompt_embeds = self.text_encoder(uncond_input, params=params["text_encoder"])[0]
-        context = jnp.concatenate([negative_prompt_embeds, prompt_embeds])
-
-        # Ensure model output will be `float32` before going into the scheduler
-        guidance_scale = jnp.array([guidance_scale], dtype=jnp.float32)
-
-        latents_shape = (
-            batch_size,
-            self.unet.config.in_channels,
-            height // self.vae_scale_factor,
-            width // self.vae_scale_factor,
-        )
-        if latents is None:
-            latents = jax.random.normal(prng_seed, shape=latents_shape, dtype=jnp.float32)
-        else:
-            if latents.shape != latents_shape:
-                raise ValueError(f"Unexpected latents shape, got {latents.shape}, expected {latents_shape}")
-
-        def loop_body(step, args):
-            latents, scheduler_state = args
-            # 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
-            latents_input = jnp.concatenate([latents] * 2)
-
-            t = jnp.array(scheduler_state.timesteps, dtype=jnp.int32)[step]
-            timestep = jnp.broadcast_to(t, latents_input.shape[0])
-
-            latents_input = self.scheduler.scale_model_input(scheduler_state, latents_input, t)
-
-            # predict the noise residual
-            noise_pred = self.unet.apply(
-                {"params": params["unet"]},
-                jnp.array(latents_input),
-                jnp.array(timestep, dtype=jnp.int32),
-                encoder_hidden_states=context,
-            ).sample
-            # perform guidance
-            noise_pred_uncond, noise_prediction_text = jnp.split(noise_pred, 2, axis=0)
-            noise_pred = noise_pred_uncond + guidance_scale * (noise_prediction_text - noise_pred_uncond)
-
-            # compute the previous noisy sample x_t -> x_t-1
-            latents, scheduler_state = self.scheduler.step(scheduler_state, noise_pred, t, latents).to_tuple()
-            return latents, scheduler_state
-
-        scheduler_state = self.scheduler.set_timesteps(
-            params["scheduler"], num_inference_steps=num_inference_steps, shape=latents.shape
-        )
-
-        # scale the initial noise by the standard deviation required by the scheduler
-        latents = latents * params["scheduler"].init_noise_sigma
-
-        if DEBUG:
-            # run with python for loop
-            for i in range(num_inference_steps):
-                latents, scheduler_state = loop_body(i, (latents, scheduler_state))
-        else:
-            latents, _ = jax.lax.fori_loop(0, num_inference_steps, loop_body, (latents, scheduler_state))
-
-        # scale and decode the image latents with vae
-        latents = 1 / self.vae.config.scaling_factor * latents
-        image = self.vae.apply({"params": params["vae"]}, latents, method=self.vae.decode).sample
-
-        image = (image / 2 + 0.5).clip(0, 1).transpose(0, 2, 3, 1)
-        return image
-
-    @replace_example_docstring(EXAMPLE_DOC_STRING)
-    def __call__(
-        self,
-        prompt_ids: jnp.array,
-        params: Union[Dict, FrozenDict],
-        prng_seed: jax.random.KeyArray,
-        num_inference_steps: int = 50,
-        height: Optional[int] = None,
-        width: Optional[int] = None,
-        guidance_scale: Union[float, jnp.array] = 7.5,
-        latents: jnp.array = None,
-        neg_prompt_ids: jnp.array = None,
-        return_dict: bool = True,
-        jit: bool = False,
-    ):
-        r"""
-        The call function to the pipeline for generation.
-
-        Args:
-            prompt (`str` or `List[str]`, *optional*):
-                The prompt or prompts to guide image generation.
-            height (`int`, *optional*, defaults to `self.unet.config.sample_size * self.vae_scale_factor`):
-                The height in pixels of the generated image.
-            width (`int`, *optional*, defaults to `self.unet.config.sample_size * self.vae_scale_factor`):
-                The width in pixels of the generated 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.
-            guidance_scale (`float`, *optional*, defaults to 7.5):
-                A higher guidance scale value encourages the model to generate images closely linked to the text
-                `prompt` at the expense of lower image quality. Guidance scale is enabled when `guidance_scale > 1`.
-            latents (`jnp.array`, *optional*):
-                Pre-generated noisy latents sampled from a Gaussian distribution, to be used as inputs for image
-                generation. Can be used to tweak the same generation with different prompts. If not provided, a latents
-                array is generated by sampling using the supplied random `generator`.
-            jit (`bool`, defaults to `False`):
-                Whether to run `pmap` versions of the generation and safety scoring functions.
-
-                    <Tip warning={true}>
-
-                    This argument exists because `__call__` is not yet end-to-end pmap-able. It will be removed in a
-                    future release.
-
-                    </Tip>
-
-            return_dict (`bool`, *optional*, defaults to `True`):
-                Whether or not to return a [`~pipelines.stable_diffusion.FlaxStableDiffusionPipelineOutput`] instead of
-                a plain tuple.
-
-        Examples:
-
-        Returns:
-            [`~pipelines.stable_diffusion.FlaxStableDiffusionPipelineOutput`] or `tuple`:
-                If `return_dict` is `True`, [`~pipelines.stable_diffusion.FlaxStableDiffusionPipelineOutput`] is
-                returned, otherwise a `tuple` is returned where the first element is a list with the generated images
-                and the second element is a list of `bool`s indicating whether the corresponding generated image
-                contains "not-safe-for-work" (nsfw) content.
-        """
-        # 0. Default height and width to unet
-        height = height or self.unet.config.sample_size * self.vae_scale_factor
-        width = width or self.unet.config.sample_size * self.vae_scale_factor
-
-        if isinstance(guidance_scale, float):
-            # Convert to a tensor so each device gets a copy. Follow the prompt_ids for
-            # shape information, as they may be sharded (when `jit` is `True`), or not.
-            guidance_scale = jnp.array([guidance_scale] * prompt_ids.shape[0])
-            if len(prompt_ids.shape) > 2:
-                # Assume sharded
-                guidance_scale = guidance_scale[:, None]
-
-        if jit:
-            images = _p_generate(
-                self,
-                prompt_ids,
-                params,
-                prng_seed,
-                num_inference_steps,
-                height,
-                width,
-                guidance_scale,
-                latents,
-                neg_prompt_ids,
-            )
-        else:
-            images = self._generate(
-                prompt_ids,
-                params,
-                prng_seed,
-                num_inference_steps,
-                height,
-                width,
-                guidance_scale,
-                latents,
-                neg_prompt_ids,
-            )
-
-        if self.safety_checker is not None:
-            safety_params = params["safety_checker"]
-            images_uint8_casted = (images * 255).round().astype("uint8")
-            num_devices, batch_size = images.shape[:2]
-
-            images_uint8_casted = np.asarray(images_uint8_casted).reshape(num_devices * batch_size, height, width, 3)
-            images_uint8_casted, has_nsfw_concept = self._run_safety_checker(images_uint8_casted, safety_params, jit)
-            images = np.asarray(images)
-
-            # block images
-            if any(has_nsfw_concept):
-                for i, is_nsfw in enumerate(has_nsfw_concept):
-                    if is_nsfw:
-                        images[i] = np.asarray(images_uint8_casted[i])
-
-            images = images.reshape(num_devices, batch_size, height, width, 3)
-        else:
-            images = np.asarray(images)
-            has_nsfw_concept = False
-
-        if not return_dict:
-            return (images, has_nsfw_concept)
-
-        return FlaxStableDiffusionPipelineOutput(images=images, nsfw_content_detected=has_nsfw_concept)
-
-
-# Static argnums are pipe, num_inference_steps, height, width. A change would trigger recompilation.
-# Non-static args are (sharded) input tensors mapped over their first dimension (hence, `0`).
-@partial(
-    jax.pmap,
-    in_axes=(None, 0, 0, 0, None, None, None, 0, 0, 0),
-    static_broadcasted_argnums=(0, 4, 5, 6),
-)
-def _p_generate(
-    pipe,
-    prompt_ids,
-    params,
-    prng_seed,
-    num_inference_steps,
-    height,
-    width,
-    guidance_scale,
-    latents,
-    neg_prompt_ids,
-):
-    return pipe._generate(
-        prompt_ids,
-        params,
-        prng_seed,
-        num_inference_steps,
-        height,
-        width,
-        guidance_scale,
-        latents,
-        neg_prompt_ids,
-    )
-
-
-@partial(jax.pmap, static_broadcasted_argnums=(0,))
-def _p_get_has_nsfw_concepts(pipe, features, params):
-    return pipe._get_has_nsfw_concepts(features, params)
-
-
-def unshard(x: jnp.ndarray):
-    # einops.rearrange(x, 'd b ... -> (d b) ...')
-    num_devices, batch_size = x.shape[:2]
-    rest = x.shape[2:]
-    return x.reshape(num_devices * batch_size, *rest)

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/pipelines/unidiffuser/__init__.py

@@ -1,20 +0,0 @@
-from ...utils import (
-    OptionalDependencyNotAvailable,
-    is_torch_available,
-    is_transformers_available,
-    is_transformers_version,
-)
-
-
-try:
-    if not (is_transformers_available() and is_torch_available()):
-        raise OptionalDependencyNotAvailable()
-except OptionalDependencyNotAvailable:
-    from ...utils.dummy_torch_and_transformers_objects import (
-        ImageTextPipelineOutput,
-        UniDiffuserPipeline,
-    )
-else:
-    from .modeling_text_decoder import UniDiffuserTextDecoder
-    from .modeling_uvit import UniDiffuserModel, UTransformer2DModel
-    from .pipeline_unidiffuser import ImageTextPipelineOutput, UniDiffuserPipeline

spaces/Andy1621/uniformer_image_detection/configs/atss/README.md

@@ -1,21 +0,0 @@
-# Bridging the Gap Between Anchor-based and Anchor-free Detection via Adaptive Training Sample Selection
-
-## Introduction
-
-[ALGORITHM]
-
-```latex
-@article{zhang2019bridging,
-  title   =  {Bridging the Gap Between Anchor-based and Anchor-free Detection via Adaptive Training Sample Selection},
-  author  =  {Zhang, Shifeng and Chi, Cheng and Yao, Yongqiang and Lei, Zhen and Li, Stan Z.},
-  journal =  {arXiv preprint arXiv:1912.02424},
-  year    =  {2019}
-}
-```
-
-## Results and Models
-
-| Backbone  | Style   | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download |
-|:---------:|:-------:|:-------:|:--------:|:--------------:|:------:|:------:|:--------:|
-| R-50      | pytorch | 1x      | 3.7      | 19.7           |  39.4  | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/atss/atss_r50_fpn_1x_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/atss/atss_r50_fpn_1x_coco/atss_r50_fpn_1x_coco_20200209-985f7bd0.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/atss/atss_r50_fpn_1x_coco/atss_r50_fpn_1x_coco_20200209_102539.log.json) |
-| R-101     | pytorch | 1x      | 5.6      | 12.3           |  41.5  | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/atss/atss_r101_fpn_1x_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/atss/atss_r101_fpn_1x_coco/atss_r101_fpn_1x_20200825-dfcadd6f.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/atss/atss_r101_fpn_1x_coco/atss_r101_fpn_1x_20200825-dfcadd6f.log.json) |

spaces/Andy1621/uniformer_image_detection/mmdet/core/post_processing/__init__.py

@@ -1,8 +0,0 @@
-from .bbox_nms import fast_nms, multiclass_nms
-from .merge_augs import (merge_aug_bboxes, merge_aug_masks,
-                         merge_aug_proposals, merge_aug_scores)
-
-__all__ = [
-    'multiclass_nms', 'merge_aug_proposals', 'merge_aug_bboxes',
-    'merge_aug_scores', 'merge_aug_masks', 'fast_nms'
-]

spaces/Andy1621/uniformer_image_detection/mmdet/models/roi_heads/dynamic_roi_head.py

@@ -1,154 +0,0 @@
-import numpy as np
-import torch
-
-from mmdet.core import bbox2roi
-from mmdet.models.losses import SmoothL1Loss
-from ..builder import HEADS
-from .standard_roi_head import StandardRoIHead
-
-EPS = 1e-15
-
-
-@HEADS.register_module()
-class DynamicRoIHead(StandardRoIHead):
-    """RoI head for `Dynamic R-CNN <https://arxiv.org/abs/2004.06002>`_."""
-
-    def __init__(self, **kwargs):
-        super(DynamicRoIHead, self).__init__(**kwargs)
-        assert isinstance(self.bbox_head.loss_bbox, SmoothL1Loss)
-        # the IoU history of the past `update_iter_interval` iterations
-        self.iou_history = []
-        # the beta history of the past `update_iter_interval` iterations
-        self.beta_history = []
-
-    def forward_train(self,
-                      x,
-                      img_metas,
-                      proposal_list,
-                      gt_bboxes,
-                      gt_labels,
-                      gt_bboxes_ignore=None,
-                      gt_masks=None):
-        """Forward function for training.
-
-        Args:
-            x (list[Tensor]): list of multi-level img features.
-
-            img_metas (list[dict]): list of image info dict where each dict
-                has: 'img_shape', 'scale_factor', 'flip', and may also contain
-                'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'.
-                For details on the values of these keys see
-                `mmdet/datasets/pipelines/formatting.py:Collect`.
-
-            proposals (list[Tensors]): list of region proposals.
-
-            gt_bboxes (list[Tensor]): each item are the truth boxes for each
-                image in [tl_x, tl_y, br_x, br_y] format.
-
-            gt_labels (list[Tensor]): class indices corresponding to each box
-
-            gt_bboxes_ignore (None | list[Tensor]): specify which bounding
-                boxes can be ignored when computing the loss.
-
-            gt_masks (None | Tensor) : true segmentation masks for each box
-                used if the architecture supports a segmentation task.
-
-        Returns:
-            dict[str, Tensor]: a dictionary of loss components
-        """
-        # assign gts and sample proposals
-        if self.with_bbox or self.with_mask:
-            num_imgs = len(img_metas)
-            if gt_bboxes_ignore is None:
-                gt_bboxes_ignore = [None for _ in range(num_imgs)]
-            sampling_results = []
-            cur_iou = []
-            for i in range(num_imgs):
-                assign_result = self.bbox_assigner.assign(
-                    proposal_list[i], gt_bboxes[i], gt_bboxes_ignore[i],
-                    gt_labels[i])
-                sampling_result = self.bbox_sampler.sample(
-                    assign_result,
-                    proposal_list[i],
-                    gt_bboxes[i],
-                    gt_labels[i],
-                    feats=[lvl_feat[i][None] for lvl_feat in x])
-                # record the `iou_topk`-th largest IoU in an image
-                iou_topk = min(self.train_cfg.dynamic_rcnn.iou_topk,
-                               len(assign_result.max_overlaps))
-                ious, _ = torch.topk(assign_result.max_overlaps, iou_topk)
-                cur_iou.append(ious[-1].item())
-                sampling_results.append(sampling_result)
-            # average the current IoUs over images
-            cur_iou = np.mean(cur_iou)
-            self.iou_history.append(cur_iou)
-
-        losses = dict()
-        # bbox head forward and loss
-        if self.with_bbox:
-            bbox_results = self._bbox_forward_train(x, sampling_results,
-                                                    gt_bboxes, gt_labels,
-                                                    img_metas)
-            losses.update(bbox_results['loss_bbox'])
-
-        # mask head forward and loss
-        if self.with_mask:
-            mask_results = self._mask_forward_train(x, sampling_results,
-                                                    bbox_results['bbox_feats'],
-                                                    gt_masks, img_metas)
-            losses.update(mask_results['loss_mask'])
-
-        # update IoU threshold and SmoothL1 beta
-        update_iter_interval = self.train_cfg.dynamic_rcnn.update_iter_interval
-        if len(self.iou_history) % update_iter_interval == 0:
-            new_iou_thr, new_beta = self.update_hyperparameters()
-
-        return losses
-
-    def _bbox_forward_train(self, x, sampling_results, gt_bboxes, gt_labels,
-                            img_metas):
-        num_imgs = len(img_metas)
-        rois = bbox2roi([res.bboxes for res in sampling_results])
-        bbox_results = self._bbox_forward(x, rois)
-
-        bbox_targets = self.bbox_head.get_targets(sampling_results, gt_bboxes,
-                                                  gt_labels, self.train_cfg)
-        # record the `beta_topk`-th smallest target
-        # `bbox_targets[2]` and `bbox_targets[3]` stand for bbox_targets
-        # and bbox_weights, respectively
-        pos_inds = bbox_targets[3][:, 0].nonzero().squeeze(1)
-        num_pos = len(pos_inds)
-        cur_target = bbox_targets[2][pos_inds, :2].abs().mean(dim=1)
-        beta_topk = min(self.train_cfg.dynamic_rcnn.beta_topk * num_imgs,
-                        num_pos)
-        cur_target = torch.kthvalue(cur_target, beta_topk)[0].item()
-        self.beta_history.append(cur_target)
-        loss_bbox = self.bbox_head.loss(bbox_results['cls_score'],
-                                        bbox_results['bbox_pred'], rois,
-                                        *bbox_targets)
-
-        bbox_results.update(loss_bbox=loss_bbox)
-        return bbox_results
-
-    def update_hyperparameters(self):
-        """Update hyperparameters like IoU thresholds for assigner and beta for
-        SmoothL1 loss based on the training statistics.
-
-        Returns:
-            tuple[float]: the updated ``iou_thr`` and ``beta``.
-        """
-        new_iou_thr = max(self.train_cfg.dynamic_rcnn.initial_iou,
-                          np.mean(self.iou_history))
-        self.iou_history = []
-        self.bbox_assigner.pos_iou_thr = new_iou_thr
-        self.bbox_assigner.neg_iou_thr = new_iou_thr
-        self.bbox_assigner.min_pos_iou = new_iou_thr
-        if (np.median(self.beta_history) < EPS):
-            # avoid 0 or too small value for new_beta
-            new_beta = self.bbox_head.loss_bbox.beta
-        else:
-            new_beta = min(self.train_cfg.dynamic_rcnn.initial_beta,
-                           np.median(self.beta_history))
-        self.beta_history = []
-        self.bbox_head.loss_bbox.beta = new_beta
-        return new_iou_thr, new_beta

spaces/Andy1621/uniformer_image_detection/mmdet/models/roi_heads/grid_roi_head.py

@@ -1,176 +0,0 @@
-import torch
-
-from mmdet.core import bbox2result, bbox2roi
-from ..builder import HEADS, build_head, build_roi_extractor
-from .standard_roi_head import StandardRoIHead
-
-
-@HEADS.register_module()
-class GridRoIHead(StandardRoIHead):
-    """Grid roi head for Grid R-CNN.
-
-    https://arxiv.org/abs/1811.12030
-    """
-
-    def __init__(self, grid_roi_extractor, grid_head, **kwargs):
-        assert grid_head is not None
-        super(GridRoIHead, self).__init__(**kwargs)
-        if grid_roi_extractor is not None:
-            self.grid_roi_extractor = build_roi_extractor(grid_roi_extractor)
-            self.share_roi_extractor = False
-        else:
-            self.share_roi_extractor = True
-            self.grid_roi_extractor = self.bbox_roi_extractor
-        self.grid_head = build_head(grid_head)
-
-    def init_weights(self, pretrained):
-        """Initialize the weights in head.
-
-        Args:
-            pretrained (str, optional): Path to pre-trained weights.
-                Defaults to None.
-        """
-        super(GridRoIHead, self).init_weights(pretrained)
-        self.grid_head.init_weights()
-        if not self.share_roi_extractor:
-            self.grid_roi_extractor.init_weights()
-
-    def _random_jitter(self, sampling_results, img_metas, amplitude=0.15):
-        """Ramdom jitter positive proposals for training."""
-        for sampling_result, img_meta in zip(sampling_results, img_metas):
-            bboxes = sampling_result.pos_bboxes
-            random_offsets = bboxes.new_empty(bboxes.shape[0], 4).uniform_(
-                -amplitude, amplitude)
-            # before jittering
-            cxcy = (bboxes[:, 2:4] + bboxes[:, :2]) / 2
-            wh = (bboxes[:, 2:4] - bboxes[:, :2]).abs()
-            # after jittering
-            new_cxcy = cxcy + wh * random_offsets[:, :2]
-            new_wh = wh * (1 + random_offsets[:, 2:])
-            # xywh to xyxy
-            new_x1y1 = (new_cxcy - new_wh / 2)
-            new_x2y2 = (new_cxcy + new_wh / 2)
-            new_bboxes = torch.cat([new_x1y1, new_x2y2], dim=1)
-            # clip bboxes
-            max_shape = img_meta['img_shape']
-            if max_shape is not None:
-                new_bboxes[:, 0::2].clamp_(min=0, max=max_shape[1] - 1)
-                new_bboxes[:, 1::2].clamp_(min=0, max=max_shape[0] - 1)
-
-            sampling_result.pos_bboxes = new_bboxes
-        return sampling_results
-
-    def forward_dummy(self, x, proposals):
-        """Dummy forward function."""
-        # bbox head
-        outs = ()
-        rois = bbox2roi([proposals])
-        if self.with_bbox:
-            bbox_results = self._bbox_forward(x, rois)
-            outs = outs + (bbox_results['cls_score'],
-                           bbox_results['bbox_pred'])
-
-        # grid head
-        grid_rois = rois[:100]
-        grid_feats = self.grid_roi_extractor(
-            x[:self.grid_roi_extractor.num_inputs], grid_rois)
-        if self.with_shared_head:
-            grid_feats = self.shared_head(grid_feats)
-        grid_pred = self.grid_head(grid_feats)
-        outs = outs + (grid_pred, )
-
-        # mask head
-        if self.with_mask:
-            mask_rois = rois[:100]
-            mask_results = self._mask_forward(x, mask_rois)
-            outs = outs + (mask_results['mask_pred'], )
-        return outs
-
-    def _bbox_forward_train(self, x, sampling_results, gt_bboxes, gt_labels,
-                            img_metas):
-        """Run forward function and calculate loss for box head in training."""
-        bbox_results = super(GridRoIHead,
-                             self)._bbox_forward_train(x, sampling_results,
-                                                       gt_bboxes, gt_labels,
-                                                       img_metas)
-
-        # Grid head forward and loss
-        sampling_results = self._random_jitter(sampling_results, img_metas)
-        pos_rois = bbox2roi([res.pos_bboxes for res in sampling_results])
-
-        # GN in head does not support zero shape input
-        if pos_rois.shape[0] == 0:
-            return bbox_results
-
-        grid_feats = self.grid_roi_extractor(
-            x[:self.grid_roi_extractor.num_inputs], pos_rois)
-        if self.with_shared_head:
-            grid_feats = self.shared_head(grid_feats)
-        # Accelerate training
-        max_sample_num_grid = self.train_cfg.get('max_num_grid', 192)
-        sample_idx = torch.randperm(
-            grid_feats.shape[0])[:min(grid_feats.shape[0], max_sample_num_grid
-                                      )]
-        grid_feats = grid_feats[sample_idx]
-
-        grid_pred = self.grid_head(grid_feats)
-
-        grid_targets = self.grid_head.get_targets(sampling_results,
-                                                  self.train_cfg)
-        grid_targets = grid_targets[sample_idx]
-
-        loss_grid = self.grid_head.loss(grid_pred, grid_targets)
-
-        bbox_results['loss_bbox'].update(loss_grid)
-        return bbox_results
-
-    def simple_test(self,
-                    x,
-                    proposal_list,
-                    img_metas,
-                    proposals=None,
-                    rescale=False):
-        """Test without augmentation."""
-        assert self.with_bbox, 'Bbox head must be implemented.'
-
-        det_bboxes, det_labels = self.simple_test_bboxes(
-            x, img_metas, proposal_list, self.test_cfg, rescale=False)
-        # pack rois into bboxes
-        grid_rois = bbox2roi([det_bbox[:, :4] for det_bbox in det_bboxes])
-        if grid_rois.shape[0] != 0:
-            grid_feats = self.grid_roi_extractor(
-                x[:len(self.grid_roi_extractor.featmap_strides)], grid_rois)
-            self.grid_head.test_mode = True
-            grid_pred = self.grid_head(grid_feats)
-            # split batch grid head prediction back to each image
-            num_roi_per_img = tuple(len(det_bbox) for det_bbox in det_bboxes)
-            grid_pred = {
-                k: v.split(num_roi_per_img, 0)
-                for k, v in grid_pred.items()
-            }
-
-            # apply bbox post-processing to each image individually
-            bbox_results = []
-            num_imgs = len(det_bboxes)
-            for i in range(num_imgs):
-                if det_bboxes[i].shape[0] == 0:
-                    bbox_results.append(grid_rois.new_tensor([]))
-                else:
-                    det_bbox = self.grid_head.get_bboxes(
-                        det_bboxes[i], grid_pred['fused'][i], [img_metas[i]])
-                    if rescale:
-                        det_bbox[:, :4] /= img_metas[i]['scale_factor']
-                    bbox_results.append(
-                        bbox2result(det_bbox, det_labels[i],
-                                    self.bbox_head.num_classes))
-        else:
-            bbox_results = [
-                grid_rois.new_tensor([]) for _ in range(len(det_bboxes))
-            ]
-
-        if not self.with_mask:
-            return bbox_results
-        else:
-            segm_results = self.simple_test_mask(
-                x, img_metas, det_bboxes, det_labels, rescale=rescale)
-            return list(zip(bbox_results, segm_results))

spaces/Andy1621/uniformer_image_segmentation/configs/apcnet/apcnet_r101-d8_769x769_40k_cityscapes.py

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

spaces/AnishKumbhar/ChatBot/text-generation-webui-main/extensions/superboogav2/chromadb.py

@@ -1,376 +0,0 @@
-import threading
-import chromadb
-import posthog
-import torch
-import math
-
-import numpy as np
-import extensions.superboogav2.parameters as parameters
-
-from chromadb.config import Settings
-from sentence_transformers import SentenceTransformer
-
-from modules.logging_colors import logger
-from modules.text_generation import encode, decode
-
-logger.debug('Intercepting all calls to posthog.')
-posthog.capture = lambda *args, **kwargs: None
-
-
-class Collecter():
-    def __init__(self):
-        pass
-
-    def add(self, texts: list[str], texts_with_context: list[str], starting_indices: list[int]):
-        pass
-
-    def get(self, search_strings: list[str], n_results: int) -> list[str]:
-        pass
-
-    def clear(self):
-        pass
-
-
-class Embedder():
-    def __init__(self):
-        pass
-
-    def embed(self, text: str) -> list[torch.Tensor]:
-        pass
-
-class Info:
-    def __init__(self, start_index, text_with_context, distance, id):
-        self.text_with_context = text_with_context
-        self.start_index = start_index
-        self.distance = distance
-        self.id = id
-
-    def calculate_distance(self, other_info):
-        if parameters.get_new_dist_strategy() == parameters.DIST_MIN_STRATEGY:
-            # Min
-            return min(self.distance, other_info.distance)
-        elif parameters.get_new_dist_strategy() == parameters.DIST_HARMONIC_STRATEGY:
-            # Harmonic mean
-            return 2 * (self.distance * other_info.distance) / (self.distance + other_info.distance)
-        elif parameters.get_new_dist_strategy() == parameters.DIST_GEOMETRIC_STRATEGY:
-            # Geometric mean
-            return (self.distance * other_info.distance) ** 0.5
-        elif parameters.get_new_dist_strategy() == parameters.DIST_ARITHMETIC_STRATEGY:
-            # Arithmetic mean
-            return (self.distance + other_info.distance) / 2
-        else: # Min is default
-            return min(self.distance, other_info.distance)
-
-    def merge_with(self, other_info):
-        s1 = self.text_with_context
-        s2 = other_info.text_with_context
-        s1_start = self.start_index
-        s2_start = other_info.start_index
-        
-        new_dist = self.calculate_distance(other_info)
-
-        if self.should_merge(s1, s2, s1_start, s2_start):
-            if s1_start <= s2_start:
-                if s1_start + len(s1) >= s2_start + len(s2):  # if s1 completely covers s2
-                    return Info(s1_start, s1, new_dist, self.id)
-                else:
-                    overlap = max(0, s1_start + len(s1) - s2_start)
-                    return Info(s1_start, s1 + s2[overlap:], new_dist, self.id)
-            else:
-                if s2_start + len(s2) >= s1_start + len(s1):  # if s2 completely covers s1
-                    return Info(s2_start, s2, new_dist, other_info.id)
-                else:
-                    overlap = max(0, s2_start + len(s2) - s1_start)
-                    return Info(s2_start, s2 + s1[overlap:], new_dist, other_info.id)
-
-        return None
-    
-    @staticmethod
-    def should_merge(s1, s2, s1_start, s2_start):
-        # Check if s1 and s2 are adjacent or overlapping
-        s1_end = s1_start + len(s1)
-        s2_end = s2_start + len(s2)
-        
-        return not (s1_end < s2_start or s2_end < s1_start)
-
-class ChromaCollector(Collecter):
-    def __init__(self, embedder: Embedder):
-        super().__init__()
-        self.chroma_client = chromadb.Client(Settings(anonymized_telemetry=False))
-        self.embedder = embedder
-        self.collection = self.chroma_client.create_collection(name="context", embedding_function=self.embedder.embed)
-        self.ids = []
-        self.id_to_info = {}
-        self.embeddings_cache = {}
-        self.lock = threading.Lock() # Locking so the server doesn't break.
-
-    def add(self, texts: list[str], texts_with_context: list[str], starting_indices: list[int], metadatas: list[dict] = None):
-        with self.lock:
-            assert metadatas is None or len(metadatas) == len(texts), "metadatas must be None or have the same length as texts"
-            
-            if len(texts) == 0: 
-                return
-
-            new_ids = self._get_new_ids(len(texts))
-
-            (existing_texts, existing_embeddings, existing_ids, existing_metas), \
-            (non_existing_texts, non_existing_ids, non_existing_metas) = self._split_texts_by_cache_hit(texts, new_ids, metadatas)
-
-            # If there are any already existing texts, add them all at once.
-            if existing_texts:
-                logger.info(f'Adding {len(existing_embeddings)} cached embeddings.')
-                args = {'embeddings': existing_embeddings, 'documents': existing_texts, 'ids': existing_ids}
-                if metadatas is not None: 
-                    args['metadatas'] = existing_metas
-                self.collection.add(**args)
-
-            # If there are any non-existing texts, compute their embeddings all at once. Each call to embed has significant overhead.
-            if non_existing_texts:
-                non_existing_embeddings = self.embedder.embed(non_existing_texts).tolist()
-                for text, embedding in zip(non_existing_texts, non_existing_embeddings):
-                    self.embeddings_cache[text] = embedding
-
-                logger.info(f'Adding {len(non_existing_embeddings)} new embeddings.')
-                args = {'embeddings': non_existing_embeddings, 'documents': non_existing_texts, 'ids': non_existing_ids}
-                if metadatas is not None: 
-                    args['metadatas'] = non_existing_metas
-                self.collection.add(**args)
-
-            # Create a dictionary that maps each ID to its context and starting index
-            new_info = {
-                id_: {'text_with_context': context, 'start_index': start_index}
-                for id_, context, start_index in zip(new_ids, texts_with_context, starting_indices)
-            }
-
-            self.id_to_info.update(new_info)
-            self.ids.extend(new_ids)
-
-    
-    def _split_texts_by_cache_hit(self, texts: list[str], new_ids: list[str], metadatas: list[dict]):
-        existing_texts, non_existing_texts = [], []
-        existing_embeddings = []
-        existing_ids, non_existing_ids = [], []
-        existing_metas, non_existing_metas = [], []
-
-        for i, text in enumerate(texts):
-            id_ = new_ids[i]
-            metadata = metadatas[i] if metadatas is not None else None
-            embedding = self.embeddings_cache.get(text)
-            if embedding:
-                existing_texts.append(text)
-                existing_embeddings.append(embedding)
-                existing_ids.append(id_)
-                existing_metas.append(metadata)
-            else:
-                non_existing_texts.append(text)
-                non_existing_ids.append(id_)
-                non_existing_metas.append(metadata)
-
-        return (existing_texts, existing_embeddings, existing_ids, existing_metas), \
-               (non_existing_texts, non_existing_ids, non_existing_metas)
-
-
-    def _get_new_ids(self, num_new_ids: int):
-        if self.ids:
-            max_existing_id = max(int(id_) for id_ in self.ids)
-        else:
-            max_existing_id = -1
-
-        return [str(i + max_existing_id + 1) for i in range(num_new_ids)]
-
-    
-    def _find_min_max_start_index(self):
-        max_index, min_index = 0, float('inf')
-        for _, val in self.id_to_info.items():
-            if val['start_index'] > max_index:
-                max_index = val['start_index']
-            if val['start_index'] < min_index:
-                min_index = val['start_index']
-        return min_index, max_index
-
-
-    # NB: Does not make sense to weigh excerpts from different documents. 
-    # But let's say that's the user's problem. Perfect world scenario:
-    # Apply time weighing to different documents. For each document, then, add
-    # separate time weighing.
-    def _apply_sigmoid_time_weighing(self, infos: list[Info], document_len: int, time_steepness: float, time_power: float):
-        sigmoid = lambda x: 1 / (1 + np.exp(-x))
-        
-        weights = sigmoid(time_steepness * np.linspace(-10, 10, document_len))
-
-        # Scale to [0,time_power] and shift it up to [1-time_power, 1]
-        weights = weights - min(weights) 
-        weights = weights * (time_power / max(weights))
-        weights = weights + (1 - time_power) 
-
-        # Reverse the weights
-        weights = weights[::-1]  
-
-        for info in infos:
-            index = info.start_index
-            info.distance *= weights[index]
-
-
-    def _filter_outliers_by_median_distance(self, infos: list[Info], significant_level: float):
-        # Ensure there are infos to filter
-        if not infos:
-            return []
-            
-        # Find info with minimum distance
-        min_info = min(infos, key=lambda x: x.distance)
-
-        # Calculate median distance among infos
-        median_distance = np.median([inf.distance for inf in infos])
-
-        # Filter out infos that have a distance significantly greater than the median
-        filtered_infos = [inf for inf in infos if inf.distance <= significant_level * median_distance]
-
-        # Always include the info with minimum distance
-        if min_info not in filtered_infos:
-            filtered_infos.append(min_info)
-
-        return filtered_infos
-
-
-    def _merge_infos(self, infos: list[Info]):
-        merged_infos = []
-        current_info = infos[0]
-
-        for next_info in infos[1:]:
-            merged = current_info.merge_with(next_info)
-            if merged is not None:
-                current_info = merged
-            else:
-                merged_infos.append(current_info)
-                current_info = next_info
-
-        merged_infos.append(current_info)
-        return merged_infos
-
-
-    # Main function for retrieving chunks by distance. It performs merging, time weighing, and mean filtering.
-    def _get_documents_ids_distances(self, search_strings: list[str], n_results: int):
-        n_results = min(len(self.ids), n_results)
-        if n_results == 0:
-            return [], [], []
-
-        if isinstance(search_strings, str):
-            search_strings = [search_strings]
-
-        infos = []
-        min_start_index, max_start_index = self._find_min_max_start_index()
-
-        for search_string in search_strings:
-            result = self.collection.query(query_texts=search_string, n_results=math.ceil(n_results / len(search_strings)), include=['distances'])
-            curr_infos = [Info(start_index=self.id_to_info[id]['start_index'], 
-                               text_with_context=self.id_to_info[id]['text_with_context'], 
-                               distance=distance, id=id) 
-                          for id, distance in zip(result['ids'][0], result['distances'][0])]
-            
-            self._apply_sigmoid_time_weighing(infos=curr_infos, document_len=max_start_index - min_start_index + 1, time_steepness=parameters.get_time_steepness(), time_power=parameters.get_time_power())
-            curr_infos = self._filter_outliers_by_median_distance(curr_infos, parameters.get_significant_level())
-            infos.extend(curr_infos)
-
-        infos.sort(key=lambda x: x.start_index)
-        infos = self._merge_infos(infos)
-
-        texts_with_context = [inf.text_with_context for inf in infos]
-        ids = [inf.id for inf in infos]
-        distances = [inf.distance for inf in infos]
-
-        return texts_with_context, ids, distances
-    
-
-    # Get chunks by similarity
-    def get(self, search_strings: list[str], n_results: int) -> list[str]:
-        with self.lock:
-            documents, _, _ = self._get_documents_ids_distances(search_strings, n_results)
-            return documents
-    
-
-    # Get ids by similarity
-    def get_ids(self, search_strings: list[str], n_results: int) -> list[str]:
-        with self.lock:
-            _, ids, _ = self._get_documents_ids_distances(search_strings, n_results)
-            return ids
-    
-    
-    # Cutoff token count
-    def _get_documents_up_to_token_count(self, documents: list[str], max_token_count: int):
-        # TODO: Move to caller; We add delimiters there which might go over the limit.
-        current_token_count = 0
-        return_documents = []
-
-        for doc in documents:
-            doc_tokens = encode(doc)[0]
-            doc_token_count = len(doc_tokens)
-            if current_token_count + doc_token_count > max_token_count:
-                # If adding this document would exceed the max token count,
-                # truncate the document to fit within the limit.
-                remaining_tokens = max_token_count - current_token_count
-                
-                truncated_doc = decode(doc_tokens[:remaining_tokens], skip_special_tokens=True)
-                return_documents.append(truncated_doc)
-                break
-            else:
-                return_documents.append(doc)
-                current_token_count += doc_token_count
-
-        return return_documents
-    
-
-    # Get chunks by similarity and then sort by ids
-    def get_sorted_by_ids(self, search_strings: list[str], n_results: int, max_token_count: int) -> list[str]:
-        with self.lock:
-            documents, ids, _ = self._get_documents_ids_distances(search_strings, n_results)
-            sorted_docs = [x for _, x in sorted(zip(ids, documents))]
-
-            return self._get_documents_up_to_token_count(sorted_docs, max_token_count)
-    
-    
-    # Get chunks by similarity and then sort by distance (lowest distance is last).
-    def get_sorted_by_dist(self, search_strings: list[str], n_results: int, max_token_count: int) -> list[str]:
-        with self.lock:
-            documents, _, distances = self._get_documents_ids_distances(search_strings, n_results)
-            sorted_docs = [doc for doc, _ in sorted(zip(documents, distances), key=lambda x: x[1])] # sorted lowest -> highest
-            
-            # If a document is truncated or competely skipped, it would be with high distance.
-            return_documents = self._get_documents_up_to_token_count(sorted_docs, max_token_count)
-            return_documents.reverse() # highest -> lowest
-
-            return return_documents
-    
-
-    def delete(self, ids_to_delete: list[str], where: dict):
-        with self.lock:
-            ids_to_delete = self.collection.get(ids=ids_to_delete, where=where)['ids']
-            self.collection.delete(ids=ids_to_delete, where=where)
-
-            # Remove the deleted ids from self.ids and self.id_to_info
-            ids_set = set(ids_to_delete)
-            self.ids = [id_ for id_ in self.ids if id_ not in ids_set]
-            for id_ in ids_to_delete:
-                self.id_to_info.pop(id_, None)
-
-            logger.info(f'Successfully deleted {len(ids_to_delete)} records from chromaDB.')
-
-
-    def clear(self):
-        with self.lock:
-            self.chroma_client.reset()
-            self.collection = self.chroma_client.create_collection("context", embedding_function=self.embedder.embed)
-            self.ids = []
-            self.id_to_info = {}
-
-            logger.info('Successfully cleared all records and reset chromaDB.')
-
-
-class SentenceTransformerEmbedder(Embedder):
-    def __init__(self) -> None:
-        logger.debug('Creating Sentence Embedder...')
-        self.model = SentenceTransformer("sentence-transformers/all-mpnet-base-v2")
-        self.embed = self.model.encode
-
-
-def make_collector():
-    return ChromaCollector(SentenceTransformerEmbedder())

spaces/Anonymous-123/ImageNet-Editing/object_removal/TFill/model/stylegan_ops/__init__.py

@@ -1,2 +0,0 @@
-from .fused_act import FusedLeakyReLU, fused_leaky_relu
-from .upfirdn2d import upfirdn2d

spaces/Anonymous-sub/Rerender/ControlNet/annotator/uniformer/mmcv/ops/upfirdn2d.py

@@ -1,330 +0,0 @@
-# modified from https://github.com/rosinality/stylegan2-pytorch/blob/master/op/upfirdn2d.py  # noqa:E501
-
-# Copyright (c) 2021, NVIDIA Corporation. All rights reserved.
-# NVIDIA Source Code License for StyleGAN2 with Adaptive Discriminator
-# Augmentation (ADA)
-# =======================================================================
-
-# 1. Definitions
-
-# "Licensor" means any person or entity that distributes its Work.
-
-# "Software" means the original work of authorship made available under
-# this License.
-
-# "Work" means the Software and any additions to or derivative works of
-# the Software that are made available under this License.
-
-# The terms "reproduce," "reproduction," "derivative works," and
-# "distribution" have the meaning as provided under U.S. copyright law;
-# provided, however, that for the purposes of this License, derivative
-# works shall not include works that remain separable from, or merely
-# link (or bind by name) to the interfaces of, the Work.
-
-# Works, including the Software, are "made available" under this License
-# by including in or with the Work either (a) a copyright notice
-# referencing the applicability of this License to the Work, or (b) a
-# copy of this License.
-
-# 2. License Grants
-
-#     2.1 Copyright Grant. Subject to the terms and conditions of this
-#     License, each Licensor grants to you a perpetual, worldwide,
-#     non-exclusive, royalty-free, copyright license to reproduce,
-#     prepare derivative works of, publicly display, publicly perform,
-#     sublicense and distribute its Work and any resulting derivative
-#     works in any form.
-
-# 3. Limitations
-
-#     3.1 Redistribution. You may reproduce or distribute the Work only
-#     if (a) you do so under this License, (b) you include a complete
-#     copy of this License with your distribution, and (c) you retain
-#     without modification any copyright, patent, trademark, or
-#     attribution notices that are present in the Work.
-
-#     3.2 Derivative Works. You may specify that additional or different
-#     terms apply to the use, reproduction, and distribution of your
-#     derivative works of the Work ("Your Terms") only if (a) Your Terms
-#     provide that the use limitation in Section 3.3 applies to your
-#     derivative works, and (b) you identify the specific derivative
-#     works that are subject to Your Terms. Notwithstanding Your Terms,
-#     this License (including the redistribution requirements in Section
-#     3.1) will continue to apply to the Work itself.
-
-#     3.3 Use Limitation. The Work and any derivative works thereof only
-#     may be used or intended for use non-commercially. Notwithstanding
-#     the foregoing, NVIDIA and its affiliates may use the Work and any
-#     derivative works commercially. As used herein, "non-commercially"
-#     means for research or evaluation purposes only.
-
-#     3.4 Patent Claims. If you bring or threaten to bring a patent claim
-#     against any Licensor (including any claim, cross-claim or
-#     counterclaim in a lawsuit) to enforce any patents that you allege
-#     are infringed by any Work, then your rights under this License from
-#     such Licensor (including the grant in Section 2.1) will terminate
-#     immediately.
-
-#     3.5 Trademarks. This License does not grant any rights to use any
-#     Licensor’s or its affiliates’ names, logos, or trademarks, except
-#     as necessary to reproduce the notices described in this License.
-
-#     3.6 Termination. If you violate any term of this License, then your
-#     rights under this License (including the grant in Section 2.1) will
-#     terminate immediately.
-
-# 4. Disclaimer of Warranty.
-
-# THE WORK IS PROVIDED "AS IS" WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WARRANTIES OR CONDITIONS OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE OR
-# NON-INFRINGEMENT. YOU BEAR THE RISK OF UNDERTAKING ANY ACTIVITIES UNDER
-# THIS LICENSE.
-
-# 5. Limitation of Liability.
-
-# EXCEPT AS PROHIBITED BY APPLICABLE LAW, IN NO EVENT AND UNDER NO LEGAL
-# THEORY, WHETHER IN TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE
-# SHALL ANY LICENSOR BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY DIRECT,
-# INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
-# OR RELATED TO THIS LICENSE, THE USE OR INABILITY TO USE THE WORK
-# (INCLUDING BUT NOT LIMITED TO LOSS OF GOODWILL, BUSINESS INTERRUPTION,
-# LOST PROFITS OR DATA, COMPUTER FAILURE OR MALFUNCTION, OR ANY OTHER
-# COMMERCIAL DAMAGES OR LOSSES), EVEN IF THE LICENSOR HAS BEEN ADVISED OF
-# THE POSSIBILITY OF SUCH DAMAGES.
-
-# =======================================================================
-
-import torch
-from torch.autograd import Function
-from torch.nn import functional as F
-
-from annotator.uniformer.mmcv.utils import to_2tuple
-from ..utils import ext_loader
-
-upfirdn2d_ext = ext_loader.load_ext('_ext', ['upfirdn2d'])
-
-
-class UpFirDn2dBackward(Function):
-
-    @staticmethod
-    def forward(ctx, grad_output, kernel, grad_kernel, up, down, pad, g_pad,
-                in_size, out_size):
-
-        up_x, up_y = up
-        down_x, down_y = down
-        g_pad_x0, g_pad_x1, g_pad_y0, g_pad_y1 = g_pad
-
-        grad_output = grad_output.reshape(-1, out_size[0], out_size[1], 1)
-
-        grad_input = upfirdn2d_ext.upfirdn2d(
-            grad_output,
-            grad_kernel,
-            up_x=down_x,
-            up_y=down_y,
-            down_x=up_x,
-            down_y=up_y,
-            pad_x0=g_pad_x0,
-            pad_x1=g_pad_x1,
-            pad_y0=g_pad_y0,
-            pad_y1=g_pad_y1)
-        grad_input = grad_input.view(in_size[0], in_size[1], in_size[2],
-                                     in_size[3])
-
-        ctx.save_for_backward(kernel)
-
-        pad_x0, pad_x1, pad_y0, pad_y1 = pad
-
-        ctx.up_x = up_x
-        ctx.up_y = up_y
-        ctx.down_x = down_x
-        ctx.down_y = down_y
-        ctx.pad_x0 = pad_x0
-        ctx.pad_x1 = pad_x1
-        ctx.pad_y0 = pad_y0
-        ctx.pad_y1 = pad_y1
-        ctx.in_size = in_size
-        ctx.out_size = out_size
-
-        return grad_input
-
-    @staticmethod
-    def backward(ctx, gradgrad_input):
-        kernel, = ctx.saved_tensors
-
-        gradgrad_input = gradgrad_input.reshape(-1, ctx.in_size[2],
-                                                ctx.in_size[3], 1)
-
-        gradgrad_out = upfirdn2d_ext.upfirdn2d(
-            gradgrad_input,
-            kernel,
-            up_x=ctx.up_x,
-            up_y=ctx.up_y,
-            down_x=ctx.down_x,
-            down_y=ctx.down_y,
-            pad_x0=ctx.pad_x0,
-            pad_x1=ctx.pad_x1,
-            pad_y0=ctx.pad_y0,
-            pad_y1=ctx.pad_y1)
-        # gradgrad_out = gradgrad_out.view(ctx.in_size[0], ctx.out_size[0],
-        #                                  ctx.out_size[1], ctx.in_size[3])
-        gradgrad_out = gradgrad_out.view(ctx.in_size[0], ctx.in_size[1],
-                                         ctx.out_size[0], ctx.out_size[1])
-
-        return gradgrad_out, None, None, None, None, None, None, None, None
-
-
-class UpFirDn2d(Function):
-
-    @staticmethod
-    def forward(ctx, input, kernel, up, down, pad):
-        up_x, up_y = up
-        down_x, down_y = down
-        pad_x0, pad_x1, pad_y0, pad_y1 = pad
-
-        kernel_h, kernel_w = kernel.shape
-        batch, channel, in_h, in_w = input.shape
-        ctx.in_size = input.shape
-
-        input = input.reshape(-1, in_h, in_w, 1)
-
-        ctx.save_for_backward(kernel, torch.flip(kernel, [0, 1]))
-
-        out_h = (in_h * up_y + pad_y0 + pad_y1 - kernel_h) // down_y + 1
-        out_w = (in_w * up_x + pad_x0 + pad_x1 - kernel_w) // down_x + 1
-        ctx.out_size = (out_h, out_w)
-
-        ctx.up = (up_x, up_y)
-        ctx.down = (down_x, down_y)
-        ctx.pad = (pad_x0, pad_x1, pad_y0, pad_y1)
-
-        g_pad_x0 = kernel_w - pad_x0 - 1
-        g_pad_y0 = kernel_h - pad_y0 - 1
-        g_pad_x1 = in_w * up_x - out_w * down_x + pad_x0 - up_x + 1
-        g_pad_y1 = in_h * up_y - out_h * down_y + pad_y0 - up_y + 1
-
-        ctx.g_pad = (g_pad_x0, g_pad_x1, g_pad_y0, g_pad_y1)
-
-        out = upfirdn2d_ext.upfirdn2d(
-            input,
-            kernel,
-            up_x=up_x,
-            up_y=up_y,
-            down_x=down_x,
-            down_y=down_y,
-            pad_x0=pad_x0,
-            pad_x1=pad_x1,
-            pad_y0=pad_y0,
-            pad_y1=pad_y1)
-        # out = out.view(major, out_h, out_w, minor)
-        out = out.view(-1, channel, out_h, out_w)
-
-        return out
-
-    @staticmethod
-    def backward(ctx, grad_output):
-        kernel, grad_kernel = ctx.saved_tensors
-
-        grad_input = UpFirDn2dBackward.apply(
-            grad_output,
-            kernel,
-            grad_kernel,
-            ctx.up,
-            ctx.down,
-            ctx.pad,
-            ctx.g_pad,
-            ctx.in_size,
-            ctx.out_size,
-        )
-
-        return grad_input, None, None, None, None
-
-
-def upfirdn2d(input, kernel, up=1, down=1, pad=(0, 0)):
-    """UpFRIDn for 2d features.
-
-    UpFIRDn is short for upsample, apply FIR filter and downsample. More
-    details can be found in:
-    https://www.mathworks.com/help/signal/ref/upfirdn.html
-
-    Args:
-        input (Tensor): Tensor with shape of (n, c, h, w).
-        kernel (Tensor): Filter kernel.
-        up (int | tuple[int], optional): Upsampling factor. If given a number,
-            we will use this factor for the both height and width side.
-            Defaults to 1.
-        down (int | tuple[int], optional): Downsampling factor. If given a
-            number, we will use this factor for the both height and width side.
-            Defaults to 1.
-        pad (tuple[int], optional): Padding for tensors, (x_pad, y_pad) or
-            (x_pad_0, x_pad_1, y_pad_0, y_pad_1). Defaults to (0, 0).
-
-    Returns:
-        Tensor: Tensor after UpFIRDn.
-    """
-    if input.device.type == 'cpu':
-        if len(pad) == 2:
-            pad = (pad[0], pad[1], pad[0], pad[1])
-
-        up = to_2tuple(up)
-
-        down = to_2tuple(down)
-
-        out = upfirdn2d_native(input, kernel, up[0], up[1], down[0], down[1],
-                               pad[0], pad[1], pad[2], pad[3])
-    else:
-        _up = to_2tuple(up)
-
-        _down = to_2tuple(down)
-
-        if len(pad) == 4:
-            _pad = pad
-        elif len(pad) == 2:
-            _pad = (pad[0], pad[1], pad[0], pad[1])
-
-        out = UpFirDn2d.apply(input, kernel, _up, _down, _pad)
-
-    return out
-
-
-def upfirdn2d_native(input, kernel, up_x, up_y, down_x, down_y, pad_x0, pad_x1,
-                     pad_y0, pad_y1):
-    _, channel, in_h, in_w = input.shape
-    input = input.reshape(-1, in_h, in_w, 1)
-
-    _, in_h, in_w, minor = input.shape
-    kernel_h, kernel_w = kernel.shape
-
-    out = input.view(-1, in_h, 1, in_w, 1, minor)
-    out = F.pad(out, [0, 0, 0, up_x - 1, 0, 0, 0, up_y - 1])
-    out = out.view(-1, in_h * up_y, in_w * up_x, minor)
-
-    out = F.pad(
-        out,
-        [0, 0,
-         max(pad_x0, 0),
-         max(pad_x1, 0),
-         max(pad_y0, 0),
-         max(pad_y1, 0)])
-    out = out[:,
-              max(-pad_y0, 0):out.shape[1] - max(-pad_y1, 0),
-              max(-pad_x0, 0):out.shape[2] - max(-pad_x1, 0), :, ]
-
-    out = out.permute(0, 3, 1, 2)
-    out = out.reshape(
-        [-1, 1, in_h * up_y + pad_y0 + pad_y1, in_w * up_x + pad_x0 + pad_x1])
-    w = torch.flip(kernel, [0, 1]).view(1, 1, kernel_h, kernel_w)
-    out = F.conv2d(out, w)
-    out = out.reshape(
-        -1,
-        minor,
-        in_h * up_y + pad_y0 + pad_y1 - kernel_h + 1,
-        in_w * up_x + pad_x0 + pad_x1 - kernel_w + 1,
-    )
-    out = out.permute(0, 2, 3, 1)
-    out = out[:, ::down_y, ::down_x, :]
-
-    out_h = (in_h * up_y + pad_y0 + pad_y1 - kernel_h) // down_y + 1
-    out_w = (in_w * up_x + pad_x0 + pad_x1 - kernel_w) // down_x + 1
-
-    return out.view(-1, channel, out_h, out_w)

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

@@ -1,27 +0,0 @@
-"""Filetype information.
-"""
-
-from typing import Tuple
-
-from pip._internal.utils.misc import splitext
-
-WHEEL_EXTENSION = ".whl"
-BZ2_EXTENSIONS: Tuple[str, ...] = (".tar.bz2", ".tbz")
-XZ_EXTENSIONS: Tuple[str, ...] = (
-    ".tar.xz",
-    ".txz",
-    ".tlz",
-    ".tar.lz",
-    ".tar.lzma",
-)
-ZIP_EXTENSIONS: Tuple[str, ...] = (".zip", WHEEL_EXTENSION)
-TAR_EXTENSIONS: Tuple[str, ...] = (".tar.gz", ".tgz", ".tar")
-ARCHIVE_EXTENSIONS = ZIP_EXTENSIONS + BZ2_EXTENSIONS + TAR_EXTENSIONS + XZ_EXTENSIONS
-
-
-def is_archive_file(name: str) -> bool:
-    """Return True if `name` is a considered as an archive file."""
-    ext = splitext(name)[1].lower()
-    if ext in ARCHIVE_EXTENSIONS:
-        return True
-    return False

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

@@ -1,364 +0,0 @@
-"""distutils.cygwinccompiler
-
-Provides the CygwinCCompiler class, a subclass of UnixCCompiler that
-handles the Cygwin port of the GNU C compiler to Windows.  It also contains
-the Mingw32CCompiler class which handles the mingw32 port of GCC (same as
-cygwin in no-cygwin mode).
-"""
-
-import os
-import sys
-import copy
-import shlex
-import warnings
-from subprocess import check_output
-
-from distutils.unixccompiler import UnixCCompiler
-from distutils.file_util import write_file
-from distutils.errors import (
-    DistutilsExecError,
-    DistutilsPlatformError,
-    CCompilerError,
-    CompileError,
-)
-from distutils.version import LooseVersion, suppress_known_deprecation
-
-
-def get_msvcr():
-    """Include the appropriate MSVC runtime library if Python was built
-    with MSVC 7.0 or later.
-    """
-    msc_pos = sys.version.find('MSC v.')
-    if msc_pos != -1:
-        msc_ver = sys.version[msc_pos + 6 : msc_pos + 10]
-        if msc_ver == '1300':
-            # MSVC 7.0
-            return ['msvcr70']
-        elif msc_ver == '1310':
-            # MSVC 7.1
-            return ['msvcr71']
-        elif msc_ver == '1400':
-            # VS2005 / MSVC 8.0
-            return ['msvcr80']
-        elif msc_ver == '1500':
-            # VS2008 / MSVC 9.0
-            return ['msvcr90']
-        elif msc_ver == '1600':
-            # VS2010 / MSVC 10.0
-            return ['msvcr100']
-        elif msc_ver == '1700':
-            # VS2012 / MSVC 11.0
-            return ['msvcr110']
-        elif msc_ver == '1800':
-            # VS2013 / MSVC 12.0
-            return ['msvcr120']
-        elif 1900 <= int(msc_ver) < 2000:
-            # VS2015 / MSVC 14.0
-            return ['ucrt', 'vcruntime140']
-        else:
-            raise ValueError("Unknown MS Compiler version %s " % msc_ver)
-
-
-_runtime_library_dirs_msg = (
-    "Unable to set runtime library search path on Windows, "
-    "usually indicated by `runtime_library_dirs` parameter to Extension"
-)
-
-
-class CygwinCCompiler(UnixCCompiler):
-    """Handles the Cygwin port of the GNU C compiler to Windows."""
-
-    compiler_type = 'cygwin'
-    obj_extension = ".o"
-    static_lib_extension = ".a"
-    shared_lib_extension = ".dll.a"
-    dylib_lib_extension = ".dll"
-    static_lib_format = "lib%s%s"
-    shared_lib_format = "lib%s%s"
-    dylib_lib_format = "cyg%s%s"
-    exe_extension = ".exe"
-
-    def __init__(self, verbose=0, dry_run=0, force=0):
-
-        super().__init__(verbose, dry_run, force)
-
-        status, details = check_config_h()
-        self.debug_print(
-            "Python's GCC status: {} (details: {})".format(status, details)
-        )
-        if status is not CONFIG_H_OK:
-            self.warn(
-                "Python's pyconfig.h doesn't seem to support your compiler. "
-                "Reason: %s. "
-                "Compiling may fail because of undefined preprocessor macros." % details
-            )
-
-        self.cc = os.environ.get('CC', 'gcc')
-        self.cxx = os.environ.get('CXX', 'g++')
-
-        self.linker_dll = self.cc
-        shared_option = "-shared"
-
-        self.set_executables(
-            compiler='%s -mcygwin -O -Wall' % self.cc,
-            compiler_so='%s -mcygwin -mdll -O -Wall' % self.cc,
-            compiler_cxx='%s -mcygwin -O -Wall' % self.cxx,
-            linker_exe='%s -mcygwin' % self.cc,
-            linker_so=('{} -mcygwin {}'.format(self.linker_dll, shared_option)),
-        )
-
-        # Include the appropriate MSVC runtime library if Python was built
-        # with MSVC 7.0 or later.
-        self.dll_libraries = get_msvcr()
-
-    @property
-    def gcc_version(self):
-        # Older numpy dependend on this existing to check for ancient
-        # gcc versions. This doesn't make much sense with clang etc so
-        # just hardcode to something recent.
-        # https://github.com/numpy/numpy/pull/20333
-        warnings.warn(
-            "gcc_version attribute of CygwinCCompiler is deprecated. "
-            "Instead of returning actual gcc version a fixed value 11.2.0 is returned.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        with suppress_known_deprecation():
-            return LooseVersion("11.2.0")
-
-    def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
-        """Compiles the source by spawning GCC and windres if needed."""
-        if ext == '.rc' or ext == '.res':
-            # gcc needs '.res' and '.rc' compiled to object files !!!
-            try:
-                self.spawn(["windres", "-i", src, "-o", obj])
-            except DistutilsExecError as msg:
-                raise CompileError(msg)
-        else:  # for other files use the C-compiler
-            try:
-                self.spawn(
-                    self.compiler_so + cc_args + [src, '-o', obj] + extra_postargs
-                )
-            except DistutilsExecError as msg:
-                raise CompileError(msg)
-
-    def link(
-        self,
-        target_desc,
-        objects,
-        output_filename,
-        output_dir=None,
-        libraries=None,
-        library_dirs=None,
-        runtime_library_dirs=None,
-        export_symbols=None,
-        debug=0,
-        extra_preargs=None,
-        extra_postargs=None,
-        build_temp=None,
-        target_lang=None,
-    ):
-        """Link the objects."""
-        # use separate copies, so we can modify the lists
-        extra_preargs = copy.copy(extra_preargs or [])
-        libraries = copy.copy(libraries or [])
-        objects = copy.copy(objects or [])
-
-        if runtime_library_dirs:
-            self.warn(_runtime_library_dirs_msg)
-
-        # Additional libraries
-        libraries.extend(self.dll_libraries)
-
-        # handle export symbols by creating a def-file
-        # with executables this only works with gcc/ld as linker
-        if (export_symbols is not None) and (
-            target_desc != self.EXECUTABLE or self.linker_dll == "gcc"
-        ):
-            # (The linker doesn't do anything if output is up-to-date.
-            # So it would probably better to check if we really need this,
-            # but for this we had to insert some unchanged parts of
-            # UnixCCompiler, and this is not what we want.)
-
-            # we want to put some files in the same directory as the
-            # object files are, build_temp doesn't help much
-            # where are the object files
-            temp_dir = os.path.dirname(objects[0])
-            # name of dll to give the helper files the same base name
-            (dll_name, dll_extension) = os.path.splitext(
-                os.path.basename(output_filename)
-            )
-
-            # generate the filenames for these files
-            def_file = os.path.join(temp_dir, dll_name + ".def")
-
-            # Generate .def file
-            contents = ["LIBRARY %s" % os.path.basename(output_filename), "EXPORTS"]
-            for sym in export_symbols:
-                contents.append(sym)
-            self.execute(write_file, (def_file, contents), "writing %s" % def_file)
-
-            # next add options for def-file
-
-            # for gcc/ld the def-file is specified as any object files
-            objects.append(def_file)
-
-        # end: if ((export_symbols is not None) and
-        #        (target_desc != self.EXECUTABLE or self.linker_dll == "gcc")):
-
-        # who wants symbols and a many times larger output file
-        # should explicitly switch the debug mode on
-        # otherwise we let ld strip the output file
-        # (On my machine: 10KiB < stripped_file < ??100KiB
-        #   unstripped_file = stripped_file + XXX KiB
-        #  ( XXX=254 for a typical python extension))
-        if not debug:
-            extra_preargs.append("-s")
-
-        UnixCCompiler.link(
-            self,
-            target_desc,
-            objects,
-            output_filename,
-            output_dir,
-            libraries,
-            library_dirs,
-            runtime_library_dirs,
-            None,  # export_symbols, we do this in our def-file
-            debug,
-            extra_preargs,
-            extra_postargs,
-            build_temp,
-            target_lang,
-        )
-
-    def runtime_library_dir_option(self, dir):
-        # cygwin doesn't support rpath. While in theory we could error
-        # out like MSVC does, code might expect it to work like on Unix, so
-        # just warn and hope for the best.
-        self.warn(_runtime_library_dirs_msg)
-        return []
-
-    # -- Miscellaneous methods -----------------------------------------
-
-    def _make_out_path(self, output_dir, strip_dir, src_name):
-        # use normcase to make sure '.rc' is really '.rc' and not '.RC'
-        norm_src_name = os.path.normcase(src_name)
-        return super()._make_out_path(output_dir, strip_dir, norm_src_name)
-
-    @property
-    def out_extensions(self):
-        """
-        Add support for rc and res files.
-        """
-        return {
-            **super().out_extensions,
-            **{ext: ext + self.obj_extension for ext in ('.res', '.rc')},
-        }
-
-
-# the same as cygwin plus some additional parameters
-class Mingw32CCompiler(CygwinCCompiler):
-    """Handles the Mingw32 port of the GNU C compiler to Windows."""
-
-    compiler_type = 'mingw32'
-
-    def __init__(self, verbose=0, dry_run=0, force=0):
-
-        super().__init__(verbose, dry_run, force)
-
-        shared_option = "-shared"
-
-        if is_cygwincc(self.cc):
-            raise CCompilerError('Cygwin gcc cannot be used with --compiler=mingw32')
-
-        self.set_executables(
-            compiler='%s -O -Wall' % self.cc,
-            compiler_so='%s -mdll -O -Wall' % self.cc,
-            compiler_cxx='%s -O -Wall' % self.cxx,
-            linker_exe='%s' % self.cc,
-            linker_so='{} {}'.format(self.linker_dll, shared_option),
-        )
-
-        # Maybe we should also append -mthreads, but then the finished
-        # dlls need another dll (mingwm10.dll see Mingw32 docs)
-        # (-mthreads: Support thread-safe exception handling on `Mingw32')
-
-        # no additional libraries needed
-        self.dll_libraries = []
-
-        # Include the appropriate MSVC runtime library if Python was built
-        # with MSVC 7.0 or later.
-        self.dll_libraries = get_msvcr()
-
-    def runtime_library_dir_option(self, dir):
-        raise DistutilsPlatformError(_runtime_library_dirs_msg)
-
-
-# Because these compilers aren't configured in Python's pyconfig.h file by
-# default, we should at least warn the user if he is using an unmodified
-# version.
-
-CONFIG_H_OK = "ok"
-CONFIG_H_NOTOK = "not ok"
-CONFIG_H_UNCERTAIN = "uncertain"
-
-
-def check_config_h():
-    """Check if the current Python installation appears amenable to building
-    extensions with GCC.
-
-    Returns a tuple (status, details), where 'status' is one of the following
-    constants:
-
-    - CONFIG_H_OK: all is well, go ahead and compile
-    - CONFIG_H_NOTOK: doesn't look good
-    - CONFIG_H_UNCERTAIN: not sure -- unable to read pyconfig.h
-
-    'details' is a human-readable string explaining the situation.
-
-    Note there are two ways to conclude "OK": either 'sys.version' contains
-    the string "GCC" (implying that this Python was built with GCC), or the
-    installed "pyconfig.h" contains the string "__GNUC__".
-    """
-
-    # XXX since this function also checks sys.version, it's not strictly a
-    # "pyconfig.h" check -- should probably be renamed...
-
-    from distutils import sysconfig
-
-    # if sys.version contains GCC then python was compiled with GCC, and the
-    # pyconfig.h file should be OK
-    if "GCC" in sys.version:
-        return CONFIG_H_OK, "sys.version mentions 'GCC'"
-
-    # Clang would also work
-    if "Clang" in sys.version:
-        return CONFIG_H_OK, "sys.version mentions 'Clang'"
-
-    # let's see if __GNUC__ is mentioned in python.h
-    fn = sysconfig.get_config_h_filename()
-    try:
-        config_h = open(fn)
-        try:
-            if "__GNUC__" in config_h.read():
-                return CONFIG_H_OK, "'%s' mentions '__GNUC__'" % fn
-            else:
-                return CONFIG_H_NOTOK, "'%s' does not mention '__GNUC__'" % fn
-        finally:
-            config_h.close()
-    except OSError as exc:
-        return (CONFIG_H_UNCERTAIN, "couldn't read '{}': {}".format(fn, exc.strerror))
-
-
-def is_cygwincc(cc):
-    '''Try to determine if the compiler that would be used is from cygwin.'''
-    out_string = check_output(shlex.split(cc) + ['-dumpmachine'])
-    return out_string.strip().endswith(b'cygwin')
-
-
-get_versions = None
-"""
-A stand-in for the previous get_versions() function to prevent failures
-when monkeypatched. See pypa/setuptools#2969.
-"""

spaces/AyushP/PolicyCompareBot/README.md

@@ -1,12 +0,0 @@
----
-title: PolicyCompareBot
-emoji: 🌖
-colorFrom: gray
-colorTo: purple
-sdk: streamlit
-sdk_version: 1.17.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/Benson/text-generation/Examples/5 Documento De Pregunta Beca 2016 Pdf.md

@@ -1,76 +0,0 @@
-
-<h1>5th Scholarship Question Paper 2016 PDF Descargar</h1>
-<p>Si usted es un estudiante que aspira a obtener una beca para su educación superior, entonces usted podría estar interesado en tomar el quinto examen de beca. Se trata de un examen competitivo que llevan a cabo diversas autoridades de la India y Sri Lanka para estudiantes que están en su último año de primaria. El examen pone a prueba sus conocimientos, habilidades y aptitudes en diversas materias y le ayuda a obtener la admisión en escuelas y colegios de renombre. </p>
-<h2>5º documento de pregunta beca 2016 pdf</h2><br /><p><b><b>Download</b> &#10004; <a href="https://bltlly.com/2v6MD1">https://bltlly.com/2v6MD1</a></b></p><br /><br />
-<p>Sin embargo, prepararse para este examen no es una tarea fácil. Es necesario tener una clara comprensión del programa de estudios, temas y patrones de preguntas. También es necesario practicar una gran cantidad de documentos del año anterior para familiarizarse con el nivel de dificultad y la gestión del tiempo. Una de las mejores maneras de hacer esto es descargar y utilizar el quinto documento de pregunta beca 2016 PDF.</p>
-<p>En este artículo, le diremos cómo descargar el quinto documento de preguntas de becas 2016 PDF y cómo usarlo para su preparación. También compartiremos algunos consejos y trucos para resolver las preguntas y algunas preguntas de muestra y respuestas del documento. Al leer este artículo, podrás aumentar tu confianza y rendimiento en el examen. </p>
- <h2>Cómo descargar el quinto documento de preguntas de becas 2016 PDF</h2>
-<p>El primer paso para prepararse para el quinto examen de beca es descargar los documentos anteriores del examen. Los trabajos anteriores te ayudarán a entender el formato, el programa y el nivel de dificultad del examen. También le ayudarán a identificar sus fortalezas y debilidades y trabajar en consecuencia. </p>
-<p></p>
-<p>El quinto documento de preguntas de becas 2016 PDF está disponible en línea en varios sitios web. Puedes descargarlo desde cualquiera de estos sitios web siguiendo estos sencillos pasos:</p>
-<h3>Paso 1: Visita el sitio web oficial de la autoridad examinadora</h3>
-
-<h3>Paso 2: Encuentre el enlace para los documentos anteriores y haga clic en él</h3>
-<p>El siguiente paso es encontrar el enlace para descargar los documentos anteriores del examen en el sitio web. Por lo general, este enlace estará bajo una sección llamada "Descargas", "Recursos" o "Documentos anteriores". Haga clic en este enlace para ir a una página donde puede ver todos los documentos anteriores disponibles para su descarga. </p>
-<h3>Paso 3: Seleccione el año 2016 y el medio de su elección</h3>
-<p>El tercer paso es seleccionar el año 2016 de la lista de artículos anteriores. Esto le mostrará el archivo PDF del quinto documento de preguntas de becas 2016 en el medio de su elección. El medio puede ser inglés, hindi, marathi, tamil, cingalés o cualquier otro idioma en el que se realice el examen. Haga clic en el archivo PDF para verlo en línea o descargarlo en su dispositivo. </p>
-<h3>Paso 4: Descargue el archivo PDF y guárdelo en su dispositivo</h3>
-<p>El paso final es descargar el archivo PDF del quinto documento de preguntas de la beca 2016 y guardarlo en su dispositivo. Puede hacer esto haciendo clic derecho en el archivo PDF y eligiendo la opción "Guardar como" o "Descargar". También puede utilizar un gestor de descargas o una extensión del navegador para descargar el archivo más rápido y fácil. Asegúrate de tener suficiente espacio en tu dispositivo y una buena conexión a Internet para descargar el archivo sin errores. </p>
- <h2>Cómo utilizar el quinto documento de preguntas de becas 2016 PDF para la preparación</h2>
-<p>Ahora que ha descargado el quinto documento de pregunta beca 2016 PDF, es posible que se pregunte cómo usarlo para su preparación. Bueno, hay muchas maneras de usar el trabajo anterior para mejorar tus conocimientos, habilidades y confianza para el examen. Estas son algunas de ellas:</p>
-<h3>Consejos y trucos para resolver las preguntas</h3>
-
-<p>Algunos de los consejos y trucos que puedes aprender del trabajo anterior son:</p>
-<ul>
-<li>Lea la pregunta cuidadosamente y entienda lo que está pidiendo. </li>
-<li> Eliminar las opciones incorrectas o irrelevantes mediante el uso de la lógica, el sentido común o el método de eliminación. </li>
-<li> Utilice atajos, fórmulas o diagramas para resolver las preguntas más rápido y fácil. </li>
-<li>Comprueba tus respuestas usando métodos de cálculo inverso, sustitución o comprobación cruzada. </li>
-<li>Evite adivinar o marcar respuestas al azar. Si no está seguro sobre una respuesta, déjela en blanco o márquela para revisarla más tarde. </li>
-</ul>
-<h3>Temas y plan de estudios tratados en el documento</h3>
-<p>La segunda forma de utilizar el artículo anterior es revisar los temas y el programa de estudios cubiertos en el examen. El quinto examen de beca cubre varias materias como Matemáticas, Ciencias, Estudios Sociales, Inglés y Conocimientos Generales. Es necesario tener un conocimiento profundo de estos temas y sus conceptos para obtener una buena puntuación en el examen. </p>
-<p>El artículo anterior te ayudará a identificar los temas y subtemas importantes que se piden con frecuencia en el examen. También te ayudará a revisar los conceptos que ya has aprendido y a llenar cualquier vacío en tu conocimiento. Puedes usar el artículo anterior como una guía para planificar tu horario de estudio y asignar tiempo para cada tema en consecuencia. </p>
-<h3>Ejemplos de preguntas y respuestas del artículo</h3>
-<p>La tercera forma de usar el artículo anterior es practicar algunas preguntas y respuestas de muestra del artículo. Esta es la mejor manera de probar sus conocimientos, habilidades y velocidad para el examen. Al resolver las preguntas de muestra, podrá evaluar su rendimiento y precisión. También podrás aprender de tus errores y mejorar tus áreas débiles. </p>
-
-<p>Aquí hay algunas preguntas de muestra y respuestas del quinto documento de preguntas de becas 2016 PDF:</p>
-<tabla>
-<tr>
-<th>Pregunta</th>
-<th>Respuesta</th>
-</tr>
-<tr>
-<td>¿Cuál de los siguientes es un número primo? </td>
-<td>A) 15<br>B) 17<br>C) 21<br>D) 25<br><br><br>La respuesta correcta es B) 17. Un número primo es un número que tiene solo dos factores, 1 y sí mismo. 17 tiene solo dos factores, 1 y 17, por lo que es un número primo. Las otras opciones no son números primos porque tienen más de dos factores. </td>
-</tr>
-<tr>
-<td>¿Cuál de las siguientes es la capital de Sri Lanka? </td>
-<td>A) Colombo<br>B) Kandy<br>C) Jaffna<br>D) Galle<br><br>La respuesta correcta es A) Colombo. Colombo es la ciudad más grande y la capital comercial de Sri Lanka. Se encuentra en la costa oeste de la isla y tiene una población de alrededor de 5,6 millones de personas. Las otras opciones son otras ciudades en Sri Lanka, pero no son la capital. </td>
-</tr>
-<tr>
-<td>¿Cuál de los siguientes es sinónimo de "feliz"? </td>
-<td>A) Triste<br>B) Enojado<br>C) Contento<br>D) Asustado<br><br>La respuesta correcta es C) Contento. Un sinónimo es una palabra que tiene el mismo o similar significado que otra palabra. Alegre significa sentir placer, alegría o satisfacción, que es similar a feliz. Las otras opciones son antónimos de feliz, lo que significa que tienen significados opuestos. </td>
-</tr>
-</tabla>
- <h2>Conclusión</h2>
-<p>En conclusión, el quinto examen de beca es una gran oportunidad para los estudiantes que quieren continuar su educación superior con apoyo financiero y excelencia académica. Para prepararse para este examen, es necesario descargar y utilizar el quinto documento de pregunta beca 2016 PDF como un recurso valioso. El artículo anterior te ayudará a entender el formato, el programa y el nivel de dificultad del examen. También le ayudará a aprender algunos consejos y trucos para resolver las preguntas y practicar algunas preguntas de muestra y respuestas del documento. </p>
-
- <h2>Preguntas frecuentes</h2>
-<h3>¿Cuáles son los criterios de elegibilidad para el quinto examen de beca? </h3>
-<p>Los criterios de elegibilidad para el quinto examen de beca pueden variar dependiendo de la autoridad que lo lleve a cabo en su región. Sin embargo, generalmente necesitas ser un estudiante que esté en su último año de primaria (grado 5 o equivalente). También necesitas tener un buen expediente académico y alcanzar las calificaciones mínimas requeridas por la autoridad. </p>
-<h3>¿Cuál es el formato y la duración del quinto examen de beca? </h3>
-<p>El formato y la duración del quinto examen de beca también puede variar dependiendo de la autoridad que lo realice en su región. Sin embargo, generalmente, el examen consiste en preguntas de opción múltiple (MCQs) que cubren varias materias como Matemáticas, Ciencias, Estudios Sociales, Inglés y Conocimientos Generales. El examen puede tener uno o dos documentos dependiendo del medio y la autoridad. La duración del examen puede variar de 1 a 2 horas dependiendo del número y tipo de preguntas. </p>
-<h3>¿Cuáles son las recompensas y el reconocimiento para el quinto examen de beca? </h3>
-<p>Las recompensas y el reconocimiento para el quinto examen de beca también pueden variar dependiendo de la autoridad que lo lleva a cabo en su región. Sin embargo, generalmente, los estudiantes que califican el examen reciben becas que cubren sus cuotas de matrícula, libros y otros gastos para su educación superior. También reciben certificados, medallas y trofeos que reconocen sus logros académicos y méritos. También se les da preferencia y admisión en escuelas y universidades de renombre que ofrecen educación e instalaciones de calidad. </p>
-<h3>¿Cómo solicitar el quinto examen de beca? </h3>
-
-<h3>¿Dónde encontrar más recursos y orientación para el quinto examen de beca? </h3>
-<p>Si quieres encontrar más recursos y orientación para el quinto examen de beca, puedes visitar algunos de estos sitios web que proporcionan información útil, consejos, materiales de estudio, pruebas simuladas y entrenamiento en línea para el examen:</p>
-<ul>
-<li>[Examen Nacional de Becas]: Este es un sitio web que proporciona entrenamiento en línea, pruebas simuladas, materiales de estudio y orientación para el Examen Nacional de Becas (NSE) realizado por NICE en India.</li>
-<li>[Examen de becas]: Este es un sitio web que proporciona información, plan de estudios, trabajos anteriores, documentos modelo y resultados para el examen de becas realizado por el Departamento de Exámenes en Sri Lanka.</li>
-<li>[Guía de becas]: Este es un sitio web que proporciona información, consejos, consejos y recursos para diversos exámenes de becas realizadas en la India y en el extranjero. </li>
-</ul></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/distlib/util.py

@@ -1,1932 +0,0 @@
-#
-# Copyright (C) 2012-2021 The Python Software Foundation.
-# See LICENSE.txt and CONTRIBUTORS.txt.
-#
-import codecs
-from collections import deque
-import contextlib
-import csv
-from glob import iglob as std_iglob
-import io
-import json
-import logging
-import os
-import py_compile
-import re
-import socket
-try:
-    import ssl
-except ImportError:  # pragma: no cover
-    ssl = None
-import subprocess
-import sys
-import tarfile
-import tempfile
-import textwrap
-
-try:
-    import threading
-except ImportError:  # pragma: no cover
-    import dummy_threading as threading
-import time
-
-from . import DistlibException
-from .compat import (string_types, text_type, shutil, raw_input, StringIO,
-                     cache_from_source, urlopen, urljoin, httplib, xmlrpclib,
-                     splittype, HTTPHandler, BaseConfigurator, valid_ident,
-                     Container, configparser, URLError, ZipFile, fsdecode,
-                     unquote, urlparse)
-
-logger = logging.getLogger(__name__)
-
-#
-# Requirement parsing code as per PEP 508
-#
-
-IDENTIFIER = re.compile(r'^([\w\.-]+)\s*')
-VERSION_IDENTIFIER = re.compile(r'^([\w\.*+-]+)\s*')
-COMPARE_OP = re.compile(r'^(<=?|>=?|={2,3}|[~!]=)\s*')
-MARKER_OP = re.compile(r'^((<=?)|(>=?)|={2,3}|[~!]=|in|not\s+in)\s*')
-OR = re.compile(r'^or\b\s*')
-AND = re.compile(r'^and\b\s*')
-NON_SPACE = re.compile(r'(\S+)\s*')
-STRING_CHUNK = re.compile(r'([\s\w\.{}()*+#:;,/?!~`@$%^&=|<>\[\]-]+)')
-
-
-def parse_marker(marker_string):
-    """
-    Parse a marker string and return a dictionary containing a marker expression.
-
-    The dictionary will contain keys "op", "lhs" and "rhs" for non-terminals in
-    the expression grammar, or strings. A string contained in quotes is to be
-    interpreted as a literal string, and a string not contained in quotes is a
-    variable (such as os_name).
-    """
-    def marker_var(remaining):
-        # either identifier, or literal string
-        m = IDENTIFIER.match(remaining)
-        if m:
-            result = m.groups()[0]
-            remaining = remaining[m.end():]
-        elif not remaining:
-            raise SyntaxError('unexpected end of input')
-        else:
-            q = remaining[0]
-            if q not in '\'"':
-                raise SyntaxError('invalid expression: %s' % remaining)
-            oq = '\'"'.replace(q, '')
-            remaining = remaining[1:]
-            parts = [q]
-            while remaining:
-                # either a string chunk, or oq, or q to terminate
-                if remaining[0] == q:
-                    break
-                elif remaining[0] == oq:
-                    parts.append(oq)
-                    remaining = remaining[1:]
-                else:
-                    m = STRING_CHUNK.match(remaining)
-                    if not m:
-                        raise SyntaxError('error in string literal: %s' % remaining)
-                    parts.append(m.groups()[0])
-                    remaining = remaining[m.end():]
-            else:
-                s = ''.join(parts)
-                raise SyntaxError('unterminated string: %s' % s)
-            parts.append(q)
-            result = ''.join(parts)
-            remaining = remaining[1:].lstrip() # skip past closing quote
-        return result, remaining
-
-    def marker_expr(remaining):
-        if remaining and remaining[0] == '(':
-            result, remaining = marker(remaining[1:].lstrip())
-            if remaining[0] != ')':
-                raise SyntaxError('unterminated parenthesis: %s' % remaining)
-            remaining = remaining[1:].lstrip()
-        else:
-            lhs, remaining = marker_var(remaining)
-            while remaining:
-                m = MARKER_OP.match(remaining)
-                if not m:
-                    break
-                op = m.groups()[0]
-                remaining = remaining[m.end():]
-                rhs, remaining = marker_var(remaining)
-                lhs = {'op': op, 'lhs': lhs, 'rhs': rhs}
-            result = lhs
-        return result, remaining
-
-    def marker_and(remaining):
-        lhs, remaining = marker_expr(remaining)
-        while remaining:
-            m = AND.match(remaining)
-            if not m:
-                break
-            remaining = remaining[m.end():]
-            rhs, remaining = marker_expr(remaining)
-            lhs = {'op': 'and', 'lhs': lhs, 'rhs': rhs}
-        return lhs, remaining
-
-    def marker(remaining):
-        lhs, remaining = marker_and(remaining)
-        while remaining:
-            m = OR.match(remaining)
-            if not m:
-                break
-            remaining = remaining[m.end():]
-            rhs, remaining = marker_and(remaining)
-            lhs = {'op': 'or', 'lhs': lhs, 'rhs': rhs}
-        return lhs, remaining
-
-    return marker(marker_string)
-
-
-def parse_requirement(req):
-    """
-    Parse a requirement passed in as a string. Return a Container
-    whose attributes contain the various parts of the requirement.
-    """
-    remaining = req.strip()
-    if not remaining or remaining.startswith('#'):
-        return None
-    m = IDENTIFIER.match(remaining)
-    if not m:
-        raise SyntaxError('name expected: %s' % remaining)
-    distname = m.groups()[0]
-    remaining = remaining[m.end():]
-    extras = mark_expr = versions = uri = None
-    if remaining and remaining[0] == '[':
-        i = remaining.find(']', 1)
-        if i < 0:
-            raise SyntaxError('unterminated extra: %s' % remaining)
-        s = remaining[1:i]
-        remaining = remaining[i + 1:].lstrip()
-        extras = []
-        while s:
-            m = IDENTIFIER.match(s)
-            if not m:
-                raise SyntaxError('malformed extra: %s' % s)
-            extras.append(m.groups()[0])
-            s = s[m.end():]
-            if not s:
-                break
-            if s[0] != ',':
-                raise SyntaxError('comma expected in extras: %s' % s)
-            s = s[1:].lstrip()
-        if not extras:
-            extras = None
-    if remaining:
-        if remaining[0] == '@':
-            # it's a URI
-            remaining = remaining[1:].lstrip()
-            m = NON_SPACE.match(remaining)
-            if not m:
-                raise SyntaxError('invalid URI: %s' % remaining)
-            uri = m.groups()[0]
-            t = urlparse(uri)
-            # there are issues with Python and URL parsing, so this test
-            # is a bit crude. See bpo-20271, bpo-23505. Python doesn't
-            # always parse invalid URLs correctly - it should raise
-            # exceptions for malformed URLs
-            if not (t.scheme and t.netloc):
-                raise SyntaxError('Invalid URL: %s' % uri)
-            remaining = remaining[m.end():].lstrip()
-        else:
-
-            def get_versions(ver_remaining):
-                """
-                Return a list of operator, version tuples if any are
-                specified, else None.
-                """
-                m = COMPARE_OP.match(ver_remaining)
-                versions = None
-                if m:
-                    versions = []
-                    while True:
-                        op = m.groups()[0]
-                        ver_remaining = ver_remaining[m.end():]
-                        m = VERSION_IDENTIFIER.match(ver_remaining)
-                        if not m:
-                            raise SyntaxError('invalid version: %s' % ver_remaining)
-                        v = m.groups()[0]
-                        versions.append((op, v))
-                        ver_remaining = ver_remaining[m.end():]
-                        if not ver_remaining or ver_remaining[0] != ',':
-                            break
-                        ver_remaining = ver_remaining[1:].lstrip()
-                        # Some packages have a trailing comma which would break things
-                        # See issue #148
-                        if not ver_remaining:
-                            break
-                        m = COMPARE_OP.match(ver_remaining)
-                        if not m:
-                            raise SyntaxError('invalid constraint: %s' % ver_remaining)
-                    if not versions:
-                        versions = None
-                return versions, ver_remaining
-
-            if remaining[0] != '(':
-                versions, remaining = get_versions(remaining)
-            else:
-                i = remaining.find(')', 1)
-                if i < 0:
-                    raise SyntaxError('unterminated parenthesis: %s' % remaining)
-                s = remaining[1:i]
-                remaining = remaining[i + 1:].lstrip()
-                # As a special diversion from PEP 508, allow a version number
-                # a.b.c in parentheses as a synonym for ~= a.b.c (because this
-                # is allowed in earlier PEPs)
-                if COMPARE_OP.match(s):
-                    versions, _ = get_versions(s)
-                else:
-                    m = VERSION_IDENTIFIER.match(s)
-                    if not m:
-                        raise SyntaxError('invalid constraint: %s' % s)
-                    v = m.groups()[0]
-                    s = s[m.end():].lstrip()
-                    if s:
-                        raise SyntaxError('invalid constraint: %s' % s)
-                    versions = [('~=', v)]
-
-    if remaining:
-        if remaining[0] != ';':
-            raise SyntaxError('invalid requirement: %s' % remaining)
-        remaining = remaining[1:].lstrip()
-
-        mark_expr, remaining = parse_marker(remaining)
-
-    if remaining and remaining[0] != '#':
-        raise SyntaxError('unexpected trailing data: %s' % remaining)
-
-    if not versions:
-        rs = distname
-    else:
-        rs = '%s %s' % (distname, ', '.join(['%s %s' % con for con in versions]))
-    return Container(name=distname, extras=extras, constraints=versions,
-                     marker=mark_expr, url=uri, requirement=rs)
-
-
-def get_resources_dests(resources_root, rules):
-    """Find destinations for resources files"""
-
-    def get_rel_path(root, path):
-        # normalizes and returns a lstripped-/-separated path
-        root = root.replace(os.path.sep, '/')
-        path = path.replace(os.path.sep, '/')
-        assert path.startswith(root)
-        return path[len(root):].lstrip('/')
-
-    destinations = {}
-    for base, suffix, dest in rules:
-        prefix = os.path.join(resources_root, base)
-        for abs_base in iglob(prefix):
-            abs_glob = os.path.join(abs_base, suffix)
-            for abs_path in iglob(abs_glob):
-                resource_file = get_rel_path(resources_root, abs_path)
-                if dest is None:  # remove the entry if it was here
-                    destinations.pop(resource_file, None)
-                else:
-                    rel_path = get_rel_path(abs_base, abs_path)
-                    rel_dest = dest.replace(os.path.sep, '/').rstrip('/')
-                    destinations[resource_file] = rel_dest + '/' + rel_path
-    return destinations
-
-
-def in_venv():
-    if hasattr(sys, 'real_prefix'):
-        # virtualenv venvs
-        result = True
-    else:
-        # PEP 405 venvs
-        result = sys.prefix != getattr(sys, 'base_prefix', sys.prefix)
-    return result
-
-
-def get_executable():
-# The __PYVENV_LAUNCHER__ dance is apparently no longer needed, as
-# changes to the stub launcher mean that sys.executable always points
-# to the stub on OS X
-#    if sys.platform == 'darwin' and ('__PYVENV_LAUNCHER__'
-#                                     in os.environ):
-#        result =  os.environ['__PYVENV_LAUNCHER__']
-#    else:
-#        result = sys.executable
-#    return result
-    # Avoid normcasing: see issue #143
-    # result = os.path.normcase(sys.executable)
-    result = sys.executable
-    if not isinstance(result, text_type):
-        result = fsdecode(result)
-    return result
-
-
-def proceed(prompt, allowed_chars, error_prompt=None, default=None):
-    p = prompt
-    while True:
-        s = raw_input(p)
-        p = prompt
-        if not s and default:
-            s = default
-        if s:
-            c = s[0].lower()
-            if c in allowed_chars:
-                break
-            if error_prompt:
-                p = '%c: %s\n%s' % (c, error_prompt, prompt)
-    return c
-
-
-def extract_by_key(d, keys):
-    if isinstance(keys, string_types):
-        keys = keys.split()
-    result = {}
-    for key in keys:
-        if key in d:
-            result[key] = d[key]
-    return result
-
-def read_exports(stream):
-    if sys.version_info[0] >= 3:
-        # needs to be a text stream
-        stream = codecs.getreader('utf-8')(stream)
-    # Try to load as JSON, falling back on legacy format
-    data = stream.read()
-    stream = StringIO(data)
-    try:
-        jdata = json.load(stream)
-        result = jdata['extensions']['python.exports']['exports']
-        for group, entries in result.items():
-            for k, v in entries.items():
-                s = '%s = %s' % (k, v)
-                entry = get_export_entry(s)
-                assert entry is not None
-                entries[k] = entry
-        return result
-    except Exception:
-        stream.seek(0, 0)
-
-    def read_stream(cp, stream):
-        if hasattr(cp, 'read_file'):
-            cp.read_file(stream)
-        else:
-            cp.readfp(stream)
-
-    cp = configparser.ConfigParser()
-    try:
-        read_stream(cp, stream)
-    except configparser.MissingSectionHeaderError:
-        stream.close()
-        data = textwrap.dedent(data)
-        stream = StringIO(data)
-        read_stream(cp, stream)
-
-    result = {}
-    for key in cp.sections():
-        result[key] = entries = {}
-        for name, value in cp.items(key):
-            s = '%s = %s' % (name, value)
-            entry = get_export_entry(s)
-            assert entry is not None
-            #entry.dist = self
-            entries[name] = entry
-    return result
-
-
-def write_exports(exports, stream):
-    if sys.version_info[0] >= 3:
-        # needs to be a text stream
-        stream = codecs.getwriter('utf-8')(stream)
-    cp = configparser.ConfigParser()
-    for k, v in exports.items():
-        # TODO check k, v for valid values
-        cp.add_section(k)
-        for entry in v.values():
-            if entry.suffix is None:
-                s = entry.prefix
-            else:
-                s = '%s:%s' % (entry.prefix, entry.suffix)
-            if entry.flags:
-                s = '%s [%s]' % (s, ', '.join(entry.flags))
-            cp.set(k, entry.name, s)
-    cp.write(stream)
-
-
-@contextlib.contextmanager
-def tempdir():
-    td = tempfile.mkdtemp()
-    try:
-        yield td
-    finally:
-        shutil.rmtree(td)
-
-@contextlib.contextmanager
-def chdir(d):
-    cwd = os.getcwd()
-    try:
-        os.chdir(d)
-        yield
-    finally:
-        os.chdir(cwd)
-
-
-@contextlib.contextmanager
-def socket_timeout(seconds=15):
-    cto = socket.getdefaulttimeout()
-    try:
-        socket.setdefaulttimeout(seconds)
-        yield
-    finally:
-        socket.setdefaulttimeout(cto)
-
-
-class cached_property(object):
-    def __init__(self, func):
-        self.func = func
-        #for attr in ('__name__', '__module__', '__doc__'):
-        #    setattr(self, attr, getattr(func, attr, None))
-
-    def __get__(self, obj, cls=None):
-        if obj is None:
-            return self
-        value = self.func(obj)
-        object.__setattr__(obj, self.func.__name__, value)
-        #obj.__dict__[self.func.__name__] = value = self.func(obj)
-        return value
-
-def convert_path(pathname):
-    """Return 'pathname' as a name that will work on the native filesystem.
-
-    The path is split on '/' and put back together again using the current
-    directory separator.  Needed because filenames in the setup script are
-    always supplied in Unix style, and have to be converted to the local
-    convention before we can actually use them in the filesystem.  Raises
-    ValueError on non-Unix-ish systems if 'pathname' either starts or
-    ends with a slash.
-    """
-    if os.sep == '/':
-        return pathname
-    if not pathname:
-        return pathname
-    if pathname[0] == '/':
-        raise ValueError("path '%s' cannot be absolute" % pathname)
-    if pathname[-1] == '/':
-        raise ValueError("path '%s' cannot end with '/'" % pathname)
-
-    paths = pathname.split('/')
-    while os.curdir in paths:
-        paths.remove(os.curdir)
-    if not paths:
-        return os.curdir
-    return os.path.join(*paths)
-
-
-class FileOperator(object):
-    def __init__(self, dry_run=False):
-        self.dry_run = dry_run
-        self.ensured = set()
-        self._init_record()
-
-    def _init_record(self):
-        self.record = False
-        self.files_written = set()
-        self.dirs_created = set()
-
-    def record_as_written(self, path):
-        if self.record:
-            self.files_written.add(path)
-
-    def newer(self, source, target):
-        """Tell if the target is newer than the source.
-
-        Returns true if 'source' exists and is more recently modified than
-        'target', or if 'source' exists and 'target' doesn't.
-
-        Returns false if both exist and 'target' is the same age or younger
-        than 'source'. Raise PackagingFileError if 'source' does not exist.
-
-        Note that this test is not very accurate: files created in the same
-        second will have the same "age".
-        """
-        if not os.path.exists(source):
-            raise DistlibException("file '%r' does not exist" %
-                                   os.path.abspath(source))
-        if not os.path.exists(target):
-            return True
-
-        return os.stat(source).st_mtime > os.stat(target).st_mtime
-
-    def copy_file(self, infile, outfile, check=True):
-        """Copy a file respecting dry-run and force flags.
-        """
-        self.ensure_dir(os.path.dirname(outfile))
-        logger.info('Copying %s to %s', infile, outfile)
-        if not self.dry_run:
-            msg = None
-            if check:
-                if os.path.islink(outfile):
-                    msg = '%s is a symlink' % outfile
-                elif os.path.exists(outfile) and not os.path.isfile(outfile):
-                    msg = '%s is a non-regular file' % outfile
-            if msg:
-                raise ValueError(msg + ' which would be overwritten')
-            shutil.copyfile(infile, outfile)
-        self.record_as_written(outfile)
-
-    def copy_stream(self, instream, outfile, encoding=None):
-        assert not os.path.isdir(outfile)
-        self.ensure_dir(os.path.dirname(outfile))
-        logger.info('Copying stream %s to %s', instream, outfile)
-        if not self.dry_run:
-            if encoding is None:
-                outstream = open(outfile, 'wb')
-            else:
-                outstream = codecs.open(outfile, 'w', encoding=encoding)
-            try:
-                shutil.copyfileobj(instream, outstream)
-            finally:
-                outstream.close()
-        self.record_as_written(outfile)
-
-    def write_binary_file(self, path, data):
-        self.ensure_dir(os.path.dirname(path))
-        if not self.dry_run:
-            if os.path.exists(path):
-                os.remove(path)
-            with open(path, 'wb') as f:
-                f.write(data)
-        self.record_as_written(path)
-
-    def write_text_file(self, path, data, encoding):
-        self.write_binary_file(path, data.encode(encoding))
-
-    def set_mode(self, bits, mask, files):
-        if os.name == 'posix' or (os.name == 'java' and os._name == 'posix'):
-            # Set the executable bits (owner, group, and world) on
-            # all the files specified.
-            for f in files:
-                if self.dry_run:
-                    logger.info("changing mode of %s", f)
-                else:
-                    mode = (os.stat(f).st_mode | bits) & mask
-                    logger.info("changing mode of %s to %o", f, mode)
-                    os.chmod(f, mode)
-
-    set_executable_mode = lambda s, f: s.set_mode(0o555, 0o7777, f)
-
-    def ensure_dir(self, path):
-        path = os.path.abspath(path)
-        if path not in self.ensured and not os.path.exists(path):
-            self.ensured.add(path)
-            d, f = os.path.split(path)
-            self.ensure_dir(d)
-            logger.info('Creating %s' % path)
-            if not self.dry_run:
-                os.mkdir(path)
-            if self.record:
-                self.dirs_created.add(path)
-
-    def byte_compile(self, path, optimize=False, force=False, prefix=None, hashed_invalidation=False):
-        dpath = cache_from_source(path, not optimize)
-        logger.info('Byte-compiling %s to %s', path, dpath)
-        if not self.dry_run:
-            if force or self.newer(path, dpath):
-                if not prefix:
-                    diagpath = None
-                else:
-                    assert path.startswith(prefix)
-                    diagpath = path[len(prefix):]
-            compile_kwargs = {}
-            if hashed_invalidation and hasattr(py_compile, 'PycInvalidationMode'):
-                compile_kwargs['invalidation_mode'] = py_compile.PycInvalidationMode.CHECKED_HASH
-            py_compile.compile(path, dpath, diagpath, True, **compile_kwargs)     # raise error
-        self.record_as_written(dpath)
-        return dpath
-
-    def ensure_removed(self, path):
-        if os.path.exists(path):
-            if os.path.isdir(path) and not os.path.islink(path):
-                logger.debug('Removing directory tree at %s', path)
-                if not self.dry_run:
-                    shutil.rmtree(path)
-                if self.record:
-                    if path in self.dirs_created:
-                        self.dirs_created.remove(path)
-            else:
-                if os.path.islink(path):
-                    s = 'link'
-                else:
-                    s = 'file'
-                logger.debug('Removing %s %s', s, path)
-                if not self.dry_run:
-                    os.remove(path)
-                if self.record:
-                    if path in self.files_written:
-                        self.files_written.remove(path)
-
-    def is_writable(self, path):
-        result = False
-        while not result:
-            if os.path.exists(path):
-                result = os.access(path, os.W_OK)
-                break
-            parent = os.path.dirname(path)
-            if parent == path:
-                break
-            path = parent
-        return result
-
-    def commit(self):
-        """
-        Commit recorded changes, turn off recording, return
-        changes.
-        """
-        assert self.record
-        result = self.files_written, self.dirs_created
-        self._init_record()
-        return result
-
-    def rollback(self):
-        if not self.dry_run:
-            for f in list(self.files_written):
-                if os.path.exists(f):
-                    os.remove(f)
-            # dirs should all be empty now, except perhaps for
-            # __pycache__ subdirs
-            # reverse so that subdirs appear before their parents
-            dirs = sorted(self.dirs_created, reverse=True)
-            for d in dirs:
-                flist = os.listdir(d)
-                if flist:
-                    assert flist == ['__pycache__']
-                    sd = os.path.join(d, flist[0])
-                    os.rmdir(sd)
-                os.rmdir(d)     # should fail if non-empty
-        self._init_record()
-
-def resolve(module_name, dotted_path):
-    if module_name in sys.modules:
-        mod = sys.modules[module_name]
-    else:
-        mod = __import__(module_name)
-    if dotted_path is None:
-        result = mod
-    else:
-        parts = dotted_path.split('.')
-        result = getattr(mod, parts.pop(0))
-        for p in parts:
-            result = getattr(result, p)
-    return result
-
-
-class ExportEntry(object):
-    def __init__(self, name, prefix, suffix, flags):
-        self.name = name
-        self.prefix = prefix
-        self.suffix = suffix
-        self.flags = flags
-
-    @cached_property
-    def value(self):
-        return resolve(self.prefix, self.suffix)
-
-    def __repr__(self):  # pragma: no cover
-        return '<ExportEntry %s = %s:%s %s>' % (self.name, self.prefix,
-                                                self.suffix, self.flags)
-
-    def __eq__(self, other):
-        if not isinstance(other, ExportEntry):
-            result = False
-        else:
-            result = (self.name == other.name and
-                      self.prefix == other.prefix and
-                      self.suffix == other.suffix and
-                      self.flags == other.flags)
-        return result
-
-    __hash__ = object.__hash__
-
-
-ENTRY_RE = re.compile(r'''(?P<name>(\w|[-.+])+)
-                      \s*=\s*(?P<callable>(\w+)([:\.]\w+)*)
-                      \s*(\[\s*(?P<flags>[\w-]+(=\w+)?(,\s*\w+(=\w+)?)*)\s*\])?
-                      ''', re.VERBOSE)
-
-def get_export_entry(specification):
-    m = ENTRY_RE.search(specification)
-    if not m:
-        result = None
-        if '[' in specification or ']' in specification:
-            raise DistlibException("Invalid specification "
-                                   "'%s'" % specification)
-    else:
-        d = m.groupdict()
-        name = d['name']
-        path = d['callable']
-        colons = path.count(':')
-        if colons == 0:
-            prefix, suffix = path, None
-        else:
-            if colons != 1:
-                raise DistlibException("Invalid specification "
-                                       "'%s'" % specification)
-            prefix, suffix = path.split(':')
-        flags = d['flags']
-        if flags is None:
-            if '[' in specification or ']' in specification:
-                raise DistlibException("Invalid specification "
-                                       "'%s'" % specification)
-            flags = []
-        else:
-            flags = [f.strip() for f in flags.split(',')]
-        result = ExportEntry(name, prefix, suffix, flags)
-    return result
-
-
-def get_cache_base(suffix=None):
-    """
-    Return the default base location for distlib caches. If the directory does
-    not exist, it is created. Use the suffix provided for the base directory,
-    and default to '.distlib' if it isn't provided.
-
-    On Windows, if LOCALAPPDATA is defined in the environment, then it is
-    assumed to be a directory, and will be the parent directory of the result.
-    On POSIX, and on Windows if LOCALAPPDATA is not defined, the user's home
-    directory - using os.expanduser('~') - will be the parent directory of
-    the result.
-
-    The result is just the directory '.distlib' in the parent directory as
-    determined above, or with the name specified with ``suffix``.
-    """
-    if suffix is None:
-        suffix = '.distlib'
-    if os.name == 'nt' and 'LOCALAPPDATA' in os.environ:
-        result = os.path.expandvars('$localappdata')
-    else:
-        # Assume posix, or old Windows
-        result = os.path.expanduser('~')
-    # we use 'isdir' instead of 'exists', because we want to
-    # fail if there's a file with that name
-    if os.path.isdir(result):
-        usable = os.access(result, os.W_OK)
-        if not usable:
-            logger.warning('Directory exists but is not writable: %s', result)
-    else:
-        try:
-            os.makedirs(result)
-            usable = True
-        except OSError:
-            logger.warning('Unable to create %s', result, exc_info=True)
-            usable = False
-    if not usable:
-        result = tempfile.mkdtemp()
-        logger.warning('Default location unusable, using %s', result)
-    return os.path.join(result, suffix)
-
-
-def path_to_cache_dir(path):
-    """
-    Convert an absolute path to a directory name for use in a cache.
-
-    The algorithm used is:
-
-    #. On Windows, any ``':'`` in the drive is replaced with ``'---'``.
-    #. Any occurrence of ``os.sep`` is replaced with ``'--'``.
-    #. ``'.cache'`` is appended.
-    """
-    d, p = os.path.splitdrive(os.path.abspath(path))
-    if d:
-        d = d.replace(':', '---')
-    p = p.replace(os.sep, '--')
-    return d + p + '.cache'
-
-
-def ensure_slash(s):
-    if not s.endswith('/'):
-        return s + '/'
-    return s
-
-
-def parse_credentials(netloc):
-    username = password = None
-    if '@' in netloc:
-        prefix, netloc = netloc.rsplit('@', 1)
-        if ':' not in prefix:
-            username = prefix
-        else:
-            username, password = prefix.split(':', 1)
-    if username:
-        username = unquote(username)
-    if password:
-        password = unquote(password)
-    return username, password, netloc
-
-
-def get_process_umask():
-    result = os.umask(0o22)
-    os.umask(result)
-    return result
-
-def is_string_sequence(seq):
-    result = True
-    i = None
-    for i, s in enumerate(seq):
-        if not isinstance(s, string_types):
-            result = False
-            break
-    assert i is not None
-    return result
-
-PROJECT_NAME_AND_VERSION = re.compile('([a-z0-9_]+([.-][a-z_][a-z0-9_]*)*)-'
-                                      '([a-z0-9_.+-]+)', re.I)
-PYTHON_VERSION = re.compile(r'-py(\d\.?\d?)')
-
-
-def split_filename(filename, project_name=None):
-    """
-    Extract name, version, python version from a filename (no extension)
-
-    Return name, version, pyver or None
-    """
-    result = None
-    pyver = None
-    filename = unquote(filename).replace(' ', '-')
-    m = PYTHON_VERSION.search(filename)
-    if m:
-        pyver = m.group(1)
-        filename = filename[:m.start()]
-    if project_name and len(filename) > len(project_name) + 1:
-        m = re.match(re.escape(project_name) + r'\b', filename)
-        if m:
-            n = m.end()
-            result = filename[:n], filename[n + 1:], pyver
-    if result is None:
-        m = PROJECT_NAME_AND_VERSION.match(filename)
-        if m:
-            result = m.group(1), m.group(3), pyver
-    return result
-
-# Allow spaces in name because of legacy dists like "Twisted Core"
-NAME_VERSION_RE = re.compile(r'(?P<name>[\w .-]+)\s*'
-                             r'\(\s*(?P<ver>[^\s)]+)\)$')
-
-def parse_name_and_version(p):
-    """
-    A utility method used to get name and version from a string.
-
-    From e.g. a Provides-Dist value.
-
-    :param p: A value in a form 'foo (1.0)'
-    :return: The name and version as a tuple.
-    """
-    m = NAME_VERSION_RE.match(p)
-    if not m:
-        raise DistlibException('Ill-formed name/version string: \'%s\'' % p)
-    d = m.groupdict()
-    return d['name'].strip().lower(), d['ver']
-
-def get_extras(requested, available):
-    result = set()
-    requested = set(requested or [])
-    available = set(available or [])
-    if '*' in requested:
-        requested.remove('*')
-        result |= available
-    for r in requested:
-        if r == '-':
-            result.add(r)
-        elif r.startswith('-'):
-            unwanted = r[1:]
-            if unwanted not in available:
-                logger.warning('undeclared extra: %s' % unwanted)
-            if unwanted in result:
-                result.remove(unwanted)
-        else:
-            if r not in available:
-                logger.warning('undeclared extra: %s' % r)
-            result.add(r)
-    return result
-#
-# Extended metadata functionality
-#
-
-def _get_external_data(url):
-    result = {}
-    try:
-        # urlopen might fail if it runs into redirections,
-        # because of Python issue #13696. Fixed in locators
-        # using a custom redirect handler.
-        resp = urlopen(url)
-        headers = resp.info()
-        ct = headers.get('Content-Type')
-        if not ct.startswith('application/json'):
-            logger.debug('Unexpected response for JSON request: %s', ct)
-        else:
-            reader = codecs.getreader('utf-8')(resp)
-            #data = reader.read().decode('utf-8')
-            #result = json.loads(data)
-            result = json.load(reader)
-    except Exception as e:
-        logger.exception('Failed to get external data for %s: %s', url, e)
-    return result
-
-_external_data_base_url = 'https://www.red-dove.com/pypi/projects/'
-
-def get_project_data(name):
-    url = '%s/%s/project.json' % (name[0].upper(), name)
-    url = urljoin(_external_data_base_url, url)
-    result = _get_external_data(url)
-    return result
-
-def get_package_data(name, version):
-    url = '%s/%s/package-%s.json' % (name[0].upper(), name, version)
-    url = urljoin(_external_data_base_url, url)
-    return _get_external_data(url)
-
-
-class Cache(object):
-    """
-    A class implementing a cache for resources that need to live in the file system
-    e.g. shared libraries. This class was moved from resources to here because it
-    could be used by other modules, e.g. the wheel module.
-    """
-
-    def __init__(self, base):
-        """
-        Initialise an instance.
-
-        :param base: The base directory where the cache should be located.
-        """
-        # we use 'isdir' instead of 'exists', because we want to
-        # fail if there's a file with that name
-        if not os.path.isdir(base):  # pragma: no cover
-            os.makedirs(base)
-        if (os.stat(base).st_mode & 0o77) != 0:
-            logger.warning('Directory \'%s\' is not private', base)
-        self.base = os.path.abspath(os.path.normpath(base))
-
-    def prefix_to_dir(self, prefix):
-        """
-        Converts a resource prefix to a directory name in the cache.
-        """
-        return path_to_cache_dir(prefix)
-
-    def clear(self):
-        """
-        Clear the cache.
-        """
-        not_removed = []
-        for fn in os.listdir(self.base):
-            fn = os.path.join(self.base, fn)
-            try:
-                if os.path.islink(fn) or os.path.isfile(fn):
-                    os.remove(fn)
-                elif os.path.isdir(fn):
-                    shutil.rmtree(fn)
-            except Exception:
-                not_removed.append(fn)
-        return not_removed
-
-
-class EventMixin(object):
-    """
-    A very simple publish/subscribe system.
-    """
-    def __init__(self):
-        self._subscribers = {}
-
-    def add(self, event, subscriber, append=True):
-        """
-        Add a subscriber for an event.
-
-        :param event: The name of an event.
-        :param subscriber: The subscriber to be added (and called when the
-                           event is published).
-        :param append: Whether to append or prepend the subscriber to an
-                       existing subscriber list for the event.
-        """
-        subs = self._subscribers
-        if event not in subs:
-            subs[event] = deque([subscriber])
-        else:
-            sq = subs[event]
-            if append:
-                sq.append(subscriber)
-            else:
-                sq.appendleft(subscriber)
-
-    def remove(self, event, subscriber):
-        """
-        Remove a subscriber for an event.
-
-        :param event: The name of an event.
-        :param subscriber: The subscriber to be removed.
-        """
-        subs = self._subscribers
-        if event not in subs:
-            raise ValueError('No subscribers: %r' % event)
-        subs[event].remove(subscriber)
-
-    def get_subscribers(self, event):
-        """
-        Return an iterator for the subscribers for an event.
-        :param event: The event to return subscribers for.
-        """
-        return iter(self._subscribers.get(event, ()))
-
-    def publish(self, event, *args, **kwargs):
-        """
-        Publish a event and return a list of values returned by its
-        subscribers.
-
-        :param event: The event to publish.
-        :param args: The positional arguments to pass to the event's
-                     subscribers.
-        :param kwargs: The keyword arguments to pass to the event's
-                       subscribers.
-        """
-        result = []
-        for subscriber in self.get_subscribers(event):
-            try:
-                value = subscriber(event, *args, **kwargs)
-            except Exception:
-                logger.exception('Exception during event publication')
-                value = None
-            result.append(value)
-        logger.debug('publish %s: args = %s, kwargs = %s, result = %s',
-                     event, args, kwargs, result)
-        return result
-
-#
-# Simple sequencing
-#
-class Sequencer(object):
-    def __init__(self):
-        self._preds = {}
-        self._succs = {}
-        self._nodes = set()     # nodes with no preds/succs
-
-    def add_node(self, node):
-        self._nodes.add(node)
-
-    def remove_node(self, node, edges=False):
-        if node in self._nodes:
-            self._nodes.remove(node)
-        if edges:
-            for p in set(self._preds.get(node, ())):
-                self.remove(p, node)
-            for s in set(self._succs.get(node, ())):
-                self.remove(node, s)
-            # Remove empties
-            for k, v in list(self._preds.items()):
-                if not v:
-                    del self._preds[k]
-            for k, v in list(self._succs.items()):
-                if not v:
-                    del self._succs[k]
-
-    def add(self, pred, succ):
-        assert pred != succ
-        self._preds.setdefault(succ, set()).add(pred)
-        self._succs.setdefault(pred, set()).add(succ)
-
-    def remove(self, pred, succ):
-        assert pred != succ
-        try:
-            preds = self._preds[succ]
-            succs = self._succs[pred]
-        except KeyError:  # pragma: no cover
-            raise ValueError('%r not a successor of anything' % succ)
-        try:
-            preds.remove(pred)
-            succs.remove(succ)
-        except KeyError:  # pragma: no cover
-            raise ValueError('%r not a successor of %r' % (succ, pred))
-
-    def is_step(self, step):
-        return (step in self._preds or step in self._succs or
-                step in self._nodes)
-
-    def get_steps(self, final):
-        if not self.is_step(final):
-            raise ValueError('Unknown: %r' % final)
-        result = []
-        todo = []
-        seen = set()
-        todo.append(final)
-        while todo:
-            step = todo.pop(0)
-            if step in seen:
-                # if a step was already seen,
-                # move it to the end (so it will appear earlier
-                # when reversed on return) ... but not for the
-                # final step, as that would be confusing for
-                # users
-                if step != final:
-                    result.remove(step)
-                    result.append(step)
-            else:
-                seen.add(step)
-                result.append(step)
-                preds = self._preds.get(step, ())
-                todo.extend(preds)
-        return reversed(result)
-
-    @property
-    def strong_connections(self):
-        #http://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm
-        index_counter = [0]
-        stack = []
-        lowlinks = {}
-        index = {}
-        result = []
-
-        graph = self._succs
-
-        def strongconnect(node):
-            # set the depth index for this node to the smallest unused index
-            index[node] = index_counter[0]
-            lowlinks[node] = index_counter[0]
-            index_counter[0] += 1
-            stack.append(node)
-
-            # Consider successors
-            try:
-                successors = graph[node]
-            except Exception:
-                successors = []
-            for successor in successors:
-                if successor not in lowlinks:
-                    # Successor has not yet been visited
-                    strongconnect(successor)
-                    lowlinks[node] = min(lowlinks[node],lowlinks[successor])
-                elif successor in stack:
-                    # the successor is in the stack and hence in the current
-                    # strongly connected component (SCC)
-                    lowlinks[node] = min(lowlinks[node],index[successor])
-
-            # If `node` is a root node, pop the stack and generate an SCC
-            if lowlinks[node] == index[node]:
-                connected_component = []
-
-                while True:
-                    successor = stack.pop()
-                    connected_component.append(successor)
-                    if successor == node: break
-                component = tuple(connected_component)
-                # storing the result
-                result.append(component)
-
-        for node in graph:
-            if node not in lowlinks:
-                strongconnect(node)
-
-        return result
-
-    @property
-    def dot(self):
-        result = ['digraph G {']
-        for succ in self._preds:
-            preds = self._preds[succ]
-            for pred in preds:
-                result.append('  %s -> %s;' % (pred, succ))
-        for node in self._nodes:
-            result.append('  %s;' % node)
-        result.append('}')
-        return '\n'.join(result)
-
-#
-# Unarchiving functionality for zip, tar, tgz, tbz, whl
-#
-
-ARCHIVE_EXTENSIONS = ('.tar.gz', '.tar.bz2', '.tar', '.zip',
-                      '.tgz', '.tbz', '.whl')
-
-def unarchive(archive_filename, dest_dir, format=None, check=True):
-
-    def check_path(path):
-        if not isinstance(path, text_type):
-            path = path.decode('utf-8')
-        p = os.path.abspath(os.path.join(dest_dir, path))
-        if not p.startswith(dest_dir) or p[plen] != os.sep:
-            raise ValueError('path outside destination: %r' % p)
-
-    dest_dir = os.path.abspath(dest_dir)
-    plen = len(dest_dir)
-    archive = None
-    if format is None:
-        if archive_filename.endswith(('.zip', '.whl')):
-            format = 'zip'
-        elif archive_filename.endswith(('.tar.gz', '.tgz')):
-            format = 'tgz'
-            mode = 'r:gz'
-        elif archive_filename.endswith(('.tar.bz2', '.tbz')):
-            format = 'tbz'
-            mode = 'r:bz2'
-        elif archive_filename.endswith('.tar'):
-            format = 'tar'
-            mode = 'r'
-        else:  # pragma: no cover
-            raise ValueError('Unknown format for %r' % archive_filename)
-    try:
-        if format == 'zip':
-            archive = ZipFile(archive_filename, 'r')
-            if check:
-                names = archive.namelist()
-                for name in names:
-                    check_path(name)
-        else:
-            archive = tarfile.open(archive_filename, mode)
-            if check:
-                names = archive.getnames()
-                for name in names:
-                    check_path(name)
-        if format != 'zip' and sys.version_info[0] < 3:
-            # See Python issue 17153. If the dest path contains Unicode,
-            # tarfile extraction fails on Python 2.x if a member path name
-            # contains non-ASCII characters - it leads to an implicit
-            # bytes -> unicode conversion using ASCII to decode.
-            for tarinfo in archive.getmembers():
-                if not isinstance(tarinfo.name, text_type):
-                    tarinfo.name = tarinfo.name.decode('utf-8')
-        archive.extractall(dest_dir)
-
-    finally:
-        if archive:
-            archive.close()
-
-
-def zip_dir(directory):
-    """zip a directory tree into a BytesIO object"""
-    result = io.BytesIO()
-    dlen = len(directory)
-    with ZipFile(result, "w") as zf:
-        for root, dirs, files in os.walk(directory):
-            for name in files:
-                full = os.path.join(root, name)
-                rel = root[dlen:]
-                dest = os.path.join(rel, name)
-                zf.write(full, dest)
-    return result
-
-#
-# Simple progress bar
-#
-
-UNITS = ('', 'K', 'M', 'G','T','P')
-
-
-class Progress(object):
-    unknown = 'UNKNOWN'
-
-    def __init__(self, minval=0, maxval=100):
-        assert maxval is None or maxval >= minval
-        self.min = self.cur = minval
-        self.max = maxval
-        self.started = None
-        self.elapsed = 0
-        self.done = False
-
-    def update(self, curval):
-        assert self.min <= curval
-        assert self.max is None or curval <= self.max
-        self.cur = curval
-        now = time.time()
-        if self.started is None:
-            self.started = now
-        else:
-            self.elapsed = now - self.started
-
-    def increment(self, incr):
-        assert incr >= 0
-        self.update(self.cur + incr)
-
-    def start(self):
-        self.update(self.min)
-        return self
-
-    def stop(self):
-        if self.max is not None:
-            self.update(self.max)
-        self.done = True
-
-    @property
-    def maximum(self):
-        return self.unknown if self.max is None else self.max
-
-    @property
-    def percentage(self):
-        if self.done:
-            result = '100 %'
-        elif self.max is None:
-            result = ' ?? %'
-        else:
-            v = 100.0 * (self.cur - self.min) / (self.max - self.min)
-            result = '%3d %%' % v
-        return result
-
-    def format_duration(self, duration):
-        if (duration <= 0) and self.max is None or self.cur == self.min:
-            result = '??:??:??'
-        #elif duration < 1:
-        #    result = '--:--:--'
-        else:
-            result = time.strftime('%H:%M:%S', time.gmtime(duration))
-        return result
-
-    @property
-    def ETA(self):
-        if self.done:
-            prefix = 'Done'
-            t = self.elapsed
-            #import pdb; pdb.set_trace()
-        else:
-            prefix = 'ETA '
-            if self.max is None:
-                t = -1
-            elif self.elapsed == 0 or (self.cur == self.min):
-                t = 0
-            else:
-                #import pdb; pdb.set_trace()
-                t = float(self.max - self.min)
-                t /= self.cur - self.min
-                t = (t - 1) * self.elapsed
-        return '%s: %s' % (prefix, self.format_duration(t))
-
-    @property
-    def speed(self):
-        if self.elapsed == 0:
-            result = 0.0
-        else:
-            result = (self.cur - self.min) / self.elapsed
-        for unit in UNITS:
-            if result < 1000:
-                break
-            result /= 1000.0
-        return '%d %sB/s' % (result, unit)
-
-#
-# Glob functionality
-#
-
-RICH_GLOB = re.compile(r'\{([^}]*)\}')
-_CHECK_RECURSIVE_GLOB = re.compile(r'[^/\\,{]\*\*|\*\*[^/\\,}]')
-_CHECK_MISMATCH_SET = re.compile(r'^[^{]*\}|\{[^}]*$')
-
-
-def iglob(path_glob):
-    """Extended globbing function that supports ** and {opt1,opt2,opt3}."""
-    if _CHECK_RECURSIVE_GLOB.search(path_glob):
-        msg = """invalid glob %r: recursive glob "**" must be used alone"""
-        raise ValueError(msg % path_glob)
-    if _CHECK_MISMATCH_SET.search(path_glob):
-        msg = """invalid glob %r: mismatching set marker '{' or '}'"""
-        raise ValueError(msg % path_glob)
-    return _iglob(path_glob)
-
-
-def _iglob(path_glob):
-    rich_path_glob = RICH_GLOB.split(path_glob, 1)
-    if len(rich_path_glob) > 1:
-        assert len(rich_path_glob) == 3, rich_path_glob
-        prefix, set, suffix = rich_path_glob
-        for item in set.split(','):
-            for path in _iglob(''.join((prefix, item, suffix))):
-                yield path
-    else:
-        if '**' not in path_glob:
-            for item in std_iglob(path_glob):
-                yield item
-        else:
-            prefix, radical = path_glob.split('**', 1)
-            if prefix == '':
-                prefix = '.'
-            if radical == '':
-                radical = '*'
-            else:
-                # we support both
-                radical = radical.lstrip('/')
-                radical = radical.lstrip('\\')
-            for path, dir, files in os.walk(prefix):
-                path = os.path.normpath(path)
-                for fn in _iglob(os.path.join(path, radical)):
-                    yield fn
-
-if ssl:
-    from .compat import (HTTPSHandler as BaseHTTPSHandler, match_hostname,
-                         CertificateError)
-
-
-#
-# HTTPSConnection which verifies certificates/matches domains
-#
-
-    class HTTPSConnection(httplib.HTTPSConnection):
-        ca_certs = None # set this to the path to the certs file (.pem)
-        check_domain = True # only used if ca_certs is not None
-
-        # noinspection PyPropertyAccess
-        def connect(self):
-            sock = socket.create_connection((self.host, self.port), self.timeout)
-            if getattr(self, '_tunnel_host', False):
-                self.sock = sock
-                self._tunnel()
-
-            context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
-            if hasattr(ssl, 'OP_NO_SSLv2'):
-                context.options |= ssl.OP_NO_SSLv2
-            if self.cert_file:
-                context.load_cert_chain(self.cert_file, self.key_file)
-            kwargs = {}
-            if self.ca_certs:
-                context.verify_mode = ssl.CERT_REQUIRED
-                context.load_verify_locations(cafile=self.ca_certs)
-                if getattr(ssl, 'HAS_SNI', False):
-                    kwargs['server_hostname'] = self.host
-
-            self.sock = context.wrap_socket(sock, **kwargs)
-            if self.ca_certs and self.check_domain:
-                try:
-                    match_hostname(self.sock.getpeercert(), self.host)
-                    logger.debug('Host verified: %s', self.host)
-                except CertificateError:  # pragma: no cover
-                    self.sock.shutdown(socket.SHUT_RDWR)
-                    self.sock.close()
-                    raise
-
-    class HTTPSHandler(BaseHTTPSHandler):
-        def __init__(self, ca_certs, check_domain=True):
-            BaseHTTPSHandler.__init__(self)
-            self.ca_certs = ca_certs
-            self.check_domain = check_domain
-
-        def _conn_maker(self, *args, **kwargs):
-            """
-            This is called to create a connection instance. Normally you'd
-            pass a connection class to do_open, but it doesn't actually check for
-            a class, and just expects a callable. As long as we behave just as a
-            constructor would have, we should be OK. If it ever changes so that
-            we *must* pass a class, we'll create an UnsafeHTTPSConnection class
-            which just sets check_domain to False in the class definition, and
-            choose which one to pass to do_open.
-            """
-            result = HTTPSConnection(*args, **kwargs)
-            if self.ca_certs:
-                result.ca_certs = self.ca_certs
-                result.check_domain = self.check_domain
-            return result
-
-        def https_open(self, req):
-            try:
-                return self.do_open(self._conn_maker, req)
-            except URLError as e:
-                if 'certificate verify failed' in str(e.reason):
-                    raise CertificateError('Unable to verify server certificate '
-                                           'for %s' % req.host)
-                else:
-                    raise
-
-    #
-    # To prevent against mixing HTTP traffic with HTTPS (examples: A Man-In-The-
-    # Middle proxy using HTTP listens on port 443, or an index mistakenly serves
-    # HTML containing a http://xyz link when it should be https://xyz),
-    # you can use the following handler class, which does not allow HTTP traffic.
-    #
-    # It works by inheriting from HTTPHandler - so build_opener won't add a
-    # handler for HTTP itself.
-    #
-    class HTTPSOnlyHandler(HTTPSHandler, HTTPHandler):
-        def http_open(self, req):
-            raise URLError('Unexpected HTTP request on what should be a secure '
-                           'connection: %s' % req)
-
-#
-# XML-RPC with timeouts
-#
-class Transport(xmlrpclib.Transport):
-    def __init__(self, timeout, use_datetime=0):
-        self.timeout = timeout
-        xmlrpclib.Transport.__init__(self, use_datetime)
-
-    def make_connection(self, host):
-        h, eh, x509 = self.get_host_info(host)
-        if not self._connection or host != self._connection[0]:
-            self._extra_headers = eh
-            self._connection = host, httplib.HTTPConnection(h)
-        return self._connection[1]
-
-if ssl:
-    class SafeTransport(xmlrpclib.SafeTransport):
-        def __init__(self, timeout, use_datetime=0):
-            self.timeout = timeout
-            xmlrpclib.SafeTransport.__init__(self, use_datetime)
-
-        def make_connection(self, host):
-            h, eh, kwargs = self.get_host_info(host)
-            if not kwargs:
-                kwargs = {}
-            kwargs['timeout'] = self.timeout
-            if not self._connection or host != self._connection[0]:
-                self._extra_headers = eh
-                self._connection = host, httplib.HTTPSConnection(h, None,
-                                                                 **kwargs)
-            return self._connection[1]
-
-
-class ServerProxy(xmlrpclib.ServerProxy):
-    def __init__(self, uri, **kwargs):
-        self.timeout = timeout = kwargs.pop('timeout', None)
-        # The above classes only come into play if a timeout
-        # is specified
-        if timeout is not None:
-            # scheme = splittype(uri)  # deprecated as of Python 3.8
-            scheme = urlparse(uri)[0]
-            use_datetime = kwargs.get('use_datetime', 0)
-            if scheme == 'https':
-                tcls = SafeTransport
-            else:
-                tcls = Transport
-            kwargs['transport'] = t = tcls(timeout, use_datetime=use_datetime)
-            self.transport = t
-        xmlrpclib.ServerProxy.__init__(self, uri, **kwargs)
-
-#
-# CSV functionality. This is provided because on 2.x, the csv module can't
-# handle Unicode. However, we need to deal with Unicode in e.g. RECORD files.
-#
-
-def _csv_open(fn, mode, **kwargs):
-    if sys.version_info[0] < 3:
-        mode += 'b'
-    else:
-        kwargs['newline'] = ''
-        # Python 3 determines encoding from locale. Force 'utf-8'
-        # file encoding to match other forced utf-8 encoding
-        kwargs['encoding'] = 'utf-8'
-    return open(fn, mode, **kwargs)
-
-
-class CSVBase(object):
-    defaults = {
-        'delimiter': str(','),      # The strs are used because we need native
-        'quotechar': str('"'),      # str in the csv API (2.x won't take
-        'lineterminator': str('\n') # Unicode)
-    }
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, *exc_info):
-        self.stream.close()
-
-
-class CSVReader(CSVBase):
-    def __init__(self, **kwargs):
-        if 'stream' in kwargs:
-            stream = kwargs['stream']
-            if sys.version_info[0] >= 3:
-                # needs to be a text stream
-                stream = codecs.getreader('utf-8')(stream)
-            self.stream = stream
-        else:
-            self.stream = _csv_open(kwargs['path'], 'r')
-        self.reader = csv.reader(self.stream, **self.defaults)
-
-    def __iter__(self):
-        return self
-
-    def next(self):
-        result = next(self.reader)
-        if sys.version_info[0] < 3:
-            for i, item in enumerate(result):
-                if not isinstance(item, text_type):
-                    result[i] = item.decode('utf-8')
-        return result
-
-    __next__ = next
-
-class CSVWriter(CSVBase):
-    def __init__(self, fn, **kwargs):
-        self.stream = _csv_open(fn, 'w')
-        self.writer = csv.writer(self.stream, **self.defaults)
-
-    def writerow(self, row):
-        if sys.version_info[0] < 3:
-            r = []
-            for item in row:
-                if isinstance(item, text_type):
-                    item = item.encode('utf-8')
-                r.append(item)
-            row = r
-        self.writer.writerow(row)
-
-#
-#   Configurator functionality
-#
-
-class Configurator(BaseConfigurator):
-
-    value_converters = dict(BaseConfigurator.value_converters)
-    value_converters['inc'] = 'inc_convert'
-
-    def __init__(self, config, base=None):
-        super(Configurator, self).__init__(config)
-        self.base = base or os.getcwd()
-
-    def configure_custom(self, config):
-        def convert(o):
-            if isinstance(o, (list, tuple)):
-                result = type(o)([convert(i) for i in o])
-            elif isinstance(o, dict):
-                if '()' in o:
-                    result = self.configure_custom(o)
-                else:
-                    result = {}
-                    for k in o:
-                        result[k] = convert(o[k])
-            else:
-                result = self.convert(o)
-            return result
-
-        c = config.pop('()')
-        if not callable(c):
-            c = self.resolve(c)
-        props = config.pop('.', None)
-        # Check for valid identifiers
-        args = config.pop('[]', ())
-        if args:
-            args = tuple([convert(o) for o in args])
-        items = [(k, convert(config[k])) for k in config if valid_ident(k)]
-        kwargs = dict(items)
-        result = c(*args, **kwargs)
-        if props:
-            for n, v in props.items():
-                setattr(result, n, convert(v))
-        return result
-
-    def __getitem__(self, key):
-        result = self.config[key]
-        if isinstance(result, dict) and '()' in result:
-            self.config[key] = result = self.configure_custom(result)
-        return result
-
-    def inc_convert(self, value):
-        """Default converter for the inc:// protocol."""
-        if not os.path.isabs(value):
-            value = os.path.join(self.base, value)
-        with codecs.open(value, 'r', encoding='utf-8') as f:
-            result = json.load(f)
-        return result
-
-
-class SubprocessMixin(object):
-    """
-    Mixin for running subprocesses and capturing their output
-    """
-    def __init__(self, verbose=False, progress=None):
-        self.verbose = verbose
-        self.progress = progress
-
-    def reader(self, stream, context):
-        """
-        Read lines from a subprocess' output stream and either pass to a progress
-        callable (if specified) or write progress information to sys.stderr.
-        """
-        progress = self.progress
-        verbose = self.verbose
-        while True:
-            s = stream.readline()
-            if not s:
-                break
-            if progress is not None:
-                progress(s, context)
-            else:
-                if not verbose:
-                    sys.stderr.write('.')
-                else:
-                    sys.stderr.write(s.decode('utf-8'))
-                sys.stderr.flush()
-        stream.close()
-
-    def run_command(self, cmd, **kwargs):
-        p = subprocess.Popen(cmd, stdout=subprocess.PIPE,
-                             stderr=subprocess.PIPE, **kwargs)
-        t1 = threading.Thread(target=self.reader, args=(p.stdout, 'stdout'))
-        t1.start()
-        t2 = threading.Thread(target=self.reader, args=(p.stderr, 'stderr'))
-        t2.start()
-        p.wait()
-        t1.join()
-        t2.join()
-        if self.progress is not None:
-            self.progress('done.', 'main')
-        elif self.verbose:
-            sys.stderr.write('done.\n')
-        return p
-
-
-def normalize_name(name):
-    """Normalize a python package name a la PEP 503"""
-    # https://www.python.org/dev/peps/pep-0503/#normalized-names
-    return re.sub('[-_.]+', '-', name).lower()
-
-# def _get_pypirc_command():
-    # """
-    # Get the distutils command for interacting with PyPI configurations.
-    # :return: the command.
-    # """
-    # from distutils.core import Distribution
-    # from distutils.config import PyPIRCCommand
-    # d = Distribution()
-    # return PyPIRCCommand(d)
-
-class PyPIRCFile(object):
-
-    DEFAULT_REPOSITORY = 'https://upload.pypi.org/legacy/'
-    DEFAULT_REALM = 'pypi'
-
-    def __init__(self, fn=None, url=None):
-        if fn is None:
-            fn = os.path.join(os.path.expanduser('~'), '.pypirc')
-        self.filename = fn
-        self.url = url
-
-    def read(self):
-        result = {}
-
-        if os.path.exists(self.filename):
-            repository = self.url or self.DEFAULT_REPOSITORY
-
-            config = configparser.RawConfigParser()
-            config.read(self.filename)
-            sections = config.sections()
-            if 'distutils' in sections:
-                # let's get the list of servers
-                index_servers = config.get('distutils', 'index-servers')
-                _servers = [server.strip() for server in
-                            index_servers.split('\n')
-                            if server.strip() != '']
-                if _servers == []:
-                    # nothing set, let's try to get the default pypi
-                    if 'pypi' in sections:
-                        _servers = ['pypi']
-                else:
-                    for server in _servers:
-                        result = {'server': server}
-                        result['username'] = config.get(server, 'username')
-
-                        # optional params
-                        for key, default in (('repository', self.DEFAULT_REPOSITORY),
-                                             ('realm', self.DEFAULT_REALM),
-                                             ('password', None)):
-                            if config.has_option(server, key):
-                                result[key] = config.get(server, key)
-                            else:
-                                result[key] = default
-
-                        # work around people having "repository" for the "pypi"
-                        # section of their config set to the HTTP (rather than
-                        # HTTPS) URL
-                        if (server == 'pypi' and
-                            repository in (self.DEFAULT_REPOSITORY, 'pypi')):
-                            result['repository'] = self.DEFAULT_REPOSITORY
-                        elif (result['server'] != repository and
-                              result['repository'] != repository):
-                            result = {}
-            elif 'server-login' in sections:
-                # old format
-                server = 'server-login'
-                if config.has_option(server, 'repository'):
-                    repository = config.get(server, 'repository')
-                else:
-                    repository = self.DEFAULT_REPOSITORY
-                result = {
-                    'username': config.get(server, 'username'),
-                    'password': config.get(server, 'password'),
-                    'repository': repository,
-                    'server': server,
-                    'realm': self.DEFAULT_REALM
-                }
-        return result
-
-    def update(self, username, password):
-        # import pdb; pdb.set_trace()
-        config = configparser.RawConfigParser()
-        fn = self.filename
-        config.read(fn)
-        if not config.has_section('pypi'):
-            config.add_section('pypi')
-        config.set('pypi', 'username', username)
-        config.set('pypi', 'password', password)
-        with open(fn, 'w') as f:
-            config.write(f)
-
-def _load_pypirc(index):
-    """
-    Read the PyPI access configuration as supported by distutils.
-    """
-    return PyPIRCFile(url=index.url).read()
-
-def _store_pypirc(index):
-    PyPIRCFile().update(index.username, index.password)
-
-#
-# get_platform()/get_host_platform() copied from Python 3.10.a0 source, with some minor
-# tweaks
-#
-
-def get_host_platform():
-    """Return a string that identifies the current platform.  This is used mainly to
-    distinguish platform-specific build directories and platform-specific built
-    distributions.  Typically includes the OS name and version and the
-    architecture (as supplied by 'os.uname()'), although the exact information
-    included depends on the OS; eg. on Linux, the kernel version isn't
-    particularly important.
-
-    Examples of returned values:
-       linux-i586
-       linux-alpha (?)
-       solaris-2.6-sun4u
-
-    Windows will return one of:
-       win-amd64 (64bit Windows on AMD64 (aka x86_64, Intel64, EM64T, etc)
-       win32 (all others - specifically, sys.platform is returned)
-
-    For other non-POSIX platforms, currently just returns 'sys.platform'.
-
-    """
-    if os.name == 'nt':
-        if 'amd64' in sys.version.lower():
-            return 'win-amd64'
-        if '(arm)' in sys.version.lower():
-            return 'win-arm32'
-        if '(arm64)' in sys.version.lower():
-            return 'win-arm64'
-        return sys.platform
-
-    # Set for cross builds explicitly
-    if "_PYTHON_HOST_PLATFORM" in os.environ:
-        return os.environ["_PYTHON_HOST_PLATFORM"]
-
-    if os.name != 'posix' or not hasattr(os, 'uname'):
-        # XXX what about the architecture? NT is Intel or Alpha,
-        # Mac OS is M68k or PPC, etc.
-        return sys.platform
-
-    # Try to distinguish various flavours of Unix
-
-    (osname, host, release, version, machine) = os.uname()
-
-    # Convert the OS name to lowercase, remove '/' characters, and translate
-    # spaces (for "Power Macintosh")
-    osname = osname.lower().replace('/', '')
-    machine = machine.replace(' ', '_').replace('/', '-')
-
-    if osname[:5] == 'linux':
-        # At least on Linux/Intel, 'machine' is the processor --
-        # i386, etc.
-        # XXX what about Alpha, SPARC, etc?
-        return  "%s-%s" % (osname, machine)
-
-    elif osname[:5] == 'sunos':
-        if release[0] >= '5':           # SunOS 5 == Solaris 2
-            osname = 'solaris'
-            release = '%d.%s' % (int(release[0]) - 3, release[2:])
-            # We can't use 'platform.architecture()[0]' because a
-            # bootstrap problem. We use a dict to get an error
-            # if some suspicious happens.
-            bitness = {2147483647:'32bit', 9223372036854775807:'64bit'}
-            machine += '.%s' % bitness[sys.maxsize]
-        # fall through to standard osname-release-machine representation
-    elif osname[:3] == 'aix':
-        from _aix_support import aix_platform
-        return aix_platform()
-    elif osname[:6] == 'cygwin':
-        osname = 'cygwin'
-        rel_re = re.compile (r'[\d.]+', re.ASCII)
-        m = rel_re.match(release)
-        if m:
-            release = m.group()
-    elif osname[:6] == 'darwin':
-        import _osx_support, distutils.sysconfig
-        osname, release, machine = _osx_support.get_platform_osx(
-                                        distutils.sysconfig.get_config_vars(),
-                                        osname, release, machine)
-
-    return '%s-%s-%s' % (osname, release, machine)
-
-
-_TARGET_TO_PLAT = {
-    'x86' : 'win32',
-    'x64' : 'win-amd64',
-    'arm' : 'win-arm32',
-}
-
-
-def get_platform():
-    if os.name != 'nt':
-        return get_host_platform()
-    cross_compilation_target = os.environ.get('VSCMD_ARG_TGT_ARCH')
-    if cross_compilation_target not in _TARGET_TO_PLAT:
-        return get_host_platform()
-    return _TARGET_TO_PLAT[cross_compilation_target]

spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/packaging/_musllinux.py

@@ -1,136 +0,0 @@
-"""PEP 656 support.
-
-This module implements logic to detect if the currently running Python is
-linked against musl, and what musl version is used.
-"""
-
-import contextlib
-import functools
-import operator
-import os
-import re
-import struct
-import subprocess
-import sys
-from typing import IO, Iterator, NamedTuple, Optional, Tuple
-
-
-def _read_unpacked(f: IO[bytes], fmt: str) -> Tuple[int, ...]:
-    return struct.unpack(fmt, f.read(struct.calcsize(fmt)))
-
-
-def _parse_ld_musl_from_elf(f: IO[bytes]) -> Optional[str]:
-    """Detect musl libc location by parsing the Python executable.
-
-    Based on: https://gist.github.com/lyssdod/f51579ae8d93c8657a5564aefc2ffbca
-    ELF header: https://refspecs.linuxfoundation.org/elf/gabi4+/ch4.eheader.html
-    """
-    f.seek(0)
-    try:
-        ident = _read_unpacked(f, "16B")
-    except struct.error:
-        return None
-    if ident[:4] != tuple(b"\x7fELF"):  # Invalid magic, not ELF.
-        return None
-    f.seek(struct.calcsize("HHI"), 1)  # Skip file type, machine, and version.
-
-    try:
-        # e_fmt: Format for program header.
-        # p_fmt: Format for section header.
-        # p_idx: Indexes to find p_type, p_offset, and p_filesz.
-        e_fmt, p_fmt, p_idx = {
-            1: ("IIIIHHH", "IIIIIIII", (0, 1, 4)),  # 32-bit.
-            2: ("QQQIHHH", "IIQQQQQQ", (0, 2, 5)),  # 64-bit.
-        }[ident[4]]
-    except KeyError:
-        return None
-    else:
-        p_get = operator.itemgetter(*p_idx)
-
-    # Find the interpreter section and return its content.
-    try:
-        _, e_phoff, _, _, _, e_phentsize, e_phnum = _read_unpacked(f, e_fmt)
-    except struct.error:
-        return None
-    for i in range(e_phnum + 1):
-        f.seek(e_phoff + e_phentsize * i)
-        try:
-            p_type, p_offset, p_filesz = p_get(_read_unpacked(f, p_fmt))
-        except struct.error:
-            return None
-        if p_type != 3:  # Not PT_INTERP.
-            continue
-        f.seek(p_offset)
-        interpreter = os.fsdecode(f.read(p_filesz)).strip("\0")
-        if "musl" not in interpreter:
-            return None
-        return interpreter
-    return None
-
-
-class _MuslVersion(NamedTuple):
-    major: int
-    minor: int
-
-
-def _parse_musl_version(output: str) -> Optional[_MuslVersion]:
-    lines = [n for n in (n.strip() for n in output.splitlines()) if n]
-    if len(lines) < 2 or lines[0][:4] != "musl":
-        return None
-    m = re.match(r"Version (\d+)\.(\d+)", lines[1])
-    if not m:
-        return None
-    return _MuslVersion(major=int(m.group(1)), minor=int(m.group(2)))
-
-
-@functools.lru_cache()
-def _get_musl_version(executable: str) -> Optional[_MuslVersion]:
-    """Detect currently-running musl runtime version.
-
-    This is done by checking the specified executable's dynamic linking
-    information, and invoking the loader to parse its output for a version
-    string. If the loader is musl, the output would be something like::
-
-        musl libc (x86_64)
-        Version 1.2.2
-        Dynamic Program Loader
-    """
-    with contextlib.ExitStack() as stack:
-        try:
-            f = stack.enter_context(open(executable, "rb"))
-        except OSError:
-            return None
-        ld = _parse_ld_musl_from_elf(f)
-    if not ld:
-        return None
-    proc = subprocess.run([ld], stderr=subprocess.PIPE, universal_newlines=True)
-    return _parse_musl_version(proc.stderr)
-
-
-def platform_tags(arch: str) -> Iterator[str]:
-    """Generate musllinux tags compatible to the current platform.
-
-    :param arch: Should be the part of platform tag after the ``linux_``
-        prefix, e.g. ``x86_64``. The ``linux_`` prefix is assumed as a
-        prerequisite for the current platform to be musllinux-compatible.
-
-    :returns: An iterator of compatible musllinux tags.
-    """
-    sys_musl = _get_musl_version(sys.executable)
-    if sys_musl is None:  # Python not dynamically linked against musl.
-        return
-    for minor in range(sys_musl.minor, -1, -1):
-        yield f"musllinux_{sys_musl.major}_{minor}_{arch}"
-
-
-if __name__ == "__main__":  # pragma: no cover
-    import sysconfig
-
-    plat = sysconfig.get_platform()
-    assert plat.startswith("linux-"), "not linux"
-
-    print("plat:", plat)
-    print("musl:", _get_musl_version(sys.executable))
-    print("tags:", end=" ")
-    for t in platform_tags(re.sub(r"[.-]", "_", plat.split("-", 1)[-1])):
-        print(t, end="\n      ")

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

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

spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/urllib3/contrib/socks.py

@@ -1,216 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-This module contains provisional support for SOCKS proxies from within
-urllib3. This module supports SOCKS4, SOCKS4A (an extension of SOCKS4), and
-SOCKS5. To enable its functionality, either install PySocks or install this
-module with the ``socks`` extra.
-
-The SOCKS implementation supports the full range of urllib3 features. It also
-supports the following SOCKS features:
-
-- SOCKS4A (``proxy_url='socks4a://...``)
-- SOCKS4 (``proxy_url='socks4://...``)
-- SOCKS5 with remote DNS (``proxy_url='socks5h://...``)
-- SOCKS5 with local DNS (``proxy_url='socks5://...``)
-- Usernames and passwords for the SOCKS proxy
-
-.. note::
-   It is recommended to use ``socks5h://`` or ``socks4a://`` schemes in
-   your ``proxy_url`` to ensure that DNS resolution is done from the remote
-   server instead of client-side when connecting to a domain name.
-
-SOCKS4 supports IPv4 and domain names with the SOCKS4A extension. SOCKS5
-supports IPv4, IPv6, and domain names.
-
-When connecting to a SOCKS4 proxy the ``username`` portion of the ``proxy_url``
-will be sent as the ``userid`` section of the SOCKS request:
-
-.. code-block:: python
-
-    proxy_url="socks4a://<userid>@proxy-host"
-
-When connecting to a SOCKS5 proxy the ``username`` and ``password`` portion
-of the ``proxy_url`` will be sent as the username/password to authenticate
-with the proxy:
-
-.. code-block:: python
-
-    proxy_url="socks5h://<username>:<password>@proxy-host"
-
-"""
-from __future__ import absolute_import
-
-try:
-    import socks
-except ImportError:
-    import warnings
-
-    from ..exceptions import DependencyWarning
-
-    warnings.warn(
-        (
-            "SOCKS support in urllib3 requires the installation of optional "
-            "dependencies: specifically, PySocks.  For more information, see "
-            "https://urllib3.readthedocs.io/en/1.26.x/contrib.html#socks-proxies"
-        ),
-        DependencyWarning,
-    )
-    raise
-
-from socket import error as SocketError
-from socket import timeout as SocketTimeout
-
-from ..connection import HTTPConnection, HTTPSConnection
-from ..connectionpool import HTTPConnectionPool, HTTPSConnectionPool
-from ..exceptions import ConnectTimeoutError, NewConnectionError
-from ..poolmanager import PoolManager
-from ..util.url import parse_url
-
-try:
-    import ssl
-except ImportError:
-    ssl = None
-
-
-class SOCKSConnection(HTTPConnection):
-    """
-    A plain-text HTTP connection that connects via a SOCKS proxy.
-    """
-
-    def __init__(self, *args, **kwargs):
-        self._socks_options = kwargs.pop("_socks_options")
-        super(SOCKSConnection, self).__init__(*args, **kwargs)
-
-    def _new_conn(self):
-        """
-        Establish a new connection via the SOCKS proxy.
-        """
-        extra_kw = {}
-        if self.source_address:
-            extra_kw["source_address"] = self.source_address
-
-        if self.socket_options:
-            extra_kw["socket_options"] = self.socket_options
-
-        try:
-            conn = socks.create_connection(
-                (self.host, self.port),
-                proxy_type=self._socks_options["socks_version"],
-                proxy_addr=self._socks_options["proxy_host"],
-                proxy_port=self._socks_options["proxy_port"],
-                proxy_username=self._socks_options["username"],
-                proxy_password=self._socks_options["password"],
-                proxy_rdns=self._socks_options["rdns"],
-                timeout=self.timeout,
-                **extra_kw
-            )
-
-        except SocketTimeout:
-            raise ConnectTimeoutError(
-                self,
-                "Connection to %s timed out. (connect timeout=%s)"
-                % (self.host, self.timeout),
-            )
-
-        except socks.ProxyError as e:
-            # This is fragile as hell, but it seems to be the only way to raise
-            # useful errors here.
-            if e.socket_err:
-                error = e.socket_err
-                if isinstance(error, SocketTimeout):
-                    raise ConnectTimeoutError(
-                        self,
-                        "Connection to %s timed out. (connect timeout=%s)"
-                        % (self.host, self.timeout),
-                    )
-                else:
-                    raise NewConnectionError(
-                        self, "Failed to establish a new connection: %s" % error
-                    )
-            else:
-                raise NewConnectionError(
-                    self, "Failed to establish a new connection: %s" % e
-                )
-
-        except SocketError as e:  # Defensive: PySocks should catch all these.
-            raise NewConnectionError(
-                self, "Failed to establish a new connection: %s" % e
-            )
-
-        return conn
-
-
-# We don't need to duplicate the Verified/Unverified distinction from
-# urllib3/connection.py here because the HTTPSConnection will already have been
-# correctly set to either the Verified or Unverified form by that module. This
-# means the SOCKSHTTPSConnection will automatically be the correct type.
-class SOCKSHTTPSConnection(SOCKSConnection, HTTPSConnection):
-    pass
-
-
-class SOCKSHTTPConnectionPool(HTTPConnectionPool):
-    ConnectionCls = SOCKSConnection
-
-
-class SOCKSHTTPSConnectionPool(HTTPSConnectionPool):
-    ConnectionCls = SOCKSHTTPSConnection
-
-
-class SOCKSProxyManager(PoolManager):
-    """
-    A version of the urllib3 ProxyManager that routes connections via the
-    defined SOCKS proxy.
-    """
-
-    pool_classes_by_scheme = {
-        "http": SOCKSHTTPConnectionPool,
-        "https": SOCKSHTTPSConnectionPool,
-    }
-
-    def __init__(
-        self,
-        proxy_url,
-        username=None,
-        password=None,
-        num_pools=10,
-        headers=None,
-        **connection_pool_kw
-    ):
-        parsed = parse_url(proxy_url)
-
-        if username is None and password is None and parsed.auth is not None:
-            split = parsed.auth.split(":")
-            if len(split) == 2:
-                username, password = split
-        if parsed.scheme == "socks5":
-            socks_version = socks.PROXY_TYPE_SOCKS5
-            rdns = False
-        elif parsed.scheme == "socks5h":
-            socks_version = socks.PROXY_TYPE_SOCKS5
-            rdns = True
-        elif parsed.scheme == "socks4":
-            socks_version = socks.PROXY_TYPE_SOCKS4
-            rdns = False
-        elif parsed.scheme == "socks4a":
-            socks_version = socks.PROXY_TYPE_SOCKS4
-            rdns = True
-        else:
-            raise ValueError("Unable to determine SOCKS version from %s" % proxy_url)
-
-        self.proxy_url = proxy_url
-
-        socks_options = {
-            "socks_version": socks_version,
-            "proxy_host": parsed.host,
-            "proxy_port": parsed.port,
-            "username": username,
-            "password": password,
-            "rdns": rdns,
-        }
-        connection_pool_kw["_socks_options"] = socks_options
-
-        super(SOCKSProxyManager, self).__init__(
-            num_pools, headers, **connection_pool_kw
-        )
-
-        self.pool_classes_by_scheme = SOCKSProxyManager.pool_classes_by_scheme

spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/detectron2/evaluation/cityscapes_evaluation.py

@@ -1,112 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-import glob
-import logging
-import os
-import tempfile
-from collections import OrderedDict
-import torch
-from fvcore.common.file_io import PathManager
-from PIL import Image
-
-from detectron2.data import MetadataCatalog
-from detectron2.utils import comm
-
-from .evaluator import DatasetEvaluator
-
-
-class CityscapesEvaluator(DatasetEvaluator):
-    """
-    Evaluate instance segmentation results using cityscapes API.
-
-    Note:
-        * It does not work in multi-machine distributed training.
-        * It contains a synchronization, therefore has to be used on all ranks.
-        * Only the main process runs evaluation.
-    """
-
-    def __init__(self, dataset_name):
-        """
-        Args:
-            dataset_name (str): the name of the dataset.
-                It must have the following metadata associated with it:
-                "thing_classes", "gt_dir".
-        """
-        self._metadata = MetadataCatalog.get(dataset_name)
-        self._cpu_device = torch.device("cpu")
-        self._logger = logging.getLogger(__name__)
-
-    def reset(self):
-        self._working_dir = tempfile.TemporaryDirectory(prefix="cityscapes_eval_")
-        self._temp_dir = self._working_dir.name
-        # All workers will write to the same results directory
-        # TODO this does not work in distributed training
-        self._temp_dir = comm.all_gather(self._temp_dir)[0]
-        if self._temp_dir != self._working_dir.name:
-            self._working_dir.cleanup()
-        self._logger.info(
-            "Writing cityscapes results to temporary directory {} ...".format(self._temp_dir)
-        )
-
-    def process(self, inputs, outputs):
-        from cityscapesscripts.helpers.labels import name2label
-
-        for input, output in zip(inputs, outputs):
-            file_name = input["file_name"]
-            basename = os.path.splitext(os.path.basename(file_name))[0]
-            pred_txt = os.path.join(self._temp_dir, basename + "_pred.txt")
-
-            output = output["instances"].to(self._cpu_device)
-            num_instances = len(output)
-            with open(pred_txt, "w") as fout:
-                for i in range(num_instances):
-                    pred_class = output.pred_classes[i]
-                    classes = self._metadata.thing_classes[pred_class]
-                    class_id = name2label[classes].id
-                    score = output.scores[i]
-                    mask = output.pred_masks[i].numpy().astype("uint8")
-                    png_filename = os.path.join(
-                        self._temp_dir, basename + "_{}_{}.png".format(i, classes)
-                    )
-
-                    Image.fromarray(mask * 255).save(png_filename)
-                    fout.write("{} {} {}\n".format(os.path.basename(png_filename), class_id, score))
-
-    def evaluate(self):
-        """
-        Returns:
-            dict: has a key "segm", whose value is a dict of "AP" and "AP50".
-        """
-        comm.synchronize()
-        if comm.get_rank() > 0:
-            return
-        import cityscapesscripts.evaluation.evalInstanceLevelSemanticLabeling as cityscapes_eval
-
-        self._logger.info("Evaluating results under {} ...".format(self._temp_dir))
-
-        # set some global states in cityscapes evaluation API, before evaluating
-        cityscapes_eval.args.predictionPath = os.path.abspath(self._temp_dir)
-        cityscapes_eval.args.predictionWalk = None
-        cityscapes_eval.args.JSONOutput = False
-        cityscapes_eval.args.colorized = False
-        cityscapes_eval.args.gtInstancesFile = os.path.join(self._temp_dir, "gtInstances.json")
-
-        # These lines are adopted from
-        # https://github.com/mcordts/cityscapesScripts/blob/master/cityscapesscripts/evaluation/evalInstanceLevelSemanticLabeling.py # noqa
-        gt_dir = PathManager.get_local_path(self._metadata.gt_dir)
-        groundTruthImgList = glob.glob(os.path.join(gt_dir, "*", "*_gtFine_instanceIds.png"))
-        assert len(
-            groundTruthImgList
-        ), "Cannot find any ground truth images to use for evaluation. Searched for: {}".format(
-            cityscapes_eval.args.groundTruthSearch
-        )
-        predictionImgList = []
-        for gt in groundTruthImgList:
-            predictionImgList.append(cityscapes_eval.getPrediction(gt, cityscapes_eval.args))
-        results = cityscapes_eval.evaluateImgLists(
-            predictionImgList, groundTruthImgList, cityscapes_eval.args
-        )["averages"]
-
-        ret = OrderedDict()
-        ret["segm"] = {"AP": results["allAp"] * 100, "AP50": results["allAp50%"] * 100}
-        self._working_dir.cleanup()
-        return ret

spaces/CVPR/LIVE/thrust/thrust/allocate_unique.h

@@ -1,444 +0,0 @@
-// Copyright (c) 2018 NVIDIA Corporation
-// Author: Bryce Adelstein Lelbach <[email protected]>
-//
-// Distributed under the Boost Software License v1.0 (boost.org/LICENSE_1_0.txt)
-
-#pragma once
-
-#include <thrust/detail/config.h>
-#include <thrust/detail/cpp11_required.h>
-
-#if THRUST_CPP_DIALECT >= 2011
-
-#include <thrust/detail/raw_pointer_cast.h>
-#include <thrust/detail/type_deduction.h>
-#include <thrust/detail/memory_algorithms.h>
-#include <thrust/detail/allocator/allocator_traits.h>
-
-#include <utility>
-#include <thrust/detail/memory_wrapper.h>
-
-namespace thrust
-{
-
-// wg21.link/p0316r0
-
-///////////////////////////////////////////////////////////////////////////////
-
-namespace detail
-{
-
-template <typename Allocator, typename Pointer>
-void allocator_delete_impl(
-  Allocator const& alloc, Pointer p, std::false_type
-)
-{
-  using traits = typename detail::allocator_traits<
-    typename std::remove_cv<
-      typename std::remove_reference<Allocator>::type
-    >::type
-  >;
-
-  typename traits::allocator_type alloc_T(alloc);
-
-  if (nullptr != pointer_traits<Pointer>::get(p))
-  {
-    traits::destroy(alloc_T, thrust::raw_pointer_cast(p));
-    traits::deallocate(alloc_T, p, 1);
-  }
-}
-
-template <typename Allocator, typename Pointer>
-void allocator_delete_impl(
-  Allocator const& alloc, Pointer p, std::true_type
-)
-{
-  using traits = typename detail::allocator_traits<
-    typename std::remove_cv<
-      typename std::remove_reference<Allocator>::type
-    >::type
-  >;
-
-  typename traits::allocator_type alloc_T(alloc);
-
-  if (nullptr != pointer_traits<Pointer>::get(p))
-  {
-    traits::deallocate(alloc_T, p, 1);
-  }
-}
-
-} // namespace detail
-
-template <typename T, typename Allocator, bool Uninitialized = false>
-struct allocator_delete final
-{
-  using allocator_type
-    = typename std::remove_cv<
-        typename std::remove_reference<Allocator>::type
-      >::type::template rebind<T>::other;
-  using pointer = typename detail::allocator_traits<allocator_type>::pointer;
-
-  template <typename UAllocator>
-  allocator_delete(UAllocator&& other) noexcept
-    : alloc_(THRUST_FWD(other))
-  {}
-
-  template <typename U, typename UAllocator>
-  allocator_delete(
-      allocator_delete<U, UAllocator> const& other
-    ) noexcept
-    : alloc_(other.get_allocator())
-  {}
-  template <typename U, typename UAllocator>
-  allocator_delete(
-      allocator_delete<U, UAllocator>&& other
-    ) noexcept
-    : alloc_(std::move(other.get_allocator()))
-  {}
-
-  template <typename U, typename UAllocator>
-  allocator_delete& operator=(
-    allocator_delete<U, UAllocator> const& other
-  ) noexcept
-  {
-    alloc_ = other.get_allocator();
-    return *this;
-  }
-  template <typename U, typename UAllocator>
-  allocator_delete& operator=(
-    allocator_delete<U, UAllocator>&& other
-  ) noexcept
-  {
-    alloc_ = std::move(other.get_allocator());
-    return *this;
-  }
-
-  void operator()(pointer p)
-  {
-    std::integral_constant<bool, Uninitialized> ic;
-
-    detail::allocator_delete_impl(get_allocator(), p, ic);
-  }
-
-  allocator_type& get_allocator() noexcept { return alloc_; }
-  allocator_type const& get_allocator() const noexcept { return alloc_; }
-
-  void swap(allocator_delete& other) noexcept
-  {
-    using std::swap;
-    swap(alloc_, other.alloc_);
-  }
-
-private:
-  allocator_type alloc_;
-};
-
-template <typename T, typename Allocator>
-using uninitialized_allocator_delete = allocator_delete<T, Allocator, true>;
-
-namespace detail {
-
-template <typename Allocator, typename Pointer, typename Size>
-void array_allocator_delete_impl(
-  Allocator const& alloc, Pointer p, Size count, std::false_type
-)
-{
-  using traits = typename detail::allocator_traits<
-    typename std::remove_cv<
-      typename std::remove_reference<Allocator>::type
-    >::type
-  >;
-
-  typename traits::allocator_type alloc_T(alloc);
-
-  if (nullptr != pointer_traits<Pointer>::get(p))
-  {
-    destroy_n(alloc_T, p, count);
-    traits::deallocate(alloc_T, p, count);
-  }
-}
-
-template <typename Allocator, typename Pointer, typename Size>
-void array_allocator_delete_impl(
-  Allocator const& alloc, Pointer p, Size count, std::true_type
-)
-{
-  using traits = typename detail::allocator_traits<
-    typename std::remove_cv<
-      typename std::remove_reference<Allocator>::type
-    >::type
-  >;
-
-  typename traits::allocator_type alloc_T(alloc);
-
-  if (nullptr != pointer_traits<Pointer>::get(p))
-  {
-    traits::deallocate(alloc_T, p, count);
-  }
-}
-
-} // namespace detail
-
-template <typename T, typename Allocator, bool Uninitialized = false>
-struct array_allocator_delete final
-{
-  using allocator_type
-    = typename std::remove_cv<
-        typename std::remove_reference<Allocator>::type
-      >::type::template rebind<T>::other;
-  using pointer = typename detail::allocator_traits<allocator_type>::pointer;
-
-  template <typename UAllocator>
-  array_allocator_delete(UAllocator&& other, std::size_t n) noexcept
-    : alloc_(THRUST_FWD(other)), count_(n)
-  {}
-
-  template <typename U, typename UAllocator>
-  array_allocator_delete(
-      array_allocator_delete<U, UAllocator> const& other
-    ) noexcept
-    : alloc_(other.get_allocator()), count_(other.count_)
-  {}
-  template <typename U, typename UAllocator>
-  array_allocator_delete(
-      array_allocator_delete<U, UAllocator>&& other
-    ) noexcept
-    : alloc_(std::move(other.get_allocator())), count_(other.count_)
-  {}
-
-  template <typename U, typename UAllocator>
-  array_allocator_delete& operator=(
-    array_allocator_delete<U, UAllocator> const& other
-  ) noexcept
-  {
-    alloc_ = other.get_allocator();
-    count_ = other.count_;
-    return *this;
-  }
-  template <typename U, typename UAllocator>
-  array_allocator_delete& operator=(
-    array_allocator_delete<U, UAllocator>&& other
-  ) noexcept
-  {
-    alloc_ = std::move(other.get_allocator());
-    count_ = other.count_;
-    return *this;
-  }
-
-  void operator()(pointer p)
-  {
-    std::integral_constant<bool, Uninitialized> ic;
-
-    detail::array_allocator_delete_impl(get_allocator(), p, count_, ic);
-  }
-
-  allocator_type& get_allocator() noexcept { return alloc_; }
-  allocator_type const& get_allocator() const noexcept { return alloc_; }
-
-  void swap(array_allocator_delete& other) noexcept
-  {
-    using std::swap;
-    swap(alloc_, other.alloc_);
-    swap(count_, other.count_);
-  }
-
-private:
-  allocator_type alloc_;
-  std::size_t    count_;
-};
-  
-template <typename T, typename Allocator>
-using uninitialized_array_allocator_delete
-  = array_allocator_delete<T, Allocator, true>;
-
-///////////////////////////////////////////////////////////////////////////////
-
-template <typename Pointer, typename Lambda>
-struct tagged_deleter : Lambda
-{
-  __host__ __device__
-  tagged_deleter(Lambda&& l) : Lambda(THRUST_FWD(l)) {}
-
-  using pointer = Pointer;
-};
-
-template <typename Pointer, typename Lambda>
-__host__ __device__
-tagged_deleter<Pointer, Lambda>
-make_tagged_deleter(Lambda&& l)
-{
-  return tagged_deleter<Pointer, Lambda>(THRUST_FWD(l));
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-template <typename T, typename Allocator, typename... Args>
-__host__
-std::unique_ptr<
-  T,
-  allocator_delete<
-    T
-  , typename detail::allocator_traits<
-      typename std::remove_cv<
-        typename std::remove_reference<Allocator>::type
-      >::type
-    >::template rebind_traits<T>::allocator_type
-  >
->
-allocate_unique(
-  Allocator const& alloc, Args&&... args
-)
-{
-  using traits = typename detail::allocator_traits<
-    typename std::remove_cv<
-      typename std::remove_reference<Allocator>::type
-    >::type
-  >::template rebind_traits<T>;
-
-  typename traits::allocator_type alloc_T(alloc);
-
-  auto hold_deleter = make_tagged_deleter<typename traits::pointer>(
-    [&alloc_T] (typename traits::pointer p) {
-      traits::deallocate(alloc_T, p, 1);
-    }
-  );
-  using hold_t = std::unique_ptr<T, decltype(hold_deleter)>;
-  auto hold = hold_t(traits::allocate(alloc_T, 1), hold_deleter);
-
-  traits::construct(
-    alloc_T, thrust::raw_pointer_cast(hold.get()), THRUST_FWD(args)...
-  );
-  auto deleter = allocator_delete<T, typename traits::allocator_type>(alloc);
-  return std::unique_ptr<T, decltype(deleter)>
-    (hold.release(), std::move(deleter));
-}
-
-template <typename T, typename Allocator>
-__host__
-std::unique_ptr<
-  T,
-  uninitialized_allocator_delete<
-    T
-  , typename detail::allocator_traits<
-      typename std::remove_cv<
-        typename std::remove_reference<Allocator>::type
-      >::type
-    >::template rebind_traits<T>::allocator_type
-  >
->
-uninitialized_allocate_unique(
-  Allocator const& alloc
-)
-{
-  using traits = typename detail::allocator_traits<
-    typename std::remove_cv<
-      typename std::remove_reference<Allocator>::type
-    >::type
-  >::template rebind_traits<T>;
-
-  typename traits::allocator_type alloc_T(alloc);
-
-  auto hold_deleter = make_tagged_deleter<typename traits::pointer>(
-    [&alloc_T] (typename traits::pointer p) {
-      traits::deallocate(alloc_T, p, 1);
-    }
-  );
-  using hold_t = std::unique_ptr<T, decltype(hold_deleter)>;
-  auto hold = hold_t(traits::allocate(alloc_T, 1), hold_deleter);
-
-  auto deleter = uninitialized_allocator_delete<
-    T, typename traits::allocator_type
-  >(alloc_T);
-  return std::unique_ptr<T, decltype(deleter)>
-    (hold.release(), std::move(deleter));
-}
-
-template <typename T, typename Allocator, typename Size, typename... Args>
-__host__
-std::unique_ptr<
-  T[],
-  array_allocator_delete<
-    T
-  , typename detail::allocator_traits<
-      typename std::remove_cv<
-        typename std::remove_reference<Allocator>::type
-      >::type
-    >::template rebind_traits<T>::allocator_type
-  >
->
-allocate_unique_n(
-  Allocator const& alloc, Size n, Args&&... args
-)
-{
-  using traits = typename detail::allocator_traits<
-    typename std::remove_cv<
-      typename std::remove_reference<Allocator>::type
-    >::type
-  >::template rebind_traits<T>;
-
-  typename traits::allocator_type alloc_T(alloc);
-
-  auto hold_deleter = make_tagged_deleter<typename traits::pointer>(
-    [n, &alloc_T] (typename traits::pointer p) {
-      traits::deallocate(alloc_T, p, n);
-    }
-  );
-  using hold_t = std::unique_ptr<T[], decltype(hold_deleter)>;
-  auto hold = hold_t(traits::allocate(alloc_T, n), hold_deleter);
-
-  uninitialized_construct_n_with_allocator(
-    alloc_T, hold.get(), n, THRUST_FWD(args)...
-  );
-  auto deleter = array_allocator_delete<
-    T, typename traits::allocator_type
-  >(alloc_T, n);
-  return std::unique_ptr<T[], decltype(deleter)>
-    (hold.release(), std::move(deleter));
-}
-
-template <typename T, typename Allocator, typename Size>
-__host__
-std::unique_ptr<
-  T[],
-  uninitialized_array_allocator_delete<
-    T
-  , typename detail::allocator_traits<
-      typename std::remove_cv<
-        typename std::remove_reference<Allocator>::type
-      >::type
-    >::template rebind_traits<T>::allocator_type
-  >
->
-uninitialized_allocate_unique_n(
-  Allocator const& alloc, Size n
-)
-{
-  using traits = typename detail::allocator_traits<
-    typename std::remove_cv<
-      typename std::remove_reference<Allocator>::type
-    >::type
-  >::template rebind_traits<T>;
-
-  typename traits::allocator_type alloc_T(alloc);
-
-  auto hold_deleter = make_tagged_deleter<typename traits::pointer>(
-    [n, &alloc_T] (typename traits::pointer p) {
-      traits::deallocate(alloc_T, p, n);
-    }
-  );
-  using hold_t = std::unique_ptr<T[], decltype(hold_deleter)>;
-  auto hold = hold_t(traits::allocate(alloc_T, n), hold_deleter);
-
-  auto deleter = uninitialized_array_allocator_delete<
-    T, typename traits::allocator_type
-  >(alloc_T, n);
-  return std::unique_ptr<T[], decltype(deleter)>
-    (hold.release(), std::move(deleter));
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-} // end namespace thrust
-
-#endif // THRUST_CPP_DIALECT >= 2011
-

spaces/CVPR/LIVE/thrust/thrust/system/detail/adl/reverse.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 reverse.h header
-// of the sequential, host, and device systems. It should be #included in any
-// code which uses adl to dispatch reverse
-
-#include <thrust/system/detail/sequential/reverse.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/reverse.h>
-#include <thrust/system/cuda/detail/reverse.h>
-#include <thrust/system/omp/detail/reverse.h>
-#include <thrust/system/tbb/detail/reverse.h>
-#endif
-
-#define __THRUST_HOST_SYSTEM_REVERSE_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/reverse.h>
-#include __THRUST_HOST_SYSTEM_REVERSE_HEADER
-#undef __THRUST_HOST_SYSTEM_REVERSE_HEADER
-
-#define __THRUST_DEVICE_SYSTEM_REVERSE_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/reverse.h>
-#include __THRUST_DEVICE_SYSTEM_REVERSE_HEADER
-#undef __THRUST_DEVICE_SYSTEM_REVERSE_HEADER
-

spaces/ChillyFaze/runwayml-stable-diffusion-v1-5/app.py

@@ -1,3 +0,0 @@
-import gradio as gr
-
-gr.Interface.load("models/runwayml/stable-diffusion-v1-5").launch()

spaces/CrabApple/prompthero-openjourney-v2/app.py

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

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fastapi/middleware/wsgi.py

@@ -1 +0,0 @@
-from starlette.middleware.wsgi import WSGIMiddleware as WSGIMiddleware  # noqa

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fontTools/pens/filterPen.py

@@ -1,164 +0,0 @@
-from fontTools.pens.basePen import AbstractPen
-from fontTools.pens.pointPen import AbstractPointPen
-from fontTools.pens.recordingPen import RecordingPen
-
-
-class _PassThruComponentsMixin(object):
-    def addComponent(self, glyphName, transformation, **kwargs):
-        self._outPen.addComponent(glyphName, transformation, **kwargs)
-
-
-class FilterPen(_PassThruComponentsMixin, AbstractPen):
-
-    """Base class for pens that apply some transformation to the coordinates
-    they receive and pass them to another pen.
-
-    You can override any of its methods. The default implementation does
-    nothing, but passes the commands unmodified to the other pen.
-
-    >>> from fontTools.pens.recordingPen import RecordingPen
-    >>> rec = RecordingPen()
-    >>> pen = FilterPen(rec)
-    >>> v = iter(rec.value)
-
-    >>> pen.moveTo((0, 0))
-    >>> next(v)
-    ('moveTo', ((0, 0),))
-
-    >>> pen.lineTo((1, 1))
-    >>> next(v)
-    ('lineTo', ((1, 1),))
-
-    >>> pen.curveTo((2, 2), (3, 3), (4, 4))
-    >>> next(v)
-    ('curveTo', ((2, 2), (3, 3), (4, 4)))
-
-    >>> pen.qCurveTo((5, 5), (6, 6), (7, 7), (8, 8))
-    >>> next(v)
-    ('qCurveTo', ((5, 5), (6, 6), (7, 7), (8, 8)))
-
-    >>> pen.closePath()
-    >>> next(v)
-    ('closePath', ())
-
-    >>> pen.moveTo((9, 9))
-    >>> next(v)
-    ('moveTo', ((9, 9),))
-
-    >>> pen.endPath()
-    >>> next(v)
-    ('endPath', ())
-
-    >>> pen.addComponent('foo', (1, 0, 0, 1, 0, 0))
-    >>> next(v)
-    ('addComponent', ('foo', (1, 0, 0, 1, 0, 0)))
-    """
-
-    def __init__(self, outPen):
-        self._outPen = outPen
-        self.current_pt = None
-
-    def moveTo(self, pt):
-        self._outPen.moveTo(pt)
-        self.current_pt = pt
-
-    def lineTo(self, pt):
-        self._outPen.lineTo(pt)
-        self.current_pt = pt
-
-    def curveTo(self, *points):
-        self._outPen.curveTo(*points)
-        self.current_pt = points[-1]
-
-    def qCurveTo(self, *points):
-        self._outPen.qCurveTo(*points)
-        self.current_pt = points[-1]
-
-    def closePath(self):
-        self._outPen.closePath()
-        self.current_pt = None
-
-    def endPath(self):
-        self._outPen.endPath()
-        self.current_pt = None
-
-
-class ContourFilterPen(_PassThruComponentsMixin, RecordingPen):
-    """A "buffered" filter pen that accumulates contour data, passes
-    it through a ``filterContour`` method when the contour is closed or ended,
-    and finally draws the result with the output pen.
-
-    Components are passed through unchanged.
-    """
-
-    def __init__(self, outPen):
-        super(ContourFilterPen, self).__init__()
-        self._outPen = outPen
-
-    def closePath(self):
-        super(ContourFilterPen, self).closePath()
-        self._flushContour()
-
-    def endPath(self):
-        super(ContourFilterPen, self).endPath()
-        self._flushContour()
-
-    def _flushContour(self):
-        result = self.filterContour(self.value)
-        if result is not None:
-            self.value = result
-        self.replay(self._outPen)
-        self.value = []
-
-    def filterContour(self, contour):
-        """Subclasses must override this to perform the filtering.
-
-        The contour is a list of pen (operator, operands) tuples.
-        Operators are strings corresponding to the AbstractPen methods:
-        "moveTo", "lineTo", "curveTo", "qCurveTo", "closePath" and
-        "endPath". The operands are the positional arguments that are
-        passed to each method.
-
-        If the method doesn't return a value (i.e. returns None), it's
-        assumed that the argument was modified in-place.
-        Otherwise, the return value is drawn with the output pen.
-        """
-        return  # or return contour
-
-
-class FilterPointPen(_PassThruComponentsMixin, AbstractPointPen):
-    """Baseclass for point pens that apply some transformation to the
-    coordinates they receive and pass them to another point pen.
-
-    You can override any of its methods. The default implementation does
-    nothing, but passes the commands unmodified to the other pen.
-
-    >>> from fontTools.pens.recordingPen import RecordingPointPen
-    >>> rec = RecordingPointPen()
-    >>> pen = FilterPointPen(rec)
-    >>> v = iter(rec.value)
-    >>> pen.beginPath(identifier="abc")
-    >>> next(v)
-    ('beginPath', (), {'identifier': 'abc'})
-    >>> pen.addPoint((1, 2), "line", False)
-    >>> next(v)
-    ('addPoint', ((1, 2), 'line', False, None), {})
-    >>> pen.addComponent("a", (2, 0, 0, 2, 10, -10), identifier="0001")
-    >>> next(v)
-    ('addComponent', ('a', (2, 0, 0, 2, 10, -10)), {'identifier': '0001'})
-    >>> pen.endPath()
-    >>> next(v)
-    ('endPath', (), {})
-    """
-
-    def __init__(self, outPointPen):
-        self._outPen = outPointPen
-
-    def beginPath(self, **kwargs):
-        self._outPen.beginPath(**kwargs)
-
-    def endPath(self):
-        self._outPen.endPath()
-
-    def addPoint(self, pt, segmentType=None, smooth=False, name=None, **kwargs):
-        self._outPen.addPoint(pt, segmentType, smooth, name, **kwargs)

spaces/DaleChen/AutoGPT/autogpt/chat.py

@@ -1,175 +0,0 @@
-import time
-
-from openai.error import RateLimitError
-
-from autogpt import token_counter
-from autogpt.config import Config
-from autogpt.llm_utils import create_chat_completion
-from autogpt.logs import logger
-
-cfg = Config()
-
-
-def create_chat_message(role, content):
-    """
-    Create a chat message with the given role and content.
-
-    Args:
-    role (str): The role of the message sender, e.g., "system", "user", or "assistant".
-    content (str): The content of the message.
-
-    Returns:
-    dict: A dictionary containing the role and content of the message.
-    """
-    return {"role": role, "content": content}
-
-
-def generate_context(prompt, relevant_memory, full_message_history, model):
-    current_context = [
-        create_chat_message("system", prompt),
-        create_chat_message(
-            "system", f"The current time and date is {time.strftime('%c')}"
-        ),
-        create_chat_message(
-            "system",
-            f"This reminds you of these events from your past:\n{relevant_memory}\n\n",
-        ),
-    ]
-
-    # Add messages from the full message history until we reach the token limit
-    next_message_to_add_index = len(full_message_history) - 1
-    insertion_index = len(current_context)
-    # Count the currently used tokens
-    current_tokens_used = token_counter.count_message_tokens(current_context, model)
-    return (
-        next_message_to_add_index,
-        current_tokens_used,
-        insertion_index,
-        current_context,
-    )
-
-
-# TODO: Change debug from hardcode to argument
-def chat_with_ai(
-    prompt, user_input, full_message_history, permanent_memory, token_limit
-):
-    """Interact with the OpenAI API, sending the prompt, user input, message history,
-    and permanent memory."""
-    while True:
-        try:
-            """
-            Interact with the OpenAI API, sending the prompt, user input,
-                message history, and permanent memory.
-
-            Args:
-                prompt (str): The prompt explaining the rules to the AI.
-                user_input (str): The input from the user.
-                full_message_history (list): The list of all messages sent between the
-                    user and the AI.
-                permanent_memory (Obj): The memory object containing the permanent
-                  memory.
-                token_limit (int): The maximum number of tokens allowed in the API call.
-
-            Returns:
-            str: The AI's response.
-            """
-            model = cfg.fast_llm_model  # TODO: Change model from hardcode to argument
-            # Reserve 1000 tokens for the response
-
-            logger.debug(f"Token limit: {token_limit}")
-            send_token_limit = token_limit - 1000
-
-            relevant_memory = (
-                ""
-                if len(full_message_history) == 0
-                else permanent_memory.get_relevant(str(full_message_history[-9:]), 10)
-            )
-
-            logger.debug(f"Memory Stats: {permanent_memory.get_stats()}")
-
-            (
-                next_message_to_add_index,
-                current_tokens_used,
-                insertion_index,
-                current_context,
-            ) = generate_context(prompt, relevant_memory, full_message_history, model)
-
-            while current_tokens_used > 2500:
-                # remove memories until we are under 2500 tokens
-                relevant_memory = relevant_memory[:-1]
-                (
-                    next_message_to_add_index,
-                    current_tokens_used,
-                    insertion_index,
-                    current_context,
-                ) = generate_context(
-                    prompt, relevant_memory, full_message_history, model
-                )
-
-            current_tokens_used += token_counter.count_message_tokens(
-                [create_chat_message("user", user_input)], model
-            )  # Account for user input (appended later)
-
-            while next_message_to_add_index >= 0:
-                # print (f"CURRENT TOKENS USED: {current_tokens_used}")
-                message_to_add = full_message_history[next_message_to_add_index]
-
-                tokens_to_add = token_counter.count_message_tokens(
-                    [message_to_add], model
-                )
-                if current_tokens_used + tokens_to_add > send_token_limit:
-                    break
-
-                # Add the most recent message to the start of the current context,
-                #  after the two system prompts.
-                current_context.insert(
-                    insertion_index, full_message_history[next_message_to_add_index]
-                )
-
-                # Count the currently used tokens
-                current_tokens_used += tokens_to_add
-
-                # Move to the next most recent message in the full message history
-                next_message_to_add_index -= 1
-
-            # Append user input, the length of this is accounted for above
-            current_context.extend([create_chat_message("user", user_input)])
-
-            # Calculate remaining tokens
-            tokens_remaining = token_limit - current_tokens_used
-            # assert tokens_remaining >= 0, "Tokens remaining is negative.
-            # This should never happen, please submit a bug report at
-            #  https://www.github.com/Torantulino/Auto-GPT"
-
-            # Debug print the current context
-            logger.debug(f"Token limit: {token_limit}")
-            logger.debug(f"Send Token Count: {current_tokens_used}")
-            logger.debug(f"Tokens remaining for response: {tokens_remaining}")
-            logger.debug("------------ CONTEXT SENT TO AI ---------------")
-            for message in current_context:
-                # Skip printing the prompt
-                if message["role"] == "system" and message["content"] == prompt:
-                    continue
-                logger.debug(f"{message['role'].capitalize()}: {message['content']}")
-                logger.debug("")
-            logger.debug("----------- END OF CONTEXT ----------------")
-
-            # TODO: use a model defined elsewhere, so that model can contain
-            # temperature and other settings we care about
-            assistant_reply = create_chat_completion(
-                model=model,
-                messages=current_context,
-                max_tokens=tokens_remaining,
-            )
-
-            # Update full message history
-            full_message_history.append(create_chat_message("user", user_input))
-            full_message_history.append(
-                create_chat_message("assistant", assistant_reply)
-            )
-
-            return assistant_reply
-        except RateLimitError:
-            # TODO: When we switch to langchain, this is built in
-            print("Error: ", "API Rate Limit Reached. Waiting 10 seconds...")
-            time.sleep(10)

spaces/Datasculptor/3D-Room-Layout-Estimation_LGT-Net/postprocessing/post_process.py

@@ -1,34 +0,0 @@
-""" 
-@Date: 2021/10/08
-@description:
-"""
-import numpy as np
-import cv2
-
-from postprocessing.dula.layout import fit_layout
-from postprocessing.dula.layout_old import fit_layout_old
-from utils.conversion import depth2xyz, xyz2depth
-
-
-def post_process(b_depth, type_name='manhattan', need_cube=False):
-    plan_y = 1
-    b_xyz = depth2xyz(b_depth, plan_y)
-
-    b_processed_xyz = []
-    for xyz in b_xyz:
-        if type_name == 'manhattan':
-            processed_xz = fit_layout(floor_xz=xyz[..., ::2], need_cube=need_cube, show=False)
-        elif type_name == 'manhattan_old':
-            processed_xz = fit_layout_old(floor_xz=xyz[..., ::2], need_cube=need_cube, show=False)
-        elif type_name == 'atalanta':
-            processed_xz = cv2.approxPolyDP(xyz[..., ::2].astype(np.float32), 0.1, False)[:, 0, :]
-        else:
-            raise NotImplementedError("Unknown post-processing type")
-
-        if need_cube:
-            assert len(processed_xz) == 4
-
-        processed_xyz = np.insert(processed_xz, 1, plan_y, axis=1)
-        b_processed_xyz.append(processed_xyz)
-
-    return np.array(b_processed_xyz)

spaces/Denevan/BingAI/README.md

@@ -1,12 +0,0 @@
----
-title: BingAI
-emoji: 📉
-colorFrom: yellow
-colorTo: red
-sdk: docker
-pinned: false
-license: mit
-app_port: 8080
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/DragGan/DragGan/torch_utils/training_stats.py

@@ -1,268 +0,0 @@
-# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES.  All rights reserved.
-#
-# NVIDIA CORPORATION and its licensors retain all intellectual property
-# and proprietary rights in and to this software, related documentation
-# and any modifications thereto.  Any use, reproduction, disclosure or
-# distribution of this software and related documentation without an express
-# license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-"""Facilities for reporting and collecting training statistics across
-multiple processes and devices. The interface is designed to minimize
-synchronization overhead as well as the amount of boilerplate in user
-code."""
-
-import re
-import numpy as np
-import torch
-import dnnlib
-
-from . import misc
-
-#----------------------------------------------------------------------------
-
-_num_moments    = 3             # [num_scalars, sum_of_scalars, sum_of_squares]
-_reduce_dtype   = torch.float32 # Data type to use for initial per-tensor reduction.
-_counter_dtype  = torch.float64 # Data type to use for the internal counters.
-_rank           = 0             # Rank of the current process.
-_sync_device    = None          # Device to use for multiprocess communication. None = single-process.
-_sync_called    = False         # Has _sync() been called yet?
-_counters       = dict()        # Running counters on each device, updated by report(): name => device => torch.Tensor
-_cumulative     = dict()        # Cumulative counters on the CPU, updated by _sync(): name => torch.Tensor
-
-#----------------------------------------------------------------------------
-
-def init_multiprocessing(rank, sync_device):
-    r"""Initializes `torch_utils.training_stats` for collecting statistics
-    across multiple processes.
-
-    This function must be called after
-    `torch.distributed.init_process_group()` and before `Collector.update()`.
-    The call is not necessary if multi-process collection is not needed.
-
-    Args:
-        rank:           Rank of the current process.
-        sync_device:    PyTorch device to use for inter-process
-                        communication, or None to disable multi-process
-                        collection. Typically `torch.device('cuda', rank)`.
-    """
-    global _rank, _sync_device
-    assert not _sync_called
-    _rank = rank
-    _sync_device = sync_device
-
-#----------------------------------------------------------------------------
-
-@misc.profiled_function
-def report(name, value):
-    r"""Broadcasts the given set of scalars to all interested instances of
-    `Collector`, across device and process boundaries.
-
-    This function is expected to be extremely cheap and can be safely
-    called from anywhere in the training loop, loss function, or inside a
-    `torch.nn.Module`.
-
-    Warning: The current implementation expects the set of unique names to
-    be consistent across processes. Please make sure that `report()` is
-    called at least once for each unique name by each process, and in the
-    same order. If a given process has no scalars to broadcast, it can do
-    `report(name, [])` (empty list).
-
-    Args:
-        name:   Arbitrary string specifying the name of the statistic.
-                Averages are accumulated separately for each unique name.
-        value:  Arbitrary set of scalars. Can be a list, tuple,
-                NumPy array, PyTorch tensor, or Python scalar.
-
-    Returns:
-        The same `value` that was passed in.
-    """
-    if name not in _counters:
-        _counters[name] = dict()
-
-    elems = torch.as_tensor(value)
-    if elems.numel() == 0:
-        return value
-
-    elems = elems.detach().flatten().to(_reduce_dtype)
-    moments = torch.stack([
-        torch.ones_like(elems).sum(),
-        elems.sum(),
-        elems.square().sum(),
-    ])
-    assert moments.ndim == 1 and moments.shape[0] == _num_moments
-    moments = moments.to(_counter_dtype)
-
-    device = moments.device
-    if device not in _counters[name]:
-        _counters[name][device] = torch.zeros_like(moments)
-    _counters[name][device].add_(moments)
-    return value
-
-#----------------------------------------------------------------------------
-
-def report0(name, value):
-    r"""Broadcasts the given set of scalars by the first process (`rank = 0`),
-    but ignores any scalars provided by the other processes.
-    See `report()` for further details.
-    """
-    report(name, value if _rank == 0 else [])
-    return value
-
-#----------------------------------------------------------------------------
-
-class Collector:
-    r"""Collects the scalars broadcasted by `report()` and `report0()` and
-    computes their long-term averages (mean and standard deviation) over
-    user-defined periods of time.
-
-    The averages are first collected into internal counters that are not
-    directly visible to the user. They are then copied to the user-visible
-    state as a result of calling `update()` and can then be queried using
-    `mean()`, `std()`, `as_dict()`, etc. Calling `update()` also resets the
-    internal counters for the next round, so that the user-visible state
-    effectively reflects averages collected between the last two calls to
-    `update()`.
-
-    Args:
-        regex:          Regular expression defining which statistics to
-                        collect. The default is to collect everything.
-        keep_previous:  Whether to retain the previous averages if no
-                        scalars were collected on a given round
-                        (default: True).
-    """
-    def __init__(self, regex='.*', keep_previous=True):
-        self._regex = re.compile(regex)
-        self._keep_previous = keep_previous
-        self._cumulative = dict()
-        self._moments = dict()
-        self.update()
-        self._moments.clear()
-
-    def names(self):
-        r"""Returns the names of all statistics broadcasted so far that
-        match the regular expression specified at construction time.
-        """
-        return [name for name in _counters if self._regex.fullmatch(name)]
-
-    def update(self):
-        r"""Copies current values of the internal counters to the
-        user-visible state and resets them for the next round.
-
-        If `keep_previous=True` was specified at construction time, the
-        operation is skipped for statistics that have received no scalars
-        since the last update, retaining their previous averages.
-
-        This method performs a number of GPU-to-CPU transfers and one
-        `torch.distributed.all_reduce()`. It is intended to be called
-        periodically in the main training loop, typically once every
-        N training steps.
-        """
-        if not self._keep_previous:
-            self._moments.clear()
-        for name, cumulative in _sync(self.names()):
-            if name not in self._cumulative:
-                self._cumulative[name] = torch.zeros([_num_moments], dtype=_counter_dtype)
-            delta = cumulative - self._cumulative[name]
-            self._cumulative[name].copy_(cumulative)
-            if float(delta[0]) != 0:
-                self._moments[name] = delta
-
-    def _get_delta(self, name):
-        r"""Returns the raw moments that were accumulated for the given
-        statistic between the last two calls to `update()`, or zero if
-        no scalars were collected.
-        """
-        assert self._regex.fullmatch(name)
-        if name not in self._moments:
-            self._moments[name] = torch.zeros([_num_moments], dtype=_counter_dtype)
-        return self._moments[name]
-
-    def num(self, name):
-        r"""Returns the number of scalars that were accumulated for the given
-        statistic between the last two calls to `update()`, or zero if
-        no scalars were collected.
-        """
-        delta = self._get_delta(name)
-        return int(delta[0])
-
-    def mean(self, name):
-        r"""Returns the mean of the scalars that were accumulated for the
-        given statistic between the last two calls to `update()`, or NaN if
-        no scalars were collected.
-        """
-        delta = self._get_delta(name)
-        if int(delta[0]) == 0:
-            return float('nan')
-        return float(delta[1] / delta[0])
-
-    def std(self, name):
-        r"""Returns the standard deviation of the scalars that were
-        accumulated for the given statistic between the last two calls to
-        `update()`, or NaN if no scalars were collected.
-        """
-        delta = self._get_delta(name)
-        if int(delta[0]) == 0 or not np.isfinite(float(delta[1])):
-            return float('nan')
-        if int(delta[0]) == 1:
-            return float(0)
-        mean = float(delta[1] / delta[0])
-        raw_var = float(delta[2] / delta[0])
-        return np.sqrt(max(raw_var - np.square(mean), 0))
-
-    def as_dict(self):
-        r"""Returns the averages accumulated between the last two calls to
-        `update()` as an `dnnlib.EasyDict`. The contents are as follows:
-
-            dnnlib.EasyDict(
-                NAME = dnnlib.EasyDict(num=FLOAT, mean=FLOAT, std=FLOAT),
-                ...
-            )
-        """
-        stats = dnnlib.EasyDict()
-        for name in self.names():
-            stats[name] = dnnlib.EasyDict(num=self.num(name), mean=self.mean(name), std=self.std(name))
-        return stats
-
-    def __getitem__(self, name):
-        r"""Convenience getter.
-        `collector[name]` is a synonym for `collector.mean(name)`.
-        """
-        return self.mean(name)
-
-#----------------------------------------------------------------------------
-
-def _sync(names):
-    r"""Synchronize the global cumulative counters across devices and
-    processes. Called internally by `Collector.update()`.
-    """
-    if len(names) == 0:
-        return []
-    global _sync_called
-    _sync_called = True
-
-    # Collect deltas within current rank.
-    deltas = []
-    device = _sync_device if _sync_device is not None else torch.device('cpu')
-    for name in names:
-        delta = torch.zeros([_num_moments], dtype=_counter_dtype, device=device)
-        for counter in _counters[name].values():
-            delta.add_(counter.to(device))
-            counter.copy_(torch.zeros_like(counter))
-        deltas.append(delta)
-    deltas = torch.stack(deltas)
-
-    # Sum deltas across ranks.
-    if _sync_device is not None:
-        torch.distributed.all_reduce(deltas)
-
-    # Update cumulative values.
-    deltas = deltas.cpu()
-    for idx, name in enumerate(names):
-        if name not in _cumulative:
-            _cumulative[name] = torch.zeros([_num_moments], dtype=_counter_dtype)
-        _cumulative[name].add_(deltas[idx])
-
-    # Return name-value pairs.
-    return [(name, _cumulative[name]) for name in names]
-
-#----------------------------------------------------------------------------

spaces/Duskfallcrew/Duskfallcrew-Osenayan_Mix/app.py

@@ -1,19 +0,0 @@
-import gradio as gr
-
-gr.Interface.load("models/Duskfallcrew/Osenayan_Mix").launch()
-
-css = """.main-div div{display:inline-flex;align-items:center;gap:.8rem;font-size:1.75rem}.main-div div h1{font-weight:900;margin-bottom:7px}.main-div p{margin-bottom:10px;font-size:94%}a{text-decoration:underline}.tabs{margin-top:0;margin-bottom:0}#gallery{min-height:20rem}
-"""
-with gr.Blocks(css=css) as demo:
-    gr.HTML(
-        f"""
-            <div class="main-div">
-              <div>
-                <h1>Osenayan Mix</h1>
-              </div>
-              <p>
-               Demo for <a href="https://huggingface.co/Duskfallcrew/Osenayan_Mix">Osenayan Mix</a> Stable Diffusion model.  We stream a lot of our testing on  <a href="https://www.twitch.tv/duskfallcrew"> Twitch </a>. Any chance you can spare a coffee or three? <a href="https://ko-fi.com/DUSKFALLcrew">Ko-Fi Anyone?</a>. Request image gens via our <a href="https://www.pixiv.net/en/users/70748346"> Pixiv</a>. Hang with us on discord: <a href="https://discord.gg/Da7s8d3KJ7"> Earth & Dusk Discord </a>. No tokens are required. <br>
-              
-            </div>
-        """
-    )

spaces/ECCV2022/PSG/OpenPSG/configs/_base_/schedules/schedule_1x.py

@@ -1,10 +0,0 @@
-# optimizer
-optimizer = dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0001)
-optimizer_config = dict(grad_clip=None)
-# learning policy
-lr_config = dict(policy='step',
-                 warmup='linear',
-                 warmup_iters=500,
-                 warmup_ratio=0.001,
-                 step=[8, 11])
-runner = dict(type='EpochBasedRunner', max_epochs=12)