dycw-utilities 0.168.1__tar.gz → 0.168.3__tar.gz

{dycw_utilities-0.168.1 → dycw_utilities-0.168.3}/PKG-INFO

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

{dycw_utilities-0.168.1 → dycw_utilities-0.168.3}/pyproject.toml

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

{dycw_utilities-0.168.1 → dycw_utilities-0.168.3}/src/tests/test_logging.py

@@ -449,10 +449,12 @@ class TestSizeAndTimeRotatingFileHandler:
             )
         )
 
+        await sleep(0.1)
         files = list(tmp_path.iterdir())
         assert len(files) == 1
         assert any(p for p in files if search(r"^log\.txt$", p.name))
 
+        await sleep(0.1)
         logger.warning("message 1")
         files = list(tmp_path.iterdir())
         assert len(files) == 1

{dycw_utilities-0.168.1 → dycw_utilities-0.168.3}/src/tests/test_pydantic_settings.py

@@ -1,15 +1,20 @@
 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
 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,
+    HashableBaseSettings,
     PathLikeOrWithSection,
     load_settings,
 )
@@ -101,11 +106,12 @@ class TestCustomBaseSettings:
             settings = load_settings(Settings)
         assert settings.x == 1
 
-    def test_env_var_with_nested(self) -> None:
+    @mark.parametrize("inner_cls", [param(BaseSettings), param(HashableBaseSettings)])
+    def test_env_var_with_nested(self, *, inner_cls: type[BaseSettings]) -> None:
         class Settings(CustomBaseSettings):
             inner: Inner
 
-        class Inner(BaseSettings):
+        class Inner(inner_cls):
             x: int
 
         _ = Settings.model_rebuild()
@@ -114,12 +120,15 @@ class TestCustomBaseSettings:
             settings = load_settings(Settings)
         assert settings.inner.x == 1
 
-    def test_env_var_with_prefix_and_nested(self) -> None:
+    @mark.parametrize("inner_cls", [param(BaseSettings), param(HashableBaseSettings)])
+    def test_env_var_with_prefix_and_nested(
+        self, *, inner_cls: type[BaseSettings]
+    ) -> None:
         class Settings(CustomBaseSettings):
             model_config = SettingsConfigDict(env_prefix="test__")
             inner: Inner
 
-        class Inner(BaseSettings):
+        class Inner(inner_cls):
             x: int
 
         _ = Settings.model_rebuild()
@@ -131,3 +140,115 @@ class TestCustomBaseSettings:
         class Settings(CustomBaseSettings): ...
 
         _ = load_settings(Settings)
+
+
+class TestHashableBaseSettings:
+    def test_hashable(self) -> None:
+        class Settings(HashableBaseSettings):
+            x: int = 1
+
+        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.1 → dycw_utilities-0.168.3}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.168.1"
+__version__ = "0.168.3"

{dycw_utilities-0.168.1 → dycw_utilities-0.168.3}/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:
@@ -29,7 +32,7 @@ type PathLikeOrWithSection = PathLike | PathLikeWithSection
 
 
 class CustomBaseSettings(BaseSettings):
-    """Base settings for loading JSON files."""
+    """Base settings for loading JSON/TOML/YAML files."""
 
     # paths
     json_files: ClassVar[Sequence[PathLikeOrWithSection]] = []
@@ -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__(
@@ -158,8 +156,80 @@ def _get_section(
     return reduce(lambda acc, el: acc.get(el, {}), always_iterable(section), mapping)
 
 
+##
+
+
+class HashableBaseSettings(BaseSettings):
+    """Base settings for loading JSON files."""
+
+    # config
+    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",
     "JsonConfigSectionSettingsSource",
     "TomlConfigSectionSettingsSource",
     "YamlConfigSectionSettingsSource",