Update app.py

app.py

@@ -1,161 +1,82 @@
-import spaces
-import gradio as gr
 import edge_tts
-import asyncio
+import gradio as gr
 import tempfile
-import os
-import re
-from pydub import AudioSegment
-import numpy as np
+import anyio
+import wave
 
-# Get all available voices
-async def get_voices():
-    voices = await edge_tts.list_voices()
-    return {f"{v['ShortName']} - {v['Locale']} ({v['Gender']})": v['ShortName'] for v in voices}
+language_dict = {
+    'English-Jenny (Female)': 'en-US-JennyNeural',
+    'English-Guy (Male)': 'en-US-GuyNeural',
+    # Add more if needed
+}
 
-# Text-to-speech function with word timing estimation
-async def text_to_speech(text, voice, rate, pitch):
-    if not text.strip():
-        return None, None, gr.Warning("Please enter text to convert.")
-    if not voice:
-        return None, None, gr.Warning("Please select a voice.")
-    
-    voice_short_name = voice.split(" - ")[0]
-    rate_str = f"{rate:+d}%"
-    pitch_str = f"{pitch:+d}Hz"
-    
-    # Generate full audio
-    communicate = edge_tts.Communicate(text, voice_short_name, rate=rate_str, pitch=pitch_str)
-    with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_file:
+async def text_to_speech_edge(text, language_code):
+    voice = language_dict.get(language_code, "en-US-JennyNeural")
+    communicate = edge_tts.Communicate(text, voice)
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp_file:
         tmp_path = tmp_file.name
         await communicate.save(tmp_path)
-    
-    # Estimate word timings
-    audio = AudioSegment.from_file(tmp_path)
-    duration = len(audio) / 1000.0  # in seconds
-    words = re.findall(r'\b\w+\b', text)
-    n_words = len(words)
-    word_timings = []
-    
-    if n_words > 0:
-        time_per_word = duration / n_words
-        for i, word in enumerate(words):
-            start_time = i * time_per_word
-            end_time = (i + 1) * time_per_word
-            word_timings.append({
-                "word": word,
-                "start": start_time,
-                "end": end_time
-            })
-    
-    # Create clickable transcript HTML
-    transcript_html = ""
-    for i, wt in enumerate(word_timings):
-        transcript_html += f'<span class="word" data-start="{wt["start"]}" data-end="{wt["end"]}" data-index="{i}">{wt["word"]}</span> '
-    
-    return tmp_path, transcript_html, None
-
-# Gradio interface function
-@spaces.GPU
-def tts_interface(text, voice, rate, pitch):
-    audio_file, transcript, warning = asyncio.run(text_to_speech(text, voice, rate, pitch))
-    return audio_file, transcript, warning
+    return text, tmp_path
 
-# Create Gradio application
-async def create_demo():
-    voices = await get_voices()
-    
-    description = """
-    Experience the power of Voicecloning.be for text-to-speech conversion.
-    <br><b>NEW:</b> Click on any word in the transcript to start playback from that position!
-    """
-    
-    # JavaScript for interactive transcript
-    js = """
+def make_interactive_transcript(text, duration):
+    words = text.split()
+    word_count = len(words)
+    est_duration_per_word = duration / word_count if word_count else 0.5
+    spans = []
+    for i, word in enumerate(words):
+        start_time = round(i * est_duration_per_word, 2)
+        spans.append(f'<span class="word" data-start="{start_time}">{word}</span>')
+    joined = ' '.join(spans)
+    script = """
     <script>
-        function handleWordClick(event) {
-            const audio = document.querySelector('#audio-player audio');
-            const start = parseFloat(event.target.dataset.start);
-            if (!isNaN(start) && audio) {
-                audio.currentTime = start;
-                audio.play();
-                
-                // Highlight clicked word
-                document.querySelectorAll('.word').forEach(w => 
-                    w.style.backgroundColor = 'transparent');
-                event.target.style.backgroundColor = '#e6f7ff';
-            }
-        }
-        
-        document.addEventListener('DOMContentLoaded', () => {
-            document.querySelectorAll('.word').forEach(word => {
-                word.addEventListener('click', handleWordClick);
+    document.addEventListener("DOMContentLoaded", () => {
+        document.querySelectorAll('.word').forEach(span => {
+            span.addEventListener('click', () => {
+                const audio = document.querySelector("audio");
+                const start = parseFloat(span.dataset.start);
+                if (audio) {
+                    audio.currentTime = start;
+                    audio.play();
+                }
             });
         });
+    });
     </script>
     """
-    
-    css = """
+    style = """
+    <style>
     .word {
         cursor: pointer;
-        padding: 2px 4px;
-        border-radius: 4px;
-        transition: background-color 0.3s;
+        padding: 0 2px;
     }
     .word:hover {
-        background-color: #f0f0f0;
-    }
-    #transcript-container {
-        max-height: 200px;
-        overflow-y: auto;
-        border: 1px solid #e0e0e0;
-        padding: 10px;
-        border-radius: 4px;
-        margin-top: 10px;
+        background-color: #ffe58a;
     }
+    </style>
     """
-    
-    with gr.Blocks(css=css) as demo:
-        gr.Markdown("# Voicecloning.be Text-to-Speech")
-        gr.Markdown(description)
-        
-        with gr.Row():
-            with gr.Column():
-                text_input = gr.Textbox(label="Input Text", lines=5)
-                voice_dropdown = gr.Dropdown(
-                    choices=[""] + list(voices.keys()), 
-                    label="Select Voice", 
-                    value=""
-                )
-                rate_slider = gr.Slider(
-                    minimum=-50, maximum=50, value=0, 
-                    label="Speech Rate Adjustment (%)", step=1
-                )
-                pitch_slider = gr.Slider(
-                    minimum=-20, maximum=20, value=0, 
-                    label="Pitch Adjustment (Hz)", step=1
-                )
-                submit_btn = gr.Button("Generate Speech", variant="primary")
-                
-            with gr.Column():
-                audio_output = gr.Audio(label="Generated Audio", elem_id="audio-player")
-                transcript_output = gr.HTML(
-                    label="Interactive Transcript", 
-                    elem_id="transcript-container"
-                )
-                warning_output = gr.Markdown(visible=False)
-        
-        submit_btn.click(
-            fn=tts_interface,
-            inputs=[text_input, voice_dropdown, rate_slider, pitch_slider],
-            outputs=[audio_output, transcript_output, warning_output]
-        )
-        
-        gr.HTML(js)
-    
-    return demo
+    return style + joined + script
+
+async def tts_with_interactive_transcript(text, language_code):
+    text_out, audio_path = await text_to_speech_edge(text, language_code)
+
+    with wave.open(audio_path, 'rb') as wf:
+        duration = wf.getnframes() / wf.getframerate()
+
+    transcript_html = make_interactive_transcript(text_out, duration)
+    return transcript_html, audio_path
+
+input_text = gr.Textbox(lines=5, label="Input Text")
+output_html = gr.HTML(label="Interactive Transcript")
+output_audio = gr.Audio(type="filepath", label="Exported Audio")
+language = gr.Dropdown(choices=list(language_dict.keys()), label="Choose the Voice Model")
+
+interface = gr.Interface(
+    fn=tts_with_interactive_transcript,
+    inputs=[input_text, language],
+    outputs=[output_html, output_audio],
+    title="Edge TTS with Interactive Transcript",
+    description="Click on any word in the transcript to jump to that part of the audio.",
+)
 
-# Run the application
 if __name__ == "__main__":
-    demo = asyncio.run(create_demo())
-    demo.launch()
+    anyio.run(interface.launch, backend="asyncio")