jarvisplot 2.1.8__tar.gz → 2.1.9__tar.gz

{jarvisplot-2.1.8 → jarvisplot-2.1.9}/JarvisPLOT.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: JarvisPLOT
-Version: 2.1.8
+Version: 2.1.9
 Summary: Jarvis-PLOT: YAML-driven plotting engine
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -350,3 +350,5 @@ Read the context docs and roadmap before changing parsing, transforms, rendering
 ## License
 
 MIT License
+
+Create a continuous forest figure with `type: forest`, a generic row table and optional point table. The default Swiss-column card uses 82.5 mm width and 5.5 mm row pitch; every row shares one numerical x domain. See [the forest contract](docs/specs/FOREST.md), [native examples](Example/forest/README.md), or `jplot man forest --json`.

{jarvisplot-2.1.8 → jarvisplot-2.1.9}/JarvisPLOT.egg-info/SOURCES.txt

@@ -36,6 +36,8 @@ jarvisplot/dryrun_runtime.py
 jarvisplot/expr_names.py
 jarvisplot/fix_apply.py
 jarvisplot/flowchart.py
+jarvisplot/forest_contract.py
+jarvisplot/forest_text.py
 jarvisplot/generated_data.py
 jarvisplot/inner_func.py
 jarvisplot/legend_cards.py
@@ -73,6 +75,9 @@ jarvisplot/Figure/distribution_1d_runtime.py
 jarvisplot/Figure/dynesty_runtime.py
 jarvisplot/Figure/figure.py
 jarvisplot/Figure/figure_types.py
+jarvisplot/Figure/forest_debug.py
+jarvisplot/Figure/forest_legend.py
+jarvisplot/Figure/forest_runtime.py
 jarvisplot/Figure/helper.py
 jarvisplot/Figure/interp_2d_runtime.py
 jarvisplot/Figure/interp_natural_neighbor.py
@@ -110,6 +115,7 @@ jarvisplot/cards/corrplot/diamond.json
 jarvisplot/cards/corrplot/matrix.json
 jarvisplot/cards/default/output.json
 jarvisplot/cards/flowchart/default.json
+jarvisplot/cards/forest/swiss_column.json
 jarvisplot/cards/gambit/1x1/ternary.json
 jarvisplot/cards/gambit/2x1/rect_cmap.json
 jarvisplot/cards/gambit/2x1/ternary.json
@@ -142,6 +148,7 @@ jarvisplot/manual_cards/manifest.yaml
 jarvisplot/manual_cards/method_notes.yaml
 jarvisplot/manual_cards/style-axes.yaml
 jarvisplot/manual_cards/type-correlation-matrix.yaml
+jarvisplot/manual_cards/type-forest.yaml
 jarvisplot/manual_cards/type-posterior-2d.yaml
 jarvisplot/manual_cards/type-profile-2d.yaml
 jarvisplot/manual_cards/validate.yaml
@@ -188,6 +195,7 @@ jarvisplot/schema/methods/tripcolor_axes.json
 jarvisplot/schema/methods/triplot.json
 jarvisplot/schema/methods/voronoi.json
 jarvisplot/schema/methods/voronoif.json
+jarvisplot/schema/types/forest.json
 jarvisplot/utils/__init__.py
 jarvisplot/utils/cmaps.py
 jarvisplot/utils/dataframes.py
@@ -246,6 +254,7 @@ tests/test_figure_contracts.py
 tests/test_figure_type_expander.py
 tests/test_fix_application.py
 tests/test_flowchart_renderer.py
+tests/test_forest.py
 tests/test_generated_data.py
 tests/test_imshow_adapter.py
 tests/test_interp_2d_transform.py

{jarvisplot-2.1.8 → jarvisplot-2.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: JarvisPLOT
-Version: 2.1.8
+Version: 2.1.9
 Summary: Jarvis-PLOT: YAML-driven plotting engine
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -350,3 +350,5 @@ Read the context docs and roadmap before changing parsing, transforms, rendering
 ## License
 
 MIT License
+
+Create a continuous forest figure with `type: forest`, a generic row table and optional point table. The default Swiss-column card uses 82.5 mm width and 5.5 mm row pitch; every row shares one numerical x domain. See [the forest contract](docs/specs/FOREST.md), [native examples](Example/forest/README.md), or `jplot man forest --json`.

{jarvisplot-2.1.8 → jarvisplot-2.1.9}/README.md

@@ -328,3 +328,5 @@ Read the context docs and roadmap before changing parsing, transforms, rendering
 ## License
 
 MIT License
+
+Create a continuous forest figure with `type: forest`, a generic row table and optional point table. The default Swiss-column card uses 82.5 mm width and 5.5 mm row pitch; every row shares one numerical x domain. See [the forest contract](docs/specs/FOREST.md), [native examples](Example/forest/README.md), or `jplot man forest --json`.

{jarvisplot-2.1.8 → jarvisplot-2.1.9}/jarvisplot/Figure/debug_config.py

@@ -71,6 +71,13 @@ _LABEL_FONT = {
 
 
 DEFAULT_DEBUG = {
+    "forest_grid": {
+        "show": True,
+        "columns": {"show": True, "plot": {"color": "#DA291C", "linewidth": 0.3, "linestyle": ":", "alpha": 0.7}},
+        "baselines": {"show": True, "plot": {"color": "#DA291C", "linewidth": 0.2, "linestyle": "--", "alpha": 0.5}},
+        "bands": {"show": True, "Rectangle": {"edgecolor": "#DA291C", "linewidth": 0.25, "fill": False, "alpha": 0.5}},
+        "labels": {"show": True, "text": {"color": "#DA291C", "fontsize": 4, "ha": "left", "va": "top"}},
+    },
     # Which axes gets fully dimensioned and hosts the info panel. First match wins.
     "primary_order": ["ax", "ax0", "ax1", "axtri"],
     "units": {"cm_per_inch": 2.54, "pt_per_inch": 72.0},

{jarvisplot-2.1.8 → jarvisplot-2.1.9}/jarvisplot/Figure/design_runtime.py

@@ -185,6 +185,10 @@ def draw_design_reference(fig) -> None:
 
 
 def _draw(fig) -> None:
+    if hasattr(fig, 'forest_layout'):
+        from .forest_debug import draw_forest_reference
+        draw_forest_reference(fig, _debug_config(fig)['forest_grid'])
+        return
     F = fig.fig
     w_in, h_in = (float(v) for v in F.get_size_inches())
     debug = _debug_config(fig)

{jarvisplot-2.1.8 → jarvisplot-2.1.9}/jarvisplot/Figure/figure_types.py

@@ -752,7 +752,8 @@ def expand_correlation_matrix(info: Mapping[str, Any]) -> dict[str, Any]:
 
 # Types that expand_figure_type can lower to layers. Keep in sync with
 # expand_figure_type dispatch and capabilities.figure_types.
-KNOWN_FIGURE_TYPES = frozenset({"posterior_2d", "profile_2d", "correlation_matrix"})
+NATIVE_FIGURE_TYPES = frozenset({"forest"})
+KNOWN_FIGURE_TYPES = frozenset({"posterior_2d", "profile_2d", "correlation_matrix"}) | NATIVE_FIGURE_TYPES
 
 
 def expand_figure_type(info: Any) -> Any:
@@ -849,6 +850,7 @@ def expand_typed_figures(
             raise KeyError(f"figure(s) not found: {', '.join(missing)}")
 
     expanded_names: list[str] = []
+    native_found = False
     for index, fig in enumerate(figures):
         if not isinstance(fig, Mapping):
             continue
@@ -876,6 +878,12 @@ def expand_typed_figures(
             _note(logger, msg)
             continue
 
+        if fig_type in NATIVE_FIGURE_TYPES:
+            # Native table-driven formats keep their public contract. Their
+            # physical solve is inspectable, not a list of hand-authored layers.
+            native_found = True
+            continue
+
         try:
             out = expand_figure_type(fig)
         except Exception as exc:
@@ -897,6 +905,7 @@ def expand_typed_figures(
 
     if (
         not expanded_names
+        and not native_found
         and not allow_noop
         and raise_on_error
         and wanted is not None

jarvisplot-2.1.9/jarvisplot/Figure/forest_debug.py

@@ -0,0 +1,35 @@
+"""Read-only Swiss grid and physical band references on a separate overlay."""
+from matplotlib.patches import Rectangle
+from ..forest_text import font_properties
+
+
+def draw_forest_reference(fig, cfg):
+    if not cfg['show'] or any(ax.get_label() == 'forest-design-reference' for ax in fig.fig.axes):
+        return
+    scene = fig.forest_layout
+    g = scene['geometry']
+    ax = fig.fig.add_axes([0, 0, 1, 1], label='forest-design-reference', zorder=10000)
+    ax.set(xlim=(0, scene['width_mm']), ylim=(scene['height_mm'], 0)); ax.axis('off')
+    ax.patch.set_alpha(0)
+    if cfg['columns']['show']:
+        for index, x in enumerate(g['grid_lines_mm']):
+            line, = ax.plot([x]*2, [0, scene['height_mm']], **cfg['columns']['plot'])
+            line.set_gid(f'forest-grid-{index:02d}')
+    if cfg['labels']['show']:
+        opts = dict(cfg['labels']['text'])
+        size = opts.pop('fontsize')
+        for index, x in enumerate(g['grid_lines_mm'][:-1]):
+            ax.text(x, g['top_axis_y_mm']+.35, f'{index+1:02d}', fontproperties=font_properties(size, scene['typography']['family']), **opts)
+    if cfg['baselines']['show']:
+        ys = [g[key] for key in ('meta_y_mm','title_y_mm','description_y_mm','x_label_y_mm','column_header_y_mm','top_tick_y_mm')]
+        ys += [r['top_mm']+g[key] for r in scene['rows'] for key in ('cell_y_mm','plot_y_mm')]
+        for index, y in enumerate(ys):
+            line, = ax.plot([g['plot_left_mm'], g['plot_right_mm']], [y]*2, **cfg['baselines']['plot'])
+            line.set_gid(f'forest-baseline-{index:03d}')
+    if cfg['bands']['show']:
+        for index, row in enumerate(scene['rows']):
+            for name, y, height in (('text', row['top_mm'], g['plot_y_mm']-g['point_band_mm']/2),
+                                    ('marks', row['top_mm']+g['plot_y_mm']-g['point_band_mm']/2, g['point_band_mm'])):
+                box = Rectangle((g['plot_left_mm'], y), scene['plot_width_mm'], height, **cfg['bands']['Rectangle'])
+                box.set_gid(f'forest-band-{name}-{index:03d}')
+                ax.add_patch(box)

jarvisplot-2.1.9/jarvisplot/Figure/forest_legend.py

@@ -0,0 +1,88 @@
+"""A native legend handler for the actual forest glyph artist container."""
+from matplotlib.container import Container
+from matplotlib.legend_handler import HandlerBase, HandlerPathCollection
+from matplotlib.lines import Line2D
+from matplotlib.patches import Rectangle
+from matplotlib.offsetbox import VPacker
+
+
+class PhysicalLegendColumn(VPacker):
+    """Recompute physical column width for each raster/vector renderer."""
+    def __init__(self, width_mm, **kwargs):
+        super().__init__(**kwargs)
+        self.width_pt = width_mm*72/25.4
+
+    def _get_bbox_and_child_offsets(self, renderer):
+        self.width = self.width_pt*renderer.points_to_pixels(1)
+        return super()._get_bbox_and_child_offsets(renderer)
+
+
+class ForestGlyph(Container):
+    def __init__(self, artists, *, glyph):
+        super().__init__(artists)
+        self.glyph = glyph
+
+
+class HandlerForestPoint(HandlerPathCollection):
+    """Place one point at the left of its compact native key."""
+    def __init__(self, key_width_pt):
+        super().__init__(numpoints=1)
+        self.key_width_pt = key_width_pt
+
+    def get_xdata(self, legend, xdescent, ydescent, width, height, fontsize):
+        x = -xdescent+self.key_width_pt/2
+        return [x, x], [x]
+
+
+def group_glyph_and_points(legend, config, layers, glyph_object, *, base_dir=None):
+    """Use the canonical native items, with glyphs left and point classes right.
+
+    Matplotlib normally balances item counts across columns, which would place
+    some point classes beside the box sample. Repack its existing item boxes
+    without recreating handles, labels, or their handlers.
+    """
+    from matplotlib.offsetbox import DrawingArea
+    from ..legend_cards import resolve_axes_legend
+    kwargs, entries = resolve_axes_legend(config, layers, base_dir=base_dir)
+    if kwargs.get('ncols', kwargs.get('ncol', 1)) != 2:
+        return
+    legend._ncols = 2
+    if kwargs.get('reverse', False):
+        entries = list(reversed(entries))
+    objects = {id(text): entry['object'] for text, entry in zip(legend.get_texts(), entries)}
+    columns = legend._legend_handle_box.get_children()
+    groups = [[], []]
+    for column in columns:
+        for item in column.get_children():
+            label = item.get_children()[-1]._text
+            groups[0 if objects[id(label)] == glyph_object else 1].append(item)
+    # Preserve the empty semantic column when only one group is present.
+    legend._legend_handle_box._children = [
+        VPacker(pad=0, sep=legend.labelspacing*legend._fontsize,
+                align='left', children=items or [DrawingArea(0, 0)])
+        for items in groups
+    ]
+    legend._legend_handle_box.align = 'top'
+
+
+class HandlerForestGlyph(HandlerBase):
+    def create_artists(self, legend, orig_handle, xdescent, ydescent, width, height, fontsize, trans):
+        whisker = orig_handle[0]
+        left, right = -xdescent, width-xdescent
+        yc = (height-ydescent)/2
+        half = height*.32
+        stroke = {'color': whisker.get_color(), 'linewidth': whisker.get_linewidth(), 'transform': trans}
+        artists = [Line2D([left, right], [yc, yc], **stroke)]
+        for xx in (left, right):
+            artists.append(Line2D([xx, xx], [yc-half, yc+half], **stroke))
+        if orig_handle.glyph == 'box':
+            box, median = orig_handle[1:]
+            artists.append(Rectangle((left+width*.25, yc-half), width*.5, half*2,
+                                     facecolor=box.get_facecolor(), edgecolor=box.get_edgecolor(),
+                                     linewidth=box.get_linewidth(), alpha=box.get_alpha(), transform=trans))
+            artists.append(Line2D([(left+right)/2]*2, [yc-half, yc+half], color=median.get_color(), linewidth=median.get_linewidth(), transform=trans))
+        else:
+            point = orig_handle[1]
+            artists.append(Line2D([(left+right)/2], [yc], linestyle='', marker=point.get_marker(), color=point.get_color(),
+                                  markersize=point.get_markersize(), markeredgewidth=point.get_markeredgewidth(), transform=trans))
+        return artists

jarvisplot-2.1.9/jarvisplot/Figure/forest_runtime.py

@@ -0,0 +1,294 @@
+"""Native physical forest renderer on one continuous canvas."""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from .figure import Figure
+from ..forest_contract import solve_forest, x_to_mm, MM_PER_PT
+
+
+class ForestFigure(Figure):
+    def from_dict(self, info):
+        self.name = info['name']
+        if info.get('enable', True) is False:
+            self._setup_status = 'disabled'
+            return False
+        from ..schema_catalog import config_validator
+        errors = list(config_validator().iter_errors({'DataSet': [], 'Figures': [info]}))
+        if errors:
+            raise ValueError(f'figure {self.name!r}: {errors[0].message}')
+        self.info = info
+        self.style = info.get('style', ['forest', 'swiss_column'])
+        self.debug = info.get('debug', False)
+        sources = [info['data'], *([info['points']] if info.get('points') else [])]
+        frames = {name: self.context.get(name) for name in sources}
+        self.forest_layout = solve_forest(info, frames)
+        for source in sources:
+            self.context.consume(source)
+        g = self.forest_layout
+        from ..forest_contract import merge
+        logo = self._frame.get('axlogo', {})
+        logo_override = info.get('frame', {}).get('axlogo', True)
+        if isinstance(logo_override, dict):
+            logo = merge(logo, logo_override)
+        self._frame = {'figure': {'figsize': [g['width_mm']/25.4, g['height_mm']/25.4]},
+                       'axes': {'ax': {'rect': [0, 0, 1, 1]}}}
+        if logo_override is not False and not self.print:
+            self._frame['axlogo'] = logo
+            size = g['geometry']['logo_size_mm']
+            self._frame['axes']['axlogo'] = {'rect': [g['geometry']['margin_left_mm']/g['width_mm'], g['geometry']['logo_bottom_mm']/g['height_mm'], g['geometry']['grid_unit_mm']/g['width_mm'], size/g['height_mm']], 'frameon': False, 'xticks': [], 'yticks': []}
+        import matplotlib.pyplot as plt
+        self.fig = plt.figure(figsize=self._frame['figure']['figsize'], dpi=self.dpi, facecolor=g['style']['rows']['background'])
+        self.fig.set_size_inches(*self._frame['figure']['figsize'], forward=False)
+        ax = self.fig.add_axes([0, 0, 1, 1])
+        ax.set(xlim=(0, g['width_mm']), ylim=(g['height_mm'], 0))
+        ax.axis('off')
+        self.axes = {'ax': ax}
+        if 'axlogo' in self._frame['axes']:
+            self.axlogo = self._frame['axes']['axlogo']
+            from ..forest_text import font_properties
+            for artist in self.axlogo.texts:
+                artist.set_fontproperties(font_properties(artist.get_fontsize(), artist.get_fontfamily()[0], artist.get_fontweight()))
+                artist.set_parse_math(False)
+        self.forest_layout['canvas_axes'] = len(self.axes)
+        self._setup_status = 'ok'
+        return True
+
+    def render(self):
+        import matplotlib as mpl
+        # Unhinted glyphs agree with physical font measurements and avoid
+        # native-hinting failures for small Helvetica ticks at low DPI.
+        with mpl.rc_context({'text.hinting': 'none'}):
+            self._render()
+
+    def _render(self):
+        from matplotlib.patches import Rectangle
+        from .legend_runtime import apply_legend
+        from .forest_legend import ForestGlyph, HandlerForestGlyph, HandlerForestPoint, PhysicalLegendColumn, group_glyph_and_points
+        from matplotlib.collections import PathCollection
+        info, layout, ax = self.info, self.forest_layout, self.axes['ax']
+        g, fonts, style = layout['geometry'], layout['typography'], layout['style']
+        width, height = layout['width_mm'], layout['height_mm']
+        domain, ticks = layout['shared_domain'], layout['shared_ticks']
+        to_x = lambda value: x_to_mm(value, domain, g)
+        checks = []
+        annotations = []
+        from ..forest_text import font_properties, wrap_text
+
+        def text(x, y, value, size, *, slot=None, row=None, **kwargs):
+            if not value:
+                return None
+            weight = kwargs.pop('fontweight', 'normal')
+            kwargs.setdefault('ha', 'left')
+            artist = ax.text(x, y, value, fontproperties=font_properties(size, fonts['family'], weight), va='center', parse_math=False, **kwargs)
+            checks.append((artist, slot, row))
+            return artist
+
+        title = info.get('title', {})
+        origin = g['margin_left_mm']
+        title_size = title.get('fontsize', fonts['title_pt'])
+        title_weight = title.get('fontweight', 'bold')
+        title_right = origin+g['title_columns']*g['grid_unit_mm']
+        for i, line in enumerate(wrap_text(title.get('text', ''), title_size, fonts['family'], title_weight, title_right-origin)):
+            text(origin, g['title_y_mm']+i*g['title_line_pitch_mm'], line, title_size, fontweight=title_weight, color=title.get('color', style['rows']['text_color']), slot=(origin, title_right, g['meta_y_mm']+1, g['x_label_y_mm']-1.5))
+        meta = info.get('meta', {})
+        for key, column in (('number', 0), ('year', 9), ('place', 10)):
+            text(g['grid_lines_mm'][column], g['meta_y_mm'], meta.get(key, ''), fonts['meta_pt'], color=style['rows']['accent'] if key == 'number' else style['rows']['text_color'], slot=(g['grid_lines_mm'][column], g['grid_lines_mm'][10 if key=='year' else 12], 0, g['title_y_mm']-1.5))
+        xlabel = info.get('x', {}).get('label', '')
+        text(origin, g['x_label_y_mm'], xlabel, fonts['header_pt'], slot=(origin, g['plot_right_mm'], g['x_label_y_mm']-1.5, g['column_header_y_mm']-1.5))
+        handles = {}
+        class_index = {layer['legend']['object']: i for i, layer in enumerate(layout['legend_layers'])}
+        def cell_x(column):
+            return column['left_mm'] + (column['width_mm']-column['text_right_padding_mm'] if column['align']=='right' else column['text_left_padding_mm'])
+        for column in layout['columns']:
+            text(cell_x(column), g['column_header_y_mm'], column['label'], fonts['header_pt'], fontweight='bold', ha=column['align'], slot=(column['left_mm'], column['left_mm']+column['width_mm'], g['column_header_y_mm']-1.5, g['top_tick_y_mm']-1))
+        tick_artists = []
+        def tick_labels(y):
+            for value in ticks:
+                # Numerical annotations follow the exact tick coordinate, just
+                # like the data marks; the modular grid governs layout edges.
+                artist = text(to_x(value), y, f"{value:g}{style['axis']['tick_suffix']}", fonts['tick_pt'], ha=style['axis']['tick_align'], color=style['rows']['secondary_color'], slot=(0, width, y-1, y+1))
+                tick_artists.append(artist)
+        tick_labels(g['top_tick_y_mm'])
+        base = g['header_mm']+layout['row_count']*g['row_pitch_mm']
+        axis = style['axis']
+        line, = ax.plot([g['plot_left_mm'],g['plot_right_mm']], [g['top_axis_y_mm']]*2, color=axis['color'], linewidth=axis['linewidth_pt'])
+        line.set_gid('forest-top-axis')
+        grid = style['grid']
+        grid_values = sorted(set(ticks + [domain[0]+i*(domain[1]-domain[0])/grid['divisions'] for i in range(grid['divisions']+1)]))
+        for index, value in enumerate(grid_values):
+            ax.plot([to_x(value)]*2, [g['top_axis_y_mm']-.5,g['top_axis_y_mm']], color=axis['color'], linewidth=axis['linewidth_pt'])
+            if grid['show']:
+                line, = ax.plot([to_x(value)]*2, [g['top_axis_y_mm'],base], color=grid['color'], linewidth=grid['linewidth_pt'], alpha=grid['alpha'], linestyle=grid['linestyle'], zorder=1)
+                line.set_gid(f'forest-numerical-grid-{index:02d}')
+        if 'reference' in info.get('x', {}):
+            ref = style['reference']
+            line, = ax.plot([to_x(info['x']['reference'])]*2, [g['top_axis_y_mm'],base], color=ref['color'], linewidth=ref['linewidth_pt'], linestyle=ref['linestyle'], zorder=2)
+            line.set_gid('forest-reference')
+        for index, row in enumerate(layout['rows']):
+            top = row['top_mm']
+            rows = style['rows']
+            row_fill = rows['fills'][index % len(rows['fills'])]
+            from matplotlib.colors import to_rgba
+            if to_rgba(row_fill)[3]:
+                ax.add_patch(Rectangle((0, top), width, g['row_band_mm'], facecolor=row_fill, edgecolor='none', zorder=0))
+            if rows['separators']:
+                line, = ax.plot([origin, g['plot_right_mm']], [top+g['row_band_mm']]*2, color=rows['separator_color'], linewidth=rows['separator_linewidth_pt'])
+                line.set_gid(f'forest-row-separator-{index:03d}')
+            trio = [text(cell_x(column), top+g['cell_y_mm'], value, column['fontsize'],
+                         slot=(column['left_mm'], column['left_mm']+column['width_mm'], top, top+g['plot_y_mm']-g['point_band_mm']/2), row=row['row'],
+                         fontweight=column['fontweight'], ha=column['align'], color=rows['text_color'] if column['role'] != 'left' else rows['secondary_color'],
+                         bbox={'facecolor':row_fill if to_rgba(row_fill)[3] else rows['background'], 'edgecolor':'none', 'boxstyle':'square,pad=0.04'})
+                    for column, value in zip(layout['columns'], row['cells'])]
+            annotations.append((row['row'], [a for a in trio if a is not None]))
+            yc = top+g['plot_y_mm']
+            c = row['coordinates']
+            if c['lower'] is not None:
+                s = style['interval']
+                whisker, = ax.plot([to_x(c['lower']), to_x(c['upper'])], [yc]*2, color=s['color'], linewidth=s['linewidth_pt'], zorder=3)
+                for value in (c['lower'], c['upper']):
+                    ax.plot([to_x(value)]*2, [yc-s['cap_height_mm']/2, yc+s['cap_height_mm']/2], color=s['color'], linewidth=s['linewidth_pt'], zorder=3)
+                if info.get('glyph', 'interval') == 'box':
+                    b = style['box']
+                    box = Rectangle((to_x(c['q1']), yc-b['height_mm']/2), to_x(c['q3'])-to_x(c['q1']), b['height_mm'], facecolor=b['facecolor'], edgecolor=b['edgecolor'], alpha=b['alpha'], linewidth=b['linewidth_pt'], zorder=3)
+                    ax.add_patch(box)
+                    median, = ax.plot([to_x(c['median'])]*2, [yc-b['height_mm']/2, yc+b['height_mm']/2], color=b['median_color'], linewidth=b['linewidth_pt'], zorder=4)
+                    glyph = ForestGlyph((whisker, box, median), glyph='box')
+                    extent = b['height_mm']/2+b['linewidth_pt']*MM_PER_PT/2
+                else:
+                    point, = ax.plot([to_x(c['estimate'])], [yc], linestyle='', marker=s['marker'], color=s['color'], markersize=s['diameter_mm']/MM_PER_PT, markeredgewidth=s['linewidth_pt'], zorder=4)
+                    glyph = ForestGlyph((whisker, point), glyph='interval')
+                    extent = (s['diameter_mm']+s['linewidth_pt']*MM_PER_PT)/2
+                extent = max(extent, (s['cap_height_mm']+s['linewidth_pt']*MM_PER_PT)/2)
+                if extent > g['point_band_mm']/2:
+                    raise ValueError(f"row {row['row']!r}: glyph exceeds reserved plot band; increase forest.geometry.point_band_mm and row band/pitch")
+                handles.setdefault(f"@layer:{class_index[layout['glyph_object']]}", glyph)
+            for p in row['points']:
+                s = p['style']
+                colors = {'color': s['color']} if s['marker'] == 'x' else {'facecolors': s['color'] if s['fill'] else 'none', 'edgecolors': s.get('edgecolor', s['color'])}
+                mark = ax.scatter([p['x_mm']], [yc+p['offset_mm']], marker=s['marker'], s=(s['diameter_mm']/MM_PER_PT)**2, **colors, linewidths=s['linewidth_pt'], zorder=5)
+                handles.setdefault(f"@layer:{class_index[p['class']]}", mark)
+        legend_config = dict(layout['legend']) if isinstance(layout['legend'], dict) else layout['legend']
+        base = g['header_mm']+layout['row_count']*g['row_pitch_mm']
+        description = info.get('description', {})
+        desc_origin = g['grid_lines_mm'][g['description_start_column']-1]
+        desc_right = desc_origin+g['description_columns']*g['grid_unit_mm']
+        desc_size, desc_weight = description.get('fontsize', fonts['footer_pt']), description.get('fontweight', 'normal')
+        description_artists = []
+        for i, line in enumerate(wrap_text(description.get('text', '').strip(), desc_size, fonts['family'], desc_weight, desc_right-desc_origin)):
+            description_artists.append(text(desc_origin, base+g['description_y_mm']+i*g['text_line_pitch_mm'], line, desc_size,
+                fontweight=desc_weight, color=description.get('color', style['rows']['secondary_color']),
+                slot=(desc_origin, desc_right, base+g['legend_y_mm'], height-1)))
+        grouped = isinstance(legend_config, dict) and legend_config.get('ncols') == 2
+        legend_origin = g['grid_lines_mm'][g['legend_start_columns'][0]-1] if grouped else origin
+        text(legend_origin, base+g['legend_heading_y_mm'], style['rows']['legend_heading'], fonts['meta_pt'], fontweight='bold', color=style['rows']['accent'], slot=(legend_origin, g['plot_right_mm'], base+3.5, base+g['legend_y_mm']-1))
+        if isinstance(legend_config, dict):
+            legend_config.setdefault('bbox_to_anchor', (legend_origin/width, 1-(base+g['legend_y_mm'])/height))
+            legend_config.setdefault('borderpad', 0)
+            legend_config['handlelength'] = g['grid_unit_mm']/MM_PER_PT/legend_config.get('fontsize', 5)-legend_config.get('handletextpad', .6)
+            legend_config['handler_map'] = {**legend_config.get('handler_map', {}), ForestGlyph: HandlerForestGlyph(), PathCollection: HandlerForestPoint(g['legend_point_key_mm']/MM_PER_PT)}
+        legend = apply_legend(ax, legend_config, handles, layer_specs=layout['legend_layers'], base_dir=self._yaml_dir)
+        if legend:
+            group_glyph_and_points(legend, legend_config, layout['legend_layers'], layout['glyph_object'], base_dir=self._yaml_dir)
+            for artist in legend.get_texts():
+                artist.set_fontproperties(font_properties(artist.get_fontsize(), fonts['family']))
+                artist.set_color(style['rows']['text_color'])
+                artist.set_ha('left')
+                artist.set_parse_math(False)
+            # Keep canonical items, with keys at declared reference columns.
+            # Labels start one reference column after their keys.
+            ncols = legend._ncols
+            if g['grid_columns'] % ncols:
+                raise ValueError('Swiss forest legend ncols must divide the 12-column grid')
+            legend._legend_handle_box.sep = 0
+            spans = ([g['legend_start_columns'][1]-g['legend_start_columns'][0],
+                      g['description_start_column']-g['legend_start_columns'][1]] if ncols == 2
+                     else [g['grid_columns']/ncols]*ncols)
+            physical_columns = []
+            for column, span in zip(legend._legend_handle_box.get_children(), spans):
+                column = PhysicalLegendColumn(span*g['grid_unit_mm'], pad=column.pad, sep=column.sep,
+                                              align='left', children=column.get_children())
+                physical_columns.append(column)
+                span_px = span*g['grid_unit_mm']/MM_PER_PT*self.fig.canvas.get_renderer().points_to_pixels(1)
+                for item in column.get_children():
+                    if item.get_children():
+                        key = item.get_children()[0]
+                        if any(isinstance(a, PathCollection) for a in key.get_children()):
+                            key.width = g['legend_point_key_mm']/MM_PER_PT
+                    if ncols == 2 and item.get_children():
+                        label = item.get_children()[-1]._text
+                        key_and_gap = (key.width+item.sep)*MM_PER_PT
+                        label.set_text('\n'.join(wrap_text(label.get_text(), label.get_fontsize(), fonts['family'], 'normal', span*g['grid_unit_mm']-key_and_gap)))
+                    if item.get_bbox(self.fig.canvas.get_renderer()).width > span_px:
+                        raise ValueError(f'Swiss forest legend item exceeds its modular span; reduce frame.ax.legend.ncols ({ncols}) or fontsize, or shorten labels')
+            legend._legend_handle_box._children = physical_columns
+            checks.append((legend, (0, width, base+3.5, height-1), None))
+        tick_labels(base+2)
+        if 'axlogo' in self.axes:
+            for artist in self.axlogo.get_children():
+                from matplotlib.text import Text
+                if isinstance(artist, Text) and artist.get_text():
+                    checks.append((artist, (0, width, height-g['logo_bottom_mm']-g['logo_size_mm']-1, height), None))
+        self.fig.canvas.draw()
+        renderer = self.fig.canvas.get_renderer()
+        def mm_bounds(artist):
+            b = artist.get_window_extent(renderer)
+            # Text's window bbox reserves the font's unused ascender/descender
+            # space (e.g. 'lp' even for B001). Measure actual literal glyph ink
+            # against the physical slot; do not shrink type to that padding.
+            from matplotlib.text import Text
+            if isinstance(artist, Text):
+                from matplotlib.textpath import TextToPath
+                from matplotlib.path import Path as MplPath
+                from matplotlib.transforms import Bbox
+                anchor = artist.get_transform().transform(artist.get_position())
+                _, lines, _ = artist._get_layout(renderer)
+                bounds = []
+                for line in lines:
+                    label = line[0]
+                    ox, oy = line[2] if len(line) == 3 else line[2:4]
+                    vertices, codes = TextToPath().get_text_path(artist.get_fontproperties(), label, ismath=False)
+                    if vertices:
+                        ink = MplPath(vertices, codes).get_extents()
+                        scale = artist.get_fontsize()/100*self.fig.dpi/72
+                        bounds.append(Bbox.from_extents(anchor[0]+ox+ink.x0*scale, anchor[1]+oy+ink.y0*scale,
+                                                       anchor[0]+ox+ink.x1*scale, anchor[1]+oy+ink.y1*scale))
+                if bounds:
+                    b = Bbox.union(bounds)
+            return (b.x0/self.fig.dpi*25.4, b.x1/self.fig.dpi*25.4,
+                    height-b.y1/self.fig.dpi*25.4, height-b.y0/self.fig.dpi*25.4)
+        for artist, slot, row in checks:
+            bounds = mm_bounds(artist)
+            tolerance = max(0.02, 25.4/self.fig.dpi/2)  # half a raster pixel for font hinting
+            if slot and (bounds[0] < slot[0]-tolerance or bounds[1] > slot[1]+tolerance or bounds[2] < slot[2]-tolerance or bounds[3] > slot[3]+tolerance):
+                label = artist.get_text() if hasattr(artist, 'get_text') else 'legend'
+                raise ValueError(f"figure {self.name!r}, row {row!r}: text/layout overflow for {label!r}; measured mm {bounds}, slot {slot}. Adjust annotation/typography/geometry or frame.ax.legend.")
+        if legend:
+            from matplotlib.transforms import Bbox
+            def physical_box(artist):
+                b = mm_bounds(artist)
+                return Bbox.from_extents(b[0], b[2], b[1], b[3])
+            badge_boxes = ([physical_box(a) for a in [*self.axlogo.images, *self.axlogo.texts]] if 'axlogo' in self.axes else [])
+            description_boxes = [physical_box(a) for a in description_artists]
+            for column in legend._legend_handle_box.get_children():
+                for item in column.get_children():
+                    if any(physical_box(item).overlaps(b) for b in badge_boxes):
+                        raise ValueError('forest footer legend overlaps axlogo; adjust forest.geometry footer/legend/logo positions or frame.ax.legend layout')
+                    if any(physical_box(item).overlaps(b) for b in description_boxes):
+                        raise ValueError('forest footer legend overlaps description; adjust forest.geometry column starts or frame.ax.legend layout')
+        for row, artists in annotations:
+            from matplotlib.transforms import Bbox
+            bounds = [mm_bounds(a) for a in artists]
+            boxes = [Bbox.from_extents(b[0], b[2], b[1], b[3]) for b in bounds]
+            for i, b in enumerate(boxes):
+                if any(b.overlaps(other) for other in boxes[i+1:]):
+                    raise ValueError(f'row {row!r}: annotation slots collide; enlarge forest.geometry slots or change literal annotations')
+        layout['verification'] = {'text_and_legend_bounds': 'passed', 'all_points_once': True, 'packing': 'deterministic_physical_mm', 'numeric_x_preserved': True, 'tick_label_count': len(tick_artists)}
+
+    def savefig(self):
+        import matplotlib as mpl
+        with mpl.rc_context({'svg.fonttype': 'none', 'text.hinting': 'none'}):
+            super().savefig()
+        path = Path(self.dir) / f'{self.name}.layout.json'
+        path.write_text(json.dumps(self.forest_layout, ensure_ascii=False, indent=2)+'\n', encoding='utf-8')

{jarvisplot-2.1.8 → jarvisplot-2.1.9}/jarvisplot/Figure/legend_runtime.py

@@ -41,12 +41,12 @@ class HandlerStack(HandlerBase):
         return artists
 
 
-def representative_handle(rendered):
+def representative_handle(rendered, handler_map=None):
     """Require one supported artist/container; multiple series are ambiguous."""
     from matplotlib.artist import Artist
     from matplotlib.container import Container
 
-    handler_map = Legend.get_default_handler_map()
+    handler_map = {**Legend.get_default_handler_map(), **(handler_map or {})}
     def collect(value):
         if isinstance(value, (Artist, Container)):
             return [value] if Legend.get_legend_handler(handler_map, value) is not None else []
@@ -74,7 +74,7 @@ def apply_legend(ax, config, layer_handles=None, *, base_dir=None, layer_specs=N
         for name in names:
             if name not in layer_handles:
                 raise ValueError(f"Legend object {entry['object']!r} is missing its rendered component {name!r}")
-            handle = representative_handle(layer_handles[name])
+            handle = representative_handle(layer_handles[name], kw.get('handler_map'))
             if handle is None:
                 raise ValueError(f"Legend object {entry['object']!r} component {name!r} has no supported legend handle")
             parts.append(handle)

{jarvisplot-2.1.8 → jarvisplot-2.1.9}/jarvisplot/capabilities.py

@@ -200,6 +200,13 @@ def _types() -> list[dict[str, Any]]:
                 else f"jplot explain {name}"
             ),
         }
+        if name == 'forest':
+            from .forest_contract import ROW_FIELDS, POINT_FIELDS
+            entry.update(expands_to='native', styles=[['forest', 'swiss_column']], axes=['ax', 'axlogo'],
+                         required=['data'], optional=['points', 'glyph', 'x', 'title', 'description', 'columns', 'glyph_label', 'fields', 'point_fields', 'annotations', 'forest', 'frame', 'debug'],
+                         glyphs=['interval', 'box'], default_glyph='interval', row_fields=list(ROW_FIELDS), point_fields=list(POINT_FIELDS),
+                         geometry='physical_mm', x_scale='shared', tick_labels='top_and_bottom',
+                         schema='https://jarvis-plot.org/schema/v2/types/forest.json', man='jplot man forest')
         if name == "correlation_matrix":
             matching = [
                 item