Update app.py

app.py

@@ -1,74 +1,193 @@
 import gradio as gr
-import pyttsx3
+import edge_tts
+import asyncio
 import os
-import warnings
+from typing import Dict
 
-# Suppress pygame welcome message
-with warnings.catch_warnings():
-    warnings.simplefilter("ignore")
-    import pygame
-
-def get_voices():
-    """Initialize engine and get available voices with error handling"""
+async def generate_speech(text: str, voice: str) -> str:
+    """Generate speech from text using the specified voice"""
     try:
-        engine = pyttsx3.init()
-        voices = engine.getProperty('voices')
-        return {f"{voice.name} ({voice.languages[0] if voice.languages else 'Unknown'})": voice.id 
-               for voice in voices}
+        communicate = edge_tts.Communicate(text, voice)
+        output_file = "output.mp3"
+        await communicate.save(output_file)
+        return output_file
     except Exception as e:
-        print(f"Error initializing TTS engine: {e}")
-        # Return a default voice if engine fails
-        return {"Default Voice": None}
+        print(f"Error: {e}")
+        return None
 
-# Get available voices
-voice_map = get_voices()
+# Expanded list of voices organized by language and gender
+VOICES: Dict[str, str] = {
+    # English (US)
+    "Jenny (Female, US)": "en-US-JennyNeural",
+    "Guy (Male, US)": "en-US-GuyNeural",
+    "Aria (Female, US)": "en-US-AriaNeural",
+    "Davis (Male, US)": "en-US-DavisNeural",
+    "Jane (Female, US)": "en-US-JaneNeural",
+    "Jason (Male, US)": "en-US-JasonNeural",
+    "Nancy (Female, US)": "en-US-NancyNeural",
+    "Tony (Male, US)": "en-US-TonyNeural",
+    "Sara (Female, US)": "en-US-SaraNeural",
+    "Brandon (Male, US)": "en-US-BrandonNeural",
+    
+    # English (UK)
+    "Libby (Female, UK)": "en-GB-LibbyNeural",
+    "Ryan (Male, UK)": "en-GB-RyanNeural",
+    "Sonia (Female, UK)": "en-GB-SoniaNeural",
+    "Thomas (Male, UK)": "en-GB-ThomasNeural",
+    
+    # English (Australia)
+    "Natasha (Female, AU)": "en-AU-NatashaNeural",
+    "William (Male, AU)": "en-AU-WilliamNeural",
+    
+    # English (India)
+    "Neerja (Female, IN)": "en-IN-NeerjaNeural",
+    "Prabhat (Male, IN)": "en-IN-PrabhatNeural",
+    
+    # Spanish
+    "Elvira (Female, ES)": "es-ES-ElviraNeural",
+    "Alvaro (Male, ES)": "es-ES-AlvaroNeural",
+    "Ana (Female, AR)": "es-AR-AnaNeural",
+    "Tomas (Male, AR)": "es-AR-TomasNeural",
+    "Camila (Female, MX)": "es-MX-CamilaNeural",
+    "Jorge (Male, MX)": "es-MX-JorgeNeural",
+    
+    # French
+    "Denise (Female, FR)": "fr-FR-DeniseNeural",
+    "Henri (Male, FR)": "fr-FR-HenriNeural",
+    "Sylvie (Female, CA)": "fr-CA-SylvieNeural",
+    "Antoine (Male, CA)": "fr-CA-AntoineNeural",
+    
+    # German
+    "Katja (Female, DE)": "de-DE-KatjaNeural",
+    "Conrad (Male, DE)": "de-DE-ConradNeural",
+    "Amala (Female, CH)": "de-CH-AmalaNeural",
+    "Jan (Male, CH)": "de-CH-JanNeural",
+    
+    # Italian
+    "Elsa (Female, IT)": "it-IT-ElsaNeural",
+    "Diego (Male, IT)": "it-IT-DiegoNeural",
+    
+    # Portuguese
+    "Francisca (Female, PT)": "pt-PT-FranciscaNeural",
+    "Duarte (Male, PT)": "pt-PT-DuarteNeural",
+    "Yara (Female, BR)": "pt-BR-YaraNeural",
+    "Antonio (Male, BR)": "pt-BR-AntonioNeural",
+    
+    # Japanese
+    "Nanami (Female, JP)": "ja-JP-NanamiNeural",
+    "Keita (Male, JP)": "ja-JP-KeitaNeural",
+    
+    # Chinese
+    "Xiaoxiao (Female, CN)": "zh-CN-XiaoxiaoNeural",
+    "Yunyang (Male, CN)": "zh-CN-YunyangNeural",
+    "HsiaoChen (Female, TW)": "zh-TW-HsiaoChenNeural",
+    "YunJhe (Male, TW)": "zh-TW-YunJheNeural",
+    
+    # Korean
+    "SunHi (Female, KR)": "ko-KR-SunHiNeural",
+    "InJoon (Male, KR)": "ko-KR-InJoonNeural",
+    
+    # Russian
+    "Svetlana (Female, RU)": "ru-RU-SvetlanaNeural",
+    "Dmitry (Male, RU)": "ru-RU-DmitryNeural",
+    
+    # Arabic
+    "Salma (Female, EG)": "ar-EG-SalmaNeural",
+    "Shakir (Male, EG)": "ar-EG-ShakirNeural",
+    "Hamed (Male, SA)": "ar-SA-HamedNeural",
+    
+    # Hindi
+    "Swara (Female, IN)": "hi-IN-SwaraNeural",
+    "Madhur (Male, IN)": "hi-IN-MadhurNeural",
+    
+    # And many more...
+    "Brigitte (Female, BE)": "fr-BE-BrigitteNeural",
+    "Gerard (Male, BE)": "fr-BE-GerardNeural",
+    "Finn (Male, NL)": "nl-NL-FinnNeural",
+    "Maarten (Male, NL)": "nl-NL-MaartenNeural",
+    "Sofie (Female, NL)": "nl-NL-SofieNeural",
+}
 
-def text_to_speech(text, voice_name, rate=200):
-    """
-    Convert text to speech with selected voice and rate.
-    Saves output as an audio file and returns the file path.
-    """
-    try:
-        # Initialize engine for each call
-        engine = pyttsx3.init()
-        
-        # Set voice if available
-        voice_id = voice_map.get(voice_name)
-        if voice_id:
-            engine.setProperty('voice', voice_id)
-        
-        # Set speech rate
-        engine.setProperty('rate', rate)
-        
-        # Save audio to a file
-        output_file = "output.wav"
-        engine.save_to_file(text, output_file)
-        engine.runAndWait()
-        
-        # Ensure file exists before returning
-        if os.path.exists(output_file):
-            return output_file
-        return None
-    except Exception as e:
-        print(f"Error in text_to_speech: {e}")
-        return None
+def text_to_speech(text: str, voice: str) -> str:
+    """Wrapper function to run async code"""
+    return asyncio.run(generate_speech(text, voice))
+
+def get_languages() -> list:
+    """Extract unique languages from voice names"""
+    languages = set()
+    for name in VOICES.keys():
+        if '(' in name and ')' in name:
+            lang = name.split('(')[1].split(')')[0]
+            languages.add(lang)
+    return sorted(languages)
 
-# Gradio interface
-with gr.Blocks(title="Text-to-Speech with Different Voices") as demo:
-    gr.Markdown("# Text-to-Speech Converter")
-    gr.Markdown("Enter text and select a voice to convert it to speech with different voices and accents.")
-    
-    text_input = gr.Textbox(label="Enter Text", placeholder="Type your text here...")
-    voice_dropdown = gr.Dropdown(choices=list(voice_map.keys()), label="Select Voice/Accent", value=list(voice_map.keys())[0] if voice_map else None)
-    rate_slider = gr.Slider(minimum=100, maximum=300, value=200, step=10, label="Speech Rate")
-    
-    convert_button = gr.Button("Convert to Speech")
-    audio_output = gr.Audio(label="Generated Speech")
-    
-    convert_button.click(
-        fn=text_to_speech,
-        inputs=[text_input, voice_dropdown, rate_slider],
-        outputs=audio_output
+def filter_voices(language: str) -> Dict[str, str]:
+    """Filter voices by selected language"""
+    if not language or language == "All":
+        return VOICES
+    return {name: voice for name, voice in VOICES.items() if f"({language})" in name}
+
+def update_voice_dropdown(language: str) -> Dict:
+    """Update voice dropdown based on selected language"""
+    filtered_voices = filter_voices(language)
+    return gr.Dropdown.update(
+        choices=list(filtered_voices.keys()),
+        value=list(filtered_voices.keys())[0] if filtered_voices else None
+    )
+
+with gr.Blocks(title="Multi-Voice Text-to-Speech", theme="soft") as demo:
+    gr.Markdown("""
+    # 🎤 Advanced Text-to-Speech Converter
+    ### With 100+ Voices Across Multiple Languages
+    """)
+    
+    with gr.Row():
+        with gr.Column():
+            text_input = gr.Textbox(
+                label="Enter your text",
+                placeholder="Type or paste your text here...",
+                lines=5,
+                max_lines=10
+            )
+            
+            with gr.Row():
+                language_filter = gr.Dropdown(
+                    ["All"] + get_languages(),
+                    label="Filter by Language",
+                    value="All"
+                )
+                voice_dropdown = gr.Dropdown(
+                    list(VOICES.keys()),
+                    label="Select Voice",
+                    value="Jenny (Female, US)"
+                )
+            
+            generate_btn = gr.Button("Generate Speech", variant="primary")
+            
+        with gr.Column():
+            audio_output = gr.Audio(label="Generated Speech", autoplay=True)
+            download_btn = gr.DownloadButton(
+                "Download Audio",
+                visible=False,
+                file_name="speech.mp3"
+            )
+    
+    # Interactive components
+    language_filter.change(
+        update_voice_dropdown,
+        inputs=language_filter,
+        outputs=voice_dropdown
+    )
+    
+    generate_btn.click(
+        text_to_speech,
+        inputs=[text_input, voice_dropdown],
+        outputs=[audio_output, download_btn]
+    )
+    
+    audio_output.change(
+        lambda: gr.DownloadButton.update(visible=True),
+        outputs=download_btn
     )
 
 if __name__ == "__main__":