Update services/podcast_service.py

services/podcast_service.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
+import io
 import logging
 import os
 import re
-import tempfile
 import uuid
 from datetime import datetime
 from pathlib import Path
@@ -19,14 +19,15 @@ MAX_NEW_TOKENS = 2048
 TEMPERATURE = 0.7
 TIMEOUT_SEC = 90
 
-# Bark voice presets for the two hosts
-HOST_A_VOICE = "v2/en_speaker_6"   # deeper male voice
-HOST_B_VOICE = "v2/en_speaker_9"   # female voice
+# Two different HF TTS models for distinct host voices — runs via HF Inference API,
+# no local model download needed, works fine on free Spaces
+TTS_MODEL_ALEX = "espnet/kan-bayashi_ljspeech_vits"  # Host Alex
+TTS_MODEL_SAM  = "facebook/mms-tts-eng"              # Host Sam
 
-# Max chars per Bark chunk (Bark struggles with long inputs)
-BARK_CHUNK_CHARS = 220
+# Max chars per TTS request
+TTS_CHUNK_CHARS = 300
 
-# Output dir for audio files — must be accessible by Gradio
+# Output dir for audio — must be accessible by Gradio's /file= endpoint
 AUDIO_OUTPUT_DIR = Path("assets/podcasts")
 
 
@@ -42,7 +43,7 @@ Write a podcast conversation between two hosts: Alex and Sam.
 - Sam explains concepts clearly with examples and analogies
 - The conversation should feel natural, not like a lecture
 - Cover the key points from the summary
-- Length: 10–15 exchanges (back-and-forth lines)
+- Length: 10-15 exchanges (back-and-forth lines)
 
 FORMAT RULES (strictly follow these):
 - Every line must start with either "Alex:" or "Sam:" followed by a space
@@ -84,18 +85,16 @@ def _script_to_markdown(lines: list[tuple[str, str]]) -> str:
     return "\n".join(parts)
 
 
-def _chunk_text(text: str, max_chars: int) -> list[str]:
-    """Split text into chunks at sentence boundaries for Bark TTS."""
+def _chunk_text(text: str, max_chars: int = TTS_CHUNK_CHARS) -> list[str]:
+    """Split text into chunks at sentence boundaries."""
     sentences = re.split(r'(?<=[.!?])\s+', text.strip())
-    chunks = []
-    current = ""
+    chunks, current = [], ""
     for sent in sentences:
         if len(current) + len(sent) + 1 <= max_chars:
             current = (current + " " + sent).strip()
         else:
             if current:
                 chunks.append(current)
-            # If single sentence is too long, hard-split it
             if len(sent) > max_chars:
                 for i in range(0, len(sent), max_chars):
                     chunks.append(sent[i:i + max_chars])
@@ -108,37 +107,60 @@ def _chunk_text(text: str, max_chars: int) -> list[str]:
 
 def _synthesize_audio(lines: list[tuple[str, str]], output_path: Path) -> bool:
     """
-    Synthesize podcast audio using Bark TTS.
-    Concatenates per-speaker audio chunks into a single WAV file.
+    Synthesize podcast audio using HF Inference API TTS.
+    Calls the API per chunk, concatenates raw audio bytes, saves as WAV.
     Returns True on success, False on failure.
     """
     try:
         import numpy as np
-        from bark import SAMPLE_RATE, generate_audio, preload_models
         import scipy.io.wavfile as wav
 
-        logger.info("Loading Bark models...")
-        preload_models()
+        token = os.environ.get("HF_TOKEN")
+        client = InferenceClient(token=token, timeout=TIMEOUT_SEC)
 
+        SAMPLE_RATE = 22050  # Standard for most HF TTS models
         all_audio: list[np.ndarray] = []
-        silence = np.zeros(int(SAMPLE_RATE * 0.4), dtype=np.float32)  # 0.4s pause between turns
+        silence = np.zeros(int(SAMPLE_RATE * 0.5), dtype=np.float32)
 
         for speaker, text in lines:
-            voice_preset = HOST_A_VOICE if speaker == "Alex" else HOST_B_VOICE
-            chunks = _chunk_text(text, BARK_CHUNK_CHARS)
+            tts_model = TTS_MODEL_ALEX if speaker == "Alex" else TTS_MODEL_SAM
+            chunks = _chunk_text(text)
+
             for chunk in chunks:
                 try:
-                    audio_array = generate_audio(chunk, history_prompt=voice_preset)
-                    all_audio.append(audio_array.astype(np.float32))
+                    # text_to_speech returns raw audio bytes
+                    audio_bytes = client.text_to_speech(chunk, model=tts_model)
+
+                    # Parse WAV bytes using scipy
+                    rate, data = wav.read(io.BytesIO(audio_bytes))
+
+                    # Normalize to float32
+                    if data.dtype == np.int16:
+                        audio_float = data.astype(np.float32) / 32768.0
+                    elif data.dtype == np.int32:
+                        audio_float = data.astype(np.float32) / 2147483648.0
+                    else:
+                        audio_float = data.astype(np.float32)
+
+                    # Handle stereo → mono
+                    if audio_float.ndim == 2:
+                        audio_float = audio_float.mean(axis=1)
+
+                    # Resample if needed (simple approach: just use as-is, note the rate)
+                    if rate != SAMPLE_RATE:
+                        SAMPLE_RATE = rate  # Use whatever rate the model returns
+
+                    all_audio.append(audio_float)
+
                 except Exception as chunk_err:
-                    logger.warning("Bark chunk failed for speaker %s: %s", speaker, chunk_err)
+                    logger.warning("TTS chunk failed for %s: %s", speaker, chunk_err)
+
             all_audio.append(silence)
 
         if not all_audio:
             return False
 
         combined = np.concatenate(all_audio)
-        # Normalize to prevent clipping
         max_val = np.max(np.abs(combined))
         if max_val > 0:
             combined = combined / max_val * 0.95
@@ -148,20 +170,20 @@ def _synthesize_audio(lines: list[tuple[str, str]], output_path: Path) -> bool:
         logger.info("Podcast audio saved to %s", output_path)
         return True
 
-    except ImportError:
-        logger.warning("Bark not installed. Skipping TTS. Install with: pip install bark")
+    except ImportError as e:
+        logger.warning("scipy not installed, skipping TTS: %s", e)
         return False
     except Exception as e:
-        logger.error("Bark TTS failed: %s", e)
+        logger.error("TTS synthesis failed: %s", e)
         return False
 
 
 def generate_podcast(notebook: Notebook, summary_content: str) -> Artifact:
     """
     Generate a podcast artifact:
-    1. Generate script via HF InferenceClient
-    2. Synthesize audio via Bark TTS
-    Returns an Artifact with content=markdown script and audio_path set if TTS succeeded.
+    1. Generate two-host script via HF InferenceClient (Qwen)
+    2. Synthesize audio via HF Inference API TTS (no local models)
+    Returns an Artifact with markdown script + audio_path if TTS succeeded.
     """
     token = os.environ.get("HF_TOKEN")
     client = InferenceClient(token=token, timeout=TIMEOUT_SEC)
@@ -194,14 +216,12 @@ def generate_podcast(notebook: Notebook, summary_content: str) -> Artifact:
         logger.error("Podcast script generation failed: %s", e)
         lines = [
             ("Alex", "Welcome to the podcast! Unfortunately we ran into an issue generating today's episode."),
-            ("Sam", f"The script generation failed with error: {e}. Please try again."),
-            ("Alex", "Thanks for listening, and we'll be back with a full episode soon!"),
+            ("Sam", f"The script generation failed. Please try again."),
+            ("Alex", "Thanks for listening — we'll be back soon!"),
         ]
 
-    # Build markdown script for display
     markdown_script = _script_to_markdown(lines)
 
-    # Synthesize audio
     audio_filename = f"podcast_{uuid.uuid4().hex[:12]}.wav"
     audio_path = AUDIO_OUTPUT_DIR / audio_filename
     audio_success = _synthesize_audio(lines, audio_path)