logging

catch_time()

Context manager to catch the time elapsed between the start and end of a block of code.

Return type:

Generator[Callable[[], float], None, None]

Returns:

A callable that returns the elapsed time in seconds.

increment_loop(log, *, name)

Increment the step used by a logger to write logs in a loop.

Parameters:

  • log (Logger) – The logger to use.

  • name (int | str) – The name of the loop.

Return type:

Logger

Returns:

The logger with the updated loop information.

log_loop(iterable, *, level, message, name=None, total=None, log=None)

Log an iterator with a given level and message.

Parameters:

  • iterable (Iterable[TypeVar(T)]) – The iterable to loop over.

  • level (Literal['trace', 'debug', 'info', 'success', 'warning', 'error']) – The logging level.

  • message (str) – The message to log.

  • name (str | None, default: None) – The name of the loop.

  • total (int | None, default: None) – The total number of elements in the iterable.

  • log (Logger | None, default: None) – The logger to use.

Yields:

The results of the iterator.

Return type:

Generator[tuple[Logger, TypeVar(T)], None, None]

log_time(func=None, *, level_start='info', level_finish='info', description='')

Decorator to log the start and finish of a function call.

Parameters:

  • func (Callable[[ParamSpec(P)], TypeVar(T)] | None, default: None) – The function to decorate.

  • level_start (Literal['trace', 'debug', 'info', 'success', 'warning', 'error'], default: 'info') – The log level to use for the start message.

  • level_finish (Literal['trace', 'debug', 'info', 'success', 'warning', 'error'], default: 'info') – The log level to use for the finish message.

  • description (str, default: '') – A description of the function call.

Return type:

Callable[[ParamSpec(P)], TypeVar(T)]

Returns:

The decorated function.

set_logging_level(level='warning', *, sink=None, format=<function _formatter>, enqueue=True)

Set the logging level (and sink, format and enqueue parameters of the loguru logger.

Parameters:

  • level (Literal['trace', 'debug', 'info', 'success', 'warning', 'error'] | int, default: 'warning') – The logging level to set.

  • sink (default: None) – The sink to use for logging.

  • format (str | Callable[..., str], default: <function _formatter at 0x7b6481026700>) – The format to use for logging.

  • enqueue (bool, default: True) – Whether to enqueue the logs (should be used with multiprocessing).

Return type:

Logger

Returns:

The loguru logger.

with_loop(log, *, name=None, step, total=None, prepare_for_subprocess=False)

Initialize a logger for a loop.

Parameters:

  • log (Logger) – The logger to use.

  • name (TypeVar(T, bound= int | str) | None, default: None) – The name of the loop.

  • step (int) – The current step of the loop.

  • total (int | None, default: None) – The total number of steps in the loop.

  • prepare_for_subprocess (bool, default: False) – Whether to prepare the logger for subprocesses.

Return type:

tuple[Logger, TypeVar(T, bound= int | str)] | tuple[tuple[dict[str, Any], int], TypeVar(T, bound= int | str)]

Returns:

A tuple containing the logger and the loop name, or a tuple containing the logger parameters and logging level (if prepare_for_subprocess=True).