fix: rewrite app.py - standalone FastAPI with Gradio mounted, fix 422 and missing _run_api_detection

app.py

@@ -5,28 +5,21 @@ import zipfile
 import cv2
 import numpy as np
 import spaces
+from PIL import Image
+import gradio as gr
+from fastapi import FastAPI, File, UploadFile, Form, HTTPException, Request
+from fastapi.responses import JSONResponse, FileResponse
+from fastapi.middleware.cors import CORSMiddleware
 
 # ---------------------------------------------------------------------------
 # Hugging Face ZeroGPU startup probe
 # ---------------------------------------------------------------------------
-# ZeroGPU statically scans the module at startup and requires a module-level
-# @spaces.GPU function. Keep this tiny probe explicit so the Space is detected
-# even when the real GPU handlers are wrapped/imported differently.
 @spaces.GPU
 def _zerogpu_startup_probe():
     return None
 
-from PIL import Image
-import gradio as gr
-from fastapi import FastAPI, File, UploadFile, Form, HTTPException
-from fastapi.responses import JSONResponse, FileResponse
-from fastapi.middleware.cors import CORSMiddleware
-
 # ---------------------------------------------------------------------------
-# Monkey-patch gradio_client bug (Gradio 4.44.0):
-# gradio_client.utils._json_schema_to_python_type crashes with
-# TypeError: argument of type 'bool' is not iterable
-# when a JSON schema has `additionalProperties: true` (a bool, not a dict).
+# Monkey-patch gradio_client bug (Gradio 4.44.0)
 # ---------------------------------------------------------------------------
 import gradio_client.utils as _gc_utils
 
@@ -42,10 +35,6 @@ _gc_utils._json_schema_to_python_type = _safe_json_schema_to_python_type
 # ---------------------------------------------------------------------------
 # Starlette / Gradio TemplateResponse & Jinja2 compatibility
 # ---------------------------------------------------------------------------
-# Gradio 4.44.0 calls TemplateResponse("index.html", {"request": request, ...})
-# Newer Starlette releases expect request as the first argument.
-# When mixed, Starlette misinterprets string vs dict argument order, passing
-# context dict to Jinja2 as template name -> TypeError: unhashable type: 'dict'.
 import jinja2
 
 _orig_get_template = jinja2.Environment.get_template
@@ -95,7 +84,6 @@ from backend.ml.orchestrator import orchestrator
 from backend.database.storage import db
 
 
-
 # ---------------------------------------------------------------------------
 # Helper functions (non-GPU)
 # ---------------------------------------------------------------------------
@@ -337,7 +325,7 @@ with gr.Blocks(css=custom_css, title="Open-World Object Intelligence Platform")
                     similarity_slider
                 ],
                 outputs=[output_img, json_output],
-                api_name="run_detection"
+                api_name="detect"
             )
 
         # -------------------------------------------------------------------
@@ -370,7 +358,7 @@ with gr.Blocks(css=custom_css, title="Open-World Object Intelligence Platform")
                 fn=teach_new_object,
                 inputs=[teach_name, teach_category, teach_desc, teach_files],
                 outputs=[teach_status, objects_df],
-                api_name="teach_object_api"
+                api_name="teach_object"
             )
 
             btn_del.click(
@@ -448,168 +436,143 @@ with gr.Blocks(css=custom_css, title="Open-World Object Intelligence Platform")
             ```
             """)
 
+
 # ---------------------------------------------------------------------------
-# Launch — use demo.launch() so HF ZeroGPU can detect @spaces.GPU functions
+# Build FastAPI app and mount Gradio on it
 # ---------------------------------------------------------------------------
-demo.queue()
+from typing import Optional
+import base64
+
+app = FastAPI(title="Object Intelligence Platform API")
 
-from gradio.routes import App as _GradioApp
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.get("/api/health")
+def api_health():
+    return {
+        "status": "healthy",
+        "models": {
+            "rtdetr": orchestrator.rtdetr.model is not None,
+            "yolo_world": orchestrator.yolo_world.model is not None,
+            "embedding_recognizer": orchestrator.embedding_recognizer.model is not None,
+        },
+        "database": os.path.exists(SQLITE_DB_PATH),
+    }
+
+
+@app.post("/api/detect")
+async def api_detect_route(
+    file: UploadFile = File(...),
+    mode: str = Form("combined"),
+    lock_mode: str = Form("false"),
+    lock_target: str = Form(""),
+    open_vocab_prompts: str = Form(""),
+    vocabulary: str = Form(""),
+    confidence: str = Form(""),
+):
+    contents = await file.read()
+    if not contents:
+        raise HTTPException(status_code=400, detail="Uploaded file is empty")
 
-_original_create = _GradioApp.create_app
+    nparr = np.frombuffer(contents, np.uint8)
+    img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+    if img is None:
+        raise HTTPException(status_code=400, detail="Invalid image file format")
 
-@staticmethod
-def _patched_create(blocks, **kwargs):
-    fastapi_app = _original_create(blocks, **kwargs)
+    is_lock_mode = str(lock_mode).strip().lower() in ("true", "1", "yes")
+    target_val = lock_target or ""
 
-    fastapi_app.add_middleware(
-        CORSMiddleware,
-        allow_origins=["*"],
-        allow_credentials=True,
-        allow_methods=["*"],
-        allow_headers=["*"],
+    try:
+        conf_val = float(confidence) if confidence else KNOWN_CONFIDENCE_THRESHOLD
+    except Exception:
+        conf_val = KNOWN_CONFIDENCE_THRESHOLD
+
+    raw_vocab = open_vocab_prompts or vocabulary
+    prompts = [p.strip() for p in raw_vocab.split(",") if p.strip()] if raw_vocab else None
+
+    annotated_frame, detections, metadata = orchestrator.process_frame(
+        image=img,
+        mode=mode,
+        lock_mode=is_lock_mode,
+        lock_target=target_val,
+        open_vocab_prompts=prompts,
+        confidence_thresh=conf_val
     )
 
-    from fastapi import Request
-    from fastapi.exceptions import RequestValidationError
-    from fastapi.responses import JSONResponse
-
-    @fastapi_app.exception_handler(RequestValidationError)
-    async def safe_validation_exception_handler(request: Request, exc: RequestValidationError):
-        safe_errors = []
-        for err in exc.errors():
-            err_dict = dict(err)
-            if "input" in err_dict and isinstance(err_dict["input"], bytes):
-                err_dict["input"] = f"<binary input: {len(err_dict['input'])} bytes>"
-            safe_errors.append(err_dict)
-        return JSONResponse(status_code=422, content={"detail": safe_errors})
-
-    @fastapi_app.get("/api/health")
-    def api_health():
-        return {
-            "status": "healthy",
-            "models": {
-                "rtdetr": orchestrator.rtdetr.model is not None,
-                "yolo_world": orchestrator.yolo_world.model is not None,
-                "embedding_recognizer": orchestrator.embedding_recognizer.model is not None,
-            },
-            "database": os.path.exists(SQLITE_DB_PATH),
-        }
-
-    from typing import Optional
-
-    @fastapi_app.post("/api/detect")
-    async def api_detect_route(
-        file: Optional[UploadFile] = File(None),
-        mode: Optional[str] = Form(None),
-        lock_mode: Optional[str] = Form(None),
-        lock_target: Optional[str] = Form(None),
-        open_vocab_prompts: Optional[str] = Form(None),
-        vocabulary: Optional[str] = Form(None),
-        confidence: Optional[str] = Form(None),
-    ):
-        try:
-            if file is None:
-                raise HTTPException(status_code=400, detail="Missing required 'file' parameter in form data")
-            
-            contents = await file.read()
-            if not contents:
-                raise HTTPException(status_code=400, detail="Uploaded file is empty")
-                
-            nparr = np.frombuffer(contents, np.uint8)
-            img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
-            if img is None:
-                raise HTTPException(status_code=400, detail="Invalid image file format")
-            
-            mode_val = mode or "combined"
-            target_val = lock_target or ""
-            is_lock_mode = str(lock_mode or "false").strip().lower() in ("true", "1", "yes")
-            
-            try:
-                conf_val = float(confidence) if confidence is not None else KNOWN_CONFIDENCE_THRESHOLD
-            except Exception:
-                conf_val = KNOWN_CONFIDENCE_THRESHOLD
-
-            raw_vocab = open_vocab_prompts or vocabulary
-            prompts = [p.strip() for p in raw_vocab.split(",") if p.strip()] if raw_vocab else None
-            annotated_frame, detections, metadata = _run_api_detection(
-                img, mode_val, is_lock_mode, target_val, prompts, conf_val
-            )
-            import base64
-            _, buffer = cv2.imencode(".png", annotated_frame)
-            img_base64 = base64.b64encode(buffer).decode("utf-8")
-            return JSONResponse(content={"status": "success", "image_base64": img_base64, "metadata": metadata, "detections": detections})
-        except HTTPException:
-            raise
-        except Exception as e:
-            raise HTTPException(status_code=500, detail=str(e))
-
-    @fastapi_app.get("/api/objects")
-    def api_get_objects_route():
-        objs = db.get_all_objects()
-        return [{"id": o.id, "name": o.name, "category": o.category, "images": o.image_count, "image_count": o.image_count} for o in objs]
-
-    @fastapi_app.post("/api/objects")
-    async def api_teach_object_route(
-        name: Optional[str] = Form(None),
-        category: Optional[str] = Form(None),
-        description: Optional[str] = Form(None),
-        files: Optional[list[UploadFile]] = File(None),
-    ):
-        try:
-            if not name or not name.strip():
-                raise HTTPException(status_code=400, detail="Missing required 'name' parameter")
-
-            cat_val = (category or "custom").strip() or "general"
-            desc_val = (description or "").strip()
-
-            existing = db.get_object_by_name(name.strip())
-            obj = existing if existing else db.create_object(name=name.strip(), category=cat_val, description=desc_val)
-            added = 0
-            if files:
-                for uf in files:
-                    contents = await uf.read()
-                    nparr = np.frombuffer(contents, np.uint8)
-                    img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
-                    if img is None:
-                        continue
-                    emb = orchestrator.embedding_recognizer.extract_embedding_from_image(img)
-                    if emb is not None:
-                        db.add_embedding(obj.id, emb.tolist())
-                        db.add_image_record(obj.id, uf.filename or "image")
-                        added += 1
-            return {"status": "success", "message": f"Taught object '{obj.name}' with {added} embeddings", "id": obj.id}
-        except HTTPException:
-            raise
-        except Exception as e:
-            raise HTTPException(status_code=500, detail=str(e))
-
-    @fastapi_app.delete("/api/objects/{object_id}")
-    def api_delete_object_route(object_id: str):
-        if db.delete_object(object_id):
-            return {"status": "deleted"}
-        raise HTTPException(status_code=404, detail="Object not found")
-
-    @fastapi_app.get("/api/downloads/export-db")
-    def api_export_db_route():
-        temp_dir = tempfile.mkdtemp()
-        zip_path = os.path.join(temp_dir, "custom_objects_library.zip")
-        db.export_database_zip(zip_path)
-        return FileResponse(zip_path, filename="custom_objects_library.zip", media_type="application/zip")
-
-    @fastapi_app.get("/api/downloads/requirements")
-    def api_download_requirements_route():
-        req_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "requirements.txt")
-        if os.path.exists(req_path):
-            return FileResponse(req_path, filename="requirements.txt", media_type="text/plain")
-        raise HTTPException(status_code=404, detail="requirements.txt not found")
-
-    return fastapi_app
-
-_GradioApp.create_app = _patched_create
+    _, buffer = cv2.imencode(".png", annotated_frame)
+    img_base64 = base64.b64encode(buffer).decode("utf-8")
+    return JSONResponse(content={"status": "success", "image_base64": img_base64, "metadata": metadata, "detections": detections})
+
+
+@app.get("/api/objects")
+def api_get_objects_route():
+    objs = db.get_all_objects()
+    return [{"id": o.id, "name": o.name, "category": o.category, "images": o.image_count, "image_count": o.image_count} for o in objs]
+
+
+@app.post("/api/objects")
+async def api_teach_object_route(
+    name: str = Form(...),
+    category: str = Form("custom"),
+    description: str = Form(""),
+    files: list[UploadFile] = File(default=[]),
+):
+    if not name or not name.strip():
+        raise HTTPException(status_code=400, detail="Missing required 'name' parameter")
+
+    cat_val = (category or "custom").strip() or "general"
+    desc_val = (description or "").strip()
+
+    existing = db.get_object_by_name(name.strip())
+    obj = existing if existing else db.create_object(name=name.strip(), category=cat_val, description=desc_val)
+    added = 0
+    for uf in files:
+        contents = await uf.read()
+        nparr = np.frombuffer(contents, np.uint8)
+        img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+        if img is None:
+            continue
+        emb = orchestrator.embedding_recognizer.extract_embedding_from_image(img)
+        if emb is not None:
+            db.add_embedding(obj.id, emb.tolist())
+            db.add_image_record(obj.id, uf.filename or "image")
+            added += 1
+    return {"status": "success", "message": f"Taught object '{obj.name}' with {added} embeddings", "id": obj.id}
+
+
+@app.delete("/api/objects/{object_id}")
+def api_delete_object_route(object_id: str):
+    if db.delete_object(object_id):
+        return {"status": "deleted"}
+    raise HTTPException(status_code=404, detail="Object not found")
+
+
+@app.get("/api/downloads/export-db")
+def api_export_db_route():
+    temp_dir = tempfile.mkdtemp()
+    zip_path = os.path.join(temp_dir, "custom_objects_library.zip")
+    db.export_database_zip(zip_path)
+    return FileResponse(zip_path, filename="custom_objects_library.zip", media_type="application/zip")
+
+
+@app.get("/api/downloads/requirements")
+def api_download_requirements_route():
+    req_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "requirements.txt")
+    if os.path.exists(req_path):
+        return FileResponse(req_path, filename="requirements.txt", media_type="text/plain")
+    raise HTTPException(status_code=404, detail="requirements.txt not found")
+
+
+# Mount Gradio on the FastAPI app
+app = gr.mount_gradio_app(app, demo, path="/")
 
 if __name__ == "__main__":
+    import uvicorn
     port = int(os.environ.get("PORT", os.environ.get("GRADIO_SERVER_PORT", "7860")))
-    demo.launch(server_name="0.0.0.0", server_port=port)
-else:
-    port = int(os.environ.get("PORT", os.environ.get("GRADIO_SERVER_PORT", "7860")))
-    demo.launch(server_name="0.0.0.0", server_port=port)
+    uvicorn.run(app, host="0.0.0.0", port=port)