1 files changed, 227 insertions, 0 deletions
diff --git a/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_internal/commands/configuration.py b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_internal/commands/configuration.py
new file mode 100644
index 0000000..e10d9a9
--- /dev/null
+++ b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_internal/commands/configuration.py
@@ -0,0 +1,227 @@
+import logging
+import os
+import subprocess
+from pip._internal.basecommand import Command
+from pip._internal.configuration import Configuration, kinds
+from pip._internal.exceptions import PipError
+from pip._internal.locations import venv_config_file
+from pip._internal.status_codes import ERROR, SUCCESS
+from pip._internal.utils.misc import get_prog
+logger = logging.getLogger(__name__)
+class ConfigurationCommand(Command):
+    """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 --venv 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.
+    """
+    name = 'config'
+    usage = """
+        %prog [<file-option>] list
+        %prog [<file-option>] [--editor <editor-path>] edit
+        %prog [<file-option>] get name
+        %prog [<file-option>] set name value
+        %prog [<file-option>] unset name
+    """
+    summary = "Manage local and global configuration."
+    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(
+            '--venv',
+            dest='venv_file',
+            action='store_true',
+            default=False,
+            help='Use the virtualenv configuration file only'
+        )
+        self.parser.insert_option_group(0, self.cmd_opts)
+    def run(self, options, args):
+        handlers = {
+            "list": self.list_values,
+            "edit": self.open_in_editor,
+            "get": self.get_name,
+            "set": self.set_name_value,
+            "unset": self.unset_name
+        }
+        # Determine action
+        if not args or args[0] not in handlers:
+            logger.error("Need an action ({}) to perform.".format(
+                ", ".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 ["get", "set", "unset", "edit"])
+            )
+        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 = {
+            kinds.USER: options.user_file,
+            kinds.GLOBAL: options.global_file,
+            kinds.VENV: options.venv_file
+        }
+        if sum(file_options.values()) == 0:
+            if not need_value:
+                return None
+            # Default to user, unless there's a virtualenv file.
+            elif os.path.exists(venv_config_file):
+                return kinds.VENV
+            else:
+                return kinds.USER
+        elif sum(file_options.values()) == 1:
+            # There's probably a better expression for this.
+            return [key for key in file_options if file_options[key]][0]
+        raise PipError(
+            "Need exactly one file to operate upon "
+            "(--user, --venv, --global) to perform."
+        )
+    def list_values(self, options, args):
+        self._get_n_args(args, "list", n=0)
+        for key, value in sorted(self.configuration.items()):
+            logger.info("%s=%r", key, value)
+    def get_name(self, options, args):
+        key = self._get_n_args(args, "get [name]", n=1)
+        value = self.configuration.get_value(key)
+        logger.info("%s", value)
+    def set_name_value(self, options, args):
+        key, value = self._get_n_args(args, "set [name] [value]", n=2)
+        self.configuration.set_value(key, value)
+        self._save_configuration()
+    def unset_name(self, options, args):
+        key = self._get_n_args(args, "unset [name]", 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("Could not determine appropriate file.")
+        try:
+            subprocess.check_call([editor, fname])
+        except subprocess.CalledProcessError as e:
+            raise PipError(
+                "Editor Subprocess exited with exit code {}"
+                .format(e.returncode)
+            )
+    def _get_n_args(self, args, example, n):
+        """Helper to make sure the command got the right number of arguments
+        """
+        if len(args) != n:
+            msg = (
+                'Got unexpected number of arguments, expected {}. '
+                '(example: "{} config {}")'
+            ).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(
+                "Unable to save configuration. Please report this as a bug.",
+                exc_info=1
+            )
+            raise PipError("Internal Error.")
+    def _determine_editor(self, options):
+        if options.editor is not None:
+            return options.editor
+        elif "VISUAL" in os.environ:
+            return os.environ["VISUAL"]
+        elif "EDITOR" in os.environ:
+            return os.environ["EDITOR"]
+        else:
+            raise PipError("Could not determine editor to use.")

diff --git a/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_internal/commands/configuration.py b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_internal/commands/configuration.py new file mode 100644 index 0000000..e10d9a9 --- /dev/null +++ b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_internal/commands/configuration.py
@@ -0,0 +1,227 @@
	1	import logging
	2	import os
	3	import subprocess
	4
	5	from pip._internal.basecommand import Command
	6	from pip._internal.configuration import Configuration, kinds
	7	from pip._internal.exceptions import PipError
	8	from pip._internal.locations import venv_config_file
	9	from pip._internal.status_codes import ERROR, SUCCESS
	10	from pip._internal.utils.misc import get_prog
	11
	12	logger = logging.getLogger(__name__)
	13
	14
	15	class ConfigurationCommand(Command):
	16	"""Manage local and global configuration.
	17
	18	Subcommands:
	19
	20	list: List the active configuration (or from the file specified)
	21	edit: Edit the configuration file in an editor
	22	get: Get the value associated with name
	23	set: Set the name=value
	24	unset: Unset the value associated with name
	25
	26	If none of --user, --global and --venv are passed, a virtual
	27	environment configuration file is used if one is active and the file
	28	exists. Otherwise, all modifications happen on the to the user file by
	29	default.
	30	"""
	31
	32	name = 'config'
	33	usage = """
	34	%prog [<file-option>] list
	35	%prog [<file-option>] [--editor <editor-path>] edit
	36
	37	%prog [<file-option>] get name
	38	%prog [<file-option>] set name value
	39	%prog [<file-option>] unset name
	40	"""
	41
	42	summary = "Manage local and global configuration."
	43
	44	def __init__(self, args, *kwargs):
	45	super(ConfigurationCommand, self).__init__(args, *kwargs)
	46
	47	self.configuration = None
	48
	49	self.cmd_opts.add_option(
	50	'--editor',
	51	dest='editor',
	52	action='store',
	53	default=None,
	54	help=(
	55	'Editor to use to edit the file. Uses VISUAL or EDITOR '
	56	'environment variables if not provided.'
	57	)
	58	)
	59
	60	self.cmd_opts.add_option(
	61	'--global',
	62	dest='global_file',
	63	action='store_true',
	64	default=False,
	65	help='Use the system-wide configuration file only'
	66	)
	67
	68	self.cmd_opts.add_option(
	69	'--user',
	70	dest='user_file',
	71	action='store_true',
	72	default=False,
	73	help='Use the user configuration file only'
	74	)
	75
	76	self.cmd_opts.add_option(
	77	'--venv',
	78	dest='venv_file',
	79	action='store_true',
	80	default=False,
	81	help='Use the virtualenv configuration file only'
	82	)
	83
	84	self.parser.insert_option_group(0, self.cmd_opts)
	85
	86	def run(self, options, args):
	87	handlers = {
	88	"list": self.list_values,
	89	"edit": self.open_in_editor,
	90	"get": self.get_name,
	91	"set": self.set_name_value,
	92	"unset": self.unset_name
	93	}
	94
	95	# Determine action
	96	if not args or args[0] not in handlers:
	97	logger.error("Need an action ({}) to perform.".format(
	98	", ".join(sorted(handlers)))
	99	)
	100	return ERROR
	101
	102	action = args[0]
	103
	104	# Determine which configuration files are to be loaded
	105	# Depends on whether the command is modifying.
	106	try:
	107	load_only = self._determine_file(
	108	options, need_value=(action in ["get", "set", "unset", "edit"])
	109	)
	110	except PipError as e:
	111	logger.error(e.args[0])
	112	return ERROR
	113
	114	# Load a new configuration
	115	self.configuration = Configuration(
	116	isolated=options.isolated_mode, load_only=load_only
	117	)
	118	self.configuration.load()
	119
	120	# Error handling happens here, not in the action-handlers.
	121	try:
	122	handlers[action](options, args[1:])
	123	except PipError as e:
	124	logger.error(e.args[0])
	125	return ERROR
	126
	127	return SUCCESS
	128
	129	def _determine_file(self, options, need_value):
	130	file_options = {
	131	kinds.USER: options.user_file,
	132	kinds.GLOBAL: options.global_file,
	133	kinds.VENV: options.venv_file
	134	}
	135
	136	if sum(file_options.values()) == 0:
	137	if not need_value:
	138	return None
	139	# Default to user, unless there's a virtualenv file.
	140	elif os.path.exists(venv_config_file):
	141	return kinds.VENV
	142	else:
	143	return kinds.USER
	144	elif sum(file_options.values()) == 1:
	145	# There's probably a better expression for this.
	146	return [key for key in file_options if file_options[key]][0]
	147
	148	raise PipError(
	149	"Need exactly one file to operate upon "
	150	"(--user, --venv, --global) to perform."
	151	)
	152
	153	def list_values(self, options, args):
	154	self._get_n_args(args, "list", n=0)
	155
	156	for key, value in sorted(self.configuration.items()):
	157	logger.info("%s=%r", key, value)
	158
	159	def get_name(self, options, args):
	160	key = self._get_n_args(args, "get [name]", n=1)
	161	value = self.configuration.get_value(key)
	162
	163	logger.info("%s", value)
	164
	165	def set_name_value(self, options, args):
	166	key, value = self._get_n_args(args, "set [name] [value]", n=2)
	167	self.configuration.set_value(key, value)
	168
	169	self._save_configuration()
	170
	171	def unset_name(self, options, args):
	172	key = self._get_n_args(args, "unset [name]", n=1)
	173	self.configuration.unset_value(key)
	174
	175	self._save_configuration()
	176
	177	def open_in_editor(self, options, args):
	178	editor = self._determine_editor(options)
	179
	180	fname = self.configuration.get_file_to_edit()
	181	if fname is None:
	182	raise PipError("Could not determine appropriate file.")
	183
	184	try:
	185	subprocess.check_call([editor, fname])
	186	except subprocess.CalledProcessError as e:
	187	raise PipError(
	188	"Editor Subprocess exited with exit code {}"
	189	.format(e.returncode)
	190	)
	191
	192	def _get_n_args(self, args, example, n):
	193	"""Helper to make sure the command got the right number of arguments
	194	"""
	195	if len(args) != n:
	196	msg = (
	197	'Got unexpected number of arguments, expected {}. '
	198	'(example: "{} config {}")'
	199	).format(n, get_prog(), example)
	200	raise PipError(msg)
	201
	202	if n == 1:
	203	return args[0]
	204	else:
	205	return args
	206
	207	def _save_configuration(self):
	208	# We successfully ran a modifying command. Need to save the
	209	# configuration.
	210	try:
	211	self.configuration.save()
	212	except Exception:
	213	logger.error(
	214	"Unable to save configuration. Please report this as a bug.",
	215	exc_info=1
	216	)
	217	raise PipError("Internal Error.")
	218
	219	def _determine_editor(self, options):
	220	if options.editor is not None:
	221	return options.editor
	222	elif "VISUAL" in os.environ:
	223	return os.environ["VISUAL"]
	224	elif "EDITOR" in os.environ:
	225	return os.environ["EDITOR"]
	226	else:
	227	raise PipError("Could not determine editor to use.")