frameplot 0.5.1__tar.gz → 0.5.3__tar.gz

{frameplot-0.5.1/src/frameplot.egg-info → frameplot-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: frameplot
-Version: 0.5.1
+Version: 0.5.3
 Summary: Turn Python-defined pipeline graphs into presentation-ready SVG and PNG diagrams.
 Author: Small Turtle 2
 License-Expression: MIT
@@ -50,9 +50,9 @@ All built-in presets stay on a white canvas. The same hero pipeline is rendered
 | --- | --- |
 | ![Soft Retro theme hero](docs/assets/frameplot-hero-soft-retro.png) | ![Retro theme hero](docs/assets/frameplot-hero-retro.png) |
 
-| Pastel | Dark |
+| Research | Dark |
 | --- | --- |
-| ![Pastel theme hero](docs/assets/frameplot-hero-pastel.png) | ![Dark theme hero](docs/assets/frameplot-hero-dark.png) |
+| ![Research theme hero](docs/assets/frameplot-hero-research.png) | ![Dark theme hero](docs/assets/frameplot-hero-dark.png) |
 
 | Cyberpunk | Monochrome |
 | --- | --- |

{frameplot-0.5.1 → frameplot-0.5.3}/README.md

@@ -21,9 +21,9 @@ All built-in presets stay on a white canvas. The same hero pipeline is rendered
 | --- | --- |
 | ![Soft Retro theme hero](docs/assets/frameplot-hero-soft-retro.png) | ![Retro theme hero](docs/assets/frameplot-hero-retro.png) |
 
-| Pastel | Dark |
+| Research | Dark |
 | --- | --- |
-| ![Pastel theme hero](docs/assets/frameplot-hero-pastel.png) | ![Dark theme hero](docs/assets/frameplot-hero-dark.png) |
+| ![Research theme hero](docs/assets/frameplot-hero-research.png) | ![Dark theme hero](docs/assets/frameplot-hero-dark.png) |
 
 | Cyberpunk | Monochrome |
 | --- | --- |

{frameplot-0.5.1 → frameplot-0.5.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "frameplot"
-version = "0.5.1"
+version = "0.5.3"
 description = "Turn Python-defined pipeline graphs into presentation-ready SVG and PNG diagrams."
 readme = "README.md"
 requires-python = ">=3.11"

{frameplot-0.5.1 → frameplot-0.5.3}/src/frameplot/layout/__init__.py

@@ -38,8 +38,14 @@ class _GroupSpacingInfo:
     group_node_ids: frozenset[str]
     min_rank: int
     max_rank: int
+    min_row: int
+    max_row: int
+    member_top: float
+    member_bottom: float
     member_left: float
     member_right: float
+    top_inside_clearance: float
+    bottom_inside_clearance: float
     left_inside_clearance: float
     right_inside_clearance: float
 
@@ -77,6 +83,8 @@ def _layout_graph(validated: "ValidatedPipeline | ValidatedDetailPanel") -> Grap
     ranks = assign_ranks(validated, scc_result)
     order = order_nodes(validated, ranks)
     rank_gap_overrides: dict[tuple[int, int], float] | None = None
+    row_gap_overrides: dict[tuple[int, int], float] | None = None
+    row_gap_floor = resolve_theme_metrics(validated.theme).compact_rank_gap
 
     for _ in range(MAX_LAYOUT_STABILIZATION_PASSES):
         placed_nodes = place_nodes(
@@ -85,13 +93,20 @@ def _layout_graph(validated: "ValidatedPipeline | ValidatedDetailPanel") -> Grap
             ranks,
             order,
             rank_gap_overrides=rank_gap_overrides,
+            row_gap_overrides=row_gap_overrides,
+            row_gap_floor=row_gap_floor,
         )
         routed_edges = route_edges(validated, placed_nodes)
         overlays = compute_group_overlays(validated, placed_nodes, routed_edges)
-        next_overrides = _rank_gap_overrides(validated, placed_nodes, routed_edges, overlays)
-        if next_overrides == (rank_gap_overrides or {}):
+        next_rank_overrides = _rank_gap_overrides(validated, placed_nodes, routed_edges, overlays)
+        next_row_overrides = _row_gap_overrides(validated, placed_nodes, routed_edges, overlays)
+        if (
+            next_rank_overrides == (rank_gap_overrides or {})
+            and next_row_overrides == (row_gap_overrides or {})
+        ):
             break
-        rank_gap_overrides = next_overrides or None
+        rank_gap_overrides = next_rank_overrides or None
+        row_gap_overrides = next_row_overrides or None
 
     return _normalize_graph_layout(placed_nodes, routed_edges, overlays, validated.theme)
 
@@ -107,7 +122,7 @@ def _rank_gap_overrides(
     base_gap = metrics.compact_rank_gap
     geometry_by_component = _build_component_geometry(placed_nodes, theme)
     required_gaps: dict[tuple[int, int], float] = {}
-    used_lane_positions: dict[tuple[int, int], set[float]] = {}
+    used_lane_positions: dict[tuple[int, int], set[tuple[str, float]]] = {}
 
     for component_id, geometry in geometry_by_component.items():
         for left_rank in geometry.gap_after_rank:
@@ -122,13 +137,18 @@ def _rank_gap_overrides(
             x = round(start.x, 2)
             for left_rank, (gap_start, gap_end) in geometry.gap_after_rank.items():
                 if gap_start + 0.01 < x < gap_end - 0.01:
-                    used_lane_positions[(component_id, left_rank)].add(x)
+                    used_lane_positions[(component_id, left_rank)].add((routed_edge.edge.id, x))
 
     overrides: dict[tuple[int, int], float] = {}
-    for key, lane_positions in used_lane_positions.items():
-        if len(lane_positions) <= 1:
+    for key, lane_entries in used_lane_positions.items():
+        if len(lane_entries) <= 1:
             continue
-        required_gap = base_gap + max(lane_positions) - min(lane_positions)
+        lane_positions = sorted(position for _, position in lane_entries)
+        required_span = max(
+            lane_positions[-1] - lane_positions[0],
+            theme.route_track_gap * len(lane_positions),
+        )
+        required_gap = base_gap + required_span
         if required_gap > base_gap + EPSILON:
             required_gaps[key] = round(required_gap, 2)
 
@@ -153,6 +173,56 @@ def _rank_gap_overrides(
     return overrides
 
 
+def _row_gap_overrides(
+    validated: "ValidatedPipeline | ValidatedDetailPanel",
+    placed_nodes: dict[str, LayoutNode],
+    routed_edges: tuple[RoutedEdge, ...],
+    overlays: tuple[GroupOverlay, ...],
+) -> dict[tuple[int, int], float]:
+    theme = validated.theme
+    base_gap = resolve_theme_metrics(theme).compact_rank_gap
+    geometry_by_component = _build_component_geometry(placed_nodes, theme)
+    used_lane_positions: dict[tuple[int, int], set[tuple[str, float]]] = {}
+    required_gaps: dict[tuple[int, int], float] = {}
+
+    for component_id, geometry in geometry_by_component.items():
+        for upper_row in geometry.gap_after_row:
+            used_lane_positions[(component_id, upper_row)] = set()
+
+    for routed_edge in routed_edges:
+        component_id = placed_nodes[routed_edge.edge.source].component_id
+        geometry = geometry_by_component[component_id]
+        for start, end in zip(routed_edge.points, routed_edge.points[1:]):
+            if start.y != end.y:
+                continue
+            y = round(start.y, 2)
+            for upper_row, (gap_start, gap_end) in geometry.gap_after_row.items():
+                if gap_start + EPSILON < y < gap_end - EPSILON:
+                    used_lane_positions[(component_id, upper_row)].add((routed_edge.edge.id, y))
+
+    for key, lane_entries in used_lane_positions.items():
+        if not lane_entries:
+            continue
+        lane_positions = sorted(position for _, position in lane_entries)
+        occupied_span = lane_positions[-1] - lane_positions[0]
+        required_gap = max(base_gap, occupied_span + theme.route_track_gap)
+        if required_gap > base_gap + EPSILON:
+            required_gaps[key] = round(required_gap, 2)
+
+    for key, required_gap in _group_row_boundary_gap_requirements(
+        placed_nodes,
+        overlays,
+        geometry_by_component,
+    ).items():
+        required_gaps[key] = round(max(required_gaps.get(key, 0.0), required_gap), 2)
+
+    return {
+        key: round(required_gap, 2)
+        for key, required_gap in required_gaps.items()
+        if required_gap > base_gap + EPSILON
+    }
+
+
 def _join_target_gap_requirements(
     validated: "ValidatedPipeline | ValidatedDetailPanel",
     placed_nodes: dict[str, LayoutNode],
@@ -282,6 +352,8 @@ def _build_group_spacing_infos(
         if not overlay.group.node_ids:
             continue
         member_nodes = [placed_nodes[node_id] for node_id in overlay.group.node_ids]
+        member_top = min(node.y for node in member_nodes)
+        member_bottom = max(node.bounds.bottom for node in member_nodes)
         member_left = min(node.x for node in member_nodes)
         member_right = max(node.right for node in member_nodes)
         infos.append(
@@ -291,8 +363,14 @@ def _build_group_spacing_infos(
                 group_node_ids=frozenset(overlay.group.node_ids),
                 min_rank=min(node.rank for node in member_nodes),
                 max_rank=max(node.rank for node in member_nodes),
+                min_row=min(node.order for node in member_nodes),
+                max_row=max(node.order for node in member_nodes),
+                member_top=member_top,
+                member_bottom=member_bottom,
                 member_left=member_left,
                 member_right=member_right,
+                top_inside_clearance=member_top - overlay.bounds.y,
+                bottom_inside_clearance=overlay.bounds.bottom - member_bottom,
                 left_inside_clearance=member_left - overlay.bounds.x,
                 right_inside_clearance=overlay.bounds.right - member_right,
             )
@@ -301,6 +379,52 @@ def _build_group_spacing_infos(
     return tuple(infos)
 
 
+def _group_row_boundary_gap_requirements(
+    placed_nodes: dict[str, LayoutNode],
+    overlays: tuple[GroupOverlay, ...],
+    geometry_by_component: dict[int, "ComponentGeometry"],
+) -> dict[tuple[int, int], float]:
+    required_gaps: dict[tuple[int, int], float] = {}
+    group_infos = _build_group_spacing_infos(placed_nodes, overlays)
+
+    for info in group_infos:
+        geometry = geometry_by_component.get(info.component_id)
+        if geometry is None:
+            continue
+
+        upper_row = _previous_row(geometry, info.min_row)
+        top_outside_node = _nearest_outside_node_by_row(
+            placed_nodes,
+            bounds=info.bounds,
+            component_id=info.component_id,
+            group_node_ids=info.group_node_ids,
+            row_predicate=lambda row: row < info.min_row,
+            side="top",
+        )
+        if upper_row is not None and top_outside_node is not None:
+            required_gaps[(info.component_id, upper_row)] = round(
+                max(required_gaps.get((info.component_id, upper_row), 0.0), info.top_inside_clearance * 2.0),
+                2,
+            )
+
+        lower_row = info.max_row
+        bottom_outside_node = _nearest_outside_node_by_row(
+            placed_nodes,
+            bounds=info.bounds,
+            component_id=info.component_id,
+            group_node_ids=info.group_node_ids,
+            row_predicate=lambda row: row > info.max_row,
+            side="bottom",
+        )
+        if lower_row in geometry.gap_after_row and bottom_outside_node is not None:
+            required_gaps[(info.component_id, lower_row)] = round(
+                max(required_gaps.get((info.component_id, lower_row), 0.0), info.bottom_inside_clearance * 2.0),
+                2,
+            )
+
+    return required_gaps
+
+
 def _nearest_outside_node(
     placed_nodes: dict[str, LayoutNode],
     *,
@@ -332,6 +456,37 @@ def _nearest_outside_node(
     return candidate
 
 
+def _nearest_outside_node_by_row(
+    placed_nodes: dict[str, LayoutNode],
+    *,
+    bounds: Bounds,
+    component_id: int,
+    group_node_ids: frozenset[str],
+    row_predicate: Callable[[int], bool],
+    side: str,
+) -> LayoutNode | None:
+    candidate: LayoutNode | None = None
+
+    for node_id, node in placed_nodes.items():
+        if node.component_id != component_id:
+            continue
+        if node_id in group_node_ids:
+            continue
+        if not row_predicate(node.order):
+            continue
+        if not _bounds_overlap_horizontally(bounds, node.bounds):
+            continue
+        if candidate is None:
+            candidate = node
+            continue
+        if side == "top" and node.bounds.bottom > candidate.bounds.bottom:
+            candidate = node
+        if side == "bottom" and node.y < candidate.y:
+            candidate = node
+
+    return candidate
+
+
 def _nearest_group_neighbor(
     info: _GroupSpacingInfo,
     group_infos: tuple[_GroupSpacingInfo, ...],
@@ -364,6 +519,10 @@ def _bounds_overlap_vertically(first: Bounds, second: Bounds) -> bool:
     return min(first.bottom, second.bottom) - max(first.y, second.y) > EPSILON
 
 
+def _bounds_overlap_horizontally(first: Bounds, second: Bounds) -> bool:
+    return min(first.right, second.right) - max(first.x, second.x) > EPSILON
+
+
 def _previous_rank(geometry: "ComponentGeometry", rank: int) -> int | None:
     candidates = [candidate_rank for candidate_rank in geometry.rank_right if candidate_rank < rank]
     if not candidates:
@@ -371,6 +530,13 @@ def _previous_rank(geometry: "ComponentGeometry", rank: int) -> int | None:
     return max(candidates)
 
 
+def _previous_row(geometry: "ComponentGeometry", row: int) -> int | None:
+    candidates = [candidate_row for candidate_row in geometry.row_bottom if candidate_row < row]
+    if not candidates:
+        return None
+    return max(candidates)
+
+
 def _normalize_graph_layout(
     placed_nodes: dict[str, LayoutNode],
     routed_edges: tuple[RoutedEdge, ...],

{frameplot-0.5.1 → frameplot-0.5.3}/src/frameplot/layout/order.py

@@ -33,7 +33,10 @@ def order_nodes(
             _resort_rank(nodes_by_rank[rank], outgoing, order, validated)
             _refresh_order(nodes_by_rank[rank], order)
 
-    if getattr(validated, "detail_panel", None) is not None:
+    if isinstance(validated, ValidatedDetailPanel):
+        _apply_detail_panel_shared_source_lanes(validated, ranks, order)
+
+    if isinstance(validated, ValidatedPipeline) and validated.detail_panel is not None:
         _apply_detail_panel_bias(validated, nodes_by_rank, ranks, order)
 
     return order
@@ -42,12 +45,18 @@ def order_nodes(
 def _forward_neighbors(
     validated: ValidatedPipeline | ValidatedDetailPanel,
     ranks: dict[str, int],
+    *,
+    included_node_ids: set[str] | None = None,
 ) -> tuple[dict[str, list[str]], dict[str, list[str]]]:
     incoming: dict[str, list[str]] = defaultdict(list)
     outgoing: dict[str, list[str]] = defaultdict(list)
 
     for edge in validated.edges:
         target_node_id = validated.edge_targets[edge.id].node_id
+        if included_node_ids is not None and (
+            edge.source not in included_node_ids or target_node_id not in included_node_ids
+        ):
+            continue
         if ranks[edge.source] < ranks[target_node_id]:
             incoming[target_node_id].append(edge.source)
             outgoing[edge.source].append(target_node_id)
@@ -112,6 +121,125 @@ def _apply_detail_panel_bias(
             order[node_id] = start_row + index
 
 
+def _apply_detail_panel_shared_source_lanes(
+    validated: ValidatedDetailPanel,
+    ranks: dict[str, int],
+    order: dict[str, int],
+) -> None:
+    group_membership = _group_membership(validated)
+    components = _weak_components(validated)
+    incoming, outgoing = _forward_neighbors(validated, ranks)
+
+    for component_nodes in components:
+        component_set = set(component_nodes)
+        shared_sources = [
+            node_id
+            for node_id in component_nodes
+            if _is_detail_panel_shared_source(
+                node_id,
+                component_set,
+                group_membership,
+                incoming,
+                outgoing,
+                order,
+            )
+        ]
+        if not shared_sources:
+            continue
+
+        shared_sources.sort(key=lambda node_id: (order[node_id], validated.node_index[node_id], node_id))
+        shared_source_ids = set(shared_sources)
+        nonshared_rows = _reorder_component_nodes(
+            validated,
+            ranks,
+            component_set - shared_source_ids,
+        )
+
+        for index, node_id in enumerate(shared_sources):
+            order[node_id] = index
+        for node_id, row in nonshared_rows.items():
+            order[node_id] = row + len(shared_sources)
+
+
+def _is_detail_panel_shared_source(
+    node_id: str,
+    component_nodes: set[str],
+    group_membership: dict[str, tuple[str, ...]],
+    incoming: dict[str, list[str]],
+    outgoing: dict[str, list[str]],
+    order: dict[str, int],
+) -> bool:
+    if group_membership.get(node_id):
+        return False
+    if incoming.get(node_id):
+        return False
+
+    targets = [target_id for target_id in outgoing.get(node_id, ()) if target_id in component_nodes]
+    if len(set(targets)) < 2:
+        return False
+
+    downstream_lanes = {
+        (
+            order[target_id],
+            group_membership.get(target_id, ()),
+        )
+        for target_id in targets
+    }
+    return len(downstream_lanes) >= 2
+
+
+def _group_membership(
+    validated: ValidatedPipeline | ValidatedDetailPanel,
+) -> dict[str, tuple[str, ...]]:
+    memberships: dict[str, list[str]] = defaultdict(list)
+    for group in validated.groups:
+        for node_id in group.node_ids:
+            memberships[node_id].append(group.id)
+    return {
+        node_id: tuple(sorted(group_ids))
+        for node_id, group_ids in memberships.items()
+    }
+
+
+def _reorder_component_nodes(
+    validated: ValidatedPipeline | ValidatedDetailPanel,
+    ranks: dict[str, int],
+    included_node_ids: set[str],
+) -> dict[str, int]:
+    if not included_node_ids:
+        return {}
+
+    nodes_by_rank: dict[int, list[str]] = defaultdict(list)
+    for node_id in included_node_ids:
+        nodes_by_rank[ranks[node_id]].append(node_id)
+
+    for rank_nodes in nodes_by_rank.values():
+        rank_nodes.sort(key=validated.node_index.__getitem__)
+
+    local_order = {
+        node_id: index
+        for rank_nodes in nodes_by_rank.values()
+        for index, node_id in enumerate(rank_nodes)
+    }
+
+    incoming, outgoing = _forward_neighbors(
+        validated,
+        ranks,
+        included_node_ids=included_node_ids,
+    )
+    ordered_ranks = sorted(nodes_by_rank)
+
+    for _ in range(4):
+        for rank in ordered_ranks[1:]:
+            _resort_rank(nodes_by_rank[rank], incoming, local_order, validated)
+            _refresh_order(nodes_by_rank[rank], local_order)
+        for rank in reversed(ordered_ranks[:-1]):
+            _resort_rank(nodes_by_rank[rank], outgoing, local_order, validated)
+            _refresh_order(nodes_by_rank[rank], local_order)
+
+    return local_order
+
+
 def _detail_focus_path_nodes(
     validated: ValidatedPipeline,
     ranks: dict[str, int],
@@ -151,22 +279,41 @@ def _reachable(start: str, adjacency: dict[str, list[str]]) -> set[str]:
     return seen
 
 
-def _weak_component_nodes(validated: ValidatedPipeline, start_node_id: str) -> set[str]:
+def _weak_components(validated: ValidatedPipeline | ValidatedDetailPanel) -> list[tuple[str, ...]]:
     adjacency: dict[str, set[str]] = {node.id: set() for node in validated.nodes}
     for edge in validated.edges:
         target_node_id = validated.edge_targets[edge.id].node_id
         adjacency[edge.source].add(target_node_id)
         adjacency[target_node_id].add(edge.source)
 
-    seen = {start_node_id}
-    queue = deque([start_node_id])
-
-    while queue:
-        node_id = queue.popleft()
-        for neighbor in sorted(adjacency[node_id], key=validated.node_index.__getitem__):
-            if neighbor in seen:
-                continue
-            seen.add(neighbor)
-            queue.append(neighbor)
+    components: list[tuple[str, ...]] = []
+    seen: set[str] = set()
 
-    return seen
+    for node in validated.nodes:
+        if node.id in seen:
+            continue
+        queue = deque([node.id])
+        seen.add(node.id)
+        members: list[str] = []
+        while queue:
+            node_id = queue.popleft()
+            members.append(node_id)
+            for neighbor in sorted(adjacency[node_id], key=validated.node_index.__getitem__):
+                if neighbor in seen:
+                    continue
+                seen.add(neighbor)
+                queue.append(neighbor)
+        members.sort(key=validated.node_index.__getitem__)
+        components.append(tuple(members))
+
+    return components
+
+
+def _weak_component_nodes(
+    validated: ValidatedPipeline | ValidatedDetailPanel,
+    start_node_id: str,
+) -> set[str]:
+    for component in _weak_components(validated):
+        if start_node_id in component:
+            return set(component)
+    return {start_node_id}

{frameplot-0.5.1 → frameplot-0.5.3}/src/frameplot/layout/place.py

@@ -13,6 +13,8 @@ def place_nodes(
     order: dict[str, int],
     *,
     rank_gap_overrides: dict[tuple[int, int], float] | None = None,
+    row_gap_overrides: dict[tuple[int, int], float] | None = None,
+    row_gap_floor: float | None = None,
 ) -> dict[str, LayoutNode]:
     components = _weak_components(validated)
     placed: dict[str, LayoutNode] = {}
@@ -41,6 +43,9 @@ def place_nodes(
             validated,
             component_nodes,
             local_rows,
+            component_id=component_id,
+            overrides=row_gap_overrides,
+            row_gap_floor=row_gap_floor,
         )
         column_widths = {
             rank: max(measurements[node_id].width for node_id in nodes)
@@ -132,41 +137,18 @@ def _row_gap_after(
     validated: "ValidatedPipeline | ValidatedDetailPanel",
     component_nodes: tuple[str, ...],
     rows: dict[str, int],
+    *,
+    component_id: int,
+    overrides: dict[tuple[int, int], float] | None,
+    row_gap_floor: float | None,
 ) -> dict[int, float]:
     row_ids = sorted({rows[node_id] for node_id in component_nodes})
-    crossing_counts = {row: 0 for row in row_ids[:-1]}
-    component_set = set(component_nodes)
-
-    node_padding = {}
-    if hasattr(validated, "groups"):
-        for group in validated.groups:
-            for node_id in group.node_ids:
-                node_padding[node_id] = validated.theme.group_padding
-
-    row_padding: dict[int, float] = {}
-    for row in row_ids:
-        nodes_in_row = [n for n in component_nodes if rows[n] == row]
-        row_padding[row] = max((node_padding.get(n, 0.0) for n in nodes_in_row), default=0.0)
-
-    for edge in validated.edges:
-        target_node_id = validated.edge_targets[edge.id].node_id
-        if edge.source not in component_set or target_node_id not in component_set:
-            continue
-        source_row = rows[edge.source]
-        target_row = rows[target_node_id]
-        if source_row == target_row:
-            continue
-        for row in range(min(source_row, target_row), max(source_row, target_row)):
-            crossing_counts[row] = crossing_counts.get(row, 0) + 1
-
+    base_gap = _base_row_gap(validated.theme) if row_gap_floor is None else row_gap_floor
     gap_after: dict[int, float] = {}
-    for i, row in enumerate(row_ids[:-1]):
-        lanes = crossing_counts.get(row, 0)
-        padding_add = row_padding[row] + row_padding[row_ids[i+1]]
+    for row in row_ids[:-1]:
+        override_key = (component_id, row)
         gap_after[row] = round(
-            _base_row_gap(validated.theme)
-            + max(0, lanes - 1) * validated.theme.route_track_gap
-            + padding_add,
+            max(base_gap, overrides.get(override_key, base_gap)) if overrides is not None else base_gap,
             2,
         )
     return gap_after