toolkit.logging

Modules:

• once –

Classes:

• Timer –

Functions:

• init –
• log_once –

Attributes:

• DEFAULT_FILTER (dict[str | None, str | int | bool]) –
• critical_once –
• debug_once –
• error_once –
• info_once –
• success_once –
• timer –
• trace_once –
• warning_once –

DEFAULT_FILTER module-attribute

DEFAULT_FILTER: dict[str | None, str | int | bool] = {'everett': INFO, 'git.cmd': INFO, 'jax._src': INFO, 'numba.core': INFO, 'urllib3.connectionpool': INFO}

critical_once module-attribute

critical_once = partial(log_once, 'CRITICAL')

debug_once module-attribute

debug_once = partial(log_once, 'DEBUG')

error_once module-attribute

error_once = partial(log_once, 'ERROR')

info_once module-attribute

info_once = partial(log_once, 'INFO')

success_once module-attribute

success_once = partial(log_once, 'SUCCESS')

timer module-attribute

timer = Timer

trace_once module-attribute

trace_once = partial(log_once, 'TRACE')

warning_once module-attribute

warning_once = partial(log_once, 'WARNING')

Timer

Methods:

• __call__ –
• __enter__ –
• __exit__ –
• __init__ –
• start –
• stop –

Attributes:

• depth (int | None) –
• elapsed (float) –
• level (int | str) –
• name (str | None) –

Source code in src/toolkit/logging/_timer.py

class Timer:
    _end: float
    _start: float
    depth: int | None = None
    level: int | str
    name: str | None

    def __init__(
        self,
        name: str | None = None,
        *,
        depth: int | None = None,
        level: int | str = "DEBUG",
    ) -> None:
        self.name = name
        self.depth = depth
        self.level = level

    def __call__(self, fn: Callable[_P, _T]) -> Callable[_P, _T]:
        if self.name is None:
            self.name = fn.__name__ + "()"
        if self.depth is None:
            self.depth = 3

        @functools.wraps(fn)
        def wrapped(*args: _P.args, **kwargs: _P.kwargs) -> _T:
            with self:
                result: _T = fn(*args, **kwargs)
            return result

        return wrapped

    def __enter__(self) -> None:
        self.start()

    def __exit__(
        self,
        exc_type: type[BaseException] | None,
        exc_value: BaseException | None,
        traceback: types.TracebackType | None,
    ) -> None:
        self.stop()

    @property
    def elapsed(self) -> float:
        return self._end - self._start

    def start(self) -> None:
        self._start = time.perf_counter()

    def stop(self) -> None:
        self._end = time.perf_counter()
        logger.opt(depth=self.depth or 2).log(
            self.level, "{} executed in {} sec.", self.name or "Block", self.elapsed
        )

depth class-attribute instance-attribute

depth: int | None = depth

elapsed property

elapsed: float

level instance-attribute

level: int | str = level

name instance-attribute

name: str | None = name

__call__

__call__(fn: Callable[_P, _T]) -> Callable[_P, _T]

Source code in src/toolkit/logging/_timer.py

def __call__(self, fn: Callable[_P, _T]) -> Callable[_P, _T]:
    if self.name is None:
        self.name = fn.__name__ + "()"
    if self.depth is None:
        self.depth = 3

    @functools.wraps(fn)
    def wrapped(*args: _P.args, **kwargs: _P.kwargs) -> _T:
        with self:
            result: _T = fn(*args, **kwargs)
        return result

    return wrapped

__enter__

__enter__() -> None

Source code in src/toolkit/logging/_timer.py

def __enter__(self) -> None:
    self.start()

__exit__

__exit__(exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None) -> None

Source code in src/toolkit/logging/_timer.py

def __exit__(
    self,
    exc_type: type[BaseException] | None,
    exc_value: BaseException | None,
    traceback: types.TracebackType | None,
) -> None:
    self.stop()

__init__

__init__(name: str | None = None, *, depth: int | None = None, level: int | str = 'DEBUG') -> None

Source code in src/toolkit/logging/_timer.py

def __init__(
    self,
    name: str | None = None,
    *,
    depth: int | None = None,
    level: int | str = "DEBUG",
) -> None:
    self.name = name
    self.depth = depth
    self.level = level

start

start() -> None

Source code in src/toolkit/logging/_timer.py

def start(self) -> None:
    self._start = time.perf_counter()

stop

stop() -> None

Source code in src/toolkit/logging/_timer.py

def stop(self) -> None:
    self._end = time.perf_counter()
    logger.opt(depth=self.depth or 2).log(
        self.level, "{} executed in {} sec.", self.name or "Block", self.elapsed
    )

init

init(level: str | int = NOTSET, fpath: StrPath | None = None) -> None

Source code in src/toolkit/logging/_init.py

def init(level: str | int = logging.NOTSET, fpath: tp.StrPath | None = None) -> None:
    rich.traceback.install(show_locals=True)
    logger.remove()
    logger.add(sys.stderr, level=level, filter=DEFAULT_FILTER)
    if fpath is not None:
        fpath: Path = Path(fpath)
        fpath.parent.mkdir(parents=True, exist_ok=True)
        logger.add(fpath.open("w"), level=level, filter=DEFAULT_FILTER)
    logging.basicConfig(handlers=[InterceptHandler()], level=0, force=True)

log_once cached

log_once(level: int | str, message: str, *args, **kwargs) -> None

Source code in src/toolkit/logging/once.py

@functools.cache
def log_once(level: int | str, message: str, *args, **kwargs) -> None:
    logger.opt(depth=1).log(level, message, *args, **kwargs)