dycw-utilities 0.112.5__py3-none-any.whl → 0.112.7__py3-none-any.whl

{dycw_utilities-0.112.5.dist-info → dycw_utilities-0.112.7.dist-info}/METADATA

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

{dycw_utilities-0.112.5.dist-info → dycw_utilities-0.112.7.dist-info}/RECORD

@@ -1,4 +1,4 @@
-utilities/__init__.py,sha256=YhMz5tXURLSN-FqrtF7DSHZw1xY-ecf2SJGla-Mbe6k,60
+utilities/__init__.py,sha256=OrvHk0ybPjcSwc2XsWqqzN9yhl5ksF0jAsvGwGFRa2I,60
 utilities/altair.py,sha256=Gpja-flOo-Db0PIPJLJsgzAlXWoKUjPU1qY-DQ829ek,9156
 utilities/astor.py,sha256=xuDUkjq0-b6fhtwjhbnebzbqQZAjMSHR1IIS5uOodVg,777
 utilities/asyncio.py,sha256=41oQUurWMvadFK5gFnaG21hMM0Vmfn2WS6OpC0R9mas,14757
@@ -11,7 +11,7 @@ utilities/contextlib.py,sha256=OOIIEa5lXKGzFAnauaul40nlQnQko6Na4ryiMJcHkIg,478
 utilities/contextvars.py,sha256=RsSGGrbQqqZ67rOydnM7WWIsM2lIE31UHJLejnHJPWY,505
 utilities/cryptography.py,sha256=HyOewI20cl3uRXsKivhIaeLVDInQdzgXZGaly7hS5dE,771
 utilities/cvxpy.py,sha256=Rv1-fD-XYerosCavRF8Pohop2DBkU3AlFaGTfD8AEAA,13776
-utilities/dataclasses.py,sha256=EG2lZRPU_rmkP3KWR7J5J43r8hr68s9uchSvevxpoZI,27433
+utilities/dataclasses.py,sha256=2BloGVlH85tNZjFQiKXNk00Qwe9aovoV7cwxqFRG2l8,32598
 utilities/datetime.py,sha256=OF7jZE702UecnwAbq9D3N-GINpp9gSGoidki1RhimCE,35752
 utilities/enum.py,sha256=HoRwVCWzsnH0vpO9ZEcAAIZLMv0Sn2vJxxA4sYMQgDs,5793
 utilities/errors.py,sha256=BtSNP0JC3ik536ddPyTerLomCRJV9f6kdMe6POz0QHM,361
@@ -41,7 +41,7 @@ utilities/operator.py,sha256=0M2yZJ0PODH47ogFEnkGMBe_cfxwZR02T_92LZVZvHo,3715
 utilities/optuna.py,sha256=loyJGWTzljgdJaoLhP09PT8Jz6o_pwBOwehY33lHkhw,1923
 utilities/orjson.py,sha256=DBm2zPP04kcHpY3l1etL24ksNynu-R3duFyx3U-RjqQ,36948
 utilities/os.py,sha256=D_FyyT-6TtqiN9KSS7c9g1fnUtgxmyMtzAjmYLkk46A,3587
-utilities/parse.py,sha256=Qr8hw14v0Bfxnc0TjFfjZtmYk6FrdVoqLnszb7R27BA,18982
+utilities/parse.py,sha256=vsZ2jf_ceSI_Kta9titixufysJaVXh0Whjz1T4awJZw,18938
 utilities/pathlib.py,sha256=31WPMXdLIyXgYOMMl_HOI2wlo66MGSE-cgeelk-Lias,1410
 utilities/period.py,sha256=RWfcNVoNlW07RNdU47g_zuLZMKbtgfK4bE6G-9tVjY8,11024
 utilities/pickle.py,sha256=Bhvd7cZl-zQKQDFjUerqGuSKlHvnW1K2QXeU5UZibtg,657
@@ -55,7 +55,7 @@ utilities/pyinstrument.py,sha256=OJFDh4o1CWIa4aYPYURdQjgap_nvP45KUsCEe94rQHY,829
 utilities/pyrsistent.py,sha256=MoDcAqQGlSNkmlS32DCJLw-cZFAfHB6K9kpox_iyI4k,2512
 utilities/pytest.py,sha256=85QUax4g2VBBAqAHtM9wekcSLB7_9O8AKFTaCshztL8,7989
 utilities/pytest_regressions.py,sha256=-SVT9647Dg6-JcdsiaDKXe3NdOmmrvGevLKWwGjxq3c,5088
-utilities/python_dotenv.py,sha256=6viKAI7zx9YQU2ewITaOcad7wMwkrf6FbYpBmCl4vCA,3170
+utilities/python_dotenv.py,sha256=iWcnpXbH7S6RoXHiLlGgyuH6udCupAcPd_gQ0eAenQ0,3190
 utilities/random.py,sha256=lYdjgxB7GCfU_fwFVl5U-BIM_HV3q6_urL9byjrwDM8,4157
 utilities/re.py,sha256=5J4d8VwIPFVrX2Eb8zfoxImDv7IwiN_U7mJ07wR2Wvs,3958
 utilities/redis.py,sha256=fAUbfOlCmxcxhh47PXQX63w0CU5iOFKfdUJ7jDn9ntM,22096
@@ -78,7 +78,7 @@ utilities/threading.py,sha256=GvBOp4CyhHfN90wGXZuA2VKe9fGzMaEa7oCl4f3nnPU,1009
 utilities/timer.py,sha256=Rkc49KSpHuC8s7vUxGO9DU55U9I6yDKnchsQqrUCVBs,4075
 utilities/traceback.py,sha256=secexUnBsecfWV4ZuqP1W4pGF3prOeO1CRyJK-8zQDU,27402
 utilities/types.py,sha256=kVY71hZkcnyYNIlYSse0mLm8yeP3OBkzhDPMME6jXxo,18126
-utilities/typing.py,sha256=ypaAUKjLIR89NlzcQnOXuKCwCHcp8ur8sDLkNKHAGoA,13737
+utilities/typing.py,sha256=H6ysJkI830aRwLsMKz0SZIw4cpcsm7d6KhQOwr-SDh0,13817
 utilities/tzdata.py,sha256=yCf70NICwAeazN3_JcXhWvRqCy06XJNQ42j7r6gw3HY,1217
 utilities/tzlocal.py,sha256=3upDNFBvGh1l9njmLR2z2S6K6VxQSb7QizYGUbAH3JU,960
 utilities/uuid.py,sha256=jJTFxz-CWgltqNuzmythB7iEQ-Q1mCwPevUfKthZT3c,611
@@ -87,7 +87,7 @@ utilities/warnings.py,sha256=un1LvHv70PU-LLv8RxPVmugTzDJkkGXRMZTE2-fTQHw,1771
 utilities/whenever.py,sha256=iLRP_-8CZtBpHKbGZGu-kjSMg1ZubJ-VSmgSy7Eudxw,17787
 utilities/zipfile.py,sha256=24lQc9ATcJxHXBPc_tBDiJk48pWyRrlxO2fIsFxU0A8,699
 utilities/zoneinfo.py,sha256=-Xm57PMMwDTYpxJdkiJG13wnbwK--I7XItBh5WVhD-o,1874
-dycw_utilities-0.112.5.dist-info/METADATA,sha256=uE2jadDQbFgL7nR5zfTSo9IPPZFgtolnNmcbVnRkdXc,13004
-dycw_utilities-0.112.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-dycw_utilities-0.112.5.dist-info/licenses/LICENSE,sha256=gppZp16M6nSVpBbUBrNL6JuYfvKwZiKgV7XoKKsHzqo,1066
-dycw_utilities-0.112.5.dist-info/RECORD,,
+dycw_utilities-0.112.7.dist-info/METADATA,sha256=NcBDjpG25EDCH04c9Cw1w6Im4LjtQILGKXPHqlTmbro,13004
+dycw_utilities-0.112.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dycw_utilities-0.112.7.dist-info/licenses/LICENSE,sha256=gppZp16M6nSVpBbUBrNL6JuYfvKwZiKgV7XoKKsHzqo,1066
+dycw_utilities-0.112.7.dist-info/RECORD,,

utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.112.5"
+__version__ = "0.112.7"

utilities/dataclasses.py

@@ -240,17 +240,31 @@ def mapping_to_dataclass(
         )
     else:
         fields_use = fields
-    fields_to_values = str_mapping_to_field_mapping(
-        cls,
-        mapping,
-        fields=fields_use,
-        globalns=globalns,
-        localns=localns,
-        warn_name_errors=warn_name_errors,
-        head=head,
-        case_sensitive=case_sensitive,
-        allow_extra=allow_extra,
-    )
+    try:
+        fields_to_values = str_mapping_to_field_mapping(
+            cls,
+            mapping,
+            fields=fields_use,
+            globalns=globalns,
+            localns=localns,
+            warn_name_errors=warn_name_errors,
+            head=head,
+            case_sensitive=case_sensitive,
+            allow_extra=allow_extra,
+        )
+    except _StrMappingToFieldMappingEmptyError as error:
+        raise _MappingToDataClassEmptyError(
+            cls=cls, key=error.key, head=head, case_sensitive=case_sensitive
+        ) from None
+    except _StrMappingToFieldMappingNonUniqueError as error:
+        raise _MappingToDataClassNonUniqueError(
+            cls=cls,
+            key=error.key,
+            head=head,
+            case_sensitive=case_sensitive,
+            first=error.first,
+            second=error.second,
+        ) from None
     field_names_to_values = {f.name: v for f, v in fields_to_values.items()}
     default = {
         f.name
@@ -261,13 +275,50 @@ def mapping_to_dataclass(
     have = set(field_names_to_values) | default
     missing = {f.name for f in fields_use} - have
     if len(missing) >= 1:
-        raise MappingToDataclassError(cls=cls, fields=missing)
+        raise _MappingToDataClassMissingValuesError(cls=cls, fields=missing)
     return cls(**field_names_to_values)
 
 
 @dataclass(kw_only=True, slots=True)
 class MappingToDataclassError(Exception, Generic[TDataclass]):
     cls: type[TDataclass]
+
+
+@dataclass(kw_only=True, slots=True)
+class _MappingToDataClassEmptyError(MappingToDataclassError[TDataclass]):
+    key: str
+    head: bool = False
+    case_sensitive: bool = False
+
+    @override
+    def __str__(self) -> str:
+        return _empty_error_str(
+            self.cls, self.key, head=self.head, case_sensitive=self.case_sensitive
+        )
+
+
+@dataclass(kw_only=True, slots=True)
+class _MappingToDataClassNonUniqueError(MappingToDataclassError[TDataclass]):
+    key: str
+    head: bool = False
+    case_sensitive: bool = False
+    first: str
+    second: str
+
+    @override
+    def __str__(self) -> str:
+        return _non_unique_error_str(
+            self.cls,
+            self.key,
+            self.first,
+            self.second,
+            head=self.head,
+            case_sensitive=self.case_sensitive,
+        )
+
+
+@dataclass(kw_only=True, slots=True)
+class _MappingToDataClassMissingValuesError(MappingToDataclassError[TDataclass]):
     fields: AbstractSet[str]
 
     @override
@@ -307,11 +358,11 @@ def one_field(
     try:
         name = one_str(mapping, key, head=head, case_sensitive=case_sensitive)
     except OneStrEmptyError:
-        raise OneFieldEmptyError(
+        raise _OneFieldEmptyError(
             cls=cls, key=key, head=head, case_sensitive=case_sensitive
         ) from None
     except OneStrNonUniqueError as error:
-        raise OneFieldNonUniqueError(
+        raise _OneFieldNonUniqueError(
             cls=cls,
             key=key,
             head=head,
@@ -331,46 +382,29 @@ class OneFieldError(Exception, Generic[TDataclass]):
 
 
 @dataclass(kw_only=True, slots=True)
-class OneFieldEmptyError(OneFieldError[TDataclass]):
+class _OneFieldEmptyError(OneFieldError[TDataclass]):
     @override
     def __str__(self) -> str:
-        head = f"Dataclass {get_class_name(self.cls)!r} does not contain"
-        match self.head, self.case_sensitive:
-            case False, True:
-                tail = f"a field {self.key!r}"
-            case False, False:
-                tail = f"a field {self.key!r} (modulo case)"
-            case True, True:
-                tail = f"any field starting with {self.key!r}"
-            case True, False:
-                tail = f"any field starting with {self.key!r} (modulo case)"
-            case _ as never:
-                assert_never(never)
-        return f"{head} {tail}"
+        return _empty_error_str(
+            self.cls, self.key, head=self.head, case_sensitive=self.case_sensitive
+        )
 
 
 @dataclass(kw_only=True, slots=True)
-class OneFieldNonUniqueError(OneFieldError[TDataclass]):
+class _OneFieldNonUniqueError(OneFieldError[TDataclass]):
     first: str
     second: str
 
     @override
     def __str__(self) -> str:
-        head = f"Dataclass {get_class_name(self.cls)!r} must contain"
-        match self.head, self.case_sensitive:
-            case False, True:
-                raise ImpossibleCaseError(  # pragma: no cover
-                    case=[f"{self.head=}", f"{self.case_sensitive=}"]
-                )
-            case False, False:
-                mid = f"field {self.key!r} exactly once (modulo case)"
-            case True, True:
-                mid = f"exactly one field starting with {self.key!r}"
-            case True, False:
-                mid = f"exactly one field starting with {self.key!r} (modulo case)"
-            case _ as never:
-                assert_never(never)
-        return f"{head} {mid}; got {self.first!r}, {self.second!r} and perhaps more"
+        return _non_unique_error_str(
+            self.cls,
+            self.key,
+            self.first,
+            self.second,
+            head=self.head,
+            case_sensitive=self.case_sensitive,
+        )
 
 
 ##
@@ -487,17 +521,31 @@ def parse_dataclass(
             cls, globalns=globalns, localns=localns, warn_name_errors=warn_name_errors
         )
     )
-    fields_to_serializes = str_mapping_to_field_mapping(
-        cls,
-        keys_to_serializes,
-        fields=fields,
-        globalns=globalns,
-        localns=localns,
-        warn_name_errors=warn_name_errors,
-        head=head,
-        case_sensitive=case_sensitive,
-        allow_extra=allow_extra_keys,
-    )
+    try:
+        fields_to_serializes = str_mapping_to_field_mapping(
+            cls,
+            keys_to_serializes,
+            fields=fields,
+            globalns=globalns,
+            localns=localns,
+            warn_name_errors=warn_name_errors,
+            head=head,
+            case_sensitive=case_sensitive,
+            allow_extra=allow_extra_keys,
+        )
+    except _StrMappingToFieldMappingEmptyError as error:
+        raise _ParseDataClassStrMappingToFieldMappingEmptyError(
+            cls=cls, key=error.key, head=head, case_sensitive=case_sensitive
+        ) from None
+    except _StrMappingToFieldMappingNonUniqueError as error:
+        raise _ParseDataClassStrMappingToFieldMappingNonUniqueError(
+            cls=cls,
+            key=error.key,
+            head=head,
+            case_sensitive=case_sensitive,
+            first=error.first,
+            second=error.second,
+        ) from None
     field_names_to_values = {
         f.name: _parse_dataclass_parse_text(
             f,
@@ -511,17 +559,20 @@ def parse_dataclass(
         )
         for f, t in fields_to_serializes.items()
     }
-    return mapping_to_dataclass(
-        cls,
-        field_names_to_values,
-        fields=fields,
-        globalns=globalns,
-        localns=localns,
-        warn_name_errors=warn_name_errors,
-        head=head,
-        case_sensitive=case_sensitive,
-        allow_extra=allow_extra_keys,
-    )
+    try:
+        return mapping_to_dataclass(
+            cls,
+            field_names_to_values,
+            fields=fields,
+            globalns=globalns,
+            localns=localns,
+            warn_name_errors=warn_name_errors,
+            head=head,
+            case_sensitive=case_sensitive,
+            allow_extra=allow_extra_keys,
+        )
+    except _MappingToDataClassMissingValuesError as error:
+        raise _ParseDataClassMissingValuesError(cls=cls, fields=error.fields) from None
 
 
 def _parse_dataclass_split_key_value_pairs(
@@ -549,7 +600,7 @@ def _parse_dataclass_split_key_value_pairs(
         ) from None
     except _SplitKeyValuePairsDuplicateKeysError as error:
         raise _ParseDataClassSplitKeyValuePairsDuplicateKeysError(
-            text=error.text, cls=cls, counts=error.counts
+            cls=cls, counts=error.counts
         ) from None
 
 
@@ -579,25 +630,28 @@ def _parse_dataclass_parse_text(
         raise _ParseDataClassTextParseError(cls=cls, field=field, text=text) from None
     except _ParseObjectExtraNonUniqueError as error:
         raise _ParseDataClassTextExtraNonUniqueError(
-            cls=cls, field=field, text=text, first=error.first, second=error.second
+            cls=cls, field=field, first=error.first, second=error.second
         ) from None
 
 
 @dataclass(kw_only=True, slots=True)
 class ParseDataClassError(Exception, Generic[TDataclass]):
-    text: str
     cls: type[TDataclass]
 
 
 @dataclass(kw_only=True, slots=True)
-class _ParseDataClassSplitKeyValuePairsSplitError(ParseDataClassError):
+class _ParseDataClassSplitKeyValuePairsSplitError(ParseDataClassError[TDataclass]):
+    text: str
+
     @override
     def __str__(self) -> str:
         return f"Unable to construct {get_class_name(self.cls)!r}; failed to split key-value pair {self.text!r}"
 
 
 @dataclass(kw_only=True, slots=True)
-class _ParseDataClassSplitKeyValuePairsDuplicateKeysError(ParseDataClassError):
+class _ParseDataClassSplitKeyValuePairsDuplicateKeysError(
+    ParseDataClassError[TDataclass]
+):
     counts: Mapping[str, int]
 
     @override
@@ -608,6 +662,7 @@ class _ParseDataClassSplitKeyValuePairsDuplicateKeysError(ParseDataClassError):
 @dataclass(kw_only=True, slots=True)
 class _ParseDataClassTextParseError(ParseDataClassError[TDataclass]):
     field: _YieldFieldsClass[Any]
+    text: str
 
     @override
     def __str__(self) -> str:
@@ -625,6 +680,56 @@ class _ParseDataClassTextExtraNonUniqueError(ParseDataClassError[TDataclass]):
         return f"Unable to construct {get_class_name(self.cls)!r} since the field {self.field.name!r} of type {self.field.type_!r} must contain exactly one parent class in `extra`; got {self.first!r}, {self.second!r} and perhaps more"
 
 
+@dataclass(kw_only=True, slots=True)
+class _ParseDataClassStrMappingToFieldMappingEmptyError(
+    ParseDataClassError[TDataclass]
+):
+    key: str
+    head: bool = False
+    case_sensitive: bool = False
+
+    @override
+    def __str__(self) -> str:
+        head = f"Unable to construct {get_class_name(self.cls)!r} since it does not contain"
+        tail = _empty_error_str_core(
+            self.key, head=self.head, case_sensitive=self.case_sensitive
+        )
+        return f"{head} {tail}"
+
+
+@dataclass(kw_only=True, slots=True)
+class _ParseDataClassStrMappingToFieldMappingNonUniqueError(
+    ParseDataClassError[TDataclass]
+):
+    key: str
+    head: bool = False
+    case_sensitive: bool = False
+    first: str
+    second: str
+
+    @override
+    def __str__(self) -> str:
+        head = f"Unable to construct {get_class_name(self.cls)!r} since it must contain"
+        tail = _non_unique_error_str_core(
+            self.key,
+            self.first,
+            self.second,
+            head=self.head,
+            case_sensitive=self.case_sensitive,
+        )
+        return f"{head} {tail}"
+
+
+@dataclass(kw_only=True, slots=True)
+class _ParseDataClassMissingValuesError(ParseDataClassError[TDataclass]):
+    fields: AbstractSet[str]
+
+    @override
+    def __str__(self) -> str:
+        desc = ", ".join(map(repr, sorted(self.fields)))
+        return f"Unable to construct {get_class_name(self.cls)!r}; missing values for {desc}"
+
+
 ##
 
 
@@ -655,36 +760,55 @@ def str_mapping_to_field_mapping(
                 head=head,
                 case_sensitive=case_sensitive,
             )
-        except OneFieldEmptyError:
+        except _OneFieldEmptyError:
             if not allow_extra:
-                raise StrMappingToFieldMappingError(
+                raise _StrMappingToFieldMappingEmptyError(
                     cls=cls, key=key, head=head, case_sensitive=case_sensitive
                 ) from None
+        except _OneFieldNonUniqueError as error:
+            raise _StrMappingToFieldMappingNonUniqueError(
+                cls=cls,
+                key=key,
+                head=head,
+                case_sensitive=case_sensitive,
+                first=error.first,
+                second=error.second,
+            ) from None
     return {field: mapping[key] for key, field in keys_to_fields.items()}
 
 
 @dataclass(kw_only=True, slots=True)
-class StrMappingToFieldMappingError(Exception):
-    cls: type[Dataclass]
+class StrMappingToFieldMappingError(Exception, Generic[TDataclass]):
+    cls: type[TDataclass]
     key: str
     head: bool = False
     case_sensitive: bool = False
 
+
+@dataclass(kw_only=True, slots=True)
+class _StrMappingToFieldMappingEmptyError(StrMappingToFieldMappingError):
     @override
     def __str__(self) -> str:
-        head = f"Dataclass {get_class_name(self.cls)!r} does not contain"
-        match self.head, self.case_sensitive:
-            case False, True:
-                tail = f"a field {self.key!r}"
-            case False, False:
-                tail = f"a field {self.key!r} (modulo case)"
-            case True, True:
-                tail = f"any field starting with {self.key!r}"
-            case True, False:
-                tail = f"any field starting with {self.key!r} (modulo case)"
-            case _ as never:
-                assert_never(never)
-        return f"{head} {tail}"
+        return _empty_error_str(
+            self.cls, self.key, head=self.head, case_sensitive=self.case_sensitive
+        )
+
+
+@dataclass(kw_only=True, slots=True)
+class _StrMappingToFieldMappingNonUniqueError(StrMappingToFieldMappingError):
+    first: str
+    second: str
+
+    @override
+    def __str__(self) -> str:
+        return _non_unique_error_str(
+            self.cls,
+            self.key,
+            self.first,
+            self.second,
+            head=self.head,
+            case_sensitive=self.case_sensitive,
+        )
 
 
 ##
@@ -852,11 +976,81 @@ class YieldFieldsError(Exception):
 
 ##
 
+
+def _empty_error_str(
+    cls: type[Dataclass],
+    key: str,
+    /,
+    *,
+    head: bool = False,
+    case_sensitive: bool = False,
+) -> str:
+    head_msg = f"Dataclass {get_class_name(cls)!r} does not contain"
+    tail_msg = _empty_error_str_core(key, head=head, case_sensitive=case_sensitive)
+    return f"{head_msg} {tail_msg}"
+
+
+def _empty_error_str_core(
+    key: str, /, *, head: bool = False, case_sensitive: bool = False
+) -> str:
+    match head, case_sensitive:
+        case False, True:
+            return f"a field {key!r}"
+        case False, False:
+            return f"a field {key!r} (modulo case)"
+        case True, True:
+            return f"any field starting with {key!r}"
+        case True, False:
+            return f"any field starting with {key!r} (modulo case)"
+        case _ as never:
+            assert_never(never)
+
+
+def _non_unique_error_str(
+    cls: type[Dataclass],
+    key: str,
+    first: str,
+    second: str,
+    /,
+    *,
+    head: bool = False,
+    case_sensitive: bool = False,
+) -> str:
+    head_msg = f"Dataclass {get_class_name(cls)!r} must contain"
+    tail_msg = _non_unique_error_str_core(
+        key, first, second, head=head, case_sensitive=case_sensitive
+    )
+    return f"{head_msg} {tail_msg}"
+
+
+def _non_unique_error_str_core(
+    key: str,
+    first: str,
+    second: str,
+    /,
+    *,
+    head: bool = False,
+    case_sensitive: bool = False,
+) -> str:
+    match head, case_sensitive:
+        case False, True:
+            raise ImpossibleCaseError(  # pragma: no cover
+                case=[f"{head=}", f"{case_sensitive=}"]
+            )
+        case False, False:
+            head_msg = f"field {key!r} exactly once (modulo case)"
+        case True, True:
+            head_msg = f"exactly one field starting with {key!r}"
+        case True, False:
+            head_msg = f"exactly one field starting with {key!r} (modulo case)"
+        case _ as never:
+            assert_never(never)
+    return f"{head_msg}; got {first!r}, {second!r} and perhaps more"
+
+
 __all__ = [
     "MappingToDataclassError",
-    "OneFieldEmptyError",
     "OneFieldError",
-    "OneFieldNonUniqueError",
     "ParseDataClassError",
     "StrMappingToFieldMappingError",
     "YieldFieldsError",

utilities/parse.py

@@ -286,9 +286,7 @@ def _parse_object_extra(cls: Any, text: str, extra: ParseObjectExtra, /) -> Any:
         parser = extra[cls]
     except KeyError:
         try:
-            parser = one(
-                p for c, p in extra.items() if (cls is c) or is_subclass_gen(cls, c)
-            )
+            parser = one(p for c, p in extra.items() if is_subclass_gen(cls, c))
         except (OneEmptyError, TypeError):
             raise _ParseObjectParseError(type_=cls, text=text) from None
         except OneNonUniqueError as error:

utilities/python_dotenv.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING, override
 
 from dotenv import dotenv_values
 
-from utilities.dataclasses import MappingToDataclassError, parse_dataclass
+from utilities.dataclasses import _ParseDataClassMissingValuesError, parse_dataclass
 from utilities.git import get_repo_root
 from utilities.iterables import MergeStrMappingsError, merge_str_mappings
 from utilities.pathlib import PWD
@@ -61,7 +61,7 @@ def load_settings(
             allow_extra_keys=True,
             extra_parsers=extra_parsers,
         )
-    except MappingToDataclassError as error:
+    except _ParseDataClassMissingValuesError as error:
         raise _LoadSettingsMissingKeysError(path=path, fields=error.fields) from None
 
 

utilities/typing.py

@@ -245,6 +245,8 @@ def is_instance_gen(obj: Any, type_: Any, /) -> bool:
         return (len(obj) == len(type_args)) and all(
             is_instance_gen(o, t) for o, t in zip(obj, type_args, strict=True)
         )
+    if isinstance(obj, tuple) is not is_tuple_type(type_):
+        return False
     # basic
     if isinstance(type_, type):
         return any(_is_instance_gen_type(obj, t) for t in get_type_classes(type_))