dycw-utilities 0.164.1__tar.gz → 0.165.1__tar.gz

{dycw_utilities-0.164.1 → dycw_utilities-0.165.1}/PKG-INFO

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

{dycw_utilities-0.164.1 → dycw_utilities-0.165.1}/pyproject.toml

@@ -128,6 +128,7 @@ polars-ols-test = [
 ]
 polars-test = [
   "numpy",
+  "scipy",
   "statsmodels",
 ]
 pottery = [
@@ -232,7 +233,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.164.1"
+version = "0.165.1"
 
 [project.entry-points.pytest11]
 pytest-randomly = "utilities.pytest_plugins.pytest_randomly"
@@ -265,7 +266,7 @@ test = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.164.1"
+current_version = "0.165.1"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.164.1 → dycw_utilities-0.165.1}/src/tests/test_contextlib.py

@@ -4,6 +4,7 @@ import asyncio
 import time
 from asyncio import run
 from dataclasses import dataclass
+from inspect import signature
 from multiprocessing import Process
 from pathlib import Path
 from typing import TYPE_CHECKING, override
@@ -103,6 +104,15 @@ class TestEnhancedContextManager:
             assert not cleared
         assert cleared
 
+    def test_sync_signature(self) -> None:
+        @enhanced_context_manager
+        def yield_marker(x: int, y: int, /) -> Iterator[int]:
+            yield x + y
+
+        sig = set(signature(yield_marker).parameters)
+        expected = {"x", "y"}
+        assert sig == expected
+
     @given(
         sigabrt=booleans(),
         sigfpe=booleans(),
@@ -142,6 +152,15 @@ class TestEnhancedContextManager:
             assert not cleared
         assert cleared
 
+    def test_async_signature(self) -> None:
+        @enhanced_async_context_manager
+        async def yield_marker(x: int, y: int, /) -> AsyncIterator[int]:
+            yield x + y
+
+        sig = set(signature(yield_marker).parameters)
+        expected = {"x", "y"}
+        assert sig == expected
+
     @mark.parametrize(
         "target",
         [

{dycw_utilities-0.164.1 → dycw_utilities-0.165.1}/src/tests/test_hypothesis.py

@@ -381,29 +381,55 @@ class TestDraw2:
 
 
 class TestFloat32s:
-    @given(data=data())
-    def test_main(self, *, data: DataObject) -> None:
+    @given(data=data(), exclude_min=booleans(), exclude_max=booleans())
+    def test_main(
+        self, *, data: DataObject, exclude_min: bool, exclude_max: bool
+    ) -> None:
         min_value, max_value = data.draw(pairs(float32s() | none()))
         with assume_does_not_raise(InvalidArgument):
-            x = data.draw(float32s(min_value=min_value, max_value=max_value))
+            x = data.draw(
+                float32s(
+                    min_value=min_value,
+                    max_value=max_value,
+                    exclude_min=exclude_min,
+                    exclude_max=exclude_max,
+                )
+            )
         assert MIN_FLOAT32 <= x <= MAX_FLOAT32
         if min_value is not None:
             assert x >= min_value
+            if exclude_min:
+                assert x != min_value
         if max_value is not None:
             assert x <= max_value
+            if exclude_max:
+                assert x != max_value
 
 
 class TestFloat64s:
-    @given(data=data())
-    def test_main(self, *, data: DataObject) -> None:
+    @given(data=data(), exclude_min=booleans(), exclude_max=booleans())
+    def test_main(
+        self, *, data: DataObject, exclude_min: bool, exclude_max: bool
+    ) -> None:
         min_value, max_value = data.draw(pairs(float64s() | none()))
         with assume_does_not_raise(InvalidArgument):
-            x = data.draw(float64s(min_value=min_value, max_value=max_value))
+            x = data.draw(
+                float64s(
+                    min_value=min_value,
+                    max_value=max_value,
+                    exclude_min=exclude_min,
+                    exclude_max=exclude_max,
+                )
+            )
         assert MIN_FLOAT64 <= x <= MAX_FLOAT64
         if min_value is not None:
             assert x >= min_value
         if max_value is not None:
             assert x <= max_value
+        if max_value is not None:
+            assert x <= max_value
+            if exclude_max:
+                assert x != max_value
 
 
 class TestFloatArrays:

{dycw_utilities-0.164.1 → dycw_utilities-0.165.1}/src/tests/test_polars.py

@@ -16,7 +16,7 @@ import hypothesis.strategies
 import numpy as np
 import polars as pl
 import whenever
-from hypothesis import given
+from hypothesis import assume, given
 from hypothesis.strategies import (
     DataObject,
     SearchStrategy,
@@ -57,11 +57,13 @@ from polars._typing import IntoExprColumn, SchemaDict
 from polars.schema import Schema
 from polars.testing import assert_frame_equal, assert_series_equal
 from pytest import mark, param, raises
+from scipy.stats import norm
 from whenever import DateDelta, DateTimeDelta, PlainDateTime, TimeDelta, ZonedDateTime
 
 import tests.test_math
 import utilities.polars
 from utilities.hypothesis import (
+    assume_does_not_raise,
     date_deltas,
     date_periods,
     date_time_deltas,
@@ -180,7 +182,8 @@ from utilities.polars import (
     map_over_columns,
     nan_sum_agg,
     nan_sum_horizontal,
-    normal,
+    normal_pdf,
+    normal_rv,
     number_of_decimals,
     offset_datetime,
     one_column,
@@ -2195,22 +2198,39 @@ class TestNanSumHorizontal:
         assert result.item() == expected
 
 
-class TestNormal:
+class TestNormalPDF:
+    @given(
+        xs=lists(float64s(), max_size=10),
+        loc=float64s(),
+        scale=float64s(min_value=0.0, exclude_min=True),
+    )
+    def test_main(self, *, xs: list[float], loc: float, scale: float) -> None:
+        x = Series(name="x", values=xs, dtype=Float64)
+        series = normal_pdf(x, loc=loc, scale=scale)
+        _ = assume(series.is_finite().all())
+        with assume_does_not_raise(
+            RuntimeWarning, match="overflow encountered in (subtract|square|divide)"
+        ):
+            expected = norm.pdf(xs, loc=loc, scale=scale)
+        assert allclose(series, expected)
+
+
+class TestNormalRV:
     @given(length=hypothesis.strategies.integers(0, 10))
     def test_int(self, *, length: int) -> None:
-        series = normal(length)
+        series = normal_rv(length)
         self._assert(series, length)
 
     @given(length=hypothesis.strategies.integers(0, 10))
     def test_series(self, *, length: int) -> None:
         orig = int_range(end=length, eager=True)
-        series = normal(orig)
+        series = normal_rv(orig)
         self._assert(series, length)
 
     @given(length=hypothesis.strategies.integers(0, 10))
     def test_dataframe(self, *, length: int) -> None:
         df = int_range(end=length, eager=True).to_frame()
-        series = normal(df)
+        series = normal_rv(df)
         self._assert(series, length)
 
     def _assert(self, series: Series, length: int, /) -> None:

{dycw_utilities-0.164.1 → dycw_utilities-0.165.1}/src/tests/test_polars_ols.py

@@ -3,11 +3,11 @@ 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 import DataFrame, Float64, Series, col, mean_horizontal
 from polars.testing import assert_frame_equal
 from sklearn.linear_model import LinearRegression
 
-from utilities.polars import concat_series, integers, normal
+from utilities.polars import concat_series, integers, normal_rv, struct_dtype
 from utilities.polars_ols import compute_rolling_ols
 
 
@@ -77,7 +77,7 @@ class TestComputeRollingOLS:
             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")
+            y=mean_horizontal("x1", 2 * col.x2, normal_rv(n, scale=10.0, seed=2))
         )
 
     def _assert_series(self, series: Series, /) -> None:
@@ -100,11 +100,7 @@ class TestComputeRollingOLS:
         expected = DataFrame(
             data=data,
             schema={
-                "coefficients": Struct({
-                    "x1": Float64,
-                    "x2": Float64,
-                    "const": Float64,
-                }),
+                "coefficients": struct_dtype(x1=Float64, x2=Float64, const=Float64),
                 "predictions": Float64,
                 "residuals": Float64,
                 "R2": Float64,

{dycw_utilities-0.164.1 → dycw_utilities-0.165.1}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.164.1"
+__version__ = "0.165.1"

{dycw_utilities-0.164.1 → dycw_utilities-0.165.1}/src/utilities/contextlib.py

@@ -8,7 +8,7 @@ from contextlib import (
     asynccontextmanager,
     contextmanager,
 )
-from functools import partial
+from functools import partial, wraps
 from signal import SIGABRT, SIGFPE, SIGILL, SIGINT, SIGSEGV, SIGTERM, getsignal, signal
 from typing import TYPE_CHECKING, Any, assert_never, cast, overload
 
@@ -77,6 +77,7 @@ def enhanced_context_manager[**P, T_co](
     make_gcm = contextmanager(func)
 
     @contextmanager
+    @wraps(func)
     def wrapped(*args: P.args, **kwargs: P.kwargs) -> Iterator[T_co]:
         gcm = make_gcm(*args, **kwargs)
         sigabrt0 = _swap_handler(SIGABRT, gcm) if sigabrt else None
@@ -159,6 +160,7 @@ def enhanced_async_context_manager[**P, T_co](
     make_agcm = asynccontextmanager(func)
 
     @asynccontextmanager
+    @wraps(func)
     async def wrapped(*args: P.args, **kwargs: P.kwargs) -> AsyncIterator[T_co]:
         agcm = make_agcm(*args, **kwargs)
         sigabrt0 = _swap_handler(SIGABRT, agcm) if sigabrt else None

{dycw_utilities-0.164.1 → dycw_utilities-0.165.1}/src/utilities/hypothesis.py

@@ -412,6 +412,8 @@ def float32s(
     *,
     min_value: MaybeSearchStrategy[float | None] = None,
     max_value: MaybeSearchStrategy[float | None] = None,
+    exclude_min: MaybeSearchStrategy[bool] = False,
+    exclude_max: MaybeSearchStrategy[bool] = False,
 ) -> float:
     """Strategy for generating float32s."""
     min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
@@ -419,7 +421,16 @@ def float32s(
     max_value_ = min_nullable([max_value_, MAX_FLOAT32])
     if is_zero(min_value_) and is_zero(max_value_):
         min_value_ = max_value_ = 0.0
-    return draw(floats(min_value_, max_value_, width=32))
+    exclude_min_, exclude_max_ = [draw2(draw, e) for e in [exclude_min, exclude_max]]
+    return draw(
+        floats(
+            min_value_,
+            max_value_,
+            width=32,
+            exclude_min=exclude_min_,
+            exclude_max=exclude_max_,
+        )
+    )
 
 
 @composite
@@ -429,6 +440,8 @@ def float64s(
     *,
     min_value: MaybeSearchStrategy[float | None] = None,
     max_value: MaybeSearchStrategy[float | None] = None,
+    exclude_min: MaybeSearchStrategy[bool] = False,
+    exclude_max: MaybeSearchStrategy[bool] = False,
 ) -> float:
     """Strategy for generating float64s."""
     min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
@@ -436,7 +449,16 @@ def float64s(
     max_value_ = min_nullable([max_value_, MAX_FLOAT64])
     if is_zero(min_value_) and is_zero(max_value_):
         min_value_ = max_value_ = 0.0
-    return draw(floats(min_value_, max_value_, width=64))
+    exclude_min_, exclude_max_ = [draw2(draw, e) for e in [exclude_min, exclude_max]]
+    return draw(
+        floats(
+            min_value_,
+            max_value_,
+            width=64,
+            exclude_min=exclude_min_,
+            exclude_max=exclude_max_,
+        )
+    )
 
 
 ##

{dycw_utilities-0.164.1 → dycw_utilities-0.165.1}/src/utilities/polars.py

@@ -6,7 +6,7 @@ from collections.abc import Set as AbstractSet
 from dataclasses import asdict, dataclass
 from functools import partial, reduce
 from itertools import chain, pairwise, product
-from math import ceil, log
+from math import ceil, log, pi, sqrt
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Literal, assert_never, cast, overload, override
 from uuid import UUID
@@ -1929,7 +1929,49 @@ def nan_sum_horizontal(*columns: IntoExprColumn) -> ExprOrSeries:
 ##
 
 
-def normal(
+@overload
+def normal_pdf(
+    x: ExprLike,
+    /,
+    *,
+    loc: float | IntoExprColumn = 0.0,
+    scale: float | IntoExprColumn = 1.0,
+) -> Expr: ...
+@overload
+def normal_pdf(
+    x: Series,
+    /,
+    *,
+    loc: float | IntoExprColumn = 0.0,
+    scale: float | IntoExprColumn = 1.0,
+) -> Series: ...
+@overload
+def normal_pdf(
+    x: IntoExprColumn,
+    /,
+    *,
+    loc: float | IntoExprColumn = 0.0,
+    scale: float | IntoExprColumn = 1.0,
+) -> ExprOrSeries: ...
+def normal_pdf(
+    x: IntoExprColumn,
+    /,
+    *,
+    loc: float | IntoExprColumn = 0.0,
+    scale: float | IntoExprColumn = 1.0,
+) -> ExprOrSeries:
+    """Compute the PDF of a normal distribution."""
+    x = ensure_expr_or_series(x)
+    loc = loc if isinstance(loc, int | float) else ensure_expr_or_series(loc)
+    scale = scale if isinstance(scale, int | float) else ensure_expr_or_series(scale)
+    expr = (1 / (scale * sqrt(2 * pi))) * (-(1 / 2) * ((x - loc) / scale) ** 2).exp()
+    return try_reify_expr(expr, x)
+
+
+##
+
+
+def normal_rv(
     obj: int | Series | DataFrame,
     /,
     *,
@@ -1948,11 +1990,11 @@ def normal(
             values = rng.normal(loc=loc, scale=scale, size=height)
             return Series(name=name, values=values, dtype=dtype)
         case Series() as series:
-            return normal(
+            return normal_rv(
                 series.len(), loc=loc, scale=scale, seed=seed, name=name, dtype=dtype
             )
         case DataFrame() as df:
-            return normal(
+            return normal_rv(
                 df.height, loc=loc, scale=scale, seed=seed, name=name, dtype=dtype
             )
         case never:
@@ -1964,22 +2006,22 @@ def normal(
 
 @overload
 def number_of_decimals(
-    series: ExprLike, /, *, max_decimals: int = MAX_DECIMALS
+    column: ExprLike, /, *, max_decimals: int = MAX_DECIMALS
 ) -> Expr: ...
 @overload
 def number_of_decimals(
-    series: Series, /, *, max_decimals: int = MAX_DECIMALS
+    column: Series, /, *, max_decimals: int = MAX_DECIMALS
 ) -> Series: ...
 @overload
 def number_of_decimals(
-    series: IntoExprColumn, /, *, max_decimals: int = MAX_DECIMALS
+    column: IntoExprColumn, /, *, max_decimals: int = MAX_DECIMALS
 ) -> ExprOrSeries: ...
 def number_of_decimals(
-    series: IntoExprColumn, /, *, max_decimals: int = MAX_DECIMALS
+    column: IntoExprColumn, /, *, max_decimals: int = MAX_DECIMALS
 ) -> ExprOrSeries:
     """Get the number of decimals."""
-    series = ensure_expr_or_series(series)
-    frac = series - series.floor()
+    column = ensure_expr_or_series(column)
+    frac = column - column.floor()
     results = (
         _number_of_decimals_check_scale(frac, s) for s in range(max_decimals + 1)
     )
@@ -2697,7 +2739,8 @@ __all__ = [
     "map_over_columns",
     "nan_sum_agg",
     "nan_sum_horizontal",
-    "normal",
+    "normal_pdf",
+    "normal_rv",
     "number_of_decimals",
     "offset_datetime",
     "one_column",