Add application file

README.md

@@ -6,7 +6,7 @@ colorTo: gray
 sdk: gradio
 sdk_version: 6.28.0
 python_version: "3.12"
-app_file: space.py
+app_file: app.py
 pinned: false
 ---
 
@@ -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). `space.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` 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.
 
-On ZeroGPU a GPU is attached for each decision: all models load before the Space starts serving, 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 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.
 
 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.0.0"
+git commit -m "DecisionLab 2.1.1"
 git push
 ```
 
@@ -226,7 +226,7 @@ DecisionLab/
 ├── docker-compose.yml
 ├── constraints.txt    # every other package, exact versions (from pip freeze)
 ├── .env.example       # copy to .env for local settings (.env is never in the image)
-├── space.py           # Hugging Face Space entry point (Gradio SDK)
+├── app.py             # Hugging Face Space entry point (Gradio SDK, ZeroGPU)
 ├── requirements.txt   # Space dependencies
 ├── requirements-container.txt  # container dependencies (with constraints.txt)
 ├── models/            # your LightDec and Arthur models, one folder each (not in the image)

app.py

@@ -7,8 +7,12 @@ API endpoint for gradio_client, both running the same decision code (app.main.ru
 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.
+  - 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.
 @spaces.GPU does nothing on non-ZeroGPU hardware, so this file also runs on a CPU Space.
@@ -19,6 +23,7 @@ import spaces  # noqa: I001  -- must be the first import (patches torch for Zero
 
 import json
 import os
+import threading
 from pathlib import Path
 
 HERE = Path(__file__).resolve().parent
@@ -87,9 +92,13 @@ def build_blocks() -> gr.Blocks:
     return demo
 
 
+served = gr.mount_gradio_app(app, build_blocks(), path=GRADIO_PATH, ssr_mode=False)
+
+
 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)
+    # 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))
 

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.0"
+VERSION = "2.1.1"
 PAGE = stamp_assets((STATIC / "index.html").read_text(encoding="utf-8"), VERSION)
 
 

space.py

@@ -0,0 +1,98 @@
+"""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

@@ -32,7 +32,7 @@ def pins(path):
 class SpacePackagingTest(unittest.TestCase):
     def test_front_matter_declares_a_gradio_space(self):
         fm = front_matter()
-        self.assertEqual((fm["sdk"], fm["app_file"]), ("gradio", "space.py"))
+        self.assertEqual((fm["sdk"], fm["app_file"]), ("gradio", "app.py"))                 # Hugging Face's default name
         self.assertIn(fm["python_version"], ("3.10", "3.12"))                 # the Pythons ZeroGPU supports
         self.assertTrue((ROOT / fm["app_file"]).is_file())
         self.assertEqual(fm["title"], "DecisionLab")
@@ -56,7 +56,7 @@ class SpacePackagingTest(unittest.TestCase):
 
     def test_spaces_is_imported_before_anything_else(self):
         import ast
-        tree = ast.parse((ROOT / "space.py").read_text(encoding="utf-8"))
+        tree = ast.parse((ROOT / "app.py").read_text(encoding="utf-8"))
         imports = [n for n in tree.body if isinstance(n, (ast.Import, ast.ImportFrom)) and
                    not (isinstance(n, ast.ImportFrom) and n.module == "__future__")]
         first = imports[0]
@@ -80,6 +80,16 @@ 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_no_leftover_space_py(self):
+        self.assertFalse((ROOT / "space.py").exists())
+
+    def test_app_py_imports_the_app_package_not_itself(self):
+        import subprocess, sys
+        r = subprocess.run([sys.executable, "-c", "import sys; sys.path.insert(0, '.'); import app.validation; print(app.validation.__file__)"],
+                           cwd=ROOT, capture_output=True, text=True)
+        self.assertEqual(r.returncode, 0, r.stderr)
+        self.assertIn("app", r.stdout)
+
     def test_models_folder_exists_for_local_models(self):
         self.assertTrue((ROOT / "models").is_dir())