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

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

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

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

@@ -232,7 +232,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.163.1"
+version = "0.164.0"
 
 [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.0"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.163.1 → dycw_utilities-0.164.0}/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.0}/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.0}/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,

{dycw_utilities-0.163.1 → dycw_utilities-0.164.0}/src/tests/test_typing.py

@@ -6,7 +6,15 @@ from dataclasses import dataclass
 from pathlib import Path
 from random import Random
 from types import NoneType
-from typing import TYPE_CHECKING, Any, Final, Literal, NamedTuple
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Final,
+    Literal,
+    NamedTuple,
+    TypedDict,
+    assert_never,
+)
 from uuid import UUID
 
 import whenever
@@ -71,6 +79,7 @@ from tests.test_typing_funcs.with_future import (
     DataClassFutureZonedDateTimePeriod,
     TrueOrFalseFutureLit,
     TrueOrFalseFutureTypeLit,
+    TypedDictFutureIntFloat,
 )
 from utilities.hypothesis import text_ascii
 from utilities.sentinel import Sentinel
@@ -87,20 +96,29 @@ from utilities.typing import (
     get_type_classes,
     get_type_hints,
     get_union_type_classes,
+    is_dataclass_class,
+    is_dataclass_instance,
     is_dict_type,
     is_frozenset_type,
     is_instance_gen,
+    is_iterable_of,
     is_list_type,
     is_literal_type,
     is_mapping_type,
     is_namedtuple_class,
     is_namedtuple_instance,
     is_optional_type,
+    is_sequence_of,
+    is_sequence_of_tuple_or_str_mapping,
     is_sequence_type,
     is_set_type,
+    is_string_mapping,
     is_subclass_gen,
+    is_tuple,
+    is_tuple_or_str_mapping,
     is_tuple_type,
     is_union_type,
+    make_isinstance,
 )
 from utilities.whenever import DatePeriod, TimePeriod, ZonedDateTimePeriod
 
@@ -149,16 +167,16 @@ type _TruthAndTrueAndFalse = _True | _TrueAndFalse
 
 
 class TestGetLiteralElements:
-    @given(
-        case=sampled_from([
-            (_PlusOrMinusOneLit, [1, -1]),
-            (_TruthLit, ["true", "false"]),
-            (_TrueAndFalse, ["true", "false"]),
-            (_TruthAndTrueAndFalse, ["true", "false"]),
-        ])
+    @mark.parametrize(
+        ("obj", "expected"),
+        [
+            param(_PlusOrMinusOneLit, [1, -1]),
+            param(_TruthLit, ["true", "false"]),
+            param(_TrueAndFalse, ["true", "false"]),
+            param(_TruthAndTrueAndFalse, ["true", "false"]),
+        ],
     )
-    def test_main(self, *, case: tuple[Any, list[Any]]) -> None:
-        obj, expected = case
+    def test_main(self, *, obj: Any, expected: list[Any]) -> None:
         result = get_literal_elements(obj)
         assert result == expected
 
@@ -477,6 +495,15 @@ class TestGetTypeHints:
         expected = {"truth": TrueOrFalseFutureTypeLit}
         assert hints == expected
 
+    def test_typed_dict(self) -> None:
+        class Example(TypedDict):
+            int_: int
+            float_: float
+
+        hints = get_type_hints(Example)
+        expected = {"int_": int, "float_": float}
+        assert hints == expected
+
     @given(data=data())
     def test_uuid(self, *, data: DataObject) -> None:
         @dataclass(kw_only=True, slots=True)
@@ -647,6 +674,34 @@ class TestIsAnnotationOfType:
         assert func(obj) is expected
 
 
+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())
+
+    @mark.parametrize("obj", [param(None), param(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())
+
+    @mark.parametrize("obj", [param(None), param(type(None))])
+    def test_others(self, *, obj: Any) -> None:
+        assert not is_dataclass_instance(obj)
+
+
 class TestIsInstanceGen:
     @given(data=data())
     @mark.parametrize(
@@ -739,6 +794,8 @@ class TestIsInstanceGen:
                     sets(strategy, min_size=10 if min_size is None else min_size)
                 )
                 assert not all(is_instance_gen(v, type_) for v in values)
+            case never:
+                assert_never(never)
 
     @given(bool_=booleans())
     def test_bool_value_vs_custom_int(self, *, bool_: bool) -> None:
@@ -753,6 +810,24 @@ class TestIsInstanceGen:
         assert not is_instance_gen(int_, MyInt)
         assert is_instance_gen(MyInt(int_), MyInt)
 
+    @mark.parametrize(
+        ("obj", "expected"),
+        [
+            param(None, False),
+            param({}, False),
+            param({None: False}, False),
+            param({"int_": None}, False),
+            param({"int_": None, "float_": None}, False),
+            param({"int_": 0, "float_": None}, False),
+            param({"int_": None, "float_": 0.0}, False),
+            param({"int_": 0, "float_": 0.0}, True),
+            param({"int_": 0, "float_": 0.0, "extra": None}, True),
+        ],
+    )
+    def test_typed_dict(self, *, obj: Any, expected: bool) -> None:
+        result = is_instance_gen(obj, TypedDictFutureIntFloat)
+        assert result is expected
+
     def test_error(self) -> None:
         with raises(
             IsInstanceGenError,
@@ -761,6 +836,37 @@ class TestIsInstanceGen:
             _ = is_instance_gen(None, Final)
 
 
+class TestIsIterableOf:
+    @mark.parametrize(
+        ("obj", "expected"),
+        [
+            param([0], True),
+            param(["0"], False),
+            param({0}, True),
+            param({0: 0}, True),
+            param(None, False),
+            param([None], False),
+        ],
+    )
+    def test_single(self, *, obj: Any, expected: bool) -> None:
+        result = is_iterable_of(obj, int)
+        assert result is expected
+
+    @mark.parametrize(
+        ("obj", "expected"),
+        [
+            param([0], True),
+            param(["0"], True),
+            param([0, "0"], True),
+            param(None, False),
+            param([None], False),
+        ],
+    )
+    def test_multiple(self, *, obj: Any, expected: bool) -> None:
+        result = is_iterable_of(obj, (int, str))
+        assert result is expected
+
+
 class TestIsNamedTuple:
     def test_main(self) -> None:
         class Example(NamedTuple):
@@ -778,6 +884,66 @@ class TestIsNamedTuple:
         assert not is_namedtuple_instance(Example(x=0))
 
 
+class TestIsSequenceOf:
+    @mark.parametrize(
+        ("obj", "expected"),
+        [
+            param([0], True),
+            param(["0"], False),
+            param({0}, False),
+            param({0: 0}, False),
+            param(None, False),
+            param([None], False),
+        ],
+    )
+    def test_single(self, *, obj: Any, expected: bool) -> None:
+        result = is_sequence_of(obj, int)
+        assert result is expected
+
+    @mark.parametrize(
+        ("obj", "expected"),
+        [
+            param([0], True),
+            param(["0"], True),
+            param([0, "0"], True),
+            param(None, False),
+            param([None], False),
+        ],
+    )
+    def test_multiple(self, *, obj: Any, expected: bool) -> None:
+        result = is_sequence_of(obj, (int, str))
+        assert result is expected
+
+
+class TestIsSequenceOfTupleOrStrMapping:
+    @mark.parametrize(
+        ("obj", "expected"),
+        [
+            param(None, False),
+            param([(1, 2, 3)], True),
+            param([{"a": 1, "b": 2, "c": 3}], True),
+            param([(1, 2, 3), {"a": 1, "b": 2, "c": 3}], True),
+        ],
+    )
+    def test_main(self, *, obj: Any, expected: bool) -> None:
+        result = is_sequence_of_tuple_or_str_mapping(obj)
+        assert result is expected
+
+
+class TestIsStringMapping:
+    @mark.parametrize(
+        ("obj", "expected"),
+        [
+            param(None, False),
+            param({"a": 1, "b": 2, "c": 3}, True),
+            param({1: "a", 2: "b", 3: "c"}, False),
+        ],
+    )
+    def test_main(self, *, obj: Any, expected: bool) -> None:
+        result = is_string_mapping(obj)
+        assert result is expected
+
+
 class TestIsSubclassGen:
     @mark.parametrize(
         ("child", "parent", "expected"),
@@ -867,3 +1033,55 @@ class TestIsSubclassGen:
             match="Argument must be a class; got None of type <class 'NoneType'>",
         ):
             _ = is_subclass_gen(None, NoneType)
+
+
+class TestIsTuple:
+    @mark.parametrize(
+        ("obj", "expected"),
+        [param(None, False), param((1, 2, 3), True), param([1, 2, 3], False)],
+    )
+    def test_main(self, *, obj: Any, expected: bool) -> None:
+        result = is_tuple(obj)
+        assert result is expected
+
+
+class TestIsTupleOrStringMapping:
+    @mark.parametrize(
+        ("obj", "expected"),
+        [
+            param(None, False),
+            param((1, 2, 3), True),
+            param({"a": 1, "b": 2, "c": 3}, True),
+            param({1: "a", 2: "b", 3: "c"}, False),
+        ],
+    )
+    def test_main(self, *, obj: Any, expected: bool) -> None:
+        result = is_tuple_or_str_mapping(obj)
+        assert result is expected
+
+
+class TestMakeIsInstance:
+    @mark.parametrize(
+        ("obj", "expected"), [param(True, True), param(False, True), param(None, False)]
+    )
+    def test_single(self, *, obj: bool | None, expected: bool) -> None:
+        func = make_isinstance(bool)
+        result = func(obj)
+        assert result is expected
+
+    @mark.parametrize(
+        ("obj", "expected"), [param(0, True), param("0", True), param(None, False)]
+    )
+    def test_multiple(self, *, obj: bool | None, expected: bool) -> None:
+        func = make_isinstance((int, str))
+        result = func(obj)
+        assert result is expected
+
+    @mark.parametrize(
+        ("obj", "expected"),
+        [param(None, False), param({"int_": 0, "float_": 0.0}, True)],
+    )
+    def test_typed_dict(self, *, obj: Any, expected: float) -> None:
+        func = make_isinstance(TypedDictFutureIntFloat)
+        result = func(obj)
+        assert result is expected