dycw-utilities 0.110.3__tar.gz → 0.110.5__tar.gz

{dycw_utilities-0.110.3 → dycw_utilities-0.110.5}/PKG-INFO

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

{dycw_utilities-0.110.3 → dycw_utilities-0.110.5}/pyproject.toml

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

{dycw_utilities-0.110.3 → dycw_utilities-0.110.5}/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.3 → dycw_utilities-0.110.5}/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.3 → dycw_utilities-0.110.5}/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,
 )
@@ -57,11 +61,11 @@ from utilities.version import Version
 
 
 class TestSerializeAndParseObject:
-    @given(value=booleans())
-    def test_bool(self, *, value: bool) -> None:
-        serialized = serialize_object(value)
+    @given(bool_=booleans())
+    def test_bool(self, *, bool_: bool) -> None:
+        serialized = serialize_object(bool_)
         result = parse_object(bool, serialized)
-        assert result is value
+        assert result is bool_
 
     @given(date=dates())
     def test_date(self, *, date: dt.date) -> None:
@@ -75,11 +79,11 @@ class TestSerializeAndParseObject:
         result = parse_object(dt.datetime, serialized)
         assert result == datetime
 
-    @given(value=dictionaries(dates(), zoned_datetimes()))
-    def test_dict(self, *, value: dict[dt.date, dt.datetime]) -> None:
-        serialized = serialize_object(value)
+    @given(mapping=dictionaries(dates(), zoned_datetimes()))
+    def test_dict(self, *, mapping: dict[dt.date, dt.datetime]) -> None:
+        serialized = serialize_object(mapping)
         result = parse_object(dict[dt.date, dt.datetime], serialized)
-        assert result == value
+        assert result == mapping
 
     @given(duration=datetime_durations(two_way=True))
     def test_duration(self, *, duration: Duration) -> None:
@@ -93,26 +97,22 @@ class TestSerializeAndParseObject:
         result = parse_object(TruthEnum, serialized)
         assert result is truth
 
-    @given(value=integers())
-    def test_extra_type(self, *, value: int) -> None:
-        serialized = serialize_object(value)
+    @given(int_=integers())
+    def test_extra_type(self, *, int_: int) -> None:
+        serialized = serialize_object(int_)
         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)
+        expected = DataClassFutureInt(int_=int_)
         assert result == expected
 
-    @given(value=floats())
-    def test_float(self, *, value: float) -> None:
-        serialized = serialize_object(value)
+    @given(float_=floats())
+    def test_float(self, *, float_: float) -> None:
+        serialized = serialize_object(float_)
         result = parse_object(float, serialized)
-        assert is_equal(result, value)
+        assert is_equal(result, float_)
 
     @given(values=frozensets(dates()))
     def test_frozenset(self, *, values: frozenset[dt.date]) -> None:
@@ -120,11 +120,11 @@ class TestSerializeAndParseObject:
         result = parse_object(frozenset[dt.date], serialized)
         assert result == values
 
-    @given(value=integers())
-    def test_int(self, *, value: int) -> None:
-        serialized = serialize_object(value)
+    @given(int_=integers())
+    def test_int(self, *, int_: int) -> None:
+        serialized = serialize_object(int_)
         result = parse_object(int, serialized)
-        assert result == value
+        assert result == int_
 
     @given(values=lists(dates()))
     def test_list(self, *, values: list[dt.date]) -> None:
@@ -193,11 +193,11 @@ class TestSerializeAndParseObject:
         result = parse_object(int | None, serialized)
         assert result is None
 
-    @given(value=integers())
-    def test_nullable_int_int(self, *, value: int) -> None:
-        serialized = serialize_object(value)
+    @given(int_=integers())
+    def test_nullable_int_int(self, *, int_: int) -> None:
+        serialized = serialize_object(int_)
         result = parse_object(int | None, serialized)
-        assert result == value
+        assert result == int_
 
     def test_sentinel(self) -> None:
         serialized = serialize_object(sentinel)
@@ -238,58 +238,58 @@ class TestSerializeAndParseObject:
         result = parse_object(TrueOrFalseFutureTypeLit, truth)
         assert result == truth
 
-    @given(value=integers())
-    def test_type_union_with_extra(self, *, value: int) -> None:
-        def parse_even_or_odd(text: str, /) -> DataClassFutureIntEvenOrOddTypeUnion:
-            value = int(text)
-            match value % 2:
+    @given(int_=integers())
+    def test_type_union_with_extra(self, *, int_: int) -> None:
+        def parser(text: str, /) -> DataClassFutureIntEvenOrOddTypeUnion:
+            int_ = int(text)
+            match int_ % 2:
                 case 0:
-                    return DataClassFutureIntEven(even_int=value)
+                    return DataClassFutureIntEven(even_int=int_)
                 case 1:
-                    return DataClassFutureIntOdd(odd_int=value)
+                    return DataClassFutureIntOdd(odd_int=int_)
                 case _:
-                    raise ImpossibleCaseError(case=[f"{value=}"])
+                    raise ImpossibleCaseError(case=[f"{int_=}"])
 
-        serialized = serialize_object(value)
+        serialized = serialize_object(int_)
         result = parse_object(
             DataClassFutureIntEvenOrOddTypeUnion,
             serialized,
-            extra={DataClassFutureIntEvenOrOddTypeUnion: parse_even_or_odd},
+            extra={DataClassFutureIntEvenOrOddTypeUnion: parser},
         )
-        match value % 2:
+        match int_ % 2:
             case 0:
-                expected = DataClassFutureIntEven(even_int=value)
+                expected = DataClassFutureIntEven(even_int=int_)
             case 1:
-                expected = DataClassFutureIntOdd(odd_int=value)
+                expected = DataClassFutureIntOdd(odd_int=int_)
             case _:
-                raise ImpossibleCaseError(case=[f"{value=}"])
+                raise ImpossibleCaseError(case=[f"{int_=}"])
         assert result == expected
 
-    @given(value=integers())
-    def test_union_with_extra(self, *, value: int) -> None:
-        def parse_even_or_odd(text: str, /) -> DataClassFutureIntEvenOrOddUnion:
-            value = int(text)
-            match value % 2:
+    @given(int_=integers())
+    def test_union_with_extra(self, *, int_: int) -> None:
+        def parser(text: str, /) -> DataClassFutureIntEvenOrOddUnion:
+            int_ = int(text)
+            match int_ % 2:
                 case 0:
-                    return DataClassFutureIntEven(even_int=value)
+                    return DataClassFutureIntEven(even_int=int_)
                 case 1:
-                    return DataClassFutureIntOdd(odd_int=value)
+                    return DataClassFutureIntOdd(odd_int=int_)
                 case _:
-                    raise ImpossibleCaseError(case=[f"{value=}"])
+                    raise ImpossibleCaseError(case=[f"{int_=}"])
 
-        serialized = serialize_object(value)
+        serialized = serialize_object(int_)
         result = parse_object(
             DataClassFutureIntEvenOrOddUnion,
             serialized,
-            extra={DataClassFutureIntEvenOrOddUnion: parse_even_or_odd},
+            extra={DataClassFutureIntEvenOrOddUnion: parser},
         )
-        match value % 2:
+        match int_ % 2:
             case 0:
-                expected = DataClassFutureIntEven(even_int=value)
+                expected = DataClassFutureIntEven(even_int=int_)
             case 1:
-                expected = DataClassFutureIntOdd(odd_int=value)
+                expected = DataClassFutureIntOdd(odd_int=int_)
             case _:
-                raise ImpossibleCaseError(case=[f"{value=}"])
+                raise ImpossibleCaseError(case=[f"{int_=}"])
         assert result == expected
 
     @given(version=versions())
@@ -299,7 +299,7 @@ class TestSerializeAndParseObject:
         assert result == version
 
 
-class TestParseSerialized:
+class TestParseObject:
     def test_error_bool(self) -> None:
         with raises(
             _ParseObjectParseError,
@@ -355,29 +355,22 @@ class TestParseSerialized:
         ):
             _ = parse_object(DataClassFutureInt, "invalid", extra={})
 
-    @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): ...
-
+    @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(
-                Child,
-                serialize_object(value),
+                DataClassFutureIntChild,
+                serialize_object(int_),
                 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,90 @@ class TestParseSerialized:
 
 
 class TestSerializeObject:
+    @given(int_=integers())
+    def test_type_with_extra(self, *, int_: int) -> None:
+        obj = DataClassFutureInt(int_=int_)
+
+        def serializer(obj: DataClassFutureInt, /) -> str:
+            return str(obj.int_)
+
+        serialized = serialize_object(obj, extra={DataClassFutureInt: serializer})
+        expected = str(int_)
+        assert serialized == expected
+
+    @given(int_=integers())
+    def test_type_union_with_extra(self, *, int_: int) -> None:
+        match int_ % 2:
+            case 0:
+                obj = DataClassFutureIntEven(even_int=int_)
+            case 1:
+                obj = DataClassFutureIntOdd(odd_int=int_)
+            case _:
+                raise ImpossibleCaseError(case=[f"{int_=}"])
+
+        def serializer(obj: DataClassFutureIntEvenOrOddTypeUnion, /) -> str:
+            match obj:
+                case DataClassFutureIntEven():
+                    return str(obj.even_int)
+                case DataClassFutureIntOdd():
+                    return str(obj.odd_int)
+
+        serialized = serialize_object(
+            obj, extra={DataClassFutureIntEvenOrOddTypeUnion: serializer}
+        )
+        expected = str(int_)
+        assert serialized == expected
+
+    @given(int_=integers())
+    def test_union_with_extra(self, *, int_: int) -> None:
+        match int_ % 2:
+            case 0:
+                obj = DataClassFutureIntEven(even_int=int_)
+            case 1:
+                obj = DataClassFutureIntOdd(odd_int=int_)
+            case _:
+                raise ImpossibleCaseError(case=[f"{int_=}"])
+
+        def serializer(obj: DataClassFutureIntEvenOrOddUnion, /) -> str:
+            match obj:
+                case DataClassFutureIntEven():
+                    return str(obj.even_int)
+                case DataClassFutureIntOdd():
+                    return str(obj.odd_int)
+
+        serialized = serialize_object(
+            obj, extra={DataClassFutureIntEvenOrOddUnion: serializer}
+        )
+        expected = str(int_)
+        assert serialized == expected
+
+    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.3 → dycw_utilities-0.110.5}/src/tests/test_text.py

@@ -91,6 +91,7 @@ class TestSplitKeyValuePairs:
             ("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:

{dycw_utilities-0.110.3 → dycw_utilities-0.110.5}/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.3 → dycw_utilities-0.110.5}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.110.3"
+__version__ = "0.110.5"