dycw-utilities 0.135.0__py3-none-any.whl → 0.178.1__py3-none-any.whl

utilities/pydantic.py

@@ -1,59 +1,11 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
 from pathlib import Path
-from typing import TYPE_CHECKING, override
+from typing import Annotated
 
-from pydantic import BaseModel
+from pydantic import BeforeValidator
 
-from utilities.atomicwrites import writer
+ExpandedPath = Annotated[Path, BeforeValidator(lambda p: Path(p).expanduser())]
 
-if TYPE_CHECKING:
-    from utilities.types import PathLike
 
-
-class HashableBaseModel(BaseModel):
-    """Subclass of BaseModel which is hashable."""
-
-    @override
-    def __hash__(self) -> int:
-        return hash((type(self), *self.__dict__.values()))
-
-
-def load_model[T: BaseModel](model: type[T], path: PathLike, /) -> T:
-    path = Path(path)
-    try:
-        with path.open() as fh:
-            return model.model_validate_json(fh.read())
-    except FileNotFoundError:
-        raise _LoadModelFileNotFoundError(model=model, path=path) from None
-    except IsADirectoryError:  # skipif-not-windows
-        raise _LoadModelIsADirectoryError(model=model, path=path) from None
-
-
-@dataclass(kw_only=True, slots=True)
-class LoadModelError(Exception):
-    model: type[BaseModel]
-    path: Path
-
-
-@dataclass(kw_only=True, slots=True)
-class _LoadModelFileNotFoundError(LoadModelError):
-    @override
-    def __str__(self) -> str:
-        return f"Unable to load {self.model}; path {str(self.path)!r} must exist."
-
-
-@dataclass(kw_only=True, slots=True)
-class _LoadModelIsADirectoryError(LoadModelError):
-    @override
-    def __str__(self) -> str:
-        return f"Unable to load {self.model}; path {str(self.path)!r} must not be a directory."  # skipif-not-windows
-
-
-def save_model(model: BaseModel, path: PathLike, /, *, overwrite: bool = False) -> None:
-    with writer(path, overwrite=overwrite) as temp, temp.open(mode="w") as fh:
-        _ = fh.write(model.model_dump_json())
-
-
-__all__ = ["HashableBaseModel", "LoadModelError", "load_model", "save_model"]
+__all__ = ["ExpandedPath"]

utilities/pydantic_settings.py

@@ -0,0 +1,240 @@
+from __future__ import annotations
+
+from functools import reduce
+from pathlib import Path
+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,
+    TomlConfigSettingsSource,
+    YamlConfigSettingsSource,
+)
+from pydantic_settings.sources import DEFAULT_PATH
+
+from utilities.errors import ImpossibleCaseError
+from utilities.iterables import always_iterable
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator, Sequence
+
+    from pydantic_settings.sources import PathType
+
+    from utilities.types import MaybeSequenceStr, PathLike
+
+
+type PathLikeWithSection = tuple[PathLike, MaybeSequenceStr]
+type PathLikeOrWithSection = PathLike | PathLikeWithSection
+
+
+class CustomBaseSettings(BaseSettings):
+    """Base settings for loading JSON/TOML/YAML files."""
+
+    # paths
+    json_files: ClassVar[Sequence[PathLikeOrWithSection]] = []
+    toml_files: ClassVar[Sequence[PathLikeOrWithSection]] = []
+    yaml_files: ClassVar[Sequence[PathLikeOrWithSection]] = []
+
+    # config
+    model_config: ClassVar[SettingsConfigDict] = SettingsConfigDict(
+        frozen=True, env_nested_delimiter="__"
+    )
+
+    @classmethod
+    @override
+    def settings_customise_sources(
+        cls,
+        settings_cls: type[BaseSettings],
+        init_settings: PydanticBaseSettingsSource,
+        env_settings: PydanticBaseSettingsSource,
+        dotenv_settings: PydanticBaseSettingsSource,
+        file_secret_settings: PydanticBaseSettingsSource,
+    ) -> tuple[PydanticBaseSettingsSource, ...]:
+        _ = (init_settings, dotenv_settings, file_secret_settings)
+        return tuple(cls._yield_base_settings_sources(settings_cls, env_settings))
+
+    @classmethod
+    def _yield_base_settings_sources(
+        cls,
+        settings_cls: type[BaseSettings],
+        env_settings: PydanticBaseSettingsSource,
+        /,
+    ) -> Iterator[PydanticBaseSettingsSource]:
+        yield env_settings
+        for file, section in map(_ensure_section, cls.json_files):
+            yield JsonConfigSectionSettingsSource(
+                settings_cls, json_file=file, section=section
+            )
+        for file, section in map(_ensure_section, cls.toml_files):
+            yield TomlConfigSectionSettingsSource(
+                settings_cls, toml_file=file, section=section
+            )
+        for file, section in map(_ensure_section, cls.yaml_files):
+            yield YamlConfigSectionSettingsSource(
+                settings_cls, yaml_file=file, section=section
+            )
+
+
+class JsonConfigSectionSettingsSource(JsonConfigSettingsSource):
+    @override
+    def __init__(
+        self,
+        settings_cls: type[BaseSettings],
+        json_file: PathType | None = DEFAULT_PATH,
+        json_file_encoding: str | None = None,
+        *,
+        section: MaybeSequenceStr,
+    ) -> None:
+        super().__init__(
+            settings_cls, json_file=json_file, json_file_encoding=json_file_encoding
+        )
+        self.section = section
+
+    @override
+    def __call__(self) -> dict[str, Any]:
+        return _get_section(super().__call__(), self.section)
+
+
+class TomlConfigSectionSettingsSource(TomlConfigSettingsSource):
+    @override
+    def __init__(
+        self,
+        settings_cls: type[BaseSettings],
+        toml_file: PathType | None = DEFAULT_PATH,
+        *,
+        section: MaybeSequenceStr,
+    ) -> None:
+        super().__init__(settings_cls, toml_file=toml_file)
+        self.section = section
+
+    @override
+    def __call__(self) -> dict[str, Any]:
+        return _get_section(super().__call__(), self.section)
+
+
+class YamlConfigSectionSettingsSource(YamlConfigSettingsSource):
+    @override
+    def __init__(
+        self,
+        settings_cls: type[BaseSettings],
+        yaml_file: PathType | None = DEFAULT_PATH,
+        yaml_file_encoding: str | None = None,
+        yaml_config_section: str | None = None,
+        *,
+        section: MaybeSequenceStr,
+    ) -> None:
+        super().__init__(
+            settings_cls,
+            yaml_file=yaml_file,
+            yaml_file_encoding=yaml_file_encoding,
+            yaml_config_section=yaml_config_section,
+        )
+        self.section = section
+
+    @override
+    def __call__(self) -> dict[str, Any]:
+        return _get_section(super().__call__(), self.section)
+
+
+def _ensure_section(file: PathLikeOrWithSection, /) -> PathLikeWithSection:
+    match file:
+        case Path() | str():
+            return file, []
+        case Path() | str() as path, str() | list() | tuple() as section:
+            return path, section
+        case never:
+            assert_never(never)
+
+
+def _get_section(
+    mapping: dict[str, Any], section: MaybeSequenceStr, /
+) -> dict[str, Any]:
+    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 (
+            isinstance(cast("Any", ann), type)  # 'ann' is possible not a type
+            and 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",
+    "load_settings",
+]

utilities/pydantic_settings_sops.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from logging import Filter, LogRecord, getLogger
+from re import search
+from typing import TYPE_CHECKING, Any, ClassVar, override
+
+from pydantic_settings.sources import DEFAULT_PATH
+from pydantic_settings_sops import SOPSConfigSettingsSource
+
+from utilities.pydantic_settings import (
+    CustomBaseSettings,
+    PathLikeOrWithSection,
+    _ensure_section,
+    _get_section,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator, Sequence
+
+    from pydantic_settings import BaseSettings, PydanticBaseSettingsSource
+    from pydantic_settings.sources import PathType
+
+    from utilities.types import MaybeSequenceStr
+
+
+class _SuppressDefaultConfigMessage(Filter):
+    @override
+    def filter(self, record: LogRecord) -> bool:
+        return not search(
+            r"^default config file does not exists '.*'$", record.getMessage()
+        )
+
+
+getLogger("sopsy.utils").addFilter(_SuppressDefaultConfigMessage())
+
+
+class SopsBaseSettings(CustomBaseSettings):
+    """Base settings for loading secrets using `sops/age`."""
+
+    # paths
+    secret_files: ClassVar[Sequence[PathLikeOrWithSection]] = []
+
+    @classmethod
+    @override
+    def _yield_base_settings_sources(
+        cls,
+        settings_cls: type[BaseSettings],
+        env_settings: PydanticBaseSettingsSource,
+        /,
+    ) -> Iterator[PydanticBaseSettingsSource]:
+        yield from super()._yield_base_settings_sources(settings_cls, env_settings)
+        for file, section in map(_ensure_section, cls.secret_files):
+            yield SOPSConfigSectionSettingsSource(
+                settings_cls, json_file=file, section=section
+            )
+
+
+class SOPSConfigSectionSettingsSource(SOPSConfigSettingsSource):
+    @override
+    def __init__(
+        self,
+        settings_cls: type[BaseSettings],
+        json_file: PathType | None = DEFAULT_PATH,
+        yaml_file: PathType | None = DEFAULT_PATH,
+        *,
+        section: MaybeSequenceStr,
+    ) -> None:
+        super().__init__(settings_cls, json_file=json_file, yaml_file=yaml_file)  # pyright: ignore[reportArgumentType]
+        self.section = section
+
+    @override
+    def __call__(self) -> dict[str, Any]:
+        return _get_section(super().__call__(), self.section)
+
+
+__all__ = ["SOPSConfigSectionSettingsSource", "SopsBaseSettings"]

utilities/pyinstrument.py

@@ -7,8 +7,8 @@ from typing import TYPE_CHECKING
 from pyinstrument.profiler import Profiler
 
 from utilities.atomicwrites import writer
-from utilities.pathlib import get_path
-from utilities.whenever import format_compact, get_now
+from utilities.pathlib import to_path
+from utilities.whenever import format_compact, get_now_local
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
@@ -17,15 +17,15 @@ if TYPE_CHECKING:
 
 
 @contextmanager
-def profile(*, path: MaybeCallablePathLike | None = Path.cwd) -> Iterator[None]:
+def profile(path: MaybeCallablePathLike = Path.cwd, /) -> Iterator[None]:
     """Profile the contents of a block."""
     with Profiler() as profiler:
         yield
-    filename = get_path(path=path).joinpath(
-        f"profile__{format_compact(get_now())}.html"
+    filename = to_path(path).joinpath(
+        f"profile__{format_compact(get_now_local(), path=True)}.html"
     )
-    with writer(filename) as temp, temp.open(mode="w") as fh:
-        _ = fh.write(profiler.output_html())
+    with writer(filename) as temp:
+        _ = temp.write_text(profiler.output_html())
 
 
 __all__ = ["profile"]