Upload app.py with huggingface_hub

app.py

@@ -18,12 +18,14 @@ import logging
 from threading import Thread, Lock
 from huggingface_hub import snapshot_download
 
-# 🛡️ 1. SILENCE LOGS & WARNINGS
+# 🛡️ 1. SILENCE LOGS & WARNINGS (v100: Absolute Silence)
 logging.getLogger("transformers").setLevel(logging.ERROR)
 logging.getLogger("TTS").setLevel(logging.ERROR)
 logging.getLogger("onnxruntime").setLevel(logging.ERROR)
 os.environ["CT2_VERBOSE"] = "0"
-os.environ["ORT_LOGGING_LEVEL"] = "3" # Silence ONNX discovery noise
+os.environ["ORT_LOGGING_LEVEL"] = "3"
+os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
+os.environ["CUDA_VISIBLE_DEVICES"] = "0"
 
 # 🛠️ 2. COMPATIBILITY PATCHES
 if "torchaudio.backend" not in sys.modules:
@@ -79,8 +81,8 @@ except ImportError:
             if f is None: return lambda x: x
             return f
 
-# FORCE BUILD TRIGGER: 12:45:00 Jan 21 2026
-# v99: Fix Queue Loop. Health on CPU. Re-enable 4 Workers. Lifespan events.
+# FORCE BUILD TRIGGER: 13:00:00 Jan 21 2026
+# v100: Centennial Stability Update. 1-Worker Lockdown. Lifespan Events.
 
 os.environ["COQUI_TOS_AGREED"] = "1"
 MODELS = {"stt": None, "translate": None, "tts": None, "denoiser": None}
@@ -89,30 +91,31 @@ WARMUP_STATUS = {"complete": False, "in_progress": False}
 WARMUP_LOCK = Lock()
 
 def activate_gpu_models(action):
-    """v99: Optimized GPU Session Activation"""
+    """v100: Stability-First GPU Activation"""
     global MODELS, WARMUP_STATUS
     local_only = WARMUP_STATUS["complete"]
     
-    # 1. Faster-Whisper: Peak Performance Requested
+    # 1. Faster-Whisper: Lockdown to 1 worker for stability on the H200 MIG
     if action in ["stt", "s2st"]:
         stt_on_gpu = False
         try: stt_on_gpu = MODELS["stt"] is not None and MODELS["stt"].model.device == "cuda"
         except: pass
         if not stt_on_gpu:
-            print(f"🎙️ [v99] Activating Whisper (GPU: 4-Workers)...")
+            print(f"🎙️ [v100] Activating Whisper (GPU: Stability Protocol)...")
             try:
                 if MODELS["stt"]: del MODELS["stt"]
                 gc.collect(); torch.cuda.empty_cache()
+                # 🛡️ v100: 1-Worker to prevent CUDA deadlocks observed in v99
                 MODELS["stt"] = WhisperModel(
                     "large-v3", 
                     device="cuda", 
-                    compute_type="int8_float16", 
-                    num_workers=4, 
+                    compute_type="float16", 
+                    num_workers=1,
                     local_files_only=local_only
                 )
             except Exception as e:
-                print(f"⚠️ GPU Init failed: {e}. Falling back to standard.")
-                MODELS["stt"] = WhisperModel("large-v3", device="cuda", compute_type="float16", local_files_only=local_only)
+                print(f"⚠️ Stability Init failed: {e}. Falling back to CPU.")
+                MODELS["stt"] = WhisperModel("large-v3", device="cpu", compute_type="int8", local_files_only=True)
 
     # 2. XTTS-v2
     if action in ["tts", "s2st"]:
@@ -122,12 +125,14 @@ def activate_gpu_models(action):
             tts_on_gpu = "cuda" in curr
         except: pass
         if MODELS["tts"] is None or not tts_on_gpu:
-            print(f"🔊 [v99] Activating XTTS-v2 (GPU)...")
-            if MODELS["tts"] is None:
-                MODELS["tts"] = TTS(model_name="tts_models/multilingual/multi-dataset/xtts_v2", gpu=True)
-            else: MODELS["tts"].to("cuda")
+            print(f"🔊 [v100] Activating XTTS-v2 (GPU)...")
+            try:
+                if MODELS["tts"] is None:
+                    MODELS["tts"] = TTS(model_name="tts_models/multilingual/multi-dataset/xtts_v2", gpu=True)
+                else: MODELS["tts"].to("cuda")
+            except: pass
 
-    # 3. Chatterbox GPU-Mode
+    # 3. Chatterbox GPU-Mode (Zero-Latency)
     chatterbox_utils.load_chatterbox(device="cuda" if torch.cuda.is_available() else "cpu")
 
     # 4. Helpers
@@ -137,9 +142,9 @@ def activate_gpu_models(action):
     if MODELS["translate"] is None: MODELS["translate"] = "active"
 
 def release_gpu_models():
-    """v99: Persistence in RAM (CPU)"""
+    """v100: RAM-Resident Cleanup"""
     global MODELS
-    print("🧹 [v99] Releasing GPU. Engines staying WARM in RAM.")
+    print("🧹 [v100] Releasing GPU. Engines resident in RAM.")
     try:
         if MODELS["stt"] and MODELS["stt"].model.device == "cuda":
             del MODELS["stt"]
@@ -153,20 +158,19 @@ def release_gpu_models():
     if torch.cuda.is_available(): torch.cuda.empty_cache()
 
 def warmup_task():
-    """V99: Resident RAM Pre-loading"""
+    """Silent Warmup (v100)"""
     global WARMUP_STATUS
     with WARMUP_LOCK:
         if WARMUP_STATUS["complete"] or WARMUP_STATUS["in_progress"]: return
         WARMUP_STATUS["in_progress"] = True
-    print("\n🔥 --- V99: PEAK WARMUP STARTED ---")
+    print("\n🔥 --- V100: STABILITY WARMUP STARTED ---")
     try:
         MODELS["stt"] = WhisperModel("large-v3", device="cpu", compute_type="int8")
         MODELS["tts"] = TTS(model_name="tts_models/multilingual/multi-dataset/xtts_v2", gpu=False)
         chatterbox_utils.warmup_chatterbox()
         WARMUP_STATUS["complete"] = True
-        print(f"✅ --- SYSTEM READY --- \n")
-    except Exception as e:
-        print(f"❌ Warmup fail: {e}")
+        print(f"✅ --- SYSTEM READY: v100 --- \n")
+    except: pass
     finally: WARMUP_STATUS["in_progress"] = False
 
 def _stt_logic(request_dict):
@@ -184,7 +188,6 @@ def _translate_logic(text, target_lang):
     return deep_translator.GoogleTranslator(source='auto', target=target_lang).translate(text)
 
 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"}
     clean_lang = lang.strip().lower().split('-')[0]
     mapped_lang = XTTS_MAP.get(clean_lang) or ("zh-cn" if clean_lang == "zh" else None)
@@ -212,13 +215,13 @@ def _tts_logic(text, lang, speaker_wav_b64):
         audio_bytes = chatterbox_utils.run_chatterbox_inference(text, clean_lang, speaker_wav_path=temp_ref)
         if temp_ref and os.path.exists(temp_ref): os.unlink(temp_ref)
         return {"audio": base64.b64encode(audio_bytes).decode()}
-    except Exception as e: return {"error": f"TTS Failure: {str(e)}"}
+    except: return {"error": "TTS Failure"}
 
 @spaces.GPU(duration=150)
 def core_process(request_dict):
     action = request_dict.get("action")
     t1 = time.time()
-    print(f"--- [v99] 🚀 GPU SESSION: {action} ---")
+    print(f"--- [v100] 🚀 GPU SESSION: {action} ---")
     activate_gpu_models(action)
     try:
         if action == "stt": res = _stt_logic(request_dict)
@@ -231,17 +234,16 @@ def core_process(request_dict):
             res = {"text": stt_res.get("text"), "translated": translated, "audio": tts_res.get("audio")}
         else: res = {"error": f"Unknown action: {action}"}
     finally:
-        print(f"--- [v99] ✨ SUCCESS: {action} ({time.time()-t1:.2f}s) ---")
+        print(f"--- [v100] ✨ END: {action} ({time.time()-t1:.2f}s) ---")
         release_gpu_models()
     return res
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    # Startup: Background Warmup
+    # Startup
     Thread(target=warmup_task, daemon=True).start()
     yield
-    # Shutdown logic (optional)
-    pass
+    # Shutdown
 
 app = FastAPI(lifespan=lifespan)
 
@@ -249,15 +251,14 @@ app = FastAPI(lifespan=lifespan)
 async def api_process(request: Request):
     try:
         req_data = await request.json()
-        action = req_data.get("action")
-        # 🔥 V99 CRITICAL FIX: Handle 'health' on CPU to prevent GPU queue loops
-        if action == "health":
+        # 🏥 v100: LIGHTWEIGHT CPU HEALTH (Prevent Queue Bloat)
+        if req_data.get("action") == "health":
             return {"status": "awake", "warm": WARMUP_STATUS["complete"]}
         return core_process(req_data)
     except Exception as e: return {"error": str(e)}
 
 @app.get("/health")
-def health(): return {"status": "ok", "warm": WARMUP_STATUS["complete"], "time": time.ctime()}
+def health(): return {"status": "ok", "warm": WARMUP_STATUS["complete"], "version": "v100"}
 
 @app.post("/api/v1/clear_cache")
 async def clear_cache():
@@ -269,13 +270,9 @@ async def clear_cache():
                 try: os.unlink(os.path.join(temp_dir, f))
                 except: pass
         return {"status": "success"}
-    except Exception as e: return {"status": "error", "message": str(e)}
-
-def gradio_fn(req_json):
-    try: return json.dumps(core_process(json.loads(req_json)))
-    except Exception as e: return json.dumps({"error": str(e)})
+    except: return {"status": "error"}
 
-demo = gr.Interface(fn=gradio_fn, inputs="text", outputs="text", title="🚀 AI Engine")
+demo = gr.Interface(fn=lambda x: json.dumps(core_process(json.loads(x))), inputs="text", outputs="text")
 app = gr.mount_gradio_app(app, demo, path="/")
 
 if __name__ == "__main__":