Update app.py

app.py

@@ -1,16 +1,19 @@
+from fastapi import FastAPI, BackgroundTasks
+import edge_tts
+import asyncio
 import os
 import time
-import asyncio
-from fastapi import FastAPI
-import edge_tts
-from fastapi.responses import FileResponse
-from pydub import AudioSegment
+from fastapi.responses import FileResponse, JSONResponse
+from typing import List
+import pydub
 
 app = FastAPI()
 
-# 🔹 Function to split text into manageable chunks
+# Global dictionary to track active requests
+active_requests = {}
+
 def split_text(text, max_chunk_size=500):
-    """Split text into smaller chunks at sentence boundaries."""
+    """Split text into chunks at sentence boundaries."""
     sentences = text.replace('।', '.').replace('؟', '?').split('.')
     chunks = []
     current_chunk = []
@@ -33,64 +36,76 @@ def split_text(text, max_chunk_size=500):
 
     return chunks
 
-# 🔹 Function to process a single chunk asynchronously
 async def process_chunk(text, voice, temp_dir, chunk_index):
-    """Generate speech for a single chunk and save as MP3."""
-    tmp_path = os.path.join(temp_dir, f"chunk_{chunk_index}.mp3")
-    print(f"🎤 Processing chunk {chunk_index}: {text[:50]}...")  # Logging for debugging
+    """Process a single chunk of text asynchronously."""
+    tmp_path = os.path.join(temp_dir, f"chunk_{chunk_index}_{int(time.time())}.mp3")
     communicate = edge_tts.Communicate(text, voice)
     await communicate.save(tmp_path)
     return tmp_path
 
-# 🔹 Function to merge all chunked MP3 files into a single audio file
 async def combine_audio_files(chunk_files, output_path):
-    """Combine multiple MP3 files into one final MP3."""
-    combined = AudioSegment.empty()
-
+    """Combine multiple MP3 files into one."""
+    combined = pydub.AudioSegment.empty()
     for file in chunk_files:
-        print(f"🔹 Adding {file} to final output")  # Logging for debugging
-        combined += AudioSegment.from_mp3(file)
+        audio_segment = pydub.AudioSegment.from_mp3(file)
+        combined += audio_segment
 
     combined.export(output_path, format="mp3")
 
-    # Remove temporary files
+    # Cleanup chunk files
     for file in chunk_files:
-        os.remove(file)
+        try:
+            os.remove(file)
+        except:
+            pass
 
 @app.get("/")
 def home():
-    return {"message": "✅ EdgeTTS FastAPI is running!"}
+    return {"message": "EdgeTTS FastAPI is running!"}
+
+@app.get("/health")
+def health_check():
+    """Check if the API is running and how many requests are active."""
+    return {"status": "running", "active_requests": len(active_requests)}
+
+@app.get("/status")
+def status():
+    """Return the list of active requests being processed."""
+    return {"active_requests": list(active_requests.keys())}
 
-# 🔹 Main TTS API
 @app.get("/tts")
-async def tts(text: str, voice: str = "en-US-AriaNeural"):
-    """Main API function to handle text-to-speech conversion."""
-    temp_dir = "temp_audio"
-    os.makedirs(temp_dir, exist_ok=True)
+async def tts(text: str, voice: str = "en-US-JennyNeural", background_tasks: BackgroundTasks = None):
+    """Generate speech from text using EdgeTTS with parallel processing."""
+    request_id = f"{int(time.time())}_{os.urandom(4).hex()}"
+    active_requests[request_id] = "processing"
 
-    chunks = split_text(text)
+    try:
+        output_file = f"output_{request_id}.mp3"
+        temp_dir = f"temp_{request_id}"
+        os.makedirs(temp_dir, exist_ok=True)
 
-    # If text is short, process directly
-    if len(chunks) == 1:
-        print("📢 Processing without chunking...")
-        output_file = await process_chunk(text, voice, temp_dir, 0)
-        return FileResponse(output_file, media_type="audio/mpeg", filename="speech.mp3")
+        chunks = split_text(text)
+        tasks = [process_chunk(chunk, voice, temp_dir, i) for i, chunk in enumerate(chunks)]
+        chunk_files = await asyncio.gather(*tasks)
 
-    print(f"🚀 Splitting into {len(chunks)} chunks and processing concurrently...")
+        await combine_audio_files(chunk_files, output_file)
 
-    # 🔹 Concurrently process all chunks
-    chunk_files = await asyncio.gather(*[
-        process_chunk(ch, voice, temp_dir, i) for i, ch in enumerate(chunks)
-    ])
+        background_tasks.add_task(cleanup_request, request_id)
+        return FileResponse(output_file, media_type="audio/mpeg", filename="speech.mp3")
 
-    # 🔹 Merge all MP3 files
-    output_file = "final_output.mp3"
-    await combine_audio_files(chunk_files, output_file)
+    except Exception as e:
+        del active_requests[request_id]
+        return JSONResponse(content={"error": str(e)}, status_code=500)
 
-    print("✅ TTS Generation Complete. Sending response...")
-    return FileResponse(output_file, media_type="audio/mpeg", filename="speech.mp3")
+def cleanup_request(request_id):
+    """Cleanup function to remove temporary files."""
+    del active_requests[request_id]
+    temp_dir = f"temp_{request_id}"
+    if os.path.exists(temp_dir):
+        for file in os.listdir(temp_dir):
+            os.remove(os.path.join(temp_dir, file))
+        os.rmdir(temp_dir)
 
-# 🔹 Ensure app starts in Hugging Face Spaces
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)