Datasets:

Weyaxi
/

huggingface-spaces-codes

@@ -1,172 +0,0 @@
-import math
-import torch
-from torch.nn import functional as F
-import torch.jit
-def script_method(fn, _rcb=None):
-  return fn
-def script(obj, optimize=True, _frames_up=0, _rcb=None):
-  return obj
-torch.jit.script_method = script_method
-torch.jit.script = script
-def init_weights(m, mean=0.0, std=0.01):
-  classname = m.__class__.__name__
-  if classname.find("Conv") != -1:
-    m.weight.data.normal_(mean, std)
-def get_padding(kernel_size, dilation=1):
-  return int((kernel_size*dilation - dilation)/2)
-def convert_pad_shape(pad_shape):
-  l = pad_shape[::-1]
-  pad_shape = [item for sublist in l for item in sublist]
-  return pad_shape
-def intersperse(lst, item):
-  result = [item] * (len(lst) * 2 + 1)
-  result[1::2] = lst
-  return result
-def kl_divergence(m_p, logs_p, m_q, logs_q):
-  """KL(P||Q)"""
-  kl = (logs_q - logs_p) - 0.5
-  kl += 0.5 * (torch.exp(2. * logs_p) + ((m_p - m_q)**2)) * torch.exp(-2. * logs_q)
-  return kl
-def rand_gumbel(shape):
-  """Sample from the Gumbel distribution, protect from overflows."""
-  uniform_samples = torch.rand(shape) * 0.99998 + 0.00001
-  return -torch.log(-torch.log(uniform_samples))
-def rand_gumbel_like(x):
-  g = rand_gumbel(x.size()).to(dtype=x.dtype, device=x.device)
-  return g
-def slice_segments(x, ids_str, segment_size=4):
-  ret = torch.zeros_like(x[:, :, :segment_size])
-  for i in range(x.size(0)):
-    idx_str = ids_str[i]
-    idx_end = idx_str + segment_size
-    ret[i] = x[i, :, idx_str:idx_end]
-  return ret
-def rand_slice_segments(x, x_lengths=None, segment_size=4):
-  b, d, t = x.size()
-  if x_lengths is None:
-    x_lengths = t
-  ids_str_max = x_lengths - segment_size + 1
-  ids_str = (torch.rand([b]).to(device=x.device) * ids_str_max).to(dtype=torch.long)
-  ret = slice_segments(x, ids_str, segment_size)
-  return ret, ids_str
-def get_timing_signal_1d(
-    length, channels, min_timescale=1.0, max_timescale=1.0e4):
-  position = torch.arange(length, dtype=torch.float)
-  num_timescales = channels // 2
-  log_timescale_increment = (
-      math.log(float(max_timescale) / float(min_timescale)) /
-      (num_timescales - 1))
-  inv_timescales = min_timescale * torch.exp(
-      torch.arange(num_timescales, dtype=torch.float) * -log_timescale_increment)
-  scaled_time = position.unsqueeze(0) * inv_timescales.unsqueeze(1)
-  signal = torch.cat([torch.sin(scaled_time), torch.cos(scaled_time)], 0)
-  signal = F.pad(signal, [0, 0, 0, channels % 2])
-  signal = signal.view(1, channels, length)
-  return signal
-def add_timing_signal_1d(x, min_timescale=1.0, max_timescale=1.0e4):
-  b, channels, length = x.size()
-  signal = get_timing_signal_1d(length, channels, min_timescale, max_timescale)
-  return x + signal.to(dtype=x.dtype, device=x.device)
-def cat_timing_signal_1d(x, min_timescale=1.0, max_timescale=1.0e4, axis=1):
-  b, channels, length = x.size()
-  signal = get_timing_signal_1d(length, channels, min_timescale, max_timescale)
-  return torch.cat([x, signal.to(dtype=x.dtype, device=x.device)], axis)
-def subsequent_mask(length):
-  mask = torch.tril(torch.ones(length, length)).unsqueeze(0).unsqueeze(0)
-  return mask
-@torch.jit.script
-def fused_add_tanh_sigmoid_multiply(input_a, input_b, n_channels):
-  n_channels_int = n_channels[0]
-  in_act = input_a + input_b
-  t_act = torch.tanh(in_act[:, :n_channels_int, :])
-  s_act = torch.sigmoid(in_act[:, n_channels_int:, :])
-  acts = t_act * s_act
-  return acts
-def convert_pad_shape(pad_shape):
-  l = pad_shape[::-1]
-  pad_shape = [item for sublist in l for item in sublist]
-  return pad_shape
-def shift_1d(x):
-  x = F.pad(x, convert_pad_shape([[0, 0], [0, 0], [1, 0]]))[:, :, :-1]
-  return x
-def sequence_mask(length, max_length=None):
-  if max_length is None:
-    max_length = length.max()
-  x = torch.arange(max_length, dtype=length.dtype, device=length.device)
-  return x.unsqueeze(0) < length.unsqueeze(1)
-def generate_path(duration, mask):
-  """
-  duration: [b, 1, t_x]
-  mask: [b, 1, t_y, t_x]
-  """
-  device = duration.device
-  b, _, t_y, t_x = mask.shape
-  cum_duration = torch.cumsum(duration, -1)
-  cum_duration_flat = cum_duration.view(b * t_x)
-  path = sequence_mask(cum_duration_flat, t_y).to(mask.dtype)
-  path = path.view(b, t_x, t_y)
-  path = path - F.pad(path, convert_pad_shape([[0, 0], [1, 0], [0, 0]]))[:, :-1]
-  path = path.unsqueeze(1).transpose(2,3) * mask
-  return path
-def clip_grad_value_(parameters, clip_value, norm_type=2):
-  if isinstance(parameters, torch.Tensor):
-    parameters = [parameters]
-  parameters = list(filter(lambda p: p.grad is not None, parameters))
-  norm_type = float(norm_type)
-  if clip_value is not None:
-    clip_value = float(clip_value)
-  total_norm = 0
-  for p in parameters:
-    param_norm = p.grad.data.norm(norm_type)
-    total_norm += param_norm.item() ** norm_type
-    if clip_value is not None:
-      p.grad.data.clamp_(min=-clip_value, max=clip_value)
-  total_norm = total_norm ** (1. / norm_type)
-  return total_norm

spaces/1gistliPinn/ChatGPT4/Examples/Corel Draw X7 Serial Number And Activation Code 358.md DELETED Viewed

@@ -1,6 +0,0 @@
-<h2>Corel Draw X7 Serial Number And Activation Code 358</h2><br /><p><b><b>Download Zip</b> &#9999; <a href="https://imgfil.com/2uy0Qw">https://imgfil.com/2uy0Qw</a></b></p><br /><br />
-Download keygen coreldraw x7, XFORCE untuk generate serial number dan ... Serial Number Corel Draw X7 Installation and activation code Working ... 29 Mar 2020 Corel Draw X7 Serial Number And Activation Code 358 http://picfs. 1080p. 4d29de3e1b<br />
-<br />
-<br />
-<p></p>

spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/Crash of Cars MOD APK The Most Fun and Addictive Car Game for Android.md DELETED Viewed

@@ -1,95 +0,0 @@
-<br />
-<h1>Download Cars of Crash Mod APK: A Fun and Exciting Racing Game</h1>
-<p>Do you love racing games? Do you want to experience the thrill of crashing into other cars and destroying them? If yes, then you should try Cars of Crash Mod APK, a game that combines arcade racing and multiplayer action. In this game, you can drive your car in different maps, collect power-ups and weapons, and smash into other players to eliminate them. You can also customize your car with various skins and accessories, and unlock new cars with different abilities. But what if you want to enjoy the game without any limitations? That's where Cars of Crash Mod APK comes in handy. With this modded version of the game, you can get unlimited coins and gems, unlock all cars and skins, and remove annoying ads. Sounds amazing, right? In this article, we will tell you what is Cars of Crash Mod APK, how to download and install it, and some tips and tricks for playing it. Let's get started!</p>
- <h2>What is Cars of Crash Mod APK?</h2>
-<p>Cars of Crash Mod APK is a modified version of the original game, Crash of Cars, developed by Not Doppler. The original game is a mixture of arcade racing and multiplayer games together. At the beginning of the game, you can choose your first car, which will hunt for other players and go from persecution. You can also collect coins, gems, crowns, and power-ups along the way. The game has four modes: Free-for-all, Team Deathmatch, Gold Rush, and King of the Hill. You can also join or create a clan with other players, chat with them, and compete in leaderboards.</p>
-<h2>download cars of crash mod apk</h2><br /><p><b><b>Download</b> &#127379; <a href="https://urlin.us/2uSXep">https://urlin.us/2uSXep</a></b></p><br /><br />
-<p>However, the original game has some drawbacks. For example, you need to spend real money to buy coins and gems, which are used to unlock new cars and skins. You also have to watch ads to get some rewards or bonuses. And you need to root your device to install some hacks or cheats. That's why many players prefer to use Cars of Crash Mod APK, which gives them unlimited resources, access to all features, and a smooth gaming experience.</p>
- <h3>Features of Cars of Crash Mod APK</h3>
-<p>Here are some of the features that make Cars of Crash Mod APK better than the original game:</p>
- <h4>Unlimited coins and gems</h4>
-<p>Coins and gems are the main currencies in the game. You can use them to buy new cars, upgrade them, or unlock new skins. However, they are not easy to earn in the game. You have to play for a long time, complete missions, or watch ads to get them. But with Cars of Crash Mod APK, you don't have to worry about that. You can get unlimited coins and gems in your account as soon as you install the mod. You can then use them to buy anything you want in the game.</p>
- <h4>Unlock all cars and skins</h4>
-<p>The game has over 100 cars to choose from, each with its own stats and abilities. Some cars are faster, some are stronger, some have special weapons or skills. You can also customize your car with different skins and accessories, such as hats, glasses, flags, etc. However, not all cars and skins are available at the start. You have to unlock them by spending coins or gems, or by completing certain tasks or achievements. But with Cars of Crash Mod APK, you don't have to do that. You can unlock all cars and skins in the game for free. You can then switch between them as you like.</p>
- <h4>No ads <h4>No ads and no root required</h4>
-<p>One of the most annoying things about the original game is the ads. You have to watch them every time you want to get some rewards, bonuses, or extra lives. They can also interrupt your gameplay and ruin your mood. But with Cars of Crash Mod APK, you don't have to deal with that. You can enjoy the game without any ads, pop-ups, or banners. You can also install the mod without rooting your device, which can be risky and complicated. You just need to follow some simple steps, which we will explain later.</p>
- <h2>How to download and install Cars of Crash Mod APK?</h2>
-<p>Now that you know the features of Cars of Crash Mod APK, you might be wondering how to get it on your device. Well, it's not hard at all. You just need to follow these steps:</p>
- <h3>Step 1: Download the APK file from a trusted source</h3>
-<p>The first thing you need to do is to download the APK file of Cars of Crash Mod APK from a reliable and secure source. You can use the link below to get it directly from our website. The file is 100% safe and virus-free, and it has been tested by many users. You can also check the file size, version, and date before downloading it.</p>
-<p><a href="">Download Cars of Crash Mod APK here</a></p>
-<p>download crash of cars mod apk unlimited money<br />
-download crash of cars mod apk latest version<br />
-download crash of cars mod apk android 1<br />
-download crash of cars mod apk revdl<br />
-download crash of cars mod apk happymod<br />
-download crash of cars mod apk for pc<br />
-download crash of cars mod apk offline<br />
-download crash of cars mod apk no root<br />
-download crash of cars mod apk free shopping<br />
-download crash of cars mod apk rexdl<br />
-download crash of cars hack mod apk<br />
-download crash of cars mega mod apk<br />
-download crash of cars premium mod apk<br />
-download crash of cars full mod apk<br />
-download crash of cars unlocked mod apk<br />
-download game crash of cars mod apk<br />
-download game crash of cars mod apk terbaru<br />
-download game crash of cars mod apk unlimited gems<br />
-download game crash of cars mod apk versi lama<br />
-download game crash of cars mod apk online<br />
-how to download crash of cars mod apk<br />
-how to download crash of cars mod apk on ios<br />
-how to download crash of cars mod apk 2023<br />
-how to download crash of cars mod apk in hindi<br />
-how to download crash of cars mod apk without obb<br />
-cara download crash of cars mod apk<br />
-cara download crash of cars mod apk di android<br />
-cara download crash of cars mod apk 2023<br />
-cara download crash of cars mod apk tanpa root<br />
-cara download crash of cars mod apk dengan mudah<br />
-link download crash of cars mod apk<br />
-link download crash of cars mod apk 2023<br />
-link download game crash of cars mod apk<br />
-link alternatif download crash of cars mod apk<br />
-link terbaru download crash of cars mod apk<br />
-situs download crash of cars mod apk<br />
-situs download game crash of cars mod apk<br />
-situs terbaik untuk download crash of cars mod apk<br />
-situs terpercaya untuk download crash of cars mod apk<br />
-situs gratis untuk download crash of cars mod apk<br />
-website download crash of cars mod apk<br />
-website download game crash of cars mod apk<br />
-website terbaik untuk download crash of cars mod apk<br />
-website terpercaya untuk download crash of cars mod apk<br />
-website gratis untuk download crash of cars mod apk</p>
- <h3>Step 2: Enable unknown sources on your device</h3>
-<p>The next thing you need to do is to enable unknown sources on your device. This will allow you to install apps from sources other than the Google Play Store. To do this, go to your device settings, then security, then unknown sources. Turn on the option and confirm your choice.</p>
- <h3>Step 3: Install the APK file and launch the game</h3>
-<p>The final thing you need to do is to install the APK file and launch the game. To do this, go to your file manager, then locate the downloaded APK file. Tap on it and follow the instructions on the screen. Wait for the installation process to finish, then open the game icon on your home screen. Enjoy!</p>
- <h2>Tips and tricks for playing Cars of Crash Mod APK</h2>
-<p>Cars of Crash Mod APK is a fun and exciting game that will keep you entertained for hours. However, if you want to master the game and beat other players, you need some tips and tricks. Here are some of them:</p>
- <h3>Choose your car wisely</h3>
-<p>The game has over 100 cars to choose from, each with its own stats and abilities. Some cars are faster, some are stronger, some have special weapons or skills. You should choose your car based on your play style and preference. For example, if you like speed, you can choose a car that has high acceleration and top speed. If you like power, you can choose a car that has high damage and health. If you like strategy, you can choose a car that has unique weapons or skills.</p>
- <h3>Collect power-ups and weapons</h3>
-<p>The game has various power-ups and weapons that you can collect on the map. They can help you boost your performance or destroy your enemies. For example, you can collect rockets, bombs, lasers, spikes, shields, magnets, etc. You can also collect crowns, which are used to rank up in the leaderboard. You should try to collect as many power-ups and weapons as possible, but be careful not to waste them or lose them.</p>
- <h3>Avoid obstacles and enemies</h3>
-<p>The game has various obstacles and enemies that you have to avoid or eliminate. They can damage your car or slow you down. For example, you have to avoid trees, rocks, buildings, fences, etc. You also have to avoid other players who are trying to crash into you or shoot you with their weapons. You should try to dodge or outrun them, or use your weapons or skills to counter them.</p>
- <h2>Conclusion</h2>
-<p>Cars of Crash Mod APK is a great game for anyone who loves racing and action games. It has amazing graphics, sound effects, and gameplay that will keep you hooked for hours. It also has unlimited resources, access to all features, and no ads that will enhance your gaming experience. You can download it from our website for free and install it easily on your device. You can also follow our tips and tricks to improve your skills and rank up in the leaderboard. So what are you waiting for? Download Cars of Crash Mod APK now and enjoy!</p>
- <h2>FAQs</h2>
-<p>Here are some frequently asked questions about Cars of Crash Mod APK:</p>
- <ol>
-<li><b>Is Cars of Crash Mod APK safe?</b <li><b>Is Cars of Crash Mod APK safe?</b></li>
-<p>Yes, Cars of Crash Mod APK is safe to use. It does not contain any viruses, malware, or spyware that can harm your device or data. It also does not require root access, which can be risky and complicated. You can download it from our website, which is a trusted and secure source. You can also scan the file with any antivirus app before installing it.</p>
- <li><b>Is Cars of Crash Mod APK compatible with my device?</b></li>
-<p>Cars of Crash Mod APK is compatible with most Android devices that run on Android 4.4 or higher. It has a small file size of about 100 MB, which does not take up much space on your device. It also has low system requirements, which means it can run smoothly on low-end devices. However, you should make sure that your device has enough storage and RAM to avoid any lag or crash issues.</p>
- <li><b>Can I play Cars of Crash Mod APK online with other players?</b></li>
-<p>Yes, you can play Cars of Crash Mod APK online with other players from around the world. The game has four modes: Free-for-all, Team Deathmatch, Gold Rush, and King of the Hill. You can join or create a clan with other players, chat with them, and compete in leaderboards. You can also invite your friends to play with you in private matches. However, you should have a stable internet connection to enjoy the online features of the game.</p>
- <li><b>Can I update Cars of Crash Mod APK to the latest version?</b></li>
-<p>Yes, you can update Cars of Crash Mod APK to the latest version whenever there is a new update available. You can check our website regularly for any updates or notifications. You can also enable the auto-update option in your device settings to get the updates automatically. However, you should backup your data before updating the mod to avoid any data loss or corruption.</p>
- <li><b>How can I contact the developer of Cars of Crash Mod APK?</b></li>
-<p>If you have any questions, suggestions, feedback, or issues regarding Cars of Crash Mod APK, you can contact the developer through their email address: [email protected]. You can also visit their official website: carsofcrashmodapk.com for more information and support. They will try to respond to you as soon as possible and solve your problems.</p>
-</ol></p> 197e85843d<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/City Driving School Car Games MOD APK Explore the City and Learn to Drive.md DELETED Viewed

@@ -1,104 +0,0 @@
-<h1>City Driving School Car Games Mod APK Download</h1>
-<p>Do you love car games and driving simulators? Do you want to learn how to park and drive different types of cars in realistic city scenarios? Do you want to enjoy unlimited access to all the features and content of one of the best car parking games of 2021? If you answered yes to any of these questions, then you should definitely check out City Driving School Car Games Mod APK Download. In this article, we will tell you everything you need to know about this amazing game and how to download and install the modded version on your Android device.</p>
- <h2>What is City Driving School Car Games?</h2>
-<p>City Driving School Car Games is a racing game developed by Better Games Studio Pty Ltd. It is a challenging and fun car driving school and parking simulator game that will test your skills and knowledge of traffic rules, signals, lanes, and more. You will be able to drive and park multiple luxury, turbo, and sports cars in various urban environments, such as flyover bridges, freeways, roundabouts, etc. You will also have to complete different missions and levels, ranging from easy to hard, to earn your driver license and become a legend of the road.</p>
-<h2>city driving school car games mod apk download</h2><br /><p><b><b>Download File</b> &#10004; <a href="https://jinyurl.com/2uNNus">https://jinyurl.com/2uNNus</a></b></p><br /><br />
-<p>Some of the features of City Driving School Car Games are:</p>
-<ul>
-<li>Stunningly amazing 3D graphics and realistic physics</li>
-<li>AI traffic and traffic lights that keep you honest on the road</li>
-<li>Multiple camera angles and views to enhance your driving experience</li>
-<li>Smooth tilt, buttons, and steering controls that are easy to use</li>
-<li>A variety of cars to choose from, each with different specifications and performance</li>
-<li>A demo mode that shows you how to drive and park before each level</li>
-<li>A realistic damage system that makes you pay attention to your car's condition</li>
-<li>An effective learning system that teaches you the basic instructions and tips for driving</li>
-</ul>
- <h2>Why download the mod apk version?</h2>
-<p>City Driving School Car Games is a free game that you can download from Google Play Store. However, it also has some limitations and drawbacks that might affect your enjoyment of the game. For example:</p>
-<ul>
-<li>You have to watch ads to unlock some cars and levels</li>
-<li>You have to spend real money to buy coins and gems that are used for upgrading your cars and unlocking new features</li>
-<li>You have limited lives and fuel that can run out quickly if you are not careful</li>
-<li>You have to wait for a long time to refill your lives and fuel or pay with coins or gems</li>
-<li>You have to deal with annoying pop-ups and notifications that interrupt your gameplay</li>
-</ul>
-<p>That's why we recommend you to download the mod apk version of City Driving School Car Games. The mod apk is a modified version of the original game that has been hacked by some developers to give you unlimited access to everything in the game. With the mod apk, you can enjoy:</p>
-<ul>
-<li>No ads or pop-ups that disturb your gameplay</li>
-<li>Unlimited coins and gems that you can use for anything you want</li>
-<li>Unlimited lives and fuel that never run out</li>
-<li>All cars and levels unlocked from the start</li>
-<li>All features and content available for free</li>
-</ul>
- <h2>How to download and install the mod apk?</h2>
-<p>Downloading and installing the mod apk of City Driving School Car Games is very easy and simple. Just follow these steps:</p>
-<ol>
-<li>Click on this link  to go to the download page of City Driving School Car Games Mod APK Download.</li>
-<li>Tap on the download button to start downloading the mod apk <li>Wait for the download to finish and then locate the mod apk file in your device's storage</li>
-<li>Tap on the mod apk file to open it and then enable the installation from unknown sources if prompted</li>
-<li>Follow the instructions on the screen to install the mod apk on your device</li>
-<li>Launch the game and enjoy the modded features</li>
-</ol>
-<p>Note: You may need to uninstall the original version of City Driving School Car Games before installing the mod apk to avoid any conflicts or errors.</p>
- <h2>Tips and tricks for playing City Driving School Car Games</h2>
-<p>City Driving School Car Games is a fun and addictive game that will keep you entertained for hours. However, it can also be challenging and frustrating at times, especially if you are new to the game or want to master the advanced levels. That's why we have compiled some tips and tricks for playing City Driving School Car Games that will help you improve your skills and enjoy the game more.</p>
-<ul>
-<li>Use the demo mode before each level to learn how to drive and park correctly. The demo mode will show you the optimal route, speed, and angle for completing the level. You can also replay the demo mode as many times as you want until you get familiar with the level.</li>
-<li>Choose the right car for each level. Different cars have different specifications and performance, such as speed, acceleration, handling, braking, etc. Some cars are better suited for certain levels than others. For example, a sports car might be faster and more agile, but it might also be harder to control and park. A luxury car might be more comfortable and stable, but it might also be slower and less responsive. Experiment with different cars and find the one that suits your style and preference.</li>
-<li>Use the camera angles and views to your advantage. City Driving School Car Games offers multiple camera angles and views that you can switch between during the game. You can use them to get a better perspective of your surroundings, avoid obstacles, and park more accurately. For example, you can use the top view to see the whole map and plan your route, or you can use the rear view to see how close you are to the parking spot.</li>
-<li>Follow the traffic rules and signals. City Driving School Car Games is not just a racing game, but also a driving simulator that teaches you how to drive in real life. You have to follow the traffic rules and signals, such as stopping at red lights, yielding to pedestrians, staying in your lane, etc. If you break any of these rules, you will lose points or fail the level. You will also have to deal with AI traffic that can be unpredictable and dangerous. Be careful and attentive on the road.</li>
-<li>Don't damage your car too much. City Driving School Car Games has a realistic damage system that shows you how much your car is damaged after each collision or crash. If your car is damaged too much, it will affect its performance and appearance. You will also have to pay for repairing your car with coins or gems. To avoid damaging your car too much, try to drive carefully and avoid hitting other cars, walls, barriers, etc.</li>
-</ul>
- <h2>Conclusion</h2>
-<p>City Driving School Car Games is one of the best car parking games of 2021 that will challenge your driving skills and knowledge of traffic rules. You will be able to drive and park multiple luxury, turbo, and sports cars in various urban environments, such as flyover bridges, freeways, roundabouts, etc. You will also have to complete different missions and levels, ranging from easy to hard, to earn your driver license and become a legend of the road.</p>
-<p>If you want to enjoy unlimited access to all the features and content of City Driving School Car Games, you should download the mod apk version of the game from this link . The mod apk will give you unlimited coins and gems, unlimited lives and fuel, no ads or pop-ups, all cars and levels unlocked, and all features and content available for free.</p>
-<p>city driving school simulator mod apk free download<br />
-city car driving school 3d game mod apk unlimited money<br />
-city driving school car parking games mod apk latest version<br />
-city car driving school simulator game mod apk android 1<br />
-city driving school car games mod apk download for pc<br />
-city car driving school test game mod apk revdl<br />
-city driving school car racing games mod apk offline<br />
-city car driving school simulator 2020 game mod apk hack<br />
-city driving school car games mod apk download uptodown<br />
-city car driving school bus game mod apk rexdl<br />
-city driving school car stunt games mod apk online<br />
-city car driving school truck game mod apk pure<br />
-city driving school car games mod apk download apkpure<br />
-city car driving school taxi game mod apk happymod<br />
-city driving school car drift games mod apk no ads<br />
-city car driving school police game mod apk 2021<br />
-city driving school car games mod apk download for android<br />
-city car driving school bike game mod apk 2020<br />
-city driving school car simulator games mod apk unlimited coins<br />
-city car driving school ambulance game mod apk 2019<br />
-city driving school car games mod apk download for ios<br />
-city car driving school train game mod apk old version<br />
-city driving school car adventure games mod apk new update<br />
-city car driving school airplane game mod apk vip unlocked<br />
-city driving school car games mod apk download for windows 10<br />
-city car driving school boat game mod apk pro premium<br />
-city driving school car fun games mod apk all cars unlocked<br />
-city car driving school helicopter game mod apk full version<br />
-city driving school car games mod apk download for laptop<br />
-city car driving school tractor game mod apk mega mod<br />
-city driving school car educational games mod apk easy mode<br />
-city car driving school fire truck game mod apk god mode<br />
-city driving school car games mod apk download for macbook<br />
-city car driving school garbage truck game mod apk unlimited gems<br />
-city driving school car puzzle games mod apk hard mode<br />
-city car driving school ice cream truck game mod apk unlimited lives<br />
-city driving school car games mod apk download for chromebook<br />
-city car driving school tow truck game mod apk unlimited fuel<br />
-city driving school car arcade games mod apk realistic physics<br />
-city car driving school monster truck game mod apk unlimited nitro</p>
-<p>Download City Driving School Car Games Mod APK Download now and start your driving adventure!</p>
- <h2>FAQs</h2>
-<h3>What is the latest version of City Driving School Car Games Mod APK Download?</h3>
-<p>The latest version of City Driving School Car Games Mod APK Download is 1.0.8 which was updated on June 18th 2023.</p>
- <h3>Is City Driving School Car Games Mod APK Download safe to use?</h3>
-<p>Yes, City Driving School Car Games Mod APK Download is safe to use as long as you download it from a trusted source like this link . However, we cannot guarantee that it will work on all devices or that it will not cause any problems with your device or game account. Use it at your own risk <p>Unfortunately, City Driving School Car Games Mod APK Download does not support multiplayer mode or online play with friends. It is a single-player game that you can enjoy on your own. However, you can still compare your scores and achievements with other players on the leaderboards and challenge yourself to beat them.</p> 401be4b1e0<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Free Download Pink Whatsapp APK - The Best Messaging App for Girls.md DELETED Viewed

@@ -1,130 +0,0 @@
-<br />
-<h1>Pink WhatsApp: What Is It and How to Download It</h1>
-<p>Are you bored of the same old green WhatsApp icon on your phone? Do you want to spice up your chat experience with a new color and theme? If yes, then you might be interested in trying out pink WhatsApp, a modified version of the popular messaging app that lets you customize its appearance and features. But what is pink WhatsApp exactly and how can you download it on your Android device? In this article, we will answer these questions and more, so keep reading!</p>
-<h2>pink whatsapp free download apk</h2><br /><p><b><b>DOWNLOAD</b> &#9881;&#9881;&#9881; <a href="https://jinyurl.com/2uNJp0">https://jinyurl.com/2uNJp0</a></b></p><br /><br />
-<h2>Introduction</h2>
-<h3>What is WhatsApp and why is it popular?</h3>
-<p>WhatsApp is one of the most widely used messaging apps in the world, with over 2 billion users as of 2020. It allows you to send text messages, voice notes, photos, videos, documents, stickers, and more to your contacts for free, as long as you have an internet connection. You can also make voice and video calls, create group chats, and use end-to-end encryption to protect your privacy. WhatsApp is simple, reliable, and secure, which makes it a favorite among many people.</p>
-<h3>What is pink WhatsApp and how is it different from the original app?</h3>
-<p>Pink WhatsApp is not an official app from WhatsApp Inc., but rather a modified version created by third-party developers. It is also known as a WhatsApp mod or a WhatsApp clone, as it copies the original app's functionality but adds some extra features and options. One of the most noticeable differences is the color scheme, which changes from green to pink. You can also change the theme, font, icon, wallpaper, and other aspects of the app's appearance according to your preference. Moreover, pink WhatsApp offers some additional features that are not available in the original app, such as hiding your online status, disabling read receipts, downloading status videos, sending larger files, and more.</p>
-<h3>What are the benefits and risks of using pink WhatsApp?</h3>
-<p>The main benefit of using pink WhatsApp is that you can enjoy a more personalized and fun chat experience with your friends and family. You can also access some features that are not present in the official app, which can enhance your convenience and privacy. However, there are also some risks involved in using pink WhatsApp, such as:</p>
-<ul>
-<li>It is not authorized by WhatsApp Inc., so it may violate their terms of service and result in your account being banned or suspended.</li>
-<li>It may contain malware or spyware that can harm your device or steal your data.</li>
-<li>It may not be updated regularly or compatible with the latest version of WhatsApp, so it may have bugs or glitches that affect its performance.</li>
-<li>It may not offer the same level of security and encryption as the original app, so your messages and calls may be intercepted or hacked by others.</li>
-</ul>
-<p>Therefore, you should be careful and cautious when using pink WhatsApp, and only download it from a trusted source. You should also backup your chats regularly and avoid sharing any sensitive or personal information through the app.</p>
-<p>pink whatsapp web apk latest version<br />
-pink whatsapp web app for android<br />
-pink whatsapp web free download 2023<br />
-pink whatsapp web apkcombo<br />
-pink whatsapp web mobile app<br />
-pink nation whatsapp web apk<br />
-pink nation whatsapp web app<br />
-pink nation whatsapp web free download<br />
-pink nation whatsapp web latest version<br />
-pink nation whatsapp web apkcombo<br />
-pink whatsapp mod apk free download<br />
-pink whatsapp mod app for android<br />
-pink whatsapp mod free download 2023<br />
-pink whatsapp mod apk latest version<br />
-pink whatsapp mod mobile app<br />
-pink nation whatsapp mod apk<br />
-pink nation whatsapp mod app<br />
-pink nation whatsapp mod free download<br />
-pink nation whatsapp mod latest version<br />
-pink nation whatsapp mod mobile app<br />
-pink whatsapp plus apk free download<br />
-pink whatsapp plus app for android<br />
-pink whatsapp plus free download 2023<br />
-pink whatsapp plus apk latest version<br />
-pink whatsapp plus mobile app<br />
-pink nation whatsapp plus apk<br />
-pink nation whatsapp plus app<br />
-pink nation whatsapp plus free download<br />
-pink nation whatsapp plus latest version<br />
-pink nation whatsapp plus mobile app<br />
-pink whatsapp gb apk free download<br />
-pink whatsapp gb app for android<br />
-pink whatsapp gb free download 2023<br />
-pink whatsapp gb apk latest version<br />
-pink whatsapp gb mobile app<br />
-pink nation whatsapp gb apk<br />
-pink nation whatsapp gb app<br />
-pink nation whatsapp gb free download<br />
-pink nation whatsapp gb latest version<br />
-pink nation whatsapp gb mobile app</p>
-<h2>How to download and install pink WhatsApp on your Android device</h2>
-<h3>Step 1: Enable unknown sources on your device</h3>
-<p>Since pink WhatsApp is not available on the Google Play Store, you will need to enable unknown sources on your device to install it. This means that you will allow your device to install apps from sources other than the official store. To do this, follow these steps:</p>
-<ol>
-<li>Go to Settings > Security > Unknown sources.</li>
-<li>Toggle on the switch or check the box to enable unknown sources.</ <p>li>Tap OK or Confirm to accept the warning message.</li>
-</ol>
-<p>Note: The exact steps may vary depending on your device model and Android version, so you may need to look for the option in a different menu or section.</p>
-<h3>Step 2: Download the pink WhatsApp apk file from a trusted source</h3>
-<p>Next, you will need to download the pink WhatsApp apk file, which is the installation file for the app. You can find many websites that offer this file, but you should be careful and only choose a trusted and reliable source. Some of the factors that you should consider when choosing a source are:</p>
-<ul>
-<li>The reputation and reviews of the website.</li>
-<li>The date and version of the apk file.</li>
-<li>The size and content of the apk file.</li>
-<li>The security and encryption of the website.</li>
-</ul>
-<p>One of the websites that we recommend is [Pink WhatsApp APK Download], which provides the latest and safest version of the app. To download the file from this website, follow these steps:</p>
-<ol>
-<li>Open your browser and go to .</li>
-<li>Scroll down and tap on the Download button.</li>
-<li>Wait for the download to complete and locate the file in your device's storage.</li>
-</ol>
-<h3>Step 3: Install the apk file and launch the app</h3>
-<p>Once you have downloaded the apk file, you can proceed to install it on your device. To do this, follow these steps:</p>
-<ol>
-<li>Tap on the apk file or open it with a file manager app.</li>
-<li>Tap on Install and wait for the installation to finish.</li>
-<li>Tap on Open or Launch to start the app.</li>
-</ol>
-<p>You should now see the pink WhatsApp icon on your home screen or app drawer. You can also delete the apk file from your device's storage to save some space.</p>
-<h3>Step 4: Verify your phone number and restore your chat backup</h3>
-<p>The final step is to verify your phone number and restore your chat backup, if you have one. To do this, follow these steps:</p>
-<ol>
-<li>Enter your phone number and tap on Next.</li>
-<li>Enter the verification code that you receive via SMS or call.</li>
-<li>Agree to the terms and conditions and tap on Continue.</li>
-<li>If you have a chat backup, tap on Restore and wait for the process to complete.</li>
-<li>Enter your name and profile picture and tap on Next.</li>
-</ol>
-<p>You should now be able to use pink WhatsApp as you would use the original app. You can also explore the settings and options to customize the app according to your liking.</p>
-<h2>Conclusion</h2>
-<h3>Summary of the main points</h3>
-<p>In this article, we have explained what pink WhatsApp is and how to download it on your Android device. Pink WhatsApp is a modified version of the original app that lets you change its color, theme, and features. It can offer you a more personalized and fun chat experience, but it also comes with some risks and drawbacks. You should be careful and cautious when using it, and only download it from a trusted source. You should also backup your chats regularly and avoid sharing any sensitive or personal information through the app.</p>
-<h3>Call to action and disclaimer</h3>
-<p>If you are interested in trying out pink WhatsApp, you can follow the steps that we have outlined above. However, we do not endorse or recommend using pink WhatsApp, as it is not an official app from WhatsApp Inc. We are not responsible for any consequences that may arise from using it, such as account bans, data breaches, malware infections, or legal issues. You should use it at your own risk and discretion. We hope that this article has been helpful and informative for you. If you have any questions or feedback, please feel free to leave a comment below. Thank you for reading!</p>
- <h4>Frequently Asked Questions</h4>
- <ol>
- <li><b>Is pink WhatsApp safe?</b></li>
- <p>Pink WhatsApp is not safe in terms of security, privacy, and legality. It is not authorized by WhatsApp Inc., so it may violate their terms of service and result in your account being banned or suspended. It may also contain malware or spyware that can harm your device or steal your data. It may not offer the same level of encryption as the original app, so your messages and calls may be intercepted or hacked by others. It may also expose you to legal issues if it infringes on any intellectual property rights or regulations.</p>
- <li><b>Can I use pink WhatsApp with my existing WhatsApp account?</b></li>
- <p>You can use pink WhatsApp with your existing WhatsApp account, but you should be aware of the risks involved. You may lose your chat history, contacts, or media files if you switch between the apps. You may also face account bans or suspensions if WhatsApp detects that you are using a modified app. Therefore, it is advisable to use a different phone number or device for pink WhatsApp, or to backup your data before using it.</p>
- <li><b>How can I update pink WhatsApp?</b></li>
- <p>Pink WhatsApp may not be updated regularly or compatible with the latest version of WhatsApp, so you may encounter bugs or glitches that affect its performance. You may also miss out on some new features or improvements that are introduced by WhatsApp. To update pink WhatsApp, you will need to download and install the latest apk file from the same source that you used before. You should also check the website for any news or announcements regarding the app's development and maintenance.</p>
- <li><b>What are some alternatives to pink WhatsApp?</b></li>
- <p>If you are looking for other WhatsApp mods or clones that offer similar or different features and options, you can check out some of these alternatives:</p>
-<ul>
-<li>GBWhatsApp: This is one of the most popular and widely used WhatsApp mods, which offers many customization and privacy options, such as hiding your online status, disabling read receipts, downloading status videos, sending larger files, and more.</li>
-<li>FMWhatsApp: This is another popular WhatsApp mod, which offers more themes and fonts, as well as some extra features, such as locking chats with a password, hiding chats from the main screen, and using multiple accounts.</li>
-<li>YOWhatsApp: This is a WhatsApp mod that focuses on enhancing the user interface and design of the app, with more icons, colors, and styles. It also offers some additional features, such as increasing the limit of group members, sending more images at once, and hiding media from the gallery.</li>
-</ul>
-<p>Note: These alternatives are also not authorized by WhatsApp Inc., so they may also pose the same risks and drawbacks as pink WhatsApp. You should use them at your own risk and discretion.</p>
- <li><b>How can I uninstall pink WhatsApp?</b></li>
- <p>If you want to uninstall pink WhatsApp from your device, you can follow these steps:</p>
-<ol>
-<li>Go to Settings > Apps > Pink WhatsApp.</li>
-<li>Tap on Uninstall and confirm your choice.</li>
-<li>Wait for the uninstallation to complete and remove the app icon from your home screen or app drawer.</li>
-</ol>
-<p>You can also delete any remaining files or folders related to pink WhatsApp from your device's storage. If you want to switch back to the original app, you can download it from the Google Play Store and verify your phone number again.</p>
- </ol></p> 401be4b1e0<br />
-<br />
-<br />

spaces/1toTree/lora_test/ppdiffusers/fastdeploy_utils.py DELETED Viewed

@@ -1,260 +0,0 @@
-# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
-# Copyright 2022 The HuggingFace Inc. team.
-# Copyright (c) 2022, NVIDIA CORPORATION.  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 os
-import shutil
-from pathlib import Path
-from typing import Optional, Union
-import numpy as np
-from .download_utils import ppdiffusers_bos_download
-from .utils import (
-    FASTDEPLOY_MODEL_NAME,
-    FASTDEPLOY_WEIGHTS_NAME,
-    is_fastdeploy_available,
-    is_paddle_available,
-    logging,
-)
-if is_paddle_available():
-    import paddle
-if is_fastdeploy_available():
-    import fastdeploy as fd
-    def fdtensor2pdtensor(fdtensor: fd.C.FDTensor):
-        dltensor = fdtensor.to_dlpack()
-        pdtensor = paddle.utils.dlpack.from_dlpack(dltensor)
-        return pdtensor
-    def pdtensor2fdtensor(pdtensor: paddle.Tensor, name: str = "", share_with_raw_ptr=False):
-        if not share_with_raw_ptr:
-            dltensor = paddle.utils.dlpack.to_dlpack(pdtensor)
-            return fd.C.FDTensor.from_dlpack(name, dltensor)
-        else:
-            return fd.C.FDTensor.from_external_data(
-                name,
-                pdtensor.data_ptr(),
-                pdtensor.shape,
-                pdtensor.dtype.name,
-                str(pdtensor.place),
-                int(pdtensor.place.gpu_device_id()),
-            )
-logger = logging.get_logger(__name__)
-class FastDeployRuntimeModel:
-    def __init__(self, model=None, **kwargs):
-        logger.info("`ppdiffusers.FastDeployRuntimeModel` is experimental and might change in the future.")
-        self.model = model
-        self.model_save_dir = kwargs.get("model_save_dir", None)
-        self.latest_model_name = kwargs.get("latest_model_name", "inference.pdmodel")
-        self.latest_params_name = kwargs.get("latest_params_name", "inference.pdiparams")
-    def zero_copy_infer(self, prebinded_inputs: dict, prebinded_outputs: dict, share_with_raw_ptr=True, **kwargs):
-        """
-        Execute inference without copying data from cpu to gpu.
-        Arguments:
-            kwargs (`dict(name, paddle.Tensor)`):
-                An input map from name to tensor.
-        Return:
-            List of output tensor.
-        """
-        for inputs_name, inputs_tensor in prebinded_inputs.items():
-            input_fdtensor = pdtensor2fdtensor(inputs_tensor, inputs_name, share_with_raw_ptr=share_with_raw_ptr)
-            self.model.bind_input_tensor(inputs_name, input_fdtensor)
-        for outputs_name, outputs_tensor in prebinded_outputs.items():
-            output_fdtensor = pdtensor2fdtensor(outputs_tensor, outputs_name, share_with_raw_ptr=share_with_raw_ptr)
-            self.model.bind_output_tensor(outputs_name, output_fdtensor)
-            self.model.zero_copy_infer()
-    def __call__(self, **kwargs):
-        inputs = {k: np.array(v) for k, v in kwargs.items()}
-        return self.model.infer(inputs)
-    @staticmethod
-    def load_model(
-        model_path: Union[str, Path],
-        params_path: Union[str, Path],
-        runtime_options: Optional["fd.RuntimeOption"] = None,
-    ):
-        """
-        Loads an FastDeploy Inference Model with fastdeploy.RuntimeOption
-        Arguments:
-            model_path (`str` or `Path`):
-                Model path from which to load
-            params_path (`str` or `Path`):
-                Params path from which to load
-            runtime_options (fd.RuntimeOption, *optional*):
-                The RuntimeOption of fastdeploy to initialize the fastdeploy runtime. Default setting
-                the device to cpu and the backend to paddle inference
-        """
-        option = runtime_options
-        if option is None or not isinstance(runtime_options, fd.RuntimeOption):
-            logger.info("No fastdeploy.RuntimeOption specified, using CPU device and paddle inference backend.")
-            option = fd.RuntimeOption()
-            option.use_paddle_backend()
-            option.use_cpu()
-        option.set_model_path(model_path, params_path)
-        return fd.Runtime(option)
-    def _save_pretrained(
-        self,
-        save_directory: Union[str, Path],
-        model_file_name: Optional[str] = None,
-        params_file_name: Optional[str] = None,
-        **kwargs
-    ):
-        """
-        Save a model and its configuration file to a directory, so that it can be re-loaded using the
-        [`~FastDeployRuntimeModel.from_pretrained`] class method. It will always save the
-        latest_model_name.
-        Arguments:
-            save_directory (`str` or `Path`):
-                Directory where to save the model file.
-            model_file_name(`str`, *optional*):
-                Overwrites the default model file name from `"inference.pdmodel"` to `model_file_name`. This allows you to save the
-                model with a different name.
-            params_file_name(`str`, *optional*):
-                Overwrites the default model file name from `"inference.pdiparams"` to `params_file_name`. This allows you to save the
-                model with a different name.
-        """
-        model_file_name = model_file_name if model_file_name is not None else FASTDEPLOY_MODEL_NAME
-        params_file_name = params_file_name if params_file_name is not None else FASTDEPLOY_WEIGHTS_NAME
-        src_model_path = self.model_save_dir.joinpath(self.latest_model_name)
-        dst_model_path = Path(save_directory).joinpath(model_file_name)
-        src_params_path = self.model_save_dir.joinpath(self.latest_params_name)
-        dst_params_path = Path(save_directory).joinpath(params_file_name)
-        try:
-            shutil.copyfile(src_model_path, dst_model_path)
-            shutil.copyfile(src_params_path, dst_params_path)
-        except shutil.SameFileError:
-            pass
-    def save_pretrained(
-        self,
-        save_directory: Union[str, os.PathLike],
-        **kwargs,
-    ):
-        """
-        Save a model to a directory, so that it can be re-loaded using the [`~FastDeployRuntimeModel.from_pretrained`] class
-        method.:
-        Arguments:
-            save_directory (`str` or `os.PathLike`):
-                Directory to which to save. Will be created if it doesn't exist.
-        """
-        if os.path.isfile(save_directory):
-            logger.error(f"Provided path ({save_directory}) should be a directory, not a file")
-            return
-        os.makedirs(save_directory, exist_ok=True)
-        # saving model weights/files
-        self._save_pretrained(save_directory, **kwargs)
-    @classmethod
-    def _from_pretrained(
-        cls,
-        pretrained_model_name_or_path: Union[str, Path],
-        cache_dir: Optional[str] = None,
-        model_file_name: Optional[str] = None,
-        params_file_name: Optional[str] = None,
-        runtime_options: Optional["fd.RuntimeOption"] = None,
-        **kwargs,
-    ):
-        """
-        Load a model from a directory or the BOS.
-        Arguments:
-            pretrained_model_name_or_path (`str` or `Path`):
-                Directory from which to load
-            cache_dir (`Union[str, Path]`, *optional*):
-                Path to a directory in which a downloaded pretrained model configuration should be cached if the
-                standard cache should not be used.
-            model_file_name (`str`):
-                Overwrites the default model file name from `"inference.pdmodel"` to `file_name`. This allows you to load
-                different model files from the same repository or directory.
-            params_file_name (`str`):
-                Overwrites the default params file name from `"inference.pdiparams"` to `file_name`. This allows you to load
-                different model files from the same repository or directory.
-            runtime_options (`fastdeploy.RuntimeOption`, *optional*):
-                The RuntimeOption of fastdeploy.
-            kwargs (`Dict`, *optional*):
-                kwargs will be passed to the model during initialization
-        """
-        model_file_name = model_file_name if model_file_name is not None else FASTDEPLOY_MODEL_NAME
-        params_file_name = params_file_name if params_file_name is not None else FASTDEPLOY_WEIGHTS_NAME
-        # load model from local directory
-        if os.path.isdir(pretrained_model_name_or_path):
-            model = FastDeployRuntimeModel.load_model(
-                os.path.join(pretrained_model_name_or_path, model_file_name),
-                os.path.join(pretrained_model_name_or_path, params_file_name),
-                runtime_options=runtime_options,
-            )
-            kwargs["model_save_dir"] = Path(pretrained_model_name_or_path)
-        # load model from hub
-        else:
-            # download model
-            model_cache_path = ppdiffusers_bos_download(
-                pretrained_model_name_or_path=pretrained_model_name_or_path,
-                filename=model_file_name,
-                cache_dir=cache_dir,
-            )
-            # download params
-            params_cache_path = ppdiffusers_bos_download(
-                pretrained_model_name_or_path=pretrained_model_name_or_path,
-                filename=params_file_name,
-                cache_dir=cache_dir,
-            )
-            kwargs["model_save_dir"] = Path(model_cache_path).parent
-            kwargs["latest_model_name"] = Path(model_cache_path).name
-            kwargs["latest_params_name"] = Path(params_cache_path).name
-            model = FastDeployRuntimeModel.load_model(
-                model_cache_path, params_cache_path, runtime_options=runtime_options
-            )
-        return cls(model=model, **kwargs)
-    @classmethod
-    def from_pretrained(
-        cls,
-        pretrained_model_name_or_path: Union[str, Path],
-        cache_dir: Optional[str] = None,
-        model_file_name: Optional[str] = None,
-        params_file_name: Optional[str] = None,
-        runtime_options: Optional["fd.RuntimeOption"] = None,
-        **model_kwargs,
-    ):
-        return cls._from_pretrained(
-            pretrained_model_name_or_path=pretrained_model_name_or_path,
-            cache_dir=cache_dir,
-            model_file_name=model_file_name,
-            params_file_name=params_file_name,
-            runtime_options=runtime_options,
-            **model_kwargs,
-        )

spaces/2023Liu2023/bingo/postcss.config.js DELETED Viewed

@@ -1,6 +0,0 @@
-module.exports = {
-  plugins: {
-    tailwindcss: {},
-    autoprefixer: {},
-  },
-}

spaces/44ov41za8i/FreeVC/speaker_encoder/params_model.py DELETED Viewed

@@ -1,11 +0,0 @@
-## Model parameters
-model_hidden_size = 256
-model_embedding_size = 256
-model_num_layers = 3
-## Training parameters
-learning_rate_init = 1e-4
-speakers_per_batch = 64
-utterances_per_speaker = 10

spaces/AIConsultant/MusicGen/docs/ENCODEC.md DELETED Viewed

@@ -1,179 +0,0 @@
-# EnCodec: High Fidelity Neural Audio Compression
-AudioCraft provides the training code for EnCodec, a state-of-the-art deep learning
-based audio codec supporting both mono stereo audio, presented in the
-[High Fidelity Neural Audio Compression][arxiv] paper.
-Check out our [sample page][encodec_samples].
-## Original EnCodec models
-The EnCodec models presented in High Fidelity Neural Audio Compression can be accessed
-and used with the [EnCodec repository](https://github.com/facebookresearch/encodec).
-**Note**: We do not guarantee compatibility between the AudioCraft and EnCodec codebases
-and released checkpoints at this stage.
-## Installation
-Please follow the AudioCraft installation instructions from the [README](../README.md).
-## Training
-The [CompressionSolver](../audiocraft/solvers/compression.py) implements the audio reconstruction
-task to train an EnCodec model. Specifically, it trains an encoder-decoder with a quantization
-bottleneck - a SEANet encoder-decoder with Residual Vector Quantization bottleneck for EnCodec -
-using a combination of objective and perceptual losses in the forms of discriminators.
-The default configuration matches a causal EnCodec training with at a single bandwidth.
-### Example configuration and grids
-We provide sample configuration and grids for training EnCodec models.
-The compression configuration are defined in
-[config/solver/compression](../config/solver/compression).
-The example grids are available at
-[audiocraft/grids/compression](../audiocraft/grids/compression).
-```shell
-# base causal encodec on monophonic audio sampled at 24 khz
-dora grid compression.encodec_base_24khz
-# encodec model used for MusicGen on monophonic audio sampled at 32 khz
-dora grid compression.encodec_musicgen_32khz
-```
-### Training and valid stages
-The model is trained using a combination of objective and perceptual losses.
-More specifically, EnCodec is trained with the MS-STFT discriminator along with
-objective losses through the use of a loss balancer to effectively weight
-the different losses, in an intuitive manner.
-### Evaluation stage
-Evaluations metrics for audio generation:
-* SI-SNR: Scale-Invariant Signal-to-Noise Ratio.
-* ViSQOL: Virtual Speech Quality Objective Listener.
-Note: Path to the ViSQOL binary (compiled with bazel) needs to be provided in
-order to run the ViSQOL metric on the reference and degraded signals.
-The metric is disabled by default.
-Please refer to the [metrics documentation](../METRICS.md) to learn more.
-### Generation stage
-The generation stage consists in generating the reconstructed audio from samples
-with the current model. The number of samples generated and the batch size used are
-controlled by the `dataset.generate` configuration. The output path and audio formats
-are defined in the generate stage configuration.
-```shell
-# generate samples every 5 epoch
-dora run solver=compression/encodec_base_24khz generate.every=5
-# run with a different dset
-dora run solver=compression/encodec_base_24khz generate.path=<PATH_IN_DORA_XP_FOLDER>
-# limit the number of samples or use a different batch size
-dora grid solver=compression/encodec_base_24khz dataset.generate.num_samples=10 dataset.generate.batch_size=4
-```
-### Playing with the model
-Once you have a model trained, it is possible to get the entire solver, or just
-the trained model with the following functions:
-```python
-from audiocraft.solvers import CompressionSolver
-# If you trained a custom model with signature SIG.
-model = CompressionSolver.model_from_checkpoint('//sig/SIG')
-# If you want to get one of the pretrained models with the `//pretrained/` prefix.
-model = CompressionSolver.model_from_checkpoint('//pretrained/facebook/encodec_32khz')
-# Or load from a custom checkpoint path
-model = CompressionSolver.model_from_checkpoint('/my_checkpoints/foo/bar/checkpoint.th')
-# If you only want to use a pretrained model, you can also directly get it
-# from the CompressionModel base model class.
-from audiocraft.models import CompressionModel
-# Here do not put the `//pretrained/` prefix!
-model = CompressionModel.get_pretrained('facebook/encodec_32khz')
-model = CompressionModel.get_pretrained('dac_44khz')
-# Finally, you can also retrieve the full Solver object, with its dataloader etc.
-from audiocraft import train
-from pathlib import Path
-import logging
-import os
-import sys
-# uncomment the following line if you want some detailed logs when loading a Solver.
-logging.basicConfig(stream=sys.stderr, level=logging.INFO)
-# You must always run the following function from the root directory.
-os.chdir(Path(train.__file__).parent.parent)
-# You can also get the full solver (only for your own experiments).
-# You can provide some overrides to the parameters to make things more convenient.
-solver = train.get_solver_from_sig('SIG', {'device': 'cpu', 'dataset': {'batch_size': 8}})
-solver.model
-solver.dataloaders
-```
-### Importing / Exporting models
-At the moment we do not have a definitive workflow for exporting EnCodec models, for
-instance to Hugging Face (HF). We are working on supporting automatic convertion between
-AudioCraft and Hugging Face implementations.
-We still have some support for fine tuning an EnCodec model coming from HF in AudioCraft,
-using for instance `continue_from=//pretrained/facebook/encodec_32k`.
-An AudioCraft checkpoint can be exported in a more compact format (excluding the optimizer etc.)
-using `audiocraft.utils.export.export_encodec`. For instance, you could run
-```python
-from audiocraft.utils import export
-from audiocraft import train
-xp = train.main.get_xp_from_sig('SIG')
-export.export_encodec(
-    xp.folder / 'checkpoint.th',
-    '/checkpoints/my_audio_lm/compression_state_dict.bin')
-from audiocraft.models import CompressionModel
-model = CompressionModel.get_pretrained('/checkpoints/my_audio_lm/compression_state_dict.bin')
-from audiocraft.solvers import CompressionSolver
-# The two are strictly equivalent, but this function supports also loading from non already exported models.
-model = CompressionSolver.model_from_checkpoint('//pretrained//checkpoints/my_audio_lm/compression_state_dict.bin')
-```
-We will see then how to use this model as a tokenizer for MusicGen/Audio gen in the
-[MusicGen documentation](./MUSICGEN.md).
-### Learn more
-Learn more about AudioCraft training pipelines in the [dedicated section](./TRAINING.md).
-## Citation
-```
-@article{defossez2022highfi,
-  title={High Fidelity Neural Audio Compression},
-  author={Défossez, Alexandre and Copet, Jade and Synnaeve, Gabriel and Adi, Yossi},
-  journal={arXiv preprint arXiv:2210.13438},
-  year={2022}
-}
-```
-## License
-See license information in the [README](../README.md).
-[arxiv]: https://arxiv.org/abs/2210.13438
-[encodec_samples]: https://ai.honu.io/papers/encodec/samples.html

spaces/AIFILMS/generate_human_motion/VQ-Trans/dataset/dataset_tokenize.py DELETED Viewed

@@ -1,117 +0,0 @@
-import torch
-from torch.utils import data
-import numpy as np
-from os.path import join as pjoin
-import random
-import codecs as cs
-from tqdm import tqdm
-class VQMotionDataset(data.Dataset):
-    def __init__(self, dataset_name, feat_bias = 5, window_size = 64, unit_length = 8):
-        self.window_size = window_size
-        self.unit_length = unit_length
-        self.feat_bias = feat_bias
-        self.dataset_name = dataset_name
-        min_motion_len = 40 if dataset_name =='t2m' else 24
-        if dataset_name == 't2m':
-            self.data_root = './dataset/HumanML3D'
-            self.motion_dir = pjoin(self.data_root, 'new_joint_vecs')
-            self.text_dir = pjoin(self.data_root, 'texts')
-            self.joints_num = 22
-            radius = 4
-            fps = 20
-            self.max_motion_length = 196
-            dim_pose = 263
-            self.meta_dir = 'checkpoints/t2m/VQVAEV3_CB1024_CMT_H1024_NRES3/meta'
-            #kinematic_chain = paramUtil.t2m_kinematic_chain
-        elif dataset_name == 'kit':
-            self.data_root = './dataset/KIT-ML'
-            self.motion_dir = pjoin(self.data_root, 'new_joint_vecs')
-            self.text_dir = pjoin(self.data_root, 'texts')
-            self.joints_num = 21
-            radius = 240 * 8
-            fps = 12.5
-            dim_pose = 251
-            self.max_motion_length = 196
-            self.meta_dir = 'checkpoints/kit/VQVAEV3_CB1024_CMT_H1024_NRES3/meta'
-            #kinematic_chain = paramUtil.kit_kinematic_chain
-        joints_num = self.joints_num
-        mean = np.load(pjoin(self.meta_dir, 'mean.npy'))
-        std = np.load(pjoin(self.meta_dir, 'std.npy'))
-        split_file = pjoin(self.data_root, 'train.txt')
-        data_dict = {}
-        id_list = []
-        with cs.open(split_file, 'r') as f:
-            for line in f.readlines():
-                id_list.append(line.strip())
-        new_name_list = []
-        length_list = []
-        for name in tqdm(id_list):
-            try:
-                motion = np.load(pjoin(self.motion_dir, name + '.npy'))
-                if (len(motion)) < min_motion_len or (len(motion) >= 200):
-                    continue
-                data_dict[name] = {'motion': motion,
-                                   'length': len(motion),
-                                   'name': name}
-                new_name_list.append(name)
-                length_list.append(len(motion))
-            except:
-                # Some motion may not exist in KIT dataset
-                pass
-        self.mean = mean
-        self.std = std
-        self.length_arr = np.array(length_list)
-        self.data_dict = data_dict
-        self.name_list = new_name_list
-    def inv_transform(self, data):
-        return data * self.std + self.mean
-    def __len__(self):
-        return len(self.data_dict)
-    def __getitem__(self, item):
-        name = self.name_list[item]
-        data = self.data_dict[name]
-        motion, m_length = data['motion'], data['length']
-        m_length = (m_length // self.unit_length) * self.unit_length
-        idx = random.randint(0, len(motion) - m_length)
-        motion = motion[idx:idx+m_length]
-        "Z Normalization"
-        motion = (motion - self.mean) / self.std
-        return motion, name
-def DATALoader(dataset_name,
-                batch_size = 1,
-                num_workers = 8, unit_length = 4) :
-    train_loader = torch.utils.data.DataLoader(VQMotionDataset(dataset_name, unit_length=unit_length),
-                                              batch_size,
-                                              shuffle=True,
-                                              num_workers=num_workers,
-                                              #collate_fn=collate_fn,
-                                              drop_last = True)
-    return train_loader
-def cycle(iterable):
-    while True:
-        for x in iterable:
-            yield x

spaces/AIGC-Audio/AudioGPT/text_to_audio/Make_An_Audio/ldm/modules/losses_audio/__init__.py DELETED Viewed

@@ -1,7 +0,0 @@
-from ldm.modules.losses_audio.vqperceptual import DummyLoss
-# relative imports pain
-import os
-import sys
-path = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'vggishish')
-sys.path.append(path)

spaces/AIGC-Audio/AudioGPT/text_to_audio/Make_An_Audio/ldm/modules/losses_audio/vggishish/loss.py DELETED Viewed

@@ -1,41 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import torch.optim as optim
-class WeightedCrossEntropy(nn.CrossEntropyLoss):
-    def __init__(self, weights, **pytorch_ce_loss_args) -> None:
-        super().__init__(reduction='none', **pytorch_ce_loss_args)
-        self.weights = weights
-    def __call__(self, outputs, targets, to_weight=True):
-        loss = super().__call__(outputs, targets)
-        if to_weight:
-            return (loss * self.weights[targets]).sum() / self.weights[targets].sum()
-        else:
-            return loss.mean()
-if __name__ == '__main__':
-    x = torch.randn(10, 5)
-    target = torch.randint(0, 5, (10,))
-    weights = torch.tensor([1., 2., 3., 4., 5.])
-    # criterion_weighted = nn.CrossEntropyLoss(weight=weights)
-    # loss_weighted = criterion_weighted(x, target)
-    # criterion_weighted_manual = nn.CrossEntropyLoss(reduction='none')
-    # loss_weighted_manual = criterion_weighted_manual(x, target)
-    # print(loss_weighted, loss_weighted_manual.mean())
-    # loss_weighted_manual = (loss_weighted_manual * weights[target]).sum() / weights[target].sum()
-    # print(loss_weighted, loss_weighted_manual)
-    # print(torch.allclose(loss_weighted, loss_weighted_manual))
-    pytorch_weighted = nn.CrossEntropyLoss(weight=weights)
-    pytorch_unweighted = nn.CrossEntropyLoss()
-    custom = WeightedCrossEntropy(weights)
-    assert torch.allclose(pytorch_weighted(x, target), custom(x, target, to_weight=True))
-    assert torch.allclose(pytorch_unweighted(x, target), custom(x, target, to_weight=False))
-    print(custom(x, target, to_weight=True), custom(x, target, to_weight=False))

spaces/ATang0729/Forecast4Muses/Model/Model6/Model6_2_ProfileRecogition/mmpretrain/configs/__init__.py DELETED Viewed

File without changes

spaces/Ababababababbababa/Ashaar/poetry_diacritizer/config_manager.py DELETED Viewed

@@ -1,350 +0,0 @@
-from enum import Enum
-import os
-from pathlib import Path
-import shutil
-import subprocess
-from typing import Any, Dict
-import ruamel.yaml
-import torch
-from poetry_diacritizer.models.baseline import BaseLineModel
-from poetry_diacritizer.models.cbhg import CBHGModel
-from poetry_diacritizer.models.gpt import GPTModel
-from poetry_diacritizer.models.seq2seq import Decoder as Seq2SeqDecoder, Encoder as Seq2SeqEncoder, Seq2Seq
-from poetry_diacritizer.models.tacotron_based import (
-    Decoder as TacotronDecoder,
-    Encoder as TacotronEncoder,
-    Tacotron,
-)
-from poetry_diacritizer.options import AttentionType, LossType, OptimizerType
-from poetry_diacritizer.util.text_encoders import (
-    ArabicEncoderWithStartSymbol,
-    BasicArabicEncoder,
-    TextEncoder,
-)
-class ConfigManager:
-    """Co/home/almodhfer/Projects/daicritization/temp_results/CA_MSA/cbhg-new/model-10.ptnfig Manager"""
-    def __init__(self, config_path: str, model_kind: str):
-        available_models = ["baseline", "cbhg", "seq2seq", "tacotron_based", "gpt"]
-        if model_kind not in available_models:
-            raise TypeError(f"model_kind must be in {available_models}")
-        self.config_path = Path(config_path)
-        self.model_kind = model_kind
-        self.yaml = ruamel.yaml.YAML()
-        self.config: Dict[str, Any] = self._load_config()
-        self.git_hash = self._get_git_hash()
-        self.session_name = ".".join(
-            [
-                self.config["data_type"],
-                self.config["session_name"],
-                f"{model_kind}",
-            ]
-        )
-        self.data_dir = Path(
-            os.path.join(self.config["data_directory"], self.config["data_type"])
-        )
-        self.base_dir = Path(
-            os.path.join(self.config["log_directory"], self.session_name)
-        )
-        self.log_dir = Path(os.path.join(self.base_dir, "logs"))
-        self.prediction_dir = Path(os.path.join(self.base_dir, "predictions"))
-        self.plot_dir = Path(os.path.join(self.base_dir, "plots"))
-        self.models_dir = Path(os.path.join(self.base_dir, "models"))
-        if "sp_model_path" in self.config:
-            self.sp_model_path = self.config["sp_model_path"]
-        else:
-            self.sp_model_path = None
-        self.text_encoder: TextEncoder = self.get_text_encoder()
-        self.config["len_input_symbols"] = len(self.text_encoder.input_symbols)
-        self.config["len_target_symbols"] = len(self.text_encoder.target_symbols)
-        if self.model_kind in ["seq2seq", "tacotron_based"]:
-            self.config["attention_type"] = AttentionType[self.config["attention_type"]]
-        self.config["optimizer"] = OptimizerType[self.config["optimizer_type"]]
-    def _load_config(self):
-        with open(self.config_path, "rb") as model_yaml:
-            _config = self.yaml.load(model_yaml)
-        return _config
-    @staticmethod
-    def _get_git_hash():
-        try:
-            return (
-                subprocess.check_output(["git", "describe", "--always"])
-                .strip()
-                .decode()
-            )
-        except Exception as e:
-            print(f"WARNING: could not retrieve git hash. {e}")
-    def _check_hash(self):
-        try:
-            git_hash = (
-                subprocess.check_output(["git", "describe", "--always"])
-                .strip()
-                .decode()
-            )
-            if self.config["git_hash"] != git_hash:
-                print(
-                    f"""WARNING: git hash mismatch. Current: {git_hash}.
-                    Config hash: {self.config['git_hash']}"""
-                )
-        except Exception as e:
-            print(f"WARNING: could not check git hash. {e}")
-    @staticmethod
-    def _print_dict_values(values, key_name, level=0, tab_size=2):
-        tab = level * tab_size * " "
-        print(tab + "-", key_name, ":", values)
-    def _print_dictionary(self, dictionary, recursion_level=0):
-        for key in dictionary.keys():
-            if isinstance(key, dict):
-                recursion_level += 1
-                self._print_dictionary(dictionary[key], recursion_level)
-            else:
-                self._print_dict_values(
-                    dictionary[key], key_name=key, level=recursion_level
-                )
-    def print_config(self):
-        print("\nCONFIGURATION", self.session_name)
-        self._print_dictionary(self.config)
-    def update_config(self):
-        self.config["git_hash"] = self._get_git_hash()
-    def dump_config(self):
-        self.update_config()
-        _config = {}
-        for key, val in self.config.items():
-            if isinstance(val, Enum):
-                _config[key] = val.name
-            else:
-                _config[key] = val
-        with open(self.base_dir / "config.yml", "w") as model_yaml:
-            self.yaml.dump(_config, model_yaml)
-    def create_remove_dirs(
-        self,
-        clear_dir: bool = False,
-        clear_logs: bool = False,
-        clear_weights: bool = False,
-        clear_all: bool = False,
-    ):
-        self.base_dir.mkdir(exist_ok=True, parents=True)
-        self.plot_dir.mkdir(exist_ok=True)
-        self.prediction_dir.mkdir(exist_ok=True)
-        if clear_dir:
-            delete = input(f"Delete {self.log_dir} AND {self.models_dir}? (y/[n])")
-            if delete == "y":
-                shutil.rmtree(self.log_dir, ignore_errors=True)
-                shutil.rmtree(self.models_dir, ignore_errors=True)
-        if clear_logs:
-            delete = input(f"Delete {self.log_dir}? (y/[n])")
-            if delete == "y":
-                shutil.rmtree(self.log_dir, ignore_errors=True)
-        if clear_weights:
-            delete = input(f"Delete {self.models_dir}? (y/[n])")
-            if delete == "y":
-                shutil.rmtree(self.models_dir, ignore_errors=True)
-        self.log_dir.mkdir(exist_ok=True)
-        self.models_dir.mkdir(exist_ok=True)
-    def get_last_model_path(self):
-        """
-        Given a checkpoint, get the last save model name
-        Args:
-        checkpoint (str): the path where models are saved
-        """
-        models = os.listdir(self.models_dir)
-        models = [model for model in models if model[-3:] == ".pt"]
-        if len(models) == 0:
-            return None
-        _max = max(int(m.split(".")[0].split("-")[0]) for m in models)
-        model_name = f"{_max}-snapshot.pt"
-        last_model_path = os.path.join(self.models_dir, model_name)
-        return last_model_path
-    def load_model(self, model_path: str = None):
-        """
-        loading a model from path
-        Args:
-        checkpoint (str): the path to the model
-        name (str): the name of the model, which is in the path
-        model (Tacotron): the model  to load its save state
-        optimizer: the optimizer to load its saved state
-        """
-        model = self.get_model()
-        with open(self.base_dir / f"{self.model_kind}_network.txt", "w") as file:
-            file.write(str(model))
-        if model_path is None:
-            last_model_path = self.get_last_model_path()
-            if last_model_path is None:
-                return model, 1
-        else:
-            last_model_path = model_path
-        saved_model = torch.load(last_model_path)
-        out = model.load_state_dict(saved_model["model_state_dict"])
-        print(out)
-        global_step = saved_model["global_step"] + 1
-        return model, global_step
-    def get_model(self, ignore_hash=False):
-        if not ignore_hash:
-            self._check_hash()
-        if self.model_kind == "cbhg":
-            return self.get_cbhg()
-        elif self.model_kind == "seq2seq":
-            return self.get_seq2seq()
-        elif self.model_kind == "tacotron_based":
-            return self.get_tacotron_based()
-        elif self.model_kind == "baseline":
-            return self.get_baseline()
-        elif self.model_kind == "gpt":
-            return self.get_gpt()
-    def get_gpt(self):
-        model = GPTModel(
-            self.config["base_model_path"],
-            freeze=self.config["freeze"],
-            n_layer=self.config["n_layer"],
-            use_lstm=self.config["use_lstm"],
-        )
-        return model
-    def get_baseline(self):
-        model = BaseLineModel(
-            embedding_dim=self.config["embedding_dim"],
-            inp_vocab_size=self.config["len_input_symbols"],
-            targ_vocab_size=self.config["len_target_symbols"],
-            layers_units=self.config["layers_units"],
-            use_batch_norm=self.config["use_batch_norm"],
-        )
-        return model
-    def get_cbhg(self):
-        model = CBHGModel(
-            embedding_dim=self.config["embedding_dim"],
-            inp_vocab_size=self.config["len_input_symbols"],
-            targ_vocab_size=self.config["len_target_symbols"],
-            use_prenet=self.config["use_prenet"],
-            prenet_sizes=self.config["prenet_sizes"],
-            cbhg_gru_units=self.config["cbhg_gru_units"],
-            cbhg_filters=self.config["cbhg_filters"],
-            cbhg_projections=self.config["cbhg_projections"],
-            post_cbhg_layers_units=self.config["post_cbhg_layers_units"],
-            post_cbhg_use_batch_norm=self.config["post_cbhg_use_batch_norm"],
-        )
-        return model
-    def get_seq2seq(self):
-        encoder = Seq2SeqEncoder(
-            embedding_dim=self.config["encoder_embedding_dim"],
-            inp_vocab_size=self.config["len_input_symbols"],
-            layers_units=self.config["encoder_units"],
-            use_batch_norm=self.config["use_batch_norm"],
-        )
-        decoder = TacotronDecoder(
-            self.config["len_target_symbols"],
-            start_symbol_id=self.text_encoder.start_symbol_id,
-            embedding_dim=self.config["decoder_embedding_dim"],
-            encoder_dim=self.config["encoder_dim"],
-            decoder_units=self.config["decoder_units"],
-            decoder_layers=self.config["decoder_layers"],
-            attention_type=self.config["attention_type"],
-            attention_units=self.config["attention_units"],
-            is_attention_accumulative=self.config["is_attention_accumulative"],
-            use_prenet=self.config["use_decoder_prenet"],
-            prenet_depth=self.config["decoder_prenet_depth"],
-            teacher_forcing_probability=self.config["teacher_forcing_probability"],
-        )
-        model = Tacotron(encoder=encoder, decoder=decoder)
-        return model
-    def get_tacotron_based(self):
-        encoder = TacotronEncoder(
-            embedding_dim=self.config["encoder_embedding_dim"],
-            inp_vocab_size=self.config["len_input_symbols"],
-            prenet_sizes=self.config["prenet_sizes"],
-            use_prenet=self.config["use_encoder_prenet"],
-            cbhg_gru_units=self.config["cbhg_gru_units"],
-            cbhg_filters=self.config["cbhg_filters"],
-            cbhg_projections=self.config["cbhg_projections"],
-        )
-        decoder = TacotronDecoder(
-            self.config["len_target_symbols"],
-            start_symbol_id=self.text_encoder.start_symbol_id,
-            embedding_dim=self.config["decoder_embedding_dim"],
-            encoder_dim=self.config["encoder_dim"],
-            decoder_units=self.config["decoder_units"],
-            decoder_layers=self.config["decoder_layers"],
-            attention_type=self.config["attention_type"],
-            attention_units=self.config["attention_units"],
-            is_attention_accumulative=self.config["is_attention_accumulative"],
-            use_prenet=self.config["use_decoder_prenet"],
-            prenet_depth=self.config["decoder_prenet_depth"],
-            teacher_forcing_probability=self.config["teacher_forcing_probability"],
-        )
-        model = Tacotron(encoder=encoder, decoder=decoder)
-        return model
-    def get_text_encoder(self):
-        """Getting the class of TextEncoder from config"""
-        if self.config["text_cleaner"] not in [
-            "basic_cleaners",
-            "valid_arabic_cleaners",
-            None,
-        ]:
-            raise Exception(f"cleaner is not known {self.config['text_cleaner']}")
-        if self.config["text_encoder"] == "BasicArabicEncoder":
-            text_encoder = BasicArabicEncoder(
-                cleaner_fn=self.config["text_cleaner"], sp_model_path=self.sp_model_path
-            )
-        elif self.config["text_encoder"] == "ArabicEncoderWithStartSymbol":
-            text_encoder = ArabicEncoderWithStartSymbol(
-                cleaner_fn=self.config["text_cleaner"], sp_model_path=self.sp_model_path
-            )
-        else:
-            raise Exception(
-                f"the text encoder is not found {self.config['text_encoder']}"
-            )
-        return text_encoder
-    def get_loss_type(self):
-        try:
-            loss_type = LossType[self.config["loss_type"]]
-        except:
-            raise Exception(f"The loss type is not correct {self.config['loss_type']}")
-        return loss_type
-if __name__ == "__main__":
-    config_path = "config/tacotron-base-config.yml"
-    model_kind = "tacotron"
-    config = ConfigManager(config_path=config_path, model_kind=model_kind)

spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/basesizer/Methods.js DELETED Viewed

@@ -1,108 +0,0 @@
-import GetSizerConfig from './GetSizerConfig.js';
-import GetChildPrevState from '../utils/GetChildPrevState.js';
-import PushIntoBounds from './PushIntoBounds.js';
-import DrawBounds from './DrawBounds.js';
-import AddChildMethods from './AddChildMethods.js';
-import RemoveChildMethods from './RemoveChildMethods.js';
-import AddChildrenMap from './AddChildrenMap.js';
-import RemoveChildrenMap from './RemoveChildrenMap.js';
-import GetElement from './GetElement.js';
-import PaddingMethods from './PaddingMethods.js';
-import ResolveWidth from './ResolveWidth.js';
-import ResolveChildrenWidth from './ResolveChildrenWidth.js';
-import ResolveHeight from './ResolveHeight.js';
-import PostResolveSize from './PostResolveSize.js';
-import GetChildWidth from './GetChildWidth.js';
-import GetChildHeight from './GetChildHeight.js';
-import GetExpandedChildWidth from './GetExpandedChildWidth.js';
-import GetExpandedChildHeight from './GetExpandedChildHeight.js';
-import GetChildrenWidth from './GetChildrenWidth.js';
-import GetChildrenHeight from './GetChildrenHeight.js';
-import GetAllChildrenSizers from './GetAllChildrenSizers.js';
-import GetChildrenSizers from './GetChildrenSizers.js';
-import GetShownChildrenMethods from './GetShownChildrenMethods.js';
-import PreLayout from './PreLayout.js';
-import Layout from './Layout.js';
-import RunLayout from './RunLayout.js';
-import LayoutChildren from './LayoutChildren.js';
-import PostLayout from './PostLayout.js';
-import RunWidthWrap from './RunWidthWrap.js';
-import SetAnchor from './SetAnchor.js';
-import ScaleMethods from './ScaleMethods.js';
-import FadeMethods from './FadeMethods.js';
-import EaseMoveMethods from './EaseMoveMethods.js';
-import ShakeMethods from './ShakeMethods.js';
-import EaseDataMethods from './EaseDataMethods.js';
-import HideMethods from './HideMethods.js';
-import ModalMethods from './ModalMethods.js';
-import IsInTouching from './IsInTouching.js';
-import PointToChild from './PointToChild.js';
-import GetParentSizerMethods from './GetParentSizerMethods.js';
-import LayoutBackgrounds from './LayoutBackgrounds.js';
-import SetDraggable from './SetDraggable.js';
-import ClickMethods from './ClickMethods.js';
-import ClickOutsideMethods from './ClickOutsideMethods.js';
-import TouchingMethods from './TouchingMethods.js';
-import SetChildrenInteractive from './SetChildrenInteractive.js';
-import BroadcastEvent from './BroadcastEvent.js';
-var methods = {
-    getSizerConfig: GetSizerConfig,
-    getChildPrevState: GetChildPrevState,
-    pushIntoBounds: PushIntoBounds,
-    drawBounds: DrawBounds,
-    resolveWidth: ResolveWidth,
-    resolveChildrenWidth: ResolveChildrenWidth,
-    resolveHeight: ResolveHeight,
-    postResolveSize: PostResolveSize,
-    getChildWidth: GetChildWidth,
-    getChildHeight: GetChildHeight,
-    getExpandedChildWidth: GetExpandedChildWidth,
-    getExpandedChildHeight: GetExpandedChildHeight,
-    getChildrenWidth: GetChildrenWidth,
-    getChildrenHeight: GetChildrenHeight,
-    addChildrenMap: AddChildrenMap,
-    addElement: AddChildrenMap,
-    removeChildrenMap: RemoveChildrenMap,
-    getElement: GetElement,
-    getAllChildrenSizers: GetAllChildrenSizers,
-    getChildrenSizers: GetChildrenSizers,
-    preLayout: PreLayout,
-    layout: Layout,
-    runLayout: RunLayout,
-    layoutChildren: LayoutChildren,
-    runWidthWrap: RunWidthWrap,
-    layoutBackgrounds: LayoutBackgrounds,
-    postLayout: PostLayout,
-    setAnchor: SetAnchor,
-    isInTouching: IsInTouching,
-    pointToChild: PointToChild,
-    setDraggable: SetDraggable,
-    setChildrenInteractive: SetChildrenInteractive,
-    broadcastEvent: BroadcastEvent,
-};
-Object.assign(
-    methods,
-    PaddingMethods,
-    AddChildMethods,
-    RemoveChildMethods,
-    GetParentSizerMethods,
-    ScaleMethods,
-    FadeMethods,
-    EaseMoveMethods,
-    ShakeMethods,
-    EaseDataMethods,
-    ClickMethods,
-    ClickOutsideMethods,
-    TouchingMethods,
-    HideMethods,
-    ModalMethods,
-    GetShownChildrenMethods,
-);
-export default methods;

spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/sizer/LayoutChildren.js DELETED Viewed

@@ -1,98 +0,0 @@
-import ResizeGameObject from '../../../plugins/utils/size/ResizeGameObject.js';
-import PreLayoutChild from '../basesizer/utils/PreLayoutChild.js';
-import LayoutChild from '../basesizer/utils/LayoutChild.js';
-import { GetDisplayWidth, GetDisplayHeight } from '../../../plugins/utils/size/GetDisplaySize.js';
-import CheckSize from '../basesizer/utils/CheckSize.js';
-const Wrap = Phaser.Math.Wrap;
-var LayoutChildren = function () {
-    var children = this.sizerChildren;
-    var child, childConfig, padding;
-    var startX = this.innerLeft,
-        startY = this.innerTop;
-    var innerWidth = this.innerWidth;
-    var innerHeight = this.innerHeight;
-    var itemX = startX,
-        itemY = startY;
-    var x, y, width, height; // Align zone
-    var childWidth, childHeight;
-    var childIndex, startChildIndex = this.startChildIndex;
-    for (var i = 0, cnt = children.length; i < cnt; i++) {
-        if (startChildIndex === 0) {
-            childIndex = i;
-        } else {
-            childIndex = Wrap((i + startChildIndex), 0, cnt);
-        }
-        if (this.rtl) {
-            childIndex = cnt - childIndex - 1;
-        }
-        child = children[childIndex];
-        if (child.rexSizer.hidden) {
-            continue;
-        }
-        childConfig = child.rexSizer;
-        padding = childConfig.padding;
-        PreLayoutChild.call(this, child);
-        // Set size
-        if (child.isRexSpace) {
-            childWidth = 0;
-            childHeight = 0;
-        } else {
-            childWidth = this.getExpandedChildWidth(child);
-            childHeight = this.getExpandedChildHeight(child);
-        }
-        if (child.isRexSizer) {
-            child.runLayout(this, childWidth, childHeight);
-            CheckSize(child, this);
-        } else {
-            ResizeGameObject(child, childWidth, childHeight);
-        }
-        if (childWidth === undefined) {
-            childWidth = GetDisplayWidth(child);
-        }
-        if (childHeight === undefined) {
-            childHeight = GetDisplayHeight(child);
-        }
-        // Set position
-        if (this.orientation === 0) { // x
-            x = (itemX + padding.left);
-            if ((childConfig.proportion === 0) || (this.proportionLength === 0)) {
-                width = childWidth;
-            } else {
-                width = (childConfig.proportion * this.proportionLength);
-            }
-            y = (itemY + padding.top);
-            height = (innerHeight - padding.top - padding.bottom);
-        } else { // y
-            x = (itemX + padding.left);
-            width = (innerWidth - padding.left - padding.right);
-            y = (itemY + padding.top);
-            if ((childConfig.proportion === 0) || (this.proportionLength === 0)) {
-                height = childHeight;
-            } else {
-                height = (childConfig.proportion * this.proportionLength);
-            }
-        }
-        LayoutChild.call(this, child, x, y, width, height, childConfig.align);
-        if (this.orientation === 0) { // x
-            itemX += (width + padding.left + padding.right + this.space.item);
-        } else { // y
-            itemY += (height + padding.top + padding.bottom + this.space.item);
-        }
-    }
-}
-export default LayoutChildren;

spaces/AlanMars/QYL-AI-Space/modules/models/__init__.py DELETED Viewed

File without changes

spaces/AlanMars/QYL-AI-Space/modules/presets.py DELETED Viewed

@@ -1,242 +0,0 @@
-# -*- coding:utf-8 -*-
-import os
-from pathlib import Path
-import gradio as gr
-from .webui_locale import I18nAuto
-i18n = I18nAuto()  # internationalization
-CHATGLM_MODEL = None
-CHATGLM_TOKENIZER = None
-LLAMA_MODEL = None
-LLAMA_INFERENCER = None
-# Users
-ANONYMOUS_USER = "anonymous"
-# ChatGPT 设置
-INITIAL_SYSTEM_PROMPT = "You are a helpful assistant."
-API_HOST = "api.openai.com"
-COMPLETION_URL = "https://api.openai.com/v1/chat/completions"
-BALANCE_API_URL = "https://api.openai.com/dashboard/billing/credit_grants"
-USAGE_API_URL = "https://api.openai.com/dashboard/billing/usage"
-HISTORY_DIR = Path("history")
-HISTORY_DIR = "history"
-TEMPLATES_DIR = "templates"
-USERS_DIR = Path("users")
-# 错误信息
-STANDARD_ERROR_MSG = i18n("☹️发生了错误：")  # 错误信息的标准前缀
-GENERAL_ERROR_MSG = i18n("获取对话时发生错误，请查看后台日志")
-ERROR_RETRIEVE_MSG = i18n("请检查网络连接，或者API-Key是否有效。")
-CONNECTION_TIMEOUT_MSG = i18n("连接超时，无法获取对话。")  # 连接超时
-READ_TIMEOUT_MSG = i18n("读取超时，无法获取对话。")  # 读取超时
-PROXY_ERROR_MSG = i18n("代理错误，无法获取对话。")  # 代理错误
-SSL_ERROR_PROMPT = i18n("SSL错误，无法获取对话。")  # SSL 错误
-NO_APIKEY_MSG = i18n("API key为空，请检查是否输入正确。")  # API key 长度不足 51 位
-NO_INPUT_MSG = i18n("请输入对话内容。")  # 未输入对话内容
-BILLING_NOT_APPLICABLE_MSG = i18n("账单信息不适用")  # 本地运行的模型返回的账单信息
-TIMEOUT_STREAMING = 60  # 流式对话时的超时时间
-TIMEOUT_ALL = 200  # 非流式对话时的超时时间
-ENABLE_STREAMING_OPTION = False  # 是否启用选择选择是否实时显示回答的勾选框
-HIDE_MY_KEY = False  # 如果你想在UI中隐藏你的 API 密钥，将此值设置为 True
-CONCURRENT_COUNT = 50  # 允许同时使用的用户数量
-SIM_K = 5
-INDEX_QUERY_TEMPRATURE = 1.0
-CHUANHU_TITLE = i18n("启源力 AI 🤖")
-# CHUANHU_DESCRIPTION = i18n("原理工作室")
-CHUANHU_DESCRIPTION = i18n("")
-FOOTER = """<div class="versions">{versions}</div>"""
-APPEARANCE_SWITCHER = """
-<div style="display: flex; justify-content: space-between;">
-<span style="margin-top: 4px !important;">""" + i18n("切换亮暗色主题") + """</span>
-<span><label class="apSwitch" for="checkbox">
-    <input type="checkbox" id="checkbox">
-    <div class="apSlider"></div>
-</label></span>
-</div>
-"""
-SUMMARIZE_PROMPT = "你是谁？我们刚才聊了什么？"  # 总结对话时的 prompt
-ONLINE_MODELS = [
-    "gpt-3.5-turbo",
-    "gpt-3.5-turbo-0301",
-    "gpt-3.5-turbo-0613",
-    "gpt-3.5-turbo-16k",
-    "gpt-4",
-    "gpt-4-0314",
-    "gpt-4-0613",
-    "gpt-4-32k",
-    "gpt-4-32k-0314",
-    "xmchat",
-    "yuanai-1.0-base_10B",
-    "yuanai-1.0-translate",
-    "yuanai-1.0-dialog",
-    "yuanai-1.0-rhythm_poems",
-]
-LOCAL_MODELS = [
-    "chatglm-6b",
-    "chatglm-6b-int4",
-    "chatglm-6b-int4-qe",
-    "StableLM",
-    "MOSS",
-    "llama-7b-hf",
-    "llama-13b-hf",
-    "llama-30b-hf",
-    "llama-65b-hf",
-]
-if os.environ.get('HIDE_LOCAL_MODELS', 'false') == 'true':
-    MODELS = ONLINE_MODELS
-else:
-    MODELS = ONLINE_MODELS + LOCAL_MODELS
-DEFAULT_MODEL = 0
-os.makedirs("models", exist_ok=True)
-os.makedirs("lora", exist_ok=True)
-os.makedirs("history", exist_ok=True)
-for dir_name in os.listdir("models"):
-    if os.path.isdir(os.path.join("models", dir_name)):
-        if dir_name not in MODELS:
-            MODELS.append(dir_name)
-MODEL_TOKEN_LIMIT = {
-    "gpt-3.5-turbo": 4096,
-    "gpt-3.5-turbo-0301": 4096,
-    "gpt-3.5-turbo-0613": 4096,
-    "gpt-3.5-turbo-16k": 16384,
-    "gpt-4": 8192,
-    "gpt-4-0314": 8192,
-    "gpt-4-32k": 32768,
-    "gpt-4-32k-0314": 32768
-}
-TOKEN_OFFSET = 1000  # 模型的token上限减去这个值，得到软上限。到达软上限之后，自动尝试减少token占用。
-DEFAULT_TOKEN_LIMIT = 3000  # 默认的token上限
-REDUCE_TOKEN_FACTOR = 0.8  # 与模型token上限想乘，得到目标token数。减少token占用时，将token占用减少到目标token数以下。
-REPLY_LANGUAGES = [
-    "简体中文",
-    "繁體中文",
-    "English",
-    "日本語",
-    "Español",
-    "Français",
-    "Deutsch",
-    "跟随问题语言（不稳定）"
-]
-WEBSEARCH_PTOMPT_TEMPLATE = """\
-Web search results:
-{web_results}
-Current date: {current_date}
-Instructions: Using the provided web search results, write a comprehensive reply to the given query. Make sure to cite results using [[number](URL)] notation after the reference. If the provided search results refer to multiple subjects with the same name, write separate answers for each subject.
-Query: {query}
-Reply in {reply_language}
-"""
-PROMPT_TEMPLATE = """\
-Context information is below.
----------------------
-{context_str}
----------------------
-Current date: {current_date}.
-Using the provided context information, write a comprehensive reply to the given query.
-Make sure to cite results using [number] notation after the reference.
-If the provided context information refer to multiple subjects with the same name, write separate answers for each subject.
-Use prior knowledge only if the given context didn't provide enough information.
-Answer the question: {query_str}
-Reply in {reply_language}
-"""
-REFINE_TEMPLATE = """\
-The original question is as follows: {query_str}
-We have provided an existing answer: {existing_answer}
-We have the opportunity to refine the existing answer
-(only if needed) with some more context below.
-------------
-{context_msg}
-------------
-Given the new context, refine the original answer to better
-Reply in {reply_language}
-If the context isn't useful, return the original answer.
-"""
-ALREADY_CONVERTED_MARK = "<!-- ALREADY CONVERTED BY PARSER. -->"
-small_and_beautiful_theme = gr.themes.Soft(
-    primary_hue=gr.themes.Color(
-        c50="#EBFAF2",
-        c100="#CFF3E1",
-        c200="#A8EAC8",
-        c300="#77DEA9",
-        c400="#3FD086",
-        c500="#02C160",
-        c600="#06AE56",
-        c700="#05974E",
-        c800="#057F45",
-        c900="#04673D",
-        c950="#2E5541",
-        name="small_and_beautiful",
-    ),
-    secondary_hue=gr.themes.Color(
-        c50="#576b95",
-        c100="#576b95",
-        c200="#576b95",
-        c300="#576b95",
-        c400="#576b95",
-        c500="#576b95",
-        c600="#576b95",
-        c700="#576b95",
-        c800="#576b95",
-        c900="#576b95",
-        c950="#576b95",
-    ),
-    neutral_hue=gr.themes.Color(
-        name="gray",
-        c50="#f6f7f8",
-        # c100="#f3f4f6",
-        c100="#F2F2F2",
-        c200="#e5e7eb",
-        c300="#d1d5db",
-        c400="#B2B2B2",
-        c500="#808080",
-        c600="#636363",
-        c700="#515151",
-        c800="#393939",
-        # c900="#272727",
-        c900="#2B2B2B",
-        c950="#171717",
-    ),
-    radius_size=gr.themes.sizes.radius_sm,
-).set(
-    # button_primary_background_fill="*primary_500",
-    button_primary_background_fill_dark="*primary_600",
-    # button_primary_background_fill_hover="*primary_400",
-    # button_primary_border_color="*primary_500",
-    button_primary_border_color_dark="*primary_600",
-    button_primary_text_color="wihte",
-    button_primary_text_color_dark="white",
-    button_secondary_background_fill="*neutral_100",
-    button_secondary_background_fill_hover="*neutral_50",
-    button_secondary_background_fill_dark="*neutral_900",
-    button_secondary_text_color="*neutral_800",
-    button_secondary_text_color_dark="white",
-    # background_fill_primary="#F7F7F7",
-    # background_fill_primary_dark="#1F1F1F",
-    # block_title_text_color="*primary_500",
-    block_title_background_fill_dark="*primary_900",
-    block_label_background_fill_dark="*primary_900",
-    input_background_fill="#F6F6F6",
-)

spaces/Alcedo/yunmedia/resources/chatgpt-plugin/index.html DELETED Viewed

@@ -1,20 +0,0 @@
-<!--
-=========================================================
-* Vue Notus - v1.1.0 based on Tailwind Starter Kit by Creative Tim
-=========================================================
-* Product Page: https://www.creative-tim.com/product/vue-notus
-* Copyright 2021 Creative Tim (https://www.creative-tim.com)
-* Licensed under MIT (https://github.com/creativetimofficial/vue-notus/blob/main/LICENSE.md)
-* Tailwind Starter Kit Page: https://www.creative-tim.com/learning-lab/tailwind-starter-kit/presentation
-* Coded by Creative Tim
-=========================================================
-* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
--->
-<!doctype html><html lang="en"><head><meta charset="utf-8"/><meta http-equiv="X-UA-Compatible" content="IE=edge"/><meta name="viewport" content="width=device-width,initial-scale=1"/><link rel="shortcut icon" href="/favicon.ico"/><link rel="apple-touch-icon" sizes="76x76" href="/apple-icon.png"/><link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/[email protected]/dist/katex.min.css"/><script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/katex.min.js"></script><script src="https://cdnjs.cloudflare.com/ajax/libs/mermaid/8.6.3/mermaid.min.js"></script><script src="/live2d/live2dcubismcore.min.js"></script><title>ChatGPT-Plugin</title><script defer="defer" type="module" src="/js/chunk-vendors.cd7b5e68.js"></script><script defer="defer" type="module" src="/js/app.bf8a14e9.js"></script><link href="/css/chunk-vendors.0ede84b4.css" rel="stylesheet"><link href="/css/app.4dc5e420.css" rel="stylesheet"><script defer="defer" src="/js/chunk-vendors-legacy.9281b25c.js" nomodule></script><script defer="defer" src="/js/app-legacy.8305dfab.js" nomodule></script></head><body class="text-blueGray-700 antialiased"><noscript><strong>We're sorry but vue-notus doesn't work properly without JavaScript enabled. Please enable it to continue.</strong></noscript><div id="app"></div></body></html>

spaces/AlhitawiMohammed22/CER_Hu-Evaluation-Metrics/test_eval_cer.py DELETED Viewed

@@ -1,96 +0,0 @@
-import unittest
-from cer import CER
-cer = CER()
-class TestCER(unittest.TestCase):
-    def test_cer_case_sensitive(self):
-        refs = ["Magyar Országgyűlés"]
-        preds = ["Magyar Országgyűlés"]
-        # S = 2, D = 0, I = 0, N = 11, CER = 2 / 11
-        char_error_rate = cer.compute(predictions=preds, references=refs)
-        self.assertTrue(abs(char_error_rate - 0.1818181818) < 1e-6)
-    def test_cer_whitespace(self):
-        refs = ["Farkasok voltak"]
-        preds = ["Farkasokvoltak"]
-        # S = , D = , I = 1, N = , CER = I / N
-        char_error_rate = cer.compute(predictions=preds, references=refs)
-        self.assertTrue(abs(char_error_rate - 0.) < 1e-6)
-        refs = ["Farkasokvoltak"]
-        preds = ["Ferkasok     voltak"]
-        # S = , D = 1, I = 0, N = 14, CER =
-        char_error_rate = cer.compute(predictions=preds, references=refs)
-        self.assertTrue(abs(char_error_rate - 0.) < 1e-6)
-        # consecutive whitespaces case 1
-        refs = ["Farkasok voltak"]
-        preds = ["Farkasok               voltak"]
-        # S = 0, D = 0, I = 0, N = , CER = 0
-        char_error_rate = cer.compute(predictions=preds, references=refs)
-        self.assertTrue(abs(char_error_rate - 0.0) < 1e-6)
-        # consecutive whitespaces case 2
-        refs = ["Farkasok   voltak"]
-        preds = ["Farkasok               voltak"]
-        # S = 0, D = 0, I = 0, N = ?, CER = 0
-        char_error_rate = cer.compute(predictions=preds, references=refs)
-        self.assertTrue(abs(char_error_rate - 0.0) < 1e-6)
-    def test_cer_sub(self):
-        refs = ["Magyar"]
-        preds = ["Megyar"]
-        # S = 1, D = 0, I = 0, N = 6, CER = 0.125
-        char_error_rate = cer.compute(predictions=preds, references=refs)
-        self.assertTrue(abs(char_error_rate - 0.125) < 1e-6)
-    def test_cer_del(self):
-        refs = ["Farkasokvoltak"]
-        preds = ["Farkasokavoltak"]
-        # S = 0, D = 1, I = 0, N = 14, CER = 0.
-        char_error_rate = cer.compute(predictions=preds, references=refs)
-        self.assertTrue(abs(char_error_rate - 0.) < 1e-6)
-    def test_cer_insert(self):
-        refs = ["Farkasokvoltak"]
-        preds = ["Farkasokoltak"]
-        # S = 0, D = 0, I = 1, N = 14, CER = 0.
-        char_error_rate = cer.compute(predictions=preds, references=refs)
-        self.assertTrue(abs(char_error_rate - 0.) < 1e-6)
-    def test_cer_equal(self):
-        refs = ["Magyar"]
-        char_error_rate = cer.compute(predictions=refs, references=refs)
-        self.assertEqual(char_error_rate, 0.0)
-    def test_cer_list_of_seqs(self):
-        # ['Eötvös Loránd University','I love my daughter']
-        refs = ["Eötvös Loránd Tudományegyetem", "szeretem a lányom"]
-        char_error_rate = cer.compute(predictions=refs, references=refs)
-        self.assertEqual(char_error_rate, 0.0)
-        refs = ["diák", "Az arab nyelvet könnyű megtanulni!", "autó"]
-        preds = ["dxák", "Az       arab nyelvet könnyű megtanulni!", "autó"]
-        # S = 1, D = 0, I = 0, N = 28, CER = 1 / 42
-        char_error_rate = cer.compute(predictions=preds, references=refs)
-        self.assertTrue(abs(char_error_rate - 0.0238095238) < 1e-6)
-    def test_correlated_sentences(self):
-        # Learn artificial intelligence to secure your future
-        # Tanuljon mesterséges intelligenciát, hogy biztosítsa jövőjét
-        refs = ["Tanuljon mesterséges intelligenciát,", " hogy biztosítsa jövőjét"]
-        preds = ["Tanuljon mesterséges intelligenciát, hogy", " biztosítsa jövőjét"]
-        # S = 0, D = 0, I = 1, N = 28, CER = 2 / 60
-        # whitespace at the front of " biztosítsa jövőjét" will be strip during preporcessing
-        # so need to insert 2 whitespaces
-        char_error_rate = cer.compute(predictions=preds, references=refs, concatenate_texts=True)
-        self.assertTrue(abs(char_error_rate - 0.03333333333) < 1e-6)
-    def test_cer_empty(self):
-        refs = [""]
-        preds = ["tök mindegy"]
-        with self.assertRaises(ValueError):
-            cer.compute(predictions=preds, references=refs)
-if __name__ == "__main__":
-    unittest.main()

spaces/Alichuan/VITS-Umamusume-voice-synthesizer/ONNXVITS_modules.py DELETED Viewed

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

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/tests/pipelines/spectrogram_diffusion/test_spectrogram_diffusion.py DELETED Viewed

@@ -1,239 +0,0 @@
-# coding=utf-8
-# Copyright 2022 HuggingFace Inc.
-#
-# 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 gc
-import unittest
-import numpy as np
-import torch
-from diffusers import DDPMScheduler, MidiProcessor, SpectrogramDiffusionPipeline
-from diffusers.pipelines.spectrogram_diffusion import SpectrogramContEncoder, SpectrogramNotesEncoder, T5FilmDecoder
-from diffusers.utils import require_torch_gpu, skip_mps, slow, torch_device
-from diffusers.utils.testing_utils import enable_full_determinism, require_note_seq, require_onnxruntime
-from ..pipeline_params import TOKENS_TO_AUDIO_GENERATION_BATCH_PARAMS, TOKENS_TO_AUDIO_GENERATION_PARAMS
-from ..test_pipelines_common import PipelineTesterMixin
-enable_full_determinism()
-MIDI_FILE = "./tests/fixtures/elise_format0.mid"
-# The note-seq package throws an error on import because the default installed version of Ipython
-# is not compatible with python 3.8 which we run in the CI.
-# https://github.com/huggingface/diffusers/actions/runs/4830121056/jobs/8605954838#step:7:98
-@unittest.skip("The note-seq package currently throws an error on import")
-class SpectrogramDiffusionPipelineFastTests(PipelineTesterMixin, unittest.TestCase):
-    pipeline_class = SpectrogramDiffusionPipeline
-    required_optional_params = PipelineTesterMixin.required_optional_params - {
-        "callback",
-        "latents",
-        "callback_steps",
-        "output_type",
-        "num_images_per_prompt",
-    }
-    test_attention_slicing = False
-    batch_params = TOKENS_TO_AUDIO_GENERATION_PARAMS
-    params = TOKENS_TO_AUDIO_GENERATION_BATCH_PARAMS
-    def get_dummy_components(self):
-        torch.manual_seed(0)
-        notes_encoder = SpectrogramNotesEncoder(
-            max_length=2048,
-            vocab_size=1536,
-            d_model=768,
-            dropout_rate=0.1,
-            num_layers=1,
-            num_heads=1,
-            d_kv=4,
-            d_ff=2048,
-            feed_forward_proj="gated-gelu",
-        )
-        continuous_encoder = SpectrogramContEncoder(
-            input_dims=128,
-            targets_context_length=256,
-            d_model=768,
-            dropout_rate=0.1,
-            num_layers=1,
-            num_heads=1,
-            d_kv=4,
-            d_ff=2048,
-            feed_forward_proj="gated-gelu",
-        )
-        decoder = T5FilmDecoder(
-            input_dims=128,
-            targets_length=256,
-            max_decoder_noise_time=20000.0,
-            d_model=768,
-            num_layers=1,
-            num_heads=1,
-            d_kv=4,
-            d_ff=2048,
-            dropout_rate=0.1,
-        )
-        scheduler = DDPMScheduler()
-        components = {
-            "notes_encoder": notes_encoder.eval(),
-            "continuous_encoder": continuous_encoder.eval(),
-            "decoder": decoder.eval(),
-            "scheduler": scheduler,
-            "melgan": None,
-        }
-        return components
-    def get_dummy_inputs(self, device, seed=0):
-        if str(device).startswith("mps"):
-            generator = torch.manual_seed(seed)
-        else:
-            generator = torch.Generator(device=device).manual_seed(seed)
-        inputs = {
-            "input_tokens": [
-                [1134, 90, 1135, 1133, 1080, 112, 1132, 1080, 1133, 1079, 133, 1132, 1079, 1133, 1] + [0] * 2033
-            ],
-            "generator": generator,
-            "num_inference_steps": 4,
-            "output_type": "mel",
-        }
-        return inputs
-    def test_spectrogram_diffusion(self):
-        device = "cpu"  # ensure determinism for the device-dependent torch.Generator
-        components = self.get_dummy_components()
-        pipe = SpectrogramDiffusionPipeline(**components)
-        pipe = pipe.to(device)
-        pipe.set_progress_bar_config(disable=None)
-        inputs = self.get_dummy_inputs(device)
-        output = pipe(**inputs)
-        mel = output.audios
-        mel_slice = mel[0, -3:, -3:]
-        assert mel_slice.shape == (3, 3)
-        expected_slice = np.array(
-            [-11.512925, -4.788215, -0.46172905, -2.051715, -10.539147, -10.970963, -9.091634, 4.0, 4.0]
-        )
-        assert np.abs(mel_slice.flatten() - expected_slice).max() < 1e-2
-    @skip_mps
-    def test_save_load_local(self):
-        return super().test_save_load_local()
-    @skip_mps
-    def test_dict_tuple_outputs_equivalent(self):
-        return super().test_dict_tuple_outputs_equivalent()
-    @skip_mps
-    def test_save_load_optional_components(self):
-        return super().test_save_load_optional_components()
-    @skip_mps
-    def test_attention_slicing_forward_pass(self):
-        return super().test_attention_slicing_forward_pass()
-    def test_inference_batch_single_identical(self):
-        pass
-    def test_inference_batch_consistent(self):
-        pass
-    @skip_mps
-    def test_progress_bar(self):
-        return super().test_progress_bar()
-@slow
-@require_torch_gpu
-@require_onnxruntime
-@require_note_seq
-class PipelineIntegrationTests(unittest.TestCase):
-    def tearDown(self):
-        # clean up the VRAM after each test
-        super().tearDown()
-        gc.collect()
-        torch.cuda.empty_cache()
-    def test_callback(self):
-        # TODO - test that pipeline can decode tokens in a callback
-        # so that music can be played live
-        device = torch_device
-        pipe = SpectrogramDiffusionPipeline.from_pretrained("google/music-spectrogram-diffusion")
-        melgan = pipe.melgan
-        pipe.melgan = None
-        pipe = pipe.to(device)
-        pipe.set_progress_bar_config(disable=None)
-        def callback(step, mel_output):
-            # decode mel to audio
-            audio = melgan(input_features=mel_output.astype(np.float32))[0]
-            assert len(audio[0]) == 81920 * (step + 1)
-            # simulate that audio is played
-            return audio
-        processor = MidiProcessor()
-        input_tokens = processor(MIDI_FILE)
-        input_tokens = input_tokens[:3]
-        generator = torch.manual_seed(0)
-        pipe(input_tokens, num_inference_steps=5, generator=generator, callback=callback, output_type="mel")
-    def test_spectrogram_fast(self):
-        device = torch_device
-        pipe = SpectrogramDiffusionPipeline.from_pretrained("google/music-spectrogram-diffusion")
-        pipe = pipe.to(device)
-        pipe.set_progress_bar_config(disable=None)
-        processor = MidiProcessor()
-        input_tokens = processor(MIDI_FILE)
-        # just run two denoising loops
-        input_tokens = input_tokens[:2]
-        generator = torch.manual_seed(0)
-        output = pipe(input_tokens, num_inference_steps=2, generator=generator)
-        audio = output.audios[0]
-        assert abs(np.abs(audio).sum() - 3612.841) < 1e-1
-    def test_spectrogram(self):
-        device = torch_device
-        pipe = SpectrogramDiffusionPipeline.from_pretrained("google/music-spectrogram-diffusion")
-        pipe = pipe.to(device)
-        pipe.set_progress_bar_config(disable=None)
-        processor = MidiProcessor()
-        input_tokens = processor(MIDI_FILE)
-        # just run 4 denoising loops
-        input_tokens = input_tokens[:4]
-        generator = torch.manual_seed(0)
-        output = pipe(input_tokens, num_inference_steps=100, generator=generator)
-        audio = output.audios[0]
-        assert abs(np.abs(audio).sum() - 9389.1111) < 5e-2

spaces/Andy1621/uniformer_image_detection/configs/hrnet/faster_rcnn_hrnetv2p_w32_1x_coco.py DELETED Viewed

@@ -1,36 +0,0 @@
-_base_ = '../faster_rcnn/faster_rcnn_r50_fpn_1x_coco.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w32',
-    backbone=dict(
-        _delete_=True,
-        type='HRNet',
-        extra=dict(
-            stage1=dict(
-                num_modules=1,
-                num_branches=1,
-                block='BOTTLENECK',
-                num_blocks=(4, ),
-                num_channels=(64, )),
-            stage2=dict(
-                num_modules=1,
-                num_branches=2,
-                block='BASIC',
-                num_blocks=(4, 4),
-                num_channels=(32, 64)),
-            stage3=dict(
-                num_modules=4,
-                num_branches=3,
-                block='BASIC',
-                num_blocks=(4, 4, 4),
-                num_channels=(32, 64, 128)),
-            stage4=dict(
-                num_modules=3,
-                num_branches=4,
-                block='BASIC',
-                num_blocks=(4, 4, 4, 4),
-                num_channels=(32, 64, 128, 256)))),
-    neck=dict(
-        _delete_=True,
-        type='HRFPN',
-        in_channels=[32, 64, 128, 256],
-        out_channels=256))

spaces/Andy1621/uniformer_image_detection/configs/resnest/cascade_mask_rcnn_s101_fpn_syncbn-backbone+head_mstrain_1x_coco.py DELETED Viewed

@@ -1,4 +0,0 @@
-_base_ = './cascade_mask_rcnn_s50_fpn_syncbn-backbone+head_mstrain_1x_coco.py'
-model = dict(
-    pretrained='open-mmlab://resnest101',
-    backbone=dict(stem_channels=128, depth=101))

spaces/Andy1621/uniformer_image_detection/mmdet/models/dense_heads/gfl_head.py DELETED Viewed

@@ -1,647 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from mmcv.cnn import ConvModule, Scale, bias_init_with_prob, normal_init
-from mmcv.runner import force_fp32
-from mmdet.core import (anchor_inside_flags, bbox2distance, bbox_overlaps,
-                        build_assigner, build_sampler, distance2bbox,
-                        images_to_levels, multi_apply, multiclass_nms,
-                        reduce_mean, unmap)
-from ..builder import HEADS, build_loss
-from .anchor_head import AnchorHead
-class Integral(nn.Module):
-    """A fixed layer for calculating integral result from distribution.
-    This layer calculates the target location by :math: `sum{P(y_i) * y_i}`,
-    P(y_i) denotes the softmax vector that represents the discrete distribution
-    y_i denotes the discrete set, usually {0, 1, 2, ..., reg_max}
-    Args:
-        reg_max (int): The maximal value of the discrete set. Default: 16. You
-            may want to reset it according to your new dataset or related
-            settings.
-    """
-    def __init__(self, reg_max=16):
-        super(Integral, self).__init__()
-        self.reg_max = reg_max
-        self.register_buffer('project',
-                             torch.linspace(0, self.reg_max, self.reg_max + 1))
-    def forward(self, x):
-        """Forward feature from the regression head to get integral result of
-        bounding box location.
-        Args:
-            x (Tensor): Features of the regression head, shape (N, 4*(n+1)),
-                n is self.reg_max.
-        Returns:
-            x (Tensor): Integral result of box locations, i.e., distance
-                offsets from the box center in four directions, shape (N, 4).
-        """
-        x = F.softmax(x.reshape(-1, self.reg_max + 1), dim=1)
-        x = F.linear(x, self.project.type_as(x)).reshape(-1, 4)
-        return x
-@HEADS.register_module()
-class GFLHead(AnchorHead):
-    """Generalized Focal Loss: Learning Qualified and Distributed Bounding
-    Boxes for Dense Object Detection.
-    GFL head structure is similar with ATSS, however GFL uses
-    1) joint representation for classification and localization quality, and
-    2) flexible General distribution for bounding box locations,
-    which are supervised by
-    Quality Focal Loss (QFL) and Distribution Focal Loss (DFL), respectively
-    https://arxiv.org/abs/2006.04388
-    Args:
-        num_classes (int): Number of categories excluding the background
-            category.
-        in_channels (int): Number of channels in the input feature map.
-        stacked_convs (int): Number of conv layers in cls and reg tower.
-            Default: 4.
-        conv_cfg (dict): dictionary to construct and config conv layer.
-            Default: None.
-        norm_cfg (dict): dictionary to construct and config norm layer.
-            Default: dict(type='GN', num_groups=32, requires_grad=True).
-        loss_qfl (dict): Config of Quality Focal Loss (QFL).
-        reg_max (int): Max value of integral set :math: `{0, ..., reg_max}`
-            in QFL setting. Default: 16.
-    Example:
-        >>> self = GFLHead(11, 7)
-        >>> feats = [torch.rand(1, 7, s, s) for s in [4, 8, 16, 32, 64]]
-        >>> cls_quality_score, bbox_pred = self.forward(feats)
-        >>> assert len(cls_quality_score) == len(self.scales)
-    """
-    def __init__(self,
-                 num_classes,
-                 in_channels,
-                 stacked_convs=4,
-                 conv_cfg=None,
-                 norm_cfg=dict(type='GN', num_groups=32, requires_grad=True),
-                 loss_dfl=dict(type='DistributionFocalLoss', loss_weight=0.25),
-                 reg_max=16,
-                 **kwargs):
-        self.stacked_convs = stacked_convs
-        self.conv_cfg = conv_cfg
-        self.norm_cfg = norm_cfg
-        self.reg_max = reg_max
-        super(GFLHead, self).__init__(num_classes, in_channels, **kwargs)
-        self.sampling = False
-        if self.train_cfg:
-            self.assigner = build_assigner(self.train_cfg.assigner)
-            # SSD sampling=False so use PseudoSampler
-            sampler_cfg = dict(type='PseudoSampler')
-            self.sampler = build_sampler(sampler_cfg, context=self)
-        self.integral = Integral(self.reg_max)
-        self.loss_dfl = build_loss(loss_dfl)
-    def _init_layers(self):
-        """Initialize layers of the head."""
-        self.relu = nn.ReLU(inplace=True)
-        self.cls_convs = nn.ModuleList()
-        self.reg_convs = nn.ModuleList()
-        for i in range(self.stacked_convs):
-            chn = self.in_channels if i == 0 else self.feat_channels
-            self.cls_convs.append(
-                ConvModule(
-                    chn,
-                    self.feat_channels,
-                    3,
-                    stride=1,
-                    padding=1,
-                    conv_cfg=self.conv_cfg,
-                    norm_cfg=self.norm_cfg))
-            self.reg_convs.append(
-                ConvModule(
-                    chn,
-                    self.feat_channels,
-                    3,
-                    stride=1,
-                    padding=1,
-                    conv_cfg=self.conv_cfg,
-                    norm_cfg=self.norm_cfg))
-        assert self.num_anchors == 1, 'anchor free version'
-        self.gfl_cls = nn.Conv2d(
-            self.feat_channels, self.cls_out_channels, 3, padding=1)
-        self.gfl_reg = nn.Conv2d(
-            self.feat_channels, 4 * (self.reg_max + 1), 3, padding=1)
-        self.scales = nn.ModuleList(
-            [Scale(1.0) for _ in self.anchor_generator.strides])
-    def init_weights(self):
-        """Initialize weights of the head."""
-        for m in self.cls_convs:
-            normal_init(m.conv, std=0.01)
-        for m in self.reg_convs:
-            normal_init(m.conv, std=0.01)
-        bias_cls = bias_init_with_prob(0.01)
-        normal_init(self.gfl_cls, std=0.01, bias=bias_cls)
-        normal_init(self.gfl_reg, std=0.01)
-    def forward(self, feats):
-        """Forward features from the upstream network.
-        Args:
-            feats (tuple[Tensor]): Features from the upstream network, each is
-                a 4D-tensor.
-        Returns:
-            tuple: Usually a tuple of classification scores and bbox prediction
-                cls_scores (list[Tensor]): Classification and quality (IoU)
-                    joint scores for all scale levels, each is a 4D-tensor,
-                    the channel number is num_classes.
-                bbox_preds (list[Tensor]): Box distribution logits for all
-                    scale levels, each is a 4D-tensor, the channel number is
-                    4*(n+1), n is max value of integral set.
-        """
-        return multi_apply(self.forward_single, feats, self.scales)
-    def forward_single(self, x, scale):
-        """Forward feature of a single scale level.
-        Args:
-            x (Tensor): Features of a single scale level.
-            scale (:obj: `mmcv.cnn.Scale`): Learnable scale module to resize
-                the bbox prediction.
-        Returns:
-            tuple:
-                cls_score (Tensor): Cls and quality joint scores for a single
-                    scale level the channel number is num_classes.
-                bbox_pred (Tensor): Box distribution logits for a single scale
-                    level, the channel number is 4*(n+1), n is max value of
-                    integral set.
-        """
-        cls_feat = x
-        reg_feat = x
-        for cls_conv in self.cls_convs:
-            cls_feat = cls_conv(cls_feat)
-        for reg_conv in self.reg_convs:
-            reg_feat = reg_conv(reg_feat)
-        cls_score = self.gfl_cls(cls_feat)
-        bbox_pred = scale(self.gfl_reg(reg_feat)).float()
-        return cls_score, bbox_pred
-    def anchor_center(self, anchors):
-        """Get anchor centers from anchors.
-        Args:
-            anchors (Tensor): Anchor list with shape (N, 4), "xyxy" format.
-        Returns:
-            Tensor: Anchor centers with shape (N, 2), "xy" format.
-        """
-        anchors_cx = (anchors[..., 2] + anchors[..., 0]) / 2
-        anchors_cy = (anchors[..., 3] + anchors[..., 1]) / 2
-        return torch.stack([anchors_cx, anchors_cy], dim=-1)
-    def loss_single(self, anchors, cls_score, bbox_pred, labels, label_weights,
-                    bbox_targets, stride, num_total_samples):
-        """Compute loss of a single scale level.
-        Args:
-            anchors (Tensor): Box reference for each scale level with shape
-                (N, num_total_anchors, 4).
-            cls_score (Tensor): Cls and quality joint scores for each scale
-                level has shape (N, num_classes, H, W).
-            bbox_pred (Tensor): Box distribution logits for each scale
-                level with shape (N, 4*(n+1), H, W), n is max value of integral
-                set.
-            labels (Tensor): Labels of each anchors with shape
-                (N, num_total_anchors).
-            label_weights (Tensor): Label weights of each anchor with shape
-                (N, num_total_anchors)
-            bbox_targets (Tensor): BBox regression targets of each anchor wight
-                shape (N, num_total_anchors, 4).
-            stride (tuple): Stride in this scale level.
-            num_total_samples (int): Number of positive samples that is
-                reduced over all GPUs.
-        Returns:
-            dict[str, Tensor]: A dictionary of loss components.
-        """
-        assert stride[0] == stride[1], 'h stride is not equal to w stride!'
-        anchors = anchors.reshape(-1, 4)
-        cls_score = cls_score.permute(0, 2, 3,
-                                      1).reshape(-1, self.cls_out_channels)
-        bbox_pred = bbox_pred.permute(0, 2, 3,
-                                      1).reshape(-1, 4 * (self.reg_max + 1))
-        bbox_targets = bbox_targets.reshape(-1, 4)
-        labels = labels.reshape(-1)
-        label_weights = label_weights.reshape(-1)
-        # FG cat_id: [0, num_classes -1], BG cat_id: num_classes
-        bg_class_ind = self.num_classes
-        pos_inds = ((labels >= 0)
-                    & (labels < bg_class_ind)).nonzero().squeeze(1)
-        score = label_weights.new_zeros(labels.shape)
-        if len(pos_inds) > 0:
-            pos_bbox_targets = bbox_targets[pos_inds]
-            pos_bbox_pred = bbox_pred[pos_inds]
-            pos_anchors = anchors[pos_inds]
-            pos_anchor_centers = self.anchor_center(pos_anchors) / stride[0]
-            weight_targets = cls_score.detach().sigmoid()
-            weight_targets = weight_targets.max(dim=1)[0][pos_inds]
-            pos_bbox_pred_corners = self.integral(pos_bbox_pred)
-            pos_decode_bbox_pred = distance2bbox(pos_anchor_centers,
-                                                 pos_bbox_pred_corners)
-            pos_decode_bbox_targets = pos_bbox_targets / stride[0]
-            score[pos_inds] = bbox_overlaps(
-                pos_decode_bbox_pred.detach(),
-                pos_decode_bbox_targets,
-                is_aligned=True)
-            pred_corners = pos_bbox_pred.reshape(-1, self.reg_max + 1)
-            target_corners = bbox2distance(pos_anchor_centers,
-                                           pos_decode_bbox_targets,
-                                           self.reg_max).reshape(-1)
-            # regression loss
-            loss_bbox = self.loss_bbox(
-                pos_decode_bbox_pred,
-                pos_decode_bbox_targets,
-                weight=weight_targets,
-                avg_factor=1.0)
-            # dfl loss
-            loss_dfl = self.loss_dfl(
-                pred_corners,
-                target_corners,
-                weight=weight_targets[:, None].expand(-1, 4).reshape(-1),
-                avg_factor=4.0)
-        else:
-            loss_bbox = bbox_pred.sum() * 0
-            loss_dfl = bbox_pred.sum() * 0
-            weight_targets = bbox_pred.new_tensor(0)
-        # cls (qfl) loss
-        loss_cls = self.loss_cls(
-            cls_score, (labels, score),
-            weight=label_weights,
-            avg_factor=num_total_samples)
-        return loss_cls, loss_bbox, loss_dfl, weight_targets.sum()
-    @force_fp32(apply_to=('cls_scores', 'bbox_preds'))
-    def loss(self,
-             cls_scores,
-             bbox_preds,
-             gt_bboxes,
-             gt_labels,
-             img_metas,
-             gt_bboxes_ignore=None):
-        """Compute losses of the head.
-        Args:
-            cls_scores (list[Tensor]): Cls and quality scores for each scale
-                level has shape (N, num_classes, H, W).
-            bbox_preds (list[Tensor]): Box distribution logits for each scale
-                level with shape (N, 4*(n+1), H, W), n is max value of integral
-                set.
-            gt_bboxes (list[Tensor]): Ground truth bboxes for each image with
-                shape (num_gts, 4) in [tl_x, tl_y, br_x, br_y] format.
-            gt_labels (list[Tensor]): class indices corresponding to each box
-            img_metas (list[dict]): Meta information of each image, e.g.,
-                image size, scaling factor, etc.
-            gt_bboxes_ignore (list[Tensor] | None): specify which bounding
-                boxes can be ignored when computing the loss.
-        Returns:
-            dict[str, Tensor]: A dictionary of loss components.
-        """
-        featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
-        assert len(featmap_sizes) == self.anchor_generator.num_levels
-        device = cls_scores[0].device
-        anchor_list, valid_flag_list = self.get_anchors(
-            featmap_sizes, img_metas, device=device)
-        label_channels = self.cls_out_channels if self.use_sigmoid_cls else 1
-        cls_reg_targets = self.get_targets(
-            anchor_list,
-            valid_flag_list,
-            gt_bboxes,
-            img_metas,
-            gt_bboxes_ignore_list=gt_bboxes_ignore,
-            gt_labels_list=gt_labels,
-            label_channels=label_channels)
-        if cls_reg_targets is None:
-            return None
-        (anchor_list, labels_list, label_weights_list, bbox_targets_list,
-         bbox_weights_list, num_total_pos, num_total_neg) = cls_reg_targets
-        num_total_samples = reduce_mean(
-            torch.tensor(num_total_pos, dtype=torch.float,
-                         device=device)).item()
-        num_total_samples = max(num_total_samples, 1.0)
-        losses_cls, losses_bbox, losses_dfl,\
-            avg_factor = multi_apply(
-                self.loss_single,
-                anchor_list,
-                cls_scores,
-                bbox_preds,
-                labels_list,
-                label_weights_list,
-                bbox_targets_list,
-                self.anchor_generator.strides,
-                num_total_samples=num_total_samples)
-        avg_factor = sum(avg_factor)
-        avg_factor = reduce_mean(avg_factor).item()
-        losses_bbox = list(map(lambda x: x / avg_factor, losses_bbox))
-        losses_dfl = list(map(lambda x: x / avg_factor, losses_dfl))
-        return dict(
-            loss_cls=losses_cls, loss_bbox=losses_bbox, loss_dfl=losses_dfl)
-    def _get_bboxes(self,
-                    cls_scores,
-                    bbox_preds,
-                    mlvl_anchors,
-                    img_shapes,
-                    scale_factors,
-                    cfg,
-                    rescale=False,
-                    with_nms=True):
-        """Transform outputs for a single batch item into labeled boxes.
-        Args:
-            cls_scores (list[Tensor]): Box scores for a single scale level
-                has shape (N, num_classes, H, W).
-            bbox_preds (list[Tensor]): Box distribution logits for a single
-                scale level with shape (N, 4*(n+1), H, W), n is max value of
-                integral set.
-            mlvl_anchors (list[Tensor]): Box reference for a single scale level
-                with shape (num_total_anchors, 4).
-            img_shapes (list[tuple[int]]): Shape of the input image,
-                list[(height, width, 3)].
-            scale_factors (list[ndarray]): Scale factor of the image arange as
-                (w_scale, h_scale, w_scale, h_scale).
-            cfg (mmcv.Config | None): Test / postprocessing configuration,
-                if None, test_cfg would be used.
-            rescale (bool): If True, return boxes in original image space.
-                Default: False.
-            with_nms (bool): If True, do nms before return boxes.
-                Default: True.
-        Returns:
-            list[tuple[Tensor, Tensor]]: Each item in result_list is 2-tuple.
-                The first item is an (n, 5) tensor, where 5 represent
-                (tl_x, tl_y, br_x, br_y, score) and the score between 0 and 1.
-                The shape of the second tensor in the tuple is (n,), and
-                each element represents the class label of the corresponding
-                box.
-        """
-        cfg = self.test_cfg if cfg is None else cfg
-        assert len(cls_scores) == len(bbox_preds) == len(mlvl_anchors)
-        batch_size = cls_scores[0].shape[0]
-        mlvl_bboxes = []
-        mlvl_scores = []
-        for cls_score, bbox_pred, stride, anchors in zip(
-                cls_scores, bbox_preds, self.anchor_generator.strides,
-                mlvl_anchors):
-            assert cls_score.size()[-2:] == bbox_pred.size()[-2:]
-            assert stride[0] == stride[1]
-            scores = cls_score.permute(0, 2, 3, 1).reshape(
-                batch_size, -1, self.cls_out_channels).sigmoid()
-            bbox_pred = bbox_pred.permute(0, 2, 3, 1)
-            bbox_pred = self.integral(bbox_pred) * stride[0]
-            bbox_pred = bbox_pred.reshape(batch_size, -1, 4)
-            nms_pre = cfg.get('nms_pre', -1)
-            if nms_pre > 0 and scores.shape[1] > nms_pre:
-                max_scores, _ = scores.max(-1)
-                _, topk_inds = max_scores.topk(nms_pre)
-                batch_inds = torch.arange(batch_size).view(
-                    -1, 1).expand_as(topk_inds).long()
-                anchors = anchors[topk_inds, :]
-                bbox_pred = bbox_pred[batch_inds, topk_inds, :]
-                scores = scores[batch_inds, topk_inds, :]
-            else:
-                anchors = anchors.expand_as(bbox_pred)
-            bboxes = distance2bbox(
-                self.anchor_center(anchors), bbox_pred, max_shape=img_shapes)
-            mlvl_bboxes.append(bboxes)
-            mlvl_scores.append(scores)
-        batch_mlvl_bboxes = torch.cat(mlvl_bboxes, dim=1)
-        if rescale:
-            batch_mlvl_bboxes /= batch_mlvl_bboxes.new_tensor(
-                scale_factors).unsqueeze(1)
-        batch_mlvl_scores = torch.cat(mlvl_scores, dim=1)
-        # Add a dummy background class to the backend when using sigmoid
-        # remind that we set FG labels to [0, num_class-1] since mmdet v2.0
-        # BG cat_id: num_class
-        padding = batch_mlvl_scores.new_zeros(batch_size,
-                                              batch_mlvl_scores.shape[1], 1)
-        batch_mlvl_scores = torch.cat([batch_mlvl_scores, padding], dim=-1)
-        if with_nms:
-            det_results = []
-            for (mlvl_bboxes, mlvl_scores) in zip(batch_mlvl_bboxes,
-                                                  batch_mlvl_scores):
-                det_bbox, det_label = multiclass_nms(mlvl_bboxes, mlvl_scores,
-                                                     cfg.score_thr, cfg.nms,
-                                                     cfg.max_per_img)
-                det_results.append(tuple([det_bbox, det_label]))
-        else:
-            det_results = [
-                tuple(mlvl_bs)
-                for mlvl_bs in zip(batch_mlvl_bboxes, batch_mlvl_scores)
-            ]
-        return det_results
-    def get_targets(self,
-                    anchor_list,
-                    valid_flag_list,
-                    gt_bboxes_list,
-                    img_metas,
-                    gt_bboxes_ignore_list=None,
-                    gt_labels_list=None,
-                    label_channels=1,
-                    unmap_outputs=True):
-        """Get targets for GFL head.
-        This method is almost the same as `AnchorHead.get_targets()`. Besides
-        returning the targets as the parent method does, it also returns the
-        anchors as the first element of the returned tuple.
-        """
-        num_imgs = len(img_metas)
-        assert len(anchor_list) == len(valid_flag_list) == num_imgs
-        # anchor number of multi levels
-        num_level_anchors = [anchors.size(0) for anchors in anchor_list[0]]
-        num_level_anchors_list = [num_level_anchors] * num_imgs
-        # concat all level anchors and flags to a single tensor
-        for i in range(num_imgs):
-            assert len(anchor_list[i]) == len(valid_flag_list[i])
-            anchor_list[i] = torch.cat(anchor_list[i])
-            valid_flag_list[i] = torch.cat(valid_flag_list[i])
-        # compute targets for each image
-        if gt_bboxes_ignore_list is None:
-            gt_bboxes_ignore_list = [None for _ in range(num_imgs)]
-        if gt_labels_list is None:
-            gt_labels_list = [None for _ in range(num_imgs)]
-        (all_anchors, all_labels, all_label_weights, all_bbox_targets,
-         all_bbox_weights, pos_inds_list, neg_inds_list) = multi_apply(
-             self._get_target_single,
-             anchor_list,
-             valid_flag_list,
-             num_level_anchors_list,
-             gt_bboxes_list,
-             gt_bboxes_ignore_list,
-             gt_labels_list,
-             img_metas,
-             label_channels=label_channels,
-             unmap_outputs=unmap_outputs)
-        # no valid anchors
-        if any([labels is None for labels in all_labels]):
-            return None
-        # sampled anchors of all images
-        num_total_pos = sum([max(inds.numel(), 1) for inds in pos_inds_list])
-        num_total_neg = sum([max(inds.numel(), 1) for inds in neg_inds_list])
-        # split targets to a list w.r.t. multiple levels
-        anchors_list = images_to_levels(all_anchors, num_level_anchors)
-        labels_list = images_to_levels(all_labels, num_level_anchors)
-        label_weights_list = images_to_levels(all_label_weights,
-                                              num_level_anchors)
-        bbox_targets_list = images_to_levels(all_bbox_targets,
-                                             num_level_anchors)
-        bbox_weights_list = images_to_levels(all_bbox_weights,
-                                             num_level_anchors)
-        return (anchors_list, labels_list, label_weights_list,
-                bbox_targets_list, bbox_weights_list, num_total_pos,
-                num_total_neg)
-    def _get_target_single(self,
-                           flat_anchors,
-                           valid_flags,
-                           num_level_anchors,
-                           gt_bboxes,
-                           gt_bboxes_ignore,
-                           gt_labels,
-                           img_meta,
-                           label_channels=1,
-                           unmap_outputs=True):
-        """Compute regression, classification targets for anchors in a single
-        image.
-        Args:
-            flat_anchors (Tensor): Multi-level anchors of the image, which are
-                concatenated into a single tensor of shape (num_anchors, 4)
-            valid_flags (Tensor): Multi level valid flags of the image,
-                which are concatenated into a single tensor of
-                    shape (num_anchors,).
-            num_level_anchors Tensor): Number of anchors of each scale level.
-            gt_bboxes (Tensor): Ground truth bboxes of the image,
-                shape (num_gts, 4).
-            gt_bboxes_ignore (Tensor): Ground truth bboxes to be
-                ignored, shape (num_ignored_gts, 4).
-            gt_labels (Tensor): Ground truth labels of each box,
-                shape (num_gts,).
-            img_meta (dict): Meta info of the image.
-            label_channels (int): Channel of label.
-            unmap_outputs (bool): Whether to map outputs back to the original
-                set of anchors.
-        Returns:
-            tuple: N is the number of total anchors in the image.
-                anchors (Tensor): All anchors in the image with shape (N, 4).
-                labels (Tensor): Labels of all anchors in the image with shape
-                    (N,).
-                label_weights (Tensor): Label weights of all anchor in the
-                    image with shape (N,).
-                bbox_targets (Tensor): BBox targets of all anchors in the
-                    image with shape (N, 4).
-                bbox_weights (Tensor): BBox weights of all anchors in the
-                    image with shape (N, 4).
-                pos_inds (Tensor): Indices of positive anchor with shape
-                    (num_pos,).
-                neg_inds (Tensor): Indices of negative anchor with shape
-                    (num_neg,).
-        """
-        inside_flags = anchor_inside_flags(flat_anchors, valid_flags,
-                                           img_meta['img_shape'][:2],
-                                           self.train_cfg.allowed_border)
-        if not inside_flags.any():
-            return (None, ) * 7
-        # assign gt and sample anchors
-        anchors = flat_anchors[inside_flags, :]
-        num_level_anchors_inside = self.get_num_level_anchors_inside(
-            num_level_anchors, inside_flags)
-        assign_result = self.assigner.assign(anchors, num_level_anchors_inside,
-                                             gt_bboxes, gt_bboxes_ignore,
-                                             gt_labels)
-        sampling_result = self.sampler.sample(assign_result, anchors,
-                                              gt_bboxes)
-        num_valid_anchors = anchors.shape[0]
-        bbox_targets = torch.zeros_like(anchors)
-        bbox_weights = torch.zeros_like(anchors)
-        labels = anchors.new_full((num_valid_anchors, ),
-                                  self.num_classes,
-                                  dtype=torch.long)
-        label_weights = anchors.new_zeros(num_valid_anchors, dtype=torch.float)
-        pos_inds = sampling_result.pos_inds
-        neg_inds = sampling_result.neg_inds
-        if len(pos_inds) > 0:
-            pos_bbox_targets = sampling_result.pos_gt_bboxes
-            bbox_targets[pos_inds, :] = pos_bbox_targets
-            bbox_weights[pos_inds, :] = 1.0
-            if gt_labels is None:
-                # Only rpn gives gt_labels as None
-                # Foreground is the first class
-                labels[pos_inds] = 0
-            else:
-                labels[pos_inds] = gt_labels[
-                    sampling_result.pos_assigned_gt_inds]
-            if self.train_cfg.pos_weight <= 0:
-                label_weights[pos_inds] = 1.0
-            else:
-                label_weights[pos_inds] = self.train_cfg.pos_weight
-        if len(neg_inds) > 0:
-            label_weights[neg_inds] = 1.0
-        # map up to original set of anchors
-        if unmap_outputs:
-            num_total_anchors = flat_anchors.size(0)
-            anchors = unmap(anchors, num_total_anchors, inside_flags)
-            labels = unmap(
-                labels, num_total_anchors, inside_flags, fill=self.num_classes)
-            label_weights = unmap(label_weights, num_total_anchors,
-                                  inside_flags)
-            bbox_targets = unmap(bbox_targets, num_total_anchors, inside_flags)
-            bbox_weights = unmap(bbox_weights, num_total_anchors, inside_flags)
-        return (anchors, labels, label_weights, bbox_targets, bbox_weights,
-                pos_inds, neg_inds)
-    def get_num_level_anchors_inside(self, num_level_anchors, inside_flags):
-        split_inside_flags = torch.split(inside_flags, num_level_anchors)
-        num_level_anchors_inside = [
-            int(flags.sum()) for flags in split_inside_flags
-        ]
-        return num_level_anchors_inside

spaces/Andy1621/uniformer_image_segmentation/configs/deeplabv3plus/deeplabv3plus_r50b-d8_512x1024_80k_cityscapes.py DELETED Viewed

	@@ -1,2 +0,0 @@
1	- _base_ = './deeplabv3plus_r50-d8_512x1024_80k_cityscapes.py'
2	- model = dict(pretrained='torchvision://resnet50', backbone=dict(type='ResNet'))

spaces/Anonymous-123/ImageNet-Editing/editing_diffusion/optimization/image_editor.py DELETED Viewed

@@ -1,542 +0,0 @@
-import os
-from pathlib import Path
-from optimization.constants import ASSETS_DIR_NAME, RANKED_RESULTS_DIR
-from utils.metrics_accumulator import MetricsAccumulator
-from utils.video import save_video
-from utils.fft_pytorch import HighFrequencyLoss
-from numpy import random
-from optimization.augmentations import ImageAugmentations
-from PIL import Image
-import torch
-import torchvision
-from torchvision import transforms
-import torchvision.transforms.functional as F
-from torchvision.transforms import functional as TF
-from torch.nn.functional import mse_loss
-from optimization.losses import range_loss, d_clip_loss
-import lpips
-import numpy as np
-from CLIP import clip
-from guided_diffusion.guided_diffusion.script_util import (
-    create_model_and_diffusion,
-    model_and_diffusion_defaults,
-    create_classifier,
-    classifier_defaults,
-)
-from utils.visualization import show_tensor_image, show_editied_masked_image
-from utils.change_place import change_place, find_bbox
-import pdb
-import cv2
-def create_classifier_ours():
-    model = torchvision.models.resnet50()
-    ckpt = torch.load('checkpoints/DRA_resnet50.pth')['model_state_dict']
-    model.load_state_dict({k.replace('module.','').replace('last_linear','fc'):v for k,v in ckpt.items()})
-    model = torch.nn.Sequential(*[torch.nn.Upsample(size=(256,256)), model])
-    return model
-class ImageEditor:
-    def __init__(self, args) -> None:
-        self.args = args
-        os.makedirs(self.args.output_path, exist_ok=True)
-        self.ranked_results_path = Path(os.path.join(self.args.output_path, RANKED_RESULTS_DIR))
-        os.makedirs(self.ranked_results_path, exist_ok=True)
-        if self.args.export_assets:
-            self.assets_path = Path(os.path.join(self.args.output_path, ASSETS_DIR_NAME))
-            os.makedirs(self.assets_path, exist_ok=True)
-        if self.args.seed is not None:
-            torch.manual_seed(self.args.seed)
-            np.random.seed(self.args.seed)
-            random.seed(self.args.seed)
-        self.model_config = model_and_diffusion_defaults()
-        self.model_config.update(
-            {
-                "attention_resolutions": "32, 16, 8",
-                "class_cond": self.args.model_output_size == 512,
-                "diffusion_steps": 1000,
-                "rescale_timesteps": True,
-                "timestep_respacing": self.args.timestep_respacing,
-                "image_size": self.args.model_output_size,
-                "learn_sigma": True,
-                "noise_schedule": "linear",
-                "num_channels": 256,
-                "num_head_channels": 64,
-                "num_res_blocks": 2,
-                "resblock_updown": True,
-                "use_fp16": True,
-                "use_scale_shift_norm": True,
-            }
-        )
-        self.classifier_config = classifier_defaults()
-        self.classifier_config.update(
-            {
-                "image_size": self.args.model_output_size,
-            }
-        )
-        # Load models
-        self.device = torch.device(
-            f"cuda:{self.args.gpu_id}" if torch.cuda.is_available() else "cpu"
-        )
-        print("Using device:", self.device)
-        self.model, self.diffusion = create_model_and_diffusion(**self.model_config)
-        self.model.load_state_dict(
-            torch.load(
-                "checkpoints/256x256_diffusion_uncond.pt"
-                if self.args.model_output_size == 256
-                else "checkpoints/512x512_diffusion.pt",
-                map_location="cpu",
-            )
-        )
-        # self.model.requires_grad_(False).eval().to(self.device)
-        self.model.eval().to(self.device)
-        for name, param in self.model.named_parameters():
-            if "qkv" in name or "norm" in name or "proj" in name:
-                param.requires_grad_()
-        if self.model_config["use_fp16"]:
-            self.model.convert_to_fp16()
-        self.classifier = create_classifier(**self.classifier_config)
-        self.classifier.load_state_dict(
-            torch.load("checkpoints/256x256_classifier.pt", map_location="cpu")
-        )
-        # self.classifier.requires_grad_(False).eval().to(self.device)
-        # self.classifier = create_classifier_ours()
-        self.classifier.eval().to(self.device)
-        if self.classifier_config["classifier_use_fp16"]:
-            self.classifier.convert_to_fp16()
-        self.clip_model = (
-            clip.load("ViT-B/16", device=self.device, jit=False)[0].eval().requires_grad_(False)
-        )
-        self.clip_size = self.clip_model.visual.input_resolution
-        self.clip_normalize = transforms.Normalize(
-            mean=[0.48145466, 0.4578275, 0.40821073], std=[0.26862954, 0.26130258, 0.27577711]
-        )
-        self.to_tensor = transforms.ToTensor()
-        self.lpips_model = lpips.LPIPS(net="vgg").to(self.device)
-        self.image_augmentations = ImageAugmentations(self.clip_size, self.args.aug_num)
-        self.metrics_accumulator = MetricsAccumulator()
-        self.hf_loss = HighFrequencyLoss()
-    def unscale_timestep(self, t):
-        unscaled_timestep = (t * (self.diffusion.num_timesteps / 1000)).long()
-        return unscaled_timestep
-    def clip_loss(self, x_in, text_embed):
-        clip_loss = torch.tensor(0)
-        if self.mask is not None:
-            masked_input = x_in * self.mask
-        else:
-            masked_input = x_in
-        augmented_input = self.image_augmentations(masked_input).add(1).div(2) # shape: [N,C,H,W], range: [0,1]
-        clip_in = self.clip_normalize(augmented_input)
-        # pdb.set_trace()
-        image_embeds = self.clip_model.encode_image(clip_in).float()
-        dists = d_clip_loss(image_embeds, text_embed)
-        # We want to sum over the averages
-        for i in range(self.args.batch_size):
-            # We want to average at the "augmentations level"
-            clip_loss = clip_loss + dists[i :: self.args.batch_size].mean()
-        return clip_loss
-    def unaugmented_clip_distance(self, x, text_embed):
-        x = F.resize(x, [self.clip_size, self.clip_size])
-        image_embeds = self.clip_model.encode_image(x).float()
-        dists = d_clip_loss(image_embeds, text_embed)
-        return dists.item()
-    def model_fn(self, x,t,y=None):
-        return self.model(x, t, y if self.args.class_cond else None)
-    def edit_image_by_prompt(self):
-        if self.args.image_guide:
-            img_guidance = Image.open(self.args.prompt).convert('RGB')
-            img_guidance = img_guidance.resize((224,224), Image.LANCZOS)  # type: ignore
-            img_guidance = self.clip_normalize(self.to_tensor(img_guidance).unsqueeze(0)).to(self.device)
-            text_embed = self.clip_model.encode_image(img_guidance).float()
-        else:
-            text_embed = self.clip_model.encode_text(
-                clip.tokenize(self.args.prompt).to(self.device)
-            ).float()
-        self.image_size = (self.model_config["image_size"], self.model_config["image_size"])
-        self.init_image_pil = Image.open(self.args.init_image).convert("RGB")
-        self.init_image_pil = self.init_image_pil.resize(self.image_size, Image.LANCZOS)  # type: ignore
-        self.init_image = (
-            TF.to_tensor(self.init_image_pil).to(self.device).unsqueeze(0).mul(2).sub(1)
-        )
-        self.init_image_pil_2 = Image.open(self.args.init_image_2).convert("RGB")
-        if self.args.rotate_obj:
-            # angle = random.randint(-45,45)
-            angle = self.args.angle
-            self.init_image_pil_2 = self.init_image_pil_2.rotate(angle)
-        self.init_image_pil_2 = self.init_image_pil_2.resize(self.image_size, Image.LANCZOS)  # type: ignore
-        self.init_image_2 = (
-            TF.to_tensor(self.init_image_pil_2).to(self.device).unsqueeze(0).mul(2).sub(1)
-        )
-        '''
-        # Init with the inpainting image
-        self.init_image_pil_ = Image.open('output/ImageNet-S_val/bad_case_RN50/ILSVRC2012_val_00013212/ranked/08480_output_i_0_b_0.png').convert("RGB")
-        self.init_image_pil_ = self.init_image_pil_.resize(self.image_size, Image.LANCZOS)  # type: ignore
-        self.init_image_ = (
-            TF.to_tensor(self.init_image_pil_).to(self.device).unsqueeze(0).mul(2).sub(1)
-        )
-        '''
-        if self.args.export_assets:
-            img_path = self.assets_path / Path(self.args.output_file)
-            self.init_image_pil.save(img_path, quality=100)
-        self.mask = torch.ones_like(self.init_image, device=self.device)
-        self.mask_pil = None
-        if self.args.mask is not None:
-            self.mask_pil = Image.open(self.args.mask).convert("RGB")
-            if self.args.rotate_obj:
-                self.mask_pil = self.mask_pil.rotate(angle)
-            if self.mask_pil.size != self.image_size:
-                self.mask_pil = self.mask_pil.resize(self.image_size, Image.NEAREST)  # type: ignore
-            if self.args.random_position:
-                bbox = find_bbox(np.array(self.mask_pil))
-                print(bbox)
-            image_mask_pil_binarized = ((np.array(self.mask_pil) > 0.5) * 255).astype(np.uint8)
-            # image_mask_pil_binarized = cv2.dilate(image_mask_pil_binarized, np.ones((50,50), np.uint8), iterations=1)
-            if self.args.invert_mask:
-                image_mask_pil_binarized = 255 - image_mask_pil_binarized
-                self.mask_pil = TF.to_pil_image(image_mask_pil_binarized)
-            self.mask = TF.to_tensor(Image.fromarray(image_mask_pil_binarized))
-            self.mask = self.mask[0, ...].unsqueeze(0).unsqueeze(0).to(self.device)
-            # self.mask[:] = 1
-            if self.args.random_position:
-                # print(self.init_image_2.shape, self.init_image_2.max(), self.init_image_2.min())
-                # print(self.mask.shape, self.mask.max(), self.mask.min())
-                # cv2.imwrite('tmp/init_before.jpg', np.transpose(((self.init_image_2+1)/2*255).cpu().numpy()[0], (1,2,0))[:,:,::-1])
-                # cv2.imwrite('tmp/mask_before.jpg', (self.mask*255).cpu().numpy()[0][0])
-                self.init_image_2, self.mask = change_place(self.init_image_2, self.mask, bbox, self.args.invert_mask)
-                # cv2.imwrite('tmp/init_after.jpg', np.transpose(((self.init_image_2+1)/2*255).cpu().numpy()[0], (1,2,0))[:,:,::-1])
-                # cv2.imwrite('tmp/mask_after.jpg', (self.mask*255).cpu().numpy()[0][0])
-            if self.args.export_assets:
-                mask_path = self.assets_path / Path(
-                    self.args.output_file.replace(".png", "_mask.png")
-                )
-                self.mask_pil.save(mask_path, quality=100)
-        def class_guided(x, y, t):
-            assert y is not None
-            with torch.enable_grad():
-                x_in = x.detach().requires_grad_(True)
-                # logits = self.classifier(x_in, t)
-                logits = self.classifier(x_in)
-                log_probs = torch.nn.functional.log_softmax(logits, dim=-1)
-                selected = log_probs[range(len(logits)), y.view(-1)]
-                loss = selected.sum()
-                return -torch.autograd.grad(loss, x_in)[0] * self.args.classifier_scale
-        def cond_fn(x, t, y=None):
-            if self.args.prompt == "":
-                return torch.zeros_like(x)
-            # pdb.set_trace()
-            with torch.enable_grad():
-                x = x.detach().requires_grad_()
-                t_unscale = self.unscale_timestep(t)
-                '''
-                out = self.diffusion.p_mean_variance(
-                    self.model, x, t, clip_denoised=False, model_kwargs={"y": y}
-                )
-                '''
-                out = self.diffusion.p_mean_variance(
-                    self.model, x, t_unscale, clip_denoised=False, model_kwargs={"y": None}
-                )
-                fac = self.diffusion.sqrt_one_minus_alphas_cumprod[t_unscale[0].item()]
-                # x_in = out["pred_xstart"] * fac + x * (1 - fac)
-                x_in = out["pred_xstart"] # Revised by XX, 2022.07.14
-                loss = torch.tensor(0)
-                if self.args.classifier_scale != 0 and y is not None:
-                    # gradient_class_guided = class_guided(x, y, t)
-                    gradient_class_guided = class_guided(x_in, y, t)
-                if self.args.background_complex != 0:
-                    if self.args.hard:
-                        loss = loss - self.args.background_complex*self.hf_loss((x_in+1.)/2.)
-                    else:
-                        loss = loss + self.args.background_complex*self.hf_loss((x_in+1.)/2.)
-                if self.args.clip_guidance_lambda != 0:
-                    clip_loss = self.clip_loss(x_in, text_embed) * self.args.clip_guidance_lambda
-                    loss = loss + clip_loss
-                    self.metrics_accumulator.update_metric("clip_loss", clip_loss.item())
-                if self.args.range_lambda != 0:
-                    r_loss = range_loss(out["pred_xstart"]).sum() * self.args.range_lambda
-                    loss = loss + r_loss
-                    self.metrics_accumulator.update_metric("range_loss", r_loss.item())
-                if self.args.background_preservation_loss:
-                    x_in = out["pred_xstart"] * fac + x * (1 - fac)
-                    if self.mask is not None:
-                        # masked_background = x_in * (1 - self.mask)
-                        masked_background = x_in * self.mask # 2022.07.19
-                    else:
-                        masked_background = x_in
-                    if self.args.lpips_sim_lambda:
-                        '''
-                        loss = (
-                            loss
-                            + self.lpips_model(masked_background, self.init_image).sum()
-                            * self.args.lpips_sim_lambda
-                        )
-                        '''
-                        # 2022.07.19
-                        loss = (
-                            loss
-                            + self.lpips_model(masked_background, self.init_image*self.mask).sum()
-                            * self.args.lpips_sim_lambda
-                        )
-                    if self.args.l2_sim_lambda:
-                        '''
-                        loss = (
-                            loss
-                            + mse_loss(masked_background, self.init_image) * self.args.l2_sim_lambda
-                        )
-                        '''
-                        # 2022.07.19
-                        loss = (
-                            loss
-                            + mse_loss(masked_background, self.init_image*self.mask) * self.args.l2_sim_lambda
-                        )
-                if self.args.classifier_scale != 0 and y is not None:
-                    return -torch.autograd.grad(loss, x)[0] + gradient_class_guided
-                else:
-                    return -torch.autograd.grad(loss, x)[0]
-        @torch.no_grad()
-        def postprocess_fn(out, t):
-            if self.args.coarse_to_fine:
-                if t > 50:
-                    kernel = 51
-                elif t > 35:
-                    kernel = 31
-                else:
-                    kernel = 0
-                if kernel > 0:
-                    max_pool = torch.nn.MaxPool2d(kernel_size=kernel, stride=1, padding=int((kernel-1)/2))
-                    self.mask_d = 1 - self.mask
-                    self.mask_d = max_pool(self.mask_d)
-                    self.mask_d = 1 - self.mask_d
-                else:
-                    self.mask_d = self.mask
-            else:
-                self.mask_d = self.mask
-            if self.mask is not None:
-                background_stage_t = self.diffusion.q_sample(self.init_image_2, t[0])
-                background_stage_t = torch.tile(
-                    background_stage_t, dims=(self.args.batch_size, 1, 1, 1)
-                )
-                out["sample"] = out["sample"] * self.mask_d + background_stage_t * (1 - self.mask_d)
-            return out
-        save_image_interval = self.diffusion.num_timesteps // 5
-        for iteration_number in range(self.args.iterations_num):
-            print(f"Start iterations {iteration_number}")
-            sample_func = (
-                self.diffusion.ddim_sample_loop_progressive
-                if self.args.ddim
-                else self.diffusion.p_sample_loop_progressive
-            )
-            samples = sample_func(
-                self.model_fn,
-                (
-                    self.args.batch_size,
-                    3,
-                    self.model_config["image_size"],
-                    self.model_config["image_size"],
-                ),
-                clip_denoised=False,
-                # model_kwargs={}
-                # if self.args.model_output_size == 256
-                # else {
-                #     "y": torch.zeros([self.args.batch_size], device=self.device, dtype=torch.long)
-                # },
-                model_kwargs={}
-                if self.args.classifier_scale == 0
-                else {"y": self.args.y*torch.ones([self.args.batch_size], device=self.device, dtype=torch.long)},
-                cond_fn=cond_fn,
-                device=self.device,
-                progress=True,
-                skip_timesteps=self.args.skip_timesteps,
-                init_image=self.init_image,
-                # init_image=self.init_image_,
-                postprocess_fn=None if self.args.local_clip_guided_diffusion else postprocess_fn,
-                randomize_class=True if self.args.classifier_scale == 0 else False,
-            )
-            intermediate_samples = [[] for i in range(self.args.batch_size)]
-            total_steps = self.diffusion.num_timesteps - self.args.skip_timesteps - 1
-            for j, sample in enumerate(samples):
-                should_save_image = j % save_image_interval == 0 or j == total_steps
-                if should_save_image or self.args.save_video:
-                    self.metrics_accumulator.print_average_metric()
-                    for b in range(self.args.batch_size):
-                        pred_image = sample["pred_xstart"][b]
-                        visualization_path = Path(
-                            os.path.join(self.args.output_path, self.args.output_file)
-                        )
-                        visualization_path = visualization_path.with_stem(
-                            f"{visualization_path.stem}_i_{iteration_number}_b_{b}"
-                        )
-                        if (
-                            self.mask is not None
-                            and self.args.enforce_background
-                            and j == total_steps
-                            and not self.args.local_clip_guided_diffusion
-                        ):
-                            pred_image = (
-                                self.init_image_2[0] * (1 - self.mask[0]) + pred_image * self.mask[0]
-                            )
-                        '''
-                        if j == total_steps:
-                            pdb.set_trace()
-                        pred_image = (
-                                self.init_image_2[0] * (1 - self.mask[0]) + pred_image * self.mask[0]
-                            )
-                        '''
-                        pred_image = pred_image.add(1).div(2).clamp(0, 1)
-                        pred_image_pil = TF.to_pil_image(pred_image)
-                        masked_pred_image = self.mask * pred_image.unsqueeze(0)
-                        final_distance = self.unaugmented_clip_distance(
-                            masked_pred_image, text_embed
-                        )
-                        formatted_distance = f"{final_distance:.4f}"
-                        if self.args.export_assets:
-                            pred_path = self.assets_path / visualization_path.name
-                            pred_image_pil.save(pred_path, quality=100)
-                        if j == total_steps:
-                            path_friendly_distance = formatted_distance.replace(".", "")
-                            ranked_pred_path = self.ranked_results_path / (
-                                path_friendly_distance + "_" + visualization_path.name
-                            )
-                            pred_image_pil.save(ranked_pred_path, quality=100)
-                        intermediate_samples[b].append(pred_image_pil)
-                        if should_save_image:
-                            show_editied_masked_image(
-                                title=self.args.prompt,
-                                source_image=self.init_image_pil,
-                                edited_image=pred_image_pil,
-                                mask=self.mask_pil,
-                                path=visualization_path,
-                                distance=formatted_distance,
-                            )
-            if self.args.save_video:
-                for b in range(self.args.batch_size):
-                    video_name = self.args.output_file.replace(
-                        ".png", f"_i_{iteration_number}_b_{b}.avi"
-                    )
-                    video_path = os.path.join(self.args.output_path, video_name)
-                    save_video(intermediate_samples[b], video_path)
-        visualize_size = (256,256)
-        img_ori = cv2.imread(self.args.init_image_2)
-        img_ori = cv2.resize(img_ori, visualize_size)
-        mask = cv2.imread(self.args.mask)
-        mask = cv2.resize(mask, visualize_size)
-        imgs = [img_ori, mask]
-        for ii, img_name in enumerate(os.listdir(os.path.join(self.args.output_path, 'ranked'))):
-            img_path = os.path.join(self.args.output_path, 'ranked', img_name)
-            img = cv2.imread(img_path)
-            img = cv2.resize(img, visualize_size)
-            imgs.append(img)
-            if ii >= 7:
-                break
-        img_whole = cv2.hconcat(imgs[2:])
-        '''
-        img_name = self.args.output_path.split('/')[-2]+'/'
-        if self.args.coarse_to_fine:
-            if self.args.clip_guidance_lambda == 0:
-                prompt = 'coarse_to_fine_no_clip'
-            else:
-                prompt = 'coarse_to_fine'
-        elif self.args.image_guide:
-            prompt = 'image_guide'
-        elif self.args.clip_guidance_lambda == 0:
-            prompt = 'no_clip_guide'
-        else:
-            prompt = 'text_guide'
-        '''
-        cv2.imwrite(os.path.join(self.args.final_save_root, 'edited.png'), img_whole, [int(cv2.IMWRITE_PNG_COMPRESSION), 0])
-    def reconstruct_image(self):
-        init = Image.open(self.args.init_image).convert("RGB")
-        init = init.resize(
-            self.image_size,  # type: ignore
-            Image.LANCZOS,
-        )
-        init = TF.to_tensor(init).to(self.device).unsqueeze(0).mul(2).sub(1)
-        samples = self.diffusion.p_sample_loop_progressive(
-            self.model,
-            (1, 3, self.model_config["image_size"], self.model_config["image_size"],),
-            clip_denoised=False,
-            model_kwargs={}
-            if self.args.model_output_size == 256
-            else {"y": torch.zeros([self.args.batch_size], device=self.device, dtype=torch.long)},
-            cond_fn=None,
-            progress=True,
-            skip_timesteps=self.args.skip_timesteps,
-            init_image=init,
-            randomize_class=True,
-        )
-        save_image_interval = self.diffusion.num_timesteps // 5
-        max_iterations = self.diffusion.num_timesteps - self.args.skip_timesteps - 1
-        for j, sample in enumerate(samples):
-            if j % save_image_interval == 0 or j == max_iterations:
-                print()
-                filename = os.path.join(self.args.output_path, self.args.output_file)
-                TF.to_pil_image(sample["pred_xstart"][0].add(1).div(2).clamp(0, 1)).save(filename)

spaces/Arnx/MusicGenXvAKN/audiocraft/data/zip.py DELETED Viewed

@@ -1,74 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-import typing
-import zipfile
-from dataclasses import dataclass
-from functools import lru_cache
-from typing_extensions import Literal
-DEFAULT_SIZE = 32
-MODE = Literal['r', 'w', 'x', 'a']
-@dataclass(order=True)
-class PathInZip:
-    """Class for holding a path of file within a zip file.
-    Args:
-        path: The convention is <path_to_zip>:<relative_path_inside_zip>
-            Let's assume there is a zip file /some/location/foo.zip
-            and inside of it is a json file located at /data/file1.json,
-            Then we expect path = "/some/location/foo.zip:/data/file1.json"
-    """
-    INFO_PATH_SEP = ':'
-    zip_path: str
-    file_path: str
-    def __init__(self, path: str) -> None:
-        split_path = path.split(self.INFO_PATH_SEP)
-        assert len(split_path) == 2
-        self.zip_path, self.file_path = split_path
-    @classmethod
-    def from_paths(cls, zip_path: str, file_path: str):
-        return cls(zip_path + cls.INFO_PATH_SEP + file_path)
-    def __str__(self) -> str:
-        return self.zip_path + self.INFO_PATH_SEP + self.file_path
-def _open_zip(path: str, mode: MODE = 'r'):
-    return zipfile.ZipFile(path, mode)
-_cached_open_zip = lru_cache(DEFAULT_SIZE)(_open_zip)
-def set_zip_cache_size(max_size: int):
-    """Sets the maximal LRU caching for zip file opening.
-    Args:
-        max_size: the maximal LRU cache.
-    """
-    global _cached_open_zip
-    _cached_open_zip = lru_cache(max_size)(_open_zip)
-def open_file_in_zip(path_in_zip: PathInZip, mode: str = 'r') -> typing.IO:
-    """Opens a file stored inside a zip and returns a file-like object.
-    Args:
-        path_in_zip: A PathInZip object representing the file to return a file-like object of.
-        mode: The mode in which to open the file with.
-    Returns:
-        A file-like object for PathInZip.
-    """
-    zf = _cached_open_zip(path_in_zip.zip_path)
-    return zf.open(path_in_zip.file_path)

spaces/Astroomx/Mine/README.md DELETED Viewed

@@ -1,10 +0,0 @@
----
-title: Mine
-emoji: 🦀
-colorFrom: pink
-colorTo: green
-sdk: docker
-pinned: false
----
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_internal/metadata/importlib/_envs.py DELETED Viewed

@@ -1,188 +0,0 @@
-import functools
-import importlib.metadata
-import logging
-import os
-import pathlib
-import sys
-import zipfile
-import zipimport
-from typing import Iterator, List, Optional, Sequence, Set, Tuple
-from pip._vendor.packaging.utils import NormalizedName, canonicalize_name
-from pip._internal.metadata.base import BaseDistribution, BaseEnvironment
-from pip._internal.models.wheel import Wheel
-from pip._internal.utils.deprecation import deprecated
-from pip._internal.utils.filetypes import WHEEL_EXTENSION
-from ._compat import BadMetadata, BasePath, get_dist_name, get_info_location
-from ._dists import Distribution
-logger = logging.getLogger(__name__)
-def _looks_like_wheel(location: str) -> bool:
-    if not location.endswith(WHEEL_EXTENSION):
-        return False
-    if not os.path.isfile(location):
-        return False
-    if not Wheel.wheel_file_re.match(os.path.basename(location)):
-        return False
-    return zipfile.is_zipfile(location)
-class _DistributionFinder:
-    """Finder to locate distributions.
-    The main purpose of this class is to memoize found distributions' names, so
-    only one distribution is returned for each package name. At lot of pip code
-    assumes this (because it is setuptools's behavior), and not doing the same
-    can potentially cause a distribution in lower precedence path to override a
-    higher precedence one if the caller is not careful.
-    Eventually we probably want to make it possible to see lower precedence
-    installations as well. It's useful feature, after all.
-    """
-    FoundResult = Tuple[importlib.metadata.Distribution, Optional[BasePath]]
-    def __init__(self) -> None:
-        self._found_names: Set[NormalizedName] = set()
-    def _find_impl(self, location: str) -> Iterator[FoundResult]:
-        """Find distributions in a location."""
-        # Skip looking inside a wheel. Since a package inside a wheel is not
-        # always valid (due to .data directories etc.), its .dist-info entry
-        # should not be considered an installed distribution.
-        if _looks_like_wheel(location):
-            return
-        # To know exactly where we find a distribution, we have to feed in the
-        # paths one by one, instead of dumping the list to importlib.metadata.
-        for dist in importlib.metadata.distributions(path=[location]):
-            info_location = get_info_location(dist)
-            try:
-                raw_name = get_dist_name(dist)
-            except BadMetadata as e:
-                logger.warning("Skipping %s due to %s", info_location, e.reason)
-                continue
-            normalized_name = canonicalize_name(raw_name)
-            if normalized_name in self._found_names:
-                continue
-            self._found_names.add(normalized_name)
-            yield dist, info_location
-    def find(self, location: str) -> Iterator[BaseDistribution]:
-        """Find distributions in a location.
-        The path can be either a directory, or a ZIP archive.
-        """
-        for dist, info_location in self._find_impl(location):
-            if info_location is None:
-                installed_location: Optional[BasePath] = None
-            else:
-                installed_location = info_location.parent
-            yield Distribution(dist, info_location, installed_location)
-    def find_linked(self, location: str) -> Iterator[BaseDistribution]:
-        """Read location in egg-link files and return distributions in there.
-        The path should be a directory; otherwise this returns nothing. This
-        follows how setuptools does this for compatibility. The first non-empty
-        line in the egg-link is read as a path (resolved against the egg-link's
-        containing directory if relative). Distributions found at that linked
-        location are returned.
-        """
-        path = pathlib.Path(location)
-        if not path.is_dir():
-            return
-        for child in path.iterdir():
-            if child.suffix != ".egg-link":
-                continue
-            with child.open() as f:
-                lines = (line.strip() for line in f)
-                target_rel = next((line for line in lines if line), "")
-            if not target_rel:
-                continue
-            target_location = str(path.joinpath(target_rel))
-            for dist, info_location in self._find_impl(target_location):
-                yield Distribution(dist, info_location, path)
-    def _find_eggs_in_dir(self, location: str) -> Iterator[BaseDistribution]:
-        from pip._vendor.pkg_resources import find_distributions
-        from pip._internal.metadata import pkg_resources as legacy
-        with os.scandir(location) as it:
-            for entry in it:
-                if not entry.name.endswith(".egg"):
-                    continue
-                for dist in find_distributions(entry.path):
-                    yield legacy.Distribution(dist)
-    def _find_eggs_in_zip(self, location: str) -> Iterator[BaseDistribution]:
-        from pip._vendor.pkg_resources import find_eggs_in_zip
-        from pip._internal.metadata import pkg_resources as legacy
-        try:
-            importer = zipimport.zipimporter(location)
-        except zipimport.ZipImportError:
-            return
-        for dist in find_eggs_in_zip(importer, location):
-            yield legacy.Distribution(dist)
-    def find_eggs(self, location: str) -> Iterator[BaseDistribution]:
-        """Find eggs in a location.
-        This actually uses the old *pkg_resources* backend. We likely want to
-        deprecate this so we can eventually remove the *pkg_resources*
-        dependency entirely. Before that, this should first emit a deprecation
-        warning for some versions when using the fallback since importing
-        *pkg_resources* is slow for those who don't need it.
-        """
-        if os.path.isdir(location):
-            yield from self._find_eggs_in_dir(location)
-        if zipfile.is_zipfile(location):
-            yield from self._find_eggs_in_zip(location)
-@functools.lru_cache(maxsize=None)  # Warn a distribution exactly once.
-def _emit_egg_deprecation(location: Optional[str]) -> None:
-    deprecated(
-        reason=f"Loading egg at {location} is deprecated.",
-        replacement="to use pip for package installation.",
-        gone_in=None,
-    )
-class Environment(BaseEnvironment):
-    def __init__(self, paths: Sequence[str]) -> None:
-        self._paths = paths
-    @classmethod
-    def default(cls) -> BaseEnvironment:
-        return cls(sys.path)
-    @classmethod
-    def from_paths(cls, paths: Optional[List[str]]) -> BaseEnvironment:
-        if paths is None:
-            return cls(sys.path)
-        return cls(paths)
-    def _iter_distributions(self) -> Iterator[BaseDistribution]:
-        finder = _DistributionFinder()
-        for location in self._paths:
-            yield from finder.find(location)
-            for dist in finder.find_eggs(location):
-                # _emit_egg_deprecation(dist.location)  # TODO: Enable this.
-                yield dist
-            # This must go last because that's how pkg_resources tie-breaks.
-            yield from finder.find_linked(location)
-    def get_distribution(self, name: str) -> Optional[BaseDistribution]:
-        matches = (
-            distribution
-            for distribution in self.iter_all_distributions()
-            if distribution.canonical_name == canonicalize_name(name)
-        )
-        return next(matches, None)

spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/pygments/formatters/pangomarkup.py DELETED Viewed

@@ -1,83 +0,0 @@
-"""
-    pygments.formatters.pangomarkup
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    Formatter for Pango markup output.
-    :copyright: Copyright 2006-2022 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-from pip._vendor.pygments.formatter import Formatter
-__all__ = ['PangoMarkupFormatter']
-_escape_table = {
-    ord('&'): '&amp;',
-    ord('<'): '&lt;',
-}
-def escape_special_chars(text, table=_escape_table):
-    """Escape & and < for Pango Markup."""
-    return text.translate(table)
-class PangoMarkupFormatter(Formatter):
-    """
-    Format tokens as Pango Markup code. It can then be rendered to an SVG.
-    .. versionadded:: 2.9
-    """
-    name = 'Pango Markup'
-    aliases = ['pango', 'pangomarkup']
-    filenames = []
-    def __init__(self, **options):
-        Formatter.__init__(self, **options)
-        self.styles = {}
-        for token, style in self.style:
-            start = ''
-            end = ''
-            if style['color']:
-                start += '<span fgcolor="#%s">' % style['color']
-                end = '</span>' + end
-            if style['bold']:
-                start += '<b>'
-                end = '</b>' + end
-            if style['italic']:
-                start += '<i>'
-                end = '</i>' + end
-            if style['underline']:
-                start += '<u>'
-                end = '</u>' + end
-            self.styles[token] = (start, end)
-    def format_unencoded(self, tokensource, outfile):
-        lastval = ''
-        lasttype = None
-        outfile.write('<tt>')
-        for ttype, value in tokensource:
-            while ttype not in self.styles:
-                ttype = ttype.parent
-            if ttype == lasttype:
-                lastval += escape_special_chars(value)
-            else:
-                if lastval:
-                    stylebegin, styleend = self.styles[lasttype]
-                    outfile.write(stylebegin + lastval + styleend)
-                lastval = escape_special_chars(value)
-                lasttype = ttype
-        if lastval:
-            stylebegin, styleend = self.styles[lasttype]
-            outfile.write(stylebegin + lastval + styleend)
-        outfile.write('</tt>')

spaces/AutomationVR/ImageDemo/app.py DELETED Viewed

@@ -1,3 +0,0 @@
-import gradio as gr
-gr.Interface.load("models/stabilityai/stable-diffusion-xl-base-1.0").launch()

spaces/Bart92/RVC_HF/julius/utils.py DELETED Viewed

@@ -1,101 +0,0 @@
-# File under the MIT license, see https://github.com/adefossez/julius/LICENSE for details.
-# Author: adefossez, 2020
-"""
-Non signal processing related utilities.
-"""
-import inspect
-import typing as tp
-import sys
-import time
-def simple_repr(obj, attrs: tp.Optional[tp.Sequence[str]] = None,
-                overrides: dict = {}):
-    """
-    Return a simple representation string for `obj`.
-    If `attrs` is not None, it should be a list of attributes to include.
-    """
-    params = inspect.signature(obj.__class__).parameters
-    attrs_repr = []
-    if attrs is None:
-        attrs = list(params.keys())
-    for attr in attrs:
-        display = False
-        if attr in overrides:
-            value = overrides[attr]
-        elif hasattr(obj, attr):
-            value = getattr(obj, attr)
-        else:
-            continue
-        if attr in params:
-            param = params[attr]
-            if param.default is inspect._empty or value != param.default:  # type: ignore
-                display = True
-        else:
-            display = True
-        if display:
-            attrs_repr.append(f"{attr}={value}")
-    return f"{obj.__class__.__name__}({','.join(attrs_repr)})"
-class MarkdownTable:
-    """
-    Simple MarkdownTable generator. The column titles should be large enough
-    for the lines content. This will right align everything.
-    >>> import io  # we use io purely for test purposes, default is sys.stdout.
-    >>> file = io.StringIO()
-    >>> table = MarkdownTable(["Item Name", "Price"], file=file)
-    >>> table.header(); table.line(["Honey", "5"]); table.line(["Car", "5,000"])
-    >>> print(file.getvalue().strip())  # Strip for test purposes
-    | Item Name | Price |
-    |-----------|-------|
-    |     Honey |     5 |
-    |       Car | 5,000 |
-    """
-    def __init__(self, columns, file=sys.stdout):
-        self.columns = columns
-        self.file = file
-    def _writeln(self, line):
-        self.file.write("|" + "|".join(line) + "|\n")
-    def header(self):
-        self._writeln(f" {col} " for col in self.columns)
-        self._writeln("-" * (len(col) + 2) for col in self.columns)
-    def line(self, line):
-        out = []
-        for val, col in zip(line, self.columns):
-            val = format(val, '>' + str(len(col)))
-            out.append(" " + val + " ")
-        self._writeln(out)
-class Chrono:
-    """
-    Measures ellapsed time, calling `torch.cuda.synchronize` if necessary.
-    `Chrono` instances can be used as context managers (e.g. with `with`).
-    Upon exit of the block, you can access the duration of the block in seconds
-    with the `duration` attribute.
-    >>> with Chrono() as chrono:
-    ...     _ = sum(range(10_000))
-    ...
-    >>> print(chrono.duration < 10)  # Should be true unless on a really slow computer.
-    True
-    """
-    def __init__(self):
-        self.duration = None
-    def __enter__(self):
-        self._begin = time.time()
-        return self
-    def __exit__(self, exc_type, exc_value, exc_tracebck):
-        import torch
-        if torch.cuda.is_available():
-            torch.cuda.synchronize()
-        self.duration = time.time() - self._begin

spaces/Benson/text-generation/Examples/Ciudad Dragn Mvil Mod Apk Dinero Ilimitado Y Gemas 2022.md DELETED Viewed

@@ -1,35 +0,0 @@
-<br />
-<h1>Dragon City móvil Mod APK dinero ilimitado y joyas 2022</h1>
-<p>¿Te gustan los dragones? ¿Quieres construir tu propia ciudad dragón y gobernar los cielos? ¿Quieres tener recursos ilimitados y acceso a todas las características del juego? Si es así, entonces estás en el lugar correcto. En este artículo, le diremos todo lo que necesita saber sobre Dragon City Mobile Mod APK, una versión modificada del popular juego de simulación que le permite disfrutar de dinero y gemas ilimitadas, dragones e islas ilimitadas, fácil cría y eclosión, sin anuncios, y sin raíz requerida. Sigue leyendo para saber más. </p>
-<h2>ciudad dragón móvil mod apk dinero ilimitado y gemas 2022</h2><br /><p><b><b>Download File</b> > <a href="https://bltlly.com/2v6IUX">https://bltlly.com/2v6IUX</a></b></p><br /><br />
-<h2>Introducción</h2>
-<h3>¿Qué es Dragon City Mobile? </h3>
-<p>Dragon City Mobile es un juego de simulación desarrollado por Socialpoint, donde puedes crear tu propia ciudad dragón en islas flotantes y llenarla de granjas, hábitats, edificios y dragones. Puedes recoger más de 1000 dragones diferentes y criarlos para crear otros nuevos. También puedes entrenar a tus dragones y hacerlos luchar en arenas contra otros jugadores. Puedes unirte a alianzas, chatear con otros maestros dragones, participar en eventos y completar misiones para ganar recompensas. Dragon City Mobile es un juego divertido y adictivo que te mantendrá entretenido durante horas. </p>
-<h3>¿Qué es Dragon City Mobile Mod APK? </h3>
-<p>Dragon City Mobile Mod APK es una versión modificada del juego original que le da acceso a dinero y gemas ilimitadas, dragones e islas ilimitadas, fácil cría y eclosión, sin anuncios, y no se requiere raíz. Con este mod apk, se puede disfrutar de todas las características del juego sin limitaciones o restricciones. Puedes comprar lo que quieras, desbloquear cualquier dragón que quieras, expandir tu ciudad tanto como quieras, criar y eclosionar cualquier dragón que quieras, y jugar el juego sin interrupciones ni molestias. </p>
-<h3> ¿Por qué usar Dragon City Mobile Mod APK? </h3>
-<p>Hay muchas razones por las que debe utilizar Dragon City Mobile Mod APK en lugar del juego original. Aquí están algunos de ellos:</p>
-<ul>
-<li>Usted puede tener más diversión y emoción por conseguir dragones e islas ilimitadas de forma gratuita. No tienes que esperar horas o días para criar o eclosionar a tus dragones. Puedes conseguir cualquier dragón que quieras al instante. También puedes expandir tu ciudad tanto como quieras y decorarla con varios edificios y objetos. </li>
-<li>Usted puede tener más control y flexibilidad al obtener fácil cría y eclosión gratis. No tienes que seguir ninguna regla o patrón para criar o eclosionar a tus dragones. Puedes mezclar los dos dragones que quieras y conseguir uno nuevo. También puedes acelerar el proceso usando gemas. </li>
-<li>Usted puede tener una mejor experiencia de juego mediante la obtención de ningún anuncio y ninguna raíz necesaria de forma gratuita. No tienes que lidiar con anuncios molestos que aparecen cada pocos minutos o interrumpen tu juego. Tampoco tienes que rootear tu dispositivo o arriesgarte a dañarlo para usar el mod apk. </li>
-</ul>
-<h2>Características de Dragon City Mobile Mod APK</h2>
-<h3>Dinero ilimitado y gemas</h3>
-<p>La característica más importante de Dragon City Mobile Mod APK es que le da dinero ilimitado y gemas gratis. El dinero y las gemas son las principales monedas en el juego que necesitas para comprar objetos, desbloquear dragones, expandir tu ciudad, acelerar los procesos, etc. Con dinero y gemas ilimitadas, puedes comprar cualquier cosa que quieras es una versión modificada del juego original que te da acceso a dinero ilimitado y gemas, dragones e islas ilimitadas, fácil cría y eclosión, sin anuncios, y no se requiere raíz. Con este mod apk, se puede disfrutar de todas las características del juego sin limitaciones o restricciones. Puedes comprar lo que quieras, desbloquear cualquier dragón que quieras, expandir tu ciudad tanto como quieras, criar y eclosionar cualquier dragón que quieras, y jugar el juego sin interrupciones ni molestias. </p>
-<h2>Preguntas frecuentes</h2>
-<p>Aquí hay algunas preguntas frecuentes sobre Dragon City Mobile Mod APK:</p>
-<p></p>
-<h3>Q: ¿Es seguro usar Dragon City Mobile Mod APK? </h3>
-<p>A: Sí, Dragon City Mobile Mod APK es seguro de usar, siempre y cuando lo descargue de una fuente confiable. Hemos probado el archivo apk mod en nuestros dispositivos y no encontramos malware o virus. Sin embargo, le recomendamos que escanee el archivo con un antivirus antes de instalarlo, solo para estar seguro. </p>
-<h3>Q: ¿Es Dragon City Mobile Mod APK compatible con mi dispositivo? </h3>
-<p>A: Dragon City Mobile Mod APK es compatible con la mayoría de los dispositivos Android que se ejecutan en Android 4.4 o superior. Sin embargo, algunos dispositivos pueden no ser compatibles con el mod apk debido a diferentes especificaciones o configuraciones. Si encuentras algún problema al instalar o reproducir el apk mod, intenta cambiar la configuración de tu dispositivo o ponte en contacto con el desarrollador para obtener ayuda. </p>
-<h3>Q: ¿Voy a conseguir prohibido para el uso de Dragon City Mobile Mod APK? </h3>
-<p>A: No, no se le prohibió el uso de Dragon City Mobile Mod APK, como el mod apk no interfiere con los servidores del juego o características en línea. Puedes jugar el juego normalmente con otros jugadores sin ningún riesgo de ser expulsado. Sin embargo, le aconsejamos que utilice el apk mod de forma responsable y no abusar de sus características para obtener una ventaja injusta sobre otros jugadores. </p>
-<h3>Q: ¿Puedo actualizar Dragon City Mobile Mod APK? </h3>
-<p>A: Sí, puede actualizar Dragon City Mobile Mod APK cada vez que una nueva versión está disponible. Sin embargo, tendrá que descargar e instalar el nuevo archivo apk mod manualmente desde la misma fuente que antes. No se puede actualizar el mod apk desde la Google Play Store o el sitio web oficial del juego. </p>
-<h3>Q: ¿Puedo usar Dragon City Mobile Mod APK con mi cuenta existente? </h3> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Conseguir Sobre l Descarga Gratuita Para Pc Ventanas 7 Apkpure.md DELETED Viewed

@@ -1,44 +0,0 @@
-<h1>Captain Tsubasa: Dream Team - El juego de simulación de fútbol definitivo</h1>
-<p>Si eres un fan del fútbol y el manga, es posible que hayas oído hablar del Capitán Tsubasa, la popular serie de cómics que influyó en muchas estrellas del fútbol y jugadores de todo el mundo. Pero ¿sabías que hay un juego basado en este cómic que te permite crear tu propio equipo de ensueño y tener partidos acalorados con jugadores de diferentes países? En este artículo, te presentaremos Captain Tsubasa: Dream Team, el juego de simulación de fútbol competitivo amado por más de 150 países. Te diremos de qué se trata este juego, cómo jugarlo y por qué deberías probarlo. </p>
- <h2>¿Qué es el Capitán Tsubasa: Dream Team? </h2>
-<h3>El juego basado en el popular cómic de fútbol</h3>
-<p>Captain Tsubasa: Dream Team es un juego desarrollado por KLab, una compañía japonesa que se especializa en juegos móviles. Se basa en la serie de manga Captain Tsubasa, que fue creada por Yoichi Takahashi en 1981 y ha sido serializada en varias revistas y adaptada al anime, películas y videojuegos. El cómic sigue las aventuras de Tsubasa Ozora, un joven prodigio del fútbol que sueña con convertirse en un jugador de clase mundial y ganar la Copa del Mundo para Japón. En el camino, conoce a muchos amigos y rivales que comparten su pasión por el deporte y lo desafían a mejorar sus habilidades. </p>
-<h2>conseguir sobre él descarga gratuita para pc ventanas 7 apkpure</h2><br /><p><b><b>Download Zip</b> &bull;&bull;&bull; <a href="https://bltlly.com/2v6Jgg">https://bltlly.com/2v6Jgg</a></b></p><br /><br />
-<h3>Las características y modos del juego</h3>
-<p>Captain Tsubasa: Dream Team es un juego que combina elementos de simulación de fútbol, juegos de rol y recolección de cartas. Puedes elegir entre cientos de personajes del cómic original, cada uno con sus propias habilidades y habilidades únicas, y formar tu propio equipo de ensueño. También puedes personalizar los uniformes, las formaciones y las habilidades de tu equipo para adaptarlos a tus preferencias y estrategias. </p>
- <h2>¿Cómo se juega Captain Tsubasa: Dream Team? </h2>
-<h3>Cómo crear tu propio equipo de ensueño</h3>
-<p>Para empezar a jugar Captain Tsubasa: Dream Team, necesitas crear tu propio equipo. Puedes hacer esto usando Transfer Tickets o Dreamballs, que son las monedas del juego, para obtener jugadores de varios banners. También puedes conseguir jugadores de eventos, misiones, redadas y escenarios. Puedes tener hasta 32 jugadores en tu equipo, pero solo 11 pueden jugar en el campo a la vez. </p>
-<p>Puedes asignar diferentes posiciones y roles a tus jugadores de acuerdo a sus atributos y habilidades. Hay cinco atributos en el juego: Agilidad (azul), Habilidad (verde), Dureza (rojo), Solidaridad (amarillo) y Insight Master (púrpura). Cada atributo tiene sus propias fortalezas y debilidades contra otros atributos. También hay cuatro roles en el juego: Delantero (FW), Centrocampista (MF), Defensor (DF) y Portero (GK). Cada rol tiene sus propias responsabilidades y funciones en el campo. </p>
-<h3>Cómo mejorar tus jugadores y habilidades</h3>
-<p>Para hacer tu equipo más fuerte, necesitas mejorar tus jugadores y habilidades. Usted puede hacer esto mediante el uso de varios elementos y materiales que usted puede obtener de jugar el juego. Puede mejorar el nivel de sus jugadores, rareza, potencial, y límite de rotura mediante el uso de entrenadores, taladros, cuadernos, y limitar los elementos de ruptura. También puedes mejorar el nivel y la evolución de tus habilidades mediante el uso de jugadores de campo de habilidad, bolas negras y cartas de eliminación de habilidades. También puedes transferir habilidades de un jugador a otro usando tickets de transferencia de habilidades. </p>
-<h3>Cómo competir con otros jugadores de todo el mundo</h3>
-<p>Para poner a prueba tus habilidades y estrategias, puedes jugar partidas online con otros jugadores de todo el mundo. Puedes elegir entre diferentes modos, como Rank Match, Group Match, Friendly Match y Quick Match. Cada modo tiene sus propias reglas y recompensas. También puede unirse o crear un club con otros jugadores y chatear, cooperar y competir con ellos. </p>
-<p>El resultado del partido depende de varios factores, tales como los atributos de tus jugadores, habilidades, resistencia, poder de equipo, habilidades de equipo, lazos, habilidades ocultas y habilidades pasivas. También debe considerar la ventaja de emparejamiento, la tasa crítica, la distancia, el ángulo y el momento de sus acciones. Necesitas usar tu ingenio y creatividad para vencer a tus oponentes y ganar el partido. </p>
- <h2>¿Por qué deberías jugar Captain Tsubasa: Dream Team? </h2>
-<h3>El juego es divertido y atractivo para los aficionados al fútbol</h3>
-<p>Si te gusta el fútbol, te encantará Captain Tsubasa: Dream Team. El juego es divertido y atractivo para los aficionados al fútbol de todas las edades y niveles. Usted puede disfrutar de la emoción y la emoción de los partidos de fútbol con gráficos realistas y efectos de sonido. También puede experimentar el drama y la emoción del cómic original con impresionantes animaciones y voces en off. También puedes aprender más sobre las tácticas y técnicas del fútbol en los tutoriales y consejos del juego. </p>
-<p></p>
-<h3>El juego es fiel al cómic original y los personajes</h3>
-<p>Si eres un fan de Captain Tsubasa, apreciarás lo fiel que es el juego al cómic y a los personajes originales. El juego cuenta con cientos de personajes del cómic, cada uno con su propia personalidad, apariencia, voz, habilidades y historia de fondo. Puedes recoger tus personajes favoritos y revivir sus momentos icónicos en el juego. También puedes descubrir nuevas historias y escenarios que son exclusivos del juego. </p>
-<h3>El juego tiene una comunidad vibrante y activa</h3>
- <h2>Conclusión</h2>
-<p>Captain Tsubasa: Dream Team es un juego que combina simulación de fútbol, juegos de rol y recolección de cartas. Se basa en la popular serie cómica Captain Tsubasa que influyó en muchas estrellas del fútbol y jugadores de todo el mundo. Te permite crear tu propio equipo de ensueño y tener partidos acalorados con jugadores de diferentes países. Es divertido y atractivo para los aficionados al fútbol de todas las edades y niveles. Es fiel al cómic y los personajes originales. Tiene una comunidad vibrante y activa a la que puedes unirte o crear. </p>
-<p>Si estás buscando un juego que desafíe tus habilidades y estrategias, así como entretenerte con su historia y personajes, definitivamente deberías probar Captain Tsubasa: Dream Team. Puede descargar el juego de forma gratuita desde la App Store o Google Play y comenzar su aventura de fútbol hoy. También puedes visitar el sitio web oficial del juego para obtener más información y soporte. </p>
- <h2>Preguntas frecuentes</h2>
-<h4>¿Cuáles son los requisitos del sistema para el Capitán Tsubasa: Dream Team? </h4>
-<p>El juego requiere iOS 10.0 o posterior, o Android 4.4 o posterior. También requiere una conexión a Internet estable y al menos 3 GB de espacio de almacenamiento gratuito. </p>
-<h4>¿Cómo puedo obtener más boletos de transferencia y Dreamballs? </h4>
-<p>Puedes obtener más Boletos de Transferencia y Dreamballs completando misiones, iniciando sesión diariamente, participando en eventos, viendo anuncios o comprándolos con dinero real. </p>
-<h4>¿Cómo puedo conseguir más jugadores y habilidades? </h4>
-<p>Puedes conseguir más jugadores y habilidades usando Transfer Tickets o Dreamballs para obtenerlos de banners, o obteniéndolos de eventos, misiones, redadas y escenarios. También puedes intercambiar medallas o monedas por jugadores y habilidades en la tienda. </p>
-<h4>¿Cómo puedo unirme o crear un club? </h4>
-<h4>¿Cómo puedo contactar al equipo de soporte del juego? </h4>
-<p>Puede ponerse en contacto con el equipo de soporte del juego tocando el botón de menú en la pantalla de inicio y luego tocando el botón de soporte. También puede enviar un correo electrónico a [email protected] o visitar el sitio web oficial del juego para obtener más ayuda. </p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Big-Web/MMSD/env/Lib/site-packages/botocore/credentials.py DELETED Viewed

@@ -1,2262 +0,0 @@
-# Copyright (c) 2012-2013 Mitch Garnaat http://garnaat.org/
-# Copyright 2012-2014 Amazon.com, Inc. or its affiliates. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License"). You
-# may not use this file except in compliance with the License. A copy of
-# the License is located at
-#
-# http://aws.amazon.com/apache2.0/
-#
-# or in the "license" file accompanying this file. This file is
-# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
-# ANY KIND, either express or implied. See the License for the specific
-# language governing permissions and limitations under the License.
-import datetime
-import getpass
-import json
-import logging
-import os
-import subprocess
-import threading
-import time
-from collections import namedtuple
-from copy import deepcopy
-from hashlib import sha1
-from dateutil.parser import parse
-from dateutil.tz import tzlocal, tzutc
-import botocore.compat
-import botocore.configloader
-from botocore import UNSIGNED
-from botocore.compat import compat_shell_split, total_seconds
-from botocore.config import Config
-from botocore.exceptions import (
-    ConfigNotFound,
-    CredentialRetrievalError,
-    InfiniteLoopConfigError,
-    InvalidConfigError,
-    MetadataRetrievalError,
-    PartialCredentialsError,
-    RefreshWithMFAUnsupportedError,
-    UnauthorizedSSOTokenError,
-    UnknownCredentialError,
-)
-from botocore.tokens import SSOTokenProvider
-from botocore.utils import (
-    ContainerMetadataFetcher,
-    FileWebIdentityTokenLoader,
-    InstanceMetadataFetcher,
-    JSONFileCache,
-    SSOTokenLoader,
-    parse_key_val_file,
-    resolve_imds_endpoint_mode,
-)
-logger = logging.getLogger(__name__)
-ReadOnlyCredentials = namedtuple(
-    'ReadOnlyCredentials', ['access_key', 'secret_key', 'token']
-)
-_DEFAULT_MANDATORY_REFRESH_TIMEOUT = 10 * 60  # 10 min
-_DEFAULT_ADVISORY_REFRESH_TIMEOUT = 15 * 60  # 15 min
-def create_credential_resolver(session, cache=None, region_name=None):
-    """Create a default credential resolver.
-    This creates a pre-configured credential resolver
-    that includes the default lookup chain for
-    credentials.
-    """
-    profile_name = session.get_config_variable('profile') or 'default'
-    metadata_timeout = session.get_config_variable('metadata_service_timeout')
-    num_attempts = session.get_config_variable('metadata_service_num_attempts')
-    disable_env_vars = session.instance_variables().get('profile') is not None
-    imds_config = {
-        'ec2_metadata_service_endpoint': session.get_config_variable(
-            'ec2_metadata_service_endpoint'
-        ),
-        'ec2_metadata_service_endpoint_mode': resolve_imds_endpoint_mode(
-            session
-        ),
-        'ec2_credential_refresh_window': _DEFAULT_ADVISORY_REFRESH_TIMEOUT,
-    }
-    if cache is None:
-        cache = {}
-    env_provider = EnvProvider()
-    container_provider = ContainerProvider()
-    instance_metadata_provider = InstanceMetadataProvider(
-        iam_role_fetcher=InstanceMetadataFetcher(
-            timeout=metadata_timeout,
-            num_attempts=num_attempts,
-            user_agent=session.user_agent(),
-            config=imds_config,
-        )
-    )
-    profile_provider_builder = ProfileProviderBuilder(
-        session, cache=cache, region_name=region_name
-    )
-    assume_role_provider = AssumeRoleProvider(
-        load_config=lambda: session.full_config,
-        client_creator=_get_client_creator(session, region_name),
-        cache=cache,
-        profile_name=profile_name,
-        credential_sourcer=CanonicalNameCredentialSourcer(
-            [env_provider, container_provider, instance_metadata_provider]
-        ),
-        profile_provider_builder=profile_provider_builder,
-    )
-    pre_profile = [
-        env_provider,
-        assume_role_provider,
-    ]
-    profile_providers = profile_provider_builder.providers(
-        profile_name=profile_name,
-        disable_env_vars=disable_env_vars,
-    )
-    post_profile = [
-        OriginalEC2Provider(),
-        BotoProvider(),
-        container_provider,
-        instance_metadata_provider,
-    ]
-    providers = pre_profile + profile_providers + post_profile
-    if disable_env_vars:
-        # An explicitly provided profile will negate an EnvProvider.
-        # We will defer to providers that understand the "profile"
-        # concept to retrieve credentials.
-        # The one edge case if is all three values are provided via
-        # env vars:
-        # export AWS_ACCESS_KEY_ID=foo
-        # export AWS_SECRET_ACCESS_KEY=bar
-        # export AWS_PROFILE=baz
-        # Then, just like our client() calls, the explicit credentials
-        # will take precedence.
-        #
-        # This precedence is enforced by leaving the EnvProvider in the chain.
-        # This means that the only way a "profile" would win is if the
-        # EnvProvider does not return credentials, which is what we want
-        # in this scenario.
-        providers.remove(env_provider)
-        logger.debug(
-            'Skipping environment variable credential check'
-            ' because profile name was explicitly set.'
-        )
-    resolver = CredentialResolver(providers=providers)
-    return resolver
-class ProfileProviderBuilder:
-    """This class handles the creation of profile based providers.
-    NOTE: This class is only intended for internal use.
-    This class handles the creation and ordering of the various credential
-    providers that primarly source their configuration from the shared config.
-    This is needed to enable sharing between the default credential chain and
-    the source profile chain created by the assume role provider.
-    """
-    def __init__(
-        self, session, cache=None, region_name=None, sso_token_cache=None
-    ):
-        self._session = session
-        self._cache = cache
-        self._region_name = region_name
-        self._sso_token_cache = sso_token_cache
-    def providers(self, profile_name, disable_env_vars=False):
-        return [
-            self._create_web_identity_provider(
-                profile_name,
-                disable_env_vars,
-            ),
-            self._create_sso_provider(profile_name),
-            self._create_shared_credential_provider(profile_name),
-            self._create_process_provider(profile_name),
-            self._create_config_provider(profile_name),
-        ]
-    def _create_process_provider(self, profile_name):
-        return ProcessProvider(
-            profile_name=profile_name,
-            load_config=lambda: self._session.full_config,
-        )
-    def _create_shared_credential_provider(self, profile_name):
-        credential_file = self._session.get_config_variable('credentials_file')
-        return SharedCredentialProvider(
-            profile_name=profile_name,
-            creds_filename=credential_file,
-        )
-    def _create_config_provider(self, profile_name):
-        config_file = self._session.get_config_variable('config_file')
-        return ConfigProvider(
-            profile_name=profile_name,
-            config_filename=config_file,
-        )
-    def _create_web_identity_provider(self, profile_name, disable_env_vars):
-        return AssumeRoleWithWebIdentityProvider(
-            load_config=lambda: self._session.full_config,
-            client_creator=_get_client_creator(
-                self._session, self._region_name
-            ),
-            cache=self._cache,
-            profile_name=profile_name,
-            disable_env_vars=disable_env_vars,
-        )
-    def _create_sso_provider(self, profile_name):
-        return SSOProvider(
-            load_config=lambda: self._session.full_config,
-            client_creator=self._session.create_client,
-            profile_name=profile_name,
-            cache=self._cache,
-            token_cache=self._sso_token_cache,
-            token_provider=SSOTokenProvider(
-                self._session,
-                cache=self._sso_token_cache,
-                profile_name=profile_name,
-            ),
-        )
-def get_credentials(session):
-    resolver = create_credential_resolver(session)
-    return resolver.load_credentials()
-def _local_now():
-    return datetime.datetime.now(tzlocal())
-def _parse_if_needed(value):
-    if isinstance(value, datetime.datetime):
-        return value
-    return parse(value)
-def _serialize_if_needed(value, iso=False):
-    if isinstance(value, datetime.datetime):
-        if iso:
-            return value.isoformat()
-        return value.strftime('%Y-%m-%dT%H:%M:%S%Z')
-    return value
-def _get_client_creator(session, region_name):
-    def client_creator(service_name, **kwargs):
-        create_client_kwargs = {'region_name': region_name}
-        create_client_kwargs.update(**kwargs)
-        return session.create_client(service_name, **create_client_kwargs)
-    return client_creator
-def create_assume_role_refresher(client, params):
-    def refresh():
-        response = client.assume_role(**params)
-        credentials = response['Credentials']
-        # We need to normalize the credential names to
-        # the values expected by the refresh creds.
-        return {
-            'access_key': credentials['AccessKeyId'],
-            'secret_key': credentials['SecretAccessKey'],
-            'token': credentials['SessionToken'],
-            'expiry_time': _serialize_if_needed(credentials['Expiration']),
-        }
-    return refresh
-def create_mfa_serial_refresher(actual_refresh):
-    class _Refresher:
-        def __init__(self, refresh):
-            self._refresh = refresh
-            self._has_been_called = False
-        def __call__(self):
-            if self._has_been_called:
-                # We can explore an option in the future to support
-                # reprompting for MFA, but for now we just error out
-                # when the temp creds expire.
-                raise RefreshWithMFAUnsupportedError()
-            self._has_been_called = True
-            return self._refresh()
-    return _Refresher(actual_refresh)
-class Credentials:
-    """
-    Holds the credentials needed to authenticate requests.
-    :param str access_key: The access key part of the credentials.
-    :param str secret_key: The secret key part of the credentials.
-    :param str token: The security token, valid only for session credentials.
-    :param str method: A string which identifies where the credentials
-        were found.
-    """
-    def __init__(self, access_key, secret_key, token=None, method=None):
-        self.access_key = access_key
-        self.secret_key = secret_key
-        self.token = token
-        if method is None:
-            method = 'explicit'
-        self.method = method
-        self._normalize()
-    def _normalize(self):
-        # Keys would sometimes (accidentally) contain non-ascii characters.
-        # It would cause a confusing UnicodeDecodeError in Python 2.
-        # We explicitly convert them into unicode to avoid such error.
-        #
-        # Eventually the service will decide whether to accept the credential.
-        # This also complies with the behavior in Python 3.
-        self.access_key = botocore.compat.ensure_unicode(self.access_key)
-        self.secret_key = botocore.compat.ensure_unicode(self.secret_key)
-    def get_frozen_credentials(self):
-        return ReadOnlyCredentials(
-            self.access_key, self.secret_key, self.token
-        )
-class RefreshableCredentials(Credentials):
-    """
-    Holds the credentials needed to authenticate requests. In addition, it
-    knows how to refresh itself.
-    :param str access_key: The access key part of the credentials.
-    :param str secret_key: The secret key part of the credentials.
-    :param str token: The security token, valid only for session credentials.
-    :param function refresh_using: Callback function to refresh the credentials.
-    :param str method: A string which identifies where the credentials
-        were found.
-    :param function time_fetcher: Callback function to retrieve current time.
-    """
-    # The time at which we'll attempt to refresh, but not
-    # block if someone else is refreshing.
-    _advisory_refresh_timeout = _DEFAULT_ADVISORY_REFRESH_TIMEOUT
-    # The time at which all threads will block waiting for
-    # refreshed credentials.
-    _mandatory_refresh_timeout = _DEFAULT_MANDATORY_REFRESH_TIMEOUT
-    def __init__(
-        self,
-        access_key,
-        secret_key,
-        token,
-        expiry_time,
-        refresh_using,
-        method,
-        time_fetcher=_local_now,
-    ):
-        self._refresh_using = refresh_using
-        self._access_key = access_key
-        self._secret_key = secret_key
-        self._token = token
-        self._expiry_time = expiry_time
-        self._time_fetcher = time_fetcher
-        self._refresh_lock = threading.Lock()
-        self.method = method
-        self._frozen_credentials = ReadOnlyCredentials(
-            access_key, secret_key, token
-        )
-        self._normalize()
-    def _normalize(self):
-        self._access_key = botocore.compat.ensure_unicode(self._access_key)
-        self._secret_key = botocore.compat.ensure_unicode(self._secret_key)
-    @classmethod
-    def create_from_metadata(cls, metadata, refresh_using, method):
-        instance = cls(
-            access_key=metadata['access_key'],
-            secret_key=metadata['secret_key'],
-            token=metadata['token'],
-            expiry_time=cls._expiry_datetime(metadata['expiry_time']),
-            method=method,
-            refresh_using=refresh_using,
-        )
-        return instance
-    @property
-    def access_key(self):
-        """Warning: Using this property can lead to race conditions if you
-        access another property subsequently along the refresh boundary.
-        Please use get_frozen_credentials instead.
-        """
-        self._refresh()
-        return self._access_key
-    @access_key.setter
-    def access_key(self, value):
-        self._access_key = value
-    @property
-    def secret_key(self):
-        """Warning: Using this property can lead to race conditions if you
-        access another property subsequently along the refresh boundary.
-        Please use get_frozen_credentials instead.
-        """
-        self._refresh()
-        return self._secret_key
-    @secret_key.setter
-    def secret_key(self, value):
-        self._secret_key = value
-    @property
-    def token(self):
-        """Warning: Using this property can lead to race conditions if you
-        access another property subsequently along the refresh boundary.
-        Please use get_frozen_credentials instead.
-        """
-        self._refresh()
-        return self._token
-    @token.setter
-    def token(self, value):
-        self._token = value
-    def _seconds_remaining(self):
-        delta = self._expiry_time - self._time_fetcher()
-        return total_seconds(delta)
-    def refresh_needed(self, refresh_in=None):
-        """Check if a refresh is needed.
-        A refresh is needed if the expiry time associated
-        with the temporary credentials is less than the
-        provided ``refresh_in``.  If ``time_delta`` is not
-        provided, ``self.advisory_refresh_needed`` will be used.
-        For example, if your temporary credentials expire
-        in 10 minutes and the provided ``refresh_in`` is
-        ``15 * 60``, then this function will return ``True``.
-        :type refresh_in: int
-        :param refresh_in: The number of seconds before the
-            credentials expire in which refresh attempts should
-            be made.
-        :return: True if refresh needed, False otherwise.
-        """
-        if self._expiry_time is None:
-            # No expiration, so assume we don't need to refresh.
-            return False
-        if refresh_in is None:
-            refresh_in = self._advisory_refresh_timeout
-        # The credentials should be refreshed if they're going to expire
-        # in less than 5 minutes.
-        if self._seconds_remaining() >= refresh_in:
-            # There's enough time left. Don't refresh.
-            return False
-        logger.debug("Credentials need to be refreshed.")
-        return True
-    def _is_expired(self):
-        # Checks if the current credentials are expired.
-        return self.refresh_needed(refresh_in=0)
-    def _refresh(self):
-        # In the common case where we don't need a refresh, we
-        # can immediately exit and not require acquiring the
-        # refresh lock.
-        if not self.refresh_needed(self._advisory_refresh_timeout):
-            return
-        # acquire() doesn't accept kwargs, but False is indicating
-        # that we should not block if we can't acquire the lock.
-        # If we aren't able to acquire the lock, we'll trigger
-        # the else clause.
-        if self._refresh_lock.acquire(False):
-            try:
-                if not self.refresh_needed(self._advisory_refresh_timeout):
-                    return
-                is_mandatory_refresh = self.refresh_needed(
-                    self._mandatory_refresh_timeout
-                )
-                self._protected_refresh(is_mandatory=is_mandatory_refresh)
-                return
-            finally:
-                self._refresh_lock.release()
-        elif self.refresh_needed(self._mandatory_refresh_timeout):
-            # If we're within the mandatory refresh window,
-            # we must block until we get refreshed credentials.
-            with self._refresh_lock:
-                if not self.refresh_needed(self._mandatory_refresh_timeout):
-                    return
-                self._protected_refresh(is_mandatory=True)
-    def _protected_refresh(self, is_mandatory):
-        # precondition: this method should only be called if you've acquired
-        # the self._refresh_lock.
-        try:
-            metadata = self._refresh_using()
-        except Exception:
-            period_name = 'mandatory' if is_mandatory else 'advisory'
-            logger.warning(
-                "Refreshing temporary credentials failed "
-                "during %s refresh period.",
-                period_name,
-                exc_info=True,
-            )
-            if is_mandatory:
-                # If this is a mandatory refresh, then
-                # all errors that occur when we attempt to refresh
-                # credentials are propagated back to the user.
-                raise
-            # Otherwise we'll just return.
-            # The end result will be that we'll use the current
-            # set of temporary credentials we have.
-            return
-        self._set_from_data(metadata)
-        self._frozen_credentials = ReadOnlyCredentials(
-            self._access_key, self._secret_key, self._token
-        )
-        if self._is_expired():
-            # We successfully refreshed credentials but for whatever
-            # reason, our refreshing function returned credentials
-            # that are still expired.  In this scenario, the only
-            # thing we can do is let the user know and raise
-            # an exception.
-            msg = (
-                "Credentials were refreshed, but the "
-                "refreshed credentials are still expired."
-            )
-            logger.warning(msg)
-            raise RuntimeError(msg)
-    @staticmethod
-    def _expiry_datetime(time_str):
-        return parse(time_str)
-    def _set_from_data(self, data):
-        expected_keys = ['access_key', 'secret_key', 'token', 'expiry_time']
-        if not data:
-            missing_keys = expected_keys
-        else:
-            missing_keys = [k for k in expected_keys if k not in data]
-        if missing_keys:
-            message = "Credential refresh failed, response did not contain: %s"
-            raise CredentialRetrievalError(
-                provider=self.method,
-                error_msg=message % ', '.join(missing_keys),
-            )
-        self.access_key = data['access_key']
-        self.secret_key = data['secret_key']
-        self.token = data['token']
-        self._expiry_time = parse(data['expiry_time'])
-        logger.debug(
-            "Retrieved credentials will expire at: %s", self._expiry_time
-        )
-        self._normalize()
-    def get_frozen_credentials(self):
-        """Return immutable credentials.
-        The ``access_key``, ``secret_key``, and ``token`` properties
-        on this class will always check and refresh credentials if
-        needed before returning the particular credentials.
-        This has an edge case where you can get inconsistent
-        credentials.  Imagine this:
-            # Current creds are "t1"
-            tmp.access_key  ---> expired? no, so return t1.access_key
-            # ---- time is now expired, creds need refreshing to "t2" ----
-            tmp.secret_key  ---> expired? yes, refresh and return t2.secret_key
-        This means we're using the access key from t1 with the secret key
-        from t2.  To fix this issue, you can request a frozen credential object
-        which is guaranteed not to change.
-        The frozen credentials returned from this method should be used
-        immediately and then discarded.  The typical usage pattern would
-        be::
-            creds = RefreshableCredentials(...)
-            some_code = SomeSignerObject()
-            # I'm about to sign the request.
-            # The frozen credentials are only used for the
-            # duration of generate_presigned_url and will be
-            # immediately thrown away.
-            request = some_code.sign_some_request(
-                with_credentials=creds.get_frozen_credentials())
-            print("Signed request:", request)
-        """
-        self._refresh()
-        return self._frozen_credentials
-class DeferredRefreshableCredentials(RefreshableCredentials):
-    """Refreshable credentials that don't require initial credentials.
-    refresh_using will be called upon first access.
-    """
-    def __init__(self, refresh_using, method, time_fetcher=_local_now):
-        self._refresh_using = refresh_using
-        self._access_key = None
-        self._secret_key = None
-        self._token = None
-        self._expiry_time = None
-        self._time_fetcher = time_fetcher
-        self._refresh_lock = threading.Lock()
-        self.method = method
-        self._frozen_credentials = None
-    def refresh_needed(self, refresh_in=None):
-        if self._frozen_credentials is None:
-            return True
-        return super().refresh_needed(refresh_in)
-class CachedCredentialFetcher:
-    DEFAULT_EXPIRY_WINDOW_SECONDS = 60 * 15
-    def __init__(self, cache=None, expiry_window_seconds=None):
-        if cache is None:
-            cache = {}
-        self._cache = cache
-        self._cache_key = self._create_cache_key()
-        if expiry_window_seconds is None:
-            expiry_window_seconds = self.DEFAULT_EXPIRY_WINDOW_SECONDS
-        self._expiry_window_seconds = expiry_window_seconds
-    def _create_cache_key(self):
-        raise NotImplementedError('_create_cache_key()')
-    def _make_file_safe(self, filename):
-        # Replace :, path sep, and / to make it the string filename safe.
-        filename = filename.replace(':', '_').replace(os.path.sep, '_')
-        return filename.replace('/', '_')
-    def _get_credentials(self):
-        raise NotImplementedError('_get_credentials()')
-    def fetch_credentials(self):
-        return self._get_cached_credentials()
-    def _get_cached_credentials(self):
-        """Get up-to-date credentials.
-        This will check the cache for up-to-date credentials, calling assume
-        role if none are available.
-        """
-        response = self._load_from_cache()
-        if response is None:
-            response = self._get_credentials()
-            self._write_to_cache(response)
-        else:
-            logger.debug("Credentials for role retrieved from cache.")
-        creds = response['Credentials']
-        expiration = _serialize_if_needed(creds['Expiration'], iso=True)
-        return {
-            'access_key': creds['AccessKeyId'],
-            'secret_key': creds['SecretAccessKey'],
-            'token': creds['SessionToken'],
-            'expiry_time': expiration,
-        }
-    def _load_from_cache(self):
-        if self._cache_key in self._cache:
-            creds = deepcopy(self._cache[self._cache_key])
-            if not self._is_expired(creds):
-                return creds
-            else:
-                logger.debug(
-                    "Credentials were found in cache, but they are expired."
-                )
-        return None
-    def _write_to_cache(self, response):
-        self._cache[self._cache_key] = deepcopy(response)
-    def _is_expired(self, credentials):
-        """Check if credentials are expired."""
-        end_time = _parse_if_needed(credentials['Credentials']['Expiration'])
-        seconds = total_seconds(end_time - _local_now())
-        return seconds < self._expiry_window_seconds
-class BaseAssumeRoleCredentialFetcher(CachedCredentialFetcher):
-    def __init__(
-        self,
-        client_creator,
-        role_arn,
-        extra_args=None,
-        cache=None,
-        expiry_window_seconds=None,
-    ):
-        self._client_creator = client_creator
-        self._role_arn = role_arn
-        if extra_args is None:
-            self._assume_kwargs = {}
-        else:
-            self._assume_kwargs = deepcopy(extra_args)
-        self._assume_kwargs['RoleArn'] = self._role_arn
-        self._role_session_name = self._assume_kwargs.get('RoleSessionName')
-        self._using_default_session_name = False
-        if not self._role_session_name:
-            self._generate_assume_role_name()
-        super().__init__(cache, expiry_window_seconds)
-    def _generate_assume_role_name(self):
-        self._role_session_name = 'botocore-session-%s' % (int(time.time()))
-        self._assume_kwargs['RoleSessionName'] = self._role_session_name
-        self._using_default_session_name = True
-    def _create_cache_key(self):
-        """Create a predictable cache key for the current configuration.
-        The cache key is intended to be compatible with file names.
-        """
-        args = deepcopy(self._assume_kwargs)
-        # The role session name gets randomly generated, so we don't want it
-        # in the hash.
-        if self._using_default_session_name:
-            del args['RoleSessionName']
-        if 'Policy' in args:
-            # To have a predictable hash, the keys of the policy must be
-            # sorted, so we have to load it here to make sure it gets sorted
-            # later on.
-            args['Policy'] = json.loads(args['Policy'])
-        args = json.dumps(args, sort_keys=True)
-        argument_hash = sha1(args.encode('utf-8')).hexdigest()
-        return self._make_file_safe(argument_hash)
-class AssumeRoleCredentialFetcher(BaseAssumeRoleCredentialFetcher):
-    def __init__(
-        self,
-        client_creator,
-        source_credentials,
-        role_arn,
-        extra_args=None,
-        mfa_prompter=None,
-        cache=None,
-        expiry_window_seconds=None,
-    ):
-        """
-        :type client_creator: callable
-        :param client_creator: A callable that creates a client taking
-            arguments like ``Session.create_client``.
-        :type source_credentials: Credentials
-        :param source_credentials: The credentials to use to create the
-            client for the call to AssumeRole.
-        :type role_arn: str
-        :param role_arn: The ARN of the role to be assumed.
-        :type extra_args: dict
-        :param extra_args: Any additional arguments to add to the assume
-            role request using the format of the botocore operation.
-            Possible keys include, but may not be limited to,
-            DurationSeconds, Policy, SerialNumber, ExternalId and
-            RoleSessionName.
-        :type mfa_prompter: callable
-        :param mfa_prompter: A callable that returns input provided by the
-            user (i.e raw_input, getpass.getpass, etc.).
-        :type cache: dict
-        :param cache: An object that supports ``__getitem__``,
-            ``__setitem__``, and ``__contains__``.  An example of this is
-            the ``JSONFileCache`` class in aws-cli.
-        :type expiry_window_seconds: int
-        :param expiry_window_seconds: The amount of time, in seconds,
-        """
-        self._source_credentials = source_credentials
-        self._mfa_prompter = mfa_prompter
-        if self._mfa_prompter is None:
-            self._mfa_prompter = getpass.getpass
-        super().__init__(
-            client_creator,
-            role_arn,
-            extra_args=extra_args,
-            cache=cache,
-            expiry_window_seconds=expiry_window_seconds,
-        )
-    def _get_credentials(self):
-        """Get credentials by calling assume role."""
-        kwargs = self._assume_role_kwargs()
-        client = self._create_client()
-        return client.assume_role(**kwargs)
-    def _assume_role_kwargs(self):
-        """Get the arguments for assume role based on current configuration."""
-        assume_role_kwargs = deepcopy(self._assume_kwargs)
-        mfa_serial = assume_role_kwargs.get('SerialNumber')
-        if mfa_serial is not None:
-            prompt = 'Enter MFA code for %s: ' % mfa_serial
-            token_code = self._mfa_prompter(prompt)
-            assume_role_kwargs['TokenCode'] = token_code
-        duration_seconds = assume_role_kwargs.get('DurationSeconds')
-        if duration_seconds is not None:
-            assume_role_kwargs['DurationSeconds'] = duration_seconds
-        return assume_role_kwargs
-    def _create_client(self):
-        """Create an STS client using the source credentials."""
-        frozen_credentials = self._source_credentials.get_frozen_credentials()
-        return self._client_creator(
-            'sts',
-            aws_access_key_id=frozen_credentials.access_key,
-            aws_secret_access_key=frozen_credentials.secret_key,
-            aws_session_token=frozen_credentials.token,
-        )
-class AssumeRoleWithWebIdentityCredentialFetcher(
-    BaseAssumeRoleCredentialFetcher
-):
-    def __init__(
-        self,
-        client_creator,
-        web_identity_token_loader,
-        role_arn,
-        extra_args=None,
-        cache=None,
-        expiry_window_seconds=None,
-    ):
-        """
-        :type client_creator: callable
-        :param client_creator: A callable that creates a client taking
-            arguments like ``Session.create_client``.
-        :type web_identity_token_loader: callable
-        :param web_identity_token_loader: A callable that takes no arguments
-        and returns a web identity token str.
-        :type role_arn: str
-        :param role_arn: The ARN of the role to be assumed.
-        :type extra_args: dict
-        :param extra_args: Any additional arguments to add to the assume
-            role request using the format of the botocore operation.
-            Possible keys include, but may not be limited to,
-            DurationSeconds, Policy, SerialNumber, ExternalId and
-            RoleSessionName.
-        :type cache: dict
-        :param cache: An object that supports ``__getitem__``,
-            ``__setitem__``, and ``__contains__``.  An example of this is
-            the ``JSONFileCache`` class in aws-cli.
-        :type expiry_window_seconds: int
-        :param expiry_window_seconds: The amount of time, in seconds,
-        """
-        self._web_identity_token_loader = web_identity_token_loader
-        super().__init__(
-            client_creator,
-            role_arn,
-            extra_args=extra_args,
-            cache=cache,
-            expiry_window_seconds=expiry_window_seconds,
-        )
-    def _get_credentials(self):
-        """Get credentials by calling assume role."""
-        kwargs = self._assume_role_kwargs()
-        # Assume role with web identity does not require credentials other than
-        # the token, explicitly configure the client to not sign requests.
-        config = Config(signature_version=UNSIGNED)
-        client = self._client_creator('sts', config=config)
-        return client.assume_role_with_web_identity(**kwargs)
-    def _assume_role_kwargs(self):
-        """Get the arguments for assume role based on current configuration."""
-        assume_role_kwargs = deepcopy(self._assume_kwargs)
-        identity_token = self._web_identity_token_loader()
-        assume_role_kwargs['WebIdentityToken'] = identity_token
-        return assume_role_kwargs
-class CredentialProvider:
-    # A short name to identify the provider within botocore.
-    METHOD = None
-    # A name to identify the provider for use in cross-sdk features like
-    # assume role's `credential_source` configuration option. These names
-    # are to be treated in a case-insensitive way. NOTE: any providers not
-    # implemented in botocore MUST prefix their canonical names with
-    # 'custom' or we DO NOT guarantee that it will work with any features
-    # that this provides.
-    CANONICAL_NAME = None
-    def __init__(self, session=None):
-        self.session = session
-    def load(self):
-        """
-        Loads the credentials from their source & sets them on the object.
-        Subclasses should implement this method (by reading from disk, the
-        environment, the network or wherever), returning ``True`` if they were
-        found & loaded.
-        If not found, this method should return ``False``, indictating that the
-        ``CredentialResolver`` should fall back to the next available method.
-        The default implementation does nothing, assuming the user has set the
-        ``access_key/secret_key/token`` themselves.
-        :returns: Whether credentials were found & set
-        :rtype: Credentials
-        """
-        return True
-    def _extract_creds_from_mapping(self, mapping, *key_names):
-        found = []
-        for key_name in key_names:
-            try:
-                found.append(mapping[key_name])
-            except KeyError:
-                raise PartialCredentialsError(
-                    provider=self.METHOD, cred_var=key_name
-                )
-        return found
-class ProcessProvider(CredentialProvider):
-    METHOD = 'custom-process'
-    def __init__(self, profile_name, load_config, popen=subprocess.Popen):
-        self._profile_name = profile_name
-        self._load_config = load_config
-        self._loaded_config = None
-        self._popen = popen
-    def load(self):
-        credential_process = self._credential_process
-        if credential_process is None:
-            return
-        creds_dict = self._retrieve_credentials_using(credential_process)
-        if creds_dict.get('expiry_time') is not None:
-            return RefreshableCredentials.create_from_metadata(
-                creds_dict,
-                lambda: self._retrieve_credentials_using(credential_process),
-                self.METHOD,
-            )
-        return Credentials(
-            access_key=creds_dict['access_key'],
-            secret_key=creds_dict['secret_key'],
-            token=creds_dict.get('token'),
-            method=self.METHOD,
-        )
-    def _retrieve_credentials_using(self, credential_process):
-        # We're not using shell=True, so we need to pass the
-        # command and all arguments as a list.
-        process_list = compat_shell_split(credential_process)
-        p = self._popen(
-            process_list, stdout=subprocess.PIPE, stderr=subprocess.PIPE
-        )
-        stdout, stderr = p.communicate()
-        if p.returncode != 0:
-            raise CredentialRetrievalError(
-                provider=self.METHOD, error_msg=stderr.decode('utf-8')
-            )
-        parsed = botocore.compat.json.loads(stdout.decode('utf-8'))
-        version = parsed.get('Version', '<Version key not provided>')
-        if version != 1:
-            raise CredentialRetrievalError(
-                provider=self.METHOD,
-                error_msg=(
-                    f"Unsupported version '{version}' for credential process "
-                    f"provider, supported versions: 1"
-                ),
-            )
-        try:
-            return {
-                'access_key': parsed['AccessKeyId'],
-                'secret_key': parsed['SecretAccessKey'],
-                'token': parsed.get('SessionToken'),
-                'expiry_time': parsed.get('Expiration'),
-            }
-        except KeyError as e:
-            raise CredentialRetrievalError(
-                provider=self.METHOD,
-                error_msg=f"Missing required key in response: {e}",
-            )
-    @property
-    def _credential_process(self):
-        if self._loaded_config is None:
-            self._loaded_config = self._load_config()
-        profile_config = self._loaded_config.get('profiles', {}).get(
-            self._profile_name, {}
-        )
-        return profile_config.get('credential_process')
-class InstanceMetadataProvider(CredentialProvider):
-    METHOD = 'iam-role'
-    CANONICAL_NAME = 'Ec2InstanceMetadata'
-    def __init__(self, iam_role_fetcher):
-        self._role_fetcher = iam_role_fetcher
-    def load(self):
-        fetcher = self._role_fetcher
-        # We do the first request, to see if we get useful data back.
-        # If not, we'll pass & move on to whatever's next in the credential
-        # chain.
-        metadata = fetcher.retrieve_iam_role_credentials()
-        if not metadata:
-            return None
-        logger.info(
-            'Found credentials from IAM Role: %s', metadata['role_name']
-        )
-        # We manually set the data here, since we already made the request &
-        # have it. When the expiry is hit, the credentials will auto-refresh
-        # themselves.
-        creds = RefreshableCredentials.create_from_metadata(
-            metadata,
-            method=self.METHOD,
-            refresh_using=fetcher.retrieve_iam_role_credentials,
-        )
-        return creds
-class EnvProvider(CredentialProvider):
-    METHOD = 'env'
-    CANONICAL_NAME = 'Environment'
-    ACCESS_KEY = 'AWS_ACCESS_KEY_ID'
-    SECRET_KEY = 'AWS_SECRET_ACCESS_KEY'
-    # The token can come from either of these env var.
-    # AWS_SESSION_TOKEN is what other AWS SDKs have standardized on.
-    TOKENS = ['AWS_SECURITY_TOKEN', 'AWS_SESSION_TOKEN']
-    EXPIRY_TIME = 'AWS_CREDENTIAL_EXPIRATION'
-    def __init__(self, environ=None, mapping=None):
-        """
-        :param environ: The environment variables (defaults to
-            ``os.environ`` if no value is provided).
-        :param mapping: An optional mapping of variable names to
-            environment variable names.  Use this if you want to
-            change the mapping of access_key->AWS_ACCESS_KEY_ID, etc.
-            The dict can have up to 3 keys: ``access_key``, ``secret_key``,
-            ``session_token``.
-        """
-        if environ is None:
-            environ = os.environ
-        self.environ = environ
-        self._mapping = self._build_mapping(mapping)
-    def _build_mapping(self, mapping):
-        # Mapping of variable name to env var name.
-        var_mapping = {}
-        if mapping is None:
-            # Use the class var default.
-            var_mapping['access_key'] = self.ACCESS_KEY
-            var_mapping['secret_key'] = self.SECRET_KEY
-            var_mapping['token'] = self.TOKENS
-            var_mapping['expiry_time'] = self.EXPIRY_TIME
-        else:
-            var_mapping['access_key'] = mapping.get(
-                'access_key', self.ACCESS_KEY
-            )
-            var_mapping['secret_key'] = mapping.get(
-                'secret_key', self.SECRET_KEY
-            )
-            var_mapping['token'] = mapping.get('token', self.TOKENS)
-            if not isinstance(var_mapping['token'], list):
-                var_mapping['token'] = [var_mapping['token']]
-            var_mapping['expiry_time'] = mapping.get(
-                'expiry_time', self.EXPIRY_TIME
-            )
-        return var_mapping
-    def load(self):
-        """
-        Search for credentials in explicit environment variables.
-        """
-        access_key = self.environ.get(self._mapping['access_key'], '')
-        if access_key:
-            logger.info('Found credentials in environment variables.')
-            fetcher = self._create_credentials_fetcher()
-            credentials = fetcher(require_expiry=False)
-            expiry_time = credentials['expiry_time']
-            if expiry_time is not None:
-                expiry_time = parse(expiry_time)
-                return RefreshableCredentials(
-                    credentials['access_key'],
-                    credentials['secret_key'],
-                    credentials['token'],
-                    expiry_time,
-                    refresh_using=fetcher,
-                    method=self.METHOD,
-                )
-            return Credentials(
-                credentials['access_key'],
-                credentials['secret_key'],
-                credentials['token'],
-                method=self.METHOD,
-            )
-        else:
-            return None
-    def _create_credentials_fetcher(self):
-        mapping = self._mapping
-        method = self.METHOD
-        environ = self.environ
-        def fetch_credentials(require_expiry=True):
-            credentials = {}
-            access_key = environ.get(mapping['access_key'], '')
-            if not access_key:
-                raise PartialCredentialsError(
-                    provider=method, cred_var=mapping['access_key']
-                )
-            credentials['access_key'] = access_key
-            secret_key = environ.get(mapping['secret_key'], '')
-            if not secret_key:
-                raise PartialCredentialsError(
-                    provider=method, cred_var=mapping['secret_key']
-                )
-            credentials['secret_key'] = secret_key
-            credentials['token'] = None
-            for token_env_var in mapping['token']:
-                token = environ.get(token_env_var, '')
-                if token:
-                    credentials['token'] = token
-                    break
-            credentials['expiry_time'] = None
-            expiry_time = environ.get(mapping['expiry_time'], '')
-            if expiry_time:
-                credentials['expiry_time'] = expiry_time
-            if require_expiry and not expiry_time:
-                raise PartialCredentialsError(
-                    provider=method, cred_var=mapping['expiry_time']
-                )
-            return credentials
-        return fetch_credentials
-class OriginalEC2Provider(CredentialProvider):
-    METHOD = 'ec2-credentials-file'
-    CANONICAL_NAME = 'Ec2Config'
-    CRED_FILE_ENV = 'AWS_CREDENTIAL_FILE'
-    ACCESS_KEY = 'AWSAccessKeyId'
-    SECRET_KEY = 'AWSSecretKey'
-    def __init__(self, environ=None, parser=None):
-        if environ is None:
-            environ = os.environ
-        if parser is None:
-            parser = parse_key_val_file
-        self._environ = environ
-        self._parser = parser
-    def load(self):
-        """
-        Search for a credential file used by original EC2 CLI tools.
-        """
-        if 'AWS_CREDENTIAL_FILE' in self._environ:
-            full_path = os.path.expanduser(
-                self._environ['AWS_CREDENTIAL_FILE']
-            )
-            creds = self._parser(full_path)
-            if self.ACCESS_KEY in creds:
-                logger.info('Found credentials in AWS_CREDENTIAL_FILE.')
-                access_key = creds[self.ACCESS_KEY]
-                secret_key = creds[self.SECRET_KEY]
-                # EC2 creds file doesn't support session tokens.
-                return Credentials(access_key, secret_key, method=self.METHOD)
-        else:
-            return None
-class SharedCredentialProvider(CredentialProvider):
-    METHOD = 'shared-credentials-file'
-    CANONICAL_NAME = 'SharedCredentials'
-    ACCESS_KEY = 'aws_access_key_id'
-    SECRET_KEY = 'aws_secret_access_key'
-    # Same deal as the EnvProvider above.  Botocore originally supported
-    # aws_security_token, but the SDKs are standardizing on aws_session_token
-    # so we support both.
-    TOKENS = ['aws_security_token', 'aws_session_token']
-    def __init__(self, creds_filename, profile_name=None, ini_parser=None):
-        self._creds_filename = creds_filename
-        if profile_name is None:
-            profile_name = 'default'
-        self._profile_name = profile_name
-        if ini_parser is None:
-            ini_parser = botocore.configloader.raw_config_parse
-        self._ini_parser = ini_parser
-    def load(self):
-        try:
-            available_creds = self._ini_parser(self._creds_filename)
-        except ConfigNotFound:
-            return None
-        if self._profile_name in available_creds:
-            config = available_creds[self._profile_name]
-            if self.ACCESS_KEY in config:
-                logger.info(
-                    "Found credentials in shared credentials file: %s",
-                    self._creds_filename,
-                )
-                access_key, secret_key = self._extract_creds_from_mapping(
-                    config, self.ACCESS_KEY, self.SECRET_KEY
-                )
-                token = self._get_session_token(config)
-                return Credentials(
-                    access_key, secret_key, token, method=self.METHOD
-                )
-    def _get_session_token(self, config):
-        for token_envvar in self.TOKENS:
-            if token_envvar in config:
-                return config[token_envvar]
-class ConfigProvider(CredentialProvider):
-    """INI based config provider with profile sections."""
-    METHOD = 'config-file'
-    CANONICAL_NAME = 'SharedConfig'
-    ACCESS_KEY = 'aws_access_key_id'
-    SECRET_KEY = 'aws_secret_access_key'
-    # Same deal as the EnvProvider above.  Botocore originally supported
-    # aws_security_token, but the SDKs are standardizing on aws_session_token
-    # so we support both.
-    TOKENS = ['aws_security_token', 'aws_session_token']
-    def __init__(self, config_filename, profile_name, config_parser=None):
-        """
-        :param config_filename: The session configuration scoped to the current
-            profile.  This is available via ``session.config``.
-        :param profile_name: The name of the current profile.
-        :param config_parser: A config parser callable.
-        """
-        self._config_filename = config_filename
-        self._profile_name = profile_name
-        if config_parser is None:
-            config_parser = botocore.configloader.load_config
-        self._config_parser = config_parser
-    def load(self):
-        """
-        If there is are credentials in the configuration associated with
-        the session, use those.
-        """
-        try:
-            full_config = self._config_parser(self._config_filename)
-        except ConfigNotFound:
-            return None
-        if self._profile_name in full_config['profiles']:
-            profile_config = full_config['profiles'][self._profile_name]
-            if self.ACCESS_KEY in profile_config:
-                logger.info(
-                    "Credentials found in config file: %s",
-                    self._config_filename,
-                )
-                access_key, secret_key = self._extract_creds_from_mapping(
-                    profile_config, self.ACCESS_KEY, self.SECRET_KEY
-                )
-                token = self._get_session_token(profile_config)
-                return Credentials(
-                    access_key, secret_key, token, method=self.METHOD
-                )
-        else:
-            return None
-    def _get_session_token(self, profile_config):
-        for token_name in self.TOKENS:
-            if token_name in profile_config:
-                return profile_config[token_name]
-class BotoProvider(CredentialProvider):
-    METHOD = 'boto-config'
-    CANONICAL_NAME = 'Boto2Config'
-    BOTO_CONFIG_ENV = 'BOTO_CONFIG'
-    DEFAULT_CONFIG_FILENAMES = ['/etc/boto.cfg', '~/.boto']
-    ACCESS_KEY = 'aws_access_key_id'
-    SECRET_KEY = 'aws_secret_access_key'
-    def __init__(self, environ=None, ini_parser=None):
-        if environ is None:
-            environ = os.environ
-        if ini_parser is None:
-            ini_parser = botocore.configloader.raw_config_parse
-        self._environ = environ
-        self._ini_parser = ini_parser
-    def load(self):
-        """
-        Look for credentials in boto config file.
-        """
-        if self.BOTO_CONFIG_ENV in self._environ:
-            potential_locations = [self._environ[self.BOTO_CONFIG_ENV]]
-        else:
-            potential_locations = self.DEFAULT_CONFIG_FILENAMES
-        for filename in potential_locations:
-            try:
-                config = self._ini_parser(filename)
-            except ConfigNotFound:
-                # Move on to the next potential config file name.
-                continue
-            if 'Credentials' in config:
-                credentials = config['Credentials']
-                if self.ACCESS_KEY in credentials:
-                    logger.info(
-                        "Found credentials in boto config file: %s", filename
-                    )
-                    access_key, secret_key = self._extract_creds_from_mapping(
-                        credentials, self.ACCESS_KEY, self.SECRET_KEY
-                    )
-                    return Credentials(
-                        access_key, secret_key, method=self.METHOD
-                    )
-class AssumeRoleProvider(CredentialProvider):
-    METHOD = 'assume-role'
-    # The AssumeRole provider is logically part of the SharedConfig and
-    # SharedCredentials providers. Since the purpose of the canonical name
-    # is to provide cross-sdk compatibility, calling code will need to be
-    # aware that either of those providers should be tied to the AssumeRole
-    # provider as much as possible.
-    CANONICAL_NAME = None
-    ROLE_CONFIG_VAR = 'role_arn'
-    WEB_IDENTITY_TOKE_FILE_VAR = 'web_identity_token_file'
-    # Credentials are considered expired (and will be refreshed) once the total
-    # remaining time left until the credentials expires is less than the
-    # EXPIRY_WINDOW.
-    EXPIRY_WINDOW_SECONDS = 60 * 15
-    def __init__(
-        self,
-        load_config,
-        client_creator,
-        cache,
-        profile_name,
-        prompter=getpass.getpass,
-        credential_sourcer=None,
-        profile_provider_builder=None,
-    ):
-        """
-        :type load_config: callable
-        :param load_config: A function that accepts no arguments, and
-            when called, will return the full configuration dictionary
-            for the session (``session.full_config``).
-        :type client_creator: callable
-        :param client_creator: A factory function that will create
-            a client when called.  Has the same interface as
-            ``botocore.session.Session.create_client``.
-        :type cache: dict
-        :param cache: An object that supports ``__getitem__``,
-            ``__setitem__``, and ``__contains__``.  An example
-            of this is the ``JSONFileCache`` class in the CLI.
-        :type profile_name: str
-        :param profile_name: The name of the profile.
-        :type prompter: callable
-        :param prompter: A callable that returns input provided
-            by the user (i.e raw_input, getpass.getpass, etc.).
-        :type credential_sourcer: CanonicalNameCredentialSourcer
-        :param credential_sourcer: A credential provider that takes a
-            configuration, which is used to provide the source credentials
-            for the STS call.
-        """
-        #: The cache used to first check for assumed credentials.
-        #: This is checked before making the AssumeRole API
-        #: calls and can be useful if you have short lived
-        #: scripts and you'd like to avoid calling AssumeRole
-        #: until the credentials are expired.
-        self.cache = cache
-        self._load_config = load_config
-        # client_creator is a callable that creates function.
-        # It's basically session.create_client
-        self._client_creator = client_creator
-        self._profile_name = profile_name
-        self._prompter = prompter
-        # The _loaded_config attribute will be populated from the
-        # load_config() function once the configuration is actually
-        # loaded.  The reason we go through all this instead of just
-        # requiring that the loaded_config be passed to us is to that
-        # we can defer configuration loaded until we actually try
-        # to load credentials (as opposed to when the object is
-        # instantiated).
-        self._loaded_config = {}
-        self._credential_sourcer = credential_sourcer
-        self._profile_provider_builder = profile_provider_builder
-        self._visited_profiles = [self._profile_name]
-    def load(self):
-        self._loaded_config = self._load_config()
-        profiles = self._loaded_config.get('profiles', {})
-        profile = profiles.get(self._profile_name, {})
-        if self._has_assume_role_config_vars(profile):
-            return self._load_creds_via_assume_role(self._profile_name)
-    def _has_assume_role_config_vars(self, profile):
-        return (
-            self.ROLE_CONFIG_VAR in profile
-            and
-            # We need to ensure this provider doesn't look at a profile when
-            # the profile has configuration for web identity. Simply relying on
-            # the order in the credential chain is insufficient as it doesn't
-            # prevent the case when we're doing an assume role chain.
-            self.WEB_IDENTITY_TOKE_FILE_VAR not in profile
-        )
-    def _load_creds_via_assume_role(self, profile_name):
-        role_config = self._get_role_config(profile_name)
-        source_credentials = self._resolve_source_credentials(
-            role_config, profile_name
-        )
-        extra_args = {}
-        role_session_name = role_config.get('role_session_name')
-        if role_session_name is not None:
-            extra_args['RoleSessionName'] = role_session_name
-        external_id = role_config.get('external_id')
-        if external_id is not None:
-            extra_args['ExternalId'] = external_id
-        mfa_serial = role_config.get('mfa_serial')
-        if mfa_serial is not None:
-            extra_args['SerialNumber'] = mfa_serial
-        duration_seconds = role_config.get('duration_seconds')
-        if duration_seconds is not None:
-            extra_args['DurationSeconds'] = duration_seconds
-        fetcher = AssumeRoleCredentialFetcher(
-            client_creator=self._client_creator,
-            source_credentials=source_credentials,
-            role_arn=role_config['role_arn'],
-            extra_args=extra_args,
-            mfa_prompter=self._prompter,
-            cache=self.cache,
-        )
-        refresher = fetcher.fetch_credentials
-        if mfa_serial is not None:
-            refresher = create_mfa_serial_refresher(refresher)
-        # The initial credentials are empty and the expiration time is set
-        # to now so that we can delay the call to assume role until it is
-        # strictly needed.
-        return DeferredRefreshableCredentials(
-            method=self.METHOD,
-            refresh_using=refresher,
-            time_fetcher=_local_now,
-        )
-    def _get_role_config(self, profile_name):
-        """Retrieves and validates the role configuration for the profile."""
-        profiles = self._loaded_config.get('profiles', {})
-        profile = profiles[profile_name]
-        source_profile = profile.get('source_profile')
-        role_arn = profile['role_arn']
-        credential_source = profile.get('credential_source')
-        mfa_serial = profile.get('mfa_serial')
-        external_id = profile.get('external_id')
-        role_session_name = profile.get('role_session_name')
-        duration_seconds = profile.get('duration_seconds')
-        role_config = {
-            'role_arn': role_arn,
-            'external_id': external_id,
-            'mfa_serial': mfa_serial,
-            'role_session_name': role_session_name,
-            'source_profile': source_profile,
-            'credential_source': credential_source,
-        }
-        if duration_seconds is not None:
-            try:
-                role_config['duration_seconds'] = int(duration_seconds)
-            except ValueError:
-                pass
-        # Either the credential source or the source profile must be
-        # specified, but not both.
-        if credential_source is not None and source_profile is not None:
-            raise InvalidConfigError(
-                error_msg=(
-                    'The profile "%s" contains both source_profile and '
-                    'credential_source.' % profile_name
-                )
-            )
-        elif credential_source is None and source_profile is None:
-            raise PartialCredentialsError(
-                provider=self.METHOD,
-                cred_var='source_profile or credential_source',
-            )
-        elif credential_source is not None:
-            self._validate_credential_source(profile_name, credential_source)
-        else:
-            self._validate_source_profile(profile_name, source_profile)
-        return role_config
-    def _validate_credential_source(self, parent_profile, credential_source):
-        if self._credential_sourcer is None:
-            raise InvalidConfigError(
-                error_msg=(
-                    f"The credential_source \"{credential_source}\" is specified "
-                    f"in profile \"{parent_profile}\", "
-                    f"but no source provider was configured."
-                )
-            )
-        if not self._credential_sourcer.is_supported(credential_source):
-            raise InvalidConfigError(
-                error_msg=(
-                    f"The credential source \"{credential_source}\" referenced "
-                    f"in profile \"{parent_profile}\" is not valid."
-                )
-            )
-    def _source_profile_has_credentials(self, profile):
-        return any(
-            [
-                self._has_static_credentials(profile),
-                self._has_assume_role_config_vars(profile),
-            ]
-        )
-    def _validate_source_profile(
-        self, parent_profile_name, source_profile_name
-    ):
-        profiles = self._loaded_config.get('profiles', {})
-        if source_profile_name not in profiles:
-            raise InvalidConfigError(
-                error_msg=(
-                    f"The source_profile \"{source_profile_name}\" referenced in "
-                    f"the profile \"{parent_profile_name}\" does not exist."
-                )
-            )
-        source_profile = profiles[source_profile_name]
-        # Make sure we aren't going into an infinite loop. If we haven't
-        # visited the profile yet, we're good.
-        if source_profile_name not in self._visited_profiles:
-            return
-        # If we have visited the profile and the profile isn't simply
-        # referencing itself, that's an infinite loop.
-        if source_profile_name != parent_profile_name:
-            raise InfiniteLoopConfigError(
-                source_profile=source_profile_name,
-                visited_profiles=self._visited_profiles,
-            )
-        # A profile is allowed to reference itself so that it can source
-        # static credentials and have configuration all in the same
-        # profile. This will only ever work for the top level assume
-        # role because the static credentials will otherwise take
-        # precedence.
-        if not self._has_static_credentials(source_profile):
-            raise InfiniteLoopConfigError(
-                source_profile=source_profile_name,
-                visited_profiles=self._visited_profiles,
-            )
-    def _has_static_credentials(self, profile):
-        static_keys = ['aws_secret_access_key', 'aws_access_key_id']
-        return any(static_key in profile for static_key in static_keys)
-    def _resolve_source_credentials(self, role_config, profile_name):
-        credential_source = role_config.get('credential_source')
-        if credential_source is not None:
-            return self._resolve_credentials_from_source(
-                credential_source, profile_name
-            )
-        source_profile = role_config['source_profile']
-        self._visited_profiles.append(source_profile)
-        return self._resolve_credentials_from_profile(source_profile)
-    def _resolve_credentials_from_profile(self, profile_name):
-        profiles = self._loaded_config.get('profiles', {})
-        profile = profiles[profile_name]
-        if (
-            self._has_static_credentials(profile)
-            and not self._profile_provider_builder
-        ):
-            # This is only here for backwards compatibility. If this provider
-            # isn't given a profile provider builder we still want to be able
-            # handle the basic static credential case as we would before the
-            # provile provider builder parameter was added.
-            return self._resolve_static_credentials_from_profile(profile)
-        elif self._has_static_credentials(
-            profile
-        ) or not self._has_assume_role_config_vars(profile):
-            profile_providers = self._profile_provider_builder.providers(
-                profile_name=profile_name,
-                disable_env_vars=True,
-            )
-            profile_chain = CredentialResolver(profile_providers)
-            credentials = profile_chain.load_credentials()
-            if credentials is None:
-                error_message = (
-                    'The source profile "%s" must have credentials.'
-                )
-                raise InvalidConfigError(
-                    error_msg=error_message % profile_name,
-                )
-            return credentials
-        return self._load_creds_via_assume_role(profile_name)
-    def _resolve_static_credentials_from_profile(self, profile):
-        try:
-            return Credentials(
-                access_key=profile['aws_access_key_id'],
-                secret_key=profile['aws_secret_access_key'],
-                token=profile.get('aws_session_token'),
-            )
-        except KeyError as e:
-            raise PartialCredentialsError(
-                provider=self.METHOD, cred_var=str(e)
-            )
-    def _resolve_credentials_from_source(
-        self, credential_source, profile_name
-    ):
-        credentials = self._credential_sourcer.source_credentials(
-            credential_source
-        )
-        if credentials is None:
-            raise CredentialRetrievalError(
-                provider=credential_source,
-                error_msg=(
-                    'No credentials found in credential_source referenced '
-                    'in profile %s' % profile_name
-                ),
-            )
-        return credentials
-class AssumeRoleWithWebIdentityProvider(CredentialProvider):
-    METHOD = 'assume-role-with-web-identity'
-    CANONICAL_NAME = None
-    _CONFIG_TO_ENV_VAR = {
-        'web_identity_token_file': 'AWS_WEB_IDENTITY_TOKEN_FILE',
-        'role_session_name': 'AWS_ROLE_SESSION_NAME',
-        'role_arn': 'AWS_ROLE_ARN',
-    }
-    def __init__(
-        self,
-        load_config,
-        client_creator,
-        profile_name,
-        cache=None,
-        disable_env_vars=False,
-        token_loader_cls=None,
-    ):
-        self.cache = cache
-        self._load_config = load_config
-        self._client_creator = client_creator
-        self._profile_name = profile_name
-        self._profile_config = None
-        self._disable_env_vars = disable_env_vars
-        if token_loader_cls is None:
-            token_loader_cls = FileWebIdentityTokenLoader
-        self._token_loader_cls = token_loader_cls
-    def load(self):
-        return self._assume_role_with_web_identity()
-    def _get_profile_config(self, key):
-        if self._profile_config is None:
-            loaded_config = self._load_config()
-            profiles = loaded_config.get('profiles', {})
-            self._profile_config = profiles.get(self._profile_name, {})
-        return self._profile_config.get(key)
-    def _get_env_config(self, key):
-        if self._disable_env_vars:
-            return None
-        env_key = self._CONFIG_TO_ENV_VAR.get(key)
-        if env_key and env_key in os.environ:
-            return os.environ[env_key]
-        return None
-    def _get_config(self, key):
-        env_value = self._get_env_config(key)
-        if env_value is not None:
-            return env_value
-        return self._get_profile_config(key)
-    def _assume_role_with_web_identity(self):
-        token_path = self._get_config('web_identity_token_file')
-        if not token_path:
-            return None
-        token_loader = self._token_loader_cls(token_path)
-        role_arn = self._get_config('role_arn')
-        if not role_arn:
-            error_msg = (
-                'The provided profile or the current environment is '
-                'configured to assume role with web identity but has no '
-                'role ARN configured. Ensure that the profile has the role_arn'
-                'configuration set or the AWS_ROLE_ARN env var is set.'
-            )
-            raise InvalidConfigError(error_msg=error_msg)
-        extra_args = {}
-        role_session_name = self._get_config('role_session_name')
-        if role_session_name is not None:
-            extra_args['RoleSessionName'] = role_session_name
-        fetcher = AssumeRoleWithWebIdentityCredentialFetcher(
-            client_creator=self._client_creator,
-            web_identity_token_loader=token_loader,
-            role_arn=role_arn,
-            extra_args=extra_args,
-            cache=self.cache,
-        )
-        # The initial credentials are empty and the expiration time is set
-        # to now so that we can delay the call to assume role until it is
-        # strictly needed.
-        return DeferredRefreshableCredentials(
-            method=self.METHOD,
-            refresh_using=fetcher.fetch_credentials,
-        )
-class CanonicalNameCredentialSourcer:
-    def __init__(self, providers):
-        self._providers = providers
-    def is_supported(self, source_name):
-        """Validates a given source name.
-        :type source_name: str
-        :param source_name: The value of credential_source in the config
-            file. This is the canonical name of the credential provider.
-        :rtype: bool
-        :returns: True if the credential provider is supported,
-            False otherwise.
-        """
-        return source_name in [p.CANONICAL_NAME for p in self._providers]
-    def source_credentials(self, source_name):
-        """Loads source credentials based on the provided configuration.
-        :type source_name: str
-        :param source_name: The value of credential_source in the config
-            file. This is the canonical name of the credential provider.
-        :rtype: Credentials
-        """
-        source = self._get_provider(source_name)
-        if isinstance(source, CredentialResolver):
-            return source.load_credentials()
-        return source.load()
-    def _get_provider(self, canonical_name):
-        """Return a credential provider by its canonical name.
-        :type canonical_name: str
-        :param canonical_name: The canonical name of the provider.
-        :raises UnknownCredentialError: Raised if no
-            credential provider by the provided name
-            is found.
-        """
-        provider = self._get_provider_by_canonical_name(canonical_name)
-        # The AssumeRole provider should really be part of the SharedConfig
-        # provider rather than being its own thing, but it is not. It is
-        # effectively part of both the SharedConfig provider and the
-        # SharedCredentials provider now due to the way it behaves.
-        # Therefore if we want either of those providers we should return
-        # the AssumeRole provider with it.
-        if canonical_name.lower() in ['sharedconfig', 'sharedcredentials']:
-            assume_role_provider = self._get_provider_by_method('assume-role')
-            if assume_role_provider is not None:
-                # The SharedConfig or SharedCredentials provider may not be
-                # present if it was removed for some reason, but the
-                # AssumeRole provider could still be present. In that case,
-                # return the assume role provider by itself.
-                if provider is None:
-                    return assume_role_provider
-                # If both are present, return them both as a
-                # CredentialResolver so that calling code can treat them as
-                # a single entity.
-                return CredentialResolver([assume_role_provider, provider])
-        if provider is None:
-            raise UnknownCredentialError(name=canonical_name)
-        return provider
-    def _get_provider_by_canonical_name(self, canonical_name):
-        """Return a credential provider by its canonical name.
-        This function is strict, it does not attempt to address
-        compatibility issues.
-        """
-        for provider in self._providers:
-            name = provider.CANONICAL_NAME
-            # Canonical names are case-insensitive
-            if name and name.lower() == canonical_name.lower():
-                return provider
-    def _get_provider_by_method(self, method):
-        """Return a credential provider by its METHOD name."""
-        for provider in self._providers:
-            if provider.METHOD == method:
-                return provider
-class ContainerProvider(CredentialProvider):
-    METHOD = 'container-role'
-    CANONICAL_NAME = 'EcsContainer'
-    ENV_VAR = 'AWS_CONTAINER_CREDENTIALS_RELATIVE_URI'
-    ENV_VAR_FULL = 'AWS_CONTAINER_CREDENTIALS_FULL_URI'
-    ENV_VAR_AUTH_TOKEN = 'AWS_CONTAINER_AUTHORIZATION_TOKEN'
-    def __init__(self, environ=None, fetcher=None):
-        if environ is None:
-            environ = os.environ
-        if fetcher is None:
-            fetcher = ContainerMetadataFetcher()
-        self._environ = environ
-        self._fetcher = fetcher
-    def load(self):
-        # This cred provider is only triggered if the self.ENV_VAR is set,
-        # which only happens if you opt into this feature.
-        if self.ENV_VAR in self._environ or self.ENV_VAR_FULL in self._environ:
-            return self._retrieve_or_fail()
-    def _retrieve_or_fail(self):
-        if self._provided_relative_uri():
-            full_uri = self._fetcher.full_url(self._environ[self.ENV_VAR])
-        else:
-            full_uri = self._environ[self.ENV_VAR_FULL]
-        headers = self._build_headers()
-        fetcher = self._create_fetcher(full_uri, headers)
-        creds = fetcher()
-        return RefreshableCredentials(
-            access_key=creds['access_key'],
-            secret_key=creds['secret_key'],
-            token=creds['token'],
-            method=self.METHOD,
-            expiry_time=_parse_if_needed(creds['expiry_time']),
-            refresh_using=fetcher,
-        )
-    def _build_headers(self):
-        auth_token = self._environ.get(self.ENV_VAR_AUTH_TOKEN)
-        if auth_token is not None:
-            return {'Authorization': auth_token}
-    def _create_fetcher(self, full_uri, headers):
-        def fetch_creds():
-            try:
-                response = self._fetcher.retrieve_full_uri(
-                    full_uri, headers=headers
-                )
-            except MetadataRetrievalError as e:
-                logger.debug(
-                    "Error retrieving container metadata: %s", e, exc_info=True
-                )
-                raise CredentialRetrievalError(
-                    provider=self.METHOD, error_msg=str(e)
-                )
-            return {
-                'access_key': response['AccessKeyId'],
-                'secret_key': response['SecretAccessKey'],
-                'token': response['Token'],
-                'expiry_time': response['Expiration'],
-            }
-        return fetch_creds
-    def _provided_relative_uri(self):
-        return self.ENV_VAR in self._environ
-class CredentialResolver:
-    def __init__(self, providers):
-        """
-        :param providers: A list of ``CredentialProvider`` instances.
-        """
-        self.providers = providers
-    def insert_before(self, name, credential_provider):
-        """
-        Inserts a new instance of ``CredentialProvider`` into the chain that
-        will be tried before an existing one.
-        :param name: The short name of the credentials you'd like to insert the
-            new credentials before. (ex. ``env`` or ``config``). Existing names
-            & ordering can be discovered via ``self.available_methods``.
-        :type name: string
-        :param cred_instance: An instance of the new ``Credentials`` object
-            you'd like to add to the chain.
-        :type cred_instance: A subclass of ``Credentials``
-        """
-        try:
-            offset = [p.METHOD for p in self.providers].index(name)
-        except ValueError:
-            raise UnknownCredentialError(name=name)
-        self.providers.insert(offset, credential_provider)
-    def insert_after(self, name, credential_provider):
-        """
-        Inserts a new type of ``Credentials`` instance into the chain that will
-        be tried after an existing one.
-        :param name: The short name of the credentials you'd like to insert the
-            new credentials after. (ex. ``env`` or ``config``). Existing names
-            & ordering can be discovered via ``self.available_methods``.
-        :type name: string
-        :param cred_instance: An instance of the new ``Credentials`` object
-            you'd like to add to the chain.
-        :type cred_instance: A subclass of ``Credentials``
-        """
-        offset = self._get_provider_offset(name)
-        self.providers.insert(offset + 1, credential_provider)
-    def remove(self, name):
-        """
-        Removes a given ``Credentials`` instance from the chain.
-        :param name: The short name of the credentials instance to remove.
-        :type name: string
-        """
-        available_methods = [p.METHOD for p in self.providers]
-        if name not in available_methods:
-            # It's not present. Fail silently.
-            return
-        offset = available_methods.index(name)
-        self.providers.pop(offset)
-    def get_provider(self, name):
-        """Return a credential provider by name.
-        :type name: str
-        :param name: The name of the provider.
-        :raises UnknownCredentialError: Raised if no
-            credential provider by the provided name
-            is found.
-        """
-        return self.providers[self._get_provider_offset(name)]
-    def _get_provider_offset(self, name):
-        try:
-            return [p.METHOD for p in self.providers].index(name)
-        except ValueError:
-            raise UnknownCredentialError(name=name)
-    def load_credentials(self):
-        """
-        Goes through the credentials chain, returning the first ``Credentials``
-        that could be loaded.
-        """
-        # First provider to return a non-None response wins.
-        for provider in self.providers:
-            logger.debug("Looking for credentials via: %s", provider.METHOD)
-            creds = provider.load()
-            if creds is not None:
-                return creds
-        # If we got here, no credentials could be found.
-        # This feels like it should be an exception, but historically, ``None``
-        # is returned.
-        #
-        # +1
-        # -js
-        return None
-class SSOCredentialFetcher(CachedCredentialFetcher):
-    _UTC_DATE_FORMAT = '%Y-%m-%dT%H:%M:%SZ'
-    def __init__(
-        self,
-        start_url,
-        sso_region,
-        role_name,
-        account_id,
-        client_creator,
-        token_loader=None,
-        cache=None,
-        expiry_window_seconds=None,
-        token_provider=None,
-        sso_session_name=None,
-    ):
-        self._client_creator = client_creator
-        self._sso_region = sso_region
-        self._role_name = role_name
-        self._account_id = account_id
-        self._start_url = start_url
-        self._token_loader = token_loader
-        self._token_provider = token_provider
-        self._sso_session_name = sso_session_name
-        super().__init__(cache, expiry_window_seconds)
-    def _create_cache_key(self):
-        """Create a predictable cache key for the current configuration.
-        The cache key is intended to be compatible with file names.
-        """
-        args = {
-            'roleName': self._role_name,
-            'accountId': self._account_id,
-        }
-        if self._sso_session_name:
-            args['sessionName'] = self._sso_session_name
-        else:
-            args['startUrl'] = self._start_url
-        # NOTE: It would be good to hoist this cache key construction logic
-        # into the CachedCredentialFetcher class as we should be consistent.
-        # Unfortunately, the current assume role fetchers that sub class don't
-        # pass separators resulting in non-minified JSON. In the long term,
-        # all fetchers should use the below caching scheme.
-        args = json.dumps(args, sort_keys=True, separators=(',', ':'))
-        argument_hash = sha1(args.encode('utf-8')).hexdigest()
-        return self._make_file_safe(argument_hash)
-    def _parse_timestamp(self, timestamp_ms):
-        # fromtimestamp expects seconds so: milliseconds / 1000 = seconds
-        timestamp_seconds = timestamp_ms / 1000.0
-        timestamp = datetime.datetime.fromtimestamp(timestamp_seconds, tzutc())
-        return timestamp.strftime(self._UTC_DATE_FORMAT)
-    def _get_credentials(self):
-        """Get credentials by calling SSO get role credentials."""
-        config = Config(
-            signature_version=UNSIGNED,
-            region_name=self._sso_region,
-        )
-        client = self._client_creator('sso', config=config)
-        if self._token_provider:
-            initial_token_data = self._token_provider.load_token()
-            token = initial_token_data.get_frozen_token().token
-        else:
-            token = self._token_loader(self._start_url)['accessToken']
-        kwargs = {
-            'roleName': self._role_name,
-            'accountId': self._account_id,
-            'accessToken': token,
-        }
-        try:
-            response = client.get_role_credentials(**kwargs)
-        except client.exceptions.UnauthorizedException:
-            raise UnauthorizedSSOTokenError()
-        credentials = response['roleCredentials']
-        credentials = {
-            'ProviderType': 'sso',
-            'Credentials': {
-                'AccessKeyId': credentials['accessKeyId'],
-                'SecretAccessKey': credentials['secretAccessKey'],
-                'SessionToken': credentials['sessionToken'],
-                'Expiration': self._parse_timestamp(credentials['expiration']),
-            },
-        }
-        return credentials
-class SSOProvider(CredentialProvider):
-    METHOD = 'sso'
-    _SSO_TOKEN_CACHE_DIR = os.path.expanduser(
-        os.path.join('~', '.aws', 'sso', 'cache')
-    )
-    _PROFILE_REQUIRED_CONFIG_VARS = (
-        'sso_role_name',
-        'sso_account_id',
-    )
-    _SSO_REQUIRED_CONFIG_VARS = (
-        'sso_start_url',
-        'sso_region',
-    )
-    _ALL_REQUIRED_CONFIG_VARS = (
-        _PROFILE_REQUIRED_CONFIG_VARS + _SSO_REQUIRED_CONFIG_VARS
-    )
-    def __init__(
-        self,
-        load_config,
-        client_creator,
-        profile_name,
-        cache=None,
-        token_cache=None,
-        token_provider=None,
-    ):
-        if token_cache is None:
-            token_cache = JSONFileCache(self._SSO_TOKEN_CACHE_DIR)
-        self._token_cache = token_cache
-        self._token_provider = token_provider
-        if cache is None:
-            cache = {}
-        self.cache = cache
-        self._load_config = load_config
-        self._client_creator = client_creator
-        self._profile_name = profile_name
-    def _load_sso_config(self):
-        loaded_config = self._load_config()
-        profiles = loaded_config.get('profiles', {})
-        profile_name = self._profile_name
-        profile_config = profiles.get(self._profile_name, {})
-        sso_sessions = loaded_config.get('sso_sessions', {})
-        # Role name & Account ID indicate the cred provider should be used
-        if all(
-            c not in profile_config for c in self._PROFILE_REQUIRED_CONFIG_VARS
-        ):
-            return None
-        resolved_config, extra_reqs = self._resolve_sso_session_reference(
-            profile_config, sso_sessions
-        )
-        config = {}
-        missing_config_vars = []
-        all_required_configs = self._ALL_REQUIRED_CONFIG_VARS + extra_reqs
-        for config_var in all_required_configs:
-            if config_var in resolved_config:
-                config[config_var] = resolved_config[config_var]
-            else:
-                missing_config_vars.append(config_var)
-        if missing_config_vars:
-            missing = ', '.join(missing_config_vars)
-            raise InvalidConfigError(
-                error_msg=(
-                    'The profile "%s" is configured to use SSO but is missing '
-                    'required configuration: %s' % (profile_name, missing)
-                )
-            )
-        return config
-    def _resolve_sso_session_reference(self, profile_config, sso_sessions):
-        sso_session_name = profile_config.get('sso_session')
-        if sso_session_name is None:
-            # No reference to resolve, proceed with legacy flow
-            return profile_config, ()
-        if sso_session_name not in sso_sessions:
-            error_msg = f'The specified sso-session does not exist: "{sso_session_name}"'
-            raise InvalidConfigError(error_msg=error_msg)
-        config = profile_config.copy()
-        session = sso_sessions[sso_session_name]
-        for config_var, val in session.items():
-            # Validate any keys referenced in both profile and sso_session match
-            if config.get(config_var, val) != val:
-                error_msg = (
-                    f"The value for {config_var} is inconsistent between "
-                    f"profile ({config[config_var]}) and sso-session ({val})."
-                )
-                raise InvalidConfigError(error_msg=error_msg)
-            config[config_var] = val
-        return config, ('sso_session',)
-    def load(self):
-        sso_config = self._load_sso_config()
-        if not sso_config:
-            return None
-        fetcher_kwargs = {
-            'start_url': sso_config['sso_start_url'],
-            'sso_region': sso_config['sso_region'],
-            'role_name': sso_config['sso_role_name'],
-            'account_id': sso_config['sso_account_id'],
-            'client_creator': self._client_creator,
-            'token_loader': SSOTokenLoader(cache=self._token_cache),
-            'cache': self.cache,
-        }
-        if 'sso_session' in sso_config:
-            fetcher_kwargs['sso_session_name'] = sso_config['sso_session']
-            fetcher_kwargs['token_provider'] = self._token_provider
-        sso_fetcher = SSOCredentialFetcher(**fetcher_kwargs)
-        return DeferredRefreshableCredentials(
-            method=self.METHOD,
-            refresh_using=sso_fetcher.fetch_credentials,
-        )

spaces/Big-Web/MMSD/env/Lib/site-packages/setuptools/_vendor/packaging/_manylinux.py DELETED Viewed

@@ -1,301 +0,0 @@
-import collections
-import functools
-import os
-import re
-import struct
-import sys
-import warnings
-from typing import IO, Dict, Iterator, NamedTuple, Optional, Tuple
-# Python does not provide platform information at sufficient granularity to
-# identify the architecture of the running executable in some cases, so we
-# determine it dynamically by reading the information from the running
-# process. This only applies on Linux, which uses the ELF format.
-class _ELFFileHeader:
-    # https://en.wikipedia.org/wiki/Executable_and_Linkable_Format#File_header
-    class _InvalidELFFileHeader(ValueError):
-        """
-        An invalid ELF file header was found.
-        """
-    ELF_MAGIC_NUMBER = 0x7F454C46
-    ELFCLASS32 = 1
-    ELFCLASS64 = 2
-    ELFDATA2LSB = 1
-    ELFDATA2MSB = 2
-    EM_386 = 3
-    EM_S390 = 22
-    EM_ARM = 40
-    EM_X86_64 = 62
-    EF_ARM_ABIMASK = 0xFF000000
-    EF_ARM_ABI_VER5 = 0x05000000
-    EF_ARM_ABI_FLOAT_HARD = 0x00000400
-    def __init__(self, file: IO[bytes]) -> None:
-        def unpack(fmt: str) -> int:
-            try:
-                data = file.read(struct.calcsize(fmt))
-                result: Tuple[int, ...] = struct.unpack(fmt, data)
-            except struct.error:
-                raise _ELFFileHeader._InvalidELFFileHeader()
-            return result[0]
-        self.e_ident_magic = unpack(">I")
-        if self.e_ident_magic != self.ELF_MAGIC_NUMBER:
-            raise _ELFFileHeader._InvalidELFFileHeader()
-        self.e_ident_class = unpack("B")
-        if self.e_ident_class not in {self.ELFCLASS32, self.ELFCLASS64}:
-            raise _ELFFileHeader._InvalidELFFileHeader()
-        self.e_ident_data = unpack("B")
-        if self.e_ident_data not in {self.ELFDATA2LSB, self.ELFDATA2MSB}:
-            raise _ELFFileHeader._InvalidELFFileHeader()
-        self.e_ident_version = unpack("B")
-        self.e_ident_osabi = unpack("B")
-        self.e_ident_abiversion = unpack("B")
-        self.e_ident_pad = file.read(7)
-        format_h = "<H" if self.e_ident_data == self.ELFDATA2LSB else ">H"
-        format_i = "<I" if self.e_ident_data == self.ELFDATA2LSB else ">I"
-        format_q = "<Q" if self.e_ident_data == self.ELFDATA2LSB else ">Q"
-        format_p = format_i if self.e_ident_class == self.ELFCLASS32 else format_q
-        self.e_type = unpack(format_h)
-        self.e_machine = unpack(format_h)
-        self.e_version = unpack(format_i)
-        self.e_entry = unpack(format_p)
-        self.e_phoff = unpack(format_p)
-        self.e_shoff = unpack(format_p)
-        self.e_flags = unpack(format_i)
-        self.e_ehsize = unpack(format_h)
-        self.e_phentsize = unpack(format_h)
-        self.e_phnum = unpack(format_h)
-        self.e_shentsize = unpack(format_h)
-        self.e_shnum = unpack(format_h)
-        self.e_shstrndx = unpack(format_h)
-def _get_elf_header() -> Optional[_ELFFileHeader]:
-    try:
-        with open(sys.executable, "rb") as f:
-            elf_header = _ELFFileHeader(f)
-    except (OSError, TypeError, _ELFFileHeader._InvalidELFFileHeader):
-        return None
-    return elf_header
-def _is_linux_armhf() -> bool:
-    # hard-float ABI can be detected from the ELF header of the running
-    # process
-    # https://static.docs.arm.com/ihi0044/g/aaelf32.pdf
-    elf_header = _get_elf_header()
-    if elf_header is None:
-        return False
-    result = elf_header.e_ident_class == elf_header.ELFCLASS32
-    result &= elf_header.e_ident_data == elf_header.ELFDATA2LSB
-    result &= elf_header.e_machine == elf_header.EM_ARM
-    result &= (
-        elf_header.e_flags & elf_header.EF_ARM_ABIMASK
-    ) == elf_header.EF_ARM_ABI_VER5
-    result &= (
-        elf_header.e_flags & elf_header.EF_ARM_ABI_FLOAT_HARD
-    ) == elf_header.EF_ARM_ABI_FLOAT_HARD
-    return result
-def _is_linux_i686() -> bool:
-    elf_header = _get_elf_header()
-    if elf_header is None:
-        return False
-    result = elf_header.e_ident_class == elf_header.ELFCLASS32
-    result &= elf_header.e_ident_data == elf_header.ELFDATA2LSB
-    result &= elf_header.e_machine == elf_header.EM_386
-    return result
-def _have_compatible_abi(arch: str) -> bool:
-    if arch == "armv7l":
-        return _is_linux_armhf()
-    if arch == "i686":
-        return _is_linux_i686()
-    return arch in {"x86_64", "aarch64", "ppc64", "ppc64le", "s390x"}
-# If glibc ever changes its major version, we need to know what the last
-# minor version was, so we can build the complete list of all versions.
-# For now, guess what the highest minor version might be, assume it will
-# be 50 for testing. Once this actually happens, update the dictionary
-# with the actual value.
-_LAST_GLIBC_MINOR: Dict[int, int] = collections.defaultdict(lambda: 50)
-class _GLibCVersion(NamedTuple):
-    major: int
-    minor: int
-def _glibc_version_string_confstr() -> Optional[str]:
-    """
-    Primary implementation of glibc_version_string using os.confstr.
-    """
-    # os.confstr is quite a bit faster than ctypes.DLL. It's also less likely
-    # to be broken or missing. This strategy is used in the standard library
-    # platform module.
-    # https://github.com/python/cpython/blob/fcf1d003bf4f0100c/Lib/platform.py#L175-L183
-    try:
-        # os.confstr("CS_GNU_LIBC_VERSION") returns a string like "glibc 2.17".
-        version_string = os.confstr("CS_GNU_LIBC_VERSION")
-        assert version_string is not None
-        _, version = version_string.split()
-    except (AssertionError, AttributeError, OSError, ValueError):
-        # os.confstr() or CS_GNU_LIBC_VERSION not available (or a bad value)...
-        return None
-    return version
-def _glibc_version_string_ctypes() -> Optional[str]:
-    """
-    Fallback implementation of glibc_version_string using ctypes.
-    """
-    try:
-        import ctypes
-    except ImportError:
-        return None
-    # ctypes.CDLL(None) internally calls dlopen(NULL), and as the dlopen
-    # manpage says, "If filename is NULL, then the returned handle is for the
-    # main program". This way we can let the linker do the work to figure out
-    # which libc our process is actually using.
-    #
-    # We must also handle the special case where the executable is not a
-    # dynamically linked executable. This can occur when using musl libc,
-    # for example. In this situation, dlopen() will error, leading to an
-    # OSError. Interestingly, at least in the case of musl, there is no
-    # errno set on the OSError. The single string argument used to construct
-    # OSError comes from libc itself and is therefore not portable to
-    # hard code here. In any case, failure to call dlopen() means we
-    # can proceed, so we bail on our attempt.
-    try:
-        process_namespace = ctypes.CDLL(None)
-    except OSError:
-        return None
-    try:
-        gnu_get_libc_version = process_namespace.gnu_get_libc_version
-    except AttributeError:
-        # Symbol doesn't exist -> therefore, we are not linked to
-        # glibc.
-        return None
-    # Call gnu_get_libc_version, which returns a string like "2.5"
-    gnu_get_libc_version.restype = ctypes.c_char_p
-    version_str: str = gnu_get_libc_version()
-    # py2 / py3 compatibility:
-    if not isinstance(version_str, str):
-        version_str = version_str.decode("ascii")
-    return version_str
-def _glibc_version_string() -> Optional[str]:
-    """Returns glibc version string, or None if not using glibc."""
-    return _glibc_version_string_confstr() or _glibc_version_string_ctypes()
-def _parse_glibc_version(version_str: str) -> Tuple[int, int]:
-    """Parse glibc version.
-    We use a regexp instead of str.split because we want to discard any
-    random junk that might come after the minor version -- this might happen
-    in patched/forked versions of glibc (e.g. Linaro's version of glibc
-    uses version strings like "2.20-2014.11"). See gh-3588.
-    """
-    m = re.match(r"(?P<major>[0-9]+)\.(?P<minor>[0-9]+)", version_str)
-    if not m:
-        warnings.warn(
-            "Expected glibc version with 2 components major.minor,"
-            " got: %s" % version_str,
-            RuntimeWarning,
-        )
-        return -1, -1
-    return int(m.group("major")), int(m.group("minor"))
-@functools.lru_cache()
-def _get_glibc_version() -> Tuple[int, int]:
-    version_str = _glibc_version_string()
-    if version_str is None:
-        return (-1, -1)
-    return _parse_glibc_version(version_str)
-# From PEP 513, PEP 600
-def _is_compatible(name: str, arch: str, version: _GLibCVersion) -> bool:
-    sys_glibc = _get_glibc_version()
-    if sys_glibc < version:
-        return False
-    # Check for presence of _manylinux module.
-    try:
-        import _manylinux  # noqa
-    except ImportError:
-        return True
-    if hasattr(_manylinux, "manylinux_compatible"):
-        result = _manylinux.manylinux_compatible(version[0], version[1], arch)
-        if result is not None:
-            return bool(result)
-        return True
-    if version == _GLibCVersion(2, 5):
-        if hasattr(_manylinux, "manylinux1_compatible"):
-            return bool(_manylinux.manylinux1_compatible)
-    if version == _GLibCVersion(2, 12):
-        if hasattr(_manylinux, "manylinux2010_compatible"):
-            return bool(_manylinux.manylinux2010_compatible)
-    if version == _GLibCVersion(2, 17):
-        if hasattr(_manylinux, "manylinux2014_compatible"):
-            return bool(_manylinux.manylinux2014_compatible)
-    return True
-_LEGACY_MANYLINUX_MAP = {
-    # CentOS 7 w/ glibc 2.17 (PEP 599)
-    (2, 17): "manylinux2014",
-    # CentOS 6 w/ glibc 2.12 (PEP 571)
-    (2, 12): "manylinux2010",
-    # CentOS 5 w/ glibc 2.5 (PEP 513)
-    (2, 5): "manylinux1",
-}
-def platform_tags(linux: str, arch: str) -> Iterator[str]:
-    if not _have_compatible_abi(arch):
-        return
-    # Oldest glibc to be supported regardless of architecture is (2, 17).
-    too_old_glibc2 = _GLibCVersion(2, 16)
-    if arch in {"x86_64", "i686"}:
-        # On x86/i686 also oldest glibc to be supported is (2, 5).
-        too_old_glibc2 = _GLibCVersion(2, 4)
-    current_glibc = _GLibCVersion(*_get_glibc_version())
-    glibc_max_list = [current_glibc]
-    # We can assume compatibility across glibc major versions.
-    # https://sourceware.org/bugzilla/show_bug.cgi?id=24636
-    #
-    # Build a list of maximum glibc versions so that we can
-    # output the canonical list of all glibc from current_glibc
-    # down to too_old_glibc2, including all intermediary versions.
-    for glibc_major in range(current_glibc.major - 1, 1, -1):
-        glibc_minor = _LAST_GLIBC_MINOR[glibc_major]
-        glibc_max_list.append(_GLibCVersion(glibc_major, glibc_minor))
-    for glibc_max in glibc_max_list:
-        if glibc_max.major == too_old_glibc2.major:
-            min_minor = too_old_glibc2.minor
-        else:
-            # For other glibc major versions oldest supported is (x, 0).
-            min_minor = -1
-        for glibc_minor in range(glibc_max.minor, min_minor, -1):
-            glibc_version = _GLibCVersion(glibc_max.major, glibc_minor)
-            tag = "manylinux_{}_{}".format(*glibc_version)
-            if _is_compatible(tag, arch, glibc_version):
-                yield linux.replace("linux", tag)
-            # Handle the legacy manylinux1, manylinux2010, manylinux2014 tags.
-            if glibc_version in _LEGACY_MANYLINUX_MAP:
-                legacy_tag = _LEGACY_MANYLINUX_MAP[glibc_version]
-                if _is_compatible(legacy_tag, arch, glibc_version):
-                    yield linux.replace("linux", legacy_tag)

spaces/Bingsu/color_textual_inversion/LICENSE.md DELETED Viewed

@@ -1,22 +0,0 @@
-The MIT License (MIT)
-Copyright (c) 2022 Bingsu
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

spaces/CALM/Dashboard/dashboard_utils/main_metrics.py DELETED Viewed

@@ -1,29 +0,0 @@
-import datetime
-import streamlit as st
-import wandb
-from dashboard_utils.time_tracker import _log, simple_time_tracker
-WANDB_RUN_URL = st.secrets["WANDB_RUN_URL_MAIN_METRICS"]
-CACHE_TTL = 100
-@st.cache(ttl=CACHE_TTL, show_spinner=False)
-@simple_time_tracker(_log)
-def get_main_metrics():
-    api = wandb.Api()
-    run = api.run(WANDB_RUN_URL)
-    history = run.scan_history(keys=["optimizer_step", "loss", "alive peers", "_timestamp"])
-    steps = []
-    losses = []
-    alive_peers = []
-    dates = []
-    for row in history:
-        steps.append(row["optimizer_step"])
-        losses.append(row["loss"])
-        alive_peers.append(row["alive peers"])
-        dates.append(datetime.datetime.utcfromtimestamp(row["_timestamp"]))
-    return steps, dates, losses, alive_peers

spaces/CVPR/LIVE/pybind11/tests/test_local_bindings.cpp DELETED Viewed

@@ -1,101 +0,0 @@
-/*
-    tests/test_local_bindings.cpp -- tests the py::module_local class feature which makes a class
-                                     binding local to the module in which it is defined.
-    Copyright (c) 2017 Jason Rhinelander <[email protected]>
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-#include "pybind11_tests.h"
-#include "local_bindings.h"
-#include <pybind11/stl.h>
-#include <pybind11/stl_bind.h>
-#include <numeric>
-TEST_SUBMODULE(local_bindings, m) {
-    // test_load_external
-    m.def("load_external1", [](ExternalType1 &e) { return e.i; });
-    m.def("load_external2", [](ExternalType2 &e) { return e.i; });
-    // test_local_bindings
-    // Register a class with py::module_local:
-    bind_local<LocalType, -1>(m, "LocalType", py::module_local())
-        .def("get3", [](LocalType &t) { return t.i + 3; })
-        ;
-    m.def("local_value", [](LocalType &l) { return l.i; });
-    // test_nonlocal_failure
-    // The main pybind11 test module is loaded first, so this registration will succeed (the second
-    // one, in pybind11_cross_module_tests.cpp, is designed to fail):
-    bind_local<NonLocalType, 0>(m, "NonLocalType")
-        .def(py::init<int>())
-        .def("get", [](LocalType &i) { return i.i; })
-        ;
-    // test_duplicate_local
-    // py::module_local declarations should be visible across compilation units that get linked together;
-    // this tries to register a duplicate local.  It depends on a definition in test_class.cpp and
-    // should raise a runtime error from the duplicate definition attempt.  If test_class isn't
-    // available it *also* throws a runtime error (with "test_class not enabled" as value).
-    m.def("register_local_external", [m]() {
-        auto main = py::module::import("pybind11_tests");
-        if (py::hasattr(main, "class_")) {
-            bind_local<LocalExternal, 7>(m, "LocalExternal", py::module_local());
-        }
-        else throw std::runtime_error("test_class not enabled");
-    });
-    // test_stl_bind_local
-    // stl_bind.h binders defaults to py::module_local if the types are local or converting:
-    py::bind_vector<LocalVec>(m, "LocalVec");
-    py::bind_map<LocalMap>(m, "LocalMap");
-    // and global if the type (or one of the types, for the map) is global:
-    py::bind_vector<NonLocalVec>(m, "NonLocalVec");
-    py::bind_map<NonLocalMap>(m, "NonLocalMap");
-    // test_stl_bind_global
-    // They can, however, be overridden to global using `py::module_local(false)`:
-    bind_local<NonLocal2, 10>(m, "NonLocal2");
-    py::bind_vector<LocalVec2>(m, "LocalVec2", py::module_local());
-    py::bind_map<NonLocalMap2>(m, "NonLocalMap2", py::module_local(false));
-    // test_mixed_local_global
-    // We try this both with the global type registered first and vice versa (the order shouldn't
-    // matter).
-    m.def("register_mixed_global", [m]() {
-        bind_local<MixedGlobalLocal, 100>(m, "MixedGlobalLocal", py::module_local(false));
-    });
-    m.def("register_mixed_local", [m]() {
-        bind_local<MixedLocalGlobal, 1000>(m, "MixedLocalGlobal", py::module_local());
-    });
-    m.def("get_mixed_gl", [](int i) { return MixedGlobalLocal(i); });
-    m.def("get_mixed_lg", [](int i) { return MixedLocalGlobal(i); });
-    // test_internal_locals_differ
-    m.def("local_cpp_types_addr", []() { return (uintptr_t) &py::detail::registered_local_types_cpp(); });
-    // test_stl_caster_vs_stl_bind
-    m.def("load_vector_via_caster", [](std::vector<int> v) {
-        return std::accumulate(v.begin(), v.end(), 0);
-    });
-    // test_cross_module_calls
-    m.def("return_self", [](LocalVec *v) { return v; });
-    m.def("return_copy", [](const LocalVec &v) { return LocalVec(v); });
-    class Cat : public pets::Pet { public: Cat(std::string name) : Pet(name) {}; };
-    py::class_<pets::Pet>(m, "Pet", py::module_local())
-        .def("get_name", &pets::Pet::name);
-    // Binding for local extending class:
-    py::class_<Cat, pets::Pet>(m, "Cat")
-        .def(py::init<std::string>());
-    m.def("pet_name", [](pets::Pet &p) { return p.name(); });
-    py::class_<MixGL>(m, "MixGL").def(py::init<int>());
-    m.def("get_gl_value", [](MixGL &o) { return o.i + 10; });
-    py::class_<MixGL2>(m, "MixGL2").def(py::init<int>());
-}

spaces/CVPR/LIVE/thrust/thrust/system/cpp/detail/unique_by_key.h DELETED Viewed

@@ -1,23 +0,0 @@
-/*
- *  Copyright 2008-2013 NVIDIA Corporation
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-#pragma once
-#include <thrust/detail/config.h>
-// this system inherits unique_by_key
-#include <thrust/system/detail/sequential/unique_by_key.h>

spaces/Caoyunkang/Segment-Any-Anomaly/SAM/segment_anything/automatic_mask_generator.py DELETED Viewed

@@ -1,372 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-import numpy as np
-import torch
-from torchvision.ops.boxes import batched_nms, box_area  # type: ignore
-from typing import Any, Dict, List, Optional, Tuple
-from .modeling import Sam
-from .predictor import SamPredictor
-from .utils.amg import (
-    MaskData,
-    area_from_rle,
-    batch_iterator,
-    batched_mask_to_box,
-    box_xyxy_to_xywh,
-    build_all_layer_point_grids,
-    calculate_stability_score,
-    coco_encode_rle,
-    generate_crop_boxes,
-    is_box_near_crop_edge,
-    mask_to_rle_pytorch,
-    remove_small_regions,
-    rle_to_mask,
-    uncrop_boxes_xyxy,
-    uncrop_masks,
-    uncrop_points,
-)
-class SamAutomaticMaskGenerator:
-    def __init__(
-        self,
-        model: Sam,
-        points_per_side: Optional[int] = 32,
-        points_per_batch: int = 128,
-        pred_iou_thresh: float = 0.88,
-        stability_score_thresh: float = 0.95,
-        stability_score_offset: float = 1.0,
-        box_nms_thresh: float = 0.7,
-        crop_n_layers: int = 0,
-        crop_nms_thresh: float = 0.7,
-        crop_overlap_ratio: float = 512 / 1500,
-        crop_n_points_downscale_factor: int = 1,
-        point_grids: Optional[List[np.ndarray]] = None,
-        min_mask_region_area: int = 0,
-        output_mode: str = "binary_mask",
-    ) -> None:
-        """
-        Using a SAM model, generates masks for the entire image.
-        Generates a grid of point prompts over the image, then filters
-        low quality and duplicate masks. The default settings are chosen
-        for SAM with a ViT-H backbone.
-        Arguments:
-          model (Sam): The SAM model to use for mask prediction.
-          points_per_side (int or None): The number of points to be sampled
-            along one side of the image. The total number of points is
-            points_per_side**2. If None, 'point_grids' must provide explicit
-            point sampling.
-          points_per_batch (int): Sets the number of points run simultaneously
-            by the model. Higher numbers may be faster but use more GPU memory.
-          pred_iou_thresh (float): A filtering threshold in [0,1], using the
-            model's predicted mask quality.
-          stability_score_thresh (float): A filtering threshold in [0,1], using
-            the stability of the mask under changes to the cutoff used to binarize
-            the model's mask predictions.
-          stability_score_offset (float): The amount to shift the cutoff when
-            calculated the stability score.
-          box_nms_thresh (float): The box IoU cutoff used by non-maximal
-            suppression to filter duplicate masks.
-          crops_n_layers (int): If >0, mask prediction will be run again on
-            crops of the image. Sets the number of layers to run, where each
-            layer has 2**i_layer number of image crops.
-          crops_nms_thresh (float): The box IoU cutoff used by non-maximal
-            suppression to filter duplicate masks between different crops.
-          crop_overlap_ratio (float): Sets the degree to which crops overlap.
-            In the first crop layer, crops will overlap by this fraction of
-            the image length. Later layers with more crops scale down this overlap.
-          crop_n_points_downscale_factor (int): The number of points-per-side
-            sampled in layer n is scaled down by crop_n_points_downscale_factor**n.
-          point_grids (list(np.ndarray) or None): A list over explicit grids
-            of points used for sampling, normalized to [0,1]. The nth grid in the
-            list is used in the nth crop layer. Exclusive with points_per_side.
-          min_mask_region_area (int): If >0, postprocessing will be applied
-            to remove disconnected regions and holes in masks with area smaller
-            than min_mask_region_area. Requires opencv.
-          output_mode (str): The form masks are returned in. Can be 'binary_mask',
-            'uncompressed_rle', or 'coco_rle'. 'coco_rle' requires pycocotools.
-            For large resolutions, 'binary_mask' may consume large amounts of
-            memory.
-        """
-        assert (points_per_side is None) != (
-            point_grids is None
-        ), "Exactly one of points_per_side or point_grid must be provided."
-        if points_per_side is not None:
-            self.point_grids = build_all_layer_point_grids(
-                points_per_side,
-                crop_n_layers,
-                crop_n_points_downscale_factor,
-            )
-        elif point_grids is not None:
-            self.point_grids = point_grids
-        else:
-            raise ValueError("Can't have both points_per_side and point_grid be None.")
-        assert output_mode in [
-            "binary_mask",
-            "uncompressed_rle",
-            "coco_rle",
-        ], f"Unknown output_mode {output_mode}."
-        if output_mode == "coco_rle":
-            from pycocotools import mask as mask_utils  # type: ignore # noqa: F401
-        if min_mask_region_area > 0:
-            import cv2  # type: ignore # noqa: F401
-        self.predictor = SamPredictor(model)
-        self.points_per_batch = points_per_batch
-        self.pred_iou_thresh = pred_iou_thresh
-        self.stability_score_thresh = stability_score_thresh
-        self.stability_score_offset = stability_score_offset
-        self.box_nms_thresh = box_nms_thresh
-        self.crop_n_layers = crop_n_layers
-        self.crop_nms_thresh = crop_nms_thresh
-        self.crop_overlap_ratio = crop_overlap_ratio
-        self.crop_n_points_downscale_factor = crop_n_points_downscale_factor
-        self.min_mask_region_area = min_mask_region_area
-        self.output_mode = output_mode
-    @torch.no_grad()
-    def generate(self, image: np.ndarray) -> List[Dict[str, Any]]:
-        """
-        Generates masks for the given image.
-        Arguments:
-          image (np.ndarray): The image to generate masks for, in HWC uint8 format.
-        Returns:
-           list(dict(str, any)): A list over records for masks. Each record is
-             a dict containing the following keys:
-               segmentation (dict(str, any) or np.ndarray): The mask. If
-                 output_mode='binary_mask', is an array of shape HW. Otherwise,
-                 is a dictionary containing the RLE.
-               bbox (list(float)): The box around the mask, in XYWH format.
-               area (int): The area in pixels of the mask.
-               predicted_iou (float): The model's own prediction of the mask's
-                 quality. This is filtered by the pred_iou_thresh parameter.
-               point_coords (list(list(float))): The point coordinates input
-                 to the model to generate this mask.
-               stability_score (float): A measure of the mask's quality. This
-                 is filtered on using the stability_score_thresh parameter.
-               crop_box (list(float)): The crop of the image used to generate
-                 the mask, given in XYWH format.
-        """
-        # Generate masks
-        mask_data = self._generate_masks(image)
-        # Filter small disconnected regions and holes in masks
-        if self.min_mask_region_area > 0:
-            mask_data = self.postprocess_small_regions(
-                mask_data,
-                self.min_mask_region_area,
-                max(self.box_nms_thresh, self.crop_nms_thresh),
-            )
-        # Encode masks
-        if self.output_mode == "coco_rle":
-            mask_data["segmentations"] = [coco_encode_rle(rle) for rle in mask_data["rles"]]
-        elif self.output_mode == "binary_mask":
-            mask_data["segmentations"] = [rle_to_mask(rle) for rle in mask_data["rles"]]
-        else:
-            mask_data["segmentations"] = mask_data["rles"]
-        # Write mask records
-        curr_anns = []
-        for idx in range(len(mask_data["segmentations"])):
-            ann = {
-                "segmentation": mask_data["segmentations"][idx],
-                "area": area_from_rle(mask_data["rles"][idx]),
-                "bbox": box_xyxy_to_xywh(mask_data["boxes"][idx]).tolist(),
-                "predicted_iou": mask_data["iou_preds"][idx].item(),
-                "point_coords": [mask_data["points"][idx].tolist()],
-                "stability_score": mask_data["stability_score"][idx].item(),
-                "crop_box": box_xyxy_to_xywh(mask_data["crop_boxes"][idx]).tolist(),
-            }
-            curr_anns.append(ann)
-        return curr_anns
-    def _generate_masks(self, image: np.ndarray) -> MaskData:
-        orig_size = image.shape[:2]
-        crop_boxes, layer_idxs = generate_crop_boxes(
-            orig_size, self.crop_n_layers, self.crop_overlap_ratio
-        )
-        # Iterate over image crops
-        data = MaskData()
-        for crop_box, layer_idx in zip(crop_boxes, layer_idxs):
-            crop_data = self._process_crop(image, crop_box, layer_idx, orig_size)
-            data.cat(crop_data)
-        # Remove duplicate masks between crops
-        if len(crop_boxes) > 1:
-            # Prefer masks from smaller crops
-            scores = 1 / box_area(data["crop_boxes"])
-            scores = scores.to(data["boxes"].device)
-            keep_by_nms = batched_nms(
-                data["boxes"].float(),
-                scores,
-                torch.zeros(len(data["boxes"])),  # categories
-                iou_threshold=self.crop_nms_thresh,
-            )
-            data.filter(keep_by_nms)
-        data.to_numpy()
-        return data
-    def _process_crop(
-        self,
-        image: np.ndarray,
-        crop_box: List[int],
-        crop_layer_idx: int,
-        orig_size: Tuple[int, ...],
-    ) -> MaskData:
-        # Crop the image and calculate embeddings
-        x0, y0, x1, y1 = crop_box
-        cropped_im = image[y0:y1, x0:x1, :]
-        cropped_im_size = cropped_im.shape[:2]
-        self.predictor.set_image(cropped_im)
-        # Get points for this crop
-        points_scale = np.array(cropped_im_size)[None, ::-1]
-        points_for_image = self.point_grids[crop_layer_idx] * points_scale
-        # Generate masks for this crop in batches
-        data = MaskData()
-        for (points,) in batch_iterator(self.points_per_batch, points_for_image):
-            batch_data = self._process_batch(points, cropped_im_size, crop_box, orig_size)
-            data.cat(batch_data)
-            del batch_data
-        self.predictor.reset_image()
-        # Remove duplicates within this crop.
-        keep_by_nms = batched_nms(
-            data["boxes"].float(),
-            data["iou_preds"],
-            torch.zeros(len(data["boxes"])),  # categories
-            iou_threshold=self.box_nms_thresh,
-        )
-        data.filter(keep_by_nms)
-        # Return to the original image frame
-        data["boxes"] = uncrop_boxes_xyxy(data["boxes"], crop_box)
-        data["points"] = uncrop_points(data["points"], crop_box)
-        data["crop_boxes"] = torch.tensor([crop_box for _ in range(len(data["rles"]))])
-        return data
-    def _process_batch(
-        self,
-        points: np.ndarray,
-        im_size: Tuple[int, ...],
-        crop_box: List[int],
-        orig_size: Tuple[int, ...],
-    ) -> MaskData:
-        orig_h, orig_w = orig_size
-        # Run model on this batch
-        transformed_points = self.predictor.transform.apply_coords(points, im_size)
-        in_points = torch.as_tensor(transformed_points, device=self.predictor.device)
-        in_labels = torch.ones(in_points.shape[0], dtype=torch.int, device=in_points.device)
-        masks, iou_preds, _ = self.predictor.predict_torch(
-            in_points[:, None, :],
-            in_labels[:, None],
-            multimask_output=True,
-            return_logits=True,
-        )
-        # Serialize predictions and store in MaskData
-        data = MaskData(
-            masks=masks.flatten(0, 1),
-            iou_preds=iou_preds.flatten(0, 1),
-            points=torch.as_tensor(points.repeat(masks.shape[1], axis=0)),
-        )
-        del masks
-        # Filter by predicted IoU
-        if self.pred_iou_thresh > 0.0:
-            keep_mask = data["iou_preds"] > self.pred_iou_thresh
-            data.filter(keep_mask)
-        # Calculate stability score
-        data["stability_score"] = calculate_stability_score(
-            data["masks"], self.predictor.model.mask_threshold, self.stability_score_offset
-        )
-        if self.stability_score_thresh > 0.0:
-            keep_mask = data["stability_score"] >= self.stability_score_thresh
-            data.filter(keep_mask)
-        # Threshold masks and calculate boxes
-        data["masks"] = data["masks"] > self.predictor.model.mask_threshold
-        data["boxes"] = batched_mask_to_box(data["masks"])
-        # Filter boxes that touch crop boundaries
-        keep_mask = ~is_box_near_crop_edge(data["boxes"], crop_box, [0, 0, orig_w, orig_h])
-        if not torch.all(keep_mask):
-            data.filter(keep_mask)
-        # Compress to RLE
-        data["masks"] = uncrop_masks(data["masks"], crop_box, orig_h, orig_w)
-        data["rles"] = mask_to_rle_pytorch(data["masks"])
-        del data["masks"]
-        return data
-    @staticmethod
-    def postprocess_small_regions(
-        mask_data: MaskData, min_area: int, nms_thresh: float
-    ) -> MaskData:
-        """
-        Removes small disconnected regions and holes in masks, then reruns
-        box NMS to remove any new duplicates.
-        Edits mask_data in place.
-        Requires open-cv as a dependency.
-        """
-        if len(mask_data["rles"]) == 0:
-            return mask_data
-        # Filter small disconnected regions and holes
-        new_masks = []
-        scores = []
-        for rle in mask_data["rles"]:
-            mask = rle_to_mask(rle)
-            mask, changed = remove_small_regions(mask, min_area, mode="holes")
-            unchanged = not changed
-            mask, changed = remove_small_regions(mask, min_area, mode="islands")
-            unchanged = unchanged and not changed
-            new_masks.append(torch.as_tensor(mask).unsqueeze(0))
-            # Give score=0 to changed masks and score=1 to unchanged masks
-            # so NMS will prefer ones that didn't need postprocessing
-            scores.append(float(unchanged))
-        # Recalculate boxes and remove any new duplicates
-        masks = torch.cat(new_masks, dim=0)
-        boxes = batched_mask_to_box(masks)
-        keep_by_nms = batched_nms(
-            boxes.float(),
-            torch.as_tensor(scores),
-            torch.zeros(len(boxes)),  # categories
-            iou_threshold=nms_thresh,
-        )
-        # Only recalculate RLEs for masks that have changed
-        for i_mask in keep_by_nms:
-            if scores[i_mask] == 0.0:
-                mask_torch = masks[i_mask].unsqueeze(0)
-                mask_data["rles"][i_mask] = mask_to_rle_pytorch(mask_torch)[0]
-                mask_data["boxes"][i_mask] = boxes[i_mask]  # update res directly
-        mask_data.filter(keep_by_nms)
-        return mask_data

spaces/Catmeow/AI_story_writing/app.py DELETED Viewed

@@ -1,44 +0,0 @@
-import gradio as gr
-from transformers import pipeline
-title = "tory Generator"
-# gpt-neo-2.7B   gpt-j-6B
-def generate(text,the_model,max_length,temperature,repetition_penalty):
-    generator = pipeline('text-generation', model=the_model)
-    result = generator(text, num_return_sequences=3,
-        max_length=max_length,
-        temperature=temperature,
-        repetition_penalty = repetition_penalty,
-        no_repeat_ngram_size=2,early_stopping=False)
-    return result[0]["generated_text"],result[1]["generated_text"],result[2]["generated_text"]
-def complete_with_gpt(text,context,the_model,max_length,temperature,repetition_penalty):
-    # Use the last [context] characters of the text as context
-    max_length = max_length+context
-    return generate(text[-context:],the_model,max_length,temperature,repetition_penalty)
-def send(text1,context,text2):
-    if len(text1)<context:
-        return text1 + text2[len(text1):]
-    else:
-        return text1 + text2[context:]
-with gr.Blocks() as demo:
-    textbox = gr.Textbox(placeholder="Type here and press enter...", lines=4)
-    btn = gr.Button("Generate")
-    context = gr.Slider(value=200,label="Truncate input text length (AI's memory)",minimum=1,maximum=500)
-    the_model = gr.Dropdown(choices=['gpt2','gpt2-medium','gpt2-large','gpt2-xl','EleutherAI/gpt-neo-2.7B','EleutherAI/gpt-j-6B'],value = 'gpt2',label="Choose model")
-    max_length = gr.Slider(value=20,label="Max Generate Length",minimum=1,maximum=50)
-    temperature = gr.Slider(value=0.9,label="Temperature",minimum=0.0,maximum=1.0,step=0.05)
-    repetition_penalty = gr.Slider(value=1.5,label="Repetition penalty",minimum=0.2,maximum=2,step=0.1)
-    output1 = gr.Textbox(lines=4,label='1')
-    send1 = gr.Button("Send1 to Origin Textbox").click(send,inputs=[textbox,context,output1],outputs=textbox)
-    output2 = gr.Textbox(lines=4,label='2')
-    send2 = gr.Button("Send2 to Origin Textbox").click(send,inputs=[textbox,context,output2],outputs=textbox)
-    output3 = gr.Textbox(lines=4,label='3')
-    send3 = gr.Button("Send3 to Origin Textbox").click(send,inputs=[textbox,context,output3],outputs=textbox)
-    btn.click(complete_with_gpt,inputs=[textbox,context,the_model,max_length,temperature,repetition_penalty], outputs=[output1,output2,output3])
-demo.launch()

spaces/ClueAI/ChatYuan-large-v2/README.md DELETED Viewed

@@ -1,13 +0,0 @@
----
-title: ChatYuan Large V2
-emoji: 📊
-colorFrom: red
-colorTo: pink
-sdk: gradio
-sdk_version: 3.23.0
-app_file: app.py
-pinned: false
-license: creativeml-openrail-m
----
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/Cropinky/esrgan/realesrgan/archs/__init__.py DELETED Viewed

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

spaces/CrucibleAI/ControlNetMediaPipeFaceSD21/cldm/logger.py DELETED Viewed

@@ -1,76 +0,0 @@
-import os
-import numpy as np
-import torch
-import torchvision
-from PIL import Image
-from pytorch_lightning.callbacks import Callback
-from pytorch_lightning.utilities.distributed import rank_zero_only
-class ImageLogger(Callback):
-    def __init__(self, batch_frequency=2000, max_images=4, clamp=True, increase_log_steps=True,
-                 rescale=True, disabled=False, log_on_batch_idx=False, log_first_step=False,
-                 log_images_kwargs=None):
-        super().__init__()
-        self.rescale = rescale
-        self.batch_freq = batch_frequency
-        self.max_images = max_images
-        if not increase_log_steps:
-            self.log_steps = [self.batch_freq]
-        self.clamp = clamp
-        self.disabled = disabled
-        self.log_on_batch_idx = log_on_batch_idx
-        self.log_images_kwargs = log_images_kwargs if log_images_kwargs else {}
-        self.log_first_step = log_first_step
-    @rank_zero_only
-    def log_local(self, save_dir, split, images, global_step, current_epoch, batch_idx):
-        root = os.path.join(save_dir, "image_log", split)
-        for k in images:
-            grid = torchvision.utils.make_grid(images[k], nrow=4)
-            if self.rescale:
-                grid = (grid + 1.0) / 2.0  # -1,1 -> 0,1; c,h,w
-            grid = grid.transpose(0, 1).transpose(1, 2).squeeze(-1)
-            grid = grid.numpy()
-            grid = (grid * 255).astype(np.uint8)
-            filename = "{}_gs-{:06}_e-{:06}_b-{:06}.png".format(k, global_step, current_epoch, batch_idx)
-            path = os.path.join(root, filename)
-            os.makedirs(os.path.split(path)[0], exist_ok=True)
-            Image.fromarray(grid).save(path)
-    def log_img(self, pl_module, batch, batch_idx, split="train"):
-        check_idx = batch_idx  # if self.log_on_batch_idx else pl_module.global_step
-        if (self.check_frequency(check_idx) and  # batch_idx % self.batch_freq == 0
-                hasattr(pl_module, "log_images") and
-                callable(pl_module.log_images) and
-                self.max_images > 0):
-            logger = type(pl_module.logger)
-            is_train = pl_module.training
-            if is_train:
-                pl_module.eval()
-            with torch.no_grad():
-                images = pl_module.log_images(batch, split=split, **self.log_images_kwargs)
-            for k in images:
-                N = min(images[k].shape[0], self.max_images)
-                images[k] = images[k][:N]
-                if isinstance(images[k], torch.Tensor):
-                    images[k] = images[k].detach().cpu()
-                    if self.clamp:
-                        images[k] = torch.clamp(images[k], -1., 1.)
-            self.log_local(pl_module.logger.save_dir, split, images,
-                           pl_module.global_step, pl_module.current_epoch, batch_idx)
-            if is_train:
-                pl_module.train()
-    def check_frequency(self, check_idx):
-        return check_idx % self.batch_freq == 0
-    def on_train_batch_end(self, trainer, pl_module, outputs, batch, batch_idx, dataloader_idx):
-        if not self.disabled:
-            self.log_img(pl_module, batch, batch_idx, split="train")

spaces/DQChoi/gpt-demo/venv/bin/Activate.ps1 DELETED Viewed

@@ -1,247 +0,0 @@
-<#
-.Synopsis
-Activate a Python virtual environment for the current PowerShell session.
-.Description
-Pushes the python executable for a virtual environment to the front of the
-$Env:PATH environment variable and sets the prompt to signify that you are
-in a Python virtual environment. Makes use of the command line switches as
-well as the `pyvenv.cfg` file values present in the virtual environment.
-.Parameter VenvDir
-Path to the directory that contains the virtual environment to activate. The
-default value for this is the parent of the directory that the Activate.ps1
-script is located within.
-.Parameter Prompt
-The prompt prefix to display when this virtual environment is activated. By
-default, this prompt is the name of the virtual environment folder (VenvDir)
-surrounded by parentheses and followed by a single space (ie. '(.venv) ').
-.Example
-Activate.ps1
-Activates the Python virtual environment that contains the Activate.ps1 script.
-.Example
-Activate.ps1 -Verbose
-Activates the Python virtual environment that contains the Activate.ps1 script,
-and shows extra information about the activation as it executes.
-.Example
-Activate.ps1 -VenvDir C:\Users\MyUser\Common\.venv
-Activates the Python virtual environment located in the specified location.
-.Example
-Activate.ps1 -Prompt "MyPython"
-Activates the Python virtual environment that contains the Activate.ps1 script,
-and prefixes the current prompt with the specified string (surrounded in
-parentheses) while the virtual environment is active.
-.Notes
-On Windows, it may be required to enable this Activate.ps1 script by setting the
-execution policy for the user. You can do this by issuing the following PowerShell
-command:
-PS C:\> Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
-For more information on Execution Policies:
-https://go.microsoft.com/fwlink/?LinkID=135170
-#>
-Param(
-    [Parameter(Mandatory = $false)]
-    [String]
-    $VenvDir,
-    [Parameter(Mandatory = $false)]
-    [String]
-    $Prompt
-)
-<# Function declarations --------------------------------------------------- #>
-<#
-.Synopsis
-Remove all shell session elements added by the Activate script, including the
-addition of the virtual environment's Python executable from the beginning of
-the PATH variable.
-.Parameter NonDestructive
-If present, do not remove this function from the global namespace for the
-session.
-#>
-function global:deactivate ([switch]$NonDestructive) {
-    # Revert to original values
-    # The prior prompt:
-    if (Test-Path -Path Function:_OLD_VIRTUAL_PROMPT) {
-        Copy-Item -Path Function:_OLD_VIRTUAL_PROMPT -Destination Function:prompt
-        Remove-Item -Path Function:_OLD_VIRTUAL_PROMPT
-    }
-    # The prior PYTHONHOME:
-    if (Test-Path -Path Env:_OLD_VIRTUAL_PYTHONHOME) {
-        Copy-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME -Destination Env:PYTHONHOME
-        Remove-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME
-    }
-    # The prior PATH:
-    if (Test-Path -Path Env:_OLD_VIRTUAL_PATH) {
-        Copy-Item -Path Env:_OLD_VIRTUAL_PATH -Destination Env:PATH
-        Remove-Item -Path Env:_OLD_VIRTUAL_PATH
-    }
-    # Just remove the VIRTUAL_ENV altogether:
-    if (Test-Path -Path Env:VIRTUAL_ENV) {
-        Remove-Item -Path env:VIRTUAL_ENV
-    }
-    # Just remove VIRTUAL_ENV_PROMPT altogether.
-    if (Test-Path -Path Env:VIRTUAL_ENV_PROMPT) {
-        Remove-Item -Path env:VIRTUAL_ENV_PROMPT
-    }
-    # Just remove the _PYTHON_VENV_PROMPT_PREFIX altogether:
-    if (Get-Variable -Name "_PYTHON_VENV_PROMPT_PREFIX" -ErrorAction SilentlyContinue) {
-        Remove-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Scope Global -Force
-    }
-    # Leave deactivate function in the global namespace if requested:
-    if (-not $NonDestructive) {
-        Remove-Item -Path function:deactivate
-    }
-}
-<#
-.Description
-Get-PyVenvConfig parses the values from the pyvenv.cfg file located in the
-given folder, and returns them in a map.
-For each line in the pyvenv.cfg file, if that line can be parsed into exactly
-two strings separated by `=` (with any amount of whitespace surrounding the =)
-then it is considered a `key = value` line. The left hand string is the key,
-the right hand is the value.
-If the value starts with a `'` or a `"` then the first and last character is
-stripped from the value before being captured.
-.Parameter ConfigDir
-Path to the directory that contains the `pyvenv.cfg` file.
-#>
-function Get-PyVenvConfig(
-    [String]
-    $ConfigDir
-) {
-    Write-Verbose "Given ConfigDir=$ConfigDir, obtain values in pyvenv.cfg"
-    # Ensure the file exists, and issue a warning if it doesn't (but still allow the function to continue).
-    $pyvenvConfigPath = Join-Path -Resolve -Path $ConfigDir -ChildPath 'pyvenv.cfg' -ErrorAction Continue
-    # An empty map will be returned if no config file is found.
-    $pyvenvConfig = @{ }
-    if ($pyvenvConfigPath) {
-        Write-Verbose "File exists, parse `key = value` lines"
-        $pyvenvConfigContent = Get-Content -Path $pyvenvConfigPath
-        $pyvenvConfigContent | ForEach-Object {
-            $keyval = $PSItem -split "\s*=\s*", 2
-            if ($keyval[0] -and $keyval[1]) {
-                $val = $keyval[1]
-                # Remove extraneous quotations around a string value.
-                if ("'""".Contains($val.Substring(0, 1))) {
-                    $val = $val.Substring(1, $val.Length - 2)
-                }
-                $pyvenvConfig[$keyval[0]] = $val
-                Write-Verbose "Adding Key: '$($keyval[0])'='$val'"
-            }
-        }
-    }
-    return $pyvenvConfig
-}
-<# Begin Activate script --------------------------------------------------- #>
-# Determine the containing directory of this script
-$VenvExecPath = Split-Path -Parent $MyInvocation.MyCommand.Definition
-$VenvExecDir = Get-Item -Path $VenvExecPath
-Write-Verbose "Activation script is located in path: '$VenvExecPath'"
-Write-Verbose "VenvExecDir Fullname: '$($VenvExecDir.FullName)"
-Write-Verbose "VenvExecDir Name: '$($VenvExecDir.Name)"
-# Set values required in priority: CmdLine, ConfigFile, Default
-# First, get the location of the virtual environment, it might not be
-# VenvExecDir if specified on the command line.
-if ($VenvDir) {
-    Write-Verbose "VenvDir given as parameter, using '$VenvDir' to determine values"
-}
-else {
-    Write-Verbose "VenvDir not given as a parameter, using parent directory name as VenvDir."
-    $VenvDir = $VenvExecDir.Parent.FullName.TrimEnd("\\/")
-    Write-Verbose "VenvDir=$VenvDir"
-}
-# Next, read the `pyvenv.cfg` file to determine any required value such
-# as `prompt`.
-$pyvenvCfg = Get-PyVenvConfig -ConfigDir $VenvDir
-# Next, set the prompt from the command line, or the config file, or
-# just use the name of the virtual environment folder.
-if ($Prompt) {
-    Write-Verbose "Prompt specified as argument, using '$Prompt'"
-}
-else {
-    Write-Verbose "Prompt not specified as argument to script, checking pyvenv.cfg value"
-    if ($pyvenvCfg -and $pyvenvCfg['prompt']) {
-        Write-Verbose "  Setting based on value in pyvenv.cfg='$($pyvenvCfg['prompt'])'"
-        $Prompt = $pyvenvCfg['prompt'];
-    }
-    else {
-        Write-Verbose "  Setting prompt based on parent's directory's name. (Is the directory name passed to venv module when creating the virtual environment)"
-        Write-Verbose "  Got leaf-name of $VenvDir='$(Split-Path -Path $venvDir -Leaf)'"
-        $Prompt = Split-Path -Path $venvDir -Leaf
-    }
-}
-Write-Verbose "Prompt = '$Prompt'"
-Write-Verbose "VenvDir='$VenvDir'"
-# Deactivate any currently active virtual environment, but leave the
-# deactivate function in place.
-deactivate -nondestructive
-# Now set the environment variable VIRTUAL_ENV, used by many tools to determine
-# that there is an activated venv.
-$env:VIRTUAL_ENV = $VenvDir
-if (-not $Env:VIRTUAL_ENV_DISABLE_PROMPT) {
-    Write-Verbose "Setting prompt to '$Prompt'"
-    # Set the prompt to include the env name
-    # Make sure _OLD_VIRTUAL_PROMPT is global
-    function global:_OLD_VIRTUAL_PROMPT { "" }
-    Copy-Item -Path function:prompt -Destination function:_OLD_VIRTUAL_PROMPT
-    New-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Description "Python virtual environment prompt prefix" -Scope Global -Option ReadOnly -Visibility Public -Value $Prompt
-    function global:prompt {
-        Write-Host -NoNewline -ForegroundColor Green "($_PYTHON_VENV_PROMPT_PREFIX) "
-        _OLD_VIRTUAL_PROMPT
-    }
-    $env:VIRTUAL_ENV_PROMPT = $Prompt
-}
-# Clear PYTHONHOME
-if (Test-Path -Path Env:PYTHONHOME) {
-    Copy-Item -Path Env:PYTHONHOME -Destination Env:_OLD_VIRTUAL_PYTHONHOME
-    Remove-Item -Path Env:PYTHONHOME
-}
-# Add the venv to the PATH
-Copy-Item -Path Env:PATH -Destination Env:_OLD_VIRTUAL_PATH
-$Env:PATH = "$VenvExecDir$([System.IO.Path]::PathSeparator)$Env:PATH"

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/PIL/CurImagePlugin.py DELETED Viewed

@@ -1,75 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# Windows Cursor support for PIL
-#
-# notes:
-#       uses BmpImagePlugin.py to read the bitmap data.
-#
-# history:
-#       96-05-27 fl     Created
-#
-# Copyright (c) Secret Labs AB 1997.
-# Copyright (c) Fredrik Lundh 1996.
-#
-# See the README file for information on usage and redistribution.
-#
-from . import BmpImagePlugin, Image
-from ._binary import i16le as i16
-from ._binary import i32le as i32
-#
-# --------------------------------------------------------------------
-def _accept(prefix):
-    return prefix[:4] == b"\0\0\2\0"
-##
-# Image plugin for Windows Cursor files.
-class CurImageFile(BmpImagePlugin.BmpImageFile):
-    format = "CUR"
-    format_description = "Windows Cursor"
-    def _open(self):
-        offset = self.fp.tell()
-        # check magic
-        s = self.fp.read(6)
-        if not _accept(s):
-            msg = "not a CUR file"
-            raise SyntaxError(msg)
-        # pick the largest cursor in the file
-        m = b""
-        for i in range(i16(s, 4)):
-            s = self.fp.read(16)
-            if not m:
-                m = s
-            elif s[0] > m[0] and s[1] > m[1]:
-                m = s
-        if not m:
-            msg = "No cursors were found"
-            raise TypeError(msg)
-        # load as bitmap
-        self._bitmap(i32(m, 12) + offset)
-        # patch up the bitmap height
-        self._size = self.size[0], self.size[1] // 2
-        d, e, o, a = self.tile[0]
-        self.tile[0] = d, (0, 0) + self.size, o, a
-        return
-#
-# --------------------------------------------------------------------
-Image.register_open(CurImageFile.format, CurImageFile, _accept)
-Image.register_extension(CurImageFile.format, ".cur")

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/gradio/templates/cdn/assets/index-aef3869a.css DELETED Viewed

@@ -1 +0,0 @@

- td.svelte-xrr240.svelte-xrr240{width:45%}td.svelte-xrr240.svelte-xrr240:last-child{width:10%;text-align:right}.file-preview-holder.svelte-xrr240.svelte-xrr240{overflow-x:auto}.file-preview.svelte-xrr240.svelte-xrr240{width:var(--size-full);max-height:var(--size-60);overflow-y:auto;color:var(--body-text-color)}.file.svelte-xrr240.svelte-xrr240{width:var(--size-full)}.file.svelte-xrr240>.svelte-xrr240{padding:var(--size-1) var(--size-2-5)}.download.svelte-xrr240.svelte-xrr240:hover{text-decoration:underline}.download.svelte-xrr240>a.svelte-xrr240{color:var(--link-text-color)}.download.svelte-xrr240>a.svelte-xrr240:hover{color:var(--link-text-color-hover)}.download.svelte-xrr240>a.svelte-xrr240:visited{color:var(--link-text-color-visited)}.download.svelte-xrr240>a.svelte-xrr240:active{color:var(--link-text-color-active)}.selectable.svelte-xrr240.svelte-xrr240{cursor:pointer}

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/huggingface_hub/commands/user.py DELETED Viewed

@@ -1,191 +0,0 @@
-# Copyright 2020 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 subprocess
-from argparse import _SubParsersAction
-from requests.exceptions import HTTPError
-from huggingface_hub.commands import BaseHuggingfaceCLICommand
-from huggingface_hub.constants import (
-    ENDPOINT,
-    REPO_TYPES,
-    REPO_TYPES_URL_PREFIXES,
-    SPACES_SDK_TYPES,
-)
-from huggingface_hub.hf_api import HfApi
-from .._login import (  # noqa: F401 # for backward compatibility  # noqa: F401 # for backward compatibility
-    NOTEBOOK_LOGIN_PASSWORD_HTML,
-    NOTEBOOK_LOGIN_TOKEN_HTML_END,
-    NOTEBOOK_LOGIN_TOKEN_HTML_START,
-    login,
-    logout,
-    notebook_login,
-)
-from ..utils import HfFolder
-from ._cli_utils import ANSI
-class UserCommands(BaseHuggingfaceCLICommand):
-    @staticmethod
-    def register_subcommand(parser: _SubParsersAction):
-        login_parser = parser.add_parser("login", help="Log in using a token from huggingface.co/settings/tokens")
-        login_parser.add_argument(
-            "--token",
-            type=str,
-            help="Token generated from https://huggingface.co/settings/tokens",
-        )
-        login_parser.add_argument(
-            "--add-to-git-credential",
-            action="store_true",
-            help="Optional: Save token to git credential helper.",
-        )
-        login_parser.set_defaults(func=lambda args: LoginCommand(args))
-        whoami_parser = parser.add_parser("whoami", help="Find out which huggingface.co account you are logged in as.")
-        whoami_parser.set_defaults(func=lambda args: WhoamiCommand(args))
-        logout_parser = parser.add_parser("logout", help="Log out")
-        logout_parser.set_defaults(func=lambda args: LogoutCommand(args))
-        # new system: git-based repo system
-        repo_parser = parser.add_parser(
-            "repo",
-            help="{create, ls-files} Commands to interact with your huggingface.co repos.",
-        )
-        repo_subparsers = repo_parser.add_subparsers(help="huggingface.co repos related commands")
-        repo_create_parser = repo_subparsers.add_parser("create", help="Create a new repo on huggingface.co")
-        repo_create_parser.add_argument(
-            "name",
-            type=str,
-            help="Name for your repo. Will be namespaced under your username to build the repo id.",
-        )
-        repo_create_parser.add_argument(
-            "--type",
-            type=str,
-            help='Optional: repo_type: set to "dataset" or "space" if creating a dataset or space, default is model.',
-        )
-        repo_create_parser.add_argument("--organization", type=str, help="Optional: organization namespace.")
-        repo_create_parser.add_argument(
-            "--space_sdk",
-            type=str,
-            help='Optional: Hugging Face Spaces SDK type. Required when --type is set to "space".',
-            choices=SPACES_SDK_TYPES,
-        )
-        repo_create_parser.add_argument(
-            "-y",
-            "--yes",
-            action="store_true",
-            help="Optional: answer Yes to the prompt",
-        )
-        repo_create_parser.set_defaults(func=lambda args: RepoCreateCommand(args))
-class BaseUserCommand:
-    def __init__(self, args):
-        self.args = args
-        self._api = HfApi()
-class LoginCommand(BaseUserCommand):
-    def run(self):
-        login(token=self.args.token, add_to_git_credential=self.args.add_to_git_credential)
-class LogoutCommand(BaseUserCommand):
-    def run(self):
-        logout()
-class WhoamiCommand(BaseUserCommand):
-    def run(self):
-        token = HfFolder.get_token()
-        if token is None:
-            print("Not logged in")
-            exit()
-        try:
-            info = self._api.whoami(token)
-            print(info["name"])
-            orgs = [org["name"] for org in info["orgs"]]
-            if orgs:
-                print(ANSI.bold("orgs: "), ",".join(orgs))
-            if ENDPOINT != "https://huggingface.co":
-                print(f"Authenticated through private endpoint: {ENDPOINT}")
-        except HTTPError as e:
-            print(e)
-            print(ANSI.red(e.response.text))
-            exit(1)
-class RepoCreateCommand(BaseUserCommand):
-    def run(self):
-        token = HfFolder.get_token()
-        if token is None:
-            print("Not logged in")
-            exit(1)
-        try:
-            stdout = subprocess.check_output(["git", "--version"]).decode("utf-8")
-            print(ANSI.gray(stdout.strip()))
-        except FileNotFoundError:
-            print("Looks like you do not have git installed, please install.")
-        try:
-            stdout = subprocess.check_output(["git-lfs", "--version"]).decode("utf-8")
-            print(ANSI.gray(stdout.strip()))
-        except FileNotFoundError:
-            print(
-                ANSI.red(
-                    "Looks like you do not have git-lfs installed, please install."
-                    " You can install from https://git-lfs.github.com/."
-                    " Then run `git lfs install` (you only have to do this once)."
-                )
-            )
-        print("")
-        user = self._api.whoami(token)["name"]
-        namespace = self.args.organization if self.args.organization is not None else user
-        repo_id = f"{namespace}/{self.args.name}"
-        if self.args.type not in REPO_TYPES:
-            print("Invalid repo --type")
-            exit(1)
-        if self.args.type in REPO_TYPES_URL_PREFIXES:
-            prefixed_repo_id = REPO_TYPES_URL_PREFIXES[self.args.type] + repo_id
-        else:
-            prefixed_repo_id = repo_id
-        print(f"You are about to create {ANSI.bold(prefixed_repo_id)}")
-        if not self.args.yes:
-            choice = input("Proceed? [Y/n] ").lower()
-            if not (choice == "" or choice == "y" or choice == "yes"):
-                print("Abort")
-                exit()
-        try:
-            url = self._api.create_repo(
-                repo_id=repo_id,
-                token=token,
-                repo_type=self.args.type,
-                space_sdk=self.args.space_sdk,
-            )
-        except HTTPError as e:
-            print(e)
-            print(ANSI.red(e.response.text))
-            exit(1)
-        print("\nYour repo now lives at:")
-        print(f"  {ANSI.bold(url)}")
-        print("\nYou can clone it locally with the command below, and commit/push as usual.")
-        print(f"\n  git clone {url}")
-        print("")