Upload app.py with huggingface_hub

app.py

@@ -14,16 +14,12 @@ import gc
 import sys
 import types
 
-# 🛠️ 1. CRITICAL COMPATIBILITY MONKEYPATCHES (v89)
-# These MUST happen before importing df (DeepFilterNet) or other audio tools
+# 🛠️ 1. CRITICAL COMPATIBILITY MONKEYPATCHES
 print("🛠️ Applying compatibility monkeypatches...")
-
-# Patch torchaudio.backend for DeepFilterNet
 if "torchaudio.backend" not in sys.modules:
     backend = types.ModuleType("torchaudio.backend")
     common = types.ModuleType("torchaudio.backend.common")
-    try:
-        common.AudioMetaData = torchaudio.AudioMetaData
+    try: common.AudioMetaData = torchaudio.AudioMetaData
     except AttributeError:
         class AudioMetaData: pass
         common.AudioMetaData = AudioMetaData
@@ -31,30 +27,20 @@ if "torchaudio.backend" not in sys.modules:
     sys.modules["torchaudio.backend"] = backend
     sys.modules["torchaudio.backend.common"] = common
 
-# Mock torchaudio.info
 if not hasattr(torchaudio, "info"):
     def mock_info(filepath, **kwargs):
         from types import SimpleNamespace
         import wave
         try:
             with wave.open(filepath, "rb") as f:
-                return SimpleNamespace(
-                    sample_rate=f.getframerate(),
-                    num_frames=f.getnframes(),
-                    num_channels=f.getnchannels(),
-                    bits_per_sample=f.getsampwidth() * 8,
-                    encoding="PCM_S"
-                )
-        except:
-             return SimpleNamespace(sample_rate=48000, num_frames=0, num_channels=1)
+                return SimpleNamespace(sample_rate=f.getframerate(), num_frames=f.getnframes(), num_channels=f.getnchannels(), bits_per_sample=f.getsampwidth() * 8, encoding="PCM_S")
+        except: return SimpleNamespace(sample_rate=48000, num_frames=0, num_channels=1)
     torchaudio.info = mock_info
 
-# Patch torchaudio.load
 try:
     _orig_load = torchaudio.load
     def patched_load(filepath, *args, **kwargs):
-        try:
-            return _orig_load(filepath, *args, **kwargs)
+        try: return _orig_load(filepath, *args, **kwargs)
         except ImportError as e:
             if "torchcodec" in str(e).lower():
                 import soundfile as sf
@@ -66,11 +52,10 @@ try:
             raise e
     torchaudio.load = patched_load
     print("✅ Torchaudio patched")
-except Exception as e:
-    print(f"⚠️ Patch failed: {e}")
+except Exception as e: print(f"⚠️ Patch failed: {e}")
 
-# 📦 2. BULKY IMPORTS (After patches)
-print("📦 Pre-loading AI Engines...")
+# 📦 2. PRE-LOADING (v90 Optimization)
+print("📦 Pre-loading AI Engines into RAM...")
 import chatterbox_utils
 from faster_whisper import WhisperModel
 from TTS.api import TTS
@@ -78,7 +63,6 @@ from df.enhance import init_df, enhance, load_audio, save_audio
 import deep_translator
 print("✅ Imports Complete")
 
-# 🛡️ ZeroGPU Support
 try:
     import spaces
     print("✅ ZeroGPU/Spaces detected")
@@ -89,23 +73,46 @@ except ImportError:
             if f is None: return lambda x: x
             return f
 
-# FORCE BUILD TRIGGER: 10:45:00 Jan 21 2026
-# v89: Fixed Import Order (Resolved ModuleNotFoundError)
+# FORCE BUILD TRIGGER: 10:55:00 Jan 21 2026
+# v90: Fixed Whisper CUDA 'Invalid Argument' crash. (Cleaner GPU Handoff)
 
 os.environ["COQUI_TOS_AGREED"] = "1"
-
-# Global models (Resident in System RAM)
 MODELS = {"stt": None, "translate": None, "tts": None, "denoiser": None}
 
 def activate_gpu_models(action):
-    """Fast GPU Activation"""
+    """v90: Optimized GPU Activation with clean handoff"""
     global MODELS
     
     # 1. Faster-Whisper GPU Activation
     if action in ["stt", "s2st"]:
-        if MODELS["stt"] is None or MODELS["stt"].model.device != "cuda":
+        stt_on_gpu = False
+        try:
+            if MODELS["stt"] is not None and hasattr(MODELS["stt"], "model") and MODELS["stt"].model.device == "cuda":
+                stt_on_gpu = True
+        except: pass
+
+        if not stt_on_gpu:
             print(f"🎙️ Activating Whisper on GPU for {action}...")
-            MODELS["stt"] = WhisperModel("large-v3", device="cuda", compute_type="float16")
+            # 🧹 CRITICAL: Clear old instance to avoid "Invalid Argument" CUDA errors
+            old_stt = MODELS.pop("stt", None)
+            if old_stt: del old_stt
+            gc.collect()
+            if torch.cuda.is_available(): torch.cuda.empty_cache()
+            
+            # Re-init on GPU with safe parameters for ZeroGPU MIG
+            try:
+                MODELS["stt"] = WhisperModel(
+                    "large-v3", 
+                    device="cuda", 
+                    device_index=0, 
+                    compute_type="int8_float16", # Better stability on H100/H200 MIG
+                    cpu_threads=4,
+                    num_workers=1
+                )
+                print("✨ Whisper Activated on GPU")
+            except Exception as e:
+                print(f"❌ Whisper GPU fail: {e}. Falling back to CPU in-session.")
+                MODELS["stt"] = WhisperModel("large-v3", device="cpu", compute_type="int8")
 
     # 2. XTTS-v2 GPU Activation
     if action in ["tts", "s2st"]:
@@ -116,36 +123,27 @@ def activate_gpu_models(action):
             if "cuda" not in current_dev:
                 print(f"🚀 Moving XTTS-v2 to GPU...")
                 MODELS["tts"].to("cuda")
-        except:
-             MODELS["tts"].to("cuda")
+        except: MODELS["tts"].to("cuda")
 
-    # 3. Denoiser & Translate
+    # 3. Helpers
     if MODELS["denoiser"] is None:
         try: MODELS["denoiser"] = init_df()
         except: pass
-    if MODELS["translate"] is None: 
-        MODELS["translate"] = "active"
-    
+    if MODELS["translate"] is None: MODELS["translate"] = "active"
     chatterbox_utils.load_chatterbox(device="cuda" if torch.cuda.is_available() else "cpu")
-    gc.collect()
-    if torch.cuda.is_available(): torch.cuda.empty_cache()
 
 def warmup_models():
-    """PRE-LOAD MODELS INTO SYSTEM RAM (CPU)"""
-    print("\n🔥 --- SYSTEM STARTUP: RAM LOADING (v89) ---")
+    """PRE-LOAD MODELS INTO SYSTEM RAM"""
+    print("\n🔥 --- SYSTEM STARTUP: RAM LOADING (v90) ---")
     start = time.time()
     try:
-        print("📥 Pre-loading Whisper to RAM...")
         MODELS["stt"] = WhisperModel("large-v3", device="cpu", compute_type="int8")
-        print("📥 Pre-loading XTTS-v2 to RAM...")
         MODELS["tts"] = TTS(model_name="tts_models/multilingual/multi-dataset/xtts_v2", gpu=False)
-        print("📥 Pre-loading DeepFilterNet...")
         try: MODELS["denoiser"] = init_df()
         except: pass
         chatterbox_utils.warmup_chatterbox()
         print(f"✅ --- SYSTEM READY ({time.time()-start:.2f}s) --- \n")
-    except Exception as e:
-        print(f"⚠️ Startup warning: {e}")
+    except Exception as e: print(f"⚠️ Startup warning: {e}")
 
 def _stt_logic(request_dict):
     audio_bytes = base64.b64decode(request_dict.get("file"))
@@ -154,8 +152,7 @@ def _stt_logic(request_dict):
         f.write(audio_bytes); temp_path = f.name
     try:
         segments, _ = MODELS["stt"].transcribe(temp_path, language=lang, beam_size=1)
-        text = " ".join([s.text for s in segments]).strip()
-        return {"text": text}
+        return {"text": " ".join([s.text for s in segments]).strip()}
     finally:
         if os.path.exists(temp_path): os.unlink(temp_path)
 
@@ -165,14 +162,9 @@ def _translate_logic(text, target_lang):
 
 def _tts_logic(text, lang, speaker_wav_b64):
     if not text or not text.strip(): return {"error": "Input empty"}
-    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"
-    }
+    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 = lang.strip().lower().split('-')[0]
     mapped_lang = XTTS_MAP.get(clean_lang) or ("zh-cn" if clean_lang == "zh" else None)
-    
     if mapped_lang:
         speaker_wav_path = None
         if speaker_wav_b64:
@@ -184,12 +176,10 @@ def _tts_logic(text, lang, speaker_wav_b64):
             with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as output_file:
                 output_path = output_file.name
             MODELS["tts"].tts_to_file(text=text, language=mapped_lang, file_path=output_path, speaker_wav=speaker_wav_path)
-            with open(output_path, "rb") as f: audio_b64 = base64.b64encode(f.read()).decode()
-            return {"audio": audio_b64}
+            with open(output_path, "rb") as f: return {"audio": base64.b64encode(f.read()).decode()}
         finally:
             if speaker_wav_path and "default_speaker" not in speaker_wav_path and os.path.exists(speaker_wav_path): os.unlink(speaker_wav_path)
             if 'output_path' in locals() and os.path.exists(output_path): os.unlink(output_path)
-    
     try:
         temp_ref = None
         if speaker_wav_b64:
@@ -205,7 +195,7 @@ def _tts_logic(text, lang, speaker_wav_b64):
 def core_process(request_dict):
     action = request_dict.get("action")
     t0 = time.time()
-    print(f"--- [v89] 🚀 GPU SESSION START: {action} ---")
+    print(f"--- [v90] 🚀 GPU SESSION START: {action} ---")
     activate_gpu_models(action)
     try:
         if action == "stt": res = _stt_logic(request_dict)
@@ -213,29 +203,22 @@ def core_process(request_dict):
         elif action == "tts": res = _tts_logic(request_dict.get("text"), request_dict.get("lang"), request_dict.get("speaker_wav"))
         elif action == "s2st":
             stt_res = _stt_logic({"file": request_dict.get("file"), "lang": request_dict.get("source_lang")})
-            text = stt_res.get("text", "")
-            if not text: return {"error": "No speech detected"}
-            translated = _translate_logic(text, request_dict.get("target_lang"))
+            translated = _translate_logic(stt_res.get("text", ""), request_dict.get("target_lang"))
             tts_res = _tts_logic(translated, request_dict.get("target_lang"), request_dict.get("speaker_wav"))
-            res = {"text": text, "translated": translated, "audio": tts_res.get("audio")}
+            res = {"text": stt_res.get("text"), "translated": translated, "audio": tts_res.get("audio")}
         elif action == "health": res = {"status": "awake"}
         else: res = {"error": f"Unknown action: {action}"}
     finally:
-        print(f"--- [v89] ✨ SESSION END: {action} ({time.time()-t0:.2f}s) ---")
+        print(f"--- [v90] ✨ END: {action} ({time.time()-t0:.2f}s) ---")
         gc.collect()
         if torch.cuda.is_available(): torch.cuda.empty_cache()
     return res
 
 app = FastAPI()
-
 @app.post("/api/v1/process")
 async def api_process(request: Request):
-    try:
-        data = await request.json()
-        return core_process(data)
-    except Exception as e:
-        traceback.print_exc()
-        return {"error": str(e)}
+    try: return core_process(await request.json())
+    except Exception as e: traceback.print_exc(); return {"error": str(e)}
 
 @app.get("/health")
 def health(): return {"status": "ok", "gpu": torch.cuda.is_available(), "time": time.ctime()}
@@ -243,14 +226,14 @@ def health(): return {"status": "ok", "gpu": torch.cuda.is_available(), "time":
 @app.post("/api/v1/clear_cache")
 async def clear_cache():
     try:
-        t0 = time.time(); gc.collect()
+        gc.collect()
         if torch.cuda.is_available(): torch.cuda.empty_cache()
-        temp_dir = tempfile.gettempdir(); count = 0
+        temp_dir = tempfile.gettempdir()
         for f in os.listdir(temp_dir):
             if f.endswith(".wav") or f.startswith("tm"):
-                try: os.unlink(os.path.join(temp_dir, f)); count += 1
+                try: os.unlink(os.path.join(temp_dir, f))
                 except: pass
-        return {"status": "success", "cleaned_files": count}
+        return {"status": "success"}
     except Exception as e: return {"status": "error", "message": str(e)}
 
 def gradio_fn(req_json):