Upload app.py with huggingface_hub

app.py

@@ -1,43 +1,42 @@
 import os
 import sys
+import time
+import base64
+import torch
+import tempfile
+import traceback
+import gc
+from fastapi import FastAPI, Request, Response
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import HTMLResponse
+import uvicorn
+from transformers import pipeline, AutoModelForSpeechSeq2Seq, AutoProcessor
+from TTS.api import TTS
 
-# --- [v137-clean-v3] 🚀 INITIALIZING SYSTEM ---
-print(f"PYTHON VERSION: {sys.version}")
-print(f"WORKING DIR: {os.getcwd()}")
+# --- [v138] 🚀 ZEROGPU LEGACY-FREE ENGINE ---
+print(f"--- [v138] 📡 BOOTING API ENGINE ---")
 
 try:
     import spaces
+    HAS_SPACES = True
 except ImportError:
+    HAS_SPACES = False
     class spaces:
         @staticmethod
         def GPU(duration=60, f=None):
             if f is None: return lambda x: x
             return f
 
-import gradio as gr
-from fastapi import FastAPI, Request
-from fastapi.middleware.cors import CORSMiddleware
-import base64
-import torch
-import tempfile
-import json
-import time
-import gc
-import traceback
-import numpy as np
-from transformers import pipeline, AutoModelForSpeechSeq2Seq, AutoProcessor
-from TTS.api import TTS
-
-# ==========================================
-# 🚀 v137 - HOPPER NATIVE (Transformers + Persistent VRAM)
-# ==========================================
-
+# --- System Config ---
 os.environ["COQUI_TOS_AGREED"] = "1"
 os.environ["PYTHONWARNINGS"] = "ignore"
 os.environ["CUBLAS_WORKSPACE_CONFIG"] = ":4096:8"
 torch.backends.cuda.matmul.allow_tf32 = False
 torch.backends.cudnn.allow_tf32 = False
 
+app = FastAPI()
+app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
+
 MODELS = {"stt": None, "tts": None}
 
 def load_gpu_models():
@@ -46,7 +45,7 @@ def load_gpu_models():
     device = "cuda"
     
     if MODELS.get("stt") is None:
-        print("--- [v137] 📥 LOADING NATIVE WHISPER (Large-v3-Turbo) ---")
+        print("--- [v138] 📥 LOADING NATIVE WHISPER (Large-v3-Turbo) ---")
         model_id = "openai/whisper-large-v3-turbo"
         model = AutoModelForSpeechSeq2Seq.from_pretrained(
             model_id, torch_dtype=torch.float16, low_cpu_mem_usage=True, use_safetensors=True
@@ -62,18 +61,18 @@ def load_gpu_models():
             device=device,
             model_kwargs={"attn_implementation": "sdpa"}
         )
-        print("--- [v137] ✅ WHISPER LOADED ---")
+        print("--- [v138] ✅ WHISPER LOADED ---")
 
     if MODELS.get("tts") is None:
-        print("--- [v137] 📥 LOADING XTTS (VRAM STABLE) ---")
+        print("--- [v138] 📥 LOADING XTTS (VRAM STABLE) ---")
         MODELS["tts"] = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to(device)
-        print("--- [v137] ✅ XTTS LOADED ---")
+        print("--- [v138] ✅ XTTS LOADED ---")
 
 @spaces.GPU(duration=120)
 def core_process(request_dict):
     global MODELS
     action = request_dict.get("action")
-    print(f"--- [v137] 🛠️ HOPPER ENGINE: {action} ---")
+    print(f"--- [v138] 🛠️ HOPPER ENGINE: {action} ---")
     t1 = time.time()
     
     try:
@@ -114,14 +113,8 @@ def core_process(request_dict):
             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" 
-                    if not os.path.exists(speaker_wav_path): speaker_wav_path = None
+                speaker_wav_path = "default_speaker.wav" 
+                if not os.path.exists(speaker_wav_path): speaker_wav_path = None
 
                 try:
                     with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as out_f:
@@ -129,62 +122,68 @@ def core_process(request_dict):
                     MODELS["tts"].tts_to_file(text=text, language=mapped_lang, file_path=out_p, speaker_wav=speaker_wav_path)
                     with open(out_p, "rb") as f: audio_b64 = 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 'out_p' in locals() and os.path.exists(out_p): os.unlink(out_p)
-            else:
-                import chatterbox_utils
-                audio_bytes = chatterbox_utils.run_chatterbox_inference(text, clean_lang)
-                audio_b64 = base64.b64encode(audio_bytes).decode()
+            else: return {"error": f"Language {clean_lang} not supported."}
             
             if action == "tts": return {"audio": audio_b64}
             return {"text": stt_text, "translated": trans_text, "audio": audio_b64}
 
     except Exception as e:
-        print(f"❌ [v137] ERROR: {traceback.format_exc()}")
+        print(f"❌ [v138] ERROR: {traceback.format_exc()}")
         return {"error": str(e)}
     finally:
-        print(f"--- [v137] ✨ DONE ({time.time()-t1:.1f}s) ---")
+        print(f"--- [v138] ✨ DONE ({time.time()-t1:.1f}s) ---")
         torch.cuda.empty_cache() 
 
-# --- Gradio UI Logic ---
-def gradio_stt_fn(audio_path) -> str:
-    if not audio_path: return "No audio provided."
-    try:
-        with open(audio_path, "rb") as f:
-            b64 = base64.b64encode(f.read()).decode()
-        res = core_process({"action": "stt", "file": b64})
-        return res.get("text", f"Error: {res.get('error')}")
-    except Exception as e:
-        return f"UI Error: {str(e)}"
-
-# --- Interface Definition ---
-with gr.Blocks(title="S2ST H200 v137") as demo:
-    gr.Markdown("# 🚀 S2ST AI Engine v137 (HOPPER NATIVE)")
-    gr.Markdown("**H200 Stable | Transformers Whisper | XTTS-v2 VRAM Singleton**")
-    with gr.Row():
-        audio_in = gr.Audio(type="filepath", label="Input Audio")
-        stt_btn = gr.Button("Transcribe (STT)")
-        txt_out = gr.Textbox(label="Result")
-    stt_btn.click(fn=gradio_stt_fn, inputs=audio_in, outputs=txt_out)
-
-# --- FastAPI Route Integration ---
-print("--- [v137-clean-v3] 🔧 INTEGRATING FASTAPI ROUTES ---")
-fastapi_app = demo.app # Access Gradio's internal FastAPI app
-fastapi_app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
-
-@fastapi_app.post("/process")
+# --- API Endpoints ---
+@app.post("/process")
 async def api_process(request: Request):
     try:
         data = await request.json()
-        if data.get("action") == "health": return {"status": "awake", "v": "137"}
+        if data.get("action") == "health": return {"status": "awake", "v": "138"}
         return core_process(data)
     except Exception as e: return {"error": str(e)}
 
-@fastapi_app.get("/api/v137_health")
-def api_v137_health():
-    return {"status": "ok", "v": "137", "details": "NATIVE_INTEGRATION"}
+@app.get("/health")
+def health(): return {"status": "ok", "v": "138", "gpu": HAS_SPACES}
+
+# --- Minimal UI ---
+@app.get("/", response_class=HTMLResponse)
+def root():
+    return """
+    <html>
+        <head>
+            <title>S2ST v138</title>
+            <style>
+                body { font-family: sans-serif; background: #111; color: #eee; text-align: center; padding-top: 50px; }
+                .card { background: #222; border: 1px solid #444; padding: 20px; border-radius: 10px; display: inline-block; }
+                button { background: #007bff; color: #fff; border: none; padding: 10px 20px; border-radius: 5px; cursor: pointer; }
+                #log { margin-top: 20px; color: #aaa; font-family: monospace; }
+            </style>
+        </head>
+        <body>
+            <div class="card">
+                <h1>🚀 AI Engine v138</h1>
+                <p>HOPPER NATIVE - FASTAPI ONLY</p>
+                <button onclick="checkHealth()">Test API Connectivity</button>
+                <div id="log">Status: Awaiting test...</div>
+            </div>
+            <script>
+                async function checkHealth() {
+                    const log = document.getElementById('log');
+                    log.innerText = 'Checking...';
+                    try {
+                        const res = await fetch('/health');
+                        const data = await res.json();
+                        log.innerText = 'Response: ' + JSON.stringify(data);
+                    } catch (e) {
+                        log.innerText = 'Error: ' + e;
+                    }
+                }
+            </script>
+        </body>
+    </html>
+    """
 
-# --- Start System ---
 if __name__ == "__main__":
-    print("--- [v137-clean-v3] 📡 LAUNCHING SYSTEM ---")
-    demo.launch(server_name="0.0.0.0", server_port=7860, show_api=False, quiet=True)
+    uvicorn.run(app, host="0.0.0.0", port=7860)