Update tts_engine.py

tts_engine.py

@@ -1,58 +1,56 @@
 """
 tts_engine.py
 ─────────────
-Text-to-Speech engine for reading scene descriptions aloud.
+Text-to-Speech engine.
 
-Priority:
-  1. pyttsx3  — offline, no network required
-  2. gTTS     — Google TTS (needs internet), saves MP3 and plays
-  3. Silent   — logs a warning if neither is available
+On Hugging Face Spaces (headless server):
+  - pyttsx3 is skipped (needs audio hardware)
+  - gTTS saves an MP3 that Gradio can play back via gr.Audio
+  - Falls back to silent mode gracefully
+
+Locally: pyttsx3 works offline, gTTS needs internet.
 """
 
 import logging
 import threading
 import os
+import io
 
 logger = logging.getLogger(__name__)
 
 
 class TTSEngine:
-    """
-    Wraps pyttsx3 (preferred) or gTTS (fallback) for async TTS.
-    """
-
     def __init__(self, rate: int = 160, volume: float = 1.0):
-        self._rate   = rate
-        self._volume = volume
-        self._engine = None
-        self._lock   = threading.Lock()
-        self._backend: str = "silent"
-        self._init_engine()
+        self._rate    = rate
+        self._volume  = volume
+        self._backend = "silent"
+        self._init()
 
-    def _init_engine(self):
-        # ── Try pyttsx3 ───────────────────────────────────────────────────────
-        try:
-            import pyttsx3
-            engine = pyttsx3.init()
-            engine.setProperty("rate",   self._rate)
-            engine.setProperty("volume", self._volume)
-            self._engine  = engine
-            self._backend = "pyttsx3"
-            logger.info("✅  TTS backend: pyttsx3 (offline)")
-            return
-        except Exception as exc:
-            logger.warning(f"pyttsx3 not available: {exc}")
+    def _init(self):
+        # Try pyttsx3 (local / desktop only)
+        if os.environ.get("GRADIO_SERVER_NAME") is None:
+            try:
+                import pyttsx3
+                e = pyttsx3.init()
+                e.setProperty("rate",   self._rate)
+                e.setProperty("volume", self._volume)
+                self._engine  = e
+                self._backend = "pyttsx3"
+                logger.info("TTS backend: pyttsx3 (offline)")
+                return
+            except Exception as exc:
+                logger.debug(f"pyttsx3 unavailable: {exc}")
 
-        # ── Try gTTS ──────────────────────────────────────────────────────────
+        # Try gTTS (online, works on HF Spaces)
         try:
             import gtts  # noqa: F401
             self._backend = "gtts"
-            logger.info("✅  TTS backend: gTTS (online)")
+            logger.info("TTS backend: gTTS (online)")
             return
         except ImportError:
-            logger.warning("gTTS not available.")
+            pass
 
-        logger.warning("⚠️  No TTS backend found — speech output disabled.")
+        logger.warning("No TTS backend available — speech output disabled.")
 
     # ── Public API ────────────────────────────────────────────────────────────
 
@@ -61,43 +59,46 @@ class TTSEngine:
         if not text:
             return
         if self._backend == "pyttsx3":
-            with self._lock:
-                self._engine.say(text)
-                self._engine.runAndWait()
+            self._engine.say(text)
+            self._engine.runAndWait()
         elif self._backend == "gtts":
-            self._speak_gtts(text)
+            self._gtts_speak(text)
         else:
-            logger.info(f"[TTS silent] {text}")
+            logger.info(f"[TTS silent]: {text[:80]}")
 
     def speak_async(self, text: str):
-        """Non-blocking speech — runs in a daemon thread."""
-        t = threading.Thread(target=self.speak, args=(text,), daemon=True)
-        t.start()
+        """Non-blocking TTS in a daemon thread."""
+        threading.Thread(target=self.speak, args=(text,), daemon=True).start()
 
-    def stop(self):
-        """Stop current speech (pyttsx3 only)."""
-        if self._backend == "pyttsx3":
-            with self._lock:
-                try:
-                    self._engine.stop()
-                except Exception:
-                    pass
+    def to_audio_bytes(self, text: str) -> bytes | None:
+        """
+        Returns MP3 bytes (for Gradio gr.Audio playback).
+        Returns None if TTS unavailable.
+        """
+        if self._backend == "gtts":
+            try:
+                from gtts import gTTS
+                buf = io.BytesIO()
+                gTTS(text=text, lang="en", slow=False).write_to_fp(buf)
+                return buf.getvalue()
+            except Exception as exc:
+                logger.error(f"gTTS error: {exc}")
+        return None
 
-    # ── Private helpers ───────────────────────────────────────────────────────
+    # ── Helpers ───────────────────────────────────────────────────────────────
 
-    def _speak_gtts(self, text: str):
+    def _gtts_speak(self, text: str):
         try:
             from gtts import gTTS
-            import tempfile, subprocess
+            import tempfile
             tts = gTTS(text=text, lang="en", slow=False)
             with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as f:
                 tts.save(f.name)
                 tmp = f.name
-            # Play with system player
-            for player in ("mpg123", "mpg321", "ffplay", "aplay"):
-                if os.system(f"which {player} > /dev/null 2>&1") == 0:
-                    os.system(f"{player} -q {tmp} > /dev/null 2>&1")
+            for player in ("mpg123", "mpg321", "ffplay -nodisp -autoexit"):
+                if os.system(f"which {player.split()[0]} > /dev/null 2>&1") == 0:
+                    os.system(f"{player} {tmp} > /dev/null 2>&1")
                     break
             os.unlink(tmp)
         except Exception as exc:
-            logger.error(f"gTTS error: {exc}")
+            logger.error(f"gTTS playback error: {exc}")