tts-sidecar 0.2.0__py3-none-any.whl

tts_sidecar/__init__.py

@@ -0,0 +1,27 @@
+"""
+TTS Sidecar — síntesis de voz con clonación de voz.
+100% local, licencia GPL-3.0-or-later, soporte para español latinoamericano.
+"""
+
+__version__ = "0.2.0"
+__author__ = "TTS Sidecar Team"
+__license__ = "GPL-3.0-or-later"
+
+# Imports perezosos: permite ejecutar --help sin que las dependencias pesadas estén instaladas
+def __getattr__(name):
+    """
+    Resuelve imports perezosos de los símbolos públicos del paquete.
+
+    ChatterboxEngine y AudioPlayer se importan solo cuando se acceden por primera
+    vez, evitando cargar torch/chatterbox al invocar subcomandos ligeros como
+    --help, version o devices.
+    """
+    if name == "ChatterboxEngine":
+        from .engine import ChatterboxEngine
+        return ChatterboxEngine
+    if name == "AudioPlayer":
+        from .audio import AudioPlayer
+        return AudioPlayer
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+__all__ = []

tts_sidecar/__main__.py

@@ -0,0 +1,6 @@
+"""Permite `python -m tts_sidecar` como vía de invocación equivalente al entry point."""
+
+from .cli import main
+
+if __name__ == "__main__":
+    main()

tts_sidecar/audio.py

@@ -0,0 +1,218 @@
+"""
+Reproducción de audio nativa para Windows, Linux y macOS.
+Usa APIs nativas de cada SO para un rendimiento óptimo.
+"""
+
+import warnings
+warnings.filterwarnings("ignore", message="pkg_resources is deprecated")
+
+import platform
+import sys
+import wave
+import io
+from typing import Optional
+
+import numpy as np
+
+
+class AudioPlayer:
+    """
+    Reproducción de audio multiplataforma usando APIs nativas.
+
+    Prioridad por plataforma:
+    1. Windows: winsound (built-in)
+    2. Linux: sounddevice (PortAudio)
+    3. macOS: afplay (nativo)
+    """
+
+    def __init__(self):
+        self.system = platform.system()
+        self._player = self._init_player()
+
+    def _init_player(self):
+        """Inicializa el player de audio apropiado para la plataforma."""
+        if self.system == "Windows":
+            return self._init_windows()
+        elif self.system == "Darwin":
+            return self._init_macos()
+        elif self.system == "Linux":
+            return self._init_linux()
+        else:
+            raise RuntimeError(f"Plataforma no soportada: {self.system}")
+
+    def _init_windows(self):
+        """Inicializa el player de audio para Windows."""
+        # winsound es built-in: no requiere dependencias externas
+        return WindowsAudioPlayer()
+
+    def _init_macos(self):
+        """Inicializa el player de audio para macOS usando afplay (built-in)."""
+        try:
+            import subprocess  # noqa: F401 — verificación de disponibilidad
+            return MacOSAudioPlayer()
+        except Exception as e:
+            raise RuntimeError(f"Error al inicializar audio en macOS: {e}")
+
+    def _init_linux(self):
+        """Inicializa el player de audio para Linux."""
+        try:
+            import sounddevice as sd
+            return SoundDevicePlayer(sd)
+        except ImportError:
+            raise ImportError(
+                "No hay librería de reproducción de audio disponible para Linux. "
+                "Instala sounddevice."
+            )
+
+    def play(self, audio_bytes: bytes) -> None:
+        """Reproduce audio desde bytes WAV."""
+        self._player.play(audio_bytes)
+
+    def play_file(self, file_path: str) -> None:
+        """Reproduce audio desde un archivo WAV."""
+        with open(file_path, 'rb') as f:
+            audio_bytes = f.read()
+        self.play(audio_bytes)
+
+
+class WindowsAudioPlayer:
+    """Reproducción de audio en Windows usando winsound (built-in)."""
+
+    def play(self, audio_bytes: bytes) -> None:
+        """Reproduce bytes WAV en Windows usando winsound built-in."""
+        import winsound
+        import tempfile
+        import os
+
+        # winsound.PlaySound requiere una ruta de archivo, no bytes en memoria
+        with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as f:
+            f.write(audio_bytes)
+            temp_path = f.name
+
+        try:
+            winsound.PlaySound(temp_path, winsound.SND_FILENAME)
+        finally:
+            os.unlink(temp_path)
+
+
+class MacOSAudioPlayer:
+    """Reproducción de audio en macOS usando afplay (built-in)."""
+
+    def __init__(self):
+        import subprocess
+        self.subprocess = subprocess
+
+    def play(self, audio_bytes: bytes) -> None:
+        """Reproduce audio usando afplay."""
+        import tempfile
+        import os
+
+        # afplay requiere una ruta de archivo
+        with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as f:
+            f.write(audio_bytes)
+            temp_path = f.name
+
+        try:
+            self.subprocess.run(['afplay', temp_path], check=True)
+        finally:
+            os.unlink(temp_path)
+
+
+class SoundDevicePlayer:
+    """Reproducción de audio multiplataforma usando sounddevice (PortAudio)."""
+
+    def __init__(self, sd):
+        self.sd = sd
+
+    def play(self, audio_bytes: bytes) -> None:
+        """Reproduce bytes WAV usando sounddevice."""
+        wav_io = io.BytesIO(audio_bytes)
+        with wave.open(wav_io, 'rb') as wf:
+            n_channels = wf.getnchannels()
+            sample_rate = wf.getframerate()
+            sample_width = wf.getsampwidth()
+            audio_data = wf.readframes(wf.getnframes())
+
+        if sample_width != 2:
+            raise ValueError(
+                f"WAV con ancho de muestra no soportado ({sample_width * 8} bits); "
+                "se espera PCM de 16 bits."
+            )
+
+        # Convierte a float32 normalizado en [-1, 1]
+        audio_np = np.frombuffer(audio_data, dtype=np.int16)
+        audio_np = audio_np.astype(np.float32) / 32768.0
+
+        # Un WAV multicanal llega intercalado: sin el reshape, sounddevice lo
+        # reproduciría como mono al doble de velocidad.
+        if n_channels > 1:
+            audio_np = audio_np.reshape((-1, n_channels))
+
+        self.sd.play(audio_np, samplerate=sample_rate, blocking=True)
+
+
+def get_audio_devices_with_status() -> tuple[list[dict], bool]:
+    """
+    Lista los dispositivos de salida de audio disponibles.
+
+    Returns:
+        Tupla (dispositivos, degraded): `degraded` es True cuando la enumeración
+        real falló y se devolvió el fallback genérico "Default" — usado por
+        `doctor`/`setup` (WARNING-03) para distinguir un subsistema de audio
+        real de uno degradado, algo que `import pycaw` por sí solo no revela.
+    """
+    system = platform.system()
+
+    if system == "Windows":
+        try:
+            from pycaw.pycaw import AudioUtilities, EDataFlow, DEVICE_STATE
+            # Enumera SOLO endpoints de render (salida) activos, descartando los de
+            # captura (micrófonos). GetAllDevices() no distingue el data-flow, así que
+            # se usa el IMMDeviceEnumerator con eRender, análogo al filtro de Linux.
+            enumerator = AudioUtilities.GetDeviceEnumerator()
+            collection = enumerator.EnumAudioEndpoints(
+                EDataFlow.eRender.value, DEVICE_STATE.ACTIVE.value
+            )
+            count = collection.GetCount()
+            result = []
+            for i in range(count):
+                dev = AudioUtilities.CreateDevice(collection.Item(i))
+                result.append({
+                    "id": i,
+                    "name": dev.FriendlyName,
+                    "latency": getattr(dev, "Latency", 0.0),
+                })
+            return result, False
+        except Exception:
+            # No solo ImportError: un fallo COM de pycaw (sesiones RDP, hosts
+            # sin audio) también debe degradar al fallback, no crashear.
+            return [{"id": 0, "name": "Default", "latency": 0.1}], True
+
+    elif system in ("Darwin", "Linux"):
+        # sounddevice (PortAudio) enumera en ambas plataformas; se filtran los
+        # dispositivos de salida, análogo al filtro eRender de Windows.
+        try:
+            import sounddevice as sd
+            return [
+                {"id": i, "name": info['name'], "latency": info['default_low_output_latency']}
+                for i, info in enumerate(sd.query_devices())
+                if info['max_output_channels'] > 0
+            ], False
+        except Exception:
+            # No solo ImportError: un fallo de PortAudio en tiempo de
+            # enumeración (sin backend ALSA/CoreAudio, host sin audio) también
+            # debe degradar al fallback, no crashear, igual que en Windows.
+            return [{"id": 0, "name": "Default", "latency": 0.1}], True
+
+    return [{"id": 0, "name": "Default", "latency": 0.1}], True
+
+
+def get_audio_devices() -> list[dict]:
+    """
+    Lista los dispositivos de salida de audio disponibles.
+
+    Returns:
+        Lista de dicts con claves 'id', 'name', 'latency'
+    """
+    devices, _degraded = get_audio_devices_with_status()
+    return devices

tts_sidecar/bootstrap.py

@@ -0,0 +1,72 @@
+"""
+Bootstrap pre-import de tts-sidecar.
+
+Fuente única de la preparación que debe correr antes de importar cualquier
+dependencia pesada (chatterbox, perth, transformers): supresión de warnings,
+variables de entorno, niveles de logging y el mock de `pkg_resources` que
+Python 3.13 necesita porque el módulo fue eliminado de la stdlib pero `perth`
+(dependencia de chatterbox) lo importa en tiempo de import.
+
+`apply()` es idempotente y debe invocarse al principio de cada vía de entrada
+del proceso (entry point pip/uv, `bin/tts-sidecar`, `python -m tts_sidecar`,
+subcomando congelado `daemon serve`), antes de cualquier otro import del
+paquete que pueda arrastrar `chatterbox`/`perth` transitivamente.
+"""
+
+import importlib.machinery
+import importlib.util
+import logging
+import os
+import sys
+import types
+import warnings
+from pathlib import Path
+
+_applied = False
+
+
+def _install_pkg_resources_mock() -> None:
+    """Instala un mock mínimo de `pkg_resources` si no está disponible.
+
+    El mock debe ser un módulo real con `__spec__`: un objeto bare haría que
+    cualquier llamada posterior a `importlib.util.find_spec('pkg_resources')`
+    lanzara "pkg_resources.__spec__ is not set" (p. ej. desde el subcomando
+    congelado `daemon serve`, que corre en el mismo proceso que el entry point
+    del CLI y reconsulta el spec).
+    """
+    if 'pkg_resources' in sys.modules:
+        return
+    if importlib.util.find_spec('pkg_resources') is not None:
+        return
+
+    def _resource_filename(package, resource):
+        spec = importlib.util.find_spec(package)
+        if spec and spec.submodule_search_locations:
+            return str(Path(spec.submodule_search_locations[0]) / resource)
+        return resource
+
+    mock = types.ModuleType('pkg_resources')
+    mock.resource_filename = _resource_filename
+    mock.__spec__ = importlib.machinery.ModuleSpec('pkg_resources', None)
+    sys.modules['pkg_resources'] = mock
+
+
+def apply() -> None:
+    """Aplica el bootstrap pre-import. Idempotente: una segunda invocación es no-op."""
+    global _applied
+    if _applied:
+        return
+    _applied = True
+
+    warnings.filterwarnings("ignore")
+    os.environ["PYTHONWARNINGS"] = "ignore"
+    os.environ["HF_HUB_DISABLE_IMPLICIT_TOKEN"] = "1"
+    os.environ["TRANSFORMERS_VERBOSITY"] = "error"
+    os.environ["TRANSFORMERS_NO_ADVISORY_WARNINGS"] = "1"
+    os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+    logging.getLogger("huggingface_hub").setLevel(logging.ERROR)
+    logging.getLogger("chatterbox.models.tokenizers.tokenizer").setLevel(logging.ERROR)
+    logging.getLogger("chatterbox.models.t3.inference.alignment_stream_analyzer").setLevel(logging.ERROR)
+
+    _install_pkg_resources_mock()