medalion-core 0.1.12__tar.gz

medalion_core-0.1.12/.gitignore

@@ -0,0 +1,16 @@
+.venv/
+__pycache__/
+*.pyc
+.pytest_cache/
+.ruff_cache/
+studio/node_modules/
+studio/.next/
+studio/next-env.d.ts
+*.log
+.DS_Store
+dist/
+services/distribution/keys/
+services/distribution/.venv/
+services/distribution/models/
+packages/medalion-studio/src/medalion/studio/dist/
+studio/out/

medalion_core-0.1.12/PKG-INFO

@@ -0,0 +1,48 @@
+Metadata-Version: 2.5
+Name: medalion-core
+Version: 0.1.12
+Summary: Medalion Platform — runtime, task contracts, API gateway, CLI and licensing
+Project-URL: Homepage, https://medalion.tech
+Project-URL: Documentation, https://medalion.tech
+Project-URL: Source, https://github.com/Medalion-Tech/medalion-platform
+Author-email: Medalion <kontakt@medalion.tech>
+License: Proprietary
+Keywords: asr,fhir,llm,medical,nlp,on-premise
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Framework :: FastAPI
+Classifier: Intended Audience :: Healthcare Industry
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: <3.13,>=3.12
+Requires-Dist: cryptography>=42
+Requires-Dist: fastapi>=0.115
+Requires-Dist: httpx>=0.27
+Requires-Dist: huggingface-hub>=0.25
+Requires-Dist: orjson>=3.10
+Requires-Dist: pydantic-settings>=2.4
+Requires-Dist: pydantic>=2.8
+Requires-Dist: python-multipart>=0.0.9
+Requires-Dist: pyyaml>=6
+Requires-Dist: ruamel-yaml>=0.18
+Requires-Dist: structlog>=24
+Requires-Dist: typer>=0.12
+Requires-Dist: uvicorn[standard]>=0.30
+Requires-Dist: websockets>=13
+Description-Content-Type: text/markdown
+
+# Medalion Platform — core
+
+The runtime of the Medalion Platform: task contracts, the API gateway that supervises one worker
+process per model, the CLI (`medalion init/update/serve/status/doctor`) and licensing.
+
+Core on its own gives you the API, the Studio UI (`medalion-studio`) and a llama.cpp chat engine.
+The clinical modules — speech to text, clinical NER, anonymisation, documents to FHIR, workflows —
+are licensed and installed from Medalion's own index:
+
+```bash
+curl -fsSL https://get.medalion.tech | sh
+```
+
+Documentation and licensing: <https://medalion.tech>.

medalion_core-0.1.12/README.md

@@ -0,0 +1,14 @@
+# Medalion Platform — core
+
+The runtime of the Medalion Platform: task contracts, the API gateway that supervises one worker
+process per model, the CLI (`medalion init/update/serve/status/doctor`) and licensing.
+
+Core on its own gives you the API, the Studio UI (`medalion-studio`) and a llama.cpp chat engine.
+The clinical modules — speech to text, clinical NER, anonymisation, documents to FHIR, workflows —
+are licensed and installed from Medalion's own index:
+
+```bash
+curl -fsSL https://get.medalion.tech | sh
+```
+
+Documentation and licensing: <https://medalion.tech>.

medalion_core-0.1.12/pyproject.toml

@@ -0,0 +1,53 @@
+[project]
+name = "medalion-core"
+version = "0.1.12"
+description = "Medalion Platform — runtime, task contracts, API gateway, CLI and licensing"
+readme = "README.md"
+requires-python = ">=3.12,<3.13"
+license = { text = "Proprietary" }
+authors = [{ name = "Medalion", email = "kontakt@medalion.tech" }]
+keywords = ["medical", "nlp", "asr", "fhir", "llm", "on-premise"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Environment :: Console",
+  "Framework :: FastAPI",
+  "Intended Audience :: Healthcare Industry",
+  "License :: Other/Proprietary License",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+
+dependencies = [
+  "fastapi>=0.115",
+  "uvicorn[standard]>=0.30",
+  "pydantic>=2.8",
+  "pydantic-settings>=2.4",
+  "httpx>=0.27",
+  "websockets>=13",
+  "python-multipart>=0.0.9",
+  "structlog>=24",
+  "typer>=0.12",
+  "pyyaml>=6",
+  "ruamel.yaml>=0.18",
+  "cryptography>=42",
+  "huggingface_hub>=0.25",
+  "orjson>=3.10",
+]
+
+[project.urls]
+Homepage = "https://medalion.tech"
+Documentation = "https://medalion.tech"
+Source = "https://github.com/Medalion-Tech/medalion-platform"
+
+[project.scripts]
+medalion = "medalion.cli:app"
+
+[project.entry-points."medalion.models"]
+llama-server = "medalion.engines.llama_server:LlamaServer"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/medalion"]

medalion_core-0.1.12/src/medalion/__init__.py

@@ -0,0 +1,16 @@
+"""Medalion Platform — one runtime, every model a plugin."""
+
+# `medalion` spans several distributions (medalion-core, medalion-asr, ...); merge
+# their `medalion/` directories into one package, also for editable installs.
+from pkgutil import extend_path
+
+__path__ = extend_path(__path__, __name__)
+
+from medalion.core.artifact import artifact  # noqa: E402
+from medalion.core.bench import BenchmarkResult  # noqa: E402
+from medalion.core.model import Model  # noqa: E402
+from medalion.core.runtime import Runtime  # noqa: E402
+from medalion.core.task import Op, Task, Unit, op  # noqa: E402
+
+__all__ = ["Model", "artifact", "Runtime", "Task", "Op", "Unit", "op", "BenchmarkResult"]
+__version__ = "0.1.12"

medalion_core-0.1.12/src/medalion/api/app.py

@@ -0,0 +1,376 @@
+"""Control-plane API: license, registry, router/proxy, usage, benchmarks. No user auth in the POC."""
+
+from __future__ import annotations
+
+import asyncio
+import inspect
+import json
+import os
+import time
+import uuid
+from contextlib import asynccontextmanager
+from typing import Any
+
+import httpx
+import structlog
+import websockets
+from fastapi import FastAPI, HTTPException, Request, WebSocket, WebSocketDisconnect
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse, Response, StreamingResponse
+
+from medalion import __version__
+from medalion.api.supervisor import Supervisor, WorkerHandle
+from medalion.api.usage import UsageStore
+from medalion.core.config import Config, load_config
+from medalion.core.license import LicenseManager
+from medalion.core.registry import scan_plugins
+from medalion.core.task import Op, all_tasks, get_task
+
+log = structlog.get_logger("medalion.api")
+
+HOP_HEADERS = {"content-length", "transfer-encoding", "connection", "host", "content-encoding"}
+
+
+def create_app(config_path: str | None = None) -> FastAPI:
+    cfg: Config = load_config(config_path)
+    api_url = f"http://{cfg.api.host}:{cfg.api.port}"
+    lic = LicenseManager(cfg, version=__version__)
+    ent = lic.start().entitlements
+    sup = Supervisor(cfg, config_path or os.environ.get("MEDALION_CONFIG", "medalion.yaml"), api_url, entitlements=ent)
+    usage = UsageStore(cfg.data_dir / "usage.db")
+
+    @asynccontextmanager
+    async def lifespan(app: FastAPI):
+        sup.start()
+        app.state.client = httpx.AsyncClient(timeout=httpx.Timeout(900.0, connect=5.0))
+        heartbeat = asyncio.get_event_loop().create_task(lic.heartbeat_loop())
+        yield
+        heartbeat.cancel()
+        await app.state.client.aclose()
+        await sup.stop()
+
+    app = FastAPI(
+        title="Medalion Platform API",
+        version=__version__,
+        description="One runtime, every model a plugin. Routes under /v1/{task}/{op} are derived from task contracts.",
+        lifespan=lifespan,
+    )
+    app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"], expose_headers=["*"])
+    app.state.cfg, app.state.sup, app.state.usage, app.state.license = cfg, sup, usage, lic
+
+    modules: list[str] = []
+
+    # ---------------------------------------------------------------- meta
+    @app.get("/v1/info", tags=["platform"])
+    def info():
+        return {"version": app.version, "deployment": cfg.deployment, "hardware": cfg.hardware, "modules": modules,
+                "license": lic.state.status, "studio": app.state.studio}
+
+    @app.get("/v1/license", tags=["platform"])
+    def license_status():
+        return lic.state.to_dict()
+
+    @app.get("/v1/capabilities", tags=["platform"])
+    def capabilities():
+        """What this deployment can do: licensed products, mounted modules, tasks with a usable model."""
+        plugins = scan_plugins(lic.state.entitlements)
+        return {
+            "products": sorted(lic.state.entitlements.products),
+            "modules": modules,
+            "tasks": {t.id: any(p.licensed and p.task == t.id for p in plugins) for t in all_tasks()},
+            "plugins": [{"id": p.id, "task": p.task, "product": p.product, "licensed": p.licensed} for p in plugins],
+            "license": lic.state.to_dict(),
+        }
+
+    @app.get("/healthz", tags=["platform"])
+    def healthz():
+        return {"ok": True, "deployment": cfg.deployment, "hardware": cfg.hardware, "models": {k: h.status for k, h in sup.workers.items()}}
+
+    @app.get("/v1/models", tags=["platform"])
+    def list_models():
+        return {"models": sup.snapshot(), "defaults": cfg.defaults}
+
+    @app.get("/v1/models/{model_id}", tags=["platform"])
+    async def get_model(model_id: str):
+        h = _handle(sup, model_id)
+        d = next(m for m in sup.snapshot() if m["model"] == model_id)
+        if h.ready:
+            try:
+                r = await app.state.client.get(f"{h.base_url}/manifest")
+                d["manifest"] = r.json()
+            except Exception:
+                pass
+        return d
+
+    @app.get("/v1/tasks", tags=["platform"])
+    def list_tasks():
+        out = []
+        for t in all_tasks():
+            m = t.manifest()
+            m["models"] = [{"id": h.spec.id, "title": h.info.title, "status": h.status} for h in sup.for_task(t.id)]
+            m["default_model"] = cfg.defaults.get(t.id) or (m["models"][0]["id"] if m["models"] else None)
+            out.append(m)
+        return {"tasks": out}
+
+    @app.get("/v1/usage", tags=["platform"])
+    def get_usage(limit: int = 50):
+        return {"summary": usage.summary(), "recent": usage.recent(limit)}
+
+    # ---------------------------------------------------------- benchmarks
+    @app.get("/v1/benchmarks", tags=["benchmarks"])
+    async def list_benchmarks():
+        out = []
+        for h in sup.workers.values():
+            item: dict[str, Any] = {"model": h.spec.id, "task": h.info.task, "has_benchmark": h.info.has_benchmark, "running": False, "result": None, "error": None}
+            if h.ready:
+                try:
+                    r = await app.state.client.get(f"{h.base_url}/v1/benchmark", timeout=10)
+                    item.update(r.json())
+                except Exception as e:  # noqa: BLE001
+                    item["error"] = str(e)
+            out.append(item)
+        return {"benchmarks": out}
+
+    @app.get("/v1/models/{model_id}/benchmark", tags=["benchmarks"])
+    async def get_benchmark(model_id: str):
+        h = _handle(sup, model_id)
+        r = await app.state.client.get(f"{h.base_url}/v1/benchmark", timeout=10)
+        return JSONResponse(r.json(), status_code=r.status_code)
+
+    @app.post("/v1/models/{model_id}/benchmark", tags=["benchmarks"])
+    async def run_benchmark(model_id: str, limit: int | None = None):
+        h = _handle(sup, model_id)
+        r = await app.state.client.post(f"{h.base_url}/v1/benchmark", params={"limit": limit} if limit else None, timeout=10)
+        return JSONResponse(r.json(), status_code=r.status_code)
+
+    # ---------------------------------------------------- derived op routes
+    for t in all_tasks():
+        for op in t.ops:
+            _mount_proxy(app, sup, usage, t.id, op)
+
+    # ------------------------------------------------------ optional modules
+    if cfg.workflows.enabled and not ent.allows("workflows"):
+        log.warning("workflows_not_licensed")
+    elif cfg.workflows.enabled:
+        try:
+            from medalion.workflows import build_router
+
+            app.include_router(build_router(app))
+            modules.append("workflows")
+        except ImportError as e:
+            log.info("workflows_unavailable", error=str(e))
+
+    # ------------------------------------------------------------- the UI
+    from medalion.api.studio import mount_studio
+
+    app.state.studio = mount_studio(app)
+    if not app.state.studio:
+        log.info("studio_not_installed")  # API-only deployment, or a dev checkout without MEDALION_STUDIO_DIR
+
+    # note: the derived route for task `chat` / op `completions` is already /v1/chat/completions (OpenAI-compatible)
+    return app
+
+
+# ------------------------------------------------------------------ helpers
+def _handle(sup: Supervisor, model_id: str) -> WorkerHandle:
+    h = sup.handle(model_id)
+    if not h:
+        raise HTTPException(404, f"unknown model {model_id!r}")
+    return h
+
+
+def _mount_proxy(app: FastAPI, sup: Supervisor, usage: UsageStore, task_id: str, op: Op) -> None:
+    path = f"/v1/{task_id}/{op.path}"
+
+    if op.protocol == "websocket":
+
+        @app.websocket(path)
+        async def ws_proxy(ws: WebSocket):
+            await _proxy_ws(sup, usage, task_id, op, ws)
+
+        return
+
+    if op.request is not None and op.accepts == "json":
+        ReqModel = op.request
+
+        async def typed_proxy(request, body):  # signature set below so the OpenAPI shows the op's request model
+            return await _proxy_http(app, sup, usage, task_id, op, request)
+
+        typed_proxy.__signature__ = inspect.Signature(  # type: ignore[attr-defined]
+            [inspect.Parameter("request", inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=Request),
+             inspect.Parameter("body", inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=ReqModel)]
+        )
+        app.post(path, tags=[task_id], summary=op.summary, name=f"{task_id}_{op.name}", response_model=op.response)(typed_proxy)
+
+    else:
+
+        @app.post(path, tags=[task_id], summary=op.summary, name=f"{task_id}_{op.name}", response_model=op.response)
+        async def raw_proxy(request: Request):
+            return await _proxy_http(app, sup, usage, task_id, op, request)
+
+
+async def call_op(
+    app: FastAPI,
+    task_id: str,
+    op_name: str,
+    *,
+    json_body: dict | None = None,
+    data: dict | None = None,
+    files: dict | None = None,
+    model: str | None = None,
+    stream: bool = False,
+    request_id: str | None = None,
+) -> httpx.Response:
+    """Invoke a model op from inside the API process (used by the workflows module).
+
+    Shares model selection, readiness checks and usage metering with the HTTP proxy;
+    calls carry ``request_id`` so workflow steps are traceable in /v1/usage.
+    The returned response has ``extensions["medalion_model"]`` set to the model used.
+    Raises LookupError (unknown model/none for task) or RuntimeError (not ready).
+    """
+    sup: Supervisor = app.state.sup
+    usage: UsageStore = app.state.usage
+    client: httpx.AsyncClient = app.state.client
+    op = get_task(task_id).op(op_name)
+    h = sup.pick(task_id, model)
+    if not h.ready:
+        raise RuntimeError(f"model {h.spec.id!r} is {h.status}" + (f": {h.error}" if h.error else ""))
+    rid = request_id or uuid.uuid4().hex[:12]
+    t0 = time.time()
+    req = client.build_request(
+        "POST", f"{h.base_url}/v1/{task_id}/{op.path}",
+        json=json_body, data=data, files=files, headers={"x-request-id": rid},
+    )
+    upstream = await client.send(req, stream=stream)
+    if not stream:
+        await upstream.aread()
+        await upstream.aclose()
+    u = upstream.headers.get("x-medalion-usage", "")
+    try:
+        amount = float(u.split("=", 1)[1]) if "=" in u else 1.0
+    except ValueError:
+        amount = 1.0
+    usage.record(task=task_id, op=op.name, model=h.spec.id, unit=op.unit.name, amount=amount,
+                 latency_ms=(time.time() - t0) * 1000, status=upstream.status_code, request_id=rid)
+    upstream.extensions["medalion_model"] = h.spec.id
+    return upstream
+
+
+async def _pick_model(sup: Supervisor, task_id: str, request: Request, body: bytes | None) -> WorkerHandle:
+    model_id = request.query_params.get("model")
+    if not model_id and body and request.headers.get("content-type", "").startswith("application/json"):
+        try:
+            model_id = json.loads(body).get("model") or None
+        except Exception:
+            model_id = None
+    if not model_id and request.headers.get("content-type", "").startswith("multipart/form-data"):
+        # cheap sniff for a `model` field without parsing the whole form twice
+        pass
+    try:
+        return sup.pick(task_id, model_id)
+    except LookupError as e:
+        raise HTTPException(404, str(e))
+
+
+async def _proxy_http(app: FastAPI, sup: Supervisor, usage: UsageStore, task_id: str, op: Op, request: Request) -> Response:
+    client: httpx.AsyncClient = app.state.client
+    body = await request.body()
+    h = await _pick_model(sup, task_id, request, body)
+    if not h.ready:
+        raise HTTPException(503, f"model {h.spec.id!r} is {h.status}" + (f": {h.error}" if h.error else ""))
+    rid = request.headers.get("x-request-id") or uuid.uuid4().hex[:12]
+    headers = {k: v for k, v in request.headers.items() if k.lower() not in HOP_HEADERS}
+    headers["x-request-id"] = rid
+    url = f"{h.base_url}/v1/{task_id}/{op.path}"
+    t0 = time.time()
+
+    req = client.build_request("POST", url, content=body, headers=headers, params=dict(request.query_params))
+    try:
+        upstream = await client.send(req, stream=True)
+    except httpx.HTTPError as e:
+        raise HTTPException(502, f"worker unreachable: {e}")
+
+    resp_headers = {k: v for k, v in upstream.headers.items() if k.lower() not in HOP_HEADERS}
+    resp_headers["x-request-id"] = rid
+    resp_headers["x-medalion-model"] = h.spec.id
+
+    def _record(status: int, amount: float | None = None):
+        unit_amount = amount
+        if unit_amount is None:
+            u = upstream.headers.get("x-medalion-usage", "")
+            try:
+                unit_amount = float(u.split("=", 1)[1]) if "=" in u else 1.0
+            except ValueError:
+                unit_amount = 1.0
+        usage.record(task=task_id, op=op.name, model=h.spec.id, unit=op.unit.name, amount=unit_amount,
+                     latency_ms=(time.time() - t0) * 1000, status=status, request_id=rid)
+
+    if upstream.headers.get("content-type", "").startswith("text/event-stream"):
+        async def gen():
+            try:
+                async for chunk in upstream.aiter_raw():
+                    yield chunk
+            finally:
+                await upstream.aclose()
+                _record(upstream.status_code)
+
+        return StreamingResponse(gen(), status_code=upstream.status_code, headers=resp_headers, media_type="text/event-stream")
+
+    content = await upstream.aread()
+    await upstream.aclose()
+    _record(upstream.status_code)
+    return Response(content=content, status_code=upstream.status_code, headers=resp_headers, media_type=upstream.headers.get("content-type"))
+
+
+async def _proxy_ws(sup: Supervisor, usage: UsageStore, task_id: str, op: Op, ws: WebSocket) -> None:
+    await ws.accept()
+    model_id = ws.query_params.get("model")
+    try:
+        h = sup.pick(task_id, model_id)
+    except LookupError as e:
+        await ws.send_text(json.dumps({"type": "error", "error": {"code": "not_found", "message": str(e)}}))
+        await ws.close(code=1008)
+        return
+    if not h.ready:
+        await ws.send_text(json.dumps({"type": "error", "error": {"code": "unavailable", "message": f"model {h.spec.id} is {h.status}"}}))
+        await ws.close(code=1013)
+        return
+    rid = uuid.uuid4().hex[:12]
+    t0 = time.time()
+    upstream_url = f"{h.ws_url}/v1/{task_id}/{op.path}"
+    try:
+        async with websockets.connect(upstream_url, max_size=16 * 1024 * 1024) as up:
+
+            async def c2s():
+                try:
+                    while True:
+                        msg = await ws.receive()
+                        if msg["type"] == "websocket.disconnect":
+                            await up.close()
+                            return
+                        if "text" in msg and msg["text"] is not None:
+                            await up.send(msg["text"])
+                        elif "bytes" in msg and msg["bytes"] is not None:
+                            await up.send(msg["bytes"])
+                except (WebSocketDisconnect, websockets.ConnectionClosed):
+                    pass
+
+            async def s2c():
+                try:
+                    async for m in up:
+                        if isinstance(m, bytes):
+                            await ws.send_bytes(m)
+                        else:
+                            await ws.send_text(m)
+                except (websockets.ConnectionClosed, WebSocketDisconnect, RuntimeError):
+                    pass
+
+            await asyncio.wait([asyncio.create_task(c2s()), asyncio.create_task(s2c())], return_when=asyncio.FIRST_COMPLETED)
+    except Exception as e:  # noqa: BLE001
+        log.warning("ws.proxy_failed", error=str(e))
+    finally:
+        usage.record(task=task_id, op=op.name, model=h.spec.id, unit=op.unit.name, amount=1.0, latency_ms=(time.time() - t0) * 1000, status=101, request_id=rid)
+        try:
+            await ws.close()
+        except Exception:
+            pass

medalion_core-0.1.12/src/medalion/api/studio.py

@@ -0,0 +1,69 @@
+"""Serve the Studio from the platform API.
+
+The `medalion-studio` wheel carries a static export (no Node on the customer's machine).
+Mounting it under the API means one origin, one port and one service: the UI talks to
+`/v1/...` on itself, so nothing has to be configured after `medalion init`.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import structlog
+from fastapi import FastAPI
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+
+log = structlog.get_logger("medalion.api")
+
+# The export renders one page per dynamic route; both sides agree on this id
+# (studio/src/lib/routes.ts: PLACEHOLDER_WORKFLOW_ID).
+PLACEHOLDER = "_id"
+
+
+def studio_root() -> Path | None:
+    """MEDALION_STUDIO_DIR (a dev checkout's `studio/out`) or the installed wheel's assets."""
+    env = os.environ.get("MEDALION_STUDIO_DIR")
+    if env:
+        p = Path(env).expanduser()
+        return p if (p / "index.html").is_file() else None
+    try:
+        from medalion.studio import root
+    except ImportError:
+        return None
+    return root()
+
+
+def mount_studio(app: FastAPI, root: Path | None = None) -> bool:
+    """Mount the UI at `/`. Returns False when the Studio package is not installed."""
+    root = root or studio_root()
+    if root is None:
+        return False
+
+    @app.get("/workflows/{workflow_id}", include_in_schema=False)
+    @app.get("/workflows/{workflow_id}/", include_in_schema=False)
+    def workflow_page(workflow_id: str) -> FileResponse:
+        return _placeholder(root, workflow_id, "index.html")
+
+    @app.get("/workflows/{workflow_id}/edit", include_in_schema=False)
+    @app.get("/workflows/{workflow_id}/edit/", include_in_schema=False)
+    def workflow_editor_page(workflow_id: str) -> FileResponse:
+        return _placeholder(root, workflow_id, "edit/index.html")
+
+    # last route: everything not claimed by /v1, /docs, … is a static file or a directory index
+    app.mount("/", StaticFiles(directory=root, html=True), name="studio")
+    log.info("studio.mounted", path=str(root))
+    return True
+
+
+def _placeholder(root: Path, workflow_id: str, rel: str) -> FileResponse:
+    """Every /workflows/<id> URL is served by the one exported placeholder page."""
+    from fastapi import HTTPException
+
+    if workflow_id in ("index.html", ""):  # `/workflows/` itself is a real page
+        raise HTTPException(404)
+    page = root / "workflows" / PLACEHOLDER / rel
+    if not page.is_file():
+        raise HTTPException(404)
+    return FileResponse(page, media_type="text/html")