pac-vector 0.1.0__py3-none-any.whl

pac_vector/preview.py

@@ -0,0 +1,275 @@
+"""Live preview sidecar: a tiny HTTP server inside the MCP process.
+
+Started lazily on the first doc_create, bound to 127.0.0.1 on an OS-picked port
+(PAC_VECTOR_PORT pins one). Browsers subscribe to /events (Server-Sent Events) and
+get the full SVG of a document after every edit. It dies with the process.
+Nothing here may write to stdout — that is the JSON-RPC pipe.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import queue
+import threading
+import webbrowser
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from urllib.parse import unquote, urlparse
+
+log = logging.getLogger("pac_vector.preview")
+
+
+class Preview:
+    def __init__(self, store, host: str = "127.0.0.1", port: int = 0):
+        self.store = store
+        self.host = host
+        self.port = port
+        self.url: str | None = None
+        self._srv = None
+        self._clients: set[queue.Queue] = set()
+        self._lock = threading.Lock()
+
+    def start(self) -> str:
+        with self._lock:
+            if self._srv:
+                return self.url
+            handler = _handler(self)
+            try:
+                srv = ThreadingHTTPServer((self.host, self.port), handler)
+            except OSError:
+                if not self.port:
+                    raise
+                log.warning("port %s busy, falling back to a free port", self.port)
+                srv = ThreadingHTTPServer((self.host, 0), handler)
+            srv.daemon_threads = True
+            threading.Thread(target=srv.serve_forever, name="pac-vector-preview", daemon=True).start()
+            self._srv = srv
+            self.url = f"http://{self.host}:{srv.server_address[1]}/"
+            log.info("preview at %s", self.url)
+            if os.environ.get("PAC_VECTOR_OPEN_BROWSER") == "1":
+                webbrowser.open(self.url)
+            return self.url
+
+    def publish(self, msg: dict) -> None:
+        if not self._srv:
+            return
+        data = json.dumps(msg)
+        with self._lock:
+            clients = list(self._clients)
+        for q in clients:
+            try:
+                q.put_nowait(data)
+            except queue.Full:  # slow tab: it skips a frame, the next one is a full SVG anyway
+                pass
+
+    def _register(self, q):
+        with self._lock:
+            self._clients.add(q)
+
+    def _unregister(self, q):
+        with self._lock:
+            self._clients.discard(q)
+
+
+def _handler(pv: Preview):
+    class Handler(BaseHTTPRequestHandler):
+        server_version = "pac-vector"
+
+        def log_message(self, fmt, *args):  # default goes to stderr; keep it quiet
+            log.debug(fmt, *args)
+
+        def do_GET(self):
+            path = urlparse(self.path).path
+            if path == "/":
+                self._send(200, "text/html; charset=utf-8", PAGE.encode("utf-8"))
+            elif path == "/events":
+                self._events()
+            elif path.startswith("/svg/"):
+                doc = pv.store.docs.get(unquote(path[5:]))
+                if not doc:
+                    self._send(404, "text/plain", b"no such document")
+                    return
+                with pv.store.lock:
+                    from lxml import etree
+
+                    body = etree.tostring(doc.root, encoding="utf-8")
+                self._send(200, "image/svg+xml", body)
+            else:
+                self._send(404, "text/plain", b"not found")
+
+        def _send(self, code, ctype, body: bytes):
+            self.send_response(code)
+            self.send_header("Content-Type", ctype)
+            self.send_header("Content-Length", str(len(body)))
+            self.send_header("Cache-Control", "no-store")
+            self.end_headers()
+            self.wfile.write(body)
+
+        def _write(self, data: str):
+            self.wfile.write(f"data: {data}\n\n".encode("utf-8"))
+            self.wfile.flush()
+
+        def _events(self):
+            self.send_response(200)
+            self.send_header("Content-Type", "text/event-stream")
+            self.send_header("Cache-Control", "no-store")
+            self.end_headers()
+            q: queue.Queue = queue.Queue(maxsize=64)
+            pv._register(q)  # register first: a racing edit arrives twice, never zero times
+            try:
+                with pv.store.lock:
+                    initial = [d.payload() for d in pv.store.docs.values()]
+                for p in initial:
+                    self._write(json.dumps(p))
+                while True:
+                    try:
+                        self._write(q.get(timeout=15))
+                    except queue.Empty:
+                        self.wfile.write(b": ping\n\n")
+                        self.wfile.flush()
+            except OSError:  # tab closed
+                pass
+            finally:
+                pv._unregister(q)
+
+    return Handler
+
+
+PAGE = r"""<!doctype html>
+<html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>pac-vector preview</title>
+<style>
+:root{--bg:#1e1f22;--panel:#2b2d31;--line:#3a3c42;--fg:#e6e6e6;--mut:#9aa0a6;--acc:#7c9cff;--hl:#ff3ec8}
+*{box-sizing:border-box}
+body{margin:0;background:var(--bg);color:var(--fg);font:13px/1.4 system-ui,"Segoe UI",sans-serif;height:100vh;display:flex;flex-direction:column}
+#tabs{display:flex;gap:2px;padding:6px 8px 0;background:var(--panel);border-bottom:1px solid var(--line);overflow-x:auto;min-height:33px}
+.tab{padding:6px 12px;border-radius:6px 6px 0 0;cursor:pointer;color:var(--mut);white-space:nowrap;border:1px solid transparent;border-bottom:none}
+.tab.on{background:var(--bg);color:var(--fg);border-color:var(--line)}
+.tab .dot{display:inline-block;width:6px;height:6px;border-radius:50%;background:var(--acc);margin-left:6px;visibility:hidden}
+.tab.flash .dot{visibility:visible}
+#bar{display:flex;gap:12px;align-items:center;padding:6px 12px;border-bottom:1px solid var(--line);color:var(--mut);font-size:12px}
+#bar button{background:var(--panel);color:var(--fg);border:1px solid var(--line);border-radius:4px;padding:2px 10px;cursor:pointer}
+#bar a{color:var(--acc)}
+#info{flex:1;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+#wrap{flex:1;overflow:auto;display:grid;place-items:center;padding:24px}
+#page{position:relative;box-shadow:0 0 0 1px var(--line),0 8px 30px #0008;background-color:#fff;
+  background-image:conic-gradient(#e6e6e6 25%,#fff 0 50%,#e6e6e6 0 75%,#fff 0);background-size:16px 16px}
+#page.bg{background-image:none}
+#page>svg{display:block}
+#ov{position:absolute;inset:0;pointer-events:none}
+.box{position:absolute;border:1.5px dashed var(--hl);transition:opacity .8s}
+.hov{position:absolute;border:1px solid var(--acc)}
+#status{padding:4px 12px;border-top:1px solid var(--line);color:var(--mut);font:12px ui-monospace,Consolas,monospace;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+#empty{color:var(--mut)}
+</style></head><body>
+<div id="tabs"></div>
+<div id="bar"><span id="info"></span><button id="zoom">fit</button><a id="raw" target="_blank">raw svg</a></div>
+<div id="wrap"><div id="empty">No documents open — call doc_create.</div><div id="page" hidden><div id="ov"></div></div></div>
+<div id="status">connecting…</div>
+<script>
+const INK = "http://www.inkscape.org/namespaces/inkscape";
+const docs = {}; let active = decodeURIComponent(location.hash.slice(1)) || null, fit = true;
+const $ = id => document.getElementById(id);
+const esc = s => String(s).replace(/[&<>"]/g, c => ({"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;"}[c]));
+const svgEl = () => $("page").querySelector(":scope > svg");
+
+function tabs() {
+  const t = $("tabs"); t.innerHTML = "";
+  for (const id in docs) {
+    const el = document.createElement("div");
+    el.className = "tab" + (id === active ? " on" : "");
+    el.title = id; el.innerHTML = esc(docs[id].name) + "<span class=dot></span>";
+    el.onclick = () => { location.hash = id; };
+    t.appendChild(el);
+  }
+}
+function show() {
+  const d = docs[active];
+  $("empty").hidden = !!d; $("page").hidden = !d;
+  if (!d) { $("info").textContent = ""; return; }
+  $("info").textContent = d.info; $("info").title = d.info;
+  $("raw").href = "/svg/" + encodeURIComponent(d.id);
+  const old = svgEl(); if (old) old.remove();
+  const parsed = new DOMParser().parseFromString(d.svg, "image/svg+xml").documentElement;
+  if (parsed.nodeName !== "svg") { $("status").textContent = "preview could not parse the SVG"; return; }
+  $("page").insertBefore(document.importNode(parsed, true), $("ov"));
+  $("page").style.backgroundColor = d.background || "#fff";
+  $("page").classList.toggle("bg", !!d.background);
+  size(); highlight(d.touched);
+}
+function size() {
+  const s = svgEl(); if (!s) return;
+  s.style.width = s.style.height = "";
+  const r = s.getBoundingClientRect();
+  if (fit && r.width && r.height) {
+    const W = $("wrap").clientWidth - 48, H = $("wrap").clientHeight - 48, k = Math.min(W / r.width, H / r.height);
+    s.style.width = r.width * k + "px"; s.style.height = r.height * k + "px";
+  }
+  $("zoom").textContent = fit ? "fit" : "100%";
+}
+function boxOf(el, cls) {
+  const pr = $("page").getBoundingClientRect(), r = el.getBoundingClientRect();
+  if (!r.width && !r.height) return null;
+  const b = document.createElement("div"); b.className = cls;
+  Object.assign(b.style, {left: r.left - pr.left - 3 + "px", top: r.top - pr.top - 3 + "px",
+                          width: r.width + 6 + "px", height: r.height + 6 + "px"});
+  return b;
+}
+function highlight(ids) {
+  const ov = $("ov"); ov.querySelectorAll(".box").forEach(b => b.remove());
+  for (const id of ids || []) {
+    const el = svgEl() && svgEl().querySelector('[id="' + CSS.escape(id) + '"]');
+    if (!el || el.closest("defs")) continue;
+    const b = boxOf(el, "box"); if (b) ov.appendChild(b);
+  }
+  setTimeout(() => ov.querySelectorAll(".box").forEach(b => b.style.opacity = 0), 2500);
+}
+function pick(t) {
+  const s = svgEl();
+  while (t && t !== s && !(t.id && t.getAttributeNS(INK, "groupmode") !== "layer")) t = t.parentNode;
+  return t && t !== s && t.id ? t : null;
+}
+function where(el) {
+  const path = []; let p = el.parentNode;
+  while (p && p !== svgEl()) {
+    if (p.id) path.unshift(p.getAttributeNS(INK, "groupmode") === "layer" ? 'layer "' + p.getAttributeNS(INK, "label") + '" #' + p.id : "#" + p.id);
+    p = p.parentNode;
+  }
+  return "#" + el.id + " <" + el.nodeName + ">" + (path.length ? "  in " + path.join(" › ") : "");
+}
+$("page").addEventListener("mousemove", e => {
+  $("ov").querySelectorAll(".hov").forEach(b => b.remove());
+  const el = pick(e.target); if (!el) return;
+  const b = boxOf(el, "hov"); if (b) $("ov").appendChild(b);
+});
+$("page").addEventListener("mouseleave", () => $("ov").querySelectorAll(".hov").forEach(b => b.remove()));
+$("page").addEventListener("click", e => {
+  const el = pick(e.target); if (!el) return;
+  $("status").textContent = where(el);
+  navigator.clipboard && navigator.clipboard.writeText(el.id).catch(() => {});
+});
+$("zoom").onclick = () => { fit = !fit; size(); highlight([]); };
+addEventListener("resize", () => { if (fit) size(); });
+addEventListener("hashchange", () => { active = decodeURIComponent(location.hash.slice(1)); tabs(); show(); });
+
+const es = new EventSource("/events");
+es.onopen = () => { $("status").textContent = "live — click an element to copy its id"; };
+es.onerror = () => { $("status").textContent = "disconnected, retrying… (is the MCP server still running?)"; };
+es.onmessage = e => {
+  const m = JSON.parse(e.data);
+  if (m.type === "doc") {
+    if (docs[m.id] && docs[m.id].version > m.version) return;
+    docs[m.id] = m;
+    if (!active || !docs[active]) { active = m.id; history.replaceState(null, "", "#" + m.id); }
+    tabs();
+    if (m.id === active) { show(); if (m.summary) $("status").textContent = m.summary.split("\n")[0]; }
+    else { const t = [...document.querySelectorAll(".tab")].find(x => x.title === m.id); if (t) t.classList.add("flash"); }
+  } else if (m.type === "closed") {
+    delete docs[m.id];
+    if (active === m.id) active = Object.keys(docs)[0] || null;
+    tabs(); show();
+  }
+};
+</script></body></html>
+"""

pac_vector/render.py

@@ -0,0 +1,168 @@
+"""Rasterising with resvg, and visual bounding boxes measured from pixels.
+
+There is no browser here, so geometry (text, strokes, filters, curves) is
+measured the robust way: render the element alone onto a transparent canvas and
+read the alpha channel's extent. Two passes — a coarse one over a wide region
+around the page, then a fine one zoomed onto the hit — give sub-pixel-ish
+precision for anything within two page-widths of the canvas.
+"""
+
+from __future__ import annotations
+
+import copy
+import io
+
+import resvg_py
+from PIL import Image as PILImage
+
+from ._xml import children, is_svg, iter_els, local, numbers, parse_length
+
+MAX_SIDE = 2048
+
+_UNIT_PX = {"": 1.0, "px": 1.0, "mm": 96 / 25.4, "cm": 96 / 2.54, "in": 96.0, "pt": 96 / 72, "pc": 16.0}
+
+Box = tuple[float, float, float, float]  # x, y, w, h
+
+
+def viewbox(root) -> Box:
+    vb = numbers(root.get("viewBox") or "")
+    if len(vb) == 4 and vb[2] > 0 and vb[3] > 0:
+        return vb[0], vb[1], vb[2], vb[3]
+    w, h = size_px(root, use_viewbox=False)
+    return 0.0, 0.0, w, h
+
+
+def size_px(root, use_viewbox: bool = True) -> tuple[float, float]:
+    out = []
+    for attr, default in (("width", 300.0), ("height", 150.0)):
+        ln = parse_length(root.get(attr))
+        if ln and ln[1] in _UNIT_PX:
+            out.append(ln[0] * _UNIT_PX[ln[1]])
+        elif use_viewbox:
+            vb = numbers(root.get("viewBox") or "")
+            out.append(vb[2] if attr == "width" and len(vb) == 4 else vb[3] if len(vb) == 4 else default)
+        else:
+            out.append(default)
+    return out[0], out[1]
+
+
+def _has_text(root) -> bool:
+    return any(local(e) in ("text", "textPath", "tspan") for e in iter_els(root))
+
+
+def _png(root, background: str | None, resources_dir: str | None) -> bytes:
+    from lxml import etree
+
+    svg = etree.tostring(root, encoding="unicode")
+    try:
+        return resvg_py.svg_to_bytes(
+            svg_string=svg,
+            background=background,
+            # Font DB loading is the slow part; only pay it when text exists.
+            skip_system_fonts=not _has_text(root),
+            resources_dir=resources_dir,
+            log_information=False,  # True would print to stdout = the JSON-RPC pipe
+        )
+    except ValueError as e:
+        from ._xml import EditError
+
+        raise EditError(f"render failed: {e}") from None
+
+
+def render_region(root, region: Box, pw: int, ph: int, background=None, resources_dir=None) -> bytes:
+    clone = copy.deepcopy(root)
+    clone.set("viewBox", " ".join(f"{v:.6g}" for v in region))
+    clone.set("width", str(pw))
+    clone.set("height", str(ph))
+    clone.set("preserveAspectRatio", "none")
+    return _png(clone, background, resources_dir)
+
+
+def render_page(root, scale: float = 1.0, background=None, resources_dir=None) -> tuple[bytes, int, int, float]:
+    """Whole page. Returns (png, w, h, effective_scale); scale is capped so the
+    longest side stays ≤ MAX_SIDE."""
+    w, h = size_px(root)
+    scale = min(scale, MAX_SIDE / max(w, h, 1))
+    pw, ph = max(1, round(w * scale)), max(1, round(h * scale))
+    return render_region(root, viewbox(root), pw, ph, background, resources_dir), pw, ph, scale
+
+
+def alpha_bbox(png: bytes) -> tuple[int, int, int, int] | None:
+    im = PILImage.open(io.BytesIO(png))
+    if im.mode != "RGBA":
+        im = im.convert("RGBA")
+    return im.getchannel("A").getbbox()
+
+
+def _bbox_in(root, region: Box, longest: int) -> Box | None:
+    rx, ry, rw, rh = region
+    if rw <= 0 or rh <= 0:
+        return None
+    s = longest / max(rw, rh)
+    pw, ph = max(1, round(rw * s)), max(1, round(rh * s))
+    bb = alpha_bbox(render_region(root, region, pw, ph))
+    if not bb:
+        return None
+    x0, y0, x1, y1 = bb
+    return rx + x0 * rw / pw, ry + y0 * rh / ph, (x1 - x0) * rw / pw, (y1 - y0) * rh / ph
+
+
+def measure(root) -> Box | None:
+    """Visual bbox (stroke, filters included) of everything drawable in `root`,
+    in root user units. None if nothing visible within 2 page-widths."""
+    vx, vy, vw, vh = viewbox(root)
+    coarse = _bbox_in(root, (vx - 2 * vw, vy - 2 * vh, 5 * vw, 5 * vh), 800)
+    if not coarse:
+        return None
+    x, y, w, h = coarse
+    m = max(5 * max(vw, vh) / 800 * 2, max(w, h) * 0.02)
+    fine = _bbox_in(root, (x - m, y - m, w + 2 * m, h + 2 * m), 1024)
+    return fine or coarse
+
+
+def isolate(root, ids: set[str]):
+    """Clone of `root` keeping only the elements with these ids (plus their
+    ancestors, descendants and all non-drawable parts like <defs>)."""
+    clone = copy.deepcopy(root)
+    targets = {e for e in iter_els(clone) if e.get("id") in ids}
+    ancestors = {a for t in targets for a in t.iterancestors()}
+
+    def prune(node):
+        for c in children(node):
+            if c in targets:
+                continue
+            if c in ancestors:
+                prune(c)
+            elif not is_svg(c) or local(c) in ("defs", "style", "metadata", "title", "desc"):
+                continue
+            else:
+                node.remove(c)
+
+    prune(clone)
+    return clone
+
+
+def union(boxes: list[Box]) -> Box | None:
+    boxes = [b for b in boxes if b]
+    if not boxes:
+        return None
+    x0 = min(b[0] for b in boxes)
+    y0 = min(b[1] for b in boxes)
+    x1 = max(b[0] + b[2] for b in boxes)
+    y1 = max(b[1] + b[3] for b in boxes)
+    return x0, y0, x1 - x0, y1 - y0
+
+
+def warm() -> None:
+    """Load the renderer, the font DB and PIL's PNG codec BEFORE the MCP loop
+    starts. On this Windows setup a native module first loaded from inside the
+    FastMCP stdio loop can wedge the process (see pac-pincers' _excel.py)."""
+    from lxml import etree
+
+    from ._xml import parse_document
+
+    root = parse_document(
+        '<svg width="8" height="8"><rect width="4" height="4"/><text y="8">a</text></svg>'
+    )
+    alpha_bbox(render_page(root)[0])
+    etree.tostring(root)