Update app.py

app.py

@@ -12,6 +12,9 @@ from typing import List, Tuple, Optional, Dict, Any
 import math
 from dataclasses import dataclass
 
+# No changes to these classes and helper functions
+# (TimingManager, Segment, TextProcessor, TTSError, etc.)
+# ...
 class TimingManager:
     def __init__(self):
         self.current_time = 0
@@ -41,178 +44,115 @@ class Segment:
     end_time: int = 0
     duration: int = 0
     audio: Optional[AudioSegment] = None
-    lines: List[str] = None  # Add lines field for display purposes only
+    lines: List[str] = None
 
 class TextProcessor:
     def __init__(self, words_per_line: int, lines_per_segment: int):
         self.words_per_line = words_per_line
         self.lines_per_segment = lines_per_segment
         self.min_segment_words = 3
-        self.max_segment_words = words_per_line * lines_per_segment * 1.5  # Allow 50% more for natural breaks
+        self.max_segment_words = words_per_line * lines_per_segment * 1.5
         self.punctuation_weights = {
-            '.': 1.0,  # Strong break
-            '!': 1.0,
-            '?': 1.0,
-            ';': 0.8,  # Medium-strong break
-            ':': 0.7,
-            ',': 0.5,  # Medium break
-            '-': 0.3,  # Weak break
-            '(': 0.2,
-            ')': 0.2
+            '.': 1.0, '!': 1.0, '?': 1.0, ';': 0.8, ':': 0.7,
+            ',': 0.5, '-': 0.3, '(': 0.2, ')': 0.2
         }
     
     def analyze_sentence_complexity(self, text: str) -> float:
-        """Analyze sentence complexity to determine optimal segment length"""
         words = text.split()
+        if not words: return 1.0
         complexity = 1.0
-        
-        # Adjust for sentence length
         if len(words) > self.words_per_line * 2:
             complexity *= 1.2
-        
-        # Adjust for punctuation density
         punct_count = sum(text.count(p) for p in self.punctuation_weights.keys())
-        if len(words) > 0:
-            complexity *= (1 + (punct_count / len(words)) * 0.5)
-        
+        complexity *= (1 + (punct_count / len(words)) * 0.5)
         return complexity
 
     def find_natural_breaks(self, text: str) -> List[Tuple[int, float]]:
-        """Find natural break points with their weights"""
         breaks = []
         words = text.split()
-        
         for i, word in enumerate(words):
             weight = 0
-            
-            # Check for punctuation
             for punct, punct_weight in self.punctuation_weights.items():
                 if word.endswith(punct):
                     weight = max(weight, punct_weight)
-            
-            # Check for natural phrase boundaries
             phrase_starters = {'however', 'therefore', 'moreover', 'furthermore', 'meanwhile', 'although', 'because'}
             if i < len(words) - 1 and words[i+1].lower() in phrase_starters:
                 weight = max(weight, 0.6)
-            
-            # Check for conjunctions at natural points
             if i > self.min_segment_words:
                 conjunctions = {'and', 'but', 'or', 'nor', 'for', 'yet', 'so'}
                 if word.lower() in conjunctions:
                     weight = max(weight, 0.4)
-            
             if weight > 0:
                 breaks.append((i, weight))
-        
         return breaks
 
     def split_into_segments(self, text: str) -> List[Segment]:
-        # Normalize text and add proper spacing around punctuation
         text = re.sub(r'\s+', ' ', text.strip())
         text = re.sub(r'([.!?,;:])\s*', r'\1 ', text)
         text = re.sub(r'\s+([.!?,;:])', r'\1', text)
-        
         segments = []
         words = text.split()
-        
         i = 0
         while i < len(words):
-            # Dynamically select a chunk to analyze for breaks
             chunk_end = i + int(self.max_segment_words)
             chunk_text = ' '.join(words[i:chunk_end])
             complexity = self.analyze_sentence_complexity(chunk_text)
             breaks = self.find_natural_breaks(chunk_text)
-            
             best_break = -1
             best_weight = -1
-            
-            # Find the best break point within the ideal segment length
             ideal_length = self.words_per_line * self.lines_per_segment
-            
             for break_idx, weight in breaks:
-                # Prioritize breaks closer to the ideal length
                 distance_penalty = 1 - (abs(break_idx - ideal_length) / ideal_length) * 0.5
                 score = weight * distance_penalty
-
                 if score > best_weight:
                     best_break = break_idx
                     best_weight = score
-            
             if best_break == -1:
-                # If no break found, split at the ideal length or end of text
                 best_break = min(ideal_length, len(words) - 1 - i)
-            
             segment_words = words[i : i + best_break + 1]
             segment_text = ' '.join(segment_words)
-            
             lines = self.split_into_lines(segment_text)
             final_segment_text = '\n'.join(lines)
-            
-            segments.append(Segment(
-                id=len(segments) + 1,
-                text=final_segment_text
-            ))
-            
+            segments.append(Segment(id=len(segments) + 1, text=final_segment_text))
             i += best_break + 1
-        
         return segments
 
     def split_into_lines(self, text: str) -> List[str]:
-        """Split segment text into natural lines"""
         words = text.split()
         lines = []
         current_line = []
         word_count = 0
-        
         for word in words:
             current_line.append(word)
             word_count += 1
-            
-            is_break = (
-                word_count >= self.words_per_line or
-                any(word.endswith(p) for p in '.!?') or
-                (word_count >= self.words_per_line * 0.7 and
-                 any(word.endswith(p) for p in ',;:'))
-            )
-            
+            is_break = (word_count >= self.words_per_line or
+                        any(word.endswith(p) for p in '.!?') or
+                        (word_count >= self.words_per_line * 0.7 and
+                         any(word.endswith(p) for p in ',;:')))
             if is_break and len(words) > word_count:
                 lines.append(' '.join(current_line))
                 current_line = []
                 word_count = 0
-        
         if current_line:
             lines.append(' '.join(current_line))
-        
         return lines
 
 class TTSError(Exception):
-    """Custom exception for TTS processing errors"""
     pass
 
 async def process_segment_with_timing(segment: Segment, voice: str, rate: str, pitch: str) -> Segment:
-    """Process a complete segment as a single TTS unit with improved error handling"""
     temp_dir = tempfile.gettempdir()
     audio_file = os.path.join(temp_dir, f"temp_segment_{segment.id}_{uuid.uuid4()}.wav")
     try:
         segment_text = ' '.join(segment.text.split('\n'))
         tts = edge_tts.Communicate(segment_text, voice, rate=rate, pitch=pitch)
-        
-        try:
-            await tts.save(audio_file)
-        except Exception as e:
-            raise TTSError(f"Failed to generate audio for segment {segment.id}: {str(e)}")
-        
+        await tts.save(audio_file)
         if not os.path.exists(audio_file) or os.path.getsize(audio_file) == 0:
             raise TTSError(f"Generated audio file is empty or missing for segment {segment.id}")
-        
-        try:
-            segment.audio = AudioSegment.from_file(audio_file)
-            silence = AudioSegment.silent(duration=30)
-            segment.audio = silence + segment.audio + silence
-            segment.duration = len(segment.audio)
-        except Exception as e:
-            raise TTSError(f"Failed to process audio file for segment {segment.id}: {str(e)}")
-        
+        segment.audio = AudioSegment.from_file(audio_file)
+        silence = AudioSegment.silent(duration=30)
+        segment.audio = silence + segment.audio + silence
+        segment.duration = len(segment.audio)
         return segment
     except Exception as e:
         if not isinstance(e, TTSError):
@@ -226,25 +166,20 @@ async def process_segment_with_timing(segment: Segment, voice: str, rate: str, p
                 pass
 
 class FileManager:
-    """Manages temporary and output files with cleanup capabilities"""
     def __init__(self):
         self.temp_dir = tempfile.mkdtemp(prefix="tts_app_")
         self.output_files = []
         self.max_files_to_keep = 5
         
     def create_output_paths(self):
-        """Create paths for output files"""
         unique_id = str(uuid.uuid4())
         audio_path = os.path.join(self.temp_dir, f"final_audio_{unique_id}.mp3")
         srt_path = os.path.join(self.temp_dir, f"final_subtitles_{unique_id}.srt")
-        
         self.output_files.append((srt_path, audio_path))
         self.cleanup_old_files()
-        
         return srt_path, audio_path
     
     def cleanup_old_files(self):
-        """Clean up old output files, keeping only the most recent ones"""
         if len(self.output_files) > self.max_files_to_keep:
             old_files_to_remove = self.output_files[:-self.max_files_to_keep]
             for srt_path, audio_path in old_files_to_remove:
@@ -256,7 +191,6 @@ class FileManager:
             self.output_files = self.output_files[-self.max_files_to_keep:]
     
     def cleanup_all(self):
-        """Clean up all managed files"""
         for srt_path, audio_path in self.output_files:
             try:
                 if os.path.exists(srt_path): os.remove(srt_path)
@@ -275,19 +209,15 @@ async def generate_accurate_srt(
     words_per_line: int, lines_per_segment: int,
     progress_callback=None, parallel: bool = True, max_workers: int = 4
 ) -> Tuple[str, str]:
-    """Generate accurate SRT with parallel processing option"""
     processor = TextProcessor(words_per_line, lines_per_segment)
     segments = processor.split_into_segments(text)
     total_segments = len(segments)
-    
     if progress_callback:
         progress_callback(0.1, "Text segmentation complete")
-    
     processed_segments = []
     if parallel and total_segments > 1:
         semaphore = asyncio.Semaphore(max_workers)
         processed_count = 0
-        
         async def process_with_semaphore(segment):
             async with semaphore:
                 nonlocal processed_count
@@ -297,10 +227,8 @@ async def generate_accurate_srt(
                     progress = 0.1 + (0.8 * processed_count / total_segments)
                     progress_callback(progress, f"Processed {processed_count}/{total_segments} segments")
                 return result
-        
         tasks = [process_with_semaphore(s) for s in segments]
         results = await asyncio.gather(*tasks, return_exceptions=True)
-        
         for res in results:
             if isinstance(res, Exception):
                 raise TTSError(f"A task failed during parallel processing: {res}")
@@ -312,11 +240,9 @@ async def generate_accurate_srt(
             if progress_callback:
                 progress = 0.1 + (0.8 * (i + 1) / total_segments)
                 progress_callback(progress, f"Processed {i + 1}/{total_segments} segments")
-    
     processed_segments.sort(key=lambda s: s.id)
     if progress_callback:
         progress_callback(0.9, "Finalizing audio and subtitles")
-    
     current_time = 0
     final_audio = AudioSegment.empty()
     srt_content = ""
@@ -326,33 +252,75 @@ async def generate_accurate_srt(
         srt_content += f"{segment.id}\n{format_time_ms(segment.start_time)} --> {format_time_ms(segment.end_time)}\n{segment.text}\n\n"
         final_audio = final_audio.append(segment.audio, crossfade=0)
         current_time = segment.end_time
-    
     srt_path, audio_path = file_manager.create_output_paths()
-    try:
-        export_params = {'format': 'mp3', 'bitrate': '192k', 'parameters': ['-ar', '44100', '-ac', '2', '-qscale:a', '2']}
-        final_audio.export(audio_path, **export_params)
-        with open(srt_path, "w", encoding='utf-8') as f: f.write(srt_content)
-    except Exception as e:
-        raise TTSError(f"Failed to export final files: {str(e)}")
-    
+    export_params = {'format': 'mp3', 'bitrate': '192k', 'parameters': ['-ar', '44100', '-ac', '2', '-qscale:a', '2']}
+    final_audio.export(audio_path, **export_params)
+    with open(srt_path, "w", encoding='utf-8') as f: f.write(srt_content)
     if progress_callback:
         progress_callback(1.0, "Complete!")
     return srt_path, audio_path
 
-# MODIFICATION: This function now returns a gr.update() object for the error textbox
+### MODIFICATION START ###
+# This new function creates the HTML for the download buttons using the JavaScript strategy.
+def create_download_links_html(srt_path: str, audio_path: str) -> str:
+    """Generates an HTML string with JS-powered download links."""
+    if not srt_path or not audio_path:
+        return ""
+
+    srt_filename = os.path.basename(srt_path)
+    audio_filename = os.path.basename(audio_path)
+
+    # This JavaScript function handles the download without navigating the page.
+    js_download_logic = """
+    event.preventDefault();
+    fetch(this.href).then(resp => resp.blob()).then(blob => {
+        const url = window.URL.createObjectURL(blob);
+        const a = document.createElement('a');
+        a.style.display = 'none';
+        a.href = url;
+        a.download = this.getAttribute('download');
+        document.body.appendChild(a);
+        a.click();
+        window.URL.revokeObjectURL(url);
+        document.body.removeChild(a);
+    });
+    """
+
+    # Use the /file= relative path which Gradio provides for serving files.
+    srt_url = f"/file={srt_path}"
+    audio_url = f"/file={audio_path}"
+
+    # Combine both links into a single HTML string.
+    html = f"""
+    <div style="text-align: center; padding: 10px 0;">
+        <a href="{srt_url}" download="{srt_filename}" onclick="{js_download_logic}"
+           style="display: inline-block; padding: 8px 15px; background-color: #0b5ed7; color: white; text-decoration: none; border-radius: 5px; font-weight: 600; margin-right: 15px; cursor: pointer;">
+            📥 Download SRT
+        </a>
+        <a href="{audio_url}" download="{audio_filename}" onclick="{js_download_logic}"
+           style="display: inline-block; padding: 8px 15px; background-color: #0b5ed7; color: white; text-decoration: none; border-radius: 5px; font-weight: 600; cursor: pointer;">
+            📥 Download Audio
+        </a>
+    </div>
+    """
+    return html
+
+# This main processing function is now simplified.
 async def process_text_with_progress(
     text, pitch, rate, voice, words_per_line, 
     lines_per_segment, parallel_processing,
     progress=gr.Progress()
 ):
     """
-    Processes text and returns audio, HTML links, and a gr.update object for status.
+    Processes text, returns an audio path for the preview and an HTML string
+    that contains either the download links or an error message.
     """
+    # On validation failure, return None for the audio preview and an error HTML.
     if not text or text.strip() == "":
-        return None, "", gr.update(visible=True, value="Please enter some text to convert to speech.")
+        return None, "<p style='color:red; text-align:center;'>Please enter some text to convert.</p>"
     
-    pitch_str = f"{pitch:+d}Hz" if pitch != 0 else "+0Hz"
-    rate_str = f"{rate:+d}%" if rate != 0 else "+0%"
+    pitch_str = f"{pitch:+d}Hz"
+    rate_str = f"{rate:+d}%"
     
     try:
         progress(0, "Preparing text...")
@@ -367,21 +335,19 @@ async def process_text_with_progress(
             parallel=parallel_processing
         )
         
-        download_html = f"""
-        <div style="text-align: center; padding-top: 10px;">
-            <a href="/file={srt_path}" target="_blank" download="subtitles.srt" style="font-weight: 600; color: #0b5ed7; text-decoration: none; margin-right: 20px;">📥 Download SRT File</a>
-            <a href="/file={audio_path}" target="_blank" download="audio.mp3" style="font-weight: 600; color: #0b5ed7; text-decoration: none;">📥 Download Audio File</a>
-        </div>
-        """
+        # Get the JS-powered download links HTML.
+        download_html = create_download_links_html(srt_path, audio_path)
         
-        # Return audio path, HTML links, and a gr.update object to hide the status
-        return audio_path, download_html, gr.update(visible=False, value="")
-    except TTSError as e:
-        return None, "", gr.update(visible=True, value=f"TTS Error: {str(e)}")
+        # Return the audio path for the player and the HTML for the download/status area.
+        return audio_path, download_html
+
     except Exception as e:
-        return None, "", gr.update(visible=True, value=f"Unexpected error: {str(e)}")
+        # On processing error, return None for audio and an error HTML.
+        error_message = f"An error occurred: {str(e)}"
+        return None, f"<p style='color:red; text-align:center;'>{error_message}</p>"
+
+### MODIFICATION END ###
 
-# Voice options dictionary
 voice_options = {
     "Andrew Male": "en-US-AndrewNeural", "Jenny Female": "en-US-JennyNeural", "Guy Male": "en-US-GuyNeural",
     "Ana Female": "en-US-AnaNeural", "Aria Female": "en-US-AriaNeural", "Brian Male": "en-US-BrianNeural",
@@ -422,15 +388,18 @@ with gr.Blocks(title="Advanced TTS with Configurable SRT Generation") as app:
             parallel_processing = gr.Checkbox(label="Enable Parallel Processing", value=True, info="Faster conversion for longer texts.")
     
     submit_btn = gr.Button("Generate Audio & Subtitles", variant="primary")
-    error_output = gr.Textbox(label="Status", visible=False, interactive=False)
     
+    ### MODIFICATION START ###
+    # The output area is simplified.
     with gr.Row():
         with gr.Column(scale=2):
+            # This component is for the audio player preview.
             audio_preview = gr.Audio(label="Preview Audio")
         with gr.Column(scale=1):
-            download_links_output = gr.HTML(label="Download Files")
-    
-    # MODIFICATION: The outputs list is now simplified
+            # This single HTML component will hold EITHER the download links OR an error message.
+            status_and_download_output = gr.HTML(label="Status & Downloads")
+
+    # The .click() event is now simpler and more robust.
     submit_btn.click(
         fn=process_text_with_progress,
         inputs=[
@@ -439,11 +408,11 @@ with gr.Blocks(title="Advanced TTS with Configurable SRT Generation") as app:
         ],
         outputs=[
             audio_preview,
-            download_links_output,
-            error_output,
+            status_and_download_output
         ],
         api_name="generate"
     )
+    ### MODIFICATION END ###
 
 if __name__ == "__main__":
     app.launch()