Upload app.py with huggingface_hub

app.py

@@ -11,13 +11,13 @@ from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import HTMLResponse
 import uvicorn
 
-# --- [v142] 🚀 REFINED HYBRID ENGINE (CPU STT + GPU TTS) ---
-print(f"--- [v142] 📡 BOOTING REFINED HYBRID ---")
+# --- [v143] 🚀 SEAMLESS HYBRID ENGINE (CPU STT + GPU TTS / FIX NESTING) ---
+print(f"--- [v143] 📡 BOOTING SEAMLESS HYBRID ---")
 
-# Top-level imports for stability
 from transformers import pipeline, AutoModelForSpeechSeq2Seq, AutoProcessor
 from TTS.api import TTS
 from deep_translator import GoogleTranslator
+
 try:
     import chatterbox_utils
     HAS_CHATTERBOX = True
@@ -35,7 +35,6 @@ except ImportError:
             if f is None: return lambda x: x
             return f
 
-# --- Global Sync ---
 os.environ["COQUI_TOS_AGREED"] = "1"
 os.environ["PYTHONWARNINGS"] = "ignore"
 
@@ -45,54 +44,34 @@ app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], all
 MODELS = {"stt": None, "tts": None}
 
 def load_cpu_stt():
-    """Loads Whisper on CPU for maximum stability."""
+    """Loads Whisper on CPU."""
     global MODELS
     if MODELS.get("stt") is None:
-        print("--- [v142] 📥 LOADING WHISPER ON CPU ---")
+        print("--- [v143] 📥 LOADING WHISPER ON CPU ---")
         model_id = "openai/whisper-large-v3-turbo"
-        model = AutoModelForSpeechSeq2Seq.from_pretrained(
-            model_id, torch_dtype=torch.float32, low_cpu_mem_usage=True
-        ) # CPU handles FP32 best
+        model = AutoModelForSpeechSeq2Seq.from_pretrained(model_id, torch_dtype=torch.float32, low_cpu_mem_usage=True)
         processor = AutoProcessor.from_pretrained(model_id)
-        MODELS["stt"] = pipeline(
-            "automatic-speech-recognition",
-            model=model,
-            tokenizer=processor.tokenizer,
-            feature_extractor=processor.feature_extractor,
-            device="cpu"
-        )
-        print("--- [v142] ✅ WHISPER LOADED (CPU) ---")
+        MODELS["stt"] = pipeline("automatic-speech-recognition", model=model, tokenizer=processor.tokenizer, feature_extractor=processor.feature_extractor, device="cpu")
+        print("--- [v143] ✅ WHISPER LOADED (CPU) ---")
 
-@spaces.GPU(duration=120)
-def load_gpu_tts():
-    """Loads XTTS on GPU for maximum speed."""
+def load_gpu_tts_internal():
+    """Loads XTTS on GPU (called within @spaces.GPU). No decorator here to avoid nesting."""
     global MODELS
     if MODELS.get("tts") is None:
-        print("--- [v142] 📥 LOADING XTTS ON GPU ---")
+        print("--- [v143] 📥 LOADING XTTS ON GPU ---")
         MODELS["tts"] = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to("cuda")
-        print("--- [v142] ✅ XTTS LOADED (GPU) ---")
-
-def stt_process_internal(audio_b64, lang):
-    load_cpu_stt()
-    audio_bytes = base64.b64decode(audio_b64)
-    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
-        f.write(audio_bytes); temp_path = f.name
-    try:
-        result = MODELS["stt"](temp_path, generate_kwargs={"language": lang if lang and len(lang) <= 3 else None})
-        return result["text"].strip()
-    finally:
-        if os.path.exists(temp_path): os.unlink(temp_path)
+        print("--- [v143] ✅ XTTS LOADED (GPU) ---")
 
 @spaces.GPU(duration=120)
-def tts_process_internal(text, target_lang, speaker_wav_b64=None):
-    load_gpu_tts()
+def tts_process_gpu(text, target_lang, speaker_wav_b64=None):
+    """The ONLY @spaces.GPU entry point for TTS."""
+    load_gpu_tts_internal()
     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 = target_lang.split('-')[0].lower()
     mapped_lang = XTTS_MAP.get(clean_lang) or ("zh-cn" if clean_lang == "zh" else None)
     
     if not mapped_lang: 
         if HAS_CHATTERBOX:
-            print(f"--- [v142] 📦 USING CHATTERBOX FOR {clean_lang} ---")
             audio_bytes = chatterbox_utils.run_chatterbox_inference(text, clean_lang)
             return base64.b64encode(audio_bytes).decode()
         return {"error": f"Language {clean_lang} not supported."}
@@ -114,27 +93,37 @@ def tts_process_internal(text, target_lang, speaker_wav_b64=None):
         if speaker_wav_b64 and os.path.exists(speaker_wav_path): os.unlink(speaker_wav_path)
         if 'out_p' in locals() and os.path.exists(out_p): os.unlink(out_p)
 
+def stt_process_cpu(audio_b64, lang):
+    load_cpu_stt()
+    audio_bytes = base64.b64decode(audio_b64)
+    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
+        f.write(audio_bytes); temp_path = f.name
+    try:
+        result = MODELS["stt"](temp_path, generate_kwargs={"language": lang if lang and len(lang) <= 3 else None})
+        return result["text"].strip()
+    finally:
+        if os.path.exists(temp_path): os.unlink(temp_path)
+
 @app.post("/process")
 async def api_process(request: Request):
     try:
         data = await request.json()
         action = data.get("action")
-        if action == "health": return {"status": "awake", "v": "142", "gpu": HAS_SPACES}
+        if action == "health": return {"status": "awake", "v": "143"}
         
-        print(f"--- [v142] 🛠️ HYBRID ENGINE: {action} ---")
+        print(f"--- [v143] 🛠️ HYBRID ACTION: {action} ---")
         t1 = time.time()
         
-        # 🎙️ STT (CPU Segment)
+        # 🎙️ STT Segment (CPU)
         stt_text = None
         if action in ["stt", "s2st"]:
-            stt_text = stt_process_internal(data.get("file"), data.get("lang"))
+            stt_text = stt_process_cpu(data.get("file"), data.get("lang"))
             if action == "stt": return {"text": stt_text}
 
-        # 🔊 TTS (GPU Segment)
+        # 🔊 TTS Segment (GPU)
         if action in ["tts", "s2st"]:
             text = (data.get("text") if action == "tts" else stt_text).strip()
             trans_text = text
-            
             if action == "s2st":
                 target = data.get("target_lang") or "en"
                 trans_text = GoogleTranslator(source='auto', target=target).translate(stt_text)
@@ -142,23 +131,24 @@ async def api_process(request: Request):
 
             if len(text) < 2: return {"audio": ""} if action == "tts" else {"text": stt_text, "translated": "", "audio": ""}
             
-            audio_res = tts_process_internal(text, (data.get("lang") if action == "tts" else target), data.get("speaker_wav"))
-            if isinstance(audio_res, dict) and "error" in audio_res: return audio_res
+            # This is the single @spaces.GPU gated call
+            audio_res = tts_process_gpu(text, (data.get("lang") if action == "tts" else target), data.get("speaker_wav"))
             
+            if isinstance(audio_res, dict) and "error" in audio_res: return audio_res
             if action == "tts": return {"audio": audio_res}
             return {"text": stt_text, "translated": trans_text, "audio": audio_res}
 
     except Exception as e:
-        print(f"❌ [v142] ERROR: {traceback.format_exc()}")
+        print(f"❌ [v143] ERROR: {traceback.format_exc()}")
         return {"error": str(e)}
     finally:
-        print(f"--- [v142] ✨ DONE ({time.time()-t1:.1f}s) ---")
+        print(f"--- [v143] ✨ DONE ({time.time()-t1:.1f}s) ---")
 
 @app.get("/health")
-def health(): return {"status": "ok", "v": "142", "mode": "HYBRID", "gpu": HAS_SPACES}
+def health(): return {"status": "ok", "v": "143", "mode": "HYBRID"}
 
 @app.get("/", response_class=HTMLResponse)
-def root(): return "<html><body><h1>🚀 AI Engine v142 (PRODUCTION HYBRID)</h1></body></html>"
+def root(): return "<html><body><h1>🚀 AI Engine v143 (SEAMLESS HYBRID)</h1></body></html>"
 
 if __name__ == "__main__":
     uvicorn.run(app, host="0.0.0.0", port=7860)