vox-cosyvoice 0.1.0__tar.gz

vox_cosyvoice-0.1.0/.gitignore

@@ -0,0 +1,17 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+dist/
+build/
+.eggs/
+*.egg
+.venv/
+venv/
+.env
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+*.so
+*.dylib
+.coverage

vox_cosyvoice-0.1.0/PKG-INFO

@@ -0,0 +1,40 @@
+Metadata-Version: 2.4
+Name: vox-cosyvoice
+Version: 0.1.0
+Summary: CosyVoice 2 TTS adapter for Vox
+Requires-Python: >=3.11
+Requires-Dist: numpy<2.4,>=1.26.0
+Requires-Dist: soundfile>=0.13.1
+Requires-Dist: vox-runtime>=0.2.2
+Description-Content-Type: text/markdown
+
+# vox-cosyvoice
+
+`vox-cosyvoice` provides a Vox TTS adapter for CosyVoice 2.
+
+Adapters:
+
+- `cosyvoice2-tts-torch` - CosyVoice 2 zero-shot streaming backend
+
+## Install
+
+```bash
+pip install vox-cosyvoice
+```
+
+## Runtime Dependencies
+
+The adapter package is intentionally light. The official CosyVoice runtime is
+installed on demand from GitHub into the isolated target runtime
+`$VOX_HOME/runtime/cosyvoice`.
+
+## Use with Vox
+
+```bash
+vox pull cosyvoice2-tts-torch:0.5b
+vox run cosyvoice2-tts-torch:0.5b "Hello from CosyVoice 2"
+```
+
+CosyVoice 2 is best used with a reference voice. Pass `reference_audio` and
+`reference_text` through the Vox API, or use a voice value that points to a
+local WAV file.

vox_cosyvoice-0.1.0/README.md

@@ -0,0 +1,30 @@
+# vox-cosyvoice
+
+`vox-cosyvoice` provides a Vox TTS adapter for CosyVoice 2.
+
+Adapters:
+
+- `cosyvoice2-tts-torch` - CosyVoice 2 zero-shot streaming backend
+
+## Install
+
+```bash
+pip install vox-cosyvoice
+```
+
+## Runtime Dependencies
+
+The adapter package is intentionally light. The official CosyVoice runtime is
+installed on demand from GitHub into the isolated target runtime
+`$VOX_HOME/runtime/cosyvoice`.
+
+## Use with Vox
+
+```bash
+vox pull cosyvoice2-tts-torch:0.5b
+vox run cosyvoice2-tts-torch:0.5b "Hello from CosyVoice 2"
+```
+
+CosyVoice 2 is best used with a reference voice. Pass `reference_audio` and
+`reference_text` through the Vox API, or use a voice value that points to a
+local WAV file.

vox_cosyvoice-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[project]
+name = "vox-cosyvoice"
+version = "0.1.0"
+description = "CosyVoice 2 TTS adapter for Vox"
+readme = { file = "README.md", content-type = "text/markdown" }
+requires-python = ">=3.11"
+dependencies = [
+    "vox-runtime>=0.2.2",
+    "numpy>=1.26.0,<2.4",
+    "soundfile>=0.13.1",
+]
+
+[tool.vox.adapter]
+import-package = "vox_cosyvoice"
+runtime-policy = "target-runtime"
+runtime-names = ["cosyvoice"]
+adapter-types = ["tts"]
+
+[project.entry-points."vox.adapters"]
+cosyvoice2-tts-torch = "vox_cosyvoice.adapter:CosyVoice2Adapter"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/vox_cosyvoice"]

vox_cosyvoice-0.1.0/src/vox_cosyvoice/__init__.py

@@ -0,0 +1,3 @@
+from vox_cosyvoice.adapter import CosyVoice2Adapter
+
+__all__ = ["CosyVoice2Adapter"]

vox_cosyvoice-0.1.0/src/vox_cosyvoice/adapter.py

@@ -0,0 +1,217 @@
+from __future__ import annotations
+
+import importlib
+import logging
+import subprocess
+import tempfile
+from collections.abc import AsyncIterator
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import soundfile as sf
+from numpy.typing import NDArray
+
+from vox.core.adapter import TTSAdapter
+from vox.core.adapter_runtime import (
+    activate_runtime_path,
+    install_target_runtime_requirements,
+    purge_runtime_modules,
+)
+from vox.core.adapter_runtime import (
+    runtime_root as vox_runtime_root,
+)
+from vox.core.types import AdapterInfo, ModelFormat, ModelType, SynthesizeChunk, VoiceInfo
+
+logger = logging.getLogger(__name__)
+
+COSYVOICE_SAMPLE_RATE = 24_000
+COSYVOICE_REPO = "git+https://github.com/FunAudioLLM/CosyVoice.git"
+
+
+def _runtime_root() -> Path:
+    return vox_runtime_root() / "cosyvoice"
+
+
+def _ensure_runtime_path() -> str:
+    runtime_dir = _runtime_root()
+    runtime_dir.mkdir(parents=True, exist_ok=True)
+    return activate_runtime_path(runtime_dir, root=runtime_dir.parent)
+
+
+def _run_install_command(cmd: list[str], timeout: int) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(cmd, capture_output=True, text=True, timeout=timeout)
+
+
+def _install_cosyvoice_runtime() -> None:
+    runtime_path = _ensure_runtime_path()
+    if not install_target_runtime_requirements(
+        runtime_path,
+        (COSYVOICE_REPO,),
+        timeout=1800,
+        install_runner=_run_install_command,
+        context="CosyVoice runtime install",
+    ):
+        raise RuntimeError("Failed to install CosyVoice runtime from GitHub.")
+
+
+def _clear_cosyvoice_modules() -> None:
+    purge_runtime_modules(("cosyvoice", "matcha", "wetext"))
+
+
+def _load_cosyvoice_class() -> type[Any]:
+    _ensure_runtime_path()
+    try:
+        module = importlib.import_module("cosyvoice.cli.cosyvoice")
+    except ImportError:
+        _install_cosyvoice_runtime()
+        _clear_cosyvoice_modules()
+        module = importlib.import_module("cosyvoice.cli.cosyvoice")
+
+    cls = getattr(module, "CosyVoice2", None)
+    if cls is None:
+        raise RuntimeError("CosyVoice runtime is installed, but cosyvoice.cli.cosyvoice.CosyVoice2 was not found.")
+    return cls
+
+
+def _voice_path(voice: str | None) -> Path | None:
+    if not voice:
+        return None
+    path = Path(voice).expanduser()
+    return path if path.is_file() else None
+
+
+def _write_reference_audio(path: Path, reference_audio: NDArray[np.float32], sample_rate: int) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    sf.write(path, np.asarray(reference_audio, dtype=np.float32), sample_rate)
+
+
+def _extract_audio(output: Any) -> NDArray[np.float32]:
+    if isinstance(output, dict):
+        for key in ("tts_speech", "audio", "wav", "waveform"):
+            if key in output:
+                return _extract_audio(output[key])
+        raise RuntimeError("CosyVoice returned a dict without audio data.")
+    if isinstance(output, tuple | list) and output and not isinstance(output[0], (int, float, np.number)):
+        return _extract_audio(output[0])
+    if hasattr(output, "detach"):
+        output = output.detach()
+    if hasattr(output, "cpu"):
+        output = output.cpu()
+    if hasattr(output, "numpy"):
+        output = output.numpy()
+    audio = np.asarray(output, dtype=np.float32).reshape(-1)
+    if audio.size == 0:
+        raise RuntimeError("CosyVoice produced no audio.")
+    return audio
+
+
+class CosyVoice2Adapter(TTSAdapter):
+    def __init__(self) -> None:
+        self._model: Any | None = None
+        self._model_id = ""
+        self._device = "cpu"
+
+    def info(self) -> AdapterInfo:
+        return AdapterInfo(
+            name="cosyvoice2-tts-torch",
+            type=ModelType.TTS,
+            architectures=("cosyvoice2-tts-torch", "cosyvoice2", "cosyvoice"),
+            default_sample_rate=COSYVOICE_SAMPLE_RATE,
+            supported_formats=(ModelFormat.PYTORCH,),
+            supports_streaming=True,
+            supports_voice_cloning=True,
+            supported_languages=(),
+        )
+
+    def load(self, model_path: str, device: str, **kwargs: Any) -> None:
+        if self._model is not None:
+            return
+
+        kwargs.pop("_source", None)
+        self._model_id = model_path
+        self._device = device
+        cls = _load_cosyvoice_class()
+
+        logger.info("Loading CosyVoice2 model from %s (device=%s)", model_path, self._device)
+        try:
+            self._model = cls(model_path, load_jit=False, load_trt=False, load_vllm=False, fp16=device == "cuda")
+        except TypeError:
+            self._model = cls(model_path)
+
+    def unload(self) -> None:
+        self._model = None
+        self._model_id = ""
+        self._device = "cpu"
+
+    @property
+    def is_loaded(self) -> bool:
+        return self._model is not None
+
+    async def synthesize(
+        self,
+        text: str,
+        *,
+        voice: str | None = None,
+        speed: float = 1.0,
+        language: str | None = None,
+        reference_audio: NDArray[np.float32] | None = None,
+        reference_text: str | None = None,
+    ) -> AsyncIterator[SynthesizeChunk]:
+        if self._model is None:
+            raise RuntimeError("CosyVoice2 model is not loaded — call load() first")
+        if not text or not text.strip():
+            return
+
+        voice_file = _voice_path(voice)
+        zero_shot_spk_id = "" if voice_file is not None else (voice or "")
+        if reference_audio is None and voice_file is None and not zero_shot_spk_id:
+            raise ValueError("CosyVoice2 requires reference_audio, a voice path, or a zero_shot_spk_id voice value.")
+
+        with tempfile.TemporaryDirectory(prefix="vox-cosyvoice-") as tmpdir:
+            prompt_wav = ""
+            if reference_audio is not None:
+                ref_path = Path(tmpdir) / "reference.wav"
+                _write_reference_audio(ref_path, reference_audio, COSYVOICE_SAMPLE_RATE)
+                prompt_wav = str(ref_path)
+            elif voice_file is not None:
+                prompt_wav = str(voice_file)
+
+            outputs = self._model.inference_zero_shot(
+                text,
+                reference_text or "",
+                prompt_wav,
+                zero_shot_spk_id=zero_shot_spk_id,
+                stream=True,
+                speed=speed,
+            )
+
+            yielded = False
+            for output in outputs:
+                audio = _extract_audio(output)
+                if audio.size:
+                    yielded = True
+                    yield SynthesizeChunk(
+                        audio=audio.tobytes(),
+                        sample_rate=COSYVOICE_SAMPLE_RATE,
+                        is_final=False,
+                    )
+
+        if not yielded:
+            raise RuntimeError("CosyVoice2 produced no audio.")
+
+        yield SynthesizeChunk(audio=b"", sample_rate=COSYVOICE_SAMPLE_RATE, is_final=True)
+
+    def list_voices(self) -> list[VoiceInfo]:
+        return [
+            VoiceInfo(
+                id="reference",
+                name="Reference audio",
+                language=None,
+                description="Pass reference_audio/reference_text, a voice path, or a saved zero_shot_spk_id.",
+                is_cloned=True,
+            )
+        ]
+
+    def estimate_vram_bytes(self, **kwargs: Any) -> int:
+        return 5_000_000_000