Update app.py

app.py

@@ -1,20 +1,29 @@
-import os, json, time, asyncio
-from typing import AsyncGenerator, Dict, Any
-from fastapi import FastAPI, Request, Response
-from fastapi.responses import JSONResponse, StreamingResponse
+import os, json, time, asyncio, base64
+from typing import AsyncGenerator, Dict, Any, Optional
+from fastapi import FastAPI, Request, Response, Query, BackgroundTasks
+from fastapi.responses import JSONResponse, StreamingResponse, FileResponse
 
-# Directories (HF Spaces writable path)
-BASE_DIR = os.environ.get("BASE_DIR", "/tmp/brain_app")
+# ========== Directories ==========
+BASE_DIR  = os.environ.get("BASE_DIR", "/tmp/brain_app")
 FILES_DIR = os.path.join(BASE_DIR, "files")
-LOGS_DIR = os.path.join(FILES_DIR, "logs")
+LOGS_DIR  = os.path.join(FILES_DIR, "logs")
 EVENTS_FILE = os.path.join(LOGS_DIR, "events.jsonl")
 
 for p in (BASE_DIR, FILES_DIR, LOGS_DIR):
     os.makedirs(p, exist_ok=True)
 
-app = FastAPI(title="Brain Skeleton", version="1.0.0")
+# ========== TTS Config ==========
+TTS_BASE  = os.environ.get("TTS_BASE", "https://Percy3822-ActualTTS.hf.space")  # your Space
+# prosody baseline: length_scale = BASE_WPM / rate_wpm (clamped)
+BASE_WPM  = int(os.environ.get("BASE_WPM", "180"))
+NOISE_SCALE = float(os.environ.get("NOISE_SCALE", "0.33"))
+NOISE_W     = float(os.environ.get("NOISE_W", "0.92"))
+DEFAULT_VOICE = os.environ.get("DEFAULT_VOICE", "en_US-amy-medium")
 
-# Simple in-memory queue to fan-out logs to /stream/logs clients
+# ========== App ==========
+app = FastAPI(title="Brain Skeleton", version="1.1.0 (with TTS)")
+
+# In-memory queue to fan-out logs to /stream/logs clients
 log_queue: "asyncio.Queue[Dict[str, Any]]" = asyncio.Queue()
 
 def write_event(event: Dict[str, Any]) -> None:
@@ -23,12 +32,21 @@ def write_event(event: Dict[str, Any]) -> None:
     os.makedirs(LOGS_DIR, exist_ok=True)
     with open(EVENTS_FILE, "a", encoding="utf-8") as f:
         f.write(json.dumps(event, ensure_ascii=False) + "\n")
-    # Put to queue without awaiting (called from sync context)
     try:
         log_queue.put_nowait(event)
     except asyncio.QueueFull:
         pass
 
+def clamp_rate(rate_wpm: Optional[int]) -> int:
+    if not isinstance(rate_wpm, int):
+        return BASE_WPM
+    return max(80, min(320, rate_wpm))
+
+def rate_to_length_scale(rate_wpm: Optional[int]) -> float:
+    r = clamp_rate(rate_wpm)
+    return round(BASE_WPM / float(r), 3)
+
+# ========== Health & Basics ==========
 @app.get("/health")
 def health():
     return {
@@ -37,6 +55,7 @@ def health():
         "time": time.time(),
         "files_dir": FILES_DIR,
         "logs_dir": LOGS_DIR,
+        "tts_base": TTS_BASE,
     }
 
 @app.post("/process")
@@ -51,11 +70,12 @@ async def process(req: Request):
     write_event(event)
     return {"ok": True, "received": payload}
 
+# ========== SSE Logs ==========
 @app.get("/stream/logs")
 async def stream_logs() -> StreamingResponse:
     """Server-Sent Events stream of log events (one per line)."""
     async def gen() -> AsyncGenerator[bytes, None]:
-        # On connect, tail recent file lines so client sees immediate data (optional)
+        # Send recent lines on connect (optional)
         try:
             if os.path.exists(EVENTS_FILE):
                 with open(EVENTS_FILE, "r", encoding="utf-8") as f:
@@ -64,7 +84,7 @@ async def stream_logs() -> StreamingResponse:
         except Exception:
             pass
 
-        # Now live stream
+        # Live stream
         while True:
             event = await log_queue.get()
             line = json.dumps(event, ensure_ascii=False)
@@ -82,4 +102,156 @@ async def log_error(req: Request):
         return JSONResponse({"ok": False, "error": "Invalid JSON body"}, status_code=400)
     event = {"type": "error", "data": payload}
     write_event(event)
-    return {"ok": True}
+    return {"ok": True}
+
+# ========== TTS: JSON (file URL) ==========
+@app.post("/tts/say")
+async def tts_say_json(req: Request):
+    """
+    POST JSON → call TTS /speak (JSON) and return audio_url.
+    Body:
+      {
+        "text": "Hello world",
+        "voice": "en_US-amy-medium",      # optional
+        "rate_wpm": 165,                  # optional (maps to length_scale)
+        "length_scale": 1.05,             # optional (overrides rate_wpm)
+        "noise_scale": 0.33,              # optional
+        "noise_w": 0.92                   # optional
+      }
+    """
+    try:
+        body = await req.json()
+    except Exception:
+        return JSONResponse({"ok": False, "error": "Invalid JSON body"}, status_code=400)
+
+    text  = (body.get("text") or "").strip()
+    if not text:
+        return JSONResponse({"ok": False, "error": "Missing text"}, status_code=400)
+
+    voice = (body.get("voice") or DEFAULT_VOICE).strip()
+    length_scale = float(body["length_scale"]) if "length_scale" in body else rate_to_length_scale(int(body.get("rate_wpm", BASE_WPM)))
+    noise_scale  = float(body.get("noise_scale", NOISE_SCALE))
+    noise_w      = float(body.get("noise_w", NOISE_W))
+
+    # Call TTS Space /speak (JSON)
+    import httpx
+    payload = {
+        "text": text,
+        "voice": voice,
+        "length_scale": length_scale,
+        "noise_scale": noise_scale,
+        "noise_w": noise_w,
+    }
+
+    async with httpx.AsyncClient(timeout=180) as client:
+        resp = await client.post(f"{TTS_BASE}/speak", json=payload)
+        ok = resp.status_code == 200
+        data = {}
+        try:
+            data = resp.json()
+        except Exception:
+            pass
+
+    event = {"type": "tts_say_json", "data": {"text_len": len(text), "voice": voice, "ok": ok, "tts_resp": data}}
+    write_event(event)
+
+    if not ok or not data.get("ok"):
+        return JSONResponse({"ok": False, "error": data.get("error") if data else f"TTS error {resp.status_code}"}, status_code=500)
+
+    # Return TTS audio_url directly
+    return {"ok": True, "audio_url": data["audio_url"], "voice": voice, "length_scale": length_scale}
+
+# ========== TTS: Direct WAV Proxy ==========
+async def _proxy_tts_wav_stream(
+    text: str,
+    voice: str,
+    length_scale: float,
+    noise_scale: float,
+    noise_w: float,
+    save_local: bool = False
+) -> StreamingResponse:
+    """
+    GET TTS /speak.wav and stream the WAV to the caller.
+    If save_local is True, also tee to a local file under FILES_DIR.
+    """
+    import httpx
+    params = {
+        "text": text,
+        "voice": voice,
+        "length_scale": f"{length_scale:.3f}",
+        "noise_scale": f"{noise_scale:.3f}",
+        "noise_w": f"{noise_w:.3f}",
+    }
+    ts = int(time.time() * 1000)
+    local_path = os.path.join(FILES_DIR, f"say-{ts}.wav") if save_local else None
+
+    async def gen():
+        async with httpx.AsyncClient(timeout=None) as client:
+            async with client.stream("GET", f"{TTS_BASE}/speak.wav", params=params) as resp:
+                if resp.status_code != 200:
+                    # bubble JSON error from TTS if any
+                    err_body = await resp.aread()
+                    yield err_body  # still return something; caller will see non-wav
+                    return
+                # stream body and optionally save
+                f = None
+                try:
+                    if local_path:
+                        f = open(local_path, "wb")
+                    async for chunk in resp.aiter_bytes():
+                        if chunk:
+                            if f: f.write(chunk)
+                            yield chunk
+                finally:
+                    if f: f.close()
+
+    headers = {"Cache-Control": "no-cache"}
+    if local_path:
+        headers["X-Local-Path"] = local_path
+    return StreamingResponse(gen(), media_type="audio/wav", headers=headers)
+
+@app.get("/tts/say.wav")
+async def tts_say_wav_get(
+    text: str = Query(..., description="Text to synthesize"),
+    voice: str = Query(DEFAULT_VOICE, description="Voice id from the TTS Space"),
+    rate_wpm: Optional[int] = Query(None, description="Words-per-minute; maps to length_scale"),
+    length_scale: Optional[float] = Query(None, description="Override prosody (else derived from rate_wpm)"),
+    noise_scale: float = Query(NOISE_SCALE),
+    noise_w: float = Query(NOISE_W),
+    save: bool = Query(False, description="Also save under /files")
+):
+    ls = float(length_scale) if length_scale is not None else rate_to_length_scale(rate_wpm if rate_wpm is not None else BASE_WPM)
+
+    write_event({"type": "tts_say_wav_get", "data": {"len": len(text), "voice": voice, "ls": ls, "save": save}})
+    return await _proxy_tts_wav_stream(text, voice, ls, noise_scale, noise_w, save_local=save)
+
+@app.post("/tts/say.wav")
+async def tts_say_wav_post(req: Request, save: bool = Query(False, description="Also save under /files")):
+    """
+    POST JSON → stream back audio/wav
+      { "text": "...", "voice": "en_US-amy-medium", "rate_wpm": 165 }
+    """
+    try:
+        body = await req.json()
+    except Exception:
+        return JSONResponse({"ok": False, "error": "Invalid JSON body"}, status_code=400)
+
+    text  = (body.get("text") or "").strip()
+    if not text:
+        return JSONResponse({"ok": False, "error": "Missing text"}, status_code=400)
+
+    voice = (body.get("voice") or DEFAULT_VOICE).strip()
+    ls = float(body["length_scale"]) if "length_scale" in body else rate_to_length_scale(int(body.get("rate_wpm", BASE_WPM)))
+    ns = float(body.get("noise_scale", NOISE_SCALE))
+    nw = float(body.get("noise_w", NOISE_W))
+
+    write_event({"type": "tts_say_wav_post", "data": {"len": len(text), "voice": voice, "ls": ls, "save": save}})
+    return await _proxy_tts_wav_stream(text, voice, ls, ns, nw, save_local=save)
+
+# ========== Serve saved files (if you used save=true) ==========
+@app.get("/files/{name}")
+def get_saved_file(name: str):
+    path = os.path.join(FILES_DIR, name)
+    if not os.path.exists(path):
+        return JSONResponse({"ok": False, "error": "not found"}, status_code=404)
+    return FileResponse(path, media_type="audio/wav", filename=name)