excalidraw-skill-pack-render 0.1.0__py3-none-any.whl

excalidraw_render/__init__.py

@@ -0,0 +1,6 @@
+"""excalidraw-render: render Excalidraw JSON to PNG."""
+
+from excalidraw_render.render import render_to_png
+
+__all__ = ["render_to_png"]
+__version__ = "0.1.0"

excalidraw_render/__main__.py

@@ -0,0 +1,5 @@
+"""python -m excalidraw_render entry."""
+
+from excalidraw_render.cli import main
+
+raise SystemExit(main())

excalidraw_render/cli.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from excalidraw_render.render import render_to_png
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Render Excalidraw JSON to PNG")
+    parser.add_argument("input", type=Path, help="Path to .excalidraw JSON file")
+    parser.add_argument(
+        "--theme", default="default-sketchy", help="Theme name (default: default-sketchy)"
+    )
+    parser.add_argument(
+        "--output", "-o", type=Path, default=None, help="Output PNG path (default: input with .png)"
+    )
+    parser.add_argument("--scale", type=int, default=2, help="Device scale factor (default: 2)")
+    parser.add_argument(
+        "--width", type=int, default=1920, help="Max viewport width (default: 1920)"
+    )
+    args = parser.parse_args()
+
+    if not args.input.exists():
+        print(f"ERROR: File not found: {args.input}", file=sys.stderr)
+        return 1
+
+    output = args.output if args.output is not None else args.input.with_suffix(".png")
+    json_str = args.input.read_text(encoding="utf-8")
+    png_bytes = render_to_png(json_str, theme=args.theme, scale=args.scale, width=args.width)
+    output.write_bytes(png_bytes)
+    print(str(output))
+    return 0

excalidraw_render/render.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import importlib.resources
+import json
+import tempfile
+from pathlib import Path
+
+
+def _compute_bounding_box(elements: list[dict]) -> tuple[float, float, float, float]:
+    min_x = float("inf")
+    min_y = float("inf")
+    max_x = float("-inf")
+    max_y = float("-inf")
+
+    for el in elements:
+        if el.get("isDeleted"):
+            continue
+        x = el.get("x", 0)
+        y = el.get("y", 0)
+        w = el.get("width", 0)
+        h = el.get("height", 0)
+
+        if el.get("type") in ("arrow", "line") and "points" in el:
+            for px, py in el["points"]:
+                min_x = min(min_x, x + px)
+                min_y = min(min_y, y + py)
+                max_x = max(max_x, x + px)
+                max_y = max(max_y, y + py)
+        else:
+            min_x = min(min_x, x)
+            min_y = min(min_y, y)
+            max_x = max(max_x, x + abs(w))
+            max_y = max(max_y, y + abs(h))
+
+    if min_x == float("inf"):
+        return (0, 0, 800, 600)
+
+    return (min_x, min_y, max_x, max_y)
+
+
+def render_to_png(json_str: str, *, theme: str, scale: int, width: int) -> bytes:
+    from playwright.sync_api import sync_playwright
+
+    data = json.loads(json_str)
+    elements = [e for e in data.get("elements", []) if not e.get("isDeleted")]
+    min_x, min_y, max_x, max_y = _compute_bounding_box(elements)
+    padding = 80
+    vp_w = min(int(max_x - min_x + padding * 2), width)
+    vp_h = max(int(max_y - min_y + padding * 2), 600)
+
+    ref = importlib.resources.files("excalidraw_render").joinpath("render_template.html")
+    with importlib.resources.as_file(ref) as template_path:
+        template_url = Path(template_path).as_uri()
+        with sync_playwright() as p:
+            browser = p.chromium.launch(headless=True)
+            page = browser.new_page(
+                viewport={"width": vp_w, "height": vp_h},
+                device_scale_factor=scale,
+            )
+            page.goto(template_url)
+            # Wait for the ES module to load (imports from esm.sh)
+            page.wait_for_function("window.__moduleReady === true", timeout=30000)
+            result = page.evaluate(f"window.renderDiagram({json_str})")
+            if not result or not result.get("success"):
+                error_msg = (
+                    result.get("error", "Unknown render error")
+                    if result
+                    else "renderDiagram returned null"
+                )
+                browser.close()
+                raise RuntimeError(f"Render failed: {error_msg}")
+            page.wait_for_function("window.__renderComplete === true", timeout=15000)
+            svg_el = page.query_selector("#root svg")
+            if svg_el is None:
+                browser.close()
+                raise RuntimeError("No SVG element found after render")
+            with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmp:
+                tmp_path = Path(tmp.name)
+            svg_el.screenshot(path=str(tmp_path))
+            png_bytes = tmp_path.read_bytes()
+            tmp_path.unlink(missing_ok=True)
+            browser.close()
+            return png_bytes

excalidraw_render/render_template.html

@@ -0,0 +1,57 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8" />
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body { background: #ffffff; overflow: hidden; }
+    #root { display: inline-block; }
+    #root svg { display: block; }
+  </style>
+</head>
+<body>
+  <div id="root"></div>
+
+  <script type="module">
+    import { exportToSvg } from "https://esm.sh/@excalidraw/excalidraw@0.18.0";
+
+    window.renderDiagram = async function(jsonData) {
+      try {
+        const data = typeof jsonData === "string" ? JSON.parse(jsonData) : jsonData;
+        const elements = data.elements || [];
+        const appState = data.appState || {};
+        const files = data.files || {};
+
+        // Force white background in appState
+        appState.viewBackgroundColor = appState.viewBackgroundColor || "#ffffff";
+        appState.exportWithDarkMode = false;
+
+        const svg = await exportToSvg({
+          elements: elements,
+          appState: {
+            ...appState,
+            exportBackground: true,
+          },
+          files: files,
+        });
+
+        // Clear any previous render
+        const root = document.getElementById("root");
+        root.innerHTML = "";
+        root.appendChild(svg);
+
+        window.__renderComplete = true;
+        window.__renderError = null;
+        return { success: true, width: svg.getAttribute("width"), height: svg.getAttribute("height") };
+      } catch (err) {
+        window.__renderComplete = true;
+        window.__renderError = err.message;
+        return { success: false, error: err.message };
+      }
+    };
+
+    // Signal that the module is loaded and ready
+    window.__moduleReady = true;
+  </script>
+</body>
+</html>

excalidraw_render/theme.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass
+class ResolvedTheme:
+    manifest: dict
+    palette: dict
+    typography: dict
+    elements: dict
+    layouts: dict
+    palette_markdown: str
+
+
+def _load_one(theme_dir: Path) -> dict:
+    manifest = json.loads((theme_dir / "theme.json").read_text(encoding="utf-8"))
+    try:
+        palette = json.loads((theme_dir / "palette.json").read_text(encoding="utf-8"))
+    except FileNotFoundError:
+        palette = {}
+    try:
+        typography = json.loads((theme_dir / "typography.json").read_text(encoding="utf-8"))
+    except FileNotFoundError:
+        typography = {}
+    elements: dict = {}
+    elements_dir = theme_dir / "elements"
+    if elements_dir.is_dir():
+        for f in elements_dir.iterdir():
+            if f.suffix == ".json":
+                elements[f.stem] = json.loads(f.read_text(encoding="utf-8"))
+    layouts: dict = {}
+    layouts_dir = theme_dir / "layouts"
+    if layouts_dir.is_dir():
+        for f in layouts_dir.iterdir():
+            if f.suffix == ".md":
+                layouts[f.stem] = f.read_text(encoding="utf-8")
+    try:
+        palette_markdown = (theme_dir / "palette.md").read_text(encoding="utf-8")
+    except FileNotFoundError:
+        palette_markdown = ""
+    return {
+        "manifest": manifest,
+        "palette": palette,
+        "typography": typography,
+        "elements": elements,
+        "layouts": layouts,
+        "palette_markdown": palette_markdown,
+    }
+
+
+def _merge(parent: dict, child: dict) -> dict:
+    return {
+        "manifest": child.get("manifest") or parent.get("manifest"),
+        "palette": {**parent.get("palette", {}), **child.get("palette", {})},
+        "typography": child.get("typography") or parent.get("typography"),
+        "elements": {**parent.get("elements", {}), **child.get("elements", {})},
+        "layouts": {**parent.get("layouts", {}), **child.get("layouts", {})},
+        "palette_markdown": child.get("palette_markdown") or parent.get("palette_markdown") or "",
+    }
+
+
+def resolve_theme(name: str, *, themes_dir: Path) -> ResolvedTheme:
+    theme_dir = themes_dir / name
+    if not (theme_dir / "theme.json").exists():
+        raise LookupError(f"Theme '{name}' not found at {theme_dir}")
+    resolved = _load_one(theme_dir)
+    seen: set[str] = {name}
+    while resolved["manifest"].get("extends"):
+        parent_name = resolved["manifest"]["extends"]
+        if parent_name in seen:
+            raise ValueError(f"Theme inheritance cycle at {parent_name}")
+        seen.add(parent_name)
+        parent_dir = themes_dir / parent_name
+        parent = _load_one(parent_dir)
+        child_manifest = {**resolved["manifest"]}
+        del child_manifest["extends"]
+        resolved["manifest"] = child_manifest
+        resolved = _merge(parent, resolved)
+    return ResolvedTheme(
+        manifest=resolved["manifest"],
+        palette=resolved["palette"],
+        typography=resolved["typography"],
+        elements=resolved["elements"],
+        layouts=resolved["layouts"],
+        palette_markdown=resolved["palette_markdown"],
+    )

excalidraw_skill_pack_render-0.1.0.dist-info/METADATA

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: excalidraw-skill-pack-render
+Version: 0.1.0
+Summary: Render Excalidraw JSON to PNG. Python binding for excalidraw-skill-pack.
+Author: Timur Isachenko
+License-Expression: MIT
+Requires-Python: >=3.11
+Requires-Dist: playwright>=1.40.0
+Description-Content-Type: text/markdown
+
+# excalidraw-render
+
+Python binding for rendering Excalidraw JSON to PNG, part of excalidraw-skill-pack.
+
+## Install
+
+```bash
+pip install excalidraw-skill-pack-render
+playwright install chromium
+```
+
+## Python API
+
+```python
+from excalidraw_render import render_to_png
+
+png_bytes = render_to_png(json_str, theme="default-sketchy", scale=2, width=1920)
+```
+
+## CLI
+
+```bash
+excalidraw-render diagram.excalidraw --output diagram.png --scale 2 --width 1920
+```
+
+## Parity with Node binding
+
+The Python and Node renderers share `packages/shared/render_template.html` and produce pixel-equivalent output at matching scale/width settings.

excalidraw_skill_pack_render-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+excalidraw_render/__init__.py,sha256=WJPvKsDWdWoRSgJDLkRhDyeC_DLTOSFLP7ZkKTJlpvM,159
+excalidraw_render/__main__.py,sha256=79redNMchlyC3RA7zPFt4lrcFhbDVg6hSInD5Og1t7Q,107
+excalidraw_render/cli.py,sha256=-Ey4Th-KUJI70n_HMF-wxAYgsid-5huqkpHSAXSNdKo,1251
+excalidraw_render/render.py,sha256=1TdQezjjRlyy80-zfdiiqLX2Olf0g1Sj4muXjZymcpY,3146
+excalidraw_render/theme.py,sha256=tsS6D8yBGbtmGW2Ih0JKHWUglJt-oXxlrat646wXU0E,3151
+excalidraw_render/render_template.html,sha256=dO0ctd7o32kUZNMfu_s3nxtSSRv2aq0dvGdECewoG0o,1686
+excalidraw_skill_pack_render-0.1.0.dist-info/METADATA,sha256=h2-wdySXOa_ItwpeYy0oHR-W1HfjyyU4r8zcEcnepUU,934
+excalidraw_skill_pack_render-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+excalidraw_skill_pack_render-0.1.0.dist-info/entry_points.txt,sha256=q5LKF4I_6bYJ450gs0vWp5xg5ksQ19SnlsD9Ztpn0yg,65
+excalidraw_skill_pack_render-0.1.0.dist-info/RECORD,,

excalidraw_skill_pack_render-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

excalidraw_skill_pack_render-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+excalidraw-render = excalidraw_render.cli:main