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()