jarvisplot 2.0.1__tar.gz → 2.0.3__tar.gz

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

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

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

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

{jarvisplot-2.0.1 → jarvisplot-2.0.3}/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.1 → jarvisplot-2.0.3}/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.1 → jarvisplot-2.0.3}/jarvisplot/capabilities.py

@@ -15,7 +15,8 @@ Two rules keep this honest:
   derived from the registry, card directory or schema that the runtime actually
   consults, and ``tests/test_capabilities.py`` fails if the two drift apart.
 - **Stay cheap.** Agents call this constantly, so the collectors read JSON and
-  module-level dicts; nothing here imports matplotlib.
+  module-level dicts. The cmap collector also inspects Matplotlib's live
+  registry because agents may need the complete built-in cmap vocabulary.
 """
 
 from __future__ import annotations
@@ -226,9 +227,42 @@ def _cmaps() -> dict[str, Any]:
         for entry in entries
         if isinstance(entry, dict) and entry.get("name")
     )
+    jarvis_and_reversed = set(names) | {f"{name}_r" for name in names}
+    matplotlib_entries: list[dict[str, Any]] = []
+    try:
+        from matplotlib import colormaps
+
+        matplotlib_names = sorted(
+            str(name) for name in colormaps if str(name) not in jarvis_and_reversed
+        )
+        matplotlib_registry = set(str(name) for name in colormaps)
+        for name in matplotlib_names:
+            cmap = colormaps[name]
+            if name.endswith("_r") and name[:-2] in matplotlib_registry:
+                reverse = name[:-2]
+            elif f"{name}_r" in matplotlib_registry:
+                reverse = f"{name}_r"
+            else:
+                reverse = None
+            samples = getattr(cmap, "N", None)
+            matplotlib_entries.append(
+                {
+                    "name": name,
+                    "type": type(cmap).__name__,
+                    "N": int(samples) if isinstance(samples, int) else samples,
+                    "reverse": reverse,
+                }
+            )
+        matplotlib_note = (
+            "Matplotlib registry entries include the normal and _r reverse names."
+        )
+    except Exception as exc:
+        matplotlib_note = f"Matplotlib registry unavailable: {exc}"
     return {
         "jarvis": names,
         "jarvis_reversed": [f"{name}_r" for name in names],
+        "matplotlib": matplotlib_entries,
+        "matplotlib_note": matplotlib_note,
         "note": (
             "Every matplotlib colormap is also available. Jarvis colormaps are "
             "registered from cards/colors/colormaps.json; each has an _r reverse."

{jarvisplot-2.0.1 → jarvisplot-2.0.3}/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.1 → jarvisplot-2.0.3}/jarvisplot/manual_cards/workflow.yaml

@@ -65,6 +65,7 @@ human:
       title: Rules
       items:
         - Never invent method, style, or cmap strings — use jplot cap.
+        - 'Write scalar-only leaf lists/maps in compact flow style: xlim: [0.1, 5.0] and labels: {x: $x$, y: $y$}; keep complex parent structures expanded.'
         - Bare path renders: jplot plot.yaml (there is no jplot run).
         - Optional tools: suggest, config set/expand — not the main author path.
         - Need layers control: jplot config expand plot.yaml --figure NAME --write
@@ -72,7 +73,7 @@ agent:
   body_markdown: |
     ## Full agent playbook
     1. **Discover** — `data describe` + `cap` subsets.
-    2. **Author** — edit `*.yaml` in the workspace (type macros preferred).
+    2. **Author** — edit `*.yaml` in the workspace (type macros preferred); write scalar-only leaf lists/maps in compact flow style, e.g. `xlim: [0.1, 5.0]` and `labels: {x: $x$, y: $y$}`.
     3. **Judge (light only)** — `validate` / `doctor --json`. No heavy re-run; partial on type: is OK.
     4. **Execute once** — `jplot <file>` for PNG/PDF + agent_output digest.
     5. **Learn** — `explain JP-*` or `man diagnostics`; figure content from digest, not doctor mesh.

{jarvisplot-2.0.1 → jarvisplot-2.0.3}/jarvisplot/templates_catalog.py

@@ -7,6 +7,8 @@ from __future__ import annotations
 from copy import deepcopy
 from typing import Any
 
+from .yaml_io import dump_yaml_doc
+
 __all__ = [
     "TEMPLATE_KINDS",
     "get_template",
@@ -42,20 +44,13 @@ def get_template(kind: str) -> dict[str, Any]:
 
 def render_template_yaml(kind: str, *, values: dict[str, Any] | None = None) -> str:
     """Fill slot defaults with ``values`` and return YAML text."""
-    import yaml
-
     spec = get_template(kind)
     slots = {s["name"]: s.get("default") for s in spec.get("slots") or []}
     if values:
         slots.update({k: v for k, v in values.items() if v is not None})
     body = deepcopy(spec["skeleton"])
     _apply_slots(body, slots)
-    return yaml.safe_dump(
-        body,
-        sort_keys=False,
-        allow_unicode=True,
-        default_flow_style=False,
-    )
+    return dump_yaml_doc(body, meta={"engine": "pyyaml"})
 
 
 def _apply_slots(node: Any, slots: dict[str, Any]) -> None: