Update app.py

app.py

@@ -1,25 +1,100 @@
 from fastapi import FastAPI
 import edge_tts
 import asyncio
-from fastapi.responses import FileResponse
-import uvicorn
+import os
+import time
+import io
+from fastapi.responses import StreamingResponse
+from tempfile import TemporaryDirectory
+from pydub import AudioSegment
 
 app = FastAPI()
 
+def split_text(text, max_chunk_size=500):
+    """Split text into chunks only if it's longer than max_chunk_size."""
+    if len(text) <= max_chunk_size:
+        return [text]  # No need to split if it's within the limit
+
+    sentences = text.replace('।', '.').replace('؟', '?').split('.')
+    chunks = []
+    current_chunk = []
+    current_length = 0
+
+    for sentence in sentences:
+        sentence = sentence.strip() + '.'
+        sentence_length = len(sentence)
+
+        if current_length + sentence_length > max_chunk_size and current_chunk:
+            chunks.append(' '.join(current_chunk))
+            current_chunk = []
+            current_length = 0
+
+        current_chunk.append(sentence)
+        current_length += sentence_length
+
+    if current_chunk:
+        chunks.append(' '.join(current_chunk))
+
+    return chunks
+
+async def process_chunk(text, voice, temp_dir, chunk_index):
+    """Process a single chunk of text into an MP3 file."""
+    tmp_path = os.path.join(temp_dir, f"chunk_{chunk_index}_{int(time.time())}_{os.urandom(4).hex()}.mp3")
+    communicate = edge_tts.Communicate(text, voice)
+    await communicate.save(tmp_path)
+    return tmp_path
+
+async def combine_audio_files(chunk_files):
+    """Combine multiple MP3 files into one final MP3 file."""
+    combined = AudioSegment.empty()
+    
+    for file in chunk_files:
+        audio_segment = AudioSegment.from_mp3(file)
+        combined += audio_segment
+
+    output = io.BytesIO()
+    combined.export(output, format="mp3")
+    output.seek(0)
+
+    # Clean up temp files
+    for file in chunk_files:
+        try:
+            os.remove(file)
+        except:
+            pass
+
+    return output
+
 @app.get("/")
 def home():
     return {"message": "EdgeTTS FastAPI is running!"}
 
 @app.get("/tts")
 async def tts(text: str, voice: str = "en-US-AriaNeural"):
-    output_file = "output.mp3"
+    if not text.strip():
+        return {"error": "Text cannot be empty."}
 
-    # Generate speech
-    communicate = edge_tts.Communicate(text, voice)
-    await communicate.save(output_file)
+    text_chunks = split_text(text)  # Split only if necessary
+
+    if len(text_chunks) == 1:
+        # Process the entire text as a single request if it's within limit
+        output_audio = io.BytesIO()
+        communicate = edge_tts.Communicate(text_chunks[0], voice)
+        await communicate.save(output_audio)
+        output_audio.seek(0)
+
+        return StreamingResponse(output_audio, media_type="audio/mpeg", headers={"Content-Disposition": "attachment; filename=speech.mp3"})
+    
+    # If text is split into chunks, process them individually
+    with TemporaryDirectory() as temp_dir:
+        chunk_files = await asyncio.gather(*[
+            process_chunk(chunk, voice, temp_dir, i) for i, chunk in enumerate(text_chunks)
+        ])
+        
+        output_audio = await combine_audio_files(chunk_files)
 
-    return FileResponse(output_file, media_type="audio/mpeg", filename="speech.mp3")
+    return StreamingResponse(output_audio, media_type="audio/mpeg", headers={"Content-Disposition": "attachment; filename=speech.mp3"})
 
-# Ensure the app starts when running in Hugging Face Spaces
 if __name__ == "__main__":
+    import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)