Update app.py

app.py

@@ -1,22 +1,114 @@
-from fastapi import FastAPI, UploadFile, File, Form
+from fastapi import FastAPI, BackgroundTasks, UploadFile, File, Form
 from fastapi.responses import FileResponse
-import torch
-import torchaudio
-import os
 from pydantic import BaseModel
-from typing import List, Optional
+from typing import List
 from pathlib import Path
+import os
+import uuid
+import asyncio
+import time
+import httpx
+from supabase import create_client, Client
+import torchaudio
+import torch
+from TTS.tts.models.xtts import Xtts
+from TTS.tts.configs.xtts_config import XttsConfig
+from huggingface_hub import hf_hub_download
+from pydub import AudioSegment
+import subprocess
 
+# -----------------------------
+# Paths & Device
+# -----------------------------
 OUTPUT_DIR = "outputs"
 os.makedirs(OUTPUT_DIR, exist_ok=True)
 
+CACHE_DIR = "disk cache"
+os.makedirs(CACHE_DIR, exist_ok=True)
+
 device = "cuda" if torch.cuda.is_available() else "cpu"
 
-from huggingface_hub import hf_hub_download
+# -----------------------------
+# Supabase client
+# -----------------------------
+SUPABASE_URL = "https://kvlxvhdgacktsgykyckm.supabase.co/"
+SUPABASE_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Imt2bHh2aGRnYWNrdHNneWt5Y2ttIiwicm9sZSI6InNlcnZpY2Vfcm9sZSIsImlhdCI6MTc3MTk2MTQ5MSwiZXhwIjoyMDg3NTM3NDkxfQ.tzfHcbzwzctHDDDp3vk4JGz30ajN2szncAV-1wK7_pM"
+supabase: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
 
-# ------------------------
-# Download model files from Hugging Face if not present
-# ------------------------
+# -----------------------------
+# Download cache (memory)
+# -----------------------------
+download_cache = {}  # URL -> local path
+
+# -----------------------------
+# Helper to get cached file (downloads if missing)
+# -----------------------------
+async def get_cached_file(url: str, subfolder: str) -> str:
+    """
+    Returns local cached path for URL.
+    Downloads and stores in subfolder if missing.
+    """
+    if url in download_cache:
+        return download_cache[url]
+
+    folder_path = os.path.join(CACHE_DIR, subfolder)
+    os.makedirs(folder_path, exist_ok=True)
+
+    local_path = os.path.join(folder_path, os.path.basename(url))
+
+    if os.path.exists(local_path):
+        download_cache[url] = local_path
+        print(f"Found on disk, added to cache: {local_path}")
+        return local_path
+
+    # Download from URL/Supabase
+    async with httpx.AsyncClient(timeout=60) as client:
+        resp = await client.get(url)
+        resp.raise_for_status()
+        with open(local_path, "wb") as f:
+            f.write(resp.content)
+    download_cache[url] = local_path
+    print(f"Downloaded and cached: {url} → {local_path}")
+    return local_path
+
+# -----------------------------
+# Preload all assets from Supabase at startup
+# -----------------------------
+def list_all_files(bucket_name: str):
+    """
+    Returns list of (file_name, public_url) tuples in bucket
+    """
+    response = supabase.storage.from_(bucket_name).list()
+    files = []
+    for f in response:
+        url = supabase.storage.from_(bucket_name).get_public_url(f["name"])
+        files.append((f["name"], url))
+    return files
+
+async def download_to_cache(url: str, subfolder: str):
+    await get_cached_file(url, subfolder)
+
+async def preload_all_assets():
+    print("Starting Supabase asset preloading...")
+    tasks = []
+
+    buckets = {
+        "voice-actor-files": "prosody",
+        "bg-music": "bg_music",
+        "location-audio-files": "sfx"
+    }
+
+    for bucket_name, subfolder in buckets.items():
+        files = list_all_files(bucket_name)
+        for _, url in files:
+            tasks.append(download_to_cache(url, subfolder))
+
+    await asyncio.gather(*tasks)
+    print(f"Preloading completed. {len(download_cache)} files cached on disk.")
+
+# -----------------------------
+# TTS Model (XTTS)
+# -----------------------------
 MODEL_DIR = "my_model"
 
 config_path = hf_hub_download(
@@ -37,30 +129,45 @@ model_path = hf_hub_download(
     cache_dir=MODEL_DIR
 )
 
-from TTS.tts.models.xtts import Xtts
-from TTS.tts.configs.xtts_config import XttsConfig
-
-# Load model
 config = XttsConfig()
 config.load_json(config_path)
 
 model = Xtts.init_from_config(config)
 model.load_checkpoint(
     config,
-    checkpoint_dir= os.path.dirname(model_path),
+    checkpoint_dir=os.path.dirname(model_path),
     use_deepspeed=False,
-    vocab_path= vocab_path
+    vocab_path=vocab_path
 )
 model.to(device)
 
-# --------- Define your models ----------
+# -----------------------------
+# Enums mapping for TTS tags
+# -----------------------------
+intensity_map = {"LOW": "low", "MEDIUM": "mid", "HIGH": "high"}
+emotion_map = {
+    "HAPPINESS": "happiness",
+    "SADNESS": "sadness",
+    "FEAR": "fear",
+    "ANGER": "anger",
+    "SURPRISE": "surprise",
+    "WHISPER": "whisper",
+    "NARRATION": "narration"
+}
+
+def generate_tagged_text(text: str, emotion_enum: str, intensity_enum: str) -> str:
+    emo_tag = f"<emo_{emotion_map[emotion_enum]}>"
+    int_tag = f"<int_{intensity_map[intensity_enum]}>"
+    return f"{emo_tag} {int_tag} {text}"
 
+# -----------------------------
+# DTO Models
+# -----------------------------
 class BGMusicDto(BaseModel):
     musicPath: str
     emotion: str
     volume: float
 
-
 class SentenceDto(BaseModel):
     speaker: str
     sentenceId: str
@@ -72,7 +179,7 @@ class SentenceDto(BaseModel):
 class LocationDto(BaseModel):
     locationName: str
     path: str
-    
+
 class SceneDto(BaseModel):
     sceneId: str
     location: LocationDto
@@ -84,114 +191,26 @@ class ChapterDto(BaseModel):
     title: SentenceDto
     scenes: List[SceneDto]
 
-
 class CastDto(BaseModel):
     name: str
     gender: str
     isAdult: bool
     voiceReference: str
 
-
 class StoryCreationDTO(BaseModel):
     storyId: str
     chapters: List[ChapterDto]
     cast: List[CastDto]
 
-#-----------------------------------------------------------
-
-#__________ func to get file from supabase__________________
-
-import httpx
-import tempfile
-import asyncio
-
-# async def download_file_from_url(url: str, retries: int = 3, delay: float = 2.0) -> str | None:
-#     """
-#     Downloads a file from a URL and returns the path to a temporary file.
-#     Retries on failure up to `retries` times, waiting `delay` seconds between attempts.
-#     Returns None if all attempts fail.
-#     """
-#     for attempt in range(1, retries + 1):
-#         try:
-#             async with httpx.AsyncClient(timeout=60.0) as client:  # increased timeout
-#                 response = await client.get(url)
-#                 response.raise_for_status()  # raises for non-200 status codes
-
-#             # Save to a temporary file
-#             temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".wav")
-#             temp_file.write(response.content)
-#             temp_file.close()
-#             print(f"Downloaded {url} successfully on attempt {attempt}")
-#             return temp_file.name
-
-#         except Exception as e:
-#             print(f"Attempt {attempt} failed for {url}: {e}")
-#             if attempt < retries:
-#                 await asyncio.sleep(delay)  # wait before retrying
-
-#     print(f"All {retries} attempts failed for {url}")
-#     return None
-
-
-download_cache = {}
-
-async def download_scene_files(scene: SceneDto):
-    tasks = []
-
-    # Sentence prosody references
-    for sentence in scene.sentences:
-        tasks.append(download_file_from_url(sentence.prosodyReference))
-
-    # Location SFX
-    if scene.location.path:
-        tasks.append(download_file_from_url(scene.location.path))
-
-    # Background music
-    if scene.bgMusic and scene.bgMusic.musicPath:
-        tasks.append(download_file_from_url(scene.bgMusic.musicPath))
-
-    # Run all downloads concurrently
-    downloaded_files = await asyncio.gather(*tasks)
-    return downloaded_files
+class TTSResponse(BaseModel):
+    fileName: str
+    duration: float
+    audioPath: str
 
-async def download_file_from_url(url: str, retries: int = 3, delay: float = 2.0) -> str | None:
-    """
-    Downloads a file from a URL and returns the path to a temporary file.
-    If download fails after `retries` attempts, returns None instead of raising an error.
-    Caches successful downloads to avoid repeated requests.
-    """
-    if url in download_cache:
-        #print(f"{url} is got from cache")
-        return download_cache[url]
-    
-    for attempt in range(1, retries + 1):
-        try:
-            async with httpx.AsyncClient(timeout=60.0) as client:
-                response = await client.get(url)
-                response.raise_for_status()
-
-            temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".wav")
-            temp_file.write(response.content)
-            temp_file.close()
-            
-            #print(f"{url} is downloaded and saved in cache")
-            
-            download_cache[url] = temp_file.name
-            return temp_file.name
-
-        except Exception as e:
-            #print(f"Attempt {attempt} failed for {url}: {e}")
-            if attempt < retries:
-                await asyncio.sleep(delay)
-
-    #print(f"All {retries} attempts failed for {url}, skipping...")
-    return None
-
-#-----------------------------------------------------------
-
-#takes the text to be said and path to the prosody audio and path to save the generated audio and returns path to the generated audio 
-# (save_path -> full path including the filename, not just a folder.)
-def inference_by_model(text: str, audio_file: str, save_path: str) -> str: 
+# -----------------------------
+# TTS Inference
+# -----------------------------
+def inference_by_model(text: str, audio_file: str, save_path: str) -> str:
     gpt_cond_latent, speaker_embedding = model.get_conditioning_latents(audio_path=[audio_file])
     out = model.inference(
         text=text,
@@ -204,17 +223,14 @@ def inference_by_model(text: str, audio_file: str, save_path: str) -> str:
         repetition_penalty=model.config.repetition_penalty,
         top_p=model.config.top_p,
     )
-    
     os.makedirs(os.path.dirname(save_path), exist_ok=True)
     torchaudio.save(save_path, torch.tensor(out["wav"]).unsqueeze(0), 24000)
     return save_path
 
-#_______________generate audios and folder structure_______________________
-
+# -----------------------------
+# Generate story audios
+# -----------------------------
 async def generate_story_audios(story: StoryCreationDTO, base_output: str):
-    """
-    Generates audio files and folders for the entire story
-    """
     story_dir = Path(base_output) / story.storyId
     story_dir.mkdir(parents=True, exist_ok=True)
 
@@ -222,337 +238,115 @@ async def generate_story_audios(story: StoryCreationDTO, base_output: str):
         chapter_dir = story_dir / chapter.chapterId
         chapter_dir.mkdir(exist_ok=True)
 
-        # --- Chapter title audio ---
-        prosody_file_title = await download_file_from_url(chapter.title.prosodyReference)
+        prosody_file_title = await get_cached_file(chapter.title.prosodyReference, "prosody")
         title_save_path = chapter_dir / "title.wav"
-        
         tagged_text_title = generate_tagged_text(
-            chapter.title.sentence, 
-            chapter.title.emotion,   
-            chapter.title.intensity    
-        )
-        
-        title_generated_audio_path = inference_by_model(
-            text=tagged_text_title,
-            audio_file=prosody_file_title,
-            save_path=title_save_path
+            chapter.title.sentence,
+            chapter.title.emotion,
+            chapter.title.intensity
         )
-        # os.remove(prosody_file_title)
+        inference_by_model(tagged_text_title, prosody_file_title, str(title_save_path))
 
         for scene in chapter.scenes:
-            await download_scene_files(scene)
             scene_dir = chapter_dir / scene.sceneId
             scene_dir.mkdir(exist_ok=True)
 
-            # --- Sentences audio ---
             for sentence in scene.sentences:
-                # Download the prosody reference audio from Supabase
-                prosody_file = download_cache[sentence.prosodyReference]
+                prosody_file = await get_cached_file(sentence.prosodyReference, "prosody")
                 sentence_save_path = scene_dir / f"{sentence.sentenceId}.wav"
                 tagged_text = generate_tagged_text(
-                    sentence.sentence, 
-                    sentence.emotion,   
-                    sentence.intensity    
-                )
-                sentence_generated_audio_path = inference_by_model(
-                    text=tagged_text,
-                    audio_file=prosody_file,
-                    save_path=sentence_save_path
+                    sentence.sentence,
+                    sentence.emotion,
+                    sentence.intensity
                 )
-                # os.remove(prosody_file)
-
-#_______________ Concatenating the generated audios to make the final story (post-processing)_______________________
-
-from pydub import AudioSegment
-import os
-import subprocess
+                inference_by_model(tagged_text, prosody_file, str(sentence_save_path))
 
+# -----------------------------
+# Concatenate audio
+# -----------------------------
 def ensure_wav(file_path: str) -> str:
-    """
-    Convert a single audio file to WAV using ffmpeg.
-    Returns the path to the WAV file.
-    If the file is already WAV, returns the original path.
-    """
     ext = os.path.splitext(file_path)[1].lower()
-    
     if ext == ".wav":
-        return file_path  # Already WAV
-    
-    # Output path: same folder, same name, .wav extension
+        return file_path
     wav_path = os.path.splitext(file_path)[0] + ".wav"
-    
-    # Run ffmpeg conversion
     subprocess.run(["ffmpeg", "-y", "-i", file_path, wav_path], check=True)
-    
-    print(f"Converted: {file_path} → {wav_path}")
     return wav_path
 
-from pydub import AudioSegment
-import asyncio
-
-async def concat_story_audio(story: StoryCreationDTO, base_output: str, final_path: str = None): # full path including filename
+async def concat_story_audio(story: StoryCreationDTO, base_output: str, final_path: str = None):
     story_dir = Path(base_output) / story.storyId
     story_dir.mkdir(parents=True, exist_ok=True)
-    
     if final_path is None:
         final_path = story_dir / f"{story.storyId}_full.wav"
     else:
         final_path = Path(final_path)
-        final_path.parent.mkdir(parents=True, exist_ok=True)  # ensure folder exists
+        final_path.parent.mkdir(parents=True, exist_ok=True)
 
-    chapters_audio = AudioSegment.silent(duration=0)  # start empty
+    chapters_audio = AudioSegment.silent(duration=0)
 
     for chapter in story.chapters:
         chapter_dir = story_dir / chapter.chapterId
-
-        # --- Chapter title ---
-        title_path = chapter_dir / "title.wav"
-        chapter_audio = AudioSegment.from_wav(title_path)
+        chapter_audio = AudioSegment.from_wav(chapter_dir / "title.wav")
 
         for scene in chapter.scenes:
             scene_dir = chapter_dir / scene.sceneId
             scene_audio = AudioSegment.silent(duration=0)
 
-            # --- Concatenate sentence audios ---
             for sentence in scene.sentences:
                 sentence_path = scene_dir / f"{sentence.sentenceId}.wav"
-                sentence_audio = AudioSegment.from_wav(sentence_path)
-                scene_audio += sentence_audio
+                scene_audio += AudioSegment.from_wav(sentence_path)
 
-           # --- Add SFX for location if available ---
             if scene.location.path:
-                sfx_file = await download_file_from_url(scene.location.path)
-                if sfx_file:
-                    sfx_file_wav = ensure_wav(sfx_file)
-                    sfx_audio = AudioSegment.from_wav(sfx_file_wav)
-                    scene_audio = scene_audio.overlay(sfx_audio)
-                    # os.remove(sfx_file)
-                #else:
-                    #print(f"SFX skipped for {scene.location.locationName}")
-
-            # --- Add background music if available ---
+                sfx_file = await get_cached_file(scene.location.path, "sfx")
+                sfx_file_wav = ensure_wav(sfx_file)
+                scene_audio = scene_audio.overlay(AudioSegment.from_wav(sfx_file_wav))
+
             if scene.bgMusic and scene.bgMusic.musicPath:
-                bg_url = scene.bgMusic.musicPath
-                bg_file = await download_file_from_url(bg_url)
+                bg_file = await get_cached_file(scene.bgMusic.musicPath, "bg_music")
                 bg_file_wav = ensure_wav(bg_file)
                 bg_audio = AudioSegment.from_file(bg_file_wav)
-
-                # Adjust volume
-                bg_audio = bg_audio - (1 - scene.bgMusic.volume) * 30  # approximate
-                # Loop if shorter than scene
+                bg_audio = bg_audio - (1 - scene.bgMusic.volume) * 30
                 if len(bg_audio) < len(scene_audio):
-                    loops = (len(scene_audio) // len(bg_audio)) + 1
-                    bg_audio = bg_audio * loops
-                bg_audio = bg_audio[:len(scene_audio)]  # trim to match scene
+                    bg_audio = bg_audio * ((len(scene_audio) // len(bg_audio)) + 1)
+                bg_audio = bg_audio[:len(scene_audio)]
                 scene_audio = scene_audio.overlay(bg_audio)
-                # os.remove(bg_file)
 
-            # Add 2 seconds of silence between scenes
             scene_audio += AudioSegment.silent(duration=2000)
             chapter_audio += scene_audio
 
-        # Add 3 seconds of silence between chapters
         chapter_audio += AudioSegment.silent(duration=3000)
         chapters_audio += chapter_audio
 
-    # Export final story
     chapters_audio.export(final_path, format="wav")
     return final_path
 
-#-------------------------------------------------------------
-
+# -----------------------------
+# FastAPI app & tasks
+# -----------------------------
 app = FastAPI(title="EGTTS Arabic TTS API")
-
 tasks = {}
 
-#___________________Test end point to test supabase fetch
-
-from fastapi import Query
-from fastapi.responses import Response
-
-@app.get("/test-download/")
-async def test_download(url: str = Query(...)):
-    try:
-        file_bytes = await download_file_from_url(url)
-
-        return Response(
-            content=file_bytes,
-            media_type="audio/wav"  # change if needed
-        )
-
-    except Exception as e:
-        return {"error": str(e)}
-#_________________________________________
-
-@app.get("/")
-def root():
-    return {"message": "Welcome! Visit /docs for Swagger UI."}
-
-#-----------------------------------------------------------
-
-class TTSResponse(BaseModel):
-    fileName: str
-    duration: float  # seconds
-    audioPath: str   
-
-#---------------------------concatenate text with tags ---------------------------
-
-# Map Intensity numbers to tag strings
-intensity_map = {
-    "LOW": "low",
-    "MEDIUM": "mid",
-    "HIGH": "high"
-}
-
-# Map Emotion enum names to lowercase tag strings
-emotion_map = {
-    "HAPPINESS": "happiness",
-    "SADNESS": "sadness",
-    "FEAR": "fear",
-    "ANGER": "anger",
-    "SURPRISE": "surprise",
-    "WHISPER": "whisper",
-    "NARRATION": "narration"
-}
-
-def generate_tagged_text(text: str, emotion_enum: str, intensity_enum: str) -> str:
-    """
-    Convert enums to <emo_x> <int_y> format and concatenate with text
-    """
-    emo_tag = f"<emo_{emotion_map[emotion_enum]}>"
-    int_tag = f"<int_{intensity_map[intensity_enum]}>"
-    return f"{emo_tag} {int_tag} {text}"
-
-#-----------------------------------------------------------
-
-#-----------------Post End Point_____________________________
-
-# @app.post("/tts/")
-# async def process_story(story: StoryCreationDTO):
-    
-#   # Optional: print info for debugging
-#     print(story.storyId)
-#     for cast in story.cast:
-#         print(cast.name, cast.voiceReference)
-#     for chapter in story.chapters:
-#         for scene in chapter.scenes:
-#             for sentence in scene.sentences:
-#                 print(sentence.speaker, sentence.sentence)
-
-#     # 1️⃣ Generate all sentence audios and folder structure
-#     await generate_story_audios(story, base_output=OUTPUT_DIR)
-
-#      # 2️⃣ Concatenate all into final story audio
-#     final_story_path = os.path.join(OUTPUT_DIR, story.storyId, f"{story.storyId}_full.wav")
-#     final_generated_story_path = await concat_story_audio(story, base_output=OUTPUT_DIR, final_path=final_story_path)
-    
-#     # Convert to base64 and get duration
-#     audio_b64, duration = audio_to_base64(final_generated_story_path)
-
-#     response = TTSResponse(
-#         file_name= os.path.basename(final_generated_story_path),
-#         duration=duration,
-#         audio_base64=audio_b64
-#     )
-
-#     return response
-
-
-# async def run_tts_pipeline(task_id: str, story: StoryCreationDTO):
-#     try:
-#         await generate_story_audios(story, base_output=OUTPUT_DIR)
-
-#         final_story_path = os.path.join(
-#             OUTPUT_DIR,
-#             story.storyId,
-#             f"{story.storyId}_full.wav"
-#         )
-
-#         final_generated_story_path = await concat_story_audio(
-#             story,
-#             base_output=OUTPUT_DIR,
-#             final_path=final_story_path
-#         )
-
-#         audio_b64, duration = audio_to_base64(final_generated_story_path)
-
-#         tasks[task_id] = {
-#             "status": "completed",
-#             "result": {
-#                 "fileName": os.path.basename(final_generated_story_path),
-#                 "duration": duration,
-#                 "audioPath": audio_b64
-#             }
-#         }
-
-#     except Exception as e:
-#         print(f"Exception caught at run tts pipeline {str(e)} and status is now failed")
-#         tasks[task_id] = {
-#             "status": "failed",
-#             "error": str(e)
-#         }
-
-import os
-import uuid
-from supabase import create_client, Client
-from pydub import AudioSegment  # For duration in seconds
-
-# Initialize Supabase client
-SUPABASE_URL = "https://kvlxvhdgacktsgykyckm.supabase.co/"
-SUPABASE_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Imt2bHh2aGRnYWNrdHNneWt5Y2ttIiwicm9sZSI6InNlcnZpY2Vfcm9sZSIsImlhdCI6MTc3MTk2MTQ5MSwiZXhwIjoyMDg3NTM3NDkxfQ.tzfHcbzwzctHDDDp3vk4JGz30ajN2szncAV-1wK7_pM"
-supabase: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
-
-import time
 async def run_tts_pipeline(task_id: str, story: StoryCreationDTO):
-    start_time = time.time()  # start timer
+    start_time = time.time()
     try:
-        # 1️⃣ Generate story audios
-        await generate_story_audios(story, base_output=OUTPUT_DIR)
-
-        # 2️⃣ Concatenate final story audio
-        final_story_path = os.path.join(
-            OUTPUT_DIR,
-            story.storyId,
-            f"{story.storyId}_full.wav"
-        )
-
-        final_generated_story_path = await concat_story_audio(
-            story,
-            base_output=OUTPUT_DIR,
-            final_path=final_story_path
-        )
-
-        print(f" final_generated_story_path: {final_generated_story_path}")
+        print(f"Starting story: {story.storyId}")
+        await generate_story_audios(story, OUTPUT_DIR)
+        final_wav_path = Path(OUTPUT_DIR) / story.storyId / f"{story.storyId}_full.wav"
+        final_generated_story_path = await concat_story_audio(story, OUTPUT_DIR, final_path=str(final_wav_path))
 
+        # Convert to mp3
         wav = AudioSegment.from_wav(final_generated_story_path)
         mp3_path = final_generated_story_path.with_suffix(".mp3")
         wav.export(mp3_path, format="mp3", bitrate="192k")
 
-        print(f" final_generated_story_path after conversion to mp3: {mp3_path}")
-
-        
-        # 3️⃣ Calculate duration
         audio_segment = AudioSegment.from_file(mp3_path)
-        duration_seconds = len(audio_segment) / 1000  # pydub gives length in milliseconds
-        
-        # 4️⃣ Prepare the file for upload
+        duration_seconds = len(audio_segment) / 1000
+
+        # Upload final story
         file_name = f"{uuid.uuid4()}_{os.path.basename(mp3_path)}"
         storage_path = f"{story.storyId}/final/{file_name}"
-
-        # with open(final_generated_story_path, "rb") as f:
-        #     file_bytes = f.read()
-
-
-        
-        supabase.storage.from_("story-audio-files").upload(
-            storage_path,
-            mp3_path
-        )
-
-        # 6️⃣ Get public URL
+        supabase.storage.from_("story-audio-files").upload(storage_path, mp3_path)
         audio_url = supabase.storage.from_("story-audio-files").get_public_url(storage_path)
 
-        # 7️⃣ Update task status with audio URL and duration
         tasks[task_id] = {
             "status": "completed",
             "result": {
@@ -562,112 +356,48 @@ async def run_tts_pipeline(task_id: str, story: StoryCreationDTO):
             }
         }
 
-        # --- Print processing time ---
-        end_time = time.time()
-        elapsed = end_time - start_time
+        elapsed = time.time() - start_time
         print(f"Story {story.storyId} processed in {elapsed:.2f} seconds")
 
     except Exception as e:
-        print(f"exception caught at run tts pipeline {str(e)}")
-        tasks[task_id] = {
-            "status": "failed",
-            "error": str(e)
-        }
-
-from fastapi import BackgroundTasks
-import uuid
+        tasks[task_id] = {"status": "failed", "error": str(e)}
+        print(f"Exception for story {story.storyId}: {e}")
 
+# -----------------------------
+# FastAPI endpoints
+# -----------------------------
 @app.post("/tts/")
 async def process_story(story: StoryCreationDTO, background_tasks: BackgroundTasks):
-
     task_id = str(uuid.uuid4())
-
-    tasks[task_id] = {
-        "status": "processing",
-        "result": None
-    }
-
+    tasks[task_id] = {"status": "processing", "result": None}
     background_tasks.add_task(run_tts_pipeline, task_id, story)
-
     return {"task_id": task_id}
 
-#-----------------------Results Get End Point ______________________________________
-
-# @app.get("/tts/results/{task_id}")
-# async def get_results(task_id: str):
-
-#     if task_id not in tasks:
-#         return {"status": "not_found"}
-
-#     task = tasks[task_id]
-
-#     if task["status"] == "processing":
-#         return {"status": "processing"}
-
-#     if task["status"] == "failed":
-#         return {
-#             "status": "failed",
-#             "error": task["error"]
-#         }
-
-#     return task["result"]
-
 @app.get("/tts/results/{task_id}")
 async def get_results(task_id: str):
     if task_id not in tasks:
         return {"status": "not_found"}
-
     task = tasks[task_id]
-
     if task["status"] == "processing":
         return {"status": "processing"}
-
     if task["status"] == "failed":
-        return {
-            "status": "failed",
-            "error": task.get("error", "Unknown error")
-        }
-
-    # Ensure result exists and has all required fields
-    result = task.get("result")
-    if result and all(k in result for k in ("fileName", "duration", "audioPath")):
-        #clearing cache
-        print(f"all fields are available {result}")
-        for file_path in download_cache.values():
-            if os.path.exists(file_path):
-                os.remove(file_path)
-        download_cache.clear()
-        
-        return {"status": "completed", **result}
-    else:
-        print(f"missing field {result}")
-        # If result is missing fields, mark as still processing
-        return {"status": "processing"}
-
-#----------------------------Test End Point to test tts inference------------------------------------
-
-@app.post("/tts_test/")
-async def tts_endpoint(
-    text: str = Form(...),
-    audio_file: UploadFile = File(...),
-    emotionName: str = Form(...),
-    intensity: int = Form(...)
-):
-    
-    file_path = os.path.join(OUTPUT_DIR, audio_file.filename)
-    with open(file_path, "wb") as f:
-        f.write(await audio_file.read())
+        return {"status": "failed", "error": task.get("error", "Unknown error")}
+    return {"status": "completed", **task["result"]}
 
-    tagged_text = generate_tagged_text(text, emotionName, intensity)
+@app.get("/")
+def root():
+    return {"message": "Welcome! Visit /docs for Swagger UI."}
 
-    output_path = os.path.join(OUTPUT_DIR, "out_test.wav")
-    output_wav = inference_by_model(tagged_text, file_path,output_path)
-    return FileResponse(output_wav, media_type="audio/wav", filename="output.wav")
+# -----------------------------
+# Startup preload event
+# -----------------------------
+@app.on_event("startup")
+async def startup_event():
+    await preload_all_assets()
 
+# -----------------------------
+# Run app
+# -----------------------------
 import uvicorn
-uvicorn.run(app, host="0.0.0.0", port=7860)
-
-
-# if __name__ == "__main__":
-#     import uvicorn
-#     uvicorn.run(app, host="0.0.0.0", port=7860)
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=7860)