predraw 0.1.1__py3-none-any.whl

predraw/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

predraw/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running predraw as: python -m predraw"""
+
+from .cli import main
+
+main()

predraw/bbox.py

@@ -0,0 +1,304 @@
+"""Bounding box computation for predraw elements.
+
+Computes axis-aligned bounding boxes from element geometry, including
+SVG path data parsing and transform application.
+"""
+
+from __future__ import annotations
+
+import re
+
+from .model import Element, Transform
+
+
+def compute_bbox(element: Element) -> tuple[float, float, float, float] | None:
+    """Compute the bounding box (min_x, min_y, max_x, max_y) of an element.
+
+    Handles:
+    - rect: (x, y, x+width, y+height)
+    - text: (x, y - font_size, x + estimated_width, y) -- rough estimate
+    - path: parse the d string and find coordinate extremes
+    - group: union of children's bboxes, with transform applied
+    - background: (0, 0, 0, 0) -- skip
+
+    Returns None if bbox can't be determined.
+    """
+    if element.type == "background":
+        return None
+
+    if element.type == "rect":
+        bbox = (element.x, element.y, element.x + element.width, element.y + element.height)
+
+    elif element.type == "text":
+        font_size = element.font.size if element.font else 16
+        # Rough width estimate: 0.6 * font_size per character
+        content = element.content or ""
+        estimated_width = len(content) * font_size * 0.6
+        # y is baseline; top is approximately y - font_size
+        x = element.x
+        if element.anchor == "middle":
+            x = element.x - estimated_width / 2
+        elif element.anchor == "end":
+            x = element.x - estimated_width
+        bbox = (x, element.y - font_size, x + estimated_width, element.y)
+
+    elif element.type == "path":
+        if not element.d:
+            return None
+        path_bbox = _bbox_from_path_d(element.d)
+        if path_bbox is None:
+            return None
+        bbox = path_bbox
+
+    elif element.type == "group":
+        if not element.elements:
+            return None
+        # Union of children bboxes
+        min_x = float("inf")
+        min_y = float("inf")
+        max_x = float("-inf")
+        max_y = float("-inf")
+        has_any = False
+        for child in element.elements:
+            child_bbox = compute_bbox(child)
+            if child_bbox is not None:
+                has_any = True
+                min_x = min(min_x, child_bbox[0])
+                min_y = min(min_y, child_bbox[1])
+                max_x = max(max_x, child_bbox[2])
+                max_y = max(max_y, child_bbox[3])
+        if not has_any:
+            return None
+        bbox = (min_x, min_y, max_x, max_y)
+
+    else:
+        return None
+
+    # Apply element transform if present
+    if element.transform is not None:
+        bbox = _apply_transform_to_bbox(bbox, element.transform)
+
+    return bbox
+
+
+# Regex to tokenize SVG path d strings: command letters and numbers
+_PATH_TOKEN_RE = re.compile(r"[A-Za-z]|[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?")
+
+
+def _bbox_from_path_d(d: str) -> tuple[float, float, float, float] | None:
+    """Parse SVG path d string and extract coordinate bounding box.
+
+    Handles M, L, H, V, C, S, Q, T, A, Z commands (uppercase = absolute).
+    For curves (C, S, Q), use control points as bbox approximation.
+    Lowercase (relative) commands need accumulation from current point.
+    """
+    tokens = _PATH_TOKEN_RE.findall(d)
+    if not tokens:
+        return None
+
+    xs: list[float] = []
+    ys: list[float] = []
+    # Current point for relative commands
+    cx, cy = 0.0, 0.0
+    i = 0
+
+    def next_num() -> float:
+        nonlocal i
+        i += 1
+        return float(tokens[i])
+
+    while i < len(tokens):
+        token = tokens[i]
+
+        if token == "M":
+            # Absolute moveto; consumes pairs of coordinates
+            cx = next_num()
+            cy = next_num()
+            xs.append(cx)
+            ys.append(cy)
+            # Implicit lineto pairs follow
+            while i + 1 < len(tokens) and not tokens[i + 1].isalpha():
+                cx = next_num()
+                cy = next_num()
+                xs.append(cx)
+                ys.append(cy)
+
+        elif token == "m":
+            # Relative moveto
+            cx += next_num()
+            cy += next_num()
+            xs.append(cx)
+            ys.append(cy)
+            while i + 1 < len(tokens) and not tokens[i + 1].isalpha():
+                cx += next_num()
+                cy += next_num()
+                xs.append(cx)
+                ys.append(cy)
+
+        elif token == "L":
+            while i + 1 < len(tokens) and not tokens[i + 1].isalpha():
+                cx = next_num()
+                cy = next_num()
+                xs.append(cx)
+                ys.append(cy)
+
+        elif token == "l":
+            while i + 1 < len(tokens) and not tokens[i + 1].isalpha():
+                cx += next_num()
+                cy += next_num()
+                xs.append(cx)
+                ys.append(cy)
+
+        elif token == "H":
+            while i + 1 < len(tokens) and not tokens[i + 1].isalpha():
+                cx = next_num()
+                xs.append(cx)
+
+        elif token == "h":
+            while i + 1 < len(tokens) and not tokens[i + 1].isalpha():
+                cx += next_num()
+                xs.append(cx)
+
+        elif token == "V":
+            while i + 1 < len(tokens) and not tokens[i + 1].isalpha():
+                cy = next_num()
+                ys.append(cy)
+
+        elif token == "v":
+            while i + 1 < len(tokens) and not tokens[i + 1].isalpha():
+                cy += next_num()
+                ys.append(cy)
+
+        elif token == "C":
+            # Cubic bezier: 3 pairs of coords (control1, control2, endpoint)
+            while i + 1 < len(tokens) and not tokens[i + 1].isalpha():
+                for _ in range(3):
+                    px = next_num()
+                    py = next_num()
+                    xs.append(px)
+                    ys.append(py)
+                # Endpoint becomes current
+                cx, cy = xs[-1], ys[-1]
+
+        elif token == "c":
+            # Relative cubic bezier
+            while i + 1 < len(tokens) and not tokens[i + 1].isalpha():
+                for _ in range(3):
+                    px = cx + next_num()
+                    py = cy + next_num()
+                    xs.append(px)
+                    ys.append(py)
+                # Endpoint becomes current (last appended pair)
+                cx, cy = xs[-1], ys[-1]
+
+        elif token == "S":
+            # Smooth cubic: 2 pairs (control2, endpoint)
+            while i + 1 < len(tokens) and not tokens[i + 1].isalpha():
+                for _ in range(2):
+                    px = next_num()
+                    py = next_num()
+                    xs.append(px)
+                    ys.append(py)
+                cx, cy = xs[-1], ys[-1]
+
+        elif token == "s":
+            while i + 1 < len(tokens) and not tokens[i + 1].isalpha():
+                for _ in range(2):
+                    px = cx + next_num()
+                    py = cy + next_num()
+                    xs.append(px)
+                    ys.append(py)
+                cx, cy = xs[-1], ys[-1]
+
+        elif token == "Q":
+            # Quadratic bezier: 2 pairs (control, endpoint)
+            while i + 1 < len(tokens) and not tokens[i + 1].isalpha():
+                for _ in range(2):
+                    px = next_num()
+                    py = next_num()
+                    xs.append(px)
+                    ys.append(py)
+                cx, cy = xs[-1], ys[-1]
+
+        elif token == "q":
+            while i + 1 < len(tokens) and not tokens[i + 1].isalpha():
+                for _ in range(2):
+                    px = cx + next_num()
+                    py = cy + next_num()
+                    xs.append(px)
+                    ys.append(py)
+                cx, cy = xs[-1], ys[-1]
+
+        elif token == "T":
+            # Smooth quadratic: 1 pair (endpoint)
+            while i + 1 < len(tokens) and not tokens[i + 1].isalpha():
+                cx = next_num()
+                cy = next_num()
+                xs.append(cx)
+                ys.append(cy)
+
+        elif token == "t":
+            while i + 1 < len(tokens) and not tokens[i + 1].isalpha():
+                cx += next_num()
+                cy += next_num()
+                xs.append(cx)
+                ys.append(cy)
+
+        elif token == "A":
+            # Arc: rx ry x-rotation large-arc-flag sweep-flag x y
+            while i + 1 < len(tokens) and not tokens[i + 1].isalpha():
+                # Skip rx, ry, x-rotation, large-arc-flag, sweep-flag
+                next_num()  # rx
+                next_num()  # ry
+                next_num()  # x-rotation
+                next_num()  # large-arc-flag
+                next_num()  # sweep-flag
+                cx = next_num()
+                cy = next_num()
+                xs.append(cx)
+                ys.append(cy)
+
+        elif token == "a":
+            while i + 1 < len(tokens) and not tokens[i + 1].isalpha():
+                next_num()  # rx
+                next_num()  # ry
+                next_num()  # x-rotation
+                next_num()  # large-arc-flag
+                next_num()  # sweep-flag
+                cx += next_num()
+                cy += next_num()
+                xs.append(cx)
+                ys.append(cy)
+
+        elif token in ("Z", "z"):
+            pass  # Close path, no coordinates
+
+        i += 1
+
+    if not xs or not ys:
+        return None
+
+    return (min(xs), min(ys), max(xs), max(ys))
+
+
+def _apply_transform_to_bbox(
+    bbox: tuple[float, float, float, float], transform: Transform
+) -> tuple[float, float, float, float]:
+    """Apply translate and scale to a bounding box."""
+    min_x, min_y, max_x, max_y = bbox
+    tx, ty = transform.translate
+    sx, sy = transform.scale
+
+    # Scale then translate
+    new_min_x = min_x * sx + tx
+    new_min_y = min_y * sy + ty
+    new_max_x = max_x * sx + tx
+    new_max_y = max_y * sy + ty
+
+    # Handle negative scales flipping min/max
+    return (
+        min(new_min_x, new_max_x),
+        min(new_min_y, new_max_y),
+        max(new_min_x, new_max_x),
+        max(new_min_y, new_max_y),
+    )

predraw/cli.py

@@ -0,0 +1,349 @@
+"""CLI entry point for predraw — argparse-based with build/pack/unpack subcommands."""
+
+from __future__ import annotations
+
+import argparse
+import copy
+import json
+import sys
+from itertools import groupby
+from pathlib import Path
+
+from .loader import load_config, load_scene, resolve_styles
+from .model import Element, Font, Scene, Style, Transform
+from .output import write_outputs
+from .pipeline import execute_pipeline
+from .renderer import render_svg
+from .validator import validate_config, validate_scene
+
+
+def main():
+    """Entry point for the predraw CLI."""
+    parser = argparse.ArgumentParser(prog="predraw", description="predraw scene builder")
+    subparsers = parser.add_subparsers(dest="command")
+
+    # -- build --
+    build_parser = subparsers.add_parser("build", help="Build scene into output files")
+    build_parser.add_argument("path", nargs="?", default=".", help="Project directory or scene file (default: .)")
+
+    # -- pack --
+    pack_parser = subparsers.add_parser("pack", help="Pack a scene directory into a single JSON file")
+    pack_parser.add_argument("path", nargs="?", default=".", help="Project directory or scene file (default: .)")
+    pack_parser.add_argument("-o", "--output", default="packed.json", help="Output file path (default: packed.json)")
+
+    # -- unpack --
+    unpack_parser = subparsers.add_parser("unpack", help="Unpack a packed JSON file into a project directory")
+    unpack_parser.add_argument("file", help="Packed JSON file to unpack")
+    unpack_parser.add_argument("-o", "--output", default=".", help="Output directory (default: .)")
+
+    # -- validate --
+    validate_parser = subparsers.add_parser("validate", help="Validate a scene or config JSON file against its schema")
+    validate_parser.add_argument("file", help="JSON file to validate")
+    validate_parser.add_argument("--schema", choices=["scene", "config"], default=None, help="Force schema type (auto-detected if omitted)")
+
+    args = parser.parse_args()
+
+    if args.command is None:
+        parser.print_help()
+        sys.exit(0)
+
+    try:
+        if args.command == "build":
+            _cmd_build(args.path)
+        elif args.command == "pack":
+            _cmd_pack(args.path, args.output)
+        elif args.command == "unpack":
+            _cmd_unpack(args.file, args.output)
+        elif args.command == "validate":
+            _cmd_validate(args.file, args.schema)
+    except FileNotFoundError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+    except json.JSONDecodeError as e:
+        print(f"Error: invalid JSON — {e}", file=sys.stderr)
+        sys.exit(1)
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+# ─── Build ───────────────────────────────────────────────────────────────────
+
+
+def _cmd_build(path: str) -> None:
+    """Build all outputs for a scene, grouped by mode to avoid redundant work."""
+    scene = load_scene(path)
+    config = load_config(path)
+    outputs = config.get("outputs", [])
+
+    if not outputs:
+        print("No outputs defined in config.")
+        return
+
+    # Resolve output directory from path
+    p = Path(path)
+    output_dir = str(p if p.is_dir() else p.parent)
+
+    # Group outputs by mode so we only resolve/render once per mode
+    def mode_key(o: dict) -> str:
+        return o.get("mode", "dark")
+
+    sorted_outputs = sorted(outputs, key=mode_key)
+
+    total_written: list[str] = []
+    for mode, group in groupby(sorted_outputs, key=mode_key):
+        group_outputs = list(group)
+        print(f"Building mode: {mode} ({len(group_outputs)} output(s))")
+
+        # Deep copy, resolve styles, run pipeline, render
+        scene_copy = copy.deepcopy(scene)
+        resolve_styles(scene_copy, mode)
+        execute_pipeline(scene_copy)
+        svg = render_svg(scene_copy)
+
+        # Write all outputs for this mode
+        mode_config = {"outputs": group_outputs}
+        written = write_outputs(svg, mode_config, output_dir)
+        total_written.extend(written)
+
+    print(f"\nDone — {len(total_written)} file(s) written.")
+
+
+# ─── Validate ───────────────────────────────────────────────────────────────
+
+
+def _cmd_validate(file: str, schema_type: str | None) -> None:
+    """Validate a JSON file against its scene or config schema."""
+    file_path = Path(file)
+    if not file_path.exists():
+        raise FileNotFoundError(f"File not found: {file}")
+
+    with open(file_path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+
+    # Auto-detect schema type if not forced: presence of "outputs" key means config
+    if schema_type is None:
+        schema_type = "config" if "outputs" in data else "scene"
+
+    if schema_type == "config":
+        errors = validate_config(data)
+        label = "config"
+    else:
+        errors = validate_scene(data)
+        label = "scene"
+
+    if errors:
+        print(f"Invalid {label} file: {file_path}", file=sys.stderr)
+        for err in errors:
+            print(f"  {err}", file=sys.stderr)
+        sys.exit(1)
+    else:
+        print(f"Valid {label} file")
+
+
+# ─── Pack ────────────────────────────────────────────────────────────────────
+
+
+def _cmd_pack(path: str, output_file: str) -> None:
+    """Pack a scene directory into a single self-contained JSON file."""
+    scene = load_scene(path)
+    packed = pack_scene(scene)
+
+    out_path = Path(output_file)
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    out_path.write_text(json.dumps(packed, indent=2), encoding="utf-8")
+    print(f"Packed scene written to: {out_path}")
+
+
+def pack_scene(scene: Scene) -> dict:
+    """Convert a Scene to a packed JSON-serializable dict.
+
+    Removes imports (already resolved into defs) and assigns IDs
+    to elements that lack them for referenceability.
+    """
+    data = _scene_to_dict(scene)
+
+    # Remove imports — they are already resolved into defs
+    data.pop("imports", None)
+
+    # Flatten: assign IDs to elements that don't have one
+    _assign_ids(data.get("elements", []))
+
+    return data
+
+
+def _assign_ids(elements: list[dict], counter: list[int] | None = None) -> None:
+    """Recursively assign auto-generated IDs to elements missing one."""
+    if counter is None:
+        counter = [0]
+
+    for el in elements:
+        if not el.get("id"):
+            el["id"] = f"el-{counter[0]}"
+            counter[0] += 1
+        # Recurse into child elements
+        if "elements" in el:
+            _assign_ids(el["elements"], counter)
+
+
+# ─── Unpack ──────────────────────────────────────────────────────────────────
+
+
+def _cmd_unpack(file: str, output_dir: str) -> None:
+    """Unpack a packed JSON file into a project directory."""
+    file_path = Path(file)
+    if not file_path.exists():
+        raise FileNotFoundError(f"File not found: {file}")
+
+    with open(file_path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+
+    scene = load_scene(str(file_path))
+    unpack_scene(scene, output_dir)
+
+
+def unpack_scene(scene: Scene, output_dir: str) -> None:
+    """Unpack a scene into a directory structure with components/ and main.json."""
+    out = Path(output_dir)
+    out.mkdir(parents=True, exist_ok=True)
+
+    imports: dict[str, str] = {}
+
+    # Extract defs into separate component files
+    if scene.defs:
+        components_dir = out / "components"
+        components_dir.mkdir(parents=True, exist_ok=True)
+
+        for name, element in scene.defs.items():
+            component_file = f"components/{name}.json"
+            component_path = components_dir / f"{name}.json"
+            component_data = _element_to_dict(element)
+            component_path.write_text(
+                json.dumps(component_data, indent=2), encoding="utf-8"
+            )
+            imports[name] = component_file
+            print(f"Extracted component: {component_path}")
+
+    # Build main.json without defs, with imports
+    main_data: dict = {
+        "width": scene.width,
+        "height": scene.height,
+    }
+    if scene.background:
+        main_data["background"] = scene.background
+    if scene.styles:
+        main_data["styles"] = {
+            name: {"light": s.light, "dark": s.dark}
+            for name, s in scene.styles.items()
+        }
+    if imports:
+        main_data["imports"] = imports
+    if scene.elements:
+        main_data["elements"] = [_element_to_dict(el) for el in scene.elements]
+    if scene.pipeline:
+        main_data["pipeline"] = scene.pipeline
+
+    main_path = out / "main.json"
+    main_path.write_text(json.dumps(main_data, indent=2), encoding="utf-8")
+    print(f"Wrote: {main_path}")
+
+
+# ─── Serialization helpers ───────────────────────────────────────────────────
+
+
+def _scene_to_dict(scene: Scene) -> dict:
+    """Convert a Scene back to a JSON-serializable dict."""
+    data: dict = {
+        "width": scene.width,
+        "height": scene.height,
+    }
+    if scene.background:
+        data["background"] = scene.background
+    if scene.styles:
+        data["styles"] = {
+            name: {"light": s.light, "dark": s.dark}
+            for name, s in scene.styles.items()
+        }
+    if scene.imports:
+        data["imports"] = scene.imports
+    if scene.defs:
+        data["defs"] = {name: _element_to_dict(el) for name, el in scene.defs.items()}
+    if scene.elements:
+        data["elements"] = [_element_to_dict(el) for el in scene.elements]
+    if scene.pipeline:
+        data["pipeline"] = scene.pipeline
+    return data
+
+
+def _element_to_dict(el: Element) -> dict:
+    """Convert an Element back to a JSON-serializable dict.
+
+    Omits default/None values to keep output clean.
+    """
+    data: dict = {"type": el.type}
+
+    if el.id:
+        data["id"] = el.id
+    if el.fill:
+        data["fill"] = el.fill
+    if el.opacity != 1.0:
+        data["opacity"] = el.opacity
+    if el.transform:
+        t: dict = {}
+        if el.transform.translate != (0.0, 0.0):
+            t["translate"] = list(el.transform.translate)
+        if el.transform.scale != (1.0, 1.0):
+            t["scale"] = list(el.transform.scale)
+        if t:
+            data["transform"] = t
+
+    # rect fields
+    if el.x != 0:
+        data["x"] = el.x
+    if el.y != 0:
+        data["y"] = el.y
+    if el.width != 0:
+        data["width"] = el.width
+    if el.height != 0:
+        data["height"] = el.height
+
+    # path
+    if el.d:
+        data["d"] = el.d
+
+    # text
+    if el.content:
+        data["content"] = el.content
+    if el.font:
+        font_data: dict = {"family": el.font.family, "size": el.font.size}
+        if el.font.weight != 400:
+            font_data["weight"] = el.font.weight
+        data["font"] = font_data
+    if el.anchor != "start":
+        data["anchor"] = el.anchor
+    if el.letter_spacing != 0:
+        data["letter_spacing"] = el.letter_spacing
+    if el.char_styles:
+        data["char_styles"] = [
+            _char_style_to_dict(cs) for cs in el.char_styles
+        ]
+
+    # group children
+    if el.elements:
+        data["elements"] = [_element_to_dict(child) for child in el.elements]
+
+    # component reference
+    if el.use:
+        data["use"] = el.use
+
+    return data
+
+
+def _char_style_to_dict(cs) -> dict:
+    """Convert a CharStyle to a dict, omitting defaults."""
+    data: dict = {"chars": cs.chars}
+    if cs.opacity != 1.0:
+        data["opacity"] = cs.opacity
+    if cs.fill:
+        data["fill"] = cs.fill
+    return data