Upload 3 files

Dockerfile

@@ -3,9 +3,9 @@ FROM python:3.10-slim
 # System tools
 RUN apt-get update && apt-get install -y \
     ffmpeg \
-    wget \
-    curl \
-    build-essential \
+    libsndfile1 \
+    libnss3 libnspr4 libatk-bridge2.0-0 libdrm2 libxkbcommon0 libxcomposite1 \
+    libxdamage1 libxrandr2 libgbm1 libpango-1.0-0 libcairo2 libasound2 \
     && rm -rf /var/lib/apt/lists/*
 
 WORKDIR /app
@@ -13,9 +13,10 @@ 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 remaining Python deps + Playwright for vocalize.fm
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
+RUN pip install --no-cache-dir playwright && playwright install chromium --with-deps
 
 # Copy app
 COPY app.py .

app.py

@@ -1,4 +1,4 @@
-import os, io, asyncio, tempfile, threading, re, time, subprocess, shutil, logging
+import os, io, asyncio, tempfile, threading, re, time, subprocess, shutil, logging, secrets
 from fastapi import FastAPI, Form, Request, HTTPException
 from fastapi.responses import StreamingResponse, JSONResponse
 from fastapi.middleware.gzip import GZipMiddleware
@@ -17,7 +17,7 @@ def verify_token(request: Request):
         logging.warning("⚠️ API_SECRET not set — rejecting request")
         raise HTTPException(status_code=503, detail="Server not configured")
     token = request.headers.get("X-API-Token", "")
-    if token != API_SECRET:
+    if not secrets.compare_digest(token, API_SECRET):
         raise HTTPException(status_code=403, detail="Unauthorized")
 
 # ══════════════════════════════════════════════════════════════════
@@ -110,18 +110,22 @@ def download_piper_model(voice_code: str) -> tuple:
     json_path  = os.path.join(PIPER_MODELS_DIR, json_file)
 
     import urllib.request
-    lang_prefix = onnx_file.split("-")[0].replace("_", "/")  # en_US → en/en_US
-    lang_dir    = lang_prefix.split("/")[0]
+    # Build correct HF path: en/en_US/amy/medium/en_US-amy-medium.onnx
+    parts = onnx_file.rsplit("-", 2)
+    lang_code = parts[0]  # en_US
+    voice     = parts[1]  # amy
+    quality   = parts[2].replace(".onnx", "")  # medium
+    lang_short = lang_code.split("_")[0]  # en
+    hf_dir = f"{lang_short}/{lang_code}/{voice}/{quality}"
 
     for fname, fpath in [(onnx_file, onnx_path), (json_file, json_path)]:
         if not os.path.exists(fpath):
-            url = f"{PIPER_BASE_URL}/{lang_dir}/{lang_prefix}/{fname}"
+            url = f"{PIPER_BASE_URL}/{hf_dir}/{fname}"
             print(f"📥 Downloading Piper model: {fname}")
             try:
                 urllib.request.urlretrieve(url, fpath)
             except Exception:
-                # Fallback URL pattern
-                url2 = f"{PIPER_BASE_URL}/{lang_dir}/{onnx_file.rsplit('-',1)[0]}/{fname}"
+                url2 = f"{PIPER_BASE_URL}/{lang_short}/{lang_code}/{fname}"
                 urllib.request.urlretrieve(url2, fpath)
     return onnx_path, json_path
 
@@ -129,6 +133,9 @@ def download_piper_model(voice_code: str) -> tuple:
 def download_piper_dynamic(voice_code: str) -> tuple:
     """Dynamic Piper voice download — code format: piper:ar_JO-kareem-low"""
     model_name = voice_code.replace("piper:", "")  # ar_JO-kareem-low
+    # Prevent path traversal
+    if ".." in model_name or "/" in model_name or "\\" in model_name:
+        raise ValueError(f"Invalid voice code: {voice_code}")
     onnx_file = f"{model_name}.onnx"
     json_file = f"{model_name}.onnx.json"
     onnx_path = os.path.join(PIPER_MODELS_DIR, onnx_file)
@@ -307,14 +314,21 @@ 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.")
     import numpy as np, scipy.io.wavfile as wav
+    try:
+        import torch
+    except ImportError:
+        raise Exception("Silero TTS requires torch. Install: pip install torch==2.1.2")
 
     lang_speaker = voice_code.replace("silero:", "")
     lang = lang_speaker.split("_")[0]
     speaker = lang_speaker.split("_", 1)[1] if "_" in lang_speaker else lang_speaker
 
     # Validate speaker — only real v4 speakers allowed
-    valid_speakers = ["xenia", "eugene", "baya", "kseniya", "aidar", "random"]
+    valid_speakers = set(SILERO_SPEAKERS_RU)
     if speaker not in valid_speakers:
         raise Exception(f"Invalid Silero speaker '{speaker}'. Valid speakers: {', '.join(valid_speakers)}")
 
@@ -337,6 +351,107 @@ def synthesize_silero(text: str, voice_code: str) -> bytes:
     return buf.read()
 
 
+# ══════════════════════════════════════════════════════════════════
+# VOCALIZE.FM TTS — Free AI voices via Playwright browser automation
+# ══════════════════════════════════════════════════════════════════
+VOCALIZE_VOICES = {
+    "17889":   {"name": "Marcus (ElevenLabs)", "gender": "male"},
+    "3228":    {"name": "Adam (ElevenLabs)", "gender": "male"},
+    "26343":   {"name": "Adam v2 (ElevenLabs)", "gender": "male"},
+    "1229":    {"name": "Male 1 (TikTok)", "gender": "male"},
+    "rachel":  {"name": "Rachel (ElevenLabs)", "gender": "female"},
+    "bella":   {"name": "Bella (ElevenLabs)", "gender": "female"},
+    "elli":    {"name": "Elli (ElevenLabs)", "gender": "female"},
+}
+
+VOCALIZE_BASE = "https://www.vocalize.fm"
+
+
+async def synthesize_vocalize(text: str, voice_code: str) -> bytes:
+    """Vocalize.fm TTS using Playwright — code: vocalize:17889"""
+    voice_id = voice_code.replace("vocalize:", "")
+    if voice_id not in VOCALIZE_VOICES:
+        raise Exception(f"Unknown vocalize voice: {voice_id}")
+
+    try:
+        from playwright.async_api import async_playwright
+    except ImportError:
+        raise Exception("Vocalize.fm requires playwright. Run: pip install playwright && playwright install chromium")
+
+    async with async_playwright() as p:
+        browser = await p.chromium.launch(headless=True, args=["--no-sandbox", "--disable-dev-shm-usage"])
+        page = await browser.new_page()
+        try:
+            await page.goto(f"{VOCALIZE_BASE}/voices/{voice_id}", wait_until="networkidle", timeout=30000)
+            # Try TTS tab / text input
+            textareas = await page.query_selector_all("textarea")
+            if textareas:
+                await textareas[0].fill(text)
+            else:
+                await page.fill("input[type='text']", text)
+            # Click convert/generate button
+            buttons = await page.query_selector_all("button")
+            for btn in buttons:
+                btn_text = (await btn.inner_text()).lower()
+                if "convert" in btn_text or "generate" in btn_text or "speak" in btn_text:
+                    await btn.click()
+                    break
+            else:
+                await page.keyboard.press("Enter")
+            # Wait for audio element
+            await page.wait_for_selector("audio", timeout=60000)
+            await asyncio.sleep(2)
+            audio_url = await page.eval_on_selector("audio", "el => el.src")
+            if not audio_url:
+                raise Exception("No audio generated")
+            import requests as _r
+            resp = _r.get(audio_url, timeout=60, headers={"User-Agent": "VoiceCraft/3.0"})
+            resp.raise_for_status()
+            return resp.content
+        finally:
+            await browser.close()
+
+
+def _ffmpeg_concat_mp3(parts: list) -> bytes:
+    """Merge multiple MP3 byte chunks using ffmpeg concat."""
+    if len(parts) == 1:
+        return parts[0]
+    tmp_files = []
+    concat_list = None
+    out_path = None
+    try:
+        for data in parts:
+            fd, path = tempfile.mkstemp(suffix=".mp3")
+            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=".mp3")
+        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
+        if concat_list:
+            try: os.unlink(concat_list)
+            except Exception: pass
+        if out_path:
+            try: os.unlink(out_path)
+            except Exception: pass
+
+
 async def synthesize_edge(
     text: str,
     voice: str,
@@ -366,7 +481,7 @@ async def synthesize_edge(
         audio_parts.append(final_data if final_data else b"")
     if len(audio_parts) == 1:
         return audio_parts[0]
-    return b"".join(audio_parts)
+    return _ffmpeg_concat_mp3(audio_parts)
 
 
 def synthesize_gtts(text: str, lang: str) -> bytes:
@@ -377,14 +492,16 @@ def synthesize_gtts(text: str, lang: str) -> bytes:
         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
+    # 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)
-    combined = b"".join(open(p, "rb").read() for p in parts)
+    # 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)
@@ -399,7 +516,7 @@ def synthesize_gtts(text: str, lang: str) -> bytes:
 
 @app.get("/")
 def root():
-    return {"status": "VoiceCraft TTS Server ✅", "engines": ["edge", "gtts", "piper", "silero"]}
+    return {"status": "VoiceCraft TTS Server ✅", "engines": ["edge", "gtts", "piper", "silero", "vocalize"]}
 
 
 @app.get("/health")
@@ -410,7 +527,7 @@ def health():
         "piper_ready": PIPER_READY,
         "silero_ready": SILERO_READY,
         "silero_speakers": SILERO_SPEAKERS_RU,
-        "engines": ["edge", "gtts", "piper", "silero"],
+        "engines": ["edge", "gtts", "piper", "silero", "vocalize"],
     }
 
 
@@ -440,13 +557,13 @@ async def edge_voices_list():
             result[f"{name} [{region}]"] = short
         return {"voices": result}
     except Exception as e:
-        return JSONResponse(status_code=500, content={"error": str(e)})
+        return JSONResponse(status_code=500, content={"error": "Failed to list voices"})
 
 
 @app.get("/all_voices")
 async def all_voices_list():
     """All voices — Edge (400+) + Piper (900+) + gTTS (60+)"""
-    result = {"edge": {}, "piper": {}, "gtts": {}, "silero": {}}
+    result = {"edge": {}, "piper": {}, "gtts": {}, "silero": {}, "vocalize": {}}
 
     # Edge TTS — 400+ voices (complete list, clean naming)
     try:
@@ -500,8 +617,8 @@ async def all_voices_list():
             result["piper"][display] = full_code
     except Exception as e:
         print(f"Piper dynamic fetch error: {e}")
-        for key, val in PIPER_VOICES.items():
-            result["piper"][key] = val
+        for key in PIPER_VOICES:
+            result["piper"][key] = key  # voice code as string, not tuple
 
     # gTTS — 60+ languages (complete)
     GTTS_LANGS = {
@@ -524,19 +641,24 @@ async def all_voices_list():
     for code, name in GTTS_LANGS.items():
         result["gtts"][f"{name} [{code}]"] = f"google:{code}"
 
-    # Silero v4 — Russian (6 real speakers only — v4 model confirmed)
+    # Silero v4 — Russian (12 speakers)
     silero_ru_speakers = {
-        "xenia":   "Xenia • Russian • Russian",
-        "eugene":  "Eugene • Russian • Russian",
-        "baya":    "Baya • Russian • Russian",
-        "kseniya": "Kseniya • Russian • Russian",
-        "aidar":   "Aidar • Russian • Russian",
-        "random":  "Random • Russian • Russian",
+        "xenia": "Xenia", "eugene": "Eugene", "baya": "Baya", "kseniya": "Kseniya",
+        "aidar": "Aidar", "kolya": "Kolya", "mikhai": "Mikhai", "nikita": "Nikita",
+        "pavel": "Pavel", "tatiana": "Tatiana", "elena": "Elena", "irina": "Irina",
     }
     for speaker_code, display_name in silero_ru_speakers.items():
-        result["silero"][display_name] = f"silero:ru_{speaker_code}"
+        result["silero"][f"{display_name} \u2022 Russian [RU]"] = f"silero:ru_{speaker_code}"
+
+    # Vocalize.fm voices
+    vocalize_names = {
+        "17889": "Marcus ⚡", "3228": "Adam (Pro)", "26343": "Adam v2",
+        "1229": "Male 1 (TikTok)", "rachel": "Rachel", "bella": "Bella", "elli": "Elli",
+    }
+    for vid, vname in vocalize_names.items():
+        result["vocalize"][f"{vname} \u2022 Vocalize.fm"] = f"vocalize:{vid}"
 
-    total = len(result["edge"]) + len(result["piper"]) + len(result["gtts"]) + len(result.get("silero", {}))
+    total = len(result["edge"]) + len(result["piper"]) + len(result["gtts"]) + len(result.get("silero", {})) + len(result["vocalize"])
     return {"voices": result, "total": total}
 
 
@@ -580,6 +702,11 @@ async def tts_endpoint(
             media = "audio/wav"
             fname = "tts_silero.wav"
 
+        elif engine == "vocalize":
+            audio = await synthesize_vocalize(text, voice)
+            media = "audio/mpeg"
+            fname = "tts_vocalize.mp3"
+
         else:
             return JSONResponse(status_code=400, content={"error": f"Unknown engine: {engine}"})
 
@@ -593,5 +720,5 @@ async def tts_endpoint(
         logging.error(f"TTS error: {e}", exc_info=True)
         return JSONResponse(
             status_code=500,
-            content={"error": f"Synthesis failed: {str(e)[:300]}"},
+            content={"error": "Synthesis failed. Please try again."},
         )

requirements.txt

@@ -8,4 +8,3 @@ numpy<2
 scipy
 omegaconf
 soundfile
-torch