Delete tts_engine.py

tts_engine.py

@@ -1,146 +0,0 @@
-"""
-TTS Engine Router — routes synthesis to local models or YourVoic API.
-"""
-
-import os
-import io
-import time
-import tempfile
-import requests
-import numpy as np
-import soundfile as sf
-import logging
-
-logger = logging.getLogger(__name__)
-
-YOURVOIC_API_KEY = os.environ.get("YOURVOIC_API_KEY", "")
-YOURVOIC_STREAM_URL = "https://yourvoic.com/api/v1/tts/stream"
-
-
-def synthesize_yourvoic(text, language_code, voice="Peter", speed=1.0):
-    """
-    Synthesize text using YourVoic API.
-    Returns (audio_array, sample_rate) or raises on failure.
-    """
-    if not YOURVOIC_API_KEY:
-        raise RuntimeError(
-            "YOURVOIC_API_KEY not set. Add it as a Space secret."
-        )
-
-    headers = {
-        "X-API-Key": YOURVOIC_API_KEY,
-        "Content-Type": "application/json",
-    }
-    payload = {
-        "text": text,
-        "voice": voice,
-        "language": language_code,
-        "model": "aura-prime",
-        "speed": speed,
-    }
-
-    t0 = time.time()
-    response = requests.post(
-        YOURVOIC_STREAM_URL,
-        headers=headers,
-        json=payload,
-        stream=True,
-        timeout=60,
-    )
-
-    if response.status_code != 200:
-        raise RuntimeError(
-            f"YourVoic API error {response.status_code}: {response.text[:200]}"
-        )
-
-    # Collect streamed audio bytes
-    audio_bytes = io.BytesIO()
-    for chunk in response.iter_content(chunk_size=8192):
-        audio_bytes.write(chunk)
-    audio_bytes.seek(0)
-
-    elapsed = time.time() - t0
-    logger.info(f"YourVoic TTS: {len(text)} chars, {elapsed:.2f}s")
-
-    # Read audio from WAV bytes
-    audio_array, sample_rate = sf.read(audio_bytes, dtype="float32")
-    return audio_array, sample_rate
-
-
-def synthesize_yourvoic_to_file(text, language_code, output_path, voice="Peter", speed=1.0):
-    """Synthesize via YourVoic and save to file."""
-    audio, sr = synthesize_yourvoic(text, language_code, voice, speed)
-    sf.write(output_path, audio, sr)
-    return output_path, sr
-
-
-def synthesize_local(text, tts_pipe):
-    """
-    Synthesize text using local HuggingFace TTS pipeline (MMS-TTS).
-    Returns (audio_array, sample_rate).
-    """
-    t0 = time.time()
-    result = tts_pipe(text)
-    audio = np.array(result["audio"]).squeeze()
-    sr = result["sampling_rate"]
-    elapsed = time.time() - t0
-    logger.info(f"Local TTS: {len(text)} chars, {elapsed:.2f}s, {len(audio)/sr:.1f}s audio")
-    return audio, sr
-
-
-def synthesize_chunked(text, language_config, tts_pipe=None, sentences_per_chunk=2):
-    """
-    Synthesize long text by chunking into sentence groups.
-    Routes to either YourVoic or local TTS based on language config.
-
-    Args:
-        text: Full text to synthesize
-        language_config: Dict from LANGUAGES (has tts_engine, yourvoic_lang, etc.)
-        tts_pipe: Local HuggingFace TTS pipeline (needed for local engine)
-        sentences_per_chunk: How many sentences to synthesize per API call
-
-    Returns:
-        (audio_array, sample_rate)
-    """
-    import re
-    sentences = re.split(r'(?<=[.!?])\s+', text)
-    sentences = [s.strip() for s in sentences if s.strip()]
-
-    if not sentences:
-        return np.array([], dtype=np.float32), 16000
-
-    engine = language_config["tts_engine"]
-    audio_segments = []
-    output_sr = None
-
-    for i in range(0, len(sentences), sentences_per_chunk):
-        chunk_text = ' '.join(sentences[i:i + sentences_per_chunk])
-        if not chunk_text:
-            continue
-
-        try:
-            if engine == "yourvoic":
-                voice = language_config["yourvoic_voices"][0] if language_config["yourvoic_voices"] else "Peter"
-                lang_code = language_config["yourvoic_lang"]
-                audio_seg, seg_sr = synthesize_yourvoic(chunk_text, lang_code, voice)
-            else:
-                if tts_pipe is None:
-                    raise RuntimeError("Local TTS pipeline not loaded")
-                audio_seg, seg_sr = synthesize_local(chunk_text, tts_pipe)
-
-            if output_sr is None:
-                output_sr = seg_sr
-            if len(audio_seg) > 0:
-                audio_segments.append(audio_seg)
-                # Small silence between chunks
-                silence = np.zeros(int(0.15 * seg_sr), dtype=np.float32)
-                audio_segments.append(silence)
-
-        except Exception as e:
-            logger.error(f"TTS chunk failed: {e}")
-            continue
-
-    if not audio_segments:
-        return np.array([], dtype=np.float32), output_sr or 16000
-
-    return np.concatenate(audio_segments), output_sr