Use Blocks launch entrypoint for Space runtime

app.py

@@ -1,15 +1,17 @@
 from __future__ import annotations
 
+import asyncio
 import os
 import sys
+import time
 import traceback
+from typing import Any
 
+import gradio as gr
 from fastapi import File, UploadFile
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import HTMLResponse, RedirectResponse
-from gradio import Server
+from fastapi.responses import RedirectResponse
 
-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
@@ -30,79 +32,107 @@ def _normalize_gradio_env() -> None:
     os.environ.pop("GRADIO_NODE_SERVER_PORT", None)
 
 
-_normalize_gradio_env()
-app = Server()
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
+def _build_demo() -> gr.Blocks:
+    with gr.Blocks(title="GenAI-DeepDetect") as demo:
+        gr.Markdown(
+            """
+            # GenAI-DeepDetect
 
+            Gradio frontend with API routes attached to the same app for your external frontend.
 
-@app.api(name="ping", queue=False)
-def ping() -> str:
-    return "ok"
+            Available API endpoints:
+            - `GET /api/health`
+            - `GET /api/health/models`
+            - `POST /api/detect/image`
+            - `POST /api/detect/video`
+            """
+        )
+    return demo
 
 
-@app.on_event("startup")
-async def startup() -> None:
-    await api_preload()
-
-
-@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_route() -> dict:
-    return await health()
+def _attach_api_routes(app: Any) -> None:
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
 
+    async def health() -> dict:
+        return await api_health()
 
-@app.get("/health/models")
-async def health_models() -> dict[str, object]:
-    return await api_health_models()
+    async def api_health_route() -> dict:
+        return await health()
 
+    async def health_models() -> dict[str, object]:
+        return await api_health_models()
 
-@app.get("/api/health/models")
-async def api_health_models_route() -> dict[str, object]:
-    return await health_models()
+    async def api_health_models_route() -> dict[str, object]:
+        return await health_models()
 
+    async def detect_image(file: UploadFile = File(...)) -> DetectionResponse:
+        return await api_detect_image(file)
 
-@app.post("/detect/image", response_model=DetectionResponse)
-async def detect_image(file: UploadFile = File(...)) -> DetectionResponse:
-    return await api_detect_image(file)
+    async def api_detect_image_route(file: UploadFile = File(...)) -> DetectionResponse:
+        return await detect_image(file)
 
+    async def detect_video(file: UploadFile = File(...)) -> DetectionResponse:
+        return await api_detect_video(file)
 
-@app.post("/api/detect/image", response_model=DetectionResponse)
-async def api_detect_image_route(file: UploadFile = File(...)) -> DetectionResponse:
-    return await detect_image(file)
+    async def api_detect_video_route(file: UploadFile = File(...)) -> DetectionResponse:
+        return await detect_video(file)
 
+    async def gradio_compat_redirect() -> RedirectResponse:
+        return RedirectResponse(url="/", status_code=307)
 
-@app.post("/detect/video", response_model=DetectionResponse)
-async def detect_video(file: UploadFile = File(...)) -> DetectionResponse:
-    return await api_detect_video(file)
+    app.add_api_route("/health", health, methods=["GET"])
+    app.add_api_route("/api/health", api_health_route, methods=["GET"])
+    app.add_api_route("/health/models", health_models, methods=["GET"])
+    app.add_api_route("/api/health/models", api_health_models_route, methods=["GET"])
+    app.add_api_route(
+        "/detect/image",
+        detect_image,
+        methods=["POST"],
+        response_model=DetectionResponse,
+    )
+    app.add_api_route(
+        "/api/detect/image",
+        api_detect_image_route,
+        methods=["POST"],
+        response_model=DetectionResponse,
+    )
+    app.add_api_route(
+        "/detect/video",
+        detect_video,
+        methods=["POST"],
+        response_model=DetectionResponse,
+    )
+    app.add_api_route(
+        "/api/detect/video",
+        api_detect_video_route,
+        methods=["POST"],
+        response_model=DetectionResponse,
+    )
+    app.add_api_route("/gradio", gradio_compat_redirect, methods=["GET"])
 
 
-@app.post("/api/detect/video", response_model=DetectionResponse)
-async def api_detect_video_route(file: UploadFile = File(...)) -> DetectionResponse:
-    return await detect_video(file)
+demo = _build_demo().queue()
 
 
 if __name__ == "__main__":
     _install_excepthook()
-    app.launch(
-        show_error=True,
-        ssr_mode=False,
-    )
+    _normalize_gradio_env()
+    try:
+        asyncio.run(api_preload())
+        app, _, _ = demo.launch(
+            prevent_thread_lock=True,
+            show_error=True,
+            ssr_mode=False,
+            app_kwargs={"docs_url": "/docs", "redoc_url": "/redoc"},
+        )
+        _attach_api_routes(app)
+        while True:
+            time.sleep(60)
+    except Exception:
+        traceback.print_exc()
+        sys.exit(1)

tests/test_zero_gpu_contract.py

@@ -34,13 +34,17 @@ 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 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 "from gradio import Server" not in source
+    assert "demo = _build_demo().queue()" in source
+    assert "prevent_thread_lock=True" in source
+    assert "while True:" in source
+    assert 'app_kwargs={"docs_url": "/docs", "redoc_url": "/redoc"}' in source
+    assert 'app.add_api_route("/api/health"' in source
+    assert "/api/detect/image" in source
+    assert "/api/detect/video" in source
+    assert "def _attach_api_routes(app: Any) -> None:" in source
     assert "show_error=True" in source
-    assert "app.launch(" in source
+    assert "demo.launch(" in source
     assert "ssr_mode=False" in source
     assert 'GRADIO_SSR_MODE"] = "False"' in source
     assert "GRADIO_NODE_SERVER_PORT" in source