dycw-utilities 0.112.4__tar.gz → 0.112.6__tar.gz

{dycw_utilities-0.112.4 → dycw_utilities-0.112.6}/PKG-INFO

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

{dycw_utilities-0.112.4 → dycw_utilities-0.112.6}/pyproject.toml

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

{dycw_utilities-0.112.4 → dycw_utilities-0.112.6}/src/tests/test_dataclasses.py

@@ -39,9 +39,10 @@ from utilities.dataclasses import (
     StrMappingToFieldMappingError,
     YieldFieldsError,
     _parse_dataclass_split_key_value_pairs,
-    _ParseDataClassParseValueError,
     _ParseDataClassSplitKeyValuePairsDuplicateKeysError,
     _ParseDataClassSplitKeyValuePairsSplitError,
+    _ParseDataClassTextExtraNonUniqueError,
+    _ParseDataClassTextParseError,
     _YieldFieldsClass,
     _YieldFieldsInstance,
     dataclass_repr,
@@ -482,13 +483,24 @@ class TestSerializeAndParseDataClass:
         ):
             _ = parse_dataclass("a=1,b=22a,b=22b,c=3", DataClassFutureInt)
 
-    def test_error_parse_value(self) -> None:
+    def test_error_text_parse(self) -> None:
         with raises(
-            _ParseDataClassParseValueError,
-            match="Unable to construct 'DataClassFutureInt'; unable to parse field 'int_' of type <class 'int'>; got 'invalid'",
+            _ParseDataClassTextParseError,
+            match="Unable to construct 'DataClassFutureInt' since the field 'int_' of type <class 'int'> could not be parsed; got 'invalid'",
         ):
             _ = parse_dataclass("int_=invalid", DataClassFutureInt)
 
+    def test_error_text_extra_non_unique(self) -> None:
+        with raises(
+            _ParseDataClassTextExtraNonUniqueError,
+            match="Unable to construct 'DataClassFutureInt' since the field 'int_' of type <class 'int'> must contain exactly one parent class in `extra`; got <class 'int'>, <class 'int'> and perhaps more",
+        ):
+            _ = parse_dataclass(
+                "int_=0",
+                DataClassFutureInt,
+                extra_parsers={int | str: int, int | float: int},
+            )
+
 
 class TestStrMappingToFieldMapping:
     @given(key=sampled_from(["int_", "INT_"]), int_=integers())

{dycw_utilities-0.112.4 → dycw_utilities-0.112.6}/src/tests/test_parse.py

@@ -25,13 +25,10 @@ from pytest import raises
 from tests.test_operator import TruthEnum
 from tests.test_typing_funcs.with_future import (
     DataClassFutureInt,
-    DataClassFutureIntChild,
     DataClassFutureIntEven,
     DataClassFutureIntEvenOrOddTypeUnion,
     DataClassFutureIntEvenOrOddUnion,
     DataClassFutureIntOdd,
-    DataClassFutureIntParentFirst,
-    DataClassFutureIntParentSecond,
     TrueOrFalseFutureLit,
     TrueOrFalseFutureTypeLit,
 )
@@ -309,7 +306,7 @@ class TestSerializeAndParseObject:
 
 class TestParseObject:
     @given(text=sampled_from(["F_a_l_s_e", "T_r_u_e"]))
-    def test_bool_custom(self, *, text: str) -> None:
+    def test_extra(self, *, text: str) -> None:
         def parser(text: str, /) -> bool:
             match text:
                 case "F_a_l_s_e":
@@ -330,7 +327,7 @@ class TestParseObject:
         assert bool_ is expected
 
     @given(text=sampled_from(["F_a_l_s_e", "T_r_u_e"]))
-    def test_bool_extra_not_used(self, *, text: str) -> None:
+    def test_extra_both_exact_match_and_non_unique_parents(self, *, text: str) -> None:
         def parser(text: str, /) -> bool:
             match text:
                 case "F_a_l_s_e":
@@ -340,10 +337,17 @@ class TestParseObject:
                 case _:
                     raise ImpossibleCaseError(case=[f"{text=}"])
 
-        with raises(
-            _ParseObjectParseError, match="Unable to parse <class 'bool'>; got '.*'"
-        ):
-            _ = parse_object(bool, text, extra={int: parser})
+        result = parse_object(
+            bool, text, extra={bool: parser, bool | int: bool, bool | float: bool}
+        )
+        match text:
+            case "F_a_l_s_e":
+                expected = False
+            case "T_r_u_e":
+                expected = True
+            case _:
+                raise ImpossibleCaseError(case=[f"{text=}"])
+        assert result is expected
 
     @given(value=text_ascii(min_size=10) | none())
     def test_optional_type_with_union_extra_not_used(
@@ -412,24 +416,29 @@ class TestParseObject:
         ):
             _ = parse_object(DataClassFutureInt, "invalid", extra={})
 
+    @given(text=sampled_from(["F_a_l_s_e", "T_r_u_e"]))
+    def test_error_extra_empty_bool_does_not_use_int(self, *, text: str) -> None:
+        def parser(text: str, /) -> bool:
+            match text:
+                case "F_a_l_s_e":
+                    return False
+                case "T_r_u_e":
+                    return True
+                case _:
+                    raise ImpossibleCaseError(case=[f"{text=}"])
+
+        with raises(
+            _ParseObjectParseError, match="Unable to parse <class 'bool'>; got '.*'"
+        ):
+            _ = parse_object(bool, text, extra={int: parser})
+
     @given(int_=integers())
     def test_error_extra_non_unique(self, *, int_: int) -> None:
         with raises(
             _ParseObjectExtraNonUniqueError,
-            match="Unable to parse <class '.*'> since `extra` must contain exactly one parent class; got <function .*>, <function .*> and perhaps more",
-        ):
-            _ = parse_object(
-                DataClassFutureIntChild,
-                serialize_object(int_),
-                extra={
-                    DataClassFutureIntParentFirst: lambda text: DataClassFutureIntChild(
-                        int1=int(text), int2=0
-                    ),
-                    DataClassFutureIntParentSecond: lambda text: DataClassFutureIntChild(
-                        int1=0, int2=int(text)
-                    ),
-                },
-            )
+            match="Unable to parse <class 'int'> since `extra` must contain exactly one parent class; got <class 'int'>, <class 'int'> and perhaps more",
+        ):
+            _ = parse_object(int, str(int_), extra={int | bool: int, int | float: int})
 
     def test_error_union_type_extra(self) -> None:
         with raises(
@@ -674,29 +683,17 @@ class TestSerializeObject:
     def test_error_extra_empty(self) -> None:
         with raises(
             _SerializeObjectSerializeError,
-            match=r"Unable to serialize object typing\.Final",
+            match=r"Unable to serialize object typing\.Final of type <class 'typing\._SpecialForm'>",
         ):
             _ = serialize_object(Final, extra={})
 
-    @given(int1=integers(), int2=integers())
-    def test_error_extra_non_unique(self, *, int1: int, int2: int) -> None:
-        def serializer1(obj: DataClassFutureIntParentFirst, /) -> str:
-            return str(obj.int1)
-
-        def serializer2(obj: DataClassFutureIntParentSecond, /) -> str:
-            return str(obj.int2)
-
+    @given(bool_=booleans())
+    def test_error_extra_non_unique(self, *, bool_: bool) -> None:
         with raises(
             _SerializeObjectExtraNonUniqueError,
-            match=r"Unable to serialize object DataClassFutureIntChild\(.*\) since `extra` must contain exactly one parent class; got <function .*>, <function .*> and perhaps more",
-        ):
-            _ = serialize_object(
-                DataClassFutureIntChild(int1=int1, int2=int2),
-                extra={
-                    DataClassFutureIntParentFirst: serializer1,
-                    DataClassFutureIntParentSecond: serializer2,
-                },
-            )
+            match=r"Unable to serialize object (True|False) of type <class 'bool'> since `extra` must contain exactly one parent class; got <class 'str'>, <class 'str'> and perhaps more",
+        ):
+            _ = serialize_object(bool_, extra={bool | int: str, bool | float: str})
 
     def test_error_not_implemented(self) -> None:
         with raises(_SerializeObjectSerializeError):

{dycw_utilities-0.112.4 → dycw_utilities-0.112.6}/src/tests/test_typing.py

@@ -53,6 +53,7 @@ from tests.test_typing_funcs.with_future import (
     TrueOrFalseFutureLit,
     TrueOrFalseFutureTypeLit,
 )
+from utilities.hypothesis import text_ascii
 from utilities.sentinel import Sentinel
 from utilities.types import Duration, LogLevel, Number, Parallelism, Seed
 from utilities.typing import (
@@ -167,14 +168,14 @@ class TestGetTypeClasses:
     def test_error_type(self) -> None:
         with raises(
             _GetTypeClassesTypeError,
-            match="Object must be a type, tuple or Union type; got None",
+            match="Object must be a type, tuple or Union type; got None of type <class 'NoneType'>",
         ):
             _ = get_type_classes(None)
 
     def test_error_tuple(self) -> None:
         with raises(
             _GetTypeClassesTupleError,
-            match="Tuple must contain types, tuples or Union types only; got None",
+            match="Tuple must contain types, tuples or Union types only; got None of type <class 'NoneType'>",
         ):
             _ = get_type_classes((None,))
 
@@ -416,14 +417,14 @@ class TestGetUnionTypeClasses:
     def test_error_union_type(self) -> None:
         with raises(
             _GetUnionTypeClassesUnionTypeError,
-            match="Object must be a Union type; got None",
+            match="Object must be a Union type; got None of type <class 'NoneType'>",
         ):
             _ = get_union_type_classes(None)
 
-    def test_error_interal_type(self) -> None:
+    def test_error_internal_type(self) -> None:
         with raises(
             _GetUnionTypeClassesInternalTypeError,
-            match=r"Union type must contain types only; got typing\.Literal\[True\]",
+            match=r"Union type must contain types only; got typing\.Literal\[True\] of type <class 'typing\._LiteralGenericAlias'>",
         ):
             _ = get_union_type_classes(Literal[True] | None)
 
@@ -530,6 +531,7 @@ class TestIsInstanceGen:
             (sampled_from([1, "2", 3]), int, 3, False),
             (sampled_from([1, "2", 3]), str, 3, False),
             (booleans(), Literal[1, 2, 3], None, False),
+            (text_ascii(), Literal["a", "b", "c"], 4, False),
             # tuple types
             (tuples(booleans()), tuple[bool], None, True),
             (tuples(booleans()), tuple[int], None, False),
@@ -552,6 +554,10 @@ class TestIsInstanceGen:
                 False,
             ),
             (tuples(just("a"), integers()), tuple[Literal["a", "b"], int], None, True),
+            (booleans(), tuple[bool], 2, False),
+            (booleans() | none(), tuple[bool], 3, False),
+            (text_ascii(), tuple[bool], None, False),
+            (text_ascii() | none(), tuple[bool], None, False),
         ]),
     )
     def test_main(
@@ -586,7 +592,8 @@ class TestIsInstanceGen:
 
     def test_error(self) -> None:
         with raises(
-            IsInstanceGenError, match=r"Invalid arguments; got None and typing\.Final"
+            IsInstanceGenError,
+            match=r"Invalid arguments; got None of type <class 'NoneType'> and typing\.Final of type <class 'typing\._SpecialForm'>",
         ):
             _ = is_instance_gen(None, Final)
 
@@ -639,6 +646,9 @@ class TestIsSubclassGen:
             (bool, bool | None, True),
             (bool | None, bool, False),
             (bool | None, bool | None, True),
+            (Number, int, False),
+            (Number, float, False),
+            (Number, Number, True),
             # literals
             (Literal[1, 2], Literal[1, 2, 3], True),
             (Literal[1, 2, 3], Literal[1, 2, 3], True),
@@ -651,6 +661,7 @@ class TestIsSubclassGen:
             (Literal[1, "2", 3], int, False),
             (Literal[1, "2", 3], str, False),
             (bool, Literal[1, 2, 3], False),
+            (str, Literal["a", "b", "c"], False),
             # tuple types
             (tuple[bool], tuple[bool], True),
             (tuple[bool], tuple[int], False),
@@ -668,6 +679,10 @@ class TestIsSubclassGen:
             (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),
+            (bool, tuple[bool], False),
+            (bool | None, tuple[bool], False),
+            (str, tuple[Literal["a", "b", "c"]], False),
+            (str | None, tuple[Literal["a", "b", "c"]], False),
         ])
     )
     def test_main(self, *, case: tuple[type[Any], Any, bool]) -> None:
@@ -684,5 +699,8 @@ class TestIsSubclassGen:
         assert is_subclass_gen(MyInt, MyInt)
 
     def test_error(self) -> None:
-        with raises(IsSubclassGenError, match="Argument must be a class; got None"):
+        with raises(
+            IsSubclassGenError,
+            match="Argument must be a class; got None of type <class 'NoneType'>",
+        ):
             _ = is_subclass_gen(None, NoneType)

{dycw_utilities-0.112.4 → dycw_utilities-0.112.6}/src/tests/test_typing_funcs/with_future.py

@@ -87,22 +87,6 @@ class DataClassFutureIntOneAndTwo:
     int2: int
 
 
-@dataclass(order=True, unsafe_hash=True, kw_only=True)
-class DataClassFutureIntParentFirst:
-    int1: int
-
-
-@dataclass(order=True, unsafe_hash=True, kw_only=True)
-class DataClassFutureIntParentSecond:
-    int2: int
-
-
-@dataclass(order=True, unsafe_hash=True, kw_only=True)
-class DataClassFutureIntChild(
-    DataClassFutureIntParentFirst, DataClassFutureIntParentSecond
-): ...
-
-
 @dataclass(order=True, unsafe_hash=True, kw_only=True)
 class DataClassFutureListInts:
     ints: list[int]

{dycw_utilities-0.112.4 → dycw_utilities-0.112.6}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.112.4"
+__version__ = "0.112.6"

{dycw_utilities-0.112.4 → dycw_utilities-0.112.6}/src/utilities/dataclasses.py

@@ -22,7 +22,12 @@ from utilities.functions import (
 )
 from utilities.iterables import OneStrEmptyError, OneStrNonUniqueError, one_str
 from utilities.operator import is_equal
-from utilities.parse import ParseObjectError, parse_object, serialize_object
+from utilities.parse import (
+    _ParseObjectExtraNonUniqueError,
+    _ParseObjectParseError,
+    parse_object,
+    serialize_object,
+)
 from utilities.re import ExtractGroupError, extract_group
 from utilities.sentinel import Sentinel, sentinel
 from utilities.text import (
@@ -570,8 +575,12 @@ def _parse_dataclass_parse_text(
             case_sensitive=case_sensitive,
             extra=extra,
         )
-    except ParseObjectError:
-        raise _ParseDataClassParseValueError(cls=cls, field=field, text=text) from None
+    except _ParseObjectParseError:
+        raise _ParseDataClassTextParseError(cls=cls, field=field, text=text) from None
+    except _ParseObjectExtraNonUniqueError as error:
+        raise _ParseDataClassTextExtraNonUniqueError(
+            cls=cls, field=field, text=text, first=error.first, second=error.second
+        ) from None
 
 
 @dataclass(kw_only=True, slots=True)
@@ -597,12 +606,23 @@ class _ParseDataClassSplitKeyValuePairsDuplicateKeysError(ParseDataClassError):
 
 
 @dataclass(kw_only=True, slots=True)
-class _ParseDataClassParseValueError(ParseDataClassError[TDataclass]):
+class _ParseDataClassTextParseError(ParseDataClassError[TDataclass]):
+    field: _YieldFieldsClass[Any]
+
+    @override
+    def __str__(self) -> str:
+        return f"Unable to construct {get_class_name(self.cls)!r} since the field {self.field.name!r} of type {self.field.type_!r} could not be parsed; got {self.text!r}"
+
+
+@dataclass(kw_only=True, slots=True)
+class _ParseDataClassTextExtraNonUniqueError(ParseDataClassError[TDataclass]):
     field: _YieldFieldsClass[Any]
+    first: type[Any]
+    second: type[Any]
 
     @override
     def __str__(self) -> str:
-        return f"Unable to construct {get_class_name(self.cls)!r}; unable to parse field {self.field.name!r} of type {self.field.type_!r}; got {self.text!r}"
+        return f"Unable to construct {get_class_name(self.cls)!r} since the field {self.field.name!r} of type {self.field.type_!r} must contain exactly one parent class in `extra`; got {self.first!r}, {self.second!r} and perhaps more"
 
 
 ##

{dycw_utilities-0.112.4 → dycw_utilities-0.112.6}/src/utilities/parse.py

@@ -283,17 +283,19 @@ def _parse_object_dict_type(
 
 def _parse_object_extra(cls: Any, text: str, extra: ParseObjectExtra, /) -> Any:
     try:
-        parser = one(
-            p for c, p in extra.items() if (cls is c) or is_subclass_gen(cls, c)
-        )
-    except (OneEmptyError, TypeError):
-        raise _ParseObjectParseError(type_=cls, text=text) from None
-    except OneNonUniqueError as error:
-        raise _ParseObjectExtraNonUniqueError(
-            type_=cls, text=text, first=error.first, second=error.second
-        ) from None
-    else:
-        return parser(text)
+        parser = extra[cls]
+    except KeyError:
+        try:
+            parser = one(
+                p for c, p in extra.items() if (cls is c) or is_subclass_gen(cls, c)
+            )
+        except (OneEmptyError, TypeError):
+            raise _ParseObjectParseError(type_=cls, text=text) from None
+        except OneNonUniqueError as error:
+            raise _ParseObjectExtraNonUniqueError(
+                type_=cls, text=text, first=error.first, second=error.second
+            ) from None
+    return parser(text)
 
 
 def _parse_object_list_type(
@@ -600,7 +602,7 @@ class SerializeObjectError(Exception):
 class _SerializeObjectSerializeError(SerializeObjectError):
     @override
     def __str__(self) -> str:
-        return f"Unable to serialize object {self.obj!r}"
+        return f"Unable to serialize object {self.obj!r} of type {type(self.obj)!r}"
 
 
 @dataclass
@@ -610,7 +612,7 @@ class _SerializeObjectExtraNonUniqueError(SerializeObjectError):
 
     @override
     def __str__(self) -> str:
-        return f"Unable to serialize object {self.obj!r} since `extra` must contain exactly one parent class; got {self.first!r}, {self.second!r} and perhaps more"
+        return f"Unable to serialize object {self.obj!r} of type {type(self.obj)!r} since `extra` must contain exactly one parent class; got {self.first!r}, {self.second!r} and perhaps more"
 
 
 __all__ = ["parse_object", "serialize_object"]

{dycw_utilities-0.112.4 → dycw_utilities-0.112.6}/src/utilities/typing.py

@@ -108,7 +108,7 @@ class GetTypeClassesError(Exception):
 class _GetTypeClassesTypeError(GetTypeClassesError):
     @override
     def __str__(self) -> str:
-        return f"Object must be a type, tuple or Union type; got {self.obj}"
+        return f"Object must be a type, tuple or Union type; got {self.obj!r} of type {type(self.obj)!r}"
 
 
 @dataclass(kw_only=True, slots=True)
@@ -117,7 +117,7 @@ class _GetTypeClassesTupleError(GetTypeClassesError):
 
     @override
     def __str__(self) -> str:
-        return f"Tuple must contain types, tuples or Union types only; got {self.inner}"
+        return f"Tuple must contain types, tuples or Union types only; got {self.inner} of type {type(self.inner)!r}"
 
 
 ##
@@ -177,7 +177,9 @@ class GetUnionTypeClassesError(Exception):
 class _GetUnionTypeClassesUnionTypeError(GetUnionTypeClassesError):
     @override
     def __str__(self) -> str:
-        return f"Object must be a Union type; got {self.obj}"
+        return (
+            f"Object must be a Union type; got {self.obj!r} of type {type(self.obj)!r}"
+        )
 
 
 @dataclass(kw_only=True, slots=True)
@@ -186,7 +188,7 @@ class _GetUnionTypeClassesInternalTypeError(GetUnionTypeClassesError):
 
     @override
     def __str__(self) -> str:
-        return f"Union type must contain types only; got {self.inner}"
+        return f"Union type must contain types only; got {self.inner} of type {type(self.inner)!r}"
 
 
 ##
@@ -243,6 +245,8 @@ def is_instance_gen(obj: Any, type_: Any, /) -> bool:
         return (len(obj) == len(type_args)) and all(
             is_instance_gen(o, t) for o, t in zip(obj, type_args, strict=True)
         )
+    if isinstance(obj, tuple) is not is_tuple_type(type_):
+        return False
     # basic
     if isinstance(type_, type):
         return any(_is_instance_gen_type(obj, t) for t in get_type_classes(type_))
@@ -272,7 +276,7 @@ class IsInstanceGenError(Exception):
 
     @override
     def __str__(self) -> str:
-        return f"Invalid arguments; got {self.obj!r} and {self.type_!r}"
+        return f"Invalid arguments; got {self.obj!r} of type {type(self.obj)!r} and {self.type_!r} of type {type(self.type_)!r}"
 
 
 ##
@@ -432,7 +436,7 @@ class IsSubclassGenError(Exception):
 
     @override
     def __str__(self) -> str:
-        return f"Argument must be a class; got {self.cls!r}"
+        return f"Argument must be a class; got {self.cls!r} of type {type(self.cls)!r}"
 
 
 ##