Upload app.py with huggingface_hub

app.py

@@ -61,8 +61,8 @@ if not hasattr(torchaudio, "info"):
 
 from df.enhance import enhance, init_df, load_audio, save_audio
 
-# FORCE BUILD TRIGGER: 09:40:00 Jan 21 2026
-# v84: Fixed SyntaxError (Missing try block in core_process)
+# FORCE BUILD TRIGGER: 10:00:00 Jan 21 2026
+# v85: ZeroGPU Warmup & Pre-caching (Prevents session timeouts)
 
 # 🛠️ Monkeypatch torchaudio.load
 try:
@@ -93,7 +93,7 @@ MODELS = {"stt": None, "translate": None, "tts": None, "tokenizer": None, "denoi
 def load_models():
     global MODELS
     if MODELS["stt"] is None:
-        print("🎙️ Loading Faster-Whisper large-v3...")
+        print("🎙️ Loading Faster-Whisper large-v3 into Engine...")
         from faster_whisper import WhisperModel
         if torch.cuda.is_available():
             print(f"🚀 GPU Detected: {torch.cuda.get_device_name(0)}")
@@ -108,7 +108,6 @@ def load_models():
         torch.cuda.empty_cache()
     
     # Initialize Chatterbox ONNX (High-Speed Fallback)
-    # This will load the model if not already loaded internally by chatterbox_utils
     chatterbox_utils.load_chatterbox(device="cuda" if torch.cuda.is_available() else "cpu")
 
     if MODELS["translate"] is None:
@@ -123,7 +122,7 @@ def load_models():
         except: pass
 
     if MODELS["tts"] is None:
-        print("🔊 Loading XTTS-v2...")
+        print("🔊 Loading XTTS-v2 into Engine...")
         from TTS.api import TTS
         try:
             MODELS["tts"] = TTS(model_name="tts_models/multilingual/multi-dataset/xtts_v2", gpu=torch.cuda.is_available())
@@ -132,6 +131,35 @@ def load_models():
             print(f"❌ Failed to load XTTS: {e}")
             raise e
 
+def warmup_models():
+    """Download and cache all models on CPU at startup (Prevents GPU timeouts)"""
+    print("\n🔥 --- SYSTEM WARMUP STARTING (CPU) ---")
+    start = time.time()
+    try:
+        # 1. Warmup Whisper
+        print("📥 Initializing Whisper large-v3 cache...")
+        from faster_whisper import WhisperModel
+        # Use simple init to trigger download
+        _ = WhisperModel("large-v3", device="cpu", compute_type="int8")
+        
+        # 2. Warmup XTTS-v2 (This takes the longest)
+        print("📥 Initializing XTTS-v2 cache...")
+        from TTS.api import TTS
+        # Initialize once on CPU just to force download
+        _ = TTS(model_name="tts_models/multilingual/multi-dataset/xtts_v2", gpu=False)
+        
+        # 3. Warmup DeepFilterNet
+        print("📥 Initializing DeepFilterNet cache...")
+        try: init_df()
+        except: pass
+        
+        # 4. Warmup Chatterbox
+        chatterbox_utils.warmup_chatterbox()
+        
+        print(f"✅ --- SYSTEM WARMUP COMPLETE (Time: {time.time()-start:.2f}s) --- \n")
+    except Exception as e:
+        print(f"⚠️ Warmup warning: {e}")
+
 def _stt_logic(request_dict):
     """STT Logic (Runs on GPU when called via core_process)"""
     audio_bytes = base64.b64decode(request_dict.get("file"))
@@ -158,8 +186,6 @@ def _tts_logic(text, lang, speaker_wav_b64):
     if not text or not text.strip():
         return {"error": "TTS Error: Input text is empty"}
         
-    # 🌍 XTTS-v2 COMPLETE 16-LANGUAGE MAPPING (v79)
-    # This dictionary ensures every officially supported XTTS language code is correctly matched.
     XTTS_MAP = {
         "en": "en", "en-us": "en", "en-gb": "en",
         "de": "de", "de-de": "de",
@@ -180,18 +206,15 @@ def _tts_logic(text, lang, speaker_wav_b64):
     }
     
     XTTS_LANG_CODES = set(XTTS_MAP.values())
-    
     mapped_lang = None
     if lang:
         lang_key = lang.strip().lower()
         mapped_lang = XTTS_MAP.get(lang_key) or XTTS_MAP.get(lang_key.split('-')[0])
         
-    print(f"[v84] TTS Request - Original: {lang}, Mapped: {mapped_lang}")
+    print(f"[v85] TTS Request - Original: {lang}, Mapped: {mapped_lang}")
     
-    # 🛣️ INTELLIGENT ROUTING
-    # Case A: XTTS Support (Voice Cloning)
     if mapped_lang and mapped_lang in XTTS_LANG_CODES:
-        print(f"[v84] Using XTTS-v2 for '{mapped_lang}'")
+        print(f"[v85] Using XTTS-v2 for '{mapped_lang}'")
         speaker_wav_path = None
         if speaker_wav_b64:
             sb = base64.b64decode(speaker_wav_b64)
@@ -205,7 +228,6 @@ def _tts_logic(text, lang, speaker_wav_b64):
             with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as output_file:
                 output_path = output_file.name
             
-            # 🎙️ XTTS Inference
             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:
@@ -216,22 +238,17 @@ def _tts_logic(text, lang, speaker_wav_b64):
                 if 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)
             
-    # Case B: Chatterbox ONNX Support (High-Quality Fast Fallback)
-    print(f"[v84] Using Chatterbox ONNX Fallback for '{lang}'")
+    print(f"[v85] Using Chatterbox ONNX Fallback for '{lang}'")
     try:
-        # Use local file if available for cloning in Chatterbox too
         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
         
-        # Chatterbox supports codes like 'fi', 'el', 'da', etc.
         chatter_lang = lang.strip().lower().split('-')[0]
         audio_bytes = chatterbox_utils.run_chatterbox_inference(text, chatter_lang, speaker_wav_path=temp_ref)
-        
         if temp_ref and os.path.exists(temp_ref): os.unlink(temp_ref)
-        
         audio_b64 = base64.b64encode(audio_bytes).decode()
         return {"audio": audio_b64}
     except Exception as e:
@@ -240,14 +257,10 @@ def _tts_logic(text, lang, speaker_wav_b64):
 
 @spaces.GPU
 def core_process(request_dict):
-    """
-    Unified GPU Entry Point (v84). 
-    This function handles all high-speed tasks inside a single GPU allocation.
-    The container stays resident on CPU but triggers GPU on demand.
-    """
+    """Unified GPU Entry Point (v85)"""
     action = request_dict.get("action")
     t0 = time.time()
-    print(f"--- [v84] 🚀 GPU SESSION START: {action} at {time.ctime()} ---")
+    print(f"--- [v85] 🚀 GPU SESSION START: {action} at {time.ctime()} ---")
     load_models() 
     
     try:
@@ -258,26 +271,21 @@ 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":
-            # 🔗 FULL PIPELINE (Single GPU Call)
             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"))
-            
             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")}
         elif action == "health":
             res = {"status": "awake", "time": time.ctime()}
         else:
             res = {"error": f"Unknown action: {action}"}
-            
     finally:
-        print(f"--- [v84] ✨ SESSION END: {action} (Total: {time.time()-t0:.2f}s) ---")
+        print(f"--- [v85] ✨ SESSION END: {action} (Total: {time.time()-t0:.2f}s) ---")
         gc.collect()
         if torch.cuda.is_available():
             torch.cuda.empty_cache()
-    
     return res
 
 def create_wav_header(sample_rate=24000, channels=1, bit_depth=16):
@@ -296,13 +304,11 @@ def create_wav_header(sample_rate=24000, channels=1, bit_depth=16):
     header.extend((0xFFFFFFFF).to_bytes(4, 'little'))
     return bytes(header)
 
-# 🚀 Sync Generator for ZeroGPU
 @spaces.GPU
 def gpu_tts_generator(text, lang, speaker_wav_path):
     load_models()
     try:
         yield bytes(create_wav_header(sample_rate=24000))
-        # inference_stream is a generator
         for chunk in MODELS["tts"].synthesizer.tts_model.inference_stream(
             text,
             lang,
@@ -320,15 +326,12 @@ def gpu_tts_generator(text, lang, speaker_wav_path):
         if torch.cuda.is_available():
             torch.cuda.empty_cache()
 
-# --- FastAPI Entry Points ---
 app = FastAPI()
 
 @app.post("/api/v1/process")
 async def api_process(request: Request):
-    """Async endpoint. Routes to CPU (STT/Translate) or Hybrid (S2ST/TTS)"""
     try:
         data = await request.json()
-        # Direct call to the hybrid process
         result = core_process(data)
         return result
     except Exception as e:
@@ -337,7 +340,6 @@ async def api_process(request: Request):
 
 @app.post("/api/v1/tts_stream")
 async def api_tts_stream(request: Request):
-    """Async entry point for StreamingResponse"""
     try:
         data = await request.json()
         speaker_wav_b64 = data.get("speaker_wav")
@@ -349,11 +351,7 @@ async def api_tts_stream(request: Request):
                 speaker_wav_path = f.name
         else:
             speaker_wav_path = "default_speaker.wav"
-            
-        return StreamingResponse(
-            gpu_tts_generator(data.get("text"), data.get("lang"), speaker_wav_path), 
-            media_type="audio/wav"
-        )
+        return StreamingResponse(gpu_tts_generator(data.get("text"), data.get("lang"), speaker_wav_path), media_type="audio/wav")
     except Exception as e:
         return {"error": str(e)}
 
@@ -363,46 +361,27 @@ def health():
 
 @app.post("/api/v1/clear_cache")
 async def clear_cache():
-    """Manual deep cleanup of memory and caches"""
     try:
         t0 = time.time()
-        print("🧹 Manual Cache Clearing Triggered...")
-        
-        # 1. GC collect
         gc.collect()
-        
-        # 2. CUDA cache
-        if torch.cuda.is_available():
-            torch.cuda.empty_cache()
-            
-        # 3. Clean temp files
+        if torch.cuda.is_available(): torch.cuda.empty_cache()
         temp_dir = tempfile.gettempdir()
         count = 0
         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)); count += 1
                 except: pass
-                
-        return {
-            "status": "success",
-            "cleaned_files": count,
-            "duration": f"{time.time()-t0:.2f}s",
-            "gpu_memory": f"{torch.cuda.memory_allocated() / 1024**2:.2f}MB" if torch.cuda.is_available() else "N/A"
-        }
+        return {"status": "success", "cleaned_files": count, "duration": f"{time.time()-t0:.2f}s"}
     except Exception as e:
         return {"status": "error", "message": str(e)}
 
-# --- Gradio UI ---
 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)})
+    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")
 app = gr.mount_gradio_app(app, demo, path="/")
 
 if __name__ == "__main__":
+    warmup_models()
     uvicorn.run(app, host="0.0.0.0", port=7860)