Update app.py

app.py

@@ -1,8 +1,9 @@
 import tempfile
 import edge_tts
 import gradio as gr
-import asyncio
+from concurrent.futures import ThreadPoolExecutor
 
+# Language and voice selection dictionary
 language_dict = {
     "Hindi": {
         "Madhur": "hi-IN-MadhurNeural",
@@ -47,51 +48,49 @@ language_dict = {
         "Leah": "en-ZA-LeahNeural",
         "Luke": "en-ZA-LukeNeural"
     },
-    # Add more languages here as needed...
+    # Add other languages...
 }
 
-async def text_to_speech_async(text, voice, lang):
-    communicate = edge_tts.Communicate(text, voice, lang)
-    return await communicate.save("output.mp3")
+# Function to chunk text into parts of max 5000 characters
+def chunk_text(text, max_length=5000):
+    return [text[i:i + max_length] for i in range(0, len(text), max_length)]
 
-def process_input_text(input_text, voice, lang):
-    # Split input into parts of 5000 characters
-    parts = [input_text[i:i+5000] for i in range(0, len(input_text), 5000)]
-    
-    # Process parts concurrently
-    tasks = [text_to_speech_async(part, voice, lang) for part in parts]
-    
-    # Run all tasks concurrently and await results
-    results = asyncio.run(asyncio.gather(*tasks))
-    
-    # Combine the resulting files into a single audio
-    with tempfile.NamedTemporaryFile(suffix='.mp3', delete=False) as combined_file:
-        combined_file_path = combined_file.name
-        with open(combined_file_path, 'wb') as output_file:
+# Function to generate speech for each chunk using edge_tts
+async def generate_speech(text_chunk, language, voice):
+    communicate = edge_tts.Communicate(text_chunk, voice=language_dict[language][voice])
+    audio_data = await communicate.save()
+    return audio_data
+
+# Function to process text and generate speech
+def process_text_to_speech(text, language, voice):
+    chunks = chunk_text(text)
+    with ThreadPoolExecutor() as executor:
+        futures = [executor.submit(generate_speech, chunk, language, voice) for chunk in chunks]
+        results = [future.result() for future in futures]
+
+    # Combine all audio parts into a single file
+    with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as output_file:
+        output_filename = output_file.name
+        with open(output_filename, "wb") as f:
             for result in results:
-                with open(result, 'rb') as input_file:
-                    output_file.write(input_file.read())
-        
-        # Provide path for downloading the combined file
-        return combined_file_path
+                f.write(result)
+    return output_filename
 
-def create_audio_interface(input_text, voice, lang):
-    output_file = process_input_text(input_text, voice, lang)
-    return output_file
+# Gradio interface function
+def gradio_interface(text, language, voice):
+    audio_filename = process_text_to_speech(text, language, voice)
+    return audio_filename
 
-def create_gradio_interface():
-    interface = gr.Interface(
-        fn=create_audio_interface,
-        inputs=[
-            gr.Textbox(lines=4, label="Enter Text"),
-            gr.Dropdown(choices=["Madhur", "Swara", "Jenny", "Guy", "Ana", "Aria", "Brian"], label="Select Voice"),
-            gr.Dropdown(choices=["Hindi", "English"], label="Select Language")
-        ],
-        outputs=gr.File(label="Download Audio"),
-        title="Text to Speech with Edge TTS"
-    )
-    return interface
+# Gradio UI setup
+iface = gr.Interface(
+    fn=gradio_interface,
+    inputs=[
+        gr.Textbox(label="Enter Text"),
+        gr.Dropdown(choices=list(language_dict.keys()), label="Select Language"),
+        gr.Dropdown(choices=["Madhur", "Swara", "Jenny", "Guy", "Ana", "Aria", "Brian"], label="Select Voice")
+    ],
+    outputs=gr.File(label="Download Audio File")
+)
 
 # Launch the Gradio interface
-gradio_interface = create_gradio_interface()
-gradio_interface.launch()
+iface.launch()