dycw-utilities 0.110.2__tar.gz → 0.110.4__tar.gz

{dycw_utilities-0.110.2 → dycw_utilities-0.110.4}/PKG-INFO

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

{dycw_utilities-0.110.2 → dycw_utilities-0.110.4}/pyproject.toml

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

{dycw_utilities-0.110.2 → dycw_utilities-0.110.4}/src/tests/test_dataclasses.py

@@ -38,6 +38,7 @@ from utilities.dataclasses import (
     OneFieldNonUniqueError,
     StrMappingToFieldMappingError,
     YieldFieldsError,
+    _parse_dataclass_split_key_value_pairs,
     _ParseDataClassParseValueError,
     _ParseDataClassSplitKeyValuePairsDuplicateKeysError,
     _ParseDataClassSplitKeyValuePairsSplitError,
@@ -364,6 +365,14 @@ class TestOneField:
             )
 
 
+class TestParseDataClassSplitKeyValuePairs:
+    @given(text=sampled_from(["a=1,b=22,c=333", "{a=1,b=22,c=333}"]))
+    def test_main(self, *, text: str) -> None:
+        result = _parse_dataclass_split_key_value_pairs(text, DataClassFutureInt)
+        expected = {"a": "1", "b": "22", "c": "333"}
+        assert result == expected
+
+
 class TestReplaceNonSentinel:
     def test_main(self) -> None:
         obj = DataClassFutureIntDefault()
@@ -382,6 +391,94 @@ class TestReplaceNonSentinel:
         assert obj.int_ == 1
 
 
+class TestSerializeAndParseDataClass:
+    @given(int_=integers())
+    def test_main_future_int(self, *, int_: int) -> None:
+        obj = DataClassFutureInt(int_=int_)
+        serialized = serialize_dataclass(obj)
+        result = parse_dataclass(serialized, DataClassFutureInt)
+        assert result == obj
+
+    def test_main_future_int_default(self) -> None:
+        obj = DataClassFutureIntDefault()
+        serialized = serialize_dataclass(obj)
+        result = parse_dataclass(serialized, DataClassFutureIntDefault)
+        assert result == obj
+
+    @given(int_=integers())
+    def test_extra_type(self, *, int_: int) -> None:
+        obj = DataClassFutureNestedOuterFirstOuter(
+            inner=DataClassFutureNestedOuterFirstInner(int_=int_)
+        )
+
+        def serializer(obj: DataClassFutureNestedOuterFirstInner, /) -> str:
+            return serialize_dataclass(obj)
+
+        serialized = serialize_dataclass(
+            obj, extra_serializers={DataClassFutureNestedOuterFirstInner: serializer}
+        )
+        result = parse_dataclass(
+            serialized,
+            DataClassFutureNestedOuterFirstOuter,
+            globalns=globals(),
+            extra_parsers={
+                DataClassFutureNestedOuterFirstInner: lambda text: parse_dataclass(
+                    text, DataClassFutureNestedOuterFirstInner
+                )
+            },
+        )
+        assert result == obj
+
+    @given(key=sampled_from(["int_", "INT_"]), int_=integers())
+    def test_parse_text_case_insensitive(self, *, key: str, int_: int) -> None:
+        result = parse_dataclass(f"{key}={int_}", DataClassFutureInt)
+        expected = DataClassFutureInt(int_=int_)
+        assert result == expected
+
+    @given(int_=integers())
+    def test_parse_text_case_sensitive(self, *, int_: int) -> None:
+        result = parse_dataclass(
+            f"int_={int_}", DataClassFutureInt, case_sensitive=True
+        )
+        expected = DataClassFutureInt(int_=int_)
+        assert result == expected
+
+    @given(key=sampled_from(["int_", "INT_"]), int_=integers())
+    def test_parse_mapping_case_insensitive(self, *, key: str, int_: int) -> None:
+        result = parse_dataclass({key: str(int_)}, DataClassFutureInt)
+        expected = DataClassFutureInt(int_=int_)
+        assert result == expected
+
+    @given(int_=integers())
+    def test_parse_mapping_case_sensitive(self, *, int_: int) -> None:
+        result = parse_dataclass(
+            {"int_": str(int_)}, DataClassFutureInt, case_sensitive=True
+        )
+        expected = DataClassFutureInt(int_=int_)
+        assert result == expected
+
+    def test_parser_split_key_value_pairs_split(self) -> None:
+        with raises(
+            _ParseDataClassSplitKeyValuePairsSplitError,
+            match="Unable to construct 'DataClassFutureInt'; failed to split key-value pair 'bbb'",
+        ):
+            _ = parse_dataclass("a=1,bbb,c=333", DataClassFutureInt)
+
+    def test_error_parse_split_key_value_pairs_duplicate(self) -> None:
+        with raises(
+            _ParseDataClassSplitKeyValuePairsDuplicateKeysError,
+            match=r"Unable to construct 'DataClassFutureInt' since there are duplicate keys; got \{'b': 2\}",
+        ):
+            _ = parse_dataclass("a=1,b=22a,b=22b,c=3", DataClassFutureInt)
+
+    def test_error_parse_value(self) -> None:
+        with raises(
+            _ParseDataClassParseValueError,
+            match="Unable to construct 'DataClassFutureInt'; unable to parse field 'int_' of type <class 'int'>; got 'invalid'",
+        ):
+            _ = parse_dataclass("int_=invalid", DataClassFutureInt)
+
+
 class TestStrMappingToFieldMapping:
     @given(key=sampled_from(["int_", "INT_"]), int_=integers())
     def test_main_text_case_insensitive(self, *, key: str, int_: int) -> None:
@@ -467,70 +564,6 @@ class TestStrMappingToFieldMapping:
             )
 
 
-class TestSerializeAndParseDataClass:
-    @given(int_=integers())
-    def test_main_future_int(self, *, int_: int) -> None:
-        obj = DataClassFutureInt(int_=int_)
-        serialized = serialize_dataclass(obj)
-        result = parse_dataclass(serialized, DataClassFutureInt)
-        assert result == obj
-
-    def test_main_future_int_default(self) -> None:
-        obj = DataClassFutureIntDefault()
-        serialized = serialize_dataclass(obj)
-        result = parse_dataclass(serialized, DataClassFutureIntDefault)
-        assert result == obj
-
-    @given(key=sampled_from(["int_", "INT_"]), int_=integers())
-    def test_parse_text_case_insensitive(self, *, key: str, int_: int) -> None:
-        result = parse_dataclass(f"{key}={int_}", DataClassFutureInt)
-        expected = DataClassFutureInt(int_=int_)
-        assert result == expected
-
-    @given(int_=integers())
-    def test_parse_text_case_sensitive(self, *, int_: int) -> None:
-        result = parse_dataclass(
-            f"int_={int_}", DataClassFutureInt, case_sensitive=True
-        )
-        expected = DataClassFutureInt(int_=int_)
-        assert result == expected
-
-    @given(key=sampled_from(["int_", "INT_"]), int_=integers())
-    def test_parse_mapping_case_insensitive(self, *, key: str, int_: int) -> None:
-        result = parse_dataclass({key: str(int_)}, DataClassFutureInt)
-        expected = DataClassFutureInt(int_=int_)
-        assert result == expected
-
-    @given(int_=integers())
-    def test_parse_mapping_case_sensitive(self, *, int_: int) -> None:
-        result = parse_dataclass(
-            {"int_": str(int_)}, DataClassFutureInt, case_sensitive=True
-        )
-        expected = DataClassFutureInt(int_=int_)
-        assert result == expected
-
-    def test_parser_split_key_value_pairs_split(self) -> None:
-        with raises(
-            _ParseDataClassSplitKeyValuePairsSplitError,
-            match="Unable to construct 'DataClassFutureInt'; failed to split key-value pair 'bbb'",
-        ):
-            _ = parse_dataclass("a=1,bbb,c=333", DataClassFutureInt)
-
-    def test_error_parse_split_key_value_pairs_duplicate(self) -> None:
-        with raises(
-            _ParseDataClassSplitKeyValuePairsDuplicateKeysError,
-            match=r"Unable to construct 'DataClassFutureInt' since there are duplicate keys; got \{'b': 2\}",
-        ):
-            _ = parse_dataclass("a=1,b=22a,b=22b,c=3", DataClassFutureInt)
-
-    def test_error_parse_value(self) -> None:
-        with raises(
-            _ParseDataClassParseValueError,
-            match="Unable to construct 'DataClassFutureInt'; unable to parse field 'int_' of type <class 'int'>; got 'invalid'",
-        ):
-            _ = parse_dataclass("int_=invalid", DataClassFutureInt)
-
-
 class TestYieldFields:
     def test_class_no_future_int(self) -> None:
         result = one(yield_fields(DataClassNoFutureInt))

{dycw_utilities-0.110.2 → dycw_utilities-0.110.4}/src/tests/test_orjson.py

@@ -147,6 +147,7 @@ class TestGetLogRecords:
         ),
         root=temp_paths(),
     )
+    @mark.flaky
     def test_dataframe(
         self, *, root: Path, items: Sequence[tuple[LogLevel, str, StrMapping]]
     ) -> None:

{dycw_utilities-0.110.2 → dycw_utilities-0.110.4}/src/tests/test_parse.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import datetime as dt
 from collections.abc import Iterable
-from dataclasses import dataclass
 from pathlib import Path
 from types import NoneType
 from typing import Final, Literal
@@ -25,10 +24,13 @@ 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,
 )
@@ -48,6 +50,8 @@ from utilities.math import is_equal
 from utilities.parse import (
     _ParseObjectExtraNonUniqueError,
     _ParseObjectParseError,
+    _SerializeObjectExtraNonUniqueError,
+    _SerializeObjectSerializeError,
     parse_object,
     serialize_object,
 )
@@ -99,11 +103,7 @@ class TestSerializeAndParseObject:
         result = parse_object(
             DataClassFutureInt,
             serialized,
-            extra={
-                DataClassFutureInt: lambda serialized: DataClassFutureInt(
-                    int_=int(serialized)
-                )
-            },
+            extra={DataClassFutureInt: lambda text: DataClassFutureInt(int_=int(text))},
         )
         expected = DataClassFutureInt(int_=value)
         assert result == expected
@@ -240,7 +240,7 @@ class TestSerializeAndParseObject:
 
     @given(value=integers())
     def test_type_union_with_extra(self, *, value: int) -> None:
-        def parse_even_or_odd(text: str, /) -> DataClassFutureIntEvenOrOddTypeUnion:
+        def parser(text: str, /) -> DataClassFutureIntEvenOrOddTypeUnion:
             value = int(text)
             match value % 2:
                 case 0:
@@ -254,7 +254,7 @@ class TestSerializeAndParseObject:
         result = parse_object(
             DataClassFutureIntEvenOrOddTypeUnion,
             serialized,
-            extra={DataClassFutureIntEvenOrOddTypeUnion: parse_even_or_odd},
+            extra={DataClassFutureIntEvenOrOddTypeUnion: parser},
         )
         match value % 2:
             case 0:
@@ -267,7 +267,7 @@ class TestSerializeAndParseObject:
 
     @given(value=integers())
     def test_union_with_extra(self, *, value: int) -> None:
-        def parse_even_or_odd(text: str, /) -> DataClassFutureIntEvenOrOddUnion:
+        def parser(text: str, /) -> DataClassFutureIntEvenOrOddUnion:
             value = int(text)
             match value % 2:
                 case 0:
@@ -281,7 +281,7 @@ class TestSerializeAndParseObject:
         result = parse_object(
             DataClassFutureIntEvenOrOddUnion,
             serialized,
-            extra={DataClassFutureIntEvenOrOddUnion: parse_even_or_odd},
+            extra={DataClassFutureIntEvenOrOddUnion: parser},
         )
         match value % 2:
             case 0:
@@ -299,7 +299,7 @@ class TestSerializeAndParseObject:
         assert result == version
 
 
-class TestParseSerialized:
+class TestParseObject:
     def test_error_bool(self) -> None:
         with raises(
             _ParseObjectParseError,
@@ -357,27 +357,20 @@ class TestParseSerialized:
 
     @given(value=integers())
     def test_error_extra_non_unique(self, *, value: int) -> None:
-        @dataclass(kw_only=True)
-        class Parent1:
-            x: int = 0
-
-        @dataclass(kw_only=True)
-        class Parent2:
-            y: int = 0
-
-        @dataclass(kw_only=True)
-        class Child(Parent1, Parent2): ...
-
         with raises(
             _ParseObjectExtraNonUniqueError,
             match="Unable to parse <class '.*'> since `extra` must contain exactly one parent class; got <function .*>, <function .*> and perhaps more",
         ):
             _ = parse_object(
-                Child,
+                DataClassFutureIntChild,
                 serialize_object(value),
                 extra={
-                    Parent1: lambda serialized: Child(x=int(serialized)),
-                    Parent2: lambda serialized: Child(y=int(serialized)),
+                    DataClassFutureIntParentFirst: lambda text: DataClassFutureIntChild(
+                        int1=int(text), int2=0
+                    ),
+                    DataClassFutureIntParentSecond: lambda text: DataClassFutureIntChild(
+                        int1=0, int2=int(text)
+                    ),
                 },
             )
 
@@ -538,6 +531,33 @@ class TestParseSerialized:
 
 
 class TestSerializeObject:
+    def test_error_extra_empty(self) -> None:
+        with raises(
+            _SerializeObjectSerializeError,
+            match=r"Unable to serialize object typing\.Final",
+        ):
+            _ = 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)
+
+        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,
+                },
+            )
+
     def test_error_not_implemented(self) -> None:
-        with raises(NotImplementedError):
+        with raises(_SerializeObjectSerializeError):
             _ = serialize_object(Final)

{dycw_utilities-0.110.2 → dycw_utilities-0.110.4}/src/tests/test_text.py

@@ -90,6 +90,8 @@ class TestSplitKeyValuePairs:
             ("a=", [("a", "")]),
             ("a=1,=22,c=333", [("a", "1"), ("", "22"), ("c", "333")]),
             ("a=1,b=,c=333", [("a", "1"), ("b", ""), ("c", "333")]),
+            ("a=1,b=(22,22,22),c=333", [("a", "1"), ("b", "(22,22,22)"), ("c", "333")]),
+            ("a=1,b=(c=22),c=333", [("a", "1"), ("b", "(c=22)"), ("c", "333")]),
         ])
     )
     def test_main(self, *, case: tuple[str, Sequence[tuple[str, str]]]) -> None:
@@ -102,10 +104,17 @@ class TestSplitKeyValuePairs:
         expected = {"a": "1", "b": "22", "c": "333"}
         assert result == expected
 
-    def test_error_split(self) -> None:
+    def test_error_split_list(self) -> None:
         with raises(
             _SplitKeyValuePairsSplitError,
-            match=r"Unable to split 'a=1,b=22=22,c=333' into key-value pairs; got 'b=22=22'",
+            match=r"Unable to split 'a=1,b=\(c=22\],d=333' into key-value pairs",
+        ):
+            _ = split_key_value_pairs("a=1,b=(c=22],d=333")
+
+    def test_error_split_pair(self) -> None:
+        with raises(
+            _SplitKeyValuePairsSplitError,
+            match=r"Unable to split 'a=1,b=22=22,c=333' into key-value pairs",
         ):
             _ = split_key_value_pairs("a=1,b=22=22,c=333")
 

{dycw_utilities-0.110.2 → dycw_utilities-0.110.4}/src/tests/test_typing_funcs/with_future.py

@@ -87,6 +87,22 @@ 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.110.2 → dycw_utilities-0.110.4}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.110.2"
+__version__ = "0.110.4"

{dycw_utilities-0.110.2 → dycw_utilities-0.110.4}/src/utilities/dataclasses.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from collections.abc import Mapping
+from contextlib import suppress
 from dataclasses import MISSING, dataclass, field, fields, replace
 from typing import (
     TYPE_CHECKING,
@@ -21,21 +22,23 @@ from utilities.functions import (
 )
 from utilities.iterables import OneStrEmptyError, OneStrNonUniqueError, one_str
 from utilities.operator import is_equal
-from utilities.parse import (
-    LIST_SEPARATOR,
-    PAIR_SEPARATOR,
-    ParseObjectError,
-    parse_object,
-    serialize_object,
-)
+from utilities.parse import ParseObjectError, parse_object, serialize_object
+from utilities.re import ExtractGroupError, extract_group
 from utilities.sentinel import Sentinel, sentinel
 from utilities.text import (
+    BRACKETS,
+    LIST_SEPARATOR,
+    PAIR_SEPARATOR,
     _SplitKeyValuePairsDuplicateKeysError,
     _SplitKeyValuePairsSplitError,
-    join_strs,
     split_key_value_pairs,
 )
-from utilities.types import ParseObjectExtra, StrStrMapping, TDataclass
+from utilities.types import (
+    ParseObjectExtra,
+    SerializeObjectExtra,
+    StrStrMapping,
+    TDataclass,
+)
 from utilities.typing import get_type_hints
 
 if TYPE_CHECKING:
@@ -408,10 +411,11 @@ def serialize_dataclass(
     exclude: Iterable[str] | None = None,
     rel_tol: float | None = None,
     abs_tol: float | None = None,
-    extra: Mapping[type[_U], Callable[[_U, _U], bool]] | None = None,
+    extra_equal: Mapping[type[_U], Callable[[_U, _U], bool]] | None = None,
     defaults: bool = False,
     list_separator: str = LIST_SEPARATOR,
     pair_separator: str = PAIR_SEPARATOR,
+    extra_serializers: SerializeObjectExtra | None = None,
 ) -> str:
     """Serialize a Dataclass."""
     mapping: StrStrMapping = {}
@@ -426,16 +430,21 @@ def serialize_dataclass(
             exclude=exclude,
             rel_tol=rel_tol,
             abs_tol=abs_tol,
-            extra=extra,
+            extra=extra_equal,
             defaults=defaults,
         ):
             mapping[fld.name] = serialize_object(
-                fld.value, list_separator=list_separator, pair_separator=pair_separator
+                fld.value,
+                list_separator=list_separator,
+                pair_separator=pair_separator,
+                extra=extra_serializers,
             )
-    joined_items = (
-        join_strs(item, separator=pair_separator) for item in mapping.items()
+    return serialize_object(
+        mapping,
+        list_separator=list_separator,
+        pair_separator=pair_separator,
+        extra=extra_serializers,
     )
-    return join_strs(joined_items, separator=list_separator)
 
 
 def parse_dataclass(
@@ -445,6 +454,7 @@ def parse_dataclass(
     *,
     list_separator: str = LIST_SEPARATOR,
     pair_separator: str = PAIR_SEPARATOR,
+    brackets: Iterable[tuple[str, str]] | None = BRACKETS,
     globalns: StrMapping | None = None,
     localns: StrMapping | None = None,
     warn_name_errors: bool = False,
@@ -457,7 +467,11 @@ def parse_dataclass(
     match text_or_mapping:
         case str() as text:
             keys_to_serializes = _parse_dataclass_split_key_value_pairs(
-                text, cls, list_separator=list_separator, pair_separator=pair_separator
+                text,
+                cls,
+                list_separator=list_separator,
+                pair_separator=pair_separator,
+                brackets=brackets,
             )
         case Mapping() as keys_to_serializes:
             ...
@@ -481,7 +495,14 @@ def parse_dataclass(
     )
     field_names_to_values = {
         f.name: _parse_dataclass_parse_text(
-            f, t, cls, head=head, case_sensitive=case_sensitive, extra=extra_parsers
+            f,
+            t,
+            cls,
+            list_separator=list_separator,
+            pair_separator=pair_separator,
+            head=head,
+            case_sensitive=case_sensitive,
+            extra=extra_parsers,
         )
         for f, t in fields_to_serializes.items()
     }
@@ -505,12 +526,16 @@ def _parse_dataclass_split_key_value_pairs(
     *,
     list_separator: str = LIST_SEPARATOR,
     pair_separator: str = PAIR_SEPARATOR,
+    brackets: Iterable[tuple[str, str]] | None = BRACKETS,
 ) -> StrStrMapping:
+    with suppress(ExtractGroupError):
+        text = extract_group(r"^\{?(.*?)\}?$", text)
     try:
         return split_key_value_pairs(
             text,
             list_separator=list_separator,
             pair_separator=pair_separator,
+            brackets=brackets,
             mapping=True,
         )
     except _SplitKeyValuePairsSplitError as error: