predictygraph 0.2.1__tar.gz → 0.2.2__tar.gz

{predictygraph-0.2.1 → predictygraph-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: predictygraph
-Version: 0.2.1
+Version: 0.2.2
 Summary: Predictable graphs: a readable, CSS-styled diagram DSL with per-group layouts, rendered to SVG/APNG
 Author-Email: Reza Jelveh <git@jelveh.me>
 License: GPL-3.0-or-later

{predictygraph-0.2.1 → predictygraph-0.2.2}/pyproject.toml

@@ -12,7 +12,7 @@ dependencies = [
 ]
 requires-python = ">=3.11"
 readme = "README.md"
-version = "0.2.1"
+version = "0.2.2"
 
 [project.license]
 text = "GPL-3.0-or-later"

{predictygraph-0.2.1 → predictygraph-0.2.2}/src/predictygraph/default.css

@@ -21,3 +21,4 @@ group sub { font-weight: normal; }
 step    { fill: #374151; color: #ffffff; font-size: 11px; font-weight: bold; }
 caption { color: #6b7280; font-size: 12px; font-style: italic; text-align: center; }
 legend  { fill: #ffffff; stroke: #d1d5db; color: #374151; font-size: 11px; }
+bracket { stroke: #9ca3af; stroke-width: 1.5; color: #4b5563; font-size: 11px; font-style: italic; }

{predictygraph-0.2.1 → predictygraph-0.2.2}/src/predictygraph/layout.py

@@ -10,21 +10,14 @@ from collections import defaultdict
 
 from .model import Document, Group, Item, Node
 from .style import box4, px
-from .text import load_image, measure
+from .styleutil import has_title_band, node_padding, text_block, title_position
+from .text import load_image
 
 
 # ---------------------------------------------------------------- sizing
-BOLD = ("bold", "bolder", "600", "700", "800", "900")
 SUB_GAP = 3.0  # px between a label and its `sub=` lines
 
 
-def text_block(text: str | None, st: dict, default_fs: float) -> tuple[float, float, list[str]]:
-    if not text:
-        return 0.0, 0.0, []
-    fs = px(st.get("font-size"), default_fs)
-    return measure(text, st.get("font-family", "sans-serif"), fs, st.get("font-weight", "normal") in BOLD)
-
-
 def size_node(n: Node, doc: Document) -> None:
     st = n.style
     label = n.label if n.label is not None else n.id
@@ -32,9 +25,7 @@ def size_node(n: Node, doc: Document) -> None:
     sw, sh, n.sub_lines = text_block(n.attrs.get("sub"), n.sub_style or st, 12)
     n.sub_h = sh + SUB_GAP if n.sub_lines else 0.0
     n.text_w, n.text_h = max(n.text_w, sw), n.text_h + n.sub_h  # text_h covers label + sub
-    pt, pr, pb, pl = box4(st.get("padding"), 8)
-    pl += accent_width(st, "left")
-    pr += accent_width(st, "right")
+    pt, pr, pb, pl = node_padding(st)
     shape = n.attrs.get("shape")
     if "image" in n.attrs:
         img = load_image(n.attrs["image"], doc.base_dir, doc.allow_outside)
@@ -85,14 +76,6 @@ def size_node(n: Node, doc: Document) -> None:
 
 
 # ---------------------------------------------------------------- helpers
-def accent_width(st: dict, side: str) -> float:
-    """Room an `accent-bar` takes on `side` (it sits inside the box, before the padding)."""
-    spec = st.get("accent-bar")
-    if not spec or spec.strip() == "none" or st.get("accent-side", "left") != side:
-        return 0.0
-    return px(st["accent-bar"].split()[0], 4)
-
-
 def direct_child(item: Item, g: Group) -> Item | None:
     """Ancestor-or-self of `item` that is a direct child of g."""
     cur = item
@@ -136,8 +119,9 @@ class LineLayout(Layout):
         gap = px(opt(self.g, "gap", "24"))
         align = opt(self.g, "align", "center")
         cross = max((k.h if horizontal else k.w) for k in self.kids)
-        pos = 0.0
-        for k in self.kids:
+        need = self.label_gaps(horizontal)
+        pos, last = 0.0, 0.0
+        for idx, k in enumerate(self.kids):
             if align == "stretch":  # every child as wide (column) / tall (row) as the widest
                 if horizontal:
                     k.h = cross
@@ -148,15 +132,37 @@ class LineLayout(Layout):
                         k.ox += grow / 2  # content stays left unless the tier asks to centre it
             size_c = k.h if horizontal else k.w
             off = {"start": 0, "end": cross - size_c}.get(align, (cross - size_c) / 2)
+            step = max(gap, need.get(idx, 0.0))
             if horizontal:
                 k.x, k.y = pos, off
-                pos += k.w + gap
+                pos += k.w + step
             else:
                 k.x, k.y = off, pos
-                pos += k.h + gap
-        pos -= gap
+                pos += k.h + step
+            last = step
+        pos -= last
         return (pos, cross) if horizontal else (cross, pos)
 
+    def label_gaps(self, horizontal: bool) -> dict[int, float]:
+        """Gap needed after child i so labels of edges between neighbours i and i+1 fit
+        (a row only: a label runs along the gap). Room = label width + arrowhead + margin."""
+        if not horizontal:
+            return {}
+        index = {k.id: i for i, k in enumerate(self.kids)}
+        need: dict[int, float] = {}
+        for e in self.doc.edges:
+            if not e.label:
+                continue
+            a, b = direct_child(self.doc.items[e.src], self.g), direct_child(self.doc.items[e.dst], self.g)
+            if a is None or b is None or a is b:
+                continue
+            i, j = sorted((index[a.id], index[b.id]))
+            if j != i + 1:
+                continue
+            w, _, _ = text_block(e.label, e.label_style or e.style, 11, bold=False)
+            need[i] = max(need.get(i, 0.0), w + 34)
+        return need
+
 
 class GridLayout(Layout):
     def run(self):
@@ -516,19 +522,27 @@ def layout_group(g: Group, doc: Document) -> None:
         lay = LAYOUTS[g.attrs["layout"]](g, doc)
         cw, ch = lay.run()
     g.label_h = g.title_h = 0.0
+    g.side_w = 0.0  # label-position: left -> a column for the rotated title
     lw = 0.0
-    if g.label and g.kind == "group":
+    pos = title_position(g.style)
+    if g.label and g.kind == "group" and pos == "left":
+        tw, th, _ = text_block(g.label, g.style, 12)
+        g.title_h = th
+        g.side_w = th + 12
+        lw = 0.0
+        ch = max(ch, tw - pt - pb + 20)  # tall enough for the rotated title, with a margin
+    elif g.label and g.kind == "group":
         lw, g.title_h, _ = text_block(g.label, g.style, 12)
         sw, sh, _ = text_block(g.attrs.get("sub"), g.sub_style or g.style, 11)
         lw = max(lw, sw)
         g.label_h = g.title_h + (sh + SUB_GAP if sh else 0.0) + 6
-        if g.style.get("title-fill") not in (None, "none") and g.style.get("label-position", "top") != "bottom":
+        if has_title_band(g.style):
             g.label_h += 6
     inner_w = max(cw, lw) + getattr(g, "extra_w", 0.0)  # extra_w: room requested for the title
-    top = g.style.get("label-position", "top") != "bottom"
-    g.ox = pl + (inner_w - cw) / 2
+    top = pos not in ("bottom", "left")
+    g.ox = pl + g.side_w + (inner_w - cw) / 2
     g.oy = pt + (g.label_h if top else 0)
-    g.w = inner_w + pl + pr
+    g.w = inner_w + pl + pr + g.side_w
     g.h = ch + pt + pb + g.label_h
     g.layout_obj = lay
 

{predictygraph-0.2.1 → predictygraph-0.2.2}/src/predictygraph/model.py

@@ -63,6 +63,7 @@ class Group(Item):
     oy: float = 0.0
     label_h: float = 0.0
     title_h: float = 0.0  # label only; label_h also counts the subtitle
+    side_w: float = 0.0  # label-position: left -> width of the rotated-title column
     part_styles: dict[str, dict[str, str]] = field(default_factory=dict)  # root: caption, legend
 
 
@@ -87,6 +88,18 @@ class Edge:
     id: str = ""
 
 
+@dataclass
+class Bracket:
+    """`bracket a, b "note"`: a curly bracket beside the span of the listed items."""
+    ids: list[str]
+    label: str = ""
+    classes: list[str] = field(default_factory=list)
+    attrs: dict[str, str] = field(default_factory=dict)
+    style: dict[str, str] = field(default_factory=dict)
+    kind: str = "bracket"
+    id: str = ""
+
+
 @dataclass
 class Document:
     root: Group
@@ -97,6 +110,7 @@ class Document:
     allow_outside: bool = False  # let image=/css "..." read files outside base_dir
     legend: list[Node] = field(default_factory=list)  # `legend .cls "text"` entries (not laid out)
     legend_title: str | None = None
+    brackets: list["Bracket"] = field(default_factory=list)
 
     def walk(self, g: Group | None = None):
         g = g or self.root

{predictygraph-0.2.1 → predictygraph-0.2.2}/src/predictygraph/parser.py

@@ -8,10 +8,10 @@ from __future__ import annotations
 import re
 from pathlib import Path
 
-from .model import Document, Edge, Group, Node
+from .model import Bracket, Document, Edge, Group, Node
 from .safe import MAX_EDGES, safe_path
 
-MAX_LEGEND = 64
+MAX_ANNOTATIONS = 64  # legend entries / brackets per diagram
 
 
 class PdgSyntaxError(ValueError):
@@ -135,6 +135,13 @@ class Parser:
                 raise PdgSyntaxError(f"unexpected token {val!r}", lineno)
         return label, classes, attrs
 
+    def _annotation_room(self, stmt: str, existing: list, what: str, lineno: int) -> None:
+        """`legend` / `bracket`: top level only, at most MAX_ANNOTATIONS of each."""
+        if self.scope is not self.root:
+            raise PdgSyntaxError(f"'{stmt}' only allowed at top level", lineno)
+        if len(existing) >= MAX_ANNOTATIONS:
+            raise PdgSyntaxError(f"too many {what} (limit {MAX_ANNOTATIONS})", lineno)
+
     def _get_node(self, nid: str, lineno: int):
         item = self.doc.items.get(nid)
         if item is None:
@@ -191,15 +198,23 @@ class Parser:
             if classes:
                 d["__classes__"] = " ".join(classes)
             return
+        if head == "bracket" and len(toks) >= 2 and toks[1][0] == "ident":
+            self._annotation_room(head, self.doc.brackets, "brackets", lineno)
+            ids, i = [], 1
+            while i < len(toks) and toks[i][0] in ("ident", "punct") and toks[i][1] != "{":
+                if toks[i][0] == "ident":
+                    ids.append(toks[i][1])
+                i += 1
+            label, classes, attrs = self._tail(toks, i, lineno)
+            self.doc.brackets.append(Bracket(ids=ids, label=label or "", classes=list(classes), attrs=attrs))
+            return
         if head == "legend" and (len(toks) == 1 or toks[1][0] in ("string", "cls")):
-            if self.scope is not self.root:
-                raise PdgSyntaxError("'legend' only allowed at top level", lineno)
             label, classes, attrs = self._tail(toks, 1, lineno)
             if not classes:  # `legend "Key"` names the box
+                self._annotation_room(head, [], "", lineno)
                 self.doc.legend_title = label
                 return
-            if len(self.doc.legend) >= MAX_LEGEND:
-                raise PdgSyntaxError(f"too many legend entries (limit {MAX_LEGEND})", lineno)
+            self._annotation_room(head, self.doc.legend, "legend entries", lineno)
             entry = Node(id=f"pdg-legend-{len(self.doc.legend)}", label=label or " ".join(classes),
                          classes=list(classes), attrs=attrs, parent=self.root)
             self.doc.legend.append(entry)
@@ -313,6 +328,10 @@ class Parser:
             for nid in (e.src, e.dst):
                 if nid not in self.doc.items:
                     raise PdgSyntaxError(f"unknown id {nid!r}", 0)
+        for b in self.doc.brackets:
+            missing = [i for i in b.ids if i not in self.doc.items]
+            if missing or not b.ids:
+                raise PdgSyntaxError(f"bracket: unknown id {missing[0]!r}" if missing else "bracket needs ids", 0)
         return self.doc
 
 

{predictygraph-0.2.1 → predictygraph-0.2.2}/src/predictygraph/render/svg.py

@@ -71,6 +71,8 @@ class SvgWriter:
             return f"<g {self.attrs_str(base)}>\n{inner}\n</g>" if base else f"<g>\n{inner}\n</g>"
         if el.kind == "text":
             a = {"x": num(float(g["x"])), "y": num(float(g["y"])), "text-anchor": g.get("anchor", "middle")}
+            if g.get("rotate"):  # about the text's own anchor point
+                a["transform"] = f"rotate({num(float(g['rotate']))} {a['x']} {a['y']})"
             a.update(self.paint_attrs(el))
             a.update(base)
             return f"<text {self.attrs_str(a)}>{escape(g['text'])}</text>"

{predictygraph-0.2.1 → predictygraph-0.2.2}/src/predictygraph/scene.py

@@ -16,16 +16,28 @@ import math
 
 from .anim import BORDER_MODES, Track, border_tracks, dash_len, flow_tracks, seconds
 from .ir import Elem, Scene
-from .layout import SUB_GAP, accent_width
+from .layout import SUB_GAP
 from .model import Document, Edge, Group, Node
 from .route import Diagonal, Router, flow_dir, lca
 from .style import box4, px
-from .text import measure
+from .styleutil import LINE_H, accent, font_size, has_title_band, node_padding, text_block, title_position
 
 TITLE_PAD = 6.0
 ER_HEADS = ("one", "many", "zero-one", "zero-many", "one-many")
 
 
+def point_along(poly: list[tuple[float, float]], frac: float) -> tuple[float, float]:
+    """The point `frac` (0..1) of the way along a polyline, by length."""
+    lens = [math.dist(a, b) for a, b in zip(poly, poly[1:])]
+    goal, acc = sum(lens) * frac, 0.0
+    for (a, b), seg in zip(zip(poly, poly[1:]), lens):
+        if seg and acc + seg >= goal:
+            t = (goal - acc) / seg
+            return a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t
+        acc += seg
+    return poly[-1]
+
+
 class SceneBuilder:
     def __init__(self, doc: Document, router: Router):
         self.doc, self.router = doc, router
@@ -47,6 +59,10 @@ class SceneBuilder:
         if self.title_layer.children:
             layers.append(self.title_layer)
         w, h = root.w, root.h
+        if self.doc.brackets:
+            br, bw = self.brackets(w)
+            layers.append(br)
+            w += bw
         legend, lw, lh = self.legend(h)
         if legend:
             layers.append(legend)
@@ -54,8 +70,8 @@ class SceneBuilder:
         cap = root.attrs.get("caption")
         if cap:
             st = root.part_styles.get("caption") or root.style
-            fs = px(st.get("font-size"), 12)
-            cw, ch, lines = measure(cap, st.get("font-family", "sans-serif"), fs)
+            fs = font_size(st, 12)
+            cw, ch, lines = text_block(cap, st, 12)
             w = max(w, cw + 28)
             align = st.get("text-align", "center")
             x, anchor = {"left": (14, "start"), "right": (w - 14, "end")}.get(align, (w / 2, "middle"))
@@ -63,31 +79,72 @@ class SceneBuilder:
             h += ch + 14
         return Scene(w, h, root.style.get("background"), layers)
 
+    def brackets(self, right: float) -> tuple[Elem, float]:
+        """`bracket a, b "note"`: a curly bracket right of the diagram spanning the listed
+        items top to bottom, the note beside it. Brackets that overlap vertically are
+        stacked outward. Returns the layer and the extra canvas width."""
+        out = Elem("group", cls="pdg-brackets")
+        depth = 8.0
+        spans = []  # (height, y0, y1, bracket, text width, text height, lines)
+        for b in self.doc.brackets:
+            items = [self.doc.items[i] for i in b.ids]
+            y0, y1 = min(i.ay for i in items), max(i.ay + i.h for i in items)
+            spans.append((y1 - y0, y0, y1, b, *text_block(b.label, b.style, 11)))
+        spans.sort(key=lambda s: s[0])  # short spans nearest the diagram, long ones outside
+        cols: list[list[tuple[float, float]]] = []
+        col_w: list[float] = []
+        placed = []
+        for _, y0, y1, b, tw, th, lines in spans:
+            col = 0
+            while col < len(cols) and any(not (y1 < a or y0 > z) for a, z in cols[col]):
+                col += 1
+            if col == len(cols):
+                cols.append([])
+                col_w.append(0.0)
+            cols[col].append((y0, y1))
+            col_w[col] = max(col_w[col], 2 * depth + 6 + tw + 14)
+            placed.append((col, y0, y1, b, th, lines))
+        for col, y0, y1, b, th, lines in placed:
+            st, fs = b.style, font_size(b.style, 11)
+            x = right + 4 + sum(col_w[:col])
+            ym = (y0 + y1) / 2
+            q = min(depth, (y1 - y0) / 4)
+            segs = [("M", x, y0), ("Q", x + depth, y0, x + depth, y0 + q), ("L", x + depth, ym - q),
+                    ("Q", x + depth, ym, x + 2 * depth, ym), ("Q", x + depth, ym, x + depth, ym + q),
+                    ("L", x + depth, y1 - q), ("Q", x + depth, y1, x, y1)]
+            kids = [Elem("path", cls="pdg-bracket-line", geom={"segs": segs},
+                         paint={"fill": "none", "stroke": st.get("stroke", "#9ca3af"),
+                                "stroke-width": px(st.get("stroke-width"), 1.5), "stroke-linecap": "round"})]
+            kids += self.text(lines, x + 2 * depth + 6, ym - th / 2, fs, st, "start")
+            out.children.append(Elem("group", cls=" ".join(["pdg-bracket"] + b.classes), children=kids))
+        return out, 4 + sum(col_w)
+
     def legend(self, top: float) -> tuple[Elem | None, float, float]:
         """`legend .cls "text"` entries: a key box under the diagram, swatches styled like nodes."""
         entries = self.doc.legend
         if not entries:
             return None, 0.0, 0.0
         st = self.doc.root.part_styles.get("legend") or {}
-        fs = px(st.get("font-size"), 11)
-        fam = st.get("font-family", self.doc.root.style.get("font-family", "sans-serif"))
+        st = {"font-family": self.doc.root.style.get("font-family", "sans-serif"), **st}
+        fs = font_size(st, 11)
         sw, gap, pad = 14.0, 16.0, 10.0
         title = self.doc.legend_title
-        tw, th, _ = measure(title, fam, fs, True) if title else (0.0, 0.0, [])
+        tw, _, _ = text_block(title, st, 11, bold=True)
         x = pad + (tw + gap if title else 0.0)
-        kids, row_h = [], max(sw, fs * 1.25)
+        kids, row_h = [], max(sw, fs * LINE_H)
         y0 = top + pad
+        ty = y0 + (row_h - fs * LINE_H) / 2  # text top, vertically centred in the row
         if title:
-            kids += self.text([title], 14 + pad, y0 + (row_h - fs * 1.25) / 2, fs, {**st, "font-weight": "bold"}, "start")
+            kids += self.text([title], 14 + pad, ty, fs, {**st, "font-weight": "bold"}, "start")
         for n in entries:
-            ew, _, _ = measure(n.label, fam, fs)
+            ew, _, _ = text_block(n.label, st, 11, bold=False)
             ns = n.style
             r = min(px(ns.get("border-radius"), 3), 4)
             kids.append(Elem("rect", cls=" ".join(["pdg-legend-swatch"] + n.classes),
                              geom={"x": 14 + x, "y": y0 + (row_h - sw) / 2, "w": sw, "h": sw, "rx": r},
                              paint={"fill": ns.get("fill", "#ffffff"), "stroke": ns.get("stroke", "#9ca3af"),
                                     "stroke-width": 1.2}))
-            kids += self.text([n.label], 14 + x + sw + 6, y0 + (row_h - fs * 1.25) / 2, fs, st, "start")
+            kids += self.text([n.label], 14 + x + sw + 6, ty, fs, st, "start")
             x += sw + 6 + ew + gap
         bw, bh = x - gap + pad, row_h + 2 * pad
         box = Elem("rect", cls="pdg-legend-box", geom={"x": 14, "y": top, "w": bw, "h": bh, "rx": 6},
@@ -96,11 +153,15 @@ class SceneBuilder:
 
     # ------------------------------------------------------------ text
     @staticmethod
-    def text(lines, cx, top, fs, st, anchor="middle") -> list[Elem]:
-        lh = fs * 1.25
-        paint = {"fill": st.get("color", "#111827"), "font-family": st.get("font-family", "sans-serif"),
-                 "font-size": fs, "font-weight": st.get("font-weight", "normal"),
-                 "font-style": st.get("font-style", "normal")}
+    def text_paint(st: dict, fs: float) -> dict:
+        return {"fill": st.get("color", "#111827"), "font-family": st.get("font-family", "sans-serif"),
+                "font-size": fs, "font-weight": st.get("font-weight", "normal"),
+                "font-style": st.get("font-style", "normal")}
+
+    @classmethod
+    def text(cls, lines, cx, top, fs, st, anchor="middle") -> list[Elem]:
+        lh = fs * LINE_H
+        paint = cls.text_paint(st, fs)
         return [Elem("text", geom={"x": cx, "y": top + lh * i + fs * 0.95, "text": line, "anchor": anchor},
                      paint=dict(paint)) for i, line in enumerate(lines)]
 
@@ -161,7 +222,7 @@ class SceneBuilder:
         shape = n.attrs.get("shape", "box")
         out = Elem("group", id=n.id, cls=" ".join(["pdg-node"] + n.classes), children=self.shape(n, shape, st))
         out.children += self.accent(n, st)
-        fs = px(st.get("font-size"), 14)
+        fs = font_size(st, 14)
         if n.image:
             img = n.image
             ix = n.cx - img["dw"] / 2
@@ -177,84 +238,91 @@ class SceneBuilder:
 
     def _node_text(self, n, st, fs):
         align = st.get("text-align", "center")
-        pt, pr, pb, pl = box4(st.get("padding"), 8)
-        pl += accent_width(st, "left")
-        pr += accent_width(st, "right")
+        pt, pr, pb, pl = node_padding(st)
         top = n.cy - n.text_h / 2
         x, anchor = {"left": (n.ax + pl, "start"), "right": (n.ax + n.w - pr, "end")}.get(align, (n.cx, "middle"))
         out = self.text(n.text_lines, x, top, fs, st, anchor)
         if n.sub_lines:
             sst = n.sub_style or st
-            sfs = px(sst.get("font-size"), 12)
             stop = top + n.text_h - n.sub_h + SUB_GAP
-            out += self.text(n.sub_lines, x, stop, sfs, sst, anchor)
+            out += self.text(n.sub_lines, x, stop, font_size(sst, 12), sst, anchor)
         return out
 
     def accent(self, it, st) -> list[Elem]:
         """`accent-bar: 4px #22c55e` draws a strip inside the box edge (`accent-side`)."""
-        spec = st.get("accent-bar")
-        if not spec or spec.strip() == "none":
+        a = accent(st)
+        if not a:
             return []
-        parts = spec.split()
-        bw = px(parts[0], 4)
-        color = parts[1] if len(parts) > 1 else st.get("stroke", "#22c55e")
-        side = st.get("accent-side", "left")
+        bw, color, side = a
         x = it.ax if side == "left" else it.ax + it.w - bw
         r = min(px(st.get("border-radius"), 6), bw)
         return [Elem("rect", cls="pdg-accent", geom={"x": x, "y": it.ay, "w": bw, "h": it.h, "rx": r},
-                     paint={"fill": color})]
+                     paint={"fill": color or st.get("stroke", "#22c55e")})]
 
     def group(self, g: Group) -> Elem:
         st = g.style
         out = Elem("group", id=g.id, cls=" ".join(["pdg-group"] + g.classes),
                    children=self.shape(g, g.attrs.get("shape", "box"), st))
         out.children += self.accent(g, st)
-        if g.label and st.get("title-fill") not in (None, "none") and st.get("label-position", "top") != "bottom":
-            pt = box4(st.get("padding"), 14)[0]
-            bh = pt + g.label_h - 3
-            r = px(st.get("border-radius"), 8)
-            out.children.append(Elem("path", cls="pdg-title-band", paint={"fill": st["title-fill"]}, geom={"segs": [
-                ("M", g.ax, g.ay + bh), ("L", g.ax, g.ay + r), ("A", r, r, 0, 0, 1, g.ax + r, g.ay),
-                ("L", g.ax + g.w - r, g.ay), ("A", r, r, 0, 0, 1, g.ax + g.w, g.ay + r),
-                ("L", g.ax + g.w, g.ay + bh), ("Z",)]}))
-        if g.label:
-            fs = px(st.get("font-size"), 12)
-            pt, pr, pb, pl = box4(st.get("padding"), 14)
-            lines = g.label.split("\n")
-            bold = st.get("font-weight", "normal") in ("bold", "600", "700")
-            tw, th, _ = measure(g.label, st.get("font-family", "sans-serif"), fs, bold)
-            bottom = st.get("label-position", "top") == "bottom"
-            top = g.ay + g.h - pb - g.label_h + 6 if bottom else g.ay + pt
-            x0 = self._title_x(g, st, tw, pl, pr, top, th)
-            box = (x0 - TITLE_PAD, top - 2, x0 + tw + TITLE_PAD, top + th + 2)
-            texts = self.text(lines, x0, top, fs, st, "start")
-            if g.attrs.get("sub") and not bottom:
-                sst = g.sub_style or st
-                texts += self.text(g.attrs["sub"].split("\n"), x0, top + g.title_h + SUB_GAP,
-                                   px(sst.get("font-size"), 11), sst, "start")
-            xs = self._crossings(box[1], box[3], box[0], box[2])
-            if xs:
-                # ask the pipeline for a wider group: children are centred, so widening
-                # by d moves the crossing edges d/2 away from the left-aligned title
-                over = max(box[2] + 2 - min(xs), 0.0)
-                self.title_needs[g.id] = 2 * over + 4
-            if self._crossings(box[1], box[3], box[0], box[2]):
-                # nowhere free to slide to: lift the title above the edges on a patch of
-                # the group's own fill, so the line visibly stops around the text
-                fill = st.get("fill", "none")
-                if fill in ("none", "transparent"):
-                    fill = self.doc.root.style.get("background", "#ffffff")
-                patch = Elem("rect", cls="pdg-title-bg",
-                             geom={"x": box[0], "y": box[1], "w": box[2] - box[0], "h": box[3] - box[1], "rx": 3},
-                             paint={"fill": fill})
-                self.title_layer.children.append(Elem("group", cls="pdg-group-title", children=[patch] + texts))
-            else:
-                out.children += texts
+        if g.label and title_position(st) == "left":
+            out.children.append(self._side_title(g, st))
+        elif g.label:
+            if has_title_band(st):
+                out.children.append(self._title_band(g, st))
+            self._top_title(g, st, out)
         for c in g.children:
             if isinstance(c, Group):
                 out.children.append(self.group(c))
         return out
 
+    def _title_band(self, g: Group, st: dict) -> Elem:
+        """`title-fill`: a band behind the title, rounded like the group's top corners."""
+        bh = box4(st.get("padding"), 14)[0] + g.label_h - 3
+        r = px(st.get("border-radius"), 8)
+        return Elem("path", cls="pdg-title-band", paint={"fill": st["title-fill"]}, geom={"segs": [
+            ("M", g.ax, g.ay + bh), ("L", g.ax, g.ay + r), ("A", r, r, 0, 0, 1, g.ax + r, g.ay),
+            ("L", g.ax + g.w - r, g.ay), ("A", r, r, 0, 0, 1, g.ax + g.w, g.ay + r),
+            ("L", g.ax + g.w, g.ay + bh), ("Z",)]})
+
+    def _side_title(self, g: Group, st: dict) -> Elem:
+        """`label-position: left`: the title turned 90°, pinned near the left edge (padding
+        moves the content, not the title, so an edge can pass between them)."""
+        fs = font_size(st, 12)
+        x = g.ax + 8 + g.side_w / 2 + fs * 0.35
+        return Elem("text", geom={"x": x, "y": g.cy, "text": g.label.replace("\n", " "),
+                                  "anchor": "middle", "rotate": -90}, paint=self.text_paint(st, fs))
+
+    def _top_title(self, g: Group, st: dict, out: Elem) -> None:
+        """Title (and `sub=` line) at the top or bottom, sliding clear of crossing edges."""
+        fs = font_size(st, 12)
+        pt, pr, pb, pl = box4(st.get("padding"), 14)
+        tw, th, _ = text_block(g.label, st, 12)
+        bottom = title_position(st) == "bottom"
+        top = g.ay + g.h - pb - g.label_h + 6 if bottom else g.ay + pt
+        x0 = self._title_x(g, st, tw, pl, pr, top, th)
+        box = (x0 - TITLE_PAD, top - 2, x0 + tw + TITLE_PAD, top + th + 2)
+        texts = self.text(g.label.split("\n"), x0, top, fs, st, "start")
+        if g.attrs.get("sub") and not bottom:
+            sst = g.sub_style or st
+            texts += self.text(g.attrs["sub"].split("\n"), x0, top + g.title_h + SUB_GAP,
+                               font_size(sst, 11), sst, "start")
+        xs = self._crossings(box[1], box[3], box[0], box[2])
+        if not xs:
+            out.children += texts
+            return
+        # ask the pipeline for a wider group: children are centred, so widening by d
+        # moves the crossing edges d/2 away from the left-aligned title
+        self.title_needs[g.id] = 2 * max(box[2] + 2 - min(xs), 0.0) + 4
+        # nowhere free to slide to: lift the title above the edges on a patch of the
+        # group's own fill, so the line visibly stops around the text
+        fill = st.get("fill", "none")
+        if fill in ("none", "transparent"):
+            fill = self.doc.root.style.get("background", "#ffffff")
+        patch = Elem("rect", cls="pdg-title-bg",
+                     geom={"x": box[0], "y": box[1], "w": box[2] - box[0], "h": box[3] - box[1], "rx": 3},
+                     paint={"fill": fill})
+        self.title_layer.children.append(Elem("group", cls="pdg-group-title", children=[patch] + texts))
+
     def _title_x(self, g, st, tw, pl, pr, top, th) -> float:
         """Preferred x from text-align; slide along the title band if edges cross there."""
         align = st.get("text-align", "left")
@@ -379,25 +447,19 @@ class SceneBuilder:
         """Numbered circle on the edge, a third of the way along its path. With a label the
         badge sits just left of the label box, so neither covers the other."""
         st = e.step_style or e.style
-        fs = px(st.get("font-size"), 11)
+        st = {**st, "font-weight": st.get("font-weight", "bold")}
+        fs = font_size(st, 11)
         txt = e.attrs["step"][:3]
-        w, h, _ = measure(txt, st.get("font-family", "sans-serif"), fs, True)
+        w, h, _ = text_block(txt, st, 11)
         r = max(w, h) / 2 + 3
-        lens = [math.dist(a, b) for a, b in zip(poly, poly[1:])]
-        goal, acc = sum(lens) / 3, 0.0
-        cx, cy = poly[0]
-        for (a, b), l in zip(zip(poly, poly[1:]), lens):
-            if acc + l >= goal and l:
-                t = (goal - acc) / l
-                cx, cy = a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t
-                break
-            acc += l
         if label_box:
             cx, cy = label_box["x"] - r - 3, label_box["y"] + label_box["h"] / 2
+        else:
+            cx, cy = point_along(poly, 1 / 3)
         circ = Elem("circle", cls="pdg-step", geom={"cx": cx, "cy": cy, "r": r},
                     paint={"fill": st.get("fill", "#374151"), "stroke": self.doc.root.style.get("background", "#ffffff"),
                            "stroke-width": 1.5})
-        return [circ] + self.text([txt], cx, cy - fs * 1.25 / 2, fs, {**st, "font-weight": st.get("font-weight", "bold")})
+        return [circ] + self.text([txt], cx, cy - fs * LINE_H / 2, fs, st)
 
     @staticmethod
     def head(kind, tip, d, hl, color, width, bg="#ffffff") -> Elem:
@@ -433,8 +495,8 @@ class SceneBuilder:
 
     def edge_label(self, e, poly) -> list[Elem]:
         st = e.label_style or e.style
-        fs = px(st.get("font-size"), 11)
-        w, h, lines = measure(e.label, st.get("font-family", "sans-serif"), fs)
+        fs = font_size(st, 11)
+        w, h, lines = text_block(e.label, st, 11, bold=False)  # same call as layout.label_gaps
         # bent edges: the run into the target is the edge's own (a fan-out bus is shared),
         # so labels go there when it fits; otherwise the longest run
         segs = list(zip(poly, poly[1:]))

{predictygraph-0.2.1 → predictygraph-0.2.2}/src/predictygraph/style.py

@@ -185,6 +185,9 @@ def apply_styles(doc: Document, target: str | None = None) -> None:
     number_steps(doc)
     root.style = sheet.resolve_vars(sheet.compute(root, []))
     root.part_styles = {k: part_style(sheet, k, root, [], root.style) for k in ("caption", "legend")}
+    for b in doc.brackets:
+        b.style = sheet.resolve_vars({"font-family": root.style.get("font-family", "sans-serif"),
+                                      **sheet.compute(b, [root])})
 
     for item in [*doc.walk(), *doc.legend]:
         anc = item.ancestors()  # nearest first; root last

predictygraph-0.2.2/src/predictygraph/styleutil.py

@@ -0,0 +1,61 @@
+# SPDX-FileCopyrightText: 2026 The predictygraph Authors
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+"""Small style readers shared by layout (sizing) and scene (drawing), so both sides
+agree on what a style means: text metrics, accent bars, header bands, title position."""
+from __future__ import annotations
+
+from .style import box4, px
+from .text import measure
+
+BOLD = ("bold", "bolder", "600", "700", "800", "900")
+LINE_H = 1.25  # line height as a multiple of the font size (matches SceneBuilder.text)
+
+
+def font_size(st: dict, default: float) -> float:
+    return px(st.get("font-size"), default)
+
+
+def is_bold(st: dict, default: bool = False) -> bool:
+    w = st.get("font-weight")
+    return default if w is None else w in BOLD
+
+
+def text_block(text: str | None, st: dict, default_fs: float,
+               bold: bool | None = None) -> tuple[float, float, list[str]]:
+    """(width, height, lines) of `text` in style `st`; zeros for empty text.
+    `bold` overrides the style's weight (step numbers, legend titles)."""
+    if not text:
+        return 0.0, 0.0, []
+    return measure(text, st.get("font-family", "sans-serif"), font_size(st, default_fs),
+                   is_bold(st) if bold is None else bold)
+
+
+def accent(st: dict) -> tuple[float, str | None, str] | None:
+    """`accent-bar: 4px #16a34a` -> (width, colour or None, side); None when off."""
+    spec = (st.get("accent-bar") or "").split()
+    if not spec or spec[0] == "none":
+        return None
+    return px(spec[0], 4), (spec[1] if len(spec) > 1 else None), st.get("accent-side", "left")
+
+
+def accent_width(st: dict, side: str) -> float:
+    """Room an accent bar takes on `side` (inside the box, before the padding)."""
+    a = accent(st)
+    return a[0] if a and a[2] == side else 0.0
+
+
+def node_padding(st: dict) -> tuple[float, float, float, float]:
+    """A node's (top, right, bottom, left) padding, widened by its accent bar."""
+    pt, pr, pb, pl = box4(st.get("padding"), 8)
+    return pt, pr + accent_width(st, "right"), pb, pl + accent_width(st, "left")
+
+
+def title_position(st: dict) -> str:
+    return st.get("label-position", "top")
+
+
+def has_title_band(st: dict) -> bool:
+    """`title-fill` draws a band behind a top title only."""
+    return st.get("title-fill") not in (None, "none") and title_position(st) == "top"

{predictygraph-0.2.1 → predictygraph-0.2.2}/tests/test_annotations.py

@@ -75,3 +75,33 @@ def test_accent_bar_widens_node_and_draws():
 def test_title_fill_band():
     _, sc = scene('css { group { title-fill: #dbeafe; } }\ngroup g "G" {\n a\n}\n')
     assert "pdg-title-band" in classes(sc)
+
+
+def test_bracket_widens_canvas_and_draws_note():
+    _, base = scene('graph layout=column\na\nb\nc\n')
+    _, sc = scene('graph layout=column\na\nb\nc\nbracket a, b "first two"\nbracket a, c "all"\n')
+    assert sc.width > base.width
+    assert {"first two", "all"} <= set(texts(sc))
+    assert classes(sc).count("pdg-bracket-line") == 2
+
+
+def test_bracket_unknown_id_is_an_error():
+    import pytest
+    from predictygraph.parser import PdgSyntaxError
+    with pytest.raises(PdgSyntaxError):
+        parse('a\nbracket a, nope "x"\n')
+
+
+def test_left_label_is_rotated_and_takes_a_column():
+    src = 'css { group { label-position: left; } }\ngroup g "Kernel space" {\n a\n}\n'
+    doc, sc = scene(src)
+    g = doc.items["g"]
+    assert g.side_w > 0
+    rotated = []
+    stack = list(sc.layers)
+    while stack:
+        e = stack.pop()
+        if e.kind == "text" and e.geom.get("rotate"):
+            rotated.append(e.geom["text"])
+        stack += e.children
+    assert rotated == ["Kernel space"]