tesorotools-python 0.1.7__py3-none-any.whl → 0.1.8__py3-none-any.whl

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/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"

tesorotools/artists/line_plot.py

@@ -39,6 +39,7 @@ from tesorotools.artists._common import (
     compact_font_pt,
     compact_headroom_pad_pt,
     compact_y_axis,
+    date_max_labels,
     date_maxticks,
     date_show_start_default,
     draw_vlines,
@@ -50,6 +51,7 @@ from tesorotools.artists._common import (
     style_compact_axes,
     style_spines,
 )
+from tesorotools.artists._dates import check_date_labels, check_date_step
 from tesorotools.utils.matplotlib import format_annotation
 from tesorotools.utils.template import TemplateLoader
 
@@ -128,12 +130,19 @@ class LinePlot(FigureLifecycle):
       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
+    * Date axis -- the x-axis labels **every year** that fits in
+      its width without overlapping (every month over spans of up to
+      ``date_monthly_max_months``, 24 by default), and only steps to
+      one every 2, 5, 10... years when they do not fit or would pass
+      the ``date_max_labels`` cap of the density level (15 at full
+      size, 8 in compact by default; both in ``plots.yaml``).
+      Spans too short for a calendar grid (a few weeks of daily data)
+      keep matplotlib's own date ticks, ``date_maxticks`` of them.
+    * ``date_density`` -- how many date labels the x-axis may show:
+      ``"few"`` / ``"default"`` / ``"many"``, mapped to the cap
+      ``date_max_labels`` per mode in ``plots.yaml``
+      (``compact.date_max_labels`` / ``line.date_max_labels``). 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),
@@ -160,6 +169,19 @@ class LinePlot(FigureLifecycle):
       blank), so in non-compact mode this switches the x-axis to
       the concise date labels -- a visible change of label *style*
       against the historical pandas one.
+    * ``date_step`` -- fix the date step instead of fitting it:
+      ``"1M"``, ``"2M"``, ``"3M"``, ``"6M"``, ``"1Y"``, ``"2Y"``,
+      ``"5Y"``, ``"10Y"``, ``"20Y"`` or ``"50Y"``. ``"auto"`` (the
+      default) picks the finest step that fits. A fixed step is drawn
+      even if its labels overlap.
+    * ``date_labels`` -- ``"tick"`` (the default) puts each label
+      under its tick; ``"centered"`` marks the start of each year (or
+      month) with a tick and centres its label over the stretch it
+      covers, the usual look for long monthly series. A year at
+      either edge is labelled only when at least
+      ``date_centered_min_fraction`` of it is drawn (half by default,
+      in ``plots.yaml``). The first label already names the starting
+      year, so ``date_show_start`` does not apply.
     * ``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
@@ -232,6 +254,8 @@ class LinePlot(FigureLifecycle):
         date_density: str = "default",
         date_rotation: float | None = None,
         date_show_start: bool | None = None,
+        date_step: str = "auto",
+        date_labels: str = "tick",
         adapt_height: bool = True,
         ref_lines: list[dict[str, Any]] | None = None,
         show_means: bool = False,
@@ -285,6 +309,8 @@ class LinePlot(FigureLifecycle):
         self.date_density = date_density
         self.date_rotation = date_rotation
         self.date_show_start = date_show_start
+        self.date_step = check_date_step(date_step)
+        self.date_labels = check_date_labels(date_labels)
         self.adapt_height = adapt_height
         self.ref_lines = ref_lines or []
         self.show_means = show_means
@@ -307,8 +333,9 @@ class LinePlot(FigureLifecycle):
     def _custom_date_axis(self) -> bool:
         """Whether the non-compact chart takes over the x-axis for dates.
 
-        When the user asks for a non-default density or a rotation, or when
-        the start date is pinned: all three need a **native** date axis,
+        When the user asks for a non-default density, step, label mode or
+        a rotation, or when the start date is pinned: all of them need a
+        **native** date axis,
         because pandas' own date plotting owns its locator and formatter (and
         labels a pinned tick blank). With none of them the historical pandas
         date plotting is kept untouched. Compact mode has its own date axis
@@ -317,6 +344,8 @@ class LinePlot(FigureLifecycle):
         return not self.compact and (
             self.date_density != "default"
             or self.date_rotation is not None
+            or self.date_step != "auto"
+            or self.date_labels != "tick"
             or self._pin_start_date
         )
 
@@ -345,6 +374,7 @@ class LinePlot(FigureLifecycle):
         ``plot_size``, ``vlines``, ``compact``, ``font_pt``,
         ``axis_decimals``, ``axis_units``, ``annotate_units``,
         ``date_density``, ``date_rotation``, ``date_show_start``,
+        ``date_step``, ``date_labels``,
         ``adapt_height``,
         ``ref_lines``, ``show_means``, ``means_window``,
         ``y_limits``, ``y_group``.
@@ -611,10 +641,19 @@ class LinePlot(FigureLifecycle):
             )
 
         if self.compact:
+            # 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
+            # the end-of-series value labels. style_compact_axes also pins
+            # the tick label size -- BEFORE the date axis, which measures the
+            # labels at that size to fit as many years as it can -- and
+            # drops the now-tickless spines.
+            side = "left" if self.annotate else "right"
+            style_compact_axes(ax, font_pt, side=side)
             # 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.
-            # date_density -> maxticks; date_rotation tilts the labels.
+            # date_density -> label cap; date_rotation tilts the labels.
             # The start tick is pinned whatever the density or rotation: an
             # even calendar cadence used to win here, but then asking for
             # more (or slanted) dates silently cost you the one date the
@@ -632,14 +671,10 @@ class LinePlot(FigureLifecycle):
                     self.date_density != "default"
                     and self.date_rotation is None
                 ),
+                max_labels=date_max_labels(self.date_density, compact=True),
+                step=self.date_step,
+                labels=self.date_labels,
             )
-            # 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
-            # the end-of-series value labels. style_compact_axes also pins
-            # the tick label size and drops the now-tickless spines.
-            side = "left" if self.annotate else "right"
-            style_compact_axes(ax, font_pt, side=side)
             # denser y-numbers (e.g. every 20 instead of every 50) so the
             # small chart still has enough reference gridlines.
             compact_y_axis(ax)
@@ -655,6 +690,9 @@ class LinePlot(FigureLifecycle):
                 data_min=plot_data.index.min(),
                 data_max=plot_data.index.max(),
                 pin_start=self._pin_start_date,
+                max_labels=date_max_labels(self.date_density, compact=False),
+                step=self.date_step,
+                labels=self.date_labels,
             )
 
         if self.legend is not None:

tesorotools/artists/plotly_backend.py

@@ -53,6 +53,7 @@ import numpy as np
 import plotly.graph_objects as go
 
 from tesorotools.artists._common import AX_CONFIG, Legend
+from tesorotools.artists._dates import plotly_dtick
 from tesorotools.utils.matplotlib import PLOT_CONFIG, format_annotation
 
 if TYPE_CHECKING:
@@ -239,6 +240,20 @@ def _fit_bar_range(fig: go.Figure, values: Any, pad_frac: float = 0.25) -> None:
     )
 
 
+def _date_axis(fig: go.Figure, start: Any, step: str, labels: str) -> None:
+    """Fixed date step and centred labels, as on the PNG axis.
+
+    With ``date_step: auto`` the interactive axis keeps Plotly's own
+    ticks, which adapt to zoom; a fixed step becomes ``dtick`` (anchored
+    like the PNG grid) and centred labels ``ticklabelmode="period"``.
+    """
+    if step != "auto":
+        dtick, tick0 = plotly_dtick(start, step)
+        fig.update_xaxes(dtick=dtick, tick0=tick0)
+    if labels == "centered":
+        fig.update_xaxes(ticklabelmode="period")
+
+
 def _padded_range(values: list[float], margin: float) -> list[float]:
     """Span *values* with *margin* padding (mirrors vector's ``_set_limits``)."""
     lo, hi = min(values), max(values)
@@ -310,6 +325,7 @@ def line_plot_to_figure(chart: LinePlot) -> go.Figure:
     # fixed or group-shared y range (see share_y_axes)
     if chart.y_limits is not None:
         fig.update_yaxes(range=list(chart.y_limits))
+    _date_axis(fig, plot_data.index.min(), chart.date_step, chart.date_labels)
     _legend_side(fig, chart.legend)
     return fig
 
@@ -447,6 +463,7 @@ def stacked_area_to_figure(chart: StackedAreaPlot) -> go.Figure:
         _baseline(fig, 0)
     if chart.fmt.units:
         fig.update_yaxes(ticksuffix=chart.fmt.units)
+    _date_axis(fig, plot_data.index.min(), chart.date_step, chart.date_labels)
     _legend_side(fig, chart.legend)
     return fig
 

tesorotools/artists/stacked.py

@@ -29,6 +29,7 @@ from tesorotools.artists._common import (
     style_compact_axes,
     style_spines,
 )
+from tesorotools.artists._dates import check_date_labels, check_date_step
 from tesorotools.utils.template import TemplateLoader
 
 
@@ -45,6 +46,11 @@ class StackedAreaPlot(FigureLifecycle):
     ``false`` leaves the plain calendar grid.  Pinning takes
     over the x-axis, so at full size the date labels switch to
     the concise style.
+
+    The date axis labels every year (or month) that fits, like
+    ``LinePlot``'s; ``date_step`` fixes the step (``"1Y"``,
+    ``"3M"``...) and ``date_labels: centered`` centres each label
+    over its year or month.
     """
 
     #: Keys that change the PNG but never the ``to_plotly()`` figure
@@ -80,6 +86,8 @@ class StackedAreaPlot(FigureLifecycle):
         compact: bool = False,
         font_pt: float | None = None,
         date_show_start: bool | None = None,
+        date_step: str = "auto",
+        date_labels: str = "tick",
     ) -> None:
         if out_path.suffix != ".png":
             raise ValueError(f"out_path must be .png: {out_path}")
@@ -95,6 +103,8 @@ class StackedAreaPlot(FigureLifecycle):
         self.figsize = figsize
         self.plot_size = plot_size
         self.date_show_start = date_show_start
+        self.date_step = check_date_step(date_step)
+        self.date_labels = check_date_labels(date_labels)
         self.compact = compact
         self.font_pt = font_pt
 
@@ -117,7 +127,7 @@ class StackedAreaPlot(FigureLifecycle):
         -------------
         ``scale``, ``start_date``, ``end_date``, ``baseline``,
         ``fmt`` (``!format``), ``legend`` (``!legend``),
-        ``date_show_start``,
+        ``date_show_start``, ``date_step``, ``date_labels``,
         ``figsize``, ``plot_size``, ``compact`` (fixed
         physical size, body-size text, legend in its own band
         and a sparse concise date axis, for two charts per row),
@@ -215,24 +225,29 @@ class StackedAreaPlot(FigureLifecycle):
             else self.date_show_start
         )
         if self.compact:
-            # sparse concise date axis (a few ticks across the narrow figure)
-            # plus body-size ticks and the house right-hand y-axis.
+            # body-size ticks and the house right-hand y-axis first, so the
+            # date axis measures its labels at their real size, then every
+            # year (or month) that fits across the narrow figure.
+            style_compact_axes(ax, font_pt, side="right")
             compact_date_axis(
                 ax,
                 plot_data.index.min(),
                 plot_data.index.max(),
                 pin_start=pin_start,
+                step=self.date_step,
+                labels=self.date_labels,
             )
-            style_compact_axes(ax, font_pt, side="right")
-        elif pin_start:
+        else:
             # stackplot already draws on a native date axis, so the ticks can
-            # be pinned to the span with the first date spelled out
+            # be laid on the calendar grid with the first date spelled out
             apply_date_axis(
                 ax,
                 maxticks=date_maxticks("default", compact=False),
                 data_min=plot_data.index.min(),
                 data_max=plot_data.index.max(),
-                pin_start=True,
+                pin_start=pin_start,
+                step=self.date_step,
+                labels=self.date_labels,
             )
 
         place_legend(

tesorotools/assets/plots.yaml

@@ -139,6 +139,22 @@ line:
     few: 3
     default: 6
     many: 14
+  # Eje de fechas por calendario: se etiqueta CADA año (o cada mes en
+  # periodos de hasta date_monthly_max_months meses) si las etiquetas caben
+  # sin solaparse y no pasan de date_max_labels; si no, se salta a uno cada
+  # 2, 5, 10... años. date_maxticks solo queda para periodos demasiado
+  # cortos para una rejilla de calendario (unas semanas de datos diarios).
+  date_max_labels:
+    few: 6
+    default: 15
+    many: 30
+  date_monthly_max_months: 24
+  # Con `date_labels: centered`, un año (o mes) de los extremos solo se
+  # etiqueta si se dibuja al menos esta fracción de él
+  date_centered_min_fraction: 0.5
+  # Hueco mínimo entre dos etiquetas de fecha vecinas, en ems (fracción del
+  # tamaño de letra): por debajo se considera que se pisan
+  date_label_gap_em: 0.3
   # Fija la fecha del PRIMER dato como primer tick del eje X, para que siempre
   # se vea desde cuando se dibuja la serie (el tick "bonito" de calendario cae
   # normalmente antes del primer dato, y entonces una serie que empieza en
@@ -227,6 +243,17 @@ compact:
     few: 3
     default: 4
     many: 12
+  # Eje de fechas por calendario (ver line.date_max_labels): todos los años
+  # que quepan en el ancho compact, con un máximo de etiquetas por nivel
+  date_max_labels:
+    few: 4
+    default: 8
+    many: 14
+  date_monthly_max_months: 24
+  date_centered_min_fraction: 0.5
+  # Hueco mínimo entre dos etiquetas de fecha vecinas, en ems (fracción del
+  # tamaño de letra): por debajo se considera que se pisan
+  date_label_gap_em: 0.3
   # 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

tesorotools/note/lint.py

@@ -598,6 +598,8 @@ _ABBREVIATION = re.compile(
     re.I,
 )
 _BOLD_RULE = "negrita solo en la entradilla, no en cifras ni frases sueltas"
+#: A footnote in the text, ``^[...]`` (one level of brackets inside).
+_NOTE_MARKUP = re.compile(r"\^\[(?:[^\[\]]|\[[^\]]*\])*\]")
 
 
 def _ends_sentence(text: str) -> bool:
@@ -652,7 +654,9 @@ def _bold_issues(line: int, text: str, *, lead: bool) -> Iterator[Issue]:
         yield Issue(line, "negrita", _BOLD_RULE)
     if not starts_bold:
         return
-    if re.match(r"^\s*\*\*[^*]+\*\*[^\s*:;,.)]", text):
+    # without its footnotes: the «**» of a note's own lead
+    # («**Lead^[**Término**: ...] sigue.**») is not the end of the lead
+    if re.match(r"^\s*\*\*[^*]+\*\*[^\s*:;,.)]", _NOTE_MARKUP.sub("", text)):
         yield Issue(
             line,
             "entradilla",

tesorotools/providers/lseg.py

@@ -650,6 +650,23 @@ class LSEGProvider(DataProvider):
           RIC.
         - **Flat columns labelled by RIC** — single-field call against
           multiple RICs (degenerate). Returned as-is.
+
+        Rows are only sorted by date, with a stable sort so that a date
+        returned twice keeps the response's order and the by-index
+        de-dup of :meth:`_download_batch` keeps the first copy the
+        source sent. They are **never** de-duplicated here, and
+        in particular never by value. Up to 0.1.7 every branch ended in
+        ``drop_duplicates()``, which compares the *values* of a row, not
+        its date: every session whose close had already appeared earlier
+        in the response was deleted, and :meth:`_download_batch`
+        reindexed the hole to NaN, so a caller that forward-fills (the
+        usual convention of a daily store) kept the previous session's
+        close in its place. A three-decimal yield revisits the same
+        figure hundreds of times in a 2 500-day window, so seeded
+        histories came out with up to half their sessions frozen. The
+        same close on two sessions is two observations; a date returned
+        twice is a different thing, and :meth:`_download_batch` drops it
+        by index.
         """
         if df.empty:
             return pd.DataFrame(columns=pd.Index(rics))
@@ -662,7 +679,7 @@ class LSEGProvider(DataProvider):
                 if key in df.columns:
                     picked[ric] = df[key]
             return (
-                pd.DataFrame(picked).drop_duplicates().sort_index()
+                pd.DataFrame(picked).sort_index(kind="stable")
                 if picked
                 else pd.DataFrame(columns=pd.Index(rics))
             )
@@ -671,14 +688,10 @@ class LSEGProvider(DataProvider):
             ric = rics[0]
             field = field_per_ric[ric]
             if field in df.columns:
-                return (
-                    pd.DataFrame({ric: df[field]})
-                    .drop_duplicates()
-                    .sort_index()
-                )
+                return pd.DataFrame({ric: df[field]}).sort_index(kind="stable")
             return pd.DataFrame(columns=pd.Index([ric]))
 
-        return df.drop_duplicates().sort_index()
+        return df.sort_index(kind="stable")
 
     # ------------------------------------------------------------------
     # Internal: per-RIC batched range download (close path)
@@ -748,6 +761,10 @@ class LSEGProvider(DataProvider):
                 df.index = dates
                 bdays_mask = ~dates.weekday.isin([5, 6])
                 df = df[bdays_mask]
+                # By date, never by value: the same close on two
+                # sessions is two observations. A business day the
+                # source does not print stays NaN after the reindex;
+                # filling it is the caller's decision.
                 df = df[~df.index.duplicated(keep="first")]
                 full_range = pd.date_range(
                     start=start_date, end=end_date, freq="B"
@@ -773,10 +790,23 @@ class LSEGProvider(DataProvider):
 
     @staticmethod
     def _unify_batches(csv_path: Path) -> pd.DataFrame:
+        """Merge every cached CSV partial into one column per RIC.
+
+        ``csv_path`` may hold partials of any range for the same RIC
+        (earlier runs, other ``start``/``end``), so the same date can
+        appear in several files. For each date the **newest file with a
+        figure** wins: files are read newest first (modification time,
+        then name for a stable tie-break) and the first non-NaN value
+        is kept. A NaN never hides a figure from another file, which
+        matters for partials written before 0.1.8, whose value-based
+        ``drop_duplicates()`` left holes; a date no file prints stays
+        NaN.
+        """
+        csv_files = [f for f in csv_path.iterdir() if f.suffix == ".csv"]
+        csv_files.sort(key=lambda f: (-f.stat().st_mtime_ns, f.name))
+
         same_col_groups: dict[str, list[pd.DataFrame]] = {}
-        for csv_file in csv_path.iterdir():
-            if csv_file.suffix != ".csv":
-                continue
+        for csv_file in csv_files:
             df = pd.read_csv(csv_file, index_col=_CSV_DATE_TITLE)
             col_name = df.columns[0]
             same_col_groups.setdefault(col_name, []).append(df)
@@ -784,9 +814,7 @@ class LSEGProvider(DataProvider):
         vertical_dfs: list[pd.DataFrame] = []
         for dfs in same_col_groups.values():
             concatenated = pd.concat(dfs, axis=0)
-            concatenated = concatenated[
-                ~concatenated.index.duplicated(keep="first")
-            ]
-            vertical_dfs.append(concatenated)
+            # ``first`` skips NaN: the newest file that prints the date.
+            vertical_dfs.append(concatenated.groupby(level=0).first())
 
         return pd.concat(vertical_dfs, axis=1).sort_index()

{tesorotools_python-0.1.7.dist-info → tesorotools_python-0.1.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tesorotools-python
-Version: 0.1.7
+Version: 0.1.8
 Requires-Python: >=3.13
 Requires-Dist: babel>=2.17
 Requires-Dist: matplotlib>=3.10

{tesorotools_python-0.1.7.dist-info → tesorotools_python-0.1.8.dist-info}/RECORD

@@ -8,27 +8,28 @@ tesorotools/palette.py,sha256=RHt_nSQXaIuGQzVVcgOaYzcvtQSEbK52ox1cOVcosyo,2122
 tesorotools/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tesorotools/scaffold.py,sha256=6mYNxLm_1CbEMjcYZ77m_2H1eTotbpatFJqhgyote0s,4578
 tesorotools/artists/__init__.py,sha256=wZTHZPB4Af6FVheWnTeuOmuzmCIG9mvziP3gHZW2nl0,2631
-tesorotools/artists/_common.py,sha256=YJtwXgt1atpoSUt_5siBQ81ry49_8srt2EzgxPuBktM,62628
+tesorotools/artists/_common.py,sha256=jeciBAyc9414OLHOyy_Mhx_1g_sE6RvvmsK3kaeloJQ,74361
+tesorotools/artists/_dates.py,sha256=bEEWJvlXHf9R3T0qN3Qpu8bue_o4DZP9WHZXyrrIeM0,7939
 tesorotools/artists/bar_line.py,sha256=8C-PuHQ8drXjTZeNsQ56R8UdQy2zvG6V270qrgFqetE,20319
 tesorotools/artists/barh_plot.py,sha256=n8DjIX1APCVS7HW4zzfh6ehggdgBqb6sezQHov1k7us,37520
 tesorotools/artists/box_plot.py,sha256=HfJ9gdAXE6wcMHG3sKMG0M2CcigkyPe2Wly7bBxq4nI,20413
 tesorotools/artists/compact.py,sha256=e_0tqkRSIgyiyMSwirJzj2TYSKojMxUHzug5tE_7toc,3003
 tesorotools/artists/intraday_plot.py,sha256=ucr5Riai0lfEgINOFm6qCuvZrGSQ4jfUmSSTxuSvIjM,13297
-tesorotools/artists/line_plot.py,sha256=GfOFhIlXIbUpKPD0STxUZCerogywhOMXl5PfiVf4xxE,31287
+tesorotools/artists/line_plot.py,sha256=MBQ8S4P6xnGzs0nr2auGm_R4UMhLS-AbhJMel5-w70o,33378
 tesorotools/artists/matrix.py,sha256=cOpj9ZO5RR0-RlIP55UmD70i-738ck8wZIqRiDO22Hw,11785
-tesorotools/artists/plotly_backend.py,sha256=1FR-X3mz1KbFJCFVx2CPuuibPgVkYvq4EizIv9iW0v0,42979
+tesorotools/artists/plotly_backend.py,sha256=YhkXJpuT5HRg8A7TvxqpKG-VSKW0H4OShd7QLB51GL8,43752
 tesorotools/artists/sankey.py,sha256=5rdWeih3AgIeqaQyUAhQMY8ZGAeVoEV4jHsi1HO3NTc,16269
 tesorotools/artists/scatter.py,sha256=CEkn_XDlX-u67O-sQxj5iPGIFewTC9J44gXTi1tYFx4,18117
 tesorotools/artists/sharing.py,sha256=Tg4AYtv0ileKQmzBSgmT1GzxA97tdU8ji_arE0oGEZ4,2236
 tesorotools/artists/shock_plot.py,sha256=fS8fi2OaIbWmG_I4FzaCF4U6i9a6tzKZSQH48l4ZobY,13473
-tesorotools/artists/stacked.py,sha256=MyItTb8NMOpR6jDclqjmofhAB-L9mD1vnzGQjXUTFBc,17439
+tesorotools/artists/stacked.py,sha256=B3NF1NzfHhK-YFjTgwoTiCEI2teX6mVtMyd3cbnnfDQ,18170
 tesorotools/artists/tikz_backend.py,sha256=zqCFa9A_amwBvGjrFULzKf8comL2-1aQx7_yEDFxXFo,5832
 tesorotools/artists/type_curve.py,sha256=0j1LjfS4Zdz4_W7qp-nY8VP0H-fENV5adUg4syAOvig,12570
 tesorotools/artists/vector_plot.py,sha256=P7BtLCXRTWs3eepRFYvXzbJ9OkvB-Ya3kmXB6yJSkR0,12211
 tesorotools/artists/waterfall.py,sha256=U40HB3gVj3lyuM4rwfnpuxpq0XE7zPRGspgKAoq9T-g,12386
 tesorotools/assets/README.md,sha256=EjDuA4Xf-Omn0Khp8erNXdW-iyWBzSM2FQFexdrS6Eg,285
 tesorotools/assets/nota_template.dotx,sha256=LC3qcMz4F3SGDkJ12VNNvinlP3f5rJH5qGU5ZtJgJuc,146199
-tesorotools/assets/plots.yaml,sha256=CxvgXBCuJnpSszZFQ-cDObV7-1yQdADfklnN1Lt4mHE,13217
+tesorotools/assets/plots.yaml,sha256=DU2O4eF2QORiLMF-uojYLOzXMan3azZ1ioJvqr7BeyM,14439
 tesorotools/assets/template.docx,sha256=QYilJmJ-ltGPH_GH22j6Kis7wmNaAgFQXr68d1KUSHY,94394
 tesorotools/assets/tesoro.mplstyle,sha256=9J3quXzu4Mhq0auHhU4RrKcHEnTCxTGgTP1GRGs8D-g,456
 tesorotools/assets/fonts/CabinetGrotesk-Black.otf,sha256=b7M_yFxz5IcGtmWWPMzLVkfx4RLhVALQDFeoq4T1YD0,37728
@@ -82,7 +83,7 @@ tesorotools/note/charts.py,sha256=7dUsCyURC39qOzLMU09mIm8Jh7B80ShBdRhpBNn6cUE,44
 tesorotools/note/cli.py,sha256=ZEzC4k7X6Go2LhVXqGAuBmqKrBdhxH4B7gWsUPabsJY,10685
 tesorotools/note/inline.py,sha256=FqpNKst1uLVvUtVHF9Q6ddhfFBKqeaOw1fXMLUvpHrw,12378
 tesorotools/note/issues.py,sha256=DZY6FblaInDyl0keen40nHt27w4mzpXz9VBMUjNdbu0,1456
-tesorotools/note/lint.py,sha256=PWGemiLoxOgp_ZrS4PoSkKYHLqPhJTBlAV04QfEH4oE,40390
+tesorotools/note/lint.py,sha256=jUgdAt1Qheh0PZo39qap2V5aRFRi_m6IG_ZzKz96Kbc,40678
 tesorotools/note/markdown.py,sha256=fk8lnBtbcVj6SaOU__ZqKRnDR3xQ46_xiRa0HMjUm3E,52823
 tesorotools/note/pdf.py,sha256=wQWrfSsCYGYxatANAn8FXXfZbMQ-4tYOp3y8lYVs1B4,4142
 tesorotools/note/skeleton.md,sha256=lWvoiHdTqt6fEc5WLu87HRkR7I9vOULM4yE5UTtkff4,2924
@@ -114,7 +115,7 @@ tesorotools/providers/bde.py,sha256=xbTwxzb013VyjHkXN88UvS_IQxklPv8j5rslzL_RQv4,
 tesorotools/providers/ecb.py,sha256=8UIW-NFLlGVIM7E2Sd_9UEWryt5wwilY3Hv13dnjY68,6422
 tesorotools/providers/fred.py,sha256=5Jk1kCOSeH86wGqPOexKSVgcVJABUUea0dQ7k4eWYlc,13132
 tesorotools/providers/imf_irfcl.py,sha256=ywix759wki5AfSTZGRnolf4LGYKqxj-23Xm8bmi3iT4,8106
-tesorotools/providers/lseg.py,sha256=paKdSxb1tWv26YCwMD0dEUfF4GLFJWzHukKII9WPges,30183
+tesorotools/providers/lseg.py,sha256=F8ePZfCEvykVXmP31FF_o931Up8EV1o_GokPXEy3WdI,32109
 tesorotools/render/__init__.py,sha256=wPbM3OMNx1R46K9KaIURxf7LNdcXIFj3eO0P7zkEqXo,662
 tesorotools/render/document.py,sha256=AiR909votacAWfZmeUekulRfZ-c5-bI6t5SnabibAd0,1136
 tesorotools/render/report.py,sha256=Gp7vAB-sfnnFRQyZXmlthlYMbtOxwQg_qh3ZWDweeNo,1385
@@ -159,7 +160,7 @@ tesorotools/web/templates/src/$package/main.py.tmpl,sha256=GXG3AA87WOjk5nTKA5Ywm
 tesorotools/web/templates/src/$package/sections.py.tmpl,sha256=4MNZ85AW5ERG1SrkVAXIwdmAMeQEBARCYdAMqUr37mg,2084
 tesorotools/web/templates/tests/__init__.py.tmpl,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tesorotools/web/templates/tests/test_app.py.tmpl,sha256=ZGfV5GPN6WsS3a2gCNLPWejkHTX2H_N9XpurIADuUxI,615
-tesorotools_python-0.1.7.dist-info/METADATA,sha256=1W3WDlBQRAKPRpED9lsjpuU3sMaafiA4lOXIn43nECc,1025
-tesorotools_python-0.1.7.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-tesorotools_python-0.1.7.dist-info/entry_points.txt,sha256=X0LciYC_rEvc6X1KGTKzQ6GvdDmSxdUy20_vg1Mcl6g,214
-tesorotools_python-0.1.7.dist-info/RECORD,,
+tesorotools_python-0.1.8.dist-info/METADATA,sha256=8Qjg10_TLhhQ9eadDIx9mrbpYsSpW2uIJHYp43dkB10,1025
+tesorotools_python-0.1.8.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+tesorotools_python-0.1.8.dist-info/entry_points.txt,sha256=X0LciYC_rEvc6X1KGTKzQ6GvdDmSxdUy20_vg1Mcl6g,214
+tesorotools_python-0.1.8.dist-info/RECORD,,