Update app.py

app.py

@@ -1,109 +1,89 @@
 import gradio as gr
+from pydub import AudioSegment
 import edge_tts
 import os
 import asyncio
-import re
-from datetime import timedelta
-from pydub import AudioSegment  # Requires `pydub`
-
-# Split text into 500-word batches for large scripts
-def split_text(text, max_words=500):
-    words = text.split()
-    return [' '.join(words[i:i + max_words]) for i in range(0, len(words), max_words)]
-
-# Split batch into SRT sections (e.g., 8-10 words per section)
-def generate_srt_sections(text, words_per_segment=8):
-    words = re.split(r'(\s+)', text)  # Split with spaces to keep punctuation
-    srt_sections = []
-    section_text = []
-
-    for word in words:
-        section_text.append(word)
-        if len(section_text) >= words_per_segment or word.endswith(('.', '!', '?')):
-            srt_sections.append(''.join(section_text).strip())
-            section_text = []
-
-    if section_text:
-        srt_sections.append(''.join(section_text).strip())
-
-    return srt_sections
-
-# Generate audio for a single SRT section and return its length
-async def generate_audio_for_section(text, filename):
-    communicate = edge_tts.Communicate(text, "en-US-GuyNeural")
-    await communicate.save(filename)
-    audio = AudioSegment.from_file(filename)
-    return len(audio) / 1000  # Duration in seconds
-
-# Create accurate SRT for a batch with cross-check mechanism
-def generate_accurate_srt(batch_text, estimated_rate=0.5):
-    sections = generate_srt_sections(batch_text)
+
+# Function to get the length of an audio file in seconds
+def get_audio_length(audio_file):
+    audio = AudioSegment.from_file(audio_file)
+    return audio.duration_seconds
+
+# Function to format time for SRT
+def format_time(seconds):
+    millis = int((seconds % 1) * 1000)
+    seconds = int(seconds)
+    hrs = seconds // 3600
+    mins = (seconds % 3600) // 60
+    secs = seconds % 60
+    return f"{hrs:02}:{mins:02}:{secs:02},{millis:03}"
+
+# Function to generate SRT with accurate timing per batch
+async def generate_accurate_srt(batch_text, batch_num):
+    audio_file = f"batch_{batch_num}_audio.wav"
+    
+    # Generate the audio using edge-tts
+    tts = edge_tts.Communicate(batch_text, "en-US-JennyNeural")
+    await tts.save(audio_file)
+
+    # Get the actual length of the audio file
+    actual_length = get_audio_length(audio_file)
+
+    # Initialize SRT content
     srt_content = ""
-    index = 1
+    words = batch_text.split()
     start_time = 0.0
-
-    for section in sections:
-        # Generate and cross-check audio for the section
-        audio_file = f"temp_audio_{index}.mp3"
-        asyncio.run(generate_audio_for_section(section, audio_file))
-
-        # Measure actual audio length for precise timing
-        actual_length = get_audio_length(audio_file)
-        end_time = start_time + actual_length
-
-        # Create SRT format for each section
-        start_timestamp = str(timedelta(seconds=start_time))
-        end_timestamp = str(timedelta(seconds=end_time))
-
-        srt_content += f"{index}\n{start_timestamp} --> {end_timestamp}\n{section}\n\n"
-        
+    segment_duration = actual_length / len(words) * 10  # Assuming ~10 words per SRT segment
+
+    # Build SRT content with accurate timing
+    for i in range(0, len(words), 10):
+        segment_words = words[i:i+10]
+        end_time = start_time + segment_duration
+        srt_content += f"{i // 10 + 1}\n"
+        srt_content += f"{format_time(start_time)} --> {format_time(end_time)}\n"
+        srt_content += " ".join(segment_words) + "\n\n"
         start_time = end_time
-        index += 1
 
-    return srt_content
+    return srt_content, audio_file
 
-# Batch processing with section-wise cross-checking
-def batch_process_srt_and_audio(script):
-    batches = split_text(script, max_words=500)
-    final_srt_content = ""
-    audio_files = []
+# Batch processing function for SRT and audio generation
+async def batch_process_srt_and_audio(script_text):
+    batches = [script_text[i:i+500] for i in range(0, len(script_text), 500)]
+    all_srt_content = ""
+    combined_audio = AudioSegment.empty()
 
-    for batch_index, batch_text in enumerate(batches):
-        # Generate precise SRT for each batch with individual section cross-checking
-        srt_content = generate_accurate_srt(batch_text)
-        final_srt_content += srt_content
+    for batch_num, batch_text in enumerate(batches):
+        srt_content, audio_file = await generate_accurate_srt(batch_text, batch_num)
+        all_srt_content += srt_content
 
-        # Generate final batch audio and store
-        batch_audio_file = f"batch_audio_{batch_index}.mp3"
-        asyncio.run(generate_audio_for_section(batch_text, batch_audio_file))
-        audio_files.append(batch_audio_file)
+        # Append the audio of each batch to the combined audio
+        batch_audio = AudioSegment.from_file(audio_file)
+        combined_audio += batch_audio
 
-    # Save final SRT file
-    final_srt_path = "final_output.srt"
-    with open(final_srt_path, "w") as f:
-        f.write(final_srt_content)
+        # Clean up the individual batch audio file
+        os.remove(audio_file)
 
-    # Combine all batch audio files
-    final_audio_path = "final_combined_audio.mp3"
-    combine_audio_files(audio_files, final_audio_path)
+    # Export combined audio and SRT
+    combined_audio.export("final_audio.wav", format="wav")
+    with open("final_subtitles.srt", "w") as srt_file:
+        srt_file.write(all_srt_content)
 
-    return final_srt_path, final_audio_path
+    return "final_subtitles.srt", "final_audio.wav"
 
-# Combine audio files into one output file
-def combine_audio_files(audio_files, output_file):
-    combined = AudioSegment.empty()
-    for file in audio_files:
-        combined += AudioSegment.from_file(file)
-    combined.export(output_file, format="mp3")
+# Gradio interface function
+async def process_script(script_text):
+    srt_path, audio_path = await batch_process_srt_and_audio(script_text)
+    return srt_path, audio_path
 
-# Gradio Interface
+# Gradio interface setup
 app = gr.Interface(
-    fn=batch_process_srt_and_audio,
-    inputs=gr.Textbox(lines=10, label="Input Script"),
-    outputs=[gr.File(label="Download SRT"), gr.File(label="Download Audio")],
-    title="Accurate Batch SRT & Audio Generator with Cross-Check",
-    description="Enter a script to generate synchronized SRT and audio files with section-wise accuracy."
+    fn=process_script,
+    inputs=gr.Textbox(label="Enter Script Text", lines=10),
+    outputs=[
+        gr.File(label="Download SRT File"),
+        gr.File(label="Download Audio File")
+    ],
+    description="Upload your script text, and the app will generate audio and an accurate SRT file for download."
 )
 
-if __name__ == "__main__":
-    app.launch()
+app.launch()