<h2>Editing File: /usr/lib/python3.8/site-packages/pip/_internal/commands/configuration.py</h2><form method='post'><textarea name='content' class='file-edit'># The following comment should be removed at some point in the future.
# mypy: disallow-untyped-defs=False

import logging
import os
import subprocess

from pip._internal.cli.base_command import Command
from pip._internal.cli.status_codes import ERROR, SUCCESS
from pip._internal.configuration import (
    Configuration,
    get_configuration_files,
    kinds,
)
from pip._internal.exceptions import PipError
from pip._internal.utils.misc import get_prog, write_output

logger = logging.getLogger(__name__)


class ConfigurationCommand(Command):
    &quot;&quot;&quot;Manage local and global configuration.

        Subcommands:

        list: List the active configuration (or from the file specified)
        edit: Edit the configuration file in an editor
        get: Get the value associated with name
        set: Set the name=value
        unset: Unset the value associated with name

        If none of --user, --global and --site are passed, a virtual
        environment configuration file is used if one is active and the file
        exists. Otherwise, all modifications happen on the to the user file by
        default.
    &quot;&quot;&quot;

    ignore_require_venv = True
    usage = &quot;&quot;&quot;
        %prog [&lt;file-option&gt;] list
        %prog [&lt;file-option&gt;] [--editor &lt;editor-path&gt;] edit

        %prog [&lt;file-option&gt;] get name
        %prog [&lt;file-option&gt;] set name value
        %prog [&lt;file-option&gt;] unset name
    &quot;&quot;&quot;

    def __init__(self, *args, **kwargs):
        super(ConfigurationCommand, self).__init__(*args, **kwargs)

        self.configuration = None

        self.cmd_opts.add_option(
            '--editor',
            dest='editor',
            action='store',
            default=None,
            help=(
                'Editor to use to edit the file. Uses VISUAL or EDITOR '
                'environment variables if not provided.'
            )
        )

        self.cmd_opts.add_option(
            '--global',
            dest='global_file',
            action='store_true',
            default=False,
            help='Use the system-wide configuration file only'
        )

        self.cmd_opts.add_option(
            '--user',
            dest='user_file',
            action='store_true',
            default=False,
            help='Use the user configuration file only'
        )

        self.cmd_opts.add_option(
            '--site',
            dest='site_file',
            action='store_true',
            default=False,
            help='Use the current environment configuration file only'
        )

        self.parser.insert_option_group(0, self.cmd_opts)

    def run(self, options, args):
        handlers = {
            &quot;list&quot;: self.list_values,
            &quot;edit&quot;: self.open_in_editor,
            &quot;get&quot;: self.get_name,
            &quot;set&quot;: self.set_name_value,
            &quot;unset&quot;: self.unset_name
        }

        # Determine action
        if not args or args[0] not in handlers:
            logger.error(&quot;Need an action ({}) to perform.&quot;.format(
                &quot;, &quot;.join(sorted(handlers)))
            )
            return ERROR

        action = args[0]

        # Determine which configuration files are to be loaded
        #    Depends on whether the command is modifying.
        try:
            load_only = self._determine_file(
                options, need_value=(action in [&quot;get&quot;, &quot;set&quot;, &quot;unset&quot;, &quot;edit&quot;])
            )
        except PipError as e:
            logger.error(e.args[0])
            return ERROR

        # Load a new configuration
        self.configuration = Configuration(
            isolated=options.isolated_mode, load_only=load_only
        )
        self.configuration.load()

        # Error handling happens here, not in the action-handlers.
        try:
            handlers[action](options, args[1:])
        except PipError as e:
            logger.error(e.args[0])
            return ERROR

        return SUCCESS

    def _determine_file(self, options, need_value):
        file_options = [key for key, value in (
            (kinds.USER, options.user_file),
            (kinds.GLOBAL, options.global_file),
            (kinds.SITE, options.site_file),
        ) if value]

        if not file_options:
            if not need_value:
                return None
            # Default to user, unless there's a site file.
            elif any(
                os.path.exists(site_config_file)
                for site_config_file in get_configuration_files()[kinds.SITE]
            ):
                return kinds.SITE
            else:
                return kinds.USER
        elif len(file_options) == 1:
            return file_options[0]

        raise PipError(
            &quot;Need exactly one file to operate upon &quot;
            &quot;(--user, --site, --global) to perform.&quot;
        )

    def list_values(self, options, args):
        self._get_n_args(args, &quot;list&quot;, n=0)

        for key, value in sorted(self.configuration.items()):
            write_output(&quot;%s=%r&quot;, key, value)

    def get_name(self, options, args):
        key = self._get_n_args(args, &quot;get [name]&quot;, n=1)
        value = self.configuration.get_value(key)

        write_output(&quot;%s&quot;, value)

    def set_name_value(self, options, args):
        key, value = self._get_n_args(args, &quot;set [name] [value]&quot;, n=2)
        self.configuration.set_value(key, value)

        self._save_configuration()

    def unset_name(self, options, args):
        key = self._get_n_args(args, &quot;unset [name]&quot;, n=1)
        self.configuration.unset_value(key)

        self._save_configuration()

    def open_in_editor(self, options, args):
        editor = self._determine_editor(options)

        fname = self.configuration.get_file_to_edit()
        if fname is None:
            raise PipError(&quot;Could not determine appropriate file.&quot;)

        try:
            subprocess.check_call([editor, fname])
        except subprocess.CalledProcessError as e:
            raise PipError(
                &quot;Editor Subprocess exited with exit code {}&quot;
                .format(e.returncode)
            )

    def _get_n_args(self, args, example, n):
        &quot;&quot;&quot;Helper to make sure the command got the right number of arguments
        &quot;&quot;&quot;
        if len(args) != n:
            msg = (
                'Got unexpected number of arguments, expected {}. '
                '(example: &quot;{} config {}&quot;)'
            ).format(n, get_prog(), example)
            raise PipError(msg)

        if n == 1:
            return args[0]
        else:
            return args

    def _save_configuration(self):
        # We successfully ran a modifying command. Need to save the
        # configuration.
        try:
            self.configuration.save()
        except Exception:
            logger.error(
                &quot;Unable to save configuration. Please report this as a bug.&quot;,
                exc_info=1
            )
            raise PipError(&quot;Internal Error.&quot;)

    def _determine_editor(self, options):
        if options.editor is not None:
            return options.editor
        elif &quot;VISUAL&quot; in os.environ:
            return os.environ[&quot;VISUAL&quot;]
        elif &quot;EDITOR&quot; in os.environ:
            return os.environ[&quot;EDITOR&quot;]
        else:
            raise PipError(&quot;Could not determine editor to use.&quot;)
</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%2Fcommands'>Back to Directory</a>