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

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

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

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

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

{dycw_utilities-0.163.1 → dycw_utilities-0.164.1}/src/tests/test_functions.py

@@ -33,15 +33,12 @@ from utilities.functions import (
     EnsureClassError,
     EnsureDateError,
     EnsureFloatError,
-    EnsureHashableError,
     EnsureIntError,
     EnsureMemberError,
     EnsureNotNoneError,
     EnsureNumberError,
     EnsurePathError,
     EnsurePlainDateTimeError,
-    EnsureSizedError,
-    EnsureSizedNotStrError,
     EnsureStrError,
     EnsureTimeDeltaError,
     EnsureTimeError,
@@ -54,15 +51,12 @@ from utilities.functions import (
     ensure_class,
     ensure_date,
     ensure_float,
-    ensure_hashable,
     ensure_int,
     ensure_member,
     ensure_not_none,
     ensure_number,
     ensure_path,
     ensure_plain_date_time,
-    ensure_sized,
-    ensure_sized_not_str,
     ensure_str,
     ensure_time,
     ensure_time_delta,
@@ -73,20 +67,8 @@ from utilities.functions import (
     get_func_name,
     get_func_qualname,
     identity,
-    is_dataclass_class,
-    is_dataclass_instance,
-    is_hashable,
-    is_iterable_of,
     is_none,
     is_not_none,
-    is_sequence_of,
-    is_sequence_of_tuple_or_str_mapping,
-    is_sized,
-    is_sized_not_str,
-    is_string_mapping,
-    is_tuple,
-    is_tuple_or_str_mapping,
-    make_isinstance,
     map_object,
     max_nullable,
     min_nullable,
@@ -232,18 +214,6 @@ class TestEnsureFloat:
             _ = ensure_float(sentinel, nullable=nullable)
 
 
-class TestEnsureHashable:
-    @given(obj=sampled_from([0, (1, 2, 3)]))
-    def test_main(self, *, obj: Any) -> None:
-        assert ensure_hashable(obj) == obj
-
-    def test_error(self) -> None:
-        with raises(
-            EnsureHashableError, match=r"Object '.*' of type '.*' must be hashable"
-        ):
-            _ = ensure_hashable([1, 2, 3])
-
-
 class TestEnsureInt:
     @given(case=sampled_from([(0, False), (0, True), (None, True)]))
     def test_main(self, *, case: tuple[int | None, bool]) -> None:
@@ -363,30 +333,6 @@ class TestEnsurePlainDateTime:
             _ = ensure_plain_date_time(sentinel, nullable=nullable)
 
 
-class TestEnsureSized:
-    @given(obj=sampled_from([[], (), ""]))
-    def test_main(self, *, obj: Any) -> None:
-        _ = ensure_sized(obj)
-
-    def test_error(self) -> None:
-        with raises(EnsureSizedError, match=r"Object '.*' of type '.*' must be sized"):
-            _ = ensure_sized(None)
-
-
-class TestEnsureSizedNotStr:
-    @given(obj=sampled_from([[], ()]))
-    def test_main(self, *, obj: Any) -> None:
-        _ = ensure_sized_not_str(obj)
-
-    @given(obj=sampled_from([None, '""']))
-    def test_error(self, *, obj: Any) -> None:
-        with raises(
-            EnsureSizedNotStrError,
-            match="Object '.*' of type '.*' must be sized and not a string",
-        ):
-            _ = ensure_sized_not_str(obj)
-
-
 class TestEnsureStr:
     @given(case=sampled_from([("", False), ("", True), (None, True)]))
     def test_main(self, *, case: tuple[bool | None, bool]) -> None:
@@ -610,72 +556,6 @@ class TestIdentity:
         assert identity(x) == x
 
 
-class TestIsDataClassClass:
-    def test_main(self) -> None:
-        @dataclass(kw_only=True, slots=True)
-        class Example:
-            x: None = None
-
-        assert is_dataclass_class(Example)
-        assert not is_dataclass_class(Example())
-
-    @given(obj=sampled_from([None, type(None)]))
-    def test_others(self, *, obj: Any) -> None:
-        assert not is_dataclass_class(obj)
-
-
-class TestIsDataClassInstance:
-    def test_main(self) -> None:
-        @dataclass(kw_only=True, slots=True)
-        class Example:
-            x: None = None
-
-        assert not is_dataclass_instance(Example)
-        assert is_dataclass_instance(Example())
-
-    @given(obj=sampled_from([None, type(None)]))
-    def test_others(self, *, obj: Any) -> None:
-        assert not is_dataclass_instance(obj)
-
-
-class TestIsHashable:
-    @given(case=sampled_from([(0, True), ((1, 2, 3), True), ([1, 2, 3], False)]))
-    def test_main(self, *, case: tuple[Any, bool]) -> None:
-        obj, expected = case
-        assert is_hashable(obj) is expected
-
-
-class TestIsIterableOf:
-    @given(
-        case=sampled_from([
-            ([0], True),
-            (["0"], False),
-            ({0}, True),
-            ({0: 0}, True),
-            (None, False),
-            ([None], False),
-        ])
-    )
-    def test_single(self, *, case: tuple[Any, bool]) -> None:
-        obj, expected = case
-        result = is_iterable_of(obj, int)
-        assert result is expected
-
-    @given(
-        case=sampled_from([
-            ([0], True),
-            (["0"], True),
-            ([0, "0"], True),
-            (None, False),
-            ([None], False),
-        ])
-    )
-    def test_multiple(self, *, case: tuple[Any, bool]) -> None:
-        obj, expected = case
-        result = is_iterable_of(obj, (int, str))
-        assert result is expected
-
-
 class TestIsNoneAndIsNotNone:
     @given(
         case=sampled_from([
@@ -691,119 +571,6 @@ class TestIsNoneAndIsNotNone:
         assert result is expected
 
 
-class TestIsSequenceOf:
-    @given(
-        case=sampled_from([
-            ([0], True),
-            (["0"], False),
-            ({0}, False),
-            ({0: 0}, False),
-            (None, False),
-            ([None], False),
-        ])
-    )
-    def test_single(self, *, case: tuple[Any, bool]) -> None:
-        obj, expected = case
-        result = is_sequence_of(obj, int)
-        assert result is expected
-
-    @given(
-        case=sampled_from([
-            ([0], True),
-            (["0"], True),
-            ([0, "0"], True),
-            (None, False),
-            ([None], False),
-        ])
-    )
-    def test_multiple(self, *, case: tuple[Any, bool]) -> None:
-        obj, expected = case
-        result = is_sequence_of(obj, (int, str))
-        assert result is expected
-
-
-class TestIsSequenceOfTupleOrStrgMapping:
-    @given(
-        case=sampled_from([
-            (None, False),
-            ([(1, 2, 3)], True),
-            ([{"a": 1, "b": 2, "c": 3}], True),
-            ([(1, 2, 3), {"a": 1, "b": 2, "c": 3}], True),
-        ])
-    )
-    def test_main(self, *, case: tuple[Any, bool]) -> None:
-        obj, expected = case
-        result = is_sequence_of_tuple_or_str_mapping(obj)
-        assert result is expected
-
-
-class TestIsSized:
-    @given(case=sampled_from([(None, False), ([], True), ((), True), ("", True)]))
-    def test_main(self, *, case: tuple[Any, bool]) -> None:
-        obj, expected = case
-        assert is_sized(obj) is expected
-
-
-class TestIsSizedNotStr:
-    @given(case=sampled_from([(None, False), ([], True), ((), True), ("", False)]))
-    def test_main(self, *, case: tuple[Any, bool]) -> None:
-        obj, expected = case
-        assert is_sized_not_str(obj) is expected
-
-
-class TestIsStringMapping:
-    @given(
-        case=sampled_from([
-            (None, False),
-            ({"a": 1, "b": 2, "c": 3}, True),
-            ({1: "a", 2: "b", 3: "c"}, False),
-        ])
-    )
-    def test_main(self, *, case: tuple[Any, bool]) -> None:
-        obj, expected = case
-        result = is_string_mapping(obj)
-        assert result is expected
-
-
-class TestIsTuple:
-    @given(case=sampled_from([(None, False), ((1, 2, 3), True), ([1, 2, 3], False)]))
-    def test_main(self, *, case: tuple[Any, bool]) -> None:
-        obj, expected = case
-        result = is_tuple(obj)
-        assert result is expected
-
-
-class TestIsTupleOrStringMapping:
-    @given(
-        case=sampled_from([
-            (None, False),
-            ((1, 2, 3), True),
-            ({"a": 1, "b": 2, "c": 3}, True),
-            ({1: "a", 2: "b", 3: "c"}, False),
-        ])
-    )
-    def test_main(self, *, case: tuple[Any, bool]) -> None:
-        obj, expected = case
-        result = is_tuple_or_str_mapping(obj)
-        assert result is expected
-
-
-class TestMakeIsInstance:
-    @given(case=sampled_from([(True, True), (False, True), (None, False)]))
-    def test_single(self, *, case: tuple[bool | None, bool]) -> None:
-        obj, expected = case
-        func = make_isinstance(bool)
-        result = func(obj)
-        assert result is expected
-
-    @given(case=sampled_from([(0, True), ("0", True), (None, False)]))
-    def test_multiple(self, *, case: tuple[bool | None, bool]) -> None:
-        obj, expected = case
-        func = make_isinstance((int, str))
-        result = func(obj)
-        assert result is expected
-
-
 class TestMapObject:
     @given(x=integers())
     def test_int(self, *, x: int) -> None:

{dycw_utilities-0.163.1 → dycw_utilities-0.164.1}/src/tests/test_iterables.py

@@ -32,7 +32,6 @@ from hypothesis.strategies import (
 from pytest import mark, param, raises
 
 from tests.test_objects.objects import objects
-from utilities.functions import is_sequence_of
 from utilities.hypothesis import pairs, sentinels, sets_fixed_length, text_ascii
 from utilities.iterables import (
     CheckBijectionError,
@@ -88,7 +87,6 @@ from utilities.iterables import (
     check_unique_modulo_case,
     chunked,
     cmp_nullable,
-    ensure_hashables,
     ensure_iterable,
     ensure_iterable_not_str,
     enumerate_with_edge,
@@ -119,6 +117,7 @@ from utilities.iterables import (
     unique_everseen,
 )
 from utilities.sentinel import Sentinel, sentinel
+from utilities.typing import is_sequence_of
 
 if TYPE_CHECKING:
     from collections.abc import Iterable, Iterator, Mapping, Sequence
@@ -609,11 +608,6 @@ class TestCmpNullable:
         assert result == expected
 
 
-class TestEnsureHashables:
-    def test_main(self) -> None:
-        assert ensure_hashables(1, 2, a=3, b=4) == ([1, 2], {"a": 3, "b": 4})
-
-
 class TestEnsureIterable:
     @mark.parametrize("obj", [param([]), param(()), param("")])
     def test_main(self, *, obj: Any) -> None:

{dycw_utilities-0.163.1 → dycw_utilities-0.164.1}/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.163.1 → dycw_utilities-0.164.1}/src/tests/test_orjson.py

@@ -50,7 +50,6 @@ from tests.test_typing_funcs.with_future import (
     DataClassFutureTypeLiteral,
     DataClassFutureTypeLiteralNullable,
 )
-from utilities.functions import is_sequence_of
 from utilities.hypothesis import (
     date_periods,
     dates,
@@ -86,7 +85,7 @@ from utilities.orjson import (
 from utilities.polars import check_polars_dataframe, zoned_date_time_dtype
 from utilities.sentinel import Sentinel, sentinel
 from utilities.types import LogLevel, MaybeIterable, PathLike
-from utilities.typing import get_args
+from utilities.typing import get_args, is_sequence_of
 from utilities.tzlocal import LOCAL_TIME_ZONE
 from utilities.whenever import (
     HOUR,