Update app.py

app.py

@@ -1,82 +1,107 @@
-import os
+from fastapi import FastAPI, Query
 import requests
+import os
 import uvicorn
-from fastapi import FastAPI
-from pydub import AudioSegment
 from uuid import uuid4
+from pydub import AudioSegment
 
 app = FastAPI()
 
-# Your first Hugging Face TTS API URL
-TTS_API_URL = "https://hivecorp-s8test.hf.space/tts"
-MAX_LENGTH = 250  # Max characters per chunk
-
-
-def split_text(text, max_length=MAX_LENGTH):
-    """Splits text into smaller chunks at sentence boundaries."""
-    chunks = []
-    current_chunk = ""
-    sentences = text.split(". ")
-
-    for sentence in sentences:
-        if len(current_chunk + sentence) > max_length:
-            chunks.append(current_chunk.strip())
-            current_chunk = ""
-        current_chunk += sentence + ". "
-
-    if current_chunk:
-        chunks.append(current_chunk.strip())
-
+TTS_API_URL = "https://hivecorp-s8test.hf.space/generate"  # Replace with your TTS API URL
+SAVE_DIR = "generated_audios"
+
+# Ensure save directory exists
+os.makedirs(SAVE_DIR, exist_ok=True)
+
+def split_text(text, max_length=500):
+    """Splits text into smaller chunks without breaking words."""
+    words = text.split()
+    chunks, chunk = [], []
+    
+    for word in words:
+        if len(" ".join(chunk) + " " + word) <= max_length:
+            chunk.append(word)
+        else:
+            chunks.append(" ".join(chunk))
+            chunk = [word]
+    
+    if chunk:
+        chunks.append(" ".join(chunk))
+    
     return chunks
 
-
 def call_tts_api(text, voice):
-    """Calls the TTS API with the text & voice and returns the generated MP3 file."""
-    response = requests.post(TTS_API_URL, json={"text": text, "voice": voice})
-    if response.status_code == 200:
-        filename = f"audio_{uuid4().hex}.mp3"
-        with open(filename, "wb") as f:
-            f.write(response.content)
-        return filename
-    return None
-
+    """Sends text to TTS API and retries if it fails."""
+    filename = f"{SAVE_DIR}/audio_{uuid4().hex}.mp3"
+    
+    try:
+        response = requests.post(TTS_API_URL, json={"text": text, "voice": voice})
+        response_data = response.json()
+        print("TTS API Response:", response_data)  # Log response
+        
+        if "audio_url" in response_data:
+            audio_url = response_data["audio_url"]
+            audio_data = requests.get(audio_url).content
+            
+            with open(filename, "wb") as f:
+                f.write(audio_data)
+            
+            return filename
+        else:
+            print("Error: TTS API did not return an audio URL!")
+            return None
+    
+    except Exception as e:
+        print("Error calling TTS API:", str(e))
+        return None
 
 def merge_audio(files):
-    """Merges multiple MP3 files into one using pydub."""
-    final_audio = AudioSegment.empty()
-
-    for file in files:
-        audio = AudioSegment.from_file(file, format="mp3")
-        final_audio += audio
-
-    final_filename = "final_audio.mp3"
-    final_audio.export(final_filename, format="mp3")
-
-    # Cleanup temp files
-    for file in files:
-        os.remove(file)
-
-    return final_filename
-
+    """Merges multiple MP3 files into one."""
+    output_file = f"{SAVE_DIR}/final_audio_{uuid4().hex}.mp3"
+    
+    try:
+        combined = AudioSegment.from_file(files[0])
+        
+        for file in files[1:]:
+            combined += AudioSegment.from_file(file)
+        
+        combined.export(output_file, format="mp3")
+        return output_file
+    except Exception as e:
+        print("Error merging audio files:", str(e))
+        return None
 
 @app.post("/generate-audio")
-async def generate_audio(text: str, voice: str):
-    """Processes text, splits it, calls TTS API, and merges MP3s."""
-    text_chunks = split_text(text)
-    audio_files = [call_tts_api(chunk, voice) for chunk in text_chunks]
-
-    if None in audio_files:
-        return {"error": "TTS API failed for some parts"}
-
-    merged_file = merge_audio(audio_files)
-    return {"audio_url": f"/download/{merged_file}"}
-
+def generate_audio(text: str = Query(...), voice: str = Query(...)):
+    """Splits text, calls TTS API, merges audio, and returns the final MP3."""
+    chunks = split_text(text)
+    print("Total Chunks:", len(chunks))
+    
+    audio_files = []
+    
+    for chunk in chunks:
+        filename = call_tts_api(chunk, voice)
+        if filename:
+            audio_files.append(filename)
+    
+    if not audio_files:
+        return {"error": "TTS API failed for all parts"}
+    
+    final_audio = merge_audio(audio_files)
+    
+    if final_audio:
+        return {"success": True, "audio_url": f"/download/{os.path.basename(final_audio)}"}
+    else:
+        return {"error": "Failed to merge audio files"}
 
 @app.get("/download/{filename}")
-async def download_file(filename: str):
-    """Endpoint to download the merged MP3 file."""
-    return {"file": filename}
-
+def download_file(filename: str):
+    """Serves the generated MP3 file."""
+    file_path = os.path.join(SAVE_DIR, filename)
+    if os.path.exists(file_path):
+        return {"download_url": file_path}
+    else:
+        return {"error": "File not found"}
 
 # Ensure the app starts when running in Hugging Face Spaces
 if __name__ == "__main__":