dycw-utilities 0.112.14__tar.gz → 0.113.1__tar.gz

{dycw_utilities-0.112.14 → dycw_utilities-0.113.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dycw-utilities
-Version: 0.112.14
+Version: 0.113.1
 Author-email: Derek Wan <d.wan@icloud.com>
 License-File: LICENSE
 Requires-Python: >=3.12
@@ -137,7 +137,6 @@ Provides-Extra: zzz-test-pickle
 Requires-Dist: atomicwrites<1.5,>=1.4.1; extra == 'zzz-test-pickle'
 Provides-Extra: zzz-test-platform
 Provides-Extra: zzz-test-polars
-Requires-Dist: dacite<1.10,>=1.9.2; extra == 'zzz-test-polars'
 Requires-Dist: polars-lts-cpu<1.30,>=1.29.0; extra == 'zzz-test-polars'
 Requires-Dist: whenever<0.8,>=0.7.3; extra == 'zzz-test-polars'
 Provides-Extra: zzz-test-pqdm

{dycw_utilities-0.112.14 → dycw_utilities-0.113.1}/pyproject.toml

@@ -21,7 +21,6 @@ dev = [
   "concurrent-log-handler >= 0.9.25, < 0.10",
   "cryptography >= 44.0.2, < 44.1",
   "cvxpy >= 1.6.5, < 1.7",
-  "dacite >= 1.9.2, < 1.10",
   "eventkit >= 1.0.3, < 1.1",
   "fastapi >= 0.115.11, < 0.116",
   "fpdf2 >= 2.8.3, < 2.9",
@@ -93,7 +92,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.112.14"
+version = "0.113.1"
 
 [project.optional-dependencies]
 test = [
@@ -231,7 +230,6 @@ zzz-test-pathlib = []
 zzz-test-pickle = ["atomicwrites >= 1.4.1, < 1.5"]
 zzz-test-platform = []
 zzz-test-polars = [
-  "dacite >= 1.9.2, < 1.10",
   "polars-lts-cpu >= 1.29.0, < 1.30",
   "whenever >= 0.7.3, < 0.8",
 ]
@@ -336,7 +334,7 @@ zzz-test-zoneinfo = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.112.14"
+current_version = "0.113.1"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.112.14 → dycw_utilities-0.113.1}/src/tests/test_dataclasses.py

@@ -1,12 +1,21 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
+from functools import total_ordering
 from pathlib import Path
 from types import NoneType
-from typing import Any, Literal, cast, override
+from typing import Any, Literal, Self, cast, override
 
 from hypothesis import given
-from hypothesis.strategies import booleans, integers, lists, sampled_from
+from hypothesis.strategies import (
+    DataObject,
+    booleans,
+    data,
+    integers,
+    lists,
+    permutations,
+    sampled_from,
+)
 from polars import DataFrame
 from pytest import raises
 
@@ -53,6 +62,7 @@ from utilities.dataclasses import (
     _YieldFieldsInstance,
     dataclass_repr,
     dataclass_to_dict,
+    is_nullable_lt,
     mapping_to_dataclass,
     one_field,
     parse_dataclass,
@@ -272,6 +282,25 @@ class TestDataClassToDictAndDataClassRepr:
         assert repr_res == repr_exp
 
 
+class TestIsNullableLT:
+    @given(data=data())
+    def test_main(self, *, data: DataObject) -> None:
+        @dataclass(kw_only=True)
+        @total_ordering
+        class Example:
+            x: int | None = None
+
+            def __lt__(self, other: Self) -> bool:
+                if (cmp := is_nullable_lt(self.x, other.x)) is not None:
+                    return cmp
+                return False
+
+        obj_none, obj1, obj2 = [Example(x=x) for x in [None, 1, 2]]
+        expected = [obj_none, obj_none, obj1, obj1, obj2, obj2]
+        result = sorted(data.draw(permutations(expected)))
+        assert result == expected
+
+
 class TestMappingToDataClass:
     @given(key=sampled_from(["int_", "INT_"]), int_=integers())
     def test_exact_match_case_insensitive(self, *, key: str, int_: int) -> None:

{dycw_utilities-0.112.14 → dycw_utilities-0.113.1}/src/tests/test_iterables.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import re
 from dataclasses import dataclass, replace
 from enum import Enum, auto
+from functools import cmp_to_key
 from itertools import chain, repeat
 from math import isfinite, isinf, isnan, nan
 from operator import add, neg, sub
@@ -92,6 +93,7 @@ from utilities.iterables import (
     check_superset,
     check_unique_modulo_case,
     chunked,
+    cmp_nullable,
     ensure_hashables,
     ensure_iterable,
     ensure_iterable_not_str,
@@ -613,6 +615,28 @@ class TestChunked:
         assert result == expected
 
 
+class TestCmpNullable:
+    @given(
+        data=data(),
+        case=sampled_from([
+            ([None, None], [None, None]),
+            ([1, None], [None, 1]),
+            ([1, None, None], [None, None, 1]),
+            ([2, 1, None], [None, 1, 2]),
+            ([2, 1, None, None], [None, None, 1, 2]),
+        ]),
+    )
+    def test_main(
+        self,
+        *,
+        data: DataObject,
+        case: tuple[Sequence[int | None], Sequence[int | None]],
+    ) -> None:
+        values, expected = case
+        result = sorted(data.draw(permutations(values)), key=cmp_to_key(cmp_nullable))
+        assert result == expected
+
+
 @dataclass(unsafe_hash=True, slots=True)
 class _Item:
     n: int

{dycw_utilities-0.112.14 → dycw_utilities-0.113.1}/src/tests/test_polars.py

@@ -87,7 +87,6 @@ from utilities.polars import (
     IsNullStructSeriesError,
     SetFirstRowAsColumnsError,
     StructFromDataClassError,
-    YieldStructSeriesElementsError,
     _check_polars_dataframe_predicates,
     _check_polars_dataframe_schema_list,
     _check_polars_dataframe_schema_set,
@@ -117,7 +116,6 @@ from utilities.polars import (
     _IsNearEventBeforeError,
     _ReifyExprsEmptyError,
     _ReifyExprsSeriesNonUniqueError,
-    _yield_struct_series_element_remove_nulls,
     ac_halflife,
     acf,
     adjust_frequencies,
@@ -167,8 +165,6 @@ from utilities.polars import (
     uniform,
     unique_element,
     week_num,
-    yield_struct_series_dataclasses,
-    yield_struct_series_elements,
     zoned_datetime,
 )
 from utilities.random import get_state
@@ -2561,154 +2557,6 @@ class TestWeekNum:
         assert_series_equal(result, expected)
 
 
-class TestYieldStructSeriesDataclasses:
-    def test_main(self) -> None:
-        @dataclass(kw_only=True, slots=True)
-        class Row:
-            lower: int | None = None
-            upper: int | None = None
-
-        series = Series(
-            name="series",
-            values=[(1, 1), (2, None), (None, 3), (None, None)],
-            dtype=Struct({"lower": Int64, "upper": Int64}),
-        )
-        result = list(yield_struct_series_dataclasses(series, Row))
-        expected = [
-            Row(lower=1, upper=1),
-            Row(lower=2, upper=None),
-            Row(lower=None, upper=3),
-            None,
-        ]
-        assert result == expected
-
-    def test_nested(self) -> None:
-        @dataclass(kw_only=True, slots=True)
-        class Inner:
-            lower: int
-            upper: int
-
-        @dataclass(kw_only=True, slots=True)
-        class Outer:
-            a: int | None = None
-            b: int | None = None
-            inner: Inner | None = None
-
-        series = Series(
-            name="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 = list(
-            yield_struct_series_dataclasses(
-                series, Outer, forward_references={"Inner": Inner}
-            )
-        )
-        expected = [
-            Outer(a=1, b=2, inner=Inner(lower=3, upper=4)),
-            Outer(a=1, b=2, inner=None),
-            Outer(a=None, b=None, inner=Inner(lower=3, upper=4)),
-            None,
-        ]
-        assert result == expected
-
-
-class TestYieldStructSeriesElements:
-    def test_main(self) -> None:
-        series = Series(
-            name="series",
-            values=[(1, 1), (2, None), (None, 3), (None, None)],
-            dtype=Struct({"lower": Int64, "upper": Int64}),
-        )
-        result = list(yield_struct_series_elements(series))
-        expected = [
-            {"lower": 1, "upper": 1},
-            {"lower": 2, "upper": None},
-            {"lower": None, "upper": 3},
-            None,
-        ]
-        assert result == expected
-
-    def test_nested(self) -> None:
-        series = Series(
-            name="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 = list(yield_struct_series_elements(series))
-        expected = [
-            {"a": 1, "b": 2, "inner": {"lower": 3, "upper": 4}},
-            {"a": 1, "b": 2, "inner": None},
-            {"a": None, "b": None, "inner": {"lower": 3, "upper": 4}},
-            None,
-        ]
-        assert result == expected
-
-    @given(
-        case=sampled_from([
-            (None, None),
-            (1, 1),
-            ({"a": 1, "b": 2}, {"a": 1, "b": 2}),
-            ({"a": 1, "b": None}, {"a": 1, "b": None}),
-            ({"a": None, "b": None}, None),
-            (
-                {"a": 1, "b": 2, "inner": {"lower": 3, "upper": 4}},
-                {"a": 1, "b": 2, "inner": {"lower": 3, "upper": 4}},
-            ),
-            (
-                {"a": 1, "b": 2, "inner": {"lower": None, "upper": None}},
-                {"a": 1, "b": 2, "inner": None},
-            ),
-            (
-                {"a": None, "b": None, "inner": {"lower": 3, "upper": 4}},
-                {"a": None, "b": None, "inner": {"lower": 3, "upper": 4}},
-            ),
-            ({"a": None, "b": None, "inner": {"lower": None, "upper": None}}, None),
-        ])
-    )
-    def test_remove_nulls(self, *, case: tuple[Any, Any]) -> None:
-        obj, expected = case
-        result = _yield_struct_series_element_remove_nulls(obj)
-        assert result == expected
-
-    def test_error_struct_dtype(self) -> None:
-        series = Series(name="series", values=[1, 2, 3, None], dtype=Int64)
-        with raises(
-            YieldStructSeriesElementsError,
-            match="Series must have Struct-dtype; got Int64",
-        ):
-            _ = list(yield_struct_series_elements(series))
-
-    def test_error_null_elements(self) -> None:
-        series = Series(
-            name="series",
-            values=[{"value": 1}, {"value": 2}, {"value": 3}, None],
-            dtype=Struct({"value": Int64}),
-        )
-        with raises(
-            YieldStructSeriesElementsError, match="Series must not have nulls; got .*"
-        ):
-            _ = list(yield_struct_series_elements(series, strict=True))
-
-
 class TestZonedDateTime:
     @given(time_zone=sampled_from([HongKong, UTC]))
     def test_main(self, *, time_zone: ZoneInfo) -> None:

{dycw_utilities-0.112.14 → dycw_utilities-0.113.1}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.112.14"
+__version__ = "0.113.1"

{dycw_utilities-0.112.14 → dycw_utilities-0.113.1}/src/utilities/dataclasses.py

@@ -20,7 +20,12 @@ from utilities.functions import (
     is_dataclass_class,
     is_dataclass_instance,
 )
-from utilities.iterables import OneStrEmptyError, OneStrNonUniqueError, one_str
+from utilities.iterables import (
+    OneStrEmptyError,
+    OneStrNonUniqueError,
+    cmp_nullable,
+    one_str,
+)
 from utilities.operator import is_equal
 from utilities.parse import (
     _ParseObjectExtraNonUniqueError,
@@ -43,6 +48,7 @@ from utilities.types import (
     SerializeObjectExtra,
     StrStrMapping,
     TDataclass,
+    TSupportsLT,
 )
 from utilities.typing import get_type_hints
 
@@ -215,6 +221,22 @@ def dataclass_to_dict(
 ##
 
 
+def is_nullable_lt(x: TSupportsLT | None, y: TSupportsLT | None, /) -> bool | None:
+    """Compare two nullable fields."""
+    match cmp_nullable(x, y):
+        case 1:
+            return False
+        case -1:
+            return True
+        case 0:
+            return None
+        case _ as never:
+            assert_never(never)
+
+
+##
+
+
 def mapping_to_dataclass(
     cls: type[TDataclass],
     mapping: StrMapping,
@@ -1056,6 +1078,7 @@ __all__ = [
     "YieldFieldsError",
     "dataclass_repr",
     "dataclass_to_dict",
+    "is_nullable_lt",
     "mapping_to_dataclass",
     "one_field",
     "parse_dataclass",

{dycw_utilities-0.112.14 → dycw_utilities-0.113.1}/src/utilities/iterables.py

@@ -45,7 +45,7 @@ from utilities.math import (
 )
 from utilities.reprlib import get_repr
 from utilities.sentinel import Sentinel, sentinel
-from utilities.types import THashable, THashable2, TSupportsAdd
+from utilities.types import Sign, THashable, THashable2, TSupportsAdd, TSupportsLT
 from utilities.zoneinfo import UTC
 
 if TYPE_CHECKING:
@@ -696,6 +696,24 @@ class _CheckUniqueModuloCaseDuplicateLowerCaseStringsError(CheckUniqueModuloCase
 ##
 
 
+def cmp_nullable(x: TSupportsLT | None, y: TSupportsLT | None, /) -> Sign:
+    """Compare two nullable objects."""
+    match x, y:
+        case None, None:
+            return 0
+        case None, _:
+            return -1
+        case _, None:
+            return 1
+        case _, _:
+            return cast("Sign", (x > y) - (x < y))
+        case _ as never:
+            assert_never(never)
+
+
+##
+
+
 def chunked(iterable: Iterable[_T], n: int, /) -> Iterator[Sequence[_T]]:
     """Break an iterable into lists of length n."""
     return iter(partial(take, n, iter(iterable)), [])
@@ -1293,7 +1311,7 @@ def sort_iterable(iterable: Iterable[_T], /) -> list[_T]:
     return sorted(iterable, key=cmp_to_key(_sort_iterable_cmp))
 
 
-def _sort_iterable_cmp(x: Any, y: Any, /) -> Literal[-1, 0, 1]:
+def _sort_iterable_cmp(x: Any, y: Any, /) -> Sign:
     """Compare two quantities."""
     if type(x) is not type(y):
         x_qualname = type(x).__qualname__
@@ -1318,7 +1336,7 @@ def _sort_iterable_cmp(x: Any, y: Any, /) -> Literal[-1, 0, 1]:
         return _sort_iterable_cmp_floats(x, y)
     if isinstance(x, str):  # else Sequence
         y = cast("str", y)
-        return cast("Literal[-1, 0, 1]", (x > y) - (x < y))
+        return cast("Sign", (x > y) - (x < y))
 
     # collections
     if isinstance(x, Sized):
@@ -1333,14 +1351,14 @@ def _sort_iterable_cmp(x: Any, y: Any, /) -> Literal[-1, 0, 1]:
         return _sort_iterable_cmp(sort_iterable(x), sort_iterable(y))
     if isinstance(x, Sequence):
         y = cast("Sequence[Any]", y)
-        it: Iterable[Literal[-1, 0, 1]] = (
+        it: Iterable[Sign] = (
             _sort_iterable_cmp(x_i, y_i) for x_i, y_i in zip(x, y, strict=True)
         )
         with suppress(StopIteration):
             return next(r for r in it if r != 0)
 
     try:
-        return cast("Literal[-1, 0, 1]", (x > y) - (x < y))
+        return cast("Sign", (x > y) - (x < y))
     except TypeError:
         raise SortIterableError(x=x, y=y) from None
 
@@ -1355,13 +1373,11 @@ class SortIterableError(Exception):
         return f"Unable to sort {get_repr(self.x)} and {get_repr(self.y)}"
 
 
-def _sort_iterable_cmp_datetimes(
-    x: dt.datetime, y: dt.datetime, /
-) -> Literal[-1, 0, 1]:
+def _sort_iterable_cmp_datetimes(x: dt.datetime, y: dt.datetime, /) -> Sign:
     """Compare two datetimes."""
     match x.tzinfo, y.tzinfo:
         case None, None:
-            return cast("Literal[-1, 0, 1]", (x > y) - (x < y))
+            return cast("Sign", (x > y) - (x < y))
         case dt.tzinfo(), None:
             return 1
         case None, dt.tzinfo():
@@ -1369,20 +1385,19 @@ def _sort_iterable_cmp_datetimes(
         case dt.tzinfo(), dt.tzinfo():
             x_utc = x.astimezone(tz=UTC)
             y_utc = y.astimezone(tz=UTC)
-            result = cast("Literal[-1, 0, 1]", (x_utc > y_utc) - (x_utc < y_utc))
+            result = cast("Sign", (x_utc > y_utc) - (x_utc < y_utc))
             if result != 0:
                 return result
             x_time_zone = ensure_not_none(ensure_not_none(x.tzinfo).tzname(x))
             y_time_zone = ensure_not_none(ensure_not_none(y.tzinfo).tzname(y))
             return cast(
-                "Literal[-1, 0, 1]",
-                (x_time_zone > y_time_zone) - (x_time_zone < y_time_zone),
+                "Sign", (x_time_zone > y_time_zone) - (x_time_zone < y_time_zone)
             )
         case _ as never:
             assert_never(never)
 
 
-def _sort_iterable_cmp_floats(x: float, y: float, /) -> Literal[-1, 0, 1]:
+def _sort_iterable_cmp_floats(x: float, y: float, /) -> Sign:
     """Compare two floats."""
     x_nan, y_nan = map(isnan, [x, y])
     match x_nan, y_nan:
@@ -1393,7 +1408,7 @@ def _sort_iterable_cmp_floats(x: float, y: float, /) -> Literal[-1, 0, 1]:
         case False, True:
             return -1
         case False, False:
-            return cast("Literal[-1, 0, 1]", (x > y) - (x < y))
+            return cast("Sign", (x > y) - (x < y))
         case _ as never:
             assert_never(never)
 
@@ -1517,6 +1532,7 @@ __all__ = [
     "check_superset",
     "check_unique_modulo_case",
     "chunked",
+    "cmp_nullable",
     "ensure_hashables",
     "ensure_iterable",
     "ensure_iterable_not_str",

{dycw_utilities-0.112.14 → dycw_utilities-0.113.1}/src/utilities/math.py

@@ -10,7 +10,7 @@ from typing import TYPE_CHECKING, Literal, assert_never, overload, override
 from utilities.errors import ImpossibleCaseError
 
 if TYPE_CHECKING:
-    from utilities.types import Number, RoundMode
+    from utilities.types import Number, RoundMode, Sign
 
 
 MIN_FLOAT32, MAX_FLOAT32 = -3.4028234663852886e38, 3.4028234663852886e38
@@ -860,7 +860,7 @@ class SafeRoundError(Exception):
 
 def sign(
     x: float, /, *, rel_tol: float | None = None, abs_tol: float | None = None
-) -> Literal[-1, 0, 1]:
+) -> Sign:
     """Get the sign of an integer/float."""
     match x:
         case int():