Update app.py

app.py

@@ -1,24 +1,107 @@
 import gradio as gr
 import requests
+from fastapi import FastAPI, APIRouter, Request, File, UploadFile, HTTPException, status
+import time
+import logging
+import uvicorn
+import os
+import numpy as np
 
-API_URL = "http://127.0.0.1:7860/api/v1/voice/score"  # if you want to call FastAPI internally
+# --- Logging setup ---
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s"
+)
+
+# --- FastAPI setup ---
+app = FastAPI(
+    title="Auralis Vocal Fatigue Scoring API",
+    version="1.0",
+    docs_url="/doc",
+    redoc_url="/redoc",
+    openapi_url="/openapi.json"
+)
+
+@app.middleware("http")
+async def log_requests(request: Request, call_next):
+    start = time.time()
+    response = await call_next(request)
+    duration = time.time() - start
+    logging.info(f"{request.method} {request.url.path} status_code={response.status_code} time={duration:.3f}")
+    return response
+
+# --- FastAPI Routes ---
+router = APIRouter(prefix="/api/v1/voice")
+
+API_MODEL_URL = os.environ.get("MODEL_API_URL", "http://localhost:7860/api/v1/voice/score")
+
+@router.post("/score")
+async def score_voice(file: UploadFile = File(...)):
+    """Direct API endpoint — calls the model scoring function."""
+    try:
+        # Save temp audio
+        temp_path = f"/tmp/{file.filename}"
+        with open(temp_path, "wb") as f:
+            f.write(await file.read())
+
+        # Call the model scoring
+        files = {"file": open(temp_path, "rb")}
+        import requests
+        response = requests.post(API_MODEL_URL, files=files)
+        files["file"].close()
+
+        if response.status_code == 200:
+            return response.json()
+        else:
+            raise HTTPException(status_code=response.status_code, detail=response.text)
+
+    except Exception as e:
+        logging.exception("Error in /score endpoint")
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e))
+
+app.include_router(router)
+
+@app.get("/health")
+def health():
+    return {"status": "ok"}
+
+@app.get("/")
+def root():
+    return {"name": "Auralis Vocal Fatigue Scoring API", "status": "running", "health": "/health"}
+
+# --- Gradio interface ---
+def gradio_score(audio_file_path: str):
+    """
+    Gradio wrapper: receives filepath and calls the FastAPI endpoint internally
+    """
+    with open(audio_file_path, "rb") as f:
+        response = requests.post(API_MODEL_URL, files={"file": f})
 
-def score_vocal(audio_file):
-    # send audio to FastAPI endpoint internally
-    with open(audio_file.name, "rb") as f:
-        files = {"file": f}
-        response = requests.post(API_URL, files=files)
     if response.status_code == 200:
-        return response.json()["fatigue_score"]
+        return response.json().get("fatigue_score", "No score returned")
     else:
-        return f"Error: {response.status_code}"
+        return f"Error {response.status_code}: {response.text}"
 
 iface = gr.Interface(
-    fn=score_vocal,
-    inputs=gr.Audio(type="filepath"),
+    fn=gradio_score,
+    inputs=gr.Audio(type="filepath", label="Upload Audio"),
     outputs=gr.Textbox(label="Vocal Fatigue Score"),
-    title="Auralis Vocal Fatigue API"
+    title="Auralis Vocal Fatigue Scoring",
+    description="Upload an audio file and get the fatigue score using the Auralis API."
 )
 
+# --- Run both FastAPI and Gradio in same container ---
 if __name__ == "__main__":
-    iface.launch(server_name="0.0.0.0", server_port=7860)
+    import threading
+
+    # Launch Gradio in a separate thread
+    def launch_gradio():
+        iface.launch(server_name="0.0.0.0", server_port=int(os.environ.get("PORT", 7860)), share=False)
+
+    t = threading.Thread(target=launch_gradio)
+    t.start()
+
+    # Run FastAPI (Uvicorn) on same port (Gradio will handle it), so only logging here
+    # FastAPI endpoints will still work via the same server
+    logging.info("Auralis API + Gradio launched.")
+    t.join()