sopro 1.0.1__py3-none-any.whl → 1.5.0__py3-none-any.whl

sopro/nn/text.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+from typing import Dict, Optional
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from sopro.config import SoproTTSConfig
+from sopro.nn.embeddings import SinusoidalPositionalEmbedding, TextEmbedding
+from sopro.tokenizer import TextTokenizer
+
+from .blocks import RMSNorm, SSMLiteBlock
+
+
+class TextEncoder(nn.Module):
+    def __init__(
+        self, cfg: SoproTTSConfig, d_model: int, n_layers: int, tokenizer: TextTokenizer
+    ):
+        super().__init__()
+        self.tok = tokenizer
+        self.embed = TextEmbedding(self.tok.vocab_size, d_model)
+        self.layers = nn.ModuleList(
+            [SSMLiteBlock(d_model, cfg.dropout, causal=False) for _ in range(n_layers)]
+        )
+        self.pos = SinusoidalPositionalEmbedding(d_model, max_len=cfg.max_text_len + 8)
+        self.norm = RMSNorm(d_model)
+
+    def forward(
+        self, text_ids: torch.Tensor, mask: torch.Tensor
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
+        x = self.embed(text_ids)
+        L = x.size(1)
+        pos = self.pos(torch.arange(L, device=x.device))
+        x = x + pos.unsqueeze(0)
+
+        x = x * mask.unsqueeze(-1).float()
+        for layer in self.layers:
+            x = layer(x)
+        x = self.norm(x)
+
+        mask_f = mask.float().unsqueeze(-1)
+        pooled = (x * mask_f).sum(dim=1) / (mask_f.sum(dim=1) + 1e-6)
+        return x, pooled
+
+
+class TextXAttnBlock(nn.Module):
+    def __init__(self, d_model: int, heads: int = 4, dropout: float = 0.0):
+        super().__init__()
+        assert d_model % heads == 0
+
+        self.d_model = int(d_model)
+        self.heads = int(heads)
+        self.head_dim = self.d_model // self.heads
+        self.dropout = float(dropout)
+
+        self.nq = RMSNorm(self.d_model)
+        self.nkv = RMSNorm(self.d_model)
+
+        self.q_proj = nn.Linear(self.d_model, self.d_model, bias=False)
+        self.k_proj = nn.Linear(self.d_model, self.d_model, bias=False)
+        self.v_proj = nn.Linear(self.d_model, self.d_model, bias=False)
+        self.out_proj = nn.Linear(self.d_model, self.d_model, bias=False)
+
+        self.gate = nn.Parameter(torch.tensor(0.0))
+
+    def _to_heads(self, t: torch.Tensor) -> torch.Tensor:
+        B, T, D = t.shape
+        return t.view(B, T, self.heads, self.head_dim).transpose(1, 2)
+
+    def _from_heads(self, t: torch.Tensor) -> torch.Tensor:
+        B, H, T, Hd = t.shape
+        return t.transpose(1, 2).contiguous().view(B, T, H * Hd)
+
+    def build_kv_cache(
+        self,
+        context: torch.Tensor,
+        key_padding_mask: Optional[torch.Tensor] = None,
+    ) -> Dict[str, torch.Tensor]:
+        kv = self.nkv(context)
+        k = self._to_heads(self.k_proj(kv))
+        v = self._to_heads(self.v_proj(kv))
+        return {"k": k, "v": v, "key_padding_mask": key_padding_mask}
+
+    def forward(
+        self,
+        x: torch.Tensor,
+        context: Optional[torch.Tensor] = None,
+        key_padding_mask: Optional[torch.Tensor] = None,
+        kv_cache: Optional[Dict[str, torch.Tensor]] = None,
+        use_cache: bool = False,
+    ):
+        q = self.nq(x)
+        q = self._to_heads(self.q_proj(q))
+
+        if kv_cache is None:
+            if context is None:
+                raise ValueError("context must be provided when kv_cache is None")
+            kv_cache = self.build_kv_cache(context, key_padding_mask=key_padding_mask)
+
+        k = kv_cache["k"]
+        v = kv_cache["v"]
+        kpm = kv_cache.get("key_padding_mask", None)
+
+        attn_mask = None
+        if kpm is not None:
+            kpm = kpm.to(torch.bool)
+
+            keep = ~kpm
+
+            bad = ~keep.any(dim=1)
+            if bad.any():
+                keep = keep.clone()
+                keep[bad, 0] = True
+
+            attn_mask = keep[:, None, None, :]
+
+        with torch.autocast(device_type=x.device.type, enabled=False):
+            a = F.scaled_dot_product_attention(
+                q.float(),
+                k.float(),
+                v.float(),
+                attn_mask=attn_mask,
+                dropout_p=self.dropout if self.training else 0.0,
+                is_causal=False,
+            )
+
+        a = torch.nan_to_num(a, nan=0.0, posinf=0.0, neginf=0.0).to(x.dtype)
+        a = self.out_proj(self._from_heads(a))
+
+        y = x + torch.tanh(self.gate) * a
+        return (y, kv_cache) if use_cache else y

sopro/sampling.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import List
+from typing import List, Tuple
 
 import torch
 
@@ -97,5 +97,5 @@ def rf_ar(ar_kernel: int, dilations: Tuple[int, ...]) -> int:
     return 1 + (ar_kernel - 1) * int(sum(dilations))
 
 
-def rf_nar(n_layers_nar: int, kernel_size: int = 7, dilation: int = 1) -> int:
-    return 1 + (kernel_size - 1) * int(n_layers_nar) * int(dilation)
+def rf_nar(kernel_size: int, dilations: Tuple[int, ...]) -> int:
+    return 1 + (kernel_size - 1) * int(sum(dilations))

sopro/streaming.py

@@ -1,20 +1,18 @@
 from __future__ import annotations
 
-import time
 from dataclasses import dataclass
-from typing import Iterator, List, Optional, Tuple
+from typing import Iterator, List, Optional
 
 import torch
 
 from .codec.mimi import MimiDecodeState, MimiStreamDecoder
-from .model import SoproTTS, SoproTTSModel
+from .model import PreparedReference, SoproTTS, SoproTTSModel
 
 
 @dataclass
 class StreamConfig:
     chunk_frames: int = 16
     nar_context_frames: Optional[int] = None
-    cond_chunk_size: int = 32
 
 
 class SoproTTSStreamer:
@@ -30,33 +28,30 @@ class SoproTTSStreamer:
         *,
         ref_audio_path: Optional[str] = None,
         ref_tokens_tq: Optional[torch.Tensor] = None,
+        ref: Optional[PreparedReference] = None,
         max_frames: int = 400,
         top_p: float = 0.9,
         temperature: float = 1.05,
         anti_loop: bool = True,
-        use_prefix: bool = True,
-        prefix_sec_fixed: Optional[float] = None,
         style_strength: Optional[float] = None,
         ref_seconds: Optional[float] = None,
         chunk_frames: Optional[int] = None,
         nar_context_frames: Optional[int] = None,
-        cond_chunk_size: Optional[int] = None,
-        use_stop_head: Optional[bool] = None,
-        stop_patience: Optional[int] = None,
-        stop_threshold: Optional[float] = None,
         min_gen_frames: Optional[int] = None,
     ) -> Iterator[torch.Tensor]:
         model: SoproTTSModel = self.tts.model
         device = self.tts.device
 
         text_ids = self.tts.encode_text(text)
-        ref = self.tts.encode_reference(
-            ref_audio_path=ref_audio_path,
-            ref_tokens_tq=ref_tokens_tq,
-            ref_seconds=ref_seconds,
-        )
 
-        prep = model.prepare_conditioning_lazy(
+        if ref is None:
+            ref = self.tts.prepare_reference(
+                ref_audio_path=ref_audio_path,
+                ref_tokens_tq=ref_tokens_tq,
+                ref_seconds=ref_seconds,
+            )
+
+        prep = model.prepare_conditioning(
             text_ids,
             ref,
             max_frames=max_frames,
@@ -69,9 +64,6 @@ class SoproTTSStreamer:
         )
 
         cf = int(chunk_frames if chunk_frames is not None else self.cfg.chunk_frames)
-        cond_cs = int(
-            cond_chunk_size if cond_chunk_size is not None else self.cfg.cond_chunk_size
-        )
 
         nar_ctx = (
             nar_context_frames
@@ -83,14 +75,11 @@ class SoproTTSStreamer:
         nar_ctx = int(nar_ctx)
 
         hist_A: List[int] = []
-
         frames_emitted = 0
-
         mimi_state = MimiDecodeState()
 
         def refine_and_emit(end: int) -> Optional[torch.Tensor]:
             nonlocal frames_emitted, mimi_state
-
             new_start = frames_emitted
             if end <= new_start:
                 return None
@@ -98,7 +87,7 @@ class SoproTTSStreamer:
             win_start = max(0, new_start - nar_ctx)
             win_end = end
 
-            cond_win = prep["cond_all"][:, win_start:win_end, :]
+            cond_win = prep["cond_ar"][:, win_start:win_end, :]
             tokens_A_win = torch.as_tensor(
                 hist_A[win_start:win_end], device=device, dtype=torch.long
             ).unsqueeze(0)
@@ -114,30 +103,25 @@ class SoproTTSStreamer:
             frames_emitted = end
             return wav_chunk if wav_chunk.numel() > 0 else None
 
-        for _t, rvq1_id, _p_stop in model.ar_stream(
+        for _t, tok, is_eos in model.ar_stream(
             prep,
             max_frames=max_frames,
             top_p=top_p,
             temperature=temperature,
             anti_loop=anti_loop,
-            use_prefix=use_prefix,
-            prefix_sec_fixed=prefix_sec_fixed,
-            cond_chunk_size=cond_cs,
-            use_stop_head=use_stop_head,
-            stop_patience=stop_patience,
-            stop_threshold=stop_threshold,
             min_gen_frames=min_gen_frames,
         ):
-            hist_A.append(int(rvq1_id))
-            T = len(hist_A)
+            if is_eos:
+                break
 
-            is_boundary = (T % cf) == 0
-            if not is_boundary and T < max_frames:
-                continue
+            hist_A.append(int(tok))
+            T = len(hist_A)
 
-            wav = refine_and_emit(T)
-            if wav is not None:
-                yield wav
+            boundary = (T % cf) == 0
+            if boundary:
+                wav = refine_and_emit(T)
+                if wav is not None:
+                    yield wav
 
         T_final = len(hist_A)
         if frames_emitted < T_final:
@@ -146,12 +130,14 @@ class SoproTTSStreamer:
                 yield wav
 
 
+@torch.inference_mode()
 def stream(
     tts: SoproTTS,
     text: str,
     *,
     ref_audio_path: Optional[str] = None,
     ref_tokens_tq: Optional[torch.Tensor] = None,
+    ref: Optional[PreparedReference] = None,
     chunk_frames: int = 6,
     **kwargs,
 ) -> Iterator[torch.Tensor]:
@@ -160,6 +146,7 @@ def stream(
         text,
         ref_audio_path=ref_audio_path,
         ref_tokens_tq=ref_tokens_tq,
+        ref=ref,
         chunk_frames=chunk_frames,
         **kwargs,
     )

{sopro-1.0.1.dist-info → sopro-1.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sopro
-Version: 1.0.1
+Version: 1.5.0
 Summary: A lightweight text-to-speech model with zero-shot voice cloning.
 Author-email: Samuel Vitorino <samvitorino@gmail.com>
 License: Apache 2.0
@@ -27,14 +27,18 @@ https://github.com/user-attachments/assets/40254391-248f-45ff-b9a4-107d64fbb95f
 
 [![Alt Text](https://img.shields.io/badge/HuggingFace-Model-orange?logo=huggingface)](https://huggingface.co/samuel-vitorino/sopro)
 
+### 📰 News
+
+**2026.02.04 – SoproTTS v1.5 is out: more stable, faster, and smaller. Trained for just $100, it reaches 250 ms TTFA streaming and 0.05 RTF (~20× realtime) on CPU.**
+
 Sopro (from the Portuguese word for “breath/blow”) is a lightweight English text-to-speech model I trained as a side project. Sopro is composed of dilated convs (à la WaveNet) and lightweight cross-attention layers, instead of the common Transformer architecture. Even though Sopro is not SOTA across most voices and situations, I still think it’s a cool project made with a very low budget (trained on a single L40S GPU), and it can be improved with better data.
 
 Some of the main features are:
 
-- **169M parameters**
+- **147M parameters**
 - **Streaming**
 - **Zero-shot voice cloning**
-- **0.25 RTF on CPU** (measured on an M3 base model), meaning it generates 30 seconds of audio in 7.5 seconds
+- **0.05 RTF on CPU** (measured on an M3 base model), meaning it generates 32 seconds of audio in 1.77 seconds
 - **3-12 seconds of reference audio** for voice cloning
 
 ---
@@ -53,7 +57,7 @@ conda activate soprotts
 ### From PyPI
 
 ```bash
-pip install sopro
+pip install -U sopro
 ```
 
 ### From the repo
@@ -79,9 +83,7 @@ soprotts \
 
 You have the expected `temperature` and `top_p` parameters, alongside:
 
-- `--style_strength` (controls the FiLM strength; increasing it can improve or reduce voice similarity; default `1.0`)
-- `--no_stop_head` to disable early stopping
-- `--stop_threshold` and `--stop_patience` (number of consecutive frames that must be classified as final before **stopping**). For short sentences, the stop head may fail to trigger, in which case you can lower these values. Likewise, if the model stops before producing the full text, adjusting these parameters up can help.
+- `--style_strength` (controls the FiLM strength; increasing it can improve or reduce voice similarity; default `1.2`)
 
 ### Python
 
@@ -119,6 +121,27 @@ wav = torch.cat(chunks, dim=-1)
 tts.save_wav("out_stream.wav", wav)
 ```
 
+You can also precalculate the reference to reduce TTFA:
+
+```python
+import torch
+from sopro import SoproTTS
+
+tts = SoproTTS.from_pretrained("samuel-vitorino/sopro", device="cpu")
+
+ref = tts.prepare_reference(ref_audio_path="ref.mp3")
+
+chunks = []
+for chunk in tts.stream(
+    "Hello! This is a streaming Sopro TTS example.",
+    ref=ref,
+):
+    chunks.append(chunk.cpu())
+
+wav = torch.cat(chunks, dim=-1)
+tts.save_wav("out_stream.wav", wav)
+```
+
 ---
 
 ## Interactive streaming demo

sopro-1.5.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+sopro/__init__.py,sha256=OpqL73InBJ22Ja8QXeGLr09igFvKn-OXPj_smU9t98g,110
+sopro/audio.py,sha256=xlp6aYzzGlOMcNZ-p9lDeeU0TUkSHMcvmLantwg_4-0,4162
+sopro/cli.py,sha256=HKZ8CD7TtjdOPy7iOgilv1aplvWUb4jaTCEvBHE0Cmo,5108
+sopro/config.py,sha256=CBTmHbsJs7hpf0mfyea5BWu-_PImL3WdSmUrzKvNC64,1052
+sopro/constants.py,sha256=wSjFKeFIcLCxyVUVb3njxMK666IuxjlNzVT4_jfPovQ,97
+sopro/hub.py,sha256=Axc19LlO3Vlo0sigJNDR42U6ByMtDOYvhRl_HicMMqU,1386
+sopro/model.py,sha256=hhzbCP-PLe1NaZPC3lYcjWxHoqn7ignjfnYRuAOQl3s,18314
+sopro/sampling.py,sha256=MXdP_oYcpW9Hf9vqaKuygOUz9VycZ7nOhIOXXfMobks,2930
+sopro/streaming.py,sha256=iq_ukrktT6vPd1bIRhBg6yZuiXFahn2ZXJ6t1YM4lb0,4476
+sopro/tokenizer.py,sha256=ucb86Jr-EaAyD9OHDoCmwB9Nh9AFIZK_TlZmMkv46KQ,1325
+sopro/codec/__init__.py,sha256=6D6Q0M-SUZZnq79OT1nATenEc8zIZDrhZBpm7zdPEE4,129
+sopro/codec/mimi.py,sha256=RNKnXfhWXUqHiU27C90wj18Rb3R2IZHpm5_cS_XAs9Y,5798
+sopro/nn/__init__.py,sha256=48i83Bq5R2Z1q21TrxlZtyBgOBWnD2DmyU7qX-JHo9c,680
+sopro/nn/blocks.py,sha256=QpRzwvzf4ea0JvHPlonfms2lRp93VRZI3Q9iE-ltldU,5814
+sopro/nn/embeddings.py,sha256=UBIJiKFca3kGUBkCw3d2Iwt_zd0NgsBfZq4912KLTug,3844
+sopro/nn/generator.py,sha256=Xnb4b9xeOYHlYWzXFjBPzxCKPdWCf0ZjWs6IJ7TkKy4,4354
+sopro/nn/nar.py,sha256=Swz8TrnLecV-ODB1tsODJyFTqd3VbucGaAgjxrKb82I,3682
+sopro/nn/ref.py,sha256=3QoxtY4MHAVNwofoBAty_-iuQSm9Hol03bOknsTiWl8,5385
+sopro/nn/speaker.py,sha256=sVpVqJoIUo8Brhuk3VDSRyr7brxjpudr5aF9201kmvw,2815
+sopro/nn/text.py,sha256=QdSXOOLOjDaRdiKoPFG7UD6t9MpqOYfLuihyrnqwgh0,4352
+sopro-1.5.0.dist-info/licenses/LICENSE.txt,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+sopro-1.5.0.dist-info/METADATA,sha256=LHe2O4Du_4cHRsmv9G0lWg4EfKMBFJgkr3eMkjTTh7c,6732
+sopro-1.5.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+sopro-1.5.0.dist-info/entry_points.txt,sha256=OWcKgC5Syk8rzOhNzTZ3QR5GJEG88UfiShkovrwb2cI,44
+sopro-1.5.0.dist-info/top_level.txt,sha256=Tik26_lEwzSKDuwQdqwoqA_O0b7CDATzousa0Q17PBo,6
+sopro-1.5.0.dist-info/RECORD,,

{sopro-1.0.1.dist-info → sopro-1.5.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

sopro/nn/xattn.py

@@ -1,98 +0,0 @@
-from __future__ import annotations
-
-from typing import Optional
-
-import torch
-import torch.nn as nn
-
-from .blocks import RMSNorm
-
-
-def rms(x: torch.Tensor, eps: float = 1e-6) -> torch.Tensor:
-    return torch.sqrt(x.pow(2).mean(dim=-1, keepdim=True) + eps)
-
-
-class RefXAttnBlock(nn.Module):
-    def __init__(self, d_model: int, heads: int = 2, dropout: float = 0.0):
-        super().__init__()
-        self.nq = RMSNorm(d_model)
-        self.nkv = RMSNorm(d_model)
-        self.attn = nn.MultiheadAttention(
-            d_model, heads, batch_first=True, dropout=dropout
-        )
-        self.gate = nn.Parameter(torch.tensor(0.5))
-        self.gmax = 0.35
-
-    def forward(
-        self,
-        x: torch.Tensor,
-        ref: torch.Tensor,
-        key_padding_mask: Optional[torch.Tensor] = None,
-    ) -> torch.Tensor:
-        q = self.nq(x)
-        kv = self.nkv(ref.float())
-
-        with torch.autocast(device_type=q.device.type, enabled=False):
-            a, _ = self.attn(
-                q.float(), kv, kv, key_padding_mask=key_padding_mask, need_weights=False
-            )
-
-        a = torch.nan_to_num(a, nan=0.0, posinf=0.0, neginf=0.0)
-
-        rms_x = rms(x.float())
-        rms_a = rms(a)
-        scale = rms_x / rms_a
-        a = (a * scale).to(x.dtype)
-
-        gate_eff = (self.gmax * torch.tanh(self.gate)).to(x.dtype)
-        return x + gate_eff * a
-
-
-class RefXAttn(nn.Module):
-    def __init__(
-        self, d_model: int, heads: int = 2, layers: int = 3, dropout: float = 0.0
-    ):
-        super().__init__()
-        self.blocks = nn.ModuleList(
-            [RefXAttnBlock(d_model, heads, dropout) for _ in range(layers)]
-        )
-
-    def forward(
-        self,
-        x: torch.Tensor,
-        ref: torch.Tensor,
-        key_padding_mask: Optional[torch.Tensor] = None,
-    ) -> torch.Tensor:
-        for blk in self.blocks:
-            x = blk(x, ref, key_padding_mask)
-        return x
-
-
-class TextXAttnBlock(nn.Module):
-    def __init__(self, d_model: int, heads: int = 4, dropout: float = 0.0):
-        super().__init__()
-        self.nq = RMSNorm(d_model)
-        self.nkv = RMSNorm(d_model)
-        self.attn = nn.MultiheadAttention(
-            d_model, num_heads=heads, dropout=dropout, batch_first=True
-        )
-        self.gate = nn.Parameter(torch.tensor(0.0))
-
-    def forward(
-        self,
-        x: torch.Tensor,
-        context: torch.Tensor,
-        key_padding_mask: Optional[torch.Tensor] = None,
-    ) -> torch.Tensor:
-        q = self.nq(x)
-        kv = self.nkv(context)
-        with torch.autocast(device_type=q.device.type, enabled=False):
-            out, _ = self.attn(
-                q.float(),
-                kv.float(),
-                kv.float(),
-                key_padding_mask=key_padding_mask,
-                need_weights=False,
-            )
-        out = torch.nan_to_num(out, nan=0.0, posinf=0.0, neginf=0.0).to(x.dtype)
-        return x + torch.tanh(self.gate) * out

sopro-1.0.1.dist-info/RECORD

@@ -1,23 +0,0 @@
-sopro/__init__.py,sha256=NFZuESqdCL7bGXuTB8c61XxUJqhkHPUOSTqzH4pyUfU,110
-sopro/audio.py,sha256=xlp6aYzzGlOMcNZ-p9lDeeU0TUkSHMcvmLantwg_4-0,4162
-sopro/cli.py,sha256=YKfGalyhbRuvjVrGJuo1NlIC7h8CszlMxuTwhYgUSwQ,5751
-sopro/config.py,sha256=OBD-k2z5GUdjFS545MyBXx-dAGhwnhRG11LW-zQt1-g,1063
-sopro/constants.py,sha256=wSjFKeFIcLCxyVUVb3njxMK666IuxjlNzVT4_jfPovQ,97
-sopro/hub.py,sha256=xsHfeO8X7v__FELvaQxWHYG8P39ygrgbluPs5GQjoCM,1391
-sopro/model.py,sha256=YXwcVGN3v5T0kvKttmo9WNPpewF-b5aOZoTMVypkzO8,28624
-sopro/sampling.py,sha256=Q5rbuef_BIuy12cv5J7v6k9ob3zQ0OFJIlMHssOkiuU,2951
-sopro/streaming.py,sha256=O5Kkl4cUBjzgjTrEwQK2ka5h6sgcYaEZmIp66-obcPM,4975
-sopro/tokenizer.py,sha256=ucb86Jr-EaAyD9OHDoCmwB9Nh9AFIZK_TlZmMkv46KQ,1325
-sopro/codec/__init__.py,sha256=6D6Q0M-SUZZnq79OT1nATenEc8zIZDrhZBpm7zdPEE4,129
-sopro/codec/mimi.py,sha256=RNKnXfhWXUqHiU27C90wj18Rb3R2IZHpm5_cS_XAs9Y,5798
-sopro/nn/__init__.py,sha256=JewW6GvQPMBsCDkmnm9u5G3tvaAzClUVMIgcVH4N7aw,561
-sopro/nn/blocks.py,sha256=zDEVUH2LXapXuQ4DyhplNh1I0iJYrNUL20IxHoz8ucs,3221
-sopro/nn/embeddings.py,sha256=7YfYKj1v1oafTV4-iucJG4fmeT43fP_rQiJ6ACRKPNI,3185
-sopro/nn/speaker.py,sha256=L2bs-bPlyxoWZyMTctBBuMTaEWm6FP7K1udrXehnTGM,2964
-sopro/nn/xattn.py,sha256=OeRo1HbRZs0AkQ6AV6Q8cqYZP9K4vI-IwT3uVn9jOqg,2939
-sopro-1.0.1.dist-info/licenses/LICENSE.txt,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-sopro-1.0.1.dist-info/METADATA,sha256=tlq9mTTsNEFgMyCtle7om5hqKRm5LwrVCFLo4olQ3_s,6470
-sopro-1.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sopro-1.0.1.dist-info/entry_points.txt,sha256=OWcKgC5Syk8rzOhNzTZ3QR5GJEG88UfiShkovrwb2cI,44
-sopro-1.0.1.dist-info/top_level.txt,sha256=Tik26_lEwzSKDuwQdqwoqA_O0b7CDATzousa0Q17PBo,6
-sopro-1.0.1.dist-info/RECORD,,