dycw-utilities 0.168.2__tar.gz → 0.168.4__tar.gz

{dycw_utilities-0.168.2 → dycw_utilities-0.168.4}/PKG-INFO

@@ -1,22 +1,22 @@
 Metadata-Version: 2.4
 Name: dycw-utilities
-Version: 0.168.2
+Version: 0.168.4
 Author-email: Derek Wan <d.wan@icloud.com>
 License-File: LICENSE
 Requires-Python: >=3.12
 Requires-Dist: atomicwrites<1.5,>=1.4.1
 Requires-Dist: typing-extensions<4.16,>=4.15.0
 Requires-Dist: tzlocal<5.4,>=5.3.1
-Requires-Dist: whenever<0.10,>=0.9.0
+Requires-Dist: whenever<0.10,>=0.9.2
 Provides-Extra: logging
 Requires-Dist: coloredlogs<15.1,>=15.0.1; extra == 'logging'
 Provides-Extra: test
 Requires-Dist: dycw-pytest-only<2.2,>=2.1.1; extra == 'test'
-Requires-Dist: hypothesis<6.141,>=6.140.2; extra == 'test'
+Requires-Dist: hypothesis<6.141,>=6.140.3; extra == 'test'
 Requires-Dist: pytest-asyncio<1.3,>=1.2.0; extra == 'test'
 Requires-Dist: pytest-cov<7.1,>=7.0.0; extra == 'test'
 Requires-Dist: pytest-instafail<0.6,>=0.5.0; extra == 'test'
-Requires-Dist: pytest-lazy-fixtures<1.4,>=1.3.4; extra == 'test'
+Requires-Dist: pytest-lazy-fixtures<1.5,>=1.4.0; extra == 'test'
 Requires-Dist: pytest-randomly<4.1,>=4.0.1; extra == 'test'
 Requires-Dist: pytest-regressions<2.9,>=2.8.3; extra == 'test'
 Requires-Dist: pytest-repeat<0.10,>=0.9.4; extra == 'test'

{dycw_utilities-0.168.2 → dycw_utilities-0.168.4}/pyproject.toml

@@ -31,10 +31,10 @@ core = [
   "atomicwrites >=1.4.1, <1.5",
   "typing-extensions >=4.15.0, <4.16",
   "tzlocal >=5.3.1, <5.4",
-  "whenever >=0.9.0, <0.10",
+  "whenever >=0.9.2, <0.10",
 ]
 cryptography = [
-  "cryptography >=46.0.1, <46.1",
+  "cryptography >=46.0.2, <46.1",
 ]
 cvxpy = [
   "cvxpy >=1.7.3, <1.8",
@@ -52,7 +52,7 @@ dev = [
   "pytest-timeout >=2.4.0, <2.5",
 ]
 fastapi = [
-  "fastapi >=0.117.1, <0.118",
+  "fastapi >=0.118.0, <0.119",
 ]
 fastapi-test = [
   "httpx",
@@ -71,7 +71,7 @@ http-test = [
   "orjson",
 ]
 hypothesis = [
-  "hypothesis >=6.140.2, <6.141",
+  "hypothesis >=6.140.3, <6.141",
 ]
 hypothesis-test = [
   "libcst",
@@ -124,7 +124,7 @@ orjson-test = [
   "polars",
 ]
 polars = [
-  "polars >=1.33.1, <1.34",
+  "polars >=1.34.0, <1.35",
 ]
 polars-ols = [
   "polars-ols >=0.3.5, <0.4",
@@ -198,7 +198,7 @@ sklearn = [
   "scikit-learn >=1.7.2, <1.8",
 ]
 slack-sdk = [
-  "slack-sdk >=3.36.0, <3.37",
+  "slack-sdk >=3.37.0, <3.38",
 ]
 slack-sdk-test = [
   "aiohttp",
@@ -227,9 +227,6 @@ statsmodels = [
 testbook = [
   "testbook >=0.4.2, <0.5",
 ]
-typed-settings = [
-  "typed-settings >=25.0.0, <25.1",
-]
 tzdata = [
   "tzdata >=2025.2, <2025.3",
 ]
@@ -244,12 +241,12 @@ dependencies = [
   "atomicwrites >=1.4.1, <1.5",
   "typing-extensions >=4.15.0, <4.16",
   "tzlocal >=5.3.1, <5.4",
-  "whenever >=0.9.0, <0.10",
+  "whenever >=0.9.2, <0.10",
 ]
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.168.2"
+version = "0.168.4"
 
 [project.entry-points.pytest11]
 pytest-randomly = "utilities.pytest_plugins.pytest_randomly"
@@ -261,12 +258,12 @@ logging = [
 ]
 test = [
   "dycw-pytest-only >=2.1.1, <2.2",
-  "hypothesis >=6.140.2, <6.141",
+  "hypothesis >=6.140.3, <6.141",
   "pytest >=8.4.2, <8.5",
   "pytest-asyncio >=1.2.0, <1.3",
   "pytest-cov >=7.0.0, <7.1",
   "pytest-instafail >=0.5.0, <0.6",
-  "pytest-lazy-fixtures >=1.3.4, <1.4",
+  "pytest-lazy-fixtures >=1.4.0, <1.5",
   "pytest-randomly >=4.0.1, <4.1",
   "pytest-regressions >=2.8.3, <2.9",
   "pytest-repeat >=0.9.4, <0.10",
@@ -282,7 +279,7 @@ test = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.168.2"
+current_version = "0.168.4"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"
@@ -486,7 +483,6 @@ select = [
   "S101",  # assert
   "SLF001",  # private-member-access
 ]
-"src/tests/test_typed_settings.py" = ["I002"]  # missing-required-import
 "src/tests/test_typing_funcs/no_future.py" = ["I002"]  # missing-required-import
 
 [tool.ruff.lint.flake8-tidy-imports]

{dycw_utilities-0.168.2 → dycw_utilities-0.168.4}/src/tests/test_pydantic_settings.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
 import json
+from stat import S_IXUSR
+from subprocess import STDOUT, CalledProcessError, check_output
 from typing import TYPE_CHECKING, ClassVar
 
 import tomlkit
@@ -8,6 +10,7 @@ import yaml
 from pydantic_settings import BaseSettings, SettingsConfigDict
 from pytest import mark, param
 
+from tests.conftest import SKIPIF_CI_AND_WINDOWS
 from utilities.os import temp_environ
 from utilities.pydantic_settings import (
     CustomBaseSettings,
@@ -146,3 +149,106 @@ class TestHashableBaseSettings:
 
         settings = load_settings(Settings)
         _ = hash(settings)
+
+
+class TestLoadSettings:
+    @mark.parametrize(
+        ("args", "expected"),
+        [
+            param([], "settings=_Settings(a=1, b=2, inner=_Inner(c=3, d=4))"),
+            param(["-a", "5"], "settings=_Settings(a=5, b=2, inner=_Inner(c=3, d=4))"),
+            param(
+                ["--inner.c", "5"],
+                "settings=_Settings(a=1, b=2, inner=_Inner(c=5, d=4))",
+            ),
+            param(
+                ["-h"],
+                """
+usage: script.py [-h] [-a int] [-b int] [--inner [JSON]] [--inner.c int]
+                 [--inner.d int]
+
+options:
+  -h, --help      show this help message and exit
+  -a int          (default: 1)
+  -b int          (default: 2)
+
+inner options:
+  --inner [JSON]  set inner from JSON string (default: {})
+  --inner.c int   (default: 3)
+  --inner.d int   (default: 4)
+""",
+            ),
+        ],
+    )
+    @SKIPIF_CI_AND_WINDOWS
+    def test_cli(self, *, tmp_path: Path, args: list[str], expected: str) -> None:
+        script = tmp_path.joinpath("script.py")
+        _ = script.write_text("""\
+#!/usr/bin/env python3
+from __future__ import annotations
+
+from collections.abc import Sequence
+from pathlib import Path
+from typing import ClassVar
+
+from pydantic_settings import BaseSettings
+
+from utilities.pydantic_settings import CustomBaseSettings, PathLikeOrWithSection, load_settings
+
+class _Settings(CustomBaseSettings):
+    toml_files: ClassVar[Sequence[PathLikeOrWithSection]] = [
+        Path(__file__).parent.joinpath("config.toml")
+    ]
+
+    a: int
+    b: int
+    inner: _Inner
+
+class _Inner(BaseSettings):
+    c: int
+    d: int
+
+def main() -> None:
+    settings = load_settings(_Settings, cli=True)
+    print(f"{settings=}")
+
+if __name__ == "__main__":
+    main()
+""")
+        script.chmod(script.stat().st_mode | S_IXUSR)
+        config = tmp_path.joinpath("config.toml")
+        _ = config.write_text(
+            """\
+a = 1
+b = 2
+
+[inner]
+c = 3
+d = 4
+"""
+        )
+        try:
+            result = check_output([script, *args], stderr=STDOUT, text=True).strip("\n")
+        except CalledProcessError as error:
+            raise RuntimeError(error.stdout) from None
+        assert result == expected.strip("\n")
+
+    def test_cli_coverage(self, *, tmp_path: Path) -> None:
+        config = tmp_path.joinpath("config.toml")
+        _ = config.write_text("""
+a = 1
+
+[inner]
+b = 2""")
+
+        class Example(CustomBaseSettings):
+            toml_files: ClassVar[Sequence[PathLikeOrWithSection]] = [config]
+
+            a: int
+            inner: _Inner
+
+        class _Inner(BaseSettings):
+            b: int
+
+        _ = Example.model_rebuild()
+        _ = load_settings(Example, cli=True)

{dycw_utilities-0.168.2 → dycw_utilities-0.168.4}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.168.2"
+__version__ = "0.168.4"

{dycw_utilities-0.168.2 → dycw_utilities-0.168.4}/src/utilities/pydantic_settings.py

@@ -2,10 +2,12 @@ from __future__ import annotations
 
 from functools import reduce
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, ClassVar, assert_never, override
+from typing import TYPE_CHECKING, Any, ClassVar, assert_never, cast, override
 
+from pydantic import Field, create_model
 from pydantic_settings import (
     BaseSettings,
+    CliSettingsSource,
     JsonConfigSettingsSource,
     PydanticBaseSettingsSource,
     SettingsConfigDict,
@@ -14,6 +16,7 @@ from pydantic_settings import (
 )
 from pydantic_settings.sources import DEFAULT_PATH
 
+from utilities.errors import ImpossibleCaseError
 from utilities.iterables import always_iterable
 
 if TYPE_CHECKING:
@@ -76,11 +79,6 @@ class CustomBaseSettings(BaseSettings):
             )
 
 
-def load_settings[T: BaseSettings](cls: type[T], /) -> T:
-    """Load a set of settings."""
-    return cls()
-
-
 class JsonConfigSectionSettingsSource(JsonConfigSettingsSource):
     @override
     def __init__(
@@ -168,6 +166,67 @@ class HashableBaseSettings(BaseSettings):
     model_config: ClassVar[SettingsConfigDict] = SettingsConfigDict(frozen=True)
 
 
+##
+
+
+def load_settings[T: BaseSettings](cls: type[T], /, *, cli: bool = False) -> T:
+    """Load a set of settings."""
+    _ = cls.model_rebuild()
+    if cli:
+        cls_with_defaults = _load_settings_create_model(cls)
+
+        @classmethod
+        def settings_customise_sources(
+            cls: type[BaseSettings],
+            settings_cls: type[BaseSettings],
+            init_settings: PydanticBaseSettingsSource,
+            env_settings: PydanticBaseSettingsSource,
+            dotenv_settings: PydanticBaseSettingsSource,
+            file_secret_settings: PydanticBaseSettingsSource,
+        ) -> tuple[PydanticBaseSettingsSource, ...]:
+            parent = cast(
+                "Any", super(cls_with_defaults, cls)
+            ).settings_customise_sources(
+                settings_cls=settings_cls,
+                init_settings=init_settings,
+                env_settings=env_settings,
+                dotenv_settings=dotenv_settings,
+                file_secret_settings=file_secret_settings,
+            )
+            return (
+                CliSettingsSource(
+                    settings_cls, cli_parse_args=True, case_sensitive=False
+                ),
+                *parent,
+            )
+
+        cls_use = type(
+            cls.__name__,
+            (cls_with_defaults,),
+            {"settings_customise_sources": settings_customise_sources},
+        )
+        cls_use = cast("type[T]", cls_use)
+    else:
+        cls_use = cls
+    return cls_use()
+
+
+def _load_settings_create_model[T: BaseSettings](
+    cls: type[T], /, *, values: T | None = None
+) -> type[T]:
+    values_use = cls() if values is None else values
+    kwargs: dict[str, Any] = {}
+    for name, field in cls.model_fields.items():
+        if (ann := field.annotation) is None:
+            raise ImpossibleCaseError(case=[f"{ann=}"])  # pragma: no cover
+        value = getattr(values_use, name)
+        if issubclass(ann, BaseSettings):
+            kwargs[name] = _load_settings_create_model(ann, values=value)
+        else:
+            kwargs[name] = (field.annotation, Field(default=value))
+    return create_model(cls.__name__, __base__=cls, **kwargs)
+
+
 __all__ = [
     "CustomBaseSettings",
     "HashableBaseSettings",

dycw_utilities-0.168.2/src/tests/test_typed_settings.py

@@ -1,321 +0,0 @@
-from collections.abc import Callable
-from dataclasses import dataclass
-from ipaddress import IPv4Address, IPv6Address
-from pathlib import Path
-from typing import Any, ClassVar, Self, assert_never, override
-from uuid import UUID
-
-import typed_settings
-from hypothesis import given
-from hypothesis.strategies import (
-    DataObject,
-    SearchStrategy,
-    booleans,
-    data,
-    integers,
-    ip_addresses,
-    sampled_from,
-    tuples,
-    uuids,
-)
-from pytest import mark, param, raises
-from typed_settings import EnvLoader, FileLoader, TomlFormat
-from whenever import (
-    Date,
-    DateDelta,
-    DateTimeDelta,
-    MonthDay,
-    PlainDateTime,
-    Time,
-    TimeDelta,
-    YearMonth,
-    ZonedDateTime,
-)
-
-from utilities.hypothesis import (
-    date_deltas,
-    date_time_deltas,
-    dates,
-    month_days,
-    paths,
-    plain_date_times,
-    temp_paths,
-    text_ascii,
-    time_deltas,
-    times,
-    year_months,
-    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,
-    LoadSettingsError,
-    load_settings,
-)
-
-app_names = text_ascii(min_size=1).map(str.lower)
-
-
-@dataclass(kw_only=True, slots=True)
-class _Case[T]:
-    cls: type[T]
-    strategy: SearchStrategy[T]
-    serialize: Callable[[T], str]
-
-
-class TestExtendedTSConverter:
-    cases: ClassVar[list[_Case]] = [
-        _Case(cls=Date, strategy=dates(), serialize=str),
-        _Case(cls=DateDelta, strategy=date_deltas(parsable=True), serialize=str),
-        _Case(
-            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=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=str),
-        _Case(cls=ZonedDateTime, strategy=zoned_date_times(), serialize=str),
-    ]
-
-    @given(data=data())
-    @mark.parametrize(("cls", "strategy"), [param(c.cls, c.strategy) for c in cases])
-    def test_default(
-        self, *, data: DataObject, cls: type[Any], strategy: SearchStrategy[Any]
-    ) -> None:
-        default = data.draw(strategy)
-
-        @dataclass(frozen=True, kw_only=True, slots=True)
-        class Settings:
-            value: cls = default  # pyright: ignore[reportInvalidTypeForm]
-
-        loaded = typed_settings.load_settings(
-            Settings, loaders=[], converter=ExtendedTSConverter()
-        )
-        assert loaded.value == default
-
-    @given(data=data(), root=temp_paths(), app_name=app_names)
-    @mark.parametrize(
-        ("cls", "strategy", "serialize"),
-        [param(c.cls, c.strategy, c.serialize) for c in cases],
-    )
-    def test_loaded(
-        self,
-        *,
-        data: DataObject,
-        root: Path,
-        app_name: str,
-        cls: type[Any],
-        strategy: SearchStrategy[Any],
-        serialize: Callable[[Any], str],
-    ) -> None:
-        default, value = data.draw(tuples(strategy, strategy))
-
-        @dataclass(frozen=True, kw_only=True, slots=True)
-        class Settings:
-            value: cls = default  # pyright: ignore[reportInvalidTypeForm]
-
-        file = Path(root, "file.toml")
-        _ = file.write_text(
-            strip_and_dedent(f"""
-                [{app_name}]
-                value = '{serialize(value)}'
-            """)
-        )
-        loaded = typed_settings.load_settings(
-            Settings,
-            loaders=[
-                FileLoader(formats={"*.toml": TomlFormat(app_name)}, files=[file])
-            ],
-            converter=ExtendedTSConverter(),
-        )
-        assert loaded.value == value
-
-    @given(
-        root=temp_paths(),
-        app_name=app_names,
-        env_name=text_ascii(min_size=1).map(lambda text: f"TEST_{text}".upper()),
-        env_value=text_ascii(min_size=1),
-    )
-    def test_path_env_var(
-        self, *, root: str, app_name: str, env_name: str, env_value: str
-    ) -> None:
-        @dataclass(frozen=True, kw_only=True, slots=True)
-        class Settings:
-            value: Path
-
-        file = Path(root, "file.toml")
-        _ = file.write_text(
-            strip_and_dedent(f"""
-                [{app_name}]
-                value = '${env_name}'
-            """)
-        )
-        with temp_environ({env_name: env_value}):
-            settings = typed_settings.load_settings(
-                Settings,
-                loaders=[
-                    FileLoader(formats={"*.toml": TomlFormat(app_name)}, files=[file])
-                ],
-                converter=ExtendedTSConverter(resolve_paths=False),
-            )
-        expected = Path(env_value)
-        assert settings.value == expected
-
-    @given(root=temp_paths(), app_name=app_names, path=paths(), resolve=booleans())
-    def test_path_resolution(
-        self, *, root: str, app_name: str, path: Path, resolve: bool
-    ) -> None:
-        @dataclass(frozen=True, kw_only=True, slots=True)
-        class Settings:
-            value: Path
-
-        file = Path(root, "file.toml")
-        _ = file.write_text(
-            strip_and_dedent(f"""
-                [{app_name}]
-                value = '{path!s}'
-            """)
-        )
-        settings = typed_settings.load_settings(
-            Settings,
-            loaders=[
-                FileLoader(formats={"*.toml": TomlFormat(app_name)}, files=[file])
-            ],
-            converter=ExtendedTSConverter(resolve_paths=resolve),
-        )
-        match resolve:
-            case True:
-                expected = Path.cwd().joinpath(path)
-            case False:
-                expected = Path(path)
-            case never:
-                assert_never(never)
-        assert settings.value == expected
-
-
-class TestLoadSettings:
-    @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:
-            date_time: ZonedDateTime
-
-        file = root.joinpath("settings.toml")
-        _ = file.write_text(
-            strip_and_dedent(f"""
-                [{app_name}]
-                date_time = {str(date_time)!r}
-            """)
-        )
-        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()),
-        date_time=zoned_date_times(),
-        app_name=app_names,
-    )
-    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:
-            date_time: ZonedDateTime
-
-        with temp_environ({key: str(date_time)}):
-            settings = load_settings(
-                Settings, app_name, loaders=[EnvLoader(prefix=f"{prefix}__")]
-            )
-        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:
-        @dataclass(frozen=True, kw_only=True, slots=True)
-        class Settings: ...
-
-        with raises(LoadSettingsError, match=r"Invalid app name; got '.+'"):
-            _ = load_settings(Settings, app_name)