Update app.py

app.py

@@ -5,6 +5,9 @@ import os
 import asyncio
 import uuid
 import re
+from concurrent.futures import ThreadPoolExecutor
+from typing import List, Tuple
+import math
 
 def get_audio_length(audio_file):
     audio = AudioSegment.from_file(audio_file)
@@ -60,43 +63,79 @@ def smart_text_split(text, words_per_line, lines_per_segment):
     
     return segments
 
-async def generate_accurate_srt(text, voice, rate, pitch, words_per_line, lines_per_segment):
-    segments = smart_text_split(text, words_per_line, lines_per_segment)
-    
-    srt_content = ""
-    combined_audio = AudioSegment.empty()
-    current_time = 0
-    
-    for idx, segment in enumerate(segments, 1):
-        # Generate audio for this segment
-        audio_file = f"temp_segment_{idx}.wav"
+async def process_segment(segment: str, idx: int, voice: str, rate: str, pitch: str) -> Tuple[str, AudioSegment, int]:
+    """Process a single segment concurrently"""
+    audio_file = f"temp_segment_{idx}_{uuid.uuid4()}.wav"
+    try:
         tts = edge_tts.Communicate(segment, voice, rate=rate, pitch=pitch)
         await tts.save(audio_file)
         
-        # Get segment duration
         segment_audio = AudioSegment.from_file(audio_file)
         segment_duration = len(segment_audio)
         
-        # Add to SRT content with precise timing
-        srt_content += f"{idx}\n"
-        srt_content += f"{format_time_ms(current_time)} --> {format_time_ms(current_time + segment_duration)}\n"
-        srt_content += segment + "\n\n"
+        srt_content = f"{idx}\n"
         
-        # Update timing and combine audio
-        current_time += segment_duration
-        combined_audio += segment_audio
+        return srt_content, segment_audio, segment_duration
+    finally:
+        if os.path.exists(audio_file):
+            os.remove(audio_file)
+
+async def process_chunk_parallel(chunks: List[str], start_idx: int, voice: str, rate: str, pitch: str) -> Tuple[str, AudioSegment]:
+    """Process a chunk of segments in parallel"""
+    tasks = [
+        process_segment(segment, i + start_idx, voice, rate, pitch)
+        for i, segment in enumerate(chunks, 1)
+    ]
+    
+    results = await asyncio.gather(*tasks)
+    
+    combined_audio = AudioSegment.empty()
+    srt_content = ""
+    current_time = 0
+    
+    for srt_part, audio_part, duration in results:
+        srt_content += srt_part
+        srt_content += f"{format_time_ms(current_time)} --> {format_time_ms(current_time + duration)}\n"
+        srt_content += chunks[len(combined_audio.get_dc_offset())] + "\n\n"
         
-        # Cleanup
-        os.remove(audio_file)
+        combined_audio += audio_part
+        current_time += duration
+    
+    return srt_content, combined_audio
+
+async def generate_accurate_srt(text, voice, rate, pitch, words_per_line, lines_per_segment):
+    segments = smart_text_split(text, words_per_line, lines_per_segment)
+    
+    # Split segments into chunks for parallel processing
+    chunk_size = 10  # Process 10 segments at a time
+    chunks = [segments[i:i + chunk_size] for i in range(0, len(segments), chunk_size)]
+    
+    final_srt = ""
+    final_audio = AudioSegment.empty()
+    
+    # Process chunks in parallel
+    chunk_tasks = []
+    for i, chunk in enumerate(chunks):
+        start_idx = i * chunk_size + 1
+        task = process_chunk_parallel(chunk, start_idx, voice, rate, pitch)
+        chunk_tasks.append(task)
+    
+    # Gather results
+    chunk_results = await asyncio.gather(*chunk_tasks)
+    
+    # Combine results
+    for srt_content, audio_content in chunk_results:
+        final_srt += srt_content
+        final_audio += audio_content
     
     # Export final files
     unique_id = uuid.uuid4()
     audio_path = f"final_audio_{unique_id}.mp3"
     srt_path = f"final_subtitles_{unique_id}.srt"
     
-    combined_audio.export(audio_path, format="mp3", bitrate="320k")
+    final_audio.export(audio_path, format="mp3", bitrate="320k")
     with open(srt_path, "w", encoding='utf-8') as f:
-        f.write(srt_content)
+        f.write(final_srt)
     
     return srt_path, audio_path