time-split 0.1.0__py3-none-any.whl

time_split/_frontend/_plot.py

@@ -0,0 +1,355 @@
+from dataclasses import asdict, dataclass
+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 .._backend import DatetimeIndexSplitter
+from .._backend._datetime_index_like import DatetimeIndexLike
+from .._backend._limits import LimitsTuple
+from .._docstrings import docs
+from .._support import handle_dask
+from ..settings import plot as settings
+from ..types import (
+    DatetimeIterable,
+    DatetimeSplitBounds,
+    DatetimeSplits,
+    Flex,
+    Schedule,
+    Span,
+)
+from ._split import split
+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]
+
+Rows = Literal["rows"]
+COUNT_ROWS: Literal["rows"] = "rows"
+
+
+@dataclass(frozen=True)
+class Available:
+    """Metadata concerning the `available` data passed by the user."""
+
+    index: DatetimeIndexLike
+    true_limits: LimitsTuple
+    expanded_limits: LimitsTuple
+
+
+@dataclass(frozen=True)
+class PlotData:
+    """Data used for plotting."""
+
+    splits: DatetimeSplits
+    """All splits to plot."""
+    removed: set[DatetimeSplitBounds]
+    """A subset of `splits` that should be plotted that would be filtered by user arguments."""
+    row_counts: pd.Series | None = None
+    """Row counts for `available`. May be pre-computed by the user."""
+    available: Available | None = None
+
+
+@docs
+def plot(
+    schedule: Schedule,
+    *,
+    before: Span = "7d",
+    after: Span = 1,
+    step: int = 1,
+    n_splits: int | None = None,
+    available: DatetimeIterable | None = None,
+    flex: Flex = "auto",
+    # Split plot args
+    bar_labels: str | Rows | list[tuple[str, str]] | bool = True,
+    show_removed: bool = False,
+    row_count_bin: str | pd.Series | None = None,
+    ax: "Axes | None" = None,
+) -> "Axes":
+    """Fold visualization.
+
+    This function plots the folds and in-fold splits that would be made by passing the same arguments to the
+    :func:`.split`-function.
+
+    Args:
+        schedule: {schedule}
+        before: {before}
+        after: {after}
+        step: {step}
+        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}
+        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
+            bar labels, pass a list ``[(data_label, future_data_label), ...]``, one tuple for each fold. This may be
+            used to write metric values per data set after cross validation.
+        show_removed: If ``True``, splits removed by `n_splits` or `step` are included in the figure.
+        row_count_bin: A {OFFSET}. If given, show normalized row count per `row_count_bin` in the background. Pass
+            ``pandas.Series`` to use pre-computed row counts.
+        ax: Axis to use for plotting. If ``None``, create new axes.
+
+    {USER_GUIDE}
+
+    Returns:
+        Matplitlib axes.
+
+    Raises:
+        ValueError: For invalid plot/split argument combinations.
+
+    Examples:
+        .. minigallery:: time_split.plot
+    """
+    import matplotlib.pyplot as plt
+
+    splitter = DatetimeIndexSplitter(
+        schedule,
+        before=before,
+        after=after,
+        step=step,
+        n_splits=n_splits,
+        flex=flex,
+    )
+    plot_data = _get_plot_data(available, splitter, row_count_bin=row_count_bin, show_removed=show_removed)
+
+    if bar_labels is True:
+        bar_labels = settings.DEFAULT_TIME_UNIT if plot_data.available is None else COUNT_ROWS
+
+    if ax is None:
+        _, ax = plt.subplots(
+            tight_layout=True,
+            figsize=(
+                plt.rcParams["figure.figsize"][0],
+                3 + len(plot_data.splits) * 0.5,
+            ),
+        )
+
+    _plot_splits(ax, plot_data.splits, removed=plot_data.removed)
+
+    if bar_labels:
+        _add_bar_labels(
+            ax,
+            plot_data,
+            unit_or_labels=bar_labels,
+            label_type="center",
+            font="monospace",
+        )
+
+    # Set title
+    split_kwargs = asdict(splitter)
+    split_kwargs["n_splits"] = n_splits  # We may "incorrectly" set this to None to show excluded folds.
+    ax.set_title(_make_title(available, split_kwargs))
+
+    if plot_data.available is None:
+        ax.legend(loc=("lower" if splitter.step > 0 else "upper") + " right")
+        return ax
+
+    _plot_limits(ax, plot_data.available.expanded_limits)
+
+    if plot_data.row_counts is not None:
+        assert isinstance(row_count_bin, (str, pd.Series))  # noqa: S101
+        _plot_row_counts(ax, row_count_bin, plot_data.row_counts)
+
+    ax.legend(loc=("lower" if splitter.step > 0 else "upper") + " right")
+
+    return ax
+
+
+def _plot_limits(ax: "Axes", limits: LimitsTuple) -> None:
+    from matplotlib.dates import date2num
+
+    left, right = limits
+    ax.axvline(left, color="k", ls="--", label="Outer range")
+    ax.axvline(right, color="k", ls="--")
+    left_tick, right_tick = date2num(left), date2num(right)  # type: ignore[no-untyped-call]
+    ax.set_xticks([left_tick, *ax.get_xticks(), right_tick])
+
+
+def _plot_splits(ax: "Axes", splits: DatetimeSplits, *, removed: set[DatetimeSplitBounds]) -> None:
+    from matplotlib.dates import AutoDateFormatter
+
+    kwargs: dict[str, Any]
+    xtick: list[Timestamp] = []
+    ytick: list[int | None] = []
+    for i, (start, mid, stop) in enumerate(splits, start=1):
+        blue_label, red_label = None, None
+        if (start, mid, stop) in removed:
+            kwargs = settings.REMOVED_FOLD_STYLE
+            ytick.append(None)
+        else:
+            kwargs = {"alpha": 1}
+            fold_no = 1 + sum(1 for t in ytick if t is not None)
+            ytick.append(fold_no)
+            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)
+        xtick.append(mid)
+
+    ax.set_xticks(xtick)
+    locator = ax.xaxis.get_major_locator()
+    ax.xaxis.set_major_formatter(AutoDateFormatter(locator, defaultfmt="%Y-%m-%d\n%A"))  # type: ignore[no-untyped-call]
+
+    ax.set_ylabel("Fold")
+    ax.yaxis.get_major_locator().set_params(integer=True)  # type: ignore[call-arg]
+    ax.yaxis.set_ticks(range(1, len(splits) + 1), labels=["" if t is None else str(t) for t in ytick])
+
+
+def _plot_row_counts(ax: "Axes", row_count_bin: str | pd.Series, row_counts: pd.Series) -> None:
+    if isinstance(row_count_bin, pd.Series):
+        from numpy import diff, timedelta64
+
+        row_counts = row_count_bin.sort_index()
+        pretty = format_seconds(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())
+
+    row_counts = row_counts * (max(ax.get_yticks()) / row_counts.max())  # Normalize to fold number yaxis
+    ax.fill_between(
+        row_counts.index,
+        row_counts,
+        alpha=0.2,
+        color="grey",
+        label=f"#rows [bin: {pretty}]",
+    )
+
+
+def _add_bar_labels(
+    ax: "Axes",
+    plot_data: PlotData,
+    *,
+    unit_or_labels: list[tuple[str, str]] | str,
+    **kwargs: Any,
+) -> None:
+    if not (hasattr(ax, "bar_label") and callable(ax.bar_label)):
+        raise TypeError(f"Given axes={ax!r} don't have a bar_label()-method.")
+
+    if isinstance(unit_or_labels, list):
+        labels = [e for t in unit_or_labels for e in t]
+    else:
+        labels = _make_count_labels(
+            plot_data.splits,
+            available=None if plot_data.available is None else plot_data.available.index,
+            unit=unit_or_labels,
+        )
+
+    for bar, label in zip(ax.containers, labels):
+        ax.bar_label(bar, labels=[label], **kwargs)  # type: ignore[arg-type]
+
+
+def _make_count_labels(
+    splits: DatetimeSplits,
+    *,
+    available: DatetimeIterable | None,
+    unit: str = COUNT_ROWS,
+) -> list[str]:
+    counts = fold_weight(splits, unit=unit, available=available)
+
+    suffix = settings.ROW_UNIT if unit == COUNT_ROWS else unit
+    if len(suffix) > 1:
+        suffix = " " + suffix
+
+    def make_label(count: int) -> str:
+        count_str = (
+            f"{count:,}".replace(",", settings.THOUSANDS_SEPARATOR)
+            if count >= settings.THOUSANDS_SEPARATOR_CUTOFF
+            else str(count)
+        )
+        return count_str + suffix
+
+    labels: list[str] = []
+    for data, future_data in counts:
+        labels.extend((make_label(data), make_label(future_data)))
+    return labels
+
+
+def _get_plot_data(
+    available: DatetimeIterable | None,
+    splitter: DatetimeIndexSplitter,
+    *,
+    row_count_bin: pd.Series | str | None,
+    show_removed: bool,
+) -> PlotData:
+    splits, ms = splitter.get_plot_data(available)
+    available = ms.available_metadata.available_as_index
+
+    if show_removed:
+        kept_splits = set(splits)
+        kwargs = asdict(splitter)  # Can't use dataclasses.replace: 3.10+ only
+        kwargs["n_splits"] = None
+        kwargs["step"] = 1
+        splits = DatetimeIndexSplitter(**kwargs).get_plot_data(available)[0]
+        if splitter.step < 0:
+            splits.reverse()
+        removed = set(splits) - set(kept_splits)
+    else:
+        removed = set()
+
+    row_counts = _compute_row_counts(available, row_count_bin=row_count_bin)
+
+    if available is None:
+        return PlotData(splits, removed=removed)
+    else:
+        return PlotData(
+            splits,
+            removed=removed,
+            row_counts=row_counts,
+            available=Available(
+                index=available,
+                true_limits=ms.available_metadata.limits,
+                expanded_limits=ms.available_metadata.expanded_limits,
+            ),
+        )
+
+
+def _compute_row_counts(
+    available: DatetimeIndexLike | None,
+    *,
+    row_count_bin: pd.Series | str | None,
+) -> pd.Series | None:
+    if row_count_bin is None:
+        return None
+
+    if isinstance(row_count_bin, pd.Series):
+        return row_count_bin
+
+    if available is None:
+        raise ValueError(f"Cannot use {row_count_bin=} without available data.")
+
+    index_like = available
+    if hasattr(index_like, "dt"):
+        # pandas series, dask datetime index
+        index_like = index_like.dt
+    elif not hasattr(index_like, "floor"):
+        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())
+
+
+def _make_title(available: Any | None, split_kwargs: dict[str, Any]) -> str:
+    from inspect import signature
+
+    default = {name: params.default for name, params in signature(split).parameters.items()}
+
+    def is_default(key: str) -> bool:
+        try:
+            return bool(split_kwargs[key] == default[key])
+        except ValueError:
+            return all(split_kwargs[key] == default[key])
+
+    kwargs = {key: value for key, value in split_kwargs.items() if not is_default(key)}
+    if available is None:
+        formatted_available = ""
+    else:
+        pretty = get_public_module(type(available), resolve_reexport=True, include_name=True)
+        formatted_available = f", available={pretty}"
+    return f"time_split.split({format_kwargs(kwargs, max_value_length=40)}{formatted_available})"

time_split/_frontend/_progress.py

@@ -0,0 +1,125 @@
+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

time_split/_frontend/_split.py

@@ -0,0 +1,45 @@
+from .._backend import DatetimeIndexSplitter
+from .._docstrings import docs
+from ..types import DatetimeIterable, DatetimeSplits, Flex, Schedule, Span
+
+
+@docs
+def split(
+    schedule: Schedule,
+    *,
+    before: Span = "7d",
+    after: Span = 1,
+    step: int = 1,
+    n_splits: int | None = None,
+    available: DatetimeIterable | None = None,
+    flex: Flex = "auto",
+) -> DatetimeSplits:
+    """Create time-based cross-validation splits.
+
+    To visualize the folds, pass the same arguments to the :func:`.plot`-function.
+
+    Args:
+        schedule: {schedule}
+        before: {before}
+        after: {after}
+        step: {step}
+        n_splits: {n_splits}
+        available: {available} Passing a tuple ``(min, max)`` is enough.
+        flex: {flex}
+
+    {USER_GUIDE}
+
+    Returns:
+        A list of tuples ``[(start, mid, end), ...]``.
+
+    Examples:
+        .. minigallery:: time_split.split
+    """
+    return DatetimeIndexSplitter(
+        schedule,
+        before=before,
+        after=after,
+        step=step,
+        n_splits=n_splits,
+        flex=flex,
+    ).get_splits(available)

time_split/_frontend/_to_string.py

@@ -0,0 +1,103 @@
+from typing import Any, Literal, overload
+
+from pandas import Timestamp
+
+from ..settings import log_split_progress
+from ..types import DatetimeSplitBounds, DatetimeTypes
+
+
+@overload
+def to_string(
+    bounds: DatetimeTypes,
+    __ignored0: DatetimeTypes,
+    __ignored1: DatetimeTypes,
+    /,
+    *,
+    format: str | None = None,
+) -> str: ...
+
+
+@overload
+def to_string(
+    start: tuple[DatetimeTypes, DatetimeTypes, DatetimeTypes],
+    mid: Literal[None] = None,
+    end: Literal[None] = None,
+    /,
+    *,
+    format: str | None = None,
+) -> str: ...
+
+
+def to_string(
+    bounds: (DatetimeTypes | DatetimeSplitBounds | tuple[DatetimeTypes, DatetimeTypes, DatetimeTypes]),
+    mid: DatetimeTypes | None = None,
+    end: DatetimeTypes | None = None,
+    /,
+    *,
+    format: str | None = None,
+) -> str:
+    """Pretty-print a fold.
+
+    .. code-block:: python
+       :caption: Sample output.
+
+       ('2021-12-30' <= [schedule: '2022-01-04' (Tuesday)] < '2022-01-04 18:00:00')
+
+    Args:
+        bounds: A fold tuple ``(start, mid, end)``, or just `start` (followed by `mid` and `end`).
+        mid: Datetime-like. Must be ``None`` when `bounds` is a tuple.
+        end: Datetime-like. Must be ``None`` when `bounds` is a tuple.
+        format: A custom format to use. Use :attr:`~.settings.log_split_progress.FOLD_FORMAT` if ``None``, but note that
+            only the `start`, `mid` and `end` keys are available to this function.
+
+    Returns:
+        Formatted bounds string.
+
+    Raises:
+        TypeError: If an incorrect number of timestamps are given.
+
+    """
+    if isinstance(bounds, tuple):
+        if not (mid is None and end is None):
+            raise TypeError(f"Too many arguments: {(bounds, mid, end)}.")
+        start, mid, end = bounds
+    else:
+        if mid is None or end is None:
+            raise TypeError(f"Too few arguments: {(bounds, mid, end)}.")
+        start = bounds
+
+    return (log_split_progress.FOLD_FORMAT if format is None else format).format(
+        start=_PrettyTimestamp(start),
+        mid=_PrettyTimestamp(mid),
+        end=_PrettyTimestamp(end),
+    )
+
+
+class _PrettyTimestamp:
+    def __init__(self, raw: DatetimeTypes) -> None:
+        self.timestamp = Timestamp(raw)
+        self._auto: str | None = None
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self.timestamp, name)
+
+    def __str__(self) -> str:
+        return str(self.timestamp)
+
+    def __repr__(self) -> str:
+        return repr(self.timestamp)
+
+    def __format__(self, format_spec: str) -> str:
+        return format(self.timestamp, format_spec)
+
+    @property
+    def auto(self) -> str:
+        if self._auto is None:
+            timestamp = self.timestamp.round("s")
+            format_spec = (
+                log_split_progress.AUTO_DATE_FORMAT
+                if timestamp.normalize() == timestamp
+                else log_split_progress.AUTO_DATETIME_FORMAT
+            )
+            self._auto = format(timestamp, format_spec)
+        return self._auto

time_split/_frontend/_weight.py

@@ -0,0 +1,66 @@
+from typing import Literal
+
+from pandas import DatetimeIndex, Timedelta
+
+from .._support import handle_dask
+from ..types import DatetimeIterable, DatetimeSplitCounts, DatetimeSplits
+
+
+def fold_weight(
+    splits: DatetimeSplits,
+    *,
+    unit: str | Literal["rows", "hours", "days"] = "hours",
+    available: DatetimeIterable | None = None,
+) -> list[DatetimeSplitCounts]:
+    """Compute fold weights.
+
+    Args:
+        splits: List of :attr:`~time_split.types.DatetimeSplitBounds`.
+        unit: Time unit of the returned count, or `'rows'` (requires `available` data).
+        available: Available data. Required when ``unit='rows'``.
+
+    Returns:
+        A list of tuples ``[(n_data_units, n_future_data_units), ...]``.
+
+    Raises:
+        ValueError: if ``unit='rows'`` and ``available=None``.
+
+    """
+    if unit == "rows":
+        if available is None:
+            raise ValueError(f"Must provide available data when {unit=}.")
+        return _from_data(available, splits)
+    else:
+        return _from_unit(unit, splits)
+
+
+def _from_unit(unit: str, splits: DatetimeSplits) -> list[DatetimeSplitCounts]:
+    resolution = Timedelta(1, unit=unit)
+    return [
+        DatetimeSplitCounts(
+            round((fold.mid - fold.start) / resolution),
+            round((fold.end - fold.mid) / resolution),
+        )
+        for fold in splits
+    ]
+
+
+def _from_data(available: DatetimeIterable, splits: DatetimeSplits) -> list[DatetimeSplitCounts]:
+    if hasattr(available, "to_series"):
+        time = available.to_series()  # Works for Dask and Pandas.
+    elif hasattr(available, "between"):
+        time = available  # This is what we want. Dask index has this attribute, but calling it fails.
+    else:
+        time = DatetimeIndex(available).to_series()  # Coerce everything else.
+
+    retval = []
+    for fold in splits:
+        data = time.between(fold.start, fold.mid, inclusive="left").sum()
+        future_data = time.between(fold.mid, fold.end, inclusive="left").sum()
+
+        data = handle_dask(data)
+        future_data = handle_dask(future_data)
+
+        retval.append(DatetimeSplitCounts(data, future_data=future_data))
+
+    return retval