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

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

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

{dycw_utilities-0.112.1 → 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.1"
+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.1"
+current_version = "0.112.3"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.112.1 → dycw_utilities-0.112.3}/src/tests/test_dataclasses.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from pathlib import Path
 from types import NoneType
-from typing import Any, cast, override
+from typing import Any, Literal, cast, override
 
 from hypothesis import given
 from hypothesis.strategies import booleans, integers, lists, sampled_from
@@ -406,7 +406,18 @@ class TestSerializeAndParseDataClass:
         assert result == obj
 
     @given(int_=integers())
-    def test_extra_type(self, *, int_: int) -> None:
+    def test_literal_type(self, *, int_: int) -> None:
+        obj = DataClassFutureInt(int_=int_)
+        serialized = serialize_dataclass(obj)
+        result = parse_dataclass(
+            serialized,
+            DataClassFutureInt,
+            extra_parsers={Literal["lit"]: NotImplementedError},
+        )
+        assert result == obj
+
+    @given(int_=integers())
+    def test_type_extra(self, *, int_: int) -> None:
         obj = DataClassFutureNestedOuterFirstOuter(
             inner=DataClassFutureNestedOuterFirstInner(int_=int_)
         )
@@ -625,9 +636,8 @@ class TestYieldFields:
         assert result == expected
         assert is_optional_type(result.type_)
         args = get_args(result.type_)
-        assert args == (TrueOrFalseFutureLit,)
-        arg = one(args)
-        assert get_args(arg) == ("true", "false")
+        assert args == (TrueOrFalseFutureLit, NoneType)
+        assert get_args(args[0]) == ("true", "false")
 
     def test_class_future_nested(self) -> None:
         result = one(
@@ -665,9 +675,8 @@ class TestYieldFields:
         assert result == expected
         assert is_optional_type(result.type_)
         args = get_args(result.type_)
-        assert args == (TrueOrFalseFutureTypeLit,)
-        arg = one(args)
-        assert get_args(arg) == ("true", "false")
+        assert args == (TrueOrFalseFutureTypeLit, NoneType)
+        assert get_args(args[0]) == ("true", "false")
 
     def test_class_orjson_log_record(self) -> None:
         result = list(yield_fields(OrjsonLogRecord, globalns=globals()))

{dycw_utilities-0.112.1 → dycw_utilities-0.112.3}/src/tests/test_parse.py

@@ -57,6 +57,7 @@ from utilities.parse import (
     serialize_object,
 )
 from utilities.sentinel import Sentinel, sentinel
+from utilities.text import parse_bool
 from utilities.types import Duration, Number
 from utilities.version import Version
 
@@ -98,28 +99,17 @@ class TestSerializeAndParseObject:
         result = parse_object(TruthEnum, serialized)
         assert result is truth
 
-    @given(int_=integers())
-    def test_extra_type(self, *, int_: int) -> None:
-        serialized = serialize_object(int_)
-        result = parse_object(
-            DataClassFutureInt,
-            serialized,
-            extra={DataClassFutureInt: lambda text: DataClassFutureInt(int_=int(text))},
-        )
-        expected = DataClassFutureInt(int_=int_)
-        assert result == expected
-
     @given(float_=floats())
     def test_float(self, *, float_: float) -> None:
         serialized = serialize_object(float_)
         result = parse_object(float, serialized)
         assert is_equal(result, float_)
 
-    @given(values=frozensets(dates()))
-    def test_frozenset(self, *, values: frozenset[dt.date]) -> None:
-        serialized = serialize_object(values)
+    @given(dates=frozensets(dates()))
+    def test_frozenset(self, *, dates: frozenset[dt.date]) -> None:
+        serialized = serialize_object(dates)
         result = parse_object(frozenset[dt.date], serialized)
-        assert result == values
+        assert result == dates
 
     @given(int_=integers())
     def test_int(self, *, int_: int) -> None:
@@ -127,11 +117,17 @@ class TestSerializeAndParseObject:
         result = parse_object(int, serialized)
         assert result == int_
 
-    @given(values=lists(dates()))
-    def test_list(self, *, values: list[dt.date]) -> None:
-        serialized = serialize_object(values)
+    @given(dates=lists(dates()))
+    def test_list(self, *, dates: list[dt.date]) -> None:
+        serialized = serialize_object(dates)
         result = parse_object(list[dt.date], serialized)
-        assert result == values
+        assert result == dates
+
+    @given(bool_=booleans())
+    def test_literal_extra(self, *, bool_: bool) -> None:
+        text = serialize_object(bool_)
+        result = parse_object(bool, text, extra={Literal["lit"]: parse_bool})
+        assert result is bool_
 
     @given(truth=sampled_from(["true", "false"]))
     def test_literal(self, *, truth: Literal["true", "false"]) -> None:
@@ -205,11 +201,11 @@ class TestSerializeAndParseObject:
         result = parse_object(Sentinel, serialized)
         assert result is sentinel
 
-    @given(values=sets(dates()))
-    def test_set(self, *, values: set[dt.date]) -> None:
-        serialized = serialize_object(values)
+    @given(dates=sets(dates()))
+    def test_set(self, *, dates: set[dt.date]) -> None:
+        serialized = serialize_object(dates)
         result = parse_object(set[dt.date], serialized)
-        assert result == values
+        assert result == dates
 
     @given(serialized=text_ascii())
     def test_to_serialized(self, *, serialized: str) -> None:
@@ -234,6 +230,17 @@ class TestSerializeAndParseObject:
         result = parse_object(tuple[int, int], serialized)
         assert result == (x, y)
 
+    @given(int_=integers())
+    def test_type_extra(self, *, int_: int) -> None:
+        serialized = serialize_object(int_)
+        result = parse_object(
+            DataClassFutureInt,
+            serialized,
+            extra={DataClassFutureInt: lambda text: DataClassFutureInt(int_=int(text))},
+        )
+        expected = DataClassFutureInt(int_=int_)
+        assert result == expected
+
     @given(truth=sampled_from(["true", "false"]))
     def test_type_literal(self, *, truth: Literal["true", "false"]) -> None:
         result = parse_object(TrueOrFalseFutureTypeLit, truth)

{dycw_utilities-0.112.1 → dycw_utilities-0.112.3}/src/tests/test_sentinel.py

@@ -26,11 +26,12 @@ class TestParseSentinel:
         result = parse_sentinel(text_use)
         assert result is sentinel
 
-    def test_error(self) -> None:
+    @given(text=sampled_from(["invalid", "ssentinell"]))
+    def test_error(self, *, text: str) -> None:
         with raises(
-            ParseSentinelError, match="Unable to parse sentinel value; got 'invalid'"
+            ParseSentinelError, match="Unable to parse sentinel value; got '.*'"
         ):
-            _ = parse_sentinel("invalid")
+            _ = parse_sentinel(text)
 
 
 class TestSentinel:

{dycw_utilities-0.112.1 → dycw_utilities-0.112.3}/src/tests/test_text.py

@@ -51,11 +51,10 @@ class TestParseBool:
         result = parse_bool(text_use)
         assert result is value
 
-    def test_error(self) -> None:
-        with raises(
-            ParseBoolError, match="Unable to parse boolean value; got 'invalid'"
-        ):
-            _ = parse_bool("invalid")
+    @given(text=sampled_from(["invalid", "11", "00", "ttruee", "ffalsee"]))
+    def test_error(self, *, text: str) -> None:
+        with raises(ParseBoolError, match="Unable to parse boolean value; got '.*'"):
+            _ = parse_bool(text)
 
 
 class TestParseNone:
@@ -66,9 +65,10 @@ class TestParseNone:
         result = parse_none(text_use)
         assert result is None
 
-    def test_error(self) -> None:
-        with raises(ParseNoneError, match="Unable to parse null value; got 'invalid'"):
-            _ = parse_none("invalid")
+    @given(text=sampled_from(["invalid", "nnonee"]))
+    def test_error(self, *, text: str) -> None:
+        with raises(ParseNoneError, match="Unable to parse null value; got '.*'"):
+            _ = parse_none(text)
 
 
 class TestReprEncode:

{dycw_utilities-0.112.1 → 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
@@ -22,8 +22,10 @@ from hypothesis.strategies import (
     just,
     none,
     sampled_from,
+    sets,
+    tuples,
 )
-from pytest import mark, param, raises
+from pytest import raises
 
 from tests.test_typing_funcs.no_future import (
     DataClassNoFutureNestedInnerFirstInner,
@@ -54,6 +56,8 @@ 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,
     _GetUnionTypeClassesInternalTypeError,
@@ -85,32 +89,40 @@ if TYPE_CHECKING:
 
 
 class TestContainsSelf:
-    @mark.parametrize("obj", [param(Self), param(Self | None)])
+    @given(obj=sampled_from([Self, Self | None]))
     def test_main(self, *, obj: Any) -> None:
         assert contains_self(obj)
 
 
 class TestGetArgs:
-    @mark.parametrize(
-        ("obj", "expected"),
-        [
-            param(dict[int, int], (int, int)),
-            param(frozenset[int], (int,)),
-            param(int | None, (int,)),
-            param(int | str, (int, str)),
-            param(list[int], (int,)),
-            param(Literal["a", "b", "c"], ("a", "b", "c")),
-            param(Mapping[int, int], (int, int)),
-            param(Sequence[int], (int,)),
-            param(set[int], (int,)),
-            param(LogLevel, ("DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL")),
-            param(Parallelism, ("processes", "threads")),
-        ],
+    @given(
+        case=sampled_from([
+            (dict[int, int], (int, int)),
+            (frozenset[int], (int,)),
+            (int | None, (int, NoneType)),
+            (int | str, (int, str)),
+            (list[int], (int,)),
+            (Literal["a", "b", "c"], ("a", "b", "c")),
+            (Mapping[int, int], (int, int)),
+            (Sequence[int], (int,)),
+            (set[int], (int,)),
+            (LogLevel, ("DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL")),
+            (Parallelism, ("processes", "threads")),
+        ])
     )
-    def test_main(self, *, obj: Any, expected: tuple[Any, ...]) -> None:
+    def test_main(self, *, case: tuple[Any, tuple[Any, ...]]) -> None:
+        obj, expected = case
         result = get_args(obj)
         assert result == expected
 
+    @given(case=sampled_from([(int | None, (int,)), (int | str | None, (int, str))]))
+    def test_optional_drop_none(
+        self, *, case: tuple[Any, tuple[type[Any], ...]]
+    ) -> None:
+        obj, expected = case
+        result = get_args(obj, optional_drop_none=True)
+        assert result == expected
+
 
 type _PlusOrMinusOneLit = Literal[1, -1]
 type _TruthLit = Literal["true", "false"]
@@ -417,73 +429,71 @@ class TestGetUnionTypeClasses:
 
 
 class TestIsAnnotationOfType:
-    @mark.parametrize(
-        ("func", "obj", "expected"),
-        [
-            param(is_dict_type, Mapping[int, int], False),
-            param(is_dict_type, Sequence[int], False),
-            param(is_dict_type, dict[int, int], True),
-            param(is_dict_type, frozenset[int], False),
-            param(is_dict_type, list[int], False),
-            param(is_dict_type, set[int], False),
-            param(is_dict_type, tuple[int, int], False),
-            param(is_frozenset_type, Mapping[int, int], False),
-            param(is_frozenset_type, Sequence[int], False),
-            param(is_frozenset_type, dict[int, int], False),
-            param(is_frozenset_type, frozenset[int], True),
-            param(is_frozenset_type, list[int], False),
-            param(is_frozenset_type, set[int], False),
-            param(is_frozenset_type, tuple[int, int], False),
-            param(is_list_type, Mapping[int, int], False),
-            param(is_list_type, Sequence[int], False),
-            param(is_list_type, dict[int, int], False),
-            param(is_list_type, frozenset[int], False),
-            param(is_list_type, list[int], True),
-            param(is_list_type, set[int], False),
-            param(is_list_type, tuple[int, int], False),
-            param(is_literal_type, Literal["a", "b", "c"], True),
-            param(is_literal_type, list[int], False),
-            param(is_mapping_type, Mapping[int, int], True),
-            param(is_mapping_type, Sequence[int], False),
-            param(is_mapping_type, dict[int, int], False),
-            param(is_mapping_type, frozenset[int], False),
-            param(is_mapping_type, list[int], False),
-            param(is_mapping_type, set[int], False),
-            param(is_mapping_type, tuple[int, int], False),
-            param(is_optional_type, Literal["a", "b", "c"] | None, True),
-            param(is_optional_type, Literal["a", "b", "c"], False),
-            param(is_optional_type, int | None, True),
-            param(is_optional_type, int | str, False),
-            param(is_optional_type, list[int] | None, True),
-            param(is_optional_type, list[int], False),
-            param(is_sequence_type, Mapping[int, int], False),
-            param(is_sequence_type, Sequence[int], True),
-            param(is_sequence_type, dict[int, int], False),
-            param(is_sequence_type, frozenset[int], False),
-            param(is_sequence_type, list[int], False),
-            param(is_sequence_type, set[int], False),
-            param(is_sequence_type, tuple[int, int], False),
-            param(is_set_type, Mapping[int, int], False),
-            param(is_set_type, Sequence[int], False),
-            param(is_set_type, dict[int, int], False),
-            param(is_set_type, frozenset[int], False),
-            param(is_set_type, list[int], False),
-            param(is_set_type, set[int], True),
-            param(is_set_type, tuple[int, int], False),
-            param(is_tuple_type, Mapping[int, int], False),
-            param(is_tuple_type, Sequence[int], False),
-            param(is_tuple_type, dict[int, int], False),
-            param(is_tuple_type, frozenset[int], False),
-            param(is_tuple_type, list[int], False),
-            param(is_tuple_type, set[int], False),
-            param(is_tuple_type, tuple[int, int], True),
-            param(is_union_type, int | str, True),
-            param(is_union_type, list[int], False),
-        ],
+    @given(
+        case=sampled_from([
+            (is_dict_type, Mapping[int, int], False),
+            (is_dict_type, Sequence[int], False),
+            (is_dict_type, dict[int, int], True),
+            (is_dict_type, frozenset[int], False),
+            (is_dict_type, list[int], False),
+            (is_dict_type, set[int], False),
+            (is_dict_type, tuple[int, int], False),
+            (is_frozenset_type, Mapping[int, int], False),
+            (is_frozenset_type, Sequence[int], False),
+            (is_frozenset_type, dict[int, int], False),
+            (is_frozenset_type, frozenset[int], True),
+            (is_frozenset_type, list[int], False),
+            (is_frozenset_type, set[int], False),
+            (is_frozenset_type, tuple[int, int], False),
+            (is_list_type, Mapping[int, int], False),
+            (is_list_type, Sequence[int], False),
+            (is_list_type, dict[int, int], False),
+            (is_list_type, frozenset[int], False),
+            (is_list_type, list[int], True),
+            (is_list_type, set[int], False),
+            (is_list_type, tuple[int, int], False),
+            (is_literal_type, Literal["a", "b", "c"], True),
+            (is_literal_type, list[int], False),
+            (is_mapping_type, Mapping[int, int], True),
+            (is_mapping_type, Sequence[int], False),
+            (is_mapping_type, dict[int, int], False),
+            (is_mapping_type, frozenset[int], False),
+            (is_mapping_type, list[int], False),
+            (is_mapping_type, set[int], False),
+            (is_mapping_type, tuple[int, int], False),
+            (is_optional_type, Literal["a", "b", "c"] | None, True),
+            (is_optional_type, Literal["a", "b", "c"], False),
+            (is_optional_type, int | None, True),
+            (is_optional_type, int | str, False),
+            (is_optional_type, list[int] | None, True),
+            (is_optional_type, list[int], False),
+            (is_sequence_type, Mapping[int, int], False),
+            (is_sequence_type, Sequence[int], True),
+            (is_sequence_type, dict[int, int], False),
+            (is_sequence_type, frozenset[int], False),
+            (is_sequence_type, list[int], False),
+            (is_sequence_type, set[int], False),
+            (is_sequence_type, tuple[int, int], False),
+            (is_set_type, Mapping[int, int], False),
+            (is_set_type, Sequence[int], False),
+            (is_set_type, dict[int, int], False),
+            (is_set_type, frozenset[int], False),
+            (is_set_type, list[int], False),
+            (is_set_type, set[int], True),
+            (is_set_type, tuple[int, int], False),
+            (is_tuple_type, Mapping[int, int], False),
+            (is_tuple_type, Sequence[int], False),
+            (is_tuple_type, dict[int, int], False),
+            (is_tuple_type, frozenset[int], False),
+            (is_tuple_type, list[int], False),
+            (is_tuple_type, set[int], False),
+            (is_tuple_type, tuple[int, int], True),
+            (is_union_type, int | str, True),
+            (is_union_type, list[int], False),
+        ])
     )
-    def test_main(
-        self, *, func: Callable[[Any], bool], obj: Any, expected: bool
-    ) -> None:
+    def test_main(self, *, case: tuple[Callable[[Any], bool], Any, bool]) -> None:
+        func, obj, expected = case
         assert func(obj) is expected
 
 
@@ -491,27 +501,75 @@ class TestIsInstanceGen:
     @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),
-            (dates(), dt.date, True),
-            (dates(), dt.datetime, False),
-            (datetimes(), dt.date, False),
-            (datetimes(), dt.datetime, True),
-            (booleans(), Number, False),
-            (integers(), Number, True),
-            (floats(), Number, True),
+            # 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),
+            # 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),
+            (sampled_from([1, 2, 3]), int, 3, True),
+            (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(
-        self, *, data: DataObject, case: tuple[SearchStrategy[Any], Any, bool]
+        self,
+        *,
+        data: DataObject,
+        case: tuple[SearchStrategy[Any], Any, int | None, bool],
     ) -> None:
-        strategy, type_, expected = case
-        value = data.draw(strategy)
-        assert is_instance_gen(value, type_) is expected
+        strategy, type_, min_size, expected = case
+        match expected:
+            case True:
+                value = data.draw(strategy)
+                assert is_instance_gen(value, type_)
+            case False:
+                values = data.draw(
+                    sets(strategy, min_size=100 if min_size is None else min_size)
+                )
+                assert not all(is_instance_gen(v, type_) for v in values)
 
     @given(bool_=booleans())
     def test_bool_value_vs_custom_int(self, *, bool_: bool) -> None:
@@ -526,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:
@@ -547,19 +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),
+            # 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),
+            (Literal[1, 2, 3], int, True),
+            (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:
@@ -574,3 +682,7 @@ class TestIsSubclassGen:
         assert not is_subclass_gen(int, MyInt)
         assert is_subclass_gen(MyInt, int)
         assert is_subclass_gen(MyInt, MyInt)
+
+    def test_error(self) -> None:
+        with raises(IsSubclassGenError, match="Argument must be a class; got None"):
+            _ = is_subclass_gen(None, NoneType)

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

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