tesorotools-python 0.0.46__py3-none-any.whl → 0.0.48__py3-none-any.whl

tesorotools/__init__.py

@@ -54,6 +54,7 @@ from tesorotools.artists import (
     StackedBarPlot,
     TypeCurve,
     VectorPlot,
+    Waterfall,
 )
 from tesorotools.orchestration import CompositeRegistry, iter_contexts
 from tesorotools.providers.base import (
@@ -83,6 +84,7 @@ def _register_builtins() -> None:
     register_artist("type_curve", TypeCurve)
     register_artist("vector_plot", VectorPlot)
     register_artist("matrix", MatrixChart)
+    register_artist("waterfall", Waterfall)
 
     register_tag("format", Format)
     register_tag("legend", Legend)
@@ -127,6 +129,7 @@ __all__ = [
     "Title",
     "TypeCurve",
     "VectorPlot",
+    "Waterfall",
     "YamlConstructor",
     "all_artists",
     "all_providers",

tesorotools/artists/__init__.py

@@ -1,7 +1,8 @@
 """Image artists.
 
-Five chart classes, one shared helpers module, one
-matplotlib stylesheet side effect on import.
+Five chart classes and one shared helpers module.  Importing
+``_common`` applies the house style (palette + fonts) as a side
+effect, so the cycle is active no matter which artist is imported.
 
 Each class follows the same shape:
 
@@ -24,8 +25,6 @@ live under :mod:`tesorotools.render`; this package is
 strictly image output.
 """
 
-import matplotlib.style
-
 from tesorotools.artists._common import Artist, Format, Legend
 from tesorotools.artists.barh_plot import GroupedBarChart, HorizontalBarChart
 from tesorotools.artists.line_plot import LinePlot
@@ -33,9 +32,7 @@ from tesorotools.artists.matrix import MatrixChart
 from tesorotools.artists.stacked import StackedAreaPlot, StackedBarPlot
 from tesorotools.artists.type_curve import TypeCurve
 from tesorotools.artists.vector_plot import VectorPlot
-from tesorotools.utils.globals import STYLE_SHEET
-
-matplotlib.style.use(STYLE_SHEET)
+from tesorotools.artists.waterfall import Waterfall
 
 __all__ = [
     "Artist",
@@ -49,4 +46,5 @@ __all__ = [
     "StackedBarPlot",
     "TypeCurve",
     "VectorPlot",
+    "Waterfall",
 ]

tesorotools/artists/_common.py

@@ -29,22 +29,62 @@ from typing import Any, Protocol, Self, cast, runtime_checkable
 import matplotlib.pyplot as plt
 import pandas as pd
 from matplotlib.axes import Axes
+from matplotlib.dates import AutoDateLocator, ConciseDateFormatter
+from matplotlib.dates import (
+    date2num,  # type: ignore[reportUnknownVariableType]
+)
+from matplotlib.dates import (
+    num2date,  # type: ignore[reportUnknownVariableType]
+)
 from matplotlib.figure import Figure
 from matplotlib.font_manager import FontProperties
-from matplotlib.ticker import FuncFormatter
+from matplotlib.legend import Legend as MplLegend
+from matplotlib.ticker import FixedLocator, FuncFormatter, MaxNLocator
 from yaml.nodes import MappingNode
 
 from tesorotools.utils.matplotlib import (
     PLOT_CONFIG,
+    apply_house_style,
     format_annotation,
-    load_fonts,
 )
 from tesorotools.utils.template import TemplateLoader
 
-load_fonts()
+# Apply the full house look (colour cycle + grid + tick sizes from the
+# stylesheet, then the bundled fonts) once, here at import: every image
+# artist imports this module, so the cycle is active no matter which
+# artist (or caller) triggers the import first.
+apply_house_style()
 
 AX_CONFIG: dict[str, Any] = PLOT_CONFIG["ax"]
 FIG_CONFIG: dict[str, Any] = PLOT_CONFIG["figure"]
+COMPACT_CONFIG: dict[str, Any] = PLOT_CONFIG.get("compact", {})
+SAVE_CONFIG: dict[str, Any] = PLOT_CONFIG.get("save", {})
+
+CM_TO_IN: float = 1.0 / 2.54
+
+
+def dynamic_dpi(fig: Figure) -> int:
+    """Save DPI adapted to the figure's physical size.
+
+    The figure DPI (``figure.dpi`` in ``plots.yaml``) drives *layout* and
+    is deliberately high; saving every PNG at it wastes memory on large
+    figures (a 16 cm chart at 500 dpi is ~3150 px wide).  Instead the save
+    DPI scales **inversely with size** so the long side lands near
+    ``save.target_px`` pixels: big figures save at fewer dpi (lighter
+    files), small ones at more.  It is clamped to ``[save.min_dpi,
+    figure.dpi]`` -- never below ``save.min_dpi`` (so the result is always
+    print-sharp, never pixelated) and never above the layout dpi (above
+    which extra pixels are pure waste).
+    """
+    target_px: float = float(SAVE_CONFIG.get("target_px", 2000))
+    min_dpi: float = float(SAVE_CONFIG.get("min_dpi", 300))
+    max_dpi: float = float(FIG_CONFIG.get("dpi", 500))
+    width_in, height_in = (float(v) for v in fig.get_size_inches())
+    long_in = max(width_in, height_in)
+    if long_in <= 0:  # pragma: no cover - defensive: a real figure
+        # never has a zero/negative side; guards against a 0/0 division.
+        return int(max_dpi)
+    return int(round(min(max_dpi, max(min_dpi, target_px / long_in))))
 
 
 # ----------------------------------------------------------------------
@@ -216,6 +256,11 @@ def auto_ncol(
     ax: Axes,
     labels: list[str],
     available_width_px: float | None = None,
+    *,
+    fontsize: float | None = None,
+    handlelength: float | None = None,
+    handletextpad: float | None = None,
+    columnspacing: float | None = None,
 ) -> int:
     """Choose the maximum legend ``ncol`` that fits the axes.
 
@@ -228,6 +273,12 @@ def auto_ncol(
     Pass ``available_width_px`` when the legend will live in
     ``fig.legend`` (figure-wide space) instead of
     ``ax.legend``; defaults to the axes width.
+
+    The keyword overrides (``fontsize`` / ``handlelength`` /
+    ``handletextpad`` / ``columnspacing``) let a caller measure
+    against a legend styled differently from ``rcParams`` -- the
+    compact mode passes its smaller legend font and shorter
+    handles here so the column count matches what is drawn.
     """
     fig = ax.get_figure()
     if fig is None:
@@ -237,18 +288,35 @@ def auto_ncol(
     if available_width_px is None:
         available_width_px = ax.get_window_extent(renderer).width  # type: ignore[reportUnknownArgumentType]
 
-    fontsize_pt: float = FontProperties(
-        size=plt.rcParams["legend.fontsize"]
-    ).get_size_in_points()
+    legend_fs: Any = (
+        fontsize if fontsize is not None else plt.rcParams["legend.fontsize"]
+    )
+    hl: float = (
+        handlelength
+        if handlelength is not None
+        else float(plt.rcParams["legend.handlelength"])
+    )
+    htp: float = (
+        handletextpad
+        if handletextpad is not None
+        else float(plt.rcParams["legend.handletextpad"])
+    )
+    cs: float = (
+        columnspacing
+        if columnspacing is not None
+        else float(plt.rcParams["legend.columnspacing"])
+    )
+
+    fontsize_pt: float = FontProperties(size=legend_fs).get_size_in_points()
     fs_px: float = fontsize_pt * fig.dpi / 72.0
-    handle_px: float = float(plt.rcParams["legend.handlelength"]) * fs_px
-    pad_px: float = float(plt.rcParams["legend.handletextpad"]) * fs_px
-    col_pad_px: float = float(plt.rcParams["legend.columnspacing"]) * fs_px
+    handle_px: float = hl * fs_px
+    pad_px: float = htp * fs_px
+    col_pad_px: float = cs * fs_px
 
     max_label_px = 0.0
     for label in labels:
         t = ax.text(  # type: ignore[reportUnknownMemberType]
-            0, 0, label
+            0, 0, label, fontsize=legend_fs
         )
         bbox = t.get_window_extent(renderer)  # type: ignore[reportUnknownArgumentType]
         max_label_px = max(max_label_px, bbox.width)
@@ -295,6 +363,276 @@ def export_legend(
         legend.remove()
 
 
+# ----------------------------------------------------------------------
+# Compact mode (charts that live inside a Word table, two per row)
+# ----------------------------------------------------------------------
+
+
+def compact_figsize() -> tuple[float, float]:
+    """Return the compact figure size ``(width, height)`` in inches.
+
+    The width is the **total** figure width (chart + legend),
+    read from the ``compact`` section of ``plots.yaml`` in
+    centimetres and converted to inches.  Defaults to
+    7.4 cm x 5.5 cm when the config is absent.
+    """
+    width_cm: float = float(COMPACT_CONFIG.get("width_cm", 7.4))
+    height_cm: float = float(COMPACT_CONFIG.get("height_cm", 5.5))
+    return (width_cm * CM_TO_IN, height_cm * CM_TO_IN)
+
+
+def compact_font_pt() -> float | None:
+    """Font size (points) for compact charts, or ``None`` to keep the style.
+
+    Because the compact figure is rendered at its true
+    physical size (7.4 cm) and embedded without rescaling,
+    these points equal the points the reader sees in Word --
+    set ``compact.font_pt`` in ``plots.yaml`` to the document
+    body-text size so chart text matches running text.
+    """
+    raw: Any = COMPACT_CONFIG.get("font_pt")
+    return None if raw is None else float(raw)
+
+
+def compact_legend_font_pt() -> float:
+    """Font size (points) for the compact legend -- never ``None``.
+
+    Falls back ``legend_font_pt`` -> ``font_pt`` -> ``9`` so the legend
+    never silently reverts to the stylesheet's body size (the original
+    "11 pt legend" bug): the legend must be measured and drawn at the
+    same, smaller size for the column count to be right.
+    """
+    return float(
+        COMPACT_CONFIG.get("legend_font_pt", COMPACT_CONFIG.get("font_pt", 9))
+    )
+
+
+def compact_legend_kwargs() -> dict[str, Any]:
+    """Legend styling for compact charts, from the ``compact`` config.
+
+    Returns ``fontsize`` / ``handlelength`` / ``handletextpad`` /
+    ``columnspacing`` as concrete values (never ``None``), so the metrics
+    used to *measure* the column count in :func:`auto_ncol` match exactly
+    the metrics used to *draw* the legend in :func:`legend_above` -- the
+    invariant that prevents an over-counted ``ncol``.  The smaller font
+    and shorter handles let several wide labels share one legend row.
+    """
+    return {
+        "fontsize": compact_legend_font_pt(),
+        "handlelength": float(COMPACT_CONFIG.get("legend_handlelength", 1.2)),
+        "handletextpad": float(COMPACT_CONFIG.get("legend_handletextpad", 0.4)),
+        "columnspacing": float(COMPACT_CONFIG.get("legend_columnspacing", 0.8)),
+    }
+
+
+def compact_legend_max_ncol() -> int | None:
+    """Hard cap on the compact legend column count (``None`` if unset)."""
+    raw: Any = COMPACT_CONFIG.get("legend_max_ncol")
+    return None if raw is None else int(raw)
+
+
+def compact_headroom_pad_pt() -> float:
+    """Points of clearance to leave above the top value label (0 if unset)."""
+    return float(COMPACT_CONFIG.get("annotate_headroom_pad_pt", 0))
+
+
+class _StartLabeledConcise(ConciseDateFormatter):
+    """``ConciseDateFormatter`` that spells out the first (start) tick.
+
+    When the compact date axis pins the first datum as the leading tick
+    (see :func:`compact_date_axis`) that date is rarely a clean month
+    boundary, so the concise formatter would label it with a bare day
+    number (e.g. ``31``).  This subclass relabels just that tick so the
+    chart's origin is unambiguous: a January start shows the **year only**
+    (``2020`` -- narrow, like the other year ticks), any other month shows
+    ``month year`` (``jul. 2020``).  Every other tick keeps the concise
+    label.
+    """
+
+    def __init__(self, locator: Any, start_num: float) -> None:
+        # show_offset=False: don't append the trailing "year-month" offset
+        # text (it duplicated the month of the last tick, e.g. "jul." plus
+        # "2026-jul."). With it off, ConciseDateFormatter shows the year
+        # inline at year-boundary ticks instead.
+        super().__init__(  # type: ignore[reportUnknownMemberType]
+            locator, show_offset=False
+        )
+        self._start_num = start_num
+
+    def format_ticks(self, values: Any) -> Any:
+        labels: list[str] = list(super().format_ticks(values))
+        for i, value in enumerate(values):
+            moment = num2date(value)
+            if abs(float(value) - self._start_num) < 0.5:  # within half a day
+                if moment.month == 1:
+                    # January start: the year alone is unambiguous and narrow,
+                    # so it won't collide with the next (year) tick.
+                    labels[i] = str(moment.year)
+                else:
+                    # locale's %b may already carry a trailing dot ("ene.");
+                    # strip it so we don't end up with "jul.. 2020".
+                    month = moment.strftime("%b").lower().rstrip(".")
+                    labels[i] = f"{month}. {moment.year}"
+            elif moment.month == 1:
+                # year boundary: show the year ("2026") instead of "ene." so
+                # the reader sees the year change without a trailing offset.
+                labels[i] = str(moment.year)
+        return labels
+
+
+def compact_date_axis(
+    ax: Axes,
+    data_min: Any,
+    data_max: Any,
+    *,
+    maxticks: int = 4,
+) -> None:
+    """Compact date x-axis: few horizontal ticks, anchored to the data span.
+
+    Ticks are computed over the **data span** ``[data_min,
+    data_max]`` and pinned with a ``FixedLocator``, so none
+    float in the right-hand margin that the value labels open
+    up -- the last tick lands as close to the final data
+    point as the tick step allows.  When ``compact.date_show_start``
+    is true (the default) the first data point is pinned as the
+    leading tick, so the reader can see exactly when the series
+    begins.  Requires the series to have been plotted with
+    ``x_compat=True`` (pandas' own date plotting ignores this
+    formatter).
+    """
+    lo: float = float(cast(Any, date2num(data_min)))
+    hi: float = float(cast(Any, date2num(data_max)))
+    locator = AutoDateLocator(minticks=2, maxticks=maxticks)
+    candidates: list[float] = cast(
+        "list[float]", locator.tick_values(data_min, data_max)
+    )
+    interior: list[float] = [t for t in candidates if lo < t <= hi]
+    if COMPACT_CONFIG.get("date_show_start", True):
+        # pin the first data point as the leading tick so the reader sees
+        # exactly when the series starts (the natural calendar tick often
+        # falls just *before* the first datum and is clipped by margins=0).
+        # Drop any auto tick that would crowd the start label.
+        min_gap: float = (hi - lo) * 0.10
+        interior = [t for t in interior if t - lo >= min_gap]
+        ticks: list[float] = [lo, *interior]
+    else:
+        ticks = [t for t in candidates if lo <= t <= hi] or [lo, hi]
+    show_start = bool(COMPACT_CONFIG.get("date_show_start", True))
+
+    def _set_ticks(values: list[float]) -> None:
+        loc = FixedLocator(values)
+        ax.xaxis.set_major_locator(loc)
+        ax.xaxis.set_major_formatter(
+            _StartLabeledConcise(loc, lo)
+            if show_start
+            else ConciseDateFormatter(loc)
+        )
+
+    _set_ticks(ticks)
+    ax.tick_params(  # type: ignore[reportUnknownMemberType]
+        axis="x", rotation=0
+    )
+
+    # A priori de-overlap: render the labels, measure their boxes, and drop
+    # any tick whose label would collide with the previous kept one (the
+    # start tick is always kept). Catches a wide start label (e.g. a January
+    # start widened to a year, or "jul. 2020") crowding the next tick.
+    fig = ax.get_figure()
+    if fig is not None and len(ticks) > 1:
+        fig.canvas.draw()  # type: ignore[reportUnknownMemberType]
+        renderer = fig.canvas.get_renderer()  # type: ignore[reportUnknownMemberType]
+        boxes = [
+            lbl.get_window_extent(renderer)  # type: ignore[reportUnknownArgumentType]
+            for lbl in ax.get_xticklabels()
+        ]
+        if len(boxes) == len(ticks):
+            pad_px = 2.0
+            kept: list[float] = [ticks[0]]
+            last_x1: float = boxes[0].x1
+            for tick, box in zip(ticks[1:], boxes[1:]):
+                if box.x0 <= last_x1 + pad_px:
+                    continue  # collides with previous kept label -> drop
+                kept.append(tick)
+                last_x1 = box.x1
+            if len(kept) < len(ticks):
+                _set_ticks(kept)
+
+    for label in ax.get_xticklabels():
+        label.set_horizontalalignment("center")
+
+
+def compact_y_axis(ax: Axes) -> None:
+    """Denser y-ticks for compact charts (more reference numbers).
+
+    Compact charts are read at body-text size, so Matplotlib's default
+    of a couple of y-numbers on a short axis is too sparse.  Bump the
+    count to ``compact.y_max_ticks`` "nice" steps (1/2/2.5/5/10 decades)
+    so the reader gets more gridline references -- e.g. every 20 instead
+    of every 50.  Leaves the default locator untouched when the knob is
+    unset, and never changes the y-tick *formatter* set by
+    :func:`style_spines`.
+    """
+    raw: Any = COMPACT_CONFIG.get("y_max_ticks")
+    if raw is None:
+        return
+    ax.yaxis.set_major_locator(
+        MaxNLocator(nbins=int(raw), steps=[1, 2, 2.5, 5, 10])
+    )
+
+
+def legend_above(
+    ax: Axes,
+    handles: list[Any],
+    labels: list[str],
+    *,
+    ncol: int,
+    fontsize: float | None = None,
+    handlelength: float | None = None,
+    handletextpad: float | None = None,
+    columnspacing: float | None = None,
+) -> MplLegend:
+    """Place the legend in a band **above the axes, spanning the figure**.
+
+    Uses ``loc="outside upper center"`` so constrained layout reserves a
+    strip at the top of the *figure* and the legend may use the whole
+    figure width -- wider than the narrow compact axes, whose left edge
+    is eaten by the y-tick numbers and whose right edge is eaten by the
+    end-of-series value labels.  Spanning the figure lets the maximum
+    number of columns share one row, which **minimises the vertical
+    space the legend steals from the plot** (fewer rows = taller chart).
+
+    ``fontsize`` / ``handlelength`` / ``handletextpad`` /
+    ``columnspacing`` style the legend (``None`` keeps the
+    ``rcParams`` default); the compact mode passes a smaller
+    font and shorter handles so more labels fit per row.
+    """
+    fig = ax.get_figure()
+    return fig.legend(  # type: ignore[reportUnknownMemberType, reportOptionalMemberAccess]
+        handles,
+        labels,
+        loc="outside upper center",
+        ncol=ncol,
+        fontsize=fontsize,
+        handlelength=handlelength,
+        handletextpad=handletextpad,
+        columnspacing=columnspacing,
+        frameon=False,  # no box: less clutter in the tight compact figure
+    )
+
+
+def declutter_spines(ax: Axes) -> None:
+    """Hide the spines that carry no ticks (top and right).
+
+    Compact line charts move the y-ticks to the **left** (so
+    the right edge is free for the end-of-series value labels)
+    and keep x-ticks on the bottom, leaving the top and right
+    spines as pure clutter -- drop them to free space and
+    reduce visual noise.
+    """
+    ax.spines["top"].set_visible(False)
+    ax.spines["right"].set_visible(False)
+
+
 # ----------------------------------------------------------------------
 # Cartesian (vertical-y) styling
 # ----------------------------------------------------------------------
@@ -333,13 +671,15 @@ def style_spines(
     ax.tick_params(  # type: ignore[reportUnknownMemberType]
         which="minor", size=0, width=0
     )
+    # Set the tick-mark colour via tick_params (not by recolouring each
+    # Line2D): this stores it in the axis' tick kwargs, so ANY tick
+    # regenerated after this call inherits it. Compact mode swaps in a
+    # denser y-locator later, which rebuilds the tick objects; recolouring
+    # the lines directly here would leave those new ticks the default black
+    # (only the relocated ones would stay grey -- hence a lone black tick).
     ax.tick_params(  # type: ignore[reportUnknownMemberType]
-        axis="both", which="major"
+        axis="both", which="major", color=color
     )
-    for tick in ax.get_xticklines():
-        tick.set_markeredgecolor(color)
-    for tick in ax.get_yticklines():
-        tick.set_markeredgecolor(color)
 
 
 def style_baseline(
@@ -378,6 +718,10 @@ def annotate_last_values(
     labels: dict[str, str] | None = None,
     series_styles: dict[str, dict[str, Any]] | None = None,
     annotate_color: str | None = None,
+    weight: str | None = None,
+    fontsize: float | None = None,
+    right_pad_px: float = 10.0,
+    headroom_pad_pt: float = 0.0,
 ) -> None:
     """Label the last non-NaN value of each column on the right.
 
@@ -392,8 +736,19 @@ def annotate_last_values(
 
     Labels are packed vertically in display space so that
     series ending at nearly the same value do not overlap.
-    The x-axis limit is extended by the widest label so
-    the text is not clipped by the axes frame.
+    They sit just right of the last point and the x-axis
+    limit is extended by the widest label plus ``right_pad_px``
+    so the text is not clipped by the axes frame; raise
+    ``right_pad_px`` (e.g. on compact charts) to open more
+    blank space on the right and keep the labels clear of both
+    the data lines and the right-hand y-tick labels.
+
+    ``headroom_pad_pt`` is the clearance kept above the top
+    label: if the packed stack would reach past the top
+    y-limit, that limit grows enough to keep this many points
+    free and the labels are re-packed at the new scale, so a
+    tall stack never spills into a legend above the axes (nor
+    is clipped at the top).
     """
     fig = ax.get_figure()
     if fig is None:
@@ -428,7 +783,7 @@ def annotate_last_values(
     trans = ax.transData
 
     sample = ax.text(  # type: ignore[reportUnknownMemberType]
-        0, 0, "0"
+        0, 0, "0", fontsize=fontsize
     )
     text_height = (
         sample.get_window_extent(renderer).height  # type: ignore[reportUnknownArgumentType]
@@ -437,14 +792,39 @@ def annotate_last_values(
     sample.remove()
 
     entries.sort(key=lambda e: e[1])
-    placements: list[float] = []
-    prev_y = -float("inf")
-    for _, val, _, _ in entries:
-        y_display: float = trans.transform((0, val))[1]  # type: ignore[reportUnknownArgumentType]
-        if y_display - prev_y < text_height:
-            y_display = prev_y + text_height
-        placements.append(y_display)
-        prev_y = y_display
+
+    def _pack(top_data: float) -> list[float]:
+        # Set the final y-scale BEFORE packing. Spacing is enforced in display
+        # space, so it must be measured at the scale the labels are drawn at;
+        # growing the y-limit *after* packing (the old approach) rescaled the
+        # data points and quietly reopened the overlaps packing should remove.
+        ax.set_ylim(top=top_data)
+        fig.canvas.draw()  # type: ignore[reportUnknownMemberType]
+        packed: list[float] = []
+        prev = -float("inf")
+        for _, value, _, _ in entries:
+            y_disp: float = trans.transform((0, value))[1]  # type: ignore[reportUnknownArgumentType]
+            if y_disp - prev < text_height:
+                y_disp = prev + text_height
+            packed.append(y_disp)
+            prev = y_disp
+        return packed
+
+    _, ymax = ax.get_ylim()
+    placements = _pack(ymax)
+
+    # The stack packs upward; if it reaches past the top y-limit it renders
+    # over the legend (compact, legend above) or is clipped (normal). Grow the
+    # y-limit so the top label keeps headroom_pad_pt of clearance, then RE-PACK
+    # so the spacing is exact at the new (final) scale.
+    pad_px = headroom_pad_pt * fig.dpi / 72.0
+    top_axes_px: float = trans.transform((0, ymax))[1]  # type: ignore[reportUnknownArgumentType]
+    needed_px = placements[-1] + text_height / 2 + pad_px
+    if needed_px > top_axes_px:
+        new_top: float = trans.inverted().transform(  # type: ignore[reportUnknownArgumentType]
+            (0, needed_px)
+        )[1]
+        placements = _pack(new_top)
 
     max_label_width = 0.0
     for (date, val, _, color), packed_y in zip(entries, placements):
@@ -459,13 +839,19 @@ def annotate_last_values(
             color=color,
             va="center",
             ha="left",
+            fontweight=weight if weight is not None else "normal",
+            fontsize=fontsize,
         )
         width = t.get_window_extent(renderer).width  # type: ignore[reportUnknownArgumentType]
         max_label_width = max(max_label_width, width)
 
+    # labels spill right of the data, so widen the x-limit by the widest
+    # label plus right_pad_px to keep them unclipped (and, with a larger
+    # pad, clear of the right-hand y-tick labels). x is independent of the
+    # y-limit set above, so this stays correct.
     inv = trans.inverted()
     x0: float = inv.transform((0, 0))[0]  # type: ignore[reportUnknownArgumentType]
-    x1: float = inv.transform((max_label_width + 10, 0))[0]  # type: ignore[reportUnknownArgumentType]
+    x1: float = inv.transform((max_label_width + right_pad_px, 0))[0]  # type: ignore[reportUnknownArgumentType]
     xmin, xmax = ax.get_xlim()
     ax.set_xlim(xmin, xmax + (x1 - x0))
 

tesorotools/artists/barh_plot.py

@@ -36,6 +36,7 @@ from tesorotools.artists._common import (
     Legend,
     adjust_figure_for_plot_size,
     auto_ncol,
+    dynamic_dpi,
     resolve_data,
 )
 from tesorotools.utils.matplotlib import PLOT_CONFIG, format_annotation
@@ -370,7 +371,7 @@ class HorizontalBarChart:
         _style_zero_baseline(ax, **AX_CONFIG["baseline"])
 
         fig.savefig(  # type: ignore[reportUnknownMemberType]
-            self.out_path
+            self.out_path, dpi=dynamic_dpi(fig)
         )
         plt.close(fig)
         return ax
@@ -572,7 +573,7 @@ class GroupedBarChart:
             adjust_figure_for_plot_size(fig, ax, self.plot_size)
 
         fig.savefig(  # type: ignore[reportUnknownMemberType]
-            self.out_path
+            self.out_path, dpi=dynamic_dpi(fig)
         )
         plt.close(fig)
         return ax