Update app.py

app.py

@@ -1,604 +1,173 @@
+from fastapi import FastAPI, HTTPException, BackgroundTasks
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse, JSONResponse
+from pydantic import BaseModel
 import gradio as gr
-from pydub import AudioSegment
-import edge_tts
-import os
-import asyncio
-import uuid
-import re
+from typing import Optional, Dict, Any
 import time
-import tempfile
-from concurrent.futures import ThreadPoolExecutor
-from typing import List, Tuple, Optional, Dict, Any
-import math
-from dataclasses import dataclass
-
-class TimingManager:
+import uvicorn
+from datetime import datetime
+import psutil
+import asyncio
+from app import (
+    generate_accurate_srt,
+    voice_options,
+    TTSError,
+    FileManager
+)
+
+# Initialize FastAPI app
+app = FastAPI(
+    title="TTS API Service",
+    description="Text-to-Speech API with real-time status monitoring",
+    version="1.0.0"
+)
+
+# Configure CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Global state management
+class ProcessingState:
     def __init__(self):
-        self.current_time = 0
-        self.segment_gap = 100  # ms gap between segments
-    
-    def get_timing(self, duration):
-        start_time = self.current_time
-        end_time = start_time + duration
-        self.current_time = end_time + self.segment_gap
-        return start_time, end_time
-
-def get_audio_length(audio_file):
-    audio = AudioSegment.from_file(audio_file)
-    return len(audio) / 1000
+        self.active_jobs: Dict[str, Dict[str, Any]] = {}
+        self.file_manager = FileManager()
 
-def format_time_ms(milliseconds):
-    seconds, ms = divmod(int(milliseconds), 1000)
-    mins, secs = divmod(seconds, 60)
-    hrs, mins = divmod(mins, 60)
-    return f"{hrs:02}:{mins:02}:{secs:02},{ms:03}"
+state = ProcessingState()
 
-@dataclass
-class Segment:
-    id: int
+# Pydantic models
+class TTSRequest(BaseModel):
     text: str
-    start_time: int = 0
-    end_time: int = 0
-    duration: int = 0
-    audio: Optional[AudioSegment] = None
-    lines: List[str] = None  # Add lines field for display purposes only
-
-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.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
-        }
-    
-    def analyze_sentence_complexity(self, text: str) -> float:
-        """Analyze sentence complexity to determine optimal segment length"""
-        words = text.split()
-        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())
-        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)
-        
-        # First, split into major segments by strong punctuation
-        segments = []
-        current_segment = []
-        current_text = ""
-        words = text.split()
-        
-        i = 0
-        while i < len(words):
-            complexity = self.analyze_sentence_complexity(' '.join(words[i:i + self.words_per_line * 2]))
-            breaks = self.find_natural_breaks(' '.join(words[i:i + int(self.max_segment_words * complexity)]))
-            
-            # Find best break point
-            best_break = None
-            best_weight = 0
-            
-            for break_idx, weight in breaks:
-                actual_idx = i + break_idx
-                if (actual_idx - i >= self.min_segment_words and 
-                    actual_idx - i <= self.max_segment_words):
-                    if weight > best_weight:
-                        best_break = break_idx
-                        best_weight = weight
-            
-            if best_break is None:
-                # If no good break found, use maximum length
-                best_break = min(self.words_per_line * self.lines_per_segment, len(words) - i)
-            
-            # Create segment
-            segment_words = words[i:i + best_break + 1]
-            segment_text = ' '.join(segment_words)
-            
-            # Split segment into lines
-            lines = self.split_into_lines(segment_text)
-            final_segment_text = '\n'.join(lines)
-            
-            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
-            
-            # Check for natural line breaks
-            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 ',;:'))
+    voice: str = "Jenny Female"
+    pitch: int = 0
+    rate: int = 0
+    words_per_line: int = 6
+    lines_per_segment: int = 2
+    parallel_processing: bool = True
+
+class HealthResponse(BaseModel):
+    status: str
+    timestamp: str
+    cpu_usage: float
+    memory_usage: float
+    active_jobs: int
+
+# Progress callback handler
+async def update_job_progress(job_id: str, progress: float, status: str):
+    state.active_jobs[job_id].update({
+        "progress": progress,
+        "status": status,
+        "last_update": datetime.now().isoformat()
+    })
+
+# API endpoints
+@app.post("/api/v1/tts")
+async def create_tts(request: TTSRequest, background_tasks: BackgroundTasks):
+    job_id = f"job_{int(time.time())}_{hash(request.text)}"
+    
+    # Initialize job status
+    state.active_jobs[job_id] = {
+        "id": job_id,
+        "status": "queued",
+        "progress": 0,
+        "created_at": datetime.now().isoformat(),
+        "last_update": datetime.now().isoformat(),
+        "request": request.dict()
+    }
+
+    async def process_tts():
+        try:
+            # Format pitch and rate strings
+            pitch_str = f"{request.pitch:+d}Hz"
+            rate_str = f"{request.rate:+d}%"
+
+            srt_path, audio_path = await generate_accurate_srt(
+                request.text,
+                voice_options[request.voice],
+                rate_str,
+                pitch_str,
+                request.words_per_line,
+                request.lines_per_segment,
+                progress_callback=lambda p, s: update_job_progress(job_id, p, s),
+                parallel=request.parallel_processing
             )
-            
-            if is_break:
-                lines.append(' '.join(current_line))
-                current_line = []
-                word_count = 0
-        
-        if current_line:
-            lines.append(' '.join(current_line))
-        
-        return lines
-
-# IMPROVEMENT 1: Enhanced Error Handling
-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"""
-    audio_file = os.path.join(tempfile.gettempdir(), f"temp_segment_{segment.id}_{uuid.uuid4()}.wav")
-    try:
-        # Process the entire segment text as one unit, replacing newlines with spaces
-        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)}")
-        
-        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)
-            # Reduced silence to 30ms for more natural flow
-            silence = AudioSegment.silent(duration=30)
-            segment.audio = silence + segment.audio + silence
-            segment.duration = len(segment.audio)
+            state.active_jobs[job_id].update({
+                "status": "completed",
+                "progress": 1.0,
+                "result": {
+                    "srt_path": srt_path,
+                    "audio_path": audio_path
+                }
+            })
         except Exception as e:
-            raise TTSError(f"Failed to process audio file for segment {segment.id}: {str(e)}")
-        
-        return segment
-    except Exception as e:
-        if not isinstance(e, TTSError):
-            raise TTSError(f"Unexpected error processing segment {segment.id}: {str(e)}")
-        raise
-    finally:
-        if os.path.exists(audio_file):
-            try:
-                os.remove(audio_file)
-            except Exception:
-                pass  # Ignore deletion errors
+            state.active_jobs[job_id].update({
+                "status": "failed",
+                "error": str(e)
+            })
 
-# IMPROVEMENT 2: Better File Management with cleanup
-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  # Keep only the 5 most recent output pairs
-        
-    def get_temp_path(self, prefix):
-        """Get a path for a temporary file"""
-        return os.path.join(self.temp_dir, f"{prefix}_{uuid.uuid4()}")
-    
-    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 = self.output_files[:-self.max_files_to_keep]
-            for srt_path, audio_path in old_files:
-                try:
-                    if os.path.exists(srt_path):
-                        os.remove(srt_path)
-                    if os.path.exists(audio_path):
-                        os.remove(audio_path)
-                except Exception:
-                    pass  # Ignore deletion errors
-            
-            # Update the list to only include files we're keeping
-            self.output_files = self.output_files[-self.max_files_to_keep:]
+    background_tasks.add_task(process_tts)
     
-    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)
-                if os.path.exists(audio_path):
-                    os.remove(audio_path)
-            except Exception:
-                pass  # Ignore deletion errors
-        
-        try:
-            os.rmdir(self.temp_dir)
-        except Exception:
-            pass  # Ignore if directory isn't empty or can't be removed
+    return {"job_id": job_id, "status": "queued"}
 
-# Create global file manager
-file_manager = FileManager()
+@app.get("/api/v1/status/{job_id}")
+async def get_job_status(job_id: str):
+    if job_id not in state.active_jobs:
+        raise HTTPException(status_code=404, detail="Job not found")
+    return state.active_jobs[job_id]
 
-# IMPROVEMENT 3: Parallel Processing for Segments
-async def generate_accurate_srt(
-    text: str, 
-    voice: str, 
-    rate: str, 
-    pitch: str, 
-    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)
-    processed_segments = []
-    
-    # Update progress to show segmentation is complete
-    if progress_callback:
-        progress_callback(0.1, "Text segmentation complete")
+@app.get("/api/v1/download/{job_id}/{file_type}")
+async def download_file(job_id: str, file_type: str):
+    if job_id not in state.active_jobs:
+        raise HTTPException(status_code=404, detail="Job not found")
     
-    if parallel and total_segments > 1:
-        # Process segments in parallel
-        processed_count = 0
-        segment_tasks = []
-        
-        # Create a semaphore to limit concurrent tasks
-        semaphore = asyncio.Semaphore(max_workers)
-        
-        async def process_with_semaphore(segment):
-            async with semaphore:
-                nonlocal processed_count
-                try:
-                    result = await process_segment_with_timing(segment, voice, rate, pitch)
-                    processed_count += 1
-                    if progress_callback:
-                        progress = 0.1 + (0.8 * processed_count / total_segments)
-                        progress_callback(progress, f"Processed {processed_count}/{total_segments} segments")
-                    return result
-                except Exception as e:
-                    # Handle errors in individual segments
-                    processed_count += 1
-                    if progress_callback:
-                        progress = 0.1 + (0.8 * processed_count / total_segments)
-                        progress_callback(progress, f"Error in segment {segment.id}: {str(e)}")
-                    raise
-        
-        # Create tasks for all segments
-        for segment in segments:
-            segment_tasks.append(process_with_semaphore(segment))
-        
-        # Run all tasks and collect results
-        try:
-            processed_segments = await asyncio.gather(*segment_tasks)
-        except Exception as e:
-            if progress_callback:
-                progress_callback(0.9, f"Error during parallel processing: {str(e)}")
-            raise TTSError(f"Failed during parallel processing: {str(e)}")
-    else:
-        # Process segments sequentially (original method)
-        for i, segment in enumerate(segments):
-            try:
-                processed_segment = await process_segment_with_timing(segment, voice, rate, pitch)
-                processed_segments.append(processed_segment)
-                
-                if progress_callback:
-                    progress = 0.1 + (0.8 * (i + 1) / total_segments)
-                    progress_callback(progress, f"Processed {i + 1}/{total_segments} segments")
-            except Exception as e:
-                if progress_callback:
-                    progress_callback(0.9, f"Error processing segment {segment.id}: {str(e)}")
-                raise TTSError(f"Failed to process segment {segment.id}: {str(e)}")
+    job = state.active_jobs[job_id]
+    if job["status"] != "completed":
+        raise HTTPException(status_code=400, detail="Job not completed")
     
-    # Sort segments by ID to ensure correct order
-    processed_segments.sort(key=lambda s: s.id)
+    if file_type not in ["audio", "srt"]:
+        raise HTTPException(status_code=400, detail="Invalid file type")
     
-    if progress_callback:
-        progress_callback(0.9, "Finalizing audio and subtitles")
-    
-    # Now combine the segments in the correct order
-    current_time = 0
-    final_audio = AudioSegment.empty()
-    srt_content = ""
-    
-    for segment in processed_segments:
-        # Calculate precise timing
-        segment.start_time = current_time
-        segment.end_time = current_time + segment.duration
-        
-        # Add to SRT with precise timing
-        srt_content += (
-            f"{segment.id}\n"
-            f"{format_time_ms(segment.start_time)} --> {format_time_ms(segment.end_time)}\n"
-            f"{segment.text}\n\n"
-        )
-        
-        # Add to final audio with precise positioning
-        final_audio = final_audio.append(segment.audio, crossfade=0)
-        
-        # Update timing with precise gap
-        current_time = segment.end_time
-    
-    # Export with high precision
-    srt_path, audio_path = file_manager.create_output_paths()
-    
-    try:
-        # Export with optimized quality settings and compression
-        export_params = {
-            'format': 'mp3',
-            'bitrate': '192k',  # Reduced from 320k but still high quality
-            'parameters': [
-                '-ar', '44100',  # Standard sample rate
-                '-ac', '2',      # Stereo
-                '-compression_level', '0',  # Best compression
-                '-qscale:a', '2'  # High quality VBR encoding
-            ]
-        }
-        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:
-        if progress_callback:
-            progress_callback(1.0, f"Error exporting final files: {str(e)}")
-        raise TTSError(f"Failed to export final files: {str(e)}")
-    
-    if progress_callback:
-        progress_callback(1.0, "Complete!")
-    
-    return srt_path, audio_path
+    file_path = job["result"][f"{file_type}_path"]
+    return FileResponse(
+        file_path,
+        filename=f"tts_output.{file_type}"
+    )
+
+@app.get("/api/v1/health", response_model=HealthResponse)
+async def health_check():
+    return {
+        "status": "healthy",
+        "timestamp": datetime.now().isoformat(),
+        "cpu_usage": psutil.cpu_percent(),
+        "memory_usage": psutil.virtual_memory().percent,
+        "active_jobs": len(state.active_jobs)
+    }
 
-# IMPROVEMENT 4: Progress Reporting with proper error handling for older Gradio versions
-async def process_text_with_progress(
-    text, 
-    pitch, 
-    rate, 
-    voice, 
-    words_per_line, 
-    lines_per_segment, 
-    parallel_processing,
-    progress=gr.Progress()
-):
-    # Input validation
-    if not text or text.strip() == "":
-        return None, None, None, True, "Please enter some text to convert to speech."
+@app.delete("/api/v1/jobs/{job_id}")
+async def cancel_job(job_id: str):
+    if job_id not in state.active_jobs:
+        raise HTTPException(status_code=404, detail="Job not found")
     
-    # Format pitch and rate strings
-    pitch_str = f"{pitch:+d}Hz" if pitch != 0 else "+0Hz"
-    rate_str = f"{rate:+d}%" if rate != 0 else "+0%"
+    job = state.active_jobs[job_id]
+    if job["status"] in ["completed", "failed"]:
+        del state.active_jobs[job_id]
+        return {"status": "deleted"}
     
-    try:
-        # Start progress tracking
-        progress(0, "Preparing text...")
-        
-        def update_progress(value, status):
-            progress(value, status)
-        
-        srt_path, audio_path = await generate_accurate_srt(
-            text,
-            voice_options[voice],
-            rate_str,
-            pitch_str,
-            words_per_line,
-            lines_per_segment,
-            progress_callback=update_progress,
-            parallel=parallel_processing
-        )
-        
-        # If successful, return results and hide error
-        return srt_path, audio_path, audio_path, False, ""
-    except TTSError as e:
-        # Return specific TTS error
-        return None, None, None, True, f"TTS Error: {str(e)}"
-    except Exception as e:
-        # Return any other error
-        return None, None, None, True, f"Unexpected error: {str(e)}"
-
-# 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",
-    "Christopher Male": "en-US-ChristopherNeural",
-    "Eric Male": "en-US-EricNeural",
-    "Michelle Male": "en-US-MichelleNeural",
-    "Roger Male": "en-US-RogerNeural",
-    "Natasha Female": "en-AU-NatashaNeural",
-    "William Male": "en-AU-WilliamNeural",
-    "Clara Female": "en-CA-ClaraNeural",
-    "Liam Female ": "en-CA-LiamNeural",
-    "Libby Female": "en-GB-LibbyNeural",
-    "Maisie": "en-GB-MaisieNeural",
-    "Ryan": "en-GB-RyanNeural",
-    "Sonia": "en-GB-SoniaNeural",
-    "Thomas": "en-GB-ThomasNeural",
-    "Sam": "en-HK-SamNeural",
-    "Yan": "en-HK-YanNeural",
-    "Connor": "en-IE-ConnorNeural",
-    "Emily": "en-IE-EmilyNeural",
-    "Neerja": "en-IN-NeerjaNeural",
-    "Prabhat": "en-IN-PrabhatNeural",
-    "Asilia": "en-KE-AsiliaNeural",
-    "Chilemba": "en-KE-ChilembaNeural",
-    "Abeo": "en-NG-AbeoNeural",
-    "Ezinne": "en-NG-EzinneNeural",
-    "Mitchell": "en-NZ-MitchellNeural",
-    "James": "en-PH-JamesNeural",
-    "Rosa": "en-PH-RosaNeural",
-    "Luna": "en-SG-LunaNeural",
-    "Wayne": "en-SG-WayneNeural",
-    "Elimu": "en-TZ-ElimuNeural",
-    "Imani": "en-TZ-ImaniNeural",
-    "Leah": "en-ZA-LeahNeural",
-    "Luke": "en-ZA-LukeNeural"
-    # Add other voices as needed
-}
+    job["status"] = "cancelled"
+    return {"status": "cancelled"}
 
-# Register cleanup on exit
-import atexit
-atexit.register(file_manager.cleanup_all)
+# Initialize Gradio interface
+with gr.Blocks() as gradio_app:
+    # ...existing gradio interface code...
 
-# Create Gradio interface
-with gr.Blocks(title="Advanced TTS with Configurable SRT Generation") as app:
-    gr.Markdown("# Advanced TTS with Configurable SRT Generation")
-    gr.Markdown("Generate perfectly synchronized audio and subtitles with natural speech patterns.")
-    
-    with gr.Row():
-        with gr.Column(scale=3):
-            text_input = gr.Textbox(label="Enter Text", lines=10, placeholder="Enter your text here...")
-        
-        with gr.Column(scale=2):
-            voice_dropdown = gr.Dropdown(
-                label="Select Voice", 
-                choices=list(voice_options.keys()), 
-                value="Jenny Female"
-            )
-            pitch_slider = gr.Slider(
-                label="Pitch Adjustment (Hz)", 
-                minimum=-10, 
-                maximum=10, 
-                value=0, 
-                step=1
-            )
-            rate_slider = gr.Slider(
-                label="Rate Adjustment (%)", 
-                minimum=-25, 
-                maximum=25, 
-                value=0, 
-                step=1
-            )
-    
-    with gr.Row():
-        with gr.Column():
-            words_per_line = gr.Slider(
-                label="Words per Line", 
-                minimum=3, 
-                maximum=12, 
-                value=6, 
-                step=1,
-                info="Controls how many words appear on each line of the subtitle"
-            )
-        with gr.Column():
-            lines_per_segment = gr.Slider(
-                label="Lines per Segment", 
-                minimum=1, 
-                maximum=4, 
-                value=2, 
-                step=1,
-                info="Controls how many lines appear in each subtitle segment"
-            )
-        with gr.Column():
-            parallel_processing = gr.Checkbox(
-                label="Enable Parallel Processing", 
-                value=True,
-                info="Process multiple segments simultaneously for faster conversion (recommended for longer texts)"
-            )
-    
-    submit_btn = gr.Button("Generate Audio & Subtitles")
-    
-    # Add error message component
-    error_output = gr.Textbox(label="Status", visible=False)
-    
-    with gr.Row():
-        with gr.Column():
-            audio_output = gr.Audio(label="Preview Audio")
-        with gr.Column():
-            srt_file = gr.File(label="Download SRT")
-            audio_file = gr.File(label="Download Audio")
-    
-    # Handle button click with manual error handling instead of .catch()
-    submit_btn.click(
-        fn=process_text_with_progress,
-        inputs=[
-            text_input,
-            pitch_slider,
-            rate_slider,
-            voice_dropdown,
-            words_per_line,
-            lines_per_segment,
-            parallel_processing
-        ],
-        outputs=[
-            srt_file,
-            audio_file,
-            audio_output,
-            error_output,
-            error_output
-        ],
-        api_name="generate"
-    )
+# Mount Gradio app
+app = gr.mount_gradio_app(app, gradio_app, path="/")
 
 if __name__ == "__main__":
-    app.launch()
+    uvicorn.run("fastapi_app:app", host="0.0.0.0", port=8000, reload=True)