time-split 0.2.1__tar.gz → 0.4.0__tar.gz

{time_split-0.2.1 → time_split-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: time-split
-Version: 0.2.1
+Version: 0.4.0
 Summary: Time-based k-fold validation splits for heterogeneous data.
 Home-page: https://github.com/rsundqvist/time-split
 Author: Richard Sundqvist
@@ -58,7 +58,7 @@ strong non-stationary characteristics.
   a CRON-expression, or a pre-defined list.
 - [Data selection](https://time-split.readthedocs.io/en/stable/guide/spans.html) based on a timedelta, or the splitting 
   schedule itself.
-- Automatically extract and [normalize](https://time-split.readthedocs.io/en/stable/guide/flex.html) data limits for 
+- Automatically extract and [normalize](https://time-split.readthedocs.io/en/stable/guide/expand_limits.html) data limits for 
   supported data types.
 - [Plotting function](https://time-split.readthedocs.io/en/stable/generated/time_split.html#time_split.plot) for
   visualization of folds. Display fold sizes (hour/row count), or 

{time_split-0.2.1 → time_split-0.4.0}/README.md

@@ -27,7 +27,7 @@ strong non-stationary characteristics.
   a CRON-expression, or a pre-defined list.
 - [Data selection](https://time-split.readthedocs.io/en/stable/guide/spans.html) based on a timedelta, or the splitting 
   schedule itself.
-- Automatically extract and [normalize](https://time-split.readthedocs.io/en/stable/guide/flex.html) data limits for 
+- Automatically extract and [normalize](https://time-split.readthedocs.io/en/stable/guide/expand_limits.html) data limits for 
   supported data types.
 - [Plotting function](https://time-split.readthedocs.io/en/stable/generated/time_split.html#time_split.plot) for
   visualization of folds. Display fold sizes (hour/row count), or 

{time_split-0.2.1 → time_split-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "time-split"
-version = "0.2.1"
+version = "0.4.0"
 description = "Time-based k-fold validation splits for heterogeneous data."
 authors = ["Richard Sundqvist <richard.sundqvist@live.se>"]
 
@@ -46,8 +46,9 @@ plotting = ["matplotlib", "seaborn"]
 [tool.poetry.group.manual-extras.dependencies]
 # Extras that must be available for docs + tests go here. Doc/test-only deps go in their respective groups.
 croniter = "^2.0.3"
-pyarrow = "^15.0.2"
+pyarrow = ">=15.0.2,<17.0.0"
 polars = { version = "^0.20.19", extras = ["pandas"] }
+numpy = "<2"  # TODO: numpy 2.0
 
 [tool.poetry.group.docs]
 [tool.poetry.group.docs.dependencies]
@@ -55,9 +56,9 @@ polars = { version = "^0.20.19", extras = ["pandas"] }
 # description: https://github.com/astropy/astropy/issues/11723
 # https://github.com/astropy/astropy/pull/12270
 sphinx = "^7.2.6"
-sphinx-gallery = "^0.15.0"
+sphinx-gallery = "^0.16.0"
 pydata-sphinx-theme = "^0.15.2"
-myst-parser = "^2.0.0"
+myst-parser = ">=2,<4"
 nbsphinx = "^0.9.3"
 ipython = "^8.23.0"
 
@@ -80,12 +81,12 @@ scikit-learn = "^1.4.2"
 # dask.datasets.timeseries() warns:
 #     UserWarning: dask_expr does not support the DataFrameIOFunction protocol for column projection
 # on dask == 2024.3.1
-dask = { version = "==2024.4.1", extras = ["dataframe"] }
+dask = { version = "==2024.5.0", extras = ["dataframe"] }
 
 [tool.poetry.group.devops.dependencies]
 invoke = "^2.2.0"
 mypy = "^1.9.0"
-ruff = "^0.3.7"
+ruff = ">=0.3.7,<0.5.0"
 
 safety = "^3.1.0"
 codespell = "^2.2.6"

{time_split-0.2.1 → time_split-0.4.0}/src/time_split/__init__.py

@@ -11,6 +11,6 @@ __all__ = [
     "__version__",  # Make MyPy happy
 ]
 
-__version__ = "0.2.1"
+__version__ = "0.4.0"
 
 _logging.getLogger(__name__).addHandler(_logging.NullHandler())

{time_split-0.2.1 → time_split-0.4.0}/src/time_split/_backend/_limits.py

@@ -4,8 +4,8 @@ from typing import NamedTuple
 
 from pandas import Timedelta, Timestamp
 
-from ..settings import auto_flex
-from ..types import Flex, TimedeltaTypes
+from ..settings import auto_expand_limits
+from ..types import ExpandLimits, TimedeltaTypes
 
 LimitsTuple = tuple[Timestamp, Timestamp]
 LevelTuple = tuple[TimedeltaTypes, TimedeltaTypes, TimedeltaTypes]
@@ -17,17 +17,21 @@ class _TimedeltaTuple(NamedTuple):
     tolerance: Timedelta
 
 
-def expand_limits(limits: LimitsTuple, *, flex: Flex | LevelTuple | Iterable[LevelTuple] = "auto") -> LimitsTuple:
+def expand_limits(
+    limits: LimitsTuple,
+    spec: ExpandLimits | LevelTuple | Iterable[LevelTuple] = "auto",
+) -> LimitsTuple:
     """Derive the `"real"` bounds of `limits`.
 
     Args:
         limits: A tuple ``(min, max)`` of timestamps.
-        flex: Flex arguments as described in the :ref:`User guide`. Also supports level-tuples
-            ``[(start_at, round_to, tolerance)...]``. Passing ``flex=[settings.auto_flex.day, settings.auto_flex.hour]``
-            is equivalent to ``flex='auto'``.
+        spec: Expansion spec as described in the :ref:`User guide`. Also supports level-tuples
+            ``[(start_at, round_to, tolerance)...]``. Passing
+            ``expand_limits=[settings.auto_expand_limits.day, settings.auto_expand_limits.hour]``
+            is equivalent to ``expand_limits='auto'``.
 
     Returns:
-        Limits rounded according to the `flex`-argument.
+        Limits rounded according to the given specification.
 
     Raises:
         ValueError: For invalid limits.
@@ -38,23 +42,23 @@ def expand_limits(limits: LimitsTuple, *, flex: Flex | LevelTuple | Iterable[Lev
 
         Basic usage.
 
-        >>> expand_limits(limits, flex="d")
+        >>> expand_limits(limits, "d")
         (Timestamp('2019-05-11 00:00:00'), Timestamp('2019-05-12 00:00:00'))
 
         You may specify a maximum "distance" that limits may be expanded.
 
-        >>> expand_limits(limits, flex="d<1h")
+        >>> expand_limits(limits, "d<1h")
         (Timestamp('2019-05-11 00:00:00'), Timestamp('2019-05-11 22:05:30'))
 
         Limits will never be rounded in the "wrong" direction...
 
         >>> limits = Timestamp("2019-05-11"), Timestamp("2019-05-11 11:05:30")
-        >>> expand_limits(limits, flex="d")
+        >>> expand_limits(limits, "d")
         (Timestamp('2019-05-11 00:00:00'), Timestamp('2019-05-11 11:05:30'))
 
         ...even if you make the tolerance large enough.
 
-        >>> expand_limits(limits, flex="d<14h")
+        >>> expand_limits(limits, "d<14h")
         (Timestamp('2019-05-11 00:00:00'), Timestamp('2019-05-11 11:05:30'))
 
     """
@@ -62,20 +66,20 @@ def expand_limits(limits: LimitsTuple, *, flex: Flex | LevelTuple | Iterable[Lev
         msg = f"Bad limits. Expected limits[1] > limits[0], but got {limits=}."
         raise ValueError(msg)
 
-    if flex is False:
+    if spec is False:
         return limits
 
-    if flex is True or flex == "auto":
+    if spec is True or spec == "auto":
         return _from_levels(limits)
 
-    if isinstance(flex, str):
-        round_to, _, tolerance = flex.partition("<")
+    if isinstance(spec, str):
+        round_to, _, tolerance = spec.partition("<")
         level = _make_level(None, round_to=round_to.strip(), tolerance=tolerance.strip())
         return _apply(limits, level=level)
-    if isinstance(flex, tuple):
-        return _from_levels(limits, levels=[_make_level(*flex)])
+    if isinstance(spec, tuple):
+        return _from_levels(limits, levels=[_make_level(*spec)])
 
-    return _from_levels(limits, levels=starmap(_make_level, flex))
+    return _from_levels(limits, levels=starmap(_make_level, spec))
 
 
 def _from_levels(limits: LimitsTuple, *, levels: Iterable[_TimedeltaTuple] | None = None) -> LimitsTuple:
@@ -106,7 +110,7 @@ def _apply(limits: LimitsTuple, *, level: _TimedeltaTuple) -> LimitsTuple:
     if abs(hi_ceil - hi) > level.tolerance:
         return limits
 
-    if auto_flex.SANITY_CHECK:
+    if auto_expand_limits.SANITY_CHECK:
         if lo.round(level.round_to) != lo_floor:
             return limits
         if hi.round(level.round_to) != hi_ceil:
@@ -116,12 +120,12 @@ def _apply(limits: LimitsTuple, *, level: _TimedeltaTuple) -> LimitsTuple:
 
 
 def _levels_from_settings() -> list[_TimedeltaTuple]:
-    day, hour = _make_level(*auto_flex.day), _make_level(*auto_flex.hour)
+    day, hour = _make_level(*auto_expand_limits.day), _make_level(*auto_expand_limits.hour)
     if day.round_to != Timedelta(days=1):
-        msg = f"Invalid settings: {auto_flex.day=} must have round_to=1 day."
+        msg = f"Invalid settings: {auto_expand_limits.day=} must have round_to=1 day."
         raise ValueError(msg)
     if hour.round_to != Timedelta(hours=1):
-        msg = f"Invalid settings: {auto_flex.hour=} must have round_to=1 hour."
+        msg = f"Invalid settings: {auto_expand_limits.hour=} must have round_to=1 hour."
         raise ValueError(msg)
     return [day, hour]
 

{time_split-0.2.1 → time_split-0.4.0}/src/time_split/_backend/_process_available.py

@@ -3,9 +3,10 @@ from typing import NamedTuple
 from pandas import DatetimeIndex, Timestamp, isna
 
 from .._support import handle_dask
-from ..types import DatetimeIterable, Flex
+from ..types import DatetimeIterable, ExpandLimits
 from ._datetime_index_like import DatetimeIndexLike
-from ._limits import LimitsTuple, expand_limits
+from ._limits import LimitsTuple
+from ._limits import expand_limits as expand
 
 
 class ProcessAvailableResult(NamedTuple):
@@ -16,12 +17,13 @@ class ProcessAvailableResult(NamedTuple):
     expanded_limits: LimitsTuple
 
 
-def process_available(available: DatetimeIterable, *, flex: Flex) -> ProcessAvailableResult:
+def process_available(available: DatetimeIterable, *, expand_limits: ExpandLimits) -> ProcessAvailableResult:
     """Process a user-given `available` argument.
 
     Args:
         available: Available data from user. May be ``None``
-        flex: Flex-argument. Determines how much (if at all) to expand limits.
+        expand_limits: Expansion spec as described in the :ref:`User guide`. Determines how much (if at all) to expand
+            limits.
 
     Returns:
         A tuple ``(available, limits)``. Note that `available` will be ``None``, it has not been iterated over. This
@@ -49,7 +51,7 @@ def process_available(available: DatetimeIterable, *, flex: Flex) -> ProcessAvai
         # (croniter 1.4.1 + numpy 1.25.2): croniter cannot handle numpy.datetime64
         limits = Timestamp(min_dt), Timestamp(max_dt)
 
-    expanded_limits = expand_limits(limits, flex=flex)
+    expanded_limits = expand(limits, spec=expand_limits)
     return ProcessAvailableResult(available_retval, limits=limits, expanded_limits=expanded_limits)
 
 

{time_split-0.2.1 → time_split-0.4.0}/src/time_split/_backend/_schedule.py

@@ -2,7 +2,7 @@ from typing import NamedTuple, cast, get_args
 
 from pandas import DatetimeIndex, NaT, Timedelta, Timestamp, date_range
 
-from ..types import DatetimeIterable, Flex, Schedule, TimedeltaTypes
+from ..types import DatetimeIterable, ExpandLimits, Schedule, TimedeltaTypes
 from ._limits import LimitsTuple
 from ._process_available import ProcessAvailableResult, process_available
 
@@ -17,7 +17,7 @@ class MaterializedSchedule(NamedTuple):
 
 
 def materialize_schedule(
-    schedule: Schedule, flex: Flex, *, available: DatetimeIterable | None = None
+    schedule: Schedule, expand_limits: ExpandLimits, *, available: DatetimeIterable | None = None
 ) -> MaterializedSchedule:
     """Materialize user schedule based on available data."""
     if available is None:
@@ -29,7 +29,7 @@ def materialize_schedule(
         except TypeError as e:
             raise ValueError("Schedule must be explicit when not bounded by an available range.") from e
 
-    available_metadata = process_available(available, flex=flex)
+    available_metadata = process_available(available, expand_limits=expand_limits)
     min_dt, max_dt = available_metadata.expanded_limits
 
     if isinstance(schedule, str) and _cron_like(schedule):

{time_split-0.2.1 → time_split-0.4.0}/src/time_split/_backend/_splitter.py

@@ -4,7 +4,8 @@ from typing import cast, get_args
 
 from pandas import Timedelta, Timestamp
 from rics.misc import format_kwargs
-from rics.performance import format_seconds
+
+from time_split._compat import fmt_sec
 
 from ..settings import misc
 from ..types import (
@@ -12,7 +13,7 @@ from ..types import (
     DatetimeIterable,
     DatetimeSplitBounds,
     DatetimeSplits,
-    Flex,
+    ExpandLimits,
     Schedule,
     Span,
     TimedeltaTypes,
@@ -33,7 +34,7 @@ class DatetimeIndexSplitter:
     after: Span
     step: int
     n_splits: int
-    flex: Flex
+    expand_limits: ExpandLimits
 
     def get_splits(self, available: DatetimeIterable | None = None) -> DatetimeSplits:
         """Compute a split of given user data."""
@@ -48,7 +49,7 @@ class DatetimeIndexSplitter:
         return splits, ms
 
     def _materialize_schedule(self, available: DatetimeIterable | None = None) -> MaterializedSchedule:
-        ms = materialize_schedule(self.schedule, self.flex, available=available)
+        ms = materialize_schedule(self.schedule, self.expand_limits, available=available)
         if not ms.schedule.sort_values().equals(ms.schedule):
             raise ValueError(f"schedule must be sorted in ascending order; schedule={self.schedule!r} is not valid.")
 
@@ -137,10 +138,10 @@ class DatetimeIndexSplitter:
             if old == new:
                 return retval + "<no change>"
             diff = (new - old).total_seconds()
-            return retval + f"{_PrettyTimestamp(new).auto} ({'+' if diff > 0 else '-'}{format_seconds(abs(diff))})"
+            return retval + f"{_PrettyTimestamp(new).auto} ({'+' if diff > 0 else '-'}{fmt_sec(abs(diff))})"
 
         LOGGER.info(
-            f"Available data limits have been expanded (since flex={self.flex!r}):\n"
+            f"Available data limits have been expanded (since expand_limits={self.expand_limits!r}):\n"
             f"  start: {stringify(original[0], new=expanded[0])}\n"
             f"    end: {stringify(original[1], new=expanded[1])}"
         )

time_split-0.4.0/src/time_split/_compat.py

@@ -0,0 +1,49 @@
+"""Vendored functions."""
+
+from functools import wraps
+from typing import Callable, ParamSpec, TypeVar
+from warnings import warn
+
+from rics.misc import tname
+
+try:
+    from rics import strings
+
+    fmt_perf = strings.format_perf_counter
+    fmt_sec = strings.format_seconds
+except ImportError:
+    from rics import performance
+
+    # TODO(0.5.0): Drop this.
+    fmt_perf = performance.format_perf_counter
+    fmt_sec = performance.format_seconds
+
+P = ParamSpec("P")
+T = TypeVar("T")
+
+PARAMS = (("expand_limits", "flex"),)
+WARNED: set[str] = set()  # Minimize the amount of warnings - once per param is enough.
+
+
+def deprecated_params(__func: Callable[P, T], /) -> Callable[P, T]:
+    @wraps(__func)
+    def wrap(*args: P.args, **kwargs: P.kwargs) -> T:
+        for new, old in PARAMS:
+            if old in kwargs:
+                if new in kwargs:
+                    name = tname(__func, prefix_classname=True)
+                    msg = f"Ambiguous call: {name}() does not accept both `{old}` and `{new}`."
+                    raise TypeError(msg)
+
+                if old not in WARNED:
+                    WARNED.add(old)
+
+                    name = tname(__func, prefix_classname=True)
+                    msg = f"{name}(): The `{old}` parameter is deprecated; use `{new}` instead."
+                    warn(message=msg, category=DeprecationWarning, stacklevel=2)
+
+                kwargs[new] = kwargs.pop(old)
+
+        return __func(*args, **kwargs)
+
+    return wrap

{time_split-0.2.1 → time_split-0.4.0}/src/time_split/_docstrings.py

@@ -1,6 +1,9 @@
-from typing import TypeVar
+from typing import Callable, ParamSpec, TypeVar
 
-FuncType = TypeVar("FuncType")  # No proper way to type this?
+from time_split._compat import deprecated_params
+
+P = ParamSpec("P")
+T = TypeVar("T")
 
 
 def add_docstrings(**kwargs: str) -> None:
@@ -8,11 +11,17 @@ def add_docstrings(**kwargs: str) -> None:
     _DOCSTRINGS.update(kwargs)
 
 
-def docs(function: FuncType) -> FuncType:
+def docs(__func: Callable[P, T], /) -> Callable[P, T]:
     """Add info the docstring of a function."""
-    assert function.__doc__ is not None  # noqa: S101
-    function.__doc__ = function.__doc__.format(**_DOCSTRINGS)
-    return function
+    assert __func.__doc__ is not None  # noqa: S101
+    __func.__doc__ = __func.__doc__.format(**_DOCSTRINGS)
+
+    if isinstance(__func, type):
+        __func.__init__ = deprecated_params(__func.__init__)
+    else:
+        __func = deprecated_params(__func)
+
+    return __func
 
 
 _OFFSET = "pandas :ref:`offset alias <pandas:timeseries.offset_aliases>`"
@@ -27,9 +36,10 @@ _DOCSTRINGS = {
     "step": "Select a subset of folds, preferring folds later in the schedule.",
     "n_splits": "Maximum number of folds, preferring folds later in the schedule.",
     "available": "Binds `schedule` to a range.",
-    "flex": f'A {_OFFSET} used to expand `available` data to its likely `"true"` limits. Pass ``False`` to disable.',
+    "expand_limits": f'A {_OFFSET} used to expand `available` data to its likely `"true"` limits. Pass ``False`` to disable.',
     "USER_GUIDE": (
-        "For more information about the `schedule`, `before/after` and `flex`-arguments" ", see the :ref:`User guide`."
+        "For more information about the `schedule`, `before/after` and `expand_limits`-arguments"
+        ", see the :ref:`User guide`."
     ),
     "OFFSET": _OFFSET,
     "DatetimeIndexSplitterKwargs": "See :func:`~time_split.split`. The `available` keyword is managed by the integration.",

{time_split-0.2.1 → time_split-0.4.0}/src/time_split/_frontend/__init__.py

@@ -1,5 +1,5 @@
 from ._plot import plot
-from ._progress import log_split_progress
+from ._progress import default_metrics_formatter, log_split_progress
 from ._split import split
 from ._to_string import to_string
 from ._weight import fold_weight
@@ -7,6 +7,7 @@ from ._weight import fold_weight
 __all__ = [
     "fold_weight",
     "log_split_progress",
+    "default_metrics_formatter",
     "plot",
     "split",
     "to_string",

{time_split-0.2.1 → time_split-0.4.0}/src/time_split/_frontend/_plot.py

@@ -4,7 +4,8 @@ from typing import TYPE_CHECKING, Any, Literal
 import pandas as pd
 from pandas import Timestamp
 from rics.misc import format_kwargs, get_public_module
-from rics.performance import format_seconds
+
+from time_split._compat import fmt_sec
 
 from .._backend import DatetimeIndexSplitter
 from .._backend._datetime_index_like import DatetimeIndexLike
@@ -16,7 +17,7 @@ from ..types import (
     DatetimeIterable,
     DatetimeSplitBounds,
     DatetimeSplits,
-    Flex,
+    ExpandLimits,
     Schedule,
     Span,
 )
@@ -64,7 +65,7 @@ def plot(
     step: int = 1,
     n_splits: int = 0,
     available: DatetimeIterable | None = None,
-    flex: Flex = "auto",
+    expand_limits: ExpandLimits = "auto",
     # Split plot args
     bar_labels: str | Rows | list[tuple[str, str]] | bool = True,
     show_removed: bool = False,
@@ -84,7 +85,7 @@ def plot(
         n_splits: {n_splits}
         available: {available} If `bar_labels` is given but is not a ``list``,
             this data will be used to compute fold sizes.
-        flex: {flex}
+        expand_limits: {expand_limits}
         bar_labels: Labels to draw on the bars. If you pass a string, it will be interpreted as a time unit (see
             :ref:`pandas:timeseries.offset_aliases` for valid frequency strings). Bars will show the number of units
             contained. Pass `'rows'` to simply count the numbers of elements in `data` (if given). To write custom
@@ -114,7 +115,7 @@ def plot(
         after=after,
         step=step,
         n_splits=n_splits,
-        flex=flex,
+        expand_limits=expand_limits,
     )
     plot_data = _get_plot_data(available, splitter, row_count_bin=row_count_bin, show_removed=show_removed)
 
@@ -207,10 +208,10 @@ def _plot_row_counts(ax: "Axes", row_count_bin: str | pd.Series, row_counts: pd.
         from numpy import diff, timedelta64
 
         row_counts = row_count_bin.sort_index()
-        pretty = format_seconds(diff(row_counts.index).min() / timedelta64(1, "s"))
+        pretty = fmt_sec(diff(row_counts.index).min() / timedelta64(1, "s"))
     else:
         row_counts = row_counts.sort_index()
-        pretty = format_seconds(pd.Timedelta(row_count_bin).total_seconds())
+        pretty = fmt_sec(pd.Timedelta(row_count_bin).total_seconds())
 
     row_counts = row_counts * (max(ax.get_yticks()) / row_counts.max())  # Normalize to fold number yaxis
     ax.fill_between(

time_split-0.4.0/src/time_split/_frontend/_progress.py

@@ -0,0 +1,245 @@
+import logging
+from collections.abc import Callable, Iterable, MutableMapping, Sequence
+from dataclasses import dataclass
+from time import perf_counter
+from typing import Any, Generic
+
+import pandas as pd
+from rics.collections.dicts import flatten_dict
+
+from time_split._compat import fmt_sec
+
+from ..settings import log_split_progress as settings
+from ..types import DatetimeSplitBounds, FormatMetrics, GetMetrics, LoggerArg, MetricsType, SplitProgressExtras
+from ._to_string import _PrettyTimestamp
+
+
+def log_split_progress(
+    splits: Sequence[DatetimeSplitBounds],
+    *,
+    logger: LoggerArg = "time_split",
+    start_level: int = logging.INFO,
+    end_level: int = logging.INFO,
+    extra: dict[str, Any] | None = None,
+    get_metrics: GetMetrics[MetricsType] | None = None,
+) -> Iterable[DatetimeSplitBounds]:
+    """Log iteration progress.
+
+    Args:
+        splits: Splits to iterate over.
+        logger: Logger or logger name to use.
+        start_level: Log level to use for the :attr:`fold-begin message <.settings.log_split_progress.START_MESSAGE>`.
+        end_level: Log level to use for the :attr:`fold-end message <.settings.log_split_progress.END_MESSAGE>`.
+        extra: Immutable, user-defined `extra`-arguments to use when logging, merged with progress-related extras (see
+            :class:`~time_split.types.SplitProgressExtras`).
+        get_metrics: A callable ``(training_date) -> fold_metrics | str`` (see :attr:`~.DatetimeSplit.training_date`).
+            If given, metrics are added to the :attr:`fold-end message <.settings.log_split_progress.END_MESSAGE>`. The
+            message is formatted using the :func:`default formatter <.support.default_metrics_formatter>` unless
+            :attr:`~.settings.log_split_progress.FORMAT_METRICS` is set. If this callback returns a ``str`` argument,
+            the :func:`default formatter <.support.default_metrics_formatter>` will assume that the metrics are
+            pre-formatted, simply appending the formatted metrics to the
+            :attr:`fold-end message <.settings.log_split_progress.END_MESSAGE>` as-is.
+
+    Returns:
+        An iterable over `splits`.
+
+    Examples:
+        Configuring the `logger` name and
+        :attr:`fold-begin message <.settings.log_split_progress.START_MESSAGE>` log level.
+
+        >>> from time_split import split, log_split_progress
+        >>> schedule = ["2023-08-16", "2023-08-17 12", "2023-08-19"]
+        >>> tracked_splits = log_split_progress(
+        ...     split(schedule),
+        ...     logger="progress",
+        ...     start_level=logging.DEBUG,
+        ... )
+        >>> list(splits)  # doctest: +SKIP
+        [progress:DEBUG] Begin fold 1/2: '2023-08-09' <= [schedule: '2023-08-16' (Wednesday)] < '2023-08-17 12:00:00'.
+        [progress:INFO] Finished fold 1/2 [schedule: '2023-08-16' (Wednesday)] after 5m 18s.
+        [progress:DEBUG] Begin fold 2/2: '2023-08-10 12:00:00' <= [schedule: '2023-08-17 12:00:00' (Thursday)] < '2023-08-19'.
+        [progress:INFO] Finished fold 2/2 [schedule: '2023-08-17 12:00:00' (Thursday)] after 4m 3s.
+
+        Using the `get_metrics` callback argument.
+
+        >>> metrics = {
+        ...     "2023-08-16 00:00:00": {"rmse": {"train": 0.11, "test": 0.5}},
+        ...     "2023-08-17 12:00:00": {"rmse": {"test": 0.5, "future": 20.19}},
+        ... }
+        >>> tracked_splits = log_split_progress(
+        ...     split(schedule),
+        ...     get_metrics=lambda key: metrics[str(key)],
+        ... )
+        >>> list(tracked_splits)  # doctest: +SKIP
+        [time_split:INFO] Begin fold 1/2: '2023-08-09' <= [schedule: '2023-08-16' (Wednesday)] < '2023-08-17 12:00:00'.
+        [time_split:INFO] Finished fold 1/2 [schedule: '2023-08-16' (Wednesday)] after 5m 18s. Fold metrics:
+        rmse.train   0.11
+        rmse.test     0.5
+        [time_split:INFO] Begin fold 2/2: '2023-08-10 12:00:00' <= [schedule: '2023-08-17 12:00:00' (Thursday)] < '2023-08-19'.
+        [time_split:INFO] Finished fold 2/2 [schedule: '2023-08-17 12:00:00' (Thursday)] after 4m 3s. Fold metrics:
+        rmse.test       0.5
+        rmse.future   20.19
+
+        Formatting was done using the :func:`default formatter <.support.default_metrics_formatter>`, since the
+        :attr:`~.settings.log_split_progress.FORMAT_METRICS` setting is ``None``.
+
+    """
+    logger = logging.getLogger(logger) if isinstance(logger, str) else logger
+
+    if isinstance(logger, logging.LoggerAdapter) and not hasattr(logger, "merge_extra"):
+        # Backport of https://github.com/python/cpython/pull/107292
+        logger = _MergingLoggerAdapter(logger.logger, logger.extra)
+
+    track = _ProgressTracker(
+        logger=logger,
+        fold_format=settings.FOLD_FORMAT,
+        start_level=start_level,
+        start_message=settings.START_MESSAGE,
+        end_level=end_level,
+        end_message=settings.END_MESSAGE,
+        seconds_formatter=settings.SECONDS_FORMATTER or fmt_sec,
+        user_extra={} if extra is None else extra.copy(),  # Not actually immutable; deepcopy can be very expensive.
+        get_metrics=get_metrics,
+        format_metrics=settings.FORMAT_METRICS or default_metrics_formatter,
+    )
+    return track(splits)
+
+
+@dataclass(frozen=True)
+class _ProgressTracker(Generic[MetricsType]):
+    logger: logging.Logger | logging.LoggerAdapter  # type: ignore[type-arg]
+    fold_format: str
+    start_level: int
+    start_message: str
+    end_level: int
+    end_message: str
+    seconds_formatter: Callable[[float], str]
+    user_extra: dict[str, Any]
+    get_metrics: GetMetrics[MetricsType] | None
+    format_metrics: FormatMetrics[MetricsType]
+
+    def __call__(self, splits: Sequence[DatetimeSplitBounds]) -> Iterable[DatetimeSplitBounds]:
+        n_splits = len(splits)
+
+        for n, split in enumerate(splits, start=1):
+            default_extras = SplitProgressExtras(
+                n=n,
+                n_splits=n_splits,
+                start=split.start.isoformat(),
+                mid=split.mid.isoformat(),
+                end=split.end.isoformat(),
+            )
+            extra = {**self.user_extra, **default_extras}
+            kwargs: dict[str, Any] = dict(
+                n=n,
+                n_splits=n_splits,
+                start=_PrettyTimestamp(split.start),
+                mid=_PrettyTimestamp(split.mid),
+                end=_PrettyTimestamp(split.end),
+                **self.user_extra,
+            )
+            kwargs.update(fold=self.fold_format.format(**kwargs))
+
+            self.logger.log(self.start_level, self.start_message.format(**kwargs), extra=extra)
+
+            # Yield split and count user time.
+            start = perf_counter()
+            yield split
+            seconds = round(perf_counter() - start, 6)
+
+            kwargs.update(
+                seconds=seconds,
+                formatted_seconds=self.seconds_formatter(seconds),
+            )
+            msg = self.end_message.format(**kwargs)
+
+            if self.get_metrics is not None:
+                extra["metrics"] = self.get_metrics(split.mid)
+                msg = self.format_metrics(msg, extra["metrics"])
+
+            extra.update(seconds=seconds)
+            self.logger.log(self.end_level, msg, extra=extra)
+
+
+def default_metrics_formatter(end_message: str, metrics: dict[Any, Any] | pd.Series | pd.DataFrame | str | Any) -> str:
+    """Default formatting implementation.
+
+    Format using an appropriate pandas ``to_string()``-method if `metrics` is a ``dict`` or a pandas type. Nested
+    dictionaries are flattened using :func:`~rics.collections.dicts.flatten_dict` if `metrics` is a dict-of-dicts.
+
+    Metrics of type ``str`` are assumed to be preformatted, and are appended to `end_message` as-is.
+
+    If any other types are given, fall back to
+    ``f"{end_message} Metrics: {metrics}"``.
+
+    Examples:
+        Formatting a nested dict.
+
+        >>> metrics = {"rmse": {"train": 0.11, "test": 0.5, "future": 20.19}}
+
+        >>> print(default_metrics_formatter("End message.", metrics))
+        End message. Fold metrics:
+              train  test  future
+        rmse   0.11   0.5   20.19
+
+        Formatting a :class:`pandas.DataFrame`.
+
+        >>> metrics = {"me": [0.1, 0.2, 0.3], "rmse": [0.11, 0.5, 20.19]}
+        >>> df = pd.DataFrame(metrics, index=["train", "test", "future"])
+        >>> print(default_metrics_formatter("End message.", df))
+        End message. Fold metrics:
+                 me   rmse
+        train   0.1   0.11
+        test    0.2   0.50
+        future  0.3  20.19
+
+        The index printed  unless` it is a :class:`pandas.RangeIndex`.
+    """
+    if isinstance(metrics, dict):
+        metrics = _convert_dict(metrics)
+
+    if isinstance(metrics, (pd.Series, pd.DataFrame)):
+        if isinstance(metrics, pd.DataFrame):
+            with_index = not isinstance(metrics, pd.RangeIndex)
+        else:
+            with_index = True
+        return f"{end_message} Fold metrics:\n{metrics.round(3).to_string(index=with_index)}"
+    elif isinstance(metrics, str):
+        return f"{end_message} {metrics}"
+    else:
+        return f"{end_message} Metrics: {metrics}"
+
+
+class _MergingLoggerAdapter(logging.LoggerAdapter[Any]):
+    # TODO(3.13): Use merge_extra=True init arg
+    def process(self, msg: Any, kwargs: MutableMapping[str, Any]) -> tuple[Any, MutableMapping[str, Any]]:
+        """See https://github.com/python/cpython/pull/107292."""
+        kwargs["extra"] = {**self.extra, **kwargs["extra"]} if "extra" in kwargs and self.extra else self.extra
+        return msg, kwargs
+
+
+def _convert_dict(metrics: dict[Any, Any]) -> dict[Any, Any] | pd.DataFrame | pd.Series:
+    original = metrics
+
+    scalar_leaves: bool = False
+
+    if all(isinstance(v, dict) for v in metrics.values()):
+        flat = flatten_dict(metrics)
+
+        # A single dot usually indicates nesting one level deep; can be formatted as a DataFrame.
+        if any(k.count(".") != 1 for k in flat) and all(pd.api.types.is_scalar(v) for v in flat.values()):
+            metrics = flat
+    elif all(pd.api.types.is_scalar(v) for v in original.values()):
+        scalar_leaves = True
+
+    try:
+        if scalar_leaves:
+            return pd.Series(metrics)
+
+        df = pd.DataFrame(metrics)
+    except Exception:
+        return original
+
+    if len(df) > len(df.columns):
+        df = df.T  # Prefer wider horizontal output
+    return df

{time_split-0.2.1 → time_split-0.4.0}/src/time_split/_frontend/_split.py

@@ -1,6 +1,6 @@
 from .._backend import DatetimeIndexSplitter
 from .._docstrings import docs
-from ..types import DatetimeIterable, DatetimeSplits, Flex, Schedule, Span
+from ..types import DatetimeIterable, DatetimeSplits, ExpandLimits, Schedule, Span
 
 
 @docs
@@ -12,7 +12,7 @@ def split(
     step: int = 1,
     n_splits: int = 0,
     available: DatetimeIterable | None = None,
-    flex: Flex = "auto",
+    expand_limits: ExpandLimits = "auto",
 ) -> DatetimeSplits:
     """Create time-based cross-validation splits.
 
@@ -25,7 +25,7 @@ def split(
         step: {step}
         n_splits: {n_splits}
         available: {available} Passing a tuple ``(min, max)`` is enough.
-        flex: {flex}
+        expand_limits: {expand_limits}
 
     {USER_GUIDE}
 
@@ -41,5 +41,5 @@ def split(
         after=after,
         step=step,
         n_splits=n_splits,
-        flex=flex,
+        expand_limits=expand_limits,
     ).get_splits(available)

{time_split-0.2.1 → time_split-0.4.0}/src/time_split/_frontend/_to_string.py

@@ -29,7 +29,7 @@ def to_string(
 
 
 def to_string(
-    bounds: (DatetimeTypes | DatetimeSplitBounds | tuple[DatetimeTypes, DatetimeTypes, DatetimeTypes]),
+    bounds: DatetimeTypes | DatetimeSplitBounds | tuple[DatetimeTypes, DatetimeTypes, DatetimeTypes],
     mid: DatetimeTypes | None = None,
     end: DatetimeTypes | None = None,
     /,

{time_split-0.2.1 → time_split-0.4.0}/src/time_split/integration/_log_progress.py

@@ -1,18 +1,18 @@
 import logging
 from collections.abc import Iterable
-from typing import Any, Union
+from typing import Any
 
 from .. import log_split_progress
 from .._docstrings import add_docstrings
-from ..types import DatetimeSplitBounds, DatetimeSplits
+from ..types import DatetimeSplitBounds, DatetimeSplits, LogSplitProgressKwargs, MetricsType
 
-LogProgressArg = Union[str, bool, dict[str, Any], logging.Logger, logging.LoggerAdapter]  # type: ignore[type-arg]
+LogProgressArg = str | bool | logging.Logger | logging.LoggerAdapter[Any] | LogSplitProgressKwargs[MetricsType]
 
 add_docstrings(log_progress="Controls logging of fold progress. See :func:`~.log_split_progress` for details.")
 
 
 def handle_log_progress_arg(
-    log_progress: LogProgressArg, *, splits: DatetimeSplits
+    log_progress: LogProgressArg[MetricsType], *, splits: DatetimeSplits
 ) -> Iterable[DatetimeSplitBounds] | None:
     """Wrapper function for integrations."""
     if log_progress is True:

time_split-0.2.1/src/time_split/integration/split_data.py → time_split-0.4.0/src/time_split/integration/base.py

@@ -49,7 +49,7 @@ class DatetimeSplit(_t.NamedTuple, _t.Generic[DataT]):
 def split_data(
     data: DataT,
     *,
-    log_progress: _log_progress.LogProgressArg = False,
+    log_progress: _log_progress.LogProgressArg[_tst.MetricsType] = False,
     as_available: DataAsAvailableFn[DataT],
     select: DataSelectFn[DataT],
     **kwargs: _t.Unpack[_tst.DatetimeIndexSplitterKwargs],

{time_split-0.2.1 → time_split-0.4.0}/src/time_split/integration/pandas/_impl.py

@@ -6,9 +6,9 @@ from pandas import DataFrame, DatetimeIndex, Series, Timestamp
 from rics.misc import tname
 
 from ..._docstrings import docs
-from ...types import DatetimeIndexSplitterKwargs
+from ...types import DatetimeIndexSplitterKwargs, MetricsType
 from .._log_progress import LogProgressArg
-from ..split_data import DatetimeSplit, split_data
+from ..base import DatetimeSplit, split_data
 
 PandasT = TypeVar("PandasT", Series, DataFrame)
 """A splittable pandas type."""
@@ -19,7 +19,7 @@ def split_pandas(
     data: PandasT,
     time_column: Hashable = None,
     *,
-    log_progress: LogProgressArg = False,
+    log_progress: LogProgressArg[MetricsType] = False,
     **kwargs: Unpack[DatetimeIndexSplitterKwargs],
 ) -> Iterable[DatetimeSplit[PandasT]]:
     """Split a pandas type.

{time_split-0.2.1 → time_split-0.4.0}/src/time_split/integration/polars/_impl.py

@@ -6,9 +6,9 @@ from polars import DataFrame, Series
 from rics.misc import tname
 
 from ..._docstrings import docs
-from ...types import DatetimeIndexSplitterKwargs
+from ...types import DatetimeIndexSplitterKwargs, MetricsType
 from .._log_progress import LogProgressArg
-from ..split_data import DatetimeSplit, split_data
+from ..base import DatetimeSplit, split_data
 
 
 @docs
@@ -16,7 +16,7 @@ def split_polars(
     data: DataFrame,
     time_column: str,
     *,
-    log_progress: LogProgressArg = False,
+    log_progress: LogProgressArg[MetricsType] = False,
     **kwargs: Unpack[DatetimeIndexSplitterKwargs],
 ) -> Iterable[DatetimeSplit[DataFrame]]:
     """Split a polars frame.

{time_split-0.2.1 → time_split-0.4.0}/src/time_split/integration/sklearn/_impl.py

@@ -10,7 +10,8 @@ from ...types import (
     DatetimeIterable,
     DatetimeSplits,
     DatetimeTypes,
-    Flex,
+    ExpandLimits,
+    MetricsType,
     Schedule,
     Span,
 )
@@ -43,7 +44,7 @@ class ScikitLearnSplitter(BaseCrossValidator):  # type: ignore[misc]
         after: {after}
         step: {step}
         n_splits: {n_splits}
-        flex: {flex}
+        expand_limits: {expand_limits}
         log_progress: {log_progress}
         verify_xy: If ``True``, split X and y independently and verify that they are equal.
 
@@ -58,9 +59,9 @@ class ScikitLearnSplitter(BaseCrossValidator):  # type: ignore[misc]
         before: Span = "7d",
         after: Span = 1,
         n_splits: int = 0,
-        flex: Flex = "auto",
+        expand_limits: ExpandLimits = "auto",
         step: int = 1,
-        log_progress: LogProgressArg = False,
+        log_progress: LogProgressArg[MetricsType] = False,
         verify_xy: bool = True,
     ) -> None:
         super().__init__()
@@ -70,7 +71,7 @@ class ScikitLearnSplitter(BaseCrossValidator):  # type: ignore[misc]
             after=after,
             step=step,
             n_splits=n_splits,
-            flex=flex,
+            expand_limits=expand_limits,
         )
         self.log_progress = log_progress
         self.verify_xy = verify_xy

{time_split-0.2.1 → time_split-0.4.0}/src/time_split/settings.py

@@ -5,14 +5,14 @@ import typing as _t
 from . import types as _tst
 
 
-class auto_flex:  # noqa: N801
-    """Configuration for the `'auto'` :attr:`~time_split.types.Flex` logic.
+class auto_expand_limits:  # noqa: N801
+    """Configuration for the `'auto'` :attr:`~time_split.types.ExpandLimits` logic.
 
-    This class determines how ``(min, max)``-tuples are expanded when flexible bounds are enabled.
+    This class determines how ``(min, max)``-tuples are expanded when expand_limitsible bounds are enabled.
     """
 
     SANITY_CHECK: bool = True
-    """If ``True``, use original limits if flexed limits do not pass sanity checks."""
+    """If ``True``, use original limits if expand_limitsed limits do not pass sanity checks."""
 
     @classmethod
     def set_level(
@@ -23,7 +23,7 @@ class auto_flex:  # noqa: N801
         round_to: _tst.TimedeltaTypes,
         tolerance: _tst.TimedeltaTypes,
     ) -> None:
-        """Set a :class:`Level` used by the auto-flex logic.
+        """Set a :class:`Level` used by the auto-expand_limits logic.
 
         Inputs are not verified until an actual split is made.
 
@@ -43,7 +43,7 @@ class auto_flex:  # noqa: N801
         setattr(cls, level, level_tuple)
 
     class Level(_t.NamedTuple):
-        """Level type used by :attr:`auto_flex`."""
+        """Level type used by :attr:`auto_expand_limits`."""
 
         start_at: _tst.TimedeltaTypes
         """Span size at which this level starts."""
@@ -113,11 +113,10 @@ class log_split_progress:  # noqa: N801
        '2021-12-30' <= [schedule: '2022-01-04' (Tuesday)] < '2022-01-04 18:00:00'
     """
 
-    SECONDS_FORMATTER: str | _t.Callable[[float], str] = "rics.performance.format_seconds"
-    """A callable ``(seconds) -> formatted_seconds``.
+    SECONDS_FORMATTER: _t.Callable[[float], str] | None = None
+    """A callable ``(seconds) -> formatted_seconds``. Use :func:`rics.strings.format_seconds` if ``None``.
 
-    Both ``seconds`` and ``formatted_seconds`` will be available to the :attr:`END_MESSAGE` message. If a string is
-    given, the actual callable will be resolved using :func:`rics.misc.get_by_full_name`.
+    Both ``seconds`` and ``formatted_seconds`` will be available to the :attr:`END_MESSAGE` message.
     """
 
     START_MESSAGE: str = "Begin fold {n}/{n_splits}: {fold}."
@@ -156,6 +155,9 @@ class log_split_progress:  # noqa: N801
     AUTO_DATETIME_FORMAT = "%Y-%m-%d %H:%M:%S"
     """Long-form timestamp format_spec used by ``<key>.auto``."""
 
+    FORMAT_METRICS: _tst.FormatMetrics[_t.Any] | None = None
+    """A callable ``(end_message, metrics) -> str``. Use the :func:`default formatter <.support.default_metrics_formatter>` if ``None``."""
+
 
 class misc:  # noqa: N801
     """Miscellaneous settings that don't fit in any other namespace."""

{time_split-0.2.1 → time_split-0.4.0}/src/time_split/support/__init__.py

@@ -12,12 +12,13 @@ dependencies if you need to use the ``support`` module.
 """
 
 from .._backend import DatetimeIndexSplitter, expand_limits, process_available
-from .._frontend import fold_weight, to_string
+from .._frontend import default_metrics_formatter, fold_weight, to_string
 
 __all__ = [
     "DatetimeIndexSplitter",
     "expand_limits",
     "process_available",
+    "default_metrics_formatter",
     "fold_weight",
     "to_string",
 ]

{time_split-0.2.1 → time_split-0.4.0}/src/time_split/types.py

@@ -1,6 +1,7 @@
 """Types related to splitting data."""
 
 import datetime as _dt
+import logging as _logging
 import typing as _t
 
 import numpy as _np
@@ -17,8 +18,8 @@ Schedule: _t.TypeAlias = _pd.DatetimeIndex | DatetimeIterable | TimedeltaTypes
 """User schedule type."""
 Span = int | _t.Literal["all"] | TimedeltaTypes
 """User span type. Used to determine limits from the timestamps given by a :attr:`Schedule`."""
-Flex = bool | _t.Literal["auto"] | str
-"""Flexibility frequency string for ``floor/ceil``. Pass ``False`` to disable."""
+ExpandLimits = bool | _t.Literal["auto"] | str
+"""Limits flexibility spec for ``floor/ceil``. Pass ``False`` to disable."""
 
 
 class DatetimeSplitBounds(_t.NamedTuple):
@@ -61,4 +62,42 @@ class DatetimeIndexSplitterKwargs(_t.TypedDict, total=False):
     after: Span
     step: int
     n_splits: int
-    flex: Flex
+    expand_limits: ExpandLimits
+
+
+LoggerArg = _logging.Logger | _logging.LoggerAdapter[_t.Any] | str
+
+
+MetricsType = _t.TypeVar("MetricsType")
+"""Metrics argument type."""
+GetMetrics = _t.Callable[[_pd.Timestamp], MetricsType]
+"""A callable ``(Timestamp) -> MetricsType``."""
+FormatMetrics = _t.Callable[[str, MetricsType], str]
+"""A callable ``(end_message, metrics) -> str``."""
+
+
+class LogSplitProgressKwargs(_t.TypedDict, _t.Generic[MetricsType], total=False):
+    """Keyword arguments for by :func:`.log_split_progress`."""
+
+    logger: LoggerArg
+    start_level: int
+    end_level: int
+    extra: dict[str, _t.Any] | None
+    get_metrics: GetMetrics[MetricsType]
+
+
+class SplitProgressExtras(_t.TypedDict):
+    """Named `extras` used for messages logged by :func:`.log_split_progress`."""
+
+    n: int
+    """Current split number (starting at 1)."""
+    n_splits: int
+    """Total split count."""
+    start: str
+    """An :meth:`ISO-formatted <pandas.Timestamp.isoformat>` timestamp (see :attr:`.DatetimeSplitBounds.start`)."""
+    mid: str
+    """An :meth:`ISO-formatted <pandas.Timestamp.isoformat>` timestamp (see :attr:`.DatetimeSplitBounds.mid`)."""
+    end: str
+    """An :meth:`ISO-formatted <pandas.Timestamp.isoformat>` timestamp (see :attr:`.DatetimeSplitBounds.end`)."""
+    seconds: _t.NotRequired[float]
+    """User time for the fold. Available only for the :attr:`fold-end message <.settings.log_split_progress.END_MESSAGE>`."""

time_split-0.2.1/src/time_split/_frontend/_progress.py

@@ -1,125 +0,0 @@
-import logging
-from collections.abc import Callable, Iterable, MutableMapping, Sequence
-from dataclasses import dataclass
-from time import perf_counter
-from typing import Any, Union
-
-from rics.misc import get_by_full_name
-
-from ..settings import log_split_progress as settings
-from ..types import DatetimeSplitBounds
-from ._to_string import _PrettyTimestamp
-
-LoggerArg = Union[logging.Logger, logging.LoggerAdapter, str]  # type: ignore[type-arg]
-
-
-def log_split_progress(
-    splits: Sequence[DatetimeSplitBounds],
-    *,
-    logger: LoggerArg = "time_split",
-    start_level: int = logging.INFO,
-    end_level: int = logging.INFO,
-    extra: dict[str, Any] | None = None,
-) -> Iterable[DatetimeSplitBounds]:
-    """Log iteration progress over `splits` using `logger`.
-
-    Args:
-        splits: Splits to iterate over.
-        logger: Logger or logger name to use.
-        start_level: Log level to use for the :attr:`fold-begin message <.settings.log_split_progress.START_MESSAGE>`.
-        end_level: Log level to use for the :attr:`fold-end message <.settings.log_split_progress.END_MESSAGE>`.
-        extra: User-defined `extra`-arguments to use when logging, merged with progress-related extras. Will be
-            available to all messages as well as the ``fold`` key. This argument is mutable; changes made to `extra`
-            will be reflected in logged records.
-
-    Returns:
-        An iterable over `splits`.
-
-    Examples:
-        Basic usage.
-
-        >>> from time_split import split, log_split_progress
-        >>> splits = split("36h", available=("2023-08-10", "2023-08-19"))
-        >>> tracked_splits = log_split_progress(
-        ...     splits, logger="progress", start_level=logging.DEBUG
-        ... )
-        >>> list(tracked_splits)  # doctest: +SKIP
-        [progress:DEBUG] Begin fold 1/2: ('2023-08-11' <= [schedule: '2023-08-16' (Wednesday)] < '2023-08-17 12:00:00').
-        [progress:INFO] Finished fold 1/2 [schedule: '2023-08-16' (Wednesday)] after 5m 18s.
-        [progress:DEBUG] Begin fold 2/2: ('2023-08-12 12:00:00' <= [schedule: '2023-08-17 12:00:00' (Thursday)] < '2023-08-19').
-        [progress:INFO] Finished fold 2/2 [schedule: '2023-08-17 12:00:00' (Thursday)] after 4m 3s.
-    """
-    logger = logging.getLogger(logger) if isinstance(logger, str) else logger
-
-    if isinstance(logger, logging.LoggerAdapter) and not hasattr(logger, "merge_extra"):
-        # Backport of https://github.com/python/cpython/pull/107292
-        logger = _MergingLoggerAdapter(logger.logger, logger.extra)
-
-    track = _ProgressTracker(
-        logger=logger,
-        fold_format=settings.FOLD_FORMAT,
-        start_level=start_level,
-        start_message=settings.START_MESSAGE,
-        end_level=end_level,
-        end_message=settings.END_MESSAGE,
-        seconds_formatter=settings.SECONDS_FORMATTER
-        if callable(settings.SECONDS_FORMATTER)
-        else get_by_full_name(settings.SECONDS_FORMATTER),
-        user_extra=extra or {},
-    )
-    return track(splits)
-
-
-@dataclass(frozen=True)
-class _ProgressTracker:
-    logger: logging.Logger | logging.LoggerAdapter  # type: ignore[type-arg]
-    fold_format: str
-    start_level: int
-    start_message: str
-    end_level: int
-    end_message: str
-    seconds_formatter: Callable[[float], str]
-    user_extra: dict[str, Any]
-
-    def __call__(self, splits: Sequence[DatetimeSplitBounds]) -> Iterable[DatetimeSplitBounds]:
-        n_splits = len(splits)
-
-        for n, split in enumerate(splits, start=1):
-            extra: dict[str, str | float | int | bool] = dict(
-                n=n,
-                n_splits=n_splits,
-                start=split.start.isoformat(),
-                mid=split.mid.isoformat(),
-                end=split.end.isoformat(),
-                **self.user_extra,
-            )
-            kwargs: dict[str, Any] = dict(
-                n=n,
-                n_splits=n_splits,
-                start=_PrettyTimestamp(split.start),
-                mid=_PrettyTimestamp(split.mid),
-                end=_PrettyTimestamp(split.end),
-                **self.user_extra,
-            )
-            kwargs.update(fold=self.fold_format.format(**kwargs))
-
-            self.logger.log(self.start_level, self.start_message.format(**kwargs), extra=extra)
-
-            # Yield split and count user time.
-            start = perf_counter()
-            yield split
-            seconds = round(perf_counter() - start, 6)
-
-            kwargs.update(
-                seconds=seconds,
-                formatted_seconds=self.seconds_formatter(seconds),
-            )
-            extra.update(seconds=seconds)
-            self.logger.log(self.end_level, self.end_message.format(**kwargs), extra=extra)
-
-
-class _MergingLoggerAdapter(logging.LoggerAdapter):  # type: ignore[type-arg]
-    def process(self, msg: Any, kwargs: MutableMapping[str, Any]) -> tuple[Any, MutableMapping[str, Any]]:
-        """See https://github.com/python/cpython/pull/107292."""
-        kwargs["extra"] = {**self.extra, **kwargs["extra"]} if "extra" in kwargs and self.extra else self.extra
-        return msg, kwargs