Update app.py

app.py

@@ -1,15 +1,10 @@
-"""Piper TTS HTTP server for the Under-The-Palm-Tree games.
+"""Piper TTS HTTP server — Under The Palm Tree.
+Robust against piper-tts API differences across versions.
 
-Exposes a tiny REST API that the games' piper-client.js can call directly
-from the browser. CORS is wide open so any origin (Vercel, GitHub Pages,
-Squarespace iframes) can use it.
-
-POST /synthesize  {"text": "...", "voice": "en_GB-alan-low" | "ar_JO-kareem-medium"}
-POST /tts         {"text": "...", "lang": "en" | "ar"}
+POST /tts         {"text":"...", "lang":"en"|"ar"}   -> audio/wav
+POST /synthesize  {"text":"...", "voice":"..."}       -> audio/wav
 GET  /healthz     -> "ok"
-GET  /            -> {"status": "ready", "voices": [...]}
-
-Each POST returns audio/wav (16-bit PCM).
+GET  /            -> {"status":"ready","voices":[...]}
 """
 import io
 import os
@@ -24,50 +19,97 @@ from piper import PiperVoice
 
 VOICES_DIR = Path(os.environ.get("VOICES_DIR", "/voices"))
 DEFAULT_VOICE = "en_GB-alan-low"
-
-LANG_VOICE_MAP = {
-    "ar": "ar_JO-kareem-medium",
-    "en": "en_GB-alan-low",
-}
+LANG_VOICE_MAP = {"ar": "ar_JO-kareem-medium", "en": "en_GB-alan-low"}
 
 app = FastAPI(title="Palm Tree TTS — Piper")
+app.add_middleware(CORSMiddleware, allow_origins=["*"],
+                   allow_methods=["GET", "POST", "OPTIONS"], allow_headers=["*"])
 
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_methods=["GET", "POST", "OPTIONS"],
-    allow_headers=["*"],
-)
+_cache = {}
 
-_voice_cache: dict = {}
 
-
-def load_voice(name: str):
-    if name in _voice_cache:
-        return _voice_cache[name]
+def load_voice(name):
+    if name in _cache:
+        return _cache[name]
     onnx = VOICES_DIR / f"{name}.onnx"
     cfg = VOICES_DIR / f"{name}.onnx.json"
-    if not onnx.exists() or not cfg.exists():
-        raise HTTPException(status_code=404, detail=f"voice '{name}' not found")
-    _voice_cache[name] = PiperVoice.load(str(onnx), config_path=str(cfg))
-    return _voice_cache[name]
+    if not onnx.exists():
+        raise HTTPException(status_code=404, detail=f"voice '{name}' not found at {onnx}")
+    try:
+        v = PiperVoice.load(str(onnx), config_path=str(cfg))
+    except TypeError:
+        v = PiperVoice.load(str(onnx))
+    _cache[name] = v
+    return v
 
 
 def available_voices():
     return sorted(p.stem for p in VOICES_DIR.glob("*.onnx"))
 
 
-def synth_wav(text: str, voice_name: str) -> bytes:
+def synth_wav(text, voice_name):
+    """Generate a WAV byte string, handling several piper-tts API shapes."""
     voice = load_voice(voice_name)
     buf = io.BytesIO()
-    with wave.open(buf, "wb") as wf:
-        # Newer piper-tts uses synthesize_wav; fall back to synthesize for older builds.
-        synth = getattr(voice, "synthesize_wav", None) or voice.synthesize
-        synth(text, wf)
-    return buf.getvalue()
-
 
-class SynthRequest(BaseModel):
+    # --- Strategy 1: synthesize_wav(text, wav_file) writes a full WAV ---
+    if hasattr(voice, "synthesize_wav"):
+        try:
+            with wave.open(buf, "wb") as wf:
+                voice.synthesize_wav(text, wf)
+            data = buf.getvalue()
+            if len(data) > 44:           # more than just a header
+                return data
+        except Exception:
+            buf = io.BytesIO()
+
+    # --- Strategy 2: synthesize() yields AudioChunk objects ---
+    if hasattr(voice, "synthesize"):
+        try:
+            chunks = list(voice.synthesize(text))
+            if chunks:
+                first = chunks[0]
+                rate = getattr(first, "sample_rate", 22050)
+                width = getattr(first, "sample_width", 2)
+                channels = getattr(first, "sample_channels", 1)
+                buf = io.BytesIO()
+                with wave.open(buf, "wb") as wf:
+                    wf.setnchannels(channels)
+                    wf.setsampwidth(width)
+                    wf.setframerate(rate)
+                    for ch in chunks:
+                        pcm = getattr(ch, "audio_int16_bytes", None)
+                        if pcm is None:
+                            pcm = getattr(ch, "audio", b"")
+                        wf.writeframes(pcm)
+                data = buf.getvalue()
+                if len(data) > 44:
+                    return data
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"synthesize failed: {e}")
+
+    # --- Strategy 3: older synthesize_stream_raw -> raw int16 PCM ---
+    if hasattr(voice, "synthesize_stream_raw"):
+        try:
+            cfg = getattr(voice, "config", None)
+            rate = getattr(cfg, "sample_rate", 22050) if cfg else 22050
+            buf = io.BytesIO()
+            with wave.open(buf, "wb") as wf:
+                wf.setnchannels(1)
+                wf.setsampwidth(2)
+                wf.setframerate(rate)
+                for pcm in voice.synthesize_stream_raw(text):
+                    wf.writeframes(pcm)
+            data = buf.getvalue()
+            if len(data) > 44:
+                return data
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"stream synth failed: {e}")
+
+    raise HTTPException(status_code=500, detail="no usable piper synth method")
+
+
+class Req(BaseModel):
     text: str
     voice: str | None = None
     lang: str | None = None
@@ -83,7 +125,7 @@ def healthz():
     return Response("ok", media_type="text/plain")
 
 
-def resolve_voice(req: SynthRequest) -> str:
+def resolve(req):
     if req.voice:
         return req.voice
     if req.lang:
@@ -92,14 +134,15 @@ def resolve_voice(req: SynthRequest) -> str:
 
 
 @app.post("/synthesize")
-def synthesize(req: SynthRequest):
+def synthesize(req: Req):
     text = (req.text or "").strip()
     if not text:
         raise HTTPException(status_code=400, detail="text is required")
-    audio = synth_wav(text, resolve_voice(req))
-    return Response(audio, media_type="audio/wav")
+    audio = synth_wav(text, resolve(req))
+    return Response(audio, media_type="audio/wav",
+                    headers={"Access-Control-Allow-Origin": "*"})
 
 
 @app.post("/tts")
-def tts(req: SynthRequest):
+def tts(req: Req):
     return synthesize(req)