Update app.py

app.py

@@ -1,25 +1,6 @@
-"""
-=================================================================
-DISASTER AI — HuggingFace Spaces API (Permanent Free Server)
 =================================================================
-Deploy this to HuggingFace Spaces for a permanent, always-on
-API that your friends can call without knowing any AI.
-
-Setup:
-1. Go to https://huggingface.co/spaces
-2. Create New Space → SDK: Docker (or Gradio)
-3. Repo name: EgoisticCoderX/dokai-inference-api
-4. Upload this file as app.py
-5. Upload requirements.txt
-6. Add secrets in Space Settings:
-   - HF_VICTIM_MODEL_REPO = EgoisticCoderX/dokai-victim-detection
-   - ROBOFLOW_API_KEY = your_key
-
-Your API will be at:
-  https://egoisticcoderx-dokai-inference-api.hf.space/
-
-ZeroGPU Note: HF Spaces has ZeroGPU (A10G, free) for inference.
-Add @spaces.GPU decorator for GPU-accelerated endpoints.
+Disaster AI — HuggingFace Spaces API
+Final version — all fixes applied
 =================================================================
 """
 
@@ -29,6 +10,7 @@ import json
 import time
 import base64
 import threading
+import traceback
 import numpy as np
 from pathlib import Path
 from PIL import Image
@@ -36,28 +18,18 @@ import cv2
 import torch
 import requests
 
-from fastapi import FastAPI, File, UploadFile, HTTPException, Depends
+from fastapi import FastAPI, File, UploadFile, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
 from huggingface_hub import hf_hub_download
 
-# ── ZeroGPU support (HuggingFace Spaces) ──
-try:
-    import spaces
-    HAS_ZERO_GPU = True
-    print("✅ ZeroGPU available")
-except ImportError:
-    HAS_ZERO_GPU = False
-    print("ℹ️  ZeroGPU not available (running locally or non-GPU space)")
-
-
 # ════════════════════════════════
 # App Setup
 # ════════════════════════════════
 app = FastAPI(
     title="Disaster AI Inference API",
-    description="Multi-model disaster scene analysis API for Dokai/RoboXavier",
-    version="1.0.0",
+    description="Multi-model disaster scene analysis for Dokai / RoboXavier",
+    version="2.0.0",
 )
 
 app.add_middleware(
@@ -70,7 +42,7 @@ app.add_middleware(
 # ════════════════════════════════
 # Configuration
 # ════════════════════════════════
-HF_VICTIM_MODEL_REPO = os.getenv("HF_VICTIM_MODEL_REPO", "EgoisticCoderX/dokai-victim-detection")
+HF_VICTIM_MODEL_REPO = os.getenv("HF_VICTIM_MODEL_REPO", "")
 ROBOFLOW_API_KEY     = os.getenv("ROBOFLOW_API_KEY", "")
 MODEL_CACHE_DIR      = "/tmp/model_cache"
 os.makedirs(MODEL_CACHE_DIR, exist_ok=True)
@@ -89,84 +61,137 @@ CLASS_PRIORITY = {
     "rescue_personnel":  0.0,
 }
 
-
 # ════════════════════════════════
-# Model Registry — lazy loading
+# Model Registry
 # ════════════════════════════════
 class ModelRegistry:
-    """
-    Lazy-loads models on first request.
-    Prevents OOM on Space startup.
-    """
     def __init__(self):
-        self._models    = {}
-        self._lock      = threading.Lock()
-        self._loading   = set()
+        self._models  = {}
+        self._errors  = {}
+        self._lock    = threading.Lock()
 
-    def get(self, name: str):
-        if name in self._models:
-            return self._models[name]
-        return None
+    def get(self, name):
+        return self._models.get(name)
 
-    def register(self, name: str, model):
+    def register(self, name, model):
         with self._lock:
             self._models[name] = model
         print(f"✅ Model registered: {name}")
 
-    def is_loaded(self, name: str) -> bool:
-        return name in self._models
-
+    def set_error(self, name, error):
+        with self._lock:
+            self._errors[name] = str(error)
+        print(f"❌ Model error [{name}]: {error}")
 
-registry = ModelRegistry()
+    def is_loaded(self, name):
+        return name in self._models
 
+    def get_error(self, name):
+        return self._errors.get(name, "Unknown error")
 
-def load_victim_model():
-    """Download + load YOLOv8 victim detection model from HuggingFace."""
-    if registry.is_loaded("victim"):
-        return registry.get("victim")
+    def status(self):
+        return {
+            "loaded":  list(self._models.keys()),
+            "errored": {k: v for k, v in self._errors.items()},
+        }
 
-    try:
-        from ultralytics import YOLO
-        model_path = hf_hub_download(
-            repo_id=HF_VICTIM_MODEL_REPO,
-            filename="best.pt",
-            cache_dir=MODEL_CACHE_DIR,
-        )
-        model = YOLO(model_path)
-        registry.register("victim", model)
-        return model
-    except Exception as e:
-        print(f"❌ Failed to load victim model: {e}")
-        return None
+registry = ModelRegistry()
 
+# ════════════════════════════════
+# Model Loaders
+# ════════════════════════════════
 
 def load_ladi_model():
-    """Load LADI-v2 classifier from HuggingFace."""
+    """Load LADI-v2 classifier from HuggingFace Hub."""
     if registry.is_loaded("ladi"):
         return registry.get("ladi")
 
     try:
         from transformers import AutoImageProcessor, AutoModelForImageClassification
+
+        print("⬇️  Loading MITLL/LADI-v2-classifier-small ...")
+
         processor = AutoImageProcessor.from_pretrained(
             "MITLL/LADI-v2-classifier-small",
             cache_dir=MODEL_CACHE_DIR,
         )
+
         model = AutoModelForImageClassification.from_pretrained(
             "MITLL/LADI-v2-classifier-small",
             cache_dir=MODEL_CACHE_DIR,
+            trust_remote_code=True,
+            ignore_mismatched_sizes=True,
         )
         model.eval()
+
+        # CPU only on HF free tier
         registry.register("ladi", {"model": model, "processor": processor})
+        print("✅ LADI-v2 ready")
         return registry.get("ladi")
+
     except Exception as e:
-        print(f"❌ Failed to load LADI model: {e}")
+        print(f"❌ LADI-v2 load failed:\n{traceback.format_exc()}")
+        registry.set_error("ladi", e)
         return None
 
 
+def load_victim_model():
+    """Load YOLOv8 victim detection model from HuggingFace Hub."""
+    if registry.is_loaded("victim"):
+        return registry.get("victim")
+
+    if not HF_VICTIM_MODEL_REPO:
+        registry.set_error("victim", "HF_VICTIM_MODEL_REPO secret not set — train the model first")
+        return None
+
+    try:
+        from ultralytics import YOLO
+
+        print(f"⬇️  Loading victim model from {HF_VICTIM_MODEL_REPO} ...")
+        model_path = hf_hub_download(
+            repo_id=HF_VICTIM_MODEL_REPO,
+            filename="best.pt",
+            cache_dir=MODEL_CACHE_DIR,
+        )
+        model = YOLO(model_path)
+        registry.register("victim", model)
+        print("✅ Victim detection model ready")
+        return model
+
+    except Exception as e:
+        print(f"❌ Victim model load failed:\n{traceback.format_exc()}")
+        registry.set_error("victim", e)
+        return None
+
+
+# ════════════════════════════════
+# Startup — preload everything
 # ════════════════════════════════
-# Utility Functions
+@app.on_event("startup")
+async def startup_event():
+    print("\n" + "="*50)
+    print("🚀 Disaster AI API starting up...")
+    print("="*50)
+
+    # Always load LADI — it's a public HF model
+    load_ladi_model()
+
+    # Only load victim model if repo is configured
+    if HF_VICTIM_MODEL_REPO:
+        load_victim_model()
+    else:
+        print("⚠️  Victim model skipped — HF_VICTIM_MODEL_REPO not set")
+        print("   Train the model first, then add the secret to this Space")
+
+    print("="*50)
+    print(f"📊 Registry status: {registry.status()}")
+    print("="*50 + "\n")
+
+
+# ════════════════════════════════
+# Utility
 # ════════════════════════════════
-def read_image_from_upload(file_bytes: bytes) -> np.ndarray:
+def read_image(file_bytes: bytes) -> np.ndarray:
     nparr = np.frombuffer(file_bytes, np.uint8)
     img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
     if img is None:
@@ -175,7 +200,6 @@ def read_image_from_upload(file_bytes: bytes) -> np.ndarray:
 
 
 def call_roboflow(image: np.ndarray, model_id: str, confidence: int = 40) -> list:
-    """Call Roboflow hosted model (ambulance, vest detection)."""
     if not ROBOFLOW_API_KEY:
         return []
     try:
@@ -192,12 +216,12 @@ def call_roboflow(image: np.ndarray, model_id: str, confidence: int = 40) -> lis
         preds = res.json().get("predictions", [])
         return [
             {
-                "class": p["class"],
+                "class":      p["class"],
                 "confidence": round(p["confidence"], 4),
                 "box": {
-                    "xmin": int(p["x"] - p["width"] / 2),
+                    "xmin": int(p["x"] - p["width"]  / 2),
                     "ymin": int(p["y"] - p["height"] / 2),
-                    "xmax": int(p["x"] + p["width"] / 2),
+                    "xmax": int(p["x"] + p["width"]  / 2),
                     "ymax": int(p["y"] + p["height"] / 2),
                 },
             }
@@ -209,31 +233,28 @@ def call_roboflow(image: np.ndarray, model_id: str, confidence: int = 40) -> lis
 
 
 def compute_triage(detections: list) -> dict:
-    """Compute triage priority summary from victim detections."""
     if not detections:
         return {
-            "total": 0,
-            "critical": 0,
-            "high": 0,
-            "moderate": 0,
-            "low": 0,
+            "total": 0, "critical": 0, "high": 0,
+            "moderate": 0, "low": 0,
             "highest_score": 0.0,
             "action": "✅ No victims detected",
+            "ranked_victims": [],
         }
 
     scored = []
     for d in detections:
         cls_name = d.get("class", "")
-        conf = d.get("confidence", 0.5)
-        weight = CLASS_PRIORITY.get(cls_name, 0.5)
-        score = conf * weight
-        rank = (
-            "CRITICAL" if score >= 0.7
-            else "HIGH" if score >= 0.4
-            else "MODERATE" if score >= 0.2
-            else "LOW"
+        conf     = d.get("confidence", 0.5)
+        weight   = CLASS_PRIORITY.get(cls_name, 0.5)
+        score    = round(conf * weight, 4)
+        rank     = (
+            "CRITICAL" if score >= 0.7 else
+            "HIGH"     if score >= 0.4 else
+            "MODERATE" if score >= 0.2 else
+            "LOW"
         )
-        scored.append({**d, "priority_score": round(score, 4), "priority_rank": rank})
+        scored.append({**d, "priority_score": score, "priority_rank": rank})
 
     scored.sort(key=lambda x: x["priority_score"], reverse=True)
 
@@ -243,10 +264,10 @@ def compute_triage(detections: list) -> dict:
     low      = sum(1 for d in scored if d["priority_rank"] == "LOW")
 
     action = (
-        "⚠️ IMMEDIATE RESCUE — Critical victims present" if critical
-        else "🔴 Deploy rescue team — High priority victims" if high
-        else "🟡 Assess and triage — Moderate victims present" if moderate
-        else "🟢 Low priority — Monitor the area"
+        "⚠️ IMMEDIATE RESCUE — Critical victims present"  if critical else
+        "🔴 Deploy rescue team — High priority victims"   if high     else
+        "🟡 Assess and triage — Moderate victims present" if moderate else
+        "🟢 Low priority — Monitor the area"
     )
 
     return {
@@ -268,15 +289,15 @@ def compute_triage(detections: list) -> dict:
 @app.get("/")
 def root():
     return {
-        "service": "Disaster AI Inference API",
-        "version": "1.0.0",
+        "service":   "Disaster AI Inference API",
+        "version":   "2.0.0",
+        "status":    registry.status(),
         "endpoints": {
-            "/health":          "GET  — Service health check",
-            "/detect/victims":  "POST — Victim detection + triage",
-            "/detect/hazards":  "POST — Fire, smoke, building damage",
-            "/detect/vehicles": "POST — Emergency vehicle detection",
-            "/classify":        "POST — LADI-v2 scene classification",
-            "/analyze/full":    "POST — All models in parallel (full analysis)",
+            "GET  /health":          "Health check + model status",
+            "POST /classify":        "LADI-v2 scene classification",
+            "POST /detect/victims":  "Victim detection + triage priority",
+            "POST /detect/vehicles": "Emergency vehicle detection",
+            "POST /analyze/full":    "All models in one call",
         }
     }
 
@@ -284,73 +305,155 @@ def root():
 @app.get("/health")
 def health():
     return {
-        "status": "ok",
-        "models_loaded": {
-            "victim_detection": registry.is_loaded("victim"),
-            "ladi_classifier":  registry.is_loaded("ladi"),
-        },
+        "status":        "ok",
+        "registry":      registry.status(),
         "gpu_available": torch.cuda.is_available(),
-        "timestamp": time.time(),
+        "timestamp":     time.time(),
     }
 
 
+# ─────────────────────────────────────────────
+# LADI-v2 Classification
+# ─────────────────────────────────────────────
+@app.post("/classify")
+async def classify_scene(
+    file:  UploadFile = File(...),
+    top_k: int = 5,
+):
+    """
+    Classify disaster scene using LADI-v2.
+    Returns top-k predicted damage categories with confidence scores.
+    """
+    ladi = load_ladi_model()
+    if ladi is None:
+        raise HTTPException(
+            status_code=503,
+            detail=f"LADI-v2 unavailable: {registry.get_error('ladi')}"
+        )
+
+    contents = await file.read()
+    try:
+        img_pil = Image.open(io.BytesIO(contents)).convert("RGB")
+    except Exception:
+        raise HTTPException(status_code=400, detail="Invalid image")
+
+    model     = ladi["model"]
+    processor = ladi["processor"]
+
+    t0 = time.time()
+    try:
+        inputs = processor(images=img_pil, return_tensors="pt")
+        with torch.no_grad():
+            outputs = model(**inputs)
+        probs = torch.nn.functional.softmax(outputs.logits, dim=-1)[0]
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Inference failed: {e}")
+
+    elapsed = round((time.time() - t0) * 1000, 2)
+
+    id2label  = model.config.id2label
+    all_scores = sorted(
+        [
+            {
+                "class":      id2label[i].lower().replace(" ", "_"),
+                "confidence": round(float(probs[i]), 4),
+            }
+            for i in range(len(probs))
+        ],
+        key=lambda x: x["confidence"],
+        reverse=True,
+    )
+
+    # Exclude water/flood from top predictions (not relevant for rover)
+    relevant = [
+        s for s in all_scores
+        if not any(w in s["class"] for w in ["water", "flood"])
+    ]
+
+    return {
+        "top_predictions":   all_scores[:top_k],
+        "relevant_only":     relevant[:top_k],
+        "all_scores":        all_scores,
+        "inference_time_ms": elapsed,
+    }
+
+
+# ─────────────────────────────────────────────
+# Victim Detection
+# ─────────────────────────────────────────────
 @app.post("/detect/victims")
 async def detect_victims(
-    file: UploadFile = File(...),
+    file:       UploadFile = File(...),
     confidence: float = 0.35,
 ):
     """
     Detect victims and classify by triage priority.
-    Returns detections with priority scores and recommended action.
+    Returns CRITICAL / HIGH / MODERATE / LOW ranked detections.
     """
-    contents = await file.read()
-    img = read_image_from_upload(contents)
-
     model = load_victim_model()
     if model is None:
-        raise HTTPException(status_code=503, detail="Victim detection model unavailable")
+        raise HTTPException(
+            status_code=503,
+            detail=f"Victim model unavailable: {registry.get_error('victim')}"
+        )
+
+    contents = await file.read()
+    img      = read_image(contents)
 
     t0 = time.time()
-    results = model.predict(source=img, conf=confidence, verbose=False)
+    try:
+        results = model.predict(source=img, conf=confidence, verbose=False)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Inference failed: {e}")
     elapsed = round((time.time() - t0) * 1000, 2)
 
-    raw_detections = []
+    raw = []
     for r in results:
         for box in r.boxes:
             x1, y1, x2, y2 = map(int, box.xyxy[0].tolist())
             conf_val = float(box.conf[0])
             cls_id   = int(box.cls[0])
-            raw_detections.append({
+            raw.append({
                 "class":      TARGET_CLASSES.get(cls_id, "unknown"),
                 "class_id":   cls_id,
                 "confidence": round(conf_val, 4),
                 "box": {"xmin": x1, "ymin": y1, "xmax": x2, "ymax": y2},
             })
 
-    triage = compute_triage(raw_detections)
+    triage   = compute_triage(raw)
+    victims  = triage.pop("ranked_victims", raw)
 
     return {
-        "detections":       triage.pop("ranked_victims", raw_detections),
-        "triage_summary":   triage,
+        "detections":        victims,
+        "triage_summary":    triage,
         "inference_time_ms": elapsed,
     }
 
 
+# ─────────────────────────────────────────────
+# Emergency Vehicle Detection
+# ─────────────────────────────────────────────
 @app.post("/detect/vehicles")
 async def detect_vehicles(file: UploadFile = File(...)):
-    """Detect emergency vehicles using Roboflow model."""
+    """
+    Detect emergency vehicles using Roboflow.
+    Returns ambulance / fire truck / rescue vehicle detections.
+    """
+    if not ROBOFLOW_API_KEY:
+        raise HTTPException(status_code=503, detail="ROBOFLOW_API_KEY secret not set")
+
     contents = await file.read()
-    img = read_image_from_upload(contents)
+    img = read_image(contents)
 
-    t0 = time.time()
+    t0         = time.time()
     detections = call_roboflow(img, "ambulance-4bova/1", confidence=40)
-    elapsed = round((time.time() - t0) * 1000, 2)
+    elapsed    = round((time.time() - t0) * 1000, 2)
 
-    has_ambulance  = any("ambulance" in d["class"].lower() for d in detections)
-    has_fire_truck = any("fire" in d["class"].lower() for d in detections)
+    has_ambulance  = any("ambulance"  in d["class"].lower() for d in detections)
+    has_fire_truck = any("fire"       in d["class"].lower() for d in detections)
 
     return {
-        "detections":           detections,
+        "detections": detections,
         "emergency_vehicles": {
             "ambulance_detected":  has_ambulance,
             "fire_truck_detected": has_fire_truck,
@@ -360,128 +463,84 @@ async def detect_vehicles(file: UploadFile = File(...)):
     }
 
 
-@app.post("/classify")
-async def classify_scene(file: UploadFile = File(...), top_k: int = 5):
-    """Classify disaster scene using LADI-v2."""
-    contents = await file.read()
-    img_pil = Image.open(io.BytesIO(contents)).convert("RGB")
-
-    ladi = load_ladi_model()
-    if ladi is None:
-        raise HTTPException(status_code=503, detail="LADI-v2 model unavailable")
-
-    model     = ladi["model"]
-    processor = ladi["processor"]
-
-    t0 = time.time()
-    inputs = processor(images=img_pil, return_tensors="pt")
-    with torch.no_grad():
-        outputs = model(**inputs)
-    probs = torch.nn.functional.softmax(outputs.logits, dim=-1)[0]
-    elapsed = round((time.time() - t0) * 1000, 2)
-
-    id2label = model.config.id2label
-    all_scores = sorted(
-        [
-            {
-                "class": id2label[i].lower().replace(" ", "_"),
-                "confidence": round(float(probs[i]), 4),
-            }
-            for i in range(len(probs))
-        ],
-        key=lambda x: x["confidence"],
-        reverse=True,
-    )
-
-    return {
-        "top_predictions":   all_scores[:top_k],
-        "all_scores":        all_scores,
-        "inference_time_ms": elapsed,
-    }
-
-
+# ─────────────────────────────────────────────
+# Full Analysis — all models in one call
+# ─────────────────────────────────────────────
 @app.post("/analyze/full")
 async def full_analysis(
-    file: UploadFile = File(...),
+    file:         UploadFile = File(...),
     run_victims:  bool = True,
     run_vehicles: bool = True,
     run_classify: bool = True,
 ):
     """
-    Run all available models in parallel on one image.
-    This is what your rover Flask app should call for full scene analysis.
+    Run all available models on one image.
+    This is the main endpoint your rover Flask app should call.
 
-    Returns a unified JSON with all detections + zone scoring.
+    Returns unified JSON with zone color, all detections, triage summary.
     """
-    import asyncio
-    from concurrent.futures import ThreadPoolExecutor
-
     contents = await file.read()
-    t_total = time.time()
-
-    results = {}
-
-    with ThreadPoolExecutor(max_workers=3) as executor:
-        futures = {}
-
-        if run_victims:
-            async def _victims():
-                f = UploadFile(filename="frame.jpg", file=io.BytesIO(contents))
-                return await detect_victims(f)
-            futures["victims"] = asyncio.ensure_future(_victims())
-
-        if run_vehicles:
-            async def _vehicles():
-                f = UploadFile(filename="frame.jpg", file=io.BytesIO(contents))
-                return await detect_vehicles(f)
-            futures["vehicles"] = asyncio.ensure_future(_vehicles())
-
-        if run_classify:
-            async def _classify():
-                f = UploadFile(filename="frame.jpg", file=io.BytesIO(contents))
-                return await classify_scene(f)
-            futures["classification"] = asyncio.ensure_future(_classify())
-
-        for key, fut in futures.items():
-            try:
-                results[key] = await fut
-            except Exception as e:
-                results[key] = {"error": str(e)}
-
-    total_ms = round((time.time() - t_total) * 1000, 2)
-
-    # Determine overall zone color
-    victim_data   = results.get("victims", {})
-    triage        = victim_data.get("triage_summary", {})
-    classify_data = results.get("classification", {})
-
-    critical = triage.get("critical", 0)
-    high     = triage.get("high", 0)
-
-    top_class = ""
-    if classify_data.get("top_predictions"):
-        top_class = classify_data["top_predictions"][0].get("class", "")
-
-    if critical > 0 or "destroy" in top_class or "collapse" in top_class:
+    t_total  = time.time()
+    output   = {}
+
+    # ── LADI classification ──
+    if run_classify:
+        try:
+            fake_file = UploadFile(filename="f.jpg", file=io.BytesIO(contents))
+            output["classification"] = await classify_scene(fake_file)
+        except HTTPException as e:
+            output["classification"] = {"error": e.detail}
+        except Exception as e:
+            output["classification"] = {"error": str(e)}
+
+    # ── Victim detection ──
+    if run_victims:
+        try:
+            fake_file = UploadFile(filename="f.jpg", file=io.BytesIO(contents))
+            output["victims"] = await detect_victims(fake_file)
+        except HTTPException as e:
+            output["victims"] = {"error": e.detail}
+        except Exception as e:
+            output["victims"] = {"error": str(e)}
+
+    # ── Vehicle detection ──
+    if run_vehicles:
+        try:
+            fake_file = UploadFile(filename="f.jpg", file=io.BytesIO(contents))
+            output["vehicles"] = await detect_vehicles(fake_file)
+        except HTTPException as e:
+            output["vehicles"] = {"error": e.detail}
+        except Exception as e:
+            output["vehicles"] = {"error": str(e)}
+
+    # ── Zone color ──
+    triage_data  = output.get("victims",        {}).get("triage_summary", {})
+    classify_top = output.get("classification", {}).get("top_predictions", [{}])
+    top_class    = classify_top[0].get("class", "") if classify_top else ""
+
+    critical = triage_data.get("critical", 0)
+    high     = triage_data.get("high",     0)
+
+    if critical > 0 or any(w in top_class for w in ["destroy", "collapse", "major"]):
         zone_color = "red"
-    elif high > 0 or "major_damage" in top_class:
+    elif high > 0 or "minor_damage" in top_class:
         zone_color = "orange"
-    elif triage.get("total", 0) > 0:
+    elif triage_data.get("total", 0) > 0:
         zone_color = "yellow"
     else:
         zone_color = "green"
 
     return {
-        "zone_color":       zone_color,
-        "results":          results,
-        "total_time_ms":    total_ms,
-        "timestamp":        time.time(),
+        "zone_color":    zone_color,
+        "results":       output,
+        "total_time_ms": round((time.time() - t_total) * 1000, 2),
+        "timestamp":     time.time(),
     }
 
 
 # ════════════════════════════════
-# Entry Point (local testing)
+# Entry Point
 # ════════════════════════════════
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)  # HF Spaces default port
+    uvicorn.run(app, host="0.0.0.0", port=7860)