Download app/cloud_switch.py from CJR61/drpig-web: direct link, hf CLI and curl.
- Browser
- Download file 4.17 kB
-
https://huggingface.co/spaces/CJR61/drpig-web/resolve/main/app/cloud_switch.py
- Command line
-
hf download hf://spaces/CJR61/drpig-web/app/cloud_switch.py
-
curl -L -o cloud_switch.py https://huggingface.co/spaces/CJR61/drpig-web/resolve/main/app/cloud_switch.py
4.17 kB
| """ | |
| cloud_switch.py — the cloud LLM (OpenAI chat + Whisper) master switch (FR-CLOUD-01…05, D-42, 2026-11-09). | |
| Default OFF and fail-closed: no row, an unreadable row, a broken JSON value or an expired `until` all mean off. | |
| State lives in SQLite `server_meta` (key `cloud_llm`) so it survives Space restarts through the regular backup and | |
| can be flipped from the admin page without touching Space Secrets (which would restart the Space). Reads are cached | |
| for ≤ 5 s; a write clears the cache. Every change is written to `admin_audit`. | |
| """ | |
| from __future__ import annotations | |
| import json | |
| import logging | |
| import time | |
| from datetime import datetime, timedelta, timezone | |
| from sqlalchemy import insert, select | |
| from app import db | |
| from app.db import admin_audit, server_meta | |
| log = logging.getLogger("drpig.cloud") | |
| KEY = "cloud_llm" | |
| CACHE_S = 5.0 | |
| MAX_HOURS = 168 | |
| _cache: tuple[float, bool] = (0.0, False) | |
| class CloudOff(Exception): | |
| """The cloud LLM is switched off: callers answer with fixed_replies.cloud_off (or 503 for partners).""" | |
| def _now() -> datetime: | |
| return datetime.now(timezone.utc) | |
| def state() -> dict: | |
| """Raw stored state (for the admin page). Fail-closed: anything unreadable → disabled.""" | |
| try: | |
| with db.read_connection() as conn: | |
| raw = conn.execute(select(server_meta.c.value).where(server_meta.c.key == KEY)).scalar() | |
| if not raw: | |
| return {"enabled": False, "at": None, "by": None, "until": None} | |
| v = json.loads(raw) | |
| enabled = v.get("enabled") is True | |
| until = v.get("until") | |
| if enabled and until: | |
| if datetime.fromisoformat(until) <= _now(): | |
| enabled = False | |
| return {"enabled": enabled, "at": v.get("at"), "by": v.get("by"), "until": until} | |
| except Exception as e: # noqa: BLE001 — fail closed | |
| log.warning("cloud switch unreadable → off: %s", e) | |
| return {"enabled": False, "at": None, "by": None, "until": None, "error": "unreadable"} | |
| def is_enabled() -> bool: | |
| global _cache | |
| t = time.monotonic() | |
| if t - _cache[0] < CACHE_S: | |
| return _cache[1] | |
| on = state()["enabled"] | |
| _cache = (t, on) | |
| return on | |
| def require_enabled() -> None: | |
| if not is_enabled(): | |
| raise CloudOff("cloud LLM switched off") | |
| def set_enabled(enabled: bool, *, actor: str, ip: str = "", ua: str = "", hours: int | None = None) -> dict: | |
| global _cache | |
| old = state() | |
| now = _now() | |
| until = (now + timedelta(hours=hours)).isoformat() if enabled and hours else None | |
| value = json.dumps({"enabled": bool(enabled), "at": now.isoformat(), "by": actor, "until": until}) | |
| with db.engine().begin() as conn: | |
| if conn.execute(select(server_meta.c.key).where(server_meta.c.key == KEY)).first(): | |
| conn.execute(server_meta.update().where(server_meta.c.key == KEY).values(value=value)) | |
| else: | |
| conn.execute(insert(server_meta).values(key=KEY, value=value)) | |
| conn.execute(insert(admin_audit).values( | |
| ts=now.isoformat(), action="cloud_llm.enable" if enabled else "cloud_llm.disable", | |
| old="on" if old["enabled"] else "off", new=("on" if enabled else "off") + (f" until {until}" if until else ""), | |
| actor=actor, ip=ip[:64], ua=ua[:200])) | |
| _cache = (0.0, False) | |
| return state() | |
| def audit_event(action: str, *, actor: str, ip: str = "", ua: str = "", detail: str = "") -> None: | |
| """Admin actions that spend OpenAI money while the switch is off (`force=1`), FR-CLOUD-04 / security §二 A.1.""" | |
| with db.engine().begin() as conn: | |
| conn.execute(insert(admin_audit).values(ts=_now().isoformat(), action=action, old=None, new=detail[:200] or None, | |
| actor=actor, ip=ip[:64], ua=ua[:200])) | |
| def audit(limit: int = 20) -> list[dict]: | |
| with db.read_connection() as conn: | |
| return [dict(r._mapping) for r in conn.execute( | |
| select(admin_audit).order_by(admin_audit.c.id.desc()).limit(max(1, min(limit, 200))))] | |
| def reset_cache() -> None: | |
| """Tests only.""" | |
| global _cache | |
| _cache = (0.0, False) | |