ref

gradio_app.py

@@ -1,263 +1,172 @@
-# filepath: /Users/udaylunawat/Downloads/Data-Science-Projects/NotebookLM_clone/gradio_app.py
 import os
 import tempfile
 import gradio as gr
-from notebook_lm_kokoro import generate_podcast_script, KPipeline
-import soundfile as sf
-import numpy as np
-import ast
 import shutil
+import ast
+import numpy as np
+import soundfile as sf
 import warnings
-import os
-import gradio as gr
-import concurrent.futures
-import multiprocessing
-from notebook_lm_kokoro import generate_podcast_script, generate_audio_from_script
-warnings.filterwarnings("ignore")
 
-# Define number of workers based on CPU cores
-NUM_WORKERS = multiprocessing.cpu_count()  # Gets total CPU cores
+try:
+    from moshi.models.tts import TTSModel
+except ImportError:
+    print("Moshi TTSModel not available — install Kyutai’s version via pip.")
+    TTSModel = None
+
+from notebook_lm_kokoro import (
+    generate_podcast_script,
+    generate_audio_from_script,
+    generate_audio_kyutai,
+    KPipeline,
+)
 
-def process_segment(entry_and_voice_map):
-    entry, voice_map = entry_and_voice_map  # Unpack the tuple
+warnings.filterwarnings("ignore")
+
+def process_segment(entry, voice_map):
     speaker, dialogue = entry
     chosen_voice = voice_map.get(speaker, "af_heart")
-    print(f"Generating audio for {speaker} with voice '{chosen_voice}'...")
-    
     pipeline = KPipeline(lang_code="a", repo_id="hexgrad/Kokoro-82M")
     generator = pipeline(dialogue, voice=chosen_voice)
-    
-    segment_audio = []
-    for _, _, audio in generator:
-        segment_audio.append(audio)
-        
-    if segment_audio:
-        return np.concatenate(segment_audio, axis=0)
-    return None
+    return np.concatenate([audio for _, _, audio in generator], axis=0) if generator else None
 
 def generate_audio_from_script_with_voices(script, speaker1_voice, speaker2_voice, output_file):
-    voice_map = {"Speaker 1": speaker1_voice, "Speaker 2": speaker2_voice}
-    
-    # Clean up the script string if needed
-    script = script.strip()
-    if not script.startswith("[") or not script.endswith("]"):
-        print("Invalid transcript format. Expected a list of tuples.")
-        return None
+    print("[DEBUG] Raw transcript string:")
+    print(script)
 
+    voice_map = {"Speaker 1": speaker1_voice, "Speaker 2": speaker2_voice}
     try:
         transcript_list = ast.literal_eval(script)
         if not isinstance(transcript_list, list):
             raise ValueError("Transcript is not a list")
 
-        all_audio_segments = []
-        # Prepare input data with voice_map for each entry
-        entries_with_voice_map = [(entry, voice_map) for entry in transcript_list]
+        entries = [entry for entry in transcript_list if isinstance(entry, tuple) and len(entry) == 2]
+        results = [process_segment(entry, voice_map) for entry in entries if entry is not None]
 
-        try:
-            # Process segments in parallel
-            with concurrent.futures.ProcessPoolExecutor(max_workers=NUM_WORKERS) as executor:
-                # Map the processing function across all dialogue entries
-                results = list(executor.map(process_segment, entries_with_voice_map))
-                
-                # Filter out None results and combine audio segments
-                all_audio_segments = [r for r in results if r is not None]
-        
-        except Exception as e:
-            print(f"Error during audio generation: {e}")
+        if not results:
             return None
-        
-        if not all_audio_segments:
-            print("No audio segments were generated")
-            return None
-
-        # Add a pause between segments
         sample_rate = 24000
         pause = np.zeros(sample_rate, dtype=np.float32)
-        final_audio = all_audio_segments[0]
-        for seg in all_audio_segments[1:]:
+        final_audio = results[0]
+        for seg in results[1:]:
             final_audio = np.concatenate((final_audio, pause, seg), axis=0)
-
         sf.write(output_file, final_audio, sample_rate)
-        print(f"Saved final audio as {output_file}")
         return output_file
-
     except Exception as e:
-        print(f"Error processing transcript: {e}")
+        print(f"Transcript parse error: {e}")
         return None
 
-
-def process_pdf(pdf_file, speaker1_voice, speaker2_voice, provider, api_key, openrouter_base=None):
-    """Process the uploaded PDF file and generate audio"""
+def process_pdf(pdf_file, speaker1_voice, speaker2_voice, kyutai_voice1, kyutai_voice2,
+                provider, openai_key=None, openrouter_key=None, openrouter_base=None, tts_engine=None):
     try:
-        # Set API configuration based on provider
-        os.environ["OPENAI_API_KEY"] = api_key
-        if provider == "openai":
+        if provider == "openai" and not openai_key:
+            return "OpenAI API key is required", None
+        if provider == "openrouter" and not openrouter_key:
+            return "OpenRouter API key is required", None
+
+        if provider in ["openai", "kyutai"]:
+            os.environ["OPENAI_API_KEY"] = openai_key or ""
             os.environ["OPENROUTER_API_BASE"] = "https://api.openai.com/v1"
-        else:
+        if provider in ["openrouter", "kyutai"]:
+            os.environ["OPENAI_API_KEY"] = openrouter_key or ""
             os.environ["OPENROUTER_API_BASE"] = openrouter_base or "https://openrouter.ai/api/v1"
 
-        # Check if file is uploaded
         if pdf_file is None:
             return "No file uploaded", None
 
-        # Use /tmp if writable, else fallback to current directory
-        base_dir = "/tmp" if os.access("/tmp", os.W_OK) else os.getcwd()
+        tmp_path = pdf_file.name
 
-        # Save uploaded PDF to temp location
-        tmp_path = os.path.join(base_dir, f"uploaded_{os.path.basename(pdf_file.name)}")
-        shutil.copy2(pdf_file.name, tmp_path)
-        print(f"[INFO] Uploaded PDF saved at {tmp_path}")
+        script_provider = "openrouter" if provider == "kyutai" and openrouter_key else provider
+        transcript, _ = generate_podcast_script(pdf_file.name, provider=script_provider)
 
-        # Generate podcast script
-        transcript, transcript_path = generate_podcast_script(tmp_path, provider=provider)
         if transcript is None:
-            return "Error generating transcript", None
-
-        # Define output file path
-        audio_output_path = os.path.join(
-            os.path.dirname(tmp_path),
-            f"audio_{os.path.basename(tmp_path).replace('.pdf', '.wav')}"
-        )
-
-        # Generate audio using ProcessPoolExecutor
-        with concurrent.futures.ProcessPoolExecutor(max_workers=NUM_WORKERS) as executor:
-            print(f"[INFO] Processing audio with {NUM_WORKERS} CPU cores")
-            future = executor.submit(
-                generate_audio_from_script_with_voices,
-                transcript, speaker1_voice, speaker2_voice, audio_output_path
-            )
-            result = future.result()
+            return "Transcript generation failed: got None", None
+        if not transcript.strip().startswith("["):
+            return f"Malformed transcript:\n{transcript}", None
 
-            if result is None:
-                return "Error generating audio", None
+        audio_path = os.path.join(os.path.dirname(tmp_path), f"audio_{os.path.basename(tmp_path).replace('.pdf', '.wav')}")
 
-            return "Process complete!", result
+        if tts_engine == "kyutai":
+            result = generate_audio_kyutai(transcript, kyutai_voice1, kyutai_voice2, audio_path)
+        else:
+            result = generate_audio_from_script_with_voices(transcript, speaker1_voice, speaker2_voice, audio_path)
 
+        return ("Process complete!", result) if result else ("Error generating audio", None)
     except Exception as e:
-        print(f"[ERROR] process_pdf failed: {str(e)}")
-        return f"Error processing file: {str(e)}", None
-
+        print(f"process_pdf error: {e}")
+        return f"Error: {e}", None
+
+def update_ui(provider, tts_engine):
+    return [
+        gr.update(visible=tts_engine == "kokoro"),
+        gr.update(visible=tts_engine == "kokoro"),
+        gr.update(visible=tts_engine == "kyutai"),
+        gr.update(visible=tts_engine == "kyutai"),
+        gr.update(visible=provider in ["openai", "kyutai"]),
+        gr.update(visible=provider in ["openrouter", "kyutai"]),
+        gr.update(visible=provider == "openrouter"),
+    ]
 
 def create_gradio_app():
-    # Add CSS for better styling
-    css = """
-    .gradio-container {max-width: 900px !important}
-    """
-    
+    css = ".gradio-container {max-width: 900px !important}"
     with gr.Blocks(css=css, theme=gr.themes.Soft()) as app:
-        gr.Markdown(
-            """
-            # 📚 NotebookLM-Kokoro TTS App
-            Upload a PDF, choose voices, and generate conversational audio using Kokoro TTS.
-            """
-        )
-        
+        gr.Markdown("# 🎧 PDF to Podcast — NotebookLM + Kokoro/Kyutai")
+
+        pdf_input = gr.File(file_types=[".pdf"], type="filepath", label="📄 Upload your PDF", scale=2)
+
         with gr.Row():
-            with gr.Column(scale=2):
-                pdf_input = gr.File(
-                    label="Upload PDF Document",
-                    file_types=[".pdf"],
-                    type="filepath"
-                )
-                
-                with gr.Row():
-                    speaker1_voice = gr.Dropdown(
-                        choices=["af_heart", "af_bella", "hf_beta"],
-                        value="af_heart",
-                        label="Speaker 1 Voice"
-                    )
-                    speaker2_voice = gr.Dropdown(
-                        choices=["af_nicole", "af_heart", "bf_emma"],
-                        value="bf_emma",
-                        label="Speaker 2 Voice"
-                    )
-                
+            speaker1_voice = gr.Dropdown(["af_heart", "af_bella", "hf_beta"], value="af_heart", label="Speaker 1 Voice")
+            speaker2_voice = gr.Dropdown(["af_nicole", "af_heart", "bf_emma"], value="bf_emma", label="Speaker 2 Voice")
+            provider = gr.Radio(["openai", "openrouter"], value="openrouter", label="API Provider")
+            openai_key = gr.Textbox(type="password", label="OpenAI Key")
+            openrouter_key = gr.Textbox(type="password", label="OpenRouter Key")
+            openrouter_base = gr.Textbox(placeholder="https://openrouter.ai/api/v1", label="OpenRouter Base URL")
+            tts_engine = gr.Radio(["kokoro", "kyutai"], value="kokoro", label="TTS Engine")
 
-                with gr.Group():
-                    provider = gr.Radio(
-                        choices=["openai", "openrouter"],
-                        value="openrouter",
-                        label="API Provider"
-                    )
-                    
-                    api_key = gr.Textbox(
-                        label="API Key",
-                        placeholder="Enter your API key here...",
-                        type="password",
-                        elem_classes="api-input"
-                    )
-                    
-                    openrouter_base = gr.Textbox(
-                        label="OpenRouter Base URL (optional)",
-                        placeholder="https://openrouter.ai/api/v1",
-                        visible=False,
-                        elem_classes="api-input"
-                    )
+        with gr.Row():
+            kyutai_voice1 = gr.Dropdown([
+                "expresso/ex03-ex01_happy_001_channel1_334s.wav",
+                "expresso/ex03-ex02_narration_001_channel1_674s.wav",
+                "vctk/p226_023_mic1.wav"
+            ],
+            value="expresso/ex03-ex01_happy_001_channel1_334s.wav",
+            label="Kyutai Voice 1",
+            visible=True)
+
+            kyutai_voice2 = gr.Dropdown([
+                "expresso/ex03-ex01_happy_001_channel1_334s.wav",
+                "expresso/ex03-ex02_narration_001_channel1_674s.wav",
+                "vctk/p225_023_mic1.wav"
+            ],
+            value="expresso/ex03-ex02_narration_001_channel1_674s.wav",
+            label="Kyutai Voice 2",
+            visible=True)
+
+        submit_btn = gr.Button("🎙️ Generate Podcast", variant="primary")
+        status_output = gr.Textbox(label="📝 Status", interactive=False)
+        audio_output = gr.Audio(type="filepath", label="🎵 Your Podcast")
 
-                    # Show/hide OpenRouter base URL based on provider selection
-                    def toggle_openrouter_base(provider_choice):
-                        return gr.update(visible=provider_choice == "openrouter")
-                    
-                    provider.change(
-                        fn=toggle_openrouter_base,
-                        inputs=[provider],
-                        outputs=[openrouter_base]
-                    )
-                
-                submit_btn = gr.Button("🎙️ Generate Audio", variant="primary")
-            
-            with gr.Column(scale=2):
-                status_output = gr.Textbox(
-                    label="Status",
-                    placeholder="Processing status will appear here..."
-                )
-                audio_output = gr.Audio(
-                    label="Generated Audio",
-                    type="filepath"
-                )
-        
-        # # Examples section
-        # gr.Examples(
-        #     examples=[
-        #         ["sample.pdf", "af_heart", "af_nicole", "openrouter", "your-api-key-here", "https://openrouter.ai/api/v1"],
-        #     ],
-        #     inputs=[pdf_input, speaker1_voice, speaker2_voice, provider, api_key, openrouter_base],
-        #     outputs=[status_output, audio_output],
-        #     fn=process_pdf,
-        #     cache_examples=True,
-        # )
-        
         submit_btn.click(
-            fn=process_pdf,
-            inputs=[
-                pdf_input, 
-                speaker1_voice, 
-                speaker2_voice, 
-                provider,
-                api_key,
-                openrouter_base
-            ],
-            outputs=[status_output, audio_output],
-            api_name="generate"
+            process_pdf,
+            inputs=[pdf_input, speaker1_voice, speaker2_voice, kyutai_voice1, kyutai_voice2,
+                    provider, openai_key, openrouter_key, openrouter_base, tts_engine],
+            outputs=[status_output, audio_output]
         )
-        
-        gr.Markdown(
-            """
-            ### 📝 Notes
-            - Make sure your PDF is readable and contains text (not scanned images)
-            - Processing large PDFs may take a few minutes
-            - You need a valid OpenAI/OpenRouter API key set as environment variable
-            """
-        )
-    
+
+        provider.change(update_ui, [provider, tts_engine],
+                        [speaker1_voice, speaker2_voice, kyutai_voice1, kyutai_voice2,
+                         openai_key, openrouter_key, openrouter_base])
+        tts_engine.change(update_ui, [provider, tts_engine],
+                          [speaker1_voice, speaker2_voice, kyutai_voice1, kyutai_voice2,
+                           openai_key, openrouter_key, openrouter_base])
+
+        gr.Markdown("""
+        **📌 Tips**
+        - Upload a clean, structured PDF.
+        - Pick your API provider and enter relevant keys.
+        - Choose the TTS engine and customize voices.
+        """)
+
     return app
 
 if __name__ == "__main__":
-    demo = create_gradio_app()
-    demo.queue().launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=True,
-        debug=True,
-        pwa=True
-    )
+    create_gradio_app().queue().launch(server_name="0.0.0.0", server_port=7860, share=True, debug=True, pwa=True)

notebook_lm_kokoro.py

@@ -12,17 +12,23 @@ If using OpenRouter, you can also set:
 """
 
 from kokoro import KPipeline
-from IPython.display import Audio  # Only needed if displaying in a notebook
 import soundfile as sf
 import PyPDF2
 import numpy as np
 import openai
 import os
 import shutil
-import asyncio
 import ast
 import json
 import warnings
+import torch
+import time
+try:
+    from moshi.models.loaders import CheckpointInfo
+    from moshi.models.tts import DEFAULT_DSM_TTS_REPO, DEFAULT_DSM_TTS_VOICE_REPO, TTSModel
+except ImportError:
+    CheckpointInfo = None
+    TTSModel = None
 warnings.filterwarnings("ignore")
 
 # Set your OpenAI (or OpenRouter) API key from the environment
@@ -30,8 +36,6 @@ openai.api_key = os.getenv("OPENAI_API_KEY")
 # For OpenRouter compatibility, set the API base if provided.
 openai.api_base = os.getenv("OPENROUTER_API_BASE", "https://api.openai.com/v1")
 
-pdf = "1706.03762v7.pdf"
-
 
 def pdf_to_prompted_text(pdf_path):
     """
@@ -134,7 +138,7 @@ def generate_audio_from_script(script, output_file="podcast_audio.wav"):
     # Clean up the script string if needed
     script = script.strip()
     if not script.startswith("[") or not script.endswith("]"):
-        print("Invalid transcript format. Expected a list of tuples.")
+        print("[ERROR] Invalid transcript format. Expected a list of tuples.")
         return
 
     try:
@@ -147,45 +151,102 @@ def generate_audio_from_script(script, output_file="podcast_audio.wav"):
         # Process each dialogue entry
         for i, entry in enumerate(transcript_list):
             if not isinstance(entry, tuple) or len(entry) != 2:
-                print(f"Skipping invalid entry {i}: {entry}")
+                print(f"[WARNING] Skipping invalid entry {i}: {entry}")
                 continue
 
             speaker, dialogue = entry
             chosen_voice = voice_map.get(speaker, "af_heart")
-            print(f"Generating audio for {speaker} with voice '{chosen_voice}'...")
+            print(f"[INFO] Generating audio for {speaker} with voice '{chosen_voice}'...")
 
-            pipeline = KPipeline(lang_code="a")
+            pipeline = KPipeline(lang_code="a", repo_id="hexgrad/Kokoro-82M")
             generator = pipeline(dialogue, voice=chosen_voice)
 
-            segment_audio = []
-            for j, (gs, ps, audio) in enumerate(generator):
-                # print(
-                #     f"{speaker} - Segment {j}: Global Step = {gs}, Partial Step = {ps}"
-                # )
-                segment_audio.append(audio)
-
+            segment_audio = [audio for _, _, audio in generator]
             if segment_audio:
-                segment_full = np.concatenate(segment_audio, axis=0)
-                all_audio_segments.append(segment_full)
+                all_audio_segments.append(np.concatenate(segment_audio, axis=0))
 
         if not all_audio_segments:
-            print("No audio segments were generated.")
+            print("[ERROR] No audio segments were generated.")
             return
 
         # Add a pause between segments
         sample_rate = 24000
         pause = np.zeros(sample_rate, dtype=np.float32)
-        final_audio = all_audio_segments[0]
-        for seg in all_audio_segments[1:]:
-            final_audio = np.concatenate((final_audio, pause, seg), axis=0)
-
+        final_audio = np.concatenate(
+            [seg if i == 0 else np.concatenate((pause, seg), axis=0)
+             for i, seg in enumerate(all_audio_segments)],
+            axis=0
+        )
         sf.write(output_file, final_audio, sample_rate)
-        print(f"Saved final audio as {output_file}")
+        print(f"[INFO] Saved final audio as {output_file}")
 
     except Exception as e:
-        print(f"Error processing transcript: {e}")
+        import traceback
+        print(f"[ERROR] Exception while parsing transcript or generating audio: {e}")
+        traceback.print_exc()
         return
 
+def generate_audio_kyutai(script, speaker1_voice=None, speaker2_voice=None, output_file="kyutai_audio.wav"):
+    if TTSModel is None:
+        print("Moshi is not installed.")
+        return None
+
+    try:
+        print(f"[INFO] Requested Kyutai voices: {speaker1_voice=}, {speaker2_voice=}")
+        # Reject absolute/local paths
+        if os.path.isabs(speaker1_voice) or os.path.isfile(speaker1_voice):
+            raise ValueError(f"❌ Invalid voice path for speaker1: {speaker1_voice}")
+        if os.path.isabs(speaker2_voice) or os.path.isfile(speaker2_voice):
+            raise ValueError(f"❌ Invalid voice path for speaker2: {speaker2_voice}")
+
+        transcript_list = ast.literal_eval(script)
+
+        # Load TTS model
+        checkpoint_info = CheckpointInfo.from_hf_repo(DEFAULT_DSM_TTS_REPO)
+        tts_model = TTSModel.from_checkpoint_info(
+            checkpoint_info,
+            n_q=32,
+            temp=0.6,
+            device=torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        )
+
+        # Use voice names directly from dropdown
+        print("[INFO] Resolving voice paths...")
+
+        start = time.time()
+        voice1_path = tts_model.get_voice_path(speaker1_voice)
+        print(f"[INFO] Got voice1_path in {time.time() - start:.2f}s")
+
+        start = time.time()
+        voice2_path = tts_model.get_voice_path(speaker2_voice)
+        print(f"[INFO] Got voice2_path in {time.time() - start:.2f}s")
+
+        texts = [dialogue for _, dialogue in transcript_list]
+        entries = tts_model.prepare_script(texts, padding_between=1)
+
+        condition_attributes = tts_model.make_condition_attributes([voice1_path, voice2_path], cfg_coef=2.0)
+
+        pcms = []
+        def _on_frame(frame):
+            if (frame != -1).all():
+                pcm = tts_model.mimi.decode(frame[:, 1:, :]).cpu().numpy()
+                pcms.append(np.clip(pcm[0, 0], -1, 1))
+
+        with tts_model.mimi.streaming(1):
+            tts_model.generate([entries], [condition_attributes], on_frame=_on_frame)
+
+        if pcms:
+            audio = np.concatenate(pcms, axis=-1)
+            sf.write(output_file, audio, tts_model.mimi.sample_rate)
+            print(f"[SUCCESS] Audio saved to: {output_file}")
+            return output_file
+
+        print("[WARNING] No audio segments were produced.")
+        return None
+
+    except Exception as e:
+        print(f"[ERROR] Kyutai TTS error: {e}")
+        return None
 
 def generate_tts():
     pipeline = KPipeline(lang_code="a")
@@ -222,25 +283,23 @@ def generate_podcast_script(
     Set provider="openrouter" to use OpenRouter, otherwise uses OpenAI.
     """
     pdf_basename = os.path.splitext(os.path.basename(pdf_path))[0]
-    
-    # Use /tmp if writable, else fallback to current working directory
-    base_dir = "/tmp" if os.access("/tmp", os.W_OK) else os.getcwd()
-    folder = os.path.join(base_dir, pdf_basename)
+    folder = os.path.join("/tmp", pdf_basename)
     os.makedirs(folder, exist_ok=True)
 
     destination_pdf = os.path.join(folder, os.path.basename(pdf_path))
-    if not os.path.exists(destination_pdf):
+    try:
         shutil.copy(pdf_path, destination_pdf)
-        print(f"Copied {pdf_path} to {destination_pdf}")
-    else:
-        print(f"PDF already copied at {destination_pdf}")
+        print(f"[INFO] Copied {pdf_path} to {destination_pdf}")
+    except PermissionError:
+        print(f"[WARNING] Cannot copy PDF to {destination_pdf}, using original path.")
+        destination_pdf = pdf_path  # fallback
 
     transcript_path = os.path.join(folder, output_file)
     # If transcript exists, load and return it without calling the API.
     if os.path.exists(transcript_path):
         with open(transcript_path, "r") as f:
             transcript = f.read()
-        print(f"Transcript loaded from {transcript_path}")
+        print(f"[INFO] Transcript loaded from {transcript_path}")
         return transcript, transcript_path
 
     # Otherwise, generate the transcript.
@@ -265,15 +324,15 @@ def generate_podcast_script(
     if provider == "openrouter":
         api_key = os.getenv("OPENAI_API_KEY")
         base_url = os.getenv("OPENROUTER_API_BASE", "https://openrouter.ai/api/v1")
-        print("Using OpenRouter API endpoint.")
+        print("[INFO] Using OpenRouter API endpoint.")
     else:
         api_key = os.getenv("OPENAI_API_KEY")
         base_url = "https://api.openai.com/v1"
-        print("Using OpenAI API endpoint.")
+        print("[INFO] Using OpenAI API endpoint.")
 
     client = openai.OpenAI(api_key=api_key, base_url=base_url)
     
-    print(f"Sending request to {base_url} to generate a podcast script...")
+    print(f"[INFO] Sending request to {base_url} to generate a podcast script...")
     response = client.chat.completions.create(
         model="gpt-4o-mini",
         messages=messages,
@@ -298,10 +357,10 @@ def generate_podcast_script(
         transcript_list = []
         for i, entry in enumerate(dialogue):
             if not isinstance(entry, list) or len(entry) != 2:
-                print(f"Skipping invalid dialogue entry {i}: {entry}")
+                print(f"[WARNING] Skipping invalid dialogue entry {i}: {entry}")
                 continue
             if entry[0] not in ["Speaker 1", "Speaker 2"]:
-                print(f"Invalid speaker label in entry {i}: {entry[0]}")
+                print(f"[WARNING] Invalid speaker label in entry {i}: {entry[0]}")
                 continue
             transcript_list.append(tuple(entry))
         
@@ -312,31 +371,26 @@ def generate_podcast_script(
         script = str(transcript_list)
         
     except json.JSONDecodeError as e:
-        print(f"Error: Invalid JSON response from API: {e}")
-        print(f"Raw response: {response.choices[0].message.content}")
+        print(f"[ERROR] Invalid JSON response from API: {e}")
+        print(f"[ERROR] Raw response: {response.choices[0].message.content}")
         return None, None
     except Exception as e:
-        print(f"Error processing response: {e}")
+        print(f"[ERROR] Error processing response: {e}")
         return None, None
 
     # Save the transcript
     with open(transcript_path, "w") as f:
         f.write(script)
-    print(f"Saved podcast script as {transcript_path}")
+    print(f"[INFO] Saved podcast script as {transcript_path}")
     
     return script, transcript_path
 
 
-async def _generate_script_async(messages):
-    response = await openai.ChatCompletion.acreate(
-        model="gpt-4o-mini", messages=messages, temperature=0.7, max_tokens=20000
-    )
-    return response["choices"][0]["message"]["content"]
-
 
+# Minimal test harness
 if __name__ == "__main__":
-    # For example, to generate a podcast script from the PDF using OpenRouter or OpenAI:
+    pdf = "1706.03762v7.pdf"
     transcript, transcript_path = generate_podcast_script(pdf, provider="openrouter")
-    # Use the transcript to generate and save the audio. The output file is stored in the same folder.
-    audio_output = transcript_path.replace(".txt", ".wav")
-    generate_audio_from_script(transcript, output_file=audio_output)
+    if transcript and transcript_path:
+        audio_output = transcript_path.replace(".txt", ".wav")
+        generate_audio_from_script(transcript, output_file=audio_output)