vibe-sketcherDocumentation

Source code for vibesketcher.document.drafts

"""Provider-neutral, bounded scene review. A proposal never supplies trusted metadata."""

from __future__ import annotations

import hashlib
import json
import subprocess
import sys
import threading
import time
from collections.abc import Callable
from typing import Any

from pydantic import BaseModel, ConfigDict, Field

from vibesketcher.document.model import Canvas, Document
from vibesketcher.limits import check_depth

MAX_BYTES = 4 * 2**20
MAX_RESULT = 16 * 2**20
_WORKERS = threading.BoundedSemaphore(2)


[docs] class DraftRefused(ValueError): """The entire proposal was refused without changing its source."""
[docs] class DraftConflict(DraftRefused): """The review or transaction no longer names the current source."""
[docs] class Scope(BaseModel): model_config = ConfigDict(extra="forbid", strict=True) whole_drawing: bool = False nodes: list[str] = Field(default_factory=list, max_length=100) root_slots: list[int] = Field(default_factory=list, max_length=100) species: list[str] = Field(default_factory=list, max_length=100) reactions: list[str] = Field(default_factory=list, max_length=100)
[docs] class Proposal(BaseModel): model_config = ConfigDict(extra="forbid", strict=True) canvas: dict[str, Any] scope: Scope notes: str = Field(default="", max_length=4000)
[docs] def encoded(value: Any) -> bytes: check_depth(value, "draft") return json.dumps(value, sort_keys=True, separators=(",", ":"), allow_nan=False).encode()
[docs] def digest(document: Document, *, content: bool = False) -> str: data = document.model_dump(mode="json") if content: data.pop("revision") data["provenance"].pop("edits") return hashlib.sha256(encoded(data)).hexdigest()
[docs] def bounded(document: Document) -> None: if len(encoded(document.model_dump(mode="json"))) > MAX_BYTES: raise DraftRefused("Draft snapshots are limited to 4 MiB each.") atoms = 0 for node in (document.canvas.data or {}).values(): if isinstance(node, dict): items = node.get("atoms", []) if not isinstance(items, list): raise DraftRefused("Canvas atoms must be an array.") atoms += len(items) if atoms > 1000: raise DraftRefused("Draft snapshots are limited to 1,000 drawn atoms.")
[docs] def prepare_inside(source: Document, proposal: Proposal) -> dict[str, Any]: """Worker implementation: derive, compare and render independently of live state.""" from vibesketcher.document.derive import derive from vibesketcher.document.ket import read_scene from vibesketcher.render import render_svg bounded(source) candidate = source.model_copy(deep=True) candidate.canvas = Canvas(format="ket", data=proposal.canvas) bounded(candidate) before: dict[str, Any] = dict(source.canvas.data or {}) after = proposal.canvas for canvas in (before, after): root = canvas.get("root", {}) if not isinstance(root, dict) or not isinstance(root.get("nodes", []), list): raise DraftRefused("A canvas root must contain a node array.") if any(not isinstance(node, dict) for node in root.get("nodes", [])): raise DraftRefused("Canvas root entries must be objects.") scope = proposal.scope for names in (scope.nodes, scope.root_slots, scope.species, scope.reactions): if len(names) != len(set(names)): raise DraftRefused("Scope targets must be distinct.") if set(scope.nodes) - (set(before) | set(after)): raise DraftRefused("A scoped scene node does not exist.") for field in ("species", "reactions"): known = {item.id for item in getattr(source, field)} if set(getattr(scope, field)) - known: raise DraftRefused(f"Unknown {field} scope target.") changed = [key for key in sorted(set(before) | set(after)) if before.get(key) != after.get(key)] left = before.get("root", {}).get("nodes", []) right = after.get("root", {}).get("nodes", []) slots = [ i for i in range(max(len(left), len(right))) if (left[i] if i < len(left) else None) != (right[i] if i < len(right) else None) ] if any(i < 0 or i >= max(len(left), len(right)) for i in scope.root_slots): raise DraftRefused("Unknown root slot in scope.") if len(set(changed) - {"root"}) + len(slots) > 100: raise DraftRefused("A draft may change at most 100 scene objects.") if not scope.whole_drawing: if set(changed) - {"root"} - set(scope.nodes) or set(slots) - set(scope.root_slots): raise DraftRefused("The candidate changes scene objects outside its declared scope.") root_before = {k: v for k, v in before.get("root", {}).items() if k != "nodes"} root_after = {k: v for k, v in after.get("root", {}).items() if k != "nodes"} if root_before != root_after: raise DraftRefused("Root metadata changes require whole-drawing scope.") scene = read_scene(after) if any(f.mol is None or f.unsupported for f in scene.fragments): raise DraftRefused("Drafts require supported, valid molecular fragments.") refs = [n["$ref"] for n in right if "$ref" in n] if len(refs) != len(set(refs)): raise DraftRefused("Duplicate scene references are ambiguous.") derived = derive(candidate) candidate = derived.document changes: list[dict[str, Any]] = [] for field in ("species", "reactions"): old = {x.id: x.model_dump(mode="json") for x in getattr(source, field)} new = {x.id: x.model_dump(mode="json") for x in getattr(candidate, field)} for key in sorted(set(old) | set(new)): if old.get(key) == new.get(key): continue if not scope.whole_drawing and key in old and key not in getattr(scope, field): raise DraftRefused(f"Derived {field} {key} changes outside scope.") changes.append( {"kind": field, "id": key, "before": old.get(key), "after": new.get(key)} ) # A scene proposal cannot silently discard non-scene user records. for field in ("jobs", "highlights"): if getattr(source, field) != getattr(candidate, field): raise DraftRefused( f"Proposal would discard {field}; resolve those records explicitly first." ) old_data, new_data = source.model_dump(mode="json"), candidate.model_dump(mode="json") for field in set(old_data) - {"canvas", "species", "reactions"}: if old_data[field] != new_data[field]: raise DraftRefused(f"Proposal changes protected document field {field}.") bounded(candidate) def preview(document: Document) -> str: canvas: dict[str, Any] = dict(document.canvas.data or {}) if not document.species and not canvas.get("root", {}).get("nodes", []): return ( '<svg xmlns="http://www.w3.org/2000/svg" width="300" height="100">' '<text x="20" y="50">Empty drawing</text></svg>' ) try: return render_svg(document).decode() except ValueError: if document.species: raise from vibesketcher.render import RenderRefused raise RenderRefused("Cannot render this proposed scene") from None result = { "schema": "vibesketcher.draft/1", "source_revision": source.revision, "source_digest": digest(source), "candidate_digest": digest(candidate), "candidate": candidate.model_dump(mode="json"), "proposal": proposal.model_dump(mode="json"), "changes": {"nodes": changed, "root_slots": slots, "records": changes}, "warnings": derived.warnings, "before_svg": preview(source), "after_svg": preview(candidate), } if len(encoded(result)) > MAX_RESULT: raise DraftRefused("Draft result exceeds 16 MiB.") return result
[docs] def prepare( source: Document, proposal: Proposal | dict[str, Any], *, cancelled: Callable[[], bool] | None = None, timeout: float = 30, ) -> dict[str, Any]: """Prepare an inspectable draft in a killable worker, without editing source.""" bounded(source) spec = Proposal.model_validate(proposal) payload = encoded( {"source": source.model_dump(mode="json"), "proposal": spec.model_dump(mode="json")} ) if len(payload) > 2 * MAX_BYTES + 16384: raise DraftRefused("Draft request exceeds its snapshot budget.") if not 0 < timeout <= 30: raise DraftRefused("Draft deadline must be positive and at most 30 seconds.") if not _WORKERS.acquire(blocking=False): raise DraftRefused("Both draft workers are busy; retry later.") child = None try: child = subprocess.Popen( [sys.executable, "-m", "vibesketcher.document.draft_worker"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, ) deadline, first = time.monotonic() + timeout, True while True: if cancelled and cancelled(): raise DraftRefused("Draft preparation cancelled.") remaining = deadline - time.monotonic() if remaining <= 0: raise DraftRefused("Draft preparation exceeded its deadline.") try: output, _ = child.communicate( payload if first else None, timeout=min(0.05, remaining) ) break except subprocess.TimeoutExpired: first = False if cancelled and cancelled(): raise DraftRefused("Draft preparation cancelled.") if child.returncode or len(output) > MAX_RESULT: raise DraftRefused("Draft worker failed or exceeded the result bound.") result = json.loads(output) if not isinstance(result, dict) or "error" in result: raise DraftRefused( str(result.get("error", "Invalid worker response")) if isinstance(result, dict) else "Invalid worker response" ) return result finally: if child: if child.poll() is None: child.kill() child.communicate() _WORKERS.release()