Upload app.py with huggingface_hub

app.py

@@ -11,9 +11,9 @@ from fastapi import FastAPI, Request
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import HTMLResponse
 
-# --- [v163] 🚀 PRO GPU ENGINE (FULL STABILITY) ---
-# This version enforces GPU usage for STT and TTS with robust error handling.
-print(f"--- [v163] 📡 BOOTING ENGINE ---")
+# --- [v164] 🚀 PRO GPU ENGINE (ULTIMATE STABILITY) ---
+# This version enforces float32 for STT to avoid CUBLAS errors and uses batch_size=1.
+print(f"--- [v164] 📡 BOOTING ENGINE ---")
 
 # 🛠️ CRITICAL: TORCHAUDIO MONKEYPATCH 🛠️
 import torchaudio
@@ -33,7 +33,7 @@ def HeroLoad(filepath, **kwargs):
 if not hasattr(torchaudio, 'load_orig'):
     torchaudio.load_orig = torchaudio.load
     torchaudio.load = HeroLoad
-    print("--- [v163] 🩹 TORCHAUDIO PATCH APPLIED ---")
+    print("--- [v164] 🩹 TORCHAUDIO PATCH APPLIED ---")
 
 from transformers import pipeline, AutoModelForSpeechSeq2Seq, AutoProcessor
 from TTS.api import TTS
@@ -78,29 +78,35 @@ def gpu_stt_full(temp_path, lang):
     device = get_best_gpu()
     
     if MODELS.get("stt") is None:
-        print(f"--- [v163] 📥 LOADING WHISPER LARGE ON {device} ---")
+        print(f"--- [v164] 📥 LOADING WHISPER LARGE (FP32) ON {device} ---")
         model_id = "openai/whisper-large-v3-turbo"
-        model = AutoModelForSpeechSeq2Seq.from_pretrained(model_id, torch_dtype=torch.float16).to(device)
+        # Using float32 to resolve CUBLAS_STATUS_EXECUTION_FAILED on H200/A10G MIG
+        model = AutoModelForSpeechSeq2Seq.from_pretrained(model_id, torch_dtype=torch.float32).to(device)
         processor = AutoProcessor.from_pretrained(model_id)
         MODELS["stt"] = pipeline(
             "automatic-speech-recognition",
             model=model,
             tokenizer=processor.tokenizer,
             feature_extractor=processor.feature_extractor,
-            chunk_length_s=30, # Mandatory for >30s support
+            chunk_length_s=30, 
             device=device
         )
     
-    print(f"--- [v163] 🎙️ WHISPER INFERENCE (TEMP 0) ---")
+    print(f"--- [v164] 🎙️ WHISPER INFERENCE (TEMP 0, BS 1) ---")
     res = MODELS["stt"](
         temp_path, 
-        batch_size=8, # Accelerated processing
+        batch_size=1, # Ultimate stability
         generate_kwargs={
             "language": lang if lang and len(lang) <= 3 else None,
-            "temperature": 0.0, # High precision as requested
-            "return_timestamps": True # Fixes ValueError: > 3000 mel features
+            "temperature": 0.0,
+            "return_timestamps": True
         }
     )
+    
+    # Post-inference cleanup
+    torch.cuda.empty_cache()
+    gc.collect()
+    
     return res["text"].strip()
 
 @spaces.GPU(duration=180)
@@ -109,13 +115,13 @@ def gpu_tts_full(text, mapped_lang, speaker_path):
     device = "cuda"
     
     if MODELS.get("tts") is None:
-        print(f"--- [v163] 📥 LOADING XTTS V2 ON GPU ---")
+        print(f"--- [v164] 📥 LOADING XTTS V2 ON GPU ---")
         MODELS["tts"] = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to(device)
     else:
         try: MODELS["tts"].to(device)
         except: pass
 
-    print(f"--- [v163] 🔊 XTTS GPU INFERENCE ---")
+    print(f"--- [v164] 🔊 XTTS GPU INFERENCE ---")
     with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as out_f:
         out_p = out_f.name
     
@@ -137,9 +143,9 @@ async def handle_process(request: Request):
     try:
         data = await request.json()
         action = data.get("action")
-        if action == "health": return {"status": "awake", "v": "163"}
+        if action == "health": return {"status": "awake", "v": "164"}
         
-        print(f"--- [v163] 🛠️ API REQUEST: {action.upper()} ---")
+        print(f"--- [v164] 🛠️ API REQUEST: {action.upper()} ---")
         
         stt_text = ""
         # 🟢 SPEECH-TO-TEXT
@@ -167,10 +173,10 @@ async def handle_process(request: Request):
             trans_text = text
             
             if action == "s2st":
-                print(f"--- [v163] 🌏 TRANSLATING TO {target} ---")
+                print(f"--- [v164] 🌏 TRANSLATING TO {target} ---")
                 trans_text = GoogleTranslator(source='auto', target=target).translate(stt_text)
                 text = trans_text
-                print(f"--- [v163] 📝 TRANS: {text[:100]}... ---")
+                print(f"--- [v164] 📝 TRANS: {text[:100]}... ---")
 
             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()
@@ -201,10 +207,10 @@ async def handle_process(request: Request):
             return {"text": stt_text, "translated": trans_text, "audio": audio_b64}
 
     except Exception as e:
-        print(f"❌ [v163] ENGINE ERROR: {traceback.format_exc()}")
+        print(f"❌ [v164] ENGINE ERROR: {traceback.format_exc()}")
         return {"error": str(e)}
     finally:
-        print(f"--- [v163] ✨ MISSION COMPLETED ({time.time()-t1:.1f}s) ---")
+        print(f"--- [v164] ✨ MISSION COMPLETED ({time.time()-t1:.1f}s) ---")
 
 @app.post("/process")
 @app.post("/api/v1/process")
@@ -214,16 +220,16 @@ async def api_process(request: Request): return await handle_process(request)
 def health(): 
     return {
         "status": "ready", 
-        "v": "163", 
+        "v": "164", 
         "gpu": torch.cuda.is_available(),
         "devices": torch.cuda.device_count(),
-        "engine": "Full GPU PRO",
-        "stt": "Whisper-v3-Turbo (GPU)",
+        "engine": "Full GPU PRO (Stable)",
+        "stt": "Whisper-v3-Turbo (FP32-GPU)",
         "tts": "XTTS-v2 (GPU)"
     }
 
 @app.get("/", response_class=HTMLResponse)
-def root(): return "<h1>🚀 PRO AI Engine v163 (GPU MODE)</h1>"
+def root(): return "<h1>🚀 PRO AI Engine v164 (GPU MODE)</h1>"
 
 if __name__ == "__main__":
     uvicorn.run(app, host="0.0.0.0", port=7860)