dycw-utilities 0.112.2__tar.gz → 0.112.3__tar.gz

{dycw_utilities-0.112.2 → dycw_utilities-0.112.3}/PKG-INFO

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

{dycw_utilities-0.112.2 → dycw_utilities-0.112.3}/pyproject.toml

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

{dycw_utilities-0.112.2 → dycw_utilities-0.112.3}/src/tests/test_typing.py

@@ -6,7 +6,7 @@ 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 typing import TYPE_CHECKING, Any, Final, Literal, NamedTuple, Self
 from uuid import UUID
 
 from hypothesis import given
@@ -56,6 +56,7 @@ from tests.test_typing_funcs.with_future import (
 from utilities.sentinel import Sentinel
 from utilities.types import Duration, LogLevel, Number, Parallelism, Seed
 from utilities.typing import (
+    IsInstanceGenError,
     IsSubclassGenError,
     _GetTypeClassesTupleError,
     _GetTypeClassesTypeError,
@@ -500,34 +501,57 @@ class TestIsInstanceGen:
     @given(
         data=data(),
         case=sampled_from([
+            # types - bool/int
             (booleans(), bool, None, True),
             (booleans(), int, None, False),
             (integers(), bool, None, False),
             (integers(), int, None, True),
             (booleans(), (bool, int), None, True),
             (integers(), (bool, int), None, True),
+            # types - datetime/date
             (dates(), dt.date, None, True),
             (dates(), dt.datetime, None, False),
             (datetimes(), dt.date, None, False),
             (datetimes(), dt.datetime, None, True),
+            # parent union
             (booleans(), Number, None, False),
             (integers(), Number, None, True),
             (floats(), Number, None, True),
-            (tuples(booleans()), (bool,), None, True),
-            (tuples(booleans()), (int,), None, False),
-            (tuples(integers()), (bool,), None, False),
-            (tuples(integers()), (int,), None, True),
-            (tuples(integers()), (int, int), None, False),
-            (integers(), int | None, None, True),
-            (integers() | none(), int, None, False),
-            (integers() | none(), int | None, None, True),
+            # child tuple/union - skip
+            # literals
             (sampled_from([1, 2]), Literal[1, 2, 3], 2, True),
             (sampled_from([1, 2, 3]), Literal[1, 2, 3], 3, True),
             (sampled_from([1, 2, 3]), Literal[1, 2], 3, False),
-            (booleans(), Literal[1, 2, 3], None, False),
+            (sampled_from([1, 2, 3]), int, 3, True),
             (sampled_from([1, 2, 3]), bool, 3, False),
-            (tuples(booleans()), Literal[1, 2, 3], None, False),
-            (sampled_from([1, 2, 3]), (bool,), 3, False),
+            (sampled_from(["1", "2", "3"]), str, 3, True),
+            (sampled_from(["1", "2", "3"]), bool, 3, False),
+            (sampled_from([1, "2", 3]), int | str, 3, True),
+            (sampled_from([1, "2", 3]), int, 3, False),
+            (sampled_from([1, "2", 3]), str, 3, False),
+            (booleans(), Literal[1, 2, 3], None, False),
+            # tuple types
+            (tuples(booleans()), tuple[bool], None, True),
+            (tuples(booleans()), tuple[int], None, False),
+            (tuples(integers()), tuple[bool], None, False),
+            (tuples(integers()), tuple[int], None, True),
+            (tuples(booleans()), tuple[Number], None, False),
+            (tuples(integers()), tuple[Number], None, True),
+            (tuples(floats()), tuple[Number], None, True),
+            (tuples(booleans()), bool, None, False),
+            (tuples(just("a"), booleans()), tuple[Literal["a"], bool], None, True),
+            (tuples(just("a"), booleans()), tuple[Literal["a"], int], None, False),
+            (tuples(just("a"), integers()), tuple[Literal["a"], bool], None, False),
+            (tuples(just("a"), integers()), tuple[Literal["a"], int], None, True),
+            (tuples(just("a"), booleans()), tuple[Literal["a", "b"], bool], None, True),
+            (tuples(just("a"), booleans()), tuple[Literal["a", "b"], int], None, False),
+            (
+                tuples(just("a"), integers()),
+                tuple[Literal["a", "b"], bool],
+                None,
+                False,
+            ),
+            (tuples(just("a"), integers()), tuple[Literal["a", "b"], int], None, True),
         ]),
     )
     def test_main(
@@ -560,6 +584,12 @@ class TestIsInstanceGen:
         assert not is_instance_gen(int_, MyInt)
         assert is_instance_gen(MyInt(int_), MyInt)
 
+    def test_error(self) -> None:
+        with raises(
+            IsInstanceGenError, match=r"Invalid arguments; got None and typing\.Final"
+        ):
+            _ = is_instance_gen(None, Final)
+
 
 class TestIsNamedTuple:
     def test_main(self) -> None:
@@ -581,34 +611,63 @@ class TestIsNamedTuple:
 class TestIsSubclassGen:
     @given(
         case=sampled_from([
+            # types - bool/int
             (bool, bool, True),
             (bool, int, False),
             (int, bool, False),
             (int, int, True),
             (bool, (bool, int), True),
             (int, (bool, int), True),
+            # types - datetime/date
             (dt.date, dt.date, True),
             (dt.date, dt.datetime, False),
             (dt.datetime, dt.date, False),
             (dt.datetime, dt.datetime, True),
+            # parent union
             (bool, Number, False),
             (int, Number, True),
             (float, Number, True),
-            ((bool,), (bool,), True),
-            ((bool,), (int,), False),
-            ((int,), (bool,), False),
-            ((int,), (int,), True),
-            ((int,), (int, int), False),
-            (int, int | None, True),
-            (int | None, int, False),
-            (int | None, int | None, True),
+            # child tuple
+            ((bool,), bool, True),
+            ((bool,), int, False),
+            ((int,), bool, False),
+            ((int,), int, True),
+            ((bool, int), int, False),
+            ((bool, int), (bool, int), True),
+            ((bool, int), (bool, int, float), True),
+            # child union
+            (bool, bool | None, True),
+            (bool | None, bool, False),
+            (bool | None, bool | None, True),
+            # literals
             (Literal[1, 2], Literal[1, 2, 3], True),
             (Literal[1, 2, 3], Literal[1, 2, 3], True),
             (Literal[1, 2, 3], Literal[1, 2], False),
-            (bool, Literal[1, 2, 3], False),
+            (Literal[1, 2, 3], int, True),
             (Literal[1, 2, 3], bool, False),
-            ((bool,), Literal[1, 2, 3], False),
-            (Literal[1, 2, 3], (bool,), False),
+            (Literal["1", "2", "3"], str, True),
+            (Literal["1", "2", "3"], bool, False),
+            (Literal[1, "2", 3], int | str, True),
+            (Literal[1, "2", 3], int, False),
+            (Literal[1, "2", 3], str, False),
+            (bool, Literal[1, 2, 3], False),
+            # tuple types
+            (tuple[bool], tuple[bool], True),
+            (tuple[bool], tuple[int], False),
+            (tuple[int], tuple[bool], False),
+            (tuple[int], tuple[int], True),
+            (tuple[bool], tuple[Number], False),
+            (tuple[int], tuple[Number], True),
+            (tuple[float], tuple[Number], True),
+            (tuple[bool], bool, False),
+            (tuple[Literal["a"], bool], tuple[Literal["a"], bool], True),
+            (tuple[Literal["a"], bool], tuple[Literal["a"], int], False),
+            (tuple[Literal["a"], int], tuple[Literal["a"], bool], False),
+            (tuple[Literal["a"], int], tuple[Literal["a"], int], True),
+            (tuple[Literal["a"], bool], tuple[Literal["a", "b"], bool], True),
+            (tuple[Literal["a"], bool], tuple[Literal["a", "b"], int], False),
+            (tuple[Literal["a"], int], tuple[Literal["a", "b"], bool], False),
+            (tuple[Literal["a"], int], tuple[Literal["a", "b"], int], True),
         ])
     )
     def test_main(self, *, case: tuple[type[Any], Any, bool]) -> None:

{dycw_utilities-0.112.2 → dycw_utilities-0.112.3}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.112.2"
+__version__ = "0.112.3"

{dycw_utilities-0.112.2 → dycw_utilities-0.112.3}/src/utilities/typing.py

@@ -230,21 +230,23 @@ def is_instance_gen(
 def is_instance_gen(obj: Any, type_: Any, /) -> bool: ...
 def is_instance_gen(obj: Any, type_: Any, /) -> bool:
     """Check if an instance relationship holds, except bool<int."""
-    if isinstance(obj, tuple) and isinstance(type_, tuple):
-        return _is_instance_gen_tuple(obj, type_)
+    # parent
+    if isinstance(type_, tuple):
+        return any(is_instance_gen(obj, t) for t in type_)
     if is_literal_type(type_):
-        return _is_instance_gen_literal(obj, type_)
-    return any(_is_instance_gen_type(obj, t) for t in get_type_classes(type_))
-
-
-def _is_instance_gen_tuple(obj: tuple[Any, ...], type_: tuple[Any, ...], /) -> bool:
-    return (len(obj) == len(type_)) and all(
-        is_instance_gen(o, t) for o, t in zip(obj, type_, strict=True)
-    )
-
-
-def _is_instance_gen_literal(obj: Any, type_: type[_T], /) -> TypeGuard[_T]:
-    return obj in get_args(type_)
+        return obj in get_args(type_)
+    if is_union_type(type_):
+        return any(is_instance_gen(obj, t) for t in get_args(type_))
+    # tuple vs tuple
+    if isinstance(obj, tuple) and is_tuple_type(type_):
+        type_args = get_args(type_)
+        return (len(obj) == len(type_args)) and all(
+            is_instance_gen(o, t) for o, t in zip(obj, type_args, strict=True)
+        )
+    # basic
+    if isinstance(type_, type):
+        return any(_is_instance_gen_type(obj, t) for t in get_type_classes(type_))
+    raise IsInstanceGenError(obj=obj, type_=type_)
 
 
 def _is_instance_gen_type(obj: Any, type_: type[_T], /) -> TypeGuard[_T]:
@@ -263,6 +265,16 @@ def _is_instance_gen_type(obj: Any, type_: type[_T], /) -> TypeGuard[_T]:
     )
 
 
+@dataclass(kw_only=True, slots=True)
+class IsInstanceGenError(Exception):
+    obj: Any
+    type_: Any
+
+    @override
+    def __str__(self) -> str:
+        return f"Invalid arguments; got {self.obj!r} and {self.type_!r}"
+
+
 ##
 
 
@@ -367,14 +379,32 @@ def is_subclass_gen(
 def is_subclass_gen(cls: Any, parent: Any, /) -> bool: ...
 def is_subclass_gen(cls: Any, parent: Any, /) -> bool:
     """Generalized `issubclass`."""
-    if isinstance(cls, tuple) and isinstance(parent, tuple):
-        return _is_subclass_gen_tuple(cls, parent)
-    if is_literal_type(cls) and is_literal_type(parent):
-        return _is_subclass_gen_literal(cls, parent)
-    if is_literal_type(cls) is not is_literal_type(parent):
-        return False
+    # child
+    if isinstance(cls, tuple):
+        return all(is_subclass_gen(c, parent) for c in cls)
+    if is_literal_type(cls):
+        types = tuple(map(type, get_args(cls)))
+        return (
+            is_literal_type(parent) and set(get_args(cls)).issubset(get_args(parent))
+        ) or is_subclass_gen(types, parent)
     if is_union_type(cls):
-        return _is_subclass_gen_union(cls, parent)
+        return all(is_subclass_gen(c, parent) for c in get_args(cls))
+    # parent
+    if isinstance(parent, tuple):
+        return any(is_subclass_gen(cls, p) for p in parent)
+    if is_literal_type(parent):
+        return is_literal_type(cls) and set(get_args(cls)).issubset(get_args(parent))
+    if is_union_type(parent):
+        return any(is_subclass_gen(cls, p) for p in get_args(parent))
+    # tuple vs tuple
+    if is_tuple_type(cls) and is_tuple_type(parent):
+        cls_args, parent_args = get_args(cls), get_args(parent)
+        return (len(cls_args) == len(parent_args)) and all(
+            is_subclass_gen(c, p) for c, p in zip(cls_args, parent_args, strict=True)
+        )
+    if is_tuple_type(cls) is not is_tuple_type(parent):
+        return False
+    # basic
     if isinstance(cls, type):
         return any(_is_subclass_gen_type(cls, p) for p in get_type_classes(parent))
     raise IsSubclassGenError(cls=cls)
@@ -396,20 +426,6 @@ def _is_subclass_gen_type(cls: type[Any], parent: type[_T], /) -> TypeGuard[type
     )
 
 
-def _is_subclass_gen_tuple(cls: tuple[Any, ...], parent: tuple[Any, ...], /) -> bool:
-    return (len(cls) == len(parent)) and all(
-        is_subclass_gen(c, p) for c, p in zip(cls, parent, strict=True)
-    )
-
-
-def _is_subclass_gen_literal(cls: Any, parent: Any, /) -> bool:
-    return set(get_args(cls)).issubset(get_args(parent))
-
-
-def _is_subclass_gen_union(cls: Any, parent: Any, /) -> bool:
-    return all(is_subclass_gen(a, parent) for a in get_args(cls))
-
-
 @dataclass(kw_only=True, slots=True)
 class IsSubclassGenError(Exception):
     cls: Any
@@ -449,6 +465,7 @@ def _is_annotation_of_type(obj: Any, origin: Any, /) -> bool:
 __all__ = [
     "GetTypeClassesError",
     "GetUnionTypeClassesError",
+    "IsInstanceGenError",
     "IsSubclassGenError",
     "contains_self",
     "get_literal_elements",