Update app.py

app.py

@@ -1,8 +1,9 @@
 """
-Two-Speaker Podcast Web App (Free HF Space)
+Two-Speaker Podcast Web App (ElevenLabs + gTTS Fallback)
 - Auto podcast after adding documents (no question needed)
 - Engaging script: hook → setup → 3 segments → mini-story → recap/CTA
-- Two voices via gTTS accent + tempo (Host: UK, Guest: AU)
+- Primary TTS: ElevenLabs (two named voices) if configured
+- Fallback TTS: gTTS accents + tempo contrast (Host: UK, Guest: AU)
 - Chroma persistent client in ./chroma_db
 - SentenceTransformer MiniLM-L3-v2 (lazy load)
 """
@@ -36,10 +37,17 @@ TARGET_MINUTES = float(os.environ.get("TARGET_MINUTES", "2.5"))
 WPM = int(os.environ.get("WPM", "170"))
 TARGET_WORDS = int(TARGET_MINUTES * WPM)
 
-# Voice accents (free-tier gTTS approximation of gender)
+# gTTS accents (free-tier approximation of different speakers)
 HOST_TLD = os.environ.get("HOST_TLD", "co.uk")   # UK English
 GUEST_TLD = os.environ.get("GUEST_TLD", "com.au")# Australian English
 
+# ElevenLabs config (optional)
+ELEVEN_API_KEY = os.environ.get("ELEVEN_API_KEY", "")
+ELEVEN_MODEL_ID = os.environ.get("ELEVEN_MODEL_ID", "eleven_multilingual_v2")
+ELEVEN_HOST_VOICE_ID = os.environ.get("ELEVEN_HOST_VOICE_ID", "")
+ELEVEN_GUEST_VOICE_ID = os.environ.get("ELEVEN_GUEST_VOICE_ID", "")
+USE_ELEVEN = bool(ELEVEN_API_KEY and (ELEVEN_HOST_VOICE_ID or ELEVEN_GUEST_VOICE_ID))
+
 os.makedirs(AUDIO_OUT_DIR, exist_ok=True)
 
 # --------------------------
@@ -49,7 +57,7 @@ os.makedirs(CHROMA_DIR, exist_ok=True)
 client = chromadb.PersistentClient(
     path=CHROMA_DIR,
     settings=Settings(anonymized_telemetry=False)
-)  # [docs confirm path + settings usage]
+)  # Persistent local store [web:15]
 
 # --------------------------
 # Lazy embeddings
@@ -151,7 +159,6 @@ def add_documents_for_user(username: str, files: List[str]) -> str:
     return f"Indexed {total_chunks} chunks into {get_collection_name(username)}."
 
 def retrieve_context(username: str, query: str = "", k: int = 12) -> List[str]:
-    # If query empty, use centroid-like approach: query with a generic prompt to surface broad coverage
     col = ensure_collection(username)
     if query and query.strip():
         q_vec = embed_texts([query.strip()])[0]
@@ -162,7 +169,6 @@ def retrieve_context(username: str, query: str = "", k: int = 12) -> List[str]:
         except Exception:
             return []
     else:
-        # No question: approximate coverage by querying with multiple generic anchors
         anchors = [
             "overview and key points",
             "main ideas and practical steps",
@@ -177,7 +183,6 @@ def retrieve_context(username: str, query: str = "", k: int = 12) -> List[str]:
                 all_docs.extend(docs[0])
             except Exception:
                 pass
-        # Deduplicate while preserving order
         seen = set()
         deduped = []
         for d in all_docs:
@@ -192,8 +197,6 @@ def retrieve_context(username: str, query: str = "", k: int = 12) -> List[str]:
 SHOW_NAME = "Signal & Summary"
 
 def synthesize_dialogue(username: str, query: str, context_docs: List[str], min_words: int = TARGET_WORDS) -> str:
-    # Build a structured two-speaker script targeting min_words.
-    # Keep labels in transcript; TTS will strip them.
     ctx_points = []
     for d in context_docs:
         s = " ".join(d.split())
@@ -204,20 +207,21 @@ def synthesize_dialogue(username: str, query: str, context_docs: List[str], min_
     G = lambda t: f"Guest: {t}"
 
     parts = []
-    # Cold open hook (no welcome phrase)
+    # Cold open hook (no generic welcomes)
     if query and query.strip():
         qtxt = query.strip()
-        parts.append(H(f"Let’s start bold: what if {qtxt} could be simplified into one move today?"))
-        parts.append(G("That’s ambitious—let’s make it real. By the end, there’s a specific next step."))
+        parts.append(H(f"Here’s a thought: what if {qtxt} could be simplified to one move today?"))
+        parts.append(G("Let’s see if that holds—by the end, there’s a concrete next step."))
     else:
-        parts.append(H("Let’s cut through noise and get to the signal."))
-        parts.append(G("Agreed—clear steps, minimal fluff, and one practical commitment at the end."))
+        parts.append(H("Let’s cut the noise and dial in the signal."))
+        parts.append(G("Clear steps, minimal fluff, and one practical commitment at the end."))
 
-    # Setup with stakes
+    # Stakes
     parts.append(H("Why this matters: attention is scarce, constraints are real, and experiments beat debates."))
-    # Context highlights woven naturally
+
+    # Natural context highlights
     if ctx_points:
-        parts.append(G("Ground truth from the reading, without jargon:"))
+        parts.append(G("From the background, said plainly:"))
         for c in ctx_points[:6]:
             parts.append(G(f"- {c}"))
 
@@ -225,20 +229,20 @@ def synthesize_dialogue(username: str, query: str, context_docs: List[str], min_
     parts.append(H("Segment 1 — Define the problem without buzzwords."))
     parts.append(G("Write it in one sentence. If it needs a paragraph, the scope is off."))
     parts.append(H("Segment 2 — Constraints as design tools."))
-    parts.append(G("Constraints don’t block progress—they focus it. Choose one that forces a useful trade‑off."))
+    parts.append(G("Constraints don’t block progress—they focus it. Choose one to force a useful trade‑off."))
     parts.append(H("Segment 3 — Practice over opinion."))
-    parts.append(G("Ship a thin slice in seven days, measure one leading indicator, and ignore vanity metrics."))
+    parts.append(G("Ship a thin slice in seven days, measure one leading indicator, ignore vanity metrics."))
 
     # Mini story
     parts.append(H("Quick story: we narrowed to a single user path and iteration speed doubled."))
     parts.append(G("Because decisions moved from meetings to real feedback, and that changed everything."))
 
     # Recap + CTA
-    parts.append(H("Recap: define clearly, use constraints, and ship the smallest thing that teaches."))
-    parts.append(G("Call to action: draft the one sentence, pick one constraint, commit to a seven‑day experiment."))
+    parts.append(H("Recap: define clearly, use constraints, ship the smallest thing that teaches."))
+    parts.append(G("Your move: write the one sentence, pick one constraint, commit to a seven‑day experiment."))
     parts.append(H(f"That’s today on {SHOW_NAME}. Keep it specific, keep it human."))
 
-    # Pad to target words with natural back‑and‑forth
+    # Pad to target words
     base_words = sum(len(p.split()) for p in parts)
     if base_words < min_words:
         beats = [
@@ -246,7 +250,7 @@ def synthesize_dialogue(username: str, query: str, context_docs: List[str], min_
             G("Answer: the one that reaches a real user and returns a signal within days, not months."),
             H("What if the result is messy or negative?"),
             G("That’s data. Shorten the loop, adjust scope, and try again—momentum matters."),
-            H("Final note: clarity scales; cleverness does not."),
+            H("Final note: clarity scales; cleverness doesn’t."),
             G("Keep it measurable and kind. Then press record—metaphorically and literally."),
         ]
         i = 0
@@ -259,69 +263,100 @@ def synthesize_dialogue(username: str, query: str, context_docs: List[str], min_
     return "\n".join(parts)
 
 # --------------------------
-# TTS: two accents + tempo
+# TTS: ElevenLabs + gTTS fallback
 # --------------------------
-def tts_line_to_file(text: str, speaker: str, lang: str = "en", tld: str = "co.uk", slow: bool = False) -> str:
-    # Strip labels so they aren't spoken
-    spoken = text
-    if spoken.startswith("Host:"):
-        spoken = spoken[len("Host:"):].lstrip()
-    elif spoken.startswith("Guest:"):
-        spoken = spoken[len("Guest:"):].lstrip()
-    out_path = os.path.join(AUDIO_OUT_DIR, f"{int(time.time())}_{speaker}_{uuid.uuid4().hex[:6]}.mp3")
+def strip_labels(text: str) -> str:
+    if text.startswith("Host:"):
+        return text[len("Host:"):].lstrip()
+    if text.startswith("Guest:"):
+        return text[len("Guest:"):].lstrip()
+    return text
+
+def tts_line_to_file_gtts(text: str, speaker: str, lang: str = "en", tld: str = "co.uk", slow: bool = False) -> str:
+    spoken = strip_labels(text)
+    path = os.path.join(AUDIO_OUT_DIR, f"{int(time.time())}_{speaker}_{uuid.uuid4().hex[:6]}.mp3")
     tts = gTTS(text=spoken, lang=lang, tld=tld, slow=slow)
-    tts.save(out_path)
-    return out_path  # Always path to the just-created MP3
+    tts.save(path)
+    return path
 
-def generate_two_voice_audio(dialogue: str) -> str:
-    # Always base synthesis on the dialogue variable provided here.
+def tts_line_to_file_eleven(text: str, voice_id: str, speaker: str) -> str:
+    # Uses official SDK convert; on error returns None for fallback
+    spoken = strip_labels(text)
+    out_path = os.path.join(AUDIO_OUT_DIR, f"{int(time.time())}_{speaker}_{uuid.uuid4().hex[:6]}.mp3")
     try:
-        from pydub import AudioSegment, effects
-        # Build segments per line with contrasting accents
-        seg_meta = []
-        for line in dialogue.splitlines():
-            line = line.strip()
-            if not line:
-                continue
-            if line.startswith("Guest:"):
-                seg_meta.append((tts_line_to_file(line, "guest", lang="en", tld=GUEST_TLD, slow=False), "guest"))
-            else:
-                seg_meta.append((tts_line_to_file(line, "host",  lang="en", tld=HOST_TLD,  slow=False), "host"))
-
-        # Concatenate and lightly adjust tempo per speaker
-        final = None
-        for path, who in seg_meta:
-            seg = AudioSegment.from_file(path, format="mp3")
-            if who == "host":
-                seg = effects.speedup(seg, playback_speed=1.06, crossfade=0)
+        from elevenlabs.client import ElevenLabs  # pip install elevenlabs
+        client_el = ElevenLabs(api_key=ELEVEN_API_KEY)
+        audio = client_el.text_to_speech.convert(
+            text=spoken,
+            voice_id=voice_id,
+            model_id=ELEVEN_MODEL_ID,
+            output_format="mp3_44100_128"
+        )  # May return an iterator of chunks
+        with open(out_path, "wb") as f:
+            if hasattr(audio, "__iter__") and not isinstance(audio, (bytes, bytearray)):
+                for chunk in audio:
+                    if isinstance(chunk, (bytes, bytearray)):
+                        f.write(chunk)
             else:
-                seg = effects.speedup(seg, playback_speed=0.95, crossfade=0)
-            final = seg if final is None else final + seg
-
-        out_path = os.path.join(AUDIO_OUT_DIR, f"{int(time.time())}_podcast_{uuid.uuid4().hex[:6]}.mp3")
-        final.export(out_path, format="mp3")
+                f.write(audio if isinstance(audio, (bytes, bytearray)) else bytes(audio))
         return out_path
+    except Exception:
+        return None  # Signal fallback
+
+def tts_line_to_file_unified(text: str, speaker: str) -> str:
+    # Prefer ElevenLabs if configured; else gTTS
+    if USE_ELEVEN:
+        vid = ELEVEN_HOST_VOICE_ID if speaker == "host" else ELEVEN_GUEST_VOICE_ID
+        if vid:
+            path = tts_line_to_file_eleven(text, vid, speaker)
+            if path:
+                return path
+    # Fallback to gTTS with contrasting accents
+    tld = HOST_TLD if speaker == "host" else GUEST_TLD
+    return tts_line_to_file_gtts(text, speaker=speaker, lang="en", tld=tld, slow=False)
 
+def generate_two_voice_audio(dialogue: str) -> str:
+    # Concatenate segments and lightly adjust tempo per voice (requires pydub + ffmpeg)
+    try:
+        from pydub import AudioSegment, effects
     except Exception:
-        # Fallback: still speak the exact dialogue variable; do NOT use any static text
-        merged_text = "\n".join(
-            [l.replace("Host:", "").replace("Guest:", "").strip()
-             for l in dialogue.splitlines() if l.strip()]
-        )
-        single = tts_line_to_file(merged_text, "podcast", lang="en", tld=HOST_TLD, slow=False)
-        return single or ""
+        merged_text = "\n".join([strip_labels(l) for l in dialogue.splitlines() if l.strip()])
+        return tts_line_to_file_unified(merged_text, speaker="host")
+
+    segs = []
+    for line in dialogue.splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        if line.startswith("Guest:"):
+            segs.append((tts_line_to_file_unified(line, "guest"), "guest"))
+        else:
+            segs.append((tts_line_to_file_unified(line, "host"), "host"))
+
+    final = None
+    for path, who in segs:
+        seg = AudioSegment.from_file(path, format="mp3")
+        # Subtle tempo differences for separation
+        if who == "host":
+            seg = effects.speedup(seg, playback_speed=1.06, crossfade=0)
+        else:
+            # pydub has speedup; for slowdown <1.0, speedup may distort—keep modest change or skip if artifacts
+            try:
+                seg = effects.speedup(seg, playback_speed=0.95, crossfade=0)
+            except Exception:
+                pass
+        final = seg if final is None else final + seg
+
+    out_path = os.path.join(AUDIO_OUT_DIR, f"{int(time.time())}_podcast_{uuid.uuid4().hex[:6]}.mp3")
+    final.export(out_path, format="mp3")
+    return out_path
 
 def answer_with_podcast_for_user(username: str, query: str = "") -> Tuple[str, str]:
     docs = retrieve_context(username, query=query, k=12)
     dialogue = synthesize_dialogue(username, query, docs, min_words=TARGET_WORDS)
     audio_path = generate_two_voice_audio(dialogue)
-    return dialogue, audio_path  # Return the fresh dialogue and its MP3 path
+    return dialogue, audio_path or ""
 
-def on_generate(username, query, pwd):
-    if not check_password(pwd):
-        return "Invalid password.", None
-    dlg, audio = answer_with_podcast_for_user(username, query=query or "")
-    return dlg, audio  # Textbox gets dlg; Audio gets the new filepath
 # --------------------------
 # Gradio UI
 # --------------------------
@@ -346,8 +381,7 @@ def main_ui():
                 add_docs_btn = gr.Button("Add Documents")
                 add_docs_output = gr.Label(value="")
             with gr.Column():
-                # Question is optional; auto generation triggers after adding docs
-                query_input = gr.Textbox(label="(Optional) Add a focus question", value="")
+                query_input = gr.Textbox(label="(Optional) Focus question", value="")
                 generate_btn = gr.Button("Generate Podcast")
                 podcast_text_output = gr.Textbox(label="Generated Dialogue", lines=18)
                 podcast_audio_output = gr.Audio(label="Download Podcast", type="filepath")
@@ -358,11 +392,9 @@ def main_ui():
 
         def on_add_docs(username, files, pwd):
             if not check_password(pwd):
-                return "Invalid password."
+                return "Invalid password.", None, None
             msg = add_documents_for_user(username, files)
-            # Auto-generate podcast immediately (no question needed)
             dlg, audio = answer_with_podcast_for_user(username, query="")
-            # Update both the add_docs label and the outputs via chained events below
             return msg, dlg, audio
 
         def on_generate(username, query, pwd):
@@ -372,26 +404,32 @@ def main_ui():
             return dlg, audio
 
         login_btn.click(on_login, inputs=password, outputs=login_msg)
-        # On add_docs, also update the podcast outputs so generation is automatic
-        add_docs_btn.click(on_add_docs, inputs=[username_input, upload_files, password],
-                           outputs=[add_docs_output, podcast_text_output, podcast_audio_output])
 
-        # Manual regenerate
-        generate_btn.click(on_generate, inputs=[username_input, query_input, password],
-                           outputs=[podcast_text_output, podcast_audio_output])
+        add_docs_btn.click(
+            on_add_docs,
+            inputs=[username_input, upload_files, password],
+            outputs=[add_docs_output, podcast_text_output, podcast_audio_output]
+        )
 
-        # Optional: also trigger on file upload directly (auto on change)
+        # Auto-generate on file upload as well
         def on_files_uploaded(files, username, pwd):
-            # only act if already logged in
             if not check_password(pwd):
                 return gr.update(), gr.update(), gr.update()
             msg = add_documents_for_user(username, files)
             dlg, audio = answer_with_podcast_for_user(username, query="")
             return msg, dlg, audio
 
-        # Bind .upload event so dropping files can auto-generate without clicking "Add Documents"
-        upload_files.upload(on_files_uploaded, inputs=[upload_files, username_input, password],
-                            outputs=[add_docs_output, podcast_text_output, podcast_audio_output])
+        upload_files.upload(
+            on_files_uploaded,
+            inputs=[upload_files, username_input, password],
+            outputs=[add_docs_output, podcast_text_output, podcast_audio_output]
+        )
+
+        generate_btn.click(
+            on_generate,
+            inputs=[username_input, query_input, password],
+            outputs=[podcast_text_output, podcast_audio_output]
+        )
 
     demo.launch()