dycw-utilities 0.158.2__tar.gz → 0.159.1__tar.gz

{dycw_utilities-0.158.2 → dycw_utilities-0.159.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dycw-utilities
-Version: 0.158.2
+Version: 0.159.1
 Author-email: Derek Wan <d.wan@icloud.com>
 License-File: LICENSE
 Requires-Python: >=3.12
@@ -12,7 +12,7 @@ Provides-Extra: logging
 Requires-Dist: coloredlogs<15.1,>=15.0.1; extra == 'logging'
 Provides-Extra: test
 Requires-Dist: dycw-pytest-only<2.2,>=2.1.1; extra == 'test'
-Requires-Dist: hypothesis<6.138,>=6.137.1; extra == 'test'
+Requires-Dist: hypothesis<6.139,>=6.138.0; extra == 'test'
 Requires-Dist: pytest-asyncio<1.2,>=1.1.0; extra == 'test'
 Requires-Dist: pytest-cov<6.3,>=6.2.1; extra == 'test'
 Requires-Dist: pytest-instafail<0.6,>=0.5.0; extra == 'test'

{dycw_utilities-0.158.2 → dycw_utilities-0.159.1}/pyproject.toml

@@ -68,7 +68,7 @@ http-test = [
   "orjson",
 ]
 hypothesis = [
-  "hypothesis >=6.137.1, <6.138",
+  "hypothesis >=6.138.0, <6.139",
 ]
 hypothesis-test = [
   "libcst",
@@ -118,7 +118,7 @@ orjson-test = [
   "polars",
 ]
 polars = [
-  "polars >=1.32.2, <1.33",
+  "polars >=1.32.3, <1.33",
 ]
 polars-ols = [
   "polars-ols >=0.3.5, <0.4",
@@ -227,7 +227,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.158.2"
+version = "0.159.1"
 
 [project.entry-points.pytest11]
 pytest-randomly = "utilities.pytest_plugins.pytest_randomly"
@@ -239,7 +239,7 @@ logging = [
 ]
 test = [
   "dycw-pytest-only >=2.1.1, <2.2",
-  "hypothesis >=6.137.1, <6.138",
+  "hypothesis >=6.138.0, <6.139",
   "pytest >=8.4.1, <8.5",
   "pytest-asyncio >=1.1.0, <1.2",
   "pytest-cov >=6.2.1, <6.3",
@@ -259,7 +259,7 @@ test = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.158.2"
+current_version = "0.159.1"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.158.2 → dycw_utilities-0.159.1}/src/tests/test_polars.py

@@ -8,7 +8,7 @@ from enum import auto
 from itertools import chain, repeat
 from math import isfinite, nan
 from random import Random
-from typing import TYPE_CHECKING, Any, ClassVar, Literal, assert_never, cast
+from typing import TYPE_CHECKING, Any, ClassVar, Literal, assert_never
 from uuid import UUID, uuid4
 
 import hypothesis.strategies
@@ -90,13 +90,12 @@ from utilities.polars import (
     DatetimeUSCentral,
     DatetimeUSEastern,
     DatetimeUTC,
-    DropNullStructSeriesError,
     ExprOrSeries,
     FiniteEWMMeanError,
     InsertAfterError,
     InsertBeforeError,
-    IsNotNullStructSeriesError,
-    IsNullStructSeriesError,
+    OneColumnEmptyError,
+    OneColumnNonUniqueError,
     SetFirstRowAsColumnsError,
     TimePeriodDType,
     _check_polars_dataframe_predicates,
@@ -137,8 +136,6 @@ from utilities.polars import (
     _reconstruct_schema,
     _ReifyExprsEmptyError,
     _ReifyExprsSeriesNonUniqueError,
-    _StructFromDataClassNotADataclassError,
-    _StructFromDataClassTypeError,
     ac_halflife,
     acf,
     adjust_frequencies,
@@ -152,7 +149,6 @@ from utilities.polars import (
     boolean_value_counts,
     check_polars_dataframe,
     choice,
-    collect_series,
     columns_to_dict,
     concat_series,
     convert_time_zone,
@@ -163,10 +159,10 @@ from utilities.polars import (
     decreasing_horizontal,
     deserialize_dataframe,
     deserialize_series,
-    drop_null_struct_series,
     ensure_data_type,
     ensure_expr_or_series,
     ensure_expr_or_series_many,
+    expr_to_series,
     finite_ewm_mean,
     get_data_type_or_series_time_zone,
     get_expr_name,
@@ -176,9 +172,9 @@ from utilities.polars import (
     insert_after,
     insert_before,
     insert_between,
+    is_false,
     is_near_event,
-    is_not_null_struct_series,
-    is_null_struct_series,
+    is_true,
     join,
     join_into_periods,
     map_over_columns,
@@ -186,6 +182,7 @@ from utilities.polars import (
     nan_sum_cols,
     normal,
     offset_datetime,
+    one_column,
     order_of_magnitude,
     period_range,
     read_dataframe,
@@ -197,7 +194,10 @@ from utilities.polars import (
     serialize_series,
     set_first_row_as_columns,
     struct_dtype,
-    struct_from_dataclass,
+    to_false,
+    to_not_false,
+    to_not_true,
+    to_true,
     touch,
     try_reify_expr,
     uniform,
@@ -830,14 +830,6 @@ class TestChoice:
         assert series.is_in(list(elements)).all()
 
 
-class TestCollectSeries:
-    def test_main(self) -> None:
-        expr = int_range(end=10)
-        series = collect_series(expr)
-        expected = int_range(end=10, eager=True)
-        assert_series_equal(series, expected)
-
-
 class TestColumnsToDict:
     def test_main(self) -> None:
         df = DataFrame(
@@ -1449,29 +1441,6 @@ class TestDatetimeDTypes:
         assert name == expected
 
 
-class TestDropNullStructSeries:
-    def test_main(self) -> None:
-        series = Series(
-            values=[
-                {"a": None, "b": None},
-                {"a": True, "b": None},
-                {"a": None, "b": False},
-                {"a": True, "b": False},
-            ],
-            dtype=Struct({"a": Boolean, "b": Boolean}),
-        )
-        result = drop_null_struct_series(series)
-        expected = series[1:]
-        assert_series_equal(result, expected)
-
-    def test_error(self) -> None:
-        series = Series(name="series", values=[1, 2, 3, None], dtype=Int64)
-        with raises(
-            DropNullStructSeriesError, match="Series must have Struct-dtype; got Int64"
-        ):
-            _ = drop_null_struct_series(series)
-
-
 class TestEnsureDataType:
     @given(dtype=sampled_from([Boolean, Boolean()]))
     def test_main(self, *, dtype: MaybeType[Boolean]) -> None:
@@ -1496,6 +1465,14 @@ class TestEnsureExprOrSeriesMany:
             assert isinstance(r, Expr | Series)
 
 
+class TestExprToSeries:
+    def test_main(self) -> None:
+        expr = int_range(end=10)
+        series = expr_to_series(expr)
+        expected = int_range(end=10, eager=True)
+        assert_series_equal(series, expected)
+
+
 class TestFiniteEWMMean:
     alpha_0_75_values: ClassVar[list[float]] = [
         -8.269850726503885,
@@ -1930,68 +1907,20 @@ class TestIsNearEvent:
             _ = is_near_event(after=after)
 
 
-class TestIsNullAndIsNotNullStructSeries:
-    @given(
-        case=sampled_from([
-            (is_null_struct_series, [True, False, False, False]),
-            (is_not_null_struct_series, [False, True, True, True]),
-        ])
+class TestIsTrueAndFalse:
+    series: ClassVar[Series] = Series(
+        name="x", values=[True, False, None], dtype=Boolean
     )
-    def test_main(self, *, case: tuple[Callable[[Series], Series], list[bool]]) -> None:
-        func, exp_values = case
-        series = Series(
-            values=[
-                {"a": None, "b": None},
-                {"a": True, "b": None},
-                {"a": None, "b": False},
-                {"a": True, "b": False},
-            ],
-            dtype=Struct({"a": Boolean, "b": Boolean}),
-        )
-        result = func(series)
-        expected = Series(values=exp_values, dtype=Boolean)
-        assert_series_equal(result, expected)
 
-    @given(
-        case=sampled_from([
-            (is_null_struct_series, [False, False, False, True]),
-            (is_not_null_struct_series, [True, True, True, False]),
-        ])
-    )
-    def test_nested(
-        self, *, case: tuple[Callable[[Series], Series], list[bool]]
-    ) -> None:
-        func, exp_values = case
-        series = Series(
-            values=[
-                {"a": 1, "b": 2, "inner": {"lower": 3, "upper": 4}},
-                {"a": 1, "b": 2, "inner": None},
-                {"a": None, "b": None, "inner": {"lower": 3, "upper": 4}},
-                {"a": None, "b": None, "inner": None},
-            ],
-            dtype=Struct({
-                "a": Int64,
-                "b": Int64,
-                "inner": Struct({"lower": Int64, "upper": Int64}),
-            }),
-        )
-        result = func(series)
-        expected = Series(values=exp_values, dtype=Boolean)
+    def test_true(self) -> None:
+        result = is_true(self.series)
+        expected = Series(name="x", values=[True, False, False], dtype=Boolean)
         assert_series_equal(result, expected)
 
-    @given(
-        case=sampled_from([
-            (is_null_struct_series, IsNullStructSeriesError),
-            (is_not_null_struct_series, IsNotNullStructSeriesError),
-        ])
-    )
-    def test_error(
-        self, *, case: tuple[Callable[[Series], Series], type[Exception]]
-    ) -> None:
-        func, error = case
-        series = Series(name="series", values=[1, 2, 3, None], dtype=Int64)
-        with raises(error, match="Series must have Struct-dtype; got Int64"):
-            _ = func(series)
+    def test_false(self) -> None:
+        result = is_false(self.series)
+        expected = Series(name="x", values=[False, True, False], dtype=Boolean)
+        assert_series_equal(result, expected)
 
 
 class TestJoin:
@@ -2313,6 +2242,27 @@ class TestOffsetDateTime:
         assert result == expected
 
 
+class TestOneColumn:
+    def test_main(self) -> None:
+        series = int_range(end=10, eager=True).alias("x")
+        df = series.to_frame()
+        result = one_column(df)
+        assert_series_equal(result, series)
+
+    def test_error_empty(self) -> None:
+        with raises(OneColumnEmptyError, match="DataFrame must not be empty"):
+            _ = one_column(DataFrame())
+
+    def test_error_non_unique(self) -> None:
+        x, y = [int_range(end=10, eager=True).alias(name) for name in ["x", "y"]]
+        df = concat_series(x, y)
+        with raises(
+            OneColumnNonUniqueError,
+            match="DataFrame must contain exactly one column; got 'x', 'y' and perhaps more",
+        ):
+            _ = one_column(df)
+
+
 class TestOrderOfMagnitude:
     @given(
         sign=sampled_from([1, -1]),
@@ -2574,130 +2524,92 @@ class TestStructDType:
         assert result == expected
 
 
-class TestStructFromDataClass:
-    def test_simple(self) -> None:
-        @dataclass(kw_only=True, slots=True)
-        class Example:
-            bool_: bool
-            bool_maybe: bool | None = None
-            date: whenever.Date
-            date_maybe: whenever.Date | None = None
-            float_: float
-            float_maybe: float | None = None
-            int_: int
-            int_maybe: int | None = None
-            str_: str
-            str_maybe: str | None = None
-
-        result = struct_from_dataclass(Example, globalns=globals())
-        expected = Struct({
-            "bool_": Boolean,
-            "bool_maybe": Boolean,
-            "date": pl.Date,
-            "date_maybe": pl.Date,
-            "float_": Float64,
-            "float_maybe": Float64,
-            "int_": Int64,
-            "int_maybe": Int64,
-            "str_": String,
-            "str_maybe": String,
-        })
-        assert result == expected
+class TestToTrueAndFalse:
+    series_tt: ClassVar[Series] = Series(name="x", values=[True, True], dtype=Boolean)
+    series_tf: ClassVar[Series] = Series(name="x", values=[True, False], dtype=Boolean)
+    series_t0: ClassVar[Series] = Series(name="x", values=[True, None], dtype=Boolean)
+    series_ft: ClassVar[Series] = Series(name="x", values=[False, True], dtype=Boolean)
+    series_ff: ClassVar[Series] = Series(name="x", values=[False, False], dtype=Boolean)
+    series_f0: ClassVar[Series] = Series(name="x", values=[False, None], dtype=Boolean)
+    series_0t: ClassVar[Series] = Series(name="x", values=[None, True], dtype=Boolean)
+    series_0f: ClassVar[Series] = Series(name="x", values=[None, False], dtype=Boolean)
+    series_00: ClassVar[Series] = Series(name="x", values=[None, None], dtype=Boolean)
 
-    def test_enum(self) -> None:
-        class Truth(enum.Enum):
-            true = auto()
-            false = auto()
-
-        @dataclass(kw_only=True, slots=True)
-        class Example:
-            field: Truth
-
-        result = struct_from_dataclass(Example, localns=locals())
-        expected = Struct({"field": String})
-        assert result == expected
-
-    def test_literal(self) -> None:
-        LowOrHigh = Literal["low", "high"]  # noqa: N806
-
-        @dataclass(kw_only=True, slots=True)
-        class Example:
-            field: LowOrHigh  # pyright: ignore[reportInvalidTypeForm]
-
-        result = struct_from_dataclass(Example, localns=locals())
-        expected = Struct({"field": String})
-        assert result == expected
-
-    def test_containers(self) -> None:
-        @dataclass(kw_only=True, slots=True)
-        class Example:
-            frozenset_: frozenset[int]
-            list_: list[int]
-            set_: set[int]
-
-        result = struct_from_dataclass(Example, time_zone=UTC)
-        expected = Struct({
-            "frozenset_": List(Int64),
-            "list_": List(Int64),
-            "set_": List(Int64),
-        })
-        assert result == expected
-
-    def test_list_of_struct(self) -> None:
-        @dataclass(kw_only=True, slots=True)
-        class Inner:
-            field: int
-
-        @dataclass(kw_only=True, slots=True)
-        class Outer:
-            inner: list[Inner]
-
-        result = struct_from_dataclass(Outer, localns=locals(), time_zone=UTC)
-        expected = Struct({"inner": List(Struct({"field": Int64}))})
-        assert result == expected
-
-    def test_struct(self) -> None:
-        @dataclass(kw_only=True, slots=True)
-        class Inner:
-            field: int
-
-        @dataclass(kw_only=True, slots=True)
-        class Outer:
-            inner: Inner
-
-        result = struct_from_dataclass(Outer, localns=locals(), time_zone=UTC)
-        expected = Struct({"inner": Struct({"field": Int64})})
-        assert result == expected
-
-    def test_struct_of_list(self) -> None:
-        @dataclass(kw_only=True, slots=True)
-        class Inner:
-            field: list[int]
-
-        @dataclass(kw_only=True, slots=True)
-        class Outer:
-            inner: Inner
-
-        result = struct_from_dataclass(Outer, localns=locals(), time_zone=UTC)
-        expected = Struct({"inner": Struct({"field": List(Int64)})})
-        assert result == expected
+    @mark.parametrize(
+        ("series", "exp_values"),
+        [
+            param(series_tt, [False, False]),
+            param(series_tf, [False, False]),
+            param(series_t0, [False, False]),
+            param(series_ft, [False, True]),
+            param(series_ff, [False, False]),
+            param(series_f0, [False, False]),
+            param(series_0t, [False, True]),
+            param(series_0f, [False, False]),
+            param(series_00, [False, False]),
+        ],
+    )
+    def test_to_true(self, *, series: Series, exp_values: list[bool]) -> None:
+        result = to_true(series)
+        exp_series = Series(name="x", values=exp_values, dtype=Boolean)
+        assert_series_equal(result, exp_series)
 
-    def test_not_a_dataclass_error(self) -> None:
-        with raises(
-            _StructFromDataClassNotADataclassError,
-            match="Object must be a dataclass; got None",
-        ):
-            _ = struct_from_dataclass(cast("Any", None))
+    @mark.parametrize(
+        ("series", "exp_values"),
+        [
+            param(series_tt, [False, False]),
+            param(series_tf, [False, True]),
+            param(series_t0, [False, True]),
+            param(series_ft, [False, False]),
+            param(series_ff, [False, False]),
+            param(series_f0, [False, False]),
+            param(series_0t, [False, False]),
+            param(series_0f, [False, False]),
+            param(series_00, [False, False]),
+        ],
+    )
+    def test_to_not_true(self, *, series: Series, exp_values: list[bool]) -> None:
+        result = to_not_true(series)
+        exp_series = Series(name="x", values=exp_values, dtype=Boolean)
+        assert_series_equal(result, exp_series)
 
-    def test_missing_type_error(self) -> None:
-        @dataclass(kw_only=True, slots=True)
-        class Example:
-            field: None
+    @mark.parametrize(
+        ("series", "exp_values"),
+        [
+            param(series_tt, [False, False]),
+            param(series_tf, [False, True]),
+            param(series_t0, [False, False]),
+            param(series_ft, [False, False]),
+            param(series_ff, [False, False]),
+            param(series_f0, [False, False]),
+            param(series_0t, [False, False]),
+            param(series_0f, [False, True]),
+            param(series_00, [False, False]),
+        ],
+    )
+    def test_to_false(self, *, series: Series, exp_values: list[bool]) -> None:
+        result = to_false(series)
+        exp_series = Series(name="x", values=exp_values, dtype=Boolean)
+        assert_series_equal(result, exp_series)
 
-        with raises(
-            _StructFromDataClassTypeError, match="Unsupported type: <class 'NoneType'>"
-        ):
-            _ = struct_from_dataclass(Example)
+    @mark.parametrize(
+        ("series", "exp_values"),
+        [
+            param(series_tt, [False, False]),
+            param(series_tf, [False, False]),
+            param(series_t0, [False, False]),
+            param(series_ft, [False, True]),
+            param(series_ff, [False, False]),
+            param(series_f0, [False, True]),
+            param(series_0t, [False, False]),
+            param(series_0f, [False, False]),
+            param(series_00, [False, False]),
+        ],
+    )
+    def test_to_not_false(self, *, series: Series, exp_values: list[bool]) -> None:
+        result = to_not_false(series)
+        exp_series = Series(name="x", values=exp_values, dtype=Boolean)
+        assert_series_equal(result, exp_series)
 
 
 class TestTryReifyExpr:

{dycw_utilities-0.158.2 → dycw_utilities-0.159.1}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.158.2"
+__version__ = "0.159.1"