dycw-utilities 0.129.10__py3-none-any.whl → 0.175.17__py3-none-any.whl

utilities/psutil.py

@@ -1,74 +1,23 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from json import dumps
-from logging import getLogger
 from math import isclose, nan
-from pathlib import Path
-from typing import TYPE_CHECKING, Self, override
+from typing import TYPE_CHECKING, Self
 
 from psutil import swap_memory, virtual_memory
 
-from utilities.asyncio import Looper
 from utilities.contextlib import suppress_super_object_attribute_error
-from utilities.datetime import SECOND, get_now
+from utilities.whenever import get_now
 
 if TYPE_CHECKING:
-    import datetime as dt
-    from logging import Logger
+    from whenever import ZonedDateTime
 
-    from utilities.types import Duration, PathLike
 
-
-@dataclass(kw_only=True)
-class MemoryMonitorService(Looper[None]):
-    """Service to monitor memory usage."""
-
-    # base
-    freq: Duration = field(default=10 * SECOND, repr=False)
-    backoff: Duration = field(default=10 * SECOND, repr=False)
-    # self
-    console: str | None = field(default=None, repr=False)
-    path: PathLike = "memory.txt"
-    _console: Logger | None = field(init=False, repr=False)
-    _path: Path = field(init=False, repr=False)
-
-    @override
-    def __post_init__(self) -> None:
-        super().__post_init__()
-        if self.console is not None:
-            self._console = getLogger(self.console)
-        self._path = Path(self.path)
-        self._path.parent.mkdir(parents=True, exist_ok=True)
-
-    @override
-    async def core(self) -> None:
-        await super().core()
-        memory = MemoryUsage.new()
-        mapping = {
-            "datetime": memory.datetime.strftime("%Y-%m-%d %H:%M:%S"),
-            "virtual used (mb)": memory.virtual_used_mb,
-            "virtual total (mb)": memory.virtual_total_mb,
-            "virtual (%)": memory.virtual_pct,
-            "swap used (mb)": memory.swap_used_mb,
-            "swap total (mb)": memory.swap_total_mb,
-            "swap (%)": memory.swap_pct,
-        }
-        ser = dumps(mapping)
-        with self._path.open(mode="a") as fh:
-            _ = fh.write(f"{ser}\n")
-        if self._console is not None:
-            self._console.info("%s", mapping)
-
-
-##
-
-
-@dataclass(kw_only=True)
+@dataclass(order=True, unsafe_hash=True, kw_only=True)
 class MemoryUsage:
     """A memory usage."""
 
-    datetime: dt.datetime = field(default_factory=get_now)
+    datetime: ZonedDateTime = field(default_factory=get_now)
     virtual_used: int = field(repr=False)
     virtual_used_mb: int = field(init=False)
     virtual_total: int = field(repr=False)
@@ -112,4 +61,4 @@ class MemoryUsage:
         return round(bytes_ / (1024**2))
 
 
-__all__ = ["MemoryMonitorService", "MemoryUsage"]
+__all__ = ["MemoryUsage"]

utilities/pwd.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from typing import assert_never
+
+from utilities.os import EFFECTIVE_USER_ID
+from utilities.platform import SYSTEM
+
+
+def get_uid_name(uid: int, /) -> str | None:
+    """Get the name of a user ID."""
+    match SYSTEM:
+        case "windows":  # skipif-not-windows
+            return None
+        case "mac" | "linux":  # skipif-windows
+            from pwd import getpwuid
+
+            return getpwuid(uid).pw_name
+        case never:
+            assert_never(never)
+
+
+ROOT_USER_NAME = get_uid_name(0)
+EFFECTIVE_USER_NAME = (
+    None if EFFECTIVE_USER_ID is None else get_uid_name(EFFECTIVE_USER_ID)
+)
+
+
+__all__ = ["EFFECTIVE_USER_NAME", "ROOT_USER_NAME", "get_uid_name"]

utilities/pydantic.py

@@ -1,61 +1,11 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
 from pathlib import Path
-from typing import TYPE_CHECKING, TypeVar, override
+from typing import Annotated
 
-from pydantic import BaseModel
+from pydantic import BeforeValidator
 
-if TYPE_CHECKING:
-    from utilities.types import PathLike
+ExpandedPath = Annotated[Path, BeforeValidator(lambda p: Path(p).expanduser())]
 
-_TBaseModel = TypeVar("_TBaseModel", bound=BaseModel)
 
-
-class HashableBaseModel(BaseModel):
-    """Subclass of BaseModel which is hashable."""
-
-    @override
-    def __hash__(self) -> int:
-        return hash((type(self), *self.__dict__.values()))
-
-
-def load_model(model: type[_TBaseModel], path: PathLike, /) -> _TBaseModel:
-    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:
-    from utilities.atomicwrites import writer
-
-    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

@@ -6,9 +6,9 @@ from typing import TYPE_CHECKING
 
 from pyinstrument.profiler import Profiler
 
-from utilities.datetime import serialize_compact
-from utilities.pathlib import get_path
-from utilities.tzlocal import get_now_local
+from utilities.atomicwrites import writer
+from utilities.pathlib import to_path
+from utilities.whenever import format_compact, get_now_local
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
@@ -17,17 +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."""
-    from utilities.atomicwrites import writer
-
     with Profiler() as profiler:
         yield
-    filename = get_path(path=path).joinpath(
-        f"profile__{serialize_compact(get_now_local())}.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"]