dycw-utilities 0.108.2__py3-none-any.whl → 0.108.4__py3-none-any.whl

{dycw_utilities-0.108.2.dist-info → dycw_utilities-0.108.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dycw-utilities
-Version: 0.108.2
+Version: 0.108.4
 Author-email: Derek Wan <d.wan@icloud.com>
 License-File: LICENSE
 Requires-Python: >=3.12
@@ -82,7 +82,7 @@ Requires-Dist: asyncpg<0.31,>=0.30.0; extra == 'zzz-test-hypothesis'
 Requires-Dist: greenlet<3.3,>=3.2.0; extra == 'zzz-test-hypothesis'
 Requires-Dist: hypothesis<6.132,>=6.131.6; extra == 'zzz-test-hypothesis'
 Requires-Dist: luigi<3.7,>=3.6.0; extra == 'zzz-test-hypothesis'
-Requires-Dist: numpy<2.3,>=2.2.4; extra == 'zzz-test-hypothesis'
+Requires-Dist: numpy<2.3,>=2.2.5; extra == 'zzz-test-hypothesis'
 Requires-Dist: pathvalidate<3.3,>=3.2.3; extra == 'zzz-test-hypothesis'
 Requires-Dist: redis<5.3,>=5.2.1; extra == 'zzz-test-hypothesis'
 Requires-Dist: sqlalchemy<2.1,>=2.0.40; extra == 'zzz-test-hypothesis'
@@ -112,14 +112,14 @@ Provides-Extra: zzz-test-luigi
 Requires-Dist: luigi<3.7,>=3.6.0; extra == 'zzz-test-luigi'
 Requires-Dist: whenever<0.8,>=0.7.3; extra == 'zzz-test-luigi'
 Provides-Extra: zzz-test-math
-Requires-Dist: numpy<2.3,>=2.2.4; extra == 'zzz-test-math'
+Requires-Dist: numpy<2.3,>=2.2.5; extra == 'zzz-test-math'
 Provides-Extra: zzz-test-memory-profiler
 Requires-Dist: memory-profiler<0.62,>=0.61.0; extra == 'zzz-test-memory-profiler'
 Provides-Extra: zzz-test-modules
 Provides-Extra: zzz-test-more-itertools
 Requires-Dist: more-itertools<10.7,>=10.6.0; extra == 'zzz-test-more-itertools'
 Provides-Extra: zzz-test-numpy
-Requires-Dist: numpy<2.3,>=2.2.4; extra == 'zzz-test-numpy'
+Requires-Dist: numpy<2.3,>=2.2.5; extra == 'zzz-test-numpy'
 Provides-Extra: zzz-test-operator
 Requires-Dist: polars-lts-cpu<1.28,>=1.27.1; extra == 'zzz-test-operator'
 Requires-Dist: whenever<0.8,>=0.7.3; extra == 'zzz-test-operator'
@@ -177,7 +177,7 @@ Requires-Dist: scipy<1.16,>=1.15.2; extra == 'zzz-test-scipy'
 Provides-Extra: zzz-test-sentinel
 Provides-Extra: zzz-test-shelve
 Provides-Extra: zzz-test-slack-sdk
-Requires-Dist: aiohttp<3.12,>=3.11.16; extra == 'zzz-test-slack-sdk'
+Requires-Dist: aiohttp<3.12,>=3.11.17; extra == 'zzz-test-slack-sdk'
 Requires-Dist: slack-sdk<3.36,>=3.35.0; extra == 'zzz-test-slack-sdk'
 Provides-Extra: zzz-test-socket
 Provides-Extra: zzz-test-sqlalchemy

{dycw_utilities-0.108.2.dist-info → dycw_utilities-0.108.4.dist-info}/RECORD

@@ -1,4 +1,4 @@
-utilities/__init__.py,sha256=cA1_Gx_WFoPXFOqGWzIcljSCQWUSLDE4oIIYB9493-g,60
+utilities/__init__.py,sha256=-2lmFv1UZnPQpN8IvJ-ViPH2DA03IC4wyaSgQYQI0zc,60
 utilities/altair.py,sha256=NSyDsm8QlkAGmsGdxVwCkHnPxt_35yJBa9Lg7bz9Ays,9054
 utilities/astor.py,sha256=xuDUkjq0-b6fhtwjhbnebzbqQZAjMSHR1IIS5uOodVg,777
 utilities/asyncio.py,sha256=41oQUurWMvadFK5gFnaG21hMM0Vmfn2WS6OpC0R9mas,14757
@@ -11,14 +11,14 @@ 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=SjDgGG6n9m5dn10KKTyC4In7mJ5pjoOqTKJ_xJi75Ss,14031
+utilities/dataclasses.py,sha256=SOWaLVMK6p_HTMPhiXtgCk5F1KGiY8wNxQkYRBz1dVg,18683
 utilities/datetime.py,sha256=GOs-MIEW_A49kzqa1yhIoeNeSqqPVgGO-h2AThtgTDk,37326
 utilities/enum.py,sha256=HoRwVCWzsnH0vpO9ZEcAAIZLMv0Sn2vJxxA4sYMQgDs,5793
 utilities/errors.py,sha256=BtSNP0JC3ik536ddPyTerLomCRJV9f6kdMe6POz0QHM,361
 utilities/eventkit.py,sha256=bG2rjgQqPaaOEW879Pc8vOCX6zRAl1frIhB1Y6fqQXg,13149
 utilities/fastapi.py,sha256=uwqOGbGwzIbP-lfm-ApG1ZEN3BA_TDsaiuTghhLmxb8,2413
 utilities/fpdf2.py,sha256=zM3gwOYcAfv7P4qhbyvzPmRY4PPAiAQ-ZnPC6I9SZ1M,1832
-utilities/functions.py,sha256=1yeJqFc6OO0W8N5x6Wc0BaEyz094Ny_oYY3qYILOho4,26706
+utilities/functions.py,sha256=BH4F_X34tqHuk-BzG9lzooYIP1OmVKm6GQw51qqYShM,27461
 utilities/functools.py,sha256=WrpHt7NLNWSUn9A1Q_ZIWlNaYZOEI4IFKyBG9HO3BC4,1643
 utilities/getpass.py,sha256=DfN5UgMAtFCqS3dSfFHUfqIMZX2shXvwphOz_6J6f6A,103
 utilities/git.py,sha256=wpt5dZ5Oi5931pN24_VLZYaQOvmR0OcQuVtgHzFUN1k,2359
@@ -53,7 +53,7 @@ utilities/pyinstrument.py,sha256=ROq2txPwbe2ZUuYJ2IDNbfT97lu2ca0v5_C_yn6sSlM,800
 utilities/pyrsistent.py,sha256=TLJfiiKO4cKNU_pCoM3zDqmSM421qpuoaeaBNnyC_Ac,2489
 utilities/pytest.py,sha256=85QUax4g2VBBAqAHtM9wekcSLB7_9O8AKFTaCshztL8,7989
 utilities/pytest_regressions.py,sha256=Kp1NS_cyXvBFqyiF_oSzYmSJzIOdAZ0SFcSGmbL_UtI,5001
-utilities/python_dotenv.py,sha256=vcjTodgb3IAQEtUgPODsxGAYwPaXHPuV3G_iDcXm0zY,7886
+utilities/python_dotenv.py,sha256=7N4ZbBxXpPNttOTfg-hpaLFFWA5iJwF7tREBzUnbPOM,3415
 utilities/random.py,sha256=lYdjgxB7GCfU_fwFVl5U-BIM_HV3q6_urL9byjrwDM8,4157
 utilities/re.py,sha256=5J4d8VwIPFVrX2Eb8zfoxImDv7IwiN_U7mJ07wR2Wvs,3958
 utilities/redis.py,sha256=CsDQqc9V6ASLzLQwtbQXZQEndyG9pJiCOhPlPeszt7Y,21203
@@ -84,7 +84,7 @@ utilities/warnings.py,sha256=yUgjnmkCRf6QhdyAXzl7u0qQFejhQG3PrjoSwxpbHrs,1819
 utilities/whenever.py,sha256=5x2t47VJmJRWcd_NLFy54NkB3uom-XQYxEbLtEfL1bs,17775
 utilities/zipfile.py,sha256=24lQc9ATcJxHXBPc_tBDiJk48pWyRrlxO2fIsFxU0A8,699
 utilities/zoneinfo.py,sha256=-DQz5a0Ikw9jfSZtL0BEQkXOMC9yGn_xiJYNCLMiqEc,1989
-dycw_utilities-0.108.2.dist-info/METADATA,sha256=N4v4D-Slw7bPRUT5KdnuEIJnUoDQVx3pTRFXkQ8kNp4,13004
-dycw_utilities-0.108.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-dycw_utilities-0.108.2.dist-info/licenses/LICENSE,sha256=gppZp16M6nSVpBbUBrNL6JuYfvKwZiKgV7XoKKsHzqo,1066
-dycw_utilities-0.108.2.dist-info/RECORD,,
+dycw_utilities-0.108.4.dist-info/METADATA,sha256=rAF0wyx5NT-CYkx5Meatz3jzjaRSMeBHx6mSCdfBcM8,13004
+dycw_utilities-0.108.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dycw_utilities-0.108.4.dist-info/licenses/LICENSE,sha256=gppZp16M6nSVpBbUBrNL6JuYfvKwZiKgV7XoKKsHzqo,1066
+dycw_utilities-0.108.4.dist-info/RECORD,,

utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.108.2"
+__version__ = "0.108.4"

utilities/dataclasses.py

@@ -1,7 +1,17 @@
 from __future__ import annotations
 
+from collections.abc import Mapping
 from dataclasses import MISSING, dataclass, field, fields, replace
-from typing import TYPE_CHECKING, Any, Generic, Literal, TypeVar, overload, override
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Generic,
+    Literal,
+    TypeVar,
+    assert_never,
+    overload,
+    override,
+)
 
 from utilities.errors import ImpossibleCaseError
 from utilities.functions import (
@@ -11,14 +21,16 @@ from utilities.functions import (
 )
 from utilities.iterables import OneStrEmptyError, OneStrNonUniqueError, one_str
 from utilities.operator import is_equal
+from utilities.parse import ParseTextError, parse_text
 from utilities.reprlib import get_repr
 from utilities.sentinel import Sentinel, sentinel
+from utilities.types import TDataclass
 from utilities.typing import get_type_hints
 
 if TYPE_CHECKING:
-    from collections.abc import Callable, Iterable, Iterator, Mapping
+    from collections.abc import Callable, Iterable, Iterator
 
-    from utilities.types import Dataclass, StrMapping, TDataclass
+    from utilities.types import Dataclass, StrMapping
 
 
 _T = TypeVar("_T")
@@ -118,7 +130,7 @@ def dataclass_to_dict(
     recursive: bool = False,
 ) -> StrMapping:
     """Convert a dataclass to a dictionary."""
-    out: dict[str, Any] = {}
+    out: StrMapping = {}
     for fld in yield_fields(obj, globalns=globalns, localns=localns):
         if fld.keep(
             include=include,
@@ -233,9 +245,7 @@ class _MappingToDataclassEmptyError(MappingToDataclassError):
     @override
     def __str__(self) -> str:
         desc = f"Mapping {get_repr(self.mapping)} does not contain {self.field!r}"
-        if not self.case_sensitive:
-            desc += " (modulo case)"
-        return desc
+        return desc if self.case_sensitive else f"{desc} (modulo case)"
 
 
 @dataclass(kw_only=True, slots=True)
@@ -280,6 +290,142 @@ def replace_non_sentinel(
 ##
 
 
+def text_to_dataclass(
+    text_or_mapping: str | Mapping[str, str],
+    cls: type[TDataclass],
+    /,
+    *,
+    globalns: StrMapping | None = None,
+    localns: StrMapping | None = None,
+    case_sensitive: bool = False,
+) -> TDataclass:
+    """Construct a dataclass from a string or a mapping or strings."""
+    fields = list(yield_fields(cls, globalns=globalns, localns=localns))
+    match text_or_mapping:
+        case str() as text:
+            text_mapping = _text_to_dataclass_split_text(text, cls)
+        case Mapping() as text_mapping:
+            ...
+        case _ as never:
+            assert_never(never)
+    value_mapping = dict(
+        _text_to_dataclass_get_and_parse(
+            fields, key, value, cls, case_sensitive=case_sensitive
+        )
+        for key, value in text_mapping.items()
+    )
+    return mapping_to_dataclass(
+        cls,
+        value_mapping,
+        globalns=globalns,
+        localns=localns,
+        case_sensitive=case_sensitive,
+    )
+
+
+def _text_to_dataclass_split_text(
+    text: str, cls: type[TDataclass], /
+) -> Mapping[str, str]:
+    pairs = (t for t in text.split(",") if t != "")
+    return dict(_text_to_dataclass_split_key_value_pair(pair, cls) for pair in pairs)
+
+
+def _text_to_dataclass_split_key_value_pair(
+    text: str, cls: type[Dataclass], /
+) -> tuple[str, str]:
+    try:
+        key, value = text.split("=")
+    except ValueError:
+        raise _TextToDataClassSplitKeyValuePairError(cls=cls, text=text) from None
+    return key, value
+
+
+def _text_to_dataclass_get_and_parse(
+    fields: Iterable[_YieldFieldsClass[Any]],
+    key: str,
+    value: str,
+    cls: type[Dataclass],
+    /,
+    *,
+    case_sensitive: bool = False,
+) -> tuple[str, Any]:
+    mapping = {f.name: f for f in fields}
+    try:
+        name = one_str(mapping, key, head=True, case_sensitive=case_sensitive)
+    except OneStrEmptyError:
+        raise _TextToDataClassGetFieldEmptyError(
+            cls=cls, key=key, case_sensitive=case_sensitive
+        ) from None
+    except OneStrNonUniqueError as error:
+        raise _TextToDataClassGetFieldNonUniqueError(
+            cls=cls,
+            key=key,
+            case_sensitive=case_sensitive,
+            first=error.first,
+            second=error.second,
+        ) from None
+    field = mapping[name]
+    try:
+        parsed = parse_text(field.type_, value, case_sensitive=case_sensitive)
+    except ParseTextError:
+        raise _TextToDataClassParseValueError(
+            cls=cls, field=field, text=value
+        ) from None
+    return key, parsed
+
+
+@dataclass(kw_only=True, slots=True)
+class TextToDataClassError(Exception, Generic[TDataclass]):
+    cls: type[TDataclass]
+
+
+@dataclass(kw_only=True, slots=True)
+class _TextToDataClassSplitKeyValuePairError(TextToDataClassError):
+    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 _TextToDataClassGetFieldEmptyError(TextToDataClassError[TDataclass]):
+    key: str
+    case_sensitive: bool = False
+
+    @override
+    def __str__(self) -> str:
+        desc = f"Dataclass {get_class_name(self.cls)!r} does not contain any field starting with {self.key!r}"
+        return desc if self.case_sensitive else f"{desc} (modulo case)"
+
+
+@dataclass(kw_only=True, slots=True)
+class _TextToDataClassGetFieldNonUniqueError(TextToDataClassError[TDataclass]):
+    key: str
+    case_sensitive: bool = False
+    first: str
+    second: str
+
+    @override
+    def __str__(self) -> str:
+        head = f"Dataclass {get_class_name(self.cls)!r} must contain exactly one field starting with {self.key!r}"
+        mid = "" if self.case_sensitive else " (modulo case)"
+        return f"{head}{mid}; got {self.first!r}, {self.second!r} and perhaps more"
+
+
+@dataclass(kw_only=True, slots=True)
+class _TextToDataClassParseValueError(TextToDataClassError[TDataclass]):
+    field: _YieldFieldsClass[Any]
+    text: str
+
+    @override
+    def __str__(self) -> str:
+        return f"Unable to construct {get_class_name(self.cls)!r}; unable to parse field {self.field.name!r} of type {self.field.type_!r}; got {self.text!r}"
+
+
+##
+
+
 @overload
 def yield_fields(
     obj: Dataclass,
@@ -346,18 +492,18 @@ def yield_fields(
         raise YieldFieldsError(obj=obj)
 
 
-@dataclass(kw_only=True, slots=True)
+@dataclass(order=True, unsafe_hash=True, kw_only=True, slots=True)
 class _YieldFieldsInstance(Generic[_T]):
     name: str
-    value: _T
-    type_: Any
-    default: _T | Sentinel = sentinel
-    default_factory: Callable[[], _T] | Sentinel = sentinel
+    value: _T = field(hash=False)
+    type_: Any = field(hash=False)
+    default: _T | Sentinel = field(default=sentinel, hash=False)
+    default_factory: Callable[[], _T] | Sentinel = field(default=sentinel, hash=False)
     repr: bool = True
     hash_: bool | None = None
     init: bool = True
     compare: bool = True
-    metadata: StrMapping = field(default_factory=dict)
+    metadata: StrMapping = field(default_factory=dict, hash=False)
     kw_only: bool | Sentinel = sentinel
 
     def equals_default(
@@ -407,17 +553,17 @@ class _YieldFieldsInstance(Generic[_T]):
         return (defaults and equal) or not equal
 
 
-@dataclass(kw_only=True, slots=True)
+@dataclass(order=True, unsafe_hash=True, kw_only=True, slots=True)
 class _YieldFieldsClass(Generic[_T]):
     name: str
-    type_: Any
-    default: _T | Sentinel = sentinel
-    default_factory: Callable[[], _T] | Sentinel = sentinel
+    type_: Any = field(hash=False)
+    default: _T | Sentinel = field(default=sentinel, hash=False)
+    default_factory: Callable[[], _T] | Sentinel = field(default=sentinel, hash=False)
     repr: bool = True
     hash_: bool | None = None
     init: bool = True
     compare: bool = True
-    metadata: StrMapping = field(default_factory=dict)
+    metadata: StrMapping = field(default_factory=dict, hash=False)
     kw_only: bool | Sentinel = sentinel
 
 
@@ -434,10 +580,12 @@ class YieldFieldsError(Exception):
 
 __all__ = [
     "MappingToDataclassError",
+    "TextToDataClassError",
     "YieldFieldsError",
     "dataclass_repr",
     "dataclass_to_dict",
     "mapping_to_dataclass",
     "replace_non_sentinel",
+    "text_to_dataclass",
     "yield_fields",
 ]

utilities/functions.py

@@ -5,6 +5,7 @@ from collections.abc import Callable, Iterable, Iterator, Sequence
 from dataclasses import asdict, dataclass, is_dataclass
 from functools import _lru_cache_wrapper, cached_property, partial, reduce, wraps
 from inspect import getattr_static
+from pathlib import Path
 from re import findall
 from types import (
     BuiltinFunctionType,
@@ -405,6 +406,31 @@ class EnsureNumberError(Exception):
 ##
 
 
+@overload
+def ensure_path(obj: Any, /, *, nullable: bool) -> Path | None: ...
+@overload
+def ensure_path(obj: Any, /, *, nullable: Literal[False] = False) -> Path: ...
+def ensure_path(obj: Any, /, *, nullable: bool = False) -> Path | None:
+    """Ensure an object is a Path."""
+    try:
+        return ensure_class(obj, Path, nullable=nullable)
+    except EnsureClassError as error:
+        raise EnsurePathError(obj=error.obj, nullable=nullable) from None
+
+
+@dataclass(kw_only=True, slots=True)
+class EnsurePathError(Exception):
+    obj: Any
+    nullable: bool
+
+    @override
+    def __str__(self) -> str:
+        return _make_error_msg(self.obj, "a Path", nullable=self.nullable)
+
+
+##
+
+
 def ensure_sized(obj: Any, /) -> Sized:
     """Ensure an object is sized."""
     if is_sized(obj):
@@ -985,6 +1011,7 @@ __all__ = [
     "EnsureMemberError",
     "EnsureNotNoneError",
     "EnsureNumberError",
+    "EnsurePathError",
     "EnsureSizedError",
     "EnsureSizedNotStrError",
     "EnsureStrError",
@@ -1004,6 +1031,7 @@ __all__ = [
     "ensure_member",
     "ensure_not_none",
     "ensure_number",
+    "ensure_path",
     "ensure_sized",
     "ensure_sized_not_str",
     "ensure_str",

utilities/python_dotenv.py

@@ -1,12 +1,8 @@
 from __future__ import annotations
 
-import datetime as dt
 from dataclasses import dataclass
-from enum import Enum
 from functools import partial
 from os import environ
-from pathlib import Path
-from re import IGNORECASE, search
 from typing import TYPE_CHECKING, Any, override
 
 from dotenv import dotenv_values
@@ -16,16 +12,15 @@ from utilities.dataclasses import (
     _YieldFieldsClass,
     mapping_to_dataclass,
 )
-from utilities.enum import EnsureEnumError, ensure_enum
-from utilities.functions import get_class_name
 from utilities.git import get_repo_root
-from utilities.iterables import MergeStrMappingsError, merge_str_mappings, one, one_str
+from utilities.iterables import MergeStrMappingsError, merge_str_mappings
+from utilities.parse import ParseTextError, parse_text
 from utilities.pathlib import PWD
 from utilities.reprlib import get_repr
-from utilities.typing import get_args, is_literal_type, is_optional_type
 
 if TYPE_CHECKING:
     from collections.abc import Mapping
+    from pathlib import Path
 
     from utilities.types import PathLike, StrMapping, TDataclass
 
@@ -65,72 +60,14 @@ def load_settings(
 
 
 def _load_settings_post(
-    field: _YieldFieldsClass[Any], value: Any, /, *, path: Path, values: StrMapping
+    field: _YieldFieldsClass[Any], text: str, /, *, path: Path, values: StrMapping
 ) -> Any:
-    type_ = field.type_
-    if type_ is str:
-        return value
-    if type_ is bool:
-        if value == "0" or search("false", value, flags=IGNORECASE):
-            return False
-        if value == "1" or search("true", value, flags=IGNORECASE):
-            return True
-        raise _LoadSettingsInvalidBoolError(
-            path=path, values=values, field=field.name, value=value
-        )
-    if type_ is float:
-        try:
-            return float(value)
-        except ValueError:
-            raise _LoadSettingsInvalidFloatError(
-                path=path, values=values, field=field.name, value=value
-            ) from None
-    if type_ is int:
-        try:
-            return int(value)
-        except ValueError:
-            raise _LoadSettingsInvalidIntError(
-                path=path, values=values, field=field.name, value=value
-            ) from None
-    if type_ is Path:
-        return Path(value).expanduser()
-    if type_ is dt.date:
-        from utilities.whenever import ParseDateError, parse_date
-
-        try:
-            return parse_date(value)
-        except ParseDateError:
-            raise _LoadSettingsInvalidDateError(
-                path=path, values=values, field=field.name, value=value
-            ) from None
-    if type_ is dt.timedelta:
-        from utilities.whenever import ParseTimedeltaError, parse_timedelta
-
-        try:
-            return parse_timedelta(value)
-        except ParseTimedeltaError:
-            raise _LoadSettingsInvalidTimeDeltaError(
-                path=path, values=values, field=field.name, value=value
-            ) from None
-    if isinstance(type_, type) and issubclass(type_, Enum):
-        try:
-            return ensure_enum(value, type_)
-        except EnsureEnumError:
-            raise _LoadSettingsInvalidEnumError(
-                path=path, values=values, field=field.name, type_=type_, value=value
-            ) from None
-    if is_literal_type(type_):
-        return one_str(get_args(type_), value)
-    if is_optional_type(type_) and (one(get_args(type_)) is int):
-        if (value is None) or (value == "") or search("none", value, flags=IGNORECASE):
-            return None
-        try:
-            return int(value)
-        except ValueError:
-            raise _LoadSettingsInvalidNullableIntError(
-                path=path, values=values, field=field.name, value=value
-            ) from None
-    raise _LoadSettingsTypeError(path=path, field=field.name, type=type_)
+    try:
+        return parse_text(field.type_, text)
+    except ParseTextError:
+        raise _LoadSettingsParseTextError(
+            path=path, values=values, field=field, text=text
+        ) from None
 
 
 @dataclass(kw_only=True, slots=True)
@@ -138,13 +75,6 @@ class LoadSettingsError(Exception):
     path: Path
 
 
-@dataclass(kw_only=True, slots=True)
-class _LoadSettingsFileNotFoundError(LoadSettingsError):
-    @override
-    def __str__(self) -> str:
-        return f"Path {str(self.path)!r} must exist"
-
-
 @dataclass(kw_only=True, slots=True)
 class _LoadSettingsDuplicateKeysError(LoadSettingsError):
     values: StrMapping
@@ -166,94 +96,21 @@ class _LoadSettingsEmptyError(LoadSettingsError):
 
 
 @dataclass(kw_only=True, slots=True)
-class _LoadSettingsInvalidBoolError(LoadSettingsError):
-    values: StrMapping
-    field: str
-    value: str
-
-    @override
-    def __str__(self) -> str:
-        return f"Field {self.field!r} must contain a valid boolean; got {self.value!r}"
-
-
-@dataclass(kw_only=True, slots=True)
-class _LoadSettingsInvalidDateError(LoadSettingsError):
-    values: StrMapping
-    field: str
-    value: str
-
-    @override
-    def __str__(self) -> str:
-        return f"Field {self.field!r} must contain a valid date; got {self.value!r}"
-
-
-@dataclass(kw_only=True, slots=True)
-class _LoadSettingsInvalidEnumError(LoadSettingsError):
-    values: StrMapping
-    field: str
-    type_: type[Enum]
-    value: str
-
-    @override
-    def __str__(self) -> str:
-        type_ = get_class_name(self.type_)
-        return f"Field {self.field!r} must contain a valid member of {type_!r}; got {self.value!r}"
-
-
-@dataclass(kw_only=True, slots=True)
-class _LoadSettingsInvalidFloatError(LoadSettingsError):
-    values: StrMapping
-    field: str
-    value: str
-
-    @override
-    def __str__(self) -> str:
-        return f"Field {self.field!r} must contain a valid float; got {self.value!r}"
-
-
-@dataclass(kw_only=True, slots=True)
-class _LoadSettingsInvalidIntError(LoadSettingsError):
-    values: StrMapping
-    field: str
-    value: str
-
-    @override
-    def __str__(self) -> str:
-        return f"Field {self.field!r} must contain a valid integer; got {self.value!r}"
-
-
-@dataclass(kw_only=True, slots=True)
-class _LoadSettingsInvalidNullableIntError(LoadSettingsError):
-    values: StrMapping
-    field: str
-    value: str
-
+class _LoadSettingsFileNotFoundError(LoadSettingsError):
     @override
     def __str__(self) -> str:
-        return f"Field {self.field!r} must contain a valid nullable integer; got {self.value!r}"
+        return f"Path {str(self.path)!r} must exist"
 
 
 @dataclass(kw_only=True, slots=True)
-class _LoadSettingsInvalidTimeDeltaError(LoadSettingsError):
+class _LoadSettingsParseTextError(LoadSettingsError):
     values: StrMapping
-    field: str
-    value: str
-
-    @override
-    def __str__(self) -> str:
-        return (
-            f"Field {self.field!r} must contain a valid timedelta; got {self.value!r}"
-        )
-
-
-@dataclass(kw_only=True, slots=True)
-class _LoadSettingsTypeError(LoadSettingsError):
-    field: str
-    type: Any
+    field: _YieldFieldsClass[Any]
+    text: str
 
     @override
     def __str__(self) -> str:
-        return f"Field {self.field!r} has unsupported type {self.type!r}"
+        return f"Unable to parse field {self.field.name!r} of type {self.field.type_!r}; got {self.text!r}"
 
 
 __all__ = ["LoadSettingsError", "load_settings"]