Upload 3 files

Dockerfile

@@ -8,10 +8,8 @@ RUN apt-get update && apt-get install -y \
 
 WORKDIR /app
 
-# Install CPU-only torch — v2.1.2 has torch.package.PackageImporter (removed in 2.3+)
-RUN pip install --no-cache-dir torch==2.1.2 --index-url https://download.pytorch.org/whl/cpu
-
-# Install remaining Python deps
+# Install Python deps (includes torch==2.1.2 — needed for Silero v4 PackageImporter,
+# removed in torch 2.3+. PyPI torch wheels are CPU-only by default.)
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 

app.py

@@ -31,9 +31,7 @@ PIPER_READY = False
 PIPER_VOICES = {
     # English
     "piper:en_US-amy-medium":        ("en_US-amy-medium.onnx",         "en_US-amy-medium.onnx.json"),
-    "piper:en_US-danny-low":         ("en_US-danny-low.onnx",          "en_US-danny-low.onnx.json"),
     "piper:en_US-joe-medium":        ("en_US-joe-medium.onnx",         "en_US-joe-medium.onnx.json"),
-    "piper:en_US-kathleen-low":      ("en_US-kathleen-low.onnx",       "en_US-kathleen-low.onnx.json"),
     "piper:en_US-lessac-medium":     ("en_US-lessac-medium.onnx",      "en_US-lessac-medium.onnx.json"),
     "piper:en_US-ryan-high":         ("en_US-ryan-high.onnx",          "en_US-ryan-high.onnx.json"),
     "piper:en_GB-alan-medium":       ("en_GB-alan-medium.onnx",        "en_GB-alan-medium.onnx.json"),
@@ -45,12 +43,8 @@ PIPER_VOICES = {
     # Other languages
     "piper:de_DE-thorsten-medium":   ("de_DE-thorsten-medium.onnx",    "de_DE-thorsten-medium.onnx.json"),
     "piper:fr_FR-upmc-medium":       ("fr_FR-upmc-medium.onnx",        "fr_FR-upmc-medium.onnx.json"),
-    "piper:es_ES-mls_10246-low":     ("es_ES-mls_10246-low.onnx",      "es_ES-mls_10246-low.onnx.json"),
     "piper:ru_RU-irina-medium":      ("ru_RU-irina-medium.onnx",       "ru_RU-irina-medium.onnx.json"),
-    "piper:zh_CN-huayan-x_low":      ("zh_CN-huayan-x_low.onnx",       "zh_CN-huayan-x_low.onnx.json"),
     "piper:tr_TR-dfki-medium":       ("tr_TR-dfki-medium.onnx",        "tr_TR-dfki-medium.onnx.json"),
-    "piper:pl_PL-mls_6892-low":      ("pl_PL-mls_6892-low.onnx",       "pl_PL-mls_6892-low.onnx.json"),
-    "piper:it_IT-riccardo-x_low":    ("it_IT-riccardo-x_low.onnx",     "it_IT-riccardo-x_low.onnx.json"),
     "piper:pt_BR-faber-medium":      ("pt_BR-faber-medium.onnx",       "pt_BR-faber-medium.onnx.json"),
     "piper:nl_NL-mls-medium":        ("nl_NL-mls-medium.onnx",         "nl_NL-mls-medium.onnx.json"),
 }
@@ -169,19 +163,10 @@ def download_piper_dynamic(voice_code: str) -> tuple:
     return onnx_path, json_path
 
 
-def synthesize_piper(text: str, voice_code: str, speed: float = 1.0) -> bytes:
-    if not PIPER_READY:
-        raise Exception("Piper is not available on this system")
-    # Pehle PIPER_VOICES dict mein check karo, nahi mila to dynamic download
-    if voice_code in PIPER_VOICES:
-        onnx_path, json_path = download_piper_model(voice_code)
-    else:
-        # Dynamic voice — direct HuggingFace se download
-        onnx_path, json_path = download_piper_dynamic(voice_code)
+def _piper_synth_chunk(text: str, onnx_path: str, json_path: str, length_scale: float) -> bytes:
     with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as out_f:
         out_path = out_f.name
     try:
-        length_scale = 1.0 / max(0.25, min(4.0, speed))
         cmd = [
             PIPER_BIN,
             "--model", onnx_path,
@@ -204,6 +189,68 @@ def synthesize_piper(text: str, voice_code: str, speed: float = 1.0) -> bytes:
             os.unlink(out_path)
 
 
+def _ffmpeg_concat_wav(parts: list) -> bytes:
+    """Merge multiple WAV byte chunks using ffmpeg concat (same codec)."""
+    if len(parts) == 1:
+        return parts[0]
+    tmp_files, concat_list, out_path = [], None, None
+    try:
+        for data in parts:
+            fd, path = tempfile.mkstemp(suffix=".wav")
+            os.close(fd)
+            with open(path, "wb") as f:
+                f.write(data)
+            tmp_files.append(path)
+        fd, concat_list = tempfile.mkstemp(suffix=".txt")
+        os.close(fd)
+        with open(concat_list, "w") as f:
+            for p in tmp_files:
+                f.write(f"file '{p}'\n")
+        fd, out_path = tempfile.mkstemp(suffix=".wav")
+        os.close(fd)
+        subprocess.run(["ffmpeg", "-y", "-hide_banner", "-loglevel", "error",
+                        "-f", "concat", "-safe", "0", "-i", concat_list,
+                        "-c", "copy", out_path], check=True, timeout=60)
+        with open(out_path, "rb") as f:
+            return f.read()
+    except Exception:
+        return b"".join(parts)
+    finally:
+        for p in tmp_files:
+            try: os.unlink(p)
+            except Exception: pass
+        for x in (concat_list, out_path):
+            if x:
+                try: os.unlink(x)
+                except Exception: pass
+
+
+def synthesize_piper(text: str, voice_code: str, speed: float = 1.0) -> bytes:
+    if not PIPER_READY:
+        raise Exception("Piper is not available on this system")
+    # Pehle PIPER_VOICES dict mein check karo, nahi mila to dynamic download
+    if voice_code in PIPER_VOICES:
+        onnx_path, json_path = download_piper_model(voice_code)
+    else:
+        # Dynamic voice — direct HuggingFace se download
+        onnx_path, json_path = download_piper_dynamic(voice_code)
+    length_scale = 1.0 / max(0.25, min(4.0, speed))
+    # Lambi text ko chunk karo (Piper stdin limit + timeout avoid karne ke liye)
+    if len(text) > 1400:
+        chunks = split_text(text, max_chars=1400)
+    else:
+        chunks = [text]
+    if len(chunks) == 1:
+        return _piper_synth_chunk(chunks[0], onnx_path, json_path, length_scale)
+    parts = []
+    for ch in chunks:
+        if ch.strip():
+            parts.append(_piper_synth_chunk(ch, onnx_path, json_path, length_scale))
+    if not parts:
+        raise Exception("Piper: no audio generated")
+    return _ffmpeg_concat_wav(parts)
+
+
 def split_text(text: str, max_chars: int = 1400) -> list:
     """Text ko chunklara bol"""
     text = text.strip()
@@ -258,6 +305,7 @@ SILERO_READY = False
 SILERO_MODELS_DIR = "/tmp/silero_models"
 SILERO_SAMPLE_RATE = 48000
 SILERO_MODELS = {}
+SILERO_LOAD_LOCK = threading.Lock()
 
 SILERO_MODEL_URLS = [
     "https://models.silero.ai/models/tts/ru/v4_ru.pt",
@@ -313,11 +361,8 @@ threading.Thread(target=setup_silero, daemon=True).start()
 
 
 def synthesize_silero(text: str, voice_code: str) -> bytes:
-    """Silero TTS — code: silero:ru_xenia. v4 model via PackageImporter."""
-    global SILERO_READY
-    if not SILERO_READY:
-        if "ru" not in SILERO_MODELS:
-            raise Exception("Silero TTS not available. Ensure torch 2.1+ is installed and model downloaded.")
+    """Silero TTS — code: silero:ru_xenia. v4 model via torch.package.
+    Model lazily load hota hai (self-heal) agar startup thread fail hua ho."""
     import numpy as np, scipy.io.wavfile as wav
     try:
         import torch
@@ -331,20 +376,23 @@ def synthesize_silero(text: str, voice_code: str) -> bytes:
     # Validate speaker — only real v4 speakers allowed
     valid_speakers = set(SILERO_SPEAKERS_RU)
     if speaker not in valid_speakers:
-        raise Exception(f"Invalid Silero speaker '{speaker}'. Valid speakers: {', '.join(valid_speakers)}")
+        raise Exception(f"Invalid Silero speaker '{speaker}'. Valid: {', '.join(valid_speakers)}")
 
+    # Model on-demand load (self-heals if startup thread failed / was slow)
     if lang not in SILERO_MODELS:
-        model_path = download_silero_model()
-        if not model_path:
-            raise Exception("Silero v4 model could not be downloaded.")
-        import torch
-        model = torch.package.PackageImporter(model_path).load_pickle("tts_models", "model")
-        SILERO_MODELS[lang] = model
-        SILERO_READY = True
+        with SILERO_LOAD_LOCK:
+            if lang not in SILERO_MODELS:
+                model_path = download_silero_model()
+                if not model_path:
+                    raise Exception("Silero v4 model could not be downloaded (check network / model URL).")
+                model = torch.package.PackageImporter(model_path).load_pickle("tts_models", "model")
+                SILERO_MODELS[lang] = model
+                global SILERO_READY
+                SILERO_READY = True
 
     model = SILERO_MODELS[lang]
     audio = model.apply_tts(text=text, speaker=speaker, sample_rate=SILERO_SAMPLE_RATE)
-    audio_np = audio.numpy() if hasattr(audio, 'numpy') else audio.cpu().detach().numpy()
+    audio_np = audio.numpy() if hasattr(audio, "numpy") else audio.cpu().detach().numpy()
 
     buf = io.BytesIO()
     wav.write(buf, SILERO_SAMPLE_RATE, (audio_np * 32767).astype(np.int16))
@@ -398,16 +446,28 @@ async def synthesize_edge(
     rate: str = "+0%",
     volume: str = "+0%",
     pitch: str = "+0Hz",
+    style: str = None,
+    styledegree: str = None,
 ) -> bytes:
     import edge_tts
     chunks = split_text(text)
     audio_parts = []
+    kwargs = {"rate": rate, "volume": volume, "pitch": pitch}
+    if style and style != "Default" and style != "General":
+        kwargs["style"] = style
+    if styledegree is not None:
+        try:
+            sd = float(styledegree)
+            if 0.0 <= sd <= 2.0:
+                kwargs["styledegree"] = styledegree
+        except Exception:
+            pass
     for chunk in chunks:
         final_data = None
         for attempt in range(3):
-            data = bytearray()  # M2 FIX: Reset buffer on each retry
+            data = bytearray()
             try:
-                comm = edge_tts.Communicate(chunk, voice, rate=rate, volume=volume, pitch=pitch)
+                comm = edge_tts.Communicate(chunk, voice, **kwargs)
                 async for packet in comm.stream():
                     if packet["type"] == "audio" and packet.get("data"):
                         data.extend(packet["data"])
@@ -424,39 +484,9 @@ async def synthesize_edge(
     return _ffmpeg_concat_mp3(audio_parts)
 
 
-def synthesize_gtts(text: str, lang: str) -> bytes:
-    from gtts import gTTS
-    chunks = split_text(text, max_chars=4200)
-    buf = io.BytesIO()
-    if len(chunks) == 1:
-        gTTS(text=chunks[0], lang=lang, slow=False).write_to_fp(buf)
-        buf.seek(0)
-        return buf.read()
-    # Multiple chunks — write to temp files and merge via ffmpeg
-    parts = []
-    for chunk in chunks:
-        tmp = tempfile.NamedTemporaryFile(suffix=".mp3", delete=False)
-        gTTS(text=chunk, lang=lang, slow=False).save(tmp.name)
-        tmp.close()
-        parts.append(tmp.name)
-    # Read all chunk bytes
-    chunk_bytes = [open(p, "rb").read() for p in parts]
-    combined = _ffmpeg_concat_mp3(chunk_bytes)
-    for p in parts:
-        try:
-            os.unlink(p)
-        except Exception:
-            pass
-    return combined
-
-
-# ══════════════════════════════════════════════════════════════════
-# ROUTES
-# ══════════════════════════════════════════════════════════════════
-
 @app.get("/")
 def root():
-    return {"status": "VoiceCraft TTS Server ✅", "engines": ["edge", "gtts", "piper", "silero"]}
+    return {"status": "VoiceCraft TTS Server OK", "engines": ["edge", "piper", "silero"]}
 
 
 @app.get("/health")
@@ -467,14 +497,14 @@ def health():
         "piper_ready": PIPER_READY,
         "silero_ready": SILERO_READY,
         "silero_speakers": SILERO_SPEAKERS_RU,
-        "engines": ["edge", "gtts", "piper", "silero"],
+        "engines": ["edge", "piper", "silero"],
     }
 
 
 @app.get("/all_voices")
 async def all_voices_list():
-    """All voices — Edge (400+) + Piper (900+) + gTTS (60+)"""
-    result = {"edge": {}, "piper": {}, "gtts": {}, "silero": {}}
+    """All voices — Edge (400+) + Piper (900+) + Silero (12 RU)"""
+    result = {"edge": {}, "piper": {}, "silero": {}}
 
     # Edge TTS — 400+ voices (complete list, clean naming)
     try:
@@ -519,6 +549,8 @@ async def all_voices_list():
                 lang_code = dash_parts[0].replace("_", "-")
                 voice = dash_parts[1].replace("_", " ").title()
                 quality = dash_parts[2]
+                if quality in ("low", "x_low"):
+                    continue
                 quality_map = {"high": " +", "medium": "", "low": " -", "x_low": " --"}
                 qs = quality_map.get(quality, " -")
                 display = f"{voice} [{lang_code}]{qs}"
@@ -531,27 +563,6 @@ async def all_voices_list():
         for key in PIPER_VOICES:
             result["piper"][key] = key  # voice code as string, not tuple
 
-    # gTTS — 60+ languages (complete)
-    GTTS_LANGS = {
-        "af":"Afrikaans","am":"Amharic","ar":"Arabic","bg":"Bulgarian","bn":"Bengali",
-        "bs":"Bosnian","ca":"Catalan","cs":"Czech","cy":"Welsh","da":"Danish",
-        "de":"German","el":"Greek","en":"English","es":"Spanish","et":"Estonian",
-        "eu":"Basque","fi":"Finnish","fr":"French","fr-CA":"French (Canada)","gl":"Galician",
-        "gu":"Gujarati","ha":"Hausa","hi":"Hindi","hr":"Croatian","hu":"Hungarian",
-        "id":"Indonesian","is":"Icelandic","it":"Italian","iw":"Hebrew","ja":"Japanese",
-        "jw":"Javanese","km":"Khmer","kn":"Kannada","ko":"Korean","la":"Latin",
-        "lt":"Lithuanian","lv":"Latvian","ml":"Malayalam","mr":"Marathi","ms":"Malay",
-        "my":"Myanmar","ne":"Nepali","nl":"Dutch","no":"Norwegian","pa":"Punjabi",
-        "pl":"Polish","pt":"Portuguese","pt-PT":"Portuguese (Portugal)","ro":"Romanian",
-        "ru":"Russian","si":"Sinhala","sk":"Slovak","sq":"Albanian","sr":"Serbian",
-        "su":"Sundanese","sv":"Swedish","sw":"Swahili","ta":"Tamil","te":"Telugu",
-        "th":"Thai","tl":"Filipino","tr":"Turkish","uk":"Ukrainian","ur":"Urdu",
-        "vi":"Vietnamese","yue":"Cantonese","zh":"Chinese","zh-CN":"Chinese (Simplified)",
-        "zh-TW":"Chinese (Traditional)"
-    }
-    for code, name in GTTS_LANGS.items():
-        result["gtts"][f"{name} [{code}]"] = f"google:{code}"
-
     # Silero v4 — Russian (12 speakers)
     silero_ru_speakers = {
         "xenia": "Xenia", "eugene": "Eugene", "baya": "Baya", "kseniya": "Kseniya",
@@ -561,20 +572,22 @@ async def all_voices_list():
     for speaker_code, display_name in silero_ru_speakers.items():
         result["silero"][f"{display_name} \u2022 Russian [RU]"] = f"silero:ru_{speaker_code}"
 
-    total = len(result["edge"]) + len(result["piper"]) + len(result["gtts"]) + len(result.get("silero", {}))
+    total = len(result["edge"]) + len(result["piper"]) + len(result.get("silero", {}))
     return {"voices": result, "total": total}
 
 
 @app.post("/tts")
 async def tts_endpoint(
     request: Request,
-    engine:  str = Form(...),   # "edge" | "gtts" | "piper"
+    engine:  str = Form(...),   # "edge" | "piper" | "silero"
     text:    str = Form(...),
-    voice:   str = Form("en-US-AvaNeural"),   # edge voice code OR gtts lang OR piper code
+    voice:   str = Form("en-US-AvaNeural"),   # edge voice code OR piper/silero code
     rate:    str = Form("+0%"),               # edge only
     volume:  str = Form("+0%"),               # edge only
     pitch:   str = Form("+0Hz"),              # edge only
     speed:   float = Form(1.0),              # piper only
+    style:   str = Form(None),               # edge style (emotion)
+    styledegree: str = Form(None),           # edge style degree 0-2
 ):
     verify_token(request)
 
@@ -585,16 +598,10 @@ async def tts_endpoint(
 
     try:
         if engine == "edge":
-            audio = await synthesize_edge(text, voice, rate=rate, volume=volume, pitch=pitch)
+            audio = await synthesize_edge(text, voice, rate=rate, volume=volume, pitch=pitch, style=style, styledegree=styledegree)
             media = "audio/mpeg"
             fname = "tts_edge.mp3"
 
-        elif engine == "gtts":
-            lang = voice if ":" not in voice else voice.split(":", 1)[1]
-            audio = synthesize_gtts(text, lang)
-            media = "audio/mpeg"
-            fname = "tts_gtts.mp3"
-
         elif engine == "piper":
             audio = synthesize_piper(text, voice, speed=speed)
             media = "audio/wav"
@@ -618,5 +625,5 @@ async def tts_endpoint(
         logging.error(f"TTS error: {e}", exc_info=True)
         return JSONResponse(
             status_code=500,
-            content={"error": "Synthesis failed. Please try again."},
+            content={"error": f"Synthesis failed: {str(e)[:240]}"},
         )

requirements.txt

@@ -1,10 +1,8 @@
 fastapi
 uvicorn
 edge-tts
-gTTS
 python-multipart
 requests
 numpy<2
 scipy
-omegaconf
-soundfile
+torch==2.1.2