feat: implement simplified audio processing with enhanced TTS API integration

src/processors/generate_simple_tts_audio.py

@@ -0,0 +1,174 @@
+"""Simplified TTS audio generation that uses the enhanced API endpoints."""
+import os
+import requests
+import tempfile
+import soundfile as sf
+import numpy as np
+import gradio as gr
+
+
+def generate_simple_tts_audio(text_input: str, audio_prompt_input=None, progress=None):
+    """
+    Generate TTS audio using the enhanced API that handles chunking and concatenation server-side.
+    
+    Args:
+        text_input: The text to convert to speech (any length)
+        audio_prompt_input: Optional audio prompt for voice cloning
+        progress: Optional progress callback
+        
+    Returns:
+        Tuple of (sample_rate, audio_data)
+    """
+    # Use the new full-text endpoint that handles everything server-side
+    FULL_TEXT_ENDPOINT = os.getenv("FULL_TEXT_TTS_ENDPOINT", "YOUR-MODAL-ENDPOINT-URL/generate_full_text_audio")
+    GENERATE_WITH_FILE_ENDPOINT = os.getenv("GENERATE_WITH_FILE_ENDPOINT", "YOUR-MODAL-ENDPOINT-URL/generate_with_file")
+    
+    if not text_input or len(text_input.strip()) == 0:
+        raise gr.Error("Please enter some text to synthesize.")
+    
+    if progress: 
+        progress(0.1, desc="Preparing request for full-text processing...")
+    
+    try:
+        if audio_prompt_input is None:
+            # Use the new full-text endpoint for enhanced processing
+            if progress: 
+                progress(0.3, desc="Sending full text to enhanced TTS API...")
+            
+            payload = {
+                "text": text_input,
+                "max_chunk_size": 800,
+                "silence_duration": 0.5,
+                "fade_duration": 0.1,
+                "overlap_sentences": 0
+            }
+            
+            response = requests.post(
+                FULL_TEXT_ENDPOINT,
+                json=payload,
+                headers={"Content-Type": "application/json"},
+                timeout=300,  # Longer timeout for full-text processing
+                stream=True
+            )
+            
+            if response.status_code != 200:
+                raise gr.Error(f"API Error: {response.status_code} - {response.text}")
+            
+            if progress: 
+                progress(0.6, desc="Server processing text chunks in parallel...")
+            
+            # Get content length if available for progress tracking
+            content_length = response.headers.get('content-length')
+            chunks_processed = response.headers.get('X-Chunks-Processed', 'unknown')
+            total_chars = response.headers.get('X-Total-Characters', len(text_input))
+            
+            if progress:
+                progress(0.7, desc=f"Processing {chunks_processed} chunks ({total_chars} characters)...")
+            
+            bytes_downloaded = 0
+            with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_file:
+                for chunk in response.iter_content(chunk_size=8192):
+                    if chunk:
+                        temp_file.write(chunk)
+                        bytes_downloaded += len(chunk)
+                        
+                        # Update progress based on bytes downloaded
+                        if progress:
+                            progress(0.7, desc=f"Downloading processed audio... ({bytes_downloaded // 1024}KB)")
+                            
+                temp_path = temp_file.name
+                
+            if progress: 
+                progress(0.9, desc="Loading final audio...")
+            
+            audio_data, sample_rate = sf.read(temp_path)
+            os.unlink(temp_path)
+            
+            if progress: 
+                progress(1.0, desc=f"Complete! Processed {chunks_processed} chunks into final audio.")
+            
+            return (sample_rate, audio_data)
+            
+        else:
+            # For voice cloning, still use the original endpoint
+            if progress: 
+                progress(0.3, desc="Preparing voice cloning request...")
+            
+            files = {'text': (None, text_input)}
+            with open(audio_prompt_input, 'rb') as f:
+                audio_content = f.read()
+            files['voice_prompt'] = ('voice_prompt.wav', audio_content, 'audio/wav')
+            
+            if progress: 
+                progress(0.5, desc="Sending request with voice cloning...")
+            
+            response = requests.post(
+                GENERATE_WITH_FILE_ENDPOINT,
+                files=files,
+                timeout=180,
+                stream=True
+            )
+            
+            if response.status_code != 200:
+                raise gr.Error(f"API Error: {response.status_code} - {response.text}")
+            
+            if progress: 
+                progress(0.8, desc="Processing cloned voice...")
+            
+            bytes_downloaded = 0
+            with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_file:
+                for chunk in response.iter_content(chunk_size=8192):
+                    if chunk:
+                        temp_file.write(chunk)
+                        bytes_downloaded += len(chunk)
+                        
+                        if progress:
+                            progress(0.8, desc=f"Downloading cloned audio... ({bytes_downloaded // 1024}KB)")
+                            
+                temp_path = temp_file.name
+                
+            audio_data, sample_rate = sf.read(temp_path)
+            os.unlink(temp_path)
+            
+            if progress: 
+                progress(1.0, desc="Voice cloning complete!")
+            
+            return (sample_rate, audio_data)
+            
+    except requests.exceptions.Timeout:
+        raise gr.Error("Request timed out. The API might be processing a large text. Please try again.")
+    except requests.exceptions.ConnectionError:
+        raise gr.Error("Unable to connect to the API. Please check if the endpoint URL is correct.")
+    except Exception as e:
+        raise gr.Error(f"Error generating audio: {str(e)}")
+
+
+def get_api_processing_info(text: str) -> dict:
+    """
+    Get processing information from the API without generating audio.
+    
+    Args:
+        text: The text to analyze
+        
+    Returns:
+        Dictionary with processing information
+    """
+    try:
+        # This could be enhanced to call an API info endpoint
+        text_length = len(text.strip()) if text else 0
+        estimated_chunks = max(1, text_length // 800)
+        
+        return {
+            "text_length": text_length,
+            "estimated_chunks": estimated_chunks,
+            "processing_mode": "server_side_parallel_gpu",
+            "benefits": [
+                "Server-side GPU acceleration",
+                "Parallel chunk processing", 
+                "Automatic audio concatenation",
+                "Optimized for large texts",
+                "No client-side resource usage"
+            ]
+        }
+    except Exception as e:
+        return {"error": f"Failed to analyze text: {str(e)}"}

src/processors/pdf_processor.py

@@ -34,24 +34,18 @@ class PDFProcessor:
                 explanations = self.extractor.generate_explanations(extracted_text)
                 
                 # Show explanations immediately, update status for audio loading
-                yield extracted_text, gr.update(value="Generating audio..."), explanations, None, gr.update(visible=False)
-                  # Step 3: Generate audio
+                yield extracted_text, gr.update(value="Generating audio..."), explanations, None, gr.update(visible=False)                # Step 3: Generate audio
                 try:
-                    from .audio_processor import AudioProcessor
+                    from .simple_audio_processor import SimpleAudioProcessor
                     
-                    # Create audio processor with parallel processing enabled
-                    audio_processor = AudioProcessor(
-                        max_chunk_size=800,
-                        max_workers=4,
-                        silence_duration=0.5,
-                        enable_parallel=True
-                    )
+                    # Create simplified audio processor
+                    audio_processor = SimpleAudioProcessor()
                     
                     # Generate progress callback for audio processing
                     def audio_progress(progress, desc=""):
                         yield extracted_text, gr.update(value=f"Generating audio: {desc}"), explanations, None, gr.update(visible=False)
                     
-                    # Generate audio using the new parallel processor
+                    # Generate audio using the simplified processor
                     audio_result, _ = audio_processor.generate_audio(explanations, progress=audio_progress)
                     
                     # Show everything, update status to complete

src/processors/simple_audio_processor.py

@@ -0,0 +1,69 @@
+"""Simplified audio generation functionality that delegates complex processing to the TTS API."""
+from typing import Tuple, Optional
+import gradio as gr
+import numpy as np
+
+class SimpleAudioProcessor:
+    """Simplified audio processor that uses the enhanced TTS API for complex processing."""
+    
+    def __init__(self):
+        """Initialize the simple audio processor."""
+        pass
+    
+    def generate_audio(self, explanation_text: str, progress=None) -> Tuple[Tuple[int, np.ndarray], dict]:
+        """
+        Generate TTS audio for explanations using the enhanced TTS API.
+        
+        This method sends the full text to the TTS API which handles:
+        - Text chunking
+        - Parallel processing 
+        - Audio concatenation
+        - All on the server side with GPU acceleration
+        
+        Args:
+            explanation_text: The text to convert to audio
+            progress: Optional progress callback
+            
+        Returns:
+            Tuple of (audio_result, update_dict) where audio_result is (sample_rate, audio_data)
+        """
+        if not explanation_text or explanation_text.strip() == "":
+            raise gr.Error("No explanations available to convert to audio. Please generate explanations first.")
+        
+        try:
+            clean_text = explanation_text.strip()
+            
+            if progress:
+                progress(0.1, desc="Sending text to TTS API for processing...")
+            
+            # Import the simplified audio generation function
+            from .generate_simple_tts_audio import generate_simple_tts_audio
+            
+            # Generate audio using the new simplified API call
+            audio_result = generate_simple_tts_audio(clean_text, progress=progress)
+            
+            if progress:
+                progress(1.0, desc="Audio generation complete!")
+            
+            return audio_result, gr.update(visible=True)
+            
+        except Exception as e:
+            raise gr.Error(f"Error generating audio: {str(e)}")
+    
+    def get_processing_info(self, text: str) -> dict:
+        """Get basic information about the text to be processed."""
+        if not text or not text.strip():
+            return {"error": "No text provided"}
+        
+        text_length = len(text.strip())
+        estimated_chunks = max(1, text_length // 800)  # Rough estimate
+        estimated_time = text_length * 0.05  # Rough estimate: 0.05 seconds per character
+        
+        return {
+            "processing_mode": "server_side_parallel",
+            "text_length": text_length,
+            "estimated_chunks": estimated_chunks,
+            "estimated_time_seconds": estimated_time,
+            "estimated_time_readable": f"{estimated_time:.1f} seconds" if estimated_time < 60 else f"{estimated_time/60:.1f} minutes",
+            "note": "Processing handled by TTS API with GPU acceleration"
+        }