dycw-utilities 0.129.14__py3-none-any.whl → 0.130.0__py3-none-any.whl

utilities/loguru.py

@@ -1,144 +0,0 @@
-from __future__ import annotations
-
-import logging
-from dataclasses import dataclass
-from enum import StrEnum, unique
-from logging import Handler, LogRecord
-from sys import _getframe
-from typing import TYPE_CHECKING, cast, override
-
-from loguru import logger
-
-from utilities.iterables import OneEmptyError, OneNonUniqueError, one
-
-if TYPE_CHECKING:
-    from collections.abc import Sequence
-
-    from loguru import LevelConfig
-
-
-LEVEL_CONFIGS: Sequence[LevelConfig] = [
-    {"name": "TRACE", "color": "<blue><bold>"},
-    {"name": "DEBUG", "color": "<cyan><bold>"},
-    {"name": "INFO", "color": "<green><bold>"},
-    {"name": "SUCCESS", "color": "<magenta><bold>"},
-    {"name": "WARNING", "color": "<yellow><bold>"},
-    {"name": "ERROR", "color": "<red><bold>"},
-    {"name": "CRITICAL", "color": "<red><bold><blink>"},
-]
-
-
-##
-
-
-class InterceptHandler(Handler):
-    """Handler for intercepting standard logging messages.
-
-    https://github.com/Delgan/loguru#entirely-compatible-with-standard-logging
-    """
-
-    @override
-    def emit(self, record: LogRecord) -> None:
-        # Get corresponding Loguru level if it exists.
-        try:  # pragma: no cover
-            level = logger.level(record.levelname).name
-        except ValueError:  # pragma: no cover
-            level = record.levelno
-
-        # Find caller from where originated the logged message.
-        frame, depth = _getframe(6), 6  # pragma: no cover
-        while (  # pragma: no cover
-            frame and frame.f_code.co_filename == logging.__file__
-        ):
-            frame = frame.f_back
-            depth += 1
-
-        logger.opt(depth=depth, exception=record.exc_info).log(  # pragma: no cover
-            level, record.getMessage()
-        )
-
-
-##
-
-
-@unique
-class LogLevel(StrEnum):
-    """An enumeration of the logging levels."""
-
-    TRACE = "TRACE"
-    DEBUG = "DEBUG"
-    INFO = "INFO"
-    SUCCESS = "SUCCESS"
-    WARNING = "WARNING"
-    ERROR = "ERROR"
-    CRITICAL = "CRITICAL"
-
-
-##
-
-
-def get_logging_level_name(level: int, /) -> str:
-    """Get the logging level name."""
-    core = logger._core  # noqa: SLF001 # pyright: ignore[reportAttributeAccessIssue]
-    try:
-        return one(k for k, v in core.levels.items() if v.no == level)
-    except OneEmptyError:
-        raise _GetLoggingLevelNameEmptyError(level=level) from None
-    except OneNonUniqueError as error:
-        error = cast("OneNonUniqueError[str]", error)
-        raise _GetLoggingLevelNameNonUniqueError(
-            level=level, first=error.first, second=error.second
-        ) from None
-
-
-@dataclass(kw_only=True, slots=True)
-class GetLoggingLevelNameError(Exception):
-    level: int
-
-
-@dataclass(kw_only=True, slots=True)
-class _GetLoggingLevelNameEmptyError(GetLoggingLevelNameError):
-    @override
-    def __str__(self) -> str:
-        return f"There is no level with severity {self.level}"
-
-
-@dataclass(kw_only=True, slots=True)
-class _GetLoggingLevelNameNonUniqueError(GetLoggingLevelNameError):
-    first: str
-    second: str
-
-    @override
-    def __str__(self) -> str:
-        return f"There must be exactly one level with severity {self.level}; got {self.first!r}, {self.second!r} and perhaps more"
-
-
-##
-
-
-def get_logging_level_number(level: str, /) -> int:
-    """Get the logging level number."""
-    try:
-        return logger.level(level).no
-    except ValueError:
-        raise GetLoggingLevelNumberError(level=level) from None
-
-
-@dataclass(kw_only=True, slots=True)
-class GetLoggingLevelNumberError(Exception):
-    level: str
-
-    @override
-    def __str__(self) -> str:
-        return f"Invalid logging level: {self.level!r}"
-
-
-__all__ = [
-    "LEVEL_CONFIGS",
-    "GetLoggingLevelNameError",
-    "GetLoggingLevelNumberError",
-    "InterceptHandler",
-    "LogLevel",
-    "get_logging_level_name",
-    "get_logging_level_number",
-]

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"]