RvcPyInfer 0.1.0__py3-none-any.whl

RvcPyInfer/resource/template/export_onnx.py

@@ -0,0 +1,249 @@
+# ----------------------------------------------------------------
+# 这只是一个用于自动生成导出脚本的模板而已，它不是正常代码！
+# ----------------------------------------------------------------
+
+# -- Template --
+ModelPath = None
+ExportedPath = None
+ParsePrefix = None
+Root = None
+
+ModelPath = '/./..{code.InsertionPoint.0}.././'
+ExportedPath = '/./..{code.InsertionPoint.1}.././'
+ParsePrefix = '/./..{code.InsertionPoint.2}.././'
+Root = '/./..{code.InsertionPoint.3}.././'
+
+assert ModelPath is not None, "ModelPath 不能为 None"
+assert ExportedPath is not None, "ExportedPath 不能为 None"
+assert ParsePrefix is not None, "ParsePrefix 不能为 None"
+
+# 以上是需要动态生成的
+device = "cpu" # 一般 cpu 就可以
+
+import sys
+if Root is not None:
+    sys.path.insert(0, Root)
+
+def set_hook() -> None:
+    import infer.lib.infer_pack.attentions as attentions # pyright: ignore[reportMissingImports]
+
+    def attention_fix(
+        self,
+        query: attentions.torch.Tensor,
+        key: attentions.torch.Tensor,
+        value: attentions.torch.Tensor,
+        mask: attentions.Optional[attentions.torch.Tensor] = None,
+    ):
+        # reshape [b, d, t] -> [b, n_h, t, d_k]
+        b, d, t_s = key.size()
+        t_t = 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 = attentions.torch.matmul(query / attentions.math.sqrt(self.k_channels), key.transpose(-2, -1))
+        if self.window_size is not None:
+            # source: assert (
+            # source:     t_s == t_t
+            # source: ), "Relative attention is only available for self-attention."
+            if not attentions.torch.jit.is_tracing(): # 大概率是没有问题的，大不了咱直接抛维度错误
+                attentions.torch._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 / attentions.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:
+            # source: assert t_s == t_t, "Proximal bias is only available for self-attention."
+            if not attentions.torch.jit.is_tracing():
+                attentions.torch._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:
+                # source: assert (
+                # source:    t_s == t_t
+                # source: ), "Local attention is only available for self-attention."
+                if not attentions.torch.jit.is_tracing():
+                    attentions.torch._assert(
+                        t_s == t_t,
+                        "Local attention is only available for self-attention."
+                    )
+                block_mask = (
+                    attentions.torch.ones_like(scores)
+                    .triu(-self.block_length)
+                    .tril(self.block_length)
+                )
+                scores = scores.masked_fill(block_mask == 0, -1e4)
+        p_attn = attentions.F.softmax(scores, dim=-1)  # [b, n_h, t_t, t_s]
+        p_attn = self.drop(p_attn)
+        output = attentions.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
+    attentions.MultiHeadAttention.attention = attention_fix
+
+    def _get_relative_embeddings_fix(self, relative_embeddings, length: int):
+        max_relative_position = 2 * self.window_size + 1 # 不知道有什么用，反正不敢删
+        # Pad first before slice to avoid using cond ops.
+        pad_length: int = attentions.torch.clamp(length - (self.window_size + 1), min=0)
+        slice_start_position = attentions.torch.clamp((self.window_size + 1) - length, min=0)
+        slice_end_position = slice_start_position + 2 * length - 1
+        # source: if pad_length > 0:
+        if True: # pad 0 那不就是没有 pad嘛，搞个分支干什么，我还得改
+            padded_relative_embeddings = attentions.F.pad(
+                relative_embeddings,
+                # commons.convert_pad_shape([[0, 0], [pad_length, pad_length], [0, 0]]),
+                [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
+    attentions.MultiHeadAttention._get_relative_embeddings = _get_relative_embeddings_fix
+
+    def _relative_position_to_absolute_position_fix(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 = attentions.F.pad(
+            x,
+            #   commons.convert_pad_shape([[0, 0], [0, 0], [0, 0], [0, 1]])
+            [0, 1, 0, 0, 0, 0, 0, 0],
+        )
+
+        # 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 = attentions.F.pad(
+            x_flat,
+            # commons.convert_pad_shape([[0, 0], [0, 0], [0, int(length) - 1]])
+            # source: [0, int(length) - 1, 0, 0, 0, 0],
+            [0, length - 1, 0, 0, 0, 0],
+        )
+
+        # 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
+    attentions.MultiHeadAttention._relative_position_to_absolute_position = _relative_position_to_absolute_position_fix
+
+    def _absolute_position_to_relative_position_fix(self, x):
+        """
+        x: [b, h, l, l]
+        ret: [b, h, l, 2*l-1]
+        """
+        batch, heads, length, _ = x.size()
+        # padd along column
+        x = attentions.F.pad(
+            x,
+            # commons.convert_pad_shape([[0, 0], [0, 0], [0, 0], [0, int(length) - 1]])
+            # source: [0, int(length) - 1, 0, 0, 0, 0, 0, 0],
+            [0, length - 1, 0, 0, 0, 0, 0, 0],
+        )
+        # source: x_flat = x.view([batch, heads, int(length**2) + int(length * (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 = attentions.F.pad(
+            x_flat,
+            #    commons.convert_pad_shape([[0, 0], [0, 0], [int(length), 0]])
+            [length, 0, 0, 0, 0, 0],
+        )
+        x_final = x_flat.view([batch, heads, length, 2 * length])[:, :, :, 1:]
+        return x_final
+    
+    attentions.MultiHeadAttention._absolute_position_to_relative_position = _absolute_position_to_relative_position_fix
+
+def main():
+    import torch # pyright: ignore[reportMissingImports]
+
+    cpt = torch.load(ModelPath, map_location="cpu")
+    cpt["config"][-3] = cpt["weight"]["emb_g.weight"].shape[0]
+    print(f'{ParsePrefix}/./..{{"sr":{cpt["config"][-1]}}}.././')
+    version = cpt["version"]
+    hidden_channels = 256 if version == "v1" else 768
+
+    test_phone = torch.rand(1, 200, hidden_channels)  # hidden unit
+    test_phone_lengths = torch.tensor([200]).long()  # hidden unit 长度（貌似没啥用）
+    test_pitch = torch.randint(size=(1, 200), low=5, high=255)  # 基频（单位赫兹）
+    test_pitchf = torch.rand(1, 200)  # nsf基频
+    test_ds = torch.LongTensor([0])  # 说话人ID
+    test_rnd = torch.rand(1, 192, 200)  # 噪声（加入随机因子）
+
+    set_hook() # 强制误差调整大法！强制替换不支持追踪的实现
+
+    from infer.lib.infer_pack.models_onnx import SynthesizerTrnMsNSFsidM # pyright: ignore[reportMissingImports]
+
+    net_g = SynthesizerTrnMsNSFsidM(
+        *cpt["config"], version=version, is_half=False
+    )  # fp32导出（C++要支持fp16必须手动将内存重新排列所以暂时不用fp16）
+    net_g.load_state_dict(cpt["weight"], strict=False)
+    input_names = ["phone", "phone_lengths", "pitch", "pitchf", "ds", "rnd"]
+    output_names = [
+        "audio",
+    ]
+    # net_g.construct_spkmixmap(n_speaker) 多角色混合轨道导出
+
+    try: 
+        torch.onnx.export(
+            net_g,
+            (
+                test_phone.to(device),
+                test_phone_lengths.to(device),
+                test_pitch.to(device),
+                test_pitchf.to(device),
+                test_ds.to(device),
+                test_rnd.to(device),
+            ),
+            ExportedPath,
+            dynamic_axes={ # 记得批处理维度！
+                "phone": {0: "batch_size", 1: "frame_sequence"}, 
+                "pitch": {0: "batch_size", 1: "frame_sequence"},
+                "pitchf": {0: "batch_size", 1: "frame_sequence"},
+                "rnd": {0: "batch_size", 2: "frame_sequence"},
+                "audio": {0: "batch_size", 2: "sampling_sequence"}
+            },
+            do_constant_folding=False,
+            opset_version=16, # 其实我觉得可以更高
+            verbose=False,
+            input_names=input_names,
+            output_names=output_names,
+        )
+    except Exception as e:
+        old_line = "\n"
+        new_line = "\\n" # python 的奇妙切词
+        old_str = "\""
+        new_str = "\\\""
+        print(f'{ParsePrefix}/./..{{"status":"fail","msg":"{str(e).replace(old_line, new_line).replace(old_str, new_str)}"}}.././')
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)
+
+    print(f'{ParsePrefix}/./..{{"status":"success"}}.././')
+    sys.exit(0)
+
+if __name__ == "__main__":
+    main()

RvcPyInfer/type_alist.py

@@ -0,0 +1,13 @@
+from pathlib import Path
+from typing import BinaryIO, Literal
+
+import numpy as np
+from numpy.typing import NDArray
+
+type PathLike = str | Path
+type FileLike = PathLike | BinaryIO
+type Audio = tuple[NDArray[np.float32], int]
+type AudioLike = FileLike | Audio
+
+F0ExtractAlgorithmList = ["dio", "harvest"]
+type F0ExtractAlgorithm = Literal["dio", "harvest"]

RvcPyInfer/warn/InferEnvWarn.py

@@ -0,0 +1,5 @@
+from .InferWarn import InferWarn
+
+
+class InferEnvWarn(InferWarn):
+    pass

RvcPyInfer/warn/InferModelWarn.py

@@ -0,0 +1,5 @@
+from .InferWarn import InferWarn
+
+
+class InferModelWarn(InferWarn):
+    pass

RvcPyInfer/warn/InferWarn.py

@@ -0,0 +1,2 @@
+class InferWarn(Warning):
+    pass

rvcpyinfer-0.1.0.dist-info/METADATA

@@ -0,0 +1,158 @@
+Metadata-Version: 2.4
+Name: RvcPyInfer
+Version: 0.1.0
+Summary: Rvc 的 ONNX 模型导出格式推理实现
+Project-URL: Homepage, https://github.com/TwoCreepers/RvcPyInfer
+Project-URL: Repository, https://github.com/TwoCreepers/RvcPyInfer
+Author: 观赏鱼
+License-Expression: MIT
+Requires-Python: >=3.13
+Requires-Dist: numpy>=2.3
+Requires-Dist: pyworld>=0.3.5
+Requires-Dist: samplerate>=0.2.4
+Requires-Dist: soundfile>=0.14.0
+Provides-Extra: cpu
+Requires-Dist: onnxruntime>=1.27.0; extra == 'cpu'
+Provides-Extra: cuda
+Requires-Dist: onnxruntime-gpu>=1.27.0; extra == 'cuda'
+Provides-Extra: dev
+Requires-Dist: pyright>=1.1.411; extra == 'dev'
+Requires-Dist: ruff>=0.15.21; extra == 'dev'
+Provides-Extra: dml
+Requires-Dist: onnxruntime-directml>=1.24.4; extra == 'dml'
+Provides-Extra: index
+Requires-Dist: faiss-cpu>=1.14.3; extra == 'index'
+Provides-Extra: openvino
+Requires-Dist: openvino>=2026.2.1; extra == 'openvino'
+Description-Content-Type: text/markdown
+
+# [RvcPyInfer](https://github.com/TwoCreepers/RvcPyInfer)
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://mit-license.org/)  
+[![Python 3.13+](https://img.shields.io/badge/python-3.13+-blue.svg)](https://www.python.org/downloads/)  
+![ONNX](https://img.shields.io/badge/ONNX-supported-blue)
+
+[RVC](https://github.com/RVC-Project/Retrieval-based-Voice-Conversion-WebUI) 的 ONNX 模型导出格式推理实现。  
+
+- 支持原 RVC 项目的 ONNX 模型推理。  
+- 跨平台支持多种推理引擎（CPU, CUDA, DirectML, OpenVINO）。  
+- 提供 Windows 下一键导出 ONNX 模型的 CLI 工具。  
+- 兼容原项目的 `.index` 特征索引文件。  
+
+## Python 版本需求
+本项目要求 Python 版本 `>= 3.13`。由于项目代码中使用了 `Python 3.12+` 引入的 `TypeParam` 等现代语法特性，因此无法向下兼容更低版本的 Python。  
+~~并且推理真的很难测试欸。~~
+
+## 安装
+本库尚未上传至 [PyPI](https://pypi.org) ，我们还在筹备这方面的工作。  
+你可以直接 clone 该仓库然后使用如下命令构建 `.whl` 文件。
+```shell
+# 克隆该仓库
+git clone https://github.com/TwoCreepers/RvcPyInfer.git
+# 进入该仓库目录
+cd RvcPyInfer
+# 使用 uv 构建
+uv build
+# 安装生成的 wheel 包 (以实际文件名为准)
+pip install ./dist/rvcpyinfer-0.1.0-py3-none-any.whl
+```
+不出意外的话，现在你需要的轮子文件应该出现在 `dist/` 下面了。  
+这里出现的 [`uv`](https://github.com/astral-sh/uv) 是一个使用 `Rust` 编写的 `Python` 项目管理工具。  
+它可以为你剩下非常多在依赖管理方面的麻烦，就比如上面的 `uv build` 它会自动为你生成虚拟环境并安装好依赖。  
+当然了， [`uv`](https://github.com/astral-sh/uv) 不是必须的，我们使用 [`hatchling`](https://pypi.org/project/hatchling) 作为构建后端，你可以自己研究一下如何构建。  
+
+或者你也可以直接把当前项目作为库安装，例如：
+```shell
+# 假设你已经在仓库目录里了
+pip install .
+# 如果需要安装 CPU 引擎和特征索引支持的话是
+pip install ".[cpu,index]"
+```
+
+
+## 关于特征模型
+你可以在[这里](https://huggingface.co/NaruseMioShirakana/MoeSS-SUBModel/tree/main)找到 `MoeSS` 使用的 `onnx` 特征模型。它们是通用的。  
+**通常情况下最常见的 `v2` 版本的生成器模型使用的是 `vec-768-layer-12.onnx`**
+
+## 关于推理引擎
+你可能已经看到了那个未安装任何推理引擎的警告或者错误。  
+请在安装命令后面添加 `[xxx]` 来安装可选依赖。  
+例如：
+```shell
+# 假设你已经在 dist/ 目录下构建好了 whl 文件
+pip install "./dist/rvcpyinfer-0.1.0-py3-none-any[cpu]"
+```
+目前我们支持以下推理引擎：
+
+- `onnxruntime`
+  - `[cpu]`：ONNX Runtime (CPU)，通用
+  - `[cuda]`：ONNX Runtime (CUDA)，Nvidia GPU 加速
+  - `[dml]`：ONNX Runtime (DML)，Windows DirectML 加速
+- `openvino`
+  - `[openvino]`：OpenVINO，Intel 硬件加速
+
+请注意 `onnxruntime` 的三个可选依赖是互斥的，你只能选择其中的一个。  
+关于 `openvino` 的 `IR` 格式，本库会转换 `IR` 格式并存档在 `.onnx` 同目录下的同名文件中，以便在下一次加载时加速，该行为目前无法被禁用。
+
+## 关于特征索引
+原项目的 `.index` 文件可直接使用，无需转换。  
+但你需要使用 `[index]` 来安装我们需要用于读取特征索引的依赖—— `faiss`。  
+
+## 快速使用
+一个简单的示例：
+```python
+import RvcPyInfer
+
+context = RvcPyInfer.RvcContext() # 创建一个上下文
+
+task = context.build_task(
+    "./你的特征模型.onnx",
+    "./你的 Rvc 生成器模型.onnx",
+    48000, # 你的 Rvc 生成器模型的生成采样率
+    "./你要推理的源文件.wav", # 可以填多个源文件
+    # 后续可选参数需显式写明名称，例如: 
+    sid=1,    # 说话者 id，一般情况下就是 0
+    seed=4321 # 噪声种子，默认 1234
+)
+task.run_and_save(
+    "./你要保存的结果.wav" # 请注意，它不会自动创建目录
+)
+```
+
+## CLI
+我们已经预制了一些 `CLI` 在库中了，并随库一并打包。  
+以下是库内置的命令：  
+- `rvc-infer`：用以快速推理模型而无需编写代码
+- `rvc-model`：与原项目模型相关的命令
+
+### rvc-infer
+最简格式： `rvc-infer --vec-model <你的特征模型路径> --gen-model <你的生成器模型路径> --gen-model-sr <你的生成器模型的输出采样率> -i <输入音频文件路径> -o <输出音频文件路径>`  
+**Tips：可出现多个 -i 和 -o，只要它们的数量一致，多个 -i 和 -o 按出现顺序一一对应。**
+
+### rvc-model
+该命令用于查看原项目的 `.pth` 模型的生成采样率，以及在 `Windows` 上快速导出 onnx 模型。
+
+#### rvc-model show-sr
+格式： `rvc-model show-sr -m <你的pth模型路径>`
+
+#### rvc-model export
+**⚠️注意：你必须安装源项目的整合包或至少有一个能运行源项目的环境以便 `PyTorch` 导出 `.onnx` 模型。**  
+它并不依赖项目内置的 `tools/export_onnx.py` 我们有自己的方法。  
+~~事实上原项目的 export_onnx.py 甚至没有做 v2 版本的支持~~  
+格式： `rvc-model export -m <你的pth模型路径> -t <你希望输出到哪> -r <rvc 原项目的根路径> --runtime <可选的导出用的 python 解释器路径，默认使用 rvc 原项目整合包自带的解释器>`  
+
+## 未来的计划
+- [ ] Github Action 可重现性构建流水线  
+- [ ] 发布至 PyPI  
+
+## 许可证
+在文件头部或文件所在目录未有额外说明的情况下，本项目代码部分使用 [`MIT`](https://mit-license.org/) 许可证授权与你，非代码部分使用 `CC BY 4.0` 授权与你。  
+
+## 🎉鸣谢
+
+- [原项目组的所有成员](https://github.com/RVC-Project)  
+没有TA们的付出就没有 RVC 模型，该项目也不会出现  
+- [提前打好特征模型 ONNX 的 MoeSS](https://github.com/Miuzarte/MoeSS)  
+省去了诸多导出特征模型的麻烦  
+- [帮了作者很多的 GLM AI](https://chatglm.cn)  
+省去了很多查资料和写 CLI 的时间  

rvcpyinfer-0.1.0.dist-info/RECORD

@@ -0,0 +1,31 @@
+RvcPyInfer/InferProviders.py,sha256=8Jn3Xi90wjrLU83egM7C24PCUFajWm75CI-pMXrFzJ4,4378
+RvcPyInfer/InferTask.py,sha256=7UyUzDID-yvZO_2m65gB7KnshKmHVutpFjle7catB0c,8004
+RvcPyInfer/RvcContext.py,sha256=v1Y9RxFj_L9iYc6FUvkxohov2qGQRxSFB-Y3FBcHvjA,4494
+RvcPyInfer/__init__.py,sha256=rHx3jplir7VUN_dLb8ynuUXTo7h_c-5BnZLW8iKl58w,1424
+RvcPyInfer/__main__.py,sha256=SXbzIbZgMuLH5wS9awdNRWoZLXoEu5WvWJ953gGTRIs,80
+RvcPyInfer/_version.py,sha256=Pru0BlFBASFCFo7McHdohtKkUtgMPDwbGfyUZlE2_Vw,21
+RvcPyInfer/cli.py,sha256=WsdGmsZqnYabLOhayq56-lZW2u7FkV7JLpzT2xlPDeg,5053
+RvcPyInfer/f0_utils.py,sha256=WoGjxNDqmJdD5_p25_aqEJA0MrhyRQtHgyrEE2E13F8,4418
+RvcPyInfer/infer_env.py,sha256=8bS1bkzLIqw6aKubGbfOiQXp6aIdVH4cHxP-pakZZd0,691
+RvcPyInfer/path_utils.py,sha256=W2VP1xe3Cev5eDeBb_GNkn9o-ObcQ1LD89HFY1-4090,180
+RvcPyInfer/type_alist.py,sha256=WuSioYk5b5LhqcusGPzY0oZJOA-k1S1d_x0hb54ZV2E,354
+RvcPyInfer/audio/audio_utils.py,sha256=xw-sDPA6z-IBpfL6Od0-M8eHVCNSfljuZE8zm6GgJtY,11629
+RvcPyInfer/error/InferEnvError.py,sha256=oBWiXBQBTbWlsxYKRtcKMnFK_c1yITqtT-pXeEDU4po,40
+RvcPyInfer/error/NotSupportedAlgorithmError.py,sha256=_daqjLlyN-vXgcogrwi1RCNzv17YzWSMH6--TOdhAQM,53
+RvcPyInfer/index/RvcFeatIndex.py,sha256=b4XOblLwf3y72RQjqYnL16kw5Xp4PySyTp631wZKooM,836
+RvcPyInfer/onnx/ContentVec.py,sha256=phpD0tZa4EobEa7xXkm4035VsXuVZ5I9nvxaKx4-eGc,1581
+RvcPyInfer/onnx/ModelSimplePool.py,sha256=w9A3SU9H8tkBxlGV5qkHCirSEYpQpddhId3nAt6YwVI,824
+RvcPyInfer/onnx/RvcGen.py,sha256=EApnlYIXRNwk6jPa5ERnbyjlzIuwmyBm98hkZxoPRTU,2330
+RvcPyInfer/onnx/model_loader.py,sha256=0daGfPzWWZ4RzOF55zvGNa1wnOfwW_-XNf50NhRF88s,2156
+RvcPyInfer/onnx/export/Exporter.py,sha256=pVTa9H1NhIkPMjpvMFNqJYWQFAsutdmgC8Z9QOkiJrc,5138
+RvcPyInfer/onnx/export/cli.py,sha256=cdP1MG9Pp3nkRpnQQNS1gOVi_Jk7bs894C82PKooliA,3640
+RvcPyInfer/onnx/export/direct_read_sr.py,sha256=rQPdaXjK0PTqjGeqLRwmegSg2ETXgEwjMcfBNPa4NDQ,3775
+RvcPyInfer/ov/OVCoreSingleton.py,sha256=JpYEZ0lo3vqlbhIVsvd32oufcbQ5rw7ErHZDljUnyJM,80
+RvcPyInfer/resource/template/export_onnx.py,sha256=GEDb2qoD5a8XEKzWB5ZCJdQYV6fdxrR2gUjw1J9aLR0,10817
+RvcPyInfer/warn/InferEnvWarn.py,sha256=H3ibEJULsZi_qhXOHNLDwZ62Cb9Dkp2MRNmVer4jeSA,74
+RvcPyInfer/warn/InferModelWarn.py,sha256=xdiOonWO1DA0gsxC1j4kEIK9RMb14ea5un_lqhGgqEA,76
+RvcPyInfer/warn/InferWarn.py,sha256=I4lXXhtlowlkxESwX823fbALCRu7UUy9Cge4NJij5tg,34
+rvcpyinfer-0.1.0.dist-info/METADATA,sha256=frDwFbzgS8iULMJbQt6wstCxmQ-OT0RKfLKKbX230tE,7143
+rvcpyinfer-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+rvcpyinfer-0.1.0.dist-info/entry_points.txt,sha256=dfU76sq76486FT-4NFaMhwL-j8fyoApLcLMExRRmqc4,105
+rvcpyinfer-0.1.0.dist-info/RECORD,,

rvcpyinfer-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

rvcpyinfer-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+rvc-infer = RvcPyInfer.__main__:infer_main
+rvc-model = RvcPyInfer.onnx.export.cli:main