dycw-utilities 0.108.4__tar.gz → 0.109.1__tar.gz

{dycw_utilities-0.108.4 → dycw_utilities-0.109.1}/PKG-INFO

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

{dycw_utilities-0.108.4 → dycw_utilities-0.109.1}/pyproject.toml

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

{dycw_utilities-0.108.4 → dycw_utilities-0.109.1}/src/tests/test_dataclasses.py

@@ -1,22 +1,12 @@
 from __future__ import annotations
 
-import re
 from dataclasses import dataclass, field
 from pathlib import Path
-from re import DOTALL
 from types import NoneType
-from typing import Any, Literal, cast, override
+from typing import Any, cast, override
 
 from hypothesis import given
-from hypothesis.strategies import (
-    DataObject,
-    booleans,
-    data,
-    integers,
-    lists,
-    none,
-    sampled_from,
-)
+from hypothesis.strategies import booleans, integers, lists, sampled_from
 from polars import DataFrame
 from pytest import raises
 
@@ -27,7 +17,8 @@ from tests.test_typing_funcs.no_future import (
 from tests.test_typing_funcs.with_future import (
     DataClassFutureInt,
     DataClassFutureIntDefault,
-    DataClassFutureIntNullable,
+    DataClassFutureIntLowerAndUpper,
+    DataClassFutureIntOneAndTwo,
     DataClassFutureListInts,
     DataClassFutureListIntsDefault,
     DataClassFutureLiteral,
@@ -36,17 +27,17 @@ from tests.test_typing_funcs.with_future import (
     DataClassFutureNestedOuterFirstOuter,
     DataClassFutureNone,
     DataClassFutureNoneDefault,
-    DataClassFuturePath,
-    DataClassFutureStr,
     DataClassFutureTypeLiteral,
     DataClassFutureTypeLiteralNullable,
+    TrueOrFalseFutureLit,
+    TrueOrFalseFutureTypeLit,
 )
 from utilities.dataclasses import (
+    MappingToDataclassError,
+    OneFieldEmptyError,
+    OneFieldNonUniqueError,
+    StrMappingToFieldMappingError,
     YieldFieldsError,
-    _MappingToDataclassCaseInsensitiveNonUniqueError,
-    _MappingToDataclassEmptyError,
-    _TextToDataClassGetFieldEmptyError,
-    _TextToDataClassGetFieldNonUniqueError,
     _TextToDataClassParseValueError,
     _TextToDataClassSplitKeyValuePairError,
     _YieldFieldsClass,
@@ -54,12 +45,13 @@ from utilities.dataclasses import (
     dataclass_repr,
     dataclass_to_dict,
     mapping_to_dataclass,
+    one_field,
     replace_non_sentinel,
+    str_mapping_to_field_mapping,
     text_to_dataclass,
     yield_fields,
 )
 from utilities.functions import get_class_name
-from utilities.hypothesis import paths, text_ascii
 from utilities.iterables import one
 from utilities.orjson import OrjsonLogRecord
 from utilities.polars import are_frames_equal
@@ -67,8 +59,6 @@ from utilities.sentinel import sentinel
 from utilities.types import Dataclass, StrMapping
 from utilities.typing import get_args, is_list_type, is_literal_type, is_optional_type
 
-TruthLit = Literal["true", "false"]  # in 3.12, use type TruthLit = ...
-
 
 class TestDataClassRepr:
     def test_overriding_repr(self) -> None:
@@ -273,82 +263,102 @@ class TestDataclassToDictAndDataclassRepr:
 
 
 class TestMappingToDataclass:
-    @given(int_=integers())
-    def test_int_case_sensitive(self, *, int_: int) -> None:
-        obj = mapping_to_dataclass(DataClassFutureInt, {"int_": int_})
-        expected = DataClassFutureInt(int_=int_)
-        assert obj == expected
-
     @given(key=sampled_from(["int_", "INT_"]), int_=integers())
-    def test_int_case_insensitive(self, *, key: str, int_: int) -> None:
+    def test_exact_match_case_insensitive(self, *, key: str, int_: int) -> None:
         obj = mapping_to_dataclass(DataClassFutureInt, {key: int_})
         expected = DataClassFutureInt(int_=int_)
         assert obj == expected
 
-    @given(data=data(), int_=integers() | none())
-    def test_int_nullable(self, *, data: DataObject, int_: int | None) -> None:
-        if int_ is None:
-            mapping = data.draw(sampled_from([{"int_": int_}, {}]))
-        else:
-            mapping = {"int_": int_}
-        obj = mapping_to_dataclass(DataClassFutureIntNullable, mapping)
-        expected = DataClassFutureIntNullable(int_=int_)
+    @given(key=sampled_from(["in", "IN"]), int_=integers())
+    def test_head_case_insensitive(self, *, key: str, int_: int) -> None:
+        obj = mapping_to_dataclass(DataClassFutureInt, {key: int_}, head=True)
+        expected = DataClassFutureInt(int_=int_)
         assert obj == expected
 
-    @given(data=data(), ints=lists(integers()))
-    def test_list_ints_nullable(self, *, data: DataObject, ints: list[int]) -> None:
-        if len(ints) == 0:
-            mapping = data.draw(sampled_from([{"ints": ints}, {}]))
-        else:
-            mapping = {"ints": ints}
-        obj = mapping_to_dataclass(DataClassFutureListIntsDefault, mapping)
-        expected = DataClassFutureListIntsDefault(ints=ints)
+    @given(int_=integers())
+    def test_exact_match_case_sensitive(self, *, int_: int) -> None:
+        obj = mapping_to_dataclass(
+            DataClassFutureInt, {"int_": int_}, case_sensitive=True
+        )
+        expected = DataClassFutureInt(int_=int_)
         assert obj == expected
 
-    @given(value=paths())
-    def test_path(self, *, value: Path) -> None:
-        obj = mapping_to_dataclass(DataClassFuturePath, {"path": value})
-        expected = DataClassFuturePath(path=value)
+    @given(int_=integers())
+    def test_head_case_sensitive(self, *, int_: int) -> None:
+        obj = mapping_to_dataclass(
+            DataClassFutureInt, {"int": int_}, head=True, case_sensitive=True
+        )
+        expected = DataClassFutureInt(int_=int_)
         assert obj == expected
 
-    @given(value=text_ascii())
-    def test_post(self, *, value: str) -> None:
+    @given(int_=integers())
+    def test_extra_key(self, *, int_: int) -> None:
         obj = mapping_to_dataclass(
-            DataClassFutureStr, {"str_": value}, post=lambda _, x: x.upper()
+            DataClassFutureInt, {"int_": int_, "extra": int_}, allow_extra=True
         )
-        expected = DataClassFutureStr(str_=value.upper())
+        expected = DataClassFutureInt(int_=int_)
         assert obj == expected
 
-    @given(value=integers())
-    def test_error_case_sensitive_empty_error(self, *, value: int) -> None:
+    def test_error(self) -> None:
+        with raises(
+            MappingToDataclassError,
+            match="Unable to construct 'DataClassFutureInt'; missing values for 'int_'",
+        ):
+            _ = mapping_to_dataclass(DataClassFutureInt, {})
+
+
+class TestOneField:
+    def test_error_exact_match_case_insensitive_empty_error(self) -> None:
         with raises(
-            _MappingToDataclassEmptyError, match=r"Mapping .* does not contain 'int_'"
+            OneFieldEmptyError,
+            match=r"Dataclass 'DataClassFutureInt' does not contain a field 'invalid' \(modulo case\)",
         ):
-            _ = mapping_to_dataclass(
-                DataClassFutureInt, {"INT_": value}, case_sensitive=True
-            )
+            _ = one_field(DataClassFutureInt, "invalid")
 
-    @given(value=integers())
-    def test_error_case_insensitive_empty_error(self, *, value: int) -> None:
+    def test_error_exact_match_case_insensitive_non_unique_error(self) -> None:
         with raises(
-            _MappingToDataclassEmptyError,
-            match=r"Mapping .* does not contain 'int_' \(modulo case\)",
+            OneFieldNonUniqueError,
+            match=r"Dataclass 'DataClassFutureIntLowerAndUpper' must contain field 'int_' exactly once \(modulo case\); got 'int_', 'INT_' and perhaps more",
         ):
-            _ = mapping_to_dataclass(DataClassFutureInt, {"other": value})
+            _ = one_field(DataClassFutureIntLowerAndUpper, "int_")
 
-    @given(value1=integers(), value2=integers())
-    def test_error_case_insensitive_non_unique_error(
-        self, *, value1: int, value2: int
-    ) -> None:
+    def test_error_head_case_insensitive_empty_error(self) -> None:
         with raises(
-            _MappingToDataclassCaseInsensitiveNonUniqueError,
-            match=re.compile(
-                r"Mapping .* must contain 'int_' exactly once \(modulo case\); got 'int_', 'INT_' and perhaps more",
-                flags=DOTALL,
-            ),
+            OneFieldEmptyError,
+            match=r"Dataclass 'DataClassFutureInt' does not contain any field starting with 'invalid' \(modulo case\)",
         ):
-            _ = mapping_to_dataclass(
-                DataClassFutureInt, {"int_": value1, "INT_": value2}
+            _ = one_field(DataClassFutureInt, "invalid", head=True)
+
+    def test_error_head_case_insensitive_non_unique_error(self) -> None:
+        with raises(
+            OneFieldNonUniqueError,
+            match=r"Dataclass 'DataClassFutureIntOneAndTwo' must contain exactly one field starting with 'int' \(modulo case\); got 'int1', 'int2' and perhaps more",
+        ):
+            _ = one_field(DataClassFutureIntOneAndTwo, "int", head=True)
+
+    def test_error_exact_match_case_sensitive_empty_error(self) -> None:
+        with raises(
+            OneFieldEmptyError,
+            match=r"Dataclass 'DataClassFutureInt' does not contain a field 'INT_'",
+        ):
+            _ = one_field(DataClassFutureInt, "INT_", case_sensitive=True)
+
+    # there is no head=False, case_sensitive=True, non-unique case
+
+    def test_error_head_case_sensitive_empty_error(self) -> None:
+        with raises(
+            OneFieldEmptyError,
+            match=r"Dataclass 'DataClassFutureInt' does not contain any field starting with 'INT_'",
+        ):
+            _ = one_field(DataClassFutureInt, "INT_", head=True, case_sensitive=True)
+
+    def test_error_head_case_sensitive_non_unique_error(self) -> None:
+        with raises(
+            OneFieldNonUniqueError,
+            match=r"Dataclass 'DataClassFutureIntOneAndTwo' must contain exactly one field starting with 'int'; got 'int1', 'int2' and perhaps more",
+        ):
+            _ = one_field(
+                DataClassFutureIntOneAndTwo, "int", head=True, case_sensitive=True
             )
 
 
@@ -370,16 +380,117 @@ class TestReplaceNonSentinel:
         assert obj.int_ == 1
 
 
+class TestStrMappingToFieldMapping:
+    @given(key=sampled_from(["int_", "INT_"]), int_=integers())
+    def test_main_text_case_insensitive(self, *, key: str, int_: int) -> None:
+        result = str_mapping_to_field_mapping(DataClassFutureInt, {key: int_})
+        assert len(result) == 1
+        assert one(result) == one(yield_fields(DataClassFutureInt))
+        assert one(result.values()) == int_
+
+    @given(key=sampled_from(["in", "IN"]), int_=integers())
+    def test_head_case_insensitive(self, *, key: str, int_: int) -> None:
+        result = str_mapping_to_field_mapping(
+            DataClassFutureInt, {key: int_}, head=True
+        )
+        assert len(result) == 1
+        assert one(result) == one(yield_fields(DataClassFutureInt))
+        assert one(result.values()) == int_
+
+    @given(int_=integers())
+    def test_exact_match_case_sensitive(self, *, int_: int) -> None:
+        result = str_mapping_to_field_mapping(
+            DataClassFutureInt, {"int_": int_}, case_sensitive=True
+        )
+        assert len(result) == 1
+        assert one(result) == one(yield_fields(DataClassFutureInt))
+        assert one(result.values()) == int_
+
+    @given(int_=integers())
+    def test_head_case_sensitive(self, *, int_: int) -> None:
+        result = str_mapping_to_field_mapping(
+            DataClassFutureInt, {"int": int_}, head=True, case_sensitive=True
+        )
+        assert len(result) == 1
+        assert one(result) == one(yield_fields(DataClassFutureInt))
+        assert one(result.values()) == int_
+
+    @given(int_=integers())
+    def test_extra_key(self, *, int_: int) -> None:
+        result = str_mapping_to_field_mapping(
+            DataClassFutureInt, {"int_": int_, "extra": int_}, allow_extra=True
+        )
+        assert len(result) == 1
+        assert one(result) == one(yield_fields(DataClassFutureInt))
+        assert one(result.values()) == int_
+
+    @given(int_=integers())
+    def test_error_exact_match_case_insensitive(self, *, int_: int) -> None:
+        with raises(
+            StrMappingToFieldMappingError,
+            match=r"Dataclass 'DataClassFutureInt' does not contain a field 'invalid' \(modulo case\)",
+        ):
+            _ = str_mapping_to_field_mapping(
+                DataClassFutureInt, {"int_": int_, "invalid": int_}
+            )
+
+    @given(int_=integers())
+    def test_error_exact_match_case_sensitive(self, *, int_: int) -> None:
+        with raises(
+            StrMappingToFieldMappingError,
+            match=r"Dataclass 'DataClassFutureInt' does not contain a field 'extra'",
+        ):
+            _ = str_mapping_to_field_mapping(
+                DataClassFutureInt, {"int_": int_, "extra": int_}, case_sensitive=True
+            )
+
+    @given(int_=integers())
+    def test_error_head_case_insensitive(self, *, int_: int) -> None:
+        with raises(
+            StrMappingToFieldMappingError,
+            match=r"Dataclass .* does not contain any field starting with 'invalid' \(modulo case\)",
+        ):
+            _ = str_mapping_to_field_mapping(
+                DataClassFutureInt, {"invalid": int_}, head=True
+            )
+
+    @given(int_=integers())
+    def test_error_head_case_sensitive(self, *, int_: int) -> None:
+        with raises(
+            StrMappingToFieldMappingError,
+            match=r"Dataclass .* does not contain any field starting with 'invalid'",
+        ):
+            _ = str_mapping_to_field_mapping(
+                DataClassFutureInt, {"invalid": int_}, head=True, case_sensitive=True
+            )
+
+
 class TestTextToDataClass:
+    @given(key=sampled_from(["int_", "INT_"]), int_=integers())
+    def test_main_text_case_insensitive(self, *, key: str, int_: int) -> None:
+        result = text_to_dataclass(f"{key}={int_}", DataClassFutureInt)
+        expected = DataClassFutureInt(int_=int_)
+        assert result == expected
+
     @given(int_=integers())
-    def test_main_text(self, *, int_: int) -> None:
-        result = text_to_dataclass(f"int_={int_}", DataClassFutureInt)
+    def test_main_text_case_sensitive(self, *, int_: int) -> None:
+        result = text_to_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_main_mapping_case_insensitive(self, *, key: str, int_: int) -> None:
+        result = text_to_dataclass({key: str(int_)}, DataClassFutureInt)
         expected = DataClassFutureInt(int_=int_)
         assert result == expected
 
     @given(int_=integers())
-    def test_main_mapping(self, *, int_: int) -> None:
-        result = text_to_dataclass({"int_": str(int_)}, DataClassFutureInt)
+    def test_main_mapping_case_sensitive(self, *, int_: int) -> None:
+        result = text_to_dataclass(
+            {"int_": str(int_)}, DataClassFutureInt, case_sensitive=True
+        )
         expected = DataClassFutureInt(int_=int_)
         assert result == expected
 
@@ -390,25 +501,6 @@ class TestTextToDataClass:
         ):
             _ = text_to_dataclass("keyvalue", DataClassFutureInt)
 
-    def test_error_get_field_empty(self) -> None:
-        with raises(
-            _TextToDataClassGetFieldEmptyError,
-            match=r"Dataclass 'DataClassFutureInt' does not contain any field starting with 'k' \(modulo case\)",
-        ):
-            _ = text_to_dataclass("k=value", DataClassFutureInt)
-
-    def test_error_get_field_non_unique(self) -> None:
-        @dataclass(order=True, unsafe_hash=True, kw_only=True)
-        class Example:
-            int1: int
-            int2: int
-
-        with raises(
-            _TextToDataClassGetFieldNonUniqueError,
-            match=r"Dataclass 'Example' must contain exactly one field starting with 'int' \(modulo case\); got 'int1', 'int2' and perhaps more",
-        ):
-            _ = text_to_dataclass("int=value", Example)
-
     def test_error_parse_value(self) -> None:
         with raises(
             _TextToDataClassParseValueError,
@@ -462,21 +554,23 @@ class TestYieldFields:
         assert get_args(result.type_) == (int,)
 
     def test_class_future_literal(self) -> None:
-        result = one(yield_fields(DataClassFutureLiteral))
-        expected = _YieldFieldsClass(name="truth", type_=TruthLit, kw_only=True)
+        result = one(yield_fields(DataClassFutureLiteral, globalns=globals()))
+        expected = _YieldFieldsClass(
+            name="truth", type_=TrueOrFalseFutureLit, kw_only=True
+        )
         assert result == expected
         assert is_literal_type(result.type_)
         assert get_args(result.type_) == ("true", "false")
 
     def test_class_future_literal_nullable(self) -> None:
-        result = one(yield_fields(DataClassFutureLiteralNullable))
+        result = one(yield_fields(DataClassFutureLiteralNullable, globalns=globals()))
         expected = _YieldFieldsClass(
-            name="truth", type_=TruthLit | None, default=None, kw_only=True
+            name="truth", type_=TrueOrFalseFutureLit | None, default=None, kw_only=True
         )
         assert result == expected
         assert is_optional_type(result.type_)
         args = get_args(result.type_)
-        assert args == (Literal["true", "false"],)
+        assert args == (TrueOrFalseFutureLit,)
         arg = one(args)
         assert get_args(arg) == ("true", "false")
 
@@ -491,8 +585,14 @@ class TestYieldFields:
         assert result.type_ is DataClassFutureNestedOuterFirstInner
 
     def test_class_future_type_literal(self) -> None:
-        result = one(yield_fields(DataClassFutureTypeLiteral, globalns=globals()))
-        expected = _YieldFieldsClass(name="truth", type_=TruthLit, kw_only=True)
+        result = one(
+            yield_fields(
+                DataClassFutureTypeLiteral, globalns=globals(), localns=locals()
+            )
+        )
+        expected = _YieldFieldsClass(
+            name="truth", type_=TrueOrFalseFutureTypeLit, kw_only=True
+        )
         assert result == expected
         assert is_literal_type(result.type_)
         assert get_args(result.type_) == ("true", "false")
@@ -502,12 +602,15 @@ class TestYieldFields:
             yield_fields(DataClassFutureTypeLiteralNullable, globalns=globals())
         )
         expected = _YieldFieldsClass(
-            name="truth", type_=TruthLit | None, default=None, kw_only=True
+            name="truth",
+            type_=TrueOrFalseFutureTypeLit | None,
+            default=None,
+            kw_only=True,
         )
         assert result == expected
         assert is_optional_type(result.type_)
         args = get_args(result.type_)
-        assert args == (Literal["true", "false"],)
+        assert args == (TrueOrFalseFutureTypeLit,)
         arg = one(args)
         assert get_args(arg) == ("true", "false")
 

{dycw_utilities-0.108.4 → dycw_utilities-0.109.1}/src/tests/test_operator.py

@@ -43,6 +43,8 @@ from tests.test_typing_funcs.with_future import (
     DataClassFutureNestedInnerFirstOuter,
     DataClassFutureNestedOuterFirstOuter,
     DataClassFutureNone,
+    DataClassFutureTypeLiteral,
+    DataClassFutureTypeLiteralNullable,
 )
 from utilities.hypothesis import (
     assume_does_not_raise,
@@ -76,6 +78,8 @@ def base_objects(
     dataclass_literal_nullable: bool = False,
     dataclass_nested: bool = False,
     dataclass_none: bool = False,
+    dataclass_type_literal: bool = False,
+    dataclass_type_literal_nullable: bool = False,
     enum: bool = False,
     exception_class: bool = False,
     exception_instance: bool = False,
@@ -132,6 +136,15 @@ def base_objects(
         )
     if dataclass_none:
         base |= builds(DataClassFutureNone)
+    if dataclass_type_literal:
+        base |= builds(
+            DataClassFutureTypeLiteral, truth=sampled_from(["true", "false"])
+        )
+    if dataclass_type_literal_nullable:
+        base |= builds(
+            DataClassFutureTypeLiteralNullable,
+            truth=sampled_from(["true", "false"]) | none(),
+        )
     if enum:
         base |= sampled_from(TruthEnum)
     if exception_class:
@@ -151,6 +164,8 @@ def make_objects(
     dataclass_literal_nullable: bool = False,
     dataclass_nested: bool = False,
     dataclass_none: bool = False,
+    dataclass_type_literal: bool = False,
+    dataclass_type_literal_nullable: bool = False,
     enum: bool = False,
     exception_class: bool = False,
     exception_instance: bool = False,
@@ -173,6 +188,8 @@ def make_objects(
         dataclass_literal_nullable=dataclass_literal_nullable,
         dataclass_nested=dataclass_nested,
         dataclass_none=dataclass_none,
+        dataclass_type_literal=dataclass_type_literal,
+        dataclass_type_literal_nullable=dataclass_type_literal_nullable,
         enum=enum,
         exception_class=exception_class,
         exception_instance=exception_instance,
@@ -272,6 +289,8 @@ class TestIsEqual:
             dataclass_literal_nullable=True,
             dataclass_nested=True,
             dataclass_none=True,
+            dataclass_type_literal=True,
+            dataclass_type_literal_nullable=True,
             enum=True,
             sub_frozenset=True,
             sub_list=True,
@@ -287,12 +306,15 @@ class TestIsEqual:
         objs=pairs(
             make_objects(
                 dataclass_custom_equality=True,
+                dataclass_default_in_init_child=True,
                 dataclass_int=True,
                 dataclass_int_default=True,
                 dataclass_literal=True,
                 dataclass_literal_nullable=True,
                 dataclass_nested=True,
                 dataclass_none=True,
+                dataclass_type_literal=True,
+                dataclass_type_literal_nullable=True,
                 enum=True,
                 sub_frozenset=True,
                 sub_list=True,

{dycw_utilities-0.108.4 → dycw_utilities-0.109.1}/src/tests/test_orjson.py

@@ -48,6 +48,8 @@ from tests.test_typing_funcs.with_future import (
     DataClassFutureNestedOuterFirstInner,
     DataClassFutureNestedOuterFirstOuter,
     DataClassFutureNone,
+    DataClassFutureTypeLiteral,
+    DataClassFutureTypeLiteralNullable,
 )
 from utilities.datetime import MINUTE, SECOND, get_now, get_now_local
 from utilities.functions import is_sequence_of
@@ -435,12 +437,15 @@ class TestSerializeAndDeserialize:
     @given(
         obj=make_objects(
             dataclass_custom_equality=True,
+            dataclass_default_in_init_child=False,
             dataclass_int=True,
             dataclass_int_default=True,
             dataclass_literal=True,
             dataclass_literal_nullable=True,
             dataclass_nested=True,
             dataclass_none=True,
+            dataclass_type_literal=True,
+            dataclass_type_literal_nullable=True,
             enum=True,
             exception_class=True,
             exception_instance=True,
@@ -467,6 +472,8 @@ class TestSerializeAndDeserialize:
                 DataClassFutureNestedOuterFirstInner,
                 DataClassFutureNestedOuterFirstOuter,
                 DataClassFutureNone,
+                DataClassFutureTypeLiteral,
+                DataClassFutureTypeLiteralNullable,
                 SubFrozenSet,
                 SubList,
                 SubSet,
@@ -559,6 +566,19 @@ class TestSerializeAndDeserialize:
         result = deserialize(ser, objects={DataClassFutureNone})
         assert is_equal(result, obj)
 
+    @given(obj=make_objects(dataclass_type_literal=True))
+    def test_dataclass_type_literal(self, *, obj: Any) -> None:
+        result = deserialize(serialize(obj), objects={DataClassFutureTypeLiteral})
+        assert is_equal(result, obj)
+
+    @given(obj=make_objects(dataclass_type_literal_nullable=True))
+    def test_dataclass_type_literal_nullable(self, *, obj: Any) -> None:
+        result = deserialize(
+            serialize(obj), objects={DataClassFutureTypeLiteralNullable}
+        )
+        with assume_does_not_raise(IsEqualError):
+            assert is_equal(result, obj)
+
     @given(obj=builds(DataClassFutureNone))
     def test_dataclass_no_objects_error(self, *, obj: DataClassFutureNone) -> None:
         ser = serialize(obj)

{dycw_utilities-0.108.4 → dycw_utilities-0.109.1}/src/tests/test_parse.py

@@ -12,6 +12,10 @@ from hypothesis.strategies import booleans, dates, floats, integers, sampled_fro
 from pytest import raises
 
 from tests.test_operator import TruthEnum
+from tests.test_typing_funcs.with_future import (
+    TrueOrFalseFutureLit,
+    TrueOrFalseFutureTypeLit,
+)
 from utilities.functions import ensure_path
 from utilities.hypothesis import (
     local_datetimes,
@@ -72,7 +76,7 @@ class TestParseText:
 
     @given(truth=sampled_from(["true", "false"]))
     def test_literal(self, *, truth: Literal["true", "false"]) -> None:
-        result = parse_text(Literal["true", "false"], truth)
+        result = parse_text(TrueOrFalseFutureLit, truth)
         assert result == truth
 
     def test_nullable_int_none(self) -> None:
@@ -131,6 +135,11 @@ class TestParseText:
         result = parse_text(dt.timedelta, text)
         assert result == timedelta
 
+    @given(truth=sampled_from(["true", "false"]))
+    def test_type_literal(self, *, truth: Literal["true", "false"]) -> None:
+        result = parse_text(TrueOrFalseFutureTypeLit, truth)
+        assert result == truth
+
     @given(version=versions())
     def test_version(self, *, version: Version) -> None:
         text = str(version)