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

utilities/period.py

@@ -1,152 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Self, TypedDict, override
-from zoneinfo import ZoneInfo
-
-from whenever import Date, DateDelta, TimeDelta, ZonedDateTime
-
-from utilities.dataclasses import replace_non_sentinel
-from utilities.functions import get_class_name
-from utilities.sentinel import Sentinel, sentinel
-from utilities.zoneinfo import get_time_zone_name
-
-if TYPE_CHECKING:
-    from utilities.types import TimeZoneLike
-
-
-class _PeriodAsDict[T: (Date, ZonedDateTime)](TypedDict):
-    start: T
-    end: T
-
-
-@dataclass(repr=False, order=True, unsafe_hash=True, kw_only=False)
-class DatePeriod:
-    """A period of dates."""
-
-    start: Date
-    end: Date
-
-    def __post_init__(self) -> None:
-        if self.start > self.end:
-            raise _PeriodInvalidError(start=self.start, end=self.end)
-
-    def __add__(self, other: DateDelta, /) -> Self:
-        """Offset the period."""
-        return self.replace(start=self.start + other, end=self.end + other)
-
-    def __contains__(self, other: Date, /) -> bool:
-        """Check if a date/datetime lies in the period."""
-        return self.start <= other <= self.end
-
-    @override
-    def __repr__(self) -> str:
-        cls = get_class_name(self)
-        return f"{cls}({self.start}, {self.end})"
-
-    def __sub__(self, other: DateDelta, /) -> Self:
-        """Offset the period."""
-        return self.replace(start=self.start - other, end=self.end - other)
-
-    @property
-    def delta(self) -> DateDelta:
-        """The delta of the period."""
-        return self.end - self.start
-
-    def replace(
-        self, *, start: Date | Sentinel = sentinel, end: Date | Sentinel = sentinel
-    ) -> Self:
-        """Replace elements of the period."""
-        return replace_non_sentinel(self, start=start, end=end)
-
-    def to_dict(self) -> _PeriodAsDict[Date]:
-        """Convert the period to a dictionary."""
-        return _PeriodAsDict(start=self.start, end=self.end)
-
-
-@dataclass(repr=False, order=True, unsafe_hash=True, kw_only=False)
-class ZonedDateTimePeriod:
-    """A period of time."""
-
-    start: ZonedDateTime
-    end: ZonedDateTime
-
-    def __post_init__(self) -> None:
-        if self.start > self.end:
-            raise _PeriodInvalidError(start=self.start, end=self.end)
-        if self.start.tz != self.end.tz:
-            raise _PeriodTimeZoneError(
-                start=ZoneInfo(self.start.tz), end=ZoneInfo(self.end.tz)
-            )
-
-    def __add__(self, other: TimeDelta, /) -> Self:
-        """Offset the period."""
-        return self.replace(start=self.start + other, end=self.end + other)
-
-    def __contains__(self, other: ZonedDateTime, /) -> bool:
-        """Check if a date/datetime lies in the period."""
-        return self.start <= other <= self.end
-
-    @override
-    def __repr__(self) -> str:
-        cls = get_class_name(self)
-        return f"{cls}({self.start.to_plain()}, {self.end.to_plain()}[{self.time_zone.key}])"
-
-    def __sub__(self, other: TimeDelta, /) -> Self:
-        """Offset the period."""
-        return self.replace(start=self.start - other, end=self.end - other)
-
-    @property
-    def delta(self) -> TimeDelta:
-        """The duration of the period."""
-        return self.end - self.start
-
-    def replace(
-        self,
-        *,
-        start: ZonedDateTime | Sentinel = sentinel,
-        end: ZonedDateTime | Sentinel = sentinel,
-    ) -> Self:
-        """Replace elements of the period."""
-        return replace_non_sentinel(self, start=start, end=end)
-
-    @property
-    def time_zone(self) -> ZoneInfo:
-        """The time zone of the period."""
-        return ZoneInfo(self.start.tz)
-
-    def to_dict(self) -> _PeriodAsDict[ZonedDateTime]:
-        """Convert the period to a dictionary."""
-        return _PeriodAsDict(start=self.start, end=self.end)
-
-    def to_tz(self, time_zone: TimeZoneLike, /) -> Self:
-        """Convert the time zone."""
-        tz = get_time_zone_name(time_zone)
-        return self.replace(start=self.start.to_tz(tz), end=self.end.to_tz(tz))
-
-
-@dataclass(kw_only=True, slots=True)
-class PeriodError(Exception): ...
-
-
-@dataclass(kw_only=True, slots=True)
-class _PeriodInvalidError[T: (Date, ZonedDateTime)](PeriodError):
-    start: T
-    end: T
-
-    @override
-    def __str__(self) -> str:
-        return f"Invalid period; got {self.start} > {self.end}"
-
-
-@dataclass(kw_only=True, slots=True)
-class _PeriodTimeZoneError(PeriodError):
-    start: ZoneInfo
-    end: ZoneInfo
-
-    @override
-    def __str__(self) -> str:
-        return f"Period must contain exactly one time zone; got {self.start} and {self.end}"
-
-
-__all__ = ["DatePeriod", "PeriodError", "ZonedDateTimePeriod"]

utilities/pudb.py

@@ -1,62 +0,0 @@
-from __future__ import annotations
-
-from asyncio import iscoroutinefunction
-from functools import partial, wraps
-from typing import TYPE_CHECKING, Any, NoReturn, cast, overload
-
-from utilities.os import GetEnvVarError, get_env_var
-
-if TYPE_CHECKING:
-    from collections.abc import Callable
-
-
-_ENV_VAR = "DEBUG"
-
-
-@overload
-def call_pudb[F: Callable](func: F, /, *, env_var: str = _ENV_VAR) -> F: ...
-@overload
-def call_pudb[F: Callable](
-    func: None = None, /, *, env_var: str = _ENV_VAR
-) -> Callable[[F], F]: ...
-def call_pudb[F: Callable](
-    func: F | None = None, /, *, env_var: str = _ENV_VAR
-) -> F | Callable[[F], F]:
-    """Call `pudb` upon failure, if the required environment variable is set."""
-    if func is None:
-        result = partial(call_pudb, env_var=env_var)
-        return cast("Callable[[F], F]", result)
-
-    if not iscoroutinefunction(func):
-
-        @wraps(func)
-        def wrapped_sync(*args: Any, **kwargs: Any) -> Any:
-            try:
-                return func(*args, **kwargs)
-            except Exception as error:  # noqa: BLE001
-                _call_pudb(error, env_var=env_var)
-
-        return cast("F", wrapped_sync)
-
-    @wraps(func)
-    async def wrapped_async(*args: Any, **kwargs: Any) -> Any:
-        try:
-            return await func(*args, **kwargs)
-        except Exception as error:  # noqa: BLE001
-            _call_pudb(error, env_var=env_var)
-
-    return cast("F", wrapped_async)
-
-
-def _call_pudb(error: Exception, /, *, env_var: str = _ENV_VAR) -> NoReturn:
-    try:
-        _ = get_env_var(env_var)
-    except GetEnvVarError:
-        raise error from None
-    from pudb import post_mortem  # pragma: no cover
-
-    post_mortem()  # pragma: no cover
-    raise error  # pragma: no cover
-
-
-__all__ = ["call_pudb"]

utilities/python_dotenv.py

@@ -1,101 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from os import environ
-from pathlib import Path
-from typing import TYPE_CHECKING, override
-
-from dotenv import dotenv_values
-
-from utilities.dataclasses import _ParseDataClassMissingValuesError, parse_dataclass
-from utilities.iterables import MergeStrMappingsError, merge_str_mappings
-from utilities.pathlib import get_root
-from utilities.reprlib import get_repr
-from utilities.types import Dataclass
-
-if TYPE_CHECKING:
-    from collections.abc import Mapping
-    from collections.abc import Set as AbstractSet
-
-    from utilities.types import MaybeCallablePathLike, ParseObjectExtra, StrMapping
-
-
-def load_settings[T: Dataclass](
-    cls: type[T],
-    /,
-    *,
-    path: MaybeCallablePathLike | None = Path.cwd,
-    globalns: StrMapping | None = None,
-    localns: StrMapping | None = None,
-    warn_name_errors: bool = False,
-    head: bool = False,
-    case_sensitive: bool = False,
-    extra_parsers: ParseObjectExtra | None = None,
-) -> T:
-    """Load a set of settings from the `.env` file."""
-    path = get_root(path=path).joinpath(".env")
-    if not path.exists():
-        raise _LoadSettingsFileNotFoundError(path=path) from None
-    maybe_values_dotenv = dotenv_values(path)
-    try:
-        maybe_values: Mapping[str, str | None] = merge_str_mappings(
-            maybe_values_dotenv, environ, case_sensitive=case_sensitive
-        )
-    except MergeStrMappingsError as error:
-        raise _LoadSettingsDuplicateKeysError(
-            path=path,
-            values=error.mapping,
-            counts=error.counts,
-            case_sensitive=case_sensitive,
-        ) from None
-    values = {k: v for k, v in maybe_values.items() if v is not None}
-    try:
-        return parse_dataclass(
-            values,
-            cls,
-            globalns=globalns,
-            localns=localns,
-            warn_name_errors=warn_name_errors,
-            head=head,
-            case_sensitive=case_sensitive,
-            allow_extra_keys=True,
-            extra_parsers=extra_parsers,
-        )
-    except _ParseDataClassMissingValuesError as error:
-        raise _LoadSettingsMissingKeysError(path=path, fields=error.fields) from None
-
-
-@dataclass(kw_only=True, slots=True)
-class LoadSettingsError(Exception):
-    path: Path
-
-
-@dataclass(kw_only=True, slots=True)
-class _LoadSettingsDuplicateKeysError(LoadSettingsError):
-    values: StrMapping
-    counts: Mapping[str, int]
-    case_sensitive: bool = False
-
-    @override
-    def __str__(self) -> str:
-        return f"Mapping {get_repr(dict(self.values))} keys must not contain duplicates (modulo case); got {get_repr(self.counts)}"
-
-
-@dataclass(kw_only=True, slots=True)
-class _LoadSettingsFileNotFoundError(LoadSettingsError):
-    @override
-    def __str__(self) -> str:
-        return f"Path {str(self.path)!r} must exist"
-
-
-@dataclass(kw_only=True, slots=True)
-class _LoadSettingsMissingKeysError(LoadSettingsError):
-    fields: AbstractSet[str]
-
-    @override
-    def __str__(self) -> str:
-        desc = ", ".join(map(repr, sorted(self.fields)))
-        return f"Unable to load {str(self.path)!r}; missing value(s) for {desc}"
-
-
-__all__ = ["LoadSettingsError", "load_settings"]

utilities/streamlit.py

@@ -1,105 +0,0 @@
-from __future__ import annotations
-
-from hmac import compare_digest
-from typing import TYPE_CHECKING, Literal
-
-from streamlit import (
-    button,
-    empty,
-    error,
-    form,
-    form_submit_button,
-    markdown,
-    secrets,
-    session_state,
-    stop,
-    text_input,
-)
-
-if TYPE_CHECKING:
-    from collections.abc import Callable
-
-    from streamlit.elements.lib.utils import Key
-    from streamlit.runtime.state import WidgetArgs, WidgetCallback, WidgetKwargs
-
-
-def centered_button(
-    label: str,
-    /,
-    *,
-    key: Key | None = None,
-    help: str | None = None,  # noqa: A002
-    on_click: WidgetCallback | None = None,
-    args: WidgetArgs | None = None,
-    kwargs: WidgetKwargs | None = None,
-    type: Literal["primary", "secondary"] = "secondary",  # noqa: A002
-    disabled: bool = False,
-    use_container_width: bool = False,
-) -> bool:
-    """Create a centered button."""
-    style = r"<style>.row-widget.stButton {text-align: center;}</style>"
-    _ = markdown(style, unsafe_allow_html=True)
-    with empty():
-        return button(
-            label,
-            key=key,
-            help=help,
-            on_click=on_click,
-            args=args,
-            kwargs=kwargs,
-            type=type,
-            disabled=disabled,
-            use_container_width=use_container_width,
-        )
-
-
-_USERNAME = "username"
-_PASSWORD = "password"  # noqa: S105
-_PASSWORD_CORRECT = "password_correct"  # noqa: S105
-
-
-def ensure_logged_in(
-    *,
-    skip: bool = False,
-    before_form: Callable[..., None] | None = None,
-    after_form: Callable[..., None] | None = None,
-) -> None:
-    """Ensure the user is logged in."""
-    if not (skip or _check_password(before_form=before_form, after_form=after_form)):
-        stop()
-
-
-def _check_password(
-    *,
-    before_form: Callable[..., None] | None = None,
-    after_form: Callable[..., None] | None = None,
-) -> bool:
-    """Return `True` if the user had a correct password."""
-    if session_state.get("password_correct", False):
-        return True
-    if before_form is not None:
-        before_form()
-    with form("Credentials"):
-        _ = text_input("Username", key=_USERNAME)
-        _ = text_input("Password", type="password", key=_PASSWORD)
-        _ = form_submit_button("Log in", on_click=_password_entered)
-    if after_form is not None:
-        after_form()
-    if _PASSWORD_CORRECT in session_state:
-        _ = error("Username/password combination invalid or incorrect")
-    return False
-
-
-def _password_entered() -> None:
-    """Check whether a password entered by the user is correct."""
-    if (session_state[_USERNAME] in secrets["passwords"]) and compare_digest(
-        session_state[_PASSWORD], secrets.passwords[session_state[_USERNAME]]
-    ):
-        session_state[_PASSWORD_CORRECT] = True
-        del session_state[_PASSWORD]
-        del session_state[_USERNAME]
-    else:
-        session_state[_PASSWORD_CORRECT] = False
-
-
-__all__ = ["ensure_logged_in"]

utilities/typed_settings.py

@@ -1,123 +0,0 @@
-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, 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
-from utilities.whenever import Freq
-
-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
-
-
-##
-
-
-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),
-            (Freq, Freq.parse),
-            (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[T](
-    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[T](
-    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"]