update TTS deployment fixes

Dockerfile

@@ -4,20 +4,28 @@ FROM nvidia/cuda:11.8.0-cudnn8-runtime-ubuntu22.04
 # Set non-interactive to avoid prompts during apt-get
 ENV DEBIAN_FRONTEND=noninteractive
 
-# Install Python 3.10, pip, and ffmpeg
+# Install Python 3.10, pip, ffmpeg, and libsndfile1 for audio processing stability
 RUN apt-get update && apt-get install -y \
     python3 \
     python3-pip \
     ffmpeg \
+    libsndfile1 \
     && rm -rf /var/lib/apt/lists/*
 
 # Set the working directory
 WORKDIR /app
 
+# Upgrade pip for better dependency resolution
+RUN pip3 install --no-cache-dir --upgrade pip
+
+# Install PyTorch explicitly for CUDA 11.8 to ensure full RTX 3090 / Vast.ai compatibility
+# (Done before other requirements to ensure correct indexing)
+RUN pip3 install --no-cache-dir torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
+
 # Copy the requirements file into the container
 COPY requirements.txt .
 
-# Install dependencies (including torch for potential GPU inference)
+# Install dependencies
 RUN pip3 install --no-cache-dir -r requirements.txt
 
 # Copy the rest of the application code

app.py

@@ -8,8 +8,12 @@ import asyncio
 from typing import Optional
 from pathlib import Path
 
-# GPU Optimization Imports (as per user request)
-import torch
+import logging
+
+# Configure basic logging
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+
+# GPU logic removed as edge-tts operates via API
 
 from utils.config import (
     DIR_TEMP, DIR_OUTPUT, DEFAULT_LANG, DEFAULT_VOICE_ID, 
@@ -24,23 +28,23 @@ app = FastAPI(
     version="1.0.0"
 )
 
-# Startup event to clear temp and output directories and initialize GPU
+# Startup event to clear temp and output directories and ensure they exist
 @app.on_event("startup")
 async def startup_event():
-    # Cleanup previous runs
+    # Ensure directories always exist
+    for directory in [DIR_TEMP, DIR_OUTPUT]:
+        directory.mkdir(parents=True, exist_ok=True)
+        
+    # Cleanup previous runs safely
     for directory in [DIR_TEMP, DIR_OUTPUT]:
         for item in directory.glob("*"):
-            if item.is_file():
-                item.unlink()
-            elif item.is_dir():
-                shutil.rmtree(item)
-    
-    # Optional GPU Warmup/Initialization
-    if torch.cuda.is_available():
-        print(f"CUDA is available: {torch.cuda.get_device_name(0)}")
-        torch.cuda.empty_cache()
-    else:
-        print("CUDA is not available. Running on CPU (edge-tts is API based).")
+            try:
+                if item.is_file():
+                    item.unlink()
+                elif item.is_dir():
+                    shutil.rmtree(item)
+            except Exception as e:
+                logging.error(f"Cleanup error on {item}: {e}")
 
 class TTSRequest(BaseModel):
     text: str = Field(..., description="Text to synthesize into speech")
@@ -48,13 +52,15 @@ class TTSRequest(BaseModel):
     voice_id: str = Field(DEFAULT_VOICE_ID, description="Voice ID from registry")
     custom_voice_name: Optional[str] = Field(None, description="Direct Voice name, e.g. 'en-US-GuyNeural'")
 
-def remove_file(path: Path):
-    """Background task to remove a file after returning it."""
+async def remove_file(path: Path):
+    """Background task to safely remove a file after returning it with a 30-second delay."""
+    await asyncio.sleep(30)  # Safe async delay to guarantee response finishes streaming before deletion
     try:
         if path.exists():
             path.unlink()
+            logging.info(f"Safely deleted output file: {path}")
     except Exception as e:
-        print(f"Failed to delete {path}: {e}")
+        logging.error(f"Failed to delete {path}: {e}")
 
 @app.post("/generate", summary="Generate TTS Audio from Text")
 async def generate_audio(request: TTSRequest, background_tasks: BackgroundTasks):
@@ -73,36 +79,50 @@ async def generate_audio(request: TTSRequest, background_tasks: BackgroundTasks)
     output_wav = DIR_OUTPUT / f"output_{req_id}.wav"
 
     try:
-        # Wrap inference simulation in no_grad for GPU memory optimization requirements
-        with torch.no_grad():
-            # 1. Chunk Text
-            chunks = chunk_text(request.text, lang=request.lang, max_chars=MAX_CHARS, min_chars=MIN_CHARS)
-            
-            if not chunks:
-                raise HTTPException(status_code=400, detail="No valid text found after cleaning.")
+        # 1. Chunk Text
+        chunks = chunk_text(request.text, lang=request.lang, max_chars=MAX_CHARS, min_chars=MIN_CHARS)
+        
+        if not chunks:
+            raise HTTPException(status_code=400, detail="No valid text found after cleaning.")
 
-            # 2. Generate Audio for each chunk asynchronously
-            tasks = []
-            chunk_wav_paths = []
-            
-            for i, chunk in enumerate(chunks):
-                chunk_wav = req_temp_dir / f"chunk_{i:04d}.wav"
-                chunk_wav_paths.append(chunk_wav)
-                tasks.append(tts_to_wav(chunk, chunk_wav, voice_name))
-            
-            # Run all edge-tts requests concurrently
-            await asyncio.gather(*tasks)
+        # 2. Generate Audio for each chunk asynchronously with concurrency limit
+        sem = asyncio.Semaphore(5) # Max 5 concurrent connections to edge-tts to prevent rate limits
+
+        async def bounded_tts(chunk_text, chunk_wav_path, voice):
+            async with sem:
+                return await tts_to_wav(chunk_text, chunk_wav_path, voice)
 
-            # 3. Concatenate
-            if len(chunk_wav_paths) == 1:
-                # If only one chunk, just move it to output
-                shutil.move(str(chunk_wav_paths[0]), str(output_wav))
+        tasks = []
+        chunk_wav_paths = []
+        
+        for i, chunk in enumerate(chunks):
+            chunk_wav = req_temp_dir / f"chunk_{i:04d}.wav"
+            chunk_wav_paths.append(chunk_wav)
+            tasks.append(bounded_tts(chunk, chunk_wav, voice_name))
+        
+        # Run edge-tts requests concurrently with a limit and catch partial failures safely
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        
+        successful_wav_paths = []
+        for path, result in zip(chunk_wav_paths, results):
+            if isinstance(result, Exception):
+                logging.error(f"Failed to generate TTS for chunk {path}: {result}")
             else:
-                await concat_wavs_by_timeline(chunk_wav_paths, output_wav)
+                successful_wav_paths.append(path)
+
+        if not successful_wav_paths:
+            logging.error(f"All TTS chunks failed for request {req_id}")
+            raise HTTPException(
+                status_code=500, 
+                detail="All TTS generation chunks failed due to API errors. Please verify the text content or try again later."
+            )
 
-        # Ensure CUDA cache is cleared after generation to prevent memory leaks
-        if torch.cuda.is_available():
-            torch.cuda.empty_cache()
+        # 3. Concatenate
+        if len(successful_wav_paths) == 1:
+            # If only one chunk, just move it to output
+            shutil.move(str(successful_wav_paths[0]), str(output_wav))
+        else:
+            await concat_wavs_by_timeline(successful_wav_paths, output_wav)
 
         # Schedule cleanup of the output file after it's returned
         background_tasks.add_task(remove_file, output_wav)
@@ -122,7 +142,4 @@ async def generate_audio(request: TTSRequest, background_tasks: BackgroundTasks)
         if output_wav.exists():
             output_wav.unlink()
             
-        if torch.cuda.is_available():
-            torch.cuda.empty_cache()
-            
-        raise HTTPException(status_code=500, detail=str(e))
+        raise HTTPException(status_code=500, detail=f"TTS Generation failed: {str(e)}")

requirements.txt

@@ -4,5 +4,4 @@ edge-tts==6.1.9
 nest_asyncio==1.5.8
 tqdm==4.66.1
 unidecode==1.3.7
-torch==2.1.0  # Added for GPU support and optimization readiness
 python-multipart==0.0.6