Add application file

README.md

@@ -65,9 +65,9 @@ With Compose, set the same build arg and uncomment the `deploy` block in `docker
 
 ## Hugging Face Space
 
-This folder is also a Gradio Space, set up for ZeroGPU hardware (it also runs on a CPU Space). `app.py` serves the same FastAPI app as the container, so the page at `/` and the API at `/api/*` are identical. A Gradio app is mounted at `/gradio`: a small form and a `decide` endpoint for `gradio_client`, running the same decision code.
+This folder is also a Gradio Space, set up for ZeroGPU hardware (it also runs on a CPU Space). `app.py` starts the Space through Gradio's own `launch()` (ZeroGPU needs it) and puts the lab's routes in front of Gradio's, so the page at `/` and the API at `/api/*` are the container's. Gradio's `decide` endpoint stays available for `gradio_client`, running the same decision code.
 
-On ZeroGPU a GPU is attached for each decision. The Space starts serving at once and the models load in the background, as in the container. Each model's time is measured on the GPU, and the round trip also includes the GPU hand-off. Each decision uses your ZeroGPU quota, so a full scoreboard run (one decision per demo) uses more of it.
+On ZeroGPU a GPU is attached for each decision. The models load before the Space starts serving (ZeroGPU prepares them at startup). Each model's time is measured on the GPU, and the round trip also includes the GPU hand-off. Each decision uses your ZeroGPU quota, so a full scoreboard run (one decision per demo) uses more of it.
 
 There is no token on the Space: on a public Space anyone can use the page and the API. Make the Space private on Hugging Face if that is not what you want.
 
@@ -80,7 +80,7 @@ cd <your-space>
 git lfs install
 # copy the contents of this DecisionLab folder into it (not the folder itself), then:
 git add .
-git commit -m "DecisionLab 2.1.1"
+git commit -m "DecisionLab 2.1.2"
 git push
 ```
 

app.py

@@ -4,17 +4,19 @@ The Space runs this file. It serves the SAME FastAPI app as the container, so th
 JavaScript) and /api/* are the container's. A Gradio app is mounted beside it at /gradio: a small form and a "decide"
 API endpoint for gradio_client, both running the same decision code (app.main.run_decision).
 
-ZeroGPU (Hugging Face docs, checked 2026-09-28):
+ZeroGPU (Hugging Face docs and the `spaces` package source, checked 2026-09-30):
   - `import spaces` comes first: it patches torch so CUDA looks available everywhere; outside @spaces.GPU a CUDA
     emulation mode lets models be moved to "cuda" without a real GPU. A real GPU exists only inside @spaces.GPU calls.
-  - Decorated calls run apart from the main process: only the model-running step is decorated; the request checks and
-    the concurrency limit stay in the main process.
-  - The server starts serving AT ONCE and the models load in the background (the page shows their progress, as in the
-    container). ZeroGPU gives a Space limited time to start: loading ~2.6 GB of models before serving made it report
-    "No @spaces.GPU function detected during startup" and take port 7860 for its error page (2.1.0, 2026-09-30).
-  - Gradio's server-side rendering is off: its Node proxy would also want port 7860.
-  - Each model times itself inside the GPU call, so model timings stay comparable; the GPU hand-off only adds to the
-    round trip.
+  - ZeroGPU's startup step (spaces/zero/__init__.py: `gradio.one_launch(torch.pack)`) runs inside Gradio's own
+    Blocks.launch(). So this file starts the server with demo.launch(), NOT uvicorn + mount_gradio_app: without
+    launch() the step never runs and the Space fails with "No @spaces.GPU function detected during startup"
+    (2.1.0 and 2.1.1, 2026-09-30).
+  - Models are loaded BEFORE launch(), so the startup step packs them (the documented ZeroGPU pattern).
+  - The lab's routes (the page at "/", /static, /api/*) are put in front of Gradio's inside Gradio's server, so "/"
+    is the container's page. Gradio's own routes stay for gradio_client (api_name "/decide").
+  - Only the model-running step is decorated; the request checks and the concurrency limit stay in the main process.
+    Each model times itself inside the GPU call, so model timings stay comparable.
+  - Gradio's server-side rendering is off: its Node proxy would take port 7860.
 @spaces.GPU does nothing on non-ZeroGPU hardware, so this file also runs on a CPU Space.
 
 No token auth anywhere (operator ruling 2026-09-28): on a public Space, anyone can use the page and the API.
@@ -31,11 +33,12 @@ os.environ.setdefault("MODELS_DIR", str(HERE / "models"))      # the Space's own
 os.environ.setdefault("DLAB_WARMUP", "0")                       # no real GPU outside @spaces.GPU: no warm-up run
 
 import gradio as gr  # noqa: E402
-import uvicorn  # noqa: E402
+from starlette.middleware import Middleware  # noqa: E402
 
 from app import main as lab  # noqa: E402
 from app.main import VERSION, Busy, app, run_decision  # noqa: E402
 from app.models import load_all  # noqa: E402
+from app.security import SecurityMiddleware  # noqa: E402
 
 GPU_SECONDS = int(os.getenv("GPU_SECONDS", "60"))   # longest a single decision may hold the GPU
 
@@ -48,7 +51,6 @@ def run_models_on_gpu(state, questions, keys):
 lab.RUN_MODELS = run_models_on_gpu
 
 
-GRADIO_PATH = "/gradio"
 EXAMPLE_STATE = "I was charged twice for March. Refund the duplicate or I cancel."
 EXAMPLE_QUESTIONS = json.dumps({
     "dept": {"type": "choice", "instructions": "Which team?",
@@ -81,7 +83,7 @@ def decide(state: str, questions_json: str, models: str = "") -> dict:
 def build_blocks() -> gr.Blocks:
     with gr.Blocks(title="DecisionLab API") as demo:
         gr.Markdown(f"# DecisionLab {VERSION}: Gradio API\n"
-                    "The full lab is at the [main page](/). This form and `gradio_client` run the same decision code.")
+                    "The full lab is the main page. `gradio_client` (api_name \"/decide\") runs the same decision code.")
         with gr.Row():
             state = gr.Textbox(label="State (text or JSON)", lines=8, value=EXAMPLE_STATE)
             questions = gr.Code(label="Questions (JSON)", language="json", value=EXAMPLE_QUESTIONS)
@@ -92,15 +94,26 @@ def build_blocks() -> gr.Blocks:
     return demo
 
 
-served = gr.mount_gradio_app(app, build_blocks(), path=GRADIO_PATH, ssr_mode=False)
+def lab_first(server_app) -> None:
+    """Put the lab's routes (page, /static, /api/*) in front of Gradio's, so "/" is DecisionLab's page."""
+    lab_routes = list(app.routes)
+    rest = [r for r in server_app.router.routes if r not in lab_routes]
+    server_app.router.routes[:] = lab_routes + rest
 
 
 def main() -> None:
-    # Serve at once; load the models in the background (see the note above). The loader runs only once, even if the
-    # lab's own startup hook also starts it.
-    threading.Thread(target=load_all, name="model-loader", daemon=True).start()
-    uvicorn.run(served, host=os.getenv("GRADIO_SERVER_NAME") or "0.0.0.0",
-                port=int(os.getenv("GRADIO_SERVER_PORT") or os.getenv("PORT") or 7860))
+    load_all()                              # before launch(): ZeroGPU's startup step packs the loaded models
+    demo = build_blocks()
+    demo.launch(
+        server_name=os.getenv("GRADIO_SERVER_NAME") or "0.0.0.0",
+        server_port=int(os.getenv("GRADIO_SERVER_PORT") or os.getenv("PORT") or 7860),
+        ssr_mode=False,
+        prevent_thread_lock=True,
+        app_kwargs={"docs_url": None, "redoc_url": None, "openapi_url": None,
+                    "middleware": [Middleware(SecurityMiddleware, max_body=lab.MAX_BODY_BYTES)]},
+    )
+    lab_first(demo.app)
+    demo.block_thread()
 
 
 if __name__ == "__main__":

app/main.py

@@ -27,7 +27,7 @@ MAX_BODY_BYTES = int(os.getenv("MAX_BODY_BYTES", str(256 * 1024)))
 DECIDE_SLOTS = Gate(int(os.getenv("MAX_PENDING_DECIDES", "4")))      # DL-SA-004
 
 # DL-SA-007: no /docs, /redoc or /openapi.json
-VERSION = "2.1.1"
+VERSION = "2.1.2"
 PAGE = stamp_assets((STATIC / "index.html").read_text(encoding="utf-8"), VERSION)
 
 

space.py

@@ -1,98 +0,0 @@
-"""DecisionLab on a Hugging Face Space (Gradio SDK, ZeroGPU hardware).
-
-The Space runs this file. It serves the SAME FastAPI app as the container, so the lab page at "/" (HTML, CSS and
-JavaScript) and /api/* are the container's. A Gradio app is mounted beside it at /gradio: a small form and a "decide"
-API endpoint for gradio_client, both running the same decision code (app.main.run_decision).
-
-ZeroGPU (Hugging Face docs, checked 2026-09-28):
-  - `import spaces` comes first: it patches torch so CUDA looks available everywhere; outside @spaces.GPU a CUDA
-    emulation mode lets models be moved to "cuda" without a real GPU. A real GPU exists only inside @spaces.GPU calls.
-  - Decorated calls run apart from the main process, so all models are loaded BEFORE the server starts, and only the
-    model-running step is decorated. The request checks and the concurrency limit stay in the main process.
-  - Each model times itself inside the GPU call, so model timings stay comparable; the GPU hand-off only adds to the
-    round trip.
-@spaces.GPU does nothing on non-ZeroGPU hardware, so this file also runs on a CPU Space.
-
-No token auth anywhere (operator ruling 2026-09-28): on a public Space, anyone can use the page and the API.
-"""
-import spaces  # noqa: I001  -- must be the first import (patches torch for ZeroGPU)
-
-import json
-import os
-from pathlib import Path
-
-HERE = Path(__file__).resolve().parent
-os.environ.setdefault("MODELS_DIR", str(HERE / "models"))      # the Space's own models/ folder
-os.environ.setdefault("DLAB_WARMUP", "0")                       # no real GPU outside @spaces.GPU: no warm-up run
-
-import gradio as gr  # noqa: E402
-import uvicorn  # noqa: E402
-
-from app import main as lab  # noqa: E402
-from app.main import VERSION, Busy, app, run_decision  # noqa: E402
-from app.models import load_all  # noqa: E402
-
-GPU_SECONDS = int(os.getenv("GPU_SECONDS", "60"))   # longest a single decision may hold the GPU
-
-
-@spaces.GPU(duration=GPU_SECONDS)
-def run_models_on_gpu(state, questions, keys):
-    return lab.run_models(state, questions, keys)
-
-
-lab.RUN_MODELS = run_models_on_gpu
-
-
-GRADIO_PATH = "/gradio"
-EXAMPLE_STATE = "I was charged twice for March. Refund the duplicate or I cancel."
-EXAMPLE_QUESTIONS = json.dumps({
-    "dept": {"type": "choice", "instructions": "Which team?",
-             "criteria": {"billing": "Payments and refunds", "tech": "Bugs and errors"}},
-    "churn": {"type": "noul", "instructions": "The customer threatens to leave"},
-}, indent=2)
-
-
-def decide(state: str, questions_json: str, models: str = "") -> dict:
-    """Run one decision. state: text, or a JSON object. questions_json: the questions as JSON.
-    models: comma-separated model keys (see /api/status); empty runs every model."""
-    try:
-        questions = json.loads(questions_json)
-    except ValueError as exc:
-        raise gr.Error(f"Questions must be valid JSON: {exc}") from None
-    if not isinstance(questions, dict):
-        raise gr.Error("Questions must be a JSON object: {name: {type, instructions, criteria}}.")
-    text = (state or "").strip()
-    try:
-        parsed = json.loads(text) if text.startswith("{") else text
-    except ValueError:
-        parsed = text
-    keys = [k.strip() for k in (models or "").split(",") if k.strip()] or None
-    try:
-        return run_decision(parsed, questions, keys)
-    except (ValueError, Busy) as exc:
-        raise gr.Error(str(exc)) from None
-
-
-def build_blocks() -> gr.Blocks:
-    with gr.Blocks(title="DecisionLab API") as demo:
-        gr.Markdown(f"# DecisionLab {VERSION}: Gradio API\n"
-                    "The full lab is at the [main page](/). This form and `gradio_client` run the same decision code.")
-        with gr.Row():
-            state = gr.Textbox(label="State (text or JSON)", lines=8, value=EXAMPLE_STATE)
-            questions = gr.Code(label="Questions (JSON)", language="json", value=EXAMPLE_QUESTIONS)
-        models = gr.Textbox(label="Models (comma-separated keys from /api/status; empty = every model)", value="")
-        run = gr.Button("Run", variant="primary")
-        out = gr.JSON(label="Result")
-        run.click(decide, [state, questions, models], out, api_name="decide")
-    return demo
-
-
-def main() -> None:
-    load_all()                               # every model is loaded before the first request (see the note above)
-    served = gr.mount_gradio_app(app, build_blocks(), path=GRADIO_PATH)
-    uvicorn.run(served, host=os.getenv("GRADIO_SERVER_NAME") or "0.0.0.0",
-                port=int(os.getenv("GRADIO_SERVER_PORT") or os.getenv("PORT") or 7860))
-
-
-if __name__ == "__main__":
-    main()

tests/test_space.py

@@ -80,6 +80,17 @@ class SpacePackagingTest(unittest.TestCase):
             with self.subTest(pattern=pattern):
                 self.assertRegex(attrs, rf"(?m)^{re.escape(pattern)} filter=lfs diff=lfs merge=lfs -text$")
 
+    def test_the_space_starts_through_gradio_launch(self):
+        """ZeroGPU's startup step runs inside Gradio's Blocks.launch(); uvicorn + mount_gradio_app skips it
+        ("No @spaces.GPU function detected during startup", 2026-09-30)."""
+        import ast
+        tree = ast.parse((ROOT / "app.py").read_text(encoding="utf-8"))
+        calls = {n.func.attr for n in ast.walk(tree) if isinstance(n, ast.Call) and isinstance(n.func, ast.Attribute)}
+        imported = {a.name for n in ast.walk(tree) if isinstance(n, ast.Import) for a in n.names}
+        self.assertIn("launch", calls)
+        self.assertNotIn("mount_gradio_app", calls)
+        self.assertNotIn("uvicorn", imported)
+
     def test_no_leftover_space_py(self):
         self.assertFalse((ROOT / "space.py").exists())