Download scripts/warmup_demo_cache.py from yahyoha/omnidiag: direct link, hf CLI and curl.
- Browser
- Download file 6.24 kB
-
https://huggingface.co/spaces/yahyoha/omnidiag/resolve/main/scripts/warmup_demo_cache.py
- Command line
-
hf download hf://spaces/yahyoha/omnidiag/scripts/warmup_demo_cache.py
-
curl -L -o warmup_demo_cache.py https://huggingface.co/spaces/yahyoha/omnidiag/resolve/main/scripts/warmup_demo_cache.py
6.24 kB
| #!/usr/bin/env python3 | |
| """ | |
| Warm the prediction / SHAP / What-If caches for every demo patient. | |
| Why this exists | |
| --------------- | |
| A diabetes What-If costs 9-14 s uncached. The first judge to click it waits | |
| that long and concludes the product is slow. Run this once before judging and | |
| every demo patient's /predict, /explain and /counterfactuals response is | |
| already in the server's cache, so every click is served in milliseconds. | |
| Cache lifetime is CACHE_TTL_COUNTERFACTUALS (default 12 h), long enough that | |
| a single morning run covers the whole day. The server's cache is in-process | |
| memory, so a Space restart or rebuild empties it -- re-run this after any | |
| restart. | |
| Usage | |
| ----- | |
| # against the live Space (the default) | |
| backend/.venv/bin/python scripts/warmup_demo_cache.py | |
| # against a local backend | |
| backend/.venv/bin/python scripts/warmup_demo_cache.py \ | |
| --base-url http://127.0.0.1:8000 | |
| # skip the slow endpoint if you only want predictions warm | |
| backend/.venv/bin/python scripts/warmup_demo_cache.py --skip-counterfactuals | |
| Exit code is 0 only when every request succeeded. | |
| The demo patients are read from frontend/src/mockPatients.js, the same file | |
| the UI renders, so the warmed inputs cannot drift from the ones on screen. | |
| Requires node on PATH to read that file (the same dependency | |
| scripts/golden_master.py already has). | |
| """ | |
| import argparse | |
| import json | |
| import os | |
| import subprocess | |
| import sys | |
| import time | |
| import urllib.error | |
| import urllib.request | |
| import uuid | |
| ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) | |
| DEFAULT_BASE_URL = "https://yahyoha-omnidiag.hf.space" | |
| # A cold Space plus a diabetes counterfactual generation. Generous on purpose: | |
| # a timeout here would report a failure for a request that was going to | |
| # succeed, and re-running is cheap. | |
| REQUEST_TIMEOUT_SECONDS = 180 | |
| def load_demo_patients() -> dict: | |
| """{disease: [(patient_id, patient_data), ...]} from the frontend's own file.""" | |
| src = os.path.join(ROOT, "frontend", "src", "mockPatients.js") | |
| if not os.path.isfile(src): | |
| sys.exit(f"demo patients not found at {src}") | |
| # mockPatients.js is an ES module; import it by path and print it as JSON. | |
| tmp = os.path.join( | |
| os.environ.get("TMPDIR", "/tmp"), f"warmup_mock_{uuid.uuid4().hex}.mjs" | |
| ) | |
| with open(src) as f, open(tmp, "w") as g: | |
| g.write(f.read()) | |
| try: | |
| out = subprocess.run( | |
| ["node", "-e", | |
| "import(process.argv[1]).then(m => console.log(JSON.stringify(m.default)))", | |
| tmp], | |
| capture_output=True, text=True, check=True, | |
| ) | |
| except FileNotFoundError: | |
| sys.exit("node is not on PATH — it is needed to read frontend/src/mockPatients.js") | |
| except subprocess.CalledProcessError as exc: | |
| sys.exit(f"could not read demo patients:\n{exc.stderr}") | |
| finally: | |
| os.remove(tmp) | |
| return { | |
| disease: [(p["id"], p["data"]) for p in patients] | |
| for disease, patients in json.loads(out.stdout).items() | |
| } | |
| def post(base_url: str, path: str, payload: dict) -> tuple[bool, float, str]: | |
| """POST *payload*; return (ok, elapsed_seconds, note).""" | |
| req = urllib.request.Request( | |
| f"{base_url}{path}", | |
| data=json.dumps(payload).encode(), | |
| headers={"Content-Type": "application/json"}, | |
| method="POST", | |
| ) | |
| start = time.perf_counter() | |
| try: | |
| with urllib.request.urlopen(req, timeout=REQUEST_TIMEOUT_SECONDS) as resp: | |
| resp.read() | |
| elapsed = time.perf_counter() - start | |
| # The server reports whether this response was already cached, so | |
| # a second run of this script visibly proves the cache is live. | |
| hit = resp.headers.get("Cache-Hit") | |
| note = {"true": "already cached", "false": "computed"}.get(hit, "") | |
| return True, elapsed, note | |
| except urllib.error.HTTPError as exc: | |
| return False, time.perf_counter() - start, f"HTTP {exc.code}: {exc.read()[:200].decode(errors='replace')}" | |
| except Exception as exc: | |
| return False, time.perf_counter() - start, f"{type(exc).__name__}: {exc}" | |
| def main() -> int: | |
| parser = argparse.ArgumentParser(description=__doc__.split("Usage")[0].strip()) | |
| parser.add_argument("--base-url", default=os.getenv("OMNIDIAG_BASE_URL", DEFAULT_BASE_URL), | |
| help=f"API root to warm (default: {DEFAULT_BASE_URL})") | |
| parser.add_argument("--skip-counterfactuals", action="store_true", | |
| help="warm only /predict and /explain") | |
| args = parser.parse_args() | |
| base_url = args.base_url.rstrip("/") | |
| # A retired module answers 410 by design; warming it would only count failures. | |
| sys.path.insert(0, ROOT) | |
| from backend.retired_diseases import is_retired | |
| patients = {d: p for d, p in load_demo_patients().items() if not is_retired(d)} | |
| endpoints = ["predict", "explain"] | |
| if not args.skip_counterfactuals: | |
| endpoints.append("counterfactuals") | |
| total = sum(len(p) for p in patients.values()) * len(endpoints) | |
| print(f"Warming {total} responses at {base_url}\n") | |
| failures = [] | |
| started = time.perf_counter() | |
| for disease, demo in sorted(patients.items()): | |
| print(f" {disease}") | |
| for patient_id, data in demo: | |
| for endpoint in endpoints: | |
| ok, elapsed, note = post( | |
| base_url, f"/api/v4/{disease}/{endpoint}", data | |
| ) | |
| mark = "ok " if ok else "FAIL" | |
| suffix = f" ({note})" if note else "" | |
| print(f" {mark} {patient_id:<8} {endpoint:<16} {elapsed:6.2f}s{suffix}") | |
| if not ok: | |
| failures.append((disease, patient_id, endpoint, note)) | |
| print() | |
| print(f"Done in {time.perf_counter() - started:.1f}s — " | |
| f"{total - len(failures)}/{total} warmed") | |
| if failures: | |
| print("\nFailures:") | |
| for disease, patient_id, endpoint, note in failures: | |
| print(f" {disease}/{patient_id}/{endpoint}: {note}") | |
| return 1 | |
| print("Every demo patient is cached. Re-run after any Space restart.") | |
| return 0 | |
| if __name__ == "__main__": | |
| sys.exit(main()) | |