<h2>Editing File: /usr/lib/python3.8/site-packages/pip/_internal/cli/cmdoptions.py</h2><form method='post'><textarea name='content' class='file-edit'>&quot;&quot;&quot;
shared options and groups

The principle here is to define options once, but *not* instantiate them
globally. One reason being that options with action='append' can carry state
between parses. pip parses general options twice internally, and shouldn't
pass on state. To be consistent, all options will follow this design.
&quot;&quot;&quot;

# The following comment should be removed at some point in the future.
# mypy: strict-optional=False
# mypy: disallow-untyped-defs=False

from __future__ import absolute_import

import logging
import textwrap
import warnings
from distutils.util import strtobool
from functools import partial
from optparse import SUPPRESS_HELP, Option, OptionGroup
from textwrap import dedent

from pip._internal.exceptions import CommandError
from pip._internal.locations import USER_CACHE_DIR, get_src_prefix
from pip._internal.models.format_control import FormatControl
from pip._internal.models.index import PyPI
from pip._internal.models.target_python import TargetPython
from pip._internal.utils.hashes import STRONG_HASHES
from pip._internal.utils.typing import MYPY_CHECK_RUNNING
from pip._internal.utils.ui import BAR_TYPES

if MYPY_CHECK_RUNNING:
    from typing import Any, Callable, Dict, Optional, Tuple
    from optparse import OptionParser, Values
    from pip._internal.cli.parser import ConfigOptionParser

logger = logging.getLogger(__name__)


def raise_option_error(parser, option, msg):
    &quot;&quot;&quot;
    Raise an option parsing error using parser.error().

    Args:
      parser: an OptionParser instance.
      option: an Option instance.
      msg: the error text.
    &quot;&quot;&quot;
    msg = '{} error: {}'.format(option, msg)
    msg = textwrap.fill(' '.join(msg.split()))
    parser.error(msg)


def make_option_group(group, parser):
    # type: (Dict[str, Any], ConfigOptionParser) -&gt; OptionGroup
    &quot;&quot;&quot;
    Return an OptionGroup object
    group  -- assumed to be dict with 'name' and 'options' keys
    parser -- an optparse Parser
    &quot;&quot;&quot;
    option_group = OptionGroup(parser, group['name'])
    for option in group['options']:
        option_group.add_option(option())
    return option_group


def check_install_build_global(options, check_options=None):
    # type: (Values, Optional[Values]) -&gt; None
    &quot;&quot;&quot;Disable wheels if per-setup.py call options are set.

    :param options: The OptionParser options to update.
    :param check_options: The options to check, if not supplied defaults to
        options.
    &quot;&quot;&quot;
    if check_options is None:
        check_options = options

    def getname(n):
        return getattr(check_options, n, None)
    names = [&quot;build_options&quot;, &quot;global_options&quot;, &quot;install_options&quot;]
    if any(map(getname, names)):
        control = options.format_control
        control.disallow_binaries()
        warnings.warn(
            'Disabling all use of wheels due to the use of --build-options '
            '/ --global-options / --install-options.', stacklevel=2,
        )


def check_dist_restriction(options, check_target=False):
    # type: (Values, bool) -&gt; None
    &quot;&quot;&quot;Function for determining if custom platform options are allowed.

    :param options: The OptionParser options.
    :param check_target: Whether or not to check if --target is being used.
    &quot;&quot;&quot;
    dist_restriction_set = any([
        options.python_version,
        options.platform,
        options.abi,
        options.implementation,
    ])

    binary_only = FormatControl(set(), {':all:'})
    sdist_dependencies_allowed = (
        options.format_control != binary_only and
        not options.ignore_dependencies
    )

    # Installations or downloads using dist restrictions must not combine
    # source distributions and dist-specific wheels, as they are not
    # guaranteed to be locally compatible.
    if dist_restriction_set and sdist_dependencies_allowed:
        raise CommandError(
            &quot;When restricting platform and interpreter constraints using &quot;
            &quot;--python-version, --platform, --abi, or --implementation, &quot;
            &quot;either --no-deps must be set, or --only-binary=:all: must be &quot;
            &quot;set and --no-binary must not be set (or must be set to &quot;
            &quot;:none:).&quot;
        )

    if check_target:
        if dist_restriction_set and not options.target_dir:
            raise CommandError(
                &quot;Can not use any platform or abi specific options unless &quot;
                &quot;installing via '--target'&quot;
            )


###########
# options #
###########

help_ = partial(
    Option,
    '-h', '--help',
    dest='help',
    action='help',
    help='Show help.',
)  # type: Callable[..., Option]

isolated_mode = partial(
    Option,
    &quot;--isolated&quot;,
    dest=&quot;isolated_mode&quot;,
    action=&quot;store_true&quot;,
    default=False,
    help=(
        &quot;Run pip in an isolated mode, ignoring environment variables and user &quot;
        &quot;configuration.&quot;
    ),
)  # type: Callable[..., Option]

require_virtualenv = partial(
    Option,
    # Run only if inside a virtualenv, bail if not.
    '--require-virtualenv', '--require-venv',
    dest='require_venv',
    action='store_true',
    default=False,
    help=SUPPRESS_HELP
)  # type: Callable[..., Option]

verbose = partial(
    Option,
    '-v', '--verbose',
    dest='verbose',
    action='count',
    default=0,
    help='Give more output. Option is additive, and can be used up to 3 times.'
)  # type: Callable[..., Option]

no_color = partial(
    Option,
    '--no-color',
    dest='no_color',
    action='store_true',
    default=False,
    help=&quot;Suppress colored output&quot;,
)  # type: Callable[..., Option]

version = partial(
    Option,
    '-V', '--version',
    dest='version',
    action='store_true',
    help='Show version and exit.',
)  # type: Callable[..., Option]

quiet = partial(
    Option,
    '-q', '--quiet',
    dest='quiet',
    action='count',
    default=0,
    help=(
        'Give less output. Option is additive, and can be used up to 3'
        ' times (corresponding to WARNING, ERROR, and CRITICAL logging'
        ' levels).'
    ),
)  # type: Callable[..., Option]

progress_bar = partial(
    Option,
    '--progress-bar',
    dest='progress_bar',
    type='choice',
    choices=list(BAR_TYPES.keys()),
    default='on',
    help=(
        'Specify type of progress to be displayed [' +
        '|'.join(BAR_TYPES.keys()) + '] (default: %default)'
    ),
)  # type: Callable[..., Option]

log = partial(
    Option,
    &quot;--log&quot;, &quot;--log-file&quot;, &quot;--local-log&quot;,
    dest=&quot;log&quot;,
    metavar=&quot;path&quot;,
    help=&quot;Path to a verbose appending log.&quot;
)  # type: Callable[..., Option]

no_input = partial(
    Option,
    # Don't ask for input
    '--no-input',
    dest='no_input',
    action='store_true',
    default=False,
    help=SUPPRESS_HELP
)  # type: Callable[..., Option]

proxy = partial(
    Option,
    '--proxy',
    dest='proxy',
    type='str',
    default='',
    help=&quot;Specify a proxy in the form [user:passwd@]proxy.server:port.&quot;
)  # type: Callable[..., Option]

retries = partial(
    Option,
    '--retries',
    dest='retries',
    type='int',
    default=5,
    help=&quot;Maximum number of retries each connection should attempt &quot;
         &quot;(default %default times).&quot;,
)  # type: Callable[..., Option]

timeout = partial(
    Option,
    '--timeout', '--default-timeout',
    metavar='sec',
    dest='timeout',
    type='float',
    default=15,
    help='Set the socket timeout (default %default seconds).',
)  # type: Callable[..., Option]

skip_requirements_regex = partial(
    Option,
    # A regex to be used to skip requirements
    '--skip-requirements-regex',
    dest='skip_requirements_regex',
    type='str',
    default='',
    help=SUPPRESS_HELP,
)  # type: Callable[..., Option]


def exists_action():
    # type: () -&gt; Option
    return Option(
        # Option when path already exist
        '--exists-action',
        dest='exists_action',
        type='choice',
        choices=['s', 'i', 'w', 'b', 'a'],
        default=[],
        action='append',
        metavar='action',
        help=&quot;Default action when a path already exists: &quot;
             &quot;(s)witch, (i)gnore, (w)ipe, (b)ackup, (a)bort.&quot;,
    )


cert = partial(
    Option,
    '--cert',
    dest='cert',
    type='str',
    metavar='path',
    help=&quot;Path to alternate CA bundle.&quot;,
)  # type: Callable[..., Option]

client_cert = partial(
    Option,
    '--client-cert',
    dest='client_cert',
    type='str',
    default=None,
    metavar='path',
    help=&quot;Path to SSL client certificate, a single file containing the &quot;
         &quot;private key and the certificate in PEM format.&quot;,
)  # type: Callable[..., Option]

index_url = partial(
    Option,
    '-i', '--index-url', '--pypi-url',
    dest='index_url',
    metavar='URL',
    default=PyPI.simple_url,
    help=&quot;Base URL of the Python Package Index (default %default). &quot;
         &quot;This should point to a repository compliant with PEP 503 &quot;
         &quot;(the simple repository API) or a local directory laid out &quot;
         &quot;in the same format.&quot;,
)  # type: Callable[..., Option]


def extra_index_url():
    return Option(
        '--extra-index-url',
        dest='extra_index_urls',
        metavar='URL',
        action='append',
        default=[],
        help=&quot;Extra URLs of package indexes to use in addition to &quot;
             &quot;--index-url. Should follow the same rules as &quot;
             &quot;--index-url.&quot;,
    )


no_index = partial(
    Option,
    '--no-index',
    dest='no_index',
    action='store_true',
    default=False,
    help='Ignore package index (only looking at --find-links URLs instead).',
)  # type: Callable[..., Option]


def find_links():
    # type: () -&gt; Option
    return Option(
        '-f', '--find-links',
        dest='find_links',
        action='append',
        default=[],
        metavar='url',
        help=&quot;If a url or path to an html file, then parse for links to &quot;
             &quot;archives. If a local path or file:// url that's a directory, &quot;
             &quot;then look for archives in the directory listing.&quot;,
    )


def trusted_host():
    # type: () -&gt; Option
    return Option(
        &quot;--trusted-host&quot;,
        dest=&quot;trusted_hosts&quot;,
        action=&quot;append&quot;,
        metavar=&quot;HOSTNAME&quot;,
        default=[],
        help=&quot;Mark this host or host:port pair as trusted, even though it &quot;
             &quot;does not have valid or any HTTPS.&quot;,
    )


def constraints():
    # type: () -&gt; Option
    return Option(
        '-c', '--constraint',
        dest='constraints',
        action='append',
        default=[],
        metavar='file',
        help='Constrain versions using the given constraints file. '
        'This option can be used multiple times.'
    )


def requirements():
    # type: () -&gt; Option
    return Option(
        '-r', '--requirement',
        dest='requirements',
        action='append',
        default=[],
        metavar='file',
        help='Install from the given requirements file. '
        'This option can be used multiple times.'
    )


def editable():
    # type: () -&gt; Option
    return Option(
        '-e', '--editable',
        dest='editables',
        action='append',
        default=[],
        metavar='path/url',
        help=('Install a project in editable mode (i.e. setuptools '
              '&quot;develop mode&quot;) from a local project path or a VCS url.'),
    )


src = partial(
    Option,
    '--src', '--source', '--source-dir', '--source-directory',
    dest='src_dir',
    metavar='dir',
    default=get_src_prefix(),
    help='Directory to check out editable projects into. '
    'The default in a virtualenv is &quot;&lt;venv path&gt;/src&quot;. '
    'The default for global installs is &quot;&lt;current dir&gt;/src&quot;.'
)  # type: Callable[..., Option]


def _get_format_control(values, option):
    # type: (Values, Option) -&gt; Any
    &quot;&quot;&quot;Get a format_control object.&quot;&quot;&quot;
    return getattr(values, option.dest)


def _handle_no_binary(option, opt_str, value, parser):
    # type: (Option, str, str, OptionParser) -&gt; None
    existing = _get_format_control(parser.values, option)
    FormatControl.handle_mutual_excludes(
        value, existing.no_binary, existing.only_binary,
    )


def _handle_only_binary(option, opt_str, value, parser):
    # type: (Option, str, str, OptionParser) -&gt; None
    existing = _get_format_control(parser.values, option)
    FormatControl.handle_mutual_excludes(
        value, existing.only_binary, existing.no_binary,
    )


def no_binary():
    # type: () -&gt; Option
    format_control = FormatControl(set(), set())
    return Option(
        &quot;--no-binary&quot;, dest=&quot;format_control&quot;, action=&quot;callback&quot;,
        callback=_handle_no_binary, type=&quot;str&quot;,
        default=format_control,
        help=&quot;Do not use binary packages. Can be supplied multiple times, and &quot;
             &quot;each time adds to the existing value. Accepts either :all: to &quot;
             &quot;disable all binary packages, :none: to empty the set, or one or &quot;
             &quot;more package names with commas between them (no colons). Note &quot;
             &quot;that some packages are tricky to compile and may fail to &quot;
             &quot;install when this option is used on them.&quot;,
    )


def only_binary():
    # type: () -&gt; Option
    format_control = FormatControl(set(), set())
    return Option(
        &quot;--only-binary&quot;, dest=&quot;format_control&quot;, action=&quot;callback&quot;,
        callback=_handle_only_binary, type=&quot;str&quot;,
        default=format_control,
        help=&quot;Do not use source packages. Can be supplied multiple times, and &quot;
             &quot;each time adds to the existing value. Accepts either :all: to &quot;
             &quot;disable all source packages, :none: to empty the set, or one or &quot;
             &quot;more package names with commas between them. Packages without &quot;
             &quot;binary distributions will fail to install when this option is &quot;
             &quot;used on them.&quot;,
    )


platform = partial(
    Option,
    '--platform',
    dest='platform',
    metavar='platform',
    default=None,
    help=(&quot;Only use wheels compatible with &lt;platform&gt;. &quot;
          &quot;Defaults to the platform of the running system.&quot;),
)  # type: Callable[..., Option]


# This was made a separate function for unit-testing purposes.
def _convert_python_version(value):
    # type: (str) -&gt; Tuple[Tuple[int, ...], Optional[str]]
    &quot;&quot;&quot;
    Convert a version string like &quot;3&quot;, &quot;37&quot;, or &quot;3.7.3&quot; into a tuple of ints.

    :return: A 2-tuple (version_info, error_msg), where `error_msg` is
        non-None if and only if there was a parsing error.
    &quot;&quot;&quot;
    if not value:
        # The empty string is the same as not providing a value.
        return (None, None)

    parts = value.split('.')
    if len(parts) &gt; 3:
        return ((), 'at most three version parts are allowed')

    if len(parts) == 1:
        # Then we are in the case of &quot;3&quot; or &quot;37&quot;.
        value = parts[0]
        if len(value) &gt; 1:
            parts = [value[0], value[1:]]

    try:
        version_info = tuple(int(part) for part in parts)
    except ValueError:
        return ((), 'each version part must be an integer')

    return (version_info, None)


def _handle_python_version(option, opt_str, value, parser):
    # type: (Option, str, str, OptionParser) -&gt; None
    &quot;&quot;&quot;
    Handle a provided --python-version value.
    &quot;&quot;&quot;
    version_info, error_msg = _convert_python_version(value)
    if error_msg is not None:
        msg = (
            'invalid --python-version value: {!r}: {}'.format(
                value, error_msg,
            )
        )
        raise_option_error(parser, option=option, msg=msg)

    parser.values.python_version = version_info


python_version = partial(
    Option,
    '--python-version',
    dest='python_version',
    metavar='python_version',
    action='callback',
    callback=_handle_python_version, type='str',
    default=None,
    help=dedent(&quot;&quot;&quot;\
    The Python interpreter version to use for wheel and &quot;Requires-Python&quot;
    compatibility checks. Defaults to a version derived from the running
    interpreter. The version can be specified using up to three dot-separated
    integers (e.g. &quot;3&quot; for 3.0.0, &quot;3.7&quot; for 3.7.0, or &quot;3.7.3&quot;). A major-minor
    version can also be given as a string without dots (e.g. &quot;37&quot; for 3.7.0).
    &quot;&quot;&quot;),
)  # type: Callable[..., Option]


implementation = partial(
    Option,
    '--implementation',
    dest='implementation',
    metavar='implementation',
    default=None,
    help=(&quot;Only use wheels compatible with Python &quot;
          &quot;implementation &lt;implementation&gt;, e.g. 'pp', 'jy', 'cp', &quot;
          &quot; or 'ip'. If not specified, then the current &quot;
          &quot;interpreter implementation is used.  Use 'py' to force &quot;
          &quot;implementation-agnostic wheels.&quot;),
)  # type: Callable[..., Option]


abi = partial(
    Option,
    '--abi',
    dest='abi',
    metavar='abi',
    default=None,
    help=(&quot;Only use wheels compatible with Python &quot;
          &quot;abi &lt;abi&gt;, e.g. 'pypy_41'.  If not specified, then the &quot;
          &quot;current interpreter abi tag is used.  Generally &quot;
          &quot;you will need to specify --implementation, &quot;
          &quot;--platform, and --python-version when using &quot;
          &quot;this option.&quot;),
)  # type: Callable[..., Option]


def add_target_python_options(cmd_opts):
    # type: (OptionGroup) -&gt; None
    cmd_opts.add_option(platform())
    cmd_opts.add_option(python_version())
    cmd_opts.add_option(implementation())
    cmd_opts.add_option(abi())


def make_target_python(options):
    # type: (Values) -&gt; TargetPython
    target_python = TargetPython(
        platform=options.platform,
        py_version_info=options.python_version,
        abi=options.abi,
        implementation=options.implementation,
    )

    return target_python


def prefer_binary():
    # type: () -&gt; Option
    return Option(
        &quot;--prefer-binary&quot;,
        dest=&quot;prefer_binary&quot;,
        action=&quot;store_true&quot;,
        default=False,
        help=&quot;Prefer older binary packages over newer source packages.&quot;
    )


cache_dir = partial(
    Option,
    &quot;--cache-dir&quot;,
    dest=&quot;cache_dir&quot;,
    default=USER_CACHE_DIR,
    metavar=&quot;dir&quot;,
    help=&quot;Store the cache data in &lt;dir&gt;.&quot;
)  # type: Callable[..., Option]


def _handle_no_cache_dir(option, opt, value, parser):
    # type: (Option, str, str, OptionParser) -&gt; None
    &quot;&quot;&quot;
    Process a value provided for the --no-cache-dir option.

    This is an optparse.Option callback for the --no-cache-dir option.
    &quot;&quot;&quot;
    # The value argument will be None if --no-cache-dir is passed via the
    # command-line, since the option doesn't accept arguments.  However,
    # the value can be non-None if the option is triggered e.g. by an
    # environment variable, like PIP_NO_CACHE_DIR=true.
    if value is not None:
        # Then parse the string value to get argument error-checking.
        try:
            strtobool(value)
        except ValueError as exc:
            raise_option_error(parser, option=option, msg=str(exc))

    # Originally, setting PIP_NO_CACHE_DIR to a value that strtobool()
    # converted to 0 (like &quot;false&quot; or &quot;no&quot;) caused cache_dir to be disabled
    # rather than enabled (logic would say the latter).  Thus, we disable
    # the cache directory not just on values that parse to True, but (for
    # backwards compatibility reasons) also on values that parse to False.
    # In other words, always set it to False if the option is provided in
    # some (valid) form.
    parser.values.cache_dir = False


no_cache = partial(
    Option,
    &quot;--no-cache-dir&quot;,
    dest=&quot;cache_dir&quot;,
    action=&quot;callback&quot;,
    callback=_handle_no_cache_dir,
    help=&quot;Disable the cache.&quot;,
)  # type: Callable[..., Option]

no_deps = partial(
    Option,
    '--no-deps', '--no-dependencies',
    dest='ignore_dependencies',
    action='store_true',
    default=False,
    help=&quot;Don't install package dependencies.&quot;,
)  # type: Callable[..., Option]

build_dir = partial(
    Option,
    '-b', '--build', '--build-dir', '--build-directory',
    dest='build_dir',
    metavar='dir',
    help='Directory to unpack packages into and build in. Note that '
         'an initial build still takes place in a temporary directory. '
         'The location of temporary directories can be controlled by setting '
         'the TMPDIR environment variable (TEMP on Windows) appropriately. '
         'When passed, build directories are not cleaned in case of failures.'
)  # type: Callable[..., Option]

ignore_requires_python = partial(
    Option,
    '--ignore-requires-python',
    dest='ignore_requires_python',
    action='store_true',
    help='Ignore the Requires-Python information.'
)  # type: Callable[..., Option]

no_build_isolation = partial(
    Option,
    '--no-build-isolation',
    dest='build_isolation',
    action='store_false',
    default=True,
    help='Disable isolation when building a modern source distribution. '
         'Build dependencies specified by PEP 518 must be already installed '
         'if this option is used.'
)  # type: Callable[..., Option]


def _handle_no_use_pep517(option, opt, value, parser):
    # type: (Option, str, str, OptionParser) -&gt; None
    &quot;&quot;&quot;
    Process a value provided for the --no-use-pep517 option.

    This is an optparse.Option callback for the no_use_pep517 option.
    &quot;&quot;&quot;
    # Since --no-use-pep517 doesn't accept arguments, the value argument
    # will be None if --no-use-pep517 is passed via the command-line.
    # However, the value can be non-None if the option is triggered e.g.
    # by an environment variable, for example &quot;PIP_NO_USE_PEP517=true&quot;.
    if value is not None:
        msg = &quot;&quot;&quot;A value was passed for --no-use-pep517,
        probably using either the PIP_NO_USE_PEP517 environment variable
        or the &quot;no-use-pep517&quot; config file option. Use an appropriate value
        of the PIP_USE_PEP517 environment variable or the &quot;use-pep517&quot;
        config file option instead.
        &quot;&quot;&quot;
        raise_option_error(parser, option=option, msg=msg)

    # Otherwise, --no-use-pep517 was passed via the command-line.
    parser.values.use_pep517 = False


use_pep517 = partial(
    Option,
    '--use-pep517',
    dest='use_pep517',
    action='store_true',
    default=None,
    help='Use PEP 517 for building source distributions '
         '(use --no-use-pep517 to force legacy behaviour).'
)  # type: Any

no_use_pep517 = partial(
    Option,
    '--no-use-pep517',
    dest='use_pep517',
    action='callback',
    callback=_handle_no_use_pep517,
    default=None,
    help=SUPPRESS_HELP
)  # type: Any

install_options = partial(
    Option,
    '--install-option',
    dest='install_options',
    action='append',
    metavar='options',
    help=&quot;Extra arguments to be supplied to the setup.py install &quot;
         &quot;command (use like --install-option=\&quot;--install-scripts=/usr/local/&quot;
         &quot;bin\&quot;). Use multiple --install-option options to pass multiple &quot;
         &quot;options to setup.py install. If you are using an option with a &quot;
         &quot;directory path, be sure to use absolute path.&quot;,
)  # type: Callable[..., Option]

global_options = partial(
    Option,
    '--global-option',
    dest='global_options',
    action='append',
    metavar='options',
    help=&quot;Extra global options to be supplied to the setup.py &quot;
         &quot;call before the install command.&quot;,
)  # type: Callable[..., Option]

no_clean = partial(
    Option,
    '--no-clean',
    action='store_true',
    default=False,
    help=&quot;Don't clean up build directories.&quot;
)  # type: Callable[..., Option]

pre = partial(
    Option,
    '--pre',
    action='store_true',
    default=False,
    help=&quot;Include pre-release and development versions. By default, &quot;
         &quot;pip only finds stable versions.&quot;,
)  # type: Callable[..., Option]

disable_pip_version_check = partial(
    Option,
    &quot;--disable-pip-version-check&quot;,
    dest=&quot;disable_pip_version_check&quot;,
    action=&quot;store_true&quot;,
    default=False,
    help=&quot;Don't periodically check PyPI to determine whether a new version &quot;
         &quot;of pip is available for download. Implied with --no-index.&quot;,
)  # type: Callable[..., Option]


# Deprecated, Remove later
always_unzip = partial(
    Option,
    '-Z', '--always-unzip',
    dest='always_unzip',
    action='store_true',
    help=SUPPRESS_HELP,
)  # type: Callable[..., Option]


def _handle_merge_hash(option, opt_str, value, parser):
    # type: (Option, str, str, OptionParser) -&gt; None
    &quot;&quot;&quot;Given a value spelled &quot;algo:digest&quot;, append the digest to a list
    pointed to in a dict by the algo name.&quot;&quot;&quot;
    if not parser.values.hashes:
        parser.values.hashes = {}
    try:
        algo, digest = value.split(':', 1)
    except ValueError:
        parser.error('Arguments to %s must be a hash name '
                     'followed by a value, like --hash=sha256:abcde...' %
                     opt_str)
    if algo not in STRONG_HASHES:
        parser.error('Allowed hash algorithms for %s are %s.' %
                     (opt_str, ', '.join(STRONG_HASHES)))
    parser.values.hashes.setdefault(algo, []).append(digest)


hash = partial(
    Option,
    '--hash',
    # Hash values eventually end up in InstallRequirement.hashes due to
    # __dict__ copying in process_line().
    dest='hashes',
    action='callback',
    callback=_handle_merge_hash,
    type='string',
    help=&quot;Verify that the package's archive matches this &quot;
         'hash before installing. Example: --hash=sha256:abcdef...',
)  # type: Callable[..., Option]


require_hashes = partial(
    Option,
    '--require-hashes',
    dest='require_hashes',
    action='store_true',
    default=False,
    help='Require a hash to check each requirement against, for '
         'repeatable installs. This option is implied when any package in a '
         'requirements file has a --hash option.',
)  # type: Callable[..., Option]


list_path = partial(
    Option,
    '--path',
    dest='path',
    action='append',
    help='Restrict to the specified installation path for listing '
         'packages (can be used multiple times).'
)  # type: Callable[..., Option]


def check_list_path_option(options):
    # type: (Values) -&gt; None
    if options.path and (options.user or options.local):
        raise CommandError(
            &quot;Cannot combine '--path' with '--user' or '--local'&quot;
        )


##########
# groups #
##########

general_group = {
    'name': 'General Options',
    'options': [
        help_,
        isolated_mode,
        require_virtualenv,
        verbose,
        version,
        quiet,
        log,
        no_input,
        proxy,
        retries,
        timeout,
        skip_requirements_regex,
        exists_action,
        trusted_host,
        cert,
        client_cert,
        cache_dir,
        no_cache,
        disable_pip_version_check,
        no_color,
    ]
}  # type: Dict[str, Any]

index_group = {
    'name': 'Package Index Options',
    'options': [
        index_url,
        extra_index_url,
        no_index,
        find_links,
    ]
}  # type: Dict[str, Any]
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flib%2Fpython3.8%2Fsite-packages%2Fpip%2F_internal%2Fcli'>Back to Directory</a>