Upload app.py with huggingface_hub

app.py

@@ -10,8 +10,8 @@ from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import HTMLResponse
 import uvicorn
 
-# --- [v150] 🚀 HIGH STABILITY H200 ENGINE ---
-print(f"--- [v150] 📡 BOOTING ENGINE ---")
+# --- [v151] 🚀 TTS DEBUG ENGINE ---
+print(f"--- [v151] 📡 BOOTING DEBUG ENGINE ---")
 
 from transformers import pipeline, AutoModelForSpeechSeq2Seq, AutoProcessor
 from TTS.api import TTS
@@ -46,8 +46,7 @@ MODELS = {"stt": None, "tts": None}
 def load_stt_gpu():
     global MODELS
     if MODELS.get("stt") is None:
-        print("--- [v150] 📥 LOADING WHISPER (Base for Stability) ---")
-        # Use Base model to ensure it fits and loads quickly in serverless context
+        print("--- [v151] 📥 LOADING WHISPER (Base) ---")
         model_id = "openai/whisper-base"
         model = AutoModelForSpeechSeq2Seq.from_pretrained(
             model_id, torch_dtype=torch.float32, low_cpu_mem_usage=True, use_safetensors=True
@@ -62,113 +61,110 @@ def load_stt_gpu():
             device="cuda",
             model_kwargs={"attn_implementation": "eager"}
         )
-        print("--- [v150] ✅ WHISPER READY ---")
+        print("--- [v151] ✅ WHISPER READY ---")
 
 def load_tts_gpu():
     global MODELS
     if MODELS.get("tts") is None:
-        print("--- [v150] 📥 LOADING XTTS v2 ---")
-        MODELS["tts"] = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to("cuda")
-        MODELS["tts"].to(torch.float32) 
-        print("--- [v150] ✅ XTTS READY ---")
-
-@spaces.GPU(duration=120)
-def unified_gpu_process(action, data):
-    """Single GPU entry point to avoid context flip-flops."""
+        print("--- [v151] 📥 LOADING XTTS V2 ---")
+        try:
+            # Try loading once and keeping in VRAM if possible (ZeroGPU might clear it)
+            MODELS["tts"] = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to("cuda")
+            MODELS["tts"].to(torch.float32)
+            print("--- [v151] ✅ XTTS LOADED SUCCESSFULLY ---")
+        except Exception as e:
+            print(f"--- [v151] ❌ XTTS FAILED TO LOAD: {e} ---")
+            raise e
+
+@spaces.GPU(duration=180) # Longer duration for XTTS
+def process_full(action, data):
     global MODELS
-    res = {}
+    print(f"--- [v151] 🚀 STARTING {action} on GPU ---")
     
     # 🎙️ STT
     stt_text = ""
     if action in ["stt", "s2st"]:
         load_stt_gpu()
-        audio_bytes = base64.b64decode(data.get("file"))
-        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
-            f.write(audio_bytes); temp_path = f.name
         try:
+            audio_bytes = base64.b64decode(data.get("file"))
+            with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
+                f.write(audio_bytes); temp_path = f.name
             lang = data.get("lang")
-            # Batch size 1 for stability
             stt_res = MODELS["stt"](temp_path, batch_size=1, generate_kwargs={"language": lang if lang and len(lang) <= 3 else None})
             stt_text = stt_res["text"].strip()
+            print(f"--- [v151] 🎙️ STT: {stt_text[:50]}... ---")
             if action == "stt": return {"text": stt_text}
         finally:
-            if os.path.exists(temp_path): os.unlink(temp_path)
+            if 'temp_path' in locals() and os.path.exists(temp_path): os.unlink(temp_path)
 
     # 🔊 TTS
     if action in ["tts", "s2st"]:
-        load_tts_gpu()
         text = (data.get("text") if action == "tts" else stt_text).strip()
         trans_text = text
-        
-        target_lang = data.get("target_lang") or data.get("lang") or "en"
+        target = data.get("target_lang") or data.get("lang") or "en"
         
         if action == "s2st":
-            trans_text = GoogleTranslator(source='auto', target=target_lang).translate(stt_text)
+            print(f"--- [v151] 🌏 TRANSLATING TO {target}... ---")
+            trans_text = GoogleTranslator(source='auto', target=target).translate(stt_text)
             text = trans_text
+            print(f"--- [v151] 📝 TRANS: {trans_text[:50]}... ---")
 
         if len(text) < 2: return {"text": stt_text, "translated": "", "audio": ""} if action == "s2st" else {"audio": ""}
 
         XTTS_MAP = {"en": "en", "de": "de", "fr": "fr", "es": "es", "it": "it", "pl": "pl", "pt": "pt", "tr": "tr", "ru": "ru", "nl": "nl", "cs": "cs", "ar": "ar", "hu": "hu", "ko": "ko", "hi": "hi", "zh": "zh-cn"}
-        clean_lang = target_lang.split('-')[0].lower()
+        clean_lang = target.split('-')[0].lower()
         mapped_lang = XTTS_MAP.get(clean_lang) or ("zh-cn" if clean_lang == "zh" else None)
         
         if not mapped_lang:
             if HAS_CHATTERBOX:
-                print(f"--- [v150] 📦 FALLBACK: CHATTERBOX FOR {clean_lang} ---")
+                print(f"--- [v151] 📦 FALLBACK: CHATTERBOX ---")
                 audio_bytes = chatterbox_utils.run_chatterbox_inference(text, clean_lang)
-                audio_b64 = base64.b64encode(audio_bytes).decode()
-            else:
-                return {"error": f"Language {clean_lang} not supported."}
+                return {"text": stt_text, "translated": trans_text, "audio": base64.b64encode(audio_bytes).decode()}
+            return {"error": f"Lang {clean_lang} unsupported"}
+
+        print(f"--- [v151] 📥 LOADING XTTS... ---")
+        load_tts_gpu()
+        
+        speaker_wav = data.get("speaker_wav")
+        speaker_path = None
+        if speaker_wav:
+            with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
+                f.write(base64.b64decode(speaker_wav)); speaker_path = f.name
         else:
-            speaker_wav_path = "default_speaker.wav"
-            if data.get("speaker_wav"):
-                sb = base64.b64decode(data.get("speaker_wav"))
-                with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
-                    f.write(sb); speaker_wav_path = f.name
-            elif not os.path.exists(speaker_wav_path):
-                speaker_wav_path = None
-
-            try:
-                with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as out_f: out_p = out_f.name
-                MODELS["tts"].tts_to_file(text=text, language=mapped_lang, file_path=out_p, speaker_wav=speaker_wav_path)
-                with open(out_p, "rb") as f: audio_b64 = base64.b64encode(f.read()).decode()
-            finally:
-                if data.get("speaker_wav") and os.path.exists(speaker_wav_path): os.unlink(speaker_wav_path)
-                if 'out_p' in locals() and os.path.exists(out_p): os.unlink(out_p)
+            speaker_path = "default_speaker.wav"
+            if not os.path.exists(speaker_path): speaker_path = None
+
+        print(f"--- [v151] 🔊 RUNNING XTTS INFERENCE... ---")
+        try:
+            with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as out_f: out_p = out_f.name
+            MODELS["tts"].tts_to_file(text=text, language=mapped_lang, file_path=out_p, speaker_wav=speaker_path)
+            with open(out_p, "rb") as f: audio_b64 = base64.b64encode(f.read()).decode()
+            print(f"--- [v151] ✅ TTS SUCCESS! ---")
+        finally:
+            if speaker_wav and speaker_path and os.path.exists(speaker_path): os.unlink(speaker_path)
+            if 'out_p' in locals() and os.path.exists(out_p): os.unlink(out_p)
 
         if action == "tts": return {"audio": audio_b64}
         return {"text": stt_text, "translated": trans_text, "audio": audio_b64}
-    
-    return {"error": "Invalid action"}
 
 @app.post("/process")
 @app.post("/api/v1/process")
-async def api_gateway(request: Request):
+async def api_process(request: Request):
     try:
         data = await request.json()
         action = data.get("action")
-        if action == "health": return {"status": "awake", "v": "150"}
-        print(f"--- [v150] 🛠️ {action} requested ---")
-        return unified_gpu_process(action, data)
+        if action == "health": return {"status": "awake", "v": "151"}
+        return process_full(action, data)
     except Exception as e:
-        print(f"❌ [v150] ERROR: {traceback.format_exc()}")
+        print(f"❌ [v151] CRASH: {traceback.format_exc()}")
         return {"error": str(e)}
-    finally:
-        torch.cuda.empty_cache()
 
 @app.get("/health")
 def health():
-    diag = {
-        "status": "ok", "v": "150", 
-        "gpu": torch.cuda.is_available(),
-        "device": torch.cuda.get_device_name(0) if torch.cuda.is_available() else "None",
-        "spaces": HAS_SPACES,
-        "chatterbox": HAS_CHATTERBOX
-    }
-    return diag
+    return {"status": "ok", "v": "151", "gpu": torch.cuda.is_available(), "chatterbox": HAS_CHATTERBOX}
 
 @app.get("/", response_class=HTMLResponse)
-def root(): return "<html><body><h1>🚀 AI Engine v150 (HIGH STABILITY)</h1></body></html>"
+def root(): return "<html><body><h1>🚀 AI Engine v151 (DEBUG)</h1></body></html>"
 
 if __name__ == "__main__":
     uvicorn.run(app, host="0.0.0.0", port=7860)