Spaces:
Running on CPU Upgrade
Running on CPU Upgrade
Download api/assistant_worklists.py from fsanyoto/runloopable: direct link, hf CLI and curl.
- Browser
- Download file 10.2 kB
-
https://huggingface.co/spaces/fsanyoto/runloopable/resolve/main/api/assistant_worklists.py
- Command line
-
hf download hf://spaces/fsanyoto/runloopable/api/assistant_worklists.py
-
curl -L -o assistant_worklists.py https://huggingface.co/spaces/fsanyoto/runloopable/resolve/main/api/assistant_worklists.py
10.2 kB
| """Store owner-bound worklist snapshots as tenant-scoped JSON blobs.""" | |
| import copy | |
| import datetime | |
| import importlib | |
| import json | |
| import math | |
| import re | |
| import secrets | |
| import time | |
| from urllib.parse import urlsplit | |
| import assistant_artifacts | |
| import assistant_log | |
| COLUMN_TYPES = {"text", "number", "money", "date", "link"} | |
| _WORKLIST_ID = re.compile(r"[0-9a-f]{32}") | |
| def _https(value): | |
| if not isinstance(value, str) or not value or any(c.isspace() or ord(c) < 32 for c in value): | |
| raise ValueError("A worklist link must be an absolute HTTPS URL.") | |
| try: | |
| parsed = urlsplit(value) | |
| port = parsed.port | |
| if (parsed.scheme != "https" or not parsed.hostname or not parsed.netloc | |
| or parsed.username is not None or parsed.password is not None or "\\" in value | |
| or port == 0): | |
| raise ValueError | |
| except ValueError as exc: | |
| raise ValueError("A worklist link must be an absolute HTTPS URL.") from exc | |
| return value | |
| def _links(): | |
| try: | |
| return importlib.import_module("loopy_links") | |
| except ModuleNotFoundError as exc: | |
| if exc.name != "loopy_links": | |
| raise | |
| raise ValueError("A secure public link is not configured.") from exc | |
| def _principal(session): | |
| rt = getattr(session, "runtime", None) | |
| username = getattr(session, "uname", None) | |
| if rt is None or not isinstance(username, str) or not username.strip(): | |
| raise ValueError("A worklist needs an authenticated owner session.") | |
| if getattr(session, "tenant", None) != assistant_log._tenant_of(rt): | |
| raise ValueError("A worklist needs its owner's tenant runtime.") | |
| return rt, username, assistant_log._hash(rt, username) | |
| def _contains_rows(value): | |
| if isinstance(value, dict): | |
| return "rows" in value or any(_contains_rows(v) for v in value.values()) | |
| if isinstance(value, (list, tuple)): | |
| return any(_contains_rows(v) for v in value) | |
| return False | |
| def _provenance(session, tool_call): | |
| if tool_call is None: | |
| tool_call = getattr(session, "tool_call", None) | |
| if tool_call is None: | |
| tool_call = getattr(session, "_tool_call", None) | |
| if (not isinstance(tool_call, dict) or not isinstance(tool_call.get("name"), str) | |
| or not tool_call["name"].strip() or not isinstance(tool_call.get("args"), dict)): | |
| raise ValueError("A worklist needs its producing tool and source arguments.") | |
| if _contains_rows(tool_call["args"]): | |
| raise ValueError("Worklist replay arguments must not contain stored rows.") | |
| call = {"name": tool_call["name"], "args": copy.deepcopy(tool_call["args"])} | |
| json.dumps(call, allow_nan=False) | |
| return call | |
| def _cell(kind, value): | |
| if value is None: | |
| return | |
| if kind == "link": | |
| if value != "": | |
| _https(value) | |
| elif kind in ("number", "money"): | |
| if isinstance(value, bool) or not isinstance(value, (int, float)) or not math.isfinite(value): | |
| raise ValueError("A numeric worklist cell needs a finite number.") | |
| elif not isinstance(value, str): | |
| raise ValueError("A text or date worklist cell needs text.") | |
| elif kind == "date" and value: | |
| try: | |
| datetime.datetime.fromisoformat(value.replace("Z", "+00:00")) | |
| except ValueError as exc: | |
| raise ValueError("A worklist date needs an ISO date or timestamp.") from exc | |
| def _table(columns, rows): | |
| if not isinstance(columns, list) or not columns or not isinstance(rows, list): | |
| raise ValueError("A worklist needs columns and a list of rows.") | |
| keys = [] | |
| for column in columns: | |
| if (not isinstance(column, dict) or not isinstance(column.get("key"), str) | |
| or not column["key"].strip() or column["key"] in keys | |
| or not isinstance(column.get("label"), str) or not column["label"].strip() | |
| or not isinstance(column.get("type"), str) or column["type"] not in COLUMN_TYPES): | |
| raise ValueError("A worklist column needs a unique key, label, and supported type.") | |
| keys.append(column["key"]) | |
| for row in rows: | |
| if isinstance(row, dict) and set(row) == set(keys): | |
| cells = [row[key] for key in keys] | |
| elif isinstance(row, (list, tuple)) and len(row) == len(keys): | |
| cells = row | |
| else: | |
| raise ValueError("A worklist row must match its columns.") | |
| for column, value in zip(columns, cells): | |
| _cell(column["type"], value) | |
| def _checks(validation, resolve): | |
| if not isinstance(validation, list): | |
| raise ValueError("A worklist needs a list of validation checks.") | |
| for check in validation: | |
| if (not isinstance(check, dict) or set(check) != {"check", "a", "b", "ok"} | |
| or not isinstance(check["check"], str) or not check["check"].strip() | |
| or not isinstance(check["ok"], bool)): | |
| raise ValueError("A validation check needs check, a, b, and a boolean ok.") | |
| if (not isinstance(resolve, dict) or set(resolve) != {"label", "href"} | |
| or not isinstance(resolve["label"], str) or not resolve["label"].strip()): | |
| raise ValueError("A worklist needs a resolution label and link.") | |
| _https(resolve["href"]) | |
| def _key(worklist_id): | |
| return f"assistant_worklist_{worklist_id}" | |
| def _path(item): | |
| return f"assistant_worklists/{item['ownerHash']}/{item['id']}.json" | |
| def save(session, title, columns, rows, validation, resolve, *, tool_call=None, door=None): | |
| """Save all rows and one report artifact with the original producing tool's provenance.""" | |
| rt, username, h = _principal(session) | |
| if not all(callable(getattr(rt, name, None)) for name in ("get", "update", "upload_bytes", "download_bytes")): | |
| raise RuntimeError("Worklist storage is not available in this workspace.") | |
| if not isinstance(title, str) or not title.strip(): | |
| raise ValueError("A worklist needs a title.") | |
| call = _provenance(session, tool_call) | |
| door = door if door is not None else (getattr(session, "door", None) or getattr(session, "_door", None) or "app") | |
| if not isinstance(door, str) or door not in assistant_artifacts.DOORS: | |
| raise ValueError("That worklist door is not available.") | |
| _table(columns, rows) | |
| _checks(validation, resolve) | |
| links = _links() | |
| _https(links.app_link("#/artifacts")) | |
| from routes_query import _no_dashes | |
| title = _no_dashes(title).strip()[:200] | |
| worklist_id = secrets.token_hex(16) | |
| built_at = assistant_artifacts.timestamp(time.time()) | |
| payload = {"title": title, "columns": columns, "rows": rows, "total": len(rows), | |
| "validation": validation, "resolve": resolve, "builtAt": built_at} | |
| data = json.dumps(payload, ensure_ascii=False, allow_nan=False, separators=(",", ":")).encode("utf-8") | |
| item = {"version": 1, "id": worklist_id, "owner": username, "ownerHash": h, | |
| "tenant": session.tenant, "total": len(rows), "size": len(data), "builtAt": built_at} | |
| rt.upload_bytes(_path(item), data, message="Save assistant worklist") | |
| import agent_runtime | |
| sources = agent_runtime.producing_turn_sources(session) | |
| item["artifactId"] = assistant_artifacts.record(rt, username, { | |
| "kind": "report", "ref": worklist_id, "title": title, "door": door, | |
| "toolCall": call, "createdAt": built_at, "frozen_at": built_at, "sources": sources}) | |
| rt.update(_key(worklist_id), lambda _raw: copy.deepcopy(item), flush="sync") | |
| return {"id": worklist_id, "link": _https(links.artifact_link(item["artifactId"]))} | |
| def owned_artifact(rt, username, row): | |
| """Validate an active report against its immutable owner-bound worklist metadata.""" | |
| if (not isinstance(row, dict) or row.get("kind") != "report" or row.get("status") != "active" | |
| or (row.get("toolCall") or {}).get("name") not in {"build_chase_list", "build_contact_worklist"}): | |
| return None | |
| item = metadata(rt, row.get("ref")) | |
| if (item is None or item["owner"] != username | |
| or item["ownerHash"] != assistant_log._hash(rt, username) | |
| or item["artifactId"] != row.get("id") or item["builtAt"] != row.get("createdAt") | |
| or row.get("frozen_at", item["builtAt"]) != item["builtAt"]): | |
| return None | |
| return item | |
| def metadata(rt, worklist_id): | |
| """Read tenant metadata without granting the caller ownership.""" | |
| if not isinstance(worklist_id, str) or not _WORKLIST_ID.fullmatch(worklist_id): | |
| return None | |
| item = rt.get(_key(worklist_id)) | |
| if (not isinstance(item, dict) or item.get("id") != worklist_id | |
| or item.get("tenant") != assistant_log._tenant_of(rt) | |
| or not isinstance(item.get("owner"), str) or not item["owner"] | |
| or item.get("ownerHash") != assistant_log._hash(rt, item["owner"]) | |
| or any(type(item.get(k)) is not int or item[k] < 0 for k in ("total", "size")) | |
| or not isinstance(item.get("builtAt"), str) or not isinstance(item.get("artifactId"), str)): | |
| return None | |
| return copy.deepcopy(item) | |
| def read_page(rt, item, *, offset=0, limit=200): | |
| """Read a page only after the route has authorized the owner metadata.""" | |
| if type(offset) is not int or type(limit) is not int or offset < 0 or limit < 1: | |
| raise ValueError("A worklist page needs a nonnegative offset and positive limit.") | |
| data = rt.download_bytes(_path(item)) | |
| if data is None: | |
| return None | |
| if not isinstance(data, (bytes, bytearray, memoryview)) or len(data) != item["size"]: | |
| raise RuntimeError("This worklist could not be read.") | |
| payload = json.loads(bytes(data)) | |
| if (not isinstance(payload, dict) | |
| or set(payload) != {"title", "columns", "rows", "total", "validation", "resolve", "builtAt"} | |
| or not isinstance(payload["rows"], list) or len(payload["rows"]) != item["total"] | |
| or payload["total"] != item["total"] or payload["builtAt"] != item["builtAt"]): | |
| raise RuntimeError("This worklist could not be read.") | |
| payload["rows"] = payload["rows"][offset:offset + limit] | |
| return payload | |