Update parquet files (step 76 of 249)

spaces/0xHacked/zkProver/Dockerfile

@@ -1,21 +0,0 @@
-FROM nvidia/cuda:12.1.1-devel-ubuntu20.04
-ARG DEBIAN_FRONTEND=noninteractive
-ENV TZ=Asia/Hong_Kong
-RUN apt-get update && apt-get install --no-install-recommends -y tzdata python3.9 python3.9-dev python3.9-venv build-essential && \
-   apt-get clean && rm -rf /var/lib/apt/lists/*
-
-RUN useradd -m -u 1000 user
-USER user
-
-ENV HOME=/home/user \
-    PATH=/home/user/.local/bin:$PATH
-
-WORKDIR $HOME/app
-COPY --chown=user . $HOME/app
-
-RUN python3.9 -m venv $HOME/app/venv && $HOME/app/venv/bin/pip install --no-cache-dir --upgrade pip
-RUN $HOME/app/venv/bin/pip install --no-cache-dir --upgrade -r requirements.txt
-
-RUN cd $HOME/app && chmod +x $HOME/app/bin/*
-
-CMD ["/home/user/app/venv/bin/python", "app.py"]

spaces/1368565466ki/ZSTRD/attentions.py

@@ -1,300 +0,0 @@
-import math
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-import commons
-from modules import LayerNorm
-   
-
-class Encoder(nn.Module):
-  def __init__(self, hidden_channels, filter_channels, n_heads, n_layers, kernel_size=1, p_dropout=0., window_size=4, **kwargs):
-    super().__init__()
-    self.hidden_channels = hidden_channels
-    self.filter_channels = filter_channels
-    self.n_heads = n_heads
-    self.n_layers = n_layers
-    self.kernel_size = kernel_size
-    self.p_dropout = p_dropout
-    self.window_size = window_size
-
-    self.drop = nn.Dropout(p_dropout)
-    self.attn_layers = nn.ModuleList()
-    self.norm_layers_1 = nn.ModuleList()
-    self.ffn_layers = nn.ModuleList()
-    self.norm_layers_2 = nn.ModuleList()
-    for i in range(self.n_layers):
-      self.attn_layers.append(MultiHeadAttention(hidden_channels, hidden_channels, n_heads, p_dropout=p_dropout, window_size=window_size))
-      self.norm_layers_1.append(LayerNorm(hidden_channels))
-      self.ffn_layers.append(FFN(hidden_channels, hidden_channels, filter_channels, kernel_size, p_dropout=p_dropout))
-      self.norm_layers_2.append(LayerNorm(hidden_channels))
-
-  def forward(self, x, x_mask):
-    attn_mask = x_mask.unsqueeze(2) * x_mask.unsqueeze(-1)
-    x = x * x_mask
-    for i in range(self.n_layers):
-      y = self.attn_layers[i](x, x, attn_mask)
-      y = self.drop(y)
-      x = self.norm_layers_1[i](x + y)
-
-      y = self.ffn_layers[i](x, x_mask)
-      y = self.drop(y)
-      x = self.norm_layers_2[i](x + y)
-    x = x * x_mask
-    return x
-
-
-class Decoder(nn.Module):
-  def __init__(self, hidden_channels, filter_channels, n_heads, n_layers, kernel_size=1, p_dropout=0., proximal_bias=False, proximal_init=True, **kwargs):
-    super().__init__()
-    self.hidden_channels = hidden_channels
-    self.filter_channels = filter_channels
-    self.n_heads = n_heads
-    self.n_layers = n_layers
-    self.kernel_size = kernel_size
-    self.p_dropout = p_dropout
-    self.proximal_bias = proximal_bias
-    self.proximal_init = proximal_init
-
-    self.drop = nn.Dropout(p_dropout)
-    self.self_attn_layers = nn.ModuleList()
-    self.norm_layers_0 = nn.ModuleList()
-    self.encdec_attn_layers = nn.ModuleList()
-    self.norm_layers_1 = nn.ModuleList()
-    self.ffn_layers = nn.ModuleList()
-    self.norm_layers_2 = nn.ModuleList()
-    for i in range(self.n_layers):
-      self.self_attn_layers.append(MultiHeadAttention(hidden_channels, hidden_channels, n_heads, p_dropout=p_dropout, proximal_bias=proximal_bias, proximal_init=proximal_init))
-      self.norm_layers_0.append(LayerNorm(hidden_channels))
-      self.encdec_attn_layers.append(MultiHeadAttention(hidden_channels, hidden_channels, n_heads, p_dropout=p_dropout))
-      self.norm_layers_1.append(LayerNorm(hidden_channels))
-      self.ffn_layers.append(FFN(hidden_channels, hidden_channels, filter_channels, kernel_size, p_dropout=p_dropout, causal=True))
-      self.norm_layers_2.append(LayerNorm(hidden_channels))
-
-  def forward(self, x, x_mask, h, h_mask):
-    """
-    x: decoder input
-    h: encoder output
-    """
-    self_attn_mask = commons.subsequent_mask(x_mask.size(2)).to(device=x.device, dtype=x.dtype)
-    encdec_attn_mask = h_mask.unsqueeze(2) * x_mask.unsqueeze(-1)
-    x = x * x_mask
-    for i in range(self.n_layers):
-      y = self.self_attn_layers[i](x, x, self_attn_mask)
-      y = self.drop(y)
-      x = self.norm_layers_0[i](x + y)
-
-      y = self.encdec_attn_layers[i](x, h, encdec_attn_mask)
-      y = self.drop(y)
-      x = self.norm_layers_1[i](x + y)
-      
-      y = self.ffn_layers[i](x, x_mask)
-      y = self.drop(y)
-      x = self.norm_layers_2[i](x + y)
-    x = x * x_mask
-    return x
-
-
-class MultiHeadAttention(nn.Module):
-  def __init__(self, channels, out_channels, n_heads, p_dropout=0., window_size=None, heads_share=True, block_length=None, proximal_bias=False, proximal_init=False):
-    super().__init__()
-    assert channels % n_heads == 0
-
-    self.channels = channels
-    self.out_channels = out_channels
-    self.n_heads = n_heads
-    self.p_dropout = p_dropout
-    self.window_size = window_size
-    self.heads_share = heads_share
-    self.block_length = block_length
-    self.proximal_bias = proximal_bias
-    self.proximal_init = proximal_init
-    self.attn = None
-
-    self.k_channels = channels // n_heads
-    self.conv_q = nn.Conv1d(channels, channels, 1)
-    self.conv_k = nn.Conv1d(channels, channels, 1)
-    self.conv_v = nn.Conv1d(channels, channels, 1)
-    self.conv_o = nn.Conv1d(channels, out_channels, 1)
-    self.drop = nn.Dropout(p_dropout)
-
-    if window_size is not None:
-      n_heads_rel = 1 if heads_share else n_heads
-      rel_stddev = self.k_channels**-0.5
-      self.emb_rel_k = nn.Parameter(torch.randn(n_heads_rel, window_size * 2 + 1, self.k_channels) * rel_stddev)
-      self.emb_rel_v = nn.Parameter(torch.randn(n_heads_rel, window_size * 2 + 1, self.k_channels) * rel_stddev)
-
-    nn.init.xavier_uniform_(self.conv_q.weight)
-    nn.init.xavier_uniform_(self.conv_k.weight)
-    nn.init.xavier_uniform_(self.conv_v.weight)
-    if proximal_init:
-      with torch.no_grad():
-        self.conv_k.weight.copy_(self.conv_q.weight)
-        self.conv_k.bias.copy_(self.conv_q.bias)
-      
-  def forward(self, x, c, attn_mask=None):
-    q = self.conv_q(x)
-    k = self.conv_k(c)
-    v = self.conv_v(c)
-    
-    x, self.attn = self.attention(q, k, v, mask=attn_mask)
-
-    x = self.conv_o(x)
-    return x
-
-  def attention(self, query, key, value, mask=None):
-    # reshape [b, d, t] -> [b, n_h, t, d_k]
-    b, d, t_s, t_t = (*key.size(), query.size(2))
-    query = query.view(b, self.n_heads, self.k_channels, t_t).transpose(2, 3)
-    key = key.view(b, self.n_heads, self.k_channels, t_s).transpose(2, 3)
-    value = value.view(b, self.n_heads, self.k_channels, t_s).transpose(2, 3)
-
-    scores = torch.matmul(query / math.sqrt(self.k_channels), key.transpose(-2, -1))
-    if self.window_size is not None:
-      assert t_s == t_t, "Relative attention is only available for self-attention."
-      key_relative_embeddings = self._get_relative_embeddings(self.emb_rel_k, t_s)
-      rel_logits = self._matmul_with_relative_keys(query /math.sqrt(self.k_channels), key_relative_embeddings)
-      scores_local = self._relative_position_to_absolute_position(rel_logits)
-      scores = scores + scores_local
-    if self.proximal_bias:
-      assert t_s == t_t, "Proximal bias is only available for self-attention."
-      scores = scores + self._attention_bias_proximal(t_s).to(device=scores.device, dtype=scores.dtype)
-    if mask is not None:
-      scores = scores.masked_fill(mask == 0, -1e4)
-      if self.block_length is not None:
-        assert t_s == t_t, "Local attention is only available for self-attention."
-        block_mask = torch.ones_like(scores).triu(-self.block_length).tril(self.block_length)
-        scores = scores.masked_fill(block_mask == 0, -1e4)
-    p_attn = F.softmax(scores, dim=-1) # [b, n_h, t_t, t_s]
-    p_attn = self.drop(p_attn)
-    output = torch.matmul(p_attn, value)
-    if self.window_size is not None:
-      relative_weights = self._absolute_position_to_relative_position(p_attn)
-      value_relative_embeddings = self._get_relative_embeddings(self.emb_rel_v, t_s)
-      output = output + self._matmul_with_relative_values(relative_weights, value_relative_embeddings)
-    output = output.transpose(2, 3).contiguous().view(b, d, t_t) # [b, n_h, t_t, d_k] -> [b, d, t_t]
-    return output, p_attn
-
-  def _matmul_with_relative_values(self, x, y):
-    """
-    x: [b, h, l, m]
-    y: [h or 1, m, d]
-    ret: [b, h, l, d]
-    """
-    ret = torch.matmul(x, y.unsqueeze(0))
-    return ret
-
-  def _matmul_with_relative_keys(self, x, y):
-    """
-    x: [b, h, l, d]
-    y: [h or 1, m, d]
-    ret: [b, h, l, m]
-    """
-    ret = torch.matmul(x, y.unsqueeze(0).transpose(-2, -1))
-    return ret
-
-  def _get_relative_embeddings(self, relative_embeddings, length):
-    max_relative_position = 2 * self.window_size + 1
-    # Pad first before slice to avoid using cond ops.
-    pad_length = max(length - (self.window_size + 1), 0)
-    slice_start_position = max((self.window_size + 1) - length, 0)
-    slice_end_position = slice_start_position + 2 * length - 1
-    if pad_length > 0:
-      padded_relative_embeddings = F.pad(
-          relative_embeddings,
-          commons.convert_pad_shape([[0, 0], [pad_length, pad_length], [0, 0]]))
-    else:
-      padded_relative_embeddings = relative_embeddings
-    used_relative_embeddings = padded_relative_embeddings[:,slice_start_position:slice_end_position]
-    return used_relative_embeddings
-
-  def _relative_position_to_absolute_position(self, x):
-    """
-    x: [b, h, l, 2*l-1]
-    ret: [b, h, l, l]
-    """
-    batch, heads, length, _ = x.size()
-    # Concat columns of pad to shift from relative to absolute indexing.
-    x = F.pad(x, commons.convert_pad_shape([[0,0],[0,0],[0,0],[0,1]]))
-
-    # Concat extra elements so to add up to shape (len+1, 2*len-1).
-    x_flat = x.view([batch, heads, length * 2 * length])
-    x_flat = F.pad(x_flat, commons.convert_pad_shape([[0,0],[0,0],[0,length-1]]))
-
-    # Reshape and slice out the padded elements.
-    x_final = x_flat.view([batch, heads, length+1, 2*length-1])[:, :, :length, length-1:]
-    return x_final
-
-  def _absolute_position_to_relative_position(self, x):
-    """
-    x: [b, h, l, l]
-    ret: [b, h, l, 2*l-1]
-    """
-    batch, heads, length, _ = x.size()
-    # padd along column
-    x = F.pad(x, commons.convert_pad_shape([[0, 0], [0, 0], [0, 0], [0, length-1]]))
-    x_flat = x.view([batch, heads, length**2 + length*(length -1)])
-    # add 0's in the beginning that will skew the elements after reshape
-    x_flat = F.pad(x_flat, commons.convert_pad_shape([[0, 0], [0, 0], [length, 0]]))
-    x_final = x_flat.view([batch, heads, length, 2*length])[:,:,:,1:]
-    return x_final
-
-  def _attention_bias_proximal(self, length):
-    """Bias for self-attention to encourage attention to close positions.
-    Args:
-      length: an integer scalar.
-    Returns:
-      a Tensor with shape [1, 1, length, length]
-    """
-    r = torch.arange(length, dtype=torch.float32)
-    diff = torch.unsqueeze(r, 0) - torch.unsqueeze(r, 1)
-    return torch.unsqueeze(torch.unsqueeze(-torch.log1p(torch.abs(diff)), 0), 0)
-
-
-class FFN(nn.Module):
-  def __init__(self, in_channels, out_channels, filter_channels, kernel_size, p_dropout=0., activation=None, causal=False):
-    super().__init__()
-    self.in_channels = in_channels
-    self.out_channels = out_channels
-    self.filter_channels = filter_channels
-    self.kernel_size = kernel_size
-    self.p_dropout = p_dropout
-    self.activation = activation
-    self.causal = causal
-
-    if causal:
-      self.padding = self._causal_padding
-    else:
-      self.padding = self._same_padding
-
-    self.conv_1 = nn.Conv1d(in_channels, filter_channels, kernel_size)
-    self.conv_2 = nn.Conv1d(filter_channels, out_channels, kernel_size)
-    self.drop = nn.Dropout(p_dropout)
-
-  def forward(self, x, x_mask):
-    x = self.conv_1(self.padding(x * x_mask))
-    if self.activation == "gelu":
-      x = x * torch.sigmoid(1.702 * x)
-    else:
-      x = torch.relu(x)
-    x = self.drop(x)
-    x = self.conv_2(self.padding(x * x_mask))
-    return x * x_mask
-  
-  def _causal_padding(self, x):
-    if self.kernel_size == 1:
-      return x
-    pad_l = self.kernel_size - 1
-    pad_r = 0
-    padding = [[0, 0], [0, 0], [pad_l, pad_r]]
-    x = F.pad(x, commons.convert_pad_shape(padding))
-    return x
-
-  def _same_padding(self, x):
-    if self.kernel_size == 1:
-      return x
-    pad_l = (self.kernel_size - 1) // 2
-    pad_r = self.kernel_size // 2
-    padding = [[0, 0], [0, 0], [pad_l, pad_r]]
-    x = F.pad(x, commons.convert_pad_shape(padding))
-    return x

spaces/17TheWord/RealESRGAN/tests/test_discriminator_arch.py

@@ -1,19 +0,0 @@
-import torch
-
-from realesrgan.archs.discriminator_arch import UNetDiscriminatorSN
-
-
-def test_unetdiscriminatorsn():
-    """Test arch: UNetDiscriminatorSN."""
-
-    # model init and forward (cpu)
-    net = UNetDiscriminatorSN(num_in_ch=3, num_feat=4, skip_connection=True)
-    img = torch.rand((1, 3, 32, 32), dtype=torch.float32)
-    output = net(img)
-    assert output.shape == (1, 1, 32, 32)
-
-    # model init and forward (gpu)
-    if torch.cuda.is_available():
-        net.cuda()
-        output = net(img.cuda())
-        assert output.shape == (1, 1, 32, 32)

spaces/1acneusushi/gradio-2dmoleculeeditor/data/Contoh Surat Rasmi Permohonan Tapak Jualan.md

@@ -1,66 +0,0 @@
-
-<h1>Contoh Surat Rasmi Permohonan Tapak Jualan</h1>
-<p>Apakah anda ingin memohon tapak jualan untuk menjalankan perniagaan anda? Jika ya, anda perlu menulis surat rasmi permohonan tapak jualan yang betul dan lengkap. Surat rasmi permohonan tapak jualan adalah surat yang ditulis oleh pemohon kepada pihak berkuasa yang menguruskan tapak jualan, seperti majlis perbandaran, pejabat tanah, atau pihak swasta. Surat ini bertujuan untuk meminta kebenaran dan persetujuan untuk menyewa atau menggunakan tapak jualan yang diingini.</p>
-<h2>Contoh Surat Rasmi Permohonan Tapak Jualan</h2><br /><p><b><b>DOWNLOAD</b> &#128279; <a href="https://byltly.com/2uKx6I">https://byltly.com/2uKx6I</a></b></p><br /><br />
-<p>Surat rasmi permohonan tapak jualan harus mengandungi beberapa maklumat penting, seperti:</p>
-<ul>
-<li>Nama dan alamat pemohon</li>
-<li>Nama dan alamat penerima surat</li>
-<li>Tarikh surat</li>
-<li>Perkara atau tajuk surat</li>
-<li>Tujuan permohonan</li>
-<li>Butir-butir tapak jualan yang dimohon, seperti lokasi, saiz, jenis perniagaan, masa operasi, dan sebagainya</li>
-<li>Dokumen-dokumen sokongan yang berkaitan, seperti salinan kad pengenalan, sijil pendaftaran perniagaan, lesen perniagaan, pelan lokasi, gambar tapak jualan, dan sebagainya</li>
-<li>Penutup surat yang sopan dan mengharapkan pertimbangan positif dari pihak penerima</li>
-<li>Tandatangan dan nama pemohon</li>
-</ul>
-<p>Berikut adalah contoh surat rasmi permohonan tapak jualan yang boleh dijadikan rujukan:</p>
-
-<pre><code>SI FULAN BIN SI FULAN
-No. 100, Kampung Tiada Nama
-58900 Kuala Tiada
-Negeri Darul Ikhlas
-
-Kepada,
-Pihak Pengurusan Tapak Jualan
-Majlis Perbandaran Kuala Tiada
-58900 Kuala Tiada
-Negeri Darul Ikhlas
-
-12 April 2023
-
-Tuan/Puan,
-
-PERMOHONAN SEWA TAPAK JUALAN DI TAMAN REKREASI KUALA TIADA
-
-Merujuk perkara di atas, saya Si Fulan Bin Si Fulan ingin memohon untuk menyewa satu tapak jualan di Taman Rekreasi Kuala Tiada. Tujuan saya memohon sewa tapak jualan ini adalah untuk menjalankan perniagaan saya iaitu menjual makanan ringan dan minuman sejuk.
-
-Dibawah ini disertakan butir-butir perniagaan saya untuk rujukan pihak tuan/puan:
-
-Nama: Si Fulan Bin Si Fulan
-No. Kad Pengenalan: 830101-01-1234
-No. Telefon: 012-3456789
-Alamat Tetap: No. 100, Kampung Tiada Nama, 58900 Kuala Tiada, Negeri Darul Ikhlas
-Pekerjaan Tetap: Guru Sekolah Menengah Kebangsaan Kuala Tiada
-Jenis Perniagaan: Menjual makanan ringan dan minuman sejuk
-Masa Perniagaan: Setiap hujung minggu dari jam 10 pagi hingga 6 petang
-
-Disini saya sertakan sekali dokumen-dokumen sokongan saya, iaitu salinan kad pengenalan, sijil pendaftaran perniagaan (SSM), lesen perniagaan (MPK), pelan lokasi tapak jualan yang dikehendaki, dan gambar tapak jualan tersebut di bahagian lampiran.
-
-Semoga permohonan saya ini dapat dipertimbangkan dengan sebaiknya oleh pihak tuan/puan. Saya amat berharap dapat
-
-<pre><code>menyewa tapak jualan di Taman Rekreasi Kuala Tiada untuk menambah pendapatan saya dan memberi perkhidmatan yang baik kepada pengunjung taman.
-
-Segala kerjasama dan bantuan dari pihak tuan/puan saya dahulukan dengan ribuan terima kasih. Sekiranya ada sebarang pertanyaan atau maklum balas, sila hubungi saya di nombor telefon yang diberikan.
-
-Sekian, terima kasih.
-
-Yang benar,
-
-..................................
-(SI FULAN BIN SI FULAN)
-No. Telefon: 012-3456789
-</code></pre></p>
-<p></p> cec2833e83<br />
-<br />
-<br />

spaces/1acneusushi/gradio-2dmoleculeeditor/data/Cours archicad 15 gratuit Matrisez le logiciel de modlisation BIM.md

@@ -1,75 +0,0 @@
-
-<br>- What are the benefits of learning Archicad 15<br>- How to access free courses and tutorials on Archicad 15 | | H2: Archicad basics | - How to install and set up Archicad 15<br>- How to use the interface and tools of Archicad 15<br>- How to create and edit 2D and 3D objects in Archicad 15 | | H2: Archicad advanced | - How to use graphic overrides and substitutions in Archicad 15<br>- How to create custom stairs, railings, roofs, and slabs in Archicad 15<br>- How to use libraries, attributes, and layers in Archicad 15 | | H2: Archicad projects | - How to create a floor plan, a section, a elevation, and a detail in Archicad 15<br>- How to generate photorealistic renderings and animations in Archicad 15<br>- How to print and export drawings and models in Archicad 15 | | H2: Archicad resources | - How to find and download free Archicad templates, objects, and materials<br>- How to access online courses, tutorials, and forums on Archicad 15<br>- How to get certified and improve your skills on Archicad 15 | | H1: Conclusion | - A summary of the main points of the article<br>- A call to action for the readers to start learning Archicad 15 | # Article with HTML formatting <h1>Introduction</h1>
-<p>Are you an architect, a designer, or a student who wants to create stunning architectural projects with ease and efficiency? If so, you might want to learn how to use Archicad, one of the most popular and powerful software for building information modeling (BIM).</p>
-<h2>Cours archicad 15 gratuit</h2><br /><p><b><b>Download</b> &#127383; <a href="https://byltly.com/2uKwi0">https://byltly.com/2uKwi0</a></b></p><br /><br />
-<p>Archicad is a software that allows you to design, model, document, and visualize your projects in 2D and 3D. You can create realistic models of buildings, structures, interiors, landscapes, and more. You can also produce high-quality drawings, renderings, animations, and reports with Archicad.</p>
-<p>But how can you learn how to use Archicad without spending a fortune on courses or books? The answer is simple: you can access free courses and tutorials on Archicad 15 online. In this article, we will show you how you can learn everything you need to know about Archicad 15 for free. We will cover the basics, the advanced features, the projects, and the resources that you can use to master Archicad 15.</p>
- <h2>Archicad basics</h2>
-<p>Before you start working on your projects with Archicad 15, you need to learn some basic concepts and skills. In this section, we will show you how to install and set up Archicad 15, how to use the interface and tools of Archicad 15, and how to create and edit 2D and 3D objects in Archicad 15.</p>
-<h3>How to install and set up Archicad 15</h3>
-<p>To install Archicad 15 on your computer, you need to download the installer from the official website of Graphisoft, the developer of Archicad. You can choose between Windows or Mac versions depending on your operating system. You can also select your preferred language from a list of options.</p>
-<p>Formation archicad 15 en ligne gratuite<br />
-Tutoriel archicad 15 pour débutants gratuit<br />
-Apprendre archicad 15 pas à pas gratuitement<br />
-Cours archicad 15 pdf télécharger gratuitement<br />
-Vidéo cours archicad 15 complet gratuit<br />
-Cours archicad 15 niveau avancé gratuit<br />
-Cours archicad 15 en français gratuit<br />
-Cours archicad 15 avec certificat gratuit<br />
-Cours archicad 15 sur udemy gratuit<br />
-Cours archicad 15 sur youtube gratuit<br />
-Cours archicad 15 avec exercices pratiques gratuit<br />
-Cours archicad 15 pour architectes gratuit<br />
-Cours archicad 15 pour étudiants gratuit<br />
-Cours archicad 15 pour professionnels gratuit<br />
-Cours archicad 15 pour débutants gratuit<br />
-Cours archicad 15 pour maîtriser le logiciel gratuit<br />
-Cours archicad 15 pour apprendre les bases gratuit<br />
-Cours archicad 15 pour créer des plans gratuits<br />
-Cours archicad 15 pour réaliser des projets gratuits<br />
-Cours archicad 15 pour dessiner en 3D gratuit<br />
-Cours archicad 15 pour modéliser des bâtiments gratuits<br />
-Cours archicad 15 pour concevoir des structures gratuites<br />
-Cours archicad 15 pour optimiser des espaces gratuits<br />
-Cours archicad 15 pour gérer des documents gratuits<br />
-Cours archicad 15 pour collaborer avec d'autres utilisateurs gratuits<br />
-Cours archicad 15 pour exporter des fichiers gratuits<br />
-Cours archicad 15 pour importer des données gratuites<br />
-Cours archicad 15 pour personnaliser des paramètres gratuits<br />
-Cours archicad 15 pour utiliser des outils gratuits<br />
-Cours archicad 15 pour appliquer des effets gratuits<br />
-Cours archicad 15 pour animer des scènes gratuites<br />
-Cours archicad 15 pour simuler des éclairages gratuits<br />
-Cours archicad 15 pour calculer des coûts gratuits<br />
-Cours archicad 15 pour respecter des normes gratuites<br />
-Cours archicad 15 pour intégrer des éléments gratuits<br />
-Cours archicad 15 pour ajouter des textures gratuites<br />
-Cours archicad 15 pour modifier des couleurs gratuites<br />
-Cours archicad 15 pour insérer des objets gratuits<br />
-Cours archicad 15 pour composer des vues gratuites<br />
-Cours archicad 15 pour générer des rendus gratuits<br />
-Cours archicad 15 pour imprimer des plans gratuits<br />
-Cours archicad 15 pour publier des rapports gratuits<br />
-Cours archicad 15 pour partager des résultats gratuits<br />
-Cours archicad 15 pour sauvegarder des travaux gratuits<br />
-Cours archicad 15 pour restaurer des versions gratuites<br />
-Cours archicad 15 pour corriger des erreurs gratuites<br />
-Cours archicad 15 pour améliorer la qualité gratuite<br />
-Cours archicad 15 pour augmenter la productivité gratuite</p>
-<p>Once you have downloaded the installer, you need to run it and follow the instructions on the screen. You will need to accept the license agreement, choose a destination folder, and enter your serial number if you have one. If you don't have a serial number, you can use the trial version of Archicad 15 for 30 days.</p>
-<p>After the installation is complete, you can launch Archicad 15 from your desktop or start menu. You will see a welcome screen that will guide you through some initial settings. You can choose your project type (residential or commercial), your measurement system (metric or imperial), your working environment (standard or customized), and your template file (default or user-defined).</p>
-<h3>How to use the interface and tools of Archicad 15</h3>
-<p>The interface of Archicad 15 consists of several elements that help you navigate and work on your projects. The main elements are:</p>
-<ul>
-<li>The menu bar: it contains various menus that give you access to different commands and options.</li>
-<li>The toolbar: it contains icons that represent different tools that you can use to create and modify objects.</li>
-<li>The toolbox: it contains icons that represent different object types that you can create with the tools.</li>
-<li>The info box: it displays information about the selected tool or object such as parameters, settings, properties, etc.</li>
-<li>The navigator: it shows the structure of your project in terms of stories, sections, elevations, layouts, etc.</li>
-<li>The project map: it shows a graphical representation of your project in terms of views such as floor plans, perspectives, axonometries, etc.</li>
-<li>The view map: it shows a list of saved views that you can recall at any time.</li>
-<li>The layout book: it shows a list of layouts that contain drawings or models that you can print or export.</li>
-<li>The publisher: it allows you to publish your project as PDF files, DWG files, images files, etc.</li>
-<li>The organizer: it allows you to organize your project data in terms of attributes such as layers, pensets</p> 0a6ba089eb<br />
-<br />
-<br />

spaces/1gistliPinn/ChatGPT4/Examples/((FULL)) Xforce Keygen 64-bit Alias AutoStudio 2019 Activation.md

@@ -1,7 +0,0 @@
-<br />
-<p> Free Porn Movie Dirty Latino Trini Porni <br> Xforce Keygen HD2k3 Full Version Keys Free Download <br> bromance <br> One Piece Xforce Keygen Sony Playstation <br> Private Postings on WhiskeyX® 4 - 1.0.4.00.0 Offline Crack <br> Free Mobile Apps Search and Browser <br> Linux News, Recipes, And Tutorials <br> Mouse Mute - DEVBuild 2007 <br> XXX Movies HD Netlix <br> download film vk <br> </p>
-<h2>xforce keygen 64-bit Alias AutoStudio 2019 activation</h2><br /><p><b><b>DOWNLOAD</b> &#10037; <a href="https://imgfil.com/2uxXfh">https://imgfil.com/2uxXfh</a></b></p><br /><br />
-<p> DXF Import Tutorial is a <br> Noob Friendly Xferxramen unetbootin lite download iran <br> The Orchard-cms.de lite - author Klaus Dehne <br> Earnest Journey 2011 English SDH ISO <br> Dance Central 3 Hack apk <br> AIDA32 128bit Download <br> Wifi Router: http://www.webfixer.eu/download.php?id=5e9e45ea4d94a2259e3a70a7ede14e91.pdf.l <br> Move Support for Exchange, Address Book and more..pptx <br> <br> India+2 hack patch/crack <br> Just a bunch of kink.mobile.10.55.0_CRL <br> <br> Cloud Septar - Apk.torrent <br> <br> xforce keygen 64-bit AutoCAD LT 2014 Crack <br> <br> Disney's Live-action Aladdin movie to hit UK cinemas on Wednesday! <br> <br> Freeware file converter and zip file creator!.exe <br> <br> Everything - Free Download for Mac<br> <br> Hitman 2 free download with trials keygen crack for play <br> <br> Anime Episode Fxu Cheat For Each Episode Download <br> <br> URL Hack No Survey Unlimited Money Best Site Newtonsoft.JSON <br> <br> bhengasi Pokkiri Raja - Full Hindi Movie HD.mp4 <br> <br> 11169442343798870042ULBG6HAL</p>
-<p> Illustrator Tutorials and Tips Free Tutorial and Tips Videos <br> Free NTI Audio Editor 3.0.0 Crack with Keygen <br> Sony IS300 V2 For Free Download <br> Algorithm Design Manual PDF <br> Toughest archer ppd statistics for 1.5 <br> FARM ITALIA - LA SCUOLA DEI MIGLIORI AMATI ( www.teammiglioriamati.com ) <br> PEUGEOT 400 2009 MANUAL FREE DOWNLOAD <br> Exclusively for: Xfire <br> Xforce Keygen Activation WINDOWS-7 <br> Manually define the number of tile groups, and the appropriate WCF settings for them <br> </p> 899543212b<br />
-<br />
-<br />

spaces/1gistliPinn/ChatGPT4/Examples/Backstreet Boys Millennium Full Album Zip.md

@@ -1,6 +0,0 @@
-<h2>Backstreet Boys, Millennium Full Album Zip</h2><br /><p><b><b>Download File</b> &#10031;&#10031;&#10031; <a href="https://imgfil.com/2uxXly">https://imgfil.com/2uxXly</a></b></p><br /><br />
-<br />
-Backstreet Boys, Millennium Full Album Zip tinyurl.com/lttzqfo. 4d29de3e1b<br />
-<br />
-<br />
-<p></p>

spaces/1gistliPinn/ChatGPT4/Examples/Cyberlink Powerdvd 14 Crack Serial Key.md

@@ -1,64 +0,0 @@
-<h2>Cyberlink powerdvd 14 crack serial key</h2><br /><p><b><b>Download</b> &hArr; <a href="https://imgfil.com/2uy0mX">https://imgfil.com/2uy0mX</a></b></p><br /><br />
-
-1. Close this window and restart the software.
-
-2. Launch the software and register.
-
-3. Please select the license key and click on "Update".
-
-4. Your new activation key will be displayed.
-
-What If I Dislike the Product?
-
-1. Use the product for 30 days (For Limited Period)
-
-For users who have a good experience with the software, please give us a good review. In order to enhance the compatibility and performance of the product, we will take no charge for technical support for 90 days after your purchase. If you have any issue after the 90 days, please use the "Customer Service" page of the product page to ask for assistance.
-
-1. Log into the product and open the activation tab.
-
-2. Click "Customer Service" and then click "Activation Request".
-
-3. Please indicate your purchase date and product name in the next blank spaces.
-
-4. Please indicate your version, operating system and the reason for your request.
-
-5. Your Customer Service will be received within 24 hours and your request will be handled within 3 days.
-
-1. Go to 
-
-2. Please register the product and log in.
-
-3. Click the "Customer Service" link and follow the instructions.
-
-What If the Software I have Already Paid is Suboptimal?
-
-1. Within 3 days from your purchase date, if you are dissatisfied with the software you have paid for, please contact Customer Support.
-
-2. Please indicate the purchase date, product name, operating system and the reason for your request.
-
-3. Please submit the "Requisition for Customer Service" form and include with your message your purchase date and product name.
-
-What If the License Key I Have Entered Is Incorrect?
-
-1. Please re-register.
-
-2. Please follow the steps on the activation page.
-
-What If I Have Forgotten the License Key?
-
-1. Please follow the steps on the activation page.
-
-3. Go to the "Settings" page.
-
-4. Select the "License Keys" tab.
-
-5. Please enter the activation code and save.
-
-6. Your activation code will be displayed.
-
-Is My License Key Valid?
-
-1. Please visit 4fefd39f24<br />
-<br />
-<br />
-<p></p>

spaces/1gistliPinn/ChatGPT4/Examples/DWG TrueView 2012 (64bit) (Product Key And Xforce Keygen) .rar UPDATED.md

@@ -1,6 +0,0 @@
-<h2>DWG TrueView 2012 (64bit) (Product Key And Xforce Keygen) .rar</h2><br /><p><b><b>DOWNLOAD</b> &#11088; <a href="https://imgfil.com/2uy1f8">https://imgfil.com/2uy1f8</a></b></p><br /><br />
-<br />
-Autodesk DWG TrueView. 2012 64-bit - free AutoCAD DWG file .... DWG TrueView 2008 (64bit) (Product Key And Xforce Keygen) .rar ... 4d29de3e1b<br />
-<br />
-<br />
-<p></p>

spaces/1gistliPinn/ChatGPT4/Examples/Digifish Aqua Real 2 Version 1.04 Full With Serial.md

@@ -1,7 +0,0 @@
-
-<p>this new version includes two improvements over the previous version 1.03: more species, updated sounds, stable and bug-free operation. added in this release: 1.04: new lighting effects, new background music engine, new fish. aquarium hd for xbox 360 is a screensaver that features a unique aquarium simulation as well as music playback! experience an exotic tropical aquarium in real time as thousands of colorful fish swim in a beautiful underwater world. the aquarium simulation includes light, sound, water and even real fish! play background music from your hard drive or from a networked pc! the music is not only for background, you can even add your own music to play while the aquarium is running. the music can be played from your hard drive or from a networked pc. choose between a quiet and a slightly more active light and sound settings.</p>
-<h2>digifish aqua real 2 version 1.04 full with serial</h2><br /><p><b><b>Download File</b> &#187;&#187;&#187; <a href="https://imgfil.com/2uxXpp">https://imgfil.com/2uxXpp</a></b></p><br /><br />
-<p>this release was created for you, eager to use aqua real 2 full version v1.04 full and without any limitations. our intentions are not to harm aqua software company but to give the possibility to those who can not pay for any piece of software out there. this should be your intention too, as a user, to fully evaluate aqua real 2 full version v1.04 without restrictions and then decide.</p>
-<p>digifish aqua real 2 for pc is a really nice fish-watching program. it eschews the traditional aquarium, instead placing your fish in the open ocean, complete with sharks. the free trial is pretty limited, but has nice animations, backgrounds, and fish. the interface is really clean and easy-to-use, as well. probably the top-of-the-line for fish screensavers. full version costs $20.</p> 899543212b<br />
-<br />
-<br />

spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/Bus Simulator Indonesia on PC How to Download and Play with LDPlayer Emulator.md

@@ -1,130 +0,0 @@
-<br />
-<h1>How to Download and Play Bus Simulator Indonesia on PC with LDPlayer</h1>
-<p>Bus Simulator Indonesia is a popular and realistic game that lets you experience what it's like to be a bus driver in Indonesia. You can design your own livery, drive in authentic Indonesian cities and places, honk your horn with the iconic "Om Telolet Om" sound, and enjoy high-quality graphics and gameplay. But what if you want to play Bus Simulator Indonesia on a bigger screen, with better performance, and more control options? That's where LDPlayer comes in. LDPlayer is a free and powerful Android emulator that allows you to play Android games on your PC. In this article, we will show you how to download and play Bus Simulator Indonesia on PC with LDPlayer.</p>
-<h2>ldplayer download bus simulator indonesia</h2><br /><p><b><b>Download Zip</b> &#10037; <a href="https://urlin.us/2uSVbG">https://urlin.us/2uSVbG</a></b></p><br /><br />
- <h2>What is Bus Simulator Indonesia?</h2>
-<p>Bus Simulator Indonesia (aka BUSSID) is a simulation game developed by Maleo, an Indonesian game studio. It was released in 2017 and has been updated regularly with new features and improvements. According to the Google Play Store, it has over 100 million downloads and 4.2 stars rating.</p>
-<h3>Features of Bus Simulator Indonesia</h3>
-<p>Below are some of the top features of Bus Simulator Indonesia:</p>
-<ul>
-<li>Design your own livery</li>
-<li>Very easy and intuitive control</li>
-<li>Authentic Indonesian cities and places</li>
-<li>Indonesian Buses</li>
-<li>Cool and fun honks</li>
-<li>"Om Telolet Om!" (Uncle, honk your horn, uncle! )</li>
-<li>High quality and detailed 3D graphics</li>
-<li>No obstructive ads while driving</li>
-<li>Leaderboard</li>
-<li>Data saved online</li>
-<li>Use your own 3D model using vehicle mod system</li>
-<li>Online multiplayer convoy</li>
-</ul>
- <h3>Why play Bus Simulator Indonesia on PC?</h3>
-<p>Playing Bus Simulator Indonesia on PC has many advantages over playing it on mobile devices. Here are some of them:</p>
-<ul>
-<li>You can enjoy a larger screen and better graphics quality.</li>
-<li>You can use your keyboard and mouse for more precise and comfortable control.</li>
-<li>You can customize your keymapping according to your preference.</li>
-<li>You can run multiple instances of the game at the same time using LDPlayer's multi-instance feature.</li>
-<li>You can avoid battery drain, overheating, and phone calls that interrupt your gameplay.</li>
-</ul>
- <h2>What is LDPlayer?</h2>
-<p>LDPlayer is a free Android emulator for Windows PC that allows you to play Android games and apps on your computer. It is based on Android 9 kernel and supports both 64-bit and 32-bit apps. It has many features that make it one of the best emulators for gaming.</p>
-<p>How to play Bus Simulator Indonesia on PC with LDPlayer<br />
-Bus Simulator Indonesia PC version free download<br />
-LDPlayer emulator for Bus Simulator Indonesia<br />
-Bus Simulator Indonesia online multiplayer with LDPlayer<br />
-Best settings for Bus Simulator Indonesia on LDPlayer<br />
-Bus Simulator Indonesia mod apk download on LDPlayer<br />
-LDPlayer Android emulator for Bus Simulator Indonesia Maleo<br />
-Bus Simulator Indonesia graphics and FPS on LDPlayer<br />
-How to install Bus Simulator Indonesia on PC using LDPlayer<br />
-Bus Simulator Indonesia custom controls with LDPlayer<br />
-Bus Simulator Indonesia livery design on PC with LDPlayer<br />
-Bus Simulator Indonesia klakson om telolet om on LDPlayer<br />
-Bus Simulator Indonesia leaderboards and data on LDPlayer<br />
-How to update Bus Simulator Indonesia on PC with LDPlayer<br />
-Bus Simulator Indonesia bug fixes and improvements on LDPlayer<br />
-Bus Simulator Indonesia authentic Indonesian environment on PC with LDPlayer<br />
-Bus Simulator Indonesia easy and intuitive control on LDPlayer<br />
-Bus Simulator Indonesia high quality and detailed 3D graphics on PC with LDPlayer<br />
-How to add music to Bus Simulator Indonesia on PC with LDPlayer<br />
-Bus Simulator Indonesia vehicle mod system on PC with LDPlayer<br />
-How to play Bus Simulator Indonesia offline on PC with LDPlayer<br />
-Bus Simulator Indonesia tips and tricks on PC with LDPlayer<br />
-How to use macros and scripts for Bus Simulator Indonesia on LDPlayer<br />
-Bus Simulator Indonesia review and rating on PC with LDPlayer<br />
-How to sync data between mobile and PC for Bus Simulator Indonesia with LDPlayer<br />
-How to play Bus Simulator Indonesia in full screen mode on PC with LDPlayer<br />
-How to record and share gameplay of Bus Simulator Indonesia on PC with LDPlayer<br />
-How to use keyboard and mouse for Bus Simulator Indonesia on PC with LDPlayer<br />
-How to customize interface and layout for Bus Simulator Indonesia on PC with LDPlayer<br />
-How to run multiple instances of Bus Simulator Indonesia on PC with LDPlayer<br />
-How to play Bus Simulator Indonesia in different languages on PC with LDPlayer<br />
-How to change resolution and orientation for Bus Simulator Indonesia on PC with LDPlayer<br />
-How to enable virtualization for better performance of Bus Simulator Indonesia on PC with LDPlayer<br />
-How to fix lag and crash issues of Bus Simulator Indonesia on PC with LDPlayer<br />
-How to access Google Play Store and Google Play Games for Bus Simulator Indonesia on PC with LDPlayer<br />
-How to use gamepad or controller for Bus Simulator Indonesia on PC with LDPlayer<br />
-How to enable smart keymapping for Bus Simulator Indonesia on PC with LDPlayer<br />
-How to enable turbo mode for faster loading of Bus Simulator Indonesia on PC with LDPlayer<br />
-How to enable root permission for advanced features of Bus Simulator Indonesia on PC with LDPlayer<br />
-How to enable network bridge for better connectivity of Bus Simulator Indonesia on PC with LDPlayer<br />
-How to enable eco mode for lower CPU usage of Bus Simulator Indonesia on PC with LDPlayer<br />
-How to enable screenshot and screen recorder for capturing moments of Bus Simulator Indonesia on PC with LDPlayer<br />
-How to enable operation recorder for automating tasks of Bus Simulator Indonesia on PC with LDPlayer<br />
-How to enable sync settings for synchronizing preferences of Bus Simulator Indonesia across devices with LDPlayer<br />
-How to enable game booster for optimizing performance of Bus Simulator Indonesia on PC with LDPlayer<br />
-How to enable disk cleanup for freeing up space of Bus Simulator Indonesia on PC with LDPlayer<br />
-How to enable app cloner for creating copies of Bus Simulator Indonesia on PC with LDPlayer<br />
-How to enable app market for discovering more games like Bus Simulator Indonesia on PC with LDPlayer</p>
- <h3>Features of LDPlayer</h3>
-<p>Below are some of the top features of LDPlayer:</p>
-<ul>
-<li>High performance and stability</li>
-<li>Low CPU and GPU consumption</li>
-<li>Graphic quality optimization</li>
-<li>Custom controls and keymapping tool</li>
-<li>Multi-instance and multi-instance sync</li>
-<li>Macros and scripts</li>
-<li>Data encryption in transit</li>
-<li>Data deletion request</li>
-<li>No data shared with third parties </li>
-<li>Compatible with Hyper-V </li>
- <h3>Why use LDPlayer to play Bus Simulator Indonesia on PC?</h3>
- <p>Using LDPlayer to play Bus Simulator Indonesia on PC has many benefits, such as:</p>
-<ul>
-<li>You can play the game smoothly and without lag, even on low-end PCs.</li>
-<li>You can enjoy the game with high-resolution graphics and realistic sound effects.</li>
-<li>You can customize your controls and keymapping to suit your play style and preferences.</li>
-<li>You can use LDPlayer's features to enhance your gameplay, such as macros, scripts, multi-instance, and multi-instance sync.</li>
-<li>You can play the game safely and securely, without worrying about data leakage or malware.</li>
-</ul>
- <h2>How to download and install LDPlayer and Bus Simulator Indonesia on PC?</h2>
-<p>Downloading and installing LDPlayer and Bus Simulator Indonesia on PC is very easy and simple. Just follow these steps:</p>
- <h3>Step 1: Download LDPlayer from the official website</h3>
-<p>Go to the official website of LDPlayer () and click on the "Download" button. You will see a pop-up window asking you to save the LDPlayer installer file. Choose a location where you want to save the file and click "Save". The file size is about 500 MB, so it may take some time depending on your internet speed.</p>
- <h3>Step 2: Install LDPlayer on your PC</h3>
-<p>Once the download is complete, locate the LDPlayer installer file and double-click on it. You will see a window asking you to choose the installation language. Select your preferred language and click "OK". Then, follow the instructions on the screen to complete the installation process. It may take a few minutes depending on your PC specifications.</p>
- <h3>Step 3: Launch LDPlayer and search for Bus Simulator Indonesia on the Play Store</h3>
-<p>After the installation is done, launch LDPlayer from your desktop or start menu. You will see the LDPlayer home screen with various icons and options. Click on the "Play Store" icon to open the Google Play Store app. You will need to sign in with your Google account or create a new one if you don't have one. Then, type "Bus Simulator Indonesia" in the search bar and hit enter. You will see a list of results related to your search query.</p>
- <h3>Step 4: Install Bus Simulator Indonesia and enjoy the game</h3>
-<p>Find the Bus Simulator Indonesia app from the list of results and click on it. You will see a page with more information about the app, such as screenshots, ratings, reviews, and description. Click on the "Install" button to start downloading and installing the app on your PC. The app size is about 300 MB, so it may take some time depending on your internet speed. Once the installation is complete, you can click on the "Open" button to launch the game. Alternatively, you can also find the game icon on your LDPlayer home screen or app drawer and click on it to start playing.</p>
- <h2>Conclusion</h2>
-<p>Bus Simulator Indonesia is a fun and realistic game that lets you experience what it's like to be a bus driver in Indonesia. You can design your own livery, drive in authentic Indonesian cities and places, honk your horn with the iconic "Om Telolet Om" sound, and enjoy high-quality graphics and gameplay. However, playing Bus Simulator Indonesia on mobile devices may not give you the best gaming experience due to small screen size, limited control options, low performance, battery drain, overheating, phone calls, etc. That's why we recommend you to play Bus Simulator Indonesia on PC with LDPlayer, a free and powerful Android emulator that allows you to play Android games on your computer with larger screen size, better graphics quality, more control options, higher performance, and more features. In this article, we have shown you how to download and play Bus Simulator Indonesia on PC with LDPlayer in four easy steps. We hope you find this article helpful and enjoy playing Bus Simulator Indonesia on PC with LDPlayer.</p>
- <h2>FAQs</h2>
-<p>Here are some frequently asked questions about playing Bus Simulator Indonesia on PC with LDPlayer:</p>
- <h4>Q: Is LDPlayer safe to use?</h4>
-<p>A: Yes, LDPlayer is safe to use. It does not contain any malware or virus that can harm your PC or data. It also does not share your data with any third parties without your consent . You can use LDPlayer with confidence and peace of mind.</p>
- <h4>Q: Is LDPlayer free to use?</h4>
-<p>A: Yes, LDPlayer is free to use. You don't have to pay anything to download or use LDPlayer. However, some optional features may require payment or subscription, such as removing ads or unlocking premium features . You can choose whether to use these features or not according to your needs.</p <h4>Q: How can I update LDPlayer and Bus Simulator Indonesia on PC?</h4>
-<p>A: To update LDPlayer, you can go to the LDPlayer settings and click on the "Check for updates" button. You will see a pop-up window telling you whether there is a new version available or not. If there is, you can click on the "Update" button to download and install the latest version of LDPlayer. To update Bus Simulator Indonesia, you can go to the Play Store app and search for Bus Simulator Indonesia. You will see a page with more information about the app, such as screenshots, ratings, reviews, and description. If there is an update available, you will see an "Update" button next to the "Open" button. You can click on the "Update" button to download and install the latest version of Bus Simulator Indonesia.</p>
- <h4>Q: How can I use LDPlayer's features to enhance my gameplay of Bus Simulator Indonesia?</h4>
-<p>A: LDPlayer has many features that can enhance your gameplay of Bus Simulator Indonesia, such as macros, scripts, multi-instance, and multi-instance sync. Macros and scripts allow you to automate certain actions or commands in the game, such as honking, braking, accelerating, etc. You can record your own macros or scripts using LDPlayer's built-in tool, or import them from other sources. Multi-instance and multi-instance sync allow you to run multiple instances of the game at the same time on your PC, and synchronize your actions across all instances. This way, you can play with multiple accounts or characters, or join online multiplayer convoys with yourself.</p>
- <h4>Q: How can I contact LDPlayer's customer service if I have any questions or issues?</h4>
-<p>A: If you have any questions or issues regarding LDPlayer or Bus Simulator Indonesia, you can contact LDPlayer's customer service through various channels, such as email, Facebook, Twitter, Discord, Reddit, YouTube, etc. You can find the contact information on the official website of LDPlayer () or on the LDPlayer app itself. You can also check out the FAQ section or the blog section on the website for more information and tips.</p>
- <h4>Q: How can I share my feedback or suggestions about LDPlayer or Bus Simulator Indonesia?</h4>
-<p>A: We appreciate your feedback and suggestions about LDPlayer or Bus Simulator Indonesia. You can share your thoughts with us through various channels, such as email, Facebook, Twitter, Discord, Reddit, YouTube, etc. You can also leave a comment or a review on the Play Store app or on the official website of LDPlayer (). Your feedback and suggestions will help us improve our products and services and provide you with a better gaming experience.</p> 197e85843d<br />
-<br />
-<br />

spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/Descubre el secreto de Clash Royale Todo Infinito APK fcil y rpido.md

@@ -1,106 +0,0 @@
-<br />
-<h1>Clash Royale Todo Infinito Apk: What Is It and How to Get It?</h1>
-<p>If you are a fan of Clash Royale, you might have heard of Clash Royale Todo Infinito Apk. This is a modified version of the game that gives you unlimited resources, such as gems, gold, and cards. But what exactly is Clash Royale, and how can you get this apk? In this article, we will answer these questions and give you some tips and tricks for playing the game.</p>
-<h2>What is Clash Royale?</h2>
-<p>Clash Royale is a popular mobile game developed and published by Supercell, the same company behind Clash of Clans. It is a real-time multiplayer battle game that combines elements of collectible card games and strategy games. Here are some of the main features of the game:</p>
-<h2>clash royale todo infinito apk</h2><br /><p><b><b>Download</b> &#10004;&#10004;&#10004; <a href="https://urlin.us/2uT29L">https://urlin.us/2uT29L</a></b></p><br /><br />
-<h3>A real-time multiplayer battle game</h3>
-<p>In Clash Royale, you can challenge players from around the world in fast-paced duels. The goal is to destroy your opponent's three towers, or at least more towers than they do, before the time runs out. You can use a variety of units, spells, and buildings to attack and defend. Each match lasts for three minutes, or longer if there is a tie.</p>
-<h3>A collectible card game</h3>
-<p>Clash Royale features over 100 cards that represent different troops, spells, and buildings from the Clash universe. You can collect and upgrade these cards by winning battles, opening chests, or buying them with gems or gold. You can also create your own battle deck with eight cards that suit your play style and strategy.</p>
-<h3>A strategic game</h3>
-<p>Clash Royale is not just about spamming cards on the battlefield. You need to think carefully about when and where to place your cards, how to counter your opponent's moves, and how to manage your elixir. Elixir is the resource that you use to play cards, and it regenerates over time. You also need to consider the strengths and weaknesses of each card, as well as their synergies and interactions.</p>
-<h2>What is Clash Royale Todo Infinito Apk?</h2>
-<p>Clash Royale Todo Infinito Apk is a modified version of the game that gives you access to unlimited resources. This means that you can get as many gems, gold, and cards as you want without spending any money or time. You can also unlock all the arenas, chests, and features that are normally restricted by your level or progress. Here are some of the benefits and risks of using this apk:</p>
-<h3>The benefits of using it</h3>
-<ul>
-<li>You can enjoy the game without any limitations or frustrations.</li>
-<li>You can experiment with different cards and decks without worrying about wasting resources.</li>
-<li>You can dominate your opponents with powerful cards and strategies.</li>
-<li>You can have more fun and excitement in the game.</li>
-</ul>
-<h3>The risks of using it</h3>
-<ul>
-<li>You might lose the challenge and thrill of the game.</li>
-<li>You might get bored or lose interest in the game.</li>
-<li>You might face technical issues or errors in the game.</li>
-<li>You might get banned or suspended by Supercell for violating their terms of service.</li>
-</ul>
-<h2>How to get Clash Royale Todo Infinito Apk?</h2>
-<p>If you want to try Clash Royale Todo Infinito Apk, you need to follow these steps:</p>
-<h3>Download from a reliable source</h3>
-<p>There are many websites that claim to offer Clash Royale Todo Infinito Apk, but not all of them are safe or trustworthy. Some of them might contain viruses, malware, or spyware that can harm your device or steal your personal information. Therefore, you need to be careful and do some research before downloading anything. You can check the reviews, ratings, and comments of other users to see if the apk is reliable and working. You can also use antivirus software or scan the apk file before installing it.</p>
-<h3>Install on your device</h3>
-<p>Once you have downloaded the apk file, you need to install it on your device. However, you might encounter some issues or errors during the installation process. This is because Clash Royale Todo Infinito Apk is not an official version of the game, and it might not be compatible with your device or operating system. To fix this, you need to enable the unknown sources option on your device settings. This will allow you to install apps from sources other than the Google Play Store. You can also uninstall the original version of Clash Royale if you have it on your device, as it might cause conflicts or crashes with the apk.</p>
-<p>clash royale mod apk unlimited gems and coins<br />
-clash royale hack apk download for android<br />
-clash royale private server apk with all cards unlocked<br />
-clash royale apk mod menu with god mode<br />
-clash royale latest version apk free download<br />
-clash royale cheat apk no root no survey<br />
-clash royale online generator apk without human verification<br />
-clash royale modded apk by master royale infinity<br />
-clash royale apk atualizado 2023 com tudo infinito<br />
-clash royale apk mediafire link download 2023<br />
-clash royale apk modificado com gemas e ouro infinito<br />
-clash royale hackeado apk descargar gratis para android<br />
-clash royale servidor privado apk con todos los personajes desbloqueados<br />
-clash royale apk mod menu con modo dios<br />
-clash royale ultima version apk descargar gratis<br />
-clash royale truco apk sin root sin encuesta<br />
-clash royale generador online apk sin verificacion humana<br />
-clash royale modificado apk por master royale infinity<br />
-clash royale descargar master royale infinity 3.2729 apk gratis para android<br />
-clash royale novo apk mod do clash royale todo infinito youtube<br />
-clash royale download the apk from uptodown for android<br />
-clash royale unlimited resources apk for android and ios<br />
-clash royale best private server apk with custom cards and skins<br />
-clash royale hack tool apk no password no jailbreak<br />
-clash royale working cheats apk 2023 updated daily<br />
-clash royale free gems and gold apk without offers or surveys<br />
-clash royale cracked apk by nulls royal latest version<br />
-clash royale baixar master royale infinity 3.2729 apk gratis para android<br />
-clash royale novo apk mod do clash royale tudo infinito mediafire<br />
-clash royale baixar o apk do uptodown para android<br />
-clash royale recursos ilimitados apk para android e ios<br />
-clash royale melhor servidor privado apk com cartas e skins personalizados<br />
-clash royale ferramenta de hackear apk sem senha sem jailbreak<br />
-clash royale truques funcionando apk 2023 atualizado diariamente<br />
-clash royale gemas e ouro gratis apk sem ofertas ou pesquisas<br />
-clash royale apk rachado por nulls royal ultima versao<br />
-descargar master royal infinity 3.2729 APK gratis para Android - Malavida.com/clashroyal/<br />
-nuevo APK mod de Clash Royale todo infinito YouTube - YouTube.com/watch?v=EOCZMUdAql4 <br />
-descargar el APK de Uptodown para Android - Clash-Royal.en.uptodown.com/android <br />
-recursos ilimitados APK para Android y iOS - Clash-Royals.com/unlimited-resources-apk/ <br />
-mejor servidor privado APK con cartas y skins personalizados - Clash-Royals.net/best-private-server-apk/ <br />
-herramienta de hackear APK sin contraseña sin jailbreak - Clash-Royals.org/hack-tool-apk/ <br />
-trucos funcionando APK 2023 actualizado diariamente - Clash-Royals.info/working-cheats-apk/ <br />
-gemas y oro gratis APK sin ofertas o encuestas - Clash-Royals.co/free-gems-and-gold-apk/ <br />
-APK agrietado por nulls royal última versión - Clash-Royals.io/cracked-apk-by-nulls/</p>
-<h3>Enjoy the game</h3>
-<p>After installing the apk, you can launch the game and enjoy the unlimited resources and features. You can create your own custom deck with any cards you want, unlock all the chests and arenas, and challenge anyone in the game. You can also join a clan and share cards with other players who use the same apk. However, you should be aware that using Clash Royale Todo Infinito Apk might affect your game experience and performance. You might face lag, glitches, or bugs in the game. You might also lose your progress or account if Supercell detects that you are using a modified version of the game.</p>
-<h2>Tips and tricks for playing Clash Royale</h2>
-<p>Whether you use Clash Royale Todo Infinito Apk or not, there are some tips and tricks that can help you improve your skills and win more battles in Clash Royale. Here are some of them:</p>
-<h3>Join a clan and share cards</h3>
-<p>One of the best ways to progress faster and get more cards in Clash Royale is to join a clan and share cards with other members. You can request and donate cards every day, which will give you gold and experience points. You can also chat with your clanmates, ask for advice, and practice with friendly battles. You can also participate in clan wars and clan chest events, which will give you more rewards and fun.</p>
-<h3>Attack in pairs and use combos</h3>
-<p>Another important tip for playing Clash Royale is to attack in pairs and use combos. This means that you should not play your cards one by one, but rather combine them to create powerful attacks and defenses. For example, you can pair a tank unit like a giant or a golem with a support unit like a wizard or a musketeer behind it. This will create a strong push that can deal a lot of damage to your opponent's towers. You can also use spells like fireball or zap to support your units or counter your opponent's units.</p>
-<h3>Be patient and count elixir</h3>
-<p>The last tip for playing Clash Royale is to be patient and count elixir. This means that you should not rush into attacking or defending without thinking first. You should wait for the right moment to play your cards, depending on the situation and your elixir advantage. Elixir advantage is the difference between your elixir and your opponent's elixir at any given time. You can gain elixir advantage by playing cheaper cards than your opponent, by making positive elixir trades (using less elixir to counter more elixir), or by letting your opponent waste their elixir on unnecessary moves.</p>
-<h2>Conclusion</h2>
-<p>Clash Royale is a fun and addictive game that combines real-time multiplayer battles, collectible card games, and strategy games. Clash Royale Todo Infinito Apk is a modified version of the game that gives you unlimited resources and features. However, it also comes with some risks and drawbacks that might affect your game experience and performance. If you want to try it, you need to download it from a reliable source, install it on your device, and enjoy the game. You can also follow some tips and tricks to improve your skills and win more battles in Clash Royale.</p>
-<h2>FAQs</h2>
-<ul>
-<li><b>What is the difference between Clash Royale Todo Infinito Apk and Clash Royale Mod Apk?</b></li>
-<li>A: Clash Royale Todo Infinito Apk and Clash Royale Mod Apk are both modified versions of Clash Royale that give you unlimited resources and features. However they might have different sources, versions, or features. For example, some Clash Royale Mod Apks might have custom servers, private servers, or unlimited chests, while others might not. You should always check the details and specifications of the apk before downloading it.</li>
-<li><b>Is Clash Royale Todo Infinito Apk safe to use?</b></li>
-<li>A: Clash Royale Todo Infinito Apk is not an official version of the game, and it might not be safe to use. It might contain viruses, malware, or spyware that can harm your device or steal your personal information. It might also cause technical issues or errors in the game. It might also get you banned or suspended by Supercell for violating their terms of service. Therefore, you should use it at your own risk and discretion.</li>
-<li><b>Can I play Clash Royale Todo Infinito Apk with my friends who use the original version of the game?</b></li>
-<li>A: No, you cannot play Clash Royale Todo Infinito Apk with your friends who use the original version of the game. This is because Clash Royale Todo Infinito Apk uses a different server and database than the original version of the game. Therefore, you can only play with other players who use the same apk as you.</li>
-<li><b>How can I update Clash Royale Todo Infinito Apk?</b></li>
-<li>A: Clash Royale Todo Infinito Apk does not update automatically like the original version of the game. You need to manually download and install the latest version of the apk from a reliable source whenever there is a new update. However, you might lose your progress or account if you update the apk, as it might not be compatible with the previous version.</li>
-<li><b>Where can I find more information about Clash Royale Todo Infinito Apk?</b></li>
-<li>A: You can find more information about Clash Royale Todo Infinito Apk on various websites, blogs, forums, or social media platforms that are dedicated to Clash Royale or mobile gaming. You can also watch videos, tutorials, or reviews of the apk on YouTube or other streaming platforms. However, you should always verify the credibility and accuracy of the information before trusting it.</li>
-</ul></p> 197e85843d<br />
-<br />
-<br />

spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/Download CarX Drift Racing Lite Mod APK with Unlimited Money and Unlocked Features.md

@@ -1,91 +0,0 @@
-<br />
-<h1>CarX Drift Racing Lite Mod APK: A Fun and Free Racing Game</h1>
-<p>If you are a fan of car racing games, you might have heard of CarX Drift Racing Lite. It is a popular game that lets you experience the thrill of drifting on different tracks with realistic physics and graphics. But what if you want to enjoy the game without any limitations or interruptions? That's where CarX Drift Racing Lite Mod APK comes in handy. In this article, we will tell you what CarX Drift Racing Lite is, how to download and install the mod apk version, and why you should use it.</p>
-<h2>carx drift racing lite mod apk happymod</h2><br /><p><b><b>Download Zip</b> &#187;&#187;&#187; <a href="https://urlin.us/2uSV3T">https://urlin.us/2uSV3T</a></b></p><br /><br />
- <h2>What is CarX Drift Racing Lite?</h2>
-<p>CarX Drift Racing Lite is a racing game developed by CarX Technologies. It is a lite version of the original CarX Drift Racing game, which means it has fewer features and content, but it is also more suitable for low-end devices. The game allows you to choose from different cars and tracks, customize your vehicle, and compete with other players online or offline. You can also earn coins by drifting and use them to upgrade your car or unlock new scenes.</p>
- <h3>Features of CarX Drift Racing Lite</h3>
-<p>CarX Drift Racing Lite has many features that make it an enjoyable and addictive game for racing enthusiasts. Here are some of them:</p>
- <h4>Realistic physics and graphics</h4>
-<p>The game uses a sophisticated car physics engine that simulates the behavior of real cars on different surfaces and conditions. You can feel the difference between asphalt, grass, sand, or snow, as well as the impact of speed, weight, and inertia on your car's performance. The game also has stunning graphics that create a realistic atmosphere for your racing experience. You can see the smoke, dust, sparks, and skid marks as you drift on the tracks.</p>
- <h4>Customizable cars and tracks</h4>
-<p>The game offers you a variety of cars to choose from, each with its own characteristics and specifications. You can also customize your car's appearance, color, wheels, engine, suspension, and more. You can also choose from different tracks that have different layouts, obstacles, and weather effects. You can even create your own tracks using the track editor feature.</p>
- <h4>Leaderboards and achievements</h4>
-<p>The game has a competitive mode that lets you challenge other players online or offline. You can see your ranking on the global or local leaderboards, as well as your personal statistics and records. You can also earn achievements by completing various tasks and challenges in the game.</p>
-<p>carx drift racing lite unlimited money mod apk<br />
-carx drift racing lite hack apk download<br />
-carx drift racing lite mod apk latest version<br />
-carx drift racing lite unlocked cars mod apk<br />
-carx drift racing lite mod apk android 1<br />
-carx drift racing lite mod apk revdl<br />
-carx drift racing lite mod apk free download<br />
-carx drift racing lite mod apk offline<br />
-carx drift racing lite mod apk no root<br />
-carx drift racing lite mod apk obb<br />
-carx drift racing lite mod apk unlimited coins<br />
-carx drift racing lite mod apk 1.1<br />
-carx drift racing lite mod apk rexdl<br />
-carx drift racing lite mod apk pure<br />
-carx drift racing lite mod apk 2023<br />
-carx drift racing lite mod apk happymod.com<br />
-carx drift racing lite mod apk all cars unlocked<br />
-carx drift racing lite mod apk unlimited everything<br />
-carx drift racing lite mod apk for pc<br />
-carx drift racing lite mod apk ios<br />
-carx drift racing lite cheat codes mod apk<br />
-carx drift racing lite hack tool mod apk<br />
-carx drift racing lite premium mod apk<br />
-carx drift racing lite pro mod apk<br />
-carx drift racing lite full version mod apk<br />
-carx drift racing lite mega mod apk<br />
-carx drift racing lite vip mod apk<br />
-carx drift racing lite gold mod apk<br />
-carx drift racing lite cracked mod apk<br />
-carx drift racing lite original mod apk<br />
-download game carx drift racing lite mod apk<br />
-how to install carx drift racing lite mod apk<br />
-cara download carx drift racing lite mod apk<br />
-descargar carx drift racing lite mod apk<br />
-telecharger carx drift racing lite mod apk<br />
-baixar carx drift racing lite mod apk<br />
-indir carx drift racing lite mod apk<br />
-scaricare carx drift racing lite mod apk<br />
-unduh carx drift racing lite mod apk<br />
-скачать carx drift racing lite мод апк</p>
- <h3>How to download and install CarX Drift Racing Lite Mod APK?</h3>
-<p>If you want to download and install CarX Drift Racing Lite Mod APK, you need to follow these simple steps:</p>
- <h4>Download the mod apk file from a trusted source</h4>
-<p>You can find many websites that offer CarX Drift Racing Lite Mod APK files for free download. However, not all of them are safe and reliable. Some of them may contain viruses, malware, or spyware that can harm your device or steal your personal information. Therefore, you need to be careful when choosing a source for downloading the mod apk file. One of the trusted sources that we recommend is HappyMod. It is a platform that provides modded versions of various games and apps with 3x speed download and verified by users.</p>
- <h4>Enable unknown sources on your device</h4>
-<p>Before you can install the mod apk file, you need to enable unknown sources on your device. This is a security setting that prevents the installation of apps from sources other than the official app store. To enable unknown sources, you need to go to your device's settings, then security, then toggle on the option that says "allow installation of apps from unknown sources". This may vary depending on your device model and Android version.</p>
- <h4>Install the mod apk file and enjoy the game</h4>
-<p>Once you have downloaded the mod apk file and enabled unknown sources, you can install the mod apk file by tapping on it and following the instructions. After the installation is complete, you can launch the game and enjoy the modded features. You don't need to uninstall the original game or create a new account. You can use your existing account and data with the mod apk version.</p>
- <h2>Why use CarX Drift Racing Lite Mod APK?</h2>
-<p>You might be wondering why you should use CarX Drift Racing Lite Mod APK instead of the original game. Well, there are many benefits of using the mod apk version that will enhance your gaming experience. Here are some of them:</p>
- <h3>Benefits of using the mod apk version</h3>
-<p>The mod apk version of CarX Drift Racing Lite has many advantages over the original game. Some of them are:</p>
- <h4>Unlimited coins and unlocked scenes</h4>
-<p>One of the main benefits of using the mod apk version is that you get unlimited coins and unlocked scenes in the game. Coins are the currency that you use to buy and upgrade cars, as well as unlock new tracks and scenes. Normally, you have to earn coins by drifting or watching ads, which can be time-consuming and annoying. But with the mod apk version, you get unlimited coins that you can spend as you wish. You also get access to all the scenes that are otherwise locked in the original game. You can enjoy different environments and challenges without any restrictions.</p>
- <h4>No ads and no root required</h4>
-<p>Another benefit of using the mod apk version is that you don't have to deal with any ads or root your device. Ads are annoying and distracting, especially when they pop up in the middle of your game. They can also consume your data and battery. But with the mod apk version, you don't have to worry about any ads interrupting your game. You can play smoothly and peacefully without any interruptions. You also don't need to root your device to use the mod apk version. Rooting is a process that gives you full control over your device, but it also voids your warranty and exposes your device to risks. But with the mod apk version, you don't need to root your device at all. You can use it safely and easily without any complications.</p>
- <h4>Compatible with most devices and easy to use</h4>
-<p>The last benefit of using the mod apk version is that it is compatible with most devices and easy to use. The mod apk version is optimized for low-end devices, which means it runs smoothly and efficiently on most Android devices. You don't need a high-end device or a lot of storage space to play the game. You also don't need any special skills or knowledge to use the mod apk version. You just need to follow the simple steps mentioned above and you are good to go.</p>
- <h2>Conclusion</h2>
-<p>CarX Drift Racing Lite is a fun and free racing game that lets you drift on different tracks with realistic physics and graphics. It has many features that make it an enjoyable and addictive game for racing enthusiasts. However, if you want to enjoy the game without any limitations or interruptions, you should use CarX Drift Racing Lite Mod APK. It is a modified version of the original game that gives you unlimited coins, unlocked scenes, no ads, no root required, and compatibility with most devices. You can download and install it easily from HappyMod and enjoy the game with more fun and freedom.</p>
- <p>I hope this article was 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>
- <h3>FAQs</h3>
-<p>Here are some frequently asked questions about CarX Drift Racing Lite Mod APK:</p>
- <ol>
-<li><b>Is CarX Drift Racing Lite Mod APK safe?</b></li>
-<p>Yes, CarX Drift Racing Lite Mod APK is safe to use as long as you download it from a trusted source like HappyMod. It does not contain any viruses, malware, or spyware that can harm your device or steal your personal information.</p>
-<li><b>Is CarX Drift Racing Lite Mod APK legal?</b></li>
-<p>Yes, CarX Drift Racing Lite Mod APK is legal to use as long as you don t use it for any illegal or unethical purposes, such as cheating, hacking, or pirating. You should also respect the rights and interests of the original developers and publishers of the game.</p>
-<li><b>Can I update CarX Drift Racing Lite Mod APK?</b></li>
-<p>Yes, you can update CarX Drift Racing Lite Mod APK whenever there is a new version available. However, you need to download and install the new mod apk file from the same source that you used before. You don't need to uninstall the previous mod apk file or lose your data. You can simply overwrite the old file with the new one and enjoy the updated features.</p>
-<li><b>Can I play CarX Drift Racing Lite Mod APK online?</b></li>
-<p>Yes, you can play CarX Drift Racing Lite Mod APK online with other players. However, you need to be careful when playing online, as some players may report you for using the mod apk version. This may result in your account being banned or suspended by the game's servers. Therefore, you should use the mod apk version at your own risk and discretion when playing online.</p>
-<li><b>Can I use CarX Drift Racing Lite Mod APK on iOS devices?</b></li>
-<p>No, CarX Drift Racing Lite Mod APK is only compatible with Android devices. It is not available for iOS devices, such as iPhones or iPads. If you want to play CarX Drift Racing Lite on iOS devices, you need to download and install the original game from the App Store.</p>
-</ol></p> 197e85843d<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Age of History APK - Download the Best Strategy Game for Android.md

@@ -1,155 +0,0 @@
-<br />
-<h1>Age of History APK Indir: A Grand Strategy Game for Android</h1>
- <p>If you are a fan of strategy games and history, you might want to check out Age of History APK indir, a grand strategy wargame that is simple to learn yet hard to master. In this game, you can use military tactics and cunning diplomacy to either unify the world or conquer it. You can also create your own history using in-game editors and play with as many players as civilizations in scenario. In this article, we will tell you everything you need to know about this game, including how to download and install it, how to play it, and how it compares to other strategy games.</p>
-<h2>age of history apk indir</h2><br /><p><b><b>Download Zip</b> &#10027; <a href="https://jinyurl.com/2uNLz0">https://jinyurl.com/2uNLz0</a></b></p><br /><br />
- <h2>What is Age of History?</h2>
- <p>Age of History is a turn-based strategy game that covers the whole history of humanity, from the dawn of civilization to the far future. You can play as many civilizations ranging from the largest empire to the smallest tribe, and lead your people to glory in a campaign spanning thousands of years. You can also choose from different ages, such as the Age of Civilizations, the Age of Feudalism, the Age of Industrialization, the Age of World War II, and more.</p>
- <p>One of the most interesting features of this game is that it lets you create your own scenarios and civilizations using in-game editors. You can customize everything from the map, the provinces, the terrain types, the growth rate, the cities, the flags, the alliances, the diplomacy colors, and more. You can also share your creations with other players online and download their scenarios as well.</p>
- <p>Another feature that makes this game unique is that it has two maps: Earth and Kepler-22b. Earth is a detailed map of the world with many historical borders and realistic geography. Kepler-22b is a fictional planet that has 404 provinces and different terrain types. You can explore both maps and see how different civilizations interact with each other.</p>
- <h2>How to download and install Age of History APK?</h2>
- <p>If you want to play this game on your Android device, you will need to download and install its APK file from a reliable source. One of the best sources for this is APKCombo, a website that offers free APK downloads for various apps and games. Here are the steps to download and install Age of History APK from APKCombo:</p>
- <ol>
-<li>Go to <a href="(^1^)">https://apkcombo.com/tr/age-of-history-ii/age.of.civilizations2.jakowski.lukasz.lite/</a> on your browser.</li>
-<li>Click on the green "Download APK" button on the page.</li>
-<li>Select your preferred version (the latest one is recommended) and click on "Download".</li>
-<li>Wait for the download to finish and then open the APK file on your device.</li>
-<li>Follow the instructions on your screen to install the game on your device.</li>
-</ol>
- <p>Some of the requirements and permissions for the game are:</p>
- <ul>
-<li>Android version: 4.4 or higher</li>
-<li>Storage: 87 MB or more</li>
-<li>Internet: required for online features</li>
-<li>Other permissions: access network state, access wifi state, internet, read external storage, write external storage</li>
-</ul>
- <p>Some of the advantages of downloading the game from APKCombo are:</p>
- <ul>
-<li>You can get the latest version of the game without waiting for updates from Google Play Store.</li>
-<li>You can download the game for free without any ads or in-app purchases.</li>
-<li>You can download the game safely and securely without any viruses or malware.</li>
-</ul>
- <h2>How to play Age of History?</h2>
- <p>Age of History is a game that requires both strategic thinking and historical knowledge. You will need to manage your economy, your military, your diplomacy, and your population as you expand your territory and influence. Here are some of the basics of the game that you should know before you start playing:</p>
- <p>The game is divided into turns, each representing a certain amount of time depending on the age you are playing. Each turn, you can issue orders to your provinces using movement points (MP). You can move your troops, build buildings, recruit units, declare war, make peace, form alliances, and more. You can also use diplomacy points (DP) to influence other civilizations and improve your relations with them. You can also use gold to buy more MP or DP, or to bribe other leaders.</p>
-<p>age of history apk download free<br />
-age of history apk full version<br />
-age of history apk mod unlimited money<br />
-age of history apk android oyun club<br />
-age of history apk latest version<br />
-age of history apk hile indir<br />
-age of history apk obb<br />
-age of history apk revdl<br />
-age of history apk hack<br />
-age of history apk 1.1548a<br />
-age of history apk uptodown<br />
-age of history apk rexdl<br />
-age of history apk pure<br />
-age of history apk 2023<br />
-age of history apk para hilesi<br />
-age of history apk pc<br />
-age of history apk tam sürüm indir<br />
-age of history apk son sürüm indir<br />
-age of history apk güncel indir<br />
-age of history apk bedava indir<br />
-age of history apk mega hile indir<br />
-age of history apk altın hilesi indir<br />
-age of history apk kurulumu<br />
-age of history apk nasıl indirilir<br />
-age of history apk nasıl yüklenir<br />
-age of history lite apk indir<br />
-age of history 2 apk indir<br />
-age of history europe apk indir<br />
-age of history world war 2 apk indir<br />
-age of history world war 1 apk indir<br />
-age of history civil war apk indir<br />
-age of history asia apk indir<br />
-age of history africa apk indir<br />
-age of history america apk indir<br />
-age of civilizations 2 apk indir<br />
-age of civilizations 2 lite apk indir<br />
-age of civilizations 2 europe apk indir<br />
-age of civilizations 2 world war 2 apk indir<br />
-age of civilizations 2 world war 1 apk indir<br />
-age of civilizations 2 civil war apk indir<br />
-age of civilizations 2 asia apk indir<br />
-age of civilizations 2 africa apk indir<br />
-age of civilizations 2 america apk indir<br />
-download game age of history mod apk android 1.com <br />
-download game android offline mod terbaik - Age Of History APK <br />
-download game perang offline mod - Age Of History APK <br />
-download game strategi offline mod - Age Of History APK <br />
-download game sejarah offline mod - Age Of History APK</p>
- <p>The combat system in the game is based on dice rolls and modifiers. Each unit has a certain attack and defense value, as well as a morale value that affects its performance. When two units clash, they roll dice to determine the outcome of the battle. The modifiers depend on factors such as terrain type, fortification level, technology level, and leader skill. The winner of the battle is the one who inflicts more casualties on the enemy or forces them to retreat. The loser may lose some units or provinces as a result.</p>
- <p>Some of the tips and tricks for playing the game effectively are:</p>
- <ul>
-<li>Plan ahead and prioritize your goals. Do you want to conquer the world or unify your region? Do you want to focus on military or economic development? Do you want to ally with other civilizations or go solo?</li>
-<li>Balance your budget and resources. Do not spend more than you earn or you will go into debt. Do not overextend your army or you will lose morale and supply. Do not neglect your population or you will face rebellions and unrest.</li>
-<li>Research new technologies and upgrade your units. Technology is the key to progress and power in this game. You can research new technologies using research points (RP) that you gain from buildings, events, or achievements. You can also upgrade your units using gold or RP to improve their stats and abilities.</li>
-<li>Explore the map and discover new lands and civilizations. The map is full of secrets and surprises that can benefit or harm you. You can find new resources, events, wonders, relics, and more. You can also encounter new civilizations that can be friendly or hostile to you.</li>
-</ul>
- <p>Some of the features and modes of the game are:</p>
- <ul>
-<li>Historical grand campaign: This is the main mode of the game where you can play as any civilization from any age and try to achieve your objectives.</li>
-<li>Scenario editor: This is where you can create your own scenarios using in-game editors. You can customize everything from the map, the provinces, the terrain types, the growth rate, the cities, the flags, the alliances, the diplomacy colors, and more.</li>
-<li>Civilization creator: This is where you can create your own civilizations using in-game editors. You can customize everything from the name, the flag, the color, the leader, the ideology, the government type, the religion, the culture, and more.</li>
-<li>Sandbox mode: This is where you can play with as many players as civilizations in scenario. You can set up your own rules and conditions for the game.</li>
-<li>Online mode: This is where you can play with other players online using multiplayer servers. You can chat with them, cooperate with them, or compete with them.</li>
-</ul>
- <h2>How does Age of History compare to other strategy games?</h2>
- <p>Age of History is a game that has many similarities and differences with other strategy games in terms of gameplay, graphics, sound, and content. Here are some of them:</p>
- <h3>The similarities and differences between Age of History and Age of Empires</h3>
- <p>Age of Empires is a real-time strategy game that covers different historical periods from the Stone Age to the Iron Age. You can play as different civilizations and build your empire by collecting resources, training units, constructing buildings, and fighting enemies. You can also advance through different ages and unlock new technologies and units.</p>
- <p>Some of the similarities between Age of History and Age of Empires are:</p>
- <ul>
-<li>Both games are strategy games that involve historical civilizations and scenarios.</li>
-<li>Both games have different ages and technologies that affect the gameplay and the units.</li>
-<li>Both games have editors that allow you to create your own maps and scenarios.</li>
-</ul>
- <p>Some of the differences between Age of History and Age of Empires are:</p>
- <ul>
-<li>Age of History is a turn-based game while Age of Empires is a real-time game.</li>
-<li>Age of History covers the whole history of humanity while Age of Empires covers only a few historical periods.</li>
-<li>Age of History has more civilizations and provinces than Age of Empires.</li>
-</ul>
- <h3>The similarities and differences between Age of History and Hearts of Iron IV</h3>
- <p>Hearts of Iron IV is a grand strategy game that focuses on the World War II era. You can play as any country in the world and lead it to victory or defeat in the global conflict. You can also customize your country's political, economic, military, and diplomatic aspects. You can also join or create factions, declare war, make peace, research new technologies, and more.</p>
- <p>Some of the similarities between Age of History and Hearts of Iron IV are:</p>
- <ul>
-<li>Both games are grand strategy games that involve historical scenarios and events.</li>
-<li>Both games have a detailed map of the world with many provinces and regions.</li>
-<li>Both games have a complex combat system that involves dice rolls, modifiers, and morale.</li>
-</ul>
- <p>Some of the differences between Age of History and Hearts of Iron IV are:</p>
- <ul>
-<li>Age of History covers the whole history of humanity while Hearts of Iron IV covers only the World War II era.</li>
-<li>Age of History has more civilizations and ages than Hearts of Iron IV.</li>
-<li>Hearts of Iron IV has more features and mechanics than Age of History, such as air warfare, naval warfare, espionage, resistance, supply lines, etc.</li>
-</ul>
- <h3>The similarities and differences between Age of History and Civilization VI</h3>
- <p>Civilization VI is a turn-based strategy game that lets you build your own civilization from scratch. You can choose from different leaders and civilizations, each with their own unique abilities and bonuses. You can also explore the map, found cities, develop districts, build wonders, research technologies, adopt policies, engage in diplomacy, wage war, and more. You can also win the game by achieving one of several victory conditions, such as science, culture, religion, domination, or diplomacy.</p>
- <p>Some of the similarities between Age of History and Civilization VI are:</p>
- <ul>
-<li>Both games are turn-based strategy games that involve historical civilizations and leaders.</li>
-<li>Both games have different ages and technologies that affect the gameplay and the units.</li>
-<li>Both games have diplomacy points and options that allow you to interact with other civilizations.</li>
-</ul>
- <p>Some of the differences between Age of History and Civilization VI are:</p>
- <ul>
-<li>Age of History covers the whole history of humanity while Civilization VI covers only a few historical periods.</li>
-<li>Civilization VI has more features and mechanics than Age of History, such as city management, district placement, wonder construction, policy cards, religion system, loyalty system, etc.</li>
-<li>Civilization VI has different victory conditions while Age of History has only one: world domination.</li>
-</ul>
- <h2>Conclusion</h2>
- <p>In conclusion, Age of History APK indir is a grand strategy game for Android that covers the whole history of humanity, from the dawn of civilization to the far future. You can play as any civilization and lead it to glory or ruin in a campaign spanning thousands of years. You can also create your own scenarios and civilizations using in-game editors and share them with other players online. You can also explore two maps: Earth and Kepler-22b, and see how different civilizations interact with each other. Age of History is a game that is simple to learn yet hard to master, and it will challenge your strategic thinking and historical knowledge. If you are looking for a game that combines history, strategy, and creativity, you should definitely give Age of History a try.</p>
- <p>If you want to download and install Age of History APK on your Android device, you can do so easily and safely from APKCombo, a website that offers free APK downloads for various apps and games. You can get the latest version of the game without any ads or in-app purchases, and enjoy its features and modes without any hassle. You can also compare this game to other strategy games, such as Age of Empires, Hearts of Iron IV, and Civilization VI, and see how it differs from them in terms of gameplay, graphics, sound, and content.</p>
- <p>So what are you waiting for? Download Age of History APK indir today and start creating your own history!</p>
- <h3>Five unique FAQs about the game</h3>
- <ol>
-<li>Q: How many civilizations are there in Age of History?    <br>A: There are over 250 civilizations in the game, each with their own flag, leader, ideology, government type, religion, culture, and more.</li>
-<li>Q: How can I change the language of the game?    <br>A: You can change the language of the game from the settings menu. The game supports 11 languages: English, Polish, French, German, Russian, Spanish, Portuguese, Turkish, Italian, Chinese, and Japanese.</li>
-<li>Q: How can I play with other players online?    <br>A: You can play with other players online using multiplayer servers. You can join or create a server from the online mode menu. You can also chat with other players using the chat feature.</li>
-<li>Q: How can I save and load my game progress?    <br>A: You can save and load your game progress from the pause menu. You can have up to 10 save slots for each scenario. You can also autosave your game every turn or every 10 turns.</li>
-<li>Q: How can I get more gold, MP, DP, or RP in the game?    <br>A: You can get more gold by collecting taxes from your provinces or by trading with other civilizations. You can get more MP by building roads or ports in your provinces or by researching new technologies. You can get more DP by improving your relations with other civilizations or by completing achievements. You can get more RP by building universities or libraries in your provinces or by researching new technologies.</li>
-</ol></p> 197e85843d<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Download Tag After School APK for Android - ThaiAPK.md

@@ -1,150 +0,0 @@
-
-<h1>Tag After School APK: A Horror School Life Simulation Game</h1>
-<p>If you are looking for a thrilling and exciting game that combines horror, romance, and mystery, then you should try Tag After School APK. This is a game developed by Genius Studio Japan Inc., a company that specializes in creating anime-style games for Android devices. In this game, you will play as Shota-Kun, a high school student who gets involved in a deadly game of tag with ghostly girls. You will have to make choices that will affect the outcome of the story and your relationships with the girls. Are you ready to face the horrors of Tag After School APK? Read on to find out more about this game.</p>
-<h2>tag after school apk thaiapk</h2><br /><p><b><b>Download Zip</b> --->>> <a href="https://jinyurl.com/2uNK1K">https://jinyurl.com/2uNK1K</a></b></p><br /><br />
- <h2>What is Tag After School APK?</h2>
-<p>Tag After School APK is a horror school life simulation game that was released in January 2023. It is available for free download on various websites, such as ThaiAPK, APKCombo, and others. The game has an age rating of 18+, as it contains mature visuals and themes that are not suitable for younger audiences. The game has a file size of about 100 MB, and it requires Android 5.0 or higher to run smoothly.</p>
- <h3>The story and the characters of Tag After School APK</h3>
-<p>The game follows the story of Shota-Kun, a normal high school student who has a crush on his childhood friend, Yui-Chan. One day, he decides to confess his feelings to her after school, but he gets interrupted by a mysterious voice that invites him to play a game of tag. He soon realizes that he is trapped in a haunted school with four ghostly girls who are after him. He has to survive until dawn by hiding from them or fighting them back. However, he also discovers that each girl has a tragic backstory that explains why they became ghosts. He can choose to help them or ignore them, depending on his actions and decisions.</p>
-<p>The four ghostly girls are:</p>
-<ul>
-<li>Ayumi-Chan: She is the first girl that Shota-Kun encounters in the game. She is a cheerful and energetic girl who loves sports and music. She died in a car accident while going to a concert with her friends.</li>
-<li>Miyuki-Chan: She is the second girl that Shota-Kun meets in the game. She is a shy and timid girl who loves books and animals. She died from an illness that made her unable to breathe properly.</li>
-<li>Sakura-Chan: She is the third girl that Shota-Kun runs into in the game. She is a sweet and kind girl who loves flowers and gardening. She died from a fire that burned down her house.</li>
-<li>Rin-Chan: She is the fourth and final girl that Shota-Kun faces in the game. She is a cold and aloof girl who hates everyone and everything. She died from suicide after being bullied at school.</li>
-</ul>
- <h3>The gameplay and the features of Tag After School APK</h3>
-<p>The game is divided into several chapters, each focusing on one of the ghostly girls. The game has two modes: story mode and free mode. In story mode, you will follow the main plot and make choices that will affect the ending of each chapter. You will also have to interact with the girls by talking to them, giving them gifts, or fighting them. In free mode, you can replay any chapter you have completed and explore different outcomes.</p>
-<p>The game also has several features that make it more enjoyable and challenging, such as: Tag After School APK has a timer, a map, a inventory, and a status bar. You can use these tools to plan your strategy and manage your resources. You can also collect items and clues that will help you solve the mystery of the school and the girls. Some items can also be used as weapons or gifts for the girls. You can also unlock achievements and gallery images as you progress through the game.</p>
-<p>tag after school android game thaiapk<br />
-tag after school apk download thaiapk<br />
-tag after school apk latest version thaiapk<br />
-tag after school apk mod thaiapk<br />
-tag after school apk offline thaiapk<br />
-tag after school apk update thaiapk<br />
-tag after school app thaiapk<br />
-tag after school game thaiapk<br />
-tag after school gameplay thaiapk<br />
-tag after school guide thaiapk<br />
-tag after school review thaiapk<br />
-tag after school tips thaiapk<br />
-tag after school walkthrough thaiapk<br />
-thaiapk tag after school 18+<br />
-thaiapk tag after school android<br />
-thaiapk tag after school apk 2023<br />
-thaiapk tag after school apk free<br />
-thaiapk tag after school apk full<br />
-thaiapk tag after school apk v5.0<br />
-thaiapk tag after school cheats<br />
-thaiapk tag after school codes<br />
-thaiapk tag after school hack<br />
-thaiapk tag after school how to play<br />
-thaiapk tag after school install<br />
-thaiapk tag after school link<br />
-thaiapk tag after school online<br />
-thaiapk tag after school video<br />
-ดาวน์โหลด tag after school apk thaiapk<br />
-วิธีเล่น tag after school apk thaiapk<br />
-สอนเล่น tag after school apk thaiapk<br />
-เกม tag after school apk thaiapk<br />
-เกมส์ tag after school apk thaiapk<br />
-เล่นเกมส์ tag after school apk thaiapk<br />
-เวอร์ชั่นล่าสุดของเกมส์ tag after school apk thaiapk<br />
-แจกเกมส์ tag after school apk thaiapk<br />
-แนะนำเกมส์ tag after school apk thaiapk<br />
-โปรเกมส์ tag after school apk thaiapk<br />
-โหลดเกมส์ tag after school apk thaiapk<br />
-ไทยแอปคอม เกมส์tagafter-school-apk-thai-apk <br />
-ไทยแอปคอม เกมส์tag-after-school-apk-thai-apk <br />
-ไทยแอปคอม เกมส์tagafterschool-apk-thai-apk <br />
-ไทยแอปคอม เกมส์tagafterschoolandroid-thai-apk <br />
-ไทยแอปคอม เกมส์tagafterschoolandroid-thai-apk <br />
-ไทยแอปคอม เกมส์tagafterschoolandroid-thai-apk <br />
-ไทยแอปคอม เกมส์tagafterschoolandroid-thai-apk</p>
- <h3>The graphics and the sound of Tag After School APK</h3>
-<p>The game has stunning graphics that create a realistic and immersive atmosphere. The game uses 3D models and animations for the characters and the environments. The game also has a dark and gloomy color scheme that enhances the horror vibe. The game also has a great sound design that adds to the tension and suspense. The game has voice acting for the main characters, as well as sound effects and background music that match the mood of each scene.</p>
- <h2>How to download and install Tag After School APK on Android devices?</h2>
-<p>If you want to play Tag After School APK on your Android device, you will need to download and install it from a third-party source, as it is not available on the Google Play Store. Here are the steps you need to follow:</p>
- <h3>Requirements and compatibility of Tag After School APK</h3>
-<p>Before you download and install Tag After School APK, you need to make sure that your device meets the following requirements:</p>
-<ul>
-<li>Your device must have Android 5.0 or higher.</li>
-<li>Your device must have at least 1 GB of RAM and 200 MB of free storage space.</li>
-<li>Your device must have a stable internet connection.</li>
-<li>Your device must allow installation of apps from unknown sources. You can enable this option by going to Settings > Security > Unknown Sources.</li>
-</ul>
- <h3>Steps to download and install Tag After School APK</h3>
-<p>Once you have checked the requirements and compatibility of Tag After School APK, you can follow these steps to download and install it:</p>
-<ol>
-<li>Go to a reliable website that offers Tag After School APK for free download, such as ThaiAPK, APKCombo, or others.</li>
-<li>Click on the download button and wait for the file to be downloaded on your device.</li>
-<li>Locate the downloaded file in your file manager and tap on it to start the installation process.</li>
-<li>Follow the instructions on the screen and wait for the installation to be completed.</li>
-<li>Launch the game from your app drawer and enjoy playing Tag After School APK.</li>
-</ol>
- <h3>Tips and tricks for playing Tag After School APK</h3>
-<p>If you want to have a better gaming experience with Tag After School APK, you can use these tips and tricks:</p>
-<ul>
-<li>Save your game frequently, as you may encounter different endings depending on your choices.</li>
-<li>Explore every corner of the school, as you may find hidden items and secrets that will help you in your quest.</li>
-<li>Pay attention to the timer, as you only have until dawn to survive and escape from the school.</li>
-<li>Use your map wisely, as it will show you where you are and where the girls are.</li>
-<li>Use your inventory smartly, as it will store your items and clues. You can also use some items as weapons or gifts for the girls.</li>
-<li>Use your status bar carefully, as it will show you your health and stamina. You need to keep them high by resting, eating, or drinking.</li>
-<li>Talk to the girls whenever you can, as it will affect your relationship with them. You can also give them gifts to increase their affection towards you.</li>
-<li>Fight back when necessary, as some girls may attack you if they catch you. You can use items or skills to defend yourself or escape from them.</li>
-<li>Be careful with your decisions, as they will have consequences on the story and the ending. You can also replay any chapter in free mode to see different outcomes.</li>
-</ul>
- <h2>Why should you play Tag After School APK?</h2>
-<p>If you are still wondering whether Tag After School APK is worth playing or not, here are some reasons why you should give it a try:</p>
- <h3>The pros and cons of Tag After School APK</h3>
-<p>Like any other game, Tag After School APK has its pros and cons. Here are some of them:</p>
- <table style="border: 1px solid black;">
-<tr style="border: 1px solid black;">
-<th style="border: 1px solid black;">Pros</th><th style="border: 1px solid black;">Cons</th></tr>
-<tr style="border: 1px solid black;">
-<td style="border: 1px solid black;">It has a captivating and original story that will keep you hooked until the end.</td><td style="border: 1px solid black;">It has some mature and disturbing scenes that may not be suitable for everyone.</td></tr>
-<tr style="border: 1px solid black;">
-<td style="border: 1px solid black;">It has beautiful and realistic graphics that create a immersive atmosphere.</td><td style="border: 1px solid black;">It has a large file size that may take up a lot of storage space on your device.</td></tr>
-<tr style="border: 1px solid black;">
-<td style="border: 1px solid black;">It has a great sound design that adds to the tension and suspense.</td><td style="border: 1px solid black;">It has some bugs and glitches that may affect the gameplay and performance.</td></tr>
-<tr style="border: 1px solid black;">
-<td style="border: 1px solid black;">It has multiple endings and outcomes that depend on your choices and actions.</td><td style="border: 1px solid black;">It has some repetitive and tedious tasks that may bore you after a while.</td></tr>
-<tr style="border: 1px solid black;">
-<td style="border: 1px solid black;">It has a variety of items and clues that will help you in your quest.</td><td style="border: 1px solid black;">It has a limited inventory space that may force you to discard some items.</td></tr>
-<tr style="border: 1px solid black;">
-<td style="border: 1px solid black;">It has a fun and challenging gameplay that will test your skills and strategy.</td><td style="border: 1px solid black;">It has a difficult and unforgiving gameplay that may frustrate you at times.</td></tr>
-</table>
- <h3>The ratings and reviews of Tag After School APK</h3>
-<p>Tag After School APK has received positive ratings and reviews from many players who have tried it. The game has an average rating of 4.5 out of 5 stars on ThaiAPK, based on more than 1000 votes. The game also has more than 500 comments from satisfied users who have praised the game for its story, graphics, sound, gameplay, and features. Here are some of the comments from the users:</p>
-<blockquote>
-<p>"This game is amazing! I love the story and the characters. It is so scary and exciting at the same time. I can't wait to see what happens next."</p>
-<p>"This game is awesome! I love the graphics and the sound. It is so realistic and immersive. I feel like I am really in the haunted school."</p>
-<p>"This game is fantastic! I love the gameplay and the features. It is so fun and challenging. I have to think carefully before making any decision."</p>
-</blockquote>
- <h3>The alternatives and similar games to Tag After School APK</h3>
-<p>If you like Tag After School APK, you may also like these games that are similar to it in terms of genre, theme, or style:</p>
-<ul>
-<li>High School Simulator: This is a game developed by KUMA GAMES, a company that also creates anime-style games for Android devices. In this game, you will play as a high school student who can do whatever you want in a realistic school environment. You can interact with other students, teachers, or objects, as well as use weapons or vehicles. You can also customize your character and your school.</li>
-<li>Horrorfield: This is a game developed by Skytec Games, Inc., a company that specializes in creating horror games for Android devices. In this game, you will play as either a survivor or a killer in a multiplayer mode. You will have to cooperate with other survivors or hunt them down as a killer in various maps. You can also upgrade your skills and equipment.</li>
-<li>School Days: This is a game developed by MDickie, a company that produces simulation games for Android devices. In this game, you will play as a student who has to survive the drama and chaos of school life. You can interact with other students, teachers, or objects, as well as fight or romance them. You can also customize your character and your school.</li>
-</ul>
- <h2>Conclusion</h2>
-<p>Tag After School APK is a horror school life simulation game that will give you a thrilling and exciting gaming experience. You will play as Shota-Kun, a high school student who gets trapped in a haunted school with four ghostly girls who are after him. You will have to make choices that will affect the story and the ending of each chapter. You will also have to interact with the girls by talking to them, giving them gifts, or fighting them. You will also have to use your skills and strategy to survive until dawn by hiding from them or escaping from them. The game has stunning graphics, great sound, multiple endings, and various features that make it more enjoyable and challenging. You can download and install Tag After School APK from a third-party source, as it is not available on the Google Play Store. You can also use some tips and tricks to have a better gaming experience with Tag After School APK. If you like this game, you may also like some alternatives and similar games that are also available for Android devices.</p>
-<p>Tag After School APK is a game that will keep you on the edge of your seat and make you feel a range of emotions. It is a game that will make you laugh, cry, scream, and smile. It is a game that will make you think, feel, and act. It is a game that will make you love, hate, and fear. It is a game that will make you live a horror school life simulation.</p>
- <h2>FAQs</h2>
-<p>Here are some frequently asked questions about Tag After School APK:</p>
-<ol>
-<li>Q: Is Tag After School APK safe to download and install?</li>
-<li>A: Yes, Tag After School APK is safe to download and install, as long as you use a reliable website that offers the original and virus-free file. However, you should always be careful when downloading and installing apps from unknown sources, as they may contain malware or spyware that can harm your device or compromise your privacy.</li>
-<li>Q: Is Tag After School APK free to play?</li>
-<li>A: Yes, Tag After School APK is free to play, as it does not require any payment or subscription to access the full content of the game. However, the game may contain some ads or in-app purchases that can enhance your gaming experience or support the developers.</li>
-<li>Q: How long does it take to finish Tag After School APK?</li>
-<li>A: The length of Tag After School APK depends on your choices and actions, as well as the mode and the difficulty level you choose. However, on average, it may take you about 5 to 10 hours to complete the game.</li>
-<li>Q: How many endings does Tag After School APK have?</li>
-<li>A: Tag After School APK has multiple endings that vary depending on your choices and actions throughout the game. There are four main endings for each girl, as well as a true ending that reveals the whole truth behind the game of tag.</li>
-<li>Q: How can I get the true ending of Tag After School APK?</li>
-<li>A: To get the true ending of Tag After School APK, you need to complete all the chapters with all the girls and unlock all the achievements and gallery images. You also need to make the right choices that will lead you to the true ending.</li>
-</ol></p> 401be4b1e0<br />
-<br />
-<br />

spaces/1toTree/lora_test/ppdiffusers/schedulers/scheduling_dpmsolver_singlestep.py

@@ -1,592 +0,0 @@
-# Copyright 2022 TSAIL Team and The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# DISCLAIMER: This file is strongly influenced by https://github.com/LuChengTHU/dpm-solver
-
-import math
-from typing import List, Optional, Tuple, Union
-
-import numpy as np
-import paddle
-
-from ..configuration_utils import ConfigMixin, register_to_config
-from ..utils import _COMPATIBLE_STABLE_DIFFUSION_SCHEDULERS
-from .scheduling_utils import SchedulerMixin, SchedulerOutput
-
-
-def betas_for_alpha_bar(num_diffusion_timesteps, max_beta=0.999):
-    """
-    Create a beta schedule that discretizes the given alpha_t_bar function, which defines the cumulative product of
-    (1-beta) over time from t = [0,1].
-
-    Contains a function alpha_bar that takes an argument t and transforms it to the cumulative product of (1-beta) up
-    to that part of the diffusion process.
-
-
-    Args:
-        num_diffusion_timesteps (`int`): the number of betas to produce.
-        max_beta (`float`): the maximum beta to use; use values lower than 1 to
-                     prevent singularities.
-
-    Returns:
-        betas (`np.ndarray`): the betas used by the scheduler to step the model outputs
-    """
-
-    def alpha_bar(time_step):
-        return math.cos((time_step + 0.008) / 1.008 * math.pi / 2) ** 2
-
-    betas = []
-    for i in range(num_diffusion_timesteps):
-        t1 = i / num_diffusion_timesteps
-        t2 = (i + 1) / num_diffusion_timesteps
-        betas.append(min(1 - alpha_bar(t2) / alpha_bar(t1), max_beta))
-    return paddle.to_tensor(betas, dtype=paddle.float32)
-
-
-class DPMSolverSinglestepScheduler(SchedulerMixin, ConfigMixin):
-    """
-    DPM-Solver (and the improved version DPM-Solver++) is a fast dedicated high-order solver for diffusion ODEs with
-    the convergence order guarantee. Empirically, sampling by DPM-Solver with only 20 steps can generate high-quality
-    samples, and it can generate quite good samples even in only 10 steps.
-
-    For more details, see the original paper: https://arxiv.org/abs/2206.00927 and https://arxiv.org/abs/2211.01095
-
-    Currently, we support the singlestep DPM-Solver for both noise prediction models and data prediction models. We
-    recommend to use `solver_order=2` for guided sampling, and `solver_order=3` for unconditional sampling.
-
-    We also support the "dynamic thresholding" method in Imagen (https://arxiv.org/abs/2205.11487). For pixel-space
-    diffusion models, you can set both `algorithm_type="dpmsolver++"` and `thresholding=True` to use the dynamic
-    thresholding. Note that the thresholding method is unsuitable for latent-space diffusion models (such as
-    stable-diffusion).
-
-    [`~ConfigMixin`] takes care of storing all config attributes that are passed in the scheduler's `__init__`
-    function, such as `num_train_timesteps`. They can be accessed via `scheduler.config.num_train_timesteps`.
-    [`SchedulerMixin`] provides general loading and saving functionality via the [`SchedulerMixin.save_pretrained`] and
-    [`~SchedulerMixin.from_pretrained`] functions.
-
-    Args:
-        num_train_timesteps (`int`): number of diffusion steps used to train the model.
-        beta_start (`float`): the starting `beta` value of inference.
-        beta_end (`float`): the final `beta` value.
-        beta_schedule (`str`):
-            the beta schedule, a mapping from a beta range to a sequence of betas for stepping the model. Choose from
-            `linear`, `scaled_linear`, or `squaredcos_cap_v2`.
-        trained_betas (`np.ndarray`, optional):
-            option to pass an array of betas directly to the constructor to bypass `beta_start`, `beta_end` etc.
-        solver_order (`int`, default `2`):
-            the order of DPM-Solver; can be `1` or `2` or `3`. We recommend to use `solver_order=2` for guided
-            sampling, and `solver_order=3` for unconditional sampling.
-        prediction_type (`str`, default `epsilon`):
-            indicates whether the model predicts the noise (epsilon), or the data / `x0`. One of `epsilon`, `sample`,
-            or `v-prediction`.
-        thresholding (`bool`, default `False`):
-            whether to use the "dynamic thresholding" method (introduced by Imagen, https://arxiv.org/abs/2205.11487).
-            For pixel-space diffusion models, you can set both `algorithm_type=dpmsolver++` and `thresholding=True` to
-            use the dynamic thresholding. Note that the thresholding method is unsuitable for latent-space diffusion
-            models (such as stable-diffusion).
-        dynamic_thresholding_ratio (`float`, default `0.995`):
-            the ratio for the dynamic thresholding method. Default is `0.995`, the same as Imagen
-            (https://arxiv.org/abs/2205.11487).
-        sample_max_value (`float`, default `1.0`):
-            the threshold value for dynamic thresholding. Valid only when `thresholding=True` and
-            `algorithm_type="dpmsolver++`.
-        algorithm_type (`str`, default `dpmsolver++`):
-            the algorithm type for the solver. Either `dpmsolver` or `dpmsolver++`. The `dpmsolver` type implements the
-            algorithms in https://arxiv.org/abs/2206.00927, and the `dpmsolver++` type implements the algorithms in
-            https://arxiv.org/abs/2211.01095. We recommend to use `dpmsolver++` with `solver_order=2` for guided
-            sampling (e.g. stable-diffusion).
-        solver_type (`str`, default `midpoint`):
-            the solver type for the second-order solver. Either `midpoint` or `heun`. The solver type slightly affects
-            the sample quality, especially for small number of steps. We empirically find that `midpoint` solvers are
-            slightly better, so we recommend to use the `midpoint` type.
-        lower_order_final (`bool`, default `True`):
-            whether to use lower-order solvers in the final steps. For singlestep schedulers, we recommend to enable
-            this to use up all the function evaluations.
-
-    """
-
-    _compatibles = _COMPATIBLE_STABLE_DIFFUSION_SCHEDULERS.copy()
-    order = 1
-
-    @register_to_config
-    def __init__(
-        self,
-        num_train_timesteps: int = 1000,
-        beta_start: float = 0.0001,
-        beta_end: float = 0.02,
-        beta_schedule: str = "linear",
-        trained_betas: Optional[np.ndarray] = None,
-        solver_order: int = 2,
-        prediction_type: str = "epsilon",
-        thresholding: bool = False,
-        dynamic_thresholding_ratio: float = 0.995,
-        sample_max_value: float = 1.0,
-        algorithm_type: str = "dpmsolver++",
-        solver_type: str = "midpoint",
-        lower_order_final: bool = True,
-    ):
-        if trained_betas is not None:
-            self.betas = paddle.to_tensor(trained_betas, dtype=paddle.float32)
-        elif beta_schedule == "linear":
-            self.betas = paddle.linspace(beta_start, beta_end, num_train_timesteps, dtype=paddle.float32)
-        elif beta_schedule == "scaled_linear":
-            # this schedule is very specific to the latent diffusion model.
-            self.betas = (
-                paddle.linspace(beta_start**0.5, beta_end**0.5, num_train_timesteps, dtype=paddle.float32) ** 2
-            )
-        elif beta_schedule == "squaredcos_cap_v2":
-            # Glide cosine schedule
-            self.betas = betas_for_alpha_bar(num_train_timesteps)
-        else:
-            raise NotImplementedError(f"{beta_schedule} does is not implemented for {self.__class__}")
-
-        self.alphas = 1.0 - self.betas
-        self.alphas_cumprod = paddle.cumprod(self.alphas, 0)
-        # Currently we only support VP-type noise schedule
-        self.alpha_t = paddle.sqrt(self.alphas_cumprod)
-        self.sigma_t = paddle.sqrt(1 - self.alphas_cumprod)
-        self.lambda_t = paddle.log(self.alpha_t) - paddle.log(self.sigma_t)
-
-        # standard deviation of the initial noise distribution
-        self.init_noise_sigma = 1.0
-
-        # settings for DPM-Solver
-        if algorithm_type not in ["dpmsolver", "dpmsolver++"]:
-            raise NotImplementedError(f"{algorithm_type} does is not implemented for {self.__class__}")
-        if solver_type not in ["midpoint", "heun"]:
-            raise NotImplementedError(f"{solver_type} does is not implemented for {self.__class__}")
-
-        # setable values
-        self.num_inference_steps = None
-        timesteps = np.linspace(0, num_train_timesteps - 1, num_train_timesteps, dtype=np.float32)[::-1].copy()
-        self.timesteps = paddle.to_tensor(timesteps)
-        self.model_outputs = [None] * solver_order
-        self.sample = None
-        self.order_list = self.get_order_list(num_train_timesteps)
-
-    def get_order_list(self, num_inference_steps: int) -> List[int]:
-        """
-        Computes the solver order at each time step.
-
-        Args:
-            num_inference_steps (`int`):
-                the number of diffusion steps used when generating samples with a pre-trained model.
-        """
-        steps = num_inference_steps
-        order = self.solver_order
-        if self.lower_order_final:
-            if order == 3:
-                if steps % 3 == 0:
-                    orders = [1, 2, 3] * (steps // 3 - 1) + [1, 2] + [1]
-                elif steps % 3 == 1:
-                    orders = [1, 2, 3] * (steps // 3) + [1]
-                else:
-                    orders = [1, 2, 3] * (steps // 3) + [1, 2]
-            elif order == 2:
-                if steps % 2 == 0:
-                    orders = [1, 2] * (steps // 2)
-                else:
-                    orders = [1, 2] * (steps // 2) + [1]
-            elif order == 1:
-                orders = [1] * steps
-        else:
-            if order == 3:
-                orders = [1, 2, 3] * (steps // 3)
-            elif order == 2:
-                orders = [1, 2] * (steps // 2)
-            elif order == 1:
-                orders = [1] * steps
-        return orders
-
-    def set_timesteps(self, num_inference_steps: int):
-        """
-        Sets the timesteps used for the diffusion chain. Supporting function to be run before inference.
-
-        Args:
-            num_inference_steps (`int`):
-                the number of diffusion steps used when generating samples with a pre-trained model.
-        """
-        self.num_inference_steps = num_inference_steps
-        timesteps = (
-            np.linspace(0, self.num_train_timesteps - 1, num_inference_steps + 1)
-            .round()[::-1][:-1]
-            .copy()
-            .astype(np.int64)
-        )
-        self.timesteps = paddle.to_tensor(timesteps)
-        self.model_outputs = [None] * self.config.solver_order
-        self.sample = None
-        self.orders = self.get_order_list(num_inference_steps)
-
-    def convert_model_output(self, model_output: paddle.Tensor, timestep: int, sample: paddle.Tensor) -> paddle.Tensor:
-        """
-        Convert the model output to the corresponding type that the algorithm (DPM-Solver / DPM-Solver++) needs.
-
-        DPM-Solver is designed to discretize an integral of the noise prediction model, and DPM-Solver++ is designed to
-        discretize an integral of the data prediction model. So we need to first convert the model output to the
-        corresponding type to match the algorithm.
-
-        Note that the algorithm type and the model type is decoupled. That is to say, we can use either DPM-Solver or
-        DPM-Solver++ for both noise prediction model and data prediction model.
-
-        Args:
-            model_output (`paddle.Tensor`): direct output from learned diffusion model.
-            timestep (`int`): current discrete timestep in the diffusion chain.
-            sample (`paddle.Tensor`):
-                current instance of sample being created by diffusion process.
-
-        Returns:
-            `paddle.Tensor`: the converted model output.
-        """
-        # DPM-Solver++ needs to solve an integral of the data prediction model.
-        if self.config.algorithm_type == "dpmsolver++":
-            if self.config.prediction_type == "epsilon":
-                alpha_t, sigma_t = self.alpha_t[timestep], self.sigma_t[timestep]
-                x0_pred = (sample - sigma_t * model_output) / alpha_t
-            elif self.config.prediction_type == "sample":
-                x0_pred = model_output
-            elif self.config.prediction_type == "v_prediction":
-                alpha_t, sigma_t = self.alpha_t[timestep], self.sigma_t[timestep]
-                x0_pred = alpha_t * sample - sigma_t * model_output
-            else:
-                raise ValueError(
-                    f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`, or"
-                    " `v_prediction` for the DPMSolverSinglestepScheduler."
-                )
-
-            if self.config.thresholding:
-                # Dynamic thresholding in https://arxiv.org/abs/2205.11487
-                dtype = x0_pred.dtype
-                dynamic_max_val = paddle.quantile(
-                    paddle.abs(x0_pred).reshape((x0_pred.shape[0], -1)).cast("float32"),
-                    self.config.dynamic_thresholding_ratio,
-                    axis=1,
-                )
-                dynamic_max_val = paddle.maximum(
-                    dynamic_max_val,
-                    self.config.sample_max_value * paddle.ones_like(dynamic_max_val),
-                )[(...,) + (None,) * (x0_pred.ndim - 1)]
-                x0_pred = paddle.clip(x0_pred, -dynamic_max_val, dynamic_max_val) / dynamic_max_val
-                x0_pred = x0_pred.cast(dtype)
-            return x0_pred
-        # DPM-Solver needs to solve an integral of the noise prediction model.
-        elif self.config.algorithm_type == "dpmsolver":
-            if self.config.prediction_type == "epsilon":
-                return model_output
-            elif self.config.prediction_type == "sample":
-                alpha_t, sigma_t = self.alpha_t[timestep], self.sigma_t[timestep]
-                epsilon = (sample - alpha_t * model_output) / sigma_t
-                return epsilon
-            elif self.config.prediction_type == "v_prediction":
-                alpha_t, sigma_t = self.alpha_t[timestep], self.sigma_t[timestep]
-                epsilon = alpha_t * model_output + sigma_t * sample
-                return epsilon
-            else:
-                raise ValueError(
-                    f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`, or"
-                    " `v_prediction` for the DPMSolverSinglestepScheduler."
-                )
-
-    def dpm_solver_first_order_update(
-        self,
-        model_output: paddle.Tensor,
-        timestep: int,
-        prev_timestep: int,
-        sample: paddle.Tensor,
-    ) -> paddle.Tensor:
-        """
-        One step for the first-order DPM-Solver (equivalent to DDIM).
-
-        See https://arxiv.org/abs/2206.00927 for the detailed derivation.
-
-        Args:
-            model_output (`paddle.Tensor`): direct output from learned diffusion model.
-            timestep (`int`): current discrete timestep in the diffusion chain.
-            prev_timestep (`int`): previous discrete timestep in the diffusion chain.
-            sample (`paddle.Tensor`):
-                current instance of sample being created by diffusion process.
-
-        Returns:
-            `paddle.Tensor`: the sample tensor at the previous timestep.
-        """
-        lambda_t, lambda_s = self.lambda_t[prev_timestep], self.lambda_t[timestep]
-        alpha_t, alpha_s = self.alpha_t[prev_timestep], self.alpha_t[timestep]
-        sigma_t, sigma_s = self.sigma_t[prev_timestep], self.sigma_t[timestep]
-        h = lambda_t - lambda_s
-        if self.config.algorithm_type == "dpmsolver++":
-            x_t = (sigma_t / sigma_s) * sample - (alpha_t * (paddle.exp(-h) - 1.0)) * model_output
-        elif self.config.algorithm_type == "dpmsolver":
-            x_t = (alpha_t / alpha_s) * sample - (sigma_t * (paddle.exp(h) - 1.0)) * model_output
-        return x_t
-
-    def singlestep_dpm_solver_second_order_update(
-        self,
-        model_output_list: List[paddle.Tensor],
-        timestep_list: List[int],
-        prev_timestep: int,
-        sample: paddle.Tensor,
-    ) -> paddle.Tensor:
-        """
-        One step for the second-order singlestep DPM-Solver.
-
-        It computes the solution at time `prev_timestep` from the time `timestep_list[-2]`.
-
-        Args:
-            model_output_list (`List[paddle.Tensor]`):
-                direct outputs from learned diffusion model at current and latter timesteps.
-            timestep (`int`): current and latter discrete timestep in the diffusion chain.
-            prev_timestep (`int`): previous discrete timestep in the diffusion chain.
-            sample (`paddle.Tensor`):
-                current instance of sample being created by diffusion process.
-
-        Returns:
-            `paddle.Tensor`: the sample tensor at the previous timestep.
-        """
-        t, s0, s1 = prev_timestep, timestep_list[-1], timestep_list[-2]
-        m0, m1 = model_output_list[-1], model_output_list[-2]
-        lambda_t, lambda_s0, lambda_s1 = self.lambda_t[t], self.lambda_t[s0], self.lambda_t[s1]
-        alpha_t, alpha_s1 = self.alpha_t[t], self.alpha_t[s1]
-        sigma_t, sigma_s1 = self.sigma_t[t], self.sigma_t[s1]
-        h, h_0 = lambda_t - lambda_s1, lambda_s0 - lambda_s1
-        r0 = h_0 / h
-        D0, D1 = m1, (1.0 / r0) * (m0 - m1)
-        if self.config.algorithm_type == "dpmsolver++":
-            # See https://arxiv.org/abs/2211.01095 for detailed derivations
-            if self.config.solver_type == "midpoint":
-                x_t = (
-                    (sigma_t / sigma_s1) * sample
-                    - (alpha_t * (paddle.exp(-h) - 1.0)) * D0
-                    - 0.5 * (alpha_t * (paddle.exp(-h) - 1.0)) * D1
-                )
-            elif self.config.solver_type == "heun":
-                x_t = (
-                    (sigma_t / sigma_s1) * sample
-                    - (alpha_t * (paddle.exp(-h) - 1.0)) * D0
-                    + (alpha_t * ((paddle.exp(-h) - 1.0) / h + 1.0)) * D1
-                )
-        elif self.config.algorithm_type == "dpmsolver":
-            # See https://arxiv.org/abs/2206.00927 for detailed derivations
-            if self.config.solver_type == "midpoint":
-                x_t = (
-                    (alpha_t / alpha_s1) * sample
-                    - (sigma_t * (paddle.exp(h) - 1.0)) * D0
-                    - 0.5 * (sigma_t * (paddle.exp(h) - 1.0)) * D1
-                )
-            elif self.config.solver_type == "heun":
-                x_t = (
-                    (alpha_t / alpha_s1) * sample
-                    - (sigma_t * (paddle.exp(h) - 1.0)) * D0
-                    - (sigma_t * ((paddle.exp(h) - 1.0) / h - 1.0)) * D1
-                )
-        return x_t
-
-    def singlestep_dpm_solver_third_order_update(
-        self,
-        model_output_list: List[paddle.Tensor],
-        timestep_list: List[int],
-        prev_timestep: int,
-        sample: paddle.Tensor,
-    ) -> paddle.Tensor:
-        """
-        One step for the third-order singlestep DPM-Solver.
-
-        It computes the solution at time `prev_timestep` from the time `timestep_list[-3]`.
-
-        Args:
-            model_output_list (`List[paddle.Tensor]`):
-                direct outputs from learned diffusion model at current and latter timesteps.
-            timestep (`int`): current and latter discrete timestep in the diffusion chain.
-            prev_timestep (`int`): previous discrete timestep in the diffusion chain.
-            sample (`paddle.Tensor`):
-                current instance of sample being created by diffusion process.
-
-        Returns:
-            `paddle.Tensor`: the sample tensor at the previous timestep.
-        """
-        t, s0, s1, s2 = prev_timestep, timestep_list[-1], timestep_list[-2], timestep_list[-3]
-        m0, m1, m2 = model_output_list[-1], model_output_list[-2], model_output_list[-3]
-        lambda_t, lambda_s0, lambda_s1, lambda_s2 = (
-            self.lambda_t[t],
-            self.lambda_t[s0],
-            self.lambda_t[s1],
-            self.lambda_t[s2],
-        )
-        alpha_t, alpha_s2 = self.alpha_t[t], self.alpha_t[s2]
-        sigma_t, sigma_s2 = self.sigma_t[t], self.sigma_t[s2]
-        h, h_0, h_1 = lambda_t - lambda_s2, lambda_s0 - lambda_s2, lambda_s1 - lambda_s2
-        r0, r1 = h_0 / h, h_1 / h
-        D0 = m2
-        D1_0, D1_1 = (1.0 / r1) * (m1 - m2), (1.0 / r0) * (m0 - m2)
-        D1 = (r0 * D1_0 - r1 * D1_1) / (r0 - r1)
-        D2 = 2.0 * (D1_1 - D1_0) / (r0 - r1)
-        if self.config.algorithm_type == "dpmsolver++":
-            # See https://arxiv.org/abs/2206.00927 for detailed derivations
-            if self.config.solver_type == "midpoint":
-                x_t = (
-                    (sigma_t / sigma_s2) * sample
-                    - (alpha_t * (paddle.exp(-h) - 1.0)) * D0
-                    + (alpha_t * ((paddle.exp(-h) - 1.0) / h + 1.0)) * D1_1
-                )
-            elif self.config.solver_type == "heun":
-                x_t = (
-                    (sigma_t / sigma_s2) * sample
-                    - (alpha_t * (paddle.exp(-h) - 1.0)) * D0
-                    + (alpha_t * ((paddle.exp(-h) - 1.0) / h + 1.0)) * D1
-                    - (alpha_t * ((paddle.exp(-h) - 1.0 + h) / h**2 - 0.5)) * D2
-                )
-        elif self.config.algorithm_type == "dpmsolver":
-            # See https://arxiv.org/abs/2206.00927 for detailed derivations
-            if self.config.solver_type == "midpoint":
-                x_t = (
-                    (alpha_t / alpha_s2) * sample
-                    - (sigma_t * (paddle.exp(h) - 1.0)) * D0
-                    - (sigma_t * ((paddle.exp(h) - 1.0) / h - 1.0)) * D1_1
-                )
-            elif self.config.solver_type == "heun":
-                x_t = (
-                    (alpha_t / alpha_s2) * sample
-                    - (sigma_t * (paddle.exp(h) - 1.0)) * D0
-                    - (sigma_t * ((paddle.exp(h) - 1.0) / h - 1.0)) * D1
-                    - (sigma_t * ((paddle.exp(h) - 1.0 - h) / h**2 - 0.5)) * D2
-                )
-        return x_t
-
-    def singlestep_dpm_solver_update(
-        self,
-        model_output_list: List[paddle.Tensor],
-        timestep_list: List[int],
-        prev_timestep: int,
-        sample: paddle.Tensor,
-        order: int,
-    ) -> paddle.Tensor:
-        """
-        One step for the singlestep DPM-Solver.
-
-        Args:
-            model_output_list (`List[paddle.Tensor]`):
-                direct outputs from learned diffusion model at current and latter timesteps.
-            timestep (`int`): current and latter discrete timestep in the diffusion chain.
-            prev_timestep (`int`): previous discrete timestep in the diffusion chain.
-            sample (`paddle.Tensor`):
-                current instance of sample being created by diffusion process.
-            order (`int`):
-                the solver order at this step.
-
-        Returns:
-            `paddle.Tensor`: the sample tensor at the previous timestep.
-        """
-        if order == 1:
-            return self.dpm_solver_first_order_update(model_output_list[-1], timestep_list[-1], prev_timestep, sample)
-        elif order == 2:
-            return self.singlestep_dpm_solver_second_order_update(
-                model_output_list, timestep_list, prev_timestep, sample
-            )
-        elif order == 3:
-            return self.singlestep_dpm_solver_third_order_update(
-                model_output_list, timestep_list, prev_timestep, sample
-            )
-        else:
-            raise ValueError(f"Order must be 1, 2, 3, got {order}")
-
-    def step(
-        self,
-        model_output: paddle.Tensor,
-        timestep: int,
-        sample: paddle.Tensor,
-        return_dict: bool = True,
-    ) -> Union[SchedulerOutput, Tuple]:
-        """
-        Step function propagating the sample with the singlestep DPM-Solver.
-
-        Args:
-            model_output (`paddle.Tensor`): direct output from learned diffusion model.
-            timestep (`int`): current discrete timestep in the diffusion chain.
-            sample (`paddle.Tensor`):
-                current instance of sample being created by diffusion process.
-            return_dict (`bool`): option for returning tuple rather than SchedulerOutput class
-
-        Returns:
-            [`~scheduling_utils.SchedulerOutput`] or `tuple`: [`~scheduling_utils.SchedulerOutput`] if `return_dict` is
-            True, otherwise a `tuple`. When returning a tuple, the first element is the sample tensor.
-
-        """
-        if self.num_inference_steps is None:
-            raise ValueError(
-                "Number of inference steps is 'None', you need to run 'set_timesteps' after creating the scheduler"
-            )
-
-        step_index = (self.timesteps == timestep).nonzero()
-        if len(step_index) == 0:
-            step_index = len(self.timesteps) - 1
-        else:
-            step_index = step_index.item()
-        prev_timestep = 0 if step_index == len(self.timesteps) - 1 else self.timesteps[step_index + 1]
-
-        model_output = self.convert_model_output(model_output, timestep, sample)
-        for i in range(self.config.solver_order - 1):
-            self.model_outputs[i] = self.model_outputs[i + 1]
-        self.model_outputs[-1] = model_output
-
-        order = self.order_list[step_index]
-        # For single-step solvers, we use the initial value at each time with order = 1.
-        if order == 1:
-            self.sample = sample
-
-        timestep_list = [self.timesteps[step_index - i] for i in range(order - 1, 0, -1)] + [timestep]
-        prev_sample = self.singlestep_dpm_solver_update(
-            self.model_outputs, timestep_list, prev_timestep, self.sample, order
-        )
-
-        if not return_dict:
-            return (prev_sample,)
-
-        return SchedulerOutput(prev_sample=prev_sample)
-
-    def scale_model_input(self, sample: paddle.Tensor, *args, **kwargs) -> paddle.Tensor:
-        """
-        Ensures interchangeability with schedulers that need to scale the denoising model input depending on the
-        current timestep.
-
-        Args:
-            sample (`paddle.Tensor`): input sample
-
-        Returns:
-            `paddle.Tensor`: scaled input sample
-        """
-        return sample
-
-    def add_noise(
-        self,
-        original_samples: paddle.Tensor,
-        noise: paddle.Tensor,
-        timesteps: paddle.Tensor,
-    ) -> paddle.Tensor:
-        # Make sure alphas_cumprod and timestep have same device and dtype as original_samples
-        self.alphas_cumprod = self.alphas_cumprod.cast(original_samples.dtype)
-
-        sqrt_alpha_prod = self.alphas_cumprod[timesteps] ** 0.5
-        sqrt_alpha_prod = sqrt_alpha_prod.flatten()
-        while len(sqrt_alpha_prod.shape) < len(original_samples.shape):
-            sqrt_alpha_prod = sqrt_alpha_prod.unsqueeze(-1)
-
-        sqrt_one_minus_alpha_prod = (1 - self.alphas_cumprod[timesteps]) ** 0.5
-        sqrt_one_minus_alpha_prod = sqrt_one_minus_alpha_prod.flatten()
-        while len(sqrt_one_minus_alpha_prod.shape) < len(original_samples.shape):
-            sqrt_one_minus_alpha_prod = sqrt_one_minus_alpha_prod.unsqueeze(-1)
-
-        noisy_samples = sqrt_alpha_prod * original_samples + sqrt_one_minus_alpha_prod * noise
-        return noisy_samples
-
-    def __len__(self):
-        return self.config.num_train_timesteps

spaces/44ov41za8i/FreeVC/speaker_encoder/config.py

@@ -1,45 +0,0 @@
-librispeech_datasets = {
-    "train": {
-        "clean": ["LibriSpeech/train-clean-100", "LibriSpeech/train-clean-360"],
-        "other": ["LibriSpeech/train-other-500"]
-    },
-    "test": {
-        "clean": ["LibriSpeech/test-clean"],
-        "other": ["LibriSpeech/test-other"]
-    },
-    "dev": {
-        "clean": ["LibriSpeech/dev-clean"],
-        "other": ["LibriSpeech/dev-other"]
-    },
-}
-libritts_datasets = {
-    "train": {
-        "clean": ["LibriTTS/train-clean-100", "LibriTTS/train-clean-360"],
-        "other": ["LibriTTS/train-other-500"]
-    },
-    "test": {
-        "clean": ["LibriTTS/test-clean"],
-        "other": ["LibriTTS/test-other"]
-    },
-    "dev": {
-        "clean": ["LibriTTS/dev-clean"],
-        "other": ["LibriTTS/dev-other"]
-    },
-}
-voxceleb_datasets = {
-    "voxceleb1" : {
-        "train": ["VoxCeleb1/wav"],
-        "test": ["VoxCeleb1/test_wav"]
-    },
-    "voxceleb2" : {
-        "train": ["VoxCeleb2/dev/aac"],
-        "test": ["VoxCeleb2/test_wav"]
-    }
-}
-
-other_datasets = [
-    "LJSpeech-1.1",
-    "VCTK-Corpus/wav48",
-]
-
-anglophone_nationalites = ["australia", "canada", "ireland", "uk", "usa"]

spaces/AB-TW/team-ai/agents/tools/smart_domain/persistent_layer_code_tool.py

@@ -1,55 +0,0 @@
-from langchain import LLMChain, PromptTemplate
-from langchain.agents import tool
-
-from models import llm
-from agents.tools.smart_domain.common import getPrefix
-from agents.tools.smart_domain.db_entity_repository import db_entity_architecture, db_entity_test_strategy
-from agents.tools.smart_domain.association_impl import association_impl_architecture, association_impl_test_strategy
-
-
-persistent_task = """"Your task is to generate the persistent layer tests and product code."""
-persistent_tech_stack = """Java17、reactor、lombok、Junit5、reactor test、Mockito、 Spring Data Reactive Couchbase、Testcontainers、Couchbase、WebClient"""
-persistent_architecture = f"""the persistent layer inclue 3 componets:
-{db_entity_architecture}
-{association_impl_architecture}"""
-
-persistent_test_strategy = f"""{db_entity_test_strategy}
-{association_impl_test_strategy}"""
-
-PERSISTENT_LAYER = getPrefix(persistent_task, persistent_tech_stack, persistent_architecture, persistent_test_strategy) + """
-
-Use the following format:
-request: the request that you need to fulfill include Entity and Association of domain layer
-
-DBEntity:
-```
-the DBEntity code that you write to fulfill the request, follow TechStack and Architecture
-```
-
-Repository:
-```
-the Repository code that you write to fulfill the request, follow TechStack and Architecture
-```
-
-Association Impletation:
-```
-the Association Impletation code that you write to fulfill the request, follow TechStack and Architecture
-```
-
-Test:
-```
-the test code that you write to fulfill the request, follow TechStack Architecture and TestStrategy
-```
-
-request: {input}"""
-
-PERSISTENT_LAYER_PROMPT = PromptTemplate(input_variables=["input"], template=PERSISTENT_LAYER,)
-
-persistentChain = LLMChain(llm = llm(temperature=0.1), prompt=PERSISTENT_LAYER_PROMPT)
-
-
-@tool("Generate Persistent Layer Code", return_direct=True)
-def persistentLayerCodeGenerator(input: str) -> str:
-    '''useful for when you need to generate persistent layer code'''
-    response = persistentChain.run(input)
-    return response

spaces/AE-NV/sentiment-productreview/app.py

@@ -1,20 +0,0 @@
-import gradio as gr
-alias = "Sentiment Analysis on product reviews"
-description = "Add a product review you can find on the internet. The model is trained on multiple languages so you can also test for that!"
-name = "models/nlptown/bert-base-multilingual-uncased-sentiment"
-examples = [
-                ['''We vinden het aanbod heel lekker maar ...
-                    We vinden het aanbod heel lekker.
-                    Wat we wel heel erg spijtig vinden dat is dat er bij zoveel gerechten nog eens een supplement wordt gevraagd.
-                    Jullie prijzen stijgen al regelmatig!
-                    Jullie geven ook wel cadeaus maar nooit voor de gebruikers. Geef ons ook eens af en toe een bonus i.p.v. te proberen méér klanten te krijgen!
-'               '''],
-                ['''Slechte kwaliteit
-                    De maaltijden zijn veel te Nederlands getint, groenten zijn niet vers als ze geleverd worden, vlees is van slechte en goedkope kwaliteit, broodjes die bijgeleverd worden zijn niet lekker.. structuur van een spons..
-                    Ik hoop dat ik zonder probleem het contract kan stopzetten…'''
-                ],
-            ]
-gr.Interface.load(name=name,
-                  alias=alias,
-                  description=description,
-                  examples=examples).launch()

spaces/AIConsultant/MusicGen/model_cards/MUSICGEN_MODEL_CARD.md

@@ -1,90 +0,0 @@
-# MusicGen Model Card
-
-## Model details
-
-**Organization developing the model:** The FAIR team of Meta AI.
-
-**Model date:** MusicGen was trained between April 2023 and May 2023.
-
-**Model version:** This is the version 1 of the model.
-
-**Model type:** MusicGen consists of an EnCodec model for audio tokenization, an auto-regressive language model based on the transformer architecture for music modeling. The model comes in different sizes: 300M, 1.5B and 3.3B parameters ; and two variants: a model trained for text-to-music generation task and a model trained for melody-guided music generation.
-
-**Paper or resources for more information:** More information can be found in the paper [Simple and Controllable Music Generation][arxiv].
-
-**Citation details:** See [our paper][arxiv]
-
-**License:** Code is released under MIT, model weights are released under CC-BY-NC 4.0.
-
-**Where to send questions or comments about the model:** Questions and comments about MusicGen can be sent via the [GitHub repository](https://github.com/facebookresearch/audiocraft) of the project, or by opening an issue.
-
-## Intended use
-**Primary intended use:** The primary use of MusicGen is research on AI-based music generation, including:
-
-- Research efforts, such as probing and better understanding the limitations of generative models to further improve the state of science
-- Generation of music guided by text or melody to understand current abilities of generative AI models by machine learning amateurs
-
-**Primary intended users:** The primary intended users of the model are researchers in audio, machine learning and artificial intelligence, as well as amateur seeking to better understand those models.
-
-**Out-of-scope use cases:** The model should not be used on downstream applications without further risk evaluation and mitigation. The model should not be used to intentionally create or disseminate music pieces that create hostile or alienating environments for people. This includes generating music that people would foreseeably find disturbing, distressing, or offensive; or content that propagates historical or current stereotypes.
-
-## Metrics
-
-**Models performance measures:** We used the following objective measure to evaluate the model on a standard music benchmark:
-
-- Frechet Audio Distance computed on features extracted from a pre-trained audio classifier (VGGish)
-- Kullback-Leibler Divergence on label distributions extracted from a pre-trained audio classifier (PaSST)
-- CLAP Score between audio embedding and text embedding extracted from a pre-trained CLAP model
-
-Additionally, we run qualitative studies with human participants, evaluating the performance of the model with the following axes:
-
-- Overall quality of the music samples;
-- Text relevance to the provided text input;
-- Adherence to the melody for melody-guided music generation.
-
-More details on performance measures and human studies can be found in the paper.
-
-**Decision thresholds:** Not applicable.
-
-## Evaluation datasets
-
-The model was evaluated on the [MusicCaps benchmark](https://www.kaggle.com/datasets/googleai/musiccaps) and on an in-domain held-out evaluation set, with no artist overlap with the training set.
-
-## Training datasets
-
-The model was trained on licensed data using the following sources: the [Meta Music Initiative Sound Collection](https://www.fb.com/sound),  [Shutterstock music collection](https://www.shutterstock.com/music) and the [Pond5 music collection](https://www.pond5.com/). See the paper for more details about the training set and corresponding preprocessing.
-
-## Evaluation results
-
-Below are the objective metrics obtained on MusicCaps with the released model. Note that for the publicly released models, we had all the datasets go through a state-of-the-art music source separation method, namely using the open source [Hybrid Transformer for Music Source Separation](https://github.com/facebookresearch/demucs) (HT-Demucs), in order to keep only the instrumental part. This explains the difference in objective metrics with the models used in the paper.
-
-| Model | Frechet Audio Distance | KLD | Text Consistency | Chroma Cosine Similarity |
-|---|---|---|---|---|
-| facebook/musicgen-small  | 4.88 | 1.28 | 0.27 | - |
-| facebook/musicgen-medium | 5.14 | 1.24 | 0.28 | - |
-| facebook/musicgen-large  | 5.48 | 1.22 | 0.28 | - |
-| facebook/musicgen-melody | 4.93 | 1.26 | 0.27 | 0.44 |
-
-More information can be found in the paper [Simple and Controllable Music Generation][arxiv], in the Results section.
-
-## Limitations and biases
-
-**Data:** The data sources used to train the model are created by music professionals and covered by legal agreements with the right holders. The model is trained on 20K hours of data, we believe that scaling the model on larger datasets can further improve the performance of the model.
-
-**Mitigations:** Vocals have been removed from the data source using corresponding tags, and then using a state-of-the-art music source separation method, namely using the open source [Hybrid Transformer for Music Source Separation](https://github.com/facebookresearch/demucs) (HT-Demucs).
-
-**Limitations:**
-
-- The model is not able to generate realistic vocals.
-- The model has been trained with English descriptions and will not perform as well in other languages.
-- The model does not perform equally well for all music styles and cultures.
-- The model sometimes generates end of songs, collapsing to silence.
-- It is sometimes difficult to assess what types of text descriptions provide the best generations. Prompt engineering may be required to obtain satisfying results.
-
-**Biases:** The source of data is potentially lacking diversity and all music cultures are not equally represented in the dataset. The model may not perform equally well on the wide variety of music genres that exists. The generated samples from the model will reflect the biases from the training data. Further work on this model should include methods for balanced and just representations of cultures, for example, by scaling the training data to be both diverse and inclusive.
-
-**Risks and harms:** Biases and limitations of the model may lead to generation of samples that may be considered as biased, inappropriate or offensive. We believe that providing the code to reproduce the research and train new models will allow to broaden the application to new and more representative data.
-
-**Use cases:** Users must be aware of the biases, limitations and risks of the model. MusicGen is a model developed for artificial intelligence research on controllable music generation. As such, it should not be used for downstream applications without further investigation and mitigation of risks.
-
-[arxiv]: https://arxiv.org/abs/2306.05284

spaces/AIGC-Audio/AudioGPT/NeuralSeq/data_gen/tts/base_binarizer_emotion.py

@@ -1,352 +0,0 @@
-import os
-
-os.environ["OMP_NUM_THREADS"] = "1"
-import torch
-from collections import Counter
-from utils.text_encoder import TokenTextEncoder
-from data_gen.tts.emotion import inference as EmotionEncoder
-from data_gen.tts.emotion.inference import embed_utterance as Embed_utterance
-from data_gen.tts.emotion.inference import preprocess_wav
-from utils.multiprocess_utils import chunked_multiprocess_run
-import random
-import traceback
-import json
-from resemblyzer import VoiceEncoder
-from tqdm import tqdm
-from data_gen.tts.data_gen_utils import get_mel2ph, get_pitch, build_phone_encoder, is_sil_phoneme
-from utils.hparams import hparams, set_hparams
-import numpy as np
-from utils.indexed_datasets import IndexedDatasetBuilder
-from vocoders.base_vocoder import get_vocoder_cls
-import pandas as pd
-
-
-class BinarizationError(Exception):
-    pass
-
-
-class EmotionBinarizer:
-    def __init__(self, processed_data_dir=None):
-        if processed_data_dir is None:
-            processed_data_dir = hparams['processed_data_dir']
-        self.processed_data_dirs = processed_data_dir.split(",")
-        self.binarization_args = hparams['binarization_args']
-        self.pre_align_args = hparams['pre_align_args']
-        self.item2txt = {}
-        self.item2ph = {}
-        self.item2wavfn = {}
-        self.item2tgfn = {}
-        self.item2spk = {}
-        self.item2emo = {}
-
-    def load_meta_data(self):
-        for ds_id, processed_data_dir in enumerate(self.processed_data_dirs):
-            self.meta_df = pd.read_csv(f"{processed_data_dir}/metadata_phone.csv", dtype=str)
-            for r_idx, r in tqdm(self.meta_df.iterrows(), desc='Loading meta data.'):
-                item_name = raw_item_name = r['item_name']
-                if len(self.processed_data_dirs) > 1:
-                    item_name = f'ds{ds_id}_{item_name}'
-                self.item2txt[item_name] = r['txt']
-                self.item2ph[item_name] = r['ph']
-                self.item2wavfn[item_name] = r['wav_fn']
-                self.item2spk[item_name] = r.get('spk_name', 'SPK1') \
-                    if self.binarization_args['with_spk_id'] else 'SPK1'
-                if len(self.processed_data_dirs) > 1:
-                    self.item2spk[item_name] = f"ds{ds_id}_{self.item2spk[item_name]}"
-                self.item2tgfn[item_name] = f"{processed_data_dir}/mfa_outputs/{raw_item_name}.TextGrid"
-                self.item2emo[item_name] = r.get('others', '"Neutral"')
-        self.item_names = sorted(list(self.item2txt.keys()))
-        if self.binarization_args['shuffle']:
-            random.seed(1234)
-            random.shuffle(self.item_names)
-
-    @property
-    def train_item_names(self):
-        return self.item_names[hparams['test_num']:]
-
-    @property
-    def valid_item_names(self):
-        return self.item_names[:hparams['test_num']]
-
-    @property
-    def test_item_names(self):
-        return self.valid_item_names
-
-    def build_spk_map(self):
-        spk_map = set()
-        for item_name in self.item_names:
-            spk_name = self.item2spk[item_name]
-            spk_map.add(spk_name)
-        spk_map = {x: i for i, x in enumerate(sorted(list(spk_map)))}
-        print("| #Spk: ", len(spk_map))
-        assert len(spk_map) == 0 or len(spk_map) <= hparams['num_spk'], len(spk_map)
-        return spk_map
-
-    def build_emo_map(self):
-        emo_map = set()
-        for item_name in self.item_names:
-            emo_name = self.item2emo[item_name]
-            emo_map.add(emo_name)
-        emo_map = {x: i for i, x in enumerate(sorted(list(emo_map)))}
-        print("| #Emo: ", len(emo_map))
-        return emo_map
-
-    def item_name2spk_id(self, item_name):
-        return self.spk_map[self.item2spk[item_name]]
-
-    def item_name2emo_id(self, item_name):
-        return self.emo_map[self.item2emo[item_name]]
-
-    def _phone_encoder(self):
-        ph_set_fn = f"{hparams['binary_data_dir']}/phone_set.json"
-        ph_set = []
-        if self.binarization_args['reset_phone_dict'] or not os.path.exists(ph_set_fn):
-            for ph_sent in self.item2ph.values():
-                ph_set += ph_sent.split(' ')
-            ph_set = sorted(set(ph_set))
-            json.dump(ph_set, open(ph_set_fn, 'w'))
-            print("| Build phone set: ", ph_set)
-        else:
-            ph_set = json.load(open(ph_set_fn, 'r'))
-            print("| Load phone set: ", ph_set)
-        return build_phone_encoder(hparams['binary_data_dir'])
-
-    def _word_encoder(self):
-        fn = f"{hparams['binary_data_dir']}/word_set.json"
-        word_set = []
-        if self.binarization_args['reset_word_dict']:
-            for word_sent in self.item2txt.values():
-                word_set += [x for x in word_sent.split(' ') if x != '']
-            word_set = Counter(word_set)
-            total_words = sum(word_set.values())
-            word_set = word_set.most_common(hparams['word_size'])
-            num_unk_words = total_words - sum([x[1] for x in word_set])
-            word_set = [x[0] for x in word_set]
-            json.dump(word_set, open(fn, 'w'))
-            print(f"| Build word set. Size: {len(word_set)}, #total words: {total_words},"
-                  f" #unk_words: {num_unk_words}, word_set[:10]:, {word_set[:10]}.")
-        else:
-            word_set = json.load(open(fn, 'r'))
-            print("| Load word set. Size: ", len(word_set), word_set[:10])
-        return TokenTextEncoder(None, vocab_list=word_set, replace_oov='<UNK>')
-
-    def meta_data(self, prefix):
-        if prefix == 'valid':
-            item_names = self.valid_item_names
-        elif prefix == 'test':
-            item_names = self.test_item_names
-        else:
-            item_names = self.train_item_names
-        for item_name in item_names:
-            ph = self.item2ph[item_name]
-            txt = self.item2txt[item_name]
-            tg_fn = self.item2tgfn.get(item_name)
-            wav_fn = self.item2wavfn[item_name]
-            spk_id = self.item_name2spk_id(item_name)
-            emotion = self.item_name2emo_id(item_name)
-            yield item_name, ph, txt, tg_fn, wav_fn, spk_id, emotion
-
-    def process(self):
-        self.load_meta_data()
-        os.makedirs(hparams['binary_data_dir'], exist_ok=True)
-        self.spk_map = self.build_spk_map()
-        print("| spk_map: ", self.spk_map)
-        spk_map_fn = f"{hparams['binary_data_dir']}/spk_map.json"
-        json.dump(self.spk_map, open(spk_map_fn, 'w'))
-
-        self.emo_map = self.build_emo_map()
-        print("| emo_map: ", self.emo_map)
-        emo_map_fn = f"{hparams['binary_data_dir']}/emo_map.json"
-        json.dump(self.emo_map, open(emo_map_fn, 'w'))
-
-        self.phone_encoder = self._phone_encoder()
-        self.word_encoder = None
-        EmotionEncoder.load_model(hparams['emotion_encoder_path'])
-
-        if self.binarization_args['with_word']:
-            self.word_encoder = self._word_encoder()
-        self.process_data('valid')
-        self.process_data('test')
-        self.process_data('train')
-
-    def process_data(self, prefix):
-        data_dir = hparams['binary_data_dir']
-        args = []
-        builder = IndexedDatasetBuilder(f'{data_dir}/{prefix}')
-        ph_lengths = []
-        mel_lengths = []
-        f0s = []
-        total_sec = 0
-        if self.binarization_args['with_spk_embed']:
-            voice_encoder = VoiceEncoder().cuda()
-
-        meta_data = list(self.meta_data(prefix))
-        for m in meta_data:
-            args.append(list(m) + [(self.phone_encoder, self.word_encoder), self.binarization_args])
-        num_workers = self.num_workers
-        for f_id, (_, item) in enumerate(
-                zip(tqdm(meta_data), chunked_multiprocess_run(self.process_item, args, num_workers=num_workers))):
-            if item is None:
-                continue
-            item['spk_embed'] = voice_encoder.embed_utterance(item['wav']) \
-                if self.binarization_args['with_spk_embed'] else None
-            processed_wav = preprocess_wav(item['wav_fn'])
-            item['emo_embed'] = Embed_utterance(processed_wav)
-            if not self.binarization_args['with_wav'] and 'wav' in item:
-                del item['wav']
-            builder.add_item(item)
-            mel_lengths.append(item['len'])
-            if 'ph_len' in item:
-                ph_lengths.append(item['ph_len'])
-            total_sec += item['sec']
-            if item.get('f0') is not None:
-                f0s.append(item['f0'])
-        builder.finalize()
-        np.save(f'{data_dir}/{prefix}_lengths.npy', mel_lengths)
-        if len(ph_lengths) > 0:
-            np.save(f'{data_dir}/{prefix}_ph_lengths.npy', ph_lengths)
-        if len(f0s) > 0:
-            f0s = np.concatenate(f0s, 0)
-            f0s = f0s[f0s != 0]
-            np.save(f'{data_dir}/{prefix}_f0s_mean_std.npy', [np.mean(f0s).item(), np.std(f0s).item()])
-        print(f"| {prefix} total duration: {total_sec:.3f}s")
-
-    @classmethod
-    def process_item(cls, item_name, ph, txt, tg_fn, wav_fn, spk_id, emotion, encoder, binarization_args):
-        res = {'item_name': item_name, 'txt': txt, 'ph': ph, 'wav_fn': wav_fn, 'spk_id': spk_id, 'emotion': emotion}
-        if binarization_args['with_linear']:
-            wav, mel, linear_stft = get_vocoder_cls(hparams).wav2spec(wav_fn) # , return_linear=True
-            res['linear'] = linear_stft
-        else:
-            wav, mel = get_vocoder_cls(hparams).wav2spec(wav_fn)
-        wav = wav.astype(np.float16)
-        res.update({'mel': mel, 'wav': wav,
-                    'sec': len(wav) / hparams['audio_sample_rate'], 'len': mel.shape[0]})
-        try:
-            if binarization_args['with_f0']:
-                cls.get_pitch(res)
-                if binarization_args['with_f0cwt']:
-                    cls.get_f0cwt(res)
-            if binarization_args['with_txt']:
-                ph_encoder, word_encoder = encoder
-                try:
-                    res['phone'] = ph_encoder.encode(ph)
-                    res['ph_len'] = len(res['phone'])
-                except:
-                    traceback.print_exc()
-                    raise BinarizationError(f"Empty phoneme")
-                if binarization_args['with_align']:
-                    cls.get_align(tg_fn, res)
-                    if binarization_args['trim_eos_bos']:
-                        bos_dur = res['dur'][0]
-                        eos_dur = res['dur'][-1]
-                        res['mel'] = mel[bos_dur:-eos_dur]
-                        res['f0'] = res['f0'][bos_dur:-eos_dur]
-                        res['pitch'] = res['pitch'][bos_dur:-eos_dur]
-                        res['mel2ph'] = res['mel2ph'][bos_dur:-eos_dur]
-                        res['wav'] = wav[bos_dur * hparams['hop_size']:-eos_dur * hparams['hop_size']]
-                        res['dur'] = res['dur'][1:-1]
-                        res['len'] = res['mel'].shape[0]
-                if binarization_args['with_word']:
-                    cls.get_word(res, word_encoder)
-        except BinarizationError as e:
-            print(f"| Skip item ({e}). item_name: {item_name}, wav_fn: {wav_fn}")
-            return None
-        except Exception as e:
-            traceback.print_exc()
-            print(f"| Skip item. item_name: {item_name}, wav_fn: {wav_fn}")
-            return None
-        return res
-
-    @staticmethod
-    def get_align(tg_fn, res):
-        ph = res['ph']
-        mel = res['mel']
-        phone_encoded = res['phone']
-        if tg_fn is not None and os.path.exists(tg_fn):
-            mel2ph, dur = get_mel2ph(tg_fn, ph, mel, hparams)
-        else:
-            raise BinarizationError(f"Align not found")
-        if mel2ph.max() - 1 >= len(phone_encoded):
-            raise BinarizationError(
-                f"Align does not match: mel2ph.max() - 1: {mel2ph.max() - 1}, len(phone_encoded): {len(phone_encoded)}")
-        res['mel2ph'] = mel2ph
-        res['dur'] = dur
-
-    @staticmethod
-    def get_pitch(res):
-        wav, mel = res['wav'], res['mel']
-        f0, pitch_coarse = get_pitch(wav, mel, hparams)
-        if sum(f0) == 0:
-            raise BinarizationError("Empty f0")
-        res['f0'] = f0
-        res['pitch'] = pitch_coarse
-
-    @staticmethod
-    def get_f0cwt(res):
-        from utils.cwt import get_cont_lf0, get_lf0_cwt
-        f0 = res['f0']
-        uv, cont_lf0_lpf = get_cont_lf0(f0)
-        logf0s_mean_org, logf0s_std_org = np.mean(cont_lf0_lpf), np.std(cont_lf0_lpf)
-        cont_lf0_lpf_norm = (cont_lf0_lpf - logf0s_mean_org) / logf0s_std_org
-        Wavelet_lf0, scales = get_lf0_cwt(cont_lf0_lpf_norm)
-        if np.any(np.isnan(Wavelet_lf0)):
-            raise BinarizationError("NaN CWT")
-        res['cwt_spec'] = Wavelet_lf0
-        res['cwt_scales'] = scales
-        res['f0_mean'] = logf0s_mean_org
-        res['f0_std'] = logf0s_std_org
-
-    @staticmethod
-    def get_word(res, word_encoder):
-        ph_split = res['ph'].split(" ")
-        # ph side mapping to word
-        ph_words = []  # ['<BOS>', 'N_AW1_', ',', 'AE1_Z_|', 'AO1_L_|', 'B_UH1_K_S_|', 'N_AA1_T_|', ....]
-        ph2word = np.zeros([len(ph_split)], dtype=int)
-        last_ph_idx_for_word = []  # [2, 11, ...]
-        for i, ph in enumerate(ph_split):
-            if ph == '|':
-                last_ph_idx_for_word.append(i)
-            elif not ph[0].isalnum():
-                if ph not in ['<BOS>']:
-                    last_ph_idx_for_word.append(i - 1)
-                last_ph_idx_for_word.append(i)
-        start_ph_idx_for_word = [0] + [i + 1 for i in last_ph_idx_for_word[:-1]]
-        for i, (s_w, e_w) in enumerate(zip(start_ph_idx_for_word, last_ph_idx_for_word)):
-            ph_words.append(ph_split[s_w:e_w + 1])
-            ph2word[s_w:e_w + 1] = i
-        ph2word = ph2word.tolist()
-        ph_words = ["_".join(w) for w in ph_words]
-
-        # mel side mapping to word
-        mel2word = []
-        dur_word = [0 for _ in range(len(ph_words))]
-        for i, m2p in enumerate(res['mel2ph']):
-            word_idx = ph2word[m2p - 1]
-            mel2word.append(ph2word[m2p - 1])
-            dur_word[word_idx] += 1
-        ph2word = [x + 1 for x in ph2word]  # 0预留给padding
-        mel2word = [x + 1 for x in mel2word]  # 0预留给padding
-        res['ph_words'] = ph_words  # [T_word]
-        res['ph2word'] = ph2word  # [T_ph]
-        res['mel2word'] = mel2word  # [T_mel]
-        res['dur_word'] = dur_word  # [T_word]
-        words = [x for x in res['txt'].split(" ") if x != '']
-        while len(words) > 0 and is_sil_phoneme(words[0]):
-            words = words[1:]
-        while len(words) > 0 and is_sil_phoneme(words[-1]):
-            words = words[:-1]
-        words = ['<BOS>'] + words + ['<EOS>']
-        word_tokens = word_encoder.encode(" ".join(words))
-        res['words'] = words
-        res['word_tokens'] = word_tokens
-        assert len(words) == len(ph_words), [words, ph_words]
-
-    @property
-    def num_workers(self):
-        return int(os.getenv('N_PROC', hparams.get('N_PROC', os.cpu_count())))
-
-
-if __name__ == "__main__":
-    set_hparams()
-    EmotionBinarizer().process()

spaces/AP123/Upside-Down-Diffusion/README.md

@@ -1,14 +0,0 @@
----
-title: Upside-Down-Diffusion
-emoji: 🙃
-colorFrom: red
-colorTo: indigo
-sdk: gradio
-sdk_version: 3.44.4
-app_file: app.py
-pinned: false
-license: openrail
-hf_oauth: true
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/ATang0729/Forecast4Muses/Model/Model6/Model6_2_ProfileRecogition/mmpretrain/configs/_base_/models/resnet18.py

@@ -1,17 +0,0 @@
-# model settings
-model = dict(
-    type='ImageClassifier',
-    backbone=dict(
-        type='ResNet',
-        depth=18,
-        num_stages=4,
-        out_indices=(3, ),
-        style='pytorch'),
-    neck=dict(type='GlobalAveragePooling'),
-    head=dict(
-        type='LinearClsHead',
-        num_classes=1000,
-        in_channels=512,
-        loss=dict(type='CrossEntropyLoss', loss_weight=1.0),
-        topk=(1, 5),
-    ))

spaces/Abhilashvj/planogram-compliance/utils/loggers/comet/__init__.py

@@ -1,615 +0,0 @@
-import glob
-import json
-import logging
-import os
-import sys
-from pathlib import Path
-
-logger = logging.getLogger(__name__)
-
-FILE = Path(__file__).resolve()
-ROOT = FILE.parents[3]  # YOLOv5 root directory
-if str(ROOT) not in sys.path:
-    sys.path.append(str(ROOT))  # add ROOT to PATH
-
-try:
-    import comet_ml
-
-    # Project Configuration
-    config = comet_ml.config.get_config()
-    COMET_PROJECT_NAME = config.get_string(
-        os.getenv("COMET_PROJECT_NAME"), "comet.project_name", default="yolov5"
-    )
-except (ModuleNotFoundError, ImportError):
-    comet_ml = None
-    COMET_PROJECT_NAME = None
-
-import PIL
-import torch
-import torchvision.transforms as T
-import yaml
-
-from utils.dataloaders import img2label_paths
-from utils.general import check_dataset, scale_boxes, xywh2xyxy
-from utils.metrics import box_iou
-
-COMET_PREFIX = "comet://"
-
-COMET_MODE = os.getenv("COMET_MODE", "online")
-
-# Model Saving Settings
-COMET_MODEL_NAME = os.getenv("COMET_MODEL_NAME", "yolov5")
-
-# Dataset Artifact Settings
-COMET_UPLOAD_DATASET = (
-    os.getenv("COMET_UPLOAD_DATASET", "false").lower() == "true"
-)
-
-# Evaluation Settings
-COMET_LOG_CONFUSION_MATRIX = (
-    os.getenv("COMET_LOG_CONFUSION_MATRIX", "true").lower() == "true"
-)
-COMET_LOG_PREDICTIONS = (
-    os.getenv("COMET_LOG_PREDICTIONS", "true").lower() == "true"
-)
-COMET_MAX_IMAGE_UPLOADS = int(os.getenv("COMET_MAX_IMAGE_UPLOADS", 100))
-
-# Confusion Matrix Settings
-CONF_THRES = float(os.getenv("CONF_THRES", 0.001))
-IOU_THRES = float(os.getenv("IOU_THRES", 0.6))
-
-# Batch Logging Settings
-COMET_LOG_BATCH_METRICS = (
-    os.getenv("COMET_LOG_BATCH_METRICS", "false").lower() == "true"
-)
-COMET_BATCH_LOGGING_INTERVAL = os.getenv("COMET_BATCH_LOGGING_INTERVAL", 1)
-COMET_PREDICTION_LOGGING_INTERVAL = os.getenv(
-    "COMET_PREDICTION_LOGGING_INTERVAL", 1
-)
-COMET_LOG_PER_CLASS_METRICS = (
-    os.getenv("COMET_LOG_PER_CLASS_METRICS", "false").lower() == "true"
-)
-
-RANK = int(os.getenv("RANK", -1))
-
-to_pil = T.ToPILImage()
-
-
-class CometLogger:
-    """Log metrics, parameters, source code, models and much more
-    with Comet
-    """
-
-    def __init__(
-        self, opt, hyp, run_id=None, job_type="Training", **experiment_kwargs
-    ) -> None:
-        self.job_type = job_type
-        self.opt = opt
-        self.hyp = hyp
-
-        # Comet Flags
-        self.comet_mode = COMET_MODE
-
-        self.save_model = opt.save_period > -1
-        self.model_name = COMET_MODEL_NAME
-
-        # Batch Logging Settings
-        self.log_batch_metrics = COMET_LOG_BATCH_METRICS
-        self.comet_log_batch_interval = COMET_BATCH_LOGGING_INTERVAL
-
-        # Dataset Artifact Settings
-        self.upload_dataset = (
-            self.opt.upload_dataset
-            if self.opt.upload_dataset
-            else COMET_UPLOAD_DATASET
-        )
-        self.resume = self.opt.resume
-
-        # Default parameters to pass to Experiment objects
-        self.default_experiment_kwargs = {
-            "log_code": False,
-            "log_env_gpu": True,
-            "log_env_cpu": True,
-            "project_name": COMET_PROJECT_NAME,
-        }
-        self.default_experiment_kwargs.update(experiment_kwargs)
-        self.experiment = self._get_experiment(self.comet_mode, run_id)
-
-        self.data_dict = self.check_dataset(self.opt.data)
-        self.class_names = self.data_dict["names"]
-        self.num_classes = self.data_dict["nc"]
-
-        self.logged_images_count = 0
-        self.max_images = COMET_MAX_IMAGE_UPLOADS
-
-        if run_id is None:
-            self.experiment.log_other("Created from", "YOLOv5")
-            if not isinstance(self.experiment, comet_ml.OfflineExperiment):
-                (
-                    workspace,
-                    project_name,
-                    experiment_id,
-                ) = self.experiment.url.split("/")[-3:]
-                self.experiment.log_other(
-                    "Run Path",
-                    f"{workspace}/{project_name}/{experiment_id}",
-                )
-            self.log_parameters(vars(opt))
-            self.log_parameters(self.opt.hyp)
-            self.log_asset_data(
-                self.opt.hyp,
-                name="hyperparameters.json",
-                metadata={"type": "hyp-config-file"},
-            )
-            self.log_asset(
-                f"{self.opt.save_dir}/opt.yaml",
-                metadata={"type": "opt-config-file"},
-            )
-
-        self.comet_log_confusion_matrix = COMET_LOG_CONFUSION_MATRIX
-
-        if hasattr(self.opt, "conf_thres"):
-            self.conf_thres = self.opt.conf_thres
-        else:
-            self.conf_thres = CONF_THRES
-        if hasattr(self.opt, "iou_thres"):
-            self.iou_thres = self.opt.iou_thres
-        else:
-            self.iou_thres = IOU_THRES
-
-        self.log_parameters(
-            {
-                "val_iou_threshold": self.iou_thres,
-                "val_conf_threshold": self.conf_thres,
-            }
-        )
-
-        self.comet_log_predictions = COMET_LOG_PREDICTIONS
-        if self.opt.bbox_interval == -1:
-            self.comet_log_prediction_interval = (
-                1 if self.opt.epochs < 10 else self.opt.epochs // 10
-            )
-        else:
-            self.comet_log_prediction_interval = self.opt.bbox_interval
-
-        if self.comet_log_predictions:
-            self.metadata_dict = {}
-            self.logged_image_names = []
-
-        self.comet_log_per_class_metrics = COMET_LOG_PER_CLASS_METRICS
-
-        self.experiment.log_others(
-            {
-                "comet_mode": COMET_MODE,
-                "comet_max_image_uploads": COMET_MAX_IMAGE_UPLOADS,
-                "comet_log_per_class_metrics": COMET_LOG_PER_CLASS_METRICS,
-                "comet_log_batch_metrics": COMET_LOG_BATCH_METRICS,
-                "comet_log_confusion_matrix": COMET_LOG_CONFUSION_MATRIX,
-                "comet_model_name": COMET_MODEL_NAME,
-            }
-        )
-
-        # Check if running the Experiment with the Comet Optimizer
-        if hasattr(self.opt, "comet_optimizer_id"):
-            self.experiment.log_other(
-                "optimizer_id", self.opt.comet_optimizer_id
-            )
-            self.experiment.log_other(
-                "optimizer_objective", self.opt.comet_optimizer_objective
-            )
-            self.experiment.log_other(
-                "optimizer_metric", self.opt.comet_optimizer_metric
-            )
-            self.experiment.log_other(
-                "optimizer_parameters", json.dumps(self.hyp)
-            )
-
-    def _get_experiment(self, mode, experiment_id=None):
-        if mode == "offline":
-            if experiment_id is not None:
-                return comet_ml.ExistingOfflineExperiment(
-                    previous_experiment=experiment_id,
-                    **self.default_experiment_kwargs,
-                )
-
-            return comet_ml.OfflineExperiment(
-                **self.default_experiment_kwargs,
-            )
-
-        else:
-            try:
-                if experiment_id is not None:
-                    return comet_ml.ExistingExperiment(
-                        previous_experiment=experiment_id,
-                        **self.default_experiment_kwargs,
-                    )
-
-                return comet_ml.Experiment(**self.default_experiment_kwargs)
-
-            except ValueError:
-                logger.warning(
-                    "COMET WARNING: "
-                    "Comet credentials have not been set. "
-                    "Comet will default to offline logging. "
-                    "Please set your credentials to enable online logging."
-                )
-                return self._get_experiment("offline", experiment_id)
-
-        return
-
-    def log_metrics(self, log_dict, **kwargs):
-        self.experiment.log_metrics(log_dict, **kwargs)
-
-    def log_parameters(self, log_dict, **kwargs):
-        self.experiment.log_parameters(log_dict, **kwargs)
-
-    def log_asset(self, asset_path, **kwargs):
-        self.experiment.log_asset(asset_path, **kwargs)
-
-    def log_asset_data(self, asset, **kwargs):
-        self.experiment.log_asset_data(asset, **kwargs)
-
-    def log_image(self, img, **kwargs):
-        self.experiment.log_image(img, **kwargs)
-
-    def log_model(self, path, opt, epoch, fitness_score, best_model=False):
-        if not self.save_model:
-            return
-
-        model_metadata = {
-            "fitness_score": fitness_score[-1],
-            "epochs_trained": epoch + 1,
-            "save_period": opt.save_period,
-            "total_epochs": opt.epochs,
-        }
-
-        model_files = glob.glob(f"{path}/*.pt")
-        for model_path in model_files:
-            name = Path(model_path).name
-
-            self.experiment.log_model(
-                self.model_name,
-                file_or_folder=model_path,
-                file_name=name,
-                metadata=model_metadata,
-                overwrite=True,
-            )
-
-    def check_dataset(self, data_file):
-        with open(data_file) as f:
-            data_config = yaml.safe_load(f)
-
-        if data_config["path"].startswith(COMET_PREFIX):
-            path = data_config["path"].replace(COMET_PREFIX, "")
-            data_dict = self.download_dataset_artifact(path)
-
-            return data_dict
-
-        self.log_asset(self.opt.data, metadata={"type": "data-config-file"})
-
-        return check_dataset(data_file)
-
-    def log_predictions(self, image, labelsn, path, shape, predn):
-        if self.logged_images_count >= self.max_images:
-            return
-        detections = predn[predn[:, 4] > self.conf_thres]
-        iou = box_iou(labelsn[:, 1:], detections[:, :4])
-        mask, _ = torch.where(iou > self.iou_thres)
-        if len(mask) == 0:
-            return
-
-        filtered_detections = detections[mask]
-        filtered_labels = labelsn[mask]
-
-        image_id = path.split("/")[-1].split(".")[0]
-        image_name = f"{image_id}_curr_epoch_{self.experiment.curr_epoch}"
-        if image_name not in self.logged_image_names:
-            native_scale_image = PIL.Image.open(path)
-            self.log_image(native_scale_image, name=image_name)
-            self.logged_image_names.append(image_name)
-
-        metadata = []
-        for cls, *xyxy in filtered_labels.tolist():
-            metadata.append(
-                {
-                    "label": f"{self.class_names[int(cls)]}-gt",
-                    "score": 100,
-                    "box": {
-                        "x": xyxy[0],
-                        "y": xyxy[1],
-                        "x2": xyxy[2],
-                        "y2": xyxy[3],
-                    },
-                }
-            )
-        for *xyxy, conf, cls in filtered_detections.tolist():
-            metadata.append(
-                {
-                    "label": f"{self.class_names[int(cls)]}",
-                    "score": conf * 100,
-                    "box": {
-                        "x": xyxy[0],
-                        "y": xyxy[1],
-                        "x2": xyxy[2],
-                        "y2": xyxy[3],
-                    },
-                }
-            )
-
-        self.metadata_dict[image_name] = metadata
-        self.logged_images_count += 1
-
-        return
-
-    def preprocess_prediction(self, image, labels, shape, pred):
-        nl, _ = labels.shape[0], pred.shape[0]
-
-        # Predictions
-        if self.opt.single_cls:
-            pred[:, 5] = 0
-
-        predn = pred.clone()
-        scale_boxes(image.shape[1:], predn[:, :4], shape[0], shape[1])
-
-        labelsn = None
-        if nl:
-            tbox = xywh2xyxy(labels[:, 1:5])  # target boxes
-            scale_boxes(
-                image.shape[1:], tbox, shape[0], shape[1]
-            )  # native-space labels
-            labelsn = torch.cat(
-                (labels[:, 0:1], tbox), 1
-            )  # native-space labels
-            scale_boxes(
-                image.shape[1:], predn[:, :4], shape[0], shape[1]
-            )  # native-space pred
-
-        return predn, labelsn
-
-    def add_assets_to_artifact(self, artifact, path, asset_path, split):
-        img_paths = sorted(glob.glob(f"{asset_path}/*"))
-        label_paths = img2label_paths(img_paths)
-
-        for image_file, label_file in zip(img_paths, label_paths):
-            image_logical_path, label_logical_path = map(
-                lambda x: os.path.relpath(x, path), [image_file, label_file]
-            )
-
-            try:
-                artifact.add(
-                    image_file,
-                    logical_path=image_logical_path,
-                    metadata={"split": split},
-                )
-                artifact.add(
-                    label_file,
-                    logical_path=label_logical_path,
-                    metadata={"split": split},
-                )
-            except ValueError as e:
-                logger.error(
-                    "COMET ERROR: Error adding file to Artifact. Skipping file."
-                )
-                logger.error(f"COMET ERROR: {e}")
-                continue
-
-        return artifact
-
-    def upload_dataset_artifact(self):
-        dataset_name = self.data_dict.get("dataset_name", "yolov5-dataset")
-        path = str((ROOT / Path(self.data_dict["path"])).resolve())
-
-        metadata = self.data_dict.copy()
-        for key in ["train", "val", "test"]:
-            split_path = metadata.get(key)
-            if split_path is not None:
-                metadata[key] = split_path.replace(path, "")
-
-        artifact = comet_ml.Artifact(
-            name=dataset_name, artifact_type="dataset", metadata=metadata
-        )
-        for key in metadata.keys():
-            if key in ["train", "val", "test"]:
-                if isinstance(self.upload_dataset, str) and (
-                    key != self.upload_dataset
-                ):
-                    continue
-
-                asset_path = self.data_dict.get(key)
-                if asset_path is not None:
-                    artifact = self.add_assets_to_artifact(
-                        artifact, path, asset_path, key
-                    )
-
-        self.experiment.log_artifact(artifact)
-
-        return
-
-    def download_dataset_artifact(self, artifact_path):
-        logged_artifact = self.experiment.get_artifact(artifact_path)
-        artifact_save_dir = str(Path(self.opt.save_dir) / logged_artifact.name)
-        logged_artifact.download(artifact_save_dir)
-
-        metadata = logged_artifact.metadata
-        data_dict = metadata.copy()
-        data_dict["path"] = artifact_save_dir
-
-        metadata_names = metadata.get("names")
-        if type(metadata_names) == dict:
-            data_dict["names"] = {
-                int(k): v for k, v in metadata.get("names").items()
-            }
-        elif type(metadata_names) == list:
-            data_dict["names"] = {
-                int(k): v
-                for k, v in zip(range(len(metadata_names)), metadata_names)
-            }
-        else:
-            raise "Invalid 'names' field in dataset yaml file. Please use a list or dictionary"
-
-        data_dict = self.update_data_paths(data_dict)
-        return data_dict
-
-    def update_data_paths(self, data_dict):
-        path = data_dict.get("path", "")
-
-        for split in ["train", "val", "test"]:
-            if data_dict.get(split):
-                split_path = data_dict.get(split)
-                data_dict[split] = (
-                    f"{path}/{split_path}"
-                    if isinstance(split, str)
-                    else [f"{path}/{x}" for x in split_path]
-                )
-
-        return data_dict
-
-    def on_pretrain_routine_end(self, paths):
-        if self.opt.resume:
-            return
-
-        for path in paths:
-            self.log_asset(str(path))
-
-        if self.upload_dataset:
-            if not self.resume:
-                self.upload_dataset_artifact()
-
-        return
-
-    def on_train_start(self):
-        self.log_parameters(self.hyp)
-
-    def on_train_epoch_start(self):
-        return
-
-    def on_train_epoch_end(self, epoch):
-        self.experiment.curr_epoch = epoch
-
-        return
-
-    def on_train_batch_start(self):
-        return
-
-    def on_train_batch_end(self, log_dict, step):
-        self.experiment.curr_step = step
-        if self.log_batch_metrics and (
-            step % self.comet_log_batch_interval == 0
-        ):
-            self.log_metrics(log_dict, step=step)
-
-        return
-
-    def on_train_end(self, files, save_dir, last, best, epoch, results):
-        if self.comet_log_predictions:
-            curr_epoch = self.experiment.curr_epoch
-            self.experiment.log_asset_data(
-                self.metadata_dict, "image-metadata.json", epoch=curr_epoch
-            )
-
-        for f in files:
-            self.log_asset(f, metadata={"epoch": epoch})
-        self.log_asset(f"{save_dir}/results.csv", metadata={"epoch": epoch})
-
-        if not self.opt.evolve:
-            model_path = str(best if best.exists() else last)
-            name = Path(model_path).name
-            if self.save_model:
-                self.experiment.log_model(
-                    self.model_name,
-                    file_or_folder=model_path,
-                    file_name=name,
-                    overwrite=True,
-                )
-
-        # Check if running Experiment with Comet Optimizer
-        if hasattr(self.opt, "comet_optimizer_id"):
-            metric = results.get(self.opt.comet_optimizer_metric)
-            self.experiment.log_other("optimizer_metric_value", metric)
-
-        self.finish_run()
-
-    def on_val_start(self):
-        return
-
-    def on_val_batch_start(self):
-        return
-
-    def on_val_batch_end(
-        self, batch_i, images, targets, paths, shapes, outputs
-    ):
-        if not (
-            self.comet_log_predictions
-            and ((batch_i + 1) % self.comet_log_prediction_interval == 0)
-        ):
-            return
-
-        for si, pred in enumerate(outputs):
-            if len(pred) == 0:
-                continue
-
-            image = images[si]
-            labels = targets[targets[:, 0] == si, 1:]
-            shape = shapes[si]
-            path = paths[si]
-            predn, labelsn = self.preprocess_prediction(
-                image, labels, shape, pred
-            )
-            if labelsn is not None:
-                self.log_predictions(image, labelsn, path, shape, predn)
-
-        return
-
-    def on_val_end(
-        self, nt, tp, fp, p, r, f1, ap, ap50, ap_class, confusion_matrix
-    ):
-        if self.comet_log_per_class_metrics:
-            if self.num_classes > 1:
-                for i, c in enumerate(ap_class):
-                    class_name = self.class_names[c]
-                    self.experiment.log_metrics(
-                        {
-                            "[email protected]": ap50[i],
-                            "[email protected]:.95": ap[i],
-                            "precision": p[i],
-                            "recall": r[i],
-                            "f1": f1[i],
-                            "true_positives": tp[i],
-                            "false_positives": fp[i],
-                            "support": nt[c],
-                        },
-                        prefix=class_name,
-                    )
-
-        if self.comet_log_confusion_matrix:
-            epoch = self.experiment.curr_epoch
-            class_names = list(self.class_names.values())
-            class_names.append("background")
-            num_classes = len(class_names)
-
-            self.experiment.log_confusion_matrix(
-                matrix=confusion_matrix.matrix,
-                max_categories=num_classes,
-                labels=class_names,
-                epoch=epoch,
-                column_label="Actual Category",
-                row_label="Predicted Category",
-                file_name=f"confusion-matrix-epoch-{epoch}.json",
-            )
-
-    def on_fit_epoch_end(self, result, epoch):
-        self.log_metrics(result, epoch=epoch)
-
-    def on_model_save(self, last, epoch, final_epoch, best_fitness, fi):
-        if (
-            (epoch + 1) % self.opt.save_period == 0 and not final_epoch
-        ) and self.opt.save_period != -1:
-            self.log_model(
-                last.parent, self.opt, epoch, fi, best_model=best_fitness == fi
-            )
-
-    def on_params_update(self, params):
-        self.log_parameters(params)
-
-    def finish_run(self):
-        self.experiment.end()

spaces/Abrish-Aadi/Chest-Xray-anomaly-detection/app.py

@@ -1,40 +0,0 @@
-import gradio as gr
-import tensorflow as tf
-import os
-import numpy as np
-
-model=tf.keras.models.load_model('model.h5')
-
-LABELS = ['NORMAL', 'TUBERCULOSIS', 'PNEUMONIA', 'COVID19']
-
-def predict_input_image(img):
-  img_4d=img.reshape(-1,128,128,3)/255.0
-  print(img_4d.min())
-  print(img_4d.max())
-  prediction=model.predict(img_4d)[0]
-  return {LABELS[i]: float(prediction[i]) for i in range(4)}
-
-def k():
-  return gr.update(value=None)
-
-with gr.Blocks(title="Chest X-Ray Anomaly Detection", css="") as demo:
-    with gr.Row():
-        textmd = gr.Markdown('''
-    # Chest X-Ray Anomaly Detection
-    ''')
-    with gr.Row():
-        with gr.Column(scale=1, min_width=600):
-              image = gr.inputs.Image(shape=(128,128))
-        with gr.Row():
-            clear_btn = gr.Button("Clear")
-            submit_btn = gr.Button("Submit", elem_id="warningk", variant='primary')
-        examples = gr.Examples(examples=["COVID19(573).jpg",
-                                       "NORMAL2-IM-1345-0001-0002.jpeg",
-                                       "person1946_bacteria_4875.jpeg",
-                                       "Tuberculosis-658.png"], inputs=image)
-    label = gr.outputs.Label(num_top_classes=4)
-    
-    clear_btn.click(k, inputs=[], outputs=image)
-    submit_btn.click(predict_input_image, inputs=image, outputs=label)
-
-demo.launch()

spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/basesizer/FadeMethods.js

@@ -1,86 +0,0 @@
-import { FadeIn, FadeOutDestroy } from '../fade/Fade.js';
-import { WaitComplete } from '../utils/WaitEvent.js';
-import GetParentSizerMethods from './GetParentSizerMethods.js';
-
-const IsPlainObject = Phaser.Utils.Objects.IsPlainObject;
-
-var OnInitFade = function (gameObject, fade) {
-    // Route 'complete' of fade to gameObject
-    fade.completeEventName = undefined;
-    fade.on('complete', function () {
-        if (fade.completeEventName) {
-            gameObject.emit(fade.completeEventName, gameObject);
-            fade.completeEventName = undefined;
-        }
-    })
-
-    // Update local state
-    fade.on('update', function () {
-        var parent = GetParentSizerMethods.getParentSizer(gameObject);
-        if (parent) {
-            parent.resetChildAlphaState(gameObject);
-        }
-    })
-}
-
-export default {
-    fadeIn(duration, alpha) {
-        if (IsPlainObject(duration)) {
-            var config = duration;
-            duration = config.duration;
-            alpha = config.alpha;
-        }
-
-        var isInit = (this._fade === undefined);
-
-        this._fade = FadeIn(this, duration, alpha, this._fade);
-
-        if (isInit) {
-            OnInitFade(this, this._fade);
-        }
-
-        this._fade.completeEventName = 'fadein.complete';
-
-        return this;
-    },
-
-    fadeInPromise(duration, alpha) {
-        this.fadeIn(duration, alpha);
-        return WaitComplete(this._fade);
-    },
-
-    fadeOutDestroy(duration, destroyMode) {
-        if (IsPlainObject(duration)) {
-            var config = duration;
-            duration = config.duration;
-            destroyMode = config.destroy;
-        }
-
-        var isInit = (this._fade === undefined);
-
-        this._fade = FadeOutDestroy(this, duration, destroyMode, this._fade);
-
-        if (isInit) {
-            OnInitFade(this, this._fade);
-        }
-
-        this._fade.completeEventName = 'fadeout.complete';
-
-        return this;
-    },
-
-    fadeOutDestroyPromise(duration, destroyMode) {
-        this.fadeOutDestroy(duration, destroyMode);
-        return WaitComplete(this._fade);
-    },
-
-    fadeOut(duration) {
-        this.fadeOutDestroy(duration, false);
-        return this;
-    },
-
-    fadeOutPromise(duration) {
-        this.fadeOut(duration);
-        return WaitComplete(this._fade);
-    }
-}

spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/scrollbar/Factory.d.ts

@@ -1,5 +0,0 @@
-import ScrollBar from './ScrollBar';
-
-export default function (
-    config?: ScrollBar.IConfig
-): ScrollBar;

spaces/Amrrs/DragGan-Inversion/PTI/torch_utils/ops/bias_act.cpp

@@ -1,99 +0,0 @@
-// Copyright (c) 2021, NVIDIA CORPORATION.  All rights reserved.
-//
-// NVIDIA CORPORATION and its licensors retain all intellectual property
-// and proprietary rights in and to this software, related documentation
-// and any modifications thereto.  Any use, reproduction, disclosure or
-// distribution of this software and related documentation without an express
-// license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-#include <torch/extension.h>
-#include <ATen/cuda/CUDAContext.h>
-#include <c10/cuda/CUDAGuard.h>
-#include "bias_act.h"
-
-//------------------------------------------------------------------------
-
-static bool has_same_layout(torch::Tensor x, torch::Tensor y)
-{
-    if (x.dim() != y.dim())
-        return false;
-    for (int64_t i = 0; i < x.dim(); i++)
-    {
-        if (x.size(i) != y.size(i))
-            return false;
-        if (x.size(i) >= 2 && x.stride(i) != y.stride(i))
-            return false;
-    }
-    return true;
-}
-
-//------------------------------------------------------------------------
-
-static torch::Tensor bias_act(torch::Tensor x, torch::Tensor b, torch::Tensor xref, torch::Tensor yref, torch::Tensor dy, int grad, int dim, int act, float alpha, float gain, float clamp)
-{
-    // Validate arguments.
-    TORCH_CHECK(x.is_cuda(), "x must reside on CUDA device");
-    TORCH_CHECK(b.numel() == 0 || (b.dtype() == x.dtype() && b.device() == x.device()), "b must have the same dtype and device as x");
-    TORCH_CHECK(xref.numel() == 0 || (xref.sizes() == x.sizes() && xref.dtype() == x.dtype() && xref.device() == x.device()), "xref must have the same shape, dtype, and device as x");
-    TORCH_CHECK(yref.numel() == 0 || (yref.sizes() == x.sizes() && yref.dtype() == x.dtype() && yref.device() == x.device()), "yref must have the same shape, dtype, and device as x");
-    TORCH_CHECK(dy.numel() == 0 || (dy.sizes() == x.sizes() && dy.dtype() == x.dtype() && dy.device() == x.device()), "dy must have the same dtype and device as x");
-    TORCH_CHECK(x.numel() <= INT_MAX, "x is too large");
-    TORCH_CHECK(b.dim() == 1, "b must have rank 1");
-    TORCH_CHECK(b.numel() == 0 || (dim >= 0 && dim < x.dim()), "dim is out of bounds");
-    TORCH_CHECK(b.numel() == 0 || b.numel() == x.size(dim), "b has wrong number of elements");
-    TORCH_CHECK(grad >= 0, "grad must be non-negative");
-
-    // Validate layout.
-    TORCH_CHECK(x.is_non_overlapping_and_dense(), "x must be non-overlapping and dense");
-    TORCH_CHECK(b.is_contiguous(), "b must be contiguous");
-    TORCH_CHECK(xref.numel() == 0 || has_same_layout(xref, x), "xref must have the same layout as x");
-    TORCH_CHECK(yref.numel() == 0 || has_same_layout(yref, x), "yref must have the same layout as x");
-    TORCH_CHECK(dy.numel() == 0 || has_same_layout(dy, x), "dy must have the same layout as x");
-
-    // Create output tensor.
-    const at::cuda::OptionalCUDAGuard device_guard(device_of(x));
-    torch::Tensor y = torch::empty_like(x);
-    TORCH_CHECK(has_same_layout(y, x), "y must have the same layout as x");
-
-    // Initialize CUDA kernel parameters.
-    bias_act_kernel_params p;
-    p.x     = x.data_ptr();
-    p.b     = (b.numel()) ? b.data_ptr() : NULL;
-    p.xref  = (xref.numel()) ? xref.data_ptr() : NULL;
-    p.yref  = (yref.numel()) ? yref.data_ptr() : NULL;
-    p.dy    = (dy.numel()) ? dy.data_ptr() : NULL;
-    p.y     = y.data_ptr();
-    p.grad  = grad;
-    p.act   = act;
-    p.alpha = alpha;
-    p.gain  = gain;
-    p.clamp = clamp;
-    p.sizeX = (int)x.numel();
-    p.sizeB = (int)b.numel();
-    p.stepB = (b.numel()) ? (int)x.stride(dim) : 1;
-
-    // Choose CUDA kernel.
-    void* kernel;
-    AT_DISPATCH_FLOATING_TYPES_AND_HALF(x.scalar_type(), "upfirdn2d_cuda", [&]
-    {
-        kernel = choose_bias_act_kernel<scalar_t>(p);
-    });
-    TORCH_CHECK(kernel, "no CUDA kernel found for the specified activation func");
-
-    // Launch CUDA kernel.
-    p.loopX = 4;
-    int blockSize = 4 * 32;
-    int gridSize = (p.sizeX - 1) / (p.loopX * blockSize) + 1;
-    void* args[] = {&p};
-    AT_CUDA_CHECK(cudaLaunchKernel(kernel, gridSize, blockSize, args, 0, at::cuda::getCurrentCUDAStream()));
-    return y;
-}
-
-//------------------------------------------------------------------------
-
-PYBIND11_MODULE(TORCH_EXTENSION_NAME, m)
-{
-    m.def("bias_act", &bias_act);
-}
-
-//------------------------------------------------------------------------

spaces/Amrrs/DragGan-Inversion/stylegan_human/torch_utils/op_edit/upfirdn2d.py

@@ -1,206 +0,0 @@
-# Copyright (c) SenseTime Research. All rights reserved.
-
-import os
-
-import torch
-from torch.nn import functional as F
-from torch.autograd import Function
-from torch.utils.cpp_extension import load
-
-
-module_path = os.path.dirname(__file__)
-upfirdn2d_op = load(
-    "upfirdn2d",
-    sources=[
-        os.path.join(module_path, "upfirdn2d.cpp"),
-        os.path.join(module_path, "upfirdn2d_kernel.cu"),
-    ],
-)
-
-
-class UpFirDn2dBackward(Function):
-    @staticmethod
-    def forward(
-        ctx, grad_output, kernel, grad_kernel, up, down, pad, g_pad, in_size, out_size
-    ):
-
-        up_x, up_y = up
-        down_x, down_y = down
-        g_pad_x0, g_pad_x1, g_pad_y0, g_pad_y1 = g_pad
-
-        grad_output = grad_output.reshape(-1, out_size[0], out_size[1], 1)
-
-        grad_input = upfirdn2d_op.upfirdn2d(
-            grad_output,
-            grad_kernel,
-            down_x,
-            down_y,
-            up_x,
-            up_y,
-            g_pad_x0,
-            g_pad_x1,
-            g_pad_y0,
-            g_pad_y1,
-        )
-        grad_input = grad_input.view(
-            in_size[0], in_size[1], in_size[2], in_size[3])
-
-        ctx.save_for_backward(kernel)
-
-        pad_x0, pad_x1, pad_y0, pad_y1 = pad
-
-        ctx.up_x = up_x
-        ctx.up_y = up_y
-        ctx.down_x = down_x
-        ctx.down_y = down_y
-        ctx.pad_x0 = pad_x0
-        ctx.pad_x1 = pad_x1
-        ctx.pad_y0 = pad_y0
-        ctx.pad_y1 = pad_y1
-        ctx.in_size = in_size
-        ctx.out_size = out_size
-
-        return grad_input
-
-    @staticmethod
-    def backward(ctx, gradgrad_input):
-        (kernel,) = ctx.saved_tensors
-
-        gradgrad_input = gradgrad_input.reshape(-1,
-                                                ctx.in_size[2], ctx.in_size[3], 1)
-
-        gradgrad_out = upfirdn2d_op.upfirdn2d(
-            gradgrad_input,
-            kernel,
-            ctx.up_x,
-            ctx.up_y,
-            ctx.down_x,
-            ctx.down_y,
-            ctx.pad_x0,
-            ctx.pad_x1,
-            ctx.pad_y0,
-            ctx.pad_y1,
-        )
-        # gradgrad_out = gradgrad_out.view(ctx.in_size[0], ctx.out_size[0], ctx.out_size[1], ctx.in_size[3])
-        gradgrad_out = gradgrad_out.view(
-            ctx.in_size[0], ctx.in_size[1], ctx.out_size[0], ctx.out_size[1]
-        )
-
-        return gradgrad_out, None, None, None, None, None, None, None, None
-
-
-class UpFirDn2d(Function):
-    @staticmethod
-    def forward(ctx, input, kernel, up, down, pad):
-        up_x, up_y = up
-        down_x, down_y = down
-        pad_x0, pad_x1, pad_y0, pad_y1 = pad
-
-        kernel_h, kernel_w = kernel.shape
-        batch, channel, in_h, in_w = input.shape
-        ctx.in_size = input.shape
-
-        input = input.reshape(-1, in_h, in_w, 1)
-
-        ctx.save_for_backward(kernel, torch.flip(kernel, [0, 1]))
-
-        out_h = (in_h * up_y + pad_y0 + pad_y1 - kernel_h) // down_y + 1
-        out_w = (in_w * up_x + pad_x0 + pad_x1 - kernel_w) // down_x + 1
-        ctx.out_size = (out_h, out_w)
-
-        ctx.up = (up_x, up_y)
-        ctx.down = (down_x, down_y)
-        ctx.pad = (pad_x0, pad_x1, pad_y0, pad_y1)
-
-        g_pad_x0 = kernel_w - pad_x0 - 1
-        g_pad_y0 = kernel_h - pad_y0 - 1
-        g_pad_x1 = in_w * up_x - out_w * down_x + pad_x0 - up_x + 1
-        g_pad_y1 = in_h * up_y - out_h * down_y + pad_y0 - up_y + 1
-
-        ctx.g_pad = (g_pad_x0, g_pad_x1, g_pad_y0, g_pad_y1)
-
-        out = upfirdn2d_op.upfirdn2d(
-            input, kernel, up_x, up_y, down_x, down_y, pad_x0, pad_x1, pad_y0, pad_y1
-        )
-        # out = out.view(major, out_h, out_w, minor)
-        out = out.view(-1, channel, out_h, out_w)
-
-        return out
-
-    @staticmethod
-    def backward(ctx, grad_output):
-        kernel, grad_kernel = ctx.saved_tensors
-
-        grad_input = UpFirDn2dBackward.apply(
-            grad_output,
-            kernel,
-            grad_kernel,
-            ctx.up,
-            ctx.down,
-            ctx.pad,
-            ctx.g_pad,
-            ctx.in_size,
-            ctx.out_size,
-        )
-
-        return grad_input, None, None, None, None
-
-
-def upfirdn2d(input, kernel, up=1, down=1, pad=(0, 0)):
-    if input.device.type == "cpu":
-        out = upfirdn2d_native(
-            input, kernel, up, up, down, down, pad[0], pad[1], pad[0], pad[1]
-        )
-
-    else:
-        out = UpFirDn2d.apply(
-            input, kernel, (up, up), (down,
-                                      down), (pad[0], pad[1], pad[0], pad[1])
-        )
-
-    return out
-
-
-def upfirdn2d_native(
-    input, kernel, up_x, up_y, down_x, down_y, pad_x0, pad_x1, pad_y0, pad_y1
-):
-    _, channel, in_h, in_w = input.shape
-    input = input.reshape(-1, in_h, in_w, 1)
-
-    _, in_h, in_w, minor = input.shape
-    kernel_h, kernel_w = kernel.shape
-
-    out = input.view(-1, in_h, 1, in_w, 1, minor)
-    out = F.pad(out, [0, 0, 0, up_x - 1, 0, 0, 0, up_y - 1])
-    out = out.view(-1, in_h * up_y, in_w * up_x, minor)
-
-    out = F.pad(
-        out, [0, 0, max(pad_x0, 0), max(pad_x1, 0),
-              max(pad_y0, 0), max(pad_y1, 0)]
-    )
-    out = out[
-        :,
-        max(-pad_y0, 0): out.shape[1] - max(-pad_y1, 0),
-        max(-pad_x0, 0): out.shape[2] - max(-pad_x1, 0),
-        :,
-    ]
-
-    out = out.permute(0, 3, 1, 2)
-    out = out.reshape(
-        [-1, 1, in_h * up_y + pad_y0 + pad_y1, in_w * up_x + pad_x0 + pad_x1]
-    )
-    w = torch.flip(kernel, [0, 1]).view(1, 1, kernel_h, kernel_w)
-    out = F.conv2d(out, w)
-    out = out.reshape(
-        -1,
-        minor,
-        in_h * up_y + pad_y0 + pad_y1 - kernel_h + 1,
-        in_w * up_x + pad_x0 + pad_x1 - kernel_w + 1,
-    )
-    out = out.permute(0, 2, 3, 1)
-    out = out[:, ::down_y, ::down_x, :]
-
-    out_h = (in_h * up_y + pad_y0 + pad_y1 - kernel_h) // down_y + 1
-    out_w = (in_w * up_x + pad_x0 + pad_x1 - kernel_w) // down_x + 1
-
-    return out.view(-1, channel, out_h, out_w)

spaces/Andy1621/uniformer_image_detection/configs/gcnet/mask_rcnn_r50_fpn_r16_gcb_c3-c5_1x_coco.py

@@ -1,8 +0,0 @@
-_base_ = '../mask_rcnn/mask_rcnn_r50_fpn_1x_coco.py'
-model = dict(
-    backbone=dict(plugins=[
-        dict(
-            cfg=dict(type='ContextBlock', ratio=1. / 16),
-            stages=(False, True, True, True),
-            position='after_conv3')
-    ]))

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

@@ -1,25 +0,0 @@
-# Rethinking ImageNet Pre-training
-
-## Introduction
-
-[ALGORITHM]
-
-```latex
-@article{he2018rethinking,
-  title={Rethinking imagenet pre-training},
-  author={He, Kaiming and Girshick, Ross and Doll{\'a}r, Piotr},
-  journal={arXiv preprint arXiv:1811.08883},
-  year={2018}
-}
-```
-
-## Results and Models
-
-| Model        | Backbone  | Style   | Lr schd | box AP | mask AP | Config | Download |
-|:------------:|:---------:|:-------:|:-------:|:------:|:-------:|:------:|:--------:|
-| Faster R-CNN | R-50-FPN  | pytorch | 6x      | 40.7   |         | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/scratch/faster_rcnn_r50_fpn_gn-all_scratch_6x_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/scratch/faster_rcnn_r50_fpn_gn-all_scratch_6x_coco/scratch_faster_rcnn_r50_fpn_gn_6x_bbox_mAP-0.407_20200201_193013-90813d01.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/scratch/faster_rcnn_r50_fpn_gn-all_scratch_6x_coco/scratch_faster_rcnn_r50_fpn_gn_6x_20200201_193013.log.json) |
-| Mask R-CNN   | R-50-FPN  | pytorch | 6x      | 41.2   | 37.4    | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/scratch/mask_rcnn_r50_fpn_gn-all_scratch_6x_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/scratch/mask_rcnn_r50_fpn_gn-all_scratch_6x_coco/scratch_mask_rcnn_r50_fpn_gn_6x_bbox_mAP-0.412__segm_mAP-0.374_20200201_193051-1e190a40.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/scratch/mask_rcnn_r50_fpn_gn-all_scratch_6x_coco/scratch_mask_rcnn_r50_fpn_gn_6x_20200201_193051.log.json)  |
-
-Note:
-
-- The above models are trained with 16 GPUs.

spaces/Andy1621/uniformer_image_detection/mmdet/models/losses/smooth_l1_loss.py

@@ -1,139 +0,0 @@
-import mmcv
-import torch
-import torch.nn as nn
-
-from ..builder import LOSSES
-from .utils import weighted_loss
-
-
-@mmcv.jit(derivate=True, coderize=True)
-@weighted_loss
-def smooth_l1_loss(pred, target, beta=1.0):
-    """Smooth L1 loss.
-
-    Args:
-        pred (torch.Tensor): The prediction.
-        target (torch.Tensor): The learning target of the prediction.
-        beta (float, optional): The threshold in the piecewise function.
-            Defaults to 1.0.
-
-    Returns:
-        torch.Tensor: Calculated loss
-    """
-    assert beta > 0
-    assert pred.size() == target.size() and target.numel() > 0
-    diff = torch.abs(pred - target)
-    loss = torch.where(diff < beta, 0.5 * diff * diff / beta,
-                       diff - 0.5 * beta)
-    return loss
-
-
-@mmcv.jit(derivate=True, coderize=True)
-@weighted_loss
-def l1_loss(pred, target):
-    """L1 loss.
-
-    Args:
-        pred (torch.Tensor): The prediction.
-        target (torch.Tensor): The learning target of the prediction.
-
-    Returns:
-        torch.Tensor: Calculated loss
-    """
-    assert pred.size() == target.size() and target.numel() > 0
-    loss = torch.abs(pred - target)
-    return loss
-
-
-@LOSSES.register_module()
-class SmoothL1Loss(nn.Module):
-    """Smooth L1 loss.
-
-    Args:
-        beta (float, optional): The threshold in the piecewise function.
-            Defaults to 1.0.
-        reduction (str, optional): The method to reduce the loss.
-            Options are "none", "mean" and "sum". Defaults to "mean".
-        loss_weight (float, optional): The weight of loss.
-    """
-
-    def __init__(self, beta=1.0, reduction='mean', loss_weight=1.0):
-        super(SmoothL1Loss, self).__init__()
-        self.beta = beta
-        self.reduction = reduction
-        self.loss_weight = loss_weight
-
-    def forward(self,
-                pred,
-                target,
-                weight=None,
-                avg_factor=None,
-                reduction_override=None,
-                **kwargs):
-        """Forward function.
-
-        Args:
-            pred (torch.Tensor): The prediction.
-            target (torch.Tensor): The learning target of the prediction.
-            weight (torch.Tensor, optional): The weight of loss for each
-                prediction. Defaults to None.
-            avg_factor (int, optional): Average factor that is used to average
-                the loss. Defaults to None.
-            reduction_override (str, optional): The reduction method used to
-                override the original reduction method of the loss.
-                Defaults to None.
-        """
-        assert reduction_override in (None, 'none', 'mean', 'sum')
-        reduction = (
-            reduction_override if reduction_override else self.reduction)
-        loss_bbox = self.loss_weight * smooth_l1_loss(
-            pred,
-            target,
-            weight,
-            beta=self.beta,
-            reduction=reduction,
-            avg_factor=avg_factor,
-            **kwargs)
-        return loss_bbox
-
-
-@LOSSES.register_module()
-class L1Loss(nn.Module):
-    """L1 loss.
-
-    Args:
-        reduction (str, optional): The method to reduce the loss.
-            Options are "none", "mean" and "sum".
-        loss_weight (float, optional): The weight of loss.
-    """
-
-    def __init__(self, reduction='mean', loss_weight=1.0):
-        super(L1Loss, self).__init__()
-        self.reduction = reduction
-        self.loss_weight = loss_weight
-
-    def forward(self,
-                pred,
-                target,
-                weight=None,
-                avg_factor=None,
-                reduction_override=None):
-        """Forward function.
-
-        Args:
-            pred (torch.Tensor): The prediction.
-            target (torch.Tensor): The learning target of the prediction.
-            weight (torch.Tensor, optional): The weight of loss for each
-                prediction. Defaults to None.
-            avg_factor (int, optional): Average factor that is used to average
-                the loss. Defaults to None.
-            reduction_override (str, optional): The reduction method used to
-                override the original reduction method of the loss.
-                Defaults to None.
-        """
-        assert reduction_override in (None, 'none', 'mean', 'sum')
-        reduction = (
-            reduction_override if reduction_override else self.reduction)
-        loss_bbox = self.loss_weight * l1_loss(
-            pred, target, weight, reduction=reduction, avg_factor=avg_factor)
-        return loss_bbox

spaces/Andy1621/uniformer_image_segmentation/configs/fcn/fcn_r101-d8_512x512_80k_ade20k.py

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

spaces/AnjaneyuluChinni/AnjiChinniGenAIAvatar/app.py

@@ -1,34 +0,0 @@
-import os
-import gradio as gr
-from langchain.chat_models import ChatOpenAI
-from langchain import LLMChain, PromptTemplate
-from langchain.memory import ConversationBufferMemory
-
-OPENAI_API_KEY=os.getenv('OPENAI_API_KEY')
-
-template = """You are a helpful assistant to answer all user queries.
-{chat_history}
-User: {user_message}
-Chatbot:"""
-
-prompt = PromptTemplate(
-    input_variables=["chat_history", "user_message"], template=template
-)
-
-memory = ConversationBufferMemory(memory_key="chat_history")
-
-llm_chain = LLMChain(
-    llm=ChatOpenAI(temperature='0.5', model_name="gpt-3.5-turbo"),
-    prompt=prompt,
-    verbose=True,
-    memory=memory,
-)
-
-def get_text_response(user_message,history):
-    response = llm_chain.predict(user_message = user_message)
-    return response
-
-demo = gr.ChatInterface(get_text_response)
-
-if __name__ == "__main__":
-    demo.launch() #To create a public link, set `share=True` in `launch()`. To enable errors and logs, set `debug=True` in `launch()`.

spaces/Arnaudding001/OpenAI_whisperLive/app-network.py

@@ -1,3 +0,0 @@
-# Run the app with no audio file restrictions, and make it available on the network
-from app import create_ui
-create_ui(-1, server_name="0.0.0.0")

spaces/Artrajz/vits-simple-api/bert_vits2/text/japanese.py

@@ -1,585 +0,0 @@
-# Convert Japanese text to phonemes which is
-# compatible with Julius https://github.com/julius-speech/segmentation-kit
-import re
-import unicodedata
-
-from transformers import AutoTokenizer
-
-from bert_vits2.text.symbols import *
-from bert_vits2.text.japanese_bert import tokenizer
-
-try:
-    import MeCab
-except ImportError as e:
-    raise ImportError("Japanese requires mecab-python3 and unidic-lite.") from e
-from num2words import num2words
-
-_CONVRULES = [
-    # Conversion of 2 letters
-    "アァ/ a a",
-    "イィ/ i i",
-    "イェ/ i e",
-    "イャ/ y a",
-    "ウゥ/ u:",
-    "エェ/ e e",
-    "オォ/ o:",
-    "カァ/ k a:",
-    "キィ/ k i:",
-    "クゥ/ k u:",
-    "クャ/ ky a",
-    "クュ/ ky u",
-    "クョ/ ky o",
-    "ケェ/ k e:",
-    "コォ/ k o:",
-    "ガァ/ g a:",
-    "ギィ/ g i:",
-    "グゥ/ g u:",
-    "グャ/ gy a",
-    "グュ/ gy u",
-    "グョ/ gy o",
-    "ゲェ/ g e:",
-    "ゴォ/ g o:",
-    "サァ/ s a:",
-    "シィ/ sh i:",
-    "スゥ/ s u:",
-    "スャ/ sh a",
-    "スュ/ sh u",
-    "スョ/ sh o",
-    "セェ/ s e:",
-    "ソォ/ s o:",
-    "ザァ/ z a:",
-    "ジィ/ j i:",
-    "ズゥ/ z u:",
-    "ズャ/ zy a",
-    "ズュ/ zy u",
-    "ズョ/ zy o",
-    "ゼェ/ z e:",
-    "ゾォ/ z o:",
-    "タァ/ t a:",
-    "チィ/ ch i:",
-    "ツァ/ ts a",
-    "ツィ/ ts i",
-    "ツゥ/ ts u:",
-    "ツャ/ ch a",
-    "ツュ/ ch u",
-    "ツョ/ ch o",
-    "ツェ/ ts e",
-    "ツォ/ ts o",
-    "テェ/ t e:",
-    "トォ/ t o:",
-    "ダァ/ d a:",
-    "ヂィ/ j i:",
-    "ヅゥ/ d u:",
-    "ヅャ/ zy a",
-    "ヅュ/ zy u",
-    "ヅョ/ zy o",
-    "デェ/ d e:",
-    "ドォ/ d o:",
-    "ナァ/ n a:",
-    "ニィ/ n i:",
-    "ヌゥ/ n u:",
-    "ヌャ/ ny a",
-    "ヌュ/ ny u",
-    "ヌョ/ ny o",
-    "ネェ/ n e:",
-    "ノォ/ n o:",
-    "ハァ/ h a:",
-    "ヒィ/ h i:",
-    "フゥ/ f u:",
-    "フャ/ hy a",
-    "フュ/ hy u",
-    "フョ/ hy o",
-    "ヘェ/ h e:",
-    "ホォ/ h o:",
-    "バァ/ b a:",
-    "ビィ/ b i:",
-    "ブゥ/ b u:",
-    "フャ/ hy a",
-    "ブュ/ by u",
-    "フョ/ hy o",
-    "ベェ/ b e:",
-    "ボォ/ b o:",
-    "パァ/ p a:",
-    "ピィ/ p i:",
-    "プゥ/ p u:",
-    "プャ/ py a",
-    "プュ/ py u",
-    "プョ/ py o",
-    "ペェ/ p e:",
-    "ポォ/ p o:",
-    "マァ/ m a:",
-    "ミィ/ m i:",
-    "ムゥ/ m u:",
-    "ムャ/ my a",
-    "ムュ/ my u",
-    "ムョ/ my o",
-    "メェ/ m e:",
-    "モォ/ m o:",
-    "ヤァ/ y a:",
-    "ユゥ/ y u:",
-    "ユャ/ y a:",
-    "ユュ/ y u:",
-    "ユョ/ y o:",
-    "ヨォ/ y o:",
-    "ラァ/ r a:",
-    "リィ/ r i:",
-    "ルゥ/ r u:",
-    "ルャ/ ry a",
-    "ルュ/ ry u",
-    "ルョ/ ry o",
-    "レェ/ r e:",
-    "ロォ/ r o:",
-    "ワァ/ w a:",
-    "ヲォ/ o:",
-    "ディ/ d i",
-    "デェ/ d e:",
-    "デャ/ dy a",
-    "デュ/ dy u",
-    "デョ/ dy o",
-    "ティ/ t i",
-    "テェ/ t e:",
-    "テャ/ ty a",
-    "テュ/ ty u",
-    "テョ/ ty o",
-    "スィ/ s i",
-    "ズァ/ z u a",
-    "ズィ/ z i",
-    "ズゥ/ z u",
-    "ズャ/ zy a",
-    "ズュ/ zy u",
-    "ズョ/ zy o",
-    "ズェ/ z e",
-    "ズォ/ z o",
-    "キャ/ ky a",
-    "キュ/ ky u",
-    "キョ/ ky o",
-    "シャ/ sh a",
-    "シュ/ sh u",
-    "シェ/ sh e",
-    "ショ/ sh o",
-    "チャ/ ch a",
-    "チュ/ ch u",
-    "チェ/ ch e",
-    "チョ/ ch o",
-    "トゥ/ t u",
-    "トャ/ ty a",
-    "トュ/ ty u",
-    "トョ/ ty o",
-    "ドァ/ d o a",
-    "ドゥ/ d u",
-    "ドャ/ dy a",
-    "ドュ/ dy u",
-    "ドョ/ dy o",
-    "ドォ/ d o:",
-    "ニャ/ ny a",
-    "ニュ/ ny u",
-    "ニョ/ ny o",
-    "ヒャ/ hy a",
-    "ヒュ/ hy u",
-    "ヒョ/ hy o",
-    "ミャ/ my a",
-    "ミュ/ my u",
-    "ミョ/ my o",
-    "リャ/ ry a",
-    "リュ/ ry u",
-    "リョ/ ry o",
-    "ギャ/ gy a",
-    "ギュ/ gy u",
-    "ギョ/ gy o",
-    "ヂェ/ j e",
-    "ヂャ/ j a",
-    "ヂュ/ j u",
-    "ヂョ/ j o",
-    "ジェ/ j e",
-    "ジャ/ j a",
-    "ジュ/ j u",
-    "ジョ/ j o",
-    "ビャ/ by a",
-    "ビュ/ by u",
-    "ビョ/ by o",
-    "ピャ/ py a",
-    "ピュ/ py u",
-    "ピョ/ py o",
-    "ウァ/ u a",
-    "ウィ/ w i",
-    "ウェ/ w e",
-    "ウォ/ w o",
-    "ファ/ f a",
-    "フィ/ f i",
-    "フゥ/ f u",
-    "フャ/ hy a",
-    "フュ/ hy u",
-    "フョ/ hy o",
-    "フェ/ f e",
-    "フォ/ f o",
-    "ヴァ/ b a",
-    "ヴィ/ b i",
-    "ヴェ/ b e",
-    "ヴォ/ b o",
-    "ヴュ/ by u",
-    # Conversion of 1 letter
-    "ア/ a",
-    "イ/ i",
-    "ウ/ u",
-    "エ/ e",
-    "オ/ o",
-    "カ/ k a",
-    "キ/ k i",
-    "ク/ k u",
-    "ケ/ k e",
-    "コ/ k o",
-    "サ/ s a",
-    "シ/ sh i",
-    "ス/ s u",
-    "セ/ s e",
-    "ソ/ s o",
-    "タ/ t a",
-    "チ/ ch i",
-    "ツ/ ts u",
-    "テ/ t e",
-    "ト/ t o",
-    "ナ/ n a",
-    "ニ/ n i",
-    "ヌ/ n u",
-    "ネ/ n e",
-    "ノ/ n o",
-    "ハ/ h a",
-    "ヒ/ h i",
-    "フ/ f u",
-    "ヘ/ h e",
-    "ホ/ h o",
-    "マ/ m a",
-    "ミ/ m i",
-    "ム/ m u",
-    "メ/ m e",
-    "モ/ m o",
-    "ラ/ r a",
-    "リ/ r i",
-    "ル/ r u",
-    "レ/ r e",
-    "ロ/ r o",
-    "ガ/ g a",
-    "ギ/ g i",
-    "グ/ g u",
-    "ゲ/ g e",
-    "ゴ/ g o",
-    "ザ/ z a",
-    "ジ/ j i",
-    "ズ/ z u",
-    "ゼ/ z e",
-    "ゾ/ z o",
-    "ダ/ d a",
-    "ヂ/ j i",
-    "ヅ/ z u",
-    "デ/ d e",
-    "ド/ d o",
-    "バ/ b a",
-    "ビ/ b i",
-    "ブ/ b u",
-    "ベ/ b e",
-    "ボ/ b o",
-    "パ/ p a",
-    "ピ/ p i",
-    "プ/ p u",
-    "ペ/ p e",
-    "ポ/ p o",
-    "ヤ/ y a",
-    "ユ/ y u",
-    "ヨ/ y o",
-    "ワ/ w a",
-    "ヰ/ i",
-    "ヱ/ e",
-    "ヲ/ o",
-    "ン/ N",
-    "ッ/ q",
-    "ヴ/ b u",
-    "ー/:",
-    # Try converting broken text
-    "ァ/ a",
-    "ィ/ i",
-    "ゥ/ u",
-    "ェ/ e",
-    "ォ/ o",
-    "ヮ/ w a",
-    "ォ/ o",
-    # Symbols
-    "、/ ,",
-    "。/ .",
-    "！/ !",
-    "？/ ?",
-    "・/ ,",
-]
-
-_COLON_RX = re.compile(":+")
-_REJECT_RX = re.compile("[^ a-zA-Z:,.?]")
-
-
-def _makerulemap():
-    l = [tuple(x.split("/")) for x in _CONVRULES]
-    return tuple({k: v for k, v in l if len(k) == i} for i in (1, 2))
-
-
-_RULEMAP1, _RULEMAP2 = _makerulemap()
-
-
-def kata2phoneme(text: str) -> str:
-    """Convert katakana text to phonemes."""
-    text = text.strip()
-    res = []
-    while text:
-        if len(text) >= 2:
-            x = _RULEMAP2.get(text[:2])
-            if x is not None:
-                text = text[2:]
-                res += x.split(" ")[1:]
-                continue
-        x = _RULEMAP1.get(text[0])
-        if x is not None:
-            text = text[1:]
-            res += x.split(" ")[1:]
-            continue
-        res.append(text[0])
-        text = text[1:]
-    # res = _COLON_RX.sub(":", res)
-    return res
-
-
-_KATAKANA = "".join(chr(ch) for ch in range(ord("ァ"), ord("ン") + 1))
-_HIRAGANA = "".join(chr(ch) for ch in range(ord("ぁ"), ord("ん") + 1))
-_HIRA2KATATRANS = str.maketrans(_HIRAGANA, _KATAKANA)
-
-
-def hira2kata(text: str) -> str:
-    text = text.translate(_HIRA2KATATRANS)
-    return text.replace("う゛", "ヴ")
-
-
-_SYMBOL_TOKENS = set(list("・、。？！"))
-_NO_YOMI_TOKENS = set(list("「」『』―（）［］[]"))
-_TAGGER = MeCab.Tagger()
-
-
-def text2kata(text: str) -> str:
-    parsed = _TAGGER.parse(text)
-    res = []
-    for line in parsed.split("\n"):
-        if line == "EOS":
-            break
-        parts = line.split("\t")
-
-        word, yomi = parts[0], parts[1]
-        if yomi:
-            res.append(yomi)
-        else:
-            if word in _SYMBOL_TOKENS:
-                res.append(word)
-            elif word in ("っ", "ッ"):
-                res.append("ッ")
-            elif word in _NO_YOMI_TOKENS:
-                pass
-            else:
-                res.append(word)
-    return hira2kata("".join(res))
-
-
-_ALPHASYMBOL_YOMI = {
-    "#": "シャープ",
-    "%": "パーセント",
-    "&": "アンド",
-    "+": "プラス",
-    "-": "マイナス",
-    ":": "コロン",
-    ";": "セミコロン",
-    "<": "小なり",
-    "=": "イコール",
-    ">": "大なり",
-    "@": "アット",
-    "a": "エー",
-    "b": "ビー",
-    "c": "シー",
-    "d": "ディー",
-    "e": "イー",
-    "f": "エフ",
-    "g": "ジー",
-    "h": "エイチ",
-    "i": "アイ",
-    "j": "ジェー",
-    "k": "ケー",
-    "l": "エル",
-    "m": "エム",
-    "n": "エヌ",
-    "o": "オー",
-    "p": "ピー",
-    "q": "キュー",
-    "r": "アール",
-    "s": "エス",
-    "t": "ティー",
-    "u": "ユー",
-    "v": "ブイ",
-    "w": "ダブリュー",
-    "x": "エックス",
-    "y": "ワイ",
-    "z": "ゼット",
-    "α": "アルファ",
-    "β": "ベータ",
-    "γ": "ガンマ",
-    "δ": "デルタ",
-    "ε": "イプシロン",
-    "ζ": "ゼータ",
-    "η": "イータ",
-    "θ": "シータ",
-    "ι": "イオタ",
-    "κ": "カッパ",
-    "λ": "ラムダ",
-    "μ": "ミュー",
-    "ν": "ニュー",
-    "ξ": "クサイ",
-    "ο": "オミクロン",
-    "π": "パイ",
-    "ρ": "ロー",
-    "σ": "シグマ",
-    "τ": "タウ",
-    "υ": "ウプシロン",
-    "φ": "ファイ",
-    "χ": "カイ",
-    "ψ": "プサイ",
-    "ω": "オメガ",
-}
-
-_NUMBER_WITH_SEPARATOR_RX = re.compile("[0-9]{1,3}(,[0-9]{3})+")
-_CURRENCY_MAP = {"$": "ドル", "¥": "円", "£": "ポンド", "€": "ユーロ"}
-_CURRENCY_RX = re.compile(r"([$¥£€])([0-9.]*[0-9])")
-_NUMBER_RX = re.compile(r"[0-9]+(\.[0-9]+)?")
-
-
-def japanese_convert_numbers_to_words(text: str) -> str:
-    res = _NUMBER_WITH_SEPARATOR_RX.sub(lambda m: m[0].replace(",", ""), text)
-    res = _CURRENCY_RX.sub(lambda m: m[2] + _CURRENCY_MAP.get(m[1], m[1]), res)
-    res = _NUMBER_RX.sub(lambda m: num2words(m[0], lang="ja"), res)
-    return res
-
-
-def japanese_convert_alpha_symbols_to_words(text: str) -> str:
-    return "".join([_ALPHASYMBOL_YOMI.get(ch, ch) for ch in text.lower()])
-
-
-def japanese_text_to_phonemes(text: str) -> str:
-    """Convert Japanese text to phonemes."""
-    res = unicodedata.normalize("NFKC", text)
-    res = japanese_convert_numbers_to_words(res)
-    # res = japanese_convert_alpha_symbols_to_words(res)
-    res = text2kata(res)
-    res = kata2phoneme(res)
-    return res
-
-
-def is_japanese_character(char):
-    # 定义日语文字系统的 Unicode 范围
-    japanese_ranges = [
-        (0x3040, 0x309F),  # 平假名
-        (0x30A0, 0x30FF),  # 片假名
-        (0x4E00, 0x9FFF),  # 汉字 (CJK Unified Ideographs)
-        (0x3400, 0x4DBF),  # 汉字扩展 A
-        (0x20000, 0x2A6DF),  # 汉字扩展 B
-        # 可以根据需要添加其他汉字扩展范围
-    ]
-
-    # 将字符的 Unicode 编码转换为整数
-    char_code = ord(char)
-
-    # 检查字符是否在任何一个日语范围内
-    for start, end in japanese_ranges:
-        if start <= char_code <= end:
-            return True
-
-    return False
-
-
-rep_map = {
-    "：": ",",
-    "；": ",",
-    "，": ",",
-    "。": ".",
-    "！": "!",
-    "？": "?",
-    "\n": ".",
-    "·": ",",
-    "、": ",",
-    "...": "…",
-}
-
-
-def replace_punctuation(text):
-    pattern = re.compile("|".join(re.escape(p) for p in rep_map.keys()))
-
-    replaced_text = pattern.sub(lambda x: rep_map[x.group()], text)
-
-    replaced_text = re.sub(
-        r"[^\u3040-\u309F\u30A0-\u30FF\u4E00-\u9FFF\u3400-\u4DBF"
-        + "".join(punctuation)
-        + r"]+",
-        "",
-        replaced_text,
-    )
-
-    return replaced_text
-
-
-def text_normalize(text):
-    res = unicodedata.normalize("NFKC", text)
-    res = japanese_convert_numbers_to_words(res)
-    # res = "".join([i for i in res if is_japanese_character(i)])
-    res = replace_punctuation(res)
-    return res
-
-
-def distribute_phone(n_phone, n_word):
-    phones_per_word = [0] * n_word
-    for task in range(n_phone):
-        min_tasks = min(phones_per_word)
-        min_index = phones_per_word.index(min_tasks)
-        phones_per_word[min_index] += 1
-    return phones_per_word
-
-
-def g2p(norm_text):
-    tokenized = tokenizer.tokenize(norm_text)
-    phs = []
-    ph_groups = []
-    for t in tokenized:
-        if not t.startswith("#"):
-            ph_groups.append([t])
-        else:
-            ph_groups[-1].append(t.replace("#", ""))
-    word2ph = []
-    for group in ph_groups:
-        phonemes = kata2phoneme(text2kata("".join(group)))
-        # phonemes = [i for i in phonemes if i in symbols]
-        for i in phonemes:
-            assert i in symbols, (i, group, norm_text, tokenized)
-        phone_len = len(phonemes)
-        word_len = len(group)
-
-        aaa = distribute_phone(phone_len, word_len)
-        word2ph += aaa
-
-        phs += phonemes
-    phones = ["_"] + phs + ["_"]
-    tones = [0 for i in phones]
-    word2ph = [1] + word2ph + [1]
-    return phones, tones, word2ph
-
-
-if __name__ == "__main__":
-    from config import ABS_PATH
-
-    tokenizer = AutoTokenizer.from_pretrained(ABS_PATH + "/bert_vits2/bert/bert-base-japanese-v3")
-    text = "hello,こんにちは、世界！……"
-    from bert_vits2.text.japanese_bert import get_bert_feature
-
-    text = text_normalize(text)
-    print(text)
-    phones, tones, word2ph = g2p(text)
-    bert = get_bert_feature(text, word2ph)
-
-    print(phones, tones, word2ph, bert.shape)

spaces/Artrajz/vits-simple-api/vits/text/vits_pinyin.py

@@ -1,98 +0,0 @@
-""" from https://github.com/PlayVoice/vits_chinese """
-import pypinyin
-from pypinyin.contrib.neutral_tone import NeutralToneWith5Mixin
-from pypinyin.converter import DefaultConverter
-from pypinyin.core import Pinyin
-
-import numpy as np
-
-from vits.bert.prosody_tool import pinyin_dict
-from vits.bert import TTSProsody
-
-
-class MyConverter(NeutralToneWith5Mixin, DefaultConverter):
-    pass
-
-
-def is_chinese(uchar):
-    if uchar >= u'\u4e00' and uchar <= u'\u9fa5':
-        return True
-    else:
-        return False
-
-
-def clean_chinese(text: str):
-    text = text.strip()
-    text_clean = []
-    for char in text:
-        if (is_chinese(char)):
-            text_clean.append(char)
-        else:
-            if len(text_clean) > 1 and is_chinese(text_clean[-1]):
-                text_clean.append(',')
-    text_clean = ''.join(text_clean).strip(',')
-    return text_clean
-
-
-class VITS_PinYin:
-    def __init__(self, bert_path, device):
-        self.pinyin_parser = Pinyin(MyConverter())
-        self.prosody = TTSProsody(bert_path, device)
-
-    def chinese_to_phonemes(self, text):
-        # 考虑使用g2pw的chinese bert替换原始的pypinyin,目前测试下来运行速度太慢。
-        # 将标准中文文本符号替换成 bert 符号库中的单符号,以保证bert的效果.
-        text = text.replace("——", "...") \
-            .replace("—", "...") \
-            .replace("……", "...") \
-            .replace("…", "...") \
-            .replace('“', '"') \
-            .replace('”', '"') \
-            .replace("\n", "")
-        tokens = self.prosody.char_model.tokenizer.tokenize(text)
-        text = ''.join(tokens)
-        assert not tokens.count("[UNK]")
-        pinyins = np.reshape(pypinyin.pinyin(text, style=pypinyin.TONE3), (-1))
-        try:
-            phone_index = 0
-            phone_items = []
-            phone_items.append('sil')
-            count_phone = []
-            count_phone.append(1)
-            temp = ""
-
-            len_pys = len(tokens)
-            for word in tokens:
-                if is_chinese(word):
-                    count_phone.append(2)
-                    if (phone_index >= len_pys):
-                        print(
-                            f"!!!![{text}]plz check ur text whether includes MULTIBYTE symbol.\
-                                (请检查你的文本中是否包含多字节符号)")
-                    pinyin = pinyins[phone_index]
-                    phone_index = phone_index + 1
-                    if not pinyin[-1].isdigit():
-                        pinyin += "5"
-                    if pinyin[:-1] in pinyin_dict:
-                        tone = pinyin[-1]
-                        a = pinyin[:-1]
-                        a1, a2 = pinyin_dict[a]
-                        phone_items += [a1, a2 + tone]
-                else:
-                    temp += word
-                    if temp == pinyins[phone_index]:
-                        temp = ""
-                        phone_index += 1
-                    count_phone.append(1)
-                    phone_items.append('sp')
-
-            count_phone.append(1)
-            phone_items.append('sil')
-            phone_items_str = ' '.join(phone_items)
-        except IndexError as e:
-            print('except:', e)
-
-        text = f'[PAD]{text}[PAD]'
-        char_embeds = self.prosody.get_char_embeds(text)
-        char_embeds = self.prosody.expand_for_phone(char_embeds, count_phone)
-        return phone_items_str, char_embeds

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

@@ -1,802 +0,0 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-
-import abc
-import functools
-import itertools
-import re
-import warnings
-from typing import (
-    Callable,
-    Dict,
-    Iterable,
-    Iterator,
-    List,
-    Optional,
-    Pattern,
-    Set,
-    Tuple,
-    TypeVar,
-    Union,
-)
-
-from .utils import canonicalize_version
-from .version import LegacyVersion, Version, parse
-
-ParsedVersion = Union[Version, LegacyVersion]
-UnparsedVersion = Union[Version, LegacyVersion, str]
-VersionTypeVar = TypeVar("VersionTypeVar", bound=UnparsedVersion)
-CallableOperator = Callable[[ParsedVersion, str], bool]
-
-
-class InvalidSpecifier(ValueError):
-    """
-    An invalid specifier was found, users should refer to PEP 440.
-    """
-
-
-class BaseSpecifier(metaclass=abc.ABCMeta):
-    @abc.abstractmethod
-    def __str__(self) -> str:
-        """
-        Returns the str representation of this Specifier like object. This
-        should be representative of the Specifier itself.
-        """
-
-    @abc.abstractmethod
-    def __hash__(self) -> int:
-        """
-        Returns a hash value for this Specifier like object.
-        """
-
-    @abc.abstractmethod
-    def __eq__(self, other: object) -> bool:
-        """
-        Returns a boolean representing whether or not the two Specifier like
-        objects are equal.
-        """
-
-    @abc.abstractproperty
-    def prereleases(self) -> Optional[bool]:
-        """
-        Returns whether or not pre-releases as a whole are allowed by this
-        specifier.
-        """
-
-    @prereleases.setter
-    def prereleases(self, value: bool) -> None:
-        """
-        Sets whether or not pre-releases as a whole are allowed by this
-        specifier.
-        """
-
-    @abc.abstractmethod
-    def contains(self, item: str, prereleases: Optional[bool] = None) -> bool:
-        """
-        Determines if the given item is contained within this specifier.
-        """
-
-    @abc.abstractmethod
-    def filter(
-        self, iterable: Iterable[VersionTypeVar], prereleases: Optional[bool] = None
-    ) -> Iterable[VersionTypeVar]:
-        """
-        Takes an iterable of items and filters them so that only items which
-        are contained within this specifier are allowed in it.
-        """
-
-
-class _IndividualSpecifier(BaseSpecifier):
-
-    _operators: Dict[str, str] = {}
-    _regex: Pattern[str]
-
-    def __init__(self, spec: str = "", prereleases: Optional[bool] = None) -> None:
-        match = self._regex.search(spec)
-        if not match:
-            raise InvalidSpecifier(f"Invalid specifier: '{spec}'")
-
-        self._spec: Tuple[str, str] = (
-            match.group("operator").strip(),
-            match.group("version").strip(),
-        )
-
-        # Store whether or not this Specifier should accept prereleases
-        self._prereleases = prereleases
-
-    def __repr__(self) -> str:
-        pre = (
-            f", prereleases={self.prereleases!r}"
-            if self._prereleases is not None
-            else ""
-        )
-
-        return f"<{self.__class__.__name__}({str(self)!r}{pre})>"
-
-    def __str__(self) -> str:
-        return "{}{}".format(*self._spec)
-
-    @property
-    def _canonical_spec(self) -> Tuple[str, str]:
-        return self._spec[0], canonicalize_version(self._spec[1])
-
-    def __hash__(self) -> int:
-        return hash(self._canonical_spec)
-
-    def __eq__(self, other: object) -> bool:
-        if isinstance(other, str):
-            try:
-                other = self.__class__(str(other))
-            except InvalidSpecifier:
-                return NotImplemented
-        elif not isinstance(other, self.__class__):
-            return NotImplemented
-
-        return self._canonical_spec == other._canonical_spec
-
-    def _get_operator(self, op: str) -> CallableOperator:
-        operator_callable: CallableOperator = getattr(
-            self, f"_compare_{self._operators[op]}"
-        )
-        return operator_callable
-
-    def _coerce_version(self, version: UnparsedVersion) -> ParsedVersion:
-        if not isinstance(version, (LegacyVersion, Version)):
-            version = parse(version)
-        return version
-
-    @property
-    def operator(self) -> str:
-        return self._spec[0]
-
-    @property
-    def version(self) -> str:
-        return self._spec[1]
-
-    @property
-    def prereleases(self) -> Optional[bool]:
-        return self._prereleases
-
-    @prereleases.setter
-    def prereleases(self, value: bool) -> None:
-        self._prereleases = value
-
-    def __contains__(self, item: str) -> bool:
-        return self.contains(item)
-
-    def contains(
-        self, item: UnparsedVersion, prereleases: Optional[bool] = None
-    ) -> bool:
-
-        # Determine if prereleases are to be allowed or not.
-        if prereleases is None:
-            prereleases = self.prereleases
-
-        # Normalize item to a Version or LegacyVersion, this allows us to have
-        # a shortcut for ``"2.0" in Specifier(">=2")
-        normalized_item = self._coerce_version(item)
-
-        # Determine if we should be supporting prereleases in this specifier
-        # or not, if we do not support prereleases than we can short circuit
-        # logic if this version is a prereleases.
-        if normalized_item.is_prerelease and not prereleases:
-            return False
-
-        # Actually do the comparison to determine if this item is contained
-        # within this Specifier or not.
-        operator_callable: CallableOperator = self._get_operator(self.operator)
-        return operator_callable(normalized_item, self.version)
-
-    def filter(
-        self, iterable: Iterable[VersionTypeVar], prereleases: Optional[bool] = None
-    ) -> Iterable[VersionTypeVar]:
-
-        yielded = False
-        found_prereleases = []
-
-        kw = {"prereleases": prereleases if prereleases is not None else True}
-
-        # Attempt to iterate over all the values in the iterable and if any of
-        # them match, yield them.
-        for version in iterable:
-            parsed_version = self._coerce_version(version)
-
-            if self.contains(parsed_version, **kw):
-                # If our version is a prerelease, and we were not set to allow
-                # prereleases, then we'll store it for later in case nothing
-                # else matches this specifier.
-                if parsed_version.is_prerelease and not (
-                    prereleases or self.prereleases
-                ):
-                    found_prereleases.append(version)
-                # Either this is not a prerelease, or we should have been
-                # accepting prereleases from the beginning.
-                else:
-                    yielded = True
-                    yield version
-
-        # Now that we've iterated over everything, determine if we've yielded
-        # any values, and if we have not and we have any prereleases stored up
-        # then we will go ahead and yield the prereleases.
-        if not yielded and found_prereleases:
-            for version in found_prereleases:
-                yield version
-
-
-class LegacySpecifier(_IndividualSpecifier):
-
-    _regex_str = r"""
-        (?P<operator>(==|!=|<=|>=|<|>))
-        \s*
-        (?P<version>
-            [^,;\s)]* # Since this is a "legacy" specifier, and the version
-                      # string can be just about anything, we match everything
-                      # except for whitespace, a semi-colon for marker support,
-                      # a closing paren since versions can be enclosed in
-                      # them, and a comma since it's a version separator.
-        )
-        """
-
-    _regex = re.compile(r"^\s*" + _regex_str + r"\s*$", re.VERBOSE | re.IGNORECASE)
-
-    _operators = {
-        "==": "equal",
-        "!=": "not_equal",
-        "<=": "less_than_equal",
-        ">=": "greater_than_equal",
-        "<": "less_than",
-        ">": "greater_than",
-    }
-
-    def __init__(self, spec: str = "", prereleases: Optional[bool] = None) -> None:
-        super().__init__(spec, prereleases)
-
-        warnings.warn(
-            "Creating a LegacyVersion has been deprecated and will be "
-            "removed in the next major release",
-            DeprecationWarning,
-        )
-
-    def _coerce_version(self, version: UnparsedVersion) -> LegacyVersion:
-        if not isinstance(version, LegacyVersion):
-            version = LegacyVersion(str(version))
-        return version
-
-    def _compare_equal(self, prospective: LegacyVersion, spec: str) -> bool:
-        return prospective == self._coerce_version(spec)
-
-    def _compare_not_equal(self, prospective: LegacyVersion, spec: str) -> bool:
-        return prospective != self._coerce_version(spec)
-
-    def _compare_less_than_equal(self, prospective: LegacyVersion, spec: str) -> bool:
-        return prospective <= self._coerce_version(spec)
-
-    def _compare_greater_than_equal(
-        self, prospective: LegacyVersion, spec: str
-    ) -> bool:
-        return prospective >= self._coerce_version(spec)
-
-    def _compare_less_than(self, prospective: LegacyVersion, spec: str) -> bool:
-        return prospective < self._coerce_version(spec)
-
-    def _compare_greater_than(self, prospective: LegacyVersion, spec: str) -> bool:
-        return prospective > self._coerce_version(spec)
-
-
-def _require_version_compare(
-    fn: Callable[["Specifier", ParsedVersion, str], bool]
-) -> Callable[["Specifier", ParsedVersion, str], bool]:
-    @functools.wraps(fn)
-    def wrapped(self: "Specifier", prospective: ParsedVersion, spec: str) -> bool:
-        if not isinstance(prospective, Version):
-            return False
-        return fn(self, prospective, spec)
-
-    return wrapped
-
-
-class Specifier(_IndividualSpecifier):
-
-    _regex_str = r"""
-        (?P<operator>(~=|==|!=|<=|>=|<|>|===))
-        (?P<version>
-            (?:
-                # The identity operators allow for an escape hatch that will
-                # do an exact string match of the version you wish to install.
-                # This will not be parsed by PEP 440 and we cannot determine
-                # any semantic meaning from it. This operator is discouraged
-                # but included entirely as an escape hatch.
-                (?<====)  # Only match for the identity operator
-                \s*
-                [^\s]*    # We just match everything, except for whitespace
-                          # since we are only testing for strict identity.
-            )
-            |
-            (?:
-                # The (non)equality operators allow for wild card and local
-                # versions to be specified so we have to define these two
-                # operators separately to enable that.
-                (?<===|!=)            # Only match for equals and not equals
-
-                \s*
-                v?
-                (?:[0-9]+!)?          # epoch
-                [0-9]+(?:\.[0-9]+)*   # release
-                (?:                   # pre release
-                    [-_\.]?
-                    (a|b|c|rc|alpha|beta|pre|preview)
-                    [-_\.]?
-                    [0-9]*
-                )?
-                (?:                   # post release
-                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
-                )?
-
-                # You cannot use a wild card and a dev or local version
-                # together so group them with a | and make them optional.
-                (?:
-                    (?:[-_\.]?dev[-_\.]?[0-9]*)?         # dev release
-                    (?:\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*)? # local
-                    |
-                    \.\*  # Wild card syntax of .*
-                )?
-            )
-            |
-            (?:
-                # The compatible operator requires at least two digits in the
-                # release segment.
-                (?<=~=)               # Only match for the compatible operator
-
-                \s*
-                v?
-                (?:[0-9]+!)?          # epoch
-                [0-9]+(?:\.[0-9]+)+   # release  (We have a + instead of a *)
-                (?:                   # pre release
-                    [-_\.]?
-                    (a|b|c|rc|alpha|beta|pre|preview)
-                    [-_\.]?
-                    [0-9]*
-                )?
-                (?:                                   # post release
-                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
-                )?
-                (?:[-_\.]?dev[-_\.]?[0-9]*)?          # dev release
-            )
-            |
-            (?:
-                # All other operators only allow a sub set of what the
-                # (non)equality operators do. Specifically they do not allow
-                # local versions to be specified nor do they allow the prefix
-                # matching wild cards.
-                (?<!==|!=|~=)         # We have special cases for these
-                                      # operators so we want to make sure they
-                                      # don't match here.
-
-                \s*
-                v?
-                (?:[0-9]+!)?          # epoch
-                [0-9]+(?:\.[0-9]+)*   # release
-                (?:                   # pre release
-                    [-_\.]?
-                    (a|b|c|rc|alpha|beta|pre|preview)
-                    [-_\.]?
-                    [0-9]*
-                )?
-                (?:                                   # post release
-                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
-                )?
-                (?:[-_\.]?dev[-_\.]?[0-9]*)?          # dev release
-            )
-        )
-        """
-
-    _regex = re.compile(r"^\s*" + _regex_str + r"\s*$", re.VERBOSE | re.IGNORECASE)
-
-    _operators = {
-        "~=": "compatible",
-        "==": "equal",
-        "!=": "not_equal",
-        "<=": "less_than_equal",
-        ">=": "greater_than_equal",
-        "<": "less_than",
-        ">": "greater_than",
-        "===": "arbitrary",
-    }
-
-    @_require_version_compare
-    def _compare_compatible(self, prospective: ParsedVersion, spec: str) -> bool:
-
-        # Compatible releases have an equivalent combination of >= and ==. That
-        # is that ~=2.2 is equivalent to >=2.2,==2.*. This allows us to
-        # implement this in terms of the other specifiers instead of
-        # implementing it ourselves. The only thing we need to do is construct
-        # the other specifiers.
-
-        # We want everything but the last item in the version, but we want to
-        # ignore suffix segments.
-        prefix = ".".join(
-            list(itertools.takewhile(_is_not_suffix, _version_split(spec)))[:-1]
-        )
-
-        # Add the prefix notation to the end of our string
-        prefix += ".*"
-
-        return self._get_operator(">=")(prospective, spec) and self._get_operator("==")(
-            prospective, prefix
-        )
-
-    @_require_version_compare
-    def _compare_equal(self, prospective: ParsedVersion, spec: str) -> bool:
-
-        # We need special logic to handle prefix matching
-        if spec.endswith(".*"):
-            # In the case of prefix matching we want to ignore local segment.
-            prospective = Version(prospective.public)
-            # Split the spec out by dots, and pretend that there is an implicit
-            # dot in between a release segment and a pre-release segment.
-            split_spec = _version_split(spec[:-2])  # Remove the trailing .*
-
-            # Split the prospective version out by dots, and pretend that there
-            # is an implicit dot in between a release segment and a pre-release
-            # segment.
-            split_prospective = _version_split(str(prospective))
-
-            # Shorten the prospective version to be the same length as the spec
-            # so that we can determine if the specifier is a prefix of the
-            # prospective version or not.
-            shortened_prospective = split_prospective[: len(split_spec)]
-
-            # Pad out our two sides with zeros so that they both equal the same
-            # length.
-            padded_spec, padded_prospective = _pad_version(
-                split_spec, shortened_prospective
-            )
-
-            return padded_prospective == padded_spec
-        else:
-            # Convert our spec string into a Version
-            spec_version = Version(spec)
-
-            # If the specifier does not have a local segment, then we want to
-            # act as if the prospective version also does not have a local
-            # segment.
-            if not spec_version.local:
-                prospective = Version(prospective.public)
-
-            return prospective == spec_version
-
-    @_require_version_compare
-    def _compare_not_equal(self, prospective: ParsedVersion, spec: str) -> bool:
-        return not self._compare_equal(prospective, spec)
-
-    @_require_version_compare
-    def _compare_less_than_equal(self, prospective: ParsedVersion, spec: str) -> bool:
-
-        # NB: Local version identifiers are NOT permitted in the version
-        # specifier, so local version labels can be universally removed from
-        # the prospective version.
-        return Version(prospective.public) <= Version(spec)
-
-    @_require_version_compare
-    def _compare_greater_than_equal(
-        self, prospective: ParsedVersion, spec: str
-    ) -> bool:
-
-        # NB: Local version identifiers are NOT permitted in the version
-        # specifier, so local version labels can be universally removed from
-        # the prospective version.
-        return Version(prospective.public) >= Version(spec)
-
-    @_require_version_compare
-    def _compare_less_than(self, prospective: ParsedVersion, spec_str: str) -> bool:
-
-        # Convert our spec to a Version instance, since we'll want to work with
-        # it as a version.
-        spec = Version(spec_str)
-
-        # Check to see if the prospective version is less than the spec
-        # version. If it's not we can short circuit and just return False now
-        # instead of doing extra unneeded work.
-        if not prospective < spec:
-            return False
-
-        # This special case is here so that, unless the specifier itself
-        # includes is a pre-release version, that we do not accept pre-release
-        # versions for the version mentioned in the specifier (e.g. <3.1 should
-        # not match 3.1.dev0, but should match 3.0.dev0).
-        if not spec.is_prerelease and prospective.is_prerelease:
-            if Version(prospective.base_version) == Version(spec.base_version):
-                return False
-
-        # If we've gotten to here, it means that prospective version is both
-        # less than the spec version *and* it's not a pre-release of the same
-        # version in the spec.
-        return True
-
-    @_require_version_compare
-    def _compare_greater_than(self, prospective: ParsedVersion, spec_str: str) -> bool:
-
-        # Convert our spec to a Version instance, since we'll want to work with
-        # it as a version.
-        spec = Version(spec_str)
-
-        # Check to see if the prospective version is greater than the spec
-        # version. If it's not we can short circuit and just return False now
-        # instead of doing extra unneeded work.
-        if not prospective > spec:
-            return False
-
-        # This special case is here so that, unless the specifier itself
-        # includes is a post-release version, that we do not accept
-        # post-release versions for the version mentioned in the specifier
-        # (e.g. >3.1 should not match 3.0.post0, but should match 3.2.post0).
-        if not spec.is_postrelease and prospective.is_postrelease:
-            if Version(prospective.base_version) == Version(spec.base_version):
-                return False
-
-        # Ensure that we do not allow a local version of the version mentioned
-        # in the specifier, which is technically greater than, to match.
-        if prospective.local is not None:
-            if Version(prospective.base_version) == Version(spec.base_version):
-                return False
-
-        # If we've gotten to here, it means that prospective version is both
-        # greater than the spec version *and* it's not a pre-release of the
-        # same version in the spec.
-        return True
-
-    def _compare_arbitrary(self, prospective: Version, spec: str) -> bool:
-        return str(prospective).lower() == str(spec).lower()
-
-    @property
-    def prereleases(self) -> bool:
-
-        # If there is an explicit prereleases set for this, then we'll just
-        # blindly use that.
-        if self._prereleases is not None:
-            return self._prereleases
-
-        # Look at all of our specifiers and determine if they are inclusive
-        # operators, and if they are if they are including an explicit
-        # prerelease.
-        operator, version = self._spec
-        if operator in ["==", ">=", "<=", "~=", "==="]:
-            # The == specifier can include a trailing .*, if it does we
-            # want to remove before parsing.
-            if operator == "==" and version.endswith(".*"):
-                version = version[:-2]
-
-            # Parse the version, and if it is a pre-release than this
-            # specifier allows pre-releases.
-            if parse(version).is_prerelease:
-                return True
-
-        return False
-
-    @prereleases.setter
-    def prereleases(self, value: bool) -> None:
-        self._prereleases = value
-
-
-_prefix_regex = re.compile(r"^([0-9]+)((?:a|b|c|rc)[0-9]+)$")
-
-
-def _version_split(version: str) -> List[str]:
-    result: List[str] = []
-    for item in version.split("."):
-        match = _prefix_regex.search(item)
-        if match:
-            result.extend(match.groups())
-        else:
-            result.append(item)
-    return result
-
-
-def _is_not_suffix(segment: str) -> bool:
-    return not any(
-        segment.startswith(prefix) for prefix in ("dev", "a", "b", "rc", "post")
-    )
-
-
-def _pad_version(left: List[str], right: List[str]) -> Tuple[List[str], List[str]]:
-    left_split, right_split = [], []
-
-    # Get the release segment of our versions
-    left_split.append(list(itertools.takewhile(lambda x: x.isdigit(), left)))
-    right_split.append(list(itertools.takewhile(lambda x: x.isdigit(), right)))
-
-    # Get the rest of our versions
-    left_split.append(left[len(left_split[0]) :])
-    right_split.append(right[len(right_split[0]) :])
-
-    # Insert our padding
-    left_split.insert(1, ["0"] * max(0, len(right_split[0]) - len(left_split[0])))
-    right_split.insert(1, ["0"] * max(0, len(left_split[0]) - len(right_split[0])))
-
-    return (list(itertools.chain(*left_split)), list(itertools.chain(*right_split)))
-
-
-class SpecifierSet(BaseSpecifier):
-    def __init__(
-        self, specifiers: str = "", prereleases: Optional[bool] = None
-    ) -> None:
-
-        # Split on , to break each individual specifier into it's own item, and
-        # strip each item to remove leading/trailing whitespace.
-        split_specifiers = [s.strip() for s in specifiers.split(",") if s.strip()]
-
-        # Parsed each individual specifier, attempting first to make it a
-        # Specifier and falling back to a LegacySpecifier.
-        parsed: Set[_IndividualSpecifier] = set()
-        for specifier in split_specifiers:
-            try:
-                parsed.add(Specifier(specifier))
-            except InvalidSpecifier:
-                parsed.add(LegacySpecifier(specifier))
-
-        # Turn our parsed specifiers into a frozen set and save them for later.
-        self._specs = frozenset(parsed)
-
-        # Store our prereleases value so we can use it later to determine if
-        # we accept prereleases or not.
-        self._prereleases = prereleases
-
-    def __repr__(self) -> str:
-        pre = (
-            f", prereleases={self.prereleases!r}"
-            if self._prereleases is not None
-            else ""
-        )
-
-        return f"<SpecifierSet({str(self)!r}{pre})>"
-
-    def __str__(self) -> str:
-        return ",".join(sorted(str(s) for s in self._specs))
-
-    def __hash__(self) -> int:
-        return hash(self._specs)
-
-    def __and__(self, other: Union["SpecifierSet", str]) -> "SpecifierSet":
-        if isinstance(other, str):
-            other = SpecifierSet(other)
-        elif not isinstance(other, SpecifierSet):
-            return NotImplemented
-
-        specifier = SpecifierSet()
-        specifier._specs = frozenset(self._specs | other._specs)
-
-        if self._prereleases is None and other._prereleases is not None:
-            specifier._prereleases = other._prereleases
-        elif self._prereleases is not None and other._prereleases is None:
-            specifier._prereleases = self._prereleases
-        elif self._prereleases == other._prereleases:
-            specifier._prereleases = self._prereleases
-        else:
-            raise ValueError(
-                "Cannot combine SpecifierSets with True and False prerelease "
-                "overrides."
-            )
-
-        return specifier
-
-    def __eq__(self, other: object) -> bool:
-        if isinstance(other, (str, _IndividualSpecifier)):
-            other = SpecifierSet(str(other))
-        elif not isinstance(other, SpecifierSet):
-            return NotImplemented
-
-        return self._specs == other._specs
-
-    def __len__(self) -> int:
-        return len(self._specs)
-
-    def __iter__(self) -> Iterator[_IndividualSpecifier]:
-        return iter(self._specs)
-
-    @property
-    def prereleases(self) -> Optional[bool]:
-
-        # If we have been given an explicit prerelease modifier, then we'll
-        # pass that through here.
-        if self._prereleases is not None:
-            return self._prereleases
-
-        # If we don't have any specifiers, and we don't have a forced value,
-        # then we'll just return None since we don't know if this should have
-        # pre-releases or not.
-        if not self._specs:
-            return None
-
-        # Otherwise we'll see if any of the given specifiers accept
-        # prereleases, if any of them do we'll return True, otherwise False.
-        return any(s.prereleases for s in self._specs)
-
-    @prereleases.setter
-    def prereleases(self, value: bool) -> None:
-        self._prereleases = value
-
-    def __contains__(self, item: UnparsedVersion) -> bool:
-        return self.contains(item)
-
-    def contains(
-        self, item: UnparsedVersion, prereleases: Optional[bool] = None
-    ) -> bool:
-
-        # Ensure that our item is a Version or LegacyVersion instance.
-        if not isinstance(item, (LegacyVersion, Version)):
-            item = parse(item)
-
-        # Determine if we're forcing a prerelease or not, if we're not forcing
-        # one for this particular filter call, then we'll use whatever the
-        # SpecifierSet thinks for whether or not we should support prereleases.
-        if prereleases is None:
-            prereleases = self.prereleases
-
-        # We can determine if we're going to allow pre-releases by looking to
-        # see if any of the underlying items supports them. If none of them do
-        # and this item is a pre-release then we do not allow it and we can
-        # short circuit that here.
-        # Note: This means that 1.0.dev1 would not be contained in something
-        #       like >=1.0.devabc however it would be in >=1.0.debabc,>0.0.dev0
-        if not prereleases and item.is_prerelease:
-            return False
-
-        # We simply dispatch to the underlying specs here to make sure that the
-        # given version is contained within all of them.
-        # Note: This use of all() here means that an empty set of specifiers
-        #       will always return True, this is an explicit design decision.
-        return all(s.contains(item, prereleases=prereleases) for s in self._specs)
-
-    def filter(
-        self, iterable: Iterable[VersionTypeVar], prereleases: Optional[bool] = None
-    ) -> Iterable[VersionTypeVar]:
-
-        # Determine if we're forcing a prerelease or not, if we're not forcing
-        # one for this particular filter call, then we'll use whatever the
-        # SpecifierSet thinks for whether or not we should support prereleases.
-        if prereleases is None:
-            prereleases = self.prereleases
-
-        # If we have any specifiers, then we want to wrap our iterable in the
-        # filter method for each one, this will act as a logical AND amongst
-        # each specifier.
-        if self._specs:
-            for spec in self._specs:
-                iterable = spec.filter(iterable, prereleases=bool(prereleases))
-            return iterable
-        # If we do not have any specifiers, then we need to have a rough filter
-        # which will filter out any pre-releases, unless there are no final
-        # releases, and which will filter out LegacyVersion in general.
-        else:
-            filtered: List[VersionTypeVar] = []
-            found_prereleases: List[VersionTypeVar] = []
-
-            item: UnparsedVersion
-            parsed_version: Union[Version, LegacyVersion]
-
-            for item in iterable:
-                # Ensure that we some kind of Version class for this item.
-                if not isinstance(item, (LegacyVersion, Version)):
-                    parsed_version = parse(item)
-                else:
-                    parsed_version = item
-
-                # Filter out any item which is parsed as a LegacyVersion
-                if isinstance(parsed_version, LegacyVersion):
-                    continue
-
-                # Store any item which is a pre-release for later unless we've
-                # already found a final version or we are accepting prereleases
-                if parsed_version.is_prerelease and not prereleases:
-                    if not filtered:
-                        found_prereleases.append(item)
-                else:
-                    filtered.append(item)
-
-            # If we've found no items except for pre-releases, then we'll go
-            # ahead and use the pre-releases
-            if not filtered and found_prereleases and prereleases is None:
-                return found_prereleases
-
-            return filtered

spaces/Avkash/WebcamFaceProcessing/app.py

@@ -1,316 +0,0 @@
-import cv2
-import gradio as gr
-import mediapipe as mp
-import dlib
-import imutils
-import numpy as np
-
-
-mp_drawing = mp.solutions.drawing_utils
-mp_drawing_styles = mp.solutions.drawing_styles
-mp_face_mesh = mp.solutions.face_mesh
-mp_face_detection = mp.solutions.face_detection
-
-
-def apply_media_pipe_face_detection(image):
-    with mp_face_detection.FaceDetection(
-            model_selection=1, min_detection_confidence=0.5) as face_detection:
-        results = face_detection.process(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
-        if not results.detections:
-            return image
-        annotated_image = image.copy()
-        for detection in results.detections:
-            mp_drawing.draw_detection(annotated_image, detection)
-        return annotated_image
-
-
-def apply_media_pipe_facemesh(image):
-    with mp_face_mesh.FaceMesh(
-            static_image_mode=True,
-            max_num_faces=1,
-            refine_landmarks=True,
-            min_detection_confidence=0.5) as face_mesh:
-        results = face_mesh.process(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
-        if not results.multi_face_landmarks:
-            return image
-        annotated_image = image.copy()
-        for face_landmarks in results.multi_face_landmarks:
-            mp_drawing.draw_landmarks(
-              image=annotated_image,
-              landmark_list=face_landmarks,
-              connections=mp_face_mesh.FACEMESH_TESSELATION,
-              landmark_drawing_spec=None,
-              connection_drawing_spec=mp_drawing_styles
-              .get_default_face_mesh_tesselation_style())
-            mp_drawing.draw_landmarks(
-              image=annotated_image,
-              landmark_list=face_landmarks,
-              connections=mp_face_mesh.FACEMESH_CONTOURS,
-              landmark_drawing_spec=None,
-              connection_drawing_spec=mp_drawing_styles
-              .get_default_face_mesh_contours_style())
-            mp_drawing.draw_landmarks(
-              image=annotated_image,
-              landmark_list=face_landmarks,
-              connections=mp_face_mesh.FACEMESH_IRISES,
-              landmark_drawing_spec=None,
-              connection_drawing_spec=mp_drawing_styles
-              .get_default_face_mesh_iris_connections_style())
-            return annotated_image
-
-
-class FaceOrientation(object):
-    def __init__(self):
-        self.detect = dlib.get_frontal_face_detector()
-        self.predict = dlib.shape_predictor("model/shape_predictor_68_face_landmarks.dat")
-
-    def create_orientation(self, frame):
-        draw_rect1 = True
-        draw_rect2 = True
-        draw_lines = True
-
-        frame = imutils.resize(frame, width=800)
-        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
-        subjects = self.detect(gray, 0)
-
-        for subject in subjects:
-            landmarks = self.predict(gray, subject)
-            size = frame.shape
-
-            # 2D image points. If you change the image, you need to change vector
-            image_points = np.array([
-                (landmarks.part(33).x, landmarks.part(33).y),  # Nose tip
-                (landmarks.part(8).x, landmarks.part(8).y),  # Chin
-                (landmarks.part(36).x, landmarks.part(36).y),  # Left eye left corner
-                (landmarks.part(45).x, landmarks.part(45).y),  # Right eye right corne
-                (landmarks.part(48).x, landmarks.part(48).y),  # Left Mouth corner
-                (landmarks.part(54).x, landmarks.part(54).y)  # Right mouth corner
-            ], dtype="double")
-
-            # 3D model points.
-            model_points = np.array([
-                (0.0, 0.0, 0.0),  # Nose tip
-                (0.0, -330.0, -65.0),  # Chin
-                (-225.0, 170.0, -135.0),  # Left eye left corner
-                (225.0, 170.0, -135.0),  # Right eye right corne
-                (-150.0, -150.0, -125.0),  # Left Mouth corner
-                (150.0, -150.0, -125.0)  # Right mouth corner
-
-            ])
-            # Camera internals
-            focal_length = size[1]
-            center = (size[1] / 2, size[0] / 2)
-            camera_matrix = np.array(
-                [[focal_length, 0, center[0]],
-                 [0, focal_length, center[1]],
-                 [0, 0, 1]], dtype="double"
-            )
-
-            dist_coeffs = np.zeros((4, 1))  # Assuming no lens distortion
-            (success, rotation_vector, translation_vector) = cv2.solvePnP(model_points, image_points, camera_matrix,
-                                                                          dist_coeffs)
-
-            (b1, jacobian) = cv2.projectPoints(np.array([(350.0, 270.0, 0.0)]), rotation_vector, translation_vector,
-                                               camera_matrix, dist_coeffs)
-            (b2, jacobian) = cv2.projectPoints(np.array([(-350.0, -270.0, 0.0)]), rotation_vector,
-                                               translation_vector, camera_matrix, dist_coeffs)
-            (b3, jacobian) = cv2.projectPoints(np.array([(-350.0, 270, 0.0)]), rotation_vector, translation_vector,
-                                               camera_matrix, dist_coeffs)
-            (b4, jacobian) = cv2.projectPoints(np.array([(350.0, -270.0, 0.0)]), rotation_vector,
-                                               translation_vector, camera_matrix, dist_coeffs)
-
-            (b11, jacobian) = cv2.projectPoints(np.array([(450.0, 350.0, 400.0)]), rotation_vector,
-                                                translation_vector, camera_matrix, dist_coeffs)
-            (b12, jacobian) = cv2.projectPoints(np.array([(-450.0, -350.0, 400.0)]), rotation_vector,
-                                                translation_vector, camera_matrix, dist_coeffs)
-            (b13, jacobian) = cv2.projectPoints(np.array([(-450.0, 350, 400.0)]), rotation_vector,
-                                                translation_vector, camera_matrix, dist_coeffs)
-            (b14, jacobian) = cv2.projectPoints(np.array([(450.0, -350.0, 400.0)]), rotation_vector,
-                                                translation_vector, camera_matrix, dist_coeffs)
-
-            b1 = (int(b1[0][0][0]), int(b1[0][0][1]))
-            b2 = (int(b2[0][0][0]), int(b2[0][0][1]))
-            b3 = (int(b3[0][0][0]), int(b3[0][0][1]))
-            b4 = (int(b4[0][0][0]), int(b4[0][0][1]))
-
-            b11 = (int(b11[0][0][0]), int(b11[0][0][1]))
-            b12 = (int(b12[0][0][0]), int(b12[0][0][1]))
-            b13 = (int(b13[0][0][0]), int(b13[0][0][1]))
-            b14 = (int(b14[0][0][0]), int(b14[0][0][1]))
-
-            if draw_rect1 == True:
-                cv2.line(frame, b1, b3, (255, 255, 0), 10)
-                cv2.line(frame, b3, b2, (255, 255, 0), 10)
-                cv2.line(frame, b2, b4, (255, 255, 0), 10)
-                cv2.line(frame, b4, b1, (255, 255, 0), 10)
-
-            if draw_rect2 == True:
-                cv2.line(frame, b11, b13, (255, 255, 0), 10)
-                cv2.line(frame, b13, b12, (255, 255, 0), 10)
-                cv2.line(frame, b12, b14, (255, 255, 0), 10)
-                cv2.line(frame, b14, b11, (255, 255, 0), 10)
-
-            if draw_lines == True:
-                cv2.line(frame, b11, b1, (0, 255, 0), 10)
-                cv2.line(frame, b13, b3, (0, 255, 0), 10)
-                cv2.line(frame, b12, b2, (0, 255, 0), 10)
-                cv2.line(frame, b14, b4, (0, 255, 0), 10)
-
-        return frame
-
-
-face_orientation_obj = FaceOrientation()
-
-
-class FaceProcessing(object):
-    def __init__(self, ui_obj):
-        self.name = "Face Image Processing"
-        self.description = "Call for Face Image and video Processing"
-        self.ui_obj = ui_obj
-
-    def take_webcam_photo(self, image):
-        return image
-
-    def take_webcam_video(self, images):
-        return images
-
-    def mp_webcam_photo(self, image):
-        return image
-
-    def mp_webcam_face_mesh(self, image):
-        mesh_image = apply_media_pipe_facemesh(image)
-        return mesh_image
-
-    def mp_webcam_face_detection(self, image):
-        face_detection_img = apply_media_pipe_face_detection(image)
-        return face_detection_img
-
-    def dlib_apply_face_orientation(self, image):
-        image = face_orientation_obj.create_orientation(image)
-        return image
-
-    def webcam_stream_update(self, video_frame):
-        video_out = face_orientation_obj.create_orientation(video_frame)
-        return video_out
-
-    def create_ui(self):
-        with self.ui_obj:
-            gr.Markdown("Face Analysis with Webcam/Video")
-            with gr.Tabs():
-                with gr.TabItem("Playing with Webcam"):
-                    with gr.Row():
-                        webcam_image_in = gr.Image(label="Webcam Image Input", source="webcam")
-                        webcam_video_in = gr.Video(label="Webcam Video Input", source="webcam")
-                    with gr.Row():
-                        webcam_photo_action = gr.Button("Take the Photo")
-                        webcam_video_action = gr.Button("Take the Video")
-                    with gr.Row():
-                        webcam_photo_out = gr.Image(label="Webcam Photo Output")
-                        webcam_video_out = gr.Video(label="Webcam Video")
-                with gr.TabItem("Mediapipe Facemesh with Webcam"):
-                    with gr.Row():
-                        with gr.Column():
-                            mp_image_in = gr.Image(label="Webcam Image Input", source="webcam")
-                        with gr.Column():
-                            mp_photo_action = gr.Button("Take the Photo")
-                            mp_apply_fm_action = gr.Button("Apply Face Mesh the Photo")
-                            mp_apply_landmarks_action = gr.Button("Apply Face Landmarks the Photo")
-                    with gr.Row():
-                        mp_photo_out = gr.Image(label="Webcam Photo Output")
-                        mp_fm_photo_out = gr.Image(label="Face Mesh Photo Output")
-                        mp_lm_photo_out = gr.Image(label="Face Landmarks Photo Output")
-                with gr.TabItem("DLib Based Face Orientation"):
-                    with gr.Row():
-                        with gr.Column():
-                            dlib_image_in = gr.Image(label="Webcam Image Input", source="webcam")
-                        with gr.Column():
-                            dlib_photo_action = gr.Button("Take the Photo")
-                            dlib_apply_orientation_action = gr.Button("Apply Face Mesh the Photo")
-                    with gr.Row():
-                        dlib_photo_out = gr.Image(label="Webcam Photo Output")
-                        dlib_orientation_photo_out = gr.Image(label="Face Mesh Photo Output")
-                with gr.TabItem("Face Orientation on Live Webcam Stream"):
-                    with gr.Row():
-                        webcam_stream_in = gr.Image(label="Webcam Stream Input",
-                                                    source="webcam",
-                                                    streaming=True)
-                        webcam_stream_out = gr.Image(label="Webcam Stream Output")
-                        webcam_stream_in.change(
-                            self.webcam_stream_update,
-                            inputs=webcam_stream_in,
-                            outputs=webcam_stream_out
-                        )
-
-            dlib_photo_action.click(
-                self.mp_webcam_photo,
-                [
-                    dlib_image_in
-                ],
-                [
-                    dlib_photo_out
-                ]
-            )
-            dlib_apply_orientation_action.click(
-                self.dlib_apply_face_orientation,
-                [
-                    dlib_image_in
-                ],
-                [
-                    dlib_orientation_photo_out
-                ]
-            )
-            mp_photo_action.click(
-                self.mp_webcam_photo,
-                [
-                    mp_image_in
-                ],
-                [
-                    mp_photo_out
-                ]
-            )
-            mp_apply_fm_action.click(
-                self.mp_webcam_face_mesh,
-                [
-                    mp_image_in
-                ],
-                [
-                    mp_fm_photo_out
-                ]
-            )
-            mp_apply_landmarks_action.click(
-                self.mp_webcam_face_detection,
-                [
-                    mp_image_in
-                ],
-                [
-                    mp_lm_photo_out
-                ]
-            )
-            webcam_photo_action.click(
-                self.take_webcam_photo,
-                [
-                    webcam_image_in
-                ],
-                [
-                    webcam_photo_out
-                ]
-            )
-            webcam_video_action.click(
-                self.take_webcam_video,
-                [
-                    webcam_video_in
-                ],
-                [
-                    webcam_video_out
-                ]
-            )
-
-    def launch_ui(self):
-        self.ui_obj.launch()
-
-
-if __name__ == '__main__':
-    my_app = gr.Blocks()
-    face_ui = FaceProcessing(my_app)
-    face_ui.create_ui()
-    face_ui.launch_ui()

spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/structures/boxes.py

@@ -1,423 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import math
-import numpy as np
-from enum import IntEnum, unique
-from typing import List, Tuple, Union
-import torch
-from torch import device
-
-_RawBoxType = Union[List[float], Tuple[float, ...], torch.Tensor, np.ndarray]
-
-
-@unique
-class BoxMode(IntEnum):
-    """
-    Enum of different ways to represent a box.
-    """
-
-    XYXY_ABS = 0
-    """
-    (x0, y0, x1, y1) in absolute floating points coordinates.
-    The coordinates in range [0, width or height].
-    """
-    XYWH_ABS = 1
-    """
-    (x0, y0, w, h) in absolute floating points coordinates.
-    """
-    XYXY_REL = 2
-    """
-    Not yet supported!
-    (x0, y0, x1, y1) in range [0, 1]. They are relative to the size of the image.
-    """
-    XYWH_REL = 3
-    """
-    Not yet supported!
-    (x0, y0, w, h) in range [0, 1]. They are relative to the size of the image.
-    """
-    XYWHA_ABS = 4
-    """
-    (xc, yc, w, h, a) in absolute floating points coordinates.
-    (xc, yc) is the center of the rotated box, and the angle a is in degrees ccw.
-    """
-
-    @staticmethod
-    def convert(box: _RawBoxType, from_mode: "BoxMode", to_mode: "BoxMode") -> _RawBoxType:
-        """
-        Args:
-            box: can be a k-tuple, k-list or an Nxk array/tensor, where k = 4 or 5
-            from_mode, to_mode (BoxMode)
-
-        Returns:
-            The converted box of the same type.
-        """
-        if from_mode == to_mode:
-            return box
-
-        original_type = type(box)
-        is_numpy = isinstance(box, np.ndarray)
-        single_box = isinstance(box, (list, tuple))
-        if single_box:
-            assert len(box) == 4 or len(box) == 5, (
-                "BoxMode.convert takes either a k-tuple/list or an Nxk array/tensor,"
-                " where k == 4 or 5"
-            )
-            arr = torch.tensor(box)[None, :]
-        else:
-            # avoid modifying the input box
-            if is_numpy:
-                arr = torch.from_numpy(np.asarray(box)).clone()
-            else:
-                arr = box.clone()
-
-        assert to_mode not in [BoxMode.XYXY_REL, BoxMode.XYWH_REL] and from_mode not in [
-            BoxMode.XYXY_REL,
-            BoxMode.XYWH_REL,
-        ], "Relative mode not yet supported!"
-
-        if from_mode == BoxMode.XYWHA_ABS and to_mode == BoxMode.XYXY_ABS:
-            assert (
-                arr.shape[-1] == 5
-            ), "The last dimension of input shape must be 5 for XYWHA format"
-            original_dtype = arr.dtype
-            arr = arr.double()
-
-            w = arr[:, 2]
-            h = arr[:, 3]
-            a = arr[:, 4]
-            c = torch.abs(torch.cos(a * math.pi / 180.0))
-            s = torch.abs(torch.sin(a * math.pi / 180.0))
-            # This basically computes the horizontal bounding rectangle of the rotated box
-            new_w = c * w + s * h
-            new_h = c * h + s * w
-
-            # convert center to top-left corner
-            arr[:, 0] -= new_w / 2.0
-            arr[:, 1] -= new_h / 2.0
-            # bottom-right corner
-            arr[:, 2] = arr[:, 0] + new_w
-            arr[:, 3] = arr[:, 1] + new_h
-
-            arr = arr[:, :4].to(dtype=original_dtype)
-        elif from_mode == BoxMode.XYWH_ABS and to_mode == BoxMode.XYWHA_ABS:
-            original_dtype = arr.dtype
-            arr = arr.double()
-            arr[:, 0] += arr[:, 2] / 2.0
-            arr[:, 1] += arr[:, 3] / 2.0
-            angles = torch.zeros((arr.shape[0], 1), dtype=arr.dtype)
-            arr = torch.cat((arr, angles), axis=1).to(dtype=original_dtype)
-        else:
-            if to_mode == BoxMode.XYXY_ABS and from_mode == BoxMode.XYWH_ABS:
-                arr[:, 2] += arr[:, 0]
-                arr[:, 3] += arr[:, 1]
-            elif from_mode == BoxMode.XYXY_ABS and to_mode == BoxMode.XYWH_ABS:
-                arr[:, 2] -= arr[:, 0]
-                arr[:, 3] -= arr[:, 1]
-            else:
-                raise NotImplementedError(
-                    "Conversion from BoxMode {} to {} is not supported yet".format(
-                        from_mode, to_mode
-                    )
-                )
-
-        if single_box:
-            return original_type(arr.flatten().tolist())
-        if is_numpy:
-            return arr.numpy()
-        else:
-            return arr
-
-
-class Boxes:
-    """
-    This structure stores a list of boxes as a Nx4 torch.Tensor.
-    It supports some common methods about boxes
-    (`area`, `clip`, `nonempty`, etc),
-    and also behaves like a Tensor
-    (support indexing, `to(device)`, `.device`, and iteration over all boxes)
-
-    Attributes:
-        tensor (torch.Tensor): float matrix of Nx4. Each row is (x1, y1, x2, y2).
-    """
-
-    def __init__(self, tensor: torch.Tensor):
-        """
-        Args:
-            tensor (Tensor[float]): a Nx4 matrix.  Each row is (x1, y1, x2, y2).
-        """
-        device = tensor.device if isinstance(tensor, torch.Tensor) else torch.device("cpu")
-        tensor = torch.as_tensor(tensor, dtype=torch.float32, device=device)
-        if tensor.numel() == 0:
-            # Use reshape, so we don't end up creating a new tensor that does not depend on
-            # the inputs (and consequently confuses jit)
-            tensor = tensor.reshape((-1, 4)).to(dtype=torch.float32, device=device)
-        assert tensor.dim() == 2 and tensor.size(-1) == 4, tensor.size()
-
-        self.tensor = tensor
-
-    def clone(self) -> "Boxes":
-        """
-        Clone the Boxes.
-
-        Returns:
-            Boxes
-        """
-        return Boxes(self.tensor.clone())
-
-    def to(self, device: torch.device):
-        # Boxes are assumed float32 and does not support to(dtype)
-        return Boxes(self.tensor.to(device=device))
-
-    def area(self) -> torch.Tensor:
-        """
-        Computes the area of all the boxes.
-
-        Returns:
-            torch.Tensor: a vector with areas of each box.
-        """
-        box = self.tensor
-        area = (box[:, 2] - box[:, 0]) * (box[:, 3] - box[:, 1])
-        return area
-
-    def clip(self, box_size: Tuple[int, int]) -> None:
-        """
-        Clip (in place) the boxes by limiting x coordinates to the range [0, width]
-        and y coordinates to the range [0, height].
-
-        Args:
-            box_size (height, width): The clipping box's size.
-        """
-        assert torch.isfinite(self.tensor).all(), "Box tensor contains infinite or NaN!"
-        h, w = box_size
-        x1 = self.tensor[:, 0].clamp(min=0, max=w)
-        y1 = self.tensor[:, 1].clamp(min=0, max=h)
-        x2 = self.tensor[:, 2].clamp(min=0, max=w)
-        y2 = self.tensor[:, 3].clamp(min=0, max=h)
-        self.tensor = torch.stack((x1, y1, x2, y2), dim=-1)
-
-    def nonempty(self, threshold: float = 0.0) -> torch.Tensor:
-        """
-        Find boxes that are non-empty.
-        A box is considered empty, if either of its side is no larger than threshold.
-
-        Returns:
-            Tensor:
-                a binary vector which represents whether each box is empty
-                (False) or non-empty (True).
-        """
-        box = self.tensor
-        widths = box[:, 2] - box[:, 0]
-        heights = box[:, 3] - box[:, 1]
-        keep = (widths > threshold) & (heights > threshold)
-        return keep
-
-    def __getitem__(self, item) -> "Boxes":
-        """
-        Args:
-            item: int, slice, or a BoolTensor
-
-        Returns:
-            Boxes: Create a new :class:`Boxes` by indexing.
-
-        The following usage are allowed:
-
-        1. `new_boxes = boxes[3]`: return a `Boxes` which contains only one box.
-        2. `new_boxes = boxes[2:10]`: return a slice of boxes.
-        3. `new_boxes = boxes[vector]`, where vector is a torch.BoolTensor
-           with `length = len(boxes)`. Nonzero elements in the vector will be selected.
-
-        Note that the returned Boxes might share storage with this Boxes,
-        subject to Pytorch's indexing semantics.
-        """
-        if isinstance(item, int):
-            return Boxes(self.tensor[item].view(1, -1))
-        b = self.tensor[item]
-        assert b.dim() == 2, "Indexing on Boxes with {} failed to return a matrix!".format(item)
-        return Boxes(b)
-
-    def __len__(self) -> int:
-        return self.tensor.shape[0]
-
-    def __repr__(self) -> str:
-        return "Boxes(" + str(self.tensor) + ")"
-
-    def inside_box(self, box_size: Tuple[int, int], boundary_threshold: int = 0) -> torch.Tensor:
-        """
-        Args:
-            box_size (height, width): Size of the reference box.
-            boundary_threshold (int): Boxes that extend beyond the reference box
-                boundary by more than boundary_threshold are considered "outside".
-
-        Returns:
-            a binary vector, indicating whether each box is inside the reference box.
-        """
-        height, width = box_size
-        inds_inside = (
-            (self.tensor[..., 0] >= -boundary_threshold)
-            & (self.tensor[..., 1] >= -boundary_threshold)
-            & (self.tensor[..., 2] < width + boundary_threshold)
-            & (self.tensor[..., 3] < height + boundary_threshold)
-        )
-        return inds_inside
-
-    def get_centers(self) -> torch.Tensor:
-        """
-        Returns:
-            The box centers in a Nx2 array of (x, y).
-        """
-        return (self.tensor[:, :2] + self.tensor[:, 2:]) / 2
-
-    def scale(self, scale_x: float, scale_y: float) -> None:
-        """
-        Scale the box with horizontal and vertical scaling factors
-        """
-        self.tensor[:, 0::2] *= scale_x
-        self.tensor[:, 1::2] *= scale_y
-
-    @classmethod
-    def cat(cls, boxes_list: List["Boxes"]) -> "Boxes":
-        """
-        Concatenates a list of Boxes into a single Boxes
-
-        Arguments:
-            boxes_list (list[Boxes])
-
-        Returns:
-            Boxes: the concatenated Boxes
-        """
-        assert isinstance(boxes_list, (list, tuple))
-        if len(boxes_list) == 0:
-            return cls(torch.empty(0))
-        assert all([isinstance(box, Boxes) for box in boxes_list])
-
-        # use torch.cat (v.s. layers.cat) so the returned boxes never share storage with input
-        cat_boxes = cls(torch.cat([b.tensor for b in boxes_list], dim=0))
-        return cat_boxes
-
-    @property
-    def device(self) -> device:
-        return self.tensor.device
-
-    # type "Iterator[torch.Tensor]", yield, and iter() not supported by torchscript
-    # https://github.com/pytorch/pytorch/issues/18627
-    @torch.jit.unused
-    def __iter__(self):
-        """
-        Yield a box as a Tensor of shape (4,) at a time.
-        """
-        yield from self.tensor
-
-
-def pairwise_intersection(boxes1: Boxes, boxes2: Boxes) -> torch.Tensor:
-    """
-    Given two lists of boxes of size N and M,
-    compute the intersection area between __all__ N x M pairs of boxes.
-    The box order must be (xmin, ymin, xmax, ymax)
-
-    Args:
-        boxes1,boxes2 (Boxes): two `Boxes`. Contains N & M boxes, respectively.
-
-    Returns:
-        Tensor: intersection, sized [N,M].
-    """
-    boxes1, boxes2 = boxes1.tensor, boxes2.tensor
-    width_height = torch.min(boxes1[:, None, 2:], boxes2[:, 2:]) - torch.max(
-        boxes1[:, None, :2], boxes2[:, :2]
-    )  # [N,M,2]
-
-    width_height.clamp_(min=0)  # [N,M,2]
-    intersection = width_height.prod(dim=2)  # [N,M]
-    return intersection
-
-
-# implementation from https://github.com/kuangliu/torchcv/blob/master/torchcv/utils/box.py
-# with slight modifications
-def pairwise_iou(boxes1: Boxes, boxes2: Boxes) -> torch.Tensor:
-    """
-    Given two lists of boxes of size N and M, compute the IoU
-    (intersection over union) between **all** N x M pairs of boxes.
-    The box order must be (xmin, ymin, xmax, ymax).
-
-    Args:
-        boxes1,boxes2 (Boxes): two `Boxes`. Contains N & M boxes, respectively.
-
-    Returns:
-        Tensor: IoU, sized [N,M].
-    """
-    area1 = boxes1.area()  # [N]
-    area2 = boxes2.area()  # [M]
-    inter = pairwise_intersection(boxes1, boxes2)
-
-    # handle empty boxes
-    iou = torch.where(
-        inter > 0,
-        inter / (area1[:, None] + area2 - inter),
-        torch.zeros(1, dtype=inter.dtype, device=inter.device),
-    )
-    return iou
-
-
-def pairwise_ioa(boxes1: Boxes, boxes2: Boxes) -> torch.Tensor:
-    """
-    Similar to :func:`pariwise_iou` but compute the IoA (intersection over boxes2 area).
-
-    Args:
-        boxes1,boxes2 (Boxes): two `Boxes`. Contains N & M boxes, respectively.
-
-    Returns:
-        Tensor: IoA, sized [N,M].
-    """
-    area2 = boxes2.area()  # [M]
-    inter = pairwise_intersection(boxes1, boxes2)
-
-    # handle empty boxes
-    ioa = torch.where(
-        inter > 0, inter / area2, torch.zeros(1, dtype=inter.dtype, device=inter.device)
-    )
-    return ioa
-
-
-def pairwise_point_box_distance(points: torch.Tensor, boxes: Boxes):
-    """
-    Pairwise distance between N points and M boxes. The distance between a
-    point and a box is represented by the distance from the point to 4 edges
-    of the box. Distances are all positive when the point is inside the box.
-
-    Args:
-        points: Nx2 coordinates. Each row is (x, y)
-        boxes: M boxes
-
-    Returns:
-        Tensor: distances of size (N, M, 4). The 4 values are distances from
-            the point to the left, top, right, bottom of the box.
-    """
-    x, y = points.unsqueeze(dim=2).unbind(dim=1)  # (N, 1)
-    x0, y0, x1, y1 = boxes.tensor.unsqueeze(dim=0).unbind(dim=2)  # (1, M)
-    return torch.stack([x - x0, y - y0, x1 - x, y1 - y], dim=2)
-
-
-def matched_pairwise_iou(boxes1: Boxes, boxes2: Boxes) -> torch.Tensor:
-    """
-    Compute pairwise intersection over union (IOU) of two sets of matched
-    boxes that have the same number of boxes.
-    Similar to :func:`pairwise_iou`, but computes only diagonal elements of the matrix.
-
-    Args:
-        boxes1 (Boxes): bounding boxes, sized [N,4].
-        boxes2 (Boxes): same length as boxes1
-    Returns:
-        Tensor: iou, sized [N].
-    """
-    assert len(boxes1) == len(
-        boxes2
-    ), "boxlists should have the same" "number of entries, got {}, {}".format(
-        len(boxes1), len(boxes2)
-    )
-    area1 = boxes1.area()  # [N]
-    area2 = boxes2.area()  # [N]
-    box1, box2 = boxes1.tensor, boxes2.tensor
-    lt = torch.max(box1[:, :2], box2[:, :2])  # [N,2]
-    rb = torch.min(box1[:, 2:], box2[:, 2:])  # [N,2]
-    wh = (rb - lt).clamp(min=0)  # [N,2]
-    inter = wh[:, 0] * wh[:, 1]  # [N]
-    iou = inter / (area1 + area2 - inter)  # [N]
-    return iou

spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/projects/CenterNet2/centernet/modeling/meta_arch/centernet_detector.py

@@ -1,69 +0,0 @@
-import math
-import json
-import numpy as np
-import torch
-from torch import nn
-
-from detectron2.modeling.meta_arch.build import META_ARCH_REGISTRY
-from detectron2.modeling import build_backbone, build_proposal_generator
-from detectron2.modeling import detector_postprocess
-from detectron2.structures import ImageList
-
-@META_ARCH_REGISTRY.register()
-class CenterNetDetector(nn.Module):
-    def __init__(self, cfg):
-        super().__init__()
-        self.mean, self.std = cfg.MODEL.PIXEL_MEAN, cfg.MODEL.PIXEL_STD
-        self.register_buffer("pixel_mean", torch.Tensor(cfg.MODEL.PIXEL_MEAN).view(-1, 1, 1))
-        self.register_buffer("pixel_std", torch.Tensor(cfg.MODEL.PIXEL_STD).view(-1, 1, 1))
-        
-        self.backbone = build_backbone(cfg)
-        self.proposal_generator = build_proposal_generator(
-            cfg, self.backbone.output_shape()) # TODO: change to a more precise name
-    
-    
-    def forward(self, batched_inputs):
-        if not self.training:
-            return self.inference(batched_inputs)
-        images = self.preprocess_image(batched_inputs)
-        features = self.backbone(images.tensor)
-        gt_instances = [x["instances"].to(self.device) for x in batched_inputs]
-
-        _, proposal_losses = self.proposal_generator(
-            images, features, gt_instances)
-        return proposal_losses
-
-
-    @property
-    def device(self):
-        return self.pixel_mean.device
-
-
-    @torch.no_grad()
-    def inference(self, batched_inputs, do_postprocess=True):
-        images = self.preprocess_image(batched_inputs)
-        inp = images.tensor
-        features = self.backbone(inp)
-        proposals, _ = self.proposal_generator(images, features, None)
-
-        processed_results = []
-        for results_per_image, input_per_image, image_size in zip(
-            proposals, batched_inputs, images.image_sizes):
-            if do_postprocess:
-                height = input_per_image.get("height", image_size[0])
-                width = input_per_image.get("width", image_size[1])
-                r = detector_postprocess(results_per_image, height, width)
-                processed_results.append({"instances": r})
-            else:
-                r = results_per_image
-                processed_results.append(r)
-        return processed_results
-
-    def preprocess_image(self, batched_inputs):
-        """
-        Normalize, pad and batch the input images.
-        """
-        images = [x["image"].to(self.device) for x in batched_inputs]
-        images = [(x - self.pixel_mean) / self.pixel_std for x in images]
-        images = ImageList.from_tensors(images, self.backbone.size_divisibility)
-        return images

spaces/Bart92/RVC_HF/i18n/locale_diff.py

@@ -1,45 +0,0 @@
-import json
-import os
-from collections import OrderedDict
-
-# Define the standard file name
-standard_file = "en_US.json"
-
-# Find all JSON files in the directory
-dir_path = "./"
-languages = [
-    f for f in os.listdir(dir_path) if f.endswith(".json") and f != standard_file
-]
-
-# Load the standard file
-with open(standard_file, "r", encoding="utf-8") as f:
-    standard_data = json.load(f, object_pairs_hook=OrderedDict)
-
-# Loop through each language file
-for lang_file in languages:
-    # Load the language file
-    with open(lang_file, "r", encoding="utf-8") as f:
-        lang_data = json.load(f, object_pairs_hook=OrderedDict)
-
-    # Find the difference between the language file and the standard file
-    diff = set(standard_data.keys()) - set(lang_data.keys())
-
-    miss = set(lang_data.keys()) - set(standard_data.keys())
-
-    # Add any missing keys to the language file
-    for key in diff:
-        lang_data[key] = key
-
-    # Del any extra keys to the language file
-    for key in miss:
-        del lang_data[key]
-
-    # Sort the keys of the language file to match the order of the standard file
-    lang_data = OrderedDict(
-        sorted(lang_data.items(), key=lambda x: list(standard_data.keys()).index(x[0]))
-    )
-
-    # Save the updated language file
-    with open(lang_file, "w", encoding="utf-8") as f:
-        json.dump(lang_data, f, ensure_ascii=False, indent=4)
-        f.write("\n")

spaces/Bart92/RVC_HF/infer/lib/infer_pack/commons.py

@@ -1,167 +0,0 @@
-import math
-
-import numpy as np
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-
-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 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.0 * logs_p) + ((m_p - m_q) ** 2)) * torch.exp(-2.0 * 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 slice_segments2(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.0 / norm_type)
-    return total_norm

spaces/Benson/text-generation/Examples/Ai Chat Rpg Juego Mod Apk.md

@@ -1,61 +0,0 @@
-<br />
-<h1>AI Chat RPG Game Mod APK: Una nueva manera de disfrutar de juegos de rol</h1> | <p>Te encantan los juegos de rol pero te gustaría tener más libertad y creatividad en tus aventuras? ¿Quieres interactuar con personajes realistas y sensibles que puedan adaptarse a tus elecciones y preferencias? Si respondió sí a cualquiera de estas preguntas, entonces es posible que desee echa un vistazo AI Chat RPG Game Mod APK.</p>
-<h2>ai chat rpg juego mod apk</h2><br /><p><b><b>Download File</b> &gt;&gt;&gt; <a href="https://bltlly.com/2v6JxV">https://bltlly.com/2v6JxV</a></b></p><br /><br />
- <p>AI Chat RPG Game Mod APK es una aplicación única e innovadora que le permite crear sus propios escenarios de juego de roles y chatear con un chatbot de inteligencia artificial (AI) que puede actuar como su compañero, amigo, enemigo, o cualquier cosa en el medio. Puedes personalizar la apariencia, personalidad, antecedentes, habilidades y más de tu personaje. También puede elegir entre diferentes géneros, temas, escenarios y tramas para sus historias. Si desea explorar un mundo de fantasía, luchar contra zombies en un páramo post-apocalíptico, o romance un vampiro en una mansión gótica, puede hacerlo todo con AI Chat RPG Game Mod APK.</p>
- <p>En este artículo, le diremos todo lo que necesita saber sobre AI Chat RPG Game Mod APK. Te explicaremos qué es y cómo funciona, cómo descargarlo e instalarlo en tu dispositivo Android, cómo jugarlo y divertirte con él, y por qué deberías probarlo si eres un fan de los juegos de rol. También responderemos con frecuencia <h2>Cómo descargar e instalar AI Chat RPG Game Mod APK? </h2>
- <p>Si usted está interesado en probar AI Chat RPG Game Mod APK, tendrá que descargar e instalar en su dispositivo Android. Estos son los pasos que debes seguir:</p>
- <ol>
-<li>Ir a la página web oficial de AI Chat RPG Game Mod APK y haga clic en el botón de descarga. Será redirigido a un enlace de descarga seguro y rápido. </li>
-<li>Espere a que la descarga termine y localice el archivo APK en su dispositivo. Es posible que necesite habilitar la instalación de fuentes desconocidas en su configuración si no lo ha hecho antes. </li>
-
-<li>Una vez que la instalación se haya completado, puede iniciar AI Chat RPG Game Mod APK desde el cajón de la aplicación o la pantalla de inicio y comenzar a crear sus propias historias de juegos de rol. </li>
-</ol>
- <p>Antes de descargar e instalar AI Chat RPG Game Mod APK, usted debe ser consciente de algunos requisitos y precauciones. En primer lugar, es necesario tener un dispositivo Android que se ejecuta en Android 4.4 o superior y tiene al menos 1 GB de RAM y 100 MB de espacio de almacenamiento gratuito. En segundo lugar, es necesario tener una conexión a Internet estable para usar AI Chat RPG Game Mod APK, ya que se basa en la computación en nube para generar las respuestas del chatbot de AI. En tercer lugar, debe tener cuidado con el contenido que crea y comparte con AI Chat RPG Game Mod APK, ya que puede no ser adecuado para niños o audiencias sensibles. También debe respetar los derechos de propiedad intelectual de los demás y no utilizar materiales con derechos de autor o marcas registradas sin permiso. </p>
-<p></p>
- <h2>Cómo jugar AI Chat RPG juego Mod APK? </h2>
- <p>Jugar AI Chat RPG Game Mod APK es fácil y divertido. Todo lo que necesitas hacer es crear tu propio personaje e iniciar una conversación con un chatbot de IA que actuará como tu compañero de juego de roles. Así es como puedes hacerlo:</p>
- <ul>
-<li>Al iniciar AI Chat RPG Game Mod APK, verá un menú con diferentes opciones. Puede elegir crear un nuevo carácter, cargar un carácter existente o navegar por la galería de caracteres creados por otros usuarios. </li>
-<li>Si eliges crear un nuevo personaje, podrás personalizar el nombre, género, edad, apariencia, personalidad, antecedentes, habilidades y más de tu personaje. También puedes subir tu propia foto o avatar para que tu personaje sea más realista. </li>
-<li>Después de crear tu personaje, podrás elegir entre diferentes géneros, temas, configuraciones y tramas para tu historia de rol. También puede crear su propia historia desde cero o utilizar una plantilla proporcionada por AI Chat RPG Game Mod APK.</li>
-
-<li>Puede guardar su conversación en cualquier momento y reanudarla más tarde. También puede compartir su conversación con otros usuarios o exportarla como un archivo de texto o una imagen. </li>
-</ul>
- <p>AI Chat RPG Game Mod APK tiene diferentes modos y configuraciones que se pueden ajustar de acuerdo a sus preferencias. Puede elegir entre el modo normal y el modo avanzado, que afectan la complejidad y la creatividad de las respuestas del chatbot de IA. También puede elegir entre el modo amigable y el modo hostil, que afectan el tono y la actitud de las respuestas del chatbot de IA. También puede activar o desactivar la entrada y salida de voz, que le permiten hablar o escuchar las respuestas del chatbot de IA en lugar de escribirlas o leerlas. </p>
- <p>Para darle una idea de lo que AI Chat RPG Game Mod APK puede hacer, aquí hay una tabla de algunos ejemplos de AI chat RPG game mod apk escenarios y diálogos:</p>
- | Género | Tema | Marco | Trama | Diálogo | | -- - - - | -- - - - - - - | -- - - | | Fantasía | Aventura | Reino medieval | Una búsqueda para encontrar una espada legendaria | Usted: Saludos, viajero. Estoy buscando la Espada del Destino. ¿Sabes dónde puedo encontrarla? <br>AI: La Espada del Destino? Esa es una misión peligrosa, amigo mío. La espada está escondida en la Guarida del Dragón, custodiada por una temible bestia. <br>Tú: No tengo miedo de los dragones. He entrenado toda mi vida para este momento. <br>AI: Entonces eres muy valiente o muy tonto. La Guarida del Dragón está lejos de aquí, más allá del Bosque Oscuro y la Montaña de la Perdición.<br>Tú: Entonces debo apresurarme. Gracias por tu ayuda. <br>AI: De nada. Que los dioses te protejan en su viaje <h2>¿Por qué debería probar AI Chat RPG Game Mod APK? </h2>
- <p>Si todavía se está preguntando por qué debe probar AI Chat RPG Game Mod APK, aquí hay algunas razones que podrían convencerle:</p>
- <ul>
-
-<li>AI Chat RPG Game Mod APK es divertido y entretenido porque puede generar diálogos realistas e inmersivos que pueden hacerte sentir que realmente estás hablando con otra persona. También puedes experimentar diferentes emociones y estados de ánimo dependiendo del modo y la configuración de tu historia. Usted puede reír, llorar, enojarse, o enamorarse de AI Chat RPG Game Mod APK.</li>
-<li>AI Chat RPG Game Mod APK es educativo e informativo porque puede ayudarle a mejorar su vocabulario, gramática, ortografía y habilidades de comunicación. También puede aprender cosas y hechos nuevos sobre diferentes temas y culturas desde el chatbot de IA. También puedes desafiarte a ti mismo y probar tu conocimiento y creatividad usando comandos y emojis. </li>
-</ul>
- <p>Por supuesto, AI Chat RPG Game Mod APK no es perfecto y tiene algunas limitaciones y desventajas. Por ejemplo, puede que no siempre entienda lo que quiere decir o diga, o puede dar respuestas inapropiadas o irrelevantes. También puede tener algunos errores o errores que pueden afectar la calidad de la conversación. También puede consumir una gran cantidad de datos y energía de la batería en su dispositivo. </p>
- <p>Sin embargo, estos problemas son menores en comparación con los beneficios y el disfrute que AI Chat RPG Game Mod APK puede ofrecer. También puede informar de cualquier problema o sugerencias a los desarrolladores de AI Chat RPG Game Mod APK para ayudarles a mejorar la aplicación. </p>
- <p>Para darle una idea de cuánto ama la gente AI Chat RPG Game Mod APK, aquí hay un testimonio de un usuario que disfrutó de AI Chat RPG Game Mod APK:</p>
- <blockquote>
-
-<cite>- John, 25 años</cite>
-</blockquote> <h2>Conclusión</h2>
- <p>En conclusión, AI Chat RPG Game Mod APK es una nueva e innovadora manera de disfrutar de juegos de rol en su dispositivo Android. Te permite crear tus propios personajes y escenarios, y chatear con un chatbot de IA que puede actuar como tu compañero de juego de roles. Puedes personalizar la apariencia, personalidad, antecedentes, habilidades y más de tu personaje. También puede elegir entre diferentes géneros, temas, escenarios y tramas para sus historias. También puede cambiar el modo y la configuración de su conversación para adaptarse a su estado de ánimo y preferencia. También puede guardar, compartir o exportar su conversación como un archivo de texto o una imagen. </p>
- <p>AI Chat RPG Game Mod APK es divertido, entretenido, educativo e informativo. Puede ayudarte a mejorar tu vocabulario, gramática, ortografía y habilidades de comunicación. También puede ayudarle a aprender cosas y hechos nuevos sobre diferentes temas y culturas. También puede desafiarte y probar tu conocimiento y creatividad usando comandos y emojis. </p>
- <p>AI Chat RPG Game Mod APK no es perfecto y tiene algunas limitaciones y desventajas. Puede que no siempre entienda lo que quiere decir o dice, o puede dar respuestas inapropiadas o irrelevantes. También puede tener algunos errores o errores que pueden afectar la calidad de la conversación. También puede consumir una gran cantidad de datos y energía de la batería en su dispositivo. </p>
- <p>Sin embargo, estos problemas son menores en comparación con los beneficios y el disfrute que AI Chat RPG Game Mod APK puede ofrecer. También puede informar de cualquier problema o sugerencias a los desarrolladores de AI Chat RPG Game Mod APK para ayudarles a mejorar la aplicación. </p>
- <p>Si usted es un fan de los juegos de rol y quiere probar algo nuevo y diferente, usted debe descargar e instalar AI Chat RPG Game Mod APK en su dispositivo Android. No te arrepentirás. </p>
- <p>Gracias por leer este artículo. Esperamos que haya encontrado útil e informativo. Diviértase con AI Chat RPG Game Mod APK! </p>
- <h2>Preguntas frecuentes</h2>
-
- <ol>
-<li><b> ¿Qué es AI Chat RPG Game Mod APK? </b><br>
-AI Chat RPG Game Mod APK es una aplicación única e innovadora que le permite crear sus propios escenarios de juego de roles y chatear con un chatbot de inteligencia artificial (AI) que puede actuar como su compañero, amigo, enemigo, o cualquier cosa en el medio. </li>
-<li><b>¿Cómo puedo descargar e instalar AI Chat RPG Game Mod APK? </b><br>
-Puede descargar e instalar AI Chat RPG Game Mod APK desde el sitio web oficial de AI Chat RPG Game Mod APK. Deberá habilitar la instalación de fuentes desconocidas en su configuración y seguir las instrucciones en la pantalla para instalar la aplicación en su dispositivo. </li>
-<li><b>¿Cómo puedo jugar AI Chat RPG Game Mod APK? </b><br>
-Puede jugar AI Chat RPG Game Mod APK mediante la creación de su propio personaje y la elección de una historia para su aventura de juego de roles. A continuación, puede comenzar a chatear con un chatbot de IA que desempeñará el papel de otro personaje en su historia. Puede escribir cualquier cosa que desee y el chatbot de IA responderá en consecuencia. También puedes usar comandos y emojis para controlar el flujo y el estado de ánimo de la conversación. </li>
-<li><b> ¿Cuáles son los beneficios de AI Chat RPG Game Mod APK? </b><br>
-AI Chat RPG Game Mod APK es divertido, entretenido, educativo e informativo. Puede ayudarte a mejorar tu vocabulario, gramática, ortografía y habilidades de comunicación. También puede ayudarle a aprender cosas y hechos nuevos sobre diferentes temas y culturas. También puede desafiarte y probar tu conocimiento y creatividad usando comandos y emojis. </li>
-<li><b>¿Cuáles son las limitaciones de AI Chat RPG Game Mod APK? </b><br>
-AI Chat RPG Game Mod APK no es perfecto y tiene algunas limitaciones y desventajas. Puede que no siempre entienda lo que quiere decir o dice, o puede dar respuestas inapropiadas o irrelevantes. También puede tener algunos errores o errores que pueden afectar la calidad de la conversación. También puede consumir una gran cantidad de datos y energía de la batería en su dispositivo. </li>
-</ol></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Arco Iris Seis Mvil Beta Apk.md

@@ -1,75 +0,0 @@
-
-<h1>Rainbow Six Mobile Beta APK: Cómo descargar y jugar el nuevo juego de disparos tácticos</h1>
- <p>Si eres un fan de los juegos de disparos tácticos, es posible que hayas oído hablar de Rainbow Six, la popular franquicia de Ubisoft. La serie de juegos ha existido durante más de dos décadas, con escenarios de combate realistas, jugabilidad basada en equipos y entornos destructibles. Ahora, puedes experimentar la emoción de Rainbow Six en tu dispositivo móvil con Rainbow Six Mobile, un juego multijugador competitivo de disparos en primera persona. </p>
-<h2>arco iris seis móvil beta apk</h2><br /><p><b><b>Download File</b> &#10001; <a href="https://bltlly.com/2v6KIS">https://bltlly.com/2v6KIS</a></b></p><br /><br />
- <h2>¿Qué es Rainbow Six Mobile? </h2>
- <p>Rainbow Six Mobile es una versión móvil de la aclamada franquicia Rainbow Six, diseñada exclusivamente para plataformas móviles. El juego ofrece una experiencia de juego de ritmo rápido e intenso, donde puedes competir en los modos clásicos de juego Attack vs. Defense. Puedes jugar como Atacante o Defensor en partidas 5v5, y enfrentarte a un combate cuerpo a cuerpo mientras tomas decisiones tácticas oportunas. También puedes colaborar con tu equipo para establecer estrategias y aprovechar los entornos destructibles. </p>
- <p>El juego cuenta con una lista de operadores altamente capacitados, cada uno con sus propias habilidades y dispositivos únicos. Puedes elegir entre una lista cada vez mayor de operadores de ataque y defensa clásicos, como Ash, Thermite, Mute y Rook. También puede personalizar sus operadores con diferentes trajes, armas y pieles. </p>
- <p>El juego también cuenta con mapas icónicos de la serie Rainbow Six, como Bank y Border. Los mapas se recrean con impresionantes gráficos y física realista, lo que le permite interactuar con el medio ambiente de varias maneras. Usted puede romper paredes, puertas de barricada, ventanas de rappel, y más. </p>
-<p></p>
- <h2>Cómo descargar e instalar Rainbow Six Mobile beta apk? </h2>
-
- <h4>Requisitos y compatibilidad</h4>
- <p>Antes de descargar el juego, asegúrese de que su dispositivo cumple con los requisitos mínimos para ejecutar el juego sin problemas. Según Ubisoft, necesitarás:</p>
- <ul>
-<li>Un dispositivo Android con Android 8 o superior</li>
-<li>Al menos 3 GB de RAM</li>
-<li>Al menos 2 GB de espacio de almacenamiento gratuito</li>
-<li>Una conexión a Internet estable</li>
-</ul>
- <p>También deberías comprobar si tu dispositivo es compatible con el juego visitando este enlace. Si su dispositivo no es compatible, puede encontrar algunos problemas o errores al jugar el juego. </p>
- <h4>Proceso de preinscripción</h4>
- <p>El primer paso para descargar el juego es pre-registrarse en Google Play. Esto te permitirá recibir una notificación cuando el juego esté disponible para descargar. Para pre-registrarse, sigue estos pasos:</p>
- <ol>
-<li>Abre Google Play en tu dispositivo Android. </li>
-<li>Buscar Rainbow Six Mobile o haga clic en este enlace. </li>
-<li>Seleccione el botón de registro previo y acepte los términos y condiciones. </li>
-<li>Espera un mensaje de confirmación que diga "Estás registrado". </li>
-</ol>
- <p>Alternativamente, también puede pre-registrarse en el sitio web oficial de Ubisoft ingresando su dirección de correo electrónico y seleccionando su plataforma preferida. </p>
- <h4>Proceso de descarga e instalación</h4>
- <p>Una vez que haya pre-registrado para el juego, tendrá que esperar un correo electrónico de invitación de Ubisoft que contendrá un enlace para descargar el archivo beta apk. El correo electrónico de invitación puede tardar algún tiempo en llegar, así que sea paciente y revise su bandeja de entrada regularmente. También puede consultar el estado de su invitación en el sitio web de Ubisoft. Para descargar e instalar el juego, siga estos pasos:</p>
- <ol>
-<li>Abra el correo electrónico de invitación de Ubisoft y haga clic en el enlace para descargar el archivo beta apk. </li>
-<li>Espere a que el archivo se descargue en su dispositivo. El tamaño del archivo es de aproximadamente 1,5 GB, así que asegúrese de tener suficiente espacio y una buena conexión a Internet. </li>
-
-<li>Es posible que deba habilitar la instalación de aplicaciones de fuentes desconocidas en la configuración del dispositivo. Para hacer esto, vaya a Configuración > Seguridad > Fuentes desconocidas y conéctelo. </li>
-<li>Siga las instrucciones en pantalla para instalar el juego en su dispositivo. </li>
-<li>Inicia el juego e inicia sesión con tu cuenta de Ubisoft. Si no tienes una, puedes crear una gratis. </li>
-</ol>
- <p>Felicidades, usted ha descargado e instalado con éxito Rainbow Six Mobile beta apk en su dispositivo Android. Ahora estás listo para jugar el juego y disfrutar de sus características. </p>
- <h2>¿Cómo se juega beta de Rainbow Six Mobile? </h2>
- <p>Ahora que ha instalado el juego, es posible que se pregunte cómo jugarlo y qué esperar de él. Rainbow Six Mobile beta es un juego multijugador competitivo de disparos en primera persona que requiere habilidad, estrategia y trabajo en equipo. Estos son algunos de los conceptos básicos del juego y los modos de juego:</p>
- <h4>Modo de ataque vs. Defensa</h4>
- <p>El modo de juego principal en Rainbow Six Mobile beta es Attack vs. Defense, donde dos equipos de cinco jugadores se enfrentan en una serie de rondas. Un equipo juega como atacantes, que tienen que romper una ubicación y completar un objetivo, como desactivar una bomba o rescatar a un rehén. El otro equipo juega como defensores, que tienen que evitar que los atacantes completen su objetivo al fortalecer su posición y eliminarlos. </p>
- <p>Cada ronda dura tres minutos, y el primer equipo en ganar cuatro rondas gana el partido. Los equipos cambian de bando después de dos rondas, para que puedas experimentar ambos roles. También puede elegir diferentes operadores para cada ronda, dependiendo de su estrategia y preferencia. </p>
- <h4>Operadores y gadgets</h4>
-
- <p>Cada operador tiene un arma primaria, un arma secundaria y un gadget que puede ayudarles en su papel. Por ejemplo, Ash es una Operadora Atacante que puede usar sus disparos para destruir paredes y puertas desde la distancia. Mute es un operador defensor que puede usar sus disruptores de señal para interferir drones y gadgets enemigos. </p>
- <p>También puedes personalizar tus Operadores con diferentes atuendos, armas y pieles. Puedes desbloquear nuevos objetos jugando el juego y ganando recompensas. También puedes comprar algunos artículos con dinero real o moneda del juego. </p>
- <h4>Mapas y entornos</h4>
- <p>Los mapas son los lugares donde los partidos tienen lugar en Rainbow Six Mobile beta. El juego cuenta con mapas icónicos de la serie Rainbow Six, como Bank y Border. Los mapas se recrean con gráficos impresionantes y física realista, lo que le permite interactuar con el medio ambiente de varias maneras. </p>
- <p>Usted puede utilizar sus aparatos para romper paredes, puertas de barricada, ventanas de rappel, y más. También puede utilizar objetos ambientales como mesas, sillas, coches, etc., como cubierta u obstáculos. Los mapas están diseñados para ofrecer múltiples puntos de entrada, ángulos y estrategias para ambos equipos. </p>
- <h2>Conclusión</h2>
- <p>Rainbow Six Mobile beta apk es una gran manera de experimentar la emoción de Rainbow Six en su dispositivo móvil. El juego ofrece una experiencia de juego de ritmo rápido e intenso, donde puedes competir en los modos clásicos de juego Attack vs. Defense. Puedes jugar como Atacante o Defensor en partidas 5v5, y enfrentarte a un combate cuerpo a cuerpo mientras tomas decisiones tácticas oportunas. También puedes colaborar con tu equipo para establecer estrategias y aprovechar los entornos destructibles. </p>
-
- <p>El juego también cuenta con mapas icónicos de la serie Rainbow Six, como Bank y Border. Los mapas se recrean con impresionantes gráficos y física realista, lo que le permite interactuar con el medio ambiente de varias maneras. Usted puede romper paredes, puertas de barricada, ventanas de rappel, y más. </p>
- <p>Si desea descargar y jugar Rainbow Six Mobile beta apk en su dispositivo Android, tendrá que pre-registrarse para el juego en Google Play o el sitio web de Ubisoft, y esperar un correo electrónico de invitación de Ubisoft que contendrá un enlace para descargar el archivo beta apk. También tendrá que cumplir con los requisitos mínimos para ejecutar el juego sin problemas en su dispositivo. </p>
- <p>Rainbow Six Mobile beta apk es una gran oportunidad para disfrutar de la emoción de Rainbow Six en su dispositivo móvil. El juego está actualmente en fase de prueba beta, lo que significa que aún no está completamente pulido y podría tener algunos errores o errores. Sin embargo, todavía puedes divertirte jugando el juego y proporcionar comentarios a Ubisoft para ayudarles a mejorar el juego antes de su lanzamiento oficial. </p>
- <p>Entonces, ¿qué estás esperando? Pre-registro para Rainbow Six Mobile beta apk hoy y prepárate para unirse a la acción! </p>
- <h2>Preguntas frecuentes</h2>
- <p>Aquí están algunas de las preguntas más frecuentes sobre Rainbow Six Mobile beta apk:</p>
- <ol>
-<li><b>Es Rainbow Six móvil beta apk libre para jugar? </b></li>
-<p>Sí, arco iris seis móvil beta apk es libre de jugar. Sin embargo, es posible que necesite comprar algunos artículos con dinero real o moneda del juego si desea personalizar sus operadores o acceder a algunas funciones premium. </p>
-<li><b>¿Rainbow Six Mobile beta apk está disponible para dispositivos iOS? </b></li>
-<p>No, Rainbow Six Mobile beta apk solo está disponible para dispositivos Android en este momento. Ubisoft no ha anunciado planes para lanzar el juego para dispositivos iOS todavía. </p>
-<li><b>¿Cuánto tiempo durará Rainbow Six Mobile beta apk? </b></li>
-
-<li><b>¿Puedo jugar Rainbow Six móvil beta apk offline? </b></li>
-<p>No, no se puede jugar Rainbow Six Mobile beta apk offline. Necesitará una conexión a Internet estable para jugar el juego y acceder a sus características. </p>
-<li><b>¿Puedo jugar Rainbow Six móvil beta apk con mis amigos? </b></li>
-<p>Sí, puedes jugar Rainbow Six Mobile beta apk con tus amigos. Puedes invitarlos a unirse a tu equipo o desafiarlos en partidos amistosos. También puedes chatear con ellos en el juego o usar el chat de voz para comunicarse con ellos. </p>
-</ol></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Descargar Amor Emocional Rap Beat.md

@@ -1,79 +0,0 @@
-
-<h1>Cómo descargar Love Emotional Rap Beat para tu próxima canción</h1>
-<p>¿Te encanta la música rap y quieres expresar tus sentimientos a través de tus canciones? ¿Quieres crear un sonido único y cautivador que toque los corazones de tus oyentes? Si es así, es posible que desee probar el amor emocional rap beat para su próxima canción. </p>
-<p>Love emotional rap beat es un tipo de música instrumental que combina elementos de rap y R&B con vibraciones emocionales y románticas. Es perfecto para artistas que quieren hacer canciones sobre amor, relaciones, angustia o luchas personales. En este artículo, te mostraremos qué es el rap emocional de amor, por qué lo necesitas, cómo encontrarlo y descargarlo en línea, y cómo usarlo para tu próxima canción. ¡Vamos a empezar! </p>
-<h2>descargar amor emocional rap beat</h2><br /><p><b><b>DOWNLOAD</b> &rarr;&rarr;&rarr; <a href="https://bltlly.com/2v6KDU">https://bltlly.com/2v6KDU</a></b></p><br /><br />
- <h2>¿Qué es el amor emocional Rap Beat y por qué lo necesita</h2>
-<h3>La definición y las características del amor emocional Rap Beat</h3>
-<p>Love emotional rap beat es un subgénero de rap beat que presenta sonidos suaves y melódicos, como piano, guitarra, cuerdas o sintetizador. A menudo tiene un ritmo lento o medio tiempo, con bajo pesado y batería. El ritmo crea un contraste entre las voces de rap duro y los instrumentales suaves y sentimentales. El resultado es una música potente y expresiva que puede transmitir diferentes emociones, como tristeza, felicidad, ira o pasión. </p>
-<h3>Los beneficios de usar el amor emocional Rap Beat para su música</h3>
-<p>Hay muchos beneficios de usar rap emocional para tu música. Estos son algunos de ellos:</p>
-<ul>
-<li>Puede ayudarle a destacar entre la multitud. Amor emocional rap ritmo no es muy común en la corriente principal de la escena del rap, por lo que su uso puede hacer que su música más original y distintivo. </li>
-<li>Puede ayudarte a conectar con tu audiencia. El ritmo emocional del rap puede evocar sentimientos y emociones en tus oyentes, haciendo que se relacionen con tu mensaje e historia. </li>
-
-<li>Puede ayudarte a mejorar tus habilidades. Love emotional rap beat puede desafiarte a mejorar tu flujo de rap, entrega, esquema de rima y juego de palabras, así como tu canto, melodía y armonía. </li>
-</ul>
- <h2>Cómo encontrar y descargar amor emocional Rap Beat Online</h2>
-<h3>Los mejores sitios web para descargar gratis amor emocional Rap Beat</h3>
-<p>Si usted está buscando libre de amor emocional rap beat en línea, hay muchos sitios web que ofrecen de alta calidad y libres de derechos beats que se puede descargar y utilizar para su música. Estos son algunos de los mejores:</p>
-<tabla>
-<tr><th>Sitio web</th><th>Descripción</th></tr>
-<tr><td>[Dizzla D Music]( 4 )</td><td>Este sitio web ofrece una variedad de ritmos de R&B y hip hop, incluido el ritmo emocional del rap. Puede navegar por género, estado de ánimo o tempo, y descargar los beats gratis o comprar una licencia para uso comercial. </td></tr>
-<tr><td>[TRAKTRAIN]( 3 )</td><td>Este sitio web es una plataforma donde los productores pueden vender sus ritmos en línea. Puedes encontrar muchos emo rap beats aquí, que son similares al amor emocional rap beat. Puedes filtrar por género, estado de ánimo, bpm o precio, y descargar algunos beats gratis o comprar un contrato de arrendamiento o derechos exclusivos. </td></tr>
-<tr><td>[Rujay]( 1 )</td><td <p>Este sitio web es un canal de YouTube que carga rap gratis todos los días. Usted puede encontrar muchos amor emocional rap beat aquí, así como otros géneros y estilos. Puede descargar los beats gratis o comprar una licencia para uso comercial. </td></tr>
-</tabla>
- <h3>Los mejores canales de YouTube para ver y descargar Love Emotional Rap Beat</h3>
-<p>Si prefieres ver y escuchar el ritmo emocional del rap en YouTube, hay muchos canales que producen y suben ritmos originales y de alta calidad que puedes disfrutar y descargar. Estos son algunos de los mejores:</p>
-<ul>
-
-<li>[RicandThadeus Music]: Este canal tiene más de 500.000 suscriptores y se especializa en R&B y soulful rap beats, incluyendo el amor emocional rap beat. Puedes descargar los beats gratis o comprar una licencia para uso comercial. </li>
-<li>[Torre Beatz]: Este canal tiene más de 400.000 suscriptores y se centra en emocional y triste rap beats, incluyendo el amor emocional rap beat. Puedes descargar los beats gratis o comprar una licencia para uso comercial. </li>
-</ul>
- <h3>Las mejores aplicaciones para descargar y crear amor emocional Rap Beat en su teléfono</h3>
-<p>Si quieres descargar y crear rap emocional de amor en tu teléfono, hay muchas aplicaciones que pueden ayudarte a hacerlo. Estos son algunos de los mejores:</p>
-<p></p>
-<ul>
-<li>[BandLab]: Esta aplicación es una plataforma de música social que le permite crear, colaborar y compartir su música en línea. Puede utilizar la aplicación para grabar, editar, mezclar y dominar sus canciones, así como acceder a miles de latidos libres, bucles y sampling, incluyendo el amor emocional rap beat. </li>
-<li>[BeatStars]: Esta aplicación es un mercado donde se puede comprar y vender beats en línea. Puedes usar la aplicación para descubrir, transmitir y descargar millones de ritmos de diferentes géneros y estilos, incluido el ritmo emocional del rap. </li>
-<li>[Rapchat]: Esta aplicación es un estudio de rap y la comunidad que le permite grabar, compartir y descubrir canciones de rap. Puede utilizar la aplicación para rapear sobre cientos de latidos libres, incluyendo el amor emocional rap beat, o crear sus propios latidos utilizando el fabricante de ritmo incorporado. </li>
-</ul>
- <h2>Cómo usar el rap emocional para tu próxima canción</h2>
-<h3>Cómo elegir el amor derecho emocional Rap Beat para su género y estado de ánimo</h3>
-<p>Una vez que hayas encontrado y descargado algo de rap emocional que te guste, debes elegir el adecuado para tu género y estado de ánimo. Aquí hay algunos consejos para ayudarle a hacer eso:</p>
-<ul>
-
-<li>Piensa en la audiencia y el propósito de tu canción. ¿Para quién estás haciendo esta canción? ¿Qué quieres que sientan? Elige un ritmo de rap emocional que atraiga a tus oyentes objetivo y se ajuste a tu objetivo. </li>
-<li>Piensa en la estructura y el flujo de tu canción. ¿Cómo quieres organizar tus versos, coro, puente, etc.? ¿Cómo quieres hacer la transición entre ellos? Elegir un amor emocional rap beat que tiene una estructura clara y pegadiza y el flujo. </li>
-</ul>
- <h3>Cómo escribir letras y melodías que coinciden con el amor emocional Rap Beat</h3>
-<p>Después de haber elegido el ritmo de rap emocional de amor adecuado para tu canción, necesitas escribir letras y melodías que coincidan con ella. Aquí hay algunos consejos para ayudarle a hacer eso:</p>
-<ul>
-<li>Escucha el rap emocional de amor latir con cuidado y repetidamente. Presta atención al estado de ánimo, tempo, ritmo, melodía, armonía, etc. del ritmo. Trate de sentir la emoción y el ambiente del ritmo. </li>
-<li>Escribe algunas palabras o frases que vienen a tu mente cuando escuchas el ritmo. Pueden estar relacionados con el tema, tema o mensaje de tu canción, o simplemente palabras aleatorias que suenan bien con el ritmo. </li>
-<li>Usa estas palabras o frases como inspiración o punto de partida para tus letras. Intenta rimarlas entre ellas o con otras palabras en el ritmo. Trata de usar metáforas, símiles, imágenes u otros recursos literarios para hacer tus letras más creativas y expresivas. </li>
-Canta o tararea junto con el ritmo para encontrar una melodía que se adapte a él. Pruebe diferentes notas, tonos, etc. hasta que encuentre una melodía que suene bien con el ritmo. Trate de hacer que su melodía sea pegadiza y memorable. Intenta combinar la melodía con el ritmo y el acento del ritmo. </li>
-</ul>
- <h3>Cómo grabar y mezclar su voz con el amor emocional Rap Beat</h3>
-<p>Finalmente, después de haber escrito tus letras y melodías, necesitas grabar y mezclar tus voces con el ritmo emocional del rap. Aquí hay algunos consejos para ayudarle a hacer eso:</p>
-<ul>
-
-<li>Practica tus voces antes de grabar. Quieres asegurarte de que puedes rapear o cantar tus letras y melodías sin problemas y con confianza. También debe asegurarse de que puede coincidir con el tiempo y el tono del ritmo. </li>
-<li>Graba múltiples tomas de tus voces. Quieres tener diferentes opciones y variaciones de tus voces, para que puedas elegir la mejor o combinarlas más tarde. También puedes grabar diferentes partes de tus voces por separado, como los versos, el coro, las improvisaciones, etc.</li>
-<li>Mezcla tus voces con el ritmo. Quieres equilibrar el volumen, EQ, compresión, reverberación, etc. de tus voces y el ritmo, para que suenen armoniosos y claros. Puede utilizar un software de mezcla o un ingeniero profesional, dependiendo de sus habilidades y preferencias. </li>
-</ul>
- <h2>Conclusión</h2>
-<p>Love emocional rap beat es una gran manera de hacer su música rap más expresiva y única. Puede ayudarte a transmitir tus sentimientos y emociones, conectar con tu audiencia, mostrar tu versatilidad y mejorar tus habilidades. Para usar el ritmo emocional del rap para tu próxima canción, necesitas encontrarlo y descargarlo en línea, elegir el adecuado para tu género y estado de ánimo, escribir letras y melodías que coincidan con él, y grabar y mezclar tus voces con él. Esperamos que este artículo te haya dado algunos consejos y recursos útiles sobre cómo descargar rap emocional para tu próxima canción. Ahora adelante y hacer algo de música increíble! </p>
- <h2>Preguntas frecuentes</h2>
-<h4>¿Cuáles son algunos ejemplos de artistas que usan el rap emocional de amor? </h4>
-<p>Algunos ejemplos de artistas que utilizan el amor emocional rap beat son Drake, Post Malone, Jugo WRLD, XXXTentacion, Lil Peep, NF, etc.</p>
-<h4>¿Dónde puedo encontrar más amor emocional rap beat? </h4>
-<p>Puedes encontrar más amor emocional rap beat en varios sitios web, canales de YouTube, aplicaciones, o comunidades en línea que ofrecen ritmos gratuitos o pagados. También puedes buscar palabras clave como "love emotional rap beat", "emo rap beat", "sad rap beat", "romantic rap beat", etc.</p>
-
-<p>Usted puede hacer su propio amor emocional rap beat mediante el uso de un ritmo que hace software o aplicación que le permite crear, editar y organizar diferentes sonidos e instrumentos. También puedes usar un teclado MIDI o un teclado de batería para tocar y grabar tus propias melodías y ritmos. </p>
-<h4>¿Cómo puedo vender mi amor emocional rap beat online? </h4>
-<p>Usted puede vender su amor emocional rap beat en línea mediante el uso de una plataforma o mercado que conecta a los productores y artistas que compran y venden beats. También puedes crear tu propio sitio web o cuenta de redes sociales para promocionar y vender tus beats. </p>
-<h4>¿Cómo puedo aprender más sobre el amor emocional rap beat? </h4>
-<p>Puedes aprender más sobre el amor emocional rap beat viendo tutoriales, reseñas o consejos de otros productores o artistas que hacen o usan el amor emocional rap beat. También puedes leer blogs, artículos o libros sobre producción o historia de música rap. </p> 64aa2da5cf<br />
-<br />
-<br />

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

@@ -1,89 +0,0 @@
-# coding: utf-8
-"""Functions for reporting filesizes. Borrowed from https://github.com/PyFilesystem/pyfilesystem2
-
-The functions declared in this module should cover the different
-use cases needed to generate a string representation of a file size
-using several different units. Since there are many standards regarding
-file size units, three different functions have been implemented.
-
-See Also:
-    * `Wikipedia: Binary prefix <https://en.wikipedia.org/wiki/Binary_prefix>`_
-
-"""
-
-__all__ = ["decimal"]
-
-from typing import Iterable, List, Optional, Tuple
-
-
-def _to_str(
-    size: int,
-    suffixes: Iterable[str],
-    base: int,
-    *,
-    precision: Optional[int] = 1,
-    separator: Optional[str] = " ",
-) -> str:
-    if size == 1:
-        return "1 byte"
-    elif size < base:
-        return "{:,} bytes".format(size)
-
-    for i, suffix in enumerate(suffixes, 2):  # noqa: B007
-        unit = base**i
-        if size < unit:
-            break
-    return "{:,.{precision}f}{separator}{}".format(
-        (base * size / unit),
-        suffix,
-        precision=precision,
-        separator=separator,
-    )
-
-
-def pick_unit_and_suffix(size: int, suffixes: List[str], base: int) -> Tuple[int, str]:
-    """Pick a suffix and base for the given size."""
-    for i, suffix in enumerate(suffixes):
-        unit = base**i
-        if size < unit * base:
-            break
-    return unit, suffix
-
-
-def decimal(
-    size: int,
-    *,
-    precision: Optional[int] = 1,
-    separator: Optional[str] = " ",
-) -> str:
-    """Convert a filesize in to a string (powers of 1000, SI prefixes).
-
-    In this convention, ``1000 B = 1 kB``.
-
-    This is typically the format used to advertise the storage
-    capacity of USB flash drives and the like (*256 MB* meaning
-    actually a storage capacity of more than *256 000 000 B*),
-    or used by **Mac OS X** since v10.6 to report file sizes.
-
-    Arguments:
-        int (size): A file size.
-        int (precision): The number of decimal places to include (default = 1).
-        str (separator): The string to separate the value from the units (default = " ").
-
-    Returns:
-        `str`: A string containing a abbreviated file size and units.
-
-    Example:
-        >>> filesize.decimal(30000)
-        '30.0 kB'
-        >>> filesize.decimal(30000, precision=2, separator="")
-        '30.00kB'
-
-    """
-    return _to_str(
-        size,
-        ("kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"),
-        1000,
-        precision=precision,
-        separator=separator,
-    )

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

@@ -1,153 +0,0 @@
-from typing import List, Optional, Tuple
-
-from .color_triplet import ColorTriplet
-from .palette import Palette
-
-_ColorTuple = Tuple[int, int, int]
-
-
-class TerminalTheme:
-    """A color theme used when exporting console content.
-
-    Args:
-        background (Tuple[int, int, int]): The background color.
-        foreground (Tuple[int, int, int]): The foreground (text) color.
-        normal (List[Tuple[int, int, int]]): A list of 8 normal intensity colors.
-        bright (List[Tuple[int, int, int]], optional): A list of 8 bright colors, or None
-            to repeat normal intensity. Defaults to None.
-    """
-
-    def __init__(
-        self,
-        background: _ColorTuple,
-        foreground: _ColorTuple,
-        normal: List[_ColorTuple],
-        bright: Optional[List[_ColorTuple]] = None,
-    ) -> None:
-        self.background_color = ColorTriplet(*background)
-        self.foreground_color = ColorTriplet(*foreground)
-        self.ansi_colors = Palette(normal + (bright or normal))
-
-
-DEFAULT_TERMINAL_THEME = TerminalTheme(
-    (255, 255, 255),
-    (0, 0, 0),
-    [
-        (0, 0, 0),
-        (128, 0, 0),
-        (0, 128, 0),
-        (128, 128, 0),
-        (0, 0, 128),
-        (128, 0, 128),
-        (0, 128, 128),
-        (192, 192, 192),
-    ],
-    [
-        (128, 128, 128),
-        (255, 0, 0),
-        (0, 255, 0),
-        (255, 255, 0),
-        (0, 0, 255),
-        (255, 0, 255),
-        (0, 255, 255),
-        (255, 255, 255),
-    ],
-)
-
-MONOKAI = TerminalTheme(
-    (12, 12, 12),
-    (217, 217, 217),
-    [
-        (26, 26, 26),
-        (244, 0, 95),
-        (152, 224, 36),
-        (253, 151, 31),
-        (157, 101, 255),
-        (244, 0, 95),
-        (88, 209, 235),
-        (196, 197, 181),
-        (98, 94, 76),
-    ],
-    [
-        (244, 0, 95),
-        (152, 224, 36),
-        (224, 213, 97),
-        (157, 101, 255),
-        (244, 0, 95),
-        (88, 209, 235),
-        (246, 246, 239),
-    ],
-)
-DIMMED_MONOKAI = TerminalTheme(
-    (25, 25, 25),
-    (185, 188, 186),
-    [
-        (58, 61, 67),
-        (190, 63, 72),
-        (135, 154, 59),
-        (197, 166, 53),
-        (79, 118, 161),
-        (133, 92, 141),
-        (87, 143, 164),
-        (185, 188, 186),
-        (136, 137, 135),
-    ],
-    [
-        (251, 0, 31),
-        (15, 114, 47),
-        (196, 112, 51),
-        (24, 109, 227),
-        (251, 0, 103),
-        (46, 112, 109),
-        (253, 255, 185),
-    ],
-)
-NIGHT_OWLISH = TerminalTheme(
-    (255, 255, 255),
-    (64, 63, 83),
-    [
-        (1, 22, 39),
-        (211, 66, 62),
-        (42, 162, 152),
-        (218, 170, 1),
-        (72, 118, 214),
-        (64, 63, 83),
-        (8, 145, 106),
-        (122, 129, 129),
-        (122, 129, 129),
-    ],
-    [
-        (247, 110, 110),
-        (73, 208, 197),
-        (218, 194, 107),
-        (92, 167, 228),
-        (105, 112, 152),
-        (0, 201, 144),
-        (152, 159, 177),
-    ],
-)
-
-SVG_EXPORT_THEME = TerminalTheme(
-    (41, 41, 41),
-    (197, 200, 198),
-    [
-        (75, 78, 85),
-        (204, 85, 90),
-        (152, 168, 75),
-        (208, 179, 68),
-        (96, 138, 177),
-        (152, 114, 159),
-        (104, 160, 179),
-        (197, 200, 198),
-        (154, 155, 153),
-    ],
-    [
-        (255, 38, 39),
-        (0, 130, 61),
-        (208, 132, 66),
-        (25, 132, 233),
-        (255, 44, 122),
-        (57, 130, 128),
-        (253, 253, 197),
-    ],
-)

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

@@ -1,2296 +0,0 @@
-import abc
-import collections
-import collections.abc
-import operator
-import sys
-import typing
-
-# After PEP 560, internal typing API was substantially reworked.
-# This is especially important for Protocol class which uses internal APIs
-# quite extensively.
-PEP_560 = sys.version_info[:3] >= (3, 7, 0)
-
-if PEP_560:
-    GenericMeta = type
-else:
-    # 3.6
-    from typing import GenericMeta, _type_vars  # noqa
-
-# The two functions below are copies of typing internal helpers.
-# They are needed by _ProtocolMeta
-
-
-def _no_slots_copy(dct):
-    dict_copy = dict(dct)
-    if '__slots__' in dict_copy:
-        for slot in dict_copy['__slots__']:
-            dict_copy.pop(slot, None)
-    return dict_copy
-
-
-def _check_generic(cls, parameters):
-    if not cls.__parameters__:
-        raise TypeError(f"{cls} is not a generic class")
-    alen = len(parameters)
-    elen = len(cls.__parameters__)
-    if alen != elen:
-        raise TypeError(f"Too {'many' if alen > elen else 'few'} arguments for {cls};"
-                        f" actual {alen}, expected {elen}")
-
-
-# Please keep __all__ alphabetized within each category.
-__all__ = [
-    # Super-special typing primitives.
-    'ClassVar',
-    'Concatenate',
-    'Final',
-    'ParamSpec',
-    'Self',
-    'Type',
-
-    # ABCs (from collections.abc).
-    'Awaitable',
-    'AsyncIterator',
-    'AsyncIterable',
-    'Coroutine',
-    'AsyncGenerator',
-    'AsyncContextManager',
-    'ChainMap',
-
-    # Concrete collection types.
-    'ContextManager',
-    'Counter',
-    'Deque',
-    'DefaultDict',
-    'OrderedDict',
-    'TypedDict',
-
-    # Structural checks, a.k.a. protocols.
-    'SupportsIndex',
-
-    # One-off things.
-    'Annotated',
-    'final',
-    'IntVar',
-    'Literal',
-    'NewType',
-    'overload',
-    'Protocol',
-    'runtime',
-    'runtime_checkable',
-    'Text',
-    'TypeAlias',
-    'TypeGuard',
-    'TYPE_CHECKING',
-]
-
-if PEP_560:
-    __all__.extend(["get_args", "get_origin", "get_type_hints"])
-
-# 3.6.2+
-if hasattr(typing, 'NoReturn'):
-    NoReturn = typing.NoReturn
-# 3.6.0-3.6.1
-else:
-    class _NoReturn(typing._FinalTypingBase, _root=True):
-        """Special type indicating functions that never return.
-        Example::
-
-          from typing import NoReturn
-
-          def stop() -> NoReturn:
-              raise Exception('no way')
-
-        This type is invalid in other positions, e.g., ``List[NoReturn]``
-        will fail in static type checkers.
-        """
-        __slots__ = ()
-
-        def __instancecheck__(self, obj):
-            raise TypeError("NoReturn cannot be used with isinstance().")
-
-        def __subclasscheck__(self, cls):
-            raise TypeError("NoReturn cannot be used with issubclass().")
-
-    NoReturn = _NoReturn(_root=True)
-
-# Some unconstrained type variables.  These are used by the container types.
-# (These are not for export.)
-T = typing.TypeVar('T')  # Any type.
-KT = typing.TypeVar('KT')  # Key type.
-VT = typing.TypeVar('VT')  # Value type.
-T_co = typing.TypeVar('T_co', covariant=True)  # Any type covariant containers.
-T_contra = typing.TypeVar('T_contra', contravariant=True)  # Ditto contravariant.
-
-ClassVar = typing.ClassVar
-
-# On older versions of typing there is an internal class named "Final".
-# 3.8+
-if hasattr(typing, 'Final') and sys.version_info[:2] >= (3, 7):
-    Final = typing.Final
-# 3.7
-elif sys.version_info[:2] >= (3, 7):
-    class _FinalForm(typing._SpecialForm, _root=True):
-
-        def __repr__(self):
-            return 'typing_extensions.' + self._name
-
-        def __getitem__(self, parameters):
-            item = typing._type_check(parameters,
-                                      f'{self._name} accepts only single type')
-            return typing._GenericAlias(self, (item,))
-
-    Final = _FinalForm('Final',
-                       doc="""A special typing construct to indicate that a name
-                       cannot be re-assigned or overridden in a subclass.
-                       For example:
-
-                           MAX_SIZE: Final = 9000
-                           MAX_SIZE += 1  # Error reported by type checker
-
-                           class Connection:
-                               TIMEOUT: Final[int] = 10
-                           class FastConnector(Connection):
-                               TIMEOUT = 1  # Error reported by type checker
-
-                       There is no runtime checking of these properties.""")
-# 3.6
-else:
-    class _Final(typing._FinalTypingBase, _root=True):
-        """A special typing construct to indicate that a name
-        cannot be re-assigned or overridden in a subclass.
-        For example:
-
-            MAX_SIZE: Final = 9000
-            MAX_SIZE += 1  # Error reported by type checker
-
-            class Connection:
-                TIMEOUT: Final[int] = 10
-            class FastConnector(Connection):
-                TIMEOUT = 1  # Error reported by type checker
-
-        There is no runtime checking of these properties.
-        """
-
-        __slots__ = ('__type__',)
-
-        def __init__(self, tp=None, **kwds):
-            self.__type__ = tp
-
-        def __getitem__(self, item):
-            cls = type(self)
-            if self.__type__ is None:
-                return cls(typing._type_check(item,
-                           f'{cls.__name__[1:]} accepts only single type.'),
-                           _root=True)
-            raise TypeError(f'{cls.__name__[1:]} cannot be further subscripted')
-
-        def _eval_type(self, globalns, localns):
-            new_tp = typing._eval_type(self.__type__, globalns, localns)
-            if new_tp == self.__type__:
-                return self
-            return type(self)(new_tp, _root=True)
-
-        def __repr__(self):
-            r = super().__repr__()
-            if self.__type__ is not None:
-                r += f'[{typing._type_repr(self.__type__)}]'
-            return r
-
-        def __hash__(self):
-            return hash((type(self).__name__, self.__type__))
-
-        def __eq__(self, other):
-            if not isinstance(other, _Final):
-                return NotImplemented
-            if self.__type__ is not None:
-                return self.__type__ == other.__type__
-            return self is other
-
-    Final = _Final(_root=True)
-
-
-# 3.8+
-if hasattr(typing, 'final'):
-    final = typing.final
-# 3.6-3.7
-else:
-    def final(f):
-        """This decorator can be used to indicate to type checkers that
-        the decorated method cannot be overridden, and decorated class
-        cannot be subclassed. For example:
-
-            class Base:
-                @final
-                def done(self) -> None:
-                    ...
-            class Sub(Base):
-                def done(self) -> None:  # Error reported by type checker
-                    ...
-            @final
-            class Leaf:
-                ...
-            class Other(Leaf):  # Error reported by type checker
-                ...
-
-        There is no runtime checking of these properties.
-        """
-        return f
-
-
-def IntVar(name):
-    return typing.TypeVar(name)
-
-
-# 3.8+:
-if hasattr(typing, 'Literal'):
-    Literal = typing.Literal
-# 3.7:
-elif sys.version_info[:2] >= (3, 7):
-    class _LiteralForm(typing._SpecialForm, _root=True):
-
-        def __repr__(self):
-            return 'typing_extensions.' + self._name
-
-        def __getitem__(self, parameters):
-            return typing._GenericAlias(self, parameters)
-
-    Literal = _LiteralForm('Literal',
-                           doc="""A type that can be used to indicate to type checkers
-                           that the corresponding value has a value literally equivalent
-                           to the provided parameter. For example:
-
-                               var: Literal[4] = 4
-
-                           The type checker understands that 'var' is literally equal to
-                           the value 4 and no other value.
-
-                           Literal[...] cannot be subclassed. There is no runtime
-                           checking verifying that the parameter is actually a value
-                           instead of a type.""")
-# 3.6:
-else:
-    class _Literal(typing._FinalTypingBase, _root=True):
-        """A type that can be used to indicate to type checkers that the
-        corresponding value has a value literally equivalent to the
-        provided parameter. For example:
-
-            var: Literal[4] = 4
-
-        The type checker understands that 'var' is literally equal to the
-        value 4 and no other value.
-
-        Literal[...] cannot be subclassed. There is no runtime checking
-        verifying that the parameter is actually a value instead of a type.
-        """
-
-        __slots__ = ('__values__',)
-
-        def __init__(self, values=None, **kwds):
-            self.__values__ = values
-
-        def __getitem__(self, values):
-            cls = type(self)
-            if self.__values__ is None:
-                if not isinstance(values, tuple):
-                    values = (values,)
-                return cls(values, _root=True)
-            raise TypeError(f'{cls.__name__[1:]} cannot be further subscripted')
-
-        def _eval_type(self, globalns, localns):
-            return self
-
-        def __repr__(self):
-            r = super().__repr__()
-            if self.__values__ is not None:
-                r += f'[{", ".join(map(typing._type_repr, self.__values__))}]'
-            return r
-
-        def __hash__(self):
-            return hash((type(self).__name__, self.__values__))
-
-        def __eq__(self, other):
-            if not isinstance(other, _Literal):
-                return NotImplemented
-            if self.__values__ is not None:
-                return self.__values__ == other.__values__
-            return self is other
-
-    Literal = _Literal(_root=True)
-
-
-_overload_dummy = typing._overload_dummy  # noqa
-overload = typing.overload
-
-
-# This is not a real generic class.  Don't use outside annotations.
-Type = typing.Type
-
-# Various ABCs mimicking those in collections.abc.
-# A few are simply re-exported for completeness.
-
-
-class _ExtensionsGenericMeta(GenericMeta):
-    def __subclasscheck__(self, subclass):
-        """This mimics a more modern GenericMeta.__subclasscheck__() logic
-        (that does not have problems with recursion) to work around interactions
-        between collections, typing, and typing_extensions on older
-        versions of Python, see https://github.com/python/typing/issues/501.
-        """
-        if self.__origin__ is not None:
-            if sys._getframe(1).f_globals['__name__'] not in ['abc', 'functools']:
-                raise TypeError("Parameterized generics cannot be used with class "
-                                "or instance checks")
-            return False
-        if not self.__extra__:
-            return super().__subclasscheck__(subclass)
-        res = self.__extra__.__subclasshook__(subclass)
-        if res is not NotImplemented:
-            return res
-        if self.__extra__ in subclass.__mro__:
-            return True
-        for scls in self.__extra__.__subclasses__():
-            if isinstance(scls, GenericMeta):
-                continue
-            if issubclass(subclass, scls):
-                return True
-        return False
-
-
-Awaitable = typing.Awaitable
-Coroutine = typing.Coroutine
-AsyncIterable = typing.AsyncIterable
-AsyncIterator = typing.AsyncIterator
-
-# 3.6.1+
-if hasattr(typing, 'Deque'):
-    Deque = typing.Deque
-# 3.6.0
-else:
-    class Deque(collections.deque, typing.MutableSequence[T],
-                metaclass=_ExtensionsGenericMeta,
-                extra=collections.deque):
-        __slots__ = ()
-
-        def __new__(cls, *args, **kwds):
-            if cls._gorg is Deque:
-                return collections.deque(*args, **kwds)
-            return typing._generic_new(collections.deque, cls, *args, **kwds)
-
-ContextManager = typing.ContextManager
-# 3.6.2+
-if hasattr(typing, 'AsyncContextManager'):
-    AsyncContextManager = typing.AsyncContextManager
-# 3.6.0-3.6.1
-else:
-    from _collections_abc import _check_methods as _check_methods_in_mro  # noqa
-
-    class AsyncContextManager(typing.Generic[T_co]):
-        __slots__ = ()
-
-        async def __aenter__(self):
-            return self
-
-        @abc.abstractmethod
-        async def __aexit__(self, exc_type, exc_value, traceback):
-            return None
-
-        @classmethod
-        def __subclasshook__(cls, C):
-            if cls is AsyncContextManager:
-                return _check_methods_in_mro(C, "__aenter__", "__aexit__")
-            return NotImplemented
-
-DefaultDict = typing.DefaultDict
-
-# 3.7.2+
-if hasattr(typing, 'OrderedDict'):
-    OrderedDict = typing.OrderedDict
-# 3.7.0-3.7.2
-elif (3, 7, 0) <= sys.version_info[:3] < (3, 7, 2):
-    OrderedDict = typing._alias(collections.OrderedDict, (KT, VT))
-# 3.6
-else:
-    class OrderedDict(collections.OrderedDict, typing.MutableMapping[KT, VT],
-                      metaclass=_ExtensionsGenericMeta,
-                      extra=collections.OrderedDict):
-
-        __slots__ = ()
-
-        def __new__(cls, *args, **kwds):
-            if cls._gorg is OrderedDict:
-                return collections.OrderedDict(*args, **kwds)
-            return typing._generic_new(collections.OrderedDict, cls, *args, **kwds)
-
-# 3.6.2+
-if hasattr(typing, 'Counter'):
-    Counter = typing.Counter
-# 3.6.0-3.6.1
-else:
-    class Counter(collections.Counter,
-                  typing.Dict[T, int],
-                  metaclass=_ExtensionsGenericMeta, extra=collections.Counter):
-
-        __slots__ = ()
-
-        def __new__(cls, *args, **kwds):
-            if cls._gorg is Counter:
-                return collections.Counter(*args, **kwds)
-            return typing._generic_new(collections.Counter, cls, *args, **kwds)
-
-# 3.6.1+
-if hasattr(typing, 'ChainMap'):
-    ChainMap = typing.ChainMap
-elif hasattr(collections, 'ChainMap'):
-    class ChainMap(collections.ChainMap, typing.MutableMapping[KT, VT],
-                   metaclass=_ExtensionsGenericMeta,
-                   extra=collections.ChainMap):
-
-        __slots__ = ()
-
-        def __new__(cls, *args, **kwds):
-            if cls._gorg is ChainMap:
-                return collections.ChainMap(*args, **kwds)
-            return typing._generic_new(collections.ChainMap, cls, *args, **kwds)
-
-# 3.6.1+
-if hasattr(typing, 'AsyncGenerator'):
-    AsyncGenerator = typing.AsyncGenerator
-# 3.6.0
-else:
-    class AsyncGenerator(AsyncIterator[T_co], typing.Generic[T_co, T_contra],
-                         metaclass=_ExtensionsGenericMeta,
-                         extra=collections.abc.AsyncGenerator):
-        __slots__ = ()
-
-NewType = typing.NewType
-Text = typing.Text
-TYPE_CHECKING = typing.TYPE_CHECKING
-
-
-def _gorg(cls):
-    """This function exists for compatibility with old typing versions."""
-    assert isinstance(cls, GenericMeta)
-    if hasattr(cls, '_gorg'):
-        return cls._gorg
-    while cls.__origin__ is not None:
-        cls = cls.__origin__
-    return cls
-
-
-_PROTO_WHITELIST = ['Callable', 'Awaitable',
-                    'Iterable', 'Iterator', 'AsyncIterable', 'AsyncIterator',
-                    'Hashable', 'Sized', 'Container', 'Collection', 'Reversible',
-                    'ContextManager', 'AsyncContextManager']
-
-
-def _get_protocol_attrs(cls):
-    attrs = set()
-    for base in cls.__mro__[:-1]:  # without object
-        if base.__name__ in ('Protocol', 'Generic'):
-            continue
-        annotations = getattr(base, '__annotations__', {})
-        for attr in list(base.__dict__.keys()) + list(annotations.keys()):
-            if (not attr.startswith('_abc_') and attr not in (
-                    '__abstractmethods__', '__annotations__', '__weakref__',
-                    '_is_protocol', '_is_runtime_protocol', '__dict__',
-                    '__args__', '__slots__',
-                    '__next_in_mro__', '__parameters__', '__origin__',
-                    '__orig_bases__', '__extra__', '__tree_hash__',
-                    '__doc__', '__subclasshook__', '__init__', '__new__',
-                    '__module__', '_MutableMapping__marker', '_gorg')):
-                attrs.add(attr)
-    return attrs
-
-
-def _is_callable_members_only(cls):
-    return all(callable(getattr(cls, attr, None)) for attr in _get_protocol_attrs(cls))
-
-
-# 3.8+
-if hasattr(typing, 'Protocol'):
-    Protocol = typing.Protocol
-# 3.7
-elif PEP_560:
-    from typing import _collect_type_vars  # noqa
-
-    def _no_init(self, *args, **kwargs):
-        if type(self)._is_protocol:
-            raise TypeError('Protocols cannot be instantiated')
-
-    class _ProtocolMeta(abc.ABCMeta):
-        # This metaclass is a bit unfortunate and exists only because of the lack
-        # of __instancehook__.
-        def __instancecheck__(cls, instance):
-            # We need this method for situations where attributes are
-            # assigned in __init__.
-            if ((not getattr(cls, '_is_protocol', False) or
-                 _is_callable_members_only(cls)) and
-                    issubclass(instance.__class__, cls)):
-                return True
-            if cls._is_protocol:
-                if all(hasattr(instance, attr) and
-                       (not callable(getattr(cls, attr, None)) or
-                        getattr(instance, attr) is not None)
-                       for attr in _get_protocol_attrs(cls)):
-                    return True
-            return super().__instancecheck__(instance)
-
-    class Protocol(metaclass=_ProtocolMeta):
-        # There is quite a lot of overlapping code with typing.Generic.
-        # Unfortunately it is hard to avoid this while these live in two different
-        # modules. The duplicated code will be removed when Protocol is moved to typing.
-        """Base class for protocol classes. Protocol classes are defined as::
-
-            class Proto(Protocol):
-                def meth(self) -> int:
-                    ...
-
-        Such classes are primarily used with static type checkers that recognize
-        structural subtyping (static duck-typing), for example::
-
-            class C:
-                def meth(self) -> int:
-                    return 0
-
-            def func(x: Proto) -> int:
-                return x.meth()
-
-            func(C())  # Passes static type check
-
-        See PEP 544 for details. Protocol classes decorated with
-        @typing_extensions.runtime act as simple-minded runtime protocol that checks
-        only the presence of given attributes, ignoring their type signatures.
-
-        Protocol classes can be generic, they are defined as::
-
-            class GenProto(Protocol[T]):
-                def meth(self) -> T:
-                    ...
-        """
-        __slots__ = ()
-        _is_protocol = True
-
-        def __new__(cls, *args, **kwds):
-            if cls is Protocol:
-                raise TypeError("Type Protocol cannot be instantiated; "
-                                "it can only be used as a base class")
-            return super().__new__(cls)
-
-        @typing._tp_cache
-        def __class_getitem__(cls, params):
-            if not isinstance(params, tuple):
-                params = (params,)
-            if not params and cls is not typing.Tuple:
-                raise TypeError(
-                    f"Parameter list to {cls.__qualname__}[...] cannot be empty")
-            msg = "Parameters to generic types must be types."
-            params = tuple(typing._type_check(p, msg) for p in params)  # noqa
-            if cls is Protocol:
-                # Generic can only be subscripted with unique type variables.
-                if not all(isinstance(p, typing.TypeVar) for p in params):
-                    i = 0
-                    while isinstance(params[i], typing.TypeVar):
-                        i += 1
-                    raise TypeError(
-                        "Parameters to Protocol[...] must all be type variables."
-                        f" Parameter {i + 1} is {params[i]}")
-                if len(set(params)) != len(params):
-                    raise TypeError(
-                        "Parameters to Protocol[...] must all be unique")
-            else:
-                # Subscripting a regular Generic subclass.
-                _check_generic(cls, params)
-            return typing._GenericAlias(cls, params)
-
-        def __init_subclass__(cls, *args, **kwargs):
-            tvars = []
-            if '__orig_bases__' in cls.__dict__:
-                error = typing.Generic in cls.__orig_bases__
-            else:
-                error = typing.Generic in cls.__bases__
-            if error:
-                raise TypeError("Cannot inherit from plain Generic")
-            if '__orig_bases__' in cls.__dict__:
-                tvars = _collect_type_vars(cls.__orig_bases__)
-                # Look for Generic[T1, ..., Tn] or Protocol[T1, ..., Tn].
-                # If found, tvars must be a subset of it.
-                # If not found, tvars is it.
-                # Also check for and reject plain Generic,
-                # and reject multiple Generic[...] and/or Protocol[...].
-                gvars = None
-                for base in cls.__orig_bases__:
-                    if (isinstance(base, typing._GenericAlias) and
-                            base.__origin__ in (typing.Generic, Protocol)):
-                        # for error messages
-                        the_base = base.__origin__.__name__
-                        if gvars is not None:
-                            raise TypeError(
-                                "Cannot inherit from Generic[...]"
-                                " and/or Protocol[...] multiple types.")
-                        gvars = base.__parameters__
-                if gvars is None:
-                    gvars = tvars
-                else:
-                    tvarset = set(tvars)
-                    gvarset = set(gvars)
-                    if not tvarset <= gvarset:
-                        s_vars = ', '.join(str(t) for t in tvars if t not in gvarset)
-                        s_args = ', '.join(str(g) for g in gvars)
-                        raise TypeError(f"Some type variables ({s_vars}) are"
-                                        f" not listed in {the_base}[{s_args}]")
-                    tvars = gvars
-            cls.__parameters__ = tuple(tvars)
-
-            # Determine if this is a protocol or a concrete subclass.
-            if not cls.__dict__.get('_is_protocol', None):
-                cls._is_protocol = any(b is Protocol for b in cls.__bases__)
-
-            # Set (or override) the protocol subclass hook.
-            def _proto_hook(other):
-                if not cls.__dict__.get('_is_protocol', None):
-                    return NotImplemented
-                if not getattr(cls, '_is_runtime_protocol', False):
-                    if sys._getframe(2).f_globals['__name__'] in ['abc', 'functools']:
-                        return NotImplemented
-                    raise TypeError("Instance and class checks can only be used with"
-                                    " @runtime protocols")
-                if not _is_callable_members_only(cls):
-                    if sys._getframe(2).f_globals['__name__'] in ['abc', 'functools']:
-                        return NotImplemented
-                    raise TypeError("Protocols with non-method members"
-                                    " don't support issubclass()")
-                if not isinstance(other, type):
-                    # Same error as for issubclass(1, int)
-                    raise TypeError('issubclass() arg 1 must be a class')
-                for attr in _get_protocol_attrs(cls):
-                    for base in other.__mro__:
-                        if attr in base.__dict__:
-                            if base.__dict__[attr] is None:
-                                return NotImplemented
-                            break
-                        annotations = getattr(base, '__annotations__', {})
-                        if (isinstance(annotations, typing.Mapping) and
-                                attr in annotations and
-                                isinstance(other, _ProtocolMeta) and
-                                other._is_protocol):
-                            break
-                    else:
-                        return NotImplemented
-                return True
-            if '__subclasshook__' not in cls.__dict__:
-                cls.__subclasshook__ = _proto_hook
-
-            # We have nothing more to do for non-protocols.
-            if not cls._is_protocol:
-                return
-
-            # Check consistency of bases.
-            for base in cls.__bases__:
-                if not (base in (object, typing.Generic) or
-                        base.__module__ == 'collections.abc' and
-                        base.__name__ in _PROTO_WHITELIST or
-                        isinstance(base, _ProtocolMeta) and base._is_protocol):
-                    raise TypeError('Protocols can only inherit from other'
-                                    f' protocols, got {repr(base)}')
-            cls.__init__ = _no_init
-# 3.6
-else:
-    from typing import _next_in_mro, _type_check  # noqa
-
-    def _no_init(self, *args, **kwargs):
-        if type(self)._is_protocol:
-            raise TypeError('Protocols cannot be instantiated')
-
-    class _ProtocolMeta(GenericMeta):
-        """Internal metaclass for Protocol.
-
-        This exists so Protocol classes can be generic without deriving
-        from Generic.
-        """
-        def __new__(cls, name, bases, namespace,
-                    tvars=None, args=None, origin=None, extra=None, orig_bases=None):
-            # This is just a version copied from GenericMeta.__new__ that
-            # includes "Protocol" special treatment. (Comments removed for brevity.)
-            assert extra is None  # Protocols should not have extra
-            if tvars is not None:
-                assert origin is not None
-                assert all(isinstance(t, typing.TypeVar) for t in tvars), tvars
-            else:
-                tvars = _type_vars(bases)
-                gvars = None
-                for base in bases:
-                    if base is typing.Generic:
-                        raise TypeError("Cannot inherit from plain Generic")
-                    if (isinstance(base, GenericMeta) and
-                            base.__origin__ in (typing.Generic, Protocol)):
-                        if gvars is not None:
-                            raise TypeError(
-                                "Cannot inherit from Generic[...] or"
-                                " Protocol[...] multiple times.")
-                        gvars = base.__parameters__
-                if gvars is None:
-                    gvars = tvars
-                else:
-                    tvarset = set(tvars)
-                    gvarset = set(gvars)
-                    if not tvarset <= gvarset:
-                        s_vars = ", ".join(str(t) for t in tvars if t not in gvarset)
-                        s_args = ", ".join(str(g) for g in gvars)
-                        cls_name = "Generic" if any(b.__origin__ is typing.Generic
-                                                    for b in bases) else "Protocol"
-                        raise TypeError(f"Some type variables ({s_vars}) are"
-                                        f" not listed in {cls_name}[{s_args}]")
-                    tvars = gvars
-
-            initial_bases = bases
-            if (extra is not None and type(extra) is abc.ABCMeta and
-                    extra not in bases):
-                bases = (extra,) + bases
-            bases = tuple(_gorg(b) if isinstance(b, GenericMeta) else b
-                          for b in bases)
-            if any(isinstance(b, GenericMeta) and b is not typing.Generic for b in bases):
-                bases = tuple(b for b in bases if b is not typing.Generic)
-            namespace.update({'__origin__': origin, '__extra__': extra})
-            self = super(GenericMeta, cls).__new__(cls, name, bases, namespace,
-                                                   _root=True)
-            super(GenericMeta, self).__setattr__('_gorg',
-                                                 self if not origin else
-                                                 _gorg(origin))
-            self.__parameters__ = tvars
-            self.__args__ = tuple(... if a is typing._TypingEllipsis else
-                                  () if a is typing._TypingEmpty else
-                                  a for a in args) if args else None
-            self.__next_in_mro__ = _next_in_mro(self)
-            if orig_bases is None:
-                self.__orig_bases__ = initial_bases
-            elif origin is not None:
-                self._abc_registry = origin._abc_registry
-                self._abc_cache = origin._abc_cache
-            if hasattr(self, '_subs_tree'):
-                self.__tree_hash__ = (hash(self._subs_tree()) if origin else
-                                      super(GenericMeta, self).__hash__())
-            return self
-
-        def __init__(cls, *args, **kwargs):
-            super().__init__(*args, **kwargs)
-            if not cls.__dict__.get('_is_protocol', None):
-                cls._is_protocol = any(b is Protocol or
-                                       isinstance(b, _ProtocolMeta) and
-                                       b.__origin__ is Protocol
-                                       for b in cls.__bases__)
-            if cls._is_protocol:
-                for base in cls.__mro__[1:]:
-                    if not (base in (object, typing.Generic) or
-                            base.__module__ == 'collections.abc' and
-                            base.__name__ in _PROTO_WHITELIST or
-                            isinstance(base, typing.TypingMeta) and base._is_protocol or
-                            isinstance(base, GenericMeta) and
-                            base.__origin__ is typing.Generic):
-                        raise TypeError(f'Protocols can only inherit from other'
-                                        f' protocols, got {repr(base)}')
-
-                cls.__init__ = _no_init
-
-            def _proto_hook(other):
-                if not cls.__dict__.get('_is_protocol', None):
-                    return NotImplemented
-                if not isinstance(other, type):
-                    # Same error as for issubclass(1, int)
-                    raise TypeError('issubclass() arg 1 must be a class')
-                for attr in _get_protocol_attrs(cls):
-                    for base in other.__mro__:
-                        if attr in base.__dict__:
-                            if base.__dict__[attr] is None:
-                                return NotImplemented
-                            break
-                        annotations = getattr(base, '__annotations__', {})
-                        if (isinstance(annotations, typing.Mapping) and
-                                attr in annotations and
-                                isinstance(other, _ProtocolMeta) and
-                                other._is_protocol):
-                            break
-                    else:
-                        return NotImplemented
-                return True
-            if '__subclasshook__' not in cls.__dict__:
-                cls.__subclasshook__ = _proto_hook
-
-        def __instancecheck__(self, instance):
-            # We need this method for situations where attributes are
-            # assigned in __init__.
-            if ((not getattr(self, '_is_protocol', False) or
-                    _is_callable_members_only(self)) and
-                    issubclass(instance.__class__, self)):
-                return True
-            if self._is_protocol:
-                if all(hasattr(instance, attr) and
-                        (not callable(getattr(self, attr, None)) or
-                         getattr(instance, attr) is not None)
-                        for attr in _get_protocol_attrs(self)):
-                    return True
-            return super(GenericMeta, self).__instancecheck__(instance)
-
-        def __subclasscheck__(self, cls):
-            if self.__origin__ is not None:
-                if sys._getframe(1).f_globals['__name__'] not in ['abc', 'functools']:
-                    raise TypeError("Parameterized generics cannot be used with class "
-                                    "or instance checks")
-                return False
-            if (self.__dict__.get('_is_protocol', None) and
-                    not self.__dict__.get('_is_runtime_protocol', None)):
-                if sys._getframe(1).f_globals['__name__'] in ['abc',
-                                                              'functools',
-                                                              'typing']:
-                    return False
-                raise TypeError("Instance and class checks can only be used with"
-                                " @runtime protocols")
-            if (self.__dict__.get('_is_runtime_protocol', None) and
-                    not _is_callable_members_only(self)):
-                if sys._getframe(1).f_globals['__name__'] in ['abc',
-                                                              'functools',
-                                                              'typing']:
-                    return super(GenericMeta, self).__subclasscheck__(cls)
-                raise TypeError("Protocols with non-method members"
-                                " don't support issubclass()")
-            return super(GenericMeta, self).__subclasscheck__(cls)
-
-        @typing._tp_cache
-        def __getitem__(self, params):
-            # We also need to copy this from GenericMeta.__getitem__ to get
-            # special treatment of "Protocol". (Comments removed for brevity.)
-            if not isinstance(params, tuple):
-                params = (params,)
-            if not params and _gorg(self) is not typing.Tuple:
-                raise TypeError(
-                    f"Parameter list to {self.__qualname__}[...] cannot be empty")
-            msg = "Parameters to generic types must be types."
-            params = tuple(_type_check(p, msg) for p in params)
-            if self in (typing.Generic, Protocol):
-                if not all(isinstance(p, typing.TypeVar) for p in params):
-                    raise TypeError(
-                        f"Parameters to {repr(self)}[...] must all be type variables")
-                if len(set(params)) != len(params):
-                    raise TypeError(
-                        f"Parameters to {repr(self)}[...] must all be unique")
-                tvars = params
-                args = params
-            elif self in (typing.Tuple, typing.Callable):
-                tvars = _type_vars(params)
-                args = params
-            elif self.__origin__ in (typing.Generic, Protocol):
-                raise TypeError(f"Cannot subscript already-subscripted {repr(self)}")
-            else:
-                _check_generic(self, params)
-                tvars = _type_vars(params)
-                args = params
-
-            prepend = (self,) if self.__origin__ is None else ()
-            return self.__class__(self.__name__,
-                                  prepend + self.__bases__,
-                                  _no_slots_copy(self.__dict__),
-                                  tvars=tvars,
-                                  args=args,
-                                  origin=self,
-                                  extra=self.__extra__,
-                                  orig_bases=self.__orig_bases__)
-
-    class Protocol(metaclass=_ProtocolMeta):
-        """Base class for protocol classes. Protocol classes are defined as::
-
-          class Proto(Protocol):
-              def meth(self) -> int:
-                  ...
-
-        Such classes are primarily used with static type checkers that recognize
-        structural subtyping (static duck-typing), for example::
-
-          class C:
-              def meth(self) -> int:
-                  return 0
-
-          def func(x: Proto) -> int:
-              return x.meth()
-
-          func(C())  # Passes static type check
-
-        See PEP 544 for details. Protocol classes decorated with
-        @typing_extensions.runtime act as simple-minded runtime protocol that checks
-        only the presence of given attributes, ignoring their type signatures.
-
-        Protocol classes can be generic, they are defined as::
-
-          class GenProto(Protocol[T]):
-              def meth(self) -> T:
-                  ...
-        """
-        __slots__ = ()
-        _is_protocol = True
-
-        def __new__(cls, *args, **kwds):
-            if _gorg(cls) is Protocol:
-                raise TypeError("Type Protocol cannot be instantiated; "
-                                "it can be used only as a base class")
-            return typing._generic_new(cls.__next_in_mro__, cls, *args, **kwds)
-
-
-# 3.8+
-if hasattr(typing, 'runtime_checkable'):
-    runtime_checkable = typing.runtime_checkable
-# 3.6-3.7
-else:
-    def runtime_checkable(cls):
-        """Mark a protocol class as a runtime protocol, so that it
-        can be used with isinstance() and issubclass(). Raise TypeError
-        if applied to a non-protocol class.
-
-        This allows a simple-minded structural check very similar to the
-        one-offs in collections.abc such as Hashable.
-        """
-        if not isinstance(cls, _ProtocolMeta) or not cls._is_protocol:
-            raise TypeError('@runtime_checkable can be only applied to protocol classes,'
-                            f' got {cls!r}')
-        cls._is_runtime_protocol = True
-        return cls
-
-
-# Exists for backwards compatibility.
-runtime = runtime_checkable
-
-
-# 3.8+
-if hasattr(typing, 'SupportsIndex'):
-    SupportsIndex = typing.SupportsIndex
-# 3.6-3.7
-else:
-    @runtime_checkable
-    class SupportsIndex(Protocol):
-        __slots__ = ()
-
-        @abc.abstractmethod
-        def __index__(self) -> int:
-            pass
-
-
-if sys.version_info >= (3, 9, 2):
-    # The standard library TypedDict in Python 3.8 does not store runtime information
-    # about which (if any) keys are optional.  See https://bugs.python.org/issue38834
-    # The standard library TypedDict in Python 3.9.0/1 does not honour the "total"
-    # keyword with old-style TypedDict().  See https://bugs.python.org/issue42059
-    TypedDict = typing.TypedDict
-else:
-    def _check_fails(cls, other):
-        try:
-            if sys._getframe(1).f_globals['__name__'] not in ['abc',
-                                                              'functools',
-                                                              'typing']:
-                # Typed dicts are only for static structural subtyping.
-                raise TypeError('TypedDict does not support instance and class checks')
-        except (AttributeError, ValueError):
-            pass
-        return False
-
-    def _dict_new(*args, **kwargs):
-        if not args:
-            raise TypeError('TypedDict.__new__(): not enough arguments')
-        _, args = args[0], args[1:]  # allow the "cls" keyword be passed
-        return dict(*args, **kwargs)
-
-    _dict_new.__text_signature__ = '($cls, _typename, _fields=None, /, **kwargs)'
-
-    def _typeddict_new(*args, total=True, **kwargs):
-        if not args:
-            raise TypeError('TypedDict.__new__(): not enough arguments')
-        _, args = args[0], args[1:]  # allow the "cls" keyword be passed
-        if args:
-            typename, args = args[0], args[1:]  # allow the "_typename" keyword be passed
-        elif '_typename' in kwargs:
-            typename = kwargs.pop('_typename')
-            import warnings
-            warnings.warn("Passing '_typename' as keyword argument is deprecated",
-                          DeprecationWarning, stacklevel=2)
-        else:
-            raise TypeError("TypedDict.__new__() missing 1 required positional "
-                            "argument: '_typename'")
-        if args:
-            try:
-                fields, = args  # allow the "_fields" keyword be passed
-            except ValueError:
-                raise TypeError('TypedDict.__new__() takes from 2 to 3 '
-                                f'positional arguments but {len(args) + 2} '
-                                'were given')
-        elif '_fields' in kwargs and len(kwargs) == 1:
-            fields = kwargs.pop('_fields')
-            import warnings
-            warnings.warn("Passing '_fields' as keyword argument is deprecated",
-                          DeprecationWarning, stacklevel=2)
-        else:
-            fields = None
-
-        if fields is None:
-            fields = kwargs
-        elif kwargs:
-            raise TypeError("TypedDict takes either a dict or keyword arguments,"
-                            " but not both")
-
-        ns = {'__annotations__': dict(fields)}
-        try:
-            # Setting correct module is necessary to make typed dict classes pickleable.
-            ns['__module__'] = sys._getframe(1).f_globals.get('__name__', '__main__')
-        except (AttributeError, ValueError):
-            pass
-
-        return _TypedDictMeta(typename, (), ns, total=total)
-
-    _typeddict_new.__text_signature__ = ('($cls, _typename, _fields=None,'
-                                         ' /, *, total=True, **kwargs)')
-
-    class _TypedDictMeta(type):
-        def __init__(cls, name, bases, ns, total=True):
-            super().__init__(name, bases, ns)
-
-        def __new__(cls, name, bases, ns, total=True):
-            # Create new typed dict class object.
-            # This method is called directly when TypedDict is subclassed,
-            # or via _typeddict_new when TypedDict is instantiated. This way
-            # TypedDict supports all three syntaxes described in its docstring.
-            # Subclasses and instances of TypedDict return actual dictionaries
-            # via _dict_new.
-            ns['__new__'] = _typeddict_new if name == 'TypedDict' else _dict_new
-            tp_dict = super().__new__(cls, name, (dict,), ns)
-
-            annotations = {}
-            own_annotations = ns.get('__annotations__', {})
-            own_annotation_keys = set(own_annotations.keys())
-            msg = "TypedDict('Name', {f0: t0, f1: t1, ...}); each t must be a type"
-            own_annotations = {
-                n: typing._type_check(tp, msg) for n, tp in own_annotations.items()
-            }
-            required_keys = set()
-            optional_keys = set()
-
-            for base in bases:
-                annotations.update(base.__dict__.get('__annotations__', {}))
-                required_keys.update(base.__dict__.get('__required_keys__', ()))
-                optional_keys.update(base.__dict__.get('__optional_keys__', ()))
-
-            annotations.update(own_annotations)
-            if total:
-                required_keys.update(own_annotation_keys)
-            else:
-                optional_keys.update(own_annotation_keys)
-
-            tp_dict.__annotations__ = annotations
-            tp_dict.__required_keys__ = frozenset(required_keys)
-            tp_dict.__optional_keys__ = frozenset(optional_keys)
-            if not hasattr(tp_dict, '__total__'):
-                tp_dict.__total__ = total
-            return tp_dict
-
-        __instancecheck__ = __subclasscheck__ = _check_fails
-
-    TypedDict = _TypedDictMeta('TypedDict', (dict,), {})
-    TypedDict.__module__ = __name__
-    TypedDict.__doc__ = \
-        """A simple typed name space. At runtime it is equivalent to a plain dict.
-
-        TypedDict creates a dictionary type that expects all of its
-        instances to have a certain set of keys, with each key
-        associated with a value of a consistent type. This expectation
-        is not checked at runtime but is only enforced by type checkers.
-        Usage::
-
-            class Point2D(TypedDict):
-                x: int
-                y: int
-                label: str
-
-            a: Point2D = {'x': 1, 'y': 2, 'label': 'good'}  # OK
-            b: Point2D = {'z': 3, 'label': 'bad'}           # Fails type check
-
-            assert Point2D(x=1, y=2, label='first') == dict(x=1, y=2, label='first')
-
-        The type info can be accessed via the Point2D.__annotations__ dict, and
-        the Point2D.__required_keys__ and Point2D.__optional_keys__ frozensets.
-        TypedDict supports two additional equivalent forms::
-
-            Point2D = TypedDict('Point2D', x=int, y=int, label=str)
-            Point2D = TypedDict('Point2D', {'x': int, 'y': int, 'label': str})
-
-        The class syntax is only supported in Python 3.6+, while two other
-        syntax forms work for Python 2.7 and 3.2+
-        """
-
-
-# Python 3.9+ has PEP 593 (Annotated and modified get_type_hints)
-if hasattr(typing, 'Annotated'):
-    Annotated = typing.Annotated
-    get_type_hints = typing.get_type_hints
-    # Not exported and not a public API, but needed for get_origin() and get_args()
-    # to work.
-    _AnnotatedAlias = typing._AnnotatedAlias
-# 3.7-3.8
-elif PEP_560:
-    class _AnnotatedAlias(typing._GenericAlias, _root=True):
-        """Runtime representation of an annotated type.
-
-        At its core 'Annotated[t, dec1, dec2, ...]' is an alias for the type 't'
-        with extra annotations. The alias behaves like a normal typing alias,
-        instantiating is the same as instantiating the underlying type, binding
-        it to types is also the same.
-        """
-        def __init__(self, origin, metadata):
-            if isinstance(origin, _AnnotatedAlias):
-                metadata = origin.__metadata__ + metadata
-                origin = origin.__origin__
-            super().__init__(origin, origin)
-            self.__metadata__ = metadata
-
-        def copy_with(self, params):
-            assert len(params) == 1
-            new_type = params[0]
-            return _AnnotatedAlias(new_type, self.__metadata__)
-
-        def __repr__(self):
-            return (f"typing_extensions.Annotated[{typing._type_repr(self.__origin__)}, "
-                    f"{', '.join(repr(a) for a in self.__metadata__)}]")
-
-        def __reduce__(self):
-            return operator.getitem, (
-                Annotated, (self.__origin__,) + self.__metadata__
-            )
-
-        def __eq__(self, other):
-            if not isinstance(other, _AnnotatedAlias):
-                return NotImplemented
-            if self.__origin__ != other.__origin__:
-                return False
-            return self.__metadata__ == other.__metadata__
-
-        def __hash__(self):
-            return hash((self.__origin__, self.__metadata__))
-
-    class Annotated:
-        """Add context specific metadata to a type.
-
-        Example: Annotated[int, runtime_check.Unsigned] indicates to the
-        hypothetical runtime_check module that this type is an unsigned int.
-        Every other consumer of this type can ignore this metadata and treat
-        this type as int.
-
-        The first argument to Annotated must be a valid type (and will be in
-        the __origin__ field), the remaining arguments are kept as a tuple in
-        the __extra__ field.
-
-        Details:
-
-        - It's an error to call `Annotated` with less than two arguments.
-        - Nested Annotated are flattened::
-
-            Annotated[Annotated[T, Ann1, Ann2], Ann3] == Annotated[T, Ann1, Ann2, Ann3]
-
-        - Instantiating an annotated type is equivalent to instantiating the
-        underlying type::
-
-            Annotated[C, Ann1](5) == C(5)
-
-        - Annotated can be used as a generic type alias::
-
-            Optimized = Annotated[T, runtime.Optimize()]
-            Optimized[int] == Annotated[int, runtime.Optimize()]
-
-            OptimizedList = Annotated[List[T], runtime.Optimize()]
-            OptimizedList[int] == Annotated[List[int], runtime.Optimize()]
-        """
-
-        __slots__ = ()
-
-        def __new__(cls, *args, **kwargs):
-            raise TypeError("Type Annotated cannot be instantiated.")
-
-        @typing._tp_cache
-        def __class_getitem__(cls, params):
-            if not isinstance(params, tuple) or len(params) < 2:
-                raise TypeError("Annotated[...] should be used "
-                                "with at least two arguments (a type and an "
-                                "annotation).")
-            msg = "Annotated[t, ...]: t must be a type."
-            origin = typing._type_check(params[0], msg)
-            metadata = tuple(params[1:])
-            return _AnnotatedAlias(origin, metadata)
-
-        def __init_subclass__(cls, *args, **kwargs):
-            raise TypeError(
-                f"Cannot subclass {cls.__module__}.Annotated"
-            )
-
-    def _strip_annotations(t):
-        """Strips the annotations from a given type.
-        """
-        if isinstance(t, _AnnotatedAlias):
-            return _strip_annotations(t.__origin__)
-        if isinstance(t, typing._GenericAlias):
-            stripped_args = tuple(_strip_annotations(a) for a in t.__args__)
-            if stripped_args == t.__args__:
-                return t
-            res = t.copy_with(stripped_args)
-            res._special = t._special
-            return res
-        return t
-
-    def get_type_hints(obj, globalns=None, localns=None, include_extras=False):
-        """Return type hints for an object.
-
-        This is often the same as obj.__annotations__, but it handles
-        forward references encoded as string literals, adds Optional[t] if a
-        default value equal to None is set and recursively replaces all
-        'Annotated[T, ...]' with 'T' (unless 'include_extras=True').
-
-        The argument may be a module, class, method, or function. The annotations
-        are returned as a dictionary. For classes, annotations include also
-        inherited members.
-
-        TypeError is raised if the argument is not of a type that can contain
-        annotations, and an empty dictionary is returned if no annotations are
-        present.
-
-        BEWARE -- the behavior of globalns and localns is counterintuitive
-        (unless you are familiar with how eval() and exec() work).  The
-        search order is locals first, then globals.
-
-        - If no dict arguments are passed, an attempt is made to use the
-          globals from obj (or the respective module's globals for classes),
-          and these are also used as the locals.  If the object does not appear
-          to have globals, an empty dictionary is used.
-
-        - If one dict argument is passed, it is used for both globals and
-          locals.
-
-        - If two dict arguments are passed, they specify globals and
-          locals, respectively.
-        """
-        hint = typing.get_type_hints(obj, globalns=globalns, localns=localns)
-        if include_extras:
-            return hint
-        return {k: _strip_annotations(t) for k, t in hint.items()}
-# 3.6
-else:
-
-    def _is_dunder(name):
-        """Returns True if name is a __dunder_variable_name__."""
-        return len(name) > 4 and name.startswith('__') and name.endswith('__')
-
-    # Prior to Python 3.7 types did not have `copy_with`. A lot of the equality
-    # checks, argument expansion etc. are done on the _subs_tre. As a result we
-    # can't provide a get_type_hints function that strips out annotations.
-
-    class AnnotatedMeta(typing.GenericMeta):
-        """Metaclass for Annotated"""
-
-        def __new__(cls, name, bases, namespace, **kwargs):
-            if any(b is not object for b in bases):
-                raise TypeError("Cannot subclass " + str(Annotated))
-            return super().__new__(cls, name, bases, namespace, **kwargs)
-
-        @property
-        def __metadata__(self):
-            return self._subs_tree()[2]
-
-        def _tree_repr(self, tree):
-            cls, origin, metadata = tree
-            if not isinstance(origin, tuple):
-                tp_repr = typing._type_repr(origin)
-            else:
-                tp_repr = origin[0]._tree_repr(origin)
-            metadata_reprs = ", ".join(repr(arg) for arg in metadata)
-            return f'{cls}[{tp_repr}, {metadata_reprs}]'
-
-        def _subs_tree(self, tvars=None, args=None):  # noqa
-            if self is Annotated:
-                return Annotated
-            res = super()._subs_tree(tvars=tvars, args=args)
-            # Flatten nested Annotated
-            if isinstance(res[1], tuple) and res[1][0] is Annotated:
-                sub_tp = res[1][1]
-                sub_annot = res[1][2]
-                return (Annotated, sub_tp, sub_annot + res[2])
-            return res
-
-        def _get_cons(self):
-            """Return the class used to create instance of this type."""
-            if self.__origin__ is None:
-                raise TypeError("Cannot get the underlying type of a "
-                                "non-specialized Annotated type.")
-            tree = self._subs_tree()
-            while isinstance(tree, tuple) and tree[0] is Annotated:
-                tree = tree[1]
-            if isinstance(tree, tuple):
-                return tree[0]
-            else:
-                return tree
-
-        @typing._tp_cache
-        def __getitem__(self, params):
-            if not isinstance(params, tuple):
-                params = (params,)
-            if self.__origin__ is not None:  # specializing an instantiated type
-                return super().__getitem__(params)
-            elif not isinstance(params, tuple) or len(params) < 2:
-                raise TypeError("Annotated[...] should be instantiated "
-                                "with at least two arguments (a type and an "
-                                "annotation).")
-            else:
-                msg = "Annotated[t, ...]: t must be a type."
-                tp = typing._type_check(params[0], msg)
-                metadata = tuple(params[1:])
-            return self.__class__(
-                self.__name__,
-                self.__bases__,
-                _no_slots_copy(self.__dict__),
-                tvars=_type_vars((tp,)),
-                # Metadata is a tuple so it won't be touched by _replace_args et al.
-                args=(tp, metadata),
-                origin=self,
-            )
-
-        def __call__(self, *args, **kwargs):
-            cons = self._get_cons()
-            result = cons(*args, **kwargs)
-            try:
-                result.__orig_class__ = self
-            except AttributeError:
-                pass
-            return result
-
-        def __getattr__(self, attr):
-            # For simplicity we just don't relay all dunder names
-            if self.__origin__ is not None and not _is_dunder(attr):
-                return getattr(self._get_cons(), attr)
-            raise AttributeError(attr)
-
-        def __setattr__(self, attr, value):
-            if _is_dunder(attr) or attr.startswith('_abc_'):
-                super().__setattr__(attr, value)
-            elif self.__origin__ is None:
-                raise AttributeError(attr)
-            else:
-                setattr(self._get_cons(), attr, value)
-
-        def __instancecheck__(self, obj):
-            raise TypeError("Annotated cannot be used with isinstance().")
-
-        def __subclasscheck__(self, cls):
-            raise TypeError("Annotated cannot be used with issubclass().")
-
-    class Annotated(metaclass=AnnotatedMeta):
-        """Add context specific metadata to a type.
-
-        Example: Annotated[int, runtime_check.Unsigned] indicates to the
-        hypothetical runtime_check module that this type is an unsigned int.
-        Every other consumer of this type can ignore this metadata and treat
-        this type as int.
-
-        The first argument to Annotated must be a valid type, the remaining
-        arguments are kept as a tuple in the __metadata__ field.
-
-        Details:
-
-        - It's an error to call `Annotated` with less than two arguments.
-        - Nested Annotated are flattened::
-
-            Annotated[Annotated[T, Ann1, Ann2], Ann3] == Annotated[T, Ann1, Ann2, Ann3]
-
-        - Instantiating an annotated type is equivalent to instantiating the
-        underlying type::
-
-            Annotated[C, Ann1](5) == C(5)
-
-        - Annotated can be used as a generic type alias::
-
-            Optimized = Annotated[T, runtime.Optimize()]
-            Optimized[int] == Annotated[int, runtime.Optimize()]
-
-            OptimizedList = Annotated[List[T], runtime.Optimize()]
-            OptimizedList[int] == Annotated[List[int], runtime.Optimize()]
-        """
-
-# Python 3.8 has get_origin() and get_args() but those implementations aren't
-# Annotated-aware, so we can't use those. Python 3.9's versions don't support
-# ParamSpecArgs and ParamSpecKwargs, so only Python 3.10's versions will do.
-if sys.version_info[:2] >= (3, 10):
-    get_origin = typing.get_origin
-    get_args = typing.get_args
-# 3.7-3.9
-elif PEP_560:
-    try:
-        # 3.9+
-        from typing import _BaseGenericAlias
-    except ImportError:
-        _BaseGenericAlias = typing._GenericAlias
-    try:
-        # 3.9+
-        from typing import GenericAlias
-    except ImportError:
-        GenericAlias = typing._GenericAlias
-
-    def get_origin(tp):
-        """Get the unsubscripted version of a type.
-
-        This supports generic types, Callable, Tuple, Union, Literal, Final, ClassVar
-        and Annotated. Return None for unsupported types. Examples::
-
-            get_origin(Literal[42]) is Literal
-            get_origin(int) is None
-            get_origin(ClassVar[int]) is ClassVar
-            get_origin(Generic) is Generic
-            get_origin(Generic[T]) is Generic
-            get_origin(Union[T, int]) is Union
-            get_origin(List[Tuple[T, T]][int]) == list
-            get_origin(P.args) is P
-        """
-        if isinstance(tp, _AnnotatedAlias):
-            return Annotated
-        if isinstance(tp, (typing._GenericAlias, GenericAlias, _BaseGenericAlias,
-                           ParamSpecArgs, ParamSpecKwargs)):
-            return tp.__origin__
-        if tp is typing.Generic:
-            return typing.Generic
-        return None
-
-    def get_args(tp):
-        """Get type arguments with all substitutions performed.
-
-        For unions, basic simplifications used by Union constructor are performed.
-        Examples::
-            get_args(Dict[str, int]) == (str, int)
-            get_args(int) == ()
-            get_args(Union[int, Union[T, int], str][int]) == (int, str)
-            get_args(Union[int, Tuple[T, int]][str]) == (int, Tuple[str, int])
-            get_args(Callable[[], T][int]) == ([], int)
-        """
-        if isinstance(tp, _AnnotatedAlias):
-            return (tp.__origin__,) + tp.__metadata__
-        if isinstance(tp, (typing._GenericAlias, GenericAlias)):
-            if getattr(tp, "_special", False):
-                return ()
-            res = tp.__args__
-            if get_origin(tp) is collections.abc.Callable and res[0] is not Ellipsis:
-                res = (list(res[:-1]), res[-1])
-            return res
-        return ()
-
-
-# 3.10+
-if hasattr(typing, 'TypeAlias'):
-    TypeAlias = typing.TypeAlias
-# 3.9
-elif sys.version_info[:2] >= (3, 9):
-    class _TypeAliasForm(typing._SpecialForm, _root=True):
-        def __repr__(self):
-            return 'typing_extensions.' + self._name
-
-    @_TypeAliasForm
-    def TypeAlias(self, parameters):
-        """Special marker indicating that an assignment should
-        be recognized as a proper type alias definition by type
-        checkers.
-
-        For example::
-
-            Predicate: TypeAlias = Callable[..., bool]
-
-        It's invalid when used anywhere except as in the example above.
-        """
-        raise TypeError(f"{self} is not subscriptable")
-# 3.7-3.8
-elif sys.version_info[:2] >= (3, 7):
-    class _TypeAliasForm(typing._SpecialForm, _root=True):
-        def __repr__(self):
-            return 'typing_extensions.' + self._name
-
-    TypeAlias = _TypeAliasForm('TypeAlias',
-                               doc="""Special marker indicating that an assignment should
-                               be recognized as a proper type alias definition by type
-                               checkers.
-
-                               For example::
-
-                                   Predicate: TypeAlias = Callable[..., bool]
-
-                               It's invalid when used anywhere except as in the example
-                               above.""")
-# 3.6
-else:
-    class _TypeAliasMeta(typing.TypingMeta):
-        """Metaclass for TypeAlias"""
-
-        def __repr__(self):
-            return 'typing_extensions.TypeAlias'
-
-    class _TypeAliasBase(typing._FinalTypingBase, metaclass=_TypeAliasMeta, _root=True):
-        """Special marker indicating that an assignment should
-        be recognized as a proper type alias definition by type
-        checkers.
-
-        For example::
-
-            Predicate: TypeAlias = Callable[..., bool]
-
-        It's invalid when used anywhere except as in the example above.
-        """
-        __slots__ = ()
-
-        def __instancecheck__(self, obj):
-            raise TypeError("TypeAlias cannot be used with isinstance().")
-
-        def __subclasscheck__(self, cls):
-            raise TypeError("TypeAlias cannot be used with issubclass().")
-
-        def __repr__(self):
-            return 'typing_extensions.TypeAlias'
-
-    TypeAlias = _TypeAliasBase(_root=True)
-
-
-# Python 3.10+ has PEP 612
-if hasattr(typing, 'ParamSpecArgs'):
-    ParamSpecArgs = typing.ParamSpecArgs
-    ParamSpecKwargs = typing.ParamSpecKwargs
-# 3.6-3.9
-else:
-    class _Immutable:
-        """Mixin to indicate that object should not be copied."""
-        __slots__ = ()
-
-        def __copy__(self):
-            return self
-
-        def __deepcopy__(self, memo):
-            return self
-
-    class ParamSpecArgs(_Immutable):
-        """The args for a ParamSpec object.
-
-        Given a ParamSpec object P, P.args is an instance of ParamSpecArgs.
-
-        ParamSpecArgs objects have a reference back to their ParamSpec:
-
-        P.args.__origin__ is P
-
-        This type is meant for runtime introspection and has no special meaning to
-        static type checkers.
-        """
-        def __init__(self, origin):
-            self.__origin__ = origin
-
-        def __repr__(self):
-            return f"{self.__origin__.__name__}.args"
-
-    class ParamSpecKwargs(_Immutable):
-        """The kwargs for a ParamSpec object.
-
-        Given a ParamSpec object P, P.kwargs is an instance of ParamSpecKwargs.
-
-        ParamSpecKwargs objects have a reference back to their ParamSpec:
-
-        P.kwargs.__origin__ is P
-
-        This type is meant for runtime introspection and has no special meaning to
-        static type checkers.
-        """
-        def __init__(self, origin):
-            self.__origin__ = origin
-
-        def __repr__(self):
-            return f"{self.__origin__.__name__}.kwargs"
-
-# 3.10+
-if hasattr(typing, 'ParamSpec'):
-    ParamSpec = typing.ParamSpec
-# 3.6-3.9
-else:
-
-    # Inherits from list as a workaround for Callable checks in Python < 3.9.2.
-    class ParamSpec(list):
-        """Parameter specification variable.
-
-        Usage::
-
-           P = ParamSpec('P')
-
-        Parameter specification variables exist primarily for the benefit of static
-        type checkers.  They are used to forward the parameter types of one
-        callable to another callable, a pattern commonly found in higher order
-        functions and decorators.  They are only valid when used in ``Concatenate``,
-        or s the first argument to ``Callable``. In Python 3.10 and higher,
-        they are also supported in user-defined Generics at runtime.
-        See class Generic for more information on generic types.  An
-        example for annotating a decorator::
-
-           T = TypeVar('T')
-           P = ParamSpec('P')
-
-           def add_logging(f: Callable[P, T]) -> Callable[P, T]:
-               '''A type-safe decorator to add logging to a function.'''
-               def inner(*args: P.args, **kwargs: P.kwargs) -> T:
-                   logging.info(f'{f.__name__} was called')
-                   return f(*args, **kwargs)
-               return inner
-
-           @add_logging
-           def add_two(x: float, y: float) -> float:
-               '''Add two numbers together.'''
-               return x + y
-
-        Parameter specification variables defined with covariant=True or
-        contravariant=True can be used to declare covariant or contravariant
-        generic types.  These keyword arguments are valid, but their actual semantics
-        are yet to be decided.  See PEP 612 for details.
-
-        Parameter specification variables can be introspected. e.g.:
-
-           P.__name__ == 'T'
-           P.__bound__ == None
-           P.__covariant__ == False
-           P.__contravariant__ == False
-
-        Note that only parameter specification variables defined in global scope can
-        be pickled.
-        """
-
-        # Trick Generic __parameters__.
-        __class__ = typing.TypeVar
-
-        @property
-        def args(self):
-            return ParamSpecArgs(self)
-
-        @property
-        def kwargs(self):
-            return ParamSpecKwargs(self)
-
-        def __init__(self, name, *, bound=None, covariant=False, contravariant=False):
-            super().__init__([self])
-            self.__name__ = name
-            self.__covariant__ = bool(covariant)
-            self.__contravariant__ = bool(contravariant)
-            if bound:
-                self.__bound__ = typing._type_check(bound, 'Bound must be a type.')
-            else:
-                self.__bound__ = None
-
-            # for pickling:
-            try:
-                def_mod = sys._getframe(1).f_globals.get('__name__', '__main__')
-            except (AttributeError, ValueError):
-                def_mod = None
-            if def_mod != 'typing_extensions':
-                self.__module__ = def_mod
-
-        def __repr__(self):
-            if self.__covariant__:
-                prefix = '+'
-            elif self.__contravariant__:
-                prefix = '-'
-            else:
-                prefix = '~'
-            return prefix + self.__name__
-
-        def __hash__(self):
-            return object.__hash__(self)
-
-        def __eq__(self, other):
-            return self is other
-
-        def __reduce__(self):
-            return self.__name__
-
-        # Hack to get typing._type_check to pass.
-        def __call__(self, *args, **kwargs):
-            pass
-
-        if not PEP_560:
-            # Only needed in 3.6.
-            def _get_type_vars(self, tvars):
-                if self not in tvars:
-                    tvars.append(self)
-
-
-# 3.6-3.9
-if not hasattr(typing, 'Concatenate'):
-    # Inherits from list as a workaround for Callable checks in Python < 3.9.2.
-    class _ConcatenateGenericAlias(list):
-
-        # Trick Generic into looking into this for __parameters__.
-        if PEP_560:
-            __class__ = typing._GenericAlias
-        else:
-            __class__ = typing._TypingBase
-
-        # Flag in 3.8.
-        _special = False
-        # Attribute in 3.6 and earlier.
-        _gorg = typing.Generic
-
-        def __init__(self, origin, args):
-            super().__init__(args)
-            self.__origin__ = origin
-            self.__args__ = args
-
-        def __repr__(self):
-            _type_repr = typing._type_repr
-            return (f'{_type_repr(self.__origin__)}'
-                    f'[{", ".join(_type_repr(arg) for arg in self.__args__)}]')
-
-        def __hash__(self):
-            return hash((self.__origin__, self.__args__))
-
-        # Hack to get typing._type_check to pass in Generic.
-        def __call__(self, *args, **kwargs):
-            pass
-
-        @property
-        def __parameters__(self):
-            return tuple(
-                tp for tp in self.__args__ if isinstance(tp, (typing.TypeVar, ParamSpec))
-            )
-
-        if not PEP_560:
-            # Only required in 3.6.
-            def _get_type_vars(self, tvars):
-                if self.__origin__ and self.__parameters__:
-                    typing._get_type_vars(self.__parameters__, tvars)
-
-
-# 3.6-3.9
-@typing._tp_cache
-def _concatenate_getitem(self, parameters):
-    if parameters == ():
-        raise TypeError("Cannot take a Concatenate of no types.")
-    if not isinstance(parameters, tuple):
-        parameters = (parameters,)
-    if not isinstance(parameters[-1], ParamSpec):
-        raise TypeError("The last parameter to Concatenate should be a "
-                        "ParamSpec variable.")
-    msg = "Concatenate[arg, ...]: each arg must be a type."
-    parameters = tuple(typing._type_check(p, msg) for p in parameters)
-    return _ConcatenateGenericAlias(self, parameters)
-
-
-# 3.10+
-if hasattr(typing, 'Concatenate'):
-    Concatenate = typing.Concatenate
-    _ConcatenateGenericAlias = typing._ConcatenateGenericAlias # noqa
-# 3.9
-elif sys.version_info[:2] >= (3, 9):
-    @_TypeAliasForm
-    def Concatenate(self, parameters):
-        """Used in conjunction with ``ParamSpec`` and ``Callable`` to represent a
-        higher order function which adds, removes or transforms parameters of a
-        callable.
-
-        For example::
-
-           Callable[Concatenate[int, P], int]
-
-        See PEP 612 for detailed information.
-        """
-        return _concatenate_getitem(self, parameters)
-# 3.7-8
-elif sys.version_info[:2] >= (3, 7):
-    class _ConcatenateForm(typing._SpecialForm, _root=True):
-        def __repr__(self):
-            return 'typing_extensions.' + self._name
-
-        def __getitem__(self, parameters):
-            return _concatenate_getitem(self, parameters)
-
-    Concatenate = _ConcatenateForm(
-        'Concatenate',
-        doc="""Used in conjunction with ``ParamSpec`` and ``Callable`` to represent a
-        higher order function which adds, removes or transforms parameters of a
-        callable.
-
-        For example::
-
-           Callable[Concatenate[int, P], int]
-
-        See PEP 612 for detailed information.
-        """)
-# 3.6
-else:
-    class _ConcatenateAliasMeta(typing.TypingMeta):
-        """Metaclass for Concatenate."""
-
-        def __repr__(self):
-            return 'typing_extensions.Concatenate'
-
-    class _ConcatenateAliasBase(typing._FinalTypingBase,
-                                metaclass=_ConcatenateAliasMeta,
-                                _root=True):
-        """Used in conjunction with ``ParamSpec`` and ``Callable`` to represent a
-        higher order function which adds, removes or transforms parameters of a
-        callable.
-
-        For example::
-
-           Callable[Concatenate[int, P], int]
-
-        See PEP 612 for detailed information.
-        """
-        __slots__ = ()
-
-        def __instancecheck__(self, obj):
-            raise TypeError("Concatenate cannot be used with isinstance().")
-
-        def __subclasscheck__(self, cls):
-            raise TypeError("Concatenate cannot be used with issubclass().")
-
-        def __repr__(self):
-            return 'typing_extensions.Concatenate'
-
-        def __getitem__(self, parameters):
-            return _concatenate_getitem(self, parameters)
-
-    Concatenate = _ConcatenateAliasBase(_root=True)
-
-# 3.10+
-if hasattr(typing, 'TypeGuard'):
-    TypeGuard = typing.TypeGuard
-# 3.9
-elif sys.version_info[:2] >= (3, 9):
-    class _TypeGuardForm(typing._SpecialForm, _root=True):
-        def __repr__(self):
-            return 'typing_extensions.' + self._name
-
-    @_TypeGuardForm
-    def TypeGuard(self, parameters):
-        """Special typing form used to annotate the return type of a user-defined
-        type guard function.  ``TypeGuard`` only accepts a single type argument.
-        At runtime, functions marked this way should return a boolean.
-
-        ``TypeGuard`` aims to benefit *type narrowing* -- a technique used by static
-        type checkers to determine a more precise type of an expression within a
-        program's code flow.  Usually type narrowing is done by analyzing
-        conditional code flow and applying the narrowing to a block of code.  The
-        conditional expression here is sometimes referred to as a "type guard".
-
-        Sometimes it would be convenient to use a user-defined boolean function
-        as a type guard.  Such a function should use ``TypeGuard[...]`` as its
-        return type to alert static type checkers to this intention.
-
-        Using  ``-> TypeGuard`` tells the static type checker that for a given
-        function:
-
-        1. The return value is a boolean.
-        2. If the return value is ``True``, the type of its argument
-        is the type inside ``TypeGuard``.
-
-        For example::
-
-            def is_str(val: Union[str, float]):
-                # "isinstance" type guard
-                if isinstance(val, str):
-                    # Type of ``val`` is narrowed to ``str``
-                    ...
-                else:
-                    # Else, type of ``val`` is narrowed to ``float``.
-                    ...
-
-        Strict type narrowing is not enforced -- ``TypeB`` need not be a narrower
-        form of ``TypeA`` (it can even be a wider form) and this may lead to
-        type-unsafe results.  The main reason is to allow for things like
-        narrowing ``List[object]`` to ``List[str]`` even though the latter is not
-        a subtype of the former, since ``List`` is invariant.  The responsibility of
-        writing type-safe type guards is left to the user.
-
-        ``TypeGuard`` also works with type variables.  For more information, see
-        PEP 647 (User-Defined Type Guards).
-        """
-        item = typing._type_check(parameters, f'{self} accepts only single type.')
-        return typing._GenericAlias(self, (item,))
-# 3.7-3.8
-elif sys.version_info[:2] >= (3, 7):
-    class _TypeGuardForm(typing._SpecialForm, _root=True):
-
-        def __repr__(self):
-            return 'typing_extensions.' + self._name
-
-        def __getitem__(self, parameters):
-            item = typing._type_check(parameters,
-                                      f'{self._name} accepts only a single type')
-            return typing._GenericAlias(self, (item,))
-
-    TypeGuard = _TypeGuardForm(
-        'TypeGuard',
-        doc="""Special typing form used to annotate the return type of a user-defined
-        type guard function.  ``TypeGuard`` only accepts a single type argument.
-        At runtime, functions marked this way should return a boolean.
-
-        ``TypeGuard`` aims to benefit *type narrowing* -- a technique used by static
-        type checkers to determine a more precise type of an expression within a
-        program's code flow.  Usually type narrowing is done by analyzing
-        conditional code flow and applying the narrowing to a block of code.  The
-        conditional expression here is sometimes referred to as a "type guard".
-
-        Sometimes it would be convenient to use a user-defined boolean function
-        as a type guard.  Such a function should use ``TypeGuard[...]`` as its
-        return type to alert static type checkers to this intention.
-
-        Using  ``-> TypeGuard`` tells the static type checker that for a given
-        function:
-
-        1. The return value is a boolean.
-        2. If the return value is ``True``, the type of its argument
-        is the type inside ``TypeGuard``.
-
-        For example::
-
-            def is_str(val: Union[str, float]):
-                # "isinstance" type guard
-                if isinstance(val, str):
-                    # Type of ``val`` is narrowed to ``str``
-                    ...
-                else:
-                    # Else, type of ``val`` is narrowed to ``float``.
-                    ...
-
-        Strict type narrowing is not enforced -- ``TypeB`` need not be a narrower
-        form of ``TypeA`` (it can even be a wider form) and this may lead to
-        type-unsafe results.  The main reason is to allow for things like
-        narrowing ``List[object]`` to ``List[str]`` even though the latter is not
-        a subtype of the former, since ``List`` is invariant.  The responsibility of
-        writing type-safe type guards is left to the user.
-
-        ``TypeGuard`` also works with type variables.  For more information, see
-        PEP 647 (User-Defined Type Guards).
-        """)
-# 3.6
-else:
-    class _TypeGuard(typing._FinalTypingBase, _root=True):
-        """Special typing form used to annotate the return type of a user-defined
-        type guard function.  ``TypeGuard`` only accepts a single type argument.
-        At runtime, functions marked this way should return a boolean.
-
-        ``TypeGuard`` aims to benefit *type narrowing* -- a technique used by static
-        type checkers to determine a more precise type of an expression within a
-        program's code flow.  Usually type narrowing is done by analyzing
-        conditional code flow and applying the narrowing to a block of code.  The
-        conditional expression here is sometimes referred to as a "type guard".
-
-        Sometimes it would be convenient to use a user-defined boolean function
-        as a type guard.  Such a function should use ``TypeGuard[...]`` as its
-        return type to alert static type checkers to this intention.
-
-        Using  ``-> TypeGuard`` tells the static type checker that for a given
-        function:
-
-        1. The return value is a boolean.
-        2. If the return value is ``True``, the type of its argument
-        is the type inside ``TypeGuard``.
-
-        For example::
-
-            def is_str(val: Union[str, float]):
-                # "isinstance" type guard
-                if isinstance(val, str):
-                    # Type of ``val`` is narrowed to ``str``
-                    ...
-                else:
-                    # Else, type of ``val`` is narrowed to ``float``.
-                    ...
-
-        Strict type narrowing is not enforced -- ``TypeB`` need not be a narrower
-        form of ``TypeA`` (it can even be a wider form) and this may lead to
-        type-unsafe results.  The main reason is to allow for things like
-        narrowing ``List[object]`` to ``List[str]`` even though the latter is not
-        a subtype of the former, since ``List`` is invariant.  The responsibility of
-        writing type-safe type guards is left to the user.
-
-        ``TypeGuard`` also works with type variables.  For more information, see
-        PEP 647 (User-Defined Type Guards).
-        """
-
-        __slots__ = ('__type__',)
-
-        def __init__(self, tp=None, **kwds):
-            self.__type__ = tp
-
-        def __getitem__(self, item):
-            cls = type(self)
-            if self.__type__ is None:
-                return cls(typing._type_check(item,
-                           f'{cls.__name__[1:]} accepts only a single type.'),
-                           _root=True)
-            raise TypeError(f'{cls.__name__[1:]} cannot be further subscripted')
-
-        def _eval_type(self, globalns, localns):
-            new_tp = typing._eval_type(self.__type__, globalns, localns)
-            if new_tp == self.__type__:
-                return self
-            return type(self)(new_tp, _root=True)
-
-        def __repr__(self):
-            r = super().__repr__()
-            if self.__type__ is not None:
-                r += f'[{typing._type_repr(self.__type__)}]'
-            return r
-
-        def __hash__(self):
-            return hash((type(self).__name__, self.__type__))
-
-        def __eq__(self, other):
-            if not isinstance(other, _TypeGuard):
-                return NotImplemented
-            if self.__type__ is not None:
-                return self.__type__ == other.__type__
-            return self is other
-
-    TypeGuard = _TypeGuard(_root=True)
-
-if hasattr(typing, "Self"):
-    Self = typing.Self
-elif sys.version_info[:2] >= (3, 7):
-    # Vendored from cpython typing._SpecialFrom
-    class _SpecialForm(typing._Final, _root=True):
-        __slots__ = ('_name', '__doc__', '_getitem')
-
-        def __init__(self, getitem):
-            self._getitem = getitem
-            self._name = getitem.__name__
-            self.__doc__ = getitem.__doc__
-
-        def __getattr__(self, item):
-            if item in {'__name__', '__qualname__'}:
-                return self._name
-
-            raise AttributeError(item)
-
-        def __mro_entries__(self, bases):
-            raise TypeError(f"Cannot subclass {self!r}")
-
-        def __repr__(self):
-            return f'typing_extensions.{self._name}'
-
-        def __reduce__(self):
-            return self._name
-
-        def __call__(self, *args, **kwds):
-            raise TypeError(f"Cannot instantiate {self!r}")
-
-        def __or__(self, other):
-            return typing.Union[self, other]
-
-        def __ror__(self, other):
-            return typing.Union[other, self]
-
-        def __instancecheck__(self, obj):
-            raise TypeError(f"{self} cannot be used with isinstance()")
-
-        def __subclasscheck__(self, cls):
-            raise TypeError(f"{self} cannot be used with issubclass()")
-
-        @typing._tp_cache
-        def __getitem__(self, parameters):
-            return self._getitem(self, parameters)
-
-    @_SpecialForm
-    def Self(self, params):
-        """Used to spell the type of "self" in classes.
-
-        Example::
-
-          from typing import Self
-
-          class ReturnsSelf:
-              def parse(self, data: bytes) -> Self:
-                  ...
-                  return self
-
-        """
-
-        raise TypeError(f"{self} is not subscriptable")
-else:
-    class _Self(typing._FinalTypingBase, _root=True):
-        """Used to spell the type of "self" in classes.
-
-        Example::
-
-          from typing import Self
-
-          class ReturnsSelf:
-              def parse(self, data: bytes) -> Self:
-                  ...
-                  return self
-
-        """
-
-        __slots__ = ()
-
-        def __instancecheck__(self, obj):
-            raise TypeError(f"{self} cannot be used with isinstance().")
-
-        def __subclasscheck__(self, cls):
-            raise TypeError(f"{self} cannot be used with issubclass().")
-
-    Self = _Self(_root=True)
-
-
-if hasattr(typing, 'Required'):
-    Required = typing.Required
-    NotRequired = typing.NotRequired
-elif sys.version_info[:2] >= (3, 9):
-    class _ExtensionsSpecialForm(typing._SpecialForm, _root=True):
-        def __repr__(self):
-            return 'typing_extensions.' + self._name
-
-    @_ExtensionsSpecialForm
-    def Required(self, parameters):
-        """A special typing construct to mark a key of a total=False TypedDict
-        as required. For example:
-
-            class Movie(TypedDict, total=False):
-                title: Required[str]
-                year: int
-
-            m = Movie(
-                title='The Matrix',  # typechecker error if key is omitted
-                year=1999,
-            )
-
-        There is no runtime checking that a required key is actually provided
-        when instantiating a related TypedDict.
-        """
-        item = typing._type_check(parameters, f'{self._name} accepts only single type')
-        return typing._GenericAlias(self, (item,))
-
-    @_ExtensionsSpecialForm
-    def NotRequired(self, parameters):
-        """A special typing construct to mark a key of a TypedDict as
-        potentially missing. For example:
-
-            class Movie(TypedDict):
-                title: str
-                year: NotRequired[int]
-
-            m = Movie(
-                title='The Matrix',  # typechecker error if key is omitted
-                year=1999,
-            )
-        """
-        item = typing._type_check(parameters, f'{self._name} accepts only single type')
-        return typing._GenericAlias(self, (item,))
-
-elif sys.version_info[:2] >= (3, 7):
-    class _RequiredForm(typing._SpecialForm, _root=True):
-        def __repr__(self):
-            return 'typing_extensions.' + self._name
-
-        def __getitem__(self, parameters):
-            item = typing._type_check(parameters,
-                                      '{} accepts only single type'.format(self._name))
-            return typing._GenericAlias(self, (item,))
-
-    Required = _RequiredForm(
-        'Required',
-        doc="""A special typing construct to mark a key of a total=False TypedDict
-        as required. For example:
-
-            class Movie(TypedDict, total=False):
-                title: Required[str]
-                year: int
-
-            m = Movie(
-                title='The Matrix',  # typechecker error if key is omitted
-                year=1999,
-            )
-
-        There is no runtime checking that a required key is actually provided
-        when instantiating a related TypedDict.
-        """)
-    NotRequired = _RequiredForm(
-        'NotRequired',
-        doc="""A special typing construct to mark a key of a TypedDict as
-        potentially missing. For example:
-
-            class Movie(TypedDict):
-                title: str
-                year: NotRequired[int]
-
-            m = Movie(
-                title='The Matrix',  # typechecker error if key is omitted
-                year=1999,
-            )
-        """)
-else:
-    # NOTE: Modeled after _Final's implementation when _FinalTypingBase available
-    class _MaybeRequired(typing._FinalTypingBase, _root=True):
-        __slots__ = ('__type__',)
-
-        def __init__(self, tp=None, **kwds):
-            self.__type__ = tp
-
-        def __getitem__(self, item):
-            cls = type(self)
-            if self.__type__ is None:
-                return cls(typing._type_check(item,
-                           '{} accepts only single type.'.format(cls.__name__[1:])),
-                           _root=True)
-            raise TypeError('{} cannot be further subscripted'
-                            .format(cls.__name__[1:]))
-
-        def _eval_type(self, globalns, localns):
-            new_tp = typing._eval_type(self.__type__, globalns, localns)
-            if new_tp == self.__type__:
-                return self
-            return type(self)(new_tp, _root=True)
-
-        def __repr__(self):
-            r = super().__repr__()
-            if self.__type__ is not None:
-                r += '[{}]'.format(typing._type_repr(self.__type__))
-            return r
-
-        def __hash__(self):
-            return hash((type(self).__name__, self.__type__))
-
-        def __eq__(self, other):
-            if not isinstance(other, type(self)):
-                return NotImplemented
-            if self.__type__ is not None:
-                return self.__type__ == other.__type__
-            return self is other
-
-    class _Required(_MaybeRequired, _root=True):
-        """A special typing construct to mark a key of a total=False TypedDict
-        as required. For example:
-
-            class Movie(TypedDict, total=False):
-                title: Required[str]
-                year: int
-
-            m = Movie(
-                title='The Matrix',  # typechecker error if key is omitted
-                year=1999,
-            )
-
-        There is no runtime checking that a required key is actually provided
-        when instantiating a related TypedDict.
-        """
-
-    class _NotRequired(_MaybeRequired, _root=True):
-        """A special typing construct to mark a key of a TypedDict as
-        potentially missing. For example:
-
-            class Movie(TypedDict):
-                title: str
-                year: NotRequired[int]
-
-            m = Movie(
-                title='The Matrix',  # typechecker error if key is omitted
-                year=1999,
-            )
-        """
-
-    Required = _Required(_root=True)
-    NotRequired = _NotRequired(_root=True)

spaces/BreadBytes1/SB-Dashboard/old_app.py

@@ -1,327 +0,0 @@
-# ---
-# jupyter:
-#   jupytext:
-#     text_representation:
-#       extension: .py
-#       format_name: light
-#       format_version: '1.5'
-#       jupytext_version: 1.14.2
-#   kernelspec:
-#     display_name: Python [conda env:bbytes] *
-#     language: python
-#     name: conda-env-bbytes-py
-# ---
-
-# +
-import csv 
-import pandas as pd
-from datetime import datetime, timedelta
-import numpy as np
-import datetime as dt
-import matplotlib.pyplot as plt
-from pathlib import Path
-
-import streamlit as st
-import plotly.express as px
-import altair as alt
-import dateutil.parser
-import copy
-
-
-# +
-@st.experimental_memo
-def get_hist_info(df_coin, principal_balance,plheader):
-    numtrades = int(len(df_coin))
-    numwin = int(sum(df_coin[plheader] > 0))
-    numloss = int(sum(df_coin[plheader] < 0))
-    winrate = int(np.round(100*numwin/numtrades,2))
-    
-    grosswin = sum(df_coin[df_coin[plheader] > 0][plheader])
-    grossloss = sum(df_coin[df_coin[plheader] < 0][plheader])
-    if grossloss !=0:
-        pfactor = -1*np.round(grosswin/grossloss,2)
-    else: 
-        pfactor = np.nan
-    return numtrades, numwin, numloss, winrate, pfactor
-@st.experimental_memo
-def get_rolling_stats(df, lev, otimeheader, days):
-    max_roll = (df[otimeheader].max() - df[otimeheader].min()).days
-    
-    if max_roll >= days:
-        rollend = df[otimeheader].max()-timedelta(days=days)
-        rolling_df = df[df[otimeheader] >= rollend]
-
-        if len(rolling_df) > 0:
-            rolling_perc = rolling_df['Return Per Trade'].dropna().cumprod().values[-1]-1
-        else: 
-            rolling_perc = np.nan
-    else:
-        rolling_perc = np.nan
-    return 100*rolling_perc
-
-@st.experimental_memo
-def filt_df(df, cheader, symbol_selections):
-    """
-        Inputs: df (pd.DataFrame), cheader (str) and symbol_selections (list[str]).
-        
-        Returns a filtered pd.DataFrame containing only data that matches symbol_selections (list[str])
-        from df[cheader].
-    """
-    
-    df = df.copy()
-    df = df[df[cheader].isin(symbol_selections)]
-
-    return df
-
-@st.experimental_memo
-def my_style(v, props=''):
-    props = 'color:red' if v < 0 else 'color:green'
-    return props
-
-@st.cache(ttl=24*3600, allow_output_mutation=True)
-def load_data(filename, otimeheader,fmat):
-    df = pd.read_csv(open(filename,'r'), sep='\t') # so as not to mutate cached value 
-    df.columns = ['Trade','Signal','Entry Date','Buy Price', 'Sell Price','Exit Date', 'P/L per token', 'P/L %']
-    
-    df['Buy Price'] = df['Buy Price'].str.replace('$', '', regex=True)
-    df['Sell Price'] = df['Sell Price'].str.replace('$', '', regex=True)
-    df['Buy Price'] = df['Buy Price'].str.replace(',', '', regex=True)
-    df['Sell Price'] = df['Sell Price'].str.replace(',', '', regex=True)
-    df['P/L per token'] = df['P/L per token'].str.replace('$', '', regex=True)
-    df['P/L per token'] = df['P/L per token'].str.replace(',', '', regex=True)
-    df['P/L %'] = df['P/L %'].str.replace('%', '', regex=True)
-
-    df['Buy Price'] = pd.to_numeric(df['Buy Price'])
-    df['Sell Price'] = pd.to_numeric(df['Sell Price'])
-    df['P/L per token'] = pd.to_numeric(df['P/L per token'])
-    df['P/L %'] = pd.to_numeric(df['P/L %'])
-
-    dateheader = 'Date'
-    theader = 'Time'
-
-    df[dateheader] = [tradetimes.split(" ")[0] for tradetimes in df[otimeheader].values]
-    df[theader] = [tradetimes.split(" ")[1] for tradetimes in df[otimeheader].values]
-
-    df[otimeheader]= [dateutil.parser.parse(date+' '+time)
-                              for date,time in zip(df[dateheader],df[theader])]
-
-    df[otimeheader] = pd.to_datetime(df[otimeheader])
-    df['Exit Date'] = pd.to_datetime(df['Exit Date'])
-    df.sort_values(by=otimeheader, inplace=True)
-
-    df[dateheader] = [dateutil.parser.parse(date).date() for date in df[dateheader]]
-    df[theader] = [dateutil.parser.parse(time).time() for time in df[theader]]
-    df['Trade'] = [i+1 for i in range(len(df))] #reindex
-    
-    return df
-
-def runapp():
-    bot_selections = "Short Bread"
-    otimeheader = 'Entry Date'
-    plheader = 'Calculated Return %'
-    fmat = '%Y-%m-%d %H:%M:%S'
-    dollar_cap = 100000.00
-    fees = .075/100
-    st.header(f"{bot_selections} Performance Dashboard :bread: :moneybag:")
-    st.write("Welcome to the Trading Bot Dashboard by BreadBytes! You can use this dashboard to track " +
-                 "the performance of our trading bots.")
- #   st.sidebar.header("FAQ")
-
- #   with st.sidebar.subheader("FAQ"):
- #       st.write(Path("FAQ_README.md").read_text())
-    st.subheader("Choose your settings:")
-    no_errors = True
-    
-    data = load_data("SB-Trade-Log.csv",otimeheader,fmat)
-    df = data.copy(deep=True)
-    
-    grouped_df = df.groupby('Exit Date').agg({'Signal':'min','Entry Date': 'min','Exit Date': 'max','Buy Price': 'mean',
-                             'Sell Price' : 'max',
-                             'P/L per token': 'mean', 
-                             'P/L %':lambda x: np.round(x.sum()/4,2)})
-    grouped_df.index = range(1, len(grouped_df)+1)
-    grouped_df.rename(columns={'Buy Price':'Avg. Buy Price',
-                               'P/L per token':'Avg. P/L per token'}, inplace=True)
-    
-    dateheader = 'Date'
-    theader = 'Time'
-
-    with st.form("user input"):
-        if no_errors:
-            with st.container():
-                col1, col2 = st.columns(2)
-                with col1:
-                    try:
-                        startdate = st.date_input("Start Date", value=pd.to_datetime(df[otimeheader]).min())
-                    except:
-                        st.error("Please select your exchange or upload a supported trade log file.")
-                        no_errors = False 
-                with col2:
-                    try:
-                        enddate = st.date_input("End Date", value=datetime.today())
-                    except:
-                        st.error("Please select your exchange or upload a supported trade log file.")
-                        no_errors = False 
-                #st.sidebar.subheader("Customize your Dashboard")
-
-                if no_errors and (enddate < startdate): 
-                    st.error("End Date must be later than Start date. Please try again.")
-                    no_errors = False 
-            with st.container(): 
-                col1,col2 = st.columns(2) 
-                with col2:
-                    lev = st.number_input('Leverage', min_value=1, value=1, max_value= 5, step=1)
-                with col1:
-                    principal_balance = st.number_input('Starting Balance', min_value=0.00, value=1000.00, max_value= dollar_cap, step=.01)
-
-        #hack way to get button centered 
-        c = st.columns(9)
-        with c[4]: 
-            submitted = st.form_submit_button("Get Cookin'!") 
-            
-    signal_map = {'Long': 1, 'Short':-1} # 1 for long #-1 for short
-
-    df['Calculated Return %'] = (1-fees)*(df['Signal'].map(signal_map)*(df['Sell Price']-df['Buy Price'])/df['Buy Price'] - fees) #accounts for fees on open and close of trade 
-
-    
-    if submitted and principal_balance * lev > dollar_cap:
-        lev = np.floor(dollar_cap/principal_balance)
-        st.error(f"WARNING: (Starting Balance)*(Leverage) exceeds the ${dollar_cap} limit. Using maximum available leverage of {lev}")
-                
-    if submitted and no_errors:
-        df = df[(df[dateheader] >= startdate) & (df[dateheader] <= enddate)]
-
-        if len(df) == 0:
-                st.error("There are no available trades matching your selections. Please try again!")
-                no_errors = False
-        if no_errors:
-            df['Return Per Trade'] = 1+lev*df['Calculated Return %'].values
-
-            df['Compounded Return'] = df['Return Per Trade'].cumprod()
-            df['New Balance'] = [min(dollar_cap/lev, bal*principal_balance) for bal in df['Compounded Return']]
-            df['Balance used in Trade'] = np.concatenate([[principal_balance], df['New Balance'].values[:-1]])
-            df['Net P/L Per Trade'] = (df['Return Per Trade']-1)*df['Balance used in Trade']
-            df['Cumulative P/L'] = df['Net P/L Per Trade'].cumsum()
-
-            cum_pl = df.loc[df.dropna().index[-1],'Cumulative P/L'] + principal_balance
-
-            effective_return = 100*((cum_pl - principal_balance)/principal_balance)
-
-            st.header(f"{bot_selections} Results")
-            if len(bot_selections) > 1:
-                st.metric(
-                    "Total Account Balance",
-                    f"${cum_pl:.2f}",
-                    f"{100*(cum_pl-principal_balance)/(principal_balance):.2f} %",
-                )
-
-            st.line_chart(data=df.dropna(), x='Exit Date', y='Cumulative P/L', use_container_width=True)
-
-            df['Per Trade Return Rate'] = df['Return Per Trade']-1
-
-            totals = pd.DataFrame([], columns = ['# of Trades', 'Wins', 'Losses', 'Win Rate', 'Profit Factor'])
-            data = get_hist_info(df.dropna(), principal_balance,'Calculated Return %')
-            totals.loc[len(totals)] = list(i for i in data)
-
-            totals['Cum. P/L'] = cum_pl-principal_balance
-            totals['Cum. P/L (%)'] = 100*(cum_pl-principal_balance)/principal_balance
-            #results_df['Avg. P/L'] = (cum_pl-principal_balance)/results_df['# of Trades'].values[0]
-            #results_df['Avg. P/L (%)'] = 100*results_df['Avg. P/L'].values[0]/principal_balance
-
-            if df.empty:
-                st.error("Oops! None of the data provided matches your selection(s). Please try again.")
-            else:
-                #st.dataframe(totals.style.format({'# of Trades': '{:.0f}','Wins': '{:.0f}','Losses': '{:.0f}','Win Rate': '{:.2f}%','Profit Factor' : '{:.2f}', 'Avg. P/L (%)': '{:.2f}%', 'Cum. P/L (%)': '{:.2f}%', 'Cum. P/L': '{:.2f}', 'Avg. P/L': '{:.2f}'})
-            #.text_gradient(subset=['Win Rate'],cmap="RdYlGn", vmin = 0, vmax = 100)\
-            #.text_gradient(subset=['Profit Factor'],cmap="RdYlGn", vmin = 0, vmax = 2), use_container_width=True)
-                for row in totals.itertuples():
-                    col1, col2, col3, col4 = st.columns(4)
-                    c1, c2, c3, c4 = st.columns(4)
-                    with col1:
-                        st.metric(
-                            "Total Trades",
-                            f"{row._1:.0f}",
-                        )
-                    with c1:
-                        st.metric(
-                            "Profit Factor",
-                            f"{row._5:.2f}",
-                        )
-                    with col2: 
-                        st.metric(
-                            "Wins",
-                            f"{row.Wins:.0f}",
-                        )
-                    with c2:
-                        st.metric(
-                            "Cumulative P/L",
-                            f"${row._6:.2f}",
-                            f"{row._7:.2f} %",
-                        )
-                    with col3: 
-                        st.metric(
-                            "Losses",
-                            f"{row.Losses:.0f}",
-                        )
-                    with c3:
-                        st.metric(
-                        "Rolling 7 Days",
-                            "",#f"{(1+get_rolling_stats(df,otimeheader, 30))*principal_balance:.2f}",
-                            f"{get_rolling_stats(df,lev, otimeheader, 7):.2f}%",
-                        )
-                        st.metric(
-                        "Rolling 30 Days",
-                            "",#f"{(1+get_rolling_stats(df,otimeheader, 30))*principal_balance:.2f}",
-                            f"{get_rolling_stats(df,lev, otimeheader, 30):.2f}%",
-                        )
-
-                    with col4: 
-                        st.metric(
-                            "Win Rate",
-                            f"{row._4:.1f}%",
-                        )
-                    with c4:
-                        st.metric(
-                        "Rolling 90 Days",
-                            "",#f"{(1+get_rolling_stats(df,otimeheader, 30))*principal_balance:.2f}",
-                            f"{get_rolling_stats(df,lev, otimeheader, 90):.2f}%",
-                        )
-                        st.metric(
-                        "Rolling 180 Days",
-                            "",#f"{(1+get_rolling_stats(df,otimeheader, 30))*principal_balance:.2f}",
-                            f"{get_rolling_stats(df,lev, otimeheader, 180):.2f}%",
-                        )
-    if submitted: 
-        grouped_df = df.groupby('Exit Date').agg({'Signal':'min','Entry Date': 'min','Exit Date': 'max','Buy Price': 'mean',
-                                 'Sell Price' : 'max',
-                                 'Net P/L Per Trade': 'mean', 
-                                 'Calculated Return %' : lambda x: np.round(100*lev*x.sum(),3)})
-        grouped_df.index = range(1, len(grouped_df)+1)
-        grouped_df.rename(columns={'Buy Price':'Avg. Buy Price',
-                                   'Net P/L Per Trade':'Net P/L', 
-                                   'Calculated Return %':'P/L %'}, inplace=True)        
-    else: 
-        grouped_df = df.groupby('Exit Date').agg({'Signal':'min','Entry Date': 'min','Exit Date': 'max','Buy Price': 'mean',
-                                 'Sell Price' : 'max',
-                                 'P/L per token': 'mean', 
-                                 'Calculated Return %' : lambda x: np.round(100*x.sum(),3)})
-        grouped_df.index = range(1, len(grouped_df)+1)
-        grouped_df.rename(columns={'Buy Price':'Avg. Buy Price',
-                                   'P/L per token':'Net P/L', 
-                                   'Calculated Return %':'P/L %'}, inplace=True)  
-    st.subheader("Trade Logs")
-    grouped_df['Entry Date'] = pd.to_datetime(grouped_df['Entry Date'])
-    grouped_df['Exit Date'] = pd.to_datetime(grouped_df['Exit Date'])
-    st.dataframe(grouped_df.style.format({'Entry Date':'{:%m-%d-%Y %H:%M:%S}','Exit Date':'{:%m-%d-%Y %H:%M:%S}','Avg. Buy Price': '${:.2f}', 'Sell Price': '${:.2f}', 'Net P/L':'${:.3f}', 'P/L %':'{:.2f}%'})\
-    .applymap(my_style,subset=['Net P/L'])\
-    .applymap(my_style,subset=['P/L %']), use_container_width=True)
-    
-if __name__ == "__main__":
-    st.set_page_config(
-        "Trading Bot Dashboard",
-        layout="wide",
-    )
-    runapp()
-# -
-
-