dycw-utilities 0.164.0__tar.gz → 0.165.0__tar.gz

{dycw_utilities-0.164.0 → dycw_utilities-0.165.0}/PKG-INFO

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

{dycw_utilities-0.164.0 → dycw_utilities-0.165.0}/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.0"
+version = "0.165.0"
 
 [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.0"
+current_version = "0.165.0"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.164.0 → dycw_utilities-0.165.0}/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.0 → dycw_utilities-0.165.0}/src/tests/test_logging.py

@@ -1,14 +1,15 @@
 from __future__ import annotations
 
 from asyncio import sleep
+from dataclasses import dataclass, field
 from io import StringIO
-from logging import Formatter, StreamHandler, getLogger
+from logging import Formatter, LoggerAdapter, StreamHandler, getLogger
 from pathlib import Path
 from re import search
 from typing import TYPE_CHECKING, Any, cast
 
 from hypothesis import given
-from hypothesis.strategies import booleans, integers
+from hypothesis.strategies import integers
 from pytest import LogCaptureFixture, mark, param, raises
 
 from tests.conftest import SKIPIF_CI_AND_WINDOWS
@@ -20,6 +21,7 @@ from utilities.logging import (
     _compute_rollover_actions,
     _FieldStyleKeys,
     _RotatingLogFile,
+    add_adapter,
     add_filters,
     basic_config,
     get_format_str,
@@ -41,14 +43,37 @@ if TYPE_CHECKING:
     from whenever import ZonedDateTime
 
 
+class TestAddAdapter:
+    def test_main(self, *, caplog: LogCaptureFixture) -> None:
+        logger = getLogger(name := unique_str())
+        logger.setLevel("DEBUG")
+
+        def process(msg: str, x: int, /) -> str:
+            return f"x={x}: {msg}"
+
+        @dataclass
+        class Example:
+            x: int = 0
+            logger: LoggerAdapter = field(init=False)
+
+            def __post_init__(self) -> None:
+                self.logger = add_adapter(logger, process, self.x)
+                self.logger.info("Initializing...")
+
+        _ = Example()
+        record = one(r for r in caplog.records if r.name == name)
+        assert record.message == "x=0: Initializing..."
+
+
 class TestAddFilters:
-    @given(expected=booleans())
+    @mark.parametrize("expected", [param(True), param(False)])
     def test_main(self, *, expected: bool) -> None:
         logger = getLogger(unique_str())
         logger.addHandler(handler := StreamHandler(buffer := StringIO()))
+        logger.setLevel("DEBUG")
         add_filters(handler, lambda _: expected)
         assert len(handler.filters) == 1
-        logger.warning("message")
+        logger.info("message")
         result = buffer.getvalue() != ""
         assert result is expected
 

{dycw_utilities-0.164.0 → dycw_utilities-0.165.0}/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.0 → dycw_utilities-0.165.0}/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.0 → dycw_utilities-0.165.0}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.164.0"
+__version__ = "0.165.0"

{dycw_utilities-0.164.0 → dycw_utilities-0.165.0}/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.0 → dycw_utilities-0.165.0}/src/utilities/logging.py

@@ -8,6 +8,7 @@ from logging import (
     Formatter,
     Handler,
     Logger,
+    LoggerAdapter,
     LogRecord,
     StreamHandler,
     basicConfig,
@@ -22,6 +23,7 @@ from socket import gethostname
 from typing import (
     TYPE_CHECKING,
     Any,
+    Concatenate,
     Literal,
     NotRequired,
     Self,
@@ -53,7 +55,7 @@ from utilities.whenever import (
 )
 
 if TYPE_CHECKING:
-    from collections.abc import Iterable, Mapping
+    from collections.abc import Callable, Iterable, Mapping, MutableMapping
     from datetime import time
     from logging import _FilterType
 
@@ -63,6 +65,7 @@ if TYPE_CHECKING:
         MaybeCallablePathLike,
         MaybeIterable,
         PathLike,
+        StrMapping,
     )
 
 
@@ -75,6 +78,35 @@ _DEFAULT_WHEN: _When = "D"
 ##
 
 
+def add_adapter[**P](
+    logger: Logger,
+    process: Callable[Concatenate[str, P], str],
+    /,
+    *args: P.args,
+    **kwargs: P.kwargs,
+) -> LoggerAdapter:
+    """Add an adapter to a logger."""
+
+    class CustomAdapter(LoggerAdapter):
+        @override
+        def process(
+            self, msg: str, kwargs: MutableMapping[str, Any]
+        ) -> tuple[str, MutableMapping[str, Any]]:
+            extra = cast("_ArgsAndKwargs", self.extra)
+            new_msg = process(msg, *extra["args"], **extra["kwargs"])
+            return new_msg, kwargs
+
+    return CustomAdapter(logger, extra=_ArgsAndKwargs(args=args, kwargs=kwargs))
+
+
+class _ArgsAndKwargs(TypedDict):
+    args: tuple[Any, ...]
+    kwargs: StrMapping
+
+
+##
+
+
 def add_filters(handler: Handler, /, *filters: _FilterType) -> None:
     """Add a set of filters to a handler."""
     for filter_i in filters:
@@ -589,6 +621,7 @@ def to_logger(logger: LoggerLike | None = None, /) -> Logger:
 __all__ = [
     "GetLoggingLevelNumberError",
     "SizeAndTimeRotatingFileHandler",
+    "add_adapter",
     "add_filters",
     "basic_config",
     "get_format_str",

{dycw_utilities-0.164.0 → dycw_utilities-0.165.0}/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",

{dycw_utilities-0.164.0 → dycw_utilities-0.165.0}/src/utilities/typing.py

@@ -333,7 +333,7 @@ def is_instance_gen(
                 warn_name_errors=warn_name_errors,
             )
             for t in type_
-        )  # skipif-ci-and-not-windows
+        )
     if is_literal_type(type_):
         return obj in get_args(type_)
     if is_union_type(type_):