Serve frontend API routes via Gradio Server

app.py

@@ -1,27 +1,21 @@
 from __future__ import annotations
 
-import io
-import mimetypes
 import os
 import sys
 import traceback
-from pathlib import Path
 
-import gradio as gr
-import uvicorn
-from fastapi import HTTPException, UploadFile
-from starlette.datastructures import Headers
+from fastapi import File, UploadFile
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import HTMLResponse, RedirectResponse
+from gradio import Server
 
-from src.api.main import IMAGE_TYPES, VIDEO_TYPES, app as api_app
-from src.api.main import detect_image, detect_video
-
-
-def _is_hf_space() -> bool:
-    return os.environ.get("SPACE_ID", "").startswith("akagtag/")
-
-
-def _is_test_mode() -> bool:
-    return "PYTEST_CURRENT_TEST" in os.environ or "pytest" in sys.modules
+from src.api.demo_page import render_demo
+from src.api.main import detect_image as api_detect_image
+from src.api.main import detect_video as api_detect_video
+from src.api.main import health as api_health
+from src.api.main import health_models as api_health_models
+from src.api.main import preload as api_preload
+from src.types import DetectionResponse
 
 
 def _install_excepthook() -> None:
@@ -31,93 +25,78 @@ def _install_excepthook() -> None:
     sys.excepthook = handle_exception
 
 
-def _build_upload(path: str) -> UploadFile:
-    file_path = Path(path)
-    content_type = (mimetypes.guess_type(file_path.name)[0] or "application/octet-stream").lower()
-    return UploadFile(
-        filename=file_path.name,
-        file=io.BytesIO(file_path.read_bytes()),
-        headers=Headers({"content-type": content_type}),
-    )
+app = Server()
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
 
 
-def _response_to_markdown(response) -> tuple[str, str, dict]:
-    summary = (
-        f"## {response.verdict}\n"
-        f"Confidence: {response.confidence:.3f}\n\n"
-        f"Attributed generator: `{response.attributed_generator}`\n"
-        f"Processing time: `{response.processing_time_ms:.2f} ms`"
-    )
-    return summary, response.explanation, response.model_dump()
-
-
-async def analyze_media(file_path: str | None) -> tuple[str, str, dict]:
-    if not file_path:
-        return "Upload an image or video.", "", {}
-
-    upload = _build_upload(file_path)
-    content_type = (upload.content_type or "").split(";")[0].strip().lower()
-
-    try:
-        if content_type in IMAGE_TYPES:
-            response = await detect_image(upload)
-        elif content_type in VIDEO_TYPES:
-            response = await detect_video(upload)
-        else:
-            return f"Unsupported file type: `{content_type or 'unknown'}`", "", {}
-    except HTTPException as exc:
-        return f"Request failed: `{exc.status_code}`", str(exc.detail), {}
-    except Exception as exc:
-        return "Analysis failed.", str(exc), {}
-
-    return _response_to_markdown(response)
-
-
-with gr.Blocks(
-    title="GenAI-DeepDetect",
-    theme=gr.themes.Base(primary_hue="red", font=["DM Sans", "sans-serif"]),
-) as demo:
-    gr.Markdown(
-        "# GenAI-DeepDetect\n"
-        "Gradio runs at the Space root.\n"
-        "The same detection backend powers both the UI and API routes."
-    )
+@app.api(name="ping")
+def ping() -> str:
+    return "ok"
 
-    with gr.Row():
-        with gr.Column(scale=1):
-            media = gr.File(
-                label="Upload Image or Video",
-                type="filepath",
-                file_types=["image", "video"],
-            )
-            analyze_btn = gr.Button("Analyze", variant="primary")
-        with gr.Column(scale=2):
-            verdict = gr.Markdown(label="Verdict")
-            explanation = gr.Markdown(label="Explanation")
-
-    details = gr.JSON(label="Detection Response")
-    analyze_btn.click(
-        fn=analyze_media,
-        inputs=[media],
-        outputs=[verdict, explanation, details],
-    )
 
+@app.on_event("startup")
+async def startup() -> None:
+    await api_preload()
 
-app = gr.mount_gradio_app(
-    api_app,
-    demo,
-    path="/",
-    show_error=True,
-    ssr_mode=False,
-)
+
+@app.get("/", response_class=HTMLResponse)
+async def root() -> HTMLResponse:
+    return HTMLResponse(render_demo())
+
+
+@app.get("/gradio")
+async def gradio_compat_redirect() -> RedirectResponse:
+    return RedirectResponse(url="/", status_code=307)
+
+
+@app.get("/health")
+async def health() -> dict:
+    return await api_health()
+
+
+@app.get("/api/health")
+async def api_health() -> dict:
+    return await health()
+
+
+@app.get("/health/models")
+async def health_models() -> dict[str, object]:
+    return await api_health_models()
+
+
+@app.get("/api/health/models")
+async def api_health_models() -> dict[str, object]:
+    return await health_models()
+
+
+@app.post("/detect/image", response_model=DetectionResponse)
+async def detect_image(file: UploadFile = File(...)) -> DetectionResponse:
+    return await api_detect_image(file)
+
+
+@app.post("/api/detect/image", response_model=DetectionResponse)
+async def api_detect_image_route(file: UploadFile = File(...)) -> DetectionResponse:
+    return await detect_image(file)
+
+
+@app.post("/detect/video", response_model=DetectionResponse)
+async def detect_video(file: UploadFile = File(...)) -> DetectionResponse:
+    return await api_detect_video(file)
+
+
+@app.post("/api/detect/video", response_model=DetectionResponse)
+async def api_detect_video_route(file: UploadFile = File(...)) -> DetectionResponse:
+    return await detect_video(file)
 
 
 if __name__ == "__main__":
-    if _is_hf_space() and not _is_test_mode():
-        _install_excepthook()
-        demo.launch(
-            show_error=True,
-            ssr_mode=False,
-        )
-    else:
-        uvicorn.run(app, host="0.0.0.0", port=7860, workers=1)
+    _install_excepthook()
+    app.launch(
+        show_error=True,
+        ssr_mode=False,
+    )

src/api/main.py

@@ -419,12 +419,22 @@ async def health() -> dict:
     }
 
 
+@app.get("/api/health")
+async def api_health() -> dict:
+    return await health()
+
+
 @app.get("/health/models")
 async def health_models() -> dict[str, object]:
     """Return the pretrained model inventory used by each engine."""
     return _model_inventory()
 
 
+@app.get("/api/health/models")
+async def api_health_models() -> dict[str, object]:
+    return await health_models()
+
+
 def _assign_processing_time(results: list[EngineResult], ms: float) -> list[EngineResult]:
     for result in results:
         result.processing_time_ms = round(ms, 2)
@@ -627,6 +637,11 @@ async def detect_image(file: UploadFile = File(...)) -> DetectionResponse:
     )
 
 
+@app.post("/api/detect/image", response_model=DetectionResponse)
+async def api_detect_image(file: UploadFile = File(...)) -> DetectionResponse:
+    return await detect_image(file)
+
+
 @app.post("/detect/video", response_model=DetectionResponse)
 async def detect_video(file: UploadFile = File(...)) -> DetectionResponse:
     t0 = time.monotonic()
@@ -694,3 +709,8 @@ async def detect_video(file: UploadFile = File(...)) -> DetectionResponse:
         metadata_text,
         t0,
     )
+
+
+@app.post("/api/detect/video", response_model=DetectionResponse)
+async def api_detect_video(file: UploadFile = File(...)) -> DetectionResponse:
+    return await detect_video(file)

tests/test_api.py

@@ -48,6 +48,18 @@ def test_health_models_returns_inventory(client):
     assert "stable_diffusion" in data["generator_labels"]
 
 
+def test_api_prefixed_health_returns_200(client):
+    r = client.get("/api/health")
+    assert r.status_code == 200
+
+
+def test_api_prefixed_health_models_returns_inventory(client):
+    data = client.get("/api/health/models").json()
+    assert "fingerprint" in data
+    assert "coherence" in data
+    assert "sstgnn" in data
+
+
 # ── GET / ─────────────────────────────────────────────────────────────────────
 
 def test_gradio_compat_redirect(client):
@@ -126,6 +138,14 @@ def test_detect_image_processing_time_positive(client, jpeg_bytes):
     assert data["processing_time_ms"] >= 0
 
 
+def test_api_prefixed_detect_image_returns_200(client, jpeg_bytes):
+    r = client.post(
+        "/api/detect/image",
+        files={"file": ("test.jpg", jpeg_bytes, "image/jpeg")},
+    )
+    assert r.status_code == 200
+
+
 # ── POST /detect/video ────────────────────────────────────────────────────────
 
 def test_detect_video_wrong_type_returns_415(client, jpeg_bytes):
@@ -134,3 +154,11 @@ def test_detect_video_wrong_type_returns_415(client, jpeg_bytes):
         files={"file": ("test.jpg", jpeg_bytes, "image/jpeg")},
     )
     assert r.status_code == 415
+
+
+def test_api_prefixed_detect_video_wrong_type_returns_415(client, jpeg_bytes):
+    r = client.post(
+        "/api/detect/video",
+        files={"file": ("test.jpg", jpeg_bytes, "image/jpeg")},
+    )
+    assert r.status_code == 415

tests/test_zero_gpu_contract.py

@@ -34,13 +34,15 @@ def test_readme_declares_gradio_space_metadata():
 def test_app_mounts_gradio_onto_fastapi():
     source = (ROOT / "app.py").read_text(encoding="utf-8")
 
-    assert "from src.api.main import IMAGE_TYPES, VIDEO_TYPES, app as api_app" in source
-    assert "app = gr.mount_gradio_app(" in source
-    assert 'path="/"' in source
-    assert 'demo.launch(' in source
+    assert "from gradio import Server" in source
+    assert "app = Server()" in source
+    assert '@app.get("/api/health")' in source
+    assert '@app.post("/api/detect/image"' in source
+    assert '@app.post("/api/detect/video"' in source
+    assert "app.launch(" in source
     assert 'show_error=True' in source
     assert 'ssr_mode=False' in source
-    assert 'uvicorn.run(app, host="0.0.0.0", port=7860, workers=1)' in source
+    assert "uvicorn.run" not in source
 
 
 def test_api_gradio_compat_redirect_exists():