Upload app.py with huggingface_hub

app.py

@@ -1,4 +1,4 @@
-# 🚀 V107: ZEROGPU HARDENING
+# 🚀 V108: ZEROGPU REQUEST-WAIT PROTOCOL
 # Must be first to patch environment correctly
 try:
     import spaces
@@ -10,7 +10,7 @@ except ImportError:
             if f is None: return lambda x: x
             return f
 
-from fastapi import FastAPI, Request, Response
+from fastapi import FastAPI, Request
 from fastapi.middleware.cors import CORSMiddleware
 from contextlib import asynccontextmanager
 import gradio as gr
@@ -19,7 +19,6 @@ import base64
 import torch
 import os
 import tempfile
-import traceback
 import json
 import time
 import torchaudio
@@ -30,16 +29,15 @@ import logging
 from threading import Thread, Lock
 from huggingface_hub import snapshot_download
 
-# 🛡️ 1. SILENCE LOGS & WARNINGS (v107: Stability Milestone)
+# 🛡️ 1. SILENCE & ENV (v108)
 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"
-os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
-os.environ["CUDA_VISIBLE_DEVICES"] = "0"
+os.environ["GRADIO_SERVER_NAME"] = "0.0.0.0"
+os.environ["GRADIO_SERVER_PORT"] = "7860"
 
-# 🛠️ 2. COMPATIBILITY PATCHES
+# 🛠️ 2. COMPATIBILITY PATCHES (v108)
 if "torchaudio.backend" not in sys.modules:
     backend = types.ModuleType("torchaudio.backend")
     common = types.ModuleType("torchaudio.backend.common")
@@ -84,8 +82,8 @@ from TTS.api import TTS
 from df.enhance import init_df
 import deep_translator
 
-# FORCE BUILD TRIGGER: 17:10:00 Jan 21 2026
-# v107: Whisper int8 stability. Gradio 5.9.1.
+# FORCE REBUILD: 17:18:00 Jan 21 2026
+# v108: Rebuilt with full requirements. Wait protocol active.
 
 os.environ["COQUI_TOS_AGREED"] = "1"
 MODELS = {"stt": None, "translate": None, "tts": None, "denoiser": None}
@@ -94,7 +92,7 @@ WARMUP_STATUS = {"complete": False, "in_progress": False}
 WARMUP_LOCK = Lock()
 
 def activate_gpu_models(action):
-    """v107: Safe Hardware Activation"""
+    """v108: Optimized Activation"""
     global MODELS, WARMUP_STATUS
     local_only = WARMUP_STATUS["complete"]
     
@@ -103,19 +101,16 @@ 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"🎙️ [v107] Activating Whisper (GPU: int8 Protocol)...")
+            print(f"🎙️ [v108] Activating Whisper (GPU: int8_float16)...")
             try:
                 if MODELS["stt"]: del MODELS["stt"]
                 gc.collect(); torch.cuda.empty_cache()
                 time.sleep(0.5)
-                # v107: Using 'int8' for guaranteed stability on H200 MIG. 
-                # Removed device_index to allow driver-level discovery.
                 MODELS["stt"] = WhisperModel(
                     "large-v3", 
                     device="cuda", 
-                    compute_type="int8", 
+                    compute_type="int8_float16", 
                     num_workers=1,
-                    cpu_threads=1,
                     local_files_only=local_only
                 )
             except Exception as e:
@@ -129,7 +124,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"🔊 [v107] Activating XTTS-v2 (GPU)...")
+            print(f"🔊 [v108] Activating XTTS-v2 (GPU)...")
             try:
                 if MODELS["tts"] is None:
                     MODELS["tts"] = TTS(model_name="tts_models/multilingual/multi-dataset/xtts_v2", gpu=True)
@@ -144,9 +139,9 @@ def activate_gpu_models(action):
     if MODELS["translate"] is None: MODELS["translate"] = "active"
 
 def release_gpu_models():
-    """v107: GPU Cleanup"""
+    """v108: Resilient Release"""
     global MODELS
-    print("🧹 [v107] Releasing GPU resources.")
+    print("🧹 [v108] Releasing GPU resources.")
     try:
         if MODELS["stt"] and MODELS["stt"].model.device == "cuda":
             del MODELS["stt"]
@@ -161,83 +156,101 @@ def release_gpu_models():
     time.sleep(0.5)
 
 def warmup_task():
-    """Silent Warmup (v107)"""
+    """v108: System Preparation"""
     global WARMUP_STATUS
     with WARMUP_LOCK:
         if WARMUP_STATUS["complete"] or WARMUP_STATUS["in_progress"]: return
         WARMUP_STATUS["in_progress"] = True
-    print("\n🔥 --- V107: ZEROGPU RECOVERY STARTED ---")
+    print("\n🔥 --- V108: ZEROGPU WARMUP STARTED ---")
     try:
+        # Pre-download everything to CPU first
         MODELS["stt"] = WhisperModel("large-v3", device="cpu", compute_type="int8")
         MODELS["tts"] = TTS(model_name="tts_models/multilingual/multi-dataset/xtts_v2", gpu=False)
+        MODELS["denoiser"] = init_df()
         chatterbox_utils.warmup_chatterbox()
         WARMUP_STATUS["complete"] = True
-        print(f"✅ --- SYSTEM READY: v107 --- \n")
-    except: pass
+        print(f"✅ --- SYSTEM READY: v108 --- \n")
+    except Exception as e:
+        print(f"❌ Warmup Error: {e}")
     finally: WARMUP_STATUS["in_progress"] = False
 
-def _stt_logic(request_dict):
-    audio_bytes = base64.b64decode(request_dict.get("file"))
-    lang = request_dict.get("lang")
-    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
-        f.write(audio_bytes); temp_path = f.name
-    try:
-        segments, _ = MODELS["stt"].transcribe(temp_path, language=lang, beam_size=1)
-        return {"text": " ".join([s.text for s in segments]).strip()}
-    finally:
-        if os.path.exists(temp_path): os.unlink(temp_path)
-
-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):
-    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:
-            sb = base64.b64decode(speaker_wav_b64)
-            with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
-                f.write(sb); speaker_wav_path = f.name
-        else: speaker_wav_path = "default_speaker.wav"
-        try:
-            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: 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:
-            sb = base64.b64decode(speaker_wav_b64)
-            with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
-                f.write(sb); temp_ref = f.name
-        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: return {"error": "TTS Failure"}
-
 @spaces.GPU(duration=150)
 def core_process(request_dict):
     action = request_dict.get("action")
+    print(f"--- [v108] 🚀 REQUEST: {action} ---")
+    
+    # 🔥 v108: WAIT PROTOCOL
+    max_wait = 180 # 3 minutes for absolute first-time build/download
+    waited = 0
+    while not WARMUP_STATUS["complete"] and waited < max_wait:
+        if waited % 5 == 0: print(f"⏳ System warming up... (waited {waited}s)")
+        time.sleep(1)
+        waited += 1
+    
+    if not WARMUP_STATUS["complete"]:
+        return {"error": "System still warming up. Please try again in 30 seconds."}
+
     t1 = time.time()
-    print(f"--- [v107] 🚀 GPU SESSION: {action} ---")
     activate_gpu_models(action)
     try:
-        if action == "stt": res = _stt_logic(request_dict)
-        elif action == "translate": res = {"translated": _translate_logic(request_dict.get("text"), request_dict.get("target_lang", "en"))}
-        elif action == "tts": res = _tts_logic(request_dict.get("text"), request_dict.get("lang"), request_dict.get("speaker_wav"))
+        if action == "stt":
+            audio_bytes = base64.b64decode(request_dict.get("file"))
+            with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
+                f.write(audio_bytes); temp_path = f.name
+            try:
+                segments, _ = MODELS["stt"].transcribe(temp_path, language=request_dict.get("lang"), beam_size=1)
+                res = {"text": " ".join([s.text for s in segments]).strip()}
+            finally:
+                if os.path.exists(temp_path): os.unlink(temp_path)
+        
+        elif action == "translate":
+            res = {"translated": deep_translator.GoogleTranslator(source='auto', target=request_dict.get("target_lang", "en")).translate(request_dict.get("text"))}
+        
+        elif action == "tts":
+            text = request_dict.get("text")
+            lang = request_dict.get("lang", "en")
+            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 request_dict.get("speaker_wav"):
+                    sb = base64.b64decode(request_dict.get("speaker_wav"))
+                    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
+                        f.write(sb); speaker_wav_path = f.name
+                else: speaker_wav_path = "default_speaker.wav"
+                
+                try:
+                    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: res = {"audio": base64.b64encode(f.read()).decode()}
+                finally:
+                    if speaker_wav_path and "default" 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)
+            else:
+                audio_bytes = chatterbox_utils.run_chatterbox_inference(text, clean_lang)
+                res = {"audio": base64.b64encode(audio_bytes).decode()}
+
         elif action == "s2st":
-            stt_res = _stt_logic({"file": request_dict.get("file"), "lang": request_dict.get("source_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"))
+            # Combined logic
+            req_copy = request_dict.copy()
+            req_copy["action"] = "stt"
+            stt_res = core_process.__wrapped__(req_copy) # Recursive but without double GPU wrapper
+            
+            translated = deep_translator.GoogleTranslator(source='auto', target=request_dict.get("target_lang")).translate(stt_res.get("text", ""))
+            
+            req_tts = {"action": "tts", "text": translated, "lang": request_dict.get("target_lang"), "speaker_wav": request_dict.get("speaker_wav")}
+            tts_res = core_process.__wrapped__(req_tts)
+            
             res = {"text": stt_res.get("text"), "translated": translated, "audio": tts_res.get("audio")}
         else: res = {"error": f"Unknown action: {action}"}
+    except Exception as e:
+        print(f"❌ Error in core_process: {traceback.format_exc()}")
+        res = {"error": str(e)}
     finally:
-        print(f"--- [v107] ✨ SUCCESS: {action} ({time.time()-t1:.2f}s) ---")
+        print(f"--- [v108] ✨ DONE ({time.time()-t1:.2f}s) ---")
         release_gpu_models()
     return res
 
@@ -246,7 +259,7 @@ async def lifespan(app: FastAPI):
     Thread(target=warmup_task, daemon=True).start()
     yield
 
-# 🚀 STEP 1: DEFINE FASTAPI
+# 🚀 4. FastAPI & Gradio Unified
 app = FastAPI(lifespan=lifespan)
 app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
 
@@ -255,31 +268,22 @@ async def api_process(request: Request):
     try:
         req_data = await request.json()
         if req_data.get("action") == "health":
-            return {"status": "awake", "warm": WARMUP_STATUS["complete"]}
+            return {"status": "awake", "warm": WARMUP_STATUS["complete"], "v": "108"}
         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": "107"}
-
-@app.post("/api/v1/clear_cache")
-async def clear_cache_api():
-    try:
-        release_gpu_models()
-        return {"status": "success"}
-    except: return {"status": "error"}
+def health(): return {"status": "ok", "warm": WARMUP_STATUS["complete"], "v": "108"}
 
-# 🚀 STEP 2: DEFINE GRADIO
 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 v107")
+demo = gr.Interface(fn=gradio_fn, inputs="text", outputs="text", title="🚀 AI Engine v108")
 demo.queue()
 
-# MOUNT
 app = gr.mount_gradio_app(app, demo, path="/")
 
 if __name__ == "__main__":
-    print("🚀 [v107] Starting Unified Server (ZeroGPU Recovery)...")
+    print("🚀 [v108] Starting System...")
     uvicorn.run(app, host="0.0.0.0", port=7860, log_level="error")