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

utilities/python_dotenv.py

@@ -1,105 +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
-
-if TYPE_CHECKING:
-    from collections.abc import Mapping
-    from collections.abc import Set as AbstractSet
-
-    from utilities.types import (
-        MaybeCallablePathLike,
-        ParseObjectExtra,
-        StrMapping,
-        TDataclass,
-    )
-
-
-def load_settings(
-    cls: type[TDataclass],
-    /,
-    *,
-    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,
-) -> TDataclass:
-    """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/sys.py

@@ -1,87 +0,0 @@
-from __future__ import annotations
-
-from asyncio import TaskGroup, run
-from dataclasses import dataclass
-from functools import partial
-from inspect import iscoroutinefunction
-from sys import version_info
-from typing import TYPE_CHECKING, Any, cast, override
-
-from utilities.logging import get_logger
-
-if TYPE_CHECKING:
-    from collections.abc import Callable, Iterable
-    from types import TracebackType
-
-    from utilities.types import Coroutine1, LoggerOrName, MaybeCoroutine1, StrMapping
-
-
-VERSION_MAJOR_MINOR = (version_info.major, version_info.minor)
-
-
-def make_except_hook(
-    *,
-    logger: LoggerOrName | None = None,
-    message: object = "",
-    extra: StrMapping | None = None,
-    callbacks: Iterable[Callable[[], MaybeCoroutine1[None]]] | None = None,
-) -> Callable[
-    [type[BaseException] | None, BaseException | None, TracebackType | None], None
-]:
-    """Create an exception hook with various features."""
-    return partial(
-        _make_except_hook_inner,
-        logger=logger,
-        message=message,
-        extra=extra,
-        callbacks=callbacks,
-    )
-
-
-def _make_except_hook_inner(
-    exc_type: type[BaseException] | None,
-    exc_val: BaseException | None,
-    traceback: TracebackType | None,
-    /,
-    *,
-    logger: LoggerOrName | None = None,
-    message: object = "",
-    extra: StrMapping | None = None,
-    callbacks: Iterable[Callable[[], MaybeCoroutine1[None]]] | None = None,
-) -> None:
-    """Exception hook to log the traceback."""
-    _ = (exc_type, traceback)
-    if exc_val is None:
-        raise MakeExceptHookError
-    logger_use = get_logger(logger=logger)
-    exc_info = (exc_type, exc_val, traceback)
-    logger_use.exception(message, exc_info=cast("Any", exc_info), extra=extra)
-    async_callbacks: list[Callable[[], Coroutine1[None]]] = []
-    if callbacks is not None:
-        for callback in callbacks:
-            if not iscoroutinefunction(callback):
-                cast("Callable[[], None]", callback)()
-            else:  # skipif-ci
-                async_callback = cast("Callable[[], Coroutine1[None]]", callback)
-                async_callbacks.append(async_callback)
-    if len(async_callbacks) >= 1:  # skipif-ci
-        run(_run_async_callbacks(async_callbacks))
-
-
-@dataclass(kw_only=True, slots=True)
-class MakeExceptHookError(Exception):
-    @override
-    def __str__(self) -> str:
-        return "No exception to log"
-
-
-async def _run_async_callbacks(
-    callbacks: Iterable[Callable[[], Coroutine1[None]]], /
-) -> None:
-    """Run all asynchronous callbacks."""
-    async with TaskGroup() as tg:  # skipif-ci
-        for callback in callbacks:
-            _ = tg.create_task(callback())
-
-
-__all__ = ["VERSION_MAJOR_MINOR", "MakeExceptHookError", "make_except_hook"]

utilities/tenacity.py

@@ -1,145 +0,0 @@
-from __future__ import annotations
-
-from contextlib import AbstractAsyncContextManager, asynccontextmanager
-from typing import TYPE_CHECKING, Any, override
-
-from tenacity import (
-    AsyncRetrying,
-    AttemptManager,
-    RetryCallState,
-    RetryError,
-    after_nothing,
-    before_nothing,
-    retry_if_exception_type,
-    stop_never,
-    wait_none,
-)
-from tenacity import wait_exponential_jitter as _wait_exponential_jitter
-from tenacity._utils import MAX_WAIT
-from tenacity.asyncio import _portable_async_sleep
-
-from utilities.asyncio import timeout_dur
-from utilities.contextlib import NoOpContextManager
-from utilities.datetime import datetime_duration_to_float
-
-if TYPE_CHECKING:
-    from collections.abc import AsyncIterator, Callable
-
-    from tenacity.retry import RetryBaseT
-    from tenacity.stop import StopBaseT
-    from tenacity.wait import WaitBaseT
-
-    from utilities.types import Duration, MaybeAwaitable
-
-
-type MaybeAttemptManager = NoOpContextManager | AttemptManager
-type MaybeAttemptContextManager = AbstractAsyncContextManager[MaybeAttemptManager]
-
-
-class wait_exponential_jitter(_wait_exponential_jitter):  # noqa: N801
-    """Subclass of `wait_exponential_jitter` accepting durations."""
-
-    @override
-    def __init__(
-        self,
-        initial: Duration = 1,
-        max: Duration = MAX_WAIT,
-        exp_base: float = 2,
-        jitter: Duration = 1,
-    ) -> None:
-        super().__init__(
-            initial=datetime_duration_to_float(initial),
-            max=datetime_duration_to_float(max),
-            exp_base=exp_base,
-            jitter=datetime_duration_to_float(jitter),
-        )
-
-
-async def yield_attempts(
-    *,
-    sleep: Callable[[int | float], MaybeAwaitable[None]] | None = None,
-    stop: StopBaseT | None = None,
-    wait: WaitBaseT | None = None,
-    retry: RetryBaseT | None = None,
-    before: Callable[[RetryCallState], MaybeAwaitable[None]] | None = None,
-    after: Callable[[RetryCallState], MaybeAwaitable[None]] | None = None,
-    before_sleep: Callable[[RetryCallState], MaybeAwaitable[None]] | None = None,
-    reraise: bool | None = None,
-    retry_error_cls: type[RetryError] | None = None,
-    retry_error_callback: Callable[[RetryCallState], MaybeAwaitable[Any]] | None = None,
-) -> AsyncIterator[MaybeAttemptManager]:
-    """Yield the attempts."""
-    if (
-        (sleep is None)
-        and (stop is None)
-        and (wait is None)
-        and (retry is None)
-        and (before is None)
-        and (after is None)
-        and (before_sleep is None)
-        and (reraise is None)
-        and (retry_error_cls is None)
-    ):
-        yield NoOpContextManager()
-    else:
-        retrying = AsyncRetrying(
-            sleep=_portable_async_sleep if sleep is None else sleep,
-            stop=stop_never if stop is None else stop,
-            wait=wait_none() if wait is None else wait,
-            retry=retry_if_exception_type() if retry is None else retry,
-            before=before_nothing if before is None else before,
-            after=after_nothing if after is None else after,
-            before_sleep=None if before_sleep is None else before_sleep,
-            reraise=False if reraise is None else reraise,
-            retry_error_cls=RetryError if retry_error_cls is None else retry_error_cls,
-            retry_error_callback=retry_error_callback,
-        )
-        async for attempt in retrying:
-            yield attempt
-
-
-async def yield_timeout_attempts(
-    *,
-    sleep: Callable[[int | float], MaybeAwaitable[None]] | None = None,
-    stop: StopBaseT | None = None,
-    wait: WaitBaseT | None = None,
-    retry: RetryBaseT | None = None,
-    before: Callable[[RetryCallState], MaybeAwaitable[None]] | None = None,
-    after: Callable[[RetryCallState], MaybeAwaitable[None]] | None = None,
-    before_sleep: Callable[[RetryCallState], MaybeAwaitable[None]] | None = None,
-    reraise: bool | None = None,
-    retry_error_cls: type[RetryError] | None = None,
-    retry_error_callback: Callable[[RetryCallState], MaybeAwaitable[Any]] | None = None,
-    timeout: Duration | None = None,
-) -> AsyncIterator[MaybeAttemptContextManager]:
-    """Yield the attempts, with timeout."""
-    async for attempt in yield_attempts(
-        sleep=sleep,
-        stop=stop,
-        wait=wait,
-        retry=retry,
-        before=before,
-        after=after,
-        before_sleep=before_sleep,
-        reraise=reraise,
-        retry_error_cls=retry_error_cls,
-        retry_error_callback=retry_error_callback,
-    ):
-
-        @asynccontextmanager
-        async def new(
-            attempt: MaybeAttemptManager, /
-        ) -> AsyncIterator[MaybeAttemptManager]:
-            with attempt:
-                async with timeout_dur(duration=timeout):
-                    yield attempt
-
-        yield new(attempt)
-
-
-__all__ = [
-    "MaybeAttemptManager",
-    "wait_exponential_jitter",
-    "yield_attempts",
-    "yield_timeout_attempts",
-]