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

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

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

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

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

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

@@ -33,16 +33,22 @@ from tests.test_typing_funcs.with_future import (
     TrueOrFalseFutureTypeLit,
 )
 from utilities.dataclasses import (
-    MappingToDataclassError,
-    OneFieldEmptyError,
-    OneFieldNonUniqueError,
-    StrMappingToFieldMappingError,
     YieldFieldsError,
+    _MappingToDataClassEmptyError,
+    _MappingToDataClassMissingValuesError,
+    _MappingToDataClassNonUniqueError,
+    _OneFieldEmptyError,
+    _OneFieldNonUniqueError,
     _parse_dataclass_split_key_value_pairs,
+    _ParseDataClassMissingValuesError,
     _ParseDataClassSplitKeyValuePairsDuplicateKeysError,
     _ParseDataClassSplitKeyValuePairsSplitError,
+    _ParseDataClassStrMappingToFieldMappingEmptyError,
+    _ParseDataClassStrMappingToFieldMappingNonUniqueError,
     _ParseDataClassTextExtraNonUniqueError,
     _ParseDataClassTextParseError,
+    _StrMappingToFieldMappingEmptyError,
+    _StrMappingToFieldMappingNonUniqueError,
     _YieldFieldsClass,
     _YieldFieldsInstance,
     dataclass_repr,
@@ -101,7 +107,7 @@ class TestDataClassRepr:
         assert result == expected
 
 
-class TestDataclassToDictAndDataclassRepr:
+class TestDataClassToDictAndDataClassRepr:
     @given(x=integers(), defaults=booleans())
     def test_field_without_defaults(self, *, x: int, defaults: bool) -> None:
         @dataclass(kw_only=True, slots=True)
@@ -222,7 +228,7 @@ class TestDataclassToDictAndDataclassRepr:
         dict_exp = {"inner": Inner(), "y": y}
         assert dict_res == dict_exp
         repr_res = dataclass_repr(obj, localns=locals())
-        repr_exp = f"Outer(inner=TestDataclassToDictAndDataclassRepr.test_nested_without_recursive.<locals>.Inner(x=0), y={y})"
+        repr_exp = f"Outer(inner=TestDataClassToDictAndDataClassRepr.test_nested_without_recursive.<locals>.Inner(x=0), y={y})"
         assert repr_res == repr_exp
 
     @given(y=lists(integers()), z=integers())
@@ -262,11 +268,11 @@ class TestDataclassToDictAndDataclassRepr:
         dict_exp = {"inner": [Inner(x=0)], "y": y, "z": z}
         assert dict_res == dict_exp
         repr_res = dataclass_repr(obj, localns=locals())
-        repr_exp = f"Outer(inner=[TestDataclassToDictAndDataclassRepr.test_nested_in_list_without_recursive.<locals>.Inner(x=0)], y={y}, z={z})"
+        repr_exp = f"Outer(inner=[TestDataClassToDictAndDataClassRepr.test_nested_in_list_without_recursive.<locals>.Inner(x=0)], y={y}, z={z})"
         assert repr_res == repr_exp
 
 
-class TestMappingToDataclass:
+class TestMappingToDataClass:
     @given(key=sampled_from(["int_", "INT_"]), int_=integers())
     def test_exact_match_case_insensitive(self, *, key: str, int_: int) -> None:
         obj = mapping_to_dataclass(DataClassFutureInt, {key: int_})
@@ -303,62 +309,155 @@ class TestMappingToDataclass:
         expected = DataClassFutureInt(int_=int_)
         assert obj == expected
 
-    def test_error(self) -> None:
+    @given(int_=integers())
+    def test_error_exact_match_case_insensitive_empty(self, *, int_: int) -> None:
+        with raises(
+            _MappingToDataClassEmptyError,
+            match=r"Dataclass 'DataClassFutureInt' does not contain a field 'invalid' \(modulo case\)",
+        ):
+            _ = mapping_to_dataclass(
+                DataClassFutureInt, {"int_": int_, "invalid": int_}
+            )
+
+    @given(int_=integers())
+    def test_error_exact_match_case_insensitive_non_unique(self, *, int_: int) -> None:
+        with raises(
+            _MappingToDataClassNonUniqueError,
+            match=r"Dataclass 'DataClassFutureIntLowerAndUpper' must contain field 'int_' exactly once \(modulo case\); got 'int_', 'INT_' and perhaps more",
+        ):
+            _ = mapping_to_dataclass(DataClassFutureIntLowerAndUpper, {"int_": int_})
+
+    @given(int_=integers())
+    def test_error_head_case_insensitive_empty(self, *, int_: int) -> None:
         with raises(
-            MappingToDataclassError,
+            _MappingToDataClassEmptyError,
+            match=r"Dataclass 'DataClassFutureInt' does not contain any field starting with 'invalid' \(modulo case\)",
+        ):
+            _ = mapping_to_dataclass(DataClassFutureInt, {"invalid": int_}, head=True)
+
+    @given(int_=integers())
+    def test_error_head_case_insensitive_non_unique(self, *, int_: int) -> None:
+        with raises(
+            _MappingToDataClassNonUniqueError,
+            match=r"Dataclass 'DataClassFutureIntOneAndTwo' must contain exactly one field starting with 'int' \(modulo case\); got 'int1', 'int2' and perhaps more",
+        ):
+            _ = mapping_to_dataclass(
+                DataClassFutureIntOneAndTwo, {"int": int_}, head=True
+            )
+
+    @given(int_=integers())
+    def test_error_exact_match_case_sensitive_empty(self, *, int_: int) -> None:
+        with raises(
+            _MappingToDataClassEmptyError,
+            match=r"Dataclass 'DataClassFutureInt' does not contain a field 'extra'",
+        ):
+            _ = mapping_to_dataclass(
+                DataClassFutureInt, {"int_": int_, "extra": int_}, case_sensitive=True
+            )
+
+    # there is no head=False, case_sensitive=True, non-unique case
+
+    @given(int_=integers())
+    def test_error_head_case_sensitive_empty(self, *, int_: int) -> None:
+        with raises(
+            _MappingToDataClassEmptyError,
+            match=r"Dataclass 'DataClassFutureInt' does not contain any field starting with 'invalid'",
+        ):
+            _ = mapping_to_dataclass(
+                DataClassFutureInt, {"invalid": int_}, head=True, case_sensitive=True
+            )
+
+    @given(int_=integers())
+    def test_error_head_case_sensitive_non_unique(self, *, int_: int) -> None:
+        with raises(
+            _MappingToDataClassNonUniqueError,
+            match=r"Dataclass 'DataClassFutureIntOneAndTwo' must contain exactly one field starting with 'int'; got 'int1', 'int2' and perhaps more",
+        ):
+            _ = mapping_to_dataclass(
+                DataClassFutureIntOneAndTwo,
+                {"int": int_},
+                head=True,
+                case_sensitive=True,
+            )
+
+    def test_error_missing_values(self) -> None:
+        with raises(
+            _MappingToDataClassMissingValuesError,
             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:
+    @given(key=sampled_from(["int_", "INT_"]))
+    def test_exact_match_case_insensitive(self, *, key: str) -> None:
+        obj = one_field(DataClassFutureInt, key)
+        expected = one(yield_fields(DataClassFutureInt))
+        assert obj == expected
+
+    @given(key=sampled_from(["in", "IN"]))
+    def test_head_case_insensitive(self, *, key: str) -> None:
+        obj = one_field(DataClassFutureInt, key, head=True)
+        expected = one(yield_fields(DataClassFutureInt))
+        assert obj == expected
+
+    def test_exact_match_case_sensitive(self) -> None:
+        obj = one_field(DataClassFutureInt, "int_", case_sensitive=True)
+        expected = one(yield_fields(DataClassFutureInt))
+        assert obj == expected
+
+    def test_head_case_sensitive(self) -> None:
+        obj = one_field(DataClassFutureInt, "int", head=True, case_sensitive=True)
+        expected = one(yield_fields(DataClassFutureInt))
+        assert obj == expected
+
+    def test_error_exact_match_case_insensitive_empty(self) -> None:
         with raises(
-            OneFieldEmptyError,
+            _OneFieldEmptyError,
             match=r"Dataclass 'DataClassFutureInt' does not contain a field 'invalid' \(modulo case\)",
         ):
             _ = one_field(DataClassFutureInt, "invalid")
 
-    def test_error_exact_match_case_insensitive_non_unique_error(self) -> None:
+    def test_error_exact_match_case_insensitive_non_unique(self) -> None:
         with raises(
-            OneFieldNonUniqueError,
+            _OneFieldNonUniqueError,
             match=r"Dataclass 'DataClassFutureIntLowerAndUpper' must contain field 'int_' exactly once \(modulo case\); got 'int_', 'INT_' and perhaps more",
         ):
             _ = one_field(DataClassFutureIntLowerAndUpper, "int_")
 
-    def test_error_head_case_insensitive_empty_error(self) -> None:
+    def test_error_head_case_insensitive_empty(self) -> None:
         with raises(
-            OneFieldEmptyError,
+            _OneFieldEmptyError,
             match=r"Dataclass 'DataClassFutureInt' does not contain any field starting with 'invalid' \(modulo case\)",
         ):
             _ = one_field(DataClassFutureInt, "invalid", head=True)
 
-    def test_error_head_case_insensitive_non_unique_error(self) -> None:
+    def test_error_head_case_insensitive_non_unique(self) -> None:
         with raises(
-            OneFieldNonUniqueError,
+            _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:
+    def test_error_exact_match_case_sensitive_empty(self) -> None:
         with raises(
-            OneFieldEmptyError,
+            _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:
+    def test_error_head_case_sensitive_empty(self) -> None:
         with raises(
-            OneFieldEmptyError,
+            _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:
+    def test_error_head_case_sensitive_non_unique(self) -> None:
         with raises(
-            OneFieldNonUniqueError,
+            _OneFieldNonUniqueError,
             match=r"Dataclass 'DataClassFutureIntOneAndTwo' must contain exactly one field starting with 'int'; got 'int1', 'int2' and perhaps more",
         ):
             _ = one_field(
@@ -501,10 +600,84 @@ class TestSerializeAndParseDataClass:
                 extra_parsers={int | str: int, int | float: int},
             )
 
+    @given(int_=integers())
+    def test_error_exact_match_case_insensitive_empty(self, *, int_: int) -> None:
+        with raises(
+            _ParseDataClassStrMappingToFieldMappingEmptyError,
+            match=r"Unable to construct 'DataClassFutureInt' since it does not contain a field 'invalid' \(modulo case\)",
+        ):
+            _ = parse_dataclass(f"int_={int_},invalid={int_}", DataClassFutureInt)
+
+    @given(int_=integers())
+    def test_error_exact_match_case_insensitive_non_unique(self, *, int_: int) -> None:
+        with raises(
+            _ParseDataClassStrMappingToFieldMappingNonUniqueError,
+            match=r"Unable to construct 'DataClassFutureIntLowerAndUpper' since it must contain field 'int_' exactly once \(modulo case\); got 'int_', 'INT_' and perhaps more",
+        ):
+            _ = parse_dataclass(f"int_={int_}", DataClassFutureIntLowerAndUpper)
+
+    @given(int_=integers())
+    def test_error_head_case_insensitive_empty(self, *, int_: int) -> None:
+        with raises(
+            _ParseDataClassStrMappingToFieldMappingEmptyError,
+            match=r"Unable to construct 'DataClassFutureInt' since it does not contain any field starting with 'invalid' \(modulo case\)",
+        ):
+            _ = parse_dataclass(f"invalid={int_}", DataClassFutureInt, head=True)
+
+    @given(int_=integers())
+    def test_error_head_case_insensitive_non_unique(self, *, int_: int) -> None:
+        with raises(
+            _ParseDataClassStrMappingToFieldMappingNonUniqueError,
+            match=r"Unable to construct 'DataClassFutureIntOneAndTwo' since it must contain exactly one field starting with 'int' \(modulo case\); got 'int1', 'int2' and perhaps more",
+        ):
+            _ = parse_dataclass(f"int={int_}", DataClassFutureIntOneAndTwo, head=True)
+
+    @given(int_=integers())
+    def test_error_exact_match_case_sensitive_empty(self, *, int_: int) -> None:
+        with raises(
+            _ParseDataClassStrMappingToFieldMappingEmptyError,
+            match=r"Unable to construct 'DataClassFutureInt' since it does not contain a field 'extra'",
+        ):
+            _ = parse_dataclass(
+                f"int_={int_},extra={int_}", DataClassFutureInt, case_sensitive=True
+            )
+
+    # there is no head=False, case_sensitive=True, non-unique case
+
+    @given(int_=integers())
+    def test_error_head_case_sensitive_empty(self, *, int_: int) -> None:
+        with raises(
+            _ParseDataClassStrMappingToFieldMappingEmptyError,
+            match=r"Unable to construct 'DataClassFutureInt' since it does not contain any field starting with 'invalid'",
+        ):
+            _ = parse_dataclass(
+                f"invalid={int_}", DataClassFutureInt, head=True, case_sensitive=True
+            )
+
+    @given(int_=integers())
+    def test_error_head_case_sensitive_non_unique(self, *, int_: int) -> None:
+        with raises(
+            _ParseDataClassStrMappingToFieldMappingNonUniqueError,
+            match=r"Unable to construct 'DataClassFutureIntOneAndTwo' since it must contain exactly one field starting with 'int'; got 'int1', 'int2' and perhaps more",
+        ):
+            _ = parse_dataclass(
+                f"int={int_}",
+                DataClassFutureIntOneAndTwo,
+                head=True,
+                case_sensitive=True,
+            )
+
+    def test_error_missing_values(self) -> None:
+        with raises(
+            _ParseDataClassMissingValuesError,
+            match="Unable to construct 'DataClassFutureInt'; missing values for 'int_'",
+        ):
+            _ = parse_dataclass("", DataClassFutureInt)
+
 
 class TestStrMappingToFieldMapping:
     @given(key=sampled_from(["int_", "INT_"]), int_=integers())
-    def test_main_text_case_insensitive(self, *, key: str, int_: int) -> None:
+    def test_exact_match_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))
@@ -547,9 +720,9 @@ class TestStrMappingToFieldMapping:
         assert one(result.values()) == int_
 
     @given(int_=integers())
-    def test_error_exact_match_case_insensitive(self, *, int_: int) -> None:
+    def test_error_exact_match_case_insensitive_empty(self, *, int_: int) -> None:
         with raises(
-            StrMappingToFieldMappingError,
+            _StrMappingToFieldMappingEmptyError,
             match=r"Dataclass 'DataClassFutureInt' does not contain a field 'invalid' \(modulo case\)",
         ):
             _ = str_mapping_to_field_mapping(
@@ -557,35 +730,70 @@ class TestStrMappingToFieldMapping:
             )
 
     @given(int_=integers())
-    def test_error_exact_match_case_sensitive(self, *, int_: int) -> None:
+    def test_error_exact_match_case_insensitive_non_unique(self, *, int_: int) -> None:
         with raises(
-            StrMappingToFieldMappingError,
-            match=r"Dataclass 'DataClassFutureInt' does not contain a field 'extra'",
+            _StrMappingToFieldMappingNonUniqueError,
+            match=r"Dataclass 'DataClassFutureIntLowerAndUpper' must contain field 'int_' exactly once \(modulo case\); got 'int_', 'INT_' and perhaps more",
         ):
             _ = str_mapping_to_field_mapping(
-                DataClassFutureInt, {"int_": int_, "extra": int_}, case_sensitive=True
+                DataClassFutureIntLowerAndUpper, {"int_": int_}
             )
 
     @given(int_=integers())
-    def test_error_head_case_insensitive(self, *, int_: int) -> None:
+    def test_error_head_case_insensitive_empty(self, *, int_: int) -> None:
         with raises(
-            StrMappingToFieldMappingError,
-            match=r"Dataclass .* does not contain any field starting with 'invalid' \(modulo case\)",
+            _StrMappingToFieldMappingEmptyError,
+            match=r"Dataclass 'DataClassFutureInt' 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:
+    def test_error_head_case_insensitive_non_unique(self, *, int_: int) -> None:
+        with raises(
+            _StrMappingToFieldMappingNonUniqueError,
+            match=r"Dataclass 'DataClassFutureIntOneAndTwo' must contain exactly one field starting with 'int' \(modulo case\); got 'int1', 'int2' and perhaps more",
+        ):
+            _ = str_mapping_to_field_mapping(
+                DataClassFutureIntOneAndTwo, {"int": int_}, head=True
+            )
+
+    @given(int_=integers())
+    def test_error_exact_match_case_sensitive_empty(self, *, int_: int) -> None:
+        with raises(
+            _StrMappingToFieldMappingEmptyError,
+            match=r"Dataclass 'DataClassFutureInt' does not contain a field 'extra'",
+        ):
+            _ = str_mapping_to_field_mapping(
+                DataClassFutureInt, {"int_": int_, "extra": int_}, case_sensitive=True
+            )
+
+    # there is no head=False, case_sensitive=True, non-unique case
+
+    @given(int_=integers())
+    def test_error_head_case_sensitive_empty(self, *, int_: int) -> None:
         with raises(
-            StrMappingToFieldMappingError,
-            match=r"Dataclass .* does not contain any field starting with 'invalid'",
+            _StrMappingToFieldMappingEmptyError,
+            match=r"Dataclass 'DataClassFutureInt' does not contain any field starting with 'invalid'",
         ):
             _ = str_mapping_to_field_mapping(
                 DataClassFutureInt, {"invalid": int_}, head=True, case_sensitive=True
             )
 
+    @given(int_=integers())
+    def test_error_head_case_sensitive_non_unique(self, *, int_: int) -> None:
+        with raises(
+            _StrMappingToFieldMappingNonUniqueError,
+            match=r"Dataclass 'DataClassFutureIntOneAndTwo' must contain exactly one field starting with 'int'; got 'int1', 'int2' and perhaps more",
+        ):
+            _ = str_mapping_to_field_mapping(
+                DataClassFutureIntOneAndTwo,
+                {"int": int_},
+                head=True,
+                case_sensitive=True,
+            )
+
 
 class TestYieldFields:
     def test_class_no_future_int(self) -> None:

{dycw_utilities-0.112.6 → dycw_utilities-0.112.8}/src/tests/test_logging.py

@@ -568,6 +568,7 @@ class TestSizeAndTimeRotatingFileHandler:
                 p for p in files if search(r"^log\.3__[\dT]+__[\dT]+\.txt$", p.name)
             )
 
+    @mark.flaky
     @skipif_windows
     def test_time(self, *, tmp_path: Path) -> None:
         logger = getLogger(str(tmp_path))

{dycw_utilities-0.112.6 → dycw_utilities-0.112.8}/src/tests/test_redis.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, Any
 
 from hypothesis import HealthCheck, Phase, given, settings
 from hypothesis.strategies import DataObject, booleans, data
+from pytest import mark
 from redis.asyncio import Redis
 
 from tests.conftest import SKIPIF_CI_AND_NOT_LINUX
@@ -40,6 +41,7 @@ class TestPublishAndSubscribe:
         ),
         obj=make_objects(),
     )
+    @mark.flaky
     @settings(
         max_examples=1,
         phases={Phase.generate},
@@ -110,6 +112,7 @@ class TestPublisher:
         ),
         obj=make_objects(),
     )
+    @mark.flaky
     @settings(
         max_examples=1,
         phases={Phase.generate},

{dycw_utilities-0.112.6 → dycw_utilities-0.112.8}/src/tests/test_text.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from itertools import chain
 from typing import TYPE_CHECKING
 
 from hypothesis import given
@@ -44,14 +45,38 @@ if TYPE_CHECKING:
 class TestParseBool:
     @given(data=data(), value=booleans())
     def test_main(self, *, data: DataObject, value: bool) -> None:
-        text = str(value)
-        text_use = data.draw(
-            sampled_from([str(int(value)), text, text.lower(), text.upper()])
+        match value:
+            case True:
+                extra_cased_texts = ["Y", "Yes", "On"]
+            case False:
+                extra_cased_texts = ["N", "No", "Off"]
+        all_cased_texts = list(chain([str(value), str(int(value))], extra_cased_texts))
+        all_texts = list(
+            chain(
+                extra_cased_texts,
+                map(str.lower, all_cased_texts),
+                map(str.upper, all_cased_texts),
+            )
         )
-        result = parse_bool(text_use)
+        text = data.draw(sampled_from(all_texts))
+        result = parse_bool(text)
         assert result is value
 
-    @given(text=sampled_from(["invalid", "11", "00", "ttruee", "ffalsee"]))
+    @given(
+        text=sampled_from([
+            "00",
+            "11",
+            "ffalsee",
+            "invalid",
+            "nn",
+            "nnoo",
+            "oofff",
+            "oonn",
+            "ttruee",
+            "yy",
+            "yyess",
+        ])
+    )
     def test_error(self, *, text: str) -> None:
         with raises(ParseBoolError, match="Unable to parse boolean value; got '.*'"):
             _ = parse_bool(text)

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

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