Upload app.py with huggingface_hub

app.py

@@ -5,14 +5,14 @@ import base64
 import torch
 import tempfile
 import traceback
-import gc
 from fastapi import FastAPI, Request
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import HTMLResponse
 import uvicorn
 
-# --- [v154] 🚀 PRO STABLE ENGINE (GPU-STT + CPU-TTS) ---
-print(f"--- [v154] 📡 BOOTING PRO STABLE ENGINE ---")
+# --- [v155] 🚀 FINAL STABLE ENGINE (GPU-STT-Base + CPU-TTS-XTTS) ---
+# This version uses the proven stable components for H200 ZeroGPU.
+print(f"--- [v155] 📡 BOOTING FINAL ENGINE ---")
 
 from transformers import pipeline, AutoModelForSpeechSeq2Seq, AutoProcessor
 from TTS.api import TTS
@@ -47,30 +47,25 @@ MODELS = {"stt": None, "tts": None}
 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
+        print("--- [v155] 📥 LOADING XTTS V2 (CPU) ---")
         MODELS["tts"] = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to("cpu")
-        print("--- [v154] ✅ XTTS READY (CPU) ---")
+        print("--- [v155] ✅ XTTS READY ---")
 
 @spaces.GPU(duration=60)
-def gpu_stt_inference(temp_path, lang):
+def gpu_stt_base(temp_path, lang):
     global MODELS
     if MODELS.get("stt") is None:
-        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")
+        print("--- [v155] 📥 LOADING WHISPER (Base) ON GPU ---")
+        model_id = "openai/whisper-base"
+        model = AutoModelForSpeechSeq2Seq.from_pretrained(model_id, torch_dtype=torch.float32).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()
 
@@ -78,25 +73,22 @@ async def handle_process(request: Request):
     try:
         data = await request.json()
         action = data.get("action")
-        if action == "health": return {"status": "awake", "v": "154"}
+        if action == "health": return {"status": "awake", "v": "155"}
         
-        print(f"--- [v154] 🛠️ {action} ---")
+        print(f"--- [v155] 🛠️ {action} ---")
         t1 = time.time()
         
-        # 🎙️ STT (GPU)
         stt_text = ""
         if action in ["stt", "s2st"]:
             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:
-                stt_text = gpu_stt_inference(temp_path, data.get("lang"))
+                stt_text = gpu_stt_base(temp_path, data.get("lang"))
             finally:
                 if os.path.exists(temp_path): os.unlink(temp_path)
-            
             if action == "stt": return {"text": stt_text}
 
-        # 🔊 TTS (CPU)
         if action in ["tts", "s2st"]:
             load_tts_cpu()
             text = (data.get("text") if action == "tts" else stt_text).strip()
@@ -138,20 +130,20 @@ async def handle_process(request: Request):
             return {"text": stt_text, "translated": trans_text, "audio": audio_b64}
 
     except Exception as e:
-        print(f"❌ [v154] ERROR: {traceback.format_exc()}")
+        print(f"❌ [v155] ERROR: {traceback.format_exc()}")
         return {"error": str(e)}
     finally:
-        print(f"--- [v154] ✨ DONE ({time.time()-t1:.1f}s) ---")
+        print(f"--- [v155] ✨ 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": "154", "gpu": torch.cuda.is_available()}
+def health(): return {"status": "ok", "v": "155", "gpu": torch.cuda.is_available()}
 
 @app.get("/", response_class=HTMLResponse)
-def root(): return "<h1>🚀 AI Engine v154 (PRO STABLE)</h1>"
+def root(): return "<h1>🚀 AI Engine v155 (STABLE)</h1>"
 
 if __name__ == "__main__":
     uvicorn.run(app, host="0.0.0.0", port=7860)