dycw-utilities 0.132.1__tar.gz → 0.132.2__tar.gz

{dycw_utilities-0.132.1 → dycw_utilities-0.132.2}/PKG-INFO

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

{dycw_utilities-0.132.1 → dycw_utilities-0.132.2}/pyproject.toml

@@ -94,7 +94,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.132.1"
+version = "0.132.2"
 
 [project.optional-dependencies]
 logging = [
@@ -121,7 +121,7 @@ test = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.132.1"
+current_version = "0.132.2"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

dycw_utilities-0.132.2/src/tests/test_typed_settings.py

@@ -0,0 +1,147 @@
+from collections.abc import Callable
+from dataclasses import dataclass
+from ipaddress import IPv4Address, IPv6Address
+from pathlib import Path
+from typing import TypeVar
+
+import typed_settings
+from hypothesis import given
+from hypothesis.strategies import DataObject, SearchStrategy, data, ip_addresses, tuples
+from pytest import mark, param, raises
+from typed_settings import EnvLoader, FileLoader, TomlFormat
+from whenever import (
+    Date,
+    DateDelta,
+    DateTimeDelta,
+    PlainDateTime,
+    Time,
+    TimeDelta,
+    ZonedDateTime,
+)
+
+from utilities.hypothesis import (
+    date_deltas,
+    date_time_deltas,
+    dates,
+    plain_datetimes,
+    temp_paths,
+    text_ascii,
+    time_deltas,
+    times,
+    zoned_datetimes,
+)
+from utilities.os import temp_environ
+from utilities.text import strip_and_dedent
+from utilities.typed_settings import (
+    ExtendedTSConverter,
+    LoadSettingsError,
+    load_settings,
+)
+
+app_names = text_ascii(min_size=1).map(str.lower)
+
+
+_T = TypeVar("_T")
+
+
+class TestExtendedTSConverter:
+    @given(data=data(), root=temp_paths(), app_name=app_names)
+    @mark.parametrize(
+        ("test_cls", "strategy", "serialize"),
+        [
+            param(Date, dates(), Date.format_common_iso),
+            param(DateDelta, date_deltas(parsable=True), DateDelta.format_common_iso),
+            param(
+                DateTimeDelta,
+                date_time_deltas(parsable=True),
+                DateTimeDelta.format_common_iso,
+            ),
+            param(IPv4Address, ip_addresses(v=4), IPv4Address),
+            param(IPv6Address, ip_addresses(v=6), IPv6Address),
+            param(PlainDateTime, plain_datetimes(), PlainDateTime.format_common_iso),
+            param(Time, times(), Time.format_common_iso),
+            param(TimeDelta, time_deltas(), TimeDelta.format_common_iso),
+            param(ZonedDateTime, zoned_datetimes(), ZonedDateTime.format_common_iso),
+        ],
+    )
+    def test_main(
+        self,
+        *,
+        data: DataObject,
+        root: Path,
+        app_name: str,
+        test_cls: type[_T],
+        strategy: SearchStrategy[_T],
+        serialize: Callable[[_T], str],
+    ) -> None:
+        default, value = data.draw(tuples(strategy, strategy))
+
+        @dataclass(frozen=True, kw_only=True, slots=True)
+        class Settings:
+            value: test_cls = default  # pyright: ignore[reportInvalidTypeForm]
+
+        settings_default = typed_settings.load_settings(
+            Settings, loaders=[], converter=ExtendedTSConverter()
+        )
+        assert settings_default.value == default
+        file = Path(root, "file.toml")
+        _ = file.write_text(
+            strip_and_dedent(f"""
+                [{app_name}]
+                value = '{serialize(value)}'
+            """)
+        )
+        settings_loaded = typed_settings.load_settings(
+            Settings,
+            loaders=[
+                FileLoader(formats={"*.toml": TomlFormat(app_name)}, files=[file])
+            ],
+            converter=ExtendedTSConverter(),
+        )
+        assert settings_loaded.value == value
+
+
+class TestLoadSettings:
+    @given(root=temp_paths(), datetime=zoned_datetimes())
+    def test_main(self, *, root: Path, datetime: ZonedDateTime) -> None:
+        @dataclass(frozen=True, kw_only=True, slots=True)
+        class Settings:
+            datetime: ZonedDateTime
+
+        file = Path(root, "file.toml")
+        _ = file.write_text("")
+        _ = file.write_text(
+            strip_and_dedent(f"""
+                [app_name]
+                datetime = '{datetime.format_common_iso()}'
+            """)
+        )
+        settings = load_settings(
+            Settings, "app_name", filenames="file.toml", start_dir=root
+        )
+        assert settings.datetime == datetime
+
+    @given(
+        prefix=app_names.map(lambda text: f"TEST_{text}".upper()),
+        datetime=zoned_datetimes(),
+    )
+    def test_loaders(self, *, prefix: str, datetime: ZonedDateTime) -> None:
+        key = f"{prefix}__DATETIME"
+
+        @dataclass(frozen=True, kw_only=True, slots=True)
+        class Settings:
+            datetime: ZonedDateTime
+
+        with temp_environ({key: datetime.format_common_iso()}):
+            settings = load_settings(
+                Settings, "app_name", loaders=[EnvLoader(prefix=f"{prefix}__")]
+            )
+        assert settings.datetime == datetime
+
+    @mark.parametrize("app_name", [param("app_"), param("app1"), param("app__name")])
+    def test_error(self, *, app_name: str) -> None:
+        @dataclass(frozen=True, kw_only=True, slots=True)
+        class Settings: ...
+
+        with raises(LoadSettingsError, match="Invalid app name; got '.+'"):
+            _ = load_settings(Settings, app_name)

{dycw_utilities-0.132.1 → dycw_utilities-0.132.2}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.132.1"
+__version__ = "0.132.2"

dycw_utilities-0.132.2/src/utilities/typed_settings.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from ipaddress import IPv4Address, IPv6Address
+from pathlib import Path
+from re import search
+from typing import TYPE_CHECKING, Any, TypeVar, override
+
+import typed_settings
+from typed_settings import EnvLoader, FileLoader, find
+from typed_settings.converters import TSConverter
+from typed_settings.loaders import TomlFormat
+from whenever import (
+    Date,
+    DateDelta,
+    DateTimeDelta,
+    PlainDateTime,
+    Time,
+    TimeDelta,
+    ZonedDateTime,
+)
+
+from utilities.iterables import always_iterable
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from typed_settings.loaders import Loader
+    from typed_settings.processors import Processor
+
+    from utilities.types import MaybeIterable, PathLike
+
+
+_T = TypeVar("_T")
+
+
+##
+
+
+class ExtendedTSConverter(TSConverter):
+    """An extension of the TSConverter for custom types."""
+
+    @override
+    def __init__(
+        self,
+        *,
+        resolve_paths: bool = True,
+        strlist_sep: str | Callable[[str], list] | None = ":",
+    ) -> None:
+        super().__init__(resolve_paths=resolve_paths, strlist_sep=strlist_sep)
+        cases: list[tuple[type[Any], Callable[..., Any]]] = [
+            (Date, Date.parse_common_iso),
+            (DateDelta, DateDelta.parse_common_iso),
+            (DateTimeDelta, DateTimeDelta.parse_common_iso),
+            (IPv4Address, IPv4Address),
+            (IPv6Address, IPv6Address),
+            (PlainDateTime, PlainDateTime.parse_common_iso),
+            (Time, Time.parse_common_iso),
+            (TimeDelta, TimeDelta.parse_common_iso),
+            (ZonedDateTime, ZonedDateTime.parse_common_iso),
+        ]
+        extras = {cls: _make_converter(cls, func) for cls, func in cases}
+        self.scalar_converters |= extras
+
+
+def _make_converter(
+    cls: type[_T], parser: Callable[[str], _T], /
+) -> Callable[[Any, type[Any]], Any]:
+    def hook(value: _T | str, _: type[_T] = cls, /) -> Any:
+        if not isinstance(value, (cls, str)):  # pragma: no cover
+            msg = f"Invalid type {type(value).__name__!r}; expected '{cls.__name__}' or 'str'"
+            raise TypeError(msg)
+        if isinstance(value, str):
+            return parser(value)
+        return value
+
+    return hook
+
+
+##
+
+_BASE_DIR: Path = Path()
+
+
+def load_settings(
+    cls: type[_T],
+    app_name: str,
+    /,
+    *,
+    filenames: MaybeIterable[str] = "settings.toml",
+    start_dir: PathLike | None = None,
+    loaders: MaybeIterable[Loader] | None = None,
+    processors: MaybeIterable[Processor] = (),
+    base_dir: Path = _BASE_DIR,
+) -> _T:
+    if not search(r"^[A-Za-z]+(?:_[A-Za-z]+)*$", app_name):
+        raise LoadSettingsError(appname=app_name)
+    filenames_use = list(always_iterable(filenames))
+    start_dir_use = None if start_dir is None else Path(start_dir)
+    files = [find(filename, start_dir=start_dir_use) for filename in filenames_use]
+    file_loader = FileLoader(formats={"*.toml": TomlFormat(app_name)}, files=files)
+    env_loader = EnvLoader(f"{app_name.upper()}__", nested_delimiter="__")
+    loaders_use: list[Loader] = [file_loader, env_loader]
+    if loaders is not None:
+        loaders_use.extend(always_iterable(loaders))
+    return typed_settings.load_settings(
+        cls,
+        loaders_use,
+        processors=list(always_iterable(processors)),
+        converter=ExtendedTSConverter(),
+        base_dir=base_dir,
+    )
+
+
+@dataclass(kw_only=True, slots=True)
+class LoadSettingsError(Exception):
+    appname: str
+
+    @override
+    def __str__(self) -> str:
+        return f"Invalid app name; got {self.appname!r}"
+
+
+__all__ = ["ExtendedTSConverter", "LoadSettingsError", "load_settings"]

dycw_utilities-0.132.1/src/tests/test_typed_settings.py

@@ -1,99 +0,0 @@
-from collections.abc import Callable
-from dataclasses import dataclass
-from operator import eq
-from pathlib import Path
-from typing import TypeVar
-
-from hypothesis import given
-from hypothesis.strategies import DataObject, SearchStrategy, data, tuples
-from pytest import mark, param
-from typed_settings import FileLoader, TomlFormat, load_settings
-from whenever import (
-    Date,
-    DateDelta,
-    DateTimeDelta,
-    PlainDateTime,
-    Time,
-    TimeDelta,
-    ZonedDateTime,
-)
-
-from utilities.hypothesis import (
-    date_deltas,
-    date_time_deltas,
-    dates,
-    plain_datetimes,
-    temp_paths,
-    text_ascii,
-    time_deltas,
-    times,
-    zoned_datetimes,
-)
-from utilities.typed_settings import ExtendedTSConverter
-
-app_names = text_ascii(min_size=1).map(str.lower)
-
-
-_T = TypeVar("_T")
-
-
-class TestExtendedTSConverter:
-    @given(data=data(), root=temp_paths(), appname=text_ascii(min_size=1))
-    @mark.parametrize(
-        ("test_cls", "strategy", "serialize"),
-        [
-            param(Date, dates(), Date.format_common_iso),
-            param(DateDelta, date_deltas(parsable=True), DateDelta.format_common_iso),
-            param(
-                DateTimeDelta,
-                date_time_deltas(parsable=True),
-                DateTimeDelta.format_common_iso,
-            ),
-            param(PlainDateTime, plain_datetimes(), PlainDateTime.format_common_iso),
-            param(Time, times(), Time.format_common_iso),
-            param(TimeDelta, time_deltas(), TimeDelta.format_common_iso),
-            param(ZonedDateTime, zoned_datetimes(), ZonedDateTime.format_common_iso),
-        ],
-    )
-    def test_main(
-        self,
-        *,
-        data: DataObject,
-        root: Path,
-        appname: str,
-        test_cls: type[_T],
-        strategy: SearchStrategy[_T],
-        serialize: Callable[[_T], str],
-    ) -> None:
-        default, value = data.draw(tuples(strategy, strategy))
-        self._run_test(test_cls, default, root, appname, serialize, value, eq)
-
-    def _run_test(
-        self,
-        test_cls: type[_T],
-        default: _T,
-        root: Path,
-        appname: str,
-        serialize: Callable[[_T], str],
-        value: _T,
-        equal: Callable[[_T, _T], bool],
-        /,
-    ) -> None:
-        @dataclass(frozen=True, kw_only=True, slots=True)
-        class Settings:
-            value: test_cls = default  # pyright: ignore[reportInvalidTypeForm]
-
-        settings_default = load_settings(
-            Settings, loaders=[], converter=ExtendedTSConverter()
-        )
-        assert settings_default.value == default
-        _ = hash(settings_default)
-        file = Path(root, "file.toml")
-        with file.open(mode="w") as fh:
-            _ = fh.write(f'[{appname}]\nvalue = "{serialize(value)}"')
-        settings_loaded = load_settings(
-            Settings,
-            loaders=[FileLoader(formats={"*.toml": TomlFormat(appname)}, files=[file])],
-            converter=ExtendedTSConverter(),
-        )
-        assert equal(settings_loaded.value, value)

dycw_utilities-0.132.1/src/utilities/typed_settings.py

@@ -1,61 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any, TypeVar, override
-
-from typed_settings.converters import TSConverter
-from whenever import (
-    Date,
-    DateDelta,
-    DateTimeDelta,
-    PlainDateTime,
-    Time,
-    TimeDelta,
-    ZonedDateTime,
-)
-
-if TYPE_CHECKING:
-    from collections.abc import Callable
-
-
-_T = TypeVar("_T")
-
-
-class ExtendedTSConverter(TSConverter):
-    """An extension of the TSConverter for custom types."""
-
-    @override
-    def __init__(
-        self,
-        *,
-        resolve_paths: bool = True,
-        strlist_sep: str | Callable[[str], list] | None = ":",
-    ) -> None:
-        super().__init__(resolve_paths=resolve_paths, strlist_sep=strlist_sep)
-        cases: list[tuple[type[Any], Callable[..., Any]]] = [
-            (Date, Date.parse_common_iso),
-            (DateDelta, DateDelta.parse_common_iso),
-            (DateTimeDelta, DateTimeDelta.parse_common_iso),
-            (PlainDateTime, PlainDateTime.parse_common_iso),
-            (Time, Time.parse_common_iso),
-            (TimeDelta, TimeDelta.parse_common_iso),
-            (ZonedDateTime, ZonedDateTime.parse_common_iso),
-        ]
-        extras = {cls: _make_converter(cls, func) for cls, func in cases}
-        self.scalar_converters |= extras
-
-
-def _make_converter(
-    cls: type[_T], parser: Callable[[str], _T], /
-) -> Callable[[Any, type[Any]], Any]:
-    def hook(value: _T | str, _: type[_T] = cls, /) -> Any:
-        if not isinstance(value, (cls, str)):  # pragma: no cover
-            msg = f"Invalid type {type(value).__name__!r}; expected '{cls.__name__}' or 'str'"
-            raise TypeError(msg)
-        if isinstance(value, str):
-            return parser(value)
-        return value
-
-    return hook
-
-
-__all__ = ["ExtendedTSConverter"]