Upload app.py with huggingface_hub

app.py

@@ -10,21 +10,34 @@ from fastapi import FastAPI, Request
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import HTMLResponse
 
-# --- [v158] 🚀 ULTRA STABLE ENGINE ---
-# This version fixes the TorchCodec/torchaudio dependency hell on H200 ZeroGPU
-print(f"--- [v158] 📡 BOOTING ENGINE ---")
+# --- [v159] 🚀 HERO STABILITY ENGINE (FINAL MISSION) ---
+print(f"--- [v159] 📡 BOOTING ENGINE ---")
 
-# 🛠️ MONKEYPATCH torchaudio BEFORE XTTS LOADING 🛠️
+# 🛠️ CRITICAL: TORCHAUDIO MONKEYPATCH 🛠️
+# This bypasses the 'torchcodec' ModuleNotFoundError on Hugging Face Spaces.
 import torchaudio
-import librosa
-def stable_load(filepath, **kwargs):
-    # Redirect torchaudio.load to librosa to bypass torchcodec issues
-    # Coqui XTTS usually passes sr as a keyword or positional argument
-    target_sr = kwargs.get("sample_rate") or kwargs.get("sr") or None
-    y, sr = librosa.load(filepath, sr=target_sr)
-    return torch.from_numpy(y).unsqueeze(0), sr
-torchaudio.load = stable_load
-print("--- [v158] 🩹 TORCHAUDIO PATCH APPLIED ---")
+import soundfile as sf
+import numpy as np
+
+defHeroLoad(filepath, **kwargs):
+    """Robust alternative to torchaudio.load using soundfile."""
+    try:
+        data, samplerate = sf.read(filepath)
+        # Convert to float32 and ensure shape is (channels, samples)
+        if len(data.shape) == 1:
+            data = data.reshape(1, -1)
+        else:
+            data = data.T # (samples, channels) -> (channels, samples)
+        return torch.from_numpy(data).float(), samplerate
+    except Exception as e:
+        print(f"--- [v159] ❌ PATCHED LOAD FAILED: {e} ---")
+        # Fallback to original if soundfile fails (unlikely)
+        return torchaudio.load_orig(filepath, **kwargs)
+
+if not hasattr(torchaudio, 'load_orig'):
+    torchaudio.load_orig = torchaudio.load
+    torchaudio.load = HeroLoad
+    print("--- [v159] 🩹 TORCHAUDIO HERO PATCH APPLIED (soundfile) ---")
 
 from transformers import pipeline, AutoModelForSpeechSeq2Seq, AutoProcessor
 from TTS.api import TTS
@@ -59,15 +72,16 @@ MODELS = {"stt": None, "tts": None}
 def load_tts_cpu():
     global MODELS
     if MODELS.get("tts") is None:
-        print("--- [v158] 📥 LOADING XTTS V2 (CPU) ---")
+        print("--- [v159] 📥 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("--- [v158] ✅ XTTS READY (CPU) ---")
+        print("--- [v159] ✅ XTTS READY (CPU) ---")
 
 @spaces.GPU(duration=60)
 def gpu_stt_base(temp_path, lang):
     global MODELS
     if MODELS.get("stt") is None:
-        print("--- [v158] 📥 LOADING WHISPER (Base) ON GPU ---")
+        print("--- [v159] 📥 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)
@@ -78,6 +92,7 @@ def gpu_stt_base(temp_path, lang):
             feature_extractor=processor.feature_extractor,
             device="cuda"
         )
+    print(f"--- [v159] 🎙️ RUNNING WHISPER INFERENCE ---")
     res = MODELS["stt"](temp_path, generate_kwargs={"language": lang if lang and len(lang) <= 3 else None})
     return res["text"].strip()
 
@@ -86,30 +101,41 @@ async def handle_process(request: Request):
     try:
         data = await request.json()
         action = data.get("action")
-        if action == "health": return {"status": "awake", "v": "158"}
+        if action == "health": return {"status": "awake", "v": "159"}
         
-        print(f"--- [v158] 🛠️ {action} ---")
+        print(f"--- [v159] 🛠️ {action.upper()} REQUESTED ---")
         
+        # 🟢 STT PATH
         stt_text = ""
         if action in ["stt", "s2st"]:
-            audio_bytes = base64.b64decode(data.get("file"))
+            audio_b64 = data.get("file")
+            if not audio_b64: return {"error": "Missing audio file"}
+            
+            audio_bytes = base64.b64decode(audio_b64)
             with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
-                f.write(audio_bytes); temp_path = f.name
+                f.write(audio_bytes)
+                temp_path = f.name
             try:
                 stt_text = gpu_stt_base(temp_path, data.get("lang"))
+                print(f"--- [v159] 🎙️ TRANSCRIPT: {stt_text} ---")
             finally:
                 if os.path.exists(temp_path): os.unlink(temp_path)
+            
             if action == "stt": return {"text": stt_text}
 
+        # 🔵 TTS PATH
         if action in ["tts", "s2st"]:
-            load_tts_cpu()
             text = (data.get("text") if action == "tts" else stt_text).strip()
+            if not text: return {"error": "Input text is empty"}
+            
             trans_text = text
             target = data.get("target_lang") or data.get("lang") or "en"
             
             if action == "s2st":
+                print(f"--- [v159] 🌏 TRANSLATING TO {target} ---")
                 trans_text = GoogleTranslator(source='auto', target=target).translate(stt_text)
                 text = trans_text
+                print(f"--- [v159] 📝 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()
@@ -117,23 +143,29 @@ async def handle_process(request: Request):
             
             if not mapped_lang:
                 if HAS_CHATTERBOX:
+                    print(f"--- [v159] 📦 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"}
             else:
+                load_tts_cpu()
                 speaker_wav_b64 = data.get("speaker_wav")
                 speaker_path = None
                 if speaker_wav_b64:
                     with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
-                        f.write(base64.b64decode(speaker_wav_b64)); speaker_path = f.name
+                        f.write(base64.b64decode(speaker_wav_b64))
+                        speaker_path = f.name
                 else:
                     speaker_path = "default_speaker.wav"
                     if not os.path.exists(speaker_path): speaker_path = None
                 
                 try:
-                    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as out_f: out_p = out_f.name
+                    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as out_f:
+                        out_p = out_f.name
+                    print(f"--- [v159] 🔊 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()
+                    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)
@@ -142,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"❌ [v158] ERROR: {traceback.format_exc()}")
+        print(f"❌ [v159] HERO ERROR: {traceback.format_exc()}")
         return {"error": str(e)}
     finally:
-        print(f"--- [v158] ✨ DONE ({time.time()-t1:.1f}s) ---")
+        print(f"--- [v159] ✨ 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": "158", "gpu": torch.cuda.is_available()}
+def health(): return {"status": "ok", "v": "159", "mode": "HERO_STABLE", "gpu": torch.cuda.is_available()}
 
 @app.get("/", response_class=HTMLResponse)
-def root(): return "<h1>🚀 AI Engine v158 (ULTRA STABLE)</h1>"
+def root(): return "<h1>🚀 AI Engine v159 (HERO STABLE)</h1>"
 
 if __name__ == "__main__":
     uvicorn.run(app, host="0.0.0.0", port=7860)