Upload app.py with huggingface_hub

app.py

@@ -10,8 +10,8 @@ from fastapi import FastAPI, Request
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import HTMLResponse
 
-# --- [v159] 🚀 HERO STABILITY ENGINE (FINAL MISSION) ---
-print(f"--- [v159] 📡 BOOTING ENGINE ---")
+# --- [v160] 🚀 HERO STABILITY ENGINE (FINAL MISSION) ---
+print(f"--- [v160] 📡 BOOTING ENGINE ---")
 
 # 🛠️ CRITICAL: TORCHAUDIO MONKEYPATCH 🛠️
 # This bypasses the 'torchcodec' ModuleNotFoundError on Hugging Face Spaces.
@@ -19,7 +19,7 @@ import torchaudio
 import soundfile as sf
 import numpy as np
 
-defHeroLoad(filepath, **kwargs):
+def HeroLoad(filepath, **kwargs):
     """Robust alternative to torchaudio.load using soundfile."""
     try:
         data, samplerate = sf.read(filepath)
@@ -37,7 +37,7 @@ defHeroLoad(filepath, **kwargs):
 if not hasattr(torchaudio, 'load_orig'):
     torchaudio.load_orig = torchaudio.load
     torchaudio.load = HeroLoad
-    print("--- [v159] 🩹 TORCHAUDIO HERO PATCH APPLIED (soundfile) ---")
+    print("--- [v160] 🩹 TORCHAUDIO HERO PATCH APPLIED (soundfile) ---")
 
 from transformers import pipeline, AutoModelForSpeechSeq2Seq, AutoProcessor
 from TTS.api import TTS
@@ -72,16 +72,16 @@ MODELS = {"stt": None, "tts": None}
 def load_tts_cpu():
     global MODELS
     if MODELS.get("tts") is None:
-        print("--- [v159] 📥 LOADING XTTS V2 (CPU MODE) ---")
+        print("--- [v160] 📥 LOADING XTTS V2 (CPU MODE) ---")
         # CPU loading is 100% stable on ZeroGPU H200
         MODELS["tts"] = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to("cpu")
-        print("--- [v159] ✅ XTTS READY (CPU) ---")
+        print("--- [v160] ✅ XTTS READY (CPU) ---")
 
 @spaces.GPU(duration=60)
 def gpu_stt_base(temp_path, lang):
     global MODELS
     if MODELS.get("stt") is None:
-        print("--- [v159] 📥 LOADING WHISPER (Base) ON GPU ---")
+        print("--- [v160] 📥 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)
@@ -92,7 +92,7 @@ def gpu_stt_base(temp_path, lang):
             feature_extractor=processor.feature_extractor,
             device="cuda"
         )
-    print(f"--- [v159] 🎙️ RUNNING WHISPER INFERENCE ---")
+    print(f"--- [v160] 🎙️ RUNNING WHISPER INFERENCE ---")
     res = MODELS["stt"](temp_path, generate_kwargs={"language": lang if lang and len(lang) <= 3 else None})
     return res["text"].strip()
 
@@ -101,9 +101,9 @@ async def handle_process(request: Request):
     try:
         data = await request.json()
         action = data.get("action")
-        if action == "health": return {"status": "awake", "v": "159"}
+        if action == "health": return {"status": "awake", "v": "160"}
         
-        print(f"--- [v159] 🛠️ {action.upper()} REQUESTED ---")
+        print(f"--- [v160] 🛠️ {action.upper()} REQUESTED ---")
         
         # 🟢 STT PATH
         stt_text = ""
@@ -117,7 +117,7 @@ async def handle_process(request: Request):
                 temp_path = f.name
             try:
                 stt_text = gpu_stt_base(temp_path, data.get("lang"))
-                print(f"--- [v159] 🎙️ TRANSCRIPT: {stt_text} ---")
+                print(f"--- [v160] 🎙️ TRANSCRIPT: {stt_text} ---")
             finally:
                 if os.path.exists(temp_path): os.unlink(temp_path)
             
@@ -132,10 +132,10 @@ async def handle_process(request: Request):
             target = data.get("target_lang") or data.get("lang") or "en"
             
             if action == "s2st":
-                print(f"--- [v159] 🌏 TRANSLATING TO {target} ---")
+                print(f"--- [v160] 🌏 TRANSLATING TO {target} ---")
                 trans_text = GoogleTranslator(source='auto', target=target).translate(stt_text)
                 text = trans_text
-                print(f"--- [v159] 📝 TRANSLATED: {text} ---")
+                print(f"--- [v160] 📝 TRANSLATED: {text} ---")
 
             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()
@@ -143,7 +143,7 @@ async def handle_process(request: Request):
             
             if not mapped_lang:
                 if HAS_CHATTERBOX:
-                    print(f"--- [v159] 📦 FALLBACK: CHATTERBOX FOR {clean_lang} ---")
+                    print(f"--- [v160] 📦 FALLBACK: CHATTERBOX FOR {clean_lang} ---")
                     audio_bytes = chatterbox_utils.run_chatterbox_inference(text, clean_lang)
                     audio_b64 = base64.b64encode(audio_bytes).decode()
                 else: return {"error": f"Lang {clean_lang} unsupported"}
@@ -162,7 +162,7 @@ async def handle_process(request: Request):
                 try:
                     with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as out_f:
                         out_p = out_f.name
-                    print(f"--- [v159] 🔊 XTTS INFERENCE (CPU) ---")
+                    print(f"--- [v160] 🔊 XTTS INFERENCE (CPU) ---")
                     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()
@@ -174,20 +174,20 @@ async def handle_process(request: Request):
             return {"text": stt_text, "translated": trans_text, "audio": audio_b64}
 
     except Exception as e:
-        print(f"❌ [v159] HERO ERROR: {traceback.format_exc()}")
+        print(f"❌ [v160] HERO ERROR: {traceback.format_exc()}")
         return {"error": str(e)}
     finally:
-        print(f"--- [v159] ✨ DONE ({time.time()-t1:.1f}s) ---")
+        print(f"--- [v160] ✨ 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": "159", "mode": "HERO_STABLE", "gpu": torch.cuda.is_available()}
+def health(): return {"status": "ok", "v": "160", "mode": "HERO_STABLE", "gpu": torch.cuda.is_available()}
 
 @app.get("/", response_class=HTMLResponse)
-def root(): return "<h1>🚀 AI Engine v159 (HERO STABLE)</h1>"
+def root(): return "<h1>🚀 AI Engine v160 (HERO STABLE)</h1>"
 
 if __name__ == "__main__":
     uvicorn.run(app, host="0.0.0.0", port=7860)