Upload app.py with huggingface_hub

app.py

@@ -1,6 +1,4 @@
 from fastapi import FastAPI, Request, Response
-from fastapi.responses import StreamingResponse
-from contextlib import asynccontextmanager
 import gradio as gr
 import uvicorn
 import base64
@@ -18,7 +16,7 @@ import logging
 from threading import Thread, Lock
 from huggingface_hub import snapshot_download
 
-# 🛡️ 1. SILENCE LOGS & WARNINGS (v102: Mission-Critical Silence & Stability)
+# 🛡️ 1. SILENCE LOGS & WARNINGS (v103: Mission-Critical Stability)
 logging.getLogger("transformers").setLevel(logging.ERROR)
 logging.getLogger("TTS").setLevel(logging.ERROR)
 logging.getLogger("onnxruntime").setLevel(logging.ERROR)
@@ -81,8 +79,8 @@ except ImportError:
             if f is None: return lambda x: x
             return f
 
-# FORCE BUILD TRIGGER: 13:16:00 Jan 21 2026
-# v102: Gradio SDK Restoration. Synchronized Port Binding.
+# FORCE BUILD TRIGGER: 13:25:00 Jan 21 2026
+# v103: Gradio Blocking Launch. ZeroGPU Ready. CPU Health Fix.
 
 os.environ["COQUI_TOS_AGREED"] = "1"
 MODELS = {"stt": None, "translate": None, "tts": None, "denoiser": None}
@@ -91,7 +89,7 @@ WARMUP_STATUS = {"complete": False, "in_progress": False}
 WARMUP_LOCK = Lock()
 
 def activate_gpu_models(action):
-    """v102: Mission-Critical GPU Mode"""
+    """v103: Stability-First Activation"""
     global MODELS, WARMUP_STATUS
     local_only = WARMUP_STATUS["complete"]
     
@@ -100,7 +98,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"🎙️ [v102] Activating Whisper (GPU)...")
+            print(f"🎙️ [v103] Activating Whisper (GPU: 1-Worker Stability)...")
             try:
                 if MODELS["stt"]: del MODELS["stt"]
                 gc.collect(); torch.cuda.empty_cache()
@@ -112,7 +110,7 @@ def activate_gpu_models(action):
                     local_files_only=local_only
                 )
             except Exception as e:
-                print(f"⚠️ GPU Init failed: {e}. Falling back to CPU in-RAM.")
+                print(f"⚠️ GPU Init failed: {e}")
                 MODELS["stt"] = WhisperModel("large-v3", device="cpu", compute_type="int8", local_files_only=True)
 
     if action in ["tts", "s2st"]:
@@ -122,7 +120,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"🔊 [v102] Activating XTTS-v2 (GPU)...")
+            print(f"🔊 [v103] Activating XTTS-v2 (GPU)...")
             try:
                 if MODELS["tts"] is None:
                     MODELS["tts"] = TTS(model_name="tts_models/multilingual/multi-dataset/xtts_v2", gpu=True)
@@ -137,9 +135,9 @@ def activate_gpu_models(action):
     if MODELS["translate"] is None: MODELS["translate"] = "active"
 
 def release_gpu_models():
-    """v102: Clean Resident State"""
+    """v103: RAM Cleanup"""
     global MODELS
-    print("🧹 [v102] Releasing GPU resources.")
+    print("🧹 [v103] Releasing GPU resources.")
     try:
         if MODELS["stt"] and MODELS["stt"].model.device == "cuda":
             del MODELS["stt"]
@@ -153,20 +151,19 @@ def release_gpu_models():
     if torch.cuda.is_available(): torch.cuda.empty_cache()
 
 def warmup_task():
-    """Silent Pre-loading (v102)"""
+    """Silent Warmup (v103)"""
     global WARMUP_STATUS
     with WARMUP_LOCK:
         if WARMUP_STATUS["complete"] or WARMUP_STATUS["in_progress"]: return
         WARMUP_STATUS["in_progress"] = True
-    print("\n🔥 --- V102: GRADIO SYNC WARMUP STARTED ---")
+    print("\n🔥 --- V103: UNIFIED 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 WARM: v102 --- \n")
-    except Exception as e:
-        print(f"❌ Warmup fail: {e}")
+        print(f"✅ --- SYSTEM READY: v103 --- \n")
+    except: pass
     finally: WARMUP_STATUS["in_progress"] = False
 
 def _stt_logic(request_dict):
@@ -217,7 +214,7 @@ def _tts_logic(text, lang, speaker_wav_b64):
 def core_process(request_dict):
     action = request_dict.get("action")
     t1 = time.time()
-    print(f"--- [v102] 🚀 GPU SESSION: {action} ---")
+    print(f"--- [v103] 🚀 GPU SESSION: {action} ---")
     activate_gpu_models(action)
     try:
         if action == "stt": res = _stt_logic(request_dict)
@@ -230,19 +227,27 @@ 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"--- [v102] ✨ SUCCESS: {action} ({time.time()-t1:.2f}s) ---")
+        print(f"--- [v103] ✨ SUCCESS: {action} ({time.time()-t1:.2f}s) ---")
         release_gpu_models()
     return res
 
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    # GRADIO MANAGED LIFECYCLE
-    Thread(target=warmup_task, daemon=True).start()
-    yield
+# 🚀 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)})
 
-app = FastAPI(lifespan=lifespan)
+# 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"
+)
 
-@app.post("/api/v1/process")
+# 🏥 ADD FASTAPI ROUTES TO GRADIO'S INTERNAL APP
+@demo.app.post("/api/v1/process")
 async def api_process(request: Request):
     try:
         req_data = await request.json()
@@ -251,33 +256,30 @@ async def api_process(request: Request):
         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"], "v": "102"}
+@demo.app.get("/health")
+def health(): return {"status": "ok", "warm": WARMUP_STATUS["complete"], "v": "103"}
 
-@app.post("/api/v1/clear_cache")
-async def clear_cache():
+@demo.app.post("/api/v1/clear_cache")
+async def clear_cache_api():
     try:
         release_gpu_models()
-        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))
-                except: pass
         return {"status": "success"}
     except: return {"status": "error"}
 
-# 🚀 V102: SYNCHRONIZED ENTRY POINT
-# We mount everything into Gradio and let the SDK handle the binding.
-demo = gr.Interface(
-    fn=lambda x: json.dumps(core_process(json.loads(x))), 
-    inputs="text", 
-    outputs="text",
-    title="🚀 AI Engine v102"
-)
-
-# Use gr.mount_gradio_app to merge FastAPI and Gradio.
-# The Hugging Face Gradio SDK will automatically detect and launch the mounted app.
-app = gr.mount_gradio_app(app, demo, path="/")
+# START WARMUP
+Thread(target=warmup_task, daemon=True).start()
 
-# No uvicorn.run here! The Hugging Face Gradio launcher handles it.
-# This prevents the "Address already in use" error.
+# 🚀 FINAL LAUNCH: This keeps the process alive on HF Spaces
+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