Upload app.py

app.py

@@ -9,6 +9,7 @@ import math
 import time
 from datetime import datetime, timedelta
 import logging
+from text_cleaning import TextCleaner
 
 # Configure logging
 logging.basicConfig(
@@ -119,49 +120,53 @@ def split_text_by_paragraphs(text, max_duration_minutes=5):
     logger.info(f"Split text into {len(segments)} segments.")
     return segments
 
+import io
+
 async def generate_audio_segment(text_segment, voice_short_name, rate_str, volume_str, pitch_str, segment_index):
-    """Generate audio for a single text segment"""
+    """Generate audio for a single text segment and return as BytesIO"""
     logger.info(f"Generating segment {segment_index}...")
     communicate = edge_tts.Communicate(text_segment, voice_short_name, rate=rate_str, volume=volume_str, pitch=pitch_str)
-    with tempfile.NamedTemporaryFile(delete=False, suffix=f"_segment_{segment_index}.mp3") as tmp_file:
-        tmp_path = tmp_file.name
-        await communicate.save(tmp_path)
+    
+    audio_data = io.BytesIO()
+    async for chunk in communicate.stream():
+        if chunk["type"] == "audio":
+            audio_data.write(chunk["data"])
+    
+    audio_data.seek(0)
     
     # Verify segment duration
     try:
-        seg_audio = AudioSegment.from_mp3(tmp_path)
+        # Make a copy for verification so we don't consume the main buffer
+        verify_buffer = io.BytesIO(audio_data.getvalue())
+        seg_audio = AudioSegment.from_mp3(verify_buffer)
         duration_min = len(seg_audio) / 1000 / 60
-        logger.info(f"Segment {segment_index} generated at {tmp_path} (Duration: {duration_min:.2f} min)")
+        logger.info(f"Segment {segment_index} generated in memory (Duration: {duration_min:.2f} min)")
     except Exception as e:
         logger.error(f"Error checking segment {segment_index} duration: {e}")
         
-    return tmp_path
+    audio_data.seek(0)
+    return audio_data
 
-async def merge_audio_files(audio_files):
-    """Merge multiple audio files into one"""
-    if not audio_files:
+async def merge_audio_files(audio_objects):
+    """Merge multiple audio BytesIO objects into one file"""
+    if not audio_objects:
         return None
     
-    if len(audio_files) == 1:
-        return audio_files[0]
+    logger.info(f"Merging {len(audio_objects)} audio segments...")
     
-    logger.info(f"Merging {len(audio_files)} audio files...")
     # Load and merge audio segments
     combined = AudioSegment.empty()
-    for audio_file in audio_files:
+    for i, audio_obj in enumerate(audio_objects):
         try:
-            segment = AudioSegment.from_mp3(audio_file)
+            audio_obj.seek(0)
+            segment = AudioSegment.from_mp3(audio_obj)
             combined += segment
+            # Explicitly close/clear the BytesIO object to free memory
+            audio_obj.close()
         except Exception as e:
-            logger.error(f"Error merging file {audio_file}: {e}")
-        
-        # Clean up temporary segment file
-        try:
-            os.remove(audio_file)
-        except:
-            pass
+            logger.error(f"Error merging segment {i+1}: {e}")
     
-    # Save merged audio
+    # Save merged audio to a single temporary file
     with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_file:
         merged_path = tmp_file.name
         combined.export(merged_path, format="mp3")
@@ -170,7 +175,7 @@ async def merge_audio_files(audio_files):
     logger.info(f"Merged audio saved to {merged_path} (Total Duration: {total_duration_min:.2f} min)")
     return merged_path
 
-async def text_to_speech_generator(text, voice, rate, volume, pitch):
+async def text_to_speech_generator(text, voice, rate, volume, pitch, cleaning_options=None):
     """Generate speech with detailed progress tracking via generator"""
     if not text.strip():
         yield None, "Please enter text to convert.", None
@@ -178,7 +183,25 @@ async def text_to_speech_generator(text, voice, rate, volume, pitch):
     if not voice:
         yield None, "Please select a voice.", None
         return
-    
+
+    # Apply text cleaning if enabled
+    if cleaning_options and cleaning_options.get('enable_cleaning', False):
+        yield 0, "Cleaning text...", None
+        # original_text = text # Unused
+        text = TextCleaner.clean_text(text, cleaning_options)
+        
+        if cleaning_options.get('save_cleaned', False):
+            # Create a filename based on timestamp or first few words
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            filename = f"text_{timestamp}.txt"
+            saved_path = TextCleaner.save_cleaned_text(text, filename)
+            if saved_path:
+                logger.info(f"Saved cleaned text to {saved_path}")
+                
+        if not text.strip():
+            yield None, "Text cleaning resulted in empty text.", None
+            return
+            
     voice_short_name = voice.split(" - ")[0]
     rate_str = f"{rate:+d}%"
     volume_str = f"{volume:+d}%"
@@ -199,7 +222,7 @@ async def text_to_speech_generator(text, voice, rate, volume, pitch):
         
         if total_segments > 1:
             # Generate audio for each segment with progress tracking
-            audio_files = []
+            audio_objects = []
             start_time = time.time()
             
             for i, segment in enumerate(segments):
@@ -216,18 +239,19 @@ async def text_to_speech_generator(text, voice, rate, volume, pitch):
                     logger.info(f"Progress: {status_msg.replace(chr(10), ', ')}")
                     yield progress, status_msg, segment_info
                     
-                    audio_file = await generate_audio_segment(
+                    # Generate to memory
+                    audio_obj = await generate_audio_segment(
                         segment, voice_short_name, rate_str, volume_str, pitch_str, i+1
                     )
-                    audio_files.append(audio_file)
+                    audio_objects.append(audio_obj)
             
             yield 90, "Merging audio files...", segment_info
             
-            # Merge all audio files
-            merged_audio = await merge_audio_files(audio_files)
+            # Merge all audio objects
+            merged_audio_path = await merge_audio_files(audio_objects)
             
             yield 100, "Audio generation complete! ✅", segment_info
-            yield merged_audio, "Done", segment_info
+            yield merged_audio_path, "Done", segment_info
             return
     
     # For short texts or single segment, use original method
@@ -243,7 +267,10 @@ async def text_to_speech_generator(text, voice, rate, volume, pitch):
     yield 100, "Audio generation complete! ✅", None
     yield tmp_path, "Done", None
 
-async def tts_interface(text, voice, rate, volume, pitch):
+async def tts_interface(text, voice, rate, volume, pitch, 
+                        enable_cleaning, save_cleaned, clean_urls, clean_html, 
+                        clean_ads, fix_enc, tidy_ws, del_gutenberg, 
+                        del_special, wetext_norm):
     """Enhanced TTS interface with detailed progress tracking"""
     if not text.strip():
         yield None, gr.update(visible=False), "Please enter text.", gr.update(visible=False)
@@ -252,12 +279,38 @@ async def tts_interface(text, voice, rate, volume, pitch):
         yield None, gr.update(visible=False), "Please select a voice.", gr.update(visible=False)
         return
     
-    estimated_duration = estimate_text_duration(text)
+    # Prepare cleaning options
+    cleaning_options = {
+        'enable_cleaning': enable_cleaning,
+        'save_cleaned': save_cleaned,
+        'remove_urls': clean_urls,
+        'remove_html': clean_html,
+        'filter_ads': clean_ads,
+        'fix_encoding': fix_enc,
+        'tidy_whitespace': tidy_ws,
+        'remove_gutenberg': del_gutenberg,
+        'remove_special_chars': del_special,
+        'wetext_normalization': wetext_norm
+    }
+    
+    # We need to clean text here first to estimate duration correctly? 
+    # Or let the generator handle it. The generator handles it, but estimation might be off.
+    # Ideally we clean first if enabled, then estimate.
+    
+    working_text = text
+    if enable_cleaning:
+        working_text = TextCleaner.clean_text(text, cleaning_options)
+        if save_cleaned:
+             # We'll let the generator save it to avoid double saving or complex logic here,
+             # but we need to pass the options.
+             pass
+
+    estimated_duration = estimate_text_duration(working_text)
     
     # Reset UI
     yield None, gr.update(value="Starting...", visible=True), "Initializing...", gr.update(visible=False)
     
-    async for result in text_to_speech_generator(text, voice, rate, volume, pitch):
+    async for result in text_to_speech_generator(text, voice, rate, volume, pitch, cleaning_options):
         if isinstance(result, tuple) and len(result) == 3:
             # Progress update
             progress_val, status_msg, segment_info = result
@@ -309,6 +362,33 @@ async def create_demo():
                 # Add text analysis info
                 text_info = gr.Markdown("**Text Analysis**: Enter text to see estimated duration and segment count", visible=True)
                 
+                with gr.Accordion("Text Cleaning Settings", open=True):
+                    with gr.Row():
+                        enable_cleaning = gr.Checkbox(label="Enable Text Cleaning", value=True)
+                        save_cleaned = gr.Checkbox(label="Save Cleaned Text File", value=True)
+                    
+                    with gr.Group(visible=True) as cleaning_options_group:
+                        with gr.Row():
+                            clean_urls = gr.Checkbox(label="Remove URLs", value=True)
+                            clean_html = gr.Checkbox(label="Remove HTML", value=True)
+                        
+                        with gr.Row():
+                            clean_ads = gr.Checkbox(label="Filter Ads", value=True)
+                            fix_enc = gr.Checkbox(label="Fix Encoding", value=True)
+                            
+                        with gr.Row():
+                            tidy_ws = gr.Checkbox(label="Tidy Whitespace", value=True)
+                            del_gutenberg = gr.Checkbox(label="Remove Project Gutenberg", value=True)
+                            
+                        with gr.Row():
+                            del_special = gr.Checkbox(label="Remove Special Characters", value=True)
+                            wetext_norm = gr.Checkbox(label="Enable WeText Normalization", value=True)
+                    
+                    def toggle_options(enabled):
+                        return gr.update(visible=enabled)
+                    
+                    enable_cleaning.change(fn=toggle_options, inputs=[enable_cleaning], outputs=[cleaning_options_group])
+
                 voice_dropdown = gr.Dropdown(choices=[""] + list(voices.keys()), label="Select Voice", value=default_voice)
                 
                 with gr.Row():
@@ -361,7 +441,12 @@ async def create_demo():
 
         generate_btn.click(
             fn=tts_interface,
-            inputs=[text_input, voice_dropdown, rate_slider, volume_slider, pitch_slider],
+            inputs=[
+                text_input, voice_dropdown, rate_slider, volume_slider, pitch_slider,
+                enable_cleaning, save_cleaned, clean_urls, clean_html, 
+                clean_ads, fix_enc, tidy_ws, del_gutenberg, 
+                del_special, wetext_norm
+            ],
             outputs=[audio_output, progress_info, status_output, segment_details]
         )