tesorotools-python 0.0.51__tar.gz → 0.0.52__tar.gz

{tesorotools_python-0.0.51 → tesorotools_python-0.0.52}/.gitignore

@@ -3,7 +3,11 @@
 
 __pycache__
 
-.vscode/
+# Ignorar ajustes personales de VS Code, pero versionar los compartidos
+# (recomendación de extensiones y formato de markdown con prettier).
+.vscode/*
+!.vscode/extensions.json
+!.vscode/settings.json
 
 data/
 config/

{tesorotools_python-0.0.51 → tesorotools_python-0.0.52}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tesorotools-python
-Version: 0.0.51
+Version: 0.0.52
 Requires-Python: >=3.13
 Requires-Dist: babel>=2.17
 Requires-Dist: matplotlib>=3.10

{tesorotools_python-0.0.51 → tesorotools_python-0.0.52}/src/tesorotools/artists/_common.py

@@ -24,7 +24,7 @@ overrides only need to update ``plots.yaml``.
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Any, Protocol, Self, cast, runtime_checkable
+from typing import Any, Literal, Protocol, Self, cast, runtime_checkable
 
 import matplotlib.pyplot as plt
 import pandas as pd
@@ -58,10 +58,44 @@ 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", {})
+LINE_CONFIG: dict[str, Any] = PLOT_CONFIG.get("line", {})
 SAVE_CONFIG: dict[str, Any] = PLOT_CONFIG.get("save", {})
 
 CM_TO_IN: float = 1.0 / 2.54
 
+# Soft date-density levels -> AutoDateLocator maxticks. Fallbacks used when the
+# matching ``plots.yaml`` block (``compact.date_maxticks`` / ``line.date_maxticks``)
+# is missing a level; "default" reproduces the historical tick count of each mode
+# (4 for compact, 6 for non-compact).
+DATE_DENSITY_LEVELS: tuple[str, ...] = ("few", "default", "many")
+_DATE_MAXTICKS_FALLBACK_COMPACT: dict[str, int] = {
+    "few": 3,
+    "default": 4,
+    "many": 7,
+}
+_DATE_MAXTICKS_FALLBACK_LINE: dict[str, int] = {
+    "few": 3,
+    "default": 6,
+    "many": 10,
+}
+
+
+def date_maxticks(density: str, *, compact: bool) -> int:
+    """Resolve a soft ``date_density`` level to an ``AutoDateLocator`` maxticks.
+
+    Reads the per-mode ``date_maxticks`` table from ``plots.yaml``
+    (``compact.date_maxticks`` when *compact*, else ``line.date_maxticks``),
+    falling back to the built-in table when the config (or a level) is absent.
+    """
+    cfg = COMPACT_CONFIG if compact else LINE_CONFIG
+    fallback = (
+        _DATE_MAXTICKS_FALLBACK_COMPACT
+        if compact
+        else _DATE_MAXTICKS_FALLBACK_LINE
+    )
+    table: dict[str, Any] = cfg.get("date_maxticks", fallback)
+    return int(table.get(density, fallback[density]))
+
 
 def dynamic_dpi(fig: Figure) -> int:
     """Save DPI adapted to the figure's physical size.
@@ -258,6 +292,51 @@ def adjust_figure_for_plot_size(
     fig.set_size_inches(new_w, new_h)
 
 
+def grow_height_to_axes(
+    fig: Figure,
+    ax: Axes,
+    target_axes_h_in: float,
+    *,
+    max_iter: int = 3,
+    cap_factor: float = 2.0,
+) -> None:
+    """Grow the figure **height** (width fixed) until *ax* is *target* inches tall.
+
+    Under ``constrained`` layout an outside legend band and the x-tick label
+    strip keep a roughly **fixed absolute** height, so height added to the
+    figure flows almost entirely into the axes rectangle.  Growing to the axes
+    height measured *before* the legend was added therefore gives the plot area
+    back the vertical space the legend (and any rotated date labels) stole,
+    instead of squashing it inside a fixed figure.
+
+    A feedback loop (grow -> draw -> re-measure the deficit) converges in a few
+    passes because the reserved bands are non-linear only at the margin; total
+    growth is capped at ``cap_factor`` times the original height so a huge
+    legend cannot run the figure away.  Measures the axes rectangle via
+    ``get_window_extent`` (not ``get_tightbbox``, which includes the very tick
+    strip being budgeted for).
+    """
+    orig_w, orig_h = (float(v) for v in fig.get_size_inches())
+    max_h = orig_h * cap_factor
+    eps_in = 0.02
+    for _ in range(max_iter):
+        fig.canvas.draw()  # type: ignore[reportUnknownMemberType]
+        renderer = fig.canvas.get_renderer()  # type: ignore[reportUnknownMemberType]
+        ax_h_in = (
+            ax.get_window_extent(renderer).height  # type: ignore[reportUnknownArgumentType]
+            / fig.dpi
+        )
+        deficit = target_axes_h_in - ax_h_in
+        if deficit <= eps_in:
+            break
+        current_h = float(fig.get_size_inches()[1])
+        new_h = min(max_h, current_h + deficit)
+        if new_h <= current_h:  # capped out: no further progress possible
+            break
+        fig.set_size_inches(orig_w, new_h)
+    fig.canvas.draw()  # type: ignore[reportUnknownMemberType]
+
+
 def auto_ncol(
     ax: Axes,
     labels: list[str],
@@ -496,25 +575,62 @@ class _StartLabeledConcise(ConciseDateFormatter):
         return labels
 
 
+def _date_label_ha(
+    rotation: float | None,
+) -> Literal["left", "center", "right"]:
+    """Horizontal alignment for date tick labels at *rotation* degrees.
+
+    Horizontal labels centre under their tick; a positive (counter-clockwise,
+    up-to-the-right) slant reads best right-anchored so each label runs
+    down-left under its tick, and a negative slant left-anchored.
+    """
+    if rotation is None or rotation == 0:
+        return "center"
+    return "right" if rotation > 0 else "left"
+
+
 def compact_date_axis(
     ax: Axes,
     data_min: Any,
     data_max: Any,
     *,
     maxticks: int = 4,
+    rotation: float | None = None,
+    pin_start: bool | None = None,
+    auto_rotate: bool = False,
 ) -> None:
-    """Compact date x-axis: few horizontal ticks, anchored to the data span.
+    """Compact date x-axis: few 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).
+    point as the tick step allows.  When the start is pinned (see
+    ``pin_start``) the first data point becomes the leading tick, so
+    the reader sees exactly when the series begins.  Requires the
+    series to have been plotted with ``x_compat=True`` (pandas' own
+    date plotting ignores this formatter).
+
+    ``rotation`` (degrees) tilts the tick labels so more dates fit;
+    ``None`` keeps them horizontal (the historical behaviour). The
+    rotation and its matching horizontal alignment are applied
+    **before** the a-priori de-overlap measures the label boxes, so
+    the collision sweep sees the real (slanted, anchored) geometry.
+
+    ``pin_start`` pins the first data point as the leading tick;
+    ``None`` (the default) reads ``compact.date_show_start``.  Pass
+    ``False`` to prefer a **clean equally spaced calendar grid** over
+    the (off-grid, wide) start label -- the caller does this when the
+    user asks for a non-default density or a rotation, where an
+    even cadence reads better than an anchored-but-ragged one.
+
+    ``auto_rotate`` makes the requested density **actually count**: it
+    tries increasing tilts (0, 30, 45, 60, 90 degrees) and keeps the
+    smallest one at which the most (ideally all) of the requested date
+    ticks survive the de-overlap -- so choosing a denser level packs
+    more dates by leaning the labels only as far as needed, instead of
+    silently collapsing to the same few. Ignored when ``rotation`` is
+    given (an explicit angle wins).
     """
     lo: float = float(cast(Any, date2num(data_min)))
     hi: float = float(cast(Any, date2num(data_max)))
@@ -522,8 +638,13 @@ def compact_date_axis(
     candidates: list[float] = cast(
         "list[float]", locator.tick_values(data_min, data_max)
     )
+    show_start: bool = (
+        bool(COMPACT_CONFIG.get("date_show_start", True))
+        if pin_start is None
+        else pin_start
+    )
     interior: list[float] = [t for t in candidates if lo < t <= hi]
-    if COMPACT_CONFIG.get("date_show_start", True):
+    if show_start:
         # 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).
@@ -533,7 +654,6 @@ def compact_date_axis(
         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)
@@ -544,18 +664,34 @@ def compact_date_axis(
             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:
+    def _style_labels(rot: float) -> None:
+        # rotation goes in the axis tick kwargs; ha / anchor rotation-mode are
+        # per-label Text properties reapplied after every draw or locator swap.
+        ha = _date_label_ha(None if rot == 0 else rot)
+        ax.tick_params(  # type: ignore[reportUnknownMemberType]
+            axis="x", rotation=rot
+        )
+        for label in ax.get_xticklabels():
+            label.set_horizontalalignment(ha)
+            if rot != 0:
+                label.set_rotation_mode("anchor")
+
+    def _decimate_at(rot: float) -> list[int]:
+        # Render all candidate ticks at this tilt, measure their label boxes,
+        # and thin to a UNIFORMLY spaced subset when they collide -- so the
+        # survivors stay equally spaced in time (a greedy left-to-right drop
+        # leaves ragged gaps). Returns the kept indices into ``ticks``.
+        _set_ticks(ticks)
+        chosen: list[int] = list(range(len(ticks)))
+        fig = ax.get_figure()
+        if fig is None or len(ticks) <= 1:
+            _style_labels(rot)
+            return chosen
         fig.canvas.draw()  # type: ignore[reportUnknownMemberType]
+        # set ha AFTER the draw (labels now exist) but BEFORE measuring:
+        # get_window_extent recomputes from the current Text properties, so the
+        # boxes reflect both the rotation (from the draw) and the anchor/ha.
+        _style_labels(rot)
         renderer = fig.canvas.get_renderer()  # type: ignore[reportUnknownMemberType]
         boxes = [
             lbl.get_window_extent(renderer)  # type: ignore[reportUnknownArgumentType]
@@ -563,18 +699,88 @@ def compact_date_axis(
         ]
         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)
+            n = len(ticks)
+
+            def _clears(idx: list[int]) -> bool:
+                return all(
+                    boxes[b].x0 > boxes[a].x1 + pad_px
+                    for a, b in zip(idx, idx[1:])
+                )
+
+            # decimate from the right (anchor the latest date) by a constant
+            # stride so the gaps are equal. Force-keep index 0 ONLY when it is
+            # the pinned start tick; otherwise the whole grid is uniform and
+            # forcing it would re-open a ragged left gap.
+            keep0: set[int] = {0} if show_start else set()
+            chosen = sorted(keep0 | {0, n - 1})
+            for stride in range(1, n):
+                idx = sorted(keep0 | set(range(n - 1, -1, -stride)))
+                if _clears(idx):
+                    chosen = idx
+                    break
+        return chosen
+
+    if auto_rotate and rotation is None:
+        # honour the requested density by leaning the labels only as far as
+        # needed: pick the smallest tilt keeping the most date ticks (ties ->
+        # flatter), stopping as soon as one keeps them all.
+        best_rot = 0.0
+        best_chosen = _decimate_at(0.0)
+        for cand in (30.0, 45.0, 60.0, 90.0):
+            if len(best_chosen) >= len(ticks):
+                break
+            cand_chosen = _decimate_at(cand)
+            if len(cand_chosen) > len(best_chosen):
+                best_rot, best_chosen = cand, cand_chosen
+        rot_final, chosen = best_rot, best_chosen
+    else:
+        rot_final = 0.0 if rotation is None else float(rotation)
+        chosen = _decimate_at(rot_final)
+
+    # apply the winning tick subset + tilt as the final state
+    if len(chosen) < len(ticks):
+        _set_ticks([ticks[i] for i in chosen])
+    fig = ax.get_figure()
+    if fig is not None:
+        fig.canvas.draw()  # type: ignore[reportUnknownMemberType]
+    _style_labels(rot_final)
+
 
+def apply_date_axis(
+    ax: Axes,
+    *,
+    maxticks: int,
+    rotation: float | None = None,
+) -> None:
+    """Native matplotlib date x-axis with a soft tick count and optional slant.
+
+    The non-compact counterpart to :func:`compact_date_axis`: it takes over the
+    x-axis (which must carry a **native** date axis, i.e. the series were
+    plotted with ``x_compat=True``) with an ``AutoDateLocator`` capped at
+    *maxticks* and a ``ConciseDateFormatter`` bound to the **same** locator
+    instance (the concise context logic misfires with a mismatched one).
+    ``rotation`` (degrees) tilts the labels; ``None`` keeps them horizontal.
+
+    Unlike the compact path this changes the label **text style** too (concise
+    hierarchical labels instead of pandas' own date formatting), so callers use
+    it only when the user explicitly asks for a non-default density or rotation.
+    """
+    locator = AutoDateLocator(minticks=2, maxticks=maxticks)
+    ax.xaxis.set_major_locator(locator)
+    ax.xaxis.set_major_formatter(ConciseDateFormatter(locator))
+    if rotation is None or rotation == 0:
+        return
+    rot = float(rotation)
+    ha = _date_label_ha(rotation)
+    ax.tick_params(  # type: ignore[reportUnknownMemberType]
+        axis="x", rotation=rot
+    )
+    fig = ax.get_figure()
+    if fig is not None:
+        fig.canvas.draw()  # type: ignore[reportUnknownMemberType]
     for label in ax.get_xticklabels():
-        label.set_horizontalalignment("center")
+        label.set_horizontalalignment(ha)
+        label.set_rotation_mode("anchor")
 
 
 def compact_y_axis(ax: Axes) -> None:

{tesorotools_python-0.0.51 → tesorotools_python-0.0.52}/src/tesorotools/artists/line_plot.py

@@ -23,18 +23,22 @@ from yaml.nodes import MappingNode
 
 from tesorotools.artists._common import (
     AX_CONFIG,
+    DATE_DENSITY_LEVELS,
     Format,
     Legend,
     resolve_data,
     adjust_figure_for_plot_size,
     annotate_last_values,
+    apply_date_axis,
     compact_date_axis,
     compact_figure_kwargs,
     compact_font_pt,
     compact_headroom_pad_pt,
     compact_y_axis,
+    date_maxticks,
     draw_vlines,
     dynamic_dpi,
+    grow_height_to_axes,
     place_legend,
     style_baseline,
     style_compact_axes,
@@ -108,6 +112,35 @@ class LinePlot:
       with the axis at 2 (``1,14``) but the annotation at 4
       (``1,1419``); a dollar-index chart with the axis at 0
       (``101``) but the annotation at 1 (``101,1``).
+    * ``axis_units`` / ``annotate_units`` -- whether ``fmt.units``
+      is shown on the y-tick numbers and on the last-value
+      annotations, **independently**. Both default ``True`` (the
+      historical behaviour). Set ``axis_units: false`` to keep the
+      unit only on the value labels (a common house look: ``mM€``
+      on the annotations, bare numbers on the axis), or the reverse.
+    * ``date_density`` -- soft target for how many date ticks the
+      x-axis shows: ``"few"`` / ``"default"`` / ``"many"``, mapped
+      to a locator ``maxticks`` per mode in ``plots.yaml``
+      (``compact.date_maxticks`` / ``line.date_maxticks``).
+      ``"default"`` reproduces the current tick count. The surviving
+      ticks are kept **equally spaced in time**. In compact mode a
+      denser level with no explicit ``date_rotation`` **auto-tilts**
+      the labels only as far as needed to actually fit the extra
+      dates (a narrow chart cannot fit many horizontal 4-digit years),
+      so choosing ``"many"`` reliably shows more.
+    * ``date_rotation`` -- tilt the date tick labels this many
+      degrees so more fit; ``None`` keeps them horizontal (and lets
+      the compact auto-tilt above pick an angle). A positive angle
+      slants up-to-the-right (right-anchored); setting it explicitly
+      disables the auto-tilt. In non-compact mode, setting a
+      non-default ``date_density`` or any ``date_rotation`` switches
+      the x-axis to matplotlib's concise date formatting (different
+      label *style* from pandas' default); leaving both at their
+      defaults keeps the pandas path.
+    * ``adapt_height`` -- when true (the default), grow the figure
+      **height** (keeping the width) so the plot area is not
+      squashed by a large legend or rotated date labels. Skipped
+      when ``plot_size`` is set (that already fixes the axes size).
 
     Render lifecycle: ``build()`` returns ``(Figure, Axes)``
     in memory; ``save(fig)`` persists to ``out_path``;
@@ -140,6 +173,11 @@ class LinePlot:
         compact: bool = False,
         font_pt: float | None = None,
         axis_decimals: int | None = None,
+        axis_units: bool = True,
+        annotate_units: bool = True,
+        date_density: str = "default",
+        date_rotation: float | None = None,
+        adapt_height: bool = True,
         ref_lines: list[dict[str, Any]] | None = None,
         show_means: bool = False,
         means_window: tuple[Any, Any] | None = None,
@@ -152,6 +190,11 @@ class LinePlot:
                 "either rebased multiplicatively (index) or subtractively "
                 "(change-since), not both"
             )
+        if date_density not in DATE_DENSITY_LEVELS:
+            raise ValueError(
+                f"date_density must be one of {DATE_DENSITY_LEVELS}: "
+                f"{date_density!r}"
+            )
         self.out_path = out_path
         self.data = resolve_data(data, data_path)
         self.series = series
@@ -175,10 +218,27 @@ class LinePlot:
         self.compact = compact
         self.font_pt = font_pt
         self.axis_decimals = axis_decimals
+        self.axis_units = axis_units
+        self.annotate_units = annotate_units
+        self.date_density = date_density
+        self.date_rotation = date_rotation
+        self.adapt_height = adapt_height
         self.ref_lines = ref_lines or []
         self.show_means = show_means
         self.means_window = means_window
 
+    @property
+    def _custom_date_axis(self) -> bool:
+        """Whether the non-compact chart takes over the x-axis for dates.
+
+        Only when the user asks for a non-default density or a rotation; else
+        the historical pandas date plotting is kept untouched. Compact mode has
+        its own date axis (:func:`compact_date_axis`) and never uses this path.
+        """
+        return not self.compact and (
+            self.date_density != "default" or self.date_rotation is not None
+        )
+
     @classmethod
     def from_yaml(cls, loader: TemplateLoader, node: MappingNode) -> Self:
         """Build a :class:`LinePlot` from the ``!line_plot`` YAML tag.
@@ -202,8 +262,9 @@ class LinePlot:
         ``baseline``, ``fmt`` (``!format``), ``legend``
         (``!legend``), ``figsize``, ``series_styles``,
         ``plot_size``, ``vlines``, ``compact``, ``font_pt``,
-        ``axis_decimals``, ``ref_lines``, ``show_means``,
-        ``means_window``.
+        ``axis_decimals``, ``axis_units``, ``annotate_units``,
+        ``date_density``, ``date_rotation``, ``adapt_height``,
+        ``ref_lines``, ``show_means``, ``means_window``.
 
         Example
         -------
@@ -314,15 +375,17 @@ class LinePlot:
         font_pt = compact_font_pt(self.font_pt) if self.compact else None
 
         ax = fig.add_subplot()
+        # compact mode -- and the non-compact custom date axis -- need
+        # matplotlib's native date axis so the AutoDateLocator /
+        # ConciseDateFormatter take effect (x_compat disables pandas' own date
+        # plotting machinery). The default non-compact path keeps x_compat off.
+        native_date_axis = self.compact or self._custom_date_axis
         for col in plot_data.columns:
             style = self.series_styles.get(col, {})
-            # compact mode needs matplotlib's native date axis so the
-            # ConciseDateFormatter takes effect (x_compat disables pandas'
-            # own date plotting machinery).
             plot_data[col].plot(
                 ax=ax,
                 label=self.series[col],
-                x_compat=self.compact,
+                x_compat=native_date_axis,
                 **style,
             )
 
@@ -334,12 +397,17 @@ class LinePlot:
         if self.vlines:
             draw_vlines(ax, self.vlines)
 
+        # units are shown on the y-tick numbers and on the last-value
+        # annotations independently; compute each once here.
+        axis_units = self.fmt.units if self.axis_units else ""
+        annotate_units = self.fmt.units if self.annotate_units else ""
+
         if self.annotate:
             annotate_last_values(
                 ax,
                 plot_data,
                 decimals=self.fmt.decimals,
-                units=self.fmt.units,
+                units=annotate_units,
                 labels=self.series,
                 series_styles=self.series_styles,
                 annotate_color=self.annotate_color,
@@ -363,7 +431,7 @@ class LinePlot:
         style_spines(
             ax,
             decimals=self.fmt.decimals,
-            units=self.fmt.units,
+            units=axis_units,
             **AX_CONFIG["spines"],
         )
         # Decouple tick precision from annotation precision: style_spines
@@ -373,7 +441,7 @@ class LinePlot:
         # the annotations at fmt.decimals.
         if self.axis_decimals is not None:
             axis_decimals = self.axis_decimals
-            units = self.fmt.units
+            units = axis_units
 
             def _fmt_axis_tick(y: float, _pos: int) -> str:
                 return format_annotation(y, axis_decimals, units)
@@ -425,11 +493,46 @@ class LinePlot:
                     zorder=1,
                 )
 
+        # Anchor for the height adaptation: the axes height BEFORE the date
+        # axis is thinned/rotated and BEFORE the legend is added, so growing
+        # back to it returns the vertical space that both the legend and any
+        # rotated date labels steal. Skipped when plot_size fixes the axes
+        # size itself. (The tiny tick-font difference vs the final compact
+        # styling is immaterial.)
+        target_axes_h_in: float | None = None
+        if self.adapt_height and self.plot_size is None:
+            fig.canvas.draw()  # type: ignore[reportUnknownMemberType]
+            renderer = fig.canvas.get_renderer()  # type: ignore[reportUnknownMemberType]
+            target_axes_h_in = (
+                ax.get_window_extent(renderer).height  # type: ignore[reportUnknownArgumentType]
+                / fig.dpi
+            )
+
         if self.compact:
             # pin the date ticks to the data span (after annotate widened the
             # x-limit) so the last tick sits next to the final data point and
             # none float in the value-label margin; match Word's body font.
-            compact_date_axis(ax, plot_data.index.min(), plot_data.index.max())
+            # date_density -> maxticks; date_rotation tilts the labels.
+            # An explicit density or rotation asks for a specific cadence, so
+            # prefer a clean equally spaced calendar grid over the pinned
+            # (off-grid, wide) start label; otherwise keep the house default.
+            custom_dates = (
+                self.date_density != "default" or self.date_rotation is not None
+            )
+            compact_date_axis(
+                ax,
+                plot_data.index.min(),
+                plot_data.index.max(),
+                maxticks=date_maxticks(self.date_density, compact=True),
+                rotation=self.date_rotation,
+                pin_start=False if custom_dates else None,
+                # a denser level with no explicit angle leans the labels only
+                # as far as needed so the extra dates actually appear.
+                auto_rotate=(
+                    self.date_density != "default"
+                    and self.date_rotation is None
+                ),
+            )
             # y-axis side: keep the house RIGHT side (matching every other
             # chart in a two-per-row row) by default, and move to the LEFT
             # only when annotate is on -- there the right edge is needed for
@@ -440,6 +543,15 @@ class LinePlot:
             # denser y-numbers (e.g. every 20 instead of every 50) so the
             # small chart still has enough reference gridlines.
             compact_y_axis(ax)
+        elif self._custom_date_axis:
+            # non-compact, but the user asked for a non-default density or a
+            # rotation: take over the (native) date axis with a concise
+            # formatter thinned to date_maxticks and tilt the labels.
+            apply_date_axis(
+                ax,
+                maxticks=date_maxticks(self.date_density, compact=False),
+                rotation=self.date_rotation,
+            )
 
         if self.legend is not None:
             # Draw from the actual labelled artists (so in-legend reference
@@ -454,6 +566,10 @@ class LinePlot:
         # so the axes-sizing pass would fight it; skip it there.
         if self.plot_size is not None and not self.compact:
             adjust_figure_for_plot_size(fig, ax, self.plot_size)
+        elif target_axes_h_in is not None:
+            # keep the width, grow the height so the legend / rotated dates do
+            # not squash the plot area below its pre-legend height.
+            grow_height_to_axes(fig, ax, target_axes_h_in)
 
         return fig, ax
 

{tesorotools_python-0.0.51 → tesorotools_python-0.0.52}/src/tesorotools/artists/plotly_backend.py

@@ -262,7 +262,9 @@ def line_plot_to_figure(chart: LinePlot) -> go.Figure:
                 x=series.index[-1],
                 y=float(series.iloc[-1]),
                 text=format_annotation(
-                    float(series.iloc[-1]), chart.fmt.decimals, chart.fmt.units
+                    float(series.iloc[-1]),
+                    chart.fmt.decimals,
+                    chart.fmt.units if chart.annotate_units else "",
                 ),
                 showarrow=False,
                 xanchor="left",
@@ -270,7 +272,9 @@ def line_plot_to_figure(chart: LinePlot) -> go.Figure:
                 font={"color": _color(color)},
             )
 
-    if chart.fmt.units:
+    # units on the y-tick numbers and on the annotations are independent
+    # toggles (mirrors the matplotlib artist).
+    if chart.fmt.units and chart.axis_units:
         fig.update_yaxes(ticksuffix=chart.fmt.units)
     return fig
 

{tesorotools_python-0.0.51 → tesorotools_python-0.0.52}/src/tesorotools/assets/plots.yaml

@@ -89,6 +89,16 @@ waterfall:
 
 line:
   ncol: 5
+  # Densidad "soft" de fechas del eje X (no-compact): cada nivel de
+  # date_density se traduce en un maxticks para el AutoDateLocator (que es
+  # conservador: elige el intervalo bonito mas fino cuyo nº de ticks <=
+  # maxticks, asi que "many" va holgado). Solo se aplica cuando date_density
+  # != "default" o hay date_rotation (si no, se mantiene el ploteo de fechas
+  # de pandas por defecto).
+  date_maxticks:
+    few: 3
+    default: 6
+    many: 14
 
 # Combo barras + línea (!bar_line): la línea es la serie protagonista
 # (marcador circular por defecto, configurable por serie con line_styles),
@@ -150,6 +160,18 @@ compact:
   annotate_headroom_pad_pt: 4  # hueco por encima de la etiqueta de valor más alta
   date_show_start: true        # fija la fecha del primer dato como primer tick X
   y_max_ticks: 10              # nº máx. de números en el eje Y (más referencias)
+  # Densidad "soft" de fechas del eje X: cada nivel de date_density se traduce
+  # en el maxticks del locator de fechas. El nivel "default" (4) es el
+  # comportamiento actual. Nota: AutoDateLocator es conservador (elige el
+  # intervalo "bonito" mas fino cuyo nº de ticks <= maxticks contando los del
+  # borde), asi que "many" necesita un valor holgado para ofrecer intervalos
+  # finos; luego la de-solapamiento recorta a lo que de verdad cabe (mas aun
+  # con anotaciones de ultimo valor, que comprimen el eje). Con rotacion caben
+  # mas.
+  date_maxticks:
+    few: 3
+    default: 4
+    many: 12
   # Gráficos de barras horizontales (barh / grouped_barh): el alto fijo de
   # compact aplastaría las etiquetas de un gráfico con muchas categorías, así
   # que en compact se mantiene el ANCHO fijo y el ALTO crece con el nº de