dycw-utilities 0.109.0__tar.gz → 0.109.2__tar.gz

{dycw_utilities-0.109.0 → dycw_utilities-0.109.2}/PKG-INFO

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

{dycw_utilities-0.109.0 → dycw_utilities-0.109.2}/pyproject.toml

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

{dycw_utilities-0.109.0 → dycw_utilities-0.109.2}/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, 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,19 +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,
@@ -56,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
@@ -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(
-            _MappingToDataclassEmptyError, match=r"Mapping .* does not contain 'int_'"
+            MappingToDataclassError,
+            match="Unable to construct 'DataClassFutureInt'; missing values for 'int_'",
         ):
-            _ = mapping_to_dataclass(
-                DataClassFutureInt, {"INT_": value}, case_sensitive=True
-            )
+            _ = mapping_to_dataclass(DataClassFutureInt, {})
+
 
-    @given(value=integers())
-    def test_error_case_insensitive_empty_error(self, *, value: int) -> None:
+class TestOneField:
+    def test_error_exact_match_case_insensitive_empty_error(self) -> None:
         with raises(
-            _MappingToDataclassEmptyError,
-            match=r"Mapping .* does not contain 'int_' \(modulo case\)",
+            OneFieldEmptyError,
+            match=r"Dataclass 'DataClassFutureInt' does not contain a field 'invalid' \(modulo case\)",
         ):
-            _ = mapping_to_dataclass(DataClassFutureInt, {"other": value})
+            _ = one_field(DataClassFutureInt, "invalid")
 
-    @given(value1=integers(), value2=integers())
-    def test_error_case_insensitive_non_unique_error(
-        self, *, value1: int, value2: int
-    ) -> None:
+    def test_error_exact_match_case_insensitive_non_unique_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,
-            ),
+            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:
+        with raises(
+            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:
+        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_'",
         ):
-            _ = mapping_to_dataclass(
-                DataClassFutureInt, {"int_": value1, "INT_": value2}
+            _ = 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,

{dycw_utilities-0.109.0 → dycw_utilities-0.109.2}/src/tests/test_python_dotenv.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import re
 from dataclasses import dataclass
 from re import DOTALL
-from typing import TYPE_CHECKING, Literal
+from typing import TYPE_CHECKING
 
 from hypothesis import given
 from hypothesis.strategies import DataObject, booleans, data, integers, sampled_from
@@ -14,9 +14,8 @@ from utilities.hypothesis import git_repos, settings_with_reduced_examples, text
 from utilities.os import temp_environ
 from utilities.python_dotenv import (
     _LoadSettingsDuplicateKeysError,
-    _LoadSettingsEmptyError,
     _LoadSettingsFileNotFoundError,
-    _LoadSettingsParseTextError,
+    _LoadSettingsMissingKeysError,
     load_settings,
 )
 
@@ -87,22 +86,6 @@ class TestLoadSettings:
         expected = Settings(key=value)
         assert settings == expected
 
-    @given(root=git_repos(), value=sampled_from(["true", "false"]))
-    @settings_with_reduced_examples()
-    def test_literal_value(
-        self, *, root: Path, value: Literal["true", "false"]
-    ) -> None:
-        @dataclass(kw_only=True, slots=True)
-        class Settings:
-            key: Literal["true", "false"]
-
-        with root.joinpath(".env").open(mode="w") as fh:
-            _ = fh.write(f"key = {value}\n")
-
-        settings = load_settings(Settings, cwd=root)
-        expected = Settings(key=value)
-        assert settings == expected
-
     @given(root=git_repos())
     @settings_with_reduced_examples()
     def test_error_file_not_found(self, *, root: Path) -> None:
@@ -135,7 +118,7 @@ class TestLoadSettings:
 
     @given(root=git_repos())
     @settings_with_reduced_examples()
-    def test_error_field_missing(self, *, root: Path) -> None:
+    def test_error_missing_keys(self, *, root: Path) -> None:
         @dataclass(kw_only=True, slots=True)
         class Settings:
             key: str
@@ -143,22 +126,7 @@ class TestLoadSettings:
         root.joinpath(".env").touch()
 
         with raises(
-            _LoadSettingsEmptyError, match=r"Field 'key' must exist \(modulo case\)"
-        ):
-            _ = load_settings(Settings, cwd=root)
-
-    @given(root=git_repos())
-    @settings_with_reduced_examples()
-    def test_error_parse_text(self, *, root: Path) -> None:
-        @dataclass(kw_only=True, slots=True)
-        class Settings:
-            key: int
-
-        with root.joinpath(".env").open(mode="w") as fh:
-            _ = fh.write("key = '...'\n")
-
-        with raises(
-            _LoadSettingsParseTextError,
-            match=r"Unable to parse field 'key' of type <class 'int'>; got '...'",
+            _LoadSettingsMissingKeysError,
+            match=r"Unable to load '.*'; missing value\(s\) for 'key'",
         ):
             _ = load_settings(Settings, cwd=root)

{dycw_utilities-0.109.0 → dycw_utilities-0.109.2}/src/tests/test_typing.py

@@ -10,7 +10,7 @@ from uuid import UUID
 
 from hypothesis import given
 from hypothesis.strategies import DataObject, data, just, none, sampled_from
-from pytest import mark, param
+from pytest import mark, param, raises
 
 from tests.test_typing_funcs.no_future import (
     DataClassNoFutureNestedInnerFirstInner,
@@ -318,6 +318,21 @@ class TestGetTypeHints:
         expected = {"inner": "Inner"}
         assert hints == expected
 
+    def test_warning(self) -> None:
+        @dataclass(kw_only=True, slots=True)
+        class Outer:
+            inner: Inner
+
+        @dataclass(kw_only=True, slots=True)
+        class Inner:
+            int_: int
+
+        with raises(
+            UserWarning,
+            match="Error getting type hints for <.*>; name 'Inner' is not defined",
+        ):
+            _ = get_type_hints(Outer, warn_name_errors=True)
+
 
 class TestIsAnnotationOfType:
     @mark.parametrize(

{dycw_utilities-0.109.0 → dycw_utilities-0.109.2}/src/tests/test_typing_funcs/with_future.py

@@ -33,11 +33,6 @@ class DataClassFutureDate:
     date: dt.date
 
 
-@dataclass(order=True, unsafe_hash=True, kw_only=True)
-class DataClassFutureInt:
-    int_: int
-
-
 @dataclass(order=True, unsafe_hash=True, kw_only=True)
 class DataClassFutureDefaultInInitParent:
     int_: int
@@ -49,6 +44,11 @@ class DataClassFutureDefaultInInitChild(DataClassFutureDefaultInInitParent):
         DataClassFutureDefaultInInitParent.__init__(self, int_=0)
 
 
+@dataclass(order=True, unsafe_hash=True, kw_only=True)
+class DataClassFutureInt:
+    int_: int
+
+
 @dataclass(order=True, unsafe_hash=True, kw_only=True)
 class DataClassFutureIntDefault:
     int_: int = 0
@@ -59,6 +59,18 @@ class DataClassFutureIntNullable:
     int_: int | None = None
 
 
+@dataclass(order=True, unsafe_hash=True, kw_only=True)
+class DataClassFutureIntLowerAndUpper:
+    int_: int
+    INT_: int
+
+
+@dataclass(order=True, unsafe_hash=True, kw_only=True)
+class DataClassFutureIntOneAndTwo:
+    int1: int
+    int2: int
+
+
 @dataclass(order=True, unsafe_hash=True, kw_only=True)
 class DataClassFutureListInts:
     ints: list[int]

{dycw_utilities-0.109.0 → dycw_utilities-0.109.2}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.109.0"
+__version__ = "0.109.2"