HARD RESET: Re-uploading app.py to force rebuild

app.py

@@ -0,0 +1,135 @@
+import gradio as gr
+from fastapi import FastAPI, Request
+import uvicorn
+import base64
+import torch
+import os
+import tempfile
+import traceback
+import json
+import time
+
+# FORCE BUILD TRIGGER: 00:05:00 Jan 20 2026
+os.environ["COQUI_TOS_AGREED"] = "1"
+
+# Global models
+MODELS = {"stt": None, "translate": None, "tts": None, "tokenizer": None}
+
+def load_models():
+    global MODELS
+    if MODELS["stt"] is None:
+        print("🎙️ Loading Whisper large-v3...")
+        import whisper
+        MODELS["stt"] = whisper.load_model("large-v3")
+        if torch.cuda.is_available():
+            MODELS["stt"] = MODELS["stt"].half().to("cuda")
+    
+    if MODELS["translate"] is None:
+        print("🌍 Loading NLLB-200...")
+        from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
+        MODELS["tokenizer"] = AutoTokenizer.from_pretrained("facebook/nllb-200-distilled-600M")
+        MODELS["translate"] = AutoModelForSeq2SeqLM.from_pretrained(
+            "facebook/nllb-200-distilled-600M",
+            torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32
+        ).to("cuda" if torch.cuda.is_available() else "cpu")
+    
+    if MODELS["tts"] is None:
+        print("🔊 Loading XTTS-v2...")
+        from TTS.api import TTS
+        MODELS["tts"] = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to(
+            "cuda" if torch.cuda.is_available() else "cpu"
+        )
+
+def process_logic(request):
+    """Core logic shared between Gradio and FastAPI"""
+    action = request.get("action")
+    print(f"⚙️ Logic Action: {action}")
+    
+    if action == "health":
+        return {"status": "ok", "gpu": torch.cuda.is_available(), "timestamp": time.time()}
+    
+    load_models()
+    
+    if action == "stt":
+        audio_b64 = request.get("file")
+        lang = request.get("lang")
+        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"].transcribe(temp_path, language=lang, fp16=torch.cuda.is_available())
+            return {"text": result["text"].strip()}
+        finally:
+            os.unlink(temp_path)
+    
+    elif action == "translate":
+        text = request.get("text")
+        target_lang = request.get("target_lang")
+        tgt_code = f"{target_lang}_Latn"
+        inputs = MODELS["tokenizer"](text, return_tensors="pt", padding=True).to(MODELS["translate"].device)
+        translated = MODELS["translate"].generate(**inputs, forced_bos_token_id=MODELS["tokenizer"].convert_tokens_to_ids(tgt_code), max_length=512)
+        result = MODELS["tokenizer"].decode(translated[0], skip_special_tokens=True)
+        return {"translated": result.strip()}
+    
+    elif action == "tts":
+        text = request.get("text")
+        lang = request.get("lang")
+        speaker_wav_b64 = request.get("speaker_wav")
+        speaker_wav_path = None
+        if speaker_wav_b64:
+            speaker_bytes = base64.b64decode(speaker_wav_b64)
+            with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
+                f.write(speaker_bytes)
+                speaker_wav_path = f.name
+        try:
+            with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as output_file:
+                output_path = output_file.name
+            MODELS["tts"].tts_to_file(text=text, language=lang, file_path=output_path, speaker_wav=speaker_wav_path)
+            with open(output_path, "rb") as f:
+                audio_b64 = base64.b64encode(f.read()).decode()
+            return {"audio": audio_b64}
+        finally:
+            if speaker_wav_path and os.path.exists(speaker_wav_path):
+                os.unlink(speaker_wav_path)
+            if os.path.exists(output_path):
+                os.unlink(output_path)
+                
+    return {"error": f"Unknown action: {action}"}
+
+# --- GRADIO SECTION ---
+def gradio_fn(request_json):
+    try:
+        req = json.loads(request_json)
+        res = process_logic(req)
+        return json.dumps(res)
+    except Exception as e:
+        return json.dumps({"error": str(e), "trace": traceback.format_exc()})
+
+demo = gr.Interface(
+    fn=gradio_fn,
+    inputs=gr.Textbox(label="JSON Request", lines=5),
+    outputs=gr.Textbox(label="JSON Response"),
+    title="🚀 Unified AI Engine"
+)
+
+# --- FASTAPI SECTION ---
+app = FastAPI()
+
+@app.post("/api/v1/process")
+async def api_v1_process(request: Request):
+    try:
+        body = await request.json()
+        return process_logic(body)
+    except Exception as e:
+        return {"error": str(e)}
+
+@app.get("/health")
+def health():
+    return {"status": "ok"}
+
+# Mount Gradio into FastAPI
+app = gr.mount_gradio_app(app, demo, path="/")
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=7860)