Upload app.py with huggingface_hub

app.py

@@ -11,10 +11,10 @@ from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import HTMLResponse
 import uvicorn
 
-# --- [v153] 🚀 EPHEMERAL GPU ENGINE ---
-print(f"--- [v153] 📡 BOOTING EPHEMERAL ENGINE ---")
+# --- [v154] 🚀 PRO STABLE ENGINE (GPU-STT + CPU-TTS) ---
+print(f"--- [v154] 📡 BOOTING PRO STABLE ENGINE ---")
 
-from transformers import pipeline
+from transformers import pipeline, AutoModelForSpeechSeq2Seq, AutoProcessor
 from TTS.api import TTS
 from deep_translator import GoogleTranslator
 
@@ -42,68 +42,63 @@ os.environ["PYTHONWARNINGS"] = "ignore"
 app = FastAPI()
 app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
 
-MODELS = {"stt": None}
+MODELS = {"stt": None, "tts": None}
 
-def load_stt_cpu():
+def load_tts_cpu():
+    global MODELS
+    if MODELS.get("tts") is None:
+        print("--- [v154] 📥 LOADING XTTS V2 (CPU MODE) ---")
+        # XTTS on CPU is stable and avoids ZeroGPU kernel crashes
+        MODELS["tts"] = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to("cpu")
+        print("--- [v154] ✅ XTTS READY (CPU) ---")
+
+@spaces.GPU(duration=60)
+def gpu_stt_inference(temp_path, lang):
     global MODELS
     if MODELS.get("stt") is None:
-        print("--- [v153] 📥 LOADING WHISPER (Base) ON CPU ---")
-        MODELS["stt"] = pipeline("automatic-speech-recognition", model="openai/whisper-base", device="cpu")
-        print("--- [v153] ✅ WHISPER READY (CPU) ---")
-
-@spaces.GPU(duration=180)
-def ephemeral_tts(text, mapped_lang, speaker_path):
-    """Pure ephemeral loading on GPU to bypass VRAM watchdogs."""
-    print(f"--- [v153] 📥 LOADING XTTS EPOCH... ---")
-    local_tts = None
-    try:
-        local_tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to("cuda")
-        local_tts.to(torch.float32)
-        
-        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as out_f:
-            out_p = out_f.name
-        
-        print(f"--- [v153] 🔊 INFERENCE... ---")
-        local_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()
-        return audio_b64
-    finally:
-        print(f"--- [v153] 🧹 CLEANUP ---")
-        if local_tts:
-            del local_tts
-        if 'out_p' in locals() and os.path.exists(out_p): os.unlink(out_p)
-        gc.collect()
-        torch.cuda.empty_cache()
+        print("--- [v154] 📥 LOADING WHISPER (Large-v3-Turbo) ON GPU ---")
+        model_id = "openai/whisper-large-v3-turbo"
+        model = AutoModelForSpeechSeq2Seq.from_pretrained(
+            model_id, torch_dtype=torch.float16, low_cpu_mem_usage=True, use_safetensors=True
+        ).to("cuda")
+        processor = AutoProcessor.from_pretrained(model_id)
+        MODELS["stt"] = pipeline(
+            "automatic-speech-recognition",
+            model=model,
+            tokenizer=processor.tokenizer,
+            feature_extractor=processor.feature_extractor,
+            torch_dtype=torch.float16,
+            device="cuda"
+        )
+    
+    res = MODELS["stt"](temp_path, generate_kwargs={"language": lang if lang and len(lang) <= 3 else None})
+    return res["text"].strip()
 
 async def handle_process(request: Request):
     try:
         data = await request.json()
         action = data.get("action")
-        if action == "health": return {"status": "awake", "v": "153"}
+        if action == "health": return {"status": "awake", "v": "154"}
         
-        print(f"--- [v153] 🛠️ {action} ---")
+        print(f"--- [v154] 🛠️ {action} ---")
         t1 = time.time()
         
-        # 🎙️ STT (CPU)
+        # 🎙️ STT (GPU)
         stt_text = ""
         if action in ["stt", "s2st"]:
-            load_stt_cpu()
             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:
-                lang = data.get("lang")
-                res = MODELS["stt"](temp_path, generate_kwargs={"language": lang if lang and len(lang) <= 3 else None})
-                stt_text = res["text"].strip()
+                stt_text = gpu_stt_inference(temp_path, data.get("lang"))
             finally:
                 if os.path.exists(temp_path): os.unlink(temp_path)
             
             if action == "stt": return {"text": stt_text}
 
-        # 🔊 TTS (GPU)
+        # 🔊 TTS (CPU)
         if action in ["tts", "s2st"]:
+            load_tts_cpu()
             text = (data.get("text") if action == "tts" else stt_text).strip()
             trans_text = text
             target = data.get("target_lang") or data.get("lang") or "en"
@@ -112,8 +107,6 @@ async def handle_process(request: Request):
                 trans_text = GoogleTranslator(source='auto', target=target).translate(stt_text)
                 text = trans_text
 
-            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.split('-')[0].lower()
             mapped_lang = XTTS_MAP.get(clean_lang) or ("zh-cn" if clean_lang == "zh" else None)
@@ -134,28 +127,31 @@ async def handle_process(request: Request):
                     if not os.path.exists(speaker_path): speaker_path = None
                 
                 try:
-                    audio_b64 = ephemeral_tts(text, mapped_lang, speaker_path)
+                    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()
                 finally:
                     if speaker_wav_b64 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}
 
     except Exception as e:
-        print(f"❌ [v153] ERROR: {traceback.format_exc()}")
+        print(f"❌ [v154] ERROR: {traceback.format_exc()}")
         return {"error": str(e)}
     finally:
-        print(f"--- [v153] ✨ DONE ({time.time()-t1:.1f}s) ---")
+        print(f"--- [v154] ✨ DONE ({time.time()-t1:.1f}s) ---")
 
 @app.post("/process")
 @app.post("/api/v1/process")
 async def api_process(request: Request): return await handle_process(request)
 
 @app.get("/health")
-def health(): return {"status": "ok", "v": "153", "gpu": torch.cuda.is_available()}
+def health(): return {"status": "ok", "v": "154", "gpu": torch.cuda.is_available()}
 
 @app.get("/", response_class=HTMLResponse)
-def root(): return "<h1>🚀 AI Engine v153 (EPHEMERAL)</h1>"
+def root(): return "<h1>🚀 AI Engine v154 (PRO STABLE)</h1>"
 
 if __name__ == "__main__":
     uvicorn.run(app, host="0.0.0.0", port=7860)