pip._internal.utils.logging Namespace Reference

Data Structures
class	BetterRotatingFileHandler
class	BrokenStdoutLoggingError
class	ExcludeLoggerFilter
class	IndentedRenderable
class	IndentingFormatter
class	MaxLevelFilter
class	RichPipStreamHandler

Functions
bool	_is_broken_pipe_error (Type[BaseException] exc_class, BaseException exc)
Generator[None, None, None]	indent_log (int num=2)
int	get_indentation ()
int	setup_logging (int verbosity, bool no_color, Optional[str] user_log_file)

Variables
	_log_state = threading.local()
	subprocess_logger = getLogger("pip.subprocessor")

Function Documentation

_is_broken_pipe_error()

bool _is_broken_pipe_error ( Type[BaseException]  exc_class, BaseException  exc  )

protected

Definition at line 41 of file logging.py.

def _is_broken_pipe_error(exc_class: Type[BaseException], exc: BaseException) -> bool:
    if exc_class is BrokenPipeError:
        return True
 
    # On Windows, a broken pipe can show up as EINVAL rather than EPIPE:
    # https://bugs.python.org/issue19612
    # https://bugs.python.org/issue30418
    if not WINDOWS:
        return False
 
    return isinstance(exc, OSError) and exc.errno in (errno.EINVAL, errno.EPIPE)
 
 
@contextlib.contextmanager

Referenced by RichPipStreamHandler.handleError().

Here is the caller graph for this function:

get_indentation()

int get_indentation

(

)

Definition at line 69 of file logging.py.

def get_indentation() -> int:
    return getattr(_log_state, "indentation", 0)
 
 

References i.

Referenced by RichPipStreamHandler.emit(), IndentingFormatter.format(), and pip._internal.utils.logging.indent_log().

Here is the caller graph for this function:

indent_log()

Generator[None, None, None] indent_log

(

int

num = 2

)

A context manager which will cause the log output to be indented for any
log messages emitted inside it.

Definition at line 55 of file logging.py.

def indent_log(num: int = 2) -> Generator[None, None, None]:
    """
    A context manager which will cause the log output to be indented for any
    log messages emitted inside it.
    """
    # For thread-safety
    _log_state.indentation = get_indentation()
    _log_state.indentation += num
    try:
        yield
    finally:
        _log_state.indentation -= num
 
 

References pip._internal.utils.logging.get_indentation(), and i.

Here is the call graph for this function:

setup_logging()

int setup_logging	(	int	verbosity,
		bool	no_color,
		Optional[str]	user_log_file
	)

Configures and sets up all of the logging

Returns the requested logging level, as its integer value.

Definition at line 226 of file logging.py.

def setup_logging(verbosity: int, no_color: bool, user_log_file: Optional[str]) -> int:
    """Configures and sets up all of the logging
 
    Returns the requested logging level, as its integer value.
    """
 
    # Determine the level to be logging at.
    if verbosity >= 2:
        level_number = logging.DEBUG
    elif verbosity == 1:
        level_number = VERBOSE
    elif verbosity == -1:
        level_number = logging.WARNING
    elif verbosity == -2:
        level_number = logging.ERROR
    elif verbosity <= -3:
        level_number = logging.CRITICAL
    else:
        level_number = logging.INFO
 
    level = logging.getLevelName(level_number)
 
    # The "root" logger should match the "console" level *unless* we also need
    # to log to a user log file.
    include_user_log = user_log_file is not None
    if include_user_log:
        additional_log_file = user_log_file
        root_level = "DEBUG"
    else:
        additional_log_file = "/dev/null"
        root_level = level
 
    # Disable any logging besides WARNING unless we have DEBUG level logging
    # enabled for vendored libraries.
    vendored_log_level = "WARNING" if level in ["INFO", "ERROR"] else "DEBUG"
 
    # Shorthands for clarity
    log_streams = {
        "stdout": "ext://sys.stdout",
        "stderr": "ext://sys.stderr",
    }
    handler_classes = {
        "stream": "pip._internal.utils.logging.RichPipStreamHandler",
        "file": "pip._internal.utils.logging.BetterRotatingFileHandler",
    }
    handlers = ["console", "console_errors", "console_subprocess"] + (
        ["user_log"] if include_user_log else []
    )
 
    logging.config.dictConfig(
        {
            "version": 1,
            "disable_existing_loggers": False,
            "filters": {
                "exclude_warnings": {
                    "()": "pip._internal.utils.logging.MaxLevelFilter",
                    "level": logging.WARNING,
                },
                "restrict_to_subprocess": {
                    "()": "logging.Filter",
                    "name": subprocess_logger.name,
                },
                "exclude_subprocess": {
                    "()": "pip._internal.utils.logging.ExcludeLoggerFilter",
                    "name": subprocess_logger.name,
                },
            },
            "formatters": {
                "indent": {
                    "()": IndentingFormatter,
                    "format": "%(message)s",
                },
                "indent_with_timestamp": {
                    "()": IndentingFormatter,
                    "format": "%(message)s",
                    "add_timestamp": True,
                },
            },
            "handlers": {
                "console": {
                    "level": level,
                    "class": handler_classes["stream"],
                    "no_color": no_color,
                    "stream": log_streams["stdout"],
                    "filters": ["exclude_subprocess", "exclude_warnings"],
                    "formatter": "indent",
                },
                "console_errors": {
                    "level": "WARNING",
                    "class": handler_classes["stream"],
                    "no_color": no_color,
                    "stream": log_streams["stderr"],
                    "filters": ["exclude_subprocess"],
                    "formatter": "indent",
                },
                # A handler responsible for logging to the console messages
                # from the "subprocessor" logger.
                "console_subprocess": {
                    "level": level,
                    "class": handler_classes["stream"],
                    "stream": log_streams["stderr"],
                    "no_color": no_color,
                    "filters": ["restrict_to_subprocess"],
                    "formatter": "indent",
                },
                "user_log": {
                    "level": "DEBUG",
                    "class": handler_classes["file"],
                    "filename": additional_log_file,
                    "encoding": "utf-8",
                    "delay": True,
                    "formatter": "indent_with_timestamp",
                },
            },
            "root": {
                "level": root_level,
                "handlers": handlers,
            },
            "loggers": {"pip._vendor": {"level": vendored_log_level}},
        }
    )
 
    return level_number

References i.

Variable Documentation

_log_state

_log_state = threading.local()

protected

Definition at line 31 of file logging.py.

subprocess_logger

subprocess_logger = getLogger("pip.subprocessor")

Definition at line 32 of file logging.py.