jarvisplot 2.0.0__tar.gz → 2.0.1__tar.gz

{jarvisplot-2.0.0 → jarvisplot-2.0.1}/JarvisPLOT.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: JarvisPLOT
-Version: 2.0.0
+Version: 2.0.1
 Summary: Jarvis-PLOT: YAML-driven plotting engine
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{jarvisplot-2.0.0 → jarvisplot-2.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: JarvisPLOT
-Version: 2.0.0
+Version: 2.0.1
 Summary: Jarvis-PLOT: YAML-driven plotting engine
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{jarvisplot-2.0.0 → jarvisplot-2.0.1}/jarvisplot/cards/flowchart/default.json

@@ -14,7 +14,7 @@
     "variable_dx": 2.55,
     "input_variable_dx": 2.55,
     "output_variable_dx": 3.25,
-    "bridge_y_offset": 0.45,
+    "bridge_y_offset": 0.55,
     "bridge_output_pad": 0.18,
     "module_icon_size": 0.9,
     "module_label_dy": -0.45,

{jarvisplot-2.0.0 → jarvisplot-2.0.1}/jarvisplot/flowchart.py

@@ -412,6 +412,7 @@ class _ClassicGraph:
         self.output_variable_dx = float(self.classic.get("output_variable_dx", self.variable_dx))
         self.bridge_y_offset = float(self.classic.get("bridge_y_offset", 0.45))
         self.bridge_output_pad = float(self.classic.get("bridge_output_pad", 0.18))
+        self.module_icon_size = float(self.classic.get("module_icon_size", 0.9))
         self.mains: dict[str, dict] = {}
         self.files: dict[str, dict] = {}
         self.variables: dict[str, dict] = {}
@@ -585,7 +586,7 @@ class _ClassicGraph:
                 y = cursor - height / 2.0
                 self._place_main_group(main_id, x, y, height)
                 cursor -= height + self.group_gap
-            self._place_standalone_bridges(layer_id, x, max_height)
+            self._place_standalone_bridges(layer_id, x, max_height, layer_groups.get(layer_id, []))
 
         self._place_unpositioned_variables(max_height)
         self._compute_bounds(max_height)
@@ -704,11 +705,20 @@ class _ClassicGraph:
                 self._place_variable(var_id, x - self.input_variable_dx, y, align="right")
         self._place_variables(self._direct_output_variables(main_id), x + self.output_variable_dx, y, align="right")
 
-    def _place_standalone_bridges(self, layer_id: str, x: float, max_height: float) -> None:
+    def _place_standalone_bridges(self, layer_id: str, x: float, max_height: float, main_ids: list[str]) -> None:
         bridges = self._standalone_bridges(layer_id)
         if not bridges:
             return
-        ys = self._spread_y(max_height / 2.0 + self.bridge_y_offset, len(bridges), self.var_gap)
+        main_items = [self.mains[main_id] for main_id in main_ids if main_id in self.mains]
+        if main_items:
+            module_top = max(item["pos"][1] + self.module_icon_size / 2.0 for item in main_items)
+            lowest_bridge_y = module_top + self.bridge_y_offset
+            ys = [
+                lowest_bridge_y + (len(bridges) - 1 - idx) * self.var_gap
+                for idx in range(len(bridges))
+            ]
+        else:
+            ys = self._spread_y(max_height / 2.0 + self.bridge_y_offset, len(bridges), self.var_gap)
         for node_id, y in zip(bridges, ys):
             label = str(self.nodes[node_id].get("label") or "")
             self.bridges[node_id] = {
@@ -823,12 +833,18 @@ class _ClassicGraph:
                 return [str(node_id) for node_id in layer.get("nodes", [])]
         return []
 
-    def _bridge_order_key(self, bridge_id: str) -> tuple[int, int, str]:
+    def _bridge_order_key(self, bridge_id: str) -> tuple[float, float, str]:
         source_id = None
         for edge in self.edges:
             if str(edge.get("target", {}).get("node")) == bridge_id:
                 source_id = str(edge.get("source", {}).get("node"))
                 break
+
+        source_item = self.variables.get(source_id or "") or self.bridges.get(source_id or "")
+        if source_item is not None:
+            # Preserve the actual top-to-bottom order of the previous layer.
+            return (0.0, -float(source_item["pos"][1]), bridge_id)
+
         source_node = self.nodes.get(source_id or "")
         source_layer = str(source_node.get("layer", "")) if isinstance(source_node, Mapping) else ""
         layer_ids = self._layer_node_ids(source_layer)
@@ -841,7 +857,7 @@ class _ClassicGraph:
             if str(layer.get("id")) == source_layer:
                 layer_pos = idx
                 break
-        return (layer_pos, source_pos, bridge_id)
+        return (float(layer_pos + 1), float(source_pos), bridge_id)
 
     def _incoming_variables(self, target_id: str) -> list[str]:
         return self._unique(

{jarvisplot-2.0.0 → jarvisplot-2.0.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "JarvisPLOT"
-version = "2.0.0"
+version = "2.0.1"
 description = "Jarvis-PLOT: YAML-driven plotting engine"
 readme = "README.md"
 requires-python = ">=3.10"

{jarvisplot-2.0.0 → jarvisplot-2.0.1}/tests/test_flowchart_renderer.py

@@ -158,7 +158,10 @@ def test_flowchart_synthesizes_missing_bridge_for_cross_layer_file_input():
         ],
     }
 
-    graph = _ClassicGraph(scene, {"classic": {"synthesize_missing_bridges": True}})
+    graph = _ClassicGraph(
+        scene,
+        {"classic": {"synthesize_missing_bridges": True, "bridge_y_offset": 0.6}},
+    )
 
     bridge_id = "bridge::x::L2"
     assert bridge_id in graph.nodes
@@ -181,6 +184,66 @@ def test_flowchart_synthesizes_missing_bridge_for_cross_layer_file_input():
         for edge in graph.edges
     )
 
+    graph.layout()
+    module_top = graph.mains["FirstModule"]["pos"][1] + graph.module_icon_size / 2.0
+    bridge_y = graph.bridges[bridge_id]["pos"][1]
+    assert abs(bridge_y - module_top - 0.6) < 1e-9
+
+
+def test_flowchart_orders_bridge_chain_by_previous_layer_y_position():
+    scene = {
+        "schema": "jarvisplot.scene/v1",
+        "scene_type": "flowchart",
+        "layers": [
+            {"id": "layer_1", "index": 1, "nodes": ["Parameters", "var::top", "var::bottom"]},
+            {"id": "layer_2", "index": 2, "nodes": []},
+            {"id": "layer_3", "index": 3, "nodes": []},
+            {
+                "id": "layer_4",
+                "index": 4,
+                "nodes": ["FinalModule", "file::FinalModule::input::final_input"],
+            },
+        ],
+        "nodes": [
+            {"id": "Parameters", "kind": "source", "label": "Parameters", "layer": "layer_1"},
+            {"id": "var::top", "kind": "variable", "role": "parameter", "label": "top", "layer": "layer_1"},
+            {"id": "var::bottom", "kind": "variable", "role": "parameter", "label": "bottom", "layer": "layer_1"},
+            {"id": "FinalModule", "kind": "module", "label": "FinalModule", "layer": "layer_4"},
+            {
+                "id": "file::FinalModule::input::final_input",
+                "kind": "file",
+                "role": "input_file",
+                "label": "final_input",
+                "layer": "layer_4",
+            },
+        ],
+        "edges": [
+            {"source": {"node": "Parameters", "port": "top"}, "target": {"node": "var::top", "port": "in"}, "role": "parameterflow"},
+            {"source": {"node": "Parameters", "port": "bottom"}, "target": {"node": "var::bottom", "port": "in"}, "role": "parameterflow"},
+            {
+                "source": {"node": "var::bottom", "port": "out"},
+                "target": {"node": "file::FinalModule::input::final_input", "port": "in"},
+                "role": "fileflow",
+                "metadata": {"variable": "bottom"},
+            },
+            {
+                "source": {"node": "var::top", "port": "out"},
+                "target": {"node": "file::FinalModule::input::final_input", "port": "in"},
+                "role": "fileflow",
+                "metadata": {"variable": "top"},
+            },
+        ],
+    }
+
+    graph = _ClassicGraph(scene, {"classic": {"synthesize_missing_bridges": True}})
+    graph.layout()
+
+    layer_2_bridges = graph._standalone_bridges("layer_2")
+    layer_3_bridges = graph._standalone_bridges("layer_3")
+    assert layer_2_bridges == ["bridge::top::L2", "bridge::bottom::L2"]
+    assert layer_3_bridges == ["bridge::top::L3", "bridge::bottom::L3"]
+    assert graph.bridges["bridge::top::L3"]["pos"][1] > graph.bridges["bridge::bottom::L3"]["pos"][1]
+
 
 def test_flowchart_uses_triangle_for_file_output_variables():
     scene = {