dycw-utilities 0.109.13__tar.gz → 0.109.15__tar.gz

{dycw_utilities-0.109.13 → dycw_utilities-0.109.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dycw-utilities
-Version: 0.109.13
+Version: 0.109.15
 Author-email: Derek Wan <d.wan@icloud.com>
 License-File: LICENSE
 Requires-Python: >=3.12

{dycw_utilities-0.109.13 → dycw_utilities-0.109.15}/pyproject.toml

@@ -29,6 +29,7 @@ dev = [
   "httpx >= 0.28.1, < 0.29",  # for fastapi
   "hypothesis >= 6.131.7, < 6.132",
   "img2pdf >= 0.6.0, < 0.7",
+  "lightweight-charts >= 2.1, < 2.2",
   "loguru >= 0.7.3, < 0.8",
   "luigi >= 3.6.0, < 3.7",
   "memory-profiler >= 0.61.0, < 0.62",
@@ -91,7 +92,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.109.13"
+version = "0.109.15"
 
 [project.optional-dependencies]
 test = [
@@ -334,7 +335,7 @@ zzz-test-zoneinfo = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.109.13"
+current_version = "0.109.15"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.109.13 → dycw_utilities-0.109.15}/src/tests/test_iterables.py

@@ -1058,7 +1058,7 @@ class TestOne:
 
     @given(args=sampled_from([([],), ([], []), ([], [], [])]))
     def test_error_empty(self, *, args: tuple[Iterable[Any], ...]) -> None:
-        with raises(OneEmptyError, match=r"Iterable\(s\) must not be empty"):
+        with raises(OneEmptyError, match=r"Iterable\(s\) .* must not be empty"):
             _ = one(*args)
 
     @given(iterable=sets(integers(), min_size=2))

dycw_utilities-0.109.15/src/tests/test_lightweight_charts.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import datetime as dt
+from typing import cast
+
+from lightweight_charts import Chart
+from polars import DataFrame, Date, Float64, Int64, col
+from pytest import fixture, raises
+
+from utilities.lightweight_charts import (
+    _SetDataFrameEmptyError,
+    _SetDataFrameNonUniqueError,
+    set_dataframe,
+)
+
+
+@fixture
+def df() -> DataFrame:
+    data = [
+        (dt.date(2000, 1, 1), 5824.0, 5824.75, 5823.75, 5824.25, 124),
+        (dt.date(2000, 1, 2), 5821.0, 5821.5, 5820.75, 5820.75, 146),
+        (dt.date(2000, 1, 3), 5820.0, 5821.0, 5819.75, 5820.5, 128),
+        (dt.date(2000, 1, 4), 5822.5, 5822.5, 5822.25, 5822.25, 78),
+        (dt.date(2000, 1, 5), 5822.5, 5822.5, 5821.5, 5821.75, 73),
+        (dt.date(2000, 1, 6), 5817.0, 5817.0, 5816.0, 5816.5, 301),
+        (dt.date(2000, 1, 7), 5817.75, 5818.75, 5817.5, 5818.75, 150),
+        (dt.date(2000, 1, 8), 5821.0, 5821.25, 5821.0, 5821.25, 75),
+        (dt.date(2000, 1, 9), 5818.0, 5819.0, 5818.0, 5818.75, 69),
+        (dt.date(2000, 1, 10), 5818.75, 5819.25, 5818.5, 5819.0, 67),
+    ]
+    return DataFrame(
+        data=data,
+        schema={
+            "date": Date,
+            "open": Float64,
+            "high": Float64,
+            "low": Float64,
+            "close": Float64,
+            "volume": Int64,
+        },
+        orient="row",
+    )
+
+
+class TestSetDataFrame:
+    def test_main(self, *, df: DataFrame) -> None:
+        chart = Chart()
+        set_dataframe(df, chart)
+
+    def test_error_empty(self, *, df: DataFrame) -> None:
+        df = df.drop("date")
+        with raises(
+            _SetDataFrameEmptyError,
+            match="At least 1 column must be of date/datetime type; got 0",
+        ):
+            set_dataframe(df, cast("Chart", None))
+
+    def test_error_non_unique(self, *, df: DataFrame) -> None:
+        df = df.with_columns(col("date").alias("date2"))
+        with raises(
+            _SetDataFrameNonUniqueError,
+            match=r"Schema\(.*\) must contain exactly 1 date/datetime column; got 'date', 'date2' and perhaps more",
+        ):
+            set_dataframe(df, cast("Chart", None))

{dycw_utilities-0.109.13 → dycw_utilities-0.109.15}/src/tests/test_polars.py

@@ -755,7 +755,7 @@ class TestDataClassToDataFrame:
 
         with raises(
             _DataClassToDataFrameNonUniqueError,
-            match="Iterable .* must contain exactly one class; got .*, .* and perhaps more",
+            match="Iterable .* must contain exactly 1 class; got .*, .* and perhaps more",
         ):
             _ = dataclass_to_dataframe([Example1(), Example2()])
 

dycw_utilities-0.109.15/src/tests/test_polars_ols.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+from hypothesis import given
+from hypothesis.strategies import sampled_from
+from numpy import isclose
+from polars import DataFrame, Float64, Series, Struct, col
+from polars.testing import assert_frame_equal
+from sklearn.linear_model import LinearRegression
+
+from utilities.polars import concat_series, integers, normal
+from utilities.polars_ols import compute_rolling_ols
+
+
+class TestComputeRollingOLS:
+    def test_main_self(self) -> None:
+        df = self._df.with_columns(
+            compute_rolling_ols(
+                "y", "x1", "x2", window_size=5, min_periods=5, add_intercept=True
+            )
+        )
+        self._assert_series(df["ols"])
+
+    def test_main_series(self) -> None:
+        ols = compute_rolling_ols(
+            self._df["y"],
+            self._df["x1"],
+            self._df["x2"],
+            window_size=5,
+            min_periods=5,
+            add_intercept=True,
+        )
+        self._assert_series(ols)
+
+    @given(
+        case=sampled_from([
+            (
+                slice(-7, -2),
+                [0.3619563208480195, 0.6583229512154678],
+                -1.386023798329262,
+                7.434533329394103,
+                0.994253238813284,
+            ),
+            (
+                slice(-6, -1),
+                [0.35564162435283264, 0.6656931556738643],
+                -0.5626805730005437,
+                -51.903154626050124,
+                0.9979752966843768,
+            ),
+            (
+                slice(-5, None),
+                [0.3100421300754358, 0.6753578168818635],
+                0.48493124625502837,
+                -36.70039604095908,
+                0.9977272526713715,
+            ),
+        ])
+    )
+    def test_tail(
+        self, *, case: tuple[slice, list[float], float, float, float]
+    ) -> None:
+        slice_, coeffs, intercept, prediction, r2 = case
+        df = self._df[slice_]
+        X = df.select("x1", "x2").to_numpy()  # noqa: N806
+        y = df.select("y").to_numpy()
+        model = LinearRegression()
+        model = model.fit(X, y)
+        assert isclose(model.coef_, coeffs).all()
+        assert isclose(model.intercept_, intercept)
+        assert isclose(model.predict(X)[-1], prediction).all()
+        assert isclose(model.score(X, y), r2)
+
+    @property
+    def _df(self) -> DataFrame:
+        n = 20
+        return concat_series(
+            integers(n, -100, high=100, seed=0).alias("x1"),
+            integers(n, -100, high=100, seed=1).alias("x2"),
+        ).with_columns(
+            ((col("x1") + 2 * col("x2") + normal(n, scale=10.0, seed=2)) / 3).alias("y")
+        )
+
+    def _assert_series(self, series: Series, /) -> None:
+        df = series.struct.unnest()
+        tail = df[-10:]
+        # fmt: off
+        data = [
+            ({"x1": 0.333396198442681, "x2": 0.6845517746145712, "const": 0.2808021232120448}, 59.921571424913495, 1.67032007883995, 0.9955364659986504),
+            ({"x1": 0.322785525889542, "x2": 0.6896341527044252, "const": 0.5401793852579858}, 15.974446064929626, -0.3429678871268038, 0.9961762567103958),
+            ({"x1": 0.31042868991153927, "x2": 0.7055685710743383, "const": 1.145326562525439}, -31.310827706894123, -0.45191863996575066, 0.998022262986332),
+            ({"x1": 0.33311466967931097, "x2": 0.684137842579758, "const": -0.7961518480794516}, 50.66821598287034, -2.975371834066671, 0.9974533939791341),
+            ({"x1": 0.35299385150914864, "x2": 0.6758890569593843, "const": -0.9377907849336107}, -0.8749325340834626, 1.0581261048863142, 0.9973453833170313),
+            ({"x1": 0.351300641938209, "x2": 0.6456834722890913, "const": -1.859577387752822}, 1.6809655259738476, 0.3217076349681922, 0.9951571413022856),
+            ({"x1": 0.3583378199895871, "x2": 0.6588347796692774, "const": -1.109675446287481}, 26.65448170418155, 2.496480675700724, 0.9933751737130443),
+            ({"x1": 0.36195632084801765, "x2": 0.658322951215466, "const": -1.3860237983291754}, 7.43453332939416, -0.791818995629618, 0.9905085882663488),
+            ({"x1": 0.35564162435283225, "x2": 0.6656931556738634, "const": -0.562680573000551}, -51.90315462605006, 0.6592474497562932, 0.9973576833556038),
+            ({"x1": 0.3100421300754357, "x2": 0.675357816881863, "const": 0.48493124625501927}, -36.70039604095908, -0.6071841038068868, 0.9978541580643828),
+        ]
+        # fmt: on
+        expected = DataFrame(
+            data=data,
+            schema={
+                "coefficients": Struct({
+                    "x1": Float64,
+                    "x2": Float64,
+                    "const": Float64,
+                }),
+                "predictions": Float64,
+                "residuals": Float64,
+                "R2": Float64,
+            },
+            orient="row",
+        )
+        assert_frame_equal(tail, expected)

{dycw_utilities-0.109.13 → dycw_utilities-0.109.15}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.109.13"
+__version__ = "0.109.15"

{dycw_utilities-0.109.13 → dycw_utilities-0.109.15}/src/utilities/altair.py

@@ -22,7 +22,6 @@ from altair import (
     vconcat,
 )
 from altair.utils.schemapi import Undefined
-from polars import Date, Datetime
 
 from utilities.functions import ensure_bytes, ensure_number
 from utilities.iterables import always_iterable
@@ -66,7 +65,7 @@ def plot_dataframes(
 ) -> VConcatChart:
     """Plot a DataFrame as a set of time series, with a multi-line tooltip."""
     import polars as pl
-    from polars import int_range
+    from polars import Date, Datetime, int_range
 
     from utilities.polars import replace_time_zone
 

{dycw_utilities-0.109.13 → dycw_utilities-0.109.15}/src/utilities/iterables.py

@@ -1009,7 +1009,7 @@ def one(*iterables: Iterable[_T]) -> _T:
     try:
         first = next(it)
     except StopIteration:
-        raise OneEmptyError from None
+        raise OneEmptyError(iterables=iterables) from None
     try:
         second = next(it)
     except StopIteration:
@@ -1018,19 +1018,19 @@ def one(*iterables: Iterable[_T]) -> _T:
 
 
 @dataclass(kw_only=True, slots=True)
-class OneError(Exception): ...
+class OneError(Exception, Generic[_T]):
+    iterables: tuple[Iterable[_T], ...]
 
 
 @dataclass(kw_only=True, slots=True)
-class OneEmptyError(OneError):
+class OneEmptyError(OneError[_T]):
     @override
     def __str__(self) -> str:
-        return "Iterable(s) must not be empty"
+        return f"Iterable(s) {get_repr(self.iterables)} must not be empty"
 
 
 @dataclass(kw_only=True, slots=True)
 class OneNonUniqueError(OneError, Generic[_T]):
-    iterables: tuple[Iterable[_T], ...]
     first: _T
     second: _T
 

dycw_utilities-0.109.15/src/utilities/lightweight_charts.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+from contextlib import asynccontextmanager
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, override
+
+from utilities.iterables import OneEmptyError, OneNonUniqueError, one
+from utilities.reprlib import get_repr
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator
+
+    from lightweight_charts import AbstractChart, Chart
+    from lightweight_charts.abstract import SeriesCommon
+    from polars import DataFrame
+    from polars._typing import SchemaDict
+
+    from utilities.types import PathLike
+
+
+##
+
+
+def save_chart(chart: Chart, path: PathLike, /, *, overwrite: bool = False) -> None:
+    """Atomically save a chart to disk."""
+    from utilities.atomicwrites import writer  # pragma: no cover
+
+    chart.show(block=False)  # pragma: no cover
+    with (  # pragma: no cover
+        writer(path, overwrite=overwrite) as temp,
+        temp.open(mode="wb") as fh,
+    ):
+        _ = fh.write(chart.screenshot())
+    chart.exit()  # pragma: no cover
+
+
+##
+
+
+def set_dataframe(df: DataFrame, obj: AbstractChart | SeriesCommon, /) -> None:
+    """Set a `polars` DataFrame onto a Chart."""
+    from polars import Date, Datetime, col  # pragma: no cover
+
+    try:
+        name = one(k for k, v in df.schema.items() if isinstance(v, Date | Datetime))
+    except OneEmptyError:
+        raise _SetDataFrameEmptyError(schema=df.schema) from None
+    except OneNonUniqueError as error:
+        raise _SetDataFrameNonUniqueError(
+            schema=df.schema, first=error.first, second=error.second
+        ) from None
+    return obj.set(
+        df.select(
+            col(name).alias("date").dt.strftime("iso"),
+            *[c for c in df.columns if c != name],
+        ).to_pandas()
+    )
+
+
+@dataclass(kw_only=True, slots=True)
+class SetDataFrameError(Exception):
+    schema: SchemaDict
+
+
+@dataclass(kw_only=True, slots=True)
+class _SetDataFrameEmptyError(SetDataFrameError):
+    @override
+    def __str__(self) -> str:
+        return "At least 1 column must be of date/datetime type; got 0"
+
+
+@dataclass(kw_only=True, slots=True)
+class _SetDataFrameNonUniqueError(SetDataFrameError):
+    first: str
+    second: str
+
+    @override
+    def __str__(self) -> str:
+        return f"{get_repr(self.schema)} must contain exactly 1 date/datetime column; got {self.first!r}, {self.second!r} and perhaps more"
+
+
+##
+
+
+@asynccontextmanager
+async def yield_chart(chart: Chart, /) -> AsyncIterator[None]:
+    """Yield a chart for visualization in a notebook."""
+    try:  # pragma: no cover
+        yield await chart.show_async()
+    except BaseException:  # pragma: no cover  # noqa: BLE001, S110
+        pass
+    finally:  # pragma: no cover
+        chart.exit()
+
+
+__all__ = ["save_chart", "set_dataframe", "yield_chart"]

{dycw_utilities-0.109.13 → dycw_utilities-0.109.15}/src/utilities/polars.py

@@ -714,7 +714,7 @@ class _DataClassToDataFrameNonUniqueError(DataClassToDataFrameError):
 
     @override
     def __str__(self) -> str:
-        return f"Iterable {get_repr(self.objs)} must contain exactly one class; got {self.first}, {self.second} and perhaps more"
+        return f"Iterable {get_repr(self.objs)} must contain exactly 1 class; got {self.first}, {self.second} and perhaps more"
 
 
 ##

dycw_utilities-0.109.15/src/utilities/polars_ols.py

@@ -0,0 +1,171 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, overload
+
+from polars import Expr, Series, struct
+from polars_ols import RollingKwargs, compute_rolling_least_squares
+
+from utilities.errors import ImpossibleCaseError
+from utilities.functions import is_sequence_of
+from utilities.polars import concat_series, ensure_expr_or_series
+
+if TYPE_CHECKING:
+    from polars._typing import IntoExprColumn
+    from polars_ols import NullPolicy
+
+    from utilities.polars import ExprLike
+
+
+@overload
+def compute_rolling_ols(
+    target: ExprLike,
+    *features: ExprLike,
+    sample_weights: ExprLike | None = None,
+    add_intercept: bool = False,
+    null_policy: NullPolicy = "drop_window",
+    window_size: int = 1000000,
+    min_periods: int | None = None,
+    use_woodbury: bool | None = None,
+    alpha: float | None = None,
+) -> Expr: ...
+@overload
+def compute_rolling_ols(
+    target: Series,
+    *features: Series,
+    sample_weights: Series | None = None,
+    add_intercept: bool = False,
+    null_policy: NullPolicy = "drop_window",
+    window_size: int = 1000000,
+    min_periods: int | None = None,
+    use_woodbury: bool | None = None,
+    alpha: float | None = None,
+) -> Series: ...
+@overload
+def compute_rolling_ols(
+    target: IntoExprColumn,
+    *features: IntoExprColumn,
+    sample_weights: IntoExprColumn | None = None,
+    add_intercept: bool = False,
+    null_policy: NullPolicy = "drop_window",
+    window_size: int = 1000000,
+    min_periods: int | None = None,
+    use_woodbury: bool | None = None,
+    alpha: float | None = None,
+) -> Expr | Series: ...
+def compute_rolling_ols(
+    target: IntoExprColumn,
+    *features: IntoExprColumn,
+    sample_weights: IntoExprColumn | None = None,
+    add_intercept: bool = False,
+    null_policy: NullPolicy = "drop_window",
+    window_size: int = 1000000,
+    min_periods: int | None = None,
+    use_woodbury: bool | None = None,
+    alpha: float | None = None,
+) -> Expr | Series:
+    """Compute a rolling OLS."""
+    target = ensure_expr_or_series(target)
+    features2 = tuple(map(ensure_expr_or_series, features))
+    sample_weights = (
+        None if sample_weights is None else ensure_expr_or_series(sample_weights)
+    )
+    if (
+        isinstance(target, Expr)
+        and is_sequence_of(features2, Expr)
+        and ((sample_weights is None) or isinstance(sample_weights, Expr))
+    ):
+        return _compute_rolling_ols_expr(
+            target,
+            *features2,
+            sample_weights=sample_weights,
+            add_intercept=add_intercept,
+            null_policy=null_policy,
+            window_size=window_size,
+            min_periods=min_periods,
+            use_woodbury=use_woodbury,
+            alpha=alpha,
+        )
+    if (
+        isinstance(target, Series)
+        and is_sequence_of(features2, Series)
+        and ((sample_weights is None) or isinstance(sample_weights, Series))
+    ):
+        return concat_series(
+            target, *features2, *([] if sample_weights is None else [sample_weights])
+        ).with_columns(
+            _compute_rolling_ols_expr(
+                target.name,
+                *(f.name for f in features2),
+                sample_weights=None if sample_weights is None else sample_weights.name,
+                add_intercept=add_intercept,
+                null_policy=null_policy,
+                window_size=window_size,
+                min_periods=min_periods,
+                use_woodbury=use_woodbury,
+                alpha=alpha,
+            )
+        )["ols"]
+    raise ImpossibleCaseError(  # pragma: no cover
+        case=[f"{target=}", f"{features2=}", f"{sample_weights=}"]
+    )
+
+
+def _compute_rolling_ols_expr(
+    target: ExprLike,
+    *features: ExprLike,
+    sample_weights: ExprLike | None = None,
+    add_intercept: bool = False,
+    null_policy: NullPolicy = "drop_window",
+    window_size: int = 1000000,
+    min_periods: int | None = None,
+    use_woodbury: bool | None = None,
+    alpha: float | None = None,
+) -> Expr:
+    """Compute a rolling OLS."""
+    target = ensure_expr_or_series(target)
+    features2 = tuple(map(ensure_expr_or_series, features))
+    sample_weights = (
+        None if sample_weights is None else ensure_expr_or_series(sample_weights)
+    )
+    rolling_kwargs = RollingKwargs(
+        null_policy=null_policy,
+        window_size=window_size,
+        min_periods=min_periods,
+        use_woodbury=use_woodbury,
+        alpha=alpha,
+    )
+    coefficients = compute_rolling_least_squares(
+        target,
+        *features2,
+        sample_weights=sample_weights,
+        add_intercept=add_intercept,
+        mode="coefficients",
+        rolling_kwargs=rolling_kwargs,
+    ).alias("coefficients")
+    predictions = compute_rolling_least_squares(
+        target,
+        *features2,
+        sample_weights=sample_weights,
+        add_intercept=add_intercept,
+        mode="predictions",
+        rolling_kwargs=rolling_kwargs,
+    ).alias("predictions")
+    residuals = compute_rolling_least_squares(
+        target,
+        *features2,
+        sample_weights=sample_weights,
+        add_intercept=add_intercept,
+        mode="residuals",
+        rolling_kwargs=rolling_kwargs,
+    ).alias("residuals")
+    ssr = (residuals**2).rolling_sum(window_size, min_samples=min_periods).alias("SSR")
+    sst = (
+        ((target - target.rolling_mean(window_size, min_samples=min_periods)) ** 2)
+        .rolling_sum(window_size, min_samples=min_periods)
+        .alias("SST")
+    )
+    r2 = (1 - ssr / sst).alias("R2")
+    return struct(coefficients, predictions, residuals, r2).alias("ols")
+
+
+__all__ = ["compute_rolling_ols"]

dycw_utilities-0.109.13/src/tests/test_polars_ols.py

@@ -1,103 +0,0 @@
-from __future__ import annotations
-
-from hypothesis import given
-from hypothesis.strategies import sampled_from
-from numpy import isclose
-from polars import DataFrame, Float64, Struct, UInt32, col
-from polars.testing import assert_frame_equal
-from sklearn.linear_model import LinearRegression
-
-from utilities.polars import concat_series, integers, normal
-from utilities.polars_ols import compute_rolling_ols
-
-
-class TestComputeRollingOLS:
-    def test_ols_results(self) -> None:
-        result = self._df["ols"].struct.unnest().with_row_index()
-        # fmt: off
-        exp_values = [
-            (10, {"x1": 0.333396198442681, "x2": 0.6845517746145712, "const": 0.2808021232120448}, 59.921571424913495, 1.67032007883995, 0.9955364659986504),
-            (11, {"x1": 0.322785525889542, "x2": 0.6896341527044252, "const": 0.5401793852579858}, 15.974446064929626, -0.3429678871268038, 0.9961762567103958),
-            (12, {"x1": 0.31042868991153927, "x2": 0.7055685710743383, "const": 1.145326562525439}, -31.310827706894123, -0.45191863996575066, 0.998022262986332),
-            (13, {"x1": 0.33311466967931097, "x2": 0.684137842579758, "const": -0.7961518480794516}, 50.66821598287034, -2.975371834066671, 0.9974533939791341),
-            (14, {"x1": 0.35299385150914864, "x2": 0.6758890569593843, "const": -0.9377907849336107}, -0.8749325340834626, 1.0581261048863142, 0.9973453833170313),
-            (15, {"x1": 0.351300641938209, "x2": 0.6456834722890913, "const": -1.859577387752822}, 1.6809655259738476, 0.3217076349681922, 0.9951571413022856),
-            (16, {"x1": 0.3583378199895871, "x2": 0.6588347796692774, "const": -1.109675446287481}, 26.65448170418155, 2.496480675700724, 0.9933751737130443),
-            (17, {"x1": 0.36195632084801765, "x2": 0.658322951215466, "const": -1.3860237983291754}, 7.43453332939416, -0.791818995629618, 0.9905085882663488),
-            (18, {"x1": 0.35564162435283225, "x2": 0.6656931556738634, "const": -0.562680573000551}, -51.90315462605006, 0.6592474497562932, 0.9973576833556038),
-            (19, {"x1": 0.3100421300754357, "x2": 0.675357816881863, "const": 0.48493124625501927}, -36.70039604095908, -0.6071841038068868, 0.9978541580643828),
-        ]
-        # fmt: on
-        expected = DataFrame(
-            data=exp_values,
-            schema={
-                "index": UInt32,
-                "coefficients": Struct({
-                    "x1": Float64,
-                    "x2": Float64,
-                    "const": Float64,
-                }),
-                "predictions": Float64,
-                "residuals": Float64,
-                "R2": Float64,
-            },
-            orient="row",
-        )
-        assert_frame_equal(result[-10:], expected)
-
-    @given(
-        case=sampled_from([
-            (
-                slice(-7, -2),
-                [0.3619563208480195, 0.6583229512154678],
-                -1.386023798329262,
-                7.434533329394103,
-                0.994253238813284,
-            ),
-            (
-                slice(-6, -1),
-                [0.35564162435283264, 0.6656931556738643],
-                -0.5626805730005437,
-                -51.903154626050124,
-                0.9979752966843768,
-            ),
-            (
-                slice(-5, None),
-                [0.3100421300754358, 0.6753578168818635],
-                0.48493124625502837,
-                -36.70039604095908,
-                0.9977272526713715,
-            ),
-        ])
-    )
-    def test_tail(
-        self, *, case: tuple[slice, list[float], float, float, float]
-    ) -> None:
-        slice_, coeffs, intercept, prediction, r2 = case
-        df = self._df[slice_]
-        X = df.select("x1", "x2").to_numpy()  # noqa: N806
-        y = df.select("y").to_numpy()
-        model = LinearRegression()
-        model = model.fit(X, y)
-        assert isclose(model.coef_, coeffs).all()
-        assert isclose(model.intercept_, intercept)
-        assert isclose(model.predict(X)[-1], prediction).all()
-        assert isclose(model.score(X, y), r2)
-
-    @property
-    def _df(self) -> DataFrame:
-        n = 20
-        return (
-            concat_series(
-                integers(n, -100, high=100, seed=0).alias("x1"),
-                integers(n, -100, high=100, seed=1).alias("x2"),
-            )
-            .with_columns(
-                y=(col("x1") + 2 * col("x2") + normal(n, scale=10.0, seed=2)) / 3
-            )
-            .with_columns(
-                compute_rolling_ols(
-                    "y", "x1", "x2", window_size=5, min_periods=5, add_intercept=True
-                )
-            )
-        )