dycw-utilities 0.112.10__tar.gz → 0.112.12__tar.gz

{dycw_utilities-0.112.10 → dycw_utilities-0.112.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dycw-utilities
-Version: 0.112.10
+Version: 0.112.12
 Author-email: Derek Wan <d.wan@icloud.com>
 License-File: LICENSE
 Requires-Python: >=3.12
@@ -84,7 +84,7 @@ Requires-Dist: hypothesis<6.132,>=6.131.9; extra == 'zzz-test-hypothesis'
 Requires-Dist: luigi<3.7,>=3.6.0; extra == 'zzz-test-hypothesis'
 Requires-Dist: numpy<2.3,>=2.2.5; extra == 'zzz-test-hypothesis'
 Requires-Dist: pathvalidate<3.3,>=3.2.3; extra == 'zzz-test-hypothesis'
-Requires-Dist: redis<5.3,>=5.2.1; extra == 'zzz-test-hypothesis'
+Requires-Dist: redis<6.1,>=6.0.0; extra == 'zzz-test-hypothesis'
 Requires-Dist: sqlalchemy<2.1,>=2.0.40; extra == 'zzz-test-hypothesis'
 Requires-Dist: tenacity<9.0,>=8.5.0; extra == 'zzz-test-hypothesis'
 Requires-Dist: tzlocal<5.4,>=5.3.1; extra == 'zzz-test-hypothesis'
@@ -165,7 +165,7 @@ Provides-Extra: zzz-test-re
 Provides-Extra: zzz-test-redis
 Requires-Dist: orjson<3.11,>=3.10.15; extra == 'zzz-test-redis'
 Requires-Dist: polars-lts-cpu<1.30,>=1.29.0; extra == 'zzz-test-redis'
-Requires-Dist: redis<5.3,>=5.2.1; extra == 'zzz-test-redis'
+Requires-Dist: redis<6.1,>=6.0.0; extra == 'zzz-test-redis'
 Requires-Dist: rich<14.1,>=14.0.0; extra == 'zzz-test-redis'
 Requires-Dist: tenacity<9.0,>=8.5.0; extra == 'zzz-test-redis'
 Requires-Dist: tzlocal<5.4,>=5.3.1; extra == 'zzz-test-redis'

{dycw_utilities-0.112.10 → dycw_utilities-0.112.12}/pyproject.toml

@@ -50,7 +50,7 @@ dev = [
   "pytest >= 8.3.5, < 8.4",
   "pytest-regressions >= 2.7.0, < 2.8",
   "python-dotenv >= 1.1.0, < 1.2",
-  "redis >= 5.2.1, < 5.3",
+  "redis >= 6.0.0, < 6.1",
   "rich >= 14.0.0, < 14.1",
   "scikit-learn >= 1.6.1, < 1.7",
   "scipy >= 1.15.2, < 1.16",
@@ -93,7 +93,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.112.10"
+version = "0.112.12"
 
 [project.optional-dependencies]
 test = [
@@ -179,7 +179,7 @@ zzz-test-hypothesis = [
   "luigi >= 3.6.0, < 3.7",
   "numpy >= 2.2.5, < 2.3",
   "pathvalidate >= 3.2.3, < 3.3",
-  "redis >= 5.2.1, < 5.3",
+  "redis >= 6.0.0, < 6.1",
   "sqlalchemy >= 2.0.40, < 2.1",
   "tenacity >= 8.5.0, < 9.0",  # limited by luigi
   "tzlocal >= 5.3.1, < 5.4",
@@ -261,7 +261,7 @@ zzz-test-re = []
 zzz-test-redis = [
   "orjson >= 3.10.15, < 3.11",
   "polars-lts-cpu >= 1.29.0, < 1.30",
-  "redis >= 5.2.1, < 5.3",
+  "redis >= 6.0.0, < 6.1",
   "rich >= 14.0.0, < 14.1",
   "tenacity >= 8.5.0, < 9.0",  # limited by luigi
   "tzlocal >= 5.3.1, < 5.4",
@@ -336,7 +336,7 @@ zzz-test-zoneinfo = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.112.10"
+current_version = "0.112.12"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.112.10 → dycw_utilities-0.112.12}/src/tests/test_polars.py

@@ -5,7 +5,7 @@ import enum
 import itertools
 from dataclasses import dataclass, field
 from enum import auto
-from itertools import chain
+from itertools import chain, repeat
 from math import isfinite, nan
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, ClassVar, Literal, cast
@@ -49,6 +49,7 @@ from polars import (
     datetime_range,
     int_range,
     lit,
+    struct,
 )
 from polars._typing import (
     IntoExprColumn,  # pyright: ignore[reportPrivateImportUsage]
@@ -112,6 +113,10 @@ from utilities.polars import (
     _GetSeriesNumberOfDecimalsNotFloatError,
     _InsertBetweenMissingColumnsError,
     _InsertBetweenNonConsecutiveError,
+    _IsNearEventAfterError,
+    _IsNearEventBeforeError,
+    _ReifyExprsEmptyError,
+    _ReifyExprsSeriesNonUniqueError,
     _yield_struct_series_element_remove_nulls,
     ac_halflife,
     acf,
@@ -144,6 +149,7 @@ from utilities.polars import (
     insert_after,
     insert_before,
     insert_between,
+    is_near_event,
     is_not_null_struct_series,
     is_null_struct_series,
     join,
@@ -151,11 +157,13 @@ from utilities.polars import (
     nan_sum_agg,
     nan_sum_cols,
     normal,
+    reify_exprs,
     replace_time_zone,
     set_first_row_as_columns,
     struct_dtype,
     struct_from_dataclass,
     touch,
+    try_reify_expr,
     uniform,
     unique_element,
     week_num,
@@ -1639,6 +1647,102 @@ class TestIntegers:
         assert series.is_between(0, high, closed="left").all()
 
 
+class TestIsNearEvent:
+    df: ClassVar[DataFrame] = DataFrame(
+        data=[
+            (False, False),
+            (False, False),
+            (True, False),
+            (True, False),
+            (False, False),
+            (False, False),
+            (False, False),
+            (False, False),
+            (False, False),
+            (False, True),
+        ],
+        schema={"x": Boolean, "y": Boolean},
+        orient="row",
+    )
+
+    def test_no_exprs(self) -> None:
+        result = self.df.with_columns(is_near_event().alias("z"))["z"]
+        expected = Series(
+            name="z", values=list(repeat(object=False, times=10)), dtype=Boolean
+        )
+        assert_series_equal(result, expected)
+
+    def test_x(self) -> None:
+        result = self.df.with_columns(is_near_event("x").alias("z"))["z"]
+        expected = Series(
+            name="z",
+            values=[False, False, True, True, False, False, False, False, False, False],
+            dtype=Boolean,
+        )
+        assert_series_equal(result, expected)
+
+    def test_y(self) -> None:
+        result = self.df.with_columns(is_near_event("y").alias("z"))["z"]
+        expected = Series(
+            name="z",
+            values=[
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                True,
+            ],
+            dtype=Boolean,
+        )
+        assert_series_equal(result, expected)
+
+    def test_x_before(self) -> None:
+        result = self.df.with_columns(is_near_event("x", before=1).alias("z"))["z"]
+        expected = Series(
+            name="z",
+            values=[False, True, True, True, False, False, False, False, False, False],
+            dtype=Boolean,
+        )
+        assert_series_equal(result, expected)
+
+    def test_x_after(self) -> None:
+        result = self.df.with_columns(is_near_event("x", after=1).alias("z"))["z"]
+        expected = Series(
+            name="z",
+            values=[False, False, True, True, True, False, False, False, False, False],
+            dtype=Boolean,
+        )
+        assert_series_equal(result, expected)
+
+    def test_x_or_y(self) -> None:
+        result = self.df.with_columns(is_near_event("x", "y").alias("z"))["z"]
+        expected = Series(
+            name="z",
+            values=[False, False, True, True, False, False, False, False, False, True],
+            dtype=Boolean,
+        )
+        assert_series_equal(result, expected)
+
+    @given(before=hypothesis.strategies.integers(max_value=-1))
+    def test_error_before(self, *, before: int) -> None:
+        with raises(
+            _IsNearEventBeforeError, match=r"'Before' must be non-negative; got \-\d+"
+        ):
+            _ = is_near_event(before=before)
+
+    @given(after=hypothesis.strategies.integers(max_value=-1))
+    def test_error_after(self, *, after: int) -> None:
+        with raises(
+            _IsNearEventAfterError, match=r"'After' must be non-negative; got \-\d+"
+        ):
+            _ = is_near_event(after=after)
+
+
 class TestIsNullAndIsNotNullStructSeries:
     @given(
         case=sampled_from([
@@ -1877,6 +1981,98 @@ class TestNormal:
         assert series.is_finite().all()
 
 
+class TestReifyExprs:
+    @given(length=hypothesis.strategies.integers(0, 10), name=text_ascii())
+    def test_one_expr(self, *, length: int, name: str) -> None:
+        expr = int_range(end=length).alias(name)
+        result = reify_exprs(expr)
+        assert isinstance(result, Expr)
+        result2 = (
+            int_range(end=length, eager=True)
+            .alias(f"_{name}")
+            .to_frame()
+            .with_columns(result)[name]
+        )
+        expected = int_range(end=length, eager=True).alias(name)
+        assert_series_equal(result2, expected)
+
+    @given(length=hypothesis.strategies.integers(0, 10), name=text_ascii())
+    def test_one_series(self, *, length: int, name: str) -> None:
+        series = int_range(end=length, eager=True).alias(name)
+        result = reify_exprs(series)
+        assert isinstance(result, Series)
+        assert_series_equal(result, series)
+
+    @given(
+        length=hypothesis.strategies.integers(0, 10),
+        names=pairs(text_ascii(), unique=True),
+    )
+    def test_two_exprs(self, *, length: int, names: tuple[str, str]) -> None:
+        name1, name2 = names
+        expr1 = int_range(end=length).alias(name1)
+        expr2 = int_range(end=length).alias(name2)
+        result = reify_exprs(expr1, expr2)
+        assert isinstance(result, Expr)
+        result2 = (
+            int_range(end=length, eager=True)
+            .alias(f"_{names}")
+            .to_frame()
+            .with_columns(result)[name1]
+        )
+        assert result2.name == name1
+        assert result2.dtype == Struct(dict.fromkeys(names, Int64))
+
+    @given(
+        length=hypothesis.strategies.integers(0, 10),
+        names=pairs(text_ascii(), unique=True),
+    )
+    def test_one_expr_and_one_series(
+        self, *, length: int, names: tuple[str, str]
+    ) -> None:
+        name1, name2 = names
+        expr = int_range(end=length).alias(name1)
+        series = int_range(end=length, eager=True).alias(name2)
+        result = reify_exprs(expr, series)
+        assert isinstance(result, DataFrame)
+        assert result.schema == dict.fromkeys(names, Int64)
+
+    @given(
+        length=hypothesis.strategies.integers(0, 10),
+        names=pairs(text_ascii(), unique=True),
+    )
+    def test_two_series(self, *, length: int, names: tuple[str, str]) -> None:
+        name1, name2 = names
+        series1 = int_range(end=length, eager=True).alias(name1)
+        series2 = int_range(end=length, eager=True).alias(name2)
+        result = reify_exprs(series1, series2)
+        assert isinstance(result, DataFrame)
+        expected = concat_series(series1, series2)
+        assert_frame_equal(result, expected)
+
+    def test_error_empty(self) -> None:
+        with raises(
+            _ReifyExprsEmptyError, match="At least 1 Expression or Series must be given"
+        ):
+            _ = reify_exprs()
+
+    @given(
+        lengths=pairs(hypothesis.strategies.integers(0, 10), unique=True),
+        names=pairs(text_ascii(), unique=True),
+    )
+    def test_error_non_unique(
+        self, *, lengths: tuple[int, int], names: tuple[str, str]
+    ) -> None:
+        series1, series2 = [
+            int_range(end=length, eager=True).alias(name)
+            for length, name in zip(lengths, names, strict=True)
+        ]
+        with raises(
+            _ReifyExprsSeriesNonUniqueError,
+            match=r"Series must contain exactly one length; got \d+, \d+ and perhaps more",
+        ):
+            _ = reify_exprs(series1, series2)
+
+
 class TestReplaceTimeZone:
     def test_datetime(self) -> None:
         now_utc = get_now()
@@ -2062,6 +2258,177 @@ class TestStructFromDataClass:
             _ = struct_from_dataclass(Example)
 
 
+class TestTryReifyExpr:
+    # expr
+
+    @given(length=hypothesis.strategies.integers(0, 10), name=text_ascii())
+    def test_flat_expr(self, *, length: int, name: str) -> None:
+        expr = int_range(end=length).alias(name)
+        result = try_reify_expr(expr)
+        assert isinstance(result, Expr)
+        result2 = (
+            int_range(end=length, eager=True)
+            .alias(f"_{name}")
+            .to_frame()
+            .with_columns(result)[name]
+        )
+        expected = int_range(end=length, eager=True).alias(name)
+        assert_series_equal(result2, expected)
+
+    @given(length=hypothesis.strategies.integers(0, 10), names=pairs(text_ascii()))
+    def test_flat_expr_and_expr(self, *, length: int, names: tuple[str, str]) -> None:
+        name1, name2 = names
+        expr1 = int_range(end=length).alias(name1)
+        expr2 = int_range(end=length).alias(name2)
+        result = try_reify_expr(expr1, expr2)
+        assert isinstance(result, Expr)
+        result2 = (
+            int_range(end=length, eager=True)
+            .alias(f"_{name1}")
+            .to_frame()
+            .with_columns(result)[name1]
+        )
+        expected = int_range(end=length, eager=True).alias(name1)
+        assert_series_equal(result2, expected)
+
+    @given(length=hypothesis.strategies.integers(0, 10), names=pairs(text_ascii()))
+    def test_flat_expr_and_series(self, *, length: int, names: tuple[str, str]) -> None:
+        name1, name2 = names
+        expr = int_range(end=length).alias(name1)
+        series = int_range(end=length, eager=True).alias(name2)
+        result = try_reify_expr(expr, series)
+        assert isinstance(result, Series)
+        assert_series_equal(result, series.alias(name1))
+
+    @given(length=hypothesis.strategies.integers(0, 10), name=text_ascii())
+    def test_struct_expr(self, *, length: int, name: str) -> None:
+        expr = struct(int_range(end=length).alias(name)).alias(name)
+        result = try_reify_expr(expr)
+        assert isinstance(result, Expr)
+        result2 = (
+            int_range(end=length, eager=True)
+            .alias(f"_{name}")
+            .to_frame()
+            .with_columns(result)[name]
+        )
+        expected = (
+            int_range(end=length, eager=True)
+            .alias(name)
+            .to_frame()
+            .select(struct(name))[name]
+        )
+        assert_series_equal(result2, expected)
+
+    @given(length=hypothesis.strategies.integers(0, 10), names=pairs(text_ascii()))
+    def test_struct_expr_and_expr(self, *, length: int, names: tuple[str, str]) -> None:
+        name1, name2 = names
+        expr1 = struct(int_range(end=length).alias(name1)).alias(name1)
+        expr2 = int_range(end=length).alias(name2)
+        result = try_reify_expr(expr1, expr2)
+        assert isinstance(result, Expr)
+        result2 = (
+            int_range(end=length, eager=True)
+            .alias(f"_{name1}")
+            .to_frame()
+            .with_columns(result)[name1]
+        )
+        expected = (
+            int_range(end=length, eager=True)
+            .alias(name1)
+            .to_frame()
+            .select(struct(name1))[name1]
+        )
+        assert_series_equal(result2, expected)
+
+    @given(length=hypothesis.strategies.integers(0, 10), names=pairs(text_ascii()))
+    def test_struct_expr_and_series(
+        self, *, length: int, names: tuple[str, str]
+    ) -> None:
+        name1, name2 = names
+        expr = struct(int_range(end=length).alias(name1)).alias(name1)
+        series = int_range(end=length, eager=True).alias(name2)
+        result = try_reify_expr(expr, series)
+        assert isinstance(result, Series)
+        expected = series.alias(name1).to_frame().select(struct(name1))[name1]
+        assert_series_equal(result, expected)
+
+    # series
+
+    @given(length=hypothesis.strategies.integers(0, 10), name=text_ascii())
+    def test_flat_series(self, *, length: int, name: str) -> None:
+        series = int_range(end=length, eager=True).alias(name)
+        result = try_reify_expr(series)
+        assert isinstance(result, Series)
+        assert_series_equal(result, series)
+
+    @given(length=hypothesis.strategies.integers(0, 10), names=pairs(text_ascii()))
+    def test_flat_series_and_expr(self, *, length: int, names: tuple[str, str]) -> None:
+        name1, name2 = names
+        series = int_range(end=length, eager=True).alias(name1)
+        expr = int_range(end=length).alias(name2)
+        result = try_reify_expr(series, expr)
+        assert isinstance(result, Series)
+        assert_series_equal(result, series)
+
+    @given(length=hypothesis.strategies.integers(0, 10), names=pairs(text_ascii()))
+    def test_flat_series_and_series(
+        self, *, length: int, names: tuple[str, str]
+    ) -> None:
+        name1, name2 = names
+        series1 = int_range(end=length, eager=True).alias(name1)
+        series2 = int_range(end=length, eager=True).alias(name2)
+        result = try_reify_expr(series1, series2)
+        assert isinstance(result, Series)
+        assert_series_equal(result, series1)
+
+    @given(length=hypothesis.strategies.integers(0, 10), name=text_ascii())
+    def test_struct_series(self, *, length: int, name: str) -> None:
+        series = (
+            int_range(end=length, eager=True)
+            .alias(name)
+            .to_frame()
+            .select(struct(name))[name]
+        )
+        assert isinstance(series.dtype, Struct)
+        result = try_reify_expr(series)
+        assert isinstance(result, Series)
+        assert_series_equal(result, series)
+
+    @given(length=hypothesis.strategies.integers(0, 10), names=pairs(text_ascii()))
+    def test_struct_series_and_expr(
+        self, *, length: int, names: tuple[str, str]
+    ) -> None:
+        name1, name2 = names
+        series = (
+            int_range(end=length, eager=True)
+            .alias(name1)
+            .to_frame()
+            .select(struct(name1))[name1]
+        )
+        assert isinstance(series.dtype, Struct)
+        expr = int_range(end=length).alias(name2)
+        result = try_reify_expr(series, expr)
+        assert isinstance(result, Series)
+        assert_series_equal(result, series)
+
+    @given(length=hypothesis.strategies.integers(0, 10), names=pairs(text_ascii()))
+    def test_struct_series_and_series(
+        self, *, length: int, names: tuple[str, str]
+    ) -> None:
+        name1, name2 = names
+        series1 = (
+            int_range(end=length, eager=True)
+            .alias(name1)
+            .to_frame()
+            .select(struct(name1))[name1]
+        )
+        assert isinstance(series1.dtype, Struct)
+        series2 = int_range(end=length).alias(name2)
+        result = try_reify_expr(series1, series2)
+        assert isinstance(result, Series)
+        assert_series_equal(result, series1)
+
+
 class TestUniform:
     @given(
         length=hypothesis.strategies.integers(0, 10),

{dycw_utilities-0.112.10 → dycw_utilities-0.112.12}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.112.10"
+__version__ = "0.112.12"