Update services/podcast_service.py

services/podcast_service.py

@@ -8,26 +8,20 @@ import uuid
 from datetime import datetime
 from pathlib import Path
 
-from huggingface_hub import InferenceClient
+import anthropic
 
 from state import Artifact, Notebook
 
 logger = logging.getLogger(__name__)
 
-GEN_MODEL = "mistralai/Mistral-7B-Instruct-v0.3"
-MAX_NEW_TOKENS = 2048
-TEMPERATURE = 0.7
-TIMEOUT_SEC = 90
+MODEL = "claude-haiku-4-5-20251001"
+MAX_TOKENS = 2048
 
-# 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 TTS request
+# Two HF TTS models for distinct host voices — runs via HF Inference API
+TTS_MODEL_ALEX = "espnet/kan-bayashi_ljspeech_vits"
+TTS_MODEL_SAM  = "facebook/mms-tts-eng"
 TTS_CHUNK_CHARS = 300
 
-# Output dir for audio — must be accessible by Gradio's /file= endpoint
 AUDIO_OUTPUT_DIR = Path("assets/podcasts")
 
 
@@ -59,7 +53,6 @@ Now write the podcast script:"""
 
 
 def _parse_script_lines(raw: str) -> list[tuple[str, str]]:
-    """Parse script into list of (speaker, text) tuples."""
     lines = []
     for line in raw.strip().splitlines():
         line = line.strip()
@@ -77,7 +70,6 @@ def _parse_script_lines(raw: str) -> list[tuple[str, str]]:
 
 
 def _script_to_markdown(lines: list[tuple[str, str]]) -> str:
-    """Convert parsed lines to readable markdown for display."""
     parts = ["## 🎙️ Podcast Script\n"]
     for speaker, text in lines:
         emoji = "🎤" if speaker == "Alex" else "🎧"
@@ -86,7 +78,6 @@ def _script_to_markdown(lines: list[tuple[str, str]]) -> str:
 
 
 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 = [], ""
     for sent in sentences:
@@ -106,55 +97,38 @@ def _chunk_text(text: str, max_chars: int = TTS_CHUNK_CHARS) -> list[str]:
 
 
 def _synthesize_audio(lines: list[tuple[str, str]], output_path: Path) -> bool:
-    """
-    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.
-    """
+    """Synthesize audio via HF Inference API TTS. Returns True on success."""
     try:
         import numpy as np
         import scipy.io.wavfile as wav
+        from huggingface_hub import InferenceClient
 
         token = os.environ.get("HF_TOKEN")
-        client = InferenceClient(token=token, timeout=TIMEOUT_SEC)
+        client = InferenceClient(token=token, timeout=90)
 
-        SAMPLE_RATE = 22050  # Standard for most HF TTS models
+        SAMPLE_RATE = 22050
         all_audio: list[np.ndarray] = []
         silence = np.zeros(int(SAMPLE_RATE * 0.5), dtype=np.float32)
 
         for speaker, text in lines:
             tts_model = TTS_MODEL_ALEX if speaker == "Alex" else TTS_MODEL_SAM
-            chunks = _chunk_text(text)
-
-            for chunk in chunks:
+            for chunk in _chunk_text(text):
                 try:
-                    # 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
-
+                        SAMPLE_RATE = rate
                     all_audio.append(audio_float)
-
-                except Exception as chunk_err:
-                    logger.warning("TTS chunk failed for %s: %s", speaker, chunk_err)
-
+                except Exception as e:
+                    logger.warning("TTS chunk failed for %s: %s", speaker, e)
             all_audio.append(silence)
 
         if not all_audio:
@@ -171,7 +145,7 @@ def _synthesize_audio(lines: list[tuple[str, str]], output_path: Path) -> bool:
         return True
 
     except ImportError as e:
-        logger.warning("scipy not installed, skipping TTS: %s", e)
+        logger.warning("Missing dependency for TTS: %s", e)
         return False
     except Exception as e:
         logger.error("TTS synthesis failed: %s", e)
@@ -179,44 +153,30 @@ def _synthesize_audio(lines: list[tuple[str, str]], output_path: Path) -> bool:
 
 
 def generate_podcast(notebook: Notebook, summary_content: str) -> Artifact:
-    """
-    Generate a podcast artifact:
-    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)
-
-    prompt = _build_podcast_prompt(summary_content)
+    """Generate podcast script via Claude + audio via HF TTS."""
+    client = anthropic.Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))
 
     try:
-        response = client.chat_completion(
-            model=GEN_MODEL,
-            messages=[
-                {
-                    "role": "system",
-                    "content": (
-                        "You are a podcast scriptwriter. Write natural, engaging dialogue between two hosts. "
-                        "Every line must start with 'Alex:' or 'Sam:'. No markdown, no stage directions."
-                    ),
-                },
-                {"role": "user", "content": prompt},
-            ],
-            max_tokens=MAX_NEW_TOKENS,
-            temperature=TEMPERATURE,
+        response = client.messages.create(
+            model=MODEL,
+            max_tokens=MAX_TOKENS,
+            system=(
+                "You are a podcast scriptwriter. Write natural, engaging dialogue between two hosts. "
+                "Every line must start with 'Alex:' or 'Sam:'. No markdown, no stage directions."
+            ),
+            messages=[{"role": "user", "content": _build_podcast_prompt(summary_content)}],
         )
-        raw_script = response.choices[0].message.content or ""
+        raw_script = response.content[0].text or ""
         lines = _parse_script_lines(raw_script)
 
         if not lines:
-            raise ValueError("No speaker lines parsed from LLM response.")
+            raise ValueError("No speaker lines parsed from response.")
 
     except Exception as e:
         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. Please try again."),
+            ("Sam", "The script generation failed. Please try again."),
             ("Alex", "Thanks for listening — we'll be back soon!"),
         ]