dycw-utilities 0.159.3__tar.gz → 0.159.5__tar.gz

{dycw_utilities-0.159.3 → dycw_utilities-0.159.5}/PKG-INFO

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

{dycw_utilities-0.159.3 → dycw_utilities-0.159.5}/pyproject.toml

@@ -227,7 +227,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.159.3"
+version = "0.159.5"
 
 [project.entry-points.pytest11]
 pytest-randomly = "utilities.pytest_plugins.pytest_randomly"
@@ -259,7 +259,7 @@ test = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.159.3"
+current_version = "0.159.5"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.159.3 → dycw_utilities-0.159.5}/src/tests/test_math.py

@@ -843,22 +843,20 @@ class TestMaxLongAndDouble:
 
 class TestNumberOfDecimals:
     max_int: ClassVar[int] = int(1e6)
+    cases: ClassVar[list[tuple[float, int]]] = [
+        (0.0, 0),
+        (0.1, 1),
+        (0.12, 2),
+        (0.123, 3),
+        (0.1234, 4),
+        (0.12345, 5),
+        (0.123456, 6),
+        (0.1234567, 7),
+        (0.12345678, 8),
+        (0.123456789, 9),
+    ]
 
-    @given(
-        integer=integers(-max_int, max_int),
-        case=sampled_from([
-            (0.0, 0),
-            (0.1, 1),
-            (0.12, 2),
-            (0.123, 3),
-            (0.1234, 4),
-            (0.12345, 5),
-            (0.123456, 6),
-            (0.1234567, 7),
-            (0.12345678, 8),
-            (0.123456789, 9),
-        ]),
-    )
+    @given(integer=integers(-max_int, max_int), case=sampled_from(cases))
     def test_main(self, *, integer: int, case: tuple[float, int]) -> None:
         frac, expected = case
         x = integer + frac
@@ -870,7 +868,7 @@ class TestNumberOfDecimals:
         with raises(
             NumberOfDecimalsError,
             match=escape(
-                "Could not determine number of decimals of 1.401298464324817e-45 (up to 20)"
+                "Could not determine number of decimals of 1.401298464324817e-45 (up to 10)"
             ),
         ):
             _ = number_of_decimals(x)

{dycw_utilities-0.159.3 → dycw_utilities-0.159.5}/src/tests/test_polars.py

@@ -9,7 +9,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
+from typing import TYPE_CHECKING, Any, ClassVar, Literal, assert_never, cast
 from uuid import UUID, uuid4
 
 import hypothesis.strategies
@@ -60,6 +60,7 @@ from pytest import mark, param, raises
 from whenever import DateDelta, DateTimeDelta, PlainDateTime, TimeDelta, ZonedDateTime
 
 import tests.test_math
+import utilities.math
 import utilities.polars
 from utilities.hypothesis import (
     date_deltas,
@@ -78,7 +79,6 @@ from utilities.hypothesis import (
     zoned_date_time_periods,
     zoned_date_times,
 )
-from utilities.math import number_of_decimals
 from utilities.numpy import DEFAULT_RNG
 from utilities.pathlib import PWD
 from utilities.polars import (
@@ -97,6 +97,7 @@ from utilities.polars import (
     InsertBeforeError,
     OneColumnEmptyError,
     OneColumnNonUniqueError,
+    RoundToFloatError,
     SetFirstRowAsColumnsError,
     TimePeriodDType,
     _check_polars_dataframe_predicates,
@@ -123,8 +124,6 @@ from utilities.polars import (
     _GetDataTypeOrSeriesTimeZoneNotDateTimeError,
     _GetDataTypeOrSeriesTimeZoneNotZonedError,
     _GetDataTypeOrSeriesTimeZoneStructNonUniqueError,
-    _GetSeriesNumberOfDecimalsAllNullError,
-    _GetSeriesNumberOfDecimalsNotFloatError,
     _InsertBetweenMissingColumnsError,
     _InsertBetweenNonConsecutiveError,
     _IsNearEventAfterError,
@@ -169,7 +168,6 @@ from utilities.polars import (
     get_data_type_or_series_time_zone,
     get_expr_name,
     get_frequency_spectrum,
-    get_series_number_of_decimals,
     increasing_horizontal,
     insert_after,
     insert_before,
@@ -183,6 +181,7 @@ from utilities.polars import (
     nan_sum_agg,
     nan_sum_cols,
     normal,
+    number_of_decimals,
     offset_datetime,
     one_column,
     order_of_magnitude,
@@ -1562,7 +1561,7 @@ class TestFiniteEWMWeights:
 
 class TestFirstTrueHorizontal:
     @mark.parametrize(
-        ("row", "expected"),
+        ("values", "expected"),
         [
             param([True, True, True], 0),
             param([False, True, True], 1),
@@ -1570,9 +1569,9 @@ class TestFirstTrueHorizontal:
             param([False, False, False], None),
         ],
     )
-    def test_main(self, *, row: list[bool], expected: int | None) -> None:
-        df = DataFrame([row], schema={str(i): Boolean for i in range(3)}, orient="row")
-        result = first_true_horizontal(df)
+    def test_main(self, *, values: list[bool], expected: int | None) -> None:
+        series = [Series(values=[v], dtype=Boolean) for v in values]
+        result = first_true_horizontal(*series)
         assert result.item() == expected
 
 
@@ -1660,34 +1659,6 @@ class TestGetFrequencySpectrum:
         assert allclose(result.filter(col("frequency").abs() > 0.02)["amplitude"], 0.0)
 
 
-class TestGetSeriesNumberOfDecimals:
-    @given(data=data(), n=hypothesis.strategies.integers(1, 10), nullable=booleans())
-    def test_main(self, *, data: DataObject, n: int, nullable: bool) -> None:
-        strategy = int64s() | none() if nullable else int64s()
-        ints_or_none = data.draw(lists(strategy, min_size=1, max_size=10))
-        values = [None if i is None else i / 10**n for i in ints_or_none]
-        series = Series(values=values, dtype=Float64)
-        result = get_series_number_of_decimals(series, nullable=nullable)
-        if not nullable:
-            assert result is not None
-            expected = max(number_of_decimals(v) for v in values if v is not None)
-            assert result == expected
-
-    def test_error_not_float(self) -> None:
-        with raises(
-            _GetSeriesNumberOfDecimalsNotFloatError,
-            match="Data type must be Float64; got Boolean",
-        ):
-            _ = get_series_number_of_decimals(Series(dtype=Boolean))
-
-    def test_error_not_zoned(self) -> None:
-        with raises(
-            _GetSeriesNumberOfDecimalsAllNullError,
-            match="Series must not be all-null; got .*",
-        ):
-            _ = get_series_number_of_decimals(Series(dtype=Float64))
-
-
 class TestIncreasingAndDecreasingHorizontal:
     def test_main(self) -> None:
         df = DataFrame(
@@ -2261,6 +2232,22 @@ class TestNormal:
         assert series.is_finite().all()
 
 
+class TestNumberOfDecimals:
+    @given(
+        integer=hypothesis.strategies.integers(
+            -tests.test_math.TestNumberOfDecimals.max_int,
+            tests.test_math.TestNumberOfDecimals.max_int,
+        ),
+        case=sampled_from(tests.test_math.TestNumberOfDecimals.cases),
+    )
+    def test_main(self, *, integer: int, case: tuple[float, int]) -> None:
+        frac, expected = case
+        x = integer + frac
+        series = Series(name="x", values=[x], dtype=Float64)
+        result = number_of_decimals(series)
+        assert result.item() == expected
+
+
 class TestOffsetDateTime:
     @mark.parametrize(
         ("n", "time"), [param(1, whenever.Time(13, 30)), param(2, whenever.Time(15))]
@@ -2441,8 +2428,8 @@ class TestReplaceTimeZone:
 class TestRoundToFloat:
     @mark.parametrize(("x", "y", "exp_value"), tests.test_math.TestRoundToFloat.cases)
     def test_main(self, *, x: float, y: float, exp_value: float) -> None:
-        series = Series(name="x", values=[x], dtype=Float64)
-        result = round_to_float(series, y)
+        x_sr = Series(name="x", values=[x], dtype=Float64)
+        result = round_to_float(x_sr, y)
         expected = Series(name="x", values=[exp_value], dtype=Float64)
         assert_series_equal(result, expected, check_exact=True)
 
@@ -2455,6 +2442,29 @@ class TestRoundToFloat:
         expected = Series(name="x", values=[1.2], dtype=Float64).to_frame()
         assert_frame_equal(df, expected)
 
+    def test_series_and_expr(self) -> None:
+        x = Series(name="x", values=[1.234], dtype=Float64)
+        y = lit(0.1, dtype=Float64).alias("y")
+        result = round_to_float(x, y)
+        assert result.item() == 1.2
+
+    def test_expr_and_expr(self) -> None:
+        x = lit(1.234, dtype=Float64).alias("x")
+        y = Series(name="y", values=[0.1], dtype=Float64)
+        result = round_to_float(x, y)
+        assert result.item() == 1.2
+
+    @mark.parametrize(
+        ("x", "y"),
+        [param("x", "y"), param(col.x, "y"), param("x", col.y), param(col.x, col.y)],
+    )
+    def test_error(self, *, x: IntoExprColumn, y: IntoExprColumn) -> None:
+        with raises(
+            RoundToFloatError,
+            match="At least 1 of the dividend and/or divisor must be a Series; got .* and .*",
+        ):
+            _ = round_to_float(cast("Any", x), cast("Any", y))
+
 
 class TestSerializeAndDeserializeDataFrame:
     cases: ClassVar[list[tuple[PolarsDataType, SearchStrategy[Any]]]] = [

{dycw_utilities-0.159.3 → dycw_utilities-0.159.5}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.159.3"
+__version__ = "0.159.5"

{dycw_utilities-0.159.3 → dycw_utilities-0.159.5}/src/utilities/math.py

@@ -641,7 +641,10 @@ def _is_close(
 ##
 
 
-def number_of_decimals(x: float, /, *, max_decimals: int = 20) -> int:
+MAX_DECIMALS = 10
+
+
+def number_of_decimals(x: float, /, *, max_decimals: int = MAX_DECIMALS) -> int:
     """Get the number of decimals."""
     _, frac = divmod(x, 1)
     results = (
@@ -889,6 +892,7 @@ def significant_figures(x: float, /, *, n: int = 2) -> str:
 
 
 __all__ = [
+    "MAX_DECIMALS",
     "MAX_FLOAT32",
     "MAX_FLOAT64",
     "MAX_INT8",

{dycw_utilities-0.159.3 → dycw_utilities-0.159.5}/src/utilities/polars.py

@@ -53,11 +53,11 @@ from polars.schema import Schema
 from polars.testing import assert_frame_equal, assert_series_equal
 from whenever import DateDelta, DateTimeDelta, PlainDateTime, TimeDelta, ZonedDateTime
 
+import utilities.math
 from utilities.dataclasses import yield_fields
 from utilities.errors import ImpossibleCaseError
 from utilities.functions import (
-    EnsureIntError,
-    ensure_int,
+    get_class_name,
     is_dataclass_class,
     is_dataclass_instance,
     make_isinstance,
@@ -80,12 +80,12 @@ from utilities.iterables import (
 )
 from utilities.json import write_formatted_json
 from utilities.math import (
+    MAX_DECIMALS,
     CheckIntegerError,
     check_integer,
     ewm_parameters,
     is_less_than,
     is_non_negative,
-    number_of_decimals,
 )
 from utilities.reprlib import get_repr
 from utilities.types import MaybeStr, Number, PathLike, WeekDay
@@ -1325,10 +1325,27 @@ class _FiniteEWMWeightsError(Exception):
 ##
 
 
-def first_true_horizontal(df: DataFrame, /) -> Series:
+@overload
+def first_true_horizontal(column: Series, /) -> Series: ...
+@overload
+def first_true_horizontal(column1: Series, column2: Series, /) -> Series: ...
+@overload
+def first_true_horizontal(
+    column1: Series, column2: Series, column3: Series, /
+) -> Series: ...
+@overload
+def first_true_horizontal(
+    column1: Series, column2: Series, column3: Series, column4: Series, /
+) -> Series: ...
+@overload
+def first_true_horizontal(*columns: Series) -> Series: ...
+@overload
+def first_true_horizontal(*columns: IntoExprColumn) -> ExprOrSeries: ...
+def first_true_horizontal(*columns: IntoExprColumn) -> ExprOrSeries:
     """Get the index of the first true in each row."""
-    expr = when(any_horizontal(pl.all())).then(concat_list(pl.all()).list.arg_max())
-    return one_column(df.select(expr))
+    columns2 = ensure_expr_or_series_many(*columns)
+    expr = when(any_horizontal(*columns2)).then(concat_list(*columns2).list.arg_max())
+    return try_reify_expr(expr, *columns2)
 
 
 ##
@@ -1427,56 +1444,6 @@ def get_frequency_spectrum(series: Series, /, *, d: int = 1) -> DataFrame:
 ##
 
 
-@overload
-def get_series_number_of_decimals(
-    series: Series, /, *, nullable: Literal[True]
-) -> int | None: ...
-@overload
-def get_series_number_of_decimals(
-    series: Series, /, *, nullable: Literal[False] = False
-) -> int: ...
-@overload
-def get_series_number_of_decimals(
-    series: Series, /, *, nullable: bool = False
-) -> int | None: ...
-def get_series_number_of_decimals(
-    series: Series, /, *, nullable: bool = False
-) -> int | None:
-    """Get the number of decimals of a series."""
-    if not isinstance(dtype := series.dtype, Float64):
-        raise _GetSeriesNumberOfDecimalsNotFloatError(dtype=dtype)
-    decimals = series.map_elements(number_of_decimals, return_dtype=Int64).max()
-    try:
-        return ensure_int(decimals, nullable=nullable)
-    except EnsureIntError:
-        raise _GetSeriesNumberOfDecimalsAllNullError(series=series) from None
-
-
-@dataclass(kw_only=True, slots=True)
-class GetSeriesNumberOfDecimalsError(Exception): ...
-
-
-@dataclass(kw_only=True, slots=True)
-class _GetSeriesNumberOfDecimalsNotFloatError(GetSeriesNumberOfDecimalsError):
-    dtype: DataType
-
-    @override
-    def __str__(self) -> str:
-        return f"Data type must be Float64; got {self.dtype}"
-
-
-@dataclass(kw_only=True, slots=True)
-class _GetSeriesNumberOfDecimalsAllNullError(GetSeriesNumberOfDecimalsError):
-    series: Series
-
-    @override
-    def __str__(self) -> str:
-        return f"Series must not be all-null; got {self.series}"
-
-
-##
-
-
 @overload
 def increasing_horizontal(*columns: ExprLike) -> Expr: ...
 @overload
@@ -2023,6 +1990,38 @@ def normal(
 ##
 
 
+@overload
+def number_of_decimals(
+    series: ExprLike, /, *, max_decimals: int = MAX_DECIMALS
+) -> Expr: ...
+@overload
+def number_of_decimals(
+    series: Series, /, *, max_decimals: int = MAX_DECIMALS
+) -> Series: ...
+@overload
+def number_of_decimals(
+    series: IntoExprColumn, /, *, max_decimals: int = MAX_DECIMALS
+) -> ExprOrSeries: ...
+def number_of_decimals(
+    series: IntoExprColumn, /, *, max_decimals: int = MAX_DECIMALS
+) -> ExprOrSeries:
+    """Get the number of decimals."""
+    series = ensure_expr_or_series(series)
+    frac = series - series.floor()
+    results = (
+        _number_of_decimals_check_scale(frac, s) for s in range(max_decimals + 1)
+    )
+    return first_true_horizontal(*results)
+
+
+def _number_of_decimals_check_scale(frac: ExprOrSeries, scale: int, /) -> ExprOrSeries:
+    scaled = 10**scale * frac
+    return is_close(scaled, scaled.round()).alias(str(scale))
+
+
+##
+
+
 def offset_datetime(
     datetime: ZonedDateTime, offset: str, /, *, n: int = 1
 ) -> ZonedDateTime:
@@ -2377,19 +2376,63 @@ def round_to_float(
 ) -> Expr: ...
 @overload
 def round_to_float(
-    x: Series, y: float, /, *, mode: RoundMode = "half_to_even"
+    x: Series, y: float | ExprOrSeries, /, *, mode: RoundMode = "half_to_even"
 ) -> Series: ...
 @overload
 def round_to_float(
-    x: IntoExprColumn, y: float, /, *, mode: RoundMode = "half_to_even"
+    x: ExprLike, y: Series, /, *, mode: RoundMode = "half_to_even"
+) -> Series: ...
+@overload
+def round_to_float(
+    x: ExprLike, y: Expr, /, *, mode: RoundMode = "half_to_even"
+) -> Expr: ...
+@overload
+def round_to_float(
+    x: IntoExprColumn, y: float | Series, /, *, mode: RoundMode = "half_to_even"
 ) -> ExprOrSeries: ...
 def round_to_float(
-    x: IntoExprColumn, y: float, /, *, mode: RoundMode = "half_to_even"
+    x: IntoExprColumn, y: float | IntoExprColumn, /, *, mode: RoundMode = "half_to_even"
 ) -> ExprOrSeries:
     """Round a column to the nearest multiple of another float."""
     x = ensure_expr_or_series(x)
-    z = (x / y).round(mode=mode) * y
-    return z.round(decimals=number_of_decimals(y) + 1)
+    y = y if isinstance(y, int | float) else ensure_expr_or_series(y)
+    match x, y:
+        case Expr() | Series(), int() | float():
+            z = (x / y).round(mode=mode) * y
+            return z.round(decimals=utilities.math.number_of_decimals(y) + 1)
+        case Series(), Expr() | Series():
+            df = (
+                x.to_frame()
+                .with_columns(y)
+                .with_columns(number_of_decimals(y).alias("_decimals"))
+                .with_row_index(name="_index")
+                .group_by("_decimals")
+                .map_groups(_round_to_float_one)
+                .sort("_index")
+            )
+            return df[df.columns[1]]
+        case Expr(), Series():
+            df = y.to_frame().with_columns(x)
+            return round_to_float(df[df.columns[1]], df[df.columns[0]], mode=mode)
+        case Expr(), Expr() | str():
+            raise RoundToFloatError(x=x, y=y)
+        case never:
+            assert_never(never)
+
+
+def _round_to_float_one(df: DataFrame, /) -> DataFrame:
+    decimals: int = df["_decimals"].unique().item()
+    return df.with_columns(col(df.columns[1]).round(decimals=decimals))
+
+
+@dataclass(kw_only=True, slots=True)
+class RoundToFloatError(Exception):
+    x: IntoExprColumn
+    y: IntoExprColumn
+
+    @override
+    def __str__(self) -> str:
+        return f"At least 1 of the dividend and/or divisor must be a Series; got {get_class_name(self.x)!r} and {get_class_name(self.y)!r}"
 
 
 ##
@@ -2595,7 +2638,6 @@ __all__ = [
     "ExprOrSeries",
     "FiniteEWMMeanError",
     "GetDataTypeOrSeriesTimeZoneError",
-    "GetSeriesNumberOfDecimalsError",
     "InsertAfterError",
     "InsertBeforeError",
     "InsertBetweenError",
@@ -2603,6 +2645,7 @@ __all__ = [
     "OneColumnEmptyError",
     "OneColumnError",
     "OneColumnNonUniqueError",
+    "RoundToFloatError",
     "SetFirstRowAsColumnsError",
     "TimePeriodDType",
     "acf",
@@ -2634,7 +2677,6 @@ __all__ = [
     "get_data_type_or_series_time_zone",
     "get_expr_name",
     "get_frequency_spectrum",
-    "get_series_number_of_decimals",
     "increasing_horizontal",
     "insert_after",
     "insert_before",
@@ -2650,6 +2692,7 @@ __all__ = [
     "nan_sum_agg",
     "nan_sum_cols",
     "normal",
+    "number_of_decimals",
     "offset_datetime",
     "one_column",
     "order_of_magnitude",