Update app.py

app.py

@@ -2,19 +2,18 @@ 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 typing import Optional, Dict, Any
+from typing import Optional, Dict, Any, List, Tuple
 import time
 import uvicorn
 from datetime import datetime
 import psutil
 import asyncio
-from app import (
-    generate_accurate_srt,
-    voice_options,
-    TTSError,
-    FileManager
-)
+import edge_tts
+from pydub import AudioSegment
+import os
+import uuid
+import tempfile
+from concurrent.futures import ThreadPoolExecutor
 
 # Initialize FastAPI app
 app = FastAPI(
@@ -32,6 +31,27 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+# Core functionality (moved from app.py)
+class TTSError(Exception):
+    pass
+
+class FileManager:
+    def __init__(self):
+        self.temp_dir = tempfile.mkdtemp(prefix="tts_api_")
+        self.output_files = []
+    
+    def get_temp_path(self, prefix: str) -> str:
+        return os.path.join(self.temp_dir, f"{prefix}_{uuid.uuid4()}")
+    
+    def cleanup_old_files(self):
+        for path in self.output_files[:-5]:  # Keep only last 5 files
+            try:
+                if os.path.exists(path):
+                    os.remove(path)
+            except Exception:
+                pass
+        self.output_files = self.output_files[-5:]
+
 # Global state management
 class ProcessingState:
     def __init__(self):
@@ -43,12 +63,9 @@ state = ProcessingState()
 # Pydantic models
 class TTSRequest(BaseModel):
     text: str
-    voice: str = "Jenny Female"
+    voice: str = "en-US-JennyNeural"
     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
@@ -57,20 +74,38 @@ class HealthResponse(BaseModel):
     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()
-    })
+# Voice options dictionary (simplified)
+voice_options = {
+    "Jenny": "en-US-JennyNeural",
+    "Guy": "en-US-GuyNeural",
+    "Ana": "en-US-AnaNeural",
+    "Aria": "en-US-AriaNeural"
+}
+
+async def generate_tts(text: str, voice: str, rate: str, pitch: str) -> Tuple[str, str]:
+    """Core TTS generation function"""
+    try:
+        audio_path = state.file_manager.get_temp_path("audio") + ".mp3"
+        
+        tts = edge_tts.Communicate(text, voice, rate=rate, pitch=pitch)
+        await tts.save(audio_path)
+        
+        if not os.path.exists(audio_path):
+            raise TTSError("Failed to generate audio file")
+        
+        state.file_manager.output_files.append(audio_path)
+        state.file_manager.cleanup_old_files()
+        
+        return audio_path
+    
+    except Exception as e:
+        raise TTSError(f"TTS generation failed: {str(e)}")
 
 # 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",
@@ -82,26 +117,20 @@ async def create_tts(request: TTSRequest, background_tasks: BackgroundTasks):
 
     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(
+            audio_path = await generate_tts(
                 request.text,
-                voice_options[request.voice],
+                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
+                pitch_str
             )
 
             state.active_jobs[job_id].update({
                 "status": "completed",
                 "progress": 1.0,
                 "result": {
-                    "srt_path": srt_path,
                     "audio_path": audio_path
                 }
             })
@@ -112,7 +141,6 @@ async def create_tts(request: TTSRequest, background_tasks: BackgroundTasks):
             })
 
     background_tasks.add_task(process_tts)
-    
     return {"job_id": job_id, "status": "queued"}
 
 @app.get("/api/v1/status/{job_id}")
@@ -121,8 +149,8 @@ async def get_job_status(job_id: str):
         raise HTTPException(status_code=404, detail="Job not found")
     return state.active_jobs[job_id]
 
-@app.get("/api/v1/download/{job_id}/{file_type}")
-async def download_file(job_id: str, file_type: str):
+@app.get("/api/v1/download/{job_id}")
+async def download_file(job_id: str):
     if job_id not in state.active_jobs:
         raise HTTPException(status_code=404, detail="Job not found")
     
@@ -130,13 +158,10 @@ async def download_file(job_id: str, file_type: str):
     if job["status"] != "completed":
         raise HTTPException(status_code=400, detail="Job not completed")
     
-    if file_type not in ["audio", "srt"]:
-        raise HTTPException(status_code=400, detail="Invalid file type")
-    
-    file_path = job["result"][f"{file_type}_path"]
+    file_path = job["result"]["audio_path"]
     return FileResponse(
         file_path,
-        filename=f"tts_output.{file_type}"
+        filename=f"tts_output.mp3"
     )
 
 @app.get("/api/v1/health", response_model=HealthResponse)
@@ -149,109 +174,9 @@ async def health_check():
         "active_jobs": len(state.active_jobs)
     }
 
-@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")
-    
-    job = state.active_jobs[job_id]
-    if job["status"] in ["completed", "failed"]:
-        del state.active_jobs[job_id]
-        return {"status": "deleted"}
-    
-    job["status"] = "cancelled"
-    return {"status": "cancelled"}
-
-# Initialize Gradio interface
-with gr.Blocks() as gradio_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"
-            )
-    
-    submit_btn = gr.Button("Generate Audio & Subtitles")
-    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")
-    
-    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 to FastAPI
-app = gr.mount_gradio_app(app, gradio_app, path="/")
+@app.get("/api/v1/voices")
+async def list_voices():
+    return {"voices": voice_options}
 
-# Start the FastAPI server
 if __name__ == "__main__":
     uvicorn.run("fastapi_app:app", host="0.0.0.0", port=8000, reload=True)