time-split 1.1.1__tar.gz → 1.2.1__tar.gz

{time_split-1.1.1 → time_split-1.2.1}/LICENSE.md

@@ -1,6 +1,6 @@
 # MIT License
 
-Copyright (c) 2024, Richard Sundqvist
+Copyright © 2026, Richard Sundqvist
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{time_split-1.1.1 → time_split-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: time-split
-Version: 1.1.1
+Version: 1.2.1
 Summary: Time-based k-fold validation splits for heterogeneous data.
 License: MIT
 License-File: LICENSE.md
@@ -116,7 +116,6 @@ most recent stable release.
 Hosted on Read the Docs: https://time-split.readthedocs.io
 
 ## Contributing
-
 All contributions, bug reports, bug fixes, documentation improvements, enhancements, and ideas are welcome. To get 
 started, see the [Contributing Guide](CONTRIBUTING.md) and [Code of Conduct](CODE_OF_CONDUCT.md).
 

{time_split-1.1.1 → time_split-1.2.1}/README.md

@@ -76,7 +76,6 @@ most recent stable release.
 Hosted on Read the Docs: https://time-split.readthedocs.io
 
 ## Contributing
-
 All contributions, bug reports, bug fixes, documentation improvements, enhancements, and ideas are welcome. To get 
 started, see the [Contributing Guide](CONTRIBUTING.md) and [Code of Conduct](CODE_OF_CONDUCT.md).
 

{time_split-1.1.1 → time_split-1.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "time-split"
-version = "1.1.1"
+version = "1.2.1"
 description = "Time-based k-fold validation splits for heterogeneous data."
 authors = [
     { name = "Richard Sundqvist", email = "richard.sundqvist@live.se" },
@@ -60,37 +60,39 @@ polars = { version = "~1.35.2", extras = ["pandas"] }
 # duplicate object warnings for sphinx>=4
 # description: https://github.com/astropy/astropy/issues/11723
 # https://github.com/astropy/astropy/pull/12270
-sphinx = "~8.1.3" # 8.2 breaks xdoc refs in README.md; maybe https://github.com/sphinx-doc/sphinx/issues/13932?
-sphinx-gallery = "~0.20.0"
-pydata-sphinx-theme = "~0.16.1"
-myst-parser = "~4.0.1"
-ipython = "~9.8.0"
+sphinx = { version = "~9.1.0", python = ">=3.12" }
+sphinx-gallery = { version = "~0.20.0", python = ">=3.12" }
+pydata-sphinx-theme = { version = "~0.16.1", python = ">=3.12" }
+myst-parser = { version = "~5.0.0", python = ">=3.12" } # https://github.com/executablebooks/MyST-Parser/issues/749
+nbsphinx = { version = "~0.9.8", python = ">=3.12" }
+ipython = { version = "~9.10.0", python = ">=3.12" }
+sphinx-llm = { version = "~0.3.0", python = ">=3.12" }
 
 [tool.poetry.group.notebooks]
 optional = true
 [tool.poetry.group.notebooks.dependencies]
-jupyterlab = "~4.4.10"
+jupyterlab = "~4.5.2"
 ipywidgets = "*"
 jupyterlab-execute-time = "*"
 tqdm = "*"
 
 [tool.poetry.group.test.dependencies]
-pytest = "~9.0.1"
+pytest = "~9.0.2"
 xdoctest = "~1.3.0"
-coverage = "~7.12.0"
+coverage = "~7.13.1"
 pytest-cov = "~7.0.0"
 
-scikit-learn = "~1.7.2"
-dask = { version = "~2025.10.0", extras = ["dataframe"] }
+scikit-learn = "~1.8.0"
+dask = { version = "~2026.1.1", extras = ["dataframe"] }
 
 [tool.poetry.group.devops.dependencies]
 invoke = "~2.2.1"
 mypy = "~1.19.0"
-ruff = "~0.14.8"
+ruff = "~0.14.13"
 
 safety = "~3.7.0"
 codespell = "~2.4.1"
-bump2version = "~1.0.1"
+bump2version = "==1.0.1"
 
 [tool.ruff]
 line-length = 120

{time_split-1.1.1 → time_split-1.2.1}/src/time_split/__init__.py

@@ -9,4 +9,4 @@ __all__ = [
     "split",
 ]
 
-__version__ = "1.1.1"
+__version__ = "1.2.1"

{time_split-1.1.1 → time_split-1.2.1}/src/time_split/_backend/_limits.py

@@ -4,6 +4,7 @@ from typing import Any, NamedTuple, TypeGuard
 
 from pandas import Timedelta, Timestamp
 
+from .._compat import fix_pandas4_warning, make_timedelta
 from ..settings import auto_expand_limits, misc
 from ..types import ExpandLimits, TimedeltaTypes
 
@@ -159,19 +160,20 @@ def _levels_from_settings() -> list[_TimedeltaTuple]:
 
 def _make_level(
     start_at: TimedeltaTypes | None,
-    round_to: TimedeltaTypes,
+    round_to: str | Timedelta,
     tolerance: TimedeltaTypes,
 ) -> _TimedeltaTuple:
-    start_at = Timedelta(start_at)  # Will be NaT if None, making all ifs False.
+    start_at = make_timedelta(start_at)  # Will be NaT if None, making all ifs False.
     if start_at <= Timedelta(0):
         raise ValueError(f"Bad {start_at=}; must be non-negative.")
 
-    try:
-        round_to = Timedelta(1, unit=round_to)
-    except ValueError as e:
-        raise ValueError(f"Got {round_to=}, which is not a valid frequency.") from e
+    if isinstance(round_to, str):
+        try:
+            round_to = Timedelta(1, unit=fix_pandas4_warning(round_to))
+        except ValueError as e:
+            raise ValueError(f"Got {round_to=}, which is not a valid frequency.") from e
 
-    tolerance = Timedelta(tolerance)
+    tolerance = make_timedelta(tolerance)
     if tolerance <= Timedelta(0):
         raise ValueError(f"Bad {tolerance=}; must be non-negative.")
 

{time_split-1.1.1 → time_split-1.2.1}/src/time_split/_backend/_schedule.py

@@ -2,6 +2,7 @@ from typing import Literal, NamedTuple, get_args
 
 from pandas import DatetimeIndex, NaT, Timedelta, Timestamp, date_range
 
+from .._compat import make_timedelta
 from ..settings import misc as settings
 from ..types import DatetimeIterable, ExpandLimits, Schedule, TimedeltaTypes
 from ._limits import LimitsTuple
@@ -60,7 +61,7 @@ def _cron_like(schedule: str) -> bool:
 
 
 def _from_timedelta(schedule: TimedeltaTypes, limits: LimitsTuple) -> DatetimeIndex:
-    timedelta = Timedelta(schedule)
+    timedelta = make_timedelta(schedule)
     if timedelta <= Timedelta(0):
         raise ValueError(f"unbounded {schedule=} must be greater than zero.")
 

time_split-1.2.1/src/time_split/_backend/_span.py

@@ -0,0 +1,153 @@
+from collections.abc import Callable
+from datetime import timedelta
+from typing import Literal, TypeAlias
+
+from pandas import DatetimeIndex, Timedelta, Timestamp
+
+from .._compat import make_timedelta
+from ..types import Span
+from ._limits import LimitsTuple
+from ._schedule import NO_LIMITS
+
+StrictSpan: TypeAlias = int | Timedelta | Literal["all", "empty"]
+SpanArgumentName = Literal["before", "after"]
+FuncType = Callable[[int], Timestamp | None]
+
+
+class InvalidSpanError(ValueError):
+    """Raised when offsets values for 'before' and 'after' arguments are invalid."""
+
+    def __init__(
+        self,
+        span: Span,
+        *,
+        name: SpanArgumentName,
+        reason: str = "must be greater than zero",
+    ) -> None:
+        super().__init__(f"Bad '{name}'-argument; offset {span!r} {reason}.")
+
+
+def _to_timedelta(span: str | timedelta | Timedelta, *, name: SpanArgumentName) -> Timedelta:
+    retval = make_timedelta(span)
+    if retval <= Timedelta(0):
+        raise InvalidSpanError(span, name=name)
+    return retval
+
+
+def to_strict_span(span: Span, *, name: SpanArgumentName) -> StrictSpan:
+    """Convert `span` to a strict span.
+
+    Args:
+        span: User span.
+        name: Name of user input. User for error reporting.
+
+    Returns:
+        A valid span with reduced types.
+
+    Raises:
+        TypeError: For bad `span` types.
+        InvalidSpanError: For invalid `span` arguments.
+
+    """
+    if span in {"all", "empty"}:
+        return span
+
+    if isinstance(span, (str, timedelta, Timedelta)):
+        return _to_timedelta(span, name=name)
+
+    if isinstance(span, (int, float)):
+        retval = int(span)
+        if retval <= 0:
+            raise InvalidSpanError(retval, name=name)
+        return retval
+
+    raise TypeError(f"cannot parse '{name}'-argument of type {type(span).__name__}: {span!r}.")
+
+
+class OffsetCalculator:
+    """Utility class for computing before/after offsets from the `schedule`."""
+
+    def __init__(
+        self,
+        span: Span,
+        schedule: DatetimeIndex,
+        limits: LimitsTuple,
+        *,
+        name: SpanArgumentName,
+    ) -> None:
+        span = to_strict_span(span, name=name)
+        is_before = name == "before"
+
+        self._schedule = schedule
+        self._is_before = is_before
+        self._limits: LimitsTuple | None = None if limits == NO_LIMITS else limits
+
+        self._func: FuncType
+        if span == "all":
+            self._func = self.get_all
+        elif span == "empty":
+            self._func = self.get_empty
+        elif isinstance(span, int):
+            self._func = self._make_int(span)
+        else:  # Timedelta
+            self._func = self._make_timedelta(span)
+
+    def get(self, i: int) -> Timestamp | None:
+        """Get get outer bound at index `i`."""
+        rv = self._func(i)
+        if rv is None:
+            return None
+
+        mid = self._schedule[i]
+
+        if self._limits:
+            min_start, max_end = self._limits
+            if not (min_start <= mid <= max_end):
+                return None  # Snapping to end may shift schedule out of range.
+            if not (min_start <= rv <= max_end):
+                return None
+
+        if rv == mid and self._func != self.get_empty:
+            return None
+
+        return rv
+
+    def get_all(self, _: int) -> Timestamp:
+        if self._limits is None:
+            raise InvalidSpanError("all", name=self.name, reason="requires available data to bound the schedule")
+
+        index = 0 if self._is_before else 1
+        return self._limits[index]
+
+    def get_empty(self, i: int) -> Timestamp:
+        return self._schedule[i]
+
+    def _make_int(self, offset: int) -> FuncType:
+        def func(i: int) -> Timestamp | None:
+            i = i - offset if self._is_before else i + offset
+            if 0 <= i < len(self._schedule):
+                return self._schedule[i]
+            else:
+                return None
+
+        func.__name__ = f"get_int({offset})"
+        return func
+
+    def _make_timedelta(self, offset: Timedelta) -> FuncType:
+        if self._is_before:
+            schedule = self._schedule - offset
+        else:
+            schedule = self._schedule + offset
+
+        def func(i: int) -> Timestamp:
+            return schedule[i]
+
+        func.__name__ = f"get_timedelta('{offset}')"
+        return func
+
+    @property
+    def name(self) -> SpanArgumentName:
+        return "before" if self._is_before else "after"
+
+    def __str__(self) -> str:
+        return f"{type(self).__name__}({self.name}={self._func.__name__})"

{time_split-1.1.1 → time_split-1.2.1}/src/time_split/_backend/_splitter.py

@@ -1,9 +1,9 @@
 from dataclasses import asdict, dataclass
 from typing import cast, get_args
 
-from pandas import Timedelta
 from rics.misc import format_kwargs, get_by_full_name
 
+from .._compat import make_timedelta
 from ..settings import misc as settings
 from ..types import (
     DatetimeIndexSplitterKwargs,
@@ -52,7 +52,7 @@ class DatetimeIndexSplitter:
         types = get_args(TimedeltaTypes)
         if (
             settings.snap_to_end
-            and self.after != "all"
+            and self.after not in {"all", "empty"}
             and ms.schedule_type == "timedelta"
             and isinstance(self.after, (types, int))
         ):
@@ -66,29 +66,25 @@ class DatetimeIndexSplitter:
 
         from_end = data_end - schedule_end
         if not isinstance(self.after, int):
-            after = Timedelta(self.after)
+            after = make_timedelta(self.after)
             from_end -= after
 
         return ms._replace(schedule=ms.schedule + from_end)
 
     def _make_bounds_list(self, ms: MaterializedSchedule) -> DatetimeSplits:
-        get_start = OffsetCalculator(
-            self.before,
-            ms.schedule,
-            ms.available_metadata.expanded_limits,
-            name="before",
-        )
-        get_end = OffsetCalculator(self.after, ms.schedule, ms.available_metadata.expanded_limits, name="after")
-
-        min_start, max_end = ms.available_metadata.expanded_limits
+        oc_start = OffsetCalculator(self.before, ms.schedule, ms.available_metadata.expanded_limits, name="before")
+        oc_end = OffsetCalculator(self.after, ms.schedule, ms.available_metadata.expanded_limits, name="after")
 
         retval = []
         for i, mid in enumerate(ms.schedule):
-            start, end = get_start(i), get_end(i)
-            if start is None or start < min_start or start >= mid:
+            start = oc_start.get(i)
+            if start is None:
                 continue
-            if end is None or end > max_end or end <= mid:
+
+            end = oc_end.get(i)
+            if end is None:
                 continue
+
             retval.append(DatetimeSplitBounds(start, mid, end))
 
         if not retval:

time_split-1.2.1/src/time_split/_compat.py

@@ -0,0 +1,14 @@
+from pandas import Timedelta
+
+from time_split.types import TimedeltaTypes
+
+
+def fix_pandas4_warning(arg: str) -> str:
+    return arg[:-1] + "D" if arg.endswith("d") else arg
+
+
+def make_timedelta(arg: TimedeltaTypes) -> Timedelta:
+    if isinstance(arg, str):
+        arg = fix_pandas4_warning(arg)
+
+    return Timedelta(arg)

{time_split-1.1.1 → time_split-1.2.1}/src/time_split/_docstrings.py

@@ -13,7 +13,7 @@ def docs(__func: Callable[P, T], /) -> Callable[P, T]:
     offset = "pandas :ref:`offset alias <pandas:timeseries.offset_aliases>`"
     span = (
         f"Range {{}} `schedule` timestamps. Either a {offset}, an integer (`schedule`-based offsets), "
-        f"or `'all'` (requires `available` data)."
+        f"or `'all'` (requires `available` data). Pass `'empty'` to disable."
     )
     docstrings = {
         "schedule": f"A :attr:`~time_split.types.DatetimeIterable`, {offset}, or `cron <https://pypi.org/project/croniter/>`_ expression.",

{time_split-1.1.1 → time_split-1.2.1}/src/time_split/_frontend/_plot.py

@@ -1,4 +1,6 @@
+import os
 from collections.abc import Sized
+from contextlib import suppress
 from dataclasses import asdict, dataclass, replace
 from typing import TYPE_CHECKING, Any, Literal
 
@@ -10,6 +12,7 @@ from rics.strings import format_seconds as fmt_sec
 from .._backend import DatetimeIndexSplitter
 from .._backend._datetime_index_like import DatetimeIndexLike
 from .._backend._limits import LimitsTuple
+from .._compat import fix_pandas4_warning, make_timedelta
 from .._docstrings import docs
 from .._support import handle_dask
 from ..settings import plot as settings
@@ -26,11 +29,8 @@ from ._split import split
 from ._to_string import _PrettyTimestamp
 from ._weight import fold_weight
 
-if TYPE_CHECKING:
-    try:
-        from matplotlib.pyplot import Axes  # type: ignore[attr-defined]
-    except ModuleNotFoundError:
-        Axes = Any  # type: ignore[misc, assignment]
+if TYPE_CHECKING or os.environ.get("SPHINX_BUILD") is True:
+    from matplotlib.axes import Axes  #  noqa: TC002
 
 Rows = Literal["rows"]
 COUNT_ROWS: Literal["rows"] = "rows"
@@ -211,8 +211,8 @@ def _plot_splits(ax: "Axes", splits: DatetimeSplits, *, removed: set[DatetimeSpl
             if fold_no == 1:
                 blue_label, red_label = settings.DATA_LABEL, settings.FUTURE_DATA_LABEL
 
-        ax.barh(i, mid - start, left=start, color="b", label=blue_label, **kwargs)
-        ax.barh(i, stop - mid, left=mid, color="r", label=red_label, **kwargs)
+        ax.barh(i, mid - start, left=start, color="b", label=None if mid == start else blue_label, **kwargs)
+        ax.barh(i, stop - mid, left=mid, color="r", label=None if mid == stop else red_label, **kwargs)
         xtick.append(mid)
 
     ax.set_xticks(xtick)
@@ -232,7 +232,7 @@ def _plot_row_counts(ax: "Axes", row_count_bin: str | pd.Series, row_counts: pd.
         pretty = fmt_sec(diff(row_counts.index).min() / timedelta64(1, "s"))
     else:
         row_counts = row_counts.sort_index()
-        pretty = fmt_sec(pd.Timedelta(row_count_bin).total_seconds())
+        pretty = fmt_sec(make_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(
@@ -264,6 +264,9 @@ def _add_bar_labels(
         )
 
     for bar, label in zip(ax.containers, labels, strict=True):
+        with suppress(Exception):
+            if bar.datavalues.tolist() == [0]:  # type: ignore[attr-defined]
+                continue  # Zero-width bar.
         ax.bar_label(bar, labels=[label], **kwargs)  # type: ignore[arg-type]
 
 
@@ -352,7 +355,7 @@ def _compute_row_counts(
         a_type = get_public_module(type(available), resolve_reexport=True, include_name=True)
         raise TypeError(f"type(available)={a_type} must have one of `floor` and `dt` to use {row_count_bin=}")
 
-    return handle_dask(index_like.floor(row_count_bin).value_counts())
+    return handle_dask(index_like.floor(fix_pandas4_warning(row_count_bin)).value_counts())
 
 
 def _make_title(available: Any | None, split_kwargs: dict[str, Any]) -> str:

{time_split-1.1.1 → time_split-1.2.1}/src/time_split/_frontend/_weight.py

@@ -2,6 +2,7 @@ from typing import Literal
 
 from pandas import DatetimeIndex, Timedelta
 
+from .._compat import fix_pandas4_warning
 from .._support import handle_dask
 from ..types import DatetimeIterable, DatetimeSplitCounts, DatetimeSplits
 
@@ -35,7 +36,7 @@ def fold_weight(
 
 
 def _from_unit(unit: str, splits: DatetimeSplits) -> list[DatetimeSplitCounts]:
-    resolution = Timedelta(1, unit=unit)
+    resolution = Timedelta(1, unit=fix_pandas4_warning(unit))
     return [
         DatetimeSplitCounts(
             round((fold.mid - fold.start) / resolution),

{time_split-1.1.1 → time_split-1.2.1}/src/time_split/types.py

@@ -18,7 +18,7 @@ TimedeltaTypes: _t.TypeAlias = str | _pd.Timedelta | _dt.timedelta | _np.timedel
 
 Schedule: _t.TypeAlias = _pd.DatetimeIndex | DatetimeIterable | TimedeltaTypes
 """User schedule type."""
-Span = int | _t.Literal["all"] | TimedeltaTypes
+Span = int | _t.Literal["all", "empty"] | TimedeltaTypes
 """User span type. Used to determine limits from the timestamps given by a :attr:`Schedule`."""
 ExpandLimits = bool | _t.Literal["auto"] | str
 """Limits flexibility spec for ``floor/ceil``. Pass ``False`` to disable."""

time_split-1.1.1/src/time_split/_backend/_span.py

@@ -1,128 +0,0 @@
-from collections.abc import Callable
-from datetime import timedelta
-from typing import Literal, TypeAlias
-
-from pandas import DatetimeIndex, Timedelta, Timestamp
-
-from ..types import Span
-from ._limits import LimitsTuple
-from ._schedule import NO_LIMITS
-
-StrictSpan: TypeAlias = int | Timedelta | Literal["all"]
-SpanArgumentName = Literal["before", "after"]
-FuncType = Callable[[int], Timestamp | None]
-
-
-class InvalidSpanError(ValueError):
-    """Raised when offsets values for 'before' and 'after' arguments are invalid."""
-
-    def __init__(
-        self,
-        span: Span,
-        *,
-        name: SpanArgumentName,
-        reason: str = "must be greater than zero",
-    ) -> None:
-        super().__init__(f"Bad '{name}'-argument; offset {span!r} {reason}.")
-
-
-def _to_timedelta(span: str | timedelta | Timedelta, *, name: SpanArgumentName) -> Timedelta:
-    retval = Timedelta(span)
-    if retval <= Timedelta(0):
-        raise InvalidSpanError(span, name=name)
-    return retval
-
-
-def to_strict_span(span: Span, *, name: SpanArgumentName) -> StrictSpan:
-    """Convert `span` to a strict span.
-
-    Args:
-        span: User span.
-        name: Name of user input. User for error reporting.
-
-    Returns:
-        A valid span with reduced types.
-
-    Raises:
-        TypeError: For bad `span` types.
-        InvalidSpanError: For invalid `span` arguments.
-
-    """
-    if span == "all":
-        return "all"
-
-    if isinstance(span, (str, timedelta, Timedelta)):
-        return _to_timedelta(span, name=name)
-
-    if span is False or isinstance(span, (int, float)):
-        retval = int(span)
-        if retval <= 0:
-            raise InvalidSpanError(retval, name=name)
-        return retval
-
-    raise TypeError(f"cannot parse '{name}'-argument of type {type(span).__name__}: {span!r}.")
-
-
-class OffsetCalculator:
-    """Utility class for computing before/after offsets from the `schedule`."""
-
-    def __init__(
-        self,
-        span: Span,
-        schedule: DatetimeIndex,
-        limits: LimitsTuple,
-        *,
-        name: SpanArgumentName,
-    ) -> None:
-        span = to_strict_span(span, name=name)
-        is_before = name == "before"
-
-        self.func: FuncType
-        if span == "all":
-            if limits == NO_LIMITS:
-                raise InvalidSpanError(
-                    span,
-                    name=name,
-                    reason="requires available data to bound the schedule",
-                )
-            self.func = self._make_all(is_before, limits)
-        elif isinstance(span, int):
-            self.func = self._make_int(is_before, span, schedule)
-        else:  # Timedelta
-            self.func = self._make_timedelta(is_before, span, schedule)
-
-    @staticmethod
-    def _make_all(is_before: bool, limits: LimitsTuple) -> FuncType:
-        retval = Timestamp(limits[0 if is_before else 1])
-
-        def func(_: int) -> Timestamp | None:
-            return retval
-
-        return func
-
-    @staticmethod
-    def _make_int(is_before: bool, offset: int, schedule: DatetimeIndex) -> FuncType:
-        def func(i: int) -> Timestamp | None:
-            i = i - offset if is_before else i + offset
-            if 0 <= i < len(schedule):
-                return schedule[i]
-            else:
-                return None
-
-        return func
-
-    @staticmethod
-    def _make_timedelta(is_before: bool, offset: Timedelta, schedule: DatetimeIndex) -> FuncType:
-        if is_before:
-            schedule = schedule - offset
-        else:
-            schedule = schedule + offset
-
-        def func(i: int) -> Timestamp | None:
-            return schedule[i]
-
-        return func
-
-    def __call__(self, i: int) -> Timestamp | None:
-        """Get start/end timestamp."""
-        return self.func(i)