Update app.py

app.py

@@ -1,656 +1,523 @@
-import gradio as gr
-import google.generativeai as genai
-from gtts import gTTS
-import pyttsx3
-from pathlib import Path
-import tempfile
-import os
-from uuid import uuid4
-import time
-import asyncio
-import edge_tts
-import numpy as np
-import soundfile as sf
-import re
-
-# Voice configurations for different speakers
-VOICE_CONFIGS = {
-    "2_speakers": [
-        {"name": "Alex", "voice": "en-US-AriaNeural", "gender": "female"},
-        {"name": "Brian", "voice": "en-US-GuyNeural", "gender": "male"}
-    ],
-    "3_speakers": [
-        {"name": "Sarah", "voice": "en-US-JennyNeural", "gender": "female"},
-        {"name": "Mike", "voice": "en-US-BrandonNeural", "gender": "male"},
-        {"name": "Emma", "voice": "en-US-AriaNeural", "gender": "female"}
-    ],
-    "4_speakers": [
-        {"name": "Sarah", "voice": "en-US-JennyNeural", "gender": "female"},
-        {"name": "Mike", "voice": "en-US-BrandonNeural", "gender": "male"},
-        {"name": "Emma", "voice": "en-US-AriaNeural", "gender": "female"},
-        {"name": "David", "voice": "en-US-GuyNeural", "gender": "male"}
-    ]
-}
-
-# Initialize Gemini client
-client = None
-
-def init_gemini(api_key):
-    """Initialize Gemini client with API key"""
-    global client
-    if api_key:
-        try:
-            genai.configure(api_key=api_key)
-            client = genai.GenerativeModel('gemini-2.0-flash')
-            return "✅ Gemini API connected successfully!"
-        except Exception as e:
-            return f"❌ Gemini API error: {str(e)}"
-    return "ℹ️ Add Gemini API key for better summaries"
-
-def generate_with_gtts(text, filename):
-    """Generate speech using Google's gTTS"""
-    try:
-        tts = gTTS(text=text, lang='en', slow=False)
-        tts.save(filename)
-        return filename, None
-    except Exception as e:
-        return None, f"gTTS Error: {str(e)}"
-
-async def generate_with_edge_tts(text, voice, filename):
-    """Generate speech using Microsoft Edge TTS with specific voice"""
-    try:
-        communicate = edge_tts.Communicate(text, voice)
-        await communicate.save(filename)
-        return filename, None
-    except Exception as e:
-        return None, f"Edge TTS Error: {str(e)}"
-
-def combine_audio_files(audio_files, output_filename):
-    """Combine multiple audio files into one"""
-    try:
-        from scipy.signal import resample
-        combined_audio = []
-        sample_rate = None
-        
-        for audio_file in audio_files:
-            if os.path.exists(audio_file):
-                data, sr = sf.read(audio_file)
-                if sample_rate is None:
-                    sample_rate = sr
-                elif sr != sample_rate:
-                    # Resample if needed
-                    data = resample(data, int(len(data) * sample_rate / sr))
-                
-                combined_audio.append(data)
-                # Add small pause between speakers
-                pause = np.zeros(int(sample_rate * 0.5))  # 0.5 second pause
-                combined_audio.append(pause)
-        
-        if combined_audio:
-            final_audio = np.concatenate(combined_audio)
-            sf.write(output_filename, final_audio, sample_rate)
-            return output_filename, None
-        else:
-            return None, "No audio files to combine"
-    except Exception as e:
-        return None, f"Audio combination error: {str(e)}"
-
-async def generate_multi_speaker_audio(script_parts, speaker_count, output_filename):
-    """Generate multi-speaker podcast audio"""
-    try:
-        voice_config = VOICE_CONFIGS[f"{speaker_count}_speakers"]
-        audio_files = []
-        
-        for i, (speaker_text, speaker_idx) in enumerate(script_parts):
-            voice = voice_config[speaker_idx]["voice"]
-            temp_filename = f"temp_speaker_{i}_{uuid4().hex[:8]}.wav"
-            
-            result, error = await generate_with_edge_tts(speaker_text, voice, temp_filename)
-            if result:
-                audio_files.append(temp_filename)
-            else:
-                # Cleanup and return error
-                for f in audio_files:
-                    try:
-                        os.unlink(f)
-                    except:
-                        pass
-                return None, f"Error generating voice {i+1}: {error}"
-        
-        # Combine all audio files
-        final_file, error = combine_audio_files(audio_files, output_filename)
-        
-        # Cleanup temp files
-        for f in audio_files:
-            try:
-                os.unlink(f)
-            except:
-                pass
-        
-        return final_file, error
-    except Exception as e:
-        return None, f"Multi-speaker generation error: {str(e)}"
-
-def generate_with_pyttsx3(text, filename):
-    """Generate speech using system's TTS engine"""
-    try:
-        engine = pyttsx3.init()
-        
-        # Set properties for better audio quality
-        engine.setProperty('rate', 180)
-        engine.setProperty('volume', 0.9)
-        
-        # Try to find a good voice
-        voices = engine.getProperty('voices')
-        for voice in voices:
-            if 'female' in voice.name.lower() or 'zira' in voice.name.lower():
-                engine.setProperty('voice', voice.id)
-                break
-        
-        engine.save_to_file(text, filename)
-        engine.runAndWait()
-        return filename, None
-    except Exception as e:
-        return None, f"pyttsx3 Error: {str(e)}"
-
-def generate_podcast_script(text, speaker_count, use_gemini):
-    """Generate a podcast script with multiple speakers"""
-    if use_gemini and client:
-        try:
-            voice_config = VOICE_CONFIGS[f"{speaker_count}_speakers"]
-            speaker_names = [config["name"] for config in voice_config]
-            
-            prompt = f"""Create an engaging podcast conversation between {speaker_count} hosts: {', '.join(speaker_names)}.
-            
-            Transform this text into a natural conversation where each speaker contributes meaningfully.
-            
-            Guidelines:
-            - Make it sound like a real podcast discussion
-            - Each speaker should have distinct perspectives and speaking styles
-            - Include natural transitions and interactions
-            - Keep it under 2500 characters total
-            - Use speaker names clearly (e.g., "Sarah: Hello everyone...")
-            - Make it conversational and engaging
-            
-            Original text: {text[:3000]}
-            
-            Format the output with clear speaker labels like:
-            Speaker1: [text]
-            Speaker2: [text]
-            etc."""
-            
-            response = client.generate_content(prompt)
-            return response.text
-        except Exception as e:
-            # Fallback to simple script
-            return f"Error generating script: {str(e)}"
-    else:
-        # Simple fallback for single speaker
-        return text[:2000] + ("..." if len(text) > 2000 else "")
-
-def parse_script_for_speakers(script, speaker_count):
-    """Parse the script to extract speaker parts"""
-    try:
-        voice_config = VOICE_CONFIGS[f"{speaker_count}_speakers"]
-        speaker_names = [config["name"] for config in voice_config]
-        
-        # Split script by speaker patterns
-        parts = []
-        lines = script.split('\n')
-        current_speaker = 0
-        current_text = ""
-        
-        for line in lines:
-            line = line.strip()
-            if not line:
-                continue
-                
-            # Check if line starts with a speaker name
-            speaker_found = False
-            for i, name in enumerate(speaker_names):
-                if line.lower().startswith(f"{name.lower()}:"):
-                    # Save previous speaker's text
-                    if current_text.strip():
-                        parts.append((current_text.strip(), current_speaker))
-                    # Start new speaker
-                    current_speaker = i
-                    current_text = line[len(name)+1:].strip()
-                    speaker_found = True
-                    break
-            
-            if not speaker_found:
-                current_text += " " + line
-        
-        # Add final speaker text
-        if current_text.strip():
-            parts.append((current_text.strip(), current_speaker))
-        
-        # If no speakers were found, distribute text evenly
-        if not parts and script.strip():
-            sentences = script.split('. ')
-            sentences_per_speaker = max(1, len(sentences) // speaker_count)
-            
-            for i in range(speaker_count):
-                start_idx = i * sentences_per_speaker
-                if i == speaker_count - 1:  # Last speaker gets remaining sentences
-                    speaker_sentences = sentences[start_idx:]
-                else:
-                    speaker_sentences = sentences[start_idx:start_idx + sentences_per_speaker]
-                
-                if speaker_sentences:
-                    speaker_text = '. '.join(speaker_sentences)
-                    if not speaker_text.endswith('.'):
-                        speaker_text += '.'
-                    parts.append((speaker_text, i))
-        
-        return parts
-    except Exception as e:
-        # Fallback: single speaker
-        return [(script, 0)]
-
-def create_podcast(text, use_gemini, tts_engine, speaker_count, progress=gr.Progress()):
-    """Main function to create podcast from text with multiple speakers"""
-    progress(0.1, "Starting processing...")
-    
-    if not text.strip():
-        return None, "❌ Please enter some text first!", ""
-    
-    # Step 1: Generate script using Gemini or use raw text
-    progress(0.3, "Generating podcast script...")
-    
-    podcast_script = generate_podcast_script(text, speaker_count, use_gemini)
-    
-    progress(0.5, "Parsing script for speakers...")
-    
-    # Parse script for multiple speakers
-    script_parts = parse_script_for_speakers(podcast_script, speaker_count)
-    
-    progress(0.6, "Generating audio with multiple voices...")
-    
-    # Step 2: Generate audio
-    try:
-        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp_file:
-            temp_filename = tmp_file.name
-        
-        if tts_engine == "Multi-Speaker (Edge TTS - Best Quality)" and speaker_count > 1:
-            # Use Edge TTS for multi-speaker
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-            try:
-                audio_file, error = loop.run_until_complete(
-                    generate_multi_speaker_audio(script_parts, speaker_count, temp_filename)
-                )
-            finally:
-                loop.close()
-        elif tts_engine == "gTTS (Online - Single Voice)":
-            # Use gTTS for single voice
-            full_text = " ".join([part[0] for part in script_parts])
-            audio_file, error = generate_with_gtts(full_text, temp_filename)
-        else:
-            # Use pyttsx3 for offline single voice
-            full_text = " ".join([part[0] for part in script_parts])
-            audio_file, error = generate_with_pyttsx3(full_text, temp_filename)
-        
-        if error:
-            return None, f"❌ {error}", ""
-        
-        progress(0.9, "Finalizing...")
-        
-        # Read the generated audio file
-        with open(audio_file, 'rb') as f:
-            audio_data = f.read()
-        
-        # Clean up
-        try:
-            os.unlink(audio_file)
-        except:
-            pass
-        
-        progress(1.0, "Complete!")
-        
-        return audio_data, "✅ Podcast generated successfully!", podcast_script
-        
-    except Exception as e:
-        return None, f"❌ Audio generation failed: {str(e)}", ""
-
-# Custom CSS for better styling
-css = """
-.gradio-container {
-    max-width: 900px !important;
-    margin: 0 auto !important;
-}
-.container {
-    padding: 20px;
-}
-.header {
-    text-align: center;
-    margin-bottom: 30px;
-}
-.header h1 {
-    color: #2563eb;
-    font-size: 2.5em;
-    margin-bottom: 10px;
-}
-.header p {
-    color: #6b7280;
-    font-size: 1.1em;
-}
-.section {
-    background: white;
-    padding: 25px;
-    border-radius: 12px;
-    margin-bottom: 20px;
-    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.05);
-}
-.section h2 {
-    color: #374151;
-    margin-bottom: 15px;
-    font-size: 1.4em;
-}
-.input-text {
-    min-height: 200px;
-    resize: vertical;
-}
-.output-audio {
-    text-align: center;
-}
-.output-script {
-    background: #f8fafc;
-    padding: 20px;
-    border-radius: 8px;
-    border-left: 4px solid #2563eb;
-    max-height: 300px;
-    overflow-y: auto;
-}
-
-.speaker-info {
-    background: linear-gradient(135deg, #ffeaa7 0%, #fab1a0 100%);
-    padding: 15px;
-    border-radius: 8px;
-    margin: 10px 0;
-    border: 1px solid #fdcb6e;
-    font-weight: bold;
-}
-
-.status-message {
-    padding: 15px;
-    border-radius: 8px;
-    font-weight: bold;
-    margin: 10px 0;
-}
-
-.status-success {
-    background-color: #d4edda;
-    color: #155724;
-    border: 1px solid #c3e6cb;
-}
-
-.status-error {
-    background-color: #f8d7da;
-    color: #721c24;
-    border: 1px solid #f5c6cb;
-}
-
-.status-info {
-    background-color: #cce7ff;
-    color: #004085;
-    border: 1px solid #99d3ff;
-}
-.instructions {
-    background: #f0f9ff;
-    padding: 20px;
-    border-radius: 8px;
-    border-left: 4px solid #0ea5e9;
-}
-.instructions h3 {
-    color: #0369a1;
-    margin-bottom: 10px;
-}
-.btn-generate {
-    background: linear-gradient(135deg, #2563eb, #1d4ed8) !important;
-    color: white !important;
-    font-weight: bold !important;
-    padding: 12px 24px !important;
-    border-radius: 8px !important;
-}
-.btn-generate:hover {
-    background: linear-gradient(135deg, #1d4ed8, #1e40af) !important;
-}
-.status-message {
-    padding: 15px;
-    border-radius: 8px;
-    margin: 10px 0;
-}
-.status-success {
-    background: #dcfce7;
-    color: #166534;
-    border-left: 4px solid #22c55e;
-}
-.status-error {
-    background: #fee2e2;
-    color: #991b1b;
-    border-left: 4px solid #ef4444;
-}
-.status-info {
-    background: #dbeafe;
-    color: #1e40af;
-    border-left: 4px solid #3b82f6;
-}
-"""
-
-# Create the Gradio interface
-with gr.Blocks(css=css, theme=gr.themes.Soft()) as demo:
-    with gr.Column(elem_classes="container"):
-        # Header
-        with gr.Column(elem_classes="header"):
-            gr.Markdown("# 🎙️ Blog to Podcast Converter")
-            gr.Markdown("Transform your text into engaging podcast audio using AI")
-        
-        # API Section
-        with gr.Column(elem_classes="section"):
-            gr.Markdown("## 🔑 API Configuration")
-            api_key = gr.Textbox(
-                label="Gemini API Key (Optional)",
-                type="password",
-                placeholder="Enter your Google Gemini API key for better summaries...",
-                info="Get a free key from https://aistudio.google.com/"
-            )
-            api_status = gr.Textbox(
-                label="API Status",
-                interactive=False,
-                value="ℹ️ Add Gemini API key for AI-powered summaries"
-            )
-            api_key.change(init_gemini, inputs=api_key, outputs=api_status)
-        
-        # Input Section
-        with gr.Column(elem_classes="section"):
-            gr.Markdown("## 📝 Input Text")
-            input_text = gr.Textbox(
-                label="Paste your blog post or article text",
-                placeholder="Enter your text here... (2000+ characters works best)",
-                lines=8,
-                elem_classes="input-text"
-            )
-        
-        # Configuration Section
-        with gr.Column(elem_classes="section"):
-            gr.Markdown("## ⚙️ Podcast Configuration")
-            
-            with gr.Row():
-                speaker_count = gr.Radio(
-                    label="Number of Speakers",
-                    choices=[1, 2, 3, 4],
-                    value=2,
-                    info="Choose how many voices/speakers for your podcast"
-                )
-                
-                use_gemini = gr.Checkbox(
-                    label="Use AI for better summaries",
-                    value=True,
-                    info="Requires valid Gemini API key above"
-                )
-            
-            tts_engine = gr.Radio(
-                label="Voice Engine",
-                choices=[
-                    "Multi-Speaker (Edge TTS - Best Quality)",
-                    "gTTS (Online - Single Voice)", 
-                    "pyttsx3 (Offline - Single Voice)"
-                ],
-                value="Multi-Speaker (Edge TTS - Best Quality)",
-                info="Edge TTS provides realistic multi-speaker conversations"
-            )
-        
-        # Generate Button
-        generate_btn = gr.Button(
-            "🎙️ Generate Podcast",
-            elem_classes="btn-generate",
-            size="lg"
-        )
-        
-        # Output Section
-        with gr.Column(elem_classes="section"):
-            gr.Markdown("## 🎧 Generated Podcast")
-            
-            # Status message
-            status_msg = gr.HTML(
-                value="<div class='status-message status-info'>Ready to generate podcast...</div>"
-            )
-            
-            # Audio output with download
-            with gr.Row():
-                audio_output = gr.Audio(
-                    label="Generated Podcast",
-                    type="filepath",
-                    visible=False
-                )
-                download_btn = gr.DownloadButton(
-                    "⬇️ Download Podcast",
-                    visible=False,
-                    variant="secondary"
-                )
-            
-            # Speaker info display
-            speaker_info = gr.HTML(
-                value="",
-                visible=False
-            )
-            
-            # Script output
-            script_output = gr.Textbox(
-                label="Podcast Script",
-                visible=False,
-                lines=8,
-                elem_classes="output-script"
-            )
-        
-        # Instructions
-        with gr.Column(elem_classes="instructions"):
-            gr.Markdown("### ℹ️ How to Use")
-            gr.Markdown("""
-            1. **Optional**: Enter your Gemini API key for AI-powered conversation generation
-            2. **Paste your text** in the input box (articles, blogs, etc.)
-            3. **Choose number of speakers** (1-4) for different conversation styles
-            4. **Select voice engine**: 
-               - Multi-Speaker Edge TTS (best quality, realistic voices)
-               - gTTS (single voice, good quality)
-               - pyttsx3 (offline, system voice)
-            5. **Click Generate Podcast** and wait for processing
-            6. **Listen and download** your podcast!
-            
-            **Speaker Configurations**:
-            - **1 Speaker**: Solo narration
-            - **2 Speakers**: Host conversation (Alex & Brian)
-            - **3 Speakers**: Panel discussion (Sarah, Mike & Emma)  
-            - **4 Speakers**: Full roundtable (Sarah, Mike, Emma & David)
-            
-            **Tips**: 
-            - For best results, use 500-3000 characters of text
-            - Multi-speaker works best with Gemini AI enabled
-            - Edge TTS provides the most realistic conversations
-            """)
-
-def get_speaker_info(speaker_count):
-    """Get speaker information for display"""
-    if speaker_count == 1:
-        return "<div class='speaker-info'><b>Single Speaker Mode</b><br/>Solo narration with one voice</div>"
-    
-    voice_config = VOICE_CONFIGS[f"{speaker_count}_speakers"]
-    speakers_html = "<div class='speaker-info'><b>Speakers in this podcast:</b><br/>"
-    
-    for i, config in enumerate(voice_config):
-        speakers_html += f"🎤 <b>{config['name']}</b> ({config['gender']} voice)<br/>"
-    
-    speakers_html += "</div>"
-    return speakers_html
-    
-    # Event handlers
-    def update_status(message, success=True):
-        """Update status message with appropriate styling"""
-        status_class = "status-success" if success else "status-error"
-        if "Ready" in message or "ℹ️" in message:
-            status_class = "status-info"
-        return f"<div class='status-message {status_class}'>{message}</div>"
-    
-    def generate_podcast_wrapper(text, use_gemini, tts_engine, speaker_count, progress=gr.Progress()):
-        """Wrapper function for podcast generation"""
-        audio_data, message, script = create_podcast(text, use_gemini, tts_engine, speaker_count, progress)
-        
-        status_html = update_status(message, success=audio_data is not None)
-        
-        outputs = [status_html]
-        if audio_data:
-            # Save audio to temporary file for playback and download
-            filename = f"podcast_{speaker_count}speakers_{uuid4().hex[:8]}.wav"
-            filepath = os.path.join(tempfile.gettempdir(), filename)
-            
-            with open(filepath, 'wb') as f:
-                f.write(audio_data)
-            
-            # Get speaker info
-            speaker_info_html = get_speaker_info(speaker_count)
-            
-            outputs.extend([filepath, filepath, speaker_info_html, script])
-        else:
-            outputs.extend([None, None, "", script])
-        
-        return outputs
-    
-    # Connect the button click event
-    generate_btn.click(
-        fn=generate_podcast_wrapper,
-        inputs=[input_text, use_gemini, tts_engine, speaker_count],
-        outputs=[status_msg, audio_output, download_btn, speaker_info, script_output]
-    )
-    
-    # Update speaker info when speaker count changes
-    speaker_count.change(
-        fn=get_speaker_info,
-        inputs=speaker_count,
-        outputs=speaker_info
-    )
-    
-    # Show/hide outputs based on results
-    def toggle_visibility(audio_data):
-        has_audio = audio_data is not None
-        return (
-            gr.Audio(visible=has_audio),
-            gr.DownloadButton(visible=has_audio), 
-            gr.HTML(visible=has_audio),
-            gr.Textbox(visible=has_audio)
-        )
-    
-    audio_output.change(
-        fn=toggle_visibility,
-        inputs=audio_output,
-        outputs=[audio_output, download_btn, speaker_info, script_output]
-    )
-
-# Launch the application
-if __name__ == "__main__":
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False,
-        show_error=True
-    )
+import gradio as gr
+import google.generativeai as genai
+from gtts import gTTS
+import pyttsx3
+import tempfile
+import os
+from uuid import uuid4
+import time
+import asyncio
+from pydub import AudioSegment
+try:
+    import edge_tts
+    EDGE_TTS_AVAILABLE = True
+except ImportError:
+    EDGE_TTS_AVAILABLE = False
+    print("Edge TTS not available, using fallback options")
+
+# Voice configurations for different speakers
+VOICE_CONFIGS = {
+    "2_speakers": [
+        {"name": "Alex", "voice": "en-US-AriaNeural", "gender": "female"},
+        {"name": "Brian", "voice": "en-US-GuyNeural", "gender": "male"}
+    ],
+    "3_speakers": [
+        {"name": "Sarah", "voice": "en-US-JennyNeural", "gender": "female"},
+        {"name": "Mike", "voice": "en-US-BrandonNeural", "gender": "male"},
+        {"name": "Emma", "voice": "en-US-AriaNeural", "gender": "female"}
+    ],
+    "4_speakers": [
+        {"name": "Sarah", "voice": "en-US-JennyNeural", "gender": "female"},
+        {"name": "Mike", "voice": "en-US-BrandonNeural", "gender": "male"},
+        {"name": "Emma", "voice": "en-US-AriaNeural", "gender": "female"},
+        {"name": "David", "voice": "en-US-GuyNeural", "gender": "male"}
+    ]
+}
+
+# Initialize Gemini client
+client = None
+
+def init_gemini(api_key):
+    """Initialize Gemini client with API key"""
+    global client
+    if api_key and api_key.strip():
+        try:
+            genai.configure(api_key=api_key)
+            client = genai.GenerativeModel('gemini-1.5-flash')
+            return "✅ Gemini API connected successfully!"
+        except Exception as e:
+            return f"❌ Gemini API error: {str(e)}"
+    return "ℹ️ Add Gemini API key for AI-powered conversations"
+
+def generate_with_gtts(text, filename):
+    """Generate speech using Google's gTTS"""
+    try:
+        tts = gTTS(text=text, lang='en', slow=False)
+        tts.save(filename)
+        return filename, None
+    except Exception as e:
+        return None, f"gTTS Error: {str(e)}"
+
+def generate_with_pyttsx3(text, filename):
+    """Generate speech using system's TTS engine"""
+    try:
+        engine = pyttsx3.init()
+        engine.setProperty('rate', 180)
+        engine.setProperty('volume', 0.9)
+        
+        voices = engine.getProperty('voices')
+        if voices:
+            for voice in voices:
+                if 'female' in voice.name.lower() or 'zira' in voice.name.lower():
+                    engine.setProperty('voice', voice.id)
+                    break
+        
+        engine.save_to_file(text, filename)
+        engine.runAndWait()
+        return filename, None
+    except Exception as e:
+        return None, f"pyttsx3 Error: {str(e)}"
+
+async def generate_with_edge_tts(text, voice, filename):
+    """Generate speech using Microsoft Edge TTS with specific voice"""
+    if not EDGE_TTS_AVAILABLE:
+        return None, "Edge TTS not available"
+    
+    try:
+        communicate = edge_tts.Communicate(text, voice)
+        # Save as MP3 since that's Edge TTS default format
+        mp3_filename = filename.replace('.wav', '.mp3')
+        await communicate.save(mp3_filename)
+        return mp3_filename, None
+    except Exception as e:
+        return None, f"Edge TTS Error: {str(e)}"
+
+def generate_podcast_script(text, speaker_count, use_gemini):
+    """Generate a podcast script with multiple speakers"""
+    if use_gemini and client:
+        try:
+            voice_config = VOICE_CONFIGS[f"{speaker_count}_speakers"]
+            speaker_names = [config["name"] for config in voice_config]
+            
+            prompt = f"""Create an engaging podcast conversation between {speaker_count} hosts: {', '.join(speaker_names)}.
+            
+            Transform this text into a natural conversation where each speaker contributes meaningfully.
+            
+            Guidelines:
+            - Make it sound like a real podcast discussion
+            - Each speaker should have distinct perspectives
+            - Include natural transitions and interactions
+            - Keep it under 2000 characters total
+            - Use speaker names clearly (e.g., "Sarah: Hello everyone...")
+            
+            Original text: {text[:2500]}
+            
+            Format the output with clear speaker labels like:
+            {speaker_names[0]}: [text]
+            {speaker_names[1] if len(speaker_names) > 1 else speaker_names[0]}: [text]
+            etc."""
+            
+            response = client.generate_content(prompt)
+            return response.text
+        except Exception as e:
+            return f"AI generation failed: {str(e)}. Using original text."
+    
+    # Fallback: simple text with speaker distribution
+    return text[:1500] + ("..." if len(text) > 1500 else "")
+
+def parse_script_for_speakers(script, speaker_count):
+    """Parse the script to extract speaker parts"""
+    try:
+        voice_config = VOICE_CONFIGS[f"{speaker_count}_speakers"]
+        speaker_names = [config["name"] for config in voice_config]
+        
+        parts = []
+        lines = script.split('\n')
+        current_speaker = 0
+        current_text = ""
+        
+        # First, try to find explicit speaker labels
+        for line in lines:
+            line = line.strip()
+            if not line:
+                continue
+                
+            # Check if line starts with a speaker name
+            speaker_found = False
+            for i, name in enumerate(speaker_names):
+                if line.lower().startswith(f"{name.lower()}:"):
+                    if current_text.strip():
+                        parts.append((current_text.strip(), current_speaker))
+                    current_speaker = i
+                    current_text = line[len(name)+1:].strip()
+                    speaker_found = True
+                    break
+            
+            if not speaker_found:
+                current_text += " " + line
+        
+        if current_text.strip():
+            parts.append((current_text.strip(), current_speaker))
+        
+        # If no explicit speakers were found, intelligently distribute text
+        if not parts or len(parts) < 2:
+            print(f"No explicit speakers found, distributing text among {speaker_count} speakers")
+            parts = []
+            
+            # Split into sentences and distribute
+            sentences = []
+            for delimiter in ['. ', '! ', '? ']:
+                if delimiter in script:
+                    sentences = script.split(delimiter)
+                    # Add back the delimiter except for the last sentence
+                    for i in range(len(sentences) - 1):
+                        sentences[i] += delimiter.strip()
+                    break
+            
+            if not sentences:
+                sentences = [script]
+            
+            # Remove empty sentences
+            sentences = [s.strip() for s in sentences if s.strip()]
+            
+            if len(sentences) >= speaker_count:
+                # Distribute sentences among speakers
+                sentences_per_speaker = len(sentences) // speaker_count
+                remainder = len(sentences) % speaker_count
+                
+                start_idx = 0
+                for i in range(speaker_count):
+                    # Give extra sentences to first speakers if there's remainder
+                    num_sentences = sentences_per_speaker + (1 if i < remainder else 0)
+                    
+                    if start_idx < len(sentences):
+                        end_idx = min(start_idx + num_sentences, len(sentences))
+                        speaker_sentences = sentences[start_idx:end_idx]
+                        
+                        if speaker_sentences:
+                            speaker_text = ' '.join(speaker_sentences)
+                            parts.append((speaker_text, i))
+                            print(f"Speaker {speaker_names[i]}: {len(speaker_sentences)} sentences")
+                        
+                        start_idx = end_idx
+            else:
+                # If we have fewer sentences than speakers, alternate between first two speakers
+                for i, sentence in enumerate(sentences):
+                    speaker_idx = i % min(speaker_count, 2)  # Alternate between first 2 speakers
+                    parts.append((sentence, speaker_idx))
+        
+        # Ensure we have content and speakers are properly assigned
+        if not parts:
+            parts = [(script, 0)]
+        
+        # Print debug info
+        print(f"Generated {len(parts)} parts for {speaker_count} speakers:")
+        for i, (text, speaker_idx) in enumerate(parts):
+            speaker_name = speaker_names[speaker_idx]
+            print(f"  Part {i+1}: {speaker_name} - {text[:60]}...")
+        
+        return parts
+        
+    except Exception as e:
+        print(f"Error parsing script: {e}")
+        return [(script, 0)]
+
+async def generate_multi_speaker_audio(script_parts, speaker_count):
+    """Generate multi-speaker podcast audio"""
+    if not EDGE_TTS_AVAILABLE:
+        return None, "Edge TTS not available for multi-speaker"
+    
+    try:
+        voice_config = VOICE_CONFIGS[f"{speaker_count}_speakers"]
+        audio_files = []
+        
+        print(f"Generating audio for {len(script_parts)} parts with {speaker_count} speakers")
+        
+        for i, (speaker_text, speaker_idx) in enumerate(script_parts):
+            voice = voice_config[speaker_idx]["voice"]
+            speaker_name = voice_config[speaker_idx]["name"]
+            temp_filename = f"temp_speaker_{i}_{speaker_name}_{uuid4().hex[:8]}.mp3"
+            
+            print(f"Part {i+1}: {speaker_name} ({voice}) says: {speaker_text[:50]}...")
+            
+            result, error = await generate_with_edge_tts(speaker_text, voice, temp_filename)
+            if result:
+                audio_files.append(temp_filename)
+                print(f"✅ Generated audio for {speaker_name}")
+            else:
+                print(f"❌ Error generating voice for {speaker_name}: {error}")
+                # Cleanup and return error
+                for f in audio_files:
+                    try:
+                        os.unlink(f)
+                    except:
+                        pass
+                return None, f"Error generating voice for {speaker_name}: {error}"
+        
+        # Combine all audio files
+        if len(audio_files) > 1:
+            print(f"Combining {len(audio_files)} audio files...")
+            combined_audio = AudioSegment.empty()
+            
+            for i, audio_file in enumerate(audio_files):
+                try:
+                    # Load the audio segment - auto-detect format
+                    segment = AudioSegment.from_file(audio_file)
+                    
+                    # Add the segment to combined audio
+                    combined_audio += segment
+                    
+                    # Add a small pause between speakers (0.5 seconds)
+                    if i < len(audio_files) - 1:  # Don't add pause after last segment
+                        pause = AudioSegment.silent(duration=500)  # 500ms pause
+                        combined_audio += pause
+                    
+                    print(f"✅ Added segment {i+1}")
+                except Exception as e:
+                    print(f"❌ Error processing audio file {audio_file}: {e}")
+            
+            # Save combined audio
+            output_filename = f"combined_podcast_{uuid4().hex[:8]}.wav"
+            combined_audio.export(output_filename, format="wav")
+            
+            # Cleanup temporary files
+            for f in audio_files:
+                try:
+                    os.unlink(f)
+                    print(f"🗑️ Cleaned up {f}")
+                except:
+                    pass
+            
+            print(f"✅ Combined audio saved as {output_filename}")
+            return output_filename, None
+            
+        elif len(audio_files) == 1:
+            # Single audio file, just return it
+            return audio_files[0], None
+        else:
+            return None, "No audio files generated"
+        
+    except Exception as e:
+        print(f"❌ Multi-speaker generation error: {str(e)}")
+        return None, f"Multi-speaker generation error: {str(e)}"
+
+def create_podcast(text, use_gemini, tts_engine, speaker_count, progress=gr.Progress()):
+    """Main function to create podcast from text with multiple speakers"""
+    try:
+        progress(0.1, "Starting processing...")
+        
+        if not text.strip():
+            return None, "❌ Please enter some text first!", ""
+        
+        progress(0.3, "Generating podcast script...")
+        podcast_script = generate_podcast_script(text, speaker_count, use_gemini)
+        
+        progress(0.5, "Parsing script for speakers...")
+        script_parts = parse_script_for_speakers(podcast_script, speaker_count)
+        
+        progress(0.7, "Generating audio...")
+        
+        # Generate audio based on engine choice
+        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp_file:
+            temp_filename = tmp_file.name
+        
+        if tts_engine == "Multi-Speaker (Edge TTS)" and speaker_count > 1 and EDGE_TTS_AVAILABLE:
+            # Use Edge TTS for multi-speaker
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            try:
+                audio_file, error = loop.run_until_complete(
+                    generate_multi_speaker_audio(script_parts, speaker_count)
+                )
+            finally:
+                loop.close()
+        elif tts_engine == "gTTS (Online)":
+            full_text = " ".join([part[0] for part in script_parts])
+            audio_file, error = generate_with_gtts(full_text, temp_filename)
+        else:  # pyttsx3
+            full_text = " ".join([part[0] for part in script_parts])
+            audio_file, error = generate_with_pyttsx3(full_text, temp_filename)
+        
+        if error:
+            return None, f"❌ {error}", podcast_script
+        
+        progress(0.9, "Finalizing...")
+        
+        # Read the generated audio file
+        with open(audio_file, 'rb') as f:
+            audio_data = f.read()
+        
+        # Clean up
+        try:
+            os.unlink(audio_file)
+        except:
+            pass
+        
+        progress(1.0, "Complete!")
+        return audio_data, "✅ Podcast generated successfully!", podcast_script
+        
+    except Exception as e:
+        return None, f"❌ Audio generation failed: {str(e)}", ""
+
+def get_speaker_info(speaker_count):
+    """Get speaker information for display"""
+    if speaker_count == 1:
+        return "**Single Speaker Mode**: Solo narration with one voice"
+    
+    voice_config = VOICE_CONFIGS[f"{speaker_count}_speakers"]
+    info = f"**{speaker_count} Speaker Mode**:\n"
+    
+    for i, config in enumerate(voice_config):
+        info += f"🎤 **{config['name']}** ({config['gender']} voice)\n"
+    
+    return info
+
+# Create the Gradio interface
+def create_interface():
+    with gr.Blocks(title="🎙️ Multi-Speaker Podcast Generator", theme=gr.themes.Soft()) as demo:
+        gr.Markdown("# 🎙️ Multi-Speaker Podcast Generator")
+        gr.Markdown("Transform your text into engaging podcast conversations with multiple realistic voices!")
+        
+        with gr.Row():
+            with gr.Column(scale=2):
+                # API Configuration
+                gr.Markdown("## 🔑 API Configuration")
+                api_key = gr.Textbox(
+                    label="Gemini API Key (Optional)",
+                    type="password",
+                    placeholder="Enter your Google Gemini API key...",
+                    info="Get a free key from https://aistudio.google.com/"
+                )
+                api_status = gr.Textbox(
+                    label="API Status",
+                    interactive=False,
+                    value="ℹ️ Add Gemini API key for AI-powered conversations"
+                )
+                
+                # Input Text
+                gr.Markdown("## 📝 Input Text")
+                input_text = gr.Textbox(
+                    label="Your Content",
+                    placeholder="Paste your article, blog post, or any text here...",
+                    lines=6
+                )
+                
+                # Configuration
+                gr.Markdown("## ⚙️ Configuration")
+                speaker_count = gr.Radio(
+                    label="Number of Speakers",
+                    choices=[1, 2, 3, 4],
+                    value=2,
+                    info="Choose how many voices for your podcast"
+                )
+                
+                use_gemini = gr.Checkbox(
+                    label="Use AI for conversation generation",
+                    value=True,
+                    info="Creates natural conversations (requires API key)"
+                )
+                
+                tts_engine = gr.Radio(
+                    label="Voice Engine",
+                    choices=[
+                        "Multi-Speaker (Edge TTS)",
+                        "gTTS (Online)", 
+                        "pyttsx3 (Offline)"
+                    ],
+                    value="Multi-Speaker (Edge TTS)" if EDGE_TTS_AVAILABLE else "gTTS (Online)",
+                    info="Edge TTS provides the most realistic conversations"
+                )
+                
+                # Generate Button
+                generate_btn = gr.Button(
+                    "🎙️ Generate Podcast",
+                    variant="primary",
+                    size="lg"
+                )
+            
+            with gr.Column(scale=1):
+                # Speaker Info
+                speaker_info = gr.Markdown(
+                    get_speaker_info(2),
+                    label="Speaker Information"
+                )
+        
+        # Status and Results
+        status_msg = gr.HTML(
+            value="<div style='padding: 10px; background: #e3f2fd; border-radius: 5px; color: #1976d2;'>Ready to generate your podcast!</div>"
+        )
+        
+        with gr.Row():
+            audio_output = gr.Audio(
+                label="Generated Podcast",
+                visible=False
+            )
+            download_btn = gr.DownloadButton(
+                "⬇️ Download Podcast",
+                visible=False
+            )
+        
+        script_output = gr.Textbox(
+            label="Generated Script",
+            lines=8,
+            visible=False
+        )
+        
+        # Event handlers
+        def update_status(message, success=True):
+            color = "#1976d2" if success else "#d32f2f"
+            bg_color = "#e3f2fd" if success else "#ffebee"
+            return f"<div style='padding: 10px; background: {bg_color}; border-radius: 5px; color: {color};'>{message}</div>"
+        
+        def generate_podcast_wrapper(text, use_gemini, tts_engine, speaker_count, progress=gr.Progress()):
+            audio_data, message, script = create_podcast(text, use_gemini, tts_engine, speaker_count, progress)
+            
+            status_html = update_status(message, success=audio_data is not None)
+            
+            if audio_data:
+                # Save audio to temporary file
+                filename = f"podcast_{speaker_count}speakers_{uuid4().hex[:8]}.wav"
+                filepath = os.path.join(tempfile.gettempdir(), filename)
+                
+                with open(filepath, 'wb') as f:
+                    f.write(audio_data)
+                
+                return [
+                    status_html,
+                    gr.Audio(value=filepath, visible=True),
+                    gr.DownloadButton(value=filepath, visible=True),
+                    gr.Textbox(value=script, visible=True)
+                ]
+            else:
+                return [
+                    status_html,
+                    gr.Audio(visible=False),
+                    gr.DownloadButton(visible=False),
+                    gr.Textbox(visible=False)
+                ]
+        
+        # Connect events
+        api_key.change(init_gemini, inputs=api_key, outputs=api_status)
+        
+        speaker_count.change(
+            get_speaker_info,
+            inputs=speaker_count,
+            outputs=speaker_info
+        )
+        
+        generate_btn.click(
+            generate_podcast_wrapper,
+            inputs=[input_text, use_gemini, tts_engine, speaker_count],
+            outputs=[status_msg, audio_output, download_btn, script_output]
+        )
+    
+    return demo
+
+if __name__ == "__main__":
+    demo = create_interface()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True
+    )