Upload app.py with huggingface_hub

app.py

@@ -1,4 +1,6 @@
 from fastapi import FastAPI, Request, Response
+from fastapi.middleware.cors import CORSMiddleware
+from contextlib import asynccontextmanager
 import gradio as gr
 import uvicorn
 import base64
@@ -16,7 +18,7 @@ import logging
 from threading import Thread, Lock
 from huggingface_hub import snapshot_download
 
-# 🛡️ 1. SILENCE LOGS & WARNINGS (v103: Mission-Critical Stability)
+# 🛡️ 1. SILENCE LOGS & WARNINGS (v104: Extreme Stability & Precedence)
 logging.getLogger("transformers").setLevel(logging.ERROR)
 logging.getLogger("TTS").setLevel(logging.ERROR)
 logging.getLogger("onnxruntime").setLevel(logging.ERROR)
@@ -79,8 +81,8 @@ except ImportError:
             if f is None: return lambda x: x
             return f
 
-# FORCE BUILD TRIGGER: 13:25:00 Jan 21 2026
-# v103: Gradio Blocking Launch. ZeroGPU Ready. CPU Health Fix.
+# FORCE BUILD TRIGGER: 13:35:00 Jan 21 2026
+# v104: FastAPI-First Precedence. Fix 405 error. ZeroGPU Unified.
 
 os.environ["COQUI_TOS_AGREED"] = "1"
 MODELS = {"stt": None, "translate": None, "tts": None, "denoiser": None}
@@ -89,7 +91,7 @@ WARMUP_STATUS = {"complete": False, "in_progress": False}
 WARMUP_LOCK = Lock()
 
 def activate_gpu_models(action):
-    """v103: Stability-First Activation"""
+    """v104: Stability Milestone Activation"""
     global MODELS, WARMUP_STATUS
     local_only = WARMUP_STATUS["complete"]
     
@@ -98,7 +100,7 @@ def activate_gpu_models(action):
         try: stt_on_gpu = MODELS["stt"] is not None and MODELS["stt"].model.device == "cuda"
         except: pass
         if not stt_on_gpu:
-            print(f"🎙️ [v103] Activating Whisper (GPU: 1-Worker Stability)...")
+            print(f"🎙️ [v104] Activating Whisper (GPU)...")
             try:
                 if MODELS["stt"]: del MODELS["stt"]
                 gc.collect(); torch.cuda.empty_cache()
@@ -120,7 +122,7 @@ 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"🔊 [v103] Activating XTTS-v2 (GPU)...")
+            print(f"🔊 [v104] Activating XTTS-v2 (GPU)...")
             try:
                 if MODELS["tts"] is None:
                     MODELS["tts"] = TTS(model_name="tts_models/multilingual/multi-dataset/xtts_v2", gpu=True)
@@ -135,9 +137,9 @@ def activate_gpu_models(action):
     if MODELS["translate"] is None: MODELS["translate"] = "active"
 
 def release_gpu_models():
-    """v103: RAM Cleanup"""
+    """v104: Resident RAM Protocol"""
     global MODELS
-    print("🧹 [v103] Releasing GPU resources.")
+    print("🧹 [v104] Releasing GPU resources.")
     try:
         if MODELS["stt"] and MODELS["stt"].model.device == "cuda":
             del MODELS["stt"]
@@ -151,18 +153,18 @@ def release_gpu_models():
     if torch.cuda.is_available(): torch.cuda.empty_cache()
 
 def warmup_task():
-    """Silent Warmup (v103)"""
+    """Silent Warmup (v104)"""
     global WARMUP_STATUS
     with WARMUP_LOCK:
         if WARMUP_STATUS["complete"] or WARMUP_STATUS["in_progress"]: return
         WARMUP_STATUS["in_progress"] = True
-    print("\n🔥 --- V103: UNIFIED WARMUP STARTED ---")
+    print("\n🔥 --- V104: PRECEDENCE 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: v103 --- \n")
+        print(f"✅ --- SYSTEM READY: v104 --- \n")
     except: pass
     finally: WARMUP_STATUS["in_progress"] = False
 
@@ -214,7 +216,7 @@ def _tts_logic(text, lang, speaker_wav_b64):
 def core_process(request_dict):
     action = request_dict.get("action")
     t1 = time.time()
-    print(f"--- [v103] 🚀 GPU SESSION: {action} ---")
+    print(f"--- [v104] 🚀 GPU SESSION: {action} ---")
     activate_gpu_models(action)
     try:
         if action == "stt": res = _stt_logic(request_dict)
@@ -227,27 +229,26 @@ 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"--- [v103] ✨ SUCCESS: {action} ({time.time()-t1:.2f}s) ---")
+        print(f"--- [v104] ✨ SUCCESS: {action} ({time.time()-t1:.2f}s) ---")
         release_gpu_models()
     return res
 
-# 🚀 GRADIO UNIFIED PORT (v103)
-# We mount everything on the Gradio app to avoid "Address already in use"
-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)})
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    Thread(target=warmup_task, daemon=True).start()
+    yield
 
-# Create Gradio interface
-demo = gr.Interface(
-    fn=gradio_fn, 
-    inputs="text", 
-    outputs="text", 
-    title="🚀 AI Engine v103 (ZeroGPU Ready)",
-    description="Backend API with integrated Gradio UI"
+# 🚀 STEP 1: DEFINE THE PRIMARY FASTAPI APP
+app = FastAPI(lifespan=lifespan)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
 )
 
-# 🏥 ADD FASTAPI ROUTES TO GRADIO'S INTERNAL APP
-@demo.app.post("/api/v1/process")
+# 🚀 STEP 2: REGISTER ROUTES ON PRIMARY APP (High Precedence)
+@app.post("/api/v1/process")
 async def api_process(request: Request):
     try:
         req_data = await request.json()
@@ -256,30 +257,34 @@ async def api_process(request: Request):
         return core_process(req_data)
     except Exception as e: return {"error": str(e)}
 
-@demo.app.get("/health")
-def health(): return {"status": "ok", "warm": WARMUP_STATUS["complete"], "v": "103"}
+@app.get("/health")
+def health(): return {"status": "ok", "warm": WARMUP_STATUS["complete"], "v": "104"}
 
-@demo.app.post("/api/v1/clear_cache")
+@app.post("/api/v1/clear_cache")
 async def clear_cache_api():
     try:
         release_gpu_models()
         return {"status": "success"}
     except: return {"status": "error"}
 
-# START WARMUP
-Thread(target=warmup_task, daemon=True).start()
+# 🚀 STEP 3: DEFINE GRADIO INTERFACE
+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)})
+
+demo = gr.Interface(
+    fn=gradio_fn, 
+    inputs="text", 
+    outputs="text", 
+    title="🚀 AI Engine v104"
+)
+
+# 🚀 STEP 4: MOUNT GRADIO ONTO FASTAPI (Low Precedence)
+# This way, our /api/v1/process route is checked BEFORE Gradio handles it.
+app = gr.mount_gradio_app(app, demo, path="/")
 
-# 🚀 FINAL LAUNCH: This keeps the process alive on HF Spaces
+# 🚀 STEP 5: FINAL LAUNCH
 if __name__ == "__main__":
-    print("🚀 [v103] Starting Engine...")
-    try:
-        demo.launch(server_name="0.0.0.0", server_port=7860, show_api=False)
-    except Exception as e:
-        print(f"⚠️ Launch failed (possibly handled by SDK): {e}")
-        # Final keep-alive if launch() returned instantly
-        while True: time.sleep(100)
-else:
-    # If imported by HF SDK wrapper
-    try:
-        demo.launch(server_name="0.0.0.0", server_port=7860, show_api=False, prevent_thread_lock=True)
-    except: pass
+    print("🚀 [v104] Starting Unified Server on Port 7860...")
+    # Using uvicorn on the unified app instance.
+    uvicorn.run(app, host="0.0.0.0", port=7860, log_level="error")