predictygraph 0.2.4__tar.gz → 0.2.5__tar.gz

{predictygraph-0.2.4 → predictygraph-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: predictygraph
-Version: 0.2.4
+Version: 0.2.5
 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.4 → predictygraph-0.2.5}/pyproject.toml

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

{predictygraph-0.2.4 → predictygraph-0.2.5}/src/predictygraph/layout.py

@@ -144,14 +144,13 @@ class LineLayout(Layout):
         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 {}
+        """Gap needed after child i so what sits on the edges between neighbours i and i+1
+        fits. Row: the edge label (plus its step circle) runs along the gap. Column: a step
+        circle sits beside the edge, so the gap must be at least one circle plus margins."""
         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:
+            if not (e.label if horizontal else e.attrs.get("step")):
                 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:
@@ -159,11 +158,15 @@ class LineLayout(Layout):
             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)
-            if e.attrs.get("step"):  # the step badge sits just left of the label
-                bw, bh, _ = text_block(e.attrs["step"][:3], e.step_style or e.style, 11, bold=True)
-                w += max(bw, bh) + 12
-            need[i] = max(need.get(i, 0.0), w + 34)
+            step = 0.0
+            if e.attrs.get("step"):  # circle diameter, as drawn by SceneBuilder.step_badge
+                sw, sh, _ = text_block(e.attrs["step"][:3], e.step_style or e.style, 11, bold=True)
+                step = max(sw, sh) + 6
+            if horizontal:
+                w, _, _ = text_block(e.label, e.label_style or e.style, 11, bold=False)
+                need[i] = max(need.get(i, 0.0), w + (step + 6 if step else 0.0) + 34)
+            else:
+                need[i] = max(need.get(i, 0.0), step + 14)
         return need
 
 

{predictygraph-0.2.4 → predictygraph-0.2.5}/src/predictygraph/scene.py

@@ -477,8 +477,10 @@ class SceneBuilder:
         return out
 
     def step_badge(self, e, poly, label_box=None) -> list[Elem]:
-        """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."""
+        """Numbered circle for an edge. Next to the label when there is one; on the line a
+        third of the way along when the edge is long enough to hold it with room to spare;
+        otherwise beside the middle of the edge, so a short arrow between stacked boxes
+        stays a visible line and the circle never sits on a box."""
         st = e.step_style or e.style
         st = {**st, "font-weight": st.get("font-weight", "bold")}
         fs = font_size(st, 11)
@@ -488,12 +490,51 @@ class SceneBuilder:
         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)
+            cx, cy = self._step_spot(e, poly, r)
         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 * LINE_H / 2, fs, st)
 
+    STEP_ROOM = 3.0  # an edge must be this many circle diameters long to carry its step
+
+    def _step_spot(self, e, poly, r) -> tuple[float, float]:
+        """Where a label-less step circle goes (see step_badge)."""
+        length = sum(math.dist(a, b) for a, b in zip(poly, poly[1:]))
+        on_line = point_along(poly, 1 / 3)
+        if length >= self.STEP_ROOM * 2 * r and not self._on_a_box(on_line, r, e):
+            return on_line
+        mx, my = point_along(poly, 1 / 2)
+        # the segment holding the midpoint gives the edge's direction there
+        ax, ay, bx, by = *poly[0], *poly[-1]
+        acc, half = 0.0, length / 2
+        for a, b in zip(poly, poly[1:]):
+            seg = math.dist(a, b)
+            if acc + seg >= half:
+                (ax, ay), (bx, by) = a, b
+                break
+            acc += seg
+        d = math.hypot(bx - ax, by - ay) or 1.0
+        nx, ny = -(by - ay) / d, (bx - ax) / d  # unit normal
+        off = r + 4
+        sides = [(mx - nx * off, my - ny * off), (mx + nx * off, my + ny * off)]
+        if abs(by - ay) >= abs(bx - ax):  # vertical-ish edge: prefer the left side
+            sides.sort(key=lambda p: p[0])
+        else:                             # horizontal-ish edge: prefer above
+            sides.sort(key=lambda p: p[1])
+        free = [p for p in sides if not self._on_a_box(p, r, e)]
+        return (free or sides)[0]
+
+    def _on_a_box(self, p, r, e) -> bool:
+        """Would a circle of radius r at p overlap any node box (with a small margin)?"""
+        x, y = p
+        for n in self.doc.walk():
+            if isinstance(n, Group):
+                continue
+            if n.ax - r - 2 < x < n.ax + n.w + r + 2 and n.ay - r - 2 < y < n.ay + n.h + r + 2:
+                return True
+        return False
+
     @staticmethod
     def head(kind, tip, d, hl, color, width, bg="#ffffff") -> Elem:
         """Arrowhead as plain geometry: tip sits exactly on the target outline.

{predictygraph-0.2.4 → predictygraph-0.2.5}/tests/test_annotations.py

@@ -105,3 +105,22 @@ def test_left_label_is_rotated_and_takes_a_column():
             rotated.append(e.geom["text"])
         stack += e.children
     assert rotated == ["Kernel space"]
+
+
+def test_step_on_short_arrow_sits_beside_it_and_clear_of_boxes():
+    doc, sc = scene('graph layout=column gap=4 steps=auto\na "top box"\nb "bottom box"\na -> b\n')
+    circles = []
+    stack = list(sc.layers)
+    while stack:
+        e = stack.pop()
+        if e.kind == "circle" and "pdg-step" in (e.cls or ""):
+            circles.append(e.geom)
+        stack += e.children
+    (c,) = circles
+    for n in (doc.items["a"], doc.items["b"]):
+        inside_x = n.ax - c["r"] < c["cx"] < n.ax + n.w + c["r"]
+        inside_y = n.ay - c["r"] < c["cy"] < n.ay + n.h + c["r"]
+        assert not (inside_x and inside_y)
+    # the column gap grew to fit the circle, even though gap=4 was asked for
+    a, b = doc.items["a"], doc.items["b"]
+    assert b.ay - (a.ay + a.h) >= 2 * c["r"]