time-split 0.3.0__tar.gz → 0.5.0__tar.gz

{time_split-0.3.0 → time_split-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: time-split
-Version: 0.3.0
+Version: 0.5.0
 Summary: Time-based k-fold validation splits for heterogeneous data.
 Home-page: https://github.com/rsundqvist/time-split
 Author: Richard Sundqvist
@@ -19,10 +19,13 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3 :: Only
 Provides-Extra: plotting
-Requires-Dist: matplotlib ; extra == "plotting"
+Provides-Extra: streamlit
+Requires-Dist: croniter ; extra == "streamlit"
+Requires-Dist: matplotlib ; extra == "plotting" or extra == "streamlit"
 Requires-Dist: pandas (>=2.0.3)
-Requires-Dist: rics (>=3.1.0)
-Requires-Dist: seaborn ; extra == "plotting"
+Requires-Dist: rics (>=4.1.1)
+Requires-Dist: seaborn ; extra == "plotting" or extra == "streamlit"
+Requires-Dist: streamlit ; extra == "streamlit"
 Project-URL: Bug Tracker, https://github.com/rsundqvist/time-split/issues
 Project-URL: Changelog, https://github.com/rsundqvist/time-split/blob/master/CHANGELOG.md
 Project-URL: Documentation, https://time-split.readthedocs.io
@@ -39,6 +42,7 @@ Time-based k-fold validation splits for heterogeneous data.
 [![Codecov](https://codecov.io/gh/rsundqvist/time-split/branch/master/graph/badge.svg)](https://codecov.io/gh/rsundqvist/time-split)
 [![Read the Docs](https://readthedocs.org/projects/time-split/badge/)](https://time-split.readthedocs.io/)
 [![PyPI - License](https://img.shields.io/pypi/l/time-split.svg)](https://pypi.python.org/pypi/time-split)
+[![Docker Image Size (tag)](https://img.shields.io/docker/image-size/rsundqvist/time-split/latest?logo=docker&label=time-split)](https://hub.docker.com/r/rsundqvist/time-split/)
 
 <div align="center">
   <img alt="Plotted folds on a two-by-two grid." 
@@ -58,13 +62,29 @@ 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 
   [use custom text](https://time-split.readthedocs.io/en/stable/auto_examples/plotting_with_metrics.html).
 - [Integrations](https://time-split.readthedocs.io/en/stable/generated/time_split.integration.html) for popular 
   libraries such as `pandas`, `polars` and `scikit-learn`.
+- Convenient [web application](#experimenting-with-parameters) for exploring folds with different parameters.
+
+## Experimenting with parameters
+The **Time Fold Explorer** application
+(available [here](http://20.240.208.202/time-split/?data=1554942900-1557610200&schedule=0+0+%2A+%2A+MON%2CFRI&n_splits=2&step=2&show_removed=True))
+is designed to help evaluate the effects of different
+[parameters](https://time-split.readthedocs.io/en/stable/#parameter-overview).
+To start it locally using
+[![Docker Image Size (tag)](https://img.shields.io/docker/image-size/rsundqvist/time-split/latest?logo=docker&label=time-split)](https://hub.docker.com/r/rsundqvist/time-split/)
+Docker, run
+```sh
+docker run -p 8501:8501 rsundqvist/time-split
+```
+in the terminal. You may use
+[`create_explorer_link()`](https://time-split.readthedocs.io/en/stable/generated/time_split.support.html#time_split.support.create_explorer_link)
+to build application URLs with preselected splitting parameters.
 
 ## Installation
 The package is published through the [Python Package Index (PyPI)]. Source code

{time_split-0.3.0 → time_split-0.5.0}/README.md

@@ -8,6 +8,7 @@ Time-based k-fold validation splits for heterogeneous data.
 [![Codecov](https://codecov.io/gh/rsundqvist/time-split/branch/master/graph/badge.svg)](https://codecov.io/gh/rsundqvist/time-split)
 [![Read the Docs](https://readthedocs.org/projects/time-split/badge/)](https://time-split.readthedocs.io/)
 [![PyPI - License](https://img.shields.io/pypi/l/time-split.svg)](https://pypi.python.org/pypi/time-split)
+[![Docker Image Size (tag)](https://img.shields.io/docker/image-size/rsundqvist/time-split/latest?logo=docker&label=time-split)](https://hub.docker.com/r/rsundqvist/time-split/)
 
 <div align="center">
   <img alt="Plotted folds on a two-by-two grid." 
@@ -27,13 +28,29 @@ 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 
   [use custom text](https://time-split.readthedocs.io/en/stable/auto_examples/plotting_with_metrics.html).
 - [Integrations](https://time-split.readthedocs.io/en/stable/generated/time_split.integration.html) for popular 
   libraries such as `pandas`, `polars` and `scikit-learn`.
+- Convenient [web application](#experimenting-with-parameters) for exploring folds with different parameters.
+
+## Experimenting with parameters
+The **Time Fold Explorer** application
+(available [here](http://20.240.208.202/time-split/?data=1554942900-1557610200&schedule=0+0+%2A+%2A+MON%2CFRI&n_splits=2&step=2&show_removed=True))
+is designed to help evaluate the effects of different
+[parameters](https://time-split.readthedocs.io/en/stable/#parameter-overview).
+To start it locally using
+[![Docker Image Size (tag)](https://img.shields.io/docker/image-size/rsundqvist/time-split/latest?logo=docker&label=time-split)](https://hub.docker.com/r/rsundqvist/time-split/)
+Docker, run
+```sh
+docker run -p 8501:8501 rsundqvist/time-split
+```
+in the terminal. You may use
+[`create_explorer_link()`](https://time-split.readthedocs.io/en/stable/generated/time_split.support.html#time_split.support.create_explorer_link)
+to build application URLs with preselected splitting parameters.
 
 ## Installation
 The package is published through the [Python Package Index (PyPI)]. Source code

{time_split-0.3.0 → time_split-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "time-split"
-version = "0.3.0"
+version = "0.5.0"
 description = "Time-based k-fold validation splits for heterogeneous data."
 authors = ["Richard Sundqvist <richard.sundqvist@live.se>"]
 
@@ -18,7 +18,7 @@ classifiers = [
     "License :: OSI Approved :: MIT License",
     "Natural Language :: English",
     "Programming Language :: Python :: 3",
-    'Programming Language :: Python :: 3 :: Only',
+    "Programming Language :: Python :: 3 :: Only",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
 ]
@@ -34,20 +34,26 @@ classifiers = [
 python = ">=3.11"
 
 pandas = ">=2.0.3"
-rics = ">=3.1.0"
+rics = ">=4.1.1"
 
 # plotting
 matplotlib = { version = "*", optional = true }
 seaborn = { version = "*", optional = true }
 
+# explorer
+streamlit = { version = "*", optional = true }
+croniter = { version = "*", optional = true }
+
 [tool.poetry.extras]
 plotting = ["matplotlib", "seaborn"]
+streamlit = ["matplotlib", "seaborn", "streamlit", "croniter"]
 
 [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,<17.0.0"
 polars = { version = "^0.20.19", extras = ["pandas"] }
+streamlit = "*"
 
 [tool.poetry.group.docs]
 [tool.poetry.group.docs.dependencies]
@@ -84,11 +90,11 @@ dask = { version = "==2024.5.0", extras = ["dataframe"] }
 
 [tool.poetry.group.devops.dependencies]
 invoke = "^2.2.0"
-mypy = "^1.9.0"
-ruff = ">=0.3.7,<0.5.0"
+mypy = "^1.10.1"
+ruff = "^0.5.0"
 
-safety = "^3.1.0"
-codespell = "^2.2.6"
+safety = "^3.2.3"
+codespell = "^2.3.0"
 bump2version = "^1.0.1"
 
 [tool.ruff]
@@ -147,6 +153,7 @@ ignore = [
     "SIM108", # Use ternary operator - coverage issue, see https://github.com/nedbat/coveragepy/issues/509
     "TD003", # Missing issue link
 ]
+allowed-confusables = ["ℹ"]
 
 [tool.ruff.lint.per-file-ignores]
 "tests/*" = [

{time_split-0.3.0 → time_split-0.5.0}/src/time_split/__init__.py

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

{time_split-0.3.0 → time_split-0.5.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.3.0 → time_split-0.5.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.3.0 → time_split-0.5.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.3.0 → time_split-0.5.0}/src/time_split/_backend/_splitter.py

@@ -1,18 +1,18 @@
 import logging
 from dataclasses import asdict, dataclass
+from functools import lru_cache
 from typing import cast, get_args
 
-from pandas import Timedelta, Timestamp
+from pandas import Timedelta
 from rics.misc import format_kwargs
-from rics.performance import format_seconds
 
-from ..settings import misc
+from ..settings import misc as settings
 from ..types import (
     DatetimeIndexSplitterKwargs,
     DatetimeIterable,
     DatetimeSplitBounds,
     DatetimeSplits,
-    Flex,
+    ExpandLimits,
     Schedule,
     Span,
     TimedeltaTypes,
@@ -29,11 +29,12 @@ class DatetimeIndexSplitter:
     """Backend interface for splitting user data. See the :ref:`Parameter overview` page."""
 
     schedule: Schedule
-    before: Span
-    after: Span
-    step: int
-    n_splits: int
-    flex: Flex
+    before: Span = "7d"
+    after: Span = 1
+    step: int = 1
+    n_splits: int = 0
+    expand_limits: ExpandLimits = "auto"
+    ignore_filters: bool = False
 
     def get_splits(self, available: DatetimeIterable | None = None) -> DatetimeSplits:
         """Compute a split of given user data."""
@@ -48,13 +49,13 @@ 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.")
 
         types = get_args(TimedeltaTypes)
         if (
-            misc.snap_to_end
+            settings.snap_to_end
             and self.after != "all"
             and isinstance(self.schedule, types)
             and isinstance(self.after, types)
@@ -98,7 +99,7 @@ class DatetimeIndexSplitter:
             msg = f"No valid splits with {limits_info}split params: ({format_kwargs(self.as_dict())})"
             raise ValueError(msg)
 
-        return self._filter(retval)
+        return retval if self.ignore_filters else self._filter(retval)
 
     def _filter(self, splits: DatetimeSplits) -> DatetimeSplits:
         """Apply splitting arguments.
@@ -121,29 +122,25 @@ class DatetimeIndexSplitter:
         if self.step < 0:  # Poorly documented - might not work as expected?
             splits.reverse()
 
-        return splits
+        if settings.filter is None:
+            return splits
+
+        return [s for s in splits if settings.filter(*s)]
 
     def _log_expansion(self, original: LimitsTuple, *, expanded: LimitsTuple) -> None:
-        if original == expanded:
-            return
+        from .._frontend import format_expanded_limits
 
-        if not LOGGER.isEnabledFor(logging.INFO):
+        if original == expanded or not LOGGER.isEnabledFor(logging.INFO):
             return
 
-        def stringify(old: Timestamp, *, new: Timestamp) -> str:
-            from .._frontend._to_string import _PrettyTimestamp
+        message = format_expanded_limits(original, expanded=expanded, expand_limits=self.expand_limits)
+        self._emit_once(message)
 
-            retval = f"{old} -> "
-            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))})"
-
-        LOGGER.info(
-            f"Available data limits have been expanded (since flex={self.flex!r}):\n"
-            f"  start: {stringify(original[0], new=expanded[0])}\n"
-            f"    end: {stringify(original[1], new=expanded[1])}"
-        )
+    @staticmethod
+    @lru_cache(8)
+    def _emit_once(message: str) -> None:
+        """Emit if **not** in the eight most recent emission messages."""
+        LOGGER.info(message)
 
     def __post_init__(self) -> None:
         # Verify n_splits

time_split-0.5.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.3.0 → time_split-0.5.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,10 +36,13 @@ _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.',
+    "ignore_filters": "Set to ignore filtering parameters (e.g. `step`) and global configuration.",
     "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.",
+    "show_removed": "If ``True``, splits removed by `n_splits` or `step` are included in the figure.",
 }

{time_split-0.3.0 → time_split-0.5.0}/src/time_split/_frontend/__init__.py

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