dycw-utilities 0.110.6__tar.gz → 0.110.8__tar.gz

{dycw_utilities-0.110.6 → dycw_utilities-0.110.8}/PKG-INFO

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

{dycw_utilities-0.110.6 → dycw_utilities-0.110.8}/pyproject.toml

@@ -94,7 +94,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.110.6"
+version = "0.110.8"
 
 [project.optional-dependencies]
 test = [
@@ -337,7 +337,7 @@ zzz-test-zoneinfo = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.110.6"
+current_version = "0.110.8"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.110.6 → dycw_utilities-0.110.8}/src/tests/test_functions.py

@@ -12,6 +12,7 @@ from typing import TYPE_CHECKING, Any, ClassVar, ParamSpec, TypeVar, cast
 from hypothesis import given
 from hypothesis.strategies import (
     DataObject,
+    SearchStrategy,
     booleans,
     builds,
     data,
@@ -73,7 +74,7 @@ from utilities.functions import (
     is_dataclass_class,
     is_dataclass_instance,
     is_hashable,
-    is_instance_int_not_bool,
+    is_instance_not_bool_int,
     is_iterable_of,
     is_none,
     is_not_none,
@@ -82,7 +83,7 @@ from utilities.functions import (
     is_sized,
     is_sized_not_str,
     is_string_mapping,
-    is_subclass_int_not_bool,
+    is_subclass_not_bool_int,
     is_tuple,
     is_tuple_or_str_mapping,
     make_isinstance,
@@ -621,14 +622,37 @@ class TestIsHashable:
         assert is_hashable(obj) is expected
 
 
-class TestIsInstanceIntNotBool:
-    @given(int_=integers())
-    def test_int(self, *, int_: int) -> None:
-        assert is_instance_int_not_bool(int_)
+class TestIsInstanceNotIntBool:
+    @given(
+        data=data(),
+        case=sampled_from([
+            (booleans(), bool, True),
+            (booleans(), int, False),
+            (integers(), bool, False),
+            (integers(), int, True),
+            (booleans(), (bool, int), True),
+            (integers(), (bool, int), True),
+        ]),
+    )
+    def test_main(
+        self, *, data: DataObject, case: tuple[SearchStrategy[Any], type[Any], bool]
+    ) -> None:
+        strategy, type_, expected = case
+        value = data.draw(strategy)
+        assert is_instance_not_bool_int(value, type_) is expected
 
     @given(bool_=booleans())
-    def test_bool(self, *, bool_: bool) -> None:
-        assert not is_instance_int_not_bool(bool_)
+    def test_bool_value_vs_custom_int(self, *, bool_: bool) -> None:
+        class MyInt(int): ...
+
+        assert not is_instance_not_bool_int(bool_, MyInt)
+
+    @given(int_=integers())
+    def test_int_value_vs_custom_int(self, *, int_: int) -> None:
+        class MyInt(int): ...
+
+        assert not is_instance_not_bool_int(int_, MyInt)
+        assert is_instance_not_bool_int(MyInt(int_), MyInt)
 
 
 class TestIsIterableOf:
@@ -751,11 +775,29 @@ class TestIsStringMapping:
         assert result is expected
 
 
-class TestIsSubclassIntNotBool:
-    @given(case=sampled_from([(int, True), (bool, False)]))
-    def test_main(self, *, case: tuple[type[Any], bool]) -> None:
-        type_, expected = case
-        assert is_subclass_int_not_bool(type_) is expected
+class TestIsSubclassNotBoolInt:
+    @given(
+        case=sampled_from([
+            (bool, bool, True),
+            (bool, int, False),
+            (int, bool, False),
+            (int, int, True),
+            (bool, (bool, int), True),
+            (int, (bool, int), True),
+        ])
+    )
+    def test_main(self, *, case: tuple[type[Any], type[Any], bool]) -> None:
+        child, parent, expected = case
+        assert is_subclass_not_bool_int(child, parent) is expected
+
+    def test_custom_int(self) -> None:
+        class MyInt(int): ...
+
+        assert not is_subclass_not_bool_int(bool, MyInt)
+        assert not is_subclass_not_bool_int(MyInt, bool)
+        assert not is_subclass_not_bool_int(int, MyInt)
+        assert is_subclass_not_bool_int(MyInt, int)
+        assert is_subclass_not_bool_int(MyInt, MyInt)
 
 
 class TestIsTuple:

{dycw_utilities-0.110.6 → dycw_utilities-0.110.8}/src/tests/test_typing.py

@@ -4,6 +4,7 @@ import datetime as dt
 from collections.abc import Mapping, Sequence
 from dataclasses import dataclass
 from pathlib import Path
+from random import Random
 from types import NoneType
 from typing import TYPE_CHECKING, Any, Literal, NamedTuple, Self
 from uuid import UUID
@@ -39,12 +40,15 @@ from tests.test_typing_funcs.with_future import (
     TrueOrFalseFutureTypeLit,
 )
 from utilities.sentinel import Sentinel
-from utilities.types import LogLevel, Parallelism
+from utilities.types import Duration, LogLevel, Number, Parallelism, Seed
 from utilities.typing import (
+    _GetUnionTypeClassesNotATypeError,
+    _GetUnionTypeClassesNotAUnionTypeError,
     contains_self,
     get_args,
     get_literal_elements,
     get_type_hints,
+    get_union_type_classes,
     is_dict_type,
     is_frozenset_type,
     is_list_type,
@@ -335,6 +339,34 @@ class TestGetTypeHints:
             _ = get_type_hints(Outer, warn_name_errors=True)
 
 
+class TestGetUnionTypeClasses:
+    @given(
+        case=sampled_from([
+            (Duration, (int, float, dt.timedelta)),
+            (Number, (int, float)),
+            (Seed, (int, float, str, bytes, bytearray, Random)),
+        ])
+    )
+    def test_main(self, *, case: tuple[Any, tuple[type[Any], ...]]) -> None:
+        obj, expected = case
+        result = get_union_type_classes(obj)
+        assert result == expected
+
+    def test_error_not_a_union_type(self) -> None:
+        with raises(
+            _GetUnionTypeClassesNotAUnionTypeError,
+            match="Object must be a Union type; got None",
+        ):
+            _ = get_union_type_classes(None)
+
+    def test_error_not_a_type(self) -> None:
+        with raises(
+            _GetUnionTypeClassesNotATypeError,
+            match=r"Union type must contain types only; got typing\.Literal\[True\]",
+        ):
+            _ = get_union_type_classes(Literal[True] | None)
+
+
 class TestIsAnnotationOfType:
     @mark.parametrize(
         ("func", "obj", "expected"),

{dycw_utilities-0.110.6 → dycw_utilities-0.110.8}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.110.6"
+__version__ = "0.110.8"

{dycw_utilities-0.110.6 → dycw_utilities-0.110.8}/src/utilities/functions.py

@@ -22,6 +22,7 @@ from typing import (
     Literal,
     TypeGuard,
     TypeVar,
+    assert_never,
     cast,
     overload,
     override,
@@ -182,6 +183,8 @@ def ensure_class(
     *,
     nullable: Literal[False] = False,
 ) -> _T1 | _T2 | _T3 | _T4 | _T5: ...
+@overload
+def ensure_class(obj: Any, cls: TypeLike[_T], /, *, nullable: bool = False) -> Any: ...
 def ensure_class(obj: Any, cls: TypeLike[_T], /, *, nullable: bool = False) -> Any:
     """Ensure an object is of the required class."""
     if isinstance(obj, cls) or ((obj is None) and nullable):
@@ -657,9 +660,23 @@ def is_hashable(obj: Any, /) -> TypeGuard[Hashable]:
 ##
 
 
-def is_instance_int_not_bool(obj: Any, /) -> TypeGuard[int]:
-    """Check if an object is an integer, and not a boolean."""
-    return isinstance(obj, int) and not isinstance(obj, bool)
+def is_instance_not_bool_int(
+    obj: Any, class_or_tuple: TypeLike[Any], /
+) -> TypeGuard[int]:
+    """Check if an instance relationship holds, except bool<int."""
+    match class_or_tuple:
+        case type() as type_:
+            return _is_instance_not_bool_int(obj, type_)
+        case tuple() as types:
+            return any(_is_instance_not_bool_int(obj, p) for p in types)
+        case _ as never:
+            assert_never(never)
+
+
+def _is_instance_not_bool_int(obj: Any, type_: type[Any], /) -> bool:
+    return isinstance(obj, type_) and not (
+        isinstance(obj, bool) and issubclass(type_, int) and not issubclass(type_, bool)
+    )
 
 
 ##
@@ -779,9 +796,23 @@ def is_string_mapping(obj: Any, /) -> TypeGuard[StrMapping]:
 ##
 
 
-def is_subclass_int_not_bool(cls: type[Any], /) -> TypeGuard[type[int]]:
-    """Check if a class is an integer, and not a boolean."""
-    return issubclass(cls, int) and not issubclass(cls, bool)
+def is_subclass_not_bool_int(cls: type[Any], class_or_tuple: TypeLike[Any], /) -> bool:
+    """Check if a subclass relationship holds, except bool<int."""
+    match class_or_tuple:
+        case type() as parent:
+            return _is_subclass_int_not_bool_one(cls, parent)
+        case tuple() as parents:
+            return any(_is_subclass_int_not_bool_one(cls, p) for p in parents)
+        case _ as never:
+            assert_never(never)
+
+
+def _is_subclass_int_not_bool_one(cls: type[Any], parent: type[Any], /) -> bool:
+    return issubclass(cls, parent) and not (
+        issubclass(cls, bool)
+        and issubclass(parent, int)
+        and not issubclass(parent, bool)
+    )
 
 
 ##
@@ -1044,7 +1075,7 @@ __all__ = [
     "is_dataclass_class",
     "is_dataclass_instance",
     "is_hashable",
-    "is_instance_int_not_bool",
+    "is_instance_not_bool_int",
     "is_iterable_of",
     "is_none",
     "is_not_none",
@@ -1052,7 +1083,7 @@ __all__ = [
     "is_sized",
     "is_sized_not_str",
     "is_string_mapping",
-    "is_subclass_int_not_bool",
+    "is_subclass_not_bool_int",
     "is_tuple",
     "is_tuple_or_str_mapping",
     "make_isinstance",

{dycw_utilities-0.110.6 → dycw_utilities-0.110.8}/src/utilities/parse.py

@@ -14,7 +14,7 @@ from utilities.datetime import (
     is_subclass_date_not_datetime,
 )
 from utilities.enum import ParseEnumError, parse_enum
-from utilities.functions import is_subclass_int_not_bool
+from utilities.functions import is_subclass_not_bool_int
 from utilities.iterables import OneEmptyError, OneNonUniqueError, one, one_str
 from utilities.math import ParseNumberError, parse_number
 from utilities.re import ExtractGroupError, extract_group
@@ -174,7 +174,7 @@ def _parse_object_type(
             return parse_bool(text)
         except ParseBoolError:
             raise _ParseObjectParseError(type_=cls, text=text) from None
-    if is_subclass_int_not_bool(cls):
+    if is_subclass_not_bool_int(cls, int):
         try:
             return int(text)
         except ValueError:

{dycw_utilities-0.110.6 → dycw_utilities-0.110.8}/src/utilities/typing.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import datetime as dt
 from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
 from itertools import chain
 from pathlib import Path
 from types import NoneType, UnionType
@@ -15,6 +16,7 @@ from typing import (
     TypeGuard,
     Union,  # pyright: ignore[reportDeprecated]
     get_origin,
+    override,
 )
 from typing import get_args as _get_args
 from typing import get_type_hints as _get_type_hints
@@ -64,7 +66,7 @@ def _get_literal_elements_inner(obj: Any, /) -> list[Any]:
 
 
 def get_type_hints(
-    cls: Any,
+    obj: Any,
     /,
     *,
     globalns: StrMapping | None = None,
@@ -72,15 +74,15 @@ def get_type_hints(
     warn_name_errors: bool = False,
 ) -> dict[str, Any]:
     """Get the type hints of an object."""
-    result: dict[str, Any] = cls.__annotations__
+    result: dict[str, Any] = obj.__annotations__
     _ = {Literal, Path, Sentinel, StrMapping, UUID, dt}
     globalns_use = globals() | ({} if globalns is None else dict(globalns))
     localns_use = {} if localns is None else dict(localns)
     try:
-        hints = _get_type_hints(cls, globalns=globalns_use, localns=localns_use)
+        hints = _get_type_hints(obj, globalns=globalns_use, localns=localns_use)
     except NameError as error:
         if warn_name_errors:
-            warn(f"Error getting type hints for {cls!r}; {error}", stacklevel=2)
+            warn(f"Error getting type hints for {obj!r}; {error}", stacklevel=2)
     else:
         result.update({
             key: value
@@ -93,6 +95,44 @@ def get_type_hints(
 ##
 
 
+def get_union_type_classes(obj: Any, /) -> tuple[type[Any], ...]:
+    if not is_union_type(obj):
+        raise _GetUnionTypeClassesNotAUnionTypeError(obj=obj)
+    types_: Sequence[type[Any]] = []
+    for arg in get_args(obj):
+        if isinstance(arg, type):
+            types_.append(arg)
+        elif is_union_type(arg):
+            types_.extend(get_union_type_classes(arg))
+        else:
+            raise _GetUnionTypeClassesNotATypeError(obj=obj, inner=arg)
+    return tuple(types_)
+
+
+@dataclass(kw_only=True, slots=True)
+class GetUnionTypeClassesError(Exception):
+    obj: Any
+
+
+@dataclass(kw_only=True, slots=True)
+class _GetUnionTypeClassesNotAUnionTypeError(GetUnionTypeClassesError):
+    @override
+    def __str__(self) -> str:
+        return f"Object must be a Union type; got {self.obj}"
+
+
+@dataclass(kw_only=True, slots=True)
+class _GetUnionTypeClassesNotATypeError(GetUnionTypeClassesError):
+    inner: Any
+
+    @override
+    def __str__(self) -> str:
+        return f"Union type must contain types only; got {self.inner}"
+
+
+##
+
+
 def is_dict_type(obj: Any, /) -> bool:
     """Check if an object is a dict type annotation."""
     return _is_annotation_of_type(obj, dict)
@@ -207,9 +247,11 @@ def _is_annotation_of_type(obj: Any, origin: Any, /) -> bool:
 
 
 __all__ = [
+    "GetUnionTypeClassesError",
     "contains_self",
     "get_literal_elements",
     "get_type_hints",
+    "get_union_type_classes",
     "is_dict_type",
     "is_frozenset_type",
     "is_list_type",