dycw-utilities 0.166.4__tar.gz → 0.166.5__tar.gz

{dycw_utilities-0.166.4 → dycw_utilities-0.166.5}/PKG-INFO

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

{dycw_utilities-0.166.4 → dycw_utilities-0.166.5}/pyproject.toml

@@ -233,7 +233,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.166.4"
+version = "0.166.5"
 
 [project.entry-points.pytest11]
 pytest-randomly = "utilities.pytest_plugins.pytest_randomly"
@@ -266,7 +266,7 @@ test = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.166.4"
+current_version = "0.166.5"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.166.4 → dycw_utilities-0.166.5}/src/tests/test_typed_settings.py

@@ -2,7 +2,7 @@ from collections.abc import Callable
 from dataclasses import dataclass
 from ipaddress import IPv4Address, IPv6Address
 from pathlib import Path
-from typing import Any, ClassVar, assert_never
+from typing import Any, ClassVar, Self, assert_never, override
 from uuid import UUID
 
 import typed_settings
@@ -12,7 +12,9 @@ from hypothesis.strategies import (
     SearchStrategy,
     booleans,
     data,
+    integers,
     ip_addresses,
+    sampled_from,
     tuples,
     uuids,
 )
@@ -45,6 +47,8 @@ from utilities.hypothesis import (
     zoned_date_times,
 )
 from utilities.os import temp_environ
+from utilities.re import extract_group
+from utilities.sentinel import Sentinel, sentinel
 from utilities.text import strip_and_dedent
 from utilities.typed_settings import (
     ExtendedTSConverter,
@@ -64,40 +68,20 @@ class _Case[T]:
 
 class TestExtendedTSConverter:
     cases: ClassVar[list[_Case]] = [
-        _Case(cls=Date, strategy=dates(), serialize=Date.format_common_iso),
+        _Case(cls=Date, strategy=dates(), serialize=str),
+        _Case(cls=DateDelta, strategy=date_deltas(parsable=True), serialize=str),
         _Case(
-            cls=DateDelta,
-            strategy=date_deltas(parsable=True),
-            serialize=DateDelta.format_common_iso,
-        ),
-        _Case(
-            cls=DateTimeDelta,
-            strategy=date_time_deltas(parsable=True),
-            serialize=DateTimeDelta.format_common_iso,
+            cls=DateTimeDelta, strategy=date_time_deltas(parsable=True), serialize=str
         ),
         _Case(cls=IPv4Address, strategy=ip_addresses(v=4), serialize=str),
         _Case(cls=IPv6Address, strategy=ip_addresses(v=6), serialize=str),
-        _Case(
-            cls=MonthDay, strategy=month_days(), serialize=MonthDay.format_common_iso
-        ),
-        _Case(
-            cls=PlainDateTime,
-            strategy=plain_date_times(),
-            serialize=PlainDateTime.format_common_iso,
-        ),
-        _Case(cls=Time, strategy=times(), serialize=Time.format_common_iso),
-        _Case(
-            cls=TimeDelta, strategy=time_deltas(), serialize=TimeDelta.format_common_iso
-        ),
+        _Case(cls=MonthDay, strategy=month_days(), serialize=str),
+        _Case(cls=PlainDateTime, strategy=plain_date_times(), serialize=str),
+        _Case(cls=Time, strategy=times(), serialize=str),
+        _Case(cls=TimeDelta, strategy=time_deltas(), serialize=str),
         _Case(cls=UUID, strategy=uuids(), serialize=str),
-        _Case(
-            cls=YearMonth, strategy=year_months(), serialize=YearMonth.format_common_iso
-        ),
-        _Case(
-            cls=ZonedDateTime,
-            strategy=zoned_date_times(),
-            serialize=ZonedDateTime.format_common_iso,
-        ),
+        _Case(cls=YearMonth, strategy=year_months(), serialize=str),
+        _Case(cls=ZonedDateTime, strategy=zoned_date_times(), serialize=str),
     ]
 
     @given(data=data())
@@ -217,41 +201,116 @@ class TestExtendedTSConverter:
 
 
 class TestLoadSettings:
-    @given(root=temp_paths(), datetime=zoned_date_times())
-    def test_main(self, *, root: Path, datetime: ZonedDateTime) -> None:
+    @given(root=temp_paths(), date_time=zoned_date_times(), app_name=app_names)
+    def test_main(self, *, root: Path, date_time: ZonedDateTime, app_name: str) -> None:
         @dataclass(frozen=True, kw_only=True, slots=True)
         class Settings:
-            datetime: ZonedDateTime
+            date_time: ZonedDateTime
 
-        file = Path(root, "file.toml")
-        _ = file.write_text("")
+        file = root.joinpath("settings.toml")
         _ = file.write_text(
             strip_and_dedent(f"""
-                [app_name]
-                datetime = '{datetime.format_common_iso()}'
+                [{app_name}]
+                date_time = {str(date_time)!r}
             """)
         )
-        settings = load_settings(
-            Settings, "app_name", filenames="file.toml", start_dir=root
-        )
-        assert settings.datetime == datetime
+        settings = load_settings(Settings, app_name, start_dir=root)
+        assert settings.date_time == date_time
 
     @given(
         prefix=app_names.map(lambda text: f"TEST_{text}".upper()),
-        datetime=zoned_date_times(),
+        date_time=zoned_date_times(),
+        app_name=app_names,
     )
-    def test_loaders(self, *, prefix: str, datetime: ZonedDateTime) -> None:
-        key = f"{prefix}__DATETIME"
+    def test_loaders(
+        self, *, prefix: str, date_time: ZonedDateTime, app_name: str
+    ) -> None:
+        key = f"{prefix}__DATE_TIME"
 
         @dataclass(frozen=True, kw_only=True, slots=True)
         class Settings:
-            datetime: ZonedDateTime
+            date_time: ZonedDateTime
 
-        with temp_environ({key: datetime.format_common_iso()}):
+        with temp_environ({key: str(date_time)}):
             settings = load_settings(
-                Settings, "app_name", loaders=[EnvLoader(prefix=f"{prefix}__")]
+                Settings, app_name, loaders=[EnvLoader(prefix=f"{prefix}__")]
             )
-        assert settings.datetime == datetime
+        assert settings.date_time == date_time
+
+    @given(root=temp_paths(), app_name=app_names)
+    def test_converter_simple(self, *, root: Path, app_name: str) -> None:
+        @dataclass(frozen=True, kw_only=True, slots=True)
+        class Settings:
+            sentinel: Sentinel
+
+        file = root.joinpath("settings.toml")
+        _ = file.write_text(
+            strip_and_dedent(f"""
+                [{app_name}]
+                sentinel = 'sentinel'
+            """)
+        )
+
+        def convert(text: str, /) -> Sentinel:
+            if text == "sentinel":
+                return sentinel
+            raise ValueError
+
+        settings = load_settings(
+            Settings, app_name, start_dir=root, converters=[(Sentinel, convert)]
+        )
+        assert settings.sentinel is sentinel
+
+    @given(data=data(), root=temp_paths(), n=integers(), app_name=app_names)
+    def test_converter_dataclass(
+        self, *, data: DataObject, root: Path, n: int, app_name: str
+    ) -> None:
+        @dataclass(repr=False, frozen=True, kw_only=True, slots=True)
+        class Left:
+            x: int
+
+            @override
+            def __str__(self) -> str:
+                return f"left{self.x}"
+
+            @classmethod
+            def parse(cls, text: str, /) -> Self:
+                x = extract_group(r"^left(.+?)$", text)
+                return cls(x=int(x))
+
+        @dataclass(frozen=True, kw_only=True, slots=True)
+        class Right:
+            y: int
+
+            @override
+            def __str__(self) -> str:
+                return f"right{self.y}"
+
+            @classmethod
+            def parse(cls, text: str, /) -> Self:
+                y = extract_group(r"^right(.+?)$", text)
+                return cls(y=int(y))
+
+        value = data.draw(sampled_from([Left(x=n), Right(y=n)]))
+
+        @dataclass(frozen=True, kw_only=True, slots=True)
+        class Settings:
+            inner: Left | Right
+
+        file = root.joinpath("settings.toml")
+        _ = file.write_text(
+            strip_and_dedent(f"""
+                [{app_name}]
+                inner = {str(value)!r}
+            """)
+        )
+        settings = load_settings(
+            Settings,
+            app_name,
+            start_dir=root,
+            converters=[(Left, Left.parse), (Right, Right.parse)],
+        )
+        assert settings.inner == value
 
     @mark.parametrize("app_name", [param("app_"), param("app1"), param("app__name")])
     def test_error(self, *, app_name: str) -> None:

{dycw_utilities-0.166.4 → dycw_utilities-0.166.5}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.166.4"
+__version__ = "0.166.5"

{dycw_utilities-0.166.4 → dycw_utilities-0.166.5}/src/utilities/typed_settings.py

@@ -30,7 +30,7 @@ from utilities.pathlib import to_path
 from utilities.string import substitute_environ
 
 if TYPE_CHECKING:
-    from collections.abc import Callable
+    from collections.abc import Callable, Iterable
 
     from typed_settings.loaders import Loader
     from typed_settings.processors import Processor
@@ -38,6 +38,9 @@ if TYPE_CHECKING:
     from utilities.types import MaybeCallablePathLike, MaybeIterable, PathLike
 
 
+type _ConverterItem = tuple[type[Any], Callable[..., Any]]
+
+
 ##
 
 
@@ -50,9 +53,10 @@ class ExtendedTSConverter(TSConverter):
         *,
         resolve_paths: bool = True,
         strlist_sep: str | Callable[[str], list] | None = ":",
+        extra: Iterable[_ConverterItem] = (),
     ) -> None:
         super().__init__(resolve_paths=resolve_paths, strlist_sep=strlist_sep)
-        cases: list[tuple[type[Any], Callable[..., Any]]] = [
+        cases: list[_ConverterItem] = [
             (Date, Date.parse_common_iso),
             (DateDelta, DateDelta.parse_common_iso),
             (DateTimeDelta, DateTimeDelta.parse_common_iso),
@@ -66,6 +70,7 @@ class ExtendedTSConverter(TSConverter):
             (UUID, UUID),
             (YearMonth, YearMonth.parse_common_iso),
             (ZonedDateTime, ZonedDateTime.parse_common_iso),
+            *extra,
         ]
         extras = {cls: _make_converter(cls, func) for cls, func in cases}
         self.scalar_converters |= extras
@@ -113,6 +118,7 @@ def load_settings[T](
     start_dir: PathLike | None = None,
     loaders: MaybeIterable[Loader] | None = None,
     processors: MaybeIterable[Processor] = (),
+    converters: Iterable[_ConverterItem] = (),
     base_dir: Path = _BASE_DIR,
 ) -> T:
     if not search(r"^[A-Za-z]+(?:_[A-Za-z]+)*$", app_name):
@@ -129,7 +135,7 @@ def load_settings[T](
         cls,
         loaders_use,
         processors=list(always_iterable(processors)),
-        converter=ExtendedTSConverter(),
+        converter=ExtendedTSConverter(extra=converters),
         base_dir=base_dir,
     )