jarvisplot 2.0.0__tar.gz → 2.0.2__tar.gz

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

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

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

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

{jarvisplot-2.0.0 → jarvisplot-2.0.2}/jarvisplot/Figure/figure.py

@@ -26,6 +26,7 @@ from .layout_runtime import (
     apply_manual_ticks,
     ensure_numbered_rect_axes,
     has_manual_ticks,
+    hide_log_minor_tick_labels,
     is_numbered_ax,
 )
 from .colorbar_runtime import (
@@ -802,6 +803,7 @@ class Figure:
             self.ax.set_yscale("log")
             from matplotlib.ticker import LogLocator
             self.ax.yaxis.set_minor_locator(LogLocator(subs='auto'))
+            hide_log_minor_tick_labels(self.ax, "y")
         else:
             self.ax.yaxis.set_minor_locator(AutoMinorLocator())
         
@@ -809,6 +811,7 @@ class Figure:
             self.ax.set_xscale("log")
             from matplotlib.ticker import LogLocator
             self.ax.xaxis.set_minor_locator(LogLocator(subs='auto'))
+            hide_log_minor_tick_labels(self.ax, "x")
         else:
             self.ax.xaxis.set_minor_locator(AutoMinorLocator())
         
@@ -838,8 +841,8 @@ class Figure:
 
         # Apply manual ticks here at initialization if provided in YAML
         ax_ticks_cfg = self.frame.get('ax', {}).get('ticks', {})
-        # self._apply_manual_ticks(self.ax, "x", ax_ticks_cfg.get('x', {}))
-        # self._apply_manual_ticks(self.ax, "y", ax_ticks_cfg.get('y', {}))
+        self._apply_manual_ticks(self.ax, "x", ax_ticks_cfg.get('x', {}))
+        self._apply_manual_ticks(self.ax, "y", ax_ticks_cfg.get('y', {}))
 
 
         self.ax.tick_params(**self.frame['ax']['ticks'].get("both", {}))

{jarvisplot-2.0.0 → jarvisplot-2.0.2}/jarvisplot/Figure/layout_runtime.py

@@ -61,6 +61,19 @@ def apply_axis_title(fig, ax_obj, ax_name: str) -> None:
     ax_obj.text(s=str(title), **text_params)
 
 
+def hide_log_minor_tick_labels(ax_obj, which: str) -> None:
+    """Keep log minor tick marks, but hide their labels by default."""
+    target = ax_obj.ax if hasattr(ax_obj, "ax") else ax_obj
+    if which == "x":
+        target.tick_params(
+            axis="x", which="minor", labelbottom=False, labeltop=False
+        )
+    elif which == "y":
+        target.tick_params(
+            axis="y", which="minor", labelleft=False, labelright=False
+        )
+
+
 def ensure_numbered_rect_axes(fig, ax_name: str, kwgs: dict):
     if not is_numbered_ax(ax_name):
         raise ValueError(f"Illegal dynamic axes name '{ax_name}'. Only ax<NUMBER> is allowed.")
@@ -88,12 +101,14 @@ def ensure_numbered_rect_axes(fig, ax_name: str, kwgs: dict):
     if fig.frame.get(ax_name, {}).get("yscale", "").lower() == "log":
         ax_obj.set_yscale("log")
         ax_obj.yaxis.set_minor_locator(LogLocator(subs="auto"))
+        hide_log_minor_tick_labels(ax_obj, "y")
     else:
         ax_obj.yaxis.set_minor_locator(AutoMinorLocator())
 
     if fig.frame.get(ax_name, {}).get("xscale", "").lower() == "log":
         ax_obj.set_xscale("log")
         ax_obj.xaxis.set_minor_locator(LogLocator(subs="auto"))
+        hide_log_minor_tick_labels(ax_obj, "x")
     else:
         ax_obj.xaxis.set_minor_locator(AutoMinorLocator())
 

{jarvisplot-2.0.0 → jarvisplot-2.0.2}/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.2}/jarvisplot/core.py

@@ -285,11 +285,22 @@ class JarvisPLOT():
     def _maybe_write_agent_digest(self, figure_cfg, figobj) -> None:
         """Write figure-level agent_output digest after a successful plot."""
         try:
-            from .agent_digest import load_figure_source_dataframe, maybe_write_figure_digest
+            from .agent_digest import (
+                load_figure_source_dataframe,
+                maybe_write_figure_digest,
+                parse_agent_output,
+            )
             from .cli import JPLOT_VERSION
 
             if not isinstance(figure_cfg, dict):
                 return
+            # Do not load the source dataframe just to discover that no agent
+            # digest was requested. This matters after rendering releases the
+            # last layer's source data.
+            root_config = getattr(self.yaml, "config", {}) or {}
+            root_output = root_config.get("output", {}) if isinstance(root_config, dict) else {}
+            if parse_agent_output(figure_cfg, root_output=root_output) is None:
+                return
             # Prefer raw YAML figure block (pre type-expand may have type: fields).
             # After expand_figure_types, config figures are already expanded; still OK.
             df = load_figure_source_dataframe(self, figure_cfg)

{jarvisplot-2.0.0 → jarvisplot-2.0.2}/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.2}/pyproject.toml

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

{jarvisplot-2.0.0 → jarvisplot-2.0.2}/tests/test_agent_digest.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import json
 import textwrap
 from pathlib import Path
+from types import SimpleNamespace
 
 import numpy as np
 
@@ -18,6 +19,30 @@ from jarvisplot.client import main
 from jarvisplot.diagnostics import DiagnosticBag
 
 
+def test_render_skips_agent_digest_source_load_when_not_requested(monkeypatch):
+    from jarvisplot.core import JarvisPLOT
+
+    core = JarvisPLOT()
+    core.yaml = SimpleNamespace(config={"output": {}})
+    core.logger = SimpleNamespace(warning=lambda *args, **kwargs: None)
+
+    def fail_if_source_is_loaded(*args, **kwargs):
+        raise AssertionError("agent digest source should not load when disabled")
+
+    monkeypatch.setattr(
+        "jarvisplot.agent_digest.load_figure_source_dataframe",
+        fail_if_source_is_loaded,
+    )
+
+    core._maybe_write_agent_digest(
+        {
+            "name": "plain_plot",
+            "layers": [{"data": [{"source": "samples"}]}],
+        },
+        SimpleNamespace(),
+    )
+
+
 def test_strip_digest_axes_stash_removes_key(tmp_path):
     from jarvisplot.agent_digest import strip_digest_axes_stash
 

{jarvisplot-2.0.0 → jarvisplot-2.0.2}/tests/test_figure_contracts.py

@@ -716,6 +716,39 @@ def test_colorbar_manual_y_ticks_override_auto_ticks(axc_name):
     plt.close(fig.fig)
 
 
+def test_main_axis_manual_log_x_ticks_are_applied_and_preserved():
+    positions = [0.1, 1.0, 5.0]
+    labels = ["0.1", "1", "5"]
+
+    fig = Figure()
+    fig.logger = _logger()
+    fig.frame = {
+        "figure": {"figsize": (2, 2)},
+        "ax": {
+            "labels": {"x": "", "y": ""},
+            "xlim": [0.1, 5.0],
+            "ylim": [0.1, 5.0],
+            "xscale": "log",
+            "yscale": "linear",
+            "ticks": {"x": {"positions": positions, "labels": labels}},
+        },
+    }
+    fig.fig = plt.figure(figsize=(2, 2))
+    fig.axes = {}
+    fig.ax = {"rect": [0.1, 0.1, 0.8, 0.8]}
+
+    fig.render()
+    fig.fig.canvas.draw()
+
+    np.testing.assert_allclose(fig.ax.xaxis.get_majorticklocs(), positions)
+    assert [label.get_text() for label in fig.ax.get_xticklabels()] == labels
+    assert all(
+        not tick.label1.get_visible() and not tick.label2.get_visible()
+        for tick in fig.ax.xaxis.get_minor_ticks()
+    )
+    plt.close(fig.fig)
+
+
 @pytest.mark.parametrize("ax_type", ["rect", "tri"])
 def test_render_layer_does_not_mutate_layer_data(monkeypatch, ax_type):
     original_data = object()

{jarvisplot-2.0.0 → jarvisplot-2.0.2}/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 = {