Update app.py

app.py

@@ -1,305 +1,673 @@
-"""
-╔══════════════════════════════════════════════════════════════╗
-║           Indic TTS API — Production Grade                   ║
-║  Models: MMS-TTS (1107 langs) · Indic Parler-TTS · IndicF5  ║
-║  Docs: /docs  |  Redoc: /redoc  |  Health: /health          ║
-╚══════════════════════════════════════════════════════════════╝
-"""
 from __future__ import annotations
 
 import io
-import gc
-import re
-import base64
+import inspect
+import json
 import logging
-import time
+import os
 import threading
-from typing import Optional, List, Dict
+import traceback
+import wave
 from collections import OrderedDict
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
 
-import numpy as np
-import soundfile as sf
-import torch
+import anyio
 import uvicorn
-from fastapi import FastAPI, HTTPException, UploadFile, File, Form
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import StreamingResponse, RedirectResponse
-from pydantic import BaseModel, Field, field_validator
-
-# ──────────────────────────────────────────────────────────────
-# Logging
-# ──────────────────────────────────────────────────────────────
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s │ %(levelname)-8s │ %(name)s │ %(message)s",
-    datefmt="%H:%M:%S",
-)
-logger = logging.getLogger("indic-tts")
+import numpy as np
+from fastapi import Body, FastAPI, HTTPException, Query, Request
+from fastapi.responses import JSONResponse, Response
+from huggingface_hub import hf_hub_download
+from pydantic import BaseModel, Field
+from piper import PiperVoice, SynthesisConfig
 
-# ──────────────────────────────────────────────────────────────
+# -----------------------------------------------------------------------------
 # Config
-# ──────────────────────────────────────────────────────────────
-VERSION           = "1.0.0"
-MAX_TEXT_CHARS    = 5000
-CHUNK_SIZE        = 250
-MODEL_CACHE_SLOTS = 3
-SILENCE_BETWEEN_CHUNKS = 0.25
-
-DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
-logger.info(f"Running on device: {DEVICE}")
-
-# ──────────────────────────────────────────────────────────────
-# Language Tables
-# ──────────────────────────────────────────────────────────────
-MMS_FEATURED = {
-    "hin": "Hindi", "eng": "English", "ben": "Bengali", "tel": "Telugu",
-    "tam": "Tamil", "mar": "Marathi", "guj": "Gujarati", "kan": "Kannada",
-    "mal": "Malayalam", "pan": "Punjabi", "ori": "Odia", "asm": "Assamese",
-}
-
-PARLER_LANGS = {
-    "hin": "Hindi", "eng": "English", "ben": "Bengali", "mar": "Marathi",
-}
-
-PARLER_VOICES = {
-    "neutral_female": "A female speaker delivers neutral, clear speech at a moderate pace with high audio quality.",
-    "neutral_male": "A male speaker delivers neutral, clear speech at a moderate pace with high audio quality.",
-}
-
-# ──────────────────────────────────────────────────────────────
-# Model Cache
-# ──────────────────────────────────────────────────────────────
-class ModelCache:
-    def __init__(self, max_slots: int = MODEL_CACHE_SLOTS):
-        self._cache: OrderedDict = OrderedDict()
-        self._max = max_slots
-        self._lock = threading.Lock()
-
-    def get(self, key: str):
-        with self._lock:
-            if key in self._cache:
-                self._cache.move_to_end(key)
-                return self._cache[key]
-        return None
-
-    def put(self, key: str, value):
-        with self._lock:
-            if key in self._cache:
-                self._cache.move_to_end(key)
-                self._cache[key] = value
-                return
-            while len(self._cache) >= self._max:
-                evicted, _ = self._cache.popitem(last=False)
-                logger.info(f"🗑️  Evicted model from cache: {evicted}")
-                gc.collect()
-                if torch.cuda.is_available():
-                    torch.cuda.empty_cache()
-            self._cache[key] = value
-            logger.info(f"✅  Cached model: {key} ({len(self._cache)}/{self._max} slots used)")
-
-    def loaded(self) -> List[str]:
-        with self._lock:
-            return list(self._cache.keys())
-
-cache = ModelCache()
-
-# ──────────────────────────────────────────────────────────────
-# Model Loaders
-# ──────────────────────────────────────────────────────────────
-def load_mms(lang_code: str) -> dict:
-    from transformers import VitsModel, AutoTokenizer
-    model_id = f"facebook/mms-tts-{lang_code}"
-    logger.info(f"⬇️  Loading MMS-TTS model: {model_id}")
-    
-    # Explicit tokenizer initialization
-    tok = AutoTokenizer.from_pretrained(model_id)
-    mdl = VitsModel.from_pretrained(model_id).to(DEVICE)
-    mdl.eval()
-    return {"model": mdl, "tokenizer": tok, "sr": mdl.config.sampling_rate}
-
-def get_mms(lang_code: str) -> dict:
-    key = f"mms-{lang_code}"
-    hit = cache.get(key)
-    if hit:
-        return hit
-    obj = load_mms(lang_code)
-    cache.put(key, obj)
-    return obj
-
-# ──────────────────────────────────────────────────────────────
-# Text Processing
-# ──────────────────────────────────────────────────────────────
-_SENT_SPLIT = re.compile(r'(?<=[।.!?؟\n])\s*')
-
-def contains_content(text: str) -> bool:
-    """
-    Checks if text contains actual alphanumeric characters.
-    Filters out strings like "???", "   .", or emojis-only.
-    """
-    return bool(re.search(r'[A-Za-z0-9\u0900-\u097F]', text))
-
-def chunk_text(text: str, max_chars: int = CHUNK_SIZE) -> List[str]:
-    text = text.strip()
-    if not text:
-        return []
-
-    sentences = [s.strip() for s in _SENT_SPLIT.split(text) if s.strip()]
-    chunks, current = [], ""
-    for sent in sentences:
-        if not current:
-            current = sent
-        elif len(current) + 1 + len(sent) <= max_chars:
-            current += " " + sent
-        else:
-            chunks.append(current)
-            current = sent
-    if current:
-        chunks.append(current)
-
-    # Post-process: Remove chunks that have no actual letters/numbers
-    valid_chunks = [c for c in chunks if contains_content(c)]
-    
-    # Word-split fallback for very long valid chunks
-    final = []
-    for chunk in valid_chunks:
-        if len(chunk) <= max_chars:
-            final.append(chunk)
-        else:
-            words, acc = chunk.split(), ""
-            for w in words:
-                if len(acc) + 1 + len(w) <= max_chars:
-                    acc = (acc + " " + w).strip()
-                else:
-                    if acc: final.append(acc)
-                    acc = w
-            if acc: final.append(acc)
-            
-    return final
-
-def concat_audio(arrays: List[np.ndarray], sr: int) -> np.ndarray:
-    if not arrays:
-        return np.array([], dtype=np.float32)
-    gap = np.zeros(int(sr * SILENCE_BETWEEN_CHUNKS), dtype=np.float32)
-    parts = []
-    for i, a in enumerate(arrays):
-        parts.append(a.astype(np.float32))
-        if i < len(arrays) - 1:
-            parts.append(gap)
-    return np.concatenate(parts)
-
-def resample_speed(audio: np.ndarray, speed: float) -> np.ndarray:
-    if abs(speed - 1.0) < 0.01:
-        return audio
-    from scipy.signal import resample
-    new_len = max(1, int(len(audio) / speed))
-    return resample(audio, new_len).astype(np.float32)
-
-def encode_wav(audio: np.ndarray, sr: int) -> bytes:
-    buf = io.BytesIO()
-    sf.write(buf, audio, sr, format="WAV", subtype="PCM_16")
-    buf.seek(0)
-    return buf.read()
-
-# ──────────────────────────────────────────────────────────────
-# Synthesis Backends
-# ──────────────────────────────────────────────────────────────
-def synth_mms(text: str, lang: str, speed: float) -> tuple[np.ndarray, int]:
-    c = get_mms(lang)
-    inputs = c["tokenizer"](text, return_tensors="pt").to(DEVICE)
-    
-    if "input_ids" in inputs:
-        inputs["input_ids"] = inputs["input_ids"].long()
-
-    with torch.no_grad():
-        wav = c["model"](**inputs).waveform.squeeze().cpu().numpy()
-    return resample_speed(wav, speed), c["sr"]
-
-# ─────────────────────���────────────────────────────────────────
-# Pydantic Schemas
-# ──────────────────────────────────────────────────────────────
+# -----------------------------------------------------------------------------
+
+LOG = logging.getLogger("piper_api")
+logging.basicConfig(level=os.getenv("LOG_LEVEL", "INFO").upper(), format='%(levelname)s:\t%(message)s')
+
+HF_REPO_ID = os.getenv("PIPER_VOICE_REPO", "rhasspy/piper-voices")
+MODELS_DIR = Path(os.getenv("PIPER_MODELS_DIR", "./piper_models")).resolve()
+MODELS_DIR.mkdir(parents=True, exist_ok=True)
+
+DEFAULT_VOICE = os.getenv("PIPER_DEFAULT_VOICE", "en_US-lessac-medium")
+PRELOAD_VOICES = [
+    v.strip()
+    for v in os.getenv("PIPER_PRELOAD_VOICES", "en_US-lessac-medium,hi_IN-rohan-medium").split(",")
+    if v.strip()
+]
+CACHE_SIZE = max(1, int(os.getenv("PIPER_CACHE_SIZE", "2")))
+USE_CUDA = os.getenv("PIPER_USE_CUDA", "0").strip().lower() in {"1", "true", "yes", "on"}
+DEFAULT_SAMPLE_RATE = int(os.getenv("PIPER_SAMPLE_RATE", "22050"))
+
+# -----------------------------------------------------------------------------
+# Schemas
+# -----------------------------------------------------------------------------
+
+
+class VoiceFile(BaseModel):
+    path: str
+    local_path: Optional[str] = None
+    size_bytes: Optional[int] = None
+    downloaded: bool = False
+
+
+class VoiceInfo(BaseModel):
+    key: str
+    name: str
+    language: Dict[str, Any]
+    quality: str
+    num_speakers: int
+    aliases: List[str] = Field(default_factory=list)
+    files: List[VoiceFile] = Field(default_factory=list)
+    loaded: bool = False
+
+
 class SynthRequest(BaseModel):
-    text: str = Field(..., description="Text to synthesize", max_length=MAX_TEXT_CHARS)
-    model: str = Field("mms-tts", description="TTS model name")
-    language: str = Field("hin", description="ISO 639-3 language code")
-    speed: float = Field(1.0, description="Speed multiplier", ge=0.5, le=2.0)
-    
-    @field_validator("text")
-    @classmethod
-    def validate_text(cls, v):
-        if not v or not v.strip():
-            raise ValueError("text cannot be empty")
-        return v
-
-# ──────────────────────────────────────────────────────────────
-# FastAPI App
-# ──────────────────────────────────────────────────────────────
-app = FastAPI(title="Indic TTS API", version=VERSION)
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
+    text: str = Field(..., min_length=1)
+    voice: Optional[str] = None
+    speaker: Optional[str] = None
+    speaker_id: Optional[int] = None
+    length_scale: Optional[float] = Field(None, gt=0)
+    noise_scale: Optional[float] = Field(None, ge=0)
+    noise_w_scale: Optional[float] = Field(None, ge=0)
+    volume: Optional[float] = Field(None, gt=0)
+    normalize_audio: Optional[bool] = None
+    download: bool = False
+
+
+class DownloadRequest(BaseModel):
+    voice: str
+
+
+class CatalogStats(BaseModel):
+    total_voices: int
+    total_languages: int
+    cached_voices: int
+    cache_size: int
+    default_voice: str
+    cuda_enabled: bool
+
+
+# -----------------------------------------------------------------------------
+# Runtime state
+# -----------------------------------------------------------------------------
+
+
+class RuntimeState:
+    def __init__(self) -> None:
+        self.catalog: Dict[str, Dict[str, Any]] = {}
+        self.alias_map: Dict[str, str] = {}
+        self.loaded_voices: "OrderedDict[str, PiperVoice]" = OrderedDict()
+        self.ready: bool = False
+
+    def canon(self, voice_name: str) -> str:
+        if voice_name in self.catalog:
+            return voice_name
+        if voice_name in self.alias_map:
+            return self.alias_map[voice_name]
+        raise KeyError(voice_name)
+
+    def list_languages(self) -> int:
+        langs = set()
+        for entry in self.catalog.values():
+            lang = entry.get("language", {}) or {}
+            code = lang.get("code")
+            if code:
+                langs.add(code)
+        return len(langs)
+
+
+STATE = RuntimeState()
+_VOICE_LOAD_LOCK = threading.Lock()
+
+# -----------------------------------------------------------------------------
+# Helpers
+# -----------------------------------------------------------------------------
+
+
+def _iter_catalog_files(entry: Dict[str, Any]) -> List[Tuple[str, Dict[str, Any]]]:
+    files = entry.get("files", {})
+
+    if isinstance(files, dict):
+        return [(str(rel_path), meta if isinstance(meta, dict) else {}) for rel_path, meta in files.items()]
+
+    if isinstance(files, list):
+        out: List[Tuple[str, Dict[str, Any]]] = []
+        for item in files:
+            if isinstance(item, dict) and item.get("path"):
+                out.append((str(item["path"]), item))
+        return out
+
+    return []
+
+
+def _download_catalog() -> Dict[str, Dict[str, Any]]:
+    LOG.info(f"Downloading catalog from {HF_REPO_ID}...")
+    catalog_path = hf_hub_download(
+        repo_id=HF_REPO_ID,
+        filename="voices.json",
+        repo_type="model",
+    )
+    with open(catalog_path, "r", encoding="utf-8") as f:
+        raw = json.load(f)
 
-def _run_synthesis(req: SynthRequest) -> tuple[np.ndarray, int, int]:
-    # This logic now relies on chunk_text filtering out empty/punctuation-only chunks
-    chunks = chunk_text(req.text, CHUNK_SIZE)
-    
-    if not chunks:
-        # If after filtering we have nothing, the input was likely only punctuation
-        raise HTTPException(
-            status_code=400, 
-            detail="Input text contains no valid content to synthesize (e.g., only punctuation or spaces)."
-        )
+    if not isinstance(raw, dict):
+        raise RuntimeError("Unexpected voices.json structure")
 
-    audios, sr = [], 16000
-    if req.model == "mms-tts":
-        for ch in chunks:
-            try:
-                a, sr = synth_mms(ch, req.language, req.speed)
-                if a.size > 0:
-                    audios.append(a)
-            except Exception as e:
-                logger.error(f"Error synthesizing chunk: {e}")
-                continue
-                
-    if not audios:
-        raise HTTPException(500, detail="Synthesis failed: No audio generated.")
+    catalog: Dict[str, Dict[str, Any]] = {}
+    alias_map: Dict[str, str] = {}
+
+    for key, entry in raw.items():
+        if not isinstance(entry, dict):
+            continue
+        catalog[key] = entry
+        alias_map[key] = key
+        for alias in entry.get("aliases", []) or []:
+            alias_map[str(alias)] = key
+
+    STATE.catalog = catalog
+    STATE.alias_map = alias_map
+    return catalog
+
+
+def _resolve_voice_name(name: str) -> str:
+    try:
+        return STATE.canon(name)
+    except KeyError as exc:
+        raise HTTPException(status_code=404, detail=f"Unknown voice: {name}") from exc
+
+
+def _ensure_voice_downloaded(voice_key: str) -> Dict[str, str]:
+    entry = STATE.catalog.get(voice_key)
+    if entry is None:
+        raise HTTPException(status_code=404, detail=f"Unknown voice: {voice_key}")
+
+    files = _iter_catalog_files(entry)
+    if not files:
+        raise HTTPException(status_code=500, detail=f"Malformed file list for voice: {voice_key}")
+
+    local_files: Dict[str, str] = {}
+    for rel_path, _meta in files:
+        try:
+            local_path = hf_hub_download(
+                repo_id=HF_REPO_ID,
+                filename=rel_path,
+                repo_type="model",
+                local_dir=str(MODELS_DIR),
+                local_dir_use_symlinks=False,
+            )
+            local_files[rel_path] = local_path
+        except Exception as e:
+            # CRITICAL FIX: Don't hide download errors
+            LOG.error(f"Failed to download {rel_path} for {voice_key}: {e}")
+            raise HTTPException(status_code=500, detail=f"Failed to download model file {rel_path}: {str(e)}")
+
+    return local_files
+
+
+def _voice_model_path(voice_key: str) -> str:
+    local_files = _ensure_voice_downloaded(voice_key)
+    for rel_path, local_path in local_files.items():
+        if rel_path.endswith(".onnx"):
+            return local_path
+    raise HTTPException(status_code=500, detail=f"No ONNX file found for voice: {voice_key}")
+
+
+def _load_voice(voice_key: str) -> PiperVoice:
+    voice_key = _resolve_voice_name(voice_key)
+
+    cached = STATE.loaded_voices.get(voice_key)
+    if cached is not None:
+        STATE.loaded_voices.move_to_end(voice_key)
+        return cached
+
+    with _VOICE_LOAD_LOCK:
+        cached = STATE.loaded_voices.get(voice_key)
+        if cached is not None:
+            return cached
+
+        LOG.info(f"Loading voice: {voice_key}")
         
-    final = concat_audio(audios, sr) if len(audios) > 1 else audios[0]
-    return final, sr, len(chunks)
-
-@app.get("/", include_in_schema=False)
-async def root():
-    return RedirectResponse("/docs")
-
-@app.post("/tts", response_class=StreamingResponse)
-async def text_to_speech(req: SynthRequest):
-    """
-    Synthesize text to speech.
-    Example: {"text": "नमस्ते दुनिया", "model": "mms-tts", "language": "hin"}
-    """
-    t0 = time.perf_counter()
+        # 1. Download/Verify files
+        try:
+            model_path = _voice_model_path(voice_key)
+        except HTTPException:
+            # Re-raise HTTP exceptions (download errors)
+            raise
+        except Exception as e:
+            LOG.error(f"Error finding model path for {voice_key}: {e}")
+            raise HTTPException(status_code=500, detail=f"Error finding model: {str(e)}")
+
+        # 2. Load the Model
+        try:
+            voice = PiperVoice.load(model_path, use_cuda=USE_CUDA)
+        except Exception as e:
+            LOG.error(f"Error loading PiperVoice from {model_path}: {e}")
+            LOG.error(traceback.format_exc())
+            raise HTTPException(status_code=500, detail=f"Failed to load voice model: {str(e)}")
+
+        # 3. Sanity Check: Does the voice actually have a config?
+        # If not, it might be a dummy/corrupted load.
+        if not hasattr(voice, 'config') or voice.config is None:
+             LOG.error(f"Voice {voice_key} loaded but has no config. This usually means files are missing or corrupted.")
+             raise HTTPException(status_code=500, detail=f"Voice {voice_key} is invalid (missing config).")
+
+        STATE.loaded_voices[voice_key] = voice
+        STATE.loaded_voices.move_to_end(voice_key)
+
+        while len(STATE.loaded_voices) > CACHE_SIZE:
+            removed_key, _ = STATE.loaded_voices.popitem(last=False)
+            LOG.info(f"Evicted voice from cache: {removed_key}")
+
+        return voice
+
+
+def _make_synthesis_config(payload: SynthRequest) -> SynthesisConfig:
+    kwargs: Dict[str, Any] = {}
+    sig = inspect.signature(SynthesisConfig)
+    for field_name in ("volume", "length_scale", "noise_scale", "noise_w_scale", "normalize_audio"):
+        value = getattr(payload, field_name)
+        if value is not None and field_name in sig.parameters:
+            kwargs[field_name] = value
+    return SynthesisConfig(**kwargs)
+
+
+def _voice_to_info(voice_key: str) -> VoiceInfo:
+    entry = STATE.catalog[voice_key]
+    files_meta = _iter_catalog_files(entry)
+
+    files: List[VoiceFile] = []
+    for rel_path, meta in files_meta:
+        local_path = (MODELS_DIR / rel_path).resolve()
+        downloaded = local_path.exists()
+
+        size_bytes = meta.get("size_bytes", meta.get("size"))
+        if isinstance(size_bytes, str) and size_bytes.isdigit():
+            size_bytes = int(size_bytes)
+        elif not isinstance(size_bytes, int):
+            size_bytes = None
+
+        files.append(
+            VoiceFile(
+                path=rel_path,
+                local_path=str(local_path) if downloaded else None,
+                size_bytes=size_bytes,
+                downloaded=downloaded,
+            )
+        )
+
+    return VoiceInfo(
+        key=entry.get("key", voice_key),
+        name=entry.get("name", ""),
+        language=entry.get("language", {}),
+        quality=entry.get("quality", ""),
+        num_speakers=int(entry.get("num_speakers", 1)),
+        aliases=list(entry.get("aliases", []) or []),
+        files=files,
+        loaded=voice_key in STATE.loaded_voices,
+    )
+
+
+def _guess_sample_rate(voice: Any, entry: Optional[Dict[str, Any]] = None) -> int:
+    if entry:
+        for key in ("sample_rate", "audio_sample_rate", "rate"):
+            val = entry.get(key)
+            if isinstance(val, (int, float)) and val > 0:
+                return int(val)
+
+    for attr in ("sample_rate",):
+        val = getattr(voice, attr, None)
+        if isinstance(val, (int, float)) and val > 0:
+            return int(val)
+
+    cfg = getattr(voice, "config", None)
+    if cfg is not None:
+        val = getattr(cfg, "sample_rate", None)
+        if isinstance(val, (int, float)) and val > 0:
+            return int(val)
+
+    return DEFAULT_SAMPLE_RATE
+
+
+def _choose_speaker_kwargs(payload: SynthRequest, synth_sig: inspect.Signature) -> Dict[str, Any]:
+    kwargs: Dict[str, Any] = {}
+    if payload.speaker_id is not None and "speaker_id" in synth_sig.parameters:
+        kwargs["speaker_id"] = payload.speaker_id
+    elif payload.speaker is not None and "speaker" in synth_sig.parameters:
+        kwargs["speaker"] = payload.speaker
+    return kwargs
+
+
+def _synthesize_wav_bytes(voice_key: str, payload: SynthRequest) -> bytes:
+    voice = _load_voice(voice_key)
+    syn_config = _make_synthesis_config(payload)
+
+    synth_sig = inspect.signature(voice.synthesize)
+    synth_kwargs = _choose_speaker_kwargs(payload, synth_sig)
+
+    gen = None
+    if "syn_config" in synth_sig.parameters:
+        gen = voice.synthesize(payload.text, syn_config=syn_config, **synth_kwargs)
+    elif "synthesis_config" in synth_sig.parameters:
+        gen = voice.synthesize(payload.text, synthesis_config=syn_config, **synth_kwargs)
+    else:
+        gen = voice.synthesize(payload.text, **synth_kwargs)
+
+    chunks = []
+    try:
+        for chunk in gen:
+            chunks.append(chunk)
+    except Exception as e:
+        LOG.error(f"Error during synthesis generation: {e}")
+        LOG.error(traceback.format_exc())
+        raise HTTPException(status_code=500, detail=f"Synthesis generator failed: {str(e)}")
+
+    if not chunks:
+        # This specific error usually means the voice loaded but is invalid
+        LOG.error(f"Synthesis produced no audio for voice {voice_key}. Text: '{payload.text}'")
+        raise HTTPException(status_code=500, detail="Piper returned no audio chunks. The voice model may be missing or corrupted.")
+
+    first = chunks[0]
+    sample_rate = int(getattr(first, "sample_rate", None) or _guess_sample_rate(voice, STATE.catalog.get(voice_key, {})))
+    sample_width = int(getattr(first, "sample_width", None) or 2)
+    sample_channels = int(getattr(first, "sample_channels", None) or 1)
+
+    for chunk in chunks:
+        if int(getattr(chunk, "sample_rate", sample_rate) or sample_rate) != sample_rate:
+            raise HTTPException(status_code=500, detail="Inconsistent sample_rate across Piper chunks.")
+        if int(getattr(chunk, "sample_width", sample_width) or sample_width) != sample_width:
+            raise HTTPException(status_code=500, detail="Inconsistent sample_width across Piper chunks.")
+        if int(getattr(chunk, "sample_channels", sample_channels) or sample_channels) != sample_channels:
+            raise HTTPException(status_code=500, detail="Inconsistent sample_channels across Piper chunks.")
+
+    buf = io.BytesIO()
+    try:
+        with wave.open(buf, "wb") as wav_file:
+            wav_file.setnchannels(sample_channels)
+            wav_file.setsampwidth(sample_width)
+            wav_file.setframerate(sample_rate)
+            wav_file.setcomptype("NONE", "not compressed")
+
+            for chunk in chunks:
+                audio_bytes = getattr(chunk, "audio_int16_bytes", None)
+                if audio_bytes is None:
+                    raw_audio = getattr(chunk, "audio", None)
+                    if raw_audio is not None:
+                        if hasattr(raw_audio, 'astype'):
+                            if raw_audio.dtype != np.int16:
+                                raw_audio = (raw_audio * 32767).astype(np.int16)
+                            audio_bytes = raw_audio.tobytes()
+                        else:
+                            audio_bytes = bytes(raw_audio)
+                    else:
+                        raise HTTPException(status_code=500, detail="Audio chunk missing audio data")
+
+                wav_file.writeframes(audio_bytes)
+    except Exception as e:
+        LOG.error(f"Error writing WAV: {e}")
+        LOG.error(traceback.format_exc())
+        raise HTTPException(status_code=500, detail=f"WAV encoding failed: {str(e)}")
+
+    wav_bytes = buf.getvalue()
+    if len(wav_bytes) < 44 or not wav_bytes.startswith(b"RIFF"):
+        raise HTTPException(status_code=500, detail="Synthesis produced an invalid WAV payload.")
+    return wav_bytes
+
+
+async def _startup() -> None:
     try:
-        audio, sr, n_chunks = _run_synthesis(req)
-    except HTTPException:
+        LOG.info("Starting application...")
+        await anyio.to_thread.run_sync(_download_catalog, limiter=None)
+
+        preload_candidates = [DEFAULT_VOICE] + [v for v in PRELOAD_VOICES if v != DEFAULT_VOICE]
+        seen = set()
+
+        for voice_name in preload_candidates:
+            if not voice_name or voice_name in seen:
+                continue
+            seen.add(voice_name)
+            try:
+                await anyio.to_thread.run_sync(_load_voice, voice_name, limiter=None)
+            except HTTPException as exc:
+                # CRITICAL FIX: Log the full detail of why it failed
+                LOG.error(f"FATAL: Failed to preload voice '{voice_name}'. Reason: {exc.detail}")
+                # Depending on your preference, you might want to raise here to stop the app
+                # raise exc 
+            except Exception as exc:
+                LOG.error(f"FATAL: Unexpected error preloading voice '{voice_name}': {exc}")
+                LOG.error(traceback.format_exc())
+                # raise exc
+
+        STATE.ready = True
+        LOG.info(f"Piper API ready with {len(STATE.catalog)} voices ({STATE.list_languages()} languages).")
+    except Exception:
+        LOG.exception("Startup failed")
         raise
-    except Exception as exc:
-        logger.exception("Synthesis error")
-        raise HTTPException(500, detail=str(exc)) from exc
-
-    wav_bytes = encode_wav(audio, sr)
-    elapsed = time.perf_counter() - t0
-
-    return StreamingResponse(
-        io.BytesIO(wav_bytes),
-        media_type="audio/wav",
-        headers={
-            "Content-Disposition": 'attachment; filename="speech.wav"',
-            "X-Processing-Time": str(round(elapsed, 3)),
-        },
+
+
+async def _shutdown() -> None:
+    STATE.loaded_voices.clear()
+    LOG.info("Application shutdown.")
+
+
+@asynccontextmanager
+async def lifespan(_: FastAPI):
+    await _startup()
+    try:
+        yield
+    finally:
+        await _shutdown()
+
+
+app = FastAPI(
+    title="Piper TTS API",
+    version="1.0.0",
+    description="FastAPI wrapper for Piper TTS with automatic Hugging Face voice download and OpenAPI docs.",
+    lifespan=lifespan,
+)
+
+# -----------------------------------------------------------------------------
+# Routes
+# -----------------------------------------------------------------------------
+
+
+@app.get("/")
+async def root() -> Dict[str, Any]:
+    return {
+        "name": "Piper TTS API",
+        "ready": STATE.ready,
+        "default_voice": DEFAULT_VOICE,
+        "docs": "/docs",
+        "health": "/health",
+        "voices": "/voices",
+        "synthesize": "/synthesize",
+    }
+
+
+@app.get("/health", tags=["system"])
+async def health() -> Dict[str, Any]:
+    return {
+        "ready": STATE.ready,
+        "cached_voices": list(STATE.loaded_voices.keys()),
+        "cache_size": CACHE_SIZE,
+        "default_voice": DEFAULT_VOICE,
+        "cuda_enabled": USE_CUDA,
+    }
+
+
+@app.get("/stats", response_model=CatalogStats, tags=["system"])
+async def stats() -> CatalogStats:
+    return CatalogStats(
+        total_voices=len(STATE.catalog),
+        total_languages=STATE.list_languages(),
+        cached_voices=len(STATE.loaded_voices),
+        cache_size=CACHE_SIZE,
+        default_voice=DEFAULT_VOICE,
+        cuda_enabled=USE_CUDA,
+    )
+
+
+@app.get("/voices", response_model=List[VoiceInfo], tags=["voices"])
+async def list_voices(
+    language: Optional[str] = Query(None),
+    quality: Optional[str] = Query(None),
+    loaded_only: bool = Query(False),
+) -> List[VoiceInfo]:
+    voices: List[VoiceInfo] = []
+    for key, entry in STATE.catalog.items():
+        if loaded_only and key not in STATE.loaded_voices:
+            continue
+        lang = entry.get("language", {}) or {}
+        if language and lang.get("code") != language:
+            continue
+        if quality and entry.get("quality") != quality:
+            continue
+        voices.append(_voice_to_info(key))
+    return voices
+
+
+@app.get("/voices/{voice_name}", response_model=VoiceInfo, tags=["voices"])
+async def get_voice(voice_name: str) -> VoiceInfo:
+    return _voice_to_info(_resolve_voice_name(voice_name))
+
+
+@app.post("/voices/download", response_model=VoiceInfo, tags=["voices"])
+async def download_voice(payload: DownloadRequest = Body(...)) -> VoiceInfo:
+    voice_key = _resolve_voice_name(payload.voice)
+    await anyio.to_thread.run_sync(_ensure_voice_downloaded, voice_key, limiter=None)
+    return _voice_to_info(voice_key)
+
+
+@app.post("/synthesize", tags=["synthesis"], responses={200: {"content": {"audio/wav": {}}}})
+async def synthesize(payload: SynthRequest = Body(...)) -> Response:
+    voice_key = _resolve_voice_name(payload.voice or DEFAULT_VOICE)
+    wav_bytes = await anyio.to_thread.run_sync(_synthesize_wav_bytes, voice_key, payload, limiter=None)
+
+    headers = {}
+    if payload.download:
+        headers["Content-Disposition"] = f'attachment; filename="{voice_key}.wav"'
+    return Response(content=wav_bytes, media_type="audio/wav", headers=headers)
+
+
+@app.get("/synthesize", tags=["synthesis"], responses={200: {"content": {"audio/wav": {}}}})
+async def synthesize_get(
+    text: str = Query(..., min_length=1),
+    voice: Optional[str] = Query(None),
+    speaker: Optional[str] = Query(None),
+    speaker_id: Optional[int] = Query(None),
+    length_scale: Optional[float] = Query(None, gt=0),
+    noise_scale: Optional[float] = Query(None, ge=0),
+    noise_w_scale: Optional[float] = Query(None, ge=0),
+    volume: Optional[float] = Query(None, gt=0),
+    normalize_audio: Optional[bool] = Query(None),
+) -> Response:
+    payload = SynthRequest(
+        text=text,
+        voice=voice,
+        speaker=speaker,
+        speaker_id=speaker_id,
+        length_scale=length_scale,
+        noise_scale=noise_scale,
+        noise_w_scale=noise_w_scale,
+        volume=volume,
+        normalize_audio=normalize_audio,
+        download=False,
+    )
+    return await synthesize(payload)
+
+
+@app.post("/tts", tags=["synthesis"], responses={200: {"content": {"audio/wav": {}}}})
+async def tts(payload: SynthRequest = Body(...)) -> Response:
+    return await synthesize(payload)
+
+
+@app.get("/tts", tags=["synthesis"], responses={200: {"content": {"audio/wav": {}}}})
+async def tts_get(
+    text: str = Query(..., min_length=1),
+    voice: Optional[str] = Query(None),
+    speaker: Optional[str] = Query(None),
+    speaker_id: Optional[int] = Query(None),
+    length_scale: Optional[float] = Query(None, gt=0),
+    noise_scale: Optional[float] = Query(None, ge=0),
+    noise_w_scale: Optional[float] = Query(None, ge=0),
+    volume: Optional[float] = Query(None, gt=0),
+    normalize_audio: Optional[bool] = Query(None),
+) -> Response:
+    return await synthesize_get(
+        text=text,
+        voice=voice,
+        speaker=speaker,
+        speaker_id=speaker_id,
+        length_scale=length_scale,
+        noise_scale=noise_speed,
+        noise_w_scale=noise_w_scale,
+        volume=volume,
+        normalize_audio=normalize_audio,
+    )
+
+
+@app.post("/tts/stream", tags=["synthesis"], responses={200: {"content": {"audio/wav": {}}}})
+async def tts_stream(payload: SynthRequest = Body(...)) -> Response:
+    return await synthesize(payload)
+
+
+@app.get("/tts/stream", tags=["synthesis"], responses={200: {"content": {"audio/wav": {}}}})
+async def tts_stream_get(
+    text: str = Query(..., min_length=1),
+    voice: Optional[str] = Query(None),
+    speaker: Optional[str] = Query(None),
+    speaker_id: Optional[int] = Query(None),
+    length_scale: Optional[float] = Query(None, gt=0),
+    noise_scale: Optional[float] = Query(None, ge=0),
+    noise_w_scale: Optional[float] = Query(None, ge=0),
+    volume: Optional[float] = Query(None, gt=0),
+    normalize_audio: Optional[bool] = Query(None),
+) -> Response:
+    return await synthesize_get(
+        text=text,
+        voice=voice,
+        speaker=speaker,
+        speaker_id=speaker_id,
+        length_scale=length_scale,
+        noise_scale=noise_scale,
+        noise_w_scale=noise_w_scale,
+        volume=volume,
+        normalize_audio=normalize_audio,
     )
 
+
+@app.post("/reload", tags=["system"])
+async def reload_catalog() -> Dict[str, Any]:
+    await anyio.to_thread.run_sync(_download_catalog, limiter=None)
+    return {
+        "ok": True,
+        "total_voices": len(STATE.catalog),
+        "total_languages": STATE.list_languages(),
+    }
+
+
+@app.exception_handler(HTTPException)
+async def http_exception_handler(_request: Request, exc: HTTPException):
+    LOG.warning(f"HTTP Exception: {exc.status_code} - {exc.detail}")
+    return JSONResponse(status_code=exc.status_code, content={"detail": exc.detail})
+
+
+@app.exception_handler(Exception)
+async def unhandled_exception_handler(_request: Request, exc: Exception):
+    LOG.error("Unhandled Exception occurred")
+    LOG.error(traceback.format_exc())
+    return JSONResponse(status_code=500, content={"detail": f"{type(exc).__name__}: {exc}"})
+
+
 if __name__ == "__main__":
-    uvicorn.run("app:app", host="0.0.0.0", port=7860)
+    uvicorn.run(
+        "app:app",
+        host=os.getenv("HOST", "0.0.0.0"),
+        port=int(os.getenv("PORT", "7860")),
+        reload=False,
+        log_level=os.getenv("LOG_LEVEL", "info").lower(),
+    )