tesorotools-python 0.1.6__tar.gz → 0.1.8__tar.gz

{tesorotools_python-0.1.6 → tesorotools_python-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tesorotools-python
-Version: 0.1.6
+Version: 0.1.8
 Requires-Python: >=3.13
 Requires-Dist: babel>=2.17
 Requires-Dist: matplotlib>=3.10
@@ -9,6 +9,7 @@ Requires-Dist: pandas>=2.2
 Requires-Dist: psycopg[binary]>=3.1
 Requires-Dist: pyarrow>=18.0
 Requires-Dist: python-docx>=1.1
+Requires-Dist: python-pptx>=1.0
 Requires-Dist: pywin32>=311; sys_platform == 'win32'
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: sqlalchemy>=2.0

{tesorotools_python-0.1.6 → tesorotools_python-0.1.8}/pyproject.toml

@@ -19,6 +19,7 @@ dependencies = [
     # data visualization
     "matplotlib>=3.10",
     "python-docx>=1.1",
+    "python-pptx>=1.0",
 
     # os dependencies
     "pywin32>=311; sys_platform == 'win32'",
@@ -39,6 +40,7 @@ web = ["streamlit>=1.62", "plotly>=5.24"]
 tesorotools-web = "tesorotools.web.cli:main"
 tesorotools-latex = "tesorotools.latex.cli:main"
 tesorotools-nota = "tesorotools.note.cli:main"
+tesorotools-presentacion = "tesorotools.presentation.cli:main"
 
 [dependency-groups]
 dev = [

{tesorotools_python-0.1.6 → tesorotools_python-0.1.8}/src/tesorotools/artists/_common.py

@@ -47,9 +47,21 @@ from matplotlib.dates import (
 from matplotlib.figure import Figure
 from matplotlib.font_manager import FontProperties
 from matplotlib.legend import Legend as MplLegend
-from matplotlib.ticker import FixedLocator, FuncFormatter, MaxNLocator
+from matplotlib.text import Text
+from matplotlib.ticker import (
+    FixedFormatter,
+    FixedLocator,
+    FuncFormatter,
+    MaxNLocator,
+    NullFormatter,
+)
 from yaml.nodes import MappingNode
 
+from tesorotools.artists._dates import (
+    DateLayout,
+    date_layouts,
+    period_label,
+)
 from tesorotools.utils.matplotlib import (
     PLOT_CONFIG,
     apply_house_style,
@@ -110,6 +122,53 @@ def date_maxticks(density: str, *, compact: bool) -> int:
     return int(table.get(density, fallback[density]))
 
 
+# Most date labels an axis shows per date_density level, read from
+# ``compact.date_max_labels`` / ``line.date_max_labels`` in ``plots.yaml``:
+# the finest calendar step (every year, every month...) whose labels fit in
+# the axis width AND stay within this count wins.
+_DATE_MAX_LABELS_FALLBACK_COMPACT: dict[str, int] = {
+    "few": 4,
+    "default": 8,
+    "many": 14,
+}
+_DATE_MAX_LABELS_FALLBACK_LINE: dict[str, int] = {
+    "few": 6,
+    "default": 15,
+    "many": 30,
+}
+
+
+def date_max_labels(density: str, *, compact: bool) -> int:
+    """Most date labels a ``date_density`` level allows on the x-axis.
+
+    Reads ``compact.date_max_labels`` / ``line.date_max_labels`` from
+    ``plots.yaml``, 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_MAX_LABELS_FALLBACK_COMPACT
+        if compact
+        else _DATE_MAX_LABELS_FALLBACK_LINE
+    )
+    table: dict[str, Any] = cfg.get("date_max_labels", fallback)
+    return int(table.get(density, fallback[density]))
+
+
+def _date_axis_config(*, compact: bool) -> tuple[int, float, float]:
+    """Calendar date-axis knobs of a mode, from ``plots.yaml``.
+
+    ``(date_monthly_max_months, date_centered_min_fraction,
+    date_label_gap_em)``.
+    """
+    cfg = COMPACT_CONFIG if compact else LINE_CONFIG
+    return (
+        int(cfg.get("date_monthly_max_months", 24)),
+        float(cfg.get("date_centered_min_fraction", 0.5)),
+        float(cfg.get("date_label_gap_em", 0.3)),
+    )
+
+
 def dynamic_dpi(fig: Figure) -> int:
     """Save DPI adapted to the figure's physical size.
 
@@ -804,6 +863,188 @@ def _date_label_ha(
     return "right" if rotation > 0 else "left"
 
 
+def _style_date_labels(ax: Axes, rot: float, *, minor: bool) -> None:
+    """Tilt the date labels *rot* degrees with the matching anchor.
+
+    Rotation goes in the axis tick kwargs; ``ha`` and the anchor rotation
+    mode are per-label Text properties, so they are 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", which="minor" if minor else "major", rotation=rot
+    )
+    for label in ax.get_xticklabels(minor=minor):
+        label.set_horizontalalignment(ha)
+        if rot != 0:
+            label.set_rotation_mode("anchor")
+
+
+def _layout_texts(layout: DateLayout, *, pin_start: bool) -> list[str]:
+    """The label texts of *layout*, as the axis will print them."""
+    if layout.centered:
+        # centred: each label names its period
+        return [
+            period_label(p, layout.step, first=i == 0)
+            for i, p in enumerate(layout.periods)
+        ]
+    values = [float(cast(Any, date2num(t))) for t in layout.ticks]
+    formatter = _tick_formatter(FixedLocator(values), values[0], pin_start)
+    return list(formatter.format_ticks(values))
+
+
+def _tick_formatter(
+    locator: FixedLocator, start: float, pin_start: bool
+) -> ConciseDateFormatter:
+    return (
+        _StartLabeledConcise(locator, start)
+        if pin_start
+        else ConciseDateFormatter(locator)
+    )
+
+
+def calendar_date_axis(
+    ax: Axes,
+    layouts: list[DateLayout],
+    *,
+    pin_start: bool,
+    rotation: float | None = None,
+    auto_rotate: bool = False,
+    gap_em: float = 0.3,
+) -> DateLayout:
+    """Label every year (or month) the axis can hold.
+
+    *layouts* are the candidate calendar steps, finest first (see
+    :func:`tesorotools.artists._dates.date_layouts`).  Each one's labels
+    are measured at their real size and position, and the first whose
+    labels do not overlap wins: a decade shows every year, thirty years
+    fall back to one every two or five.  When none fits, the coarsest is
+    used.  Returns the layout drawn.
+
+    With the start pinned, the first calendar tick gives way to the
+    (wider) start label when they collide and it lies under half a step
+    from the start: a series from October 2015 shows ``oct. 2015``,
+    2017, 2018...  Further away, dropping it would read as a skipped
+    year, so that step counts as not fitting.
+
+    Centred layouts (``date_labels: centered``) put the tick marks on the
+    period boundaries and the labels, as minor ticks without a mark, in
+    the middle of each period.
+
+    ``rotation`` tilts the labels.  ``auto_rotate`` (ignored when a
+    rotation is given) tries 0, 30, 45, 60 and 90 degrees and keeps the
+    flattest tilt that reaches the finest step any of them reaches.
+
+    Neighbouring labels must stay *gap_em* ems apart
+    (``date_label_gap_em`` in ``plots.yaml``).
+    """
+    fig = ax.get_figure()
+    assert fig is not None
+    # settle the layout so dates map to their final pixels
+    fig.canvas.draw()  # type: ignore[reportUnknownMemberType]
+    renderer = fig.canvas.get_renderer()  # type: ignore[reportUnknownMemberType]
+    font = ax.xaxis.get_major_ticks()[0].label1.get_fontproperties()
+    # a fixed share of an em between neighbouring labels, whatever the dpi
+    pad_px = (
+        float(
+            renderer.points_to_pixels(font.get_size_in_points())  # type: ignore[reportUnknownMemberType]
+        )
+        * gap_em
+    )
+
+    def _boxes(layout: DateLayout, rot: float) -> list[Any]:
+        texts = _layout_texts(layout, pin_start=pin_start)
+        ha = _date_label_ha(None if rot == 0 else rot)
+        boxes: list[Any] = []
+        for when, text in zip(layout.labels, texts):
+            x_px = float(
+                ax.transData.transform((float(cast(Any, date2num(when))), 0))[0]
+            )
+            probe = Text(
+                x_px,
+                0.0,
+                text,
+                fontproperties=font,
+                rotation=rot,
+                horizontalalignment=ha,
+                rotation_mode="anchor" if rot != 0 else "default",
+            )
+            probe.set_figure(fig)
+            boxes.append(probe.get_window_extent(renderer))  # type: ignore[reportUnknownArgumentType]
+        return boxes
+
+    def _fit(layout: DateLayout, rot: float) -> list[int] | None:
+        boxes = _boxes(layout, rot)
+        kept = list(range(len(boxes)))
+        centered = layout.centered
+        if pin_start and not centered and len(kept) > 2:
+            # the first calendar tick may give way to the (wider) start
+            # label only when it sits under half a step from the start:
+            # further away, dropping it would open a gap that reads as a
+            # skipped year, so the step does not fit instead
+            when = [float(cast(Any, date2num(t))) for t in layout.ticks]
+            near = when[1] - when[0] < (when[2] - when[1]) / 2
+            if near and boxes[1].x0 <= boxes[0].x1 + pad_px:
+                kept.pop(1)
+        clear = all(
+            boxes[b].x0 > boxes[a].x1 + pad_px for a, b in zip(kept, kept[1:])
+        )
+        return kept if clear else None
+
+    tilts = (
+        (0.0, 30.0, 45.0, 60.0, 90.0)
+        if auto_rotate and rotation is None
+        else (0.0 if rotation is None else float(rotation),)
+    )
+    best: tuple[int, float, list[int]] | None = None
+    for rot in tilts:
+        for i, layout in enumerate(layouts):
+            if best is not None and i >= best[0]:
+                break
+            kept = _fit(layout, rot)
+            if kept is not None:
+                best = (i, rot, kept)
+                break
+        if best is not None and best[0] == 0:
+            break
+    if best is None:
+        coarsest = layouts[-1]
+        best = (len(layouts) - 1, tilts[0], list(range(len(coarsest.labels))))
+    index, rot, kept = best
+    layout = layouts[index]
+    centered = layout.centered
+
+    if centered:
+        major = FixedLocator(
+            [float(cast(Any, date2num(t))) for t in layout.ticks]
+        )
+        ax.xaxis.set_major_locator(major)
+        ax.xaxis.set_major_formatter(NullFormatter())
+        texts = _layout_texts(layout, pin_start=pin_start)
+        ax.xaxis.set_minor_locator(
+            FixedLocator(
+                [float(cast(Any, date2num(layout.labels[k]))) for k in kept]
+            )
+        )
+        ax.xaxis.set_minor_formatter(FixedFormatter([texts[k] for k in kept]))
+        ax.tick_params(  # type: ignore[reportUnknownMemberType]
+            axis="x",
+            which="minor",
+            length=0,
+            labelsize=ax.xaxis.get_major_ticks()[0].label1.get_fontsize(),
+        )
+    else:
+        values = [float(cast(Any, date2num(layout.ticks[k]))) for k in kept]
+        fixed = FixedLocator(values)
+        ax.xaxis.set_major_locator(fixed)
+        ax.xaxis.set_major_formatter(
+            _tick_formatter(fixed, values[0], pin_start)
+        )
+    fig.canvas.draw()  # type: ignore[reportUnknownMemberType]
+    _style_date_labels(ax, rot, minor=centered)
+    return layout
+
+
 def compact_date_axis(
     ax: Axes,
     data_min: Any,
@@ -813,8 +1054,22 @@ def compact_date_axis(
     rotation: float | None = None,
     pin_start: bool | None = None,
     auto_rotate: bool = False,
+    max_labels: int | None = None,
+    step: str = "auto",
+    labels: str = "tick",
 ) -> None:
-    """Compact date x-axis: few ticks, anchored to the data span.
+    """Compact date x-axis: as many calendar dates as fit the narrow figure.
+
+    The axis labels every year (or, over two years at most, every month)
+    that fits in the width without overlapping and within *max_labels*
+    (``None`` reads ``compact.date_max_labels`` for the default density),
+    stepping to one every 2, 5, 10... years only when they do not fit;
+    ``step`` (``"1Y"``, ``"3M"``...) fixes the step instead, and
+    ``labels="centered"`` centres each year over its stretch.  See
+    :func:`calendar_date_axis`.
+
+    Spans too short for a calendar grid (a few weeks of daily data) keep
+    the historical behaviour described below, with *maxticks* ticks.
 
     Ticks are computed over the **data span** ``[data_min,
     data_max]`` and pinned with a ``FixedLocator``, so none
@@ -853,6 +1108,31 @@ def compact_date_axis(
         if pin_start is None
         else pin_start
     )
+    monthly_max, min_fraction, gap_em = _date_axis_config(compact=True)
+    layouts = date_layouts(
+        data_min,
+        data_max,
+        step=step,
+        max_labels=(
+            date_max_labels("default", compact=True)
+            if max_labels is None
+            else max_labels
+        ),
+        monthly_max_months=monthly_max,
+        pin_start=show_start,
+        centered=labels == "centered",
+        min_fraction=min_fraction,
+    )
+    if layouts:
+        calendar_date_axis(
+            ax,
+            layouts,
+            pin_start=show_start,
+            rotation=rotation,
+            auto_rotate=auto_rotate,
+            gap_em=gap_em,
+        )
+        return
     # same span-clipped ticks (and same pinned start) the non-compact axis
     # uses, so both modes answer "when does this start?" identically
     ticks: list[float] = date_span_ticks(
@@ -958,8 +1238,20 @@ def apply_date_axis(
     data_min: Any = None,
     data_max: Any = None,
     pin_start: bool = False,
+    max_labels: int | None = None,
+    step: str = "auto",
+    labels: str = "tick",
 ) -> None:
-    """Native matplotlib date x-axis with a soft tick count and optional slant.
+    """Native matplotlib date x-axis with every year (or month) that fits.
+
+    Given the ``data_min`` / ``data_max`` span, the axis labels every year
+    (or, over two years at most, every month) that fits in the width and
+    within *max_labels* (``None`` reads ``line.date_max_labels`` for the
+    default density), stepping to one every 2, 5, 10... years only when
+    they do not; ``step`` fixes the step and ``labels="centered"`` centres
+    each year over its stretch (see :func:`calendar_date_axis`).  The rest
+    of this docstring describes the fallback for spans too short for a
+    calendar grid, or when no span is given.
 
     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
@@ -984,6 +1276,31 @@ def apply_date_axis(
     ``rotation=None`` has to *actively* flatten them to keep the documented
     "horizontal unless asked" behaviour.
     """
+    if data_min is not None and data_max is not None:
+        monthly_max, min_fraction, gap_em = _date_axis_config(compact=False)
+        layouts = date_layouts(
+            data_min,
+            data_max,
+            step=step,
+            max_labels=(
+                date_max_labels("default", compact=False)
+                if max_labels is None
+                else max_labels
+            ),
+            monthly_max_months=monthly_max,
+            pin_start=pin_start,
+            centered=labels == "centered",
+            min_fraction=min_fraction,
+        )
+        if layouts:
+            calendar_date_axis(
+                ax,
+                layouts,
+                pin_start=pin_start,
+                rotation=rotation,
+                gap_em=gap_em,
+            )
+            return
     if pin_start and data_min is not None and data_max is not None:
         ticks = date_span_ticks(
             data_min, data_max, maxticks=maxticks, pin_start=True
@@ -1226,8 +1543,9 @@ def style_compact_axes(
     :func:`declutter_spines`.
     """
     if font_pt is not None:
+        # which="both": centred date labels live on the minor ticks
         ax.tick_params(  # type: ignore[reportUnknownMemberType]
-            axis="both", labelsize=font_pt
+            axis="both", which="both", labelsize=font_pt
         )
     if side == "right":
         ax.yaxis.tick_right()

tesorotools_python-0.1.8/src/tesorotools/artists/_dates.py

@@ -0,0 +1,238 @@
+"""Calendar grids for date x-axes: every year (or month) the axis can hold.
+
+Pure date maths shared by the matplotlib date axes in ``_common`` and by
+the Plotly backend: which calendar steps are worth trying over a span,
+where their ticks fall and, for centred labels, where each period label
+sits.  Nothing here draws or measures text; picking the finest step whose
+labels actually fit is the caller's job.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+import pandas as pd
+
+#: Calendar steps, finest first. ``M`` counts months, ``Y`` years; the
+#: month steps divide a year, so January is always on the grid.
+DATE_STEPS: tuple[str, ...] = (
+    "1M",
+    "2M",
+    "3M",
+    "6M",
+    "1Y",
+    "2Y",
+    "5Y",
+    "10Y",
+    "20Y",
+    "50Y",
+)
+
+#: How a date label relates to its tick: under it, or centred over the
+#: period (year or month) that starts at the tick.
+DATE_LABEL_MODES: tuple[str, ...] = ("tick", "centered")
+
+
+@dataclass(frozen=True)
+class DateLayout:
+    """Where one calendar step puts the tick marks and the labels.
+
+    ``ticks`` are the tick marks.  ``labels`` are the label positions;
+    with ``tick`` labels they are the ticks themselves, with ``centered``
+    labels they sit mid-period.  ``periods`` holds, per label, the date
+    that names it (the tick itself, or the start of its period).
+    """
+
+    step: str
+    ticks: list[pd.Timestamp]
+    labels: list[pd.Timestamp]
+    periods: list[pd.Timestamp]
+    centered: bool = False
+
+
+def check_date_step(step: str) -> str:
+    """Return *step* when it is ``auto`` or one of :data:`DATE_STEPS`."""
+    if step != "auto" and step not in DATE_STEPS:
+        raise ValueError(
+            f"date_step must be 'auto' or one of {DATE_STEPS}: {step!r}"
+        )
+    return step
+
+
+def check_date_labels(mode: str) -> str:
+    """Return *mode* when it is one of :data:`DATE_LABEL_MODES`."""
+    if mode not in DATE_LABEL_MODES:
+        raise ValueError(
+            f"date_labels must be one of {DATE_LABEL_MODES}: {mode!r}"
+        )
+    return mode
+
+
+def _parse(step: str) -> tuple[str, int]:
+    return step[-1], int(step[:-1])
+
+
+def _month_index(ts: pd.Timestamp) -> int:
+    return ts.year * 12 + ts.month - 1
+
+
+def _month_start(index: int) -> pd.Timestamp:
+    return pd.Timestamp(year=index // 12, month=index % 12 + 1, day=1)
+
+
+def _period_starts(
+    lo: pd.Timestamp, hi: pd.Timestamp, step: str, *, anchor_year: int
+) -> list[pd.Timestamp]:
+    """Calendar boundaries of *step* from the one at or before *lo* to *hi*.
+
+    Year steps run from ``anchor_year`` (so a two-year step over a series
+    starting in 2015 gives 2015, 2017, 2019 and not the calendar 2016,
+    2018); month steps stay on the calendar grid (quarters start in
+    January, April, July and October), which keeps January, and so the
+    year, on the axis.
+    """
+    unit, n = _parse(step)
+    if unit == "Y":
+        return [
+            pd.Timestamp(year=y, month=1, day=1)
+            for y in range(anchor_year, hi.year + 1, n)
+        ]
+    first = _month_index(lo) - _month_index(lo) % n
+    return [_month_start(i) for i in range(first, _month_index(hi) + 1, n)]
+
+
+def _tick_layout(
+    lo: pd.Timestamp, hi: pd.Timestamp, step: str, *, pin_start: bool
+) -> DateLayout:
+    # pinned, the start label stands for its own year, so the grid is
+    # anchored there; unpinned, at the first year boundary inside the span
+    on_new_year = lo == pd.Timestamp(year=lo.year, month=1, day=1)
+    anchor = lo.year if pin_start or on_new_year else lo.year + 1
+    grid = [
+        t
+        for t in _period_starts(lo, hi, step, anchor_year=anchor)
+        if lo < t <= hi or (not pin_start and t == lo)
+    ]
+    ticks = [lo, *grid] if pin_start else grid
+    return DateLayout(step, ticks, ticks, ticks)
+
+
+def _centered_layout(
+    lo: pd.Timestamp, hi: pd.Timestamp, step: str, *, min_fraction: float
+) -> DateLayout:
+    unit, _n = _parse(step)
+    length = pd.DateOffset(years=1) if unit == "Y" else pd.DateOffset(months=1)
+    starts = _period_starts(lo, hi, step, anchor_year=lo.year)
+    labels: list[pd.Timestamp] = []
+    periods: list[pd.Timestamp] = []
+    for start in starts:
+        end = start + length
+        shown_lo = max(start, lo)
+        shown_hi = min(end, hi)
+        # a sliver of a year at either edge would push its label off the
+        # plot: label a period only when enough of it is drawn
+        if shown_hi - shown_lo >= (end - start) * min_fraction:
+            labels.append(shown_lo + (shown_hi - shown_lo) / 2)
+            periods.append(start)
+    ticks = [t for t in starts if lo <= t <= hi]
+    return DateLayout(step, ticks, labels, periods, centered=True)
+
+
+def date_layout(
+    data_min: Any,
+    data_max: Any,
+    step: str,
+    *,
+    pin_start: bool,
+    centered: bool = False,
+    min_fraction: float = 0.5,
+) -> DateLayout:
+    """Ticks and labels that *step* puts over ``[data_min, data_max]``.
+
+    With ``tick`` labels (the default) every tick is labelled and, with
+    ``pin_start``, the first datum leads as its own tick.  With
+    ``centered`` labels the ticks mark where each period starts and its
+    name sits in the middle of the part drawn; ``pin_start`` is ignored
+    there, since the first label already names the starting period.
+    """
+    lo = pd.Timestamp(data_min)
+    hi = pd.Timestamp(data_max)
+    if centered:
+        return _centered_layout(lo, hi, step, min_fraction=min_fraction)
+    return _tick_layout(lo, hi, step, pin_start=pin_start)
+
+
+def date_layouts(
+    data_min: Any,
+    data_max: Any,
+    *,
+    step: str,
+    max_labels: int,
+    monthly_max_months: int,
+    pin_start: bool,
+    centered: bool = False,
+    min_fraction: float = 0.5,
+) -> list[DateLayout]:
+    """Candidate layouts for the span, finest first.
+
+    An explicit *step* is the only candidate.  With ``auto``, month steps
+    are tried only over spans up to *monthly_max_months* (beyond that the
+    axis reads in years), and a step is kept when it gives between two
+    and *max_labels* labels.  An empty list means no calendar step suits
+    the span (a few weeks of daily data, say) and the caller falls back to
+    matplotlib's own date locator.
+    """
+    lo = pd.Timestamp(data_min)
+    hi = pd.Timestamp(data_max)
+    if step != "auto":
+        pool: tuple[str, ...] = (step,)
+        limit = None
+    else:
+        months = _month_index(hi) - _month_index(lo)
+        pool = tuple(
+            s
+            for s in DATE_STEPS
+            if months <= monthly_max_months or s.endswith("Y")
+        )
+        limit = max_labels
+    layouts: list[DateLayout] = []
+    for candidate in pool:
+        layout = date_layout(
+            lo,
+            hi,
+            candidate,
+            pin_start=pin_start,
+            centered=centered,
+            min_fraction=min_fraction,
+        )
+        count = len(layout.labels)
+        if count >= 2 and (limit is None or count <= limit):
+            layouts.append(layout)
+    return layouts
+
+
+def period_label(
+    period: pd.Timestamp, step: str, *, first: bool = False
+) -> str:
+    """Text of a centred label: the year, or the month (the year in January).
+
+    The *first* month label carries its year too (``may. 2024``) unless
+    it is January, so the reader knows which year the axis starts in.
+    """
+    unit, _n = _parse(step)
+    if unit == "Y" or period.month == 1:
+        return str(period.year)
+    if first:
+        # locale's %b may already end in a dot ("may."): avoid "may.. 2024"
+        month = period.strftime("%b").lower().rstrip(".")
+        return f"{month}. {period.year}"
+    return period.strftime("%b")
+
+
+def plotly_dtick(data_min: Any, step: str) -> tuple[str, str]:
+    """Plotly ``(dtick, tick0)`` for *step*, anchored as the PNG axis is."""
+    unit, n = _parse(step)
+    if unit == "Y":
+        return f"M{12 * n}", f"{pd.Timestamp(data_min).year}-01-01"
+    return f"M{n}", "2000-01-01"