Mount FastAPI routes into Gradio space app

README.md

@@ -1,10 +1,10 @@
 ---
 title: GenAI-DeepDetect
-emoji: 🔍
+emoji: "🔍"
 colorFrom: red
 colorTo: gray
 sdk: gradio
-sdk_version: '4.44.0'
+sdk_version: "5.23.0"
 app_file: app.py
 pinned: true
 hardware: zero-gpu
@@ -13,8 +13,15 @@ license: mit
 
 # GenAI-DeepDetect
 
-Gradio-based Hugging Face Space for multimodal deepfake detection and generator
-attribution.
+Gradio Space with FastAPI routes mounted into the same ASGI app.
 
-The app runs four modules per uploaded video: LipFD lip-sync detection, CLIP
-style fingerprinting, SSTGNN graph analysis, and NVIDIA NIM explanation.
+Frontend/API endpoints:
+
+- `GET /health`
+- `GET /health/models`
+- `POST /detect/image`
+- `POST /detect/video`
+
+Interactive Gradio demo:
+
+- `GET /gradio`

app.py

@@ -1,84 +1,58 @@
 from __future__ import annotations
 
-import os
-import time
+import io
+import mimetypes
+from pathlib import Path
 
 import gradio as gr
-import spaces
+import uvicorn
+from fastapi import HTTPException, UploadFile
+from starlette.datastructures import Headers
 
-from modules.m1_lipsync import LipSyncModule
-from modules.m2_fingerprint import FingerprintModule
-from modules.m3_sstgnn import SSTGNNModule
-from modules.m5_explain import ExplainModule
-from modules.m5_fusion import FusionModule
+from src.api.main import IMAGE_TYPES, VIDEO_TYPES, app as api_app
+from src.api.main import detect_image, detect_video
 
 
-CACHE = "/data/model_cache" if os.path.exists("/data") else "./cache"
-os.makedirs(CACHE, exist_ok=True)
-os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
-
-print("Loading modules on CPU...")
-m1 = LipSyncModule(cache_dir=CACHE)
-m2 = FingerprintModule(cache_dir=CACHE)
-m3 = SSTGNNModule(cache_dir=CACHE)
-m5_fusion = FusionModule(weights_path="weights/fusion_mlp.pt")
-m5_explain = ExplainModule()
-print("Ready. GPU will be allocated per request via ZeroGPU.")
-
-
-@spaces.GPU(duration=120)
-def analyze(video_file: str | None):
-    if video_file is None:
-        return "Upload a video.", "", "", ""
-
-    start = time.time()
+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}),
+    )
 
-    m1.to_gpu()
-    m2.to_gpu()
-    m3.to_gpu()
 
-    try:
-        r1 = m1.score(video_file)
-        r2 = m2.score(video_file)
-        r3 = m3.score(video_file)
-    finally:
-        m1.to_cpu()
-        m2.to_cpu()
-        m3.to_cpu()
-
-    fusion = m5_fusion.fuse(r1["s1"], r2["s2"], r3["s3"])
-    explanation = m5_explain.explain(
-        fakescore=fusion["FakeScore"],
-        s1=r1["s1"],
-        s2=r2["s2"],
-        s3=r3["s3"],
-        weights=fusion["weights"],
-        attribution=r2["attribution"],
-        segments=r1.get("segments", []),
-        top_generator=r2["top_generator"],
+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()
 
-    elapsed = time.time() - start
-    verdict = "FAKE" if fusion["FakeScore"] > 0.5 else "REAL"
-    icon = "RED" if verdict == "FAKE" else "GREEN"
-    verdict_text = f"{icon} **{verdict}** (FakeScore: {fusion['FakeScore']:.3f})"
 
-    scores_text = f"""**Per-Module Scores:**
-- Lip-Sync (M1): {r1['s1']:.3f} [weight: {fusion['weights']['lip_sync']:.2f}]
-- Fingerprint (M2): {r2['s2']:.3f} [weight: {fusion['weights']['fingerprint']:.2f}]
-- Graph-GNN (M3): {r3['s3']:.3f} [weight: {fusion['weights']['graph_gnn']:.2f}]
+async def analyze_media(file_path: str | None) -> tuple[str, str, dict]:
+    if not file_path:
+        return "Upload an image or video.", "", {}
 
-**Time:** {elapsed:.1f}s | **Hardware:** A10G (ZeroGPU)"""
+    upload = _build_upload(file_path)
+    content_type = (upload.content_type or "").split(";")[0].strip().lower()
 
-    attr_text = "**Generator Attribution:**\n"
-    if r2["attribution"]:
-        for gen, prob in sorted(r2["attribution"].items(), key=lambda item: -item[1]):
-            bar = "#" * int(prob * 30)
-            attr_text += f"- {gen}: {prob * 100:.1f}% {bar}\n"
-    else:
-        attr_text += "- N/A (classified as real)"
+    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 verdict_text, scores_text, attr_text, explanation
+    return _response_to_markdown(response)
 
 
 with gr.Blocks(
@@ -87,30 +61,38 @@ with gr.Blocks(
 ) as demo:
     gr.Markdown(
         "# GenAI-DeepDetect\n"
-        "### Multimodal Deepfake Detection and Attribution\n"
-        "**Modules:** LipFD | CLIP Detector | SSTGNN | Llama-3.1-8B via NVIDIA NIM | "
-        "**Hardware:** ZeroGPU (A10G)"
+        "FastAPI routes stay at the Space root for your frontend.\n"
+        "This Gradio UI is mounted at `/gradio` on the same app."
     )
 
     with gr.Row():
         with gr.Column(scale=1):
-            vid = gr.Video(label="Upload Video", height=300)
-            btn = gr.Button("Analyze", variant="primary", size="lg")
+            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):
-            v_out = gr.Markdown(label="Verdict")
-            s_out = gr.Markdown(label="Scores")
-
-    with gr.Row():
-        a_out = gr.Markdown(label="Attribution")
-        e_out = gr.Markdown(label="Explanation")
+            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],
+    )
 
-    btn.click(fn=analyze, inputs=[vid], outputs=[v_out, s_out, a_out, e_out])
 
-    gr.Markdown(
-        "---\n**Paper:** GenAI-DeepDetect | "
-        "**Authors:** Akshat Agarwal, Dev Chopda | SRM IST"
-    )
+app = gr.mount_gradio_app(
+    api_app,
+    demo,
+    path="/gradio",
+    show_error=True,
+    ssr_mode=False,
+)
 
 
 if __name__ == "__main__":
-    demo.launch()
+    uvicorn.run(app, host="0.0.0.0", port=7860, workers=1)

requirements.txt

@@ -1,14 +1,28 @@
-spaces>=0.28.0
+gradio==5.23.0
+fastapi>=0.111.0
+uvicorn[standard]>=0.29.0
+python-multipart>=0.0.9
+aiofiles>=23.2.1
+httpx>=0.27.0
+python-dotenv>=1.0.1
+pydantic>=2.7.0,<2.11
+
 torch>=2.1.0
 torchvision>=0.16.0
 torchaudio>=2.1.0
-torch-geometric>=2.4.0
-transformers>=4.36.0
-gradio>=4.44.0
-opencv-python-headless>=4.8.0
-librosa>=0.10.0
-numpy>=1.24.0
-Pillow>=10.0.0
+transformers>=4.40.0
+timm>=1.0.0
+
+mediapipe>=0.10.14
+opencv-python-headless>=4.9.0
+librosa>=0.10.2
+scipy>=1.13.0
+facenet-pytorch>=2.5.3; python_version < "3.13"
+
+Pillow>=10.3.0
+numpy>=1.26.0
+scikit-learn>=1.5.0
+soundfile>=0.12.1
+
 openai>=1.0.0
-huggingface-hub>=0.19.3,<1.0
-soundfile>=0.12.0
+huggingface-hub>=0.23.0,<1.0

src/api/main.py

@@ -14,7 +14,7 @@ import numpy as np
 from dotenv import load_dotenv
 from fastapi import FastAPI, File, HTTPException, UploadFile
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import HTMLResponse
+from fastapi.responses import HTMLResponse, RedirectResponse
 from PIL import ExifTags, Image
 
 from src.continual.novelty_detector import NoveltyDetector
@@ -252,8 +252,8 @@ def _model_inventory() -> dict[str, object]:
 
 
 @app.get("/", response_class=HTMLResponse)
-async def root() -> HTMLResponse:
-    return HTMLResponse("<h1>GenAI-DeepDetect API</h1><p>See /docs</p>")
+async def root() -> RedirectResponse:
+    return RedirectResponse(url="/gradio", status_code=307)
 
 
 @app.on_event("startup")
@@ -262,6 +262,11 @@ async def preload() -> None:
         logger.info("Skipping startup preload in test mode")
         return
 
+    backend = get_inference_backend()
+    if backend in {"hf", "runpod"}:
+        logger.info("Skipping local model preload for backend=%s", backend)
+        return
+
     logger.info("Preloading models...")
     # Keep model imports/loads sequential to avoid lazy-import race issues.
     await asyncio.to_thread(_fp._ensure)

tests/test_api.py

@@ -51,9 +51,9 @@ def test_health_models_returns_inventory(client):
 # ── GET / ─────────────────────────────────────────────────────────────────────
 
 def test_root_returns_html(client):
-    r = client.get("/")
-    assert r.status_code == 200
-    assert "text/html" in r.headers["content-type"]
+    r = client.get("/", follow_redirects=False)
+    assert r.status_code == 307
+    assert r.headers["location"] == "/gradio"
 
 
 # ── POST /detect/image ────────────────────────────────────────────────────────

tests/test_zero_gpu_contract.py

@@ -23,26 +23,33 @@ def _load_module(path: str, name: str):
     return module
 
 
-def test_readme_declares_zero_gpu_space_metadata():
+def test_readme_declares_gradio_space_metadata():
     readme = (ROOT / "README.md").read_text(encoding="utf-8")
 
-    assert "hardware: zero-gpu" in readme
-    assert "sdk_version: '4.44.0'" in readme
+    assert "sdk: gradio" in readme
+    assert 'sdk_version: "5.23.0"' in readme
     assert "app_file: app.py" in readme
 
 
-def test_app_uses_fallback_sstgnn_and_spaces_gpu_decorator():
+def test_app_mounts_gradio_onto_fastapi():
     source = (ROOT / "app.py").read_text(encoding="utf-8")
-    tree = ast.parse(source)
 
-    assert "from modules.m3_fallback import SSTGNNModule" in source
-    assert "import spaces" in source
+    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="/gradio"' in source
+    assert 'uvicorn.run(app, host="0.0.0.0", port=7860, workers=1)' in source
+
+
+def test_api_root_redirects_to_gradio():
+    source = (ROOT / "src" / "api" / "main.py").read_text(encoding="utf-8")
+    tree = ast.parse(source)
 
-    analyze = next(
-        node for node in tree.body if isinstance(node, ast.FunctionDef) and node.name == "analyze"
+    assert "RedirectResponse" in source
+    assert 'return RedirectResponse(url="/gradio", status_code=307)' in source
+    assert any(
+        isinstance(node, ast.AsyncFunctionDef) and node.name == "root"
+        for node in tree.body
     )
-    decorator_names = [ast.unparse(decorator) for decorator in analyze.decorator_list]
-    assert any(name.startswith("spaces.GPU(") for name in decorator_names)
 
 
 def test_gpu_modules_expose_zero_gpu_device_transfer_methods():
@@ -69,10 +76,9 @@ def test_sstgnn_architecture_module_exists():
 
 def test_required_space_files_exist():
     for path in (
-        "packages.txt",
+        "app.py",
+        "src/api/main.py",
         ".env.example",
-        "weights/fusion_mlp.pt",
-        "lipfd/model.py",
     ):
         assert (ROOT / path).exists()