time-split 1.1.0__tar.gz → 1.2.0__tar.gz

{time_split-1.1.0 → time_split-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: time-split
-Version: 1.1.0
+Version: 1.2.0
 Summary: Time-based k-fold validation splits for heterogeneous data.
 License: MIT
 License-File: LICENSE.md

{time_split-1.1.0 → time_split-1.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "time-split"
-version = "1.1.0"
+version = "1.2.0"
 description = "Time-based k-fold validation splits for heterogeneous data."
 authors = [
     { name = "Richard Sundqvist", email = "richard.sundqvist@live.se" },
@@ -65,6 +65,7 @@ sphinx-gallery = "~0.20.0"
 pydata-sphinx-theme = "~0.16.1"
 myst-parser = "~4.0.1"
 ipython = "~9.8.0"
+sphinx-llm = "~0.2.1"
 
 [tool.poetry.group.notebooks]
 optional = true

{time_split-1.1.0 → time_split-1.2.0}/src/time_split/__init__.py

@@ -9,4 +9,4 @@ __all__ = [
     "split",
 ]
 
-__version__ = "1.1.0"
+__version__ = "1.2.0"

{time_split-1.1.0 → time_split-1.2.0}/src/time_split/_backend/_schedule.py

@@ -1,4 +1,4 @@
-from typing import NamedTuple, get_args
+from typing import Literal, NamedTuple, get_args
 
 from pandas import DatetimeIndex, NaT, Timedelta, Timestamp, date_range
 
@@ -8,6 +8,7 @@ from ._limits import LimitsTuple
 from ._process_available import ProcessAvailableResult, process_available
 
 NO_LIMITS: LimitsTuple = NaT, NaT
+ScheduleType = Literal["cron", "explicit", "timedelta"]
 
 
 class MaterializedSchedule(NamedTuple):
@@ -15,6 +16,7 @@ class MaterializedSchedule(NamedTuple):
 
     schedule: DatetimeIndex
     available_metadata: ProcessAvailableResult
+    schedule_type: ScheduleType
 
 
 def materialize_schedule(
@@ -26,6 +28,7 @@ def materialize_schedule(
             return MaterializedSchedule(
                 DatetimeIndex(schedule),
                 available_metadata=ProcessAvailableResult(None, NO_LIMITS, NO_LIMITS),
+                schedule_type="explicit",
             )
         except TypeError as e:
             raise ValueError("Schedule must be explicit when not bounded by an available range.") from e
@@ -33,17 +36,22 @@ def materialize_schedule(
     available_metadata = process_available(available, expand_limits=expand_limits)
     min_dt, max_dt = available_metadata.expanded_limits
 
+    schedule_type: ScheduleType
     if isinstance(schedule, str) and _cron_like(schedule):
         schedule = _handle_cron(schedule, min_dt, max_dt)
+        schedule_type = "cron"
     elif isinstance(schedule, get_args(TimedeltaTypes)):
         schedule = _from_timedelta(schedule, available_metadata.expanded_limits)
+        schedule_type = "timedelta"
     else:
         if not isinstance(schedule, DatetimeIndex):
             schedule = DatetimeIndex(schedule)
 
         schedule = schedule.tz_localize(min_dt.tz) if schedule.tz is None else schedule.tz_convert(min_dt.tz)
         schedule = schedule[(min_dt <= schedule) & (schedule <= max_dt)]
-    return MaterializedSchedule(schedule, available_metadata=available_metadata)
+        schedule_type = "explicit"
+
+    return MaterializedSchedule(schedule, available_metadata, schedule_type)
 
 
 def _cron_like(schedule: str) -> bool:

{time_split-1.1.0 → time_split-1.2.0}/src/time_split/_backend/_span.py

@@ -8,7 +8,7 @@ from ..types import Span
 from ._limits import LimitsTuple
 from ._schedule import NO_LIMITS
 
-StrictSpan: TypeAlias = int | Timedelta | Literal["all"]
+StrictSpan: TypeAlias = int | Timedelta | Literal["all", "empty"]
 SpanArgumentName = Literal["before", "after"]
 FuncType = Callable[[int], Timestamp | None]
 
@@ -48,13 +48,13 @@ def to_strict_span(span: Span, *, name: SpanArgumentName) -> StrictSpan:
         InvalidSpanError: For invalid `span` arguments.
 
     """
-    if span == "all":
-        return "all"
+    if span in {"all", "empty"}:
+        return span
 
     if isinstance(span, (str, timedelta, Timedelta)):
         return _to_timedelta(span, name=name)
 
-    if span is False or isinstance(span, (int, float)):
+    if isinstance(span, (int, float)):
         retval = int(span)
         if retval <= 0:
             raise InvalidSpanError(retval, name=name)
@@ -77,52 +77,76 @@ class OffsetCalculator:
         span = to_strict_span(span, name=name)
         is_before = name == "before"
 
-        self.func: FuncType
+        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":
-            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)
+            self._func = self.get_all
+        elif span == "empty":
+            self._func = self.get_empty
         elif isinstance(span, int):
-            self.func = self._make_int(is_before, span, schedule)
+            self._func = self._make_int(span)
         else:  # Timedelta
-            self.func = self._make_timedelta(is_before, span, schedule)
+            self._func = self._make_timedelta(span)
 
-    @staticmethod
-    def _make_all(is_before: bool, limits: LimitsTuple) -> FuncType:
-        retval = Timestamp(limits[0 if is_before else 1])
+    def get(self, i: int) -> Timestamp | None:
+        """Get get outer bound at index `i`."""
+        rv = self._func(i)
+        if rv is None:
+            return None
 
-        def func(_: int) -> Timestamp | None:
-            return retval
+        mid = self._schedule[i]
 
-        return func
+        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
 
-    @staticmethod
-    def _make_int(is_before: bool, offset: int, schedule: DatetimeIndex) -> FuncType:
+    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 is_before else i + offset
-            if 0 <= i < len(schedule):
-                return schedule[i]
+            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
 
-    @staticmethod
-    def _make_timedelta(is_before: bool, offset: Timedelta, schedule: DatetimeIndex) -> FuncType:
-        if is_before:
-            schedule = schedule - offset
+    def _make_timedelta(self, offset: Timedelta) -> FuncType:
+        if self._is_before:
+            schedule = self._schedule - offset
         else:
-            schedule = schedule + offset
+            schedule = self._schedule + offset
 
-        def func(i: int) -> Timestamp | None:
+        def func(i: int) -> Timestamp:
             return schedule[i]
 
+        func.__name__ = f"get_timedelta('{offset}')"
         return func
 
-    def __call__(self, i: int) -> Timestamp | None:
-        """Get start/end timestamp."""
-        return self.func(i)
+    @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.0 → time_split-1.2.0}/src/time_split/_backend/_splitter.py

@@ -52,8 +52,8 @@ class DatetimeIndexSplitter:
         types = get_args(TimedeltaTypes)
         if (
             settings.snap_to_end
-            and self.after != "all"
-            and isinstance(self.schedule, types)
+            and self.after not in {"all", "empty"}
+            and ms.schedule_type == "timedelta"
             and isinstance(self.after, (types, int))
         ):
             ms = self._snap_to_end(ms)
@@ -72,23 +72,19 @@ class DatetimeIndexSplitter:
         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.1.0 → time_split-1.2.0}/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.0 → time_split-1.2.0}/src/time_split/_frontend/_plot.py

@@ -1,4 +1,5 @@
 from collections.abc import Sized
+from contextlib import suppress
 from dataclasses import asdict, dataclass, replace
 from typing import TYPE_CHECKING, Any, Literal
 
@@ -211,8 +212,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)
@@ -264,6 +265,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]
 
 

{time_split-1.1.0 → time_split-1.2.0}/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."""