view env/lib/python3.9/site-packages/pip/_internal/commands/ @ 0:4f3585e2f14b draft default tip

"planemo upload commit 60cee0fc7c0cda8592644e1aad72851dec82c959"
author shellac
date Mon, 22 Mar 2021 18:12:50 +0000
line wrap: on
line source

import locale
import logging
import os
import sys

import pip._vendor
from pip._vendor import pkg_resources
from pip._vendor.certifi import where
from pip._vendor.packaging.version import parse as parse_version

from pip import __file__ as pip_location
from pip._internal.cli import cmdoptions
from pip._internal.cli.base_command import Command
from pip._internal.cli.cmdoptions import make_target_python
from pip._internal.cli.status_codes import SUCCESS
from pip._internal.utils.logging import indent_log
from pip._internal.utils.misc import get_pip_version
from pip._internal.utils.typing import MYPY_CHECK_RUNNING

    from optparse import Values
    from types import ModuleType
    from typing import Dict, List, Optional

    from pip._internal.configuration import Configuration

logger = logging.getLogger(__name__)

def show_value(name, value):
    # type: (str, Optional[str]) -> None'%s: %s', name, value)

def show_sys_implementation():
    # type: () -> None'sys.implementation:')
    implementation_name =
    with indent_log():
        show_value('name', implementation_name)

def create_vendor_txt_map():
    # type: () -> Dict[str, str]
    vendor_txt_path = os.path.join(

    with open(vendor_txt_path) as f:
        # Purge non version specifying lines.
        # Also, remove any space prefix or suffixes (including comments).
        lines = [line.strip().split(' ', 1)[0]
                 for line in f.readlines() if '==' in line]

    # Transform into "module" -> version dict.
    return dict(line.split('==', 1) for line in lines)  # type: ignore

def get_module_from_module_name(module_name):
    # type: (str) -> ModuleType
    # Module name can be uppercase in vendor.txt for some reason...
    module_name = module_name.lower()
    # PATCH: setuptools is actually only pkg_resources.
    if module_name == 'setuptools':
        module_name = 'pkg_resources'

    return getattr(pip._vendor, module_name)

def get_vendor_version_from_module(module_name):
    # type: (str) -> Optional[str]
    module = get_module_from_module_name(module_name)
    version = getattr(module, '__version__', None)

    if not version:
        # Try to find version in debundled module info
        pkg_set = pkg_resources.WorkingSet([os.path.dirname(module.__file__)])
        package = pkg_set.find(pkg_resources.Requirement.parse(module_name))
        version = getattr(package, 'version', None)

    return version

def show_actual_vendor_versions(vendor_txt_versions):
    # type: (Dict[str, str]) -> None
    """Log the actual version and print extra info if there is
    a conflict or if the actual version could not be imported.
    for module_name, expected_version in vendor_txt_versions.items():
        extra_message = ''
        actual_version = get_vendor_version_from_module(module_name)
        if not actual_version:
            extra_message = ' (Unable to locate actual module version, using'\
                            ' vendor.txt specified version)'
            actual_version = expected_version
        elif parse_version(actual_version) != parse_version(expected_version):
            extra_message = ' (CONFLICT: vendor.txt suggests version should'\
                            ' be {})'.format(expected_version)'%s==%s%s', module_name, actual_version, extra_message)

def show_vendor_versions():
    # type: () -> None'vendored library versions:')

    vendor_txt_versions = create_vendor_txt_map()
    with indent_log():

def show_tags(options):
    # type: (Values) -> None
    tag_limit = 10

    target_python = make_target_python(options)
    tags = target_python.get_tags()

    # Display the target options that were explicitly provided.
    formatted_target = target_python.format_given()
    suffix = ''
    if formatted_target:
        suffix = f' (target: {formatted_target})'

    msg = 'Compatible tags: {}{}'.format(len(tags), suffix)

    if options.verbose < 1 and len(tags) > tag_limit:
        tags_limited = True
        tags = tags[:tag_limit]
        tags_limited = False

    with indent_log():
        for tag in tags:

        if tags_limited:
            msg = (
                '[First {tag_limit} tags shown. Pass --verbose to show all.]'

def ca_bundle_info(config):
    # type: (Configuration) -> str
    levels = set()
    for key, _ in config.items():

    if not levels:
        return "Not specified"

    levels_that_override_global = ['install', 'wheel', 'download']
    global_overriding_level = [
        level for level in levels if level in levels_that_override_global
    if not global_overriding_level:
        return 'global'

    if 'global' in levels:
    return ", ".join(levels)

class DebugCommand(Command):
    Display debug information.

    usage = """
      %prog <options>"""
    ignore_require_venv = True

    def add_options(self):
        # type: () -> None
        self.parser.insert_option_group(0, self.cmd_opts)

    def run(self, options, args):
        # type: (Values, List[str]) -> int
            "This command is only meant for debugging. "
            "Do not use this with automation for parsing and getting these "
            "details, since the output and options of this command may "
            "change without notice."
        show_value('pip version', get_pip_version())
        show_value('sys.version', sys.version)
        show_value('sys.executable', sys.executable)
        show_value('sys.getdefaultencoding', sys.getdefaultencoding())
        show_value('sys.getfilesystemencoding', sys.getfilesystemencoding())
            'locale.getpreferredencoding', locale.getpreferredencoding(),
        show_value('sys.platform', sys.platform)

        show_value("'cert' config value", ca_bundle_info(self.parser.config))
        show_value("REQUESTS_CA_BUNDLE", os.environ.get('REQUESTS_CA_BUNDLE'))
        show_value("CURL_CA_BUNDLE", os.environ.get('CURL_CA_BUNDLE'))
        show_value("pip._vendor.certifi.where()", where())
        show_value("pip._vendor.DEBUNDLED", pip._vendor.DEBUNDLED)



        return SUCCESS