1 files changed, 378 insertions, 0 deletions
diff --git a/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_internal/configuration.py b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_internal/configuration.py
new file mode 100644
index 0000000..07af373
--- /dev/null
+++ b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_internal/configuration.py
@@ -0,0 +1,378 @@
+"""Configuration management setup
+Some terminology:
+- name
+  As written in config files.
+- value
+  Value associated with a name
+- key
+  Name combined with it's section (section.name)
+- variant
+  A single word describing where the configuration key-value pair came from
+"""
+import locale
+import logging
+import os
+from pip._vendor import six
+from pip._vendor.six.moves import configparser
+from pip._internal.exceptions import ConfigurationError
+from pip._internal.locations import (
+    legacy_config_file, new_config_file, running_under_virtualenv,
+    site_config_files, venv_config_file,
+)
+from pip._internal.utils.misc import ensure_dir, enum
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+if MYPY_CHECK_RUNNING:
+    from typing import Any, Dict, Iterable, List, NewType, Optional, Tuple
+    RawConfigParser = configparser.RawConfigParser  # Shorthand
+    Kind = NewType("Kind", str)
+logger = logging.getLogger(__name__)
+# NOTE: Maybe use the optionx attribute to normalize keynames.
+def _normalize_name(name):
+    # type: (str) -> str
+    """Make a name consistent regardless of source (environment or file)
+    """
+    name = name.lower().replace('_', '-')
+    if name.startswith('--'):
+        name = name[2:]  # only prefer long opts
+    return name
+def _disassemble_key(name):
+    # type: (str) -> List[str]
+    return name.split(".", 1)
+# The kinds of configurations there are.
+kinds = enum(
+    USER="user",        # User Specific
+    GLOBAL="global",    # System Wide
+    VENV="venv",        # Virtual Environment Specific
+    ENV="env",          # from PIP_CONFIG_FILE
+    ENV_VAR="env-var",  # from Environment Variables
+)
+class Configuration(object):
+    """Handles management of configuration.
+    Provides an interface to accessing and managing configuration files.
+    This class converts provides an API that takes "section.key-name" style
+    keys and stores the value associated with it as "key-name" under the
+    section "section".
+    This allows for a clean interface wherein the both the section and the
+    key-name are preserved in an easy to manage form in the configuration files
+    and the data stored is also nice.
+    """
+    def __init__(self, isolated, load_only=None):
+        # type: (bool, Kind) -> None
+        super(Configuration, self).__init__()
+        _valid_load_only = [kinds.USER, kinds.GLOBAL, kinds.VENV, None]
+        if load_only not in _valid_load_only:
+            raise ConfigurationError(
+                "Got invalid value for load_only - should be one of {}".format(
+                    ", ".join(map(repr, _valid_load_only[:-1]))
+                )
+            )
+        self.isolated = isolated  # type: bool
+        self.load_only = load_only  # type: Optional[Kind]
+        # The order here determines the override order.
+        self._override_order = [
+            kinds.GLOBAL, kinds.USER, kinds.VENV, kinds.ENV, kinds.ENV_VAR
+        ]
+        self._ignore_env_names = ["version", "help"]
+        # Because we keep track of where we got the data from
+        self._parsers = {
+            variant: [] for variant in self._override_order
+        }  # type: Dict[Kind, List[Tuple[str, RawConfigParser]]]
+        self._config = {
+            variant: {} for variant in self._override_order
+        }  # type: Dict[Kind, Dict[str, Any]]
+        self._modified_parsers = []  # type: List[Tuple[str, RawConfigParser]]
+    def load(self):
+        # type: () -> None
+        """Loads configuration from configuration files and environment
+        """
+        self._load_config_files()
+        if not self.isolated:
+            self._load_environment_vars()
+    def get_file_to_edit(self):
+        # type: () -> Optional[str]
+        """Returns the file with highest priority in configuration
+        """
+        assert self.load_only is not None, \
+            "Need to be specified a file to be editing"
+        try:
+            return self._get_parser_to_modify()[0]
+        except IndexError:
+            return None
+    def items(self):
+        # type: () -> Iterable[Tuple[str, Any]]
+        """Returns key-value pairs like dict.items() representing the loaded
+        configuration
+        """
+        return self._dictionary.items()
+    def get_value(self, key):
+        # type: (str) -> Any
+        """Get a value from the configuration.
+        """
+        try:
+            return self._dictionary[key]
+        except KeyError:
+            raise ConfigurationError("No such key - {}".format(key))
+    def set_value(self, key, value):
+        # type: (str, Any) -> None
+        """Modify a value in the configuration.
+        """
+        self._ensure_have_load_only()
+        fname, parser = self._get_parser_to_modify()
+        if parser is not None:
+            section, name = _disassemble_key(key)
+            # Modify the parser and the configuration
+            if not parser.has_section(section):
+                parser.add_section(section)
+            parser.set(section, name, value)
+        self._config[self.load_only][key] = value
+        self._mark_as_modified(fname, parser)
+    def unset_value(self, key):
+        # type: (str) -> None
+        """Unset a value in the configuration.
+        """
+        self._ensure_have_load_only()
+        if key not in self._config[self.load_only]:
+            raise ConfigurationError("No such key - {}".format(key))
+        fname, parser = self._get_parser_to_modify()
+        if parser is not None:
+            section, name = _disassemble_key(key)
+            # Remove the key in the parser
+            modified_something = False
+            if parser.has_section(section):
+                # Returns whether the option was removed or not
+                modified_something = parser.remove_option(section, name)
+            if modified_something:
+                # name removed from parser, section may now be empty
+                section_iter = iter(parser.items(section))
+                try:
+                    val = six.next(section_iter)
+                except StopIteration:
+                    val = None
+                if val is None:
+                    parser.remove_section(section)
+                self._mark_as_modified(fname, parser)
+            else:
+                raise ConfigurationError(
+                    "Fatal Internal error [id=1]. Please report as a bug."
+                )
+        del self._config[self.load_only][key]
+    def save(self):
+        # type: () -> None
+        """Save the currentin-memory state.
+        """
+        self._ensure_have_load_only()
+        for fname, parser in self._modified_parsers:
+            logger.info("Writing to %s", fname)
+            # Ensure directory exists.
+            ensure_dir(os.path.dirname(fname))
+            with open(fname, "w") as f:
+                parser.write(f)  # type: ignore
+    #
+    # Private routines
+    #
+    def _ensure_have_load_only(self):
+        # type: () -> None
+        if self.load_only is None:
+            raise ConfigurationError("Needed a specific file to be modifying.")
+        logger.debug("Will be working with %s variant only", self.load_only)
+    @property
+    def _dictionary(self):
+        # type: () -> Dict[str, Any]
+        """A dictionary representing the loaded configuration.
+        """
+        # NOTE: Dictionaries are not populated if not loaded. So, conditionals
+        #       are not needed here.
+        retval = {}
+        for variant in self._override_order:
+            retval.update(self._config[variant])
+        return retval
+    def _load_config_files(self):
+        # type: () -> None
+        """Loads configuration from configuration files
+        """
+        config_files = dict(self._iter_config_files())
+        if config_files[kinds.ENV][0:1] == [os.devnull]:
+            logger.debug(
+                "Skipping loading configuration files due to "
+                "environment's PIP_CONFIG_FILE being os.devnull"
+            )
+            return
+        for variant, files in config_files.items():
+            for fname in files:
+                # If there's specific variant set in `load_only`, load only
+                # that variant, not the others.
+                if self.load_only is not None and variant != self.load_only:
+                    logger.debug(
+                        "Skipping file '%s' (variant: %s)", fname, variant
+                    )
+                    continue
+                parser = self._load_file(variant, fname)
+                # Keeping track of the parsers used
+                self._parsers[variant].append((fname, parser))
+    def _load_file(self, variant, fname):
+        # type: (Kind, str) -> RawConfigParser
+        logger.debug("For variant '%s', will try loading '%s'", variant, fname)
+        parser = self._construct_parser(fname)
+        for section in parser.sections():
+            items = parser.items(section)
+            self._config[variant].update(self._normalized_keys(section, items))
+        return parser
+    def _construct_parser(self, fname):
+        # type: (str) -> RawConfigParser
+        parser = configparser.RawConfigParser()
+        # If there is no such file, don't bother reading it but create the
+        # parser anyway, to hold the data.
+        # Doing this is useful when modifying and saving files, where we don't
+        # need to construct a parser.
+        if os.path.exists(fname):
+            try:
+                parser.read(fname)
+            except UnicodeDecodeError:
+                raise ConfigurationError((
+                    "ERROR: "
+                    "Configuration file contains invalid %s characters.\n"
+                    "Please fix your configuration, located at %s\n"
+                ) % (locale.getpreferredencoding(False), fname))
+        return parser
+    def _load_environment_vars(self):
+        # type: () -> None
+        """Loads configuration from environment variables
+        """
+        self._config[kinds.ENV_VAR].update(
+            self._normalized_keys(":env:", self._get_environ_vars())
+        )
+    def _normalized_keys(self, section, items):
+        # type: (str, Iterable[Tuple[str, Any]]) -> Dict[str, Any]
+        """Normalizes items to construct a dictionary with normalized keys.
+        This routine is where the names become keys and are made the same
+        regardless of source - configuration files or environment.
+        """
+        normalized = {}
+        for name, val in items:
+            key = section + "." + _normalize_name(name)
+            normalized[key] = val
+        return normalized
+    def _get_environ_vars(self):
+        # type: () -> Iterable[Tuple[str, str]]
+        """Returns a generator with all environmental vars with prefix PIP_"""
+        for key, val in os.environ.items():
+            should_be_yielded = (
+                key.startswith("PIP_") and
+                key[4:].lower() not in self._ignore_env_names
+            )
+            if should_be_yielded:
+                yield key[4:].lower(), val
+    # XXX: This is patched in the tests.
+    def _iter_config_files(self):
+        # type: () -> Iterable[Tuple[Kind, List[str]]]
+        """Yields variant and configuration files associated with it.
+        This should be treated like items of a dictionary.
+        """
+        # SMELL: Move the conditions out of this function
+        # environment variables have the lowest priority
+        config_file = os.environ.get('PIP_CONFIG_FILE', None)
+        if config_file is not None:
+            yield kinds.ENV, [config_file]
+        else:
+            yield kinds.ENV, []
+        # at the base we have any global configuration
+        yield kinds.GLOBAL, list(site_config_files)
+        # per-user configuration next
+        should_load_user_config = not self.isolated and not (
+            config_file and os.path.exists(config_file)
+        )
+        if should_load_user_config:
+            # The legacy config file is overridden by the new config file
+            yield kinds.USER, [legacy_config_file, new_config_file]
+        # finally virtualenv configuration first trumping others
+        if running_under_virtualenv():
+            yield kinds.VENV, [venv_config_file]
+    def _get_parser_to_modify(self):
+        # type: () -> Tuple[str, RawConfigParser]
+        # Determine which parser to modify
+        parsers = self._parsers[self.load_only]
+        if not parsers:
+            # This should not happen if everything works correctly.
+            raise ConfigurationError(
+                "Fatal Internal error [id=2]. Please report as a bug."
+            )
+        # Use the highest priority parser.
+        return parsers[-1]
+    # XXX: This is patched in the tests.
+    def _mark_as_modified(self, fname, parser):
+        # type: (str, RawConfigParser) -> None
+        file_parser_tuple = (fname, parser)
+        if file_parser_tuple not in self._modified_parsers:
+            self._modified_parsers.append(file_parser_tuple)

diff --git a/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_internal/configuration.py b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_internal/configuration.py new file mode 100644 index 0000000..07af373 --- /dev/null +++ b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_internal/configuration.py
@@ -0,0 +1,378 @@
	1	"""Configuration management setup
	2
	3	Some terminology:
	4	- name
	5	As written in config files.
	6	- value
	7	Value associated with a name
	8	- key
	9	Name combined with it's section (section.name)
	10	- variant
	11	A single word describing where the configuration key-value pair came from
	12	"""
	13
	14	import locale
	15	import logging
	16	import os
	17
	18	from pip._vendor import six
	19	from pip._vendor.six.moves import configparser
	20
	21	from pip._internal.exceptions import ConfigurationError
	22	from pip._internal.locations import (
	23	legacy_config_file, new_config_file, running_under_virtualenv,
	24	site_config_files, venv_config_file,
	25	)
	26	from pip._internal.utils.misc import ensure_dir, enum
	27	from pip._internal.utils.typing import MYPY_CHECK_RUNNING
	28
	29	if MYPY_CHECK_RUNNING:
	30	from typing import Any, Dict, Iterable, List, NewType, Optional, Tuple
	31
	32	RawConfigParser = configparser.RawConfigParser # Shorthand
	33	Kind = NewType("Kind", str)
	34
	35	logger = logging.getLogger(__name__)
	36
	37
	38	# NOTE: Maybe use the optionx attribute to normalize keynames.
	39	def _normalize_name(name):
	40	# type: (str) -> str
	41	"""Make a name consistent regardless of source (environment or file)
	42	"""
	43	name = name.lower().replace('_', '-')
	44	if name.startswith('--'):
	45	name = name[2:] # only prefer long opts
	46	return name
	47
	48
	49	def _disassemble_key(name):
	50	# type: (str) -> List[str]
	51	return name.split(".", 1)
	52
	53
	54	# The kinds of configurations there are.
	55	kinds = enum(
	56	USER="user", # User Specific
	57	GLOBAL="global", # System Wide
	58	VENV="venv", # Virtual Environment Specific
	59	ENV="env", # from PIP_CONFIG_FILE
	60	ENV_VAR="env-var", # from Environment Variables
	61	)
	62
	63
	64	class Configuration(object):
	65	"""Handles management of configuration.
	66
	67	Provides an interface to accessing and managing configuration files.
	68
	69	This class converts provides an API that takes "section.key-name" style
	70	keys and stores the value associated with it as "key-name" under the
	71	section "section".
	72
	73	This allows for a clean interface wherein the both the section and the
	74	key-name are preserved in an easy to manage form in the configuration files
	75	and the data stored is also nice.
	76	"""
	77
	78	def __init__(self, isolated, load_only=None):
	79	# type: (bool, Kind) -> None
	80	super(Configuration, self).__init__()
	81
	82	_valid_load_only = [kinds.USER, kinds.GLOBAL, kinds.VENV, None]
	83	if load_only not in _valid_load_only:
	84	raise ConfigurationError(
	85	"Got invalid value for load_only - should be one of {}".format(
	86	", ".join(map(repr, _valid_load_only[:-1]))
	87	)
	88	)
	89	self.isolated = isolated # type: bool
	90	self.load_only = load_only # type: Optional[Kind]
	91
	92	# The order here determines the override order.
	93	self._override_order = [
	94	kinds.GLOBAL, kinds.USER, kinds.VENV, kinds.ENV, kinds.ENV_VAR
	95	]
	96
	97	self._ignore_env_names = ["version", "help"]
	98
	99	# Because we keep track of where we got the data from
	100	self._parsers = {
	101	variant: [] for variant in self._override_order
	102	} # type: Dict[Kind, List[Tuple[str, RawConfigParser]]]
	103	self._config = {
	104	variant: {} for variant in self._override_order
	105	} # type: Dict[Kind, Dict[str, Any]]
	106	self._modified_parsers = [] # type: List[Tuple[str, RawConfigParser]]
	107
	108	def load(self):
	109	# type: () -> None
	110	"""Loads configuration from configuration files and environment
	111	"""
	112	self._load_config_files()
	113	if not self.isolated:
	114	self._load_environment_vars()
	115
	116	def get_file_to_edit(self):
	117	# type: () -> Optional[str]
	118	"""Returns the file with highest priority in configuration
	119	"""
	120	assert self.load_only is not None, \
	121	"Need to be specified a file to be editing"
	122
	123	try:
	124	return self._get_parser_to_modify()[0]
	125	except IndexError:
	126	return None
	127
	128	def items(self):
	129	# type: () -> Iterable[Tuple[str, Any]]
	130	"""Returns key-value pairs like dict.items() representing the loaded
	131	configuration
	132	"""
	133	return self._dictionary.items()
	134
	135	def get_value(self, key):
	136	# type: (str) -> Any
	137	"""Get a value from the configuration.
	138	"""
	139	try:
	140	return self._dictionary[key]
	141	except KeyError:
	142	raise ConfigurationError("No such key - {}".format(key))
	143
	144	def set_value(self, key, value):
	145	# type: (str, Any) -> None
	146	"""Modify a value in the configuration.
	147	"""
	148	self._ensure_have_load_only()
	149
	150	fname, parser = self._get_parser_to_modify()
	151
	152	if parser is not None:
	153	section, name = _disassemble_key(key)
	154
	155	# Modify the parser and the configuration
	156	if not parser.has_section(section):
	157	parser.add_section(section)
	158	parser.set(section, name, value)
	159
	160	self._config[self.load_only][key] = value
	161	self._mark_as_modified(fname, parser)
	162
	163	def unset_value(self, key):
	164	# type: (str) -> None
	165	"""Unset a value in the configuration.
	166	"""
	167	self._ensure_have_load_only()
	168
	169	if key not in self._config[self.load_only]:
	170	raise ConfigurationError("No such key - {}".format(key))
	171
	172	fname, parser = self._get_parser_to_modify()
	173
	174	if parser is not None:
	175	section, name = _disassemble_key(key)
	176
	177	# Remove the key in the parser
	178	modified_something = False
	179	if parser.has_section(section):
	180	# Returns whether the option was removed or not
	181	modified_something = parser.remove_option(section, name)
	182
	183	if modified_something:
	184	# name removed from parser, section may now be empty
	185	section_iter = iter(parser.items(section))
	186	try:
	187	val = six.next(section_iter)
	188	except StopIteration:
	189	val = None
	190
	191	if val is None:
	192	parser.remove_section(section)
	193
	194	self._mark_as_modified(fname, parser)
	195	else:
	196	raise ConfigurationError(
	197	"Fatal Internal error [id=1]. Please report as a bug."
	198	)
	199
	200	del self._config[self.load_only][key]
	201
	202	def save(self):
	203	# type: () -> None
	204	"""Save the currentin-memory state.
	205	"""
	206	self._ensure_have_load_only()
	207
	208	for fname, parser in self._modified_parsers:
	209	logger.info("Writing to %s", fname)
	210
	211	# Ensure directory exists.
	212	ensure_dir(os.path.dirname(fname))
	213
	214	with open(fname, "w") as f:
	215	parser.write(f) # type: ignore
	216
	217	#
	218	# Private routines
	219	#
	220
	221	def _ensure_have_load_only(self):
	222	# type: () -> None
	223	if self.load_only is None:
	224	raise ConfigurationError("Needed a specific file to be modifying.")
	225	logger.debug("Will be working with %s variant only", self.load_only)
	226
	227	@property
	228	def _dictionary(self):
	229	# type: () -> Dict[str, Any]
	230	"""A dictionary representing the loaded configuration.
	231	"""
	232	# NOTE: Dictionaries are not populated if not loaded. So, conditionals
	233	# are not needed here.
	234	retval = {}
	235
	236	for variant in self._override_order:
	237	retval.update(self._config[variant])
	238
	239	return retval
	240
	241	def _load_config_files(self):
	242	# type: () -> None
	243	"""Loads configuration from configuration files
	244	"""
	245	config_files = dict(self._iter_config_files())
	246	if config_files[kinds.ENV][0:1] == [os.devnull]:
	247	logger.debug(
	248	"Skipping loading configuration files due to "
	249	"environment's PIP_CONFIG_FILE being os.devnull"
	250	)
	251	return
	252
	253	for variant, files in config_files.items():
	254	for fname in files:
	255	# If there's specific variant set in `load_only`, load only
	256	# that variant, not the others.
	257	if self.load_only is not None and variant != self.load_only:
	258	logger.debug(
	259	"Skipping file '%s' (variant: %s)", fname, variant
	260	)
	261	continue
	262
	263	parser = self._load_file(variant, fname)
	264
	265	# Keeping track of the parsers used
	266	self._parsers[variant].append((fname, parser))
	267
	268	def _load_file(self, variant, fname):
	269	# type: (Kind, str) -> RawConfigParser
	270	logger.debug("For variant '%s', will try loading '%s'", variant, fname)
	271	parser = self._construct_parser(fname)
	272
	273	for section in parser.sections():
	274	items = parser.items(section)
	275	self._config[variant].update(self._normalized_keys(section, items))
	276
	277	return parser
	278
	279	def _construct_parser(self, fname):
	280	# type: (str) -> RawConfigParser
	281	parser = configparser.RawConfigParser()
	282	# If there is no such file, don't bother reading it but create the
	283	# parser anyway, to hold the data.
	284	# Doing this is useful when modifying and saving files, where we don't
	285	# need to construct a parser.
	286	if os.path.exists(fname):
	287	try:
	288	parser.read(fname)
	289	except UnicodeDecodeError:
	290	raise ConfigurationError((
	291	"ERROR: "
	292	"Configuration file contains invalid %s characters.\n"
	293	"Please fix your configuration, located at %s\n"
	294	) % (locale.getpreferredencoding(False), fname))
	295	return parser
	296
	297	def _load_environment_vars(self):
	298	# type: () -> None
	299	"""Loads configuration from environment variables
	300	"""
	301	self._config[kinds.ENV_VAR].update(
	302	self._normalized_keys(":env:", self._get_environ_vars())
	303	)
	304
	305	def _normalized_keys(self, section, items):
	306	# type: (str, Iterable[Tuple[str, Any]]) -> Dict[str, Any]
	307	"""Normalizes items to construct a dictionary with normalized keys.
	308
	309	This routine is where the names become keys and are made the same
	310	regardless of source - configuration files or environment.
	311	"""
	312	normalized = {}
	313	for name, val in items:
	314	key = section + "." + _normalize_name(name)
	315	normalized[key] = val
	316	return normalized
	317
	318	def _get_environ_vars(self):
	319	# type: () -> Iterable[Tuple[str, str]]
	320	"""Returns a generator with all environmental vars with prefix PIP_"""
	321	for key, val in os.environ.items():
	322	should_be_yielded = (
	323	key.startswith("PIP_") and
	324	key[4:].lower() not in self._ignore_env_names
	325	)
	326	if should_be_yielded:
	327	yield key[4:].lower(), val
	328
	329	# XXX: This is patched in the tests.
	330	def _iter_config_files(self):
	331	# type: () -> Iterable[Tuple[Kind, List[str]]]
	332	"""Yields variant and configuration files associated with it.
	333
	334	This should be treated like items of a dictionary.
	335	"""
	336	# SMELL: Move the conditions out of this function
	337
	338	# environment variables have the lowest priority
	339	config_file = os.environ.get('PIP_CONFIG_FILE', None)
	340	if config_file is not None:
	341	yield kinds.ENV, [config_file]
	342	else:
	343	yield kinds.ENV, []
	344
	345	# at the base we have any global configuration
	346	yield kinds.GLOBAL, list(site_config_files)
	347
	348	# per-user configuration next
	349	should_load_user_config = not self.isolated and not (
	350	config_file and os.path.exists(config_file)
	351	)
	352	if should_load_user_config:
	353	# The legacy config file is overridden by the new config file
	354	yield kinds.USER, [legacy_config_file, new_config_file]
	355
	356	# finally virtualenv configuration first trumping others
	357	if running_under_virtualenv():
	358	yield kinds.VENV, [venv_config_file]
	359
	360	def _get_parser_to_modify(self):
	361	# type: () -> Tuple[str, RawConfigParser]
	362	# Determine which parser to modify
	363	parsers = self._parsers[self.load_only]
	364	if not parsers:
	365	# This should not happen if everything works correctly.
	366	raise ConfigurationError(
	367	"Fatal Internal error [id=2]. Please report as a bug."
	368	)
	369
	370	# Use the highest priority parser.
	371	return parsers[-1]
	372
	373	# XXX: This is patched in the tests.
	374	def _mark_as_modified(self, fname, parser):
	375	# type: (str, RawConfigParser) -> None
	376	file_parser_tuple = (fname, parser)
	377	if file_parser_tuple not in self._modified_parsers:
	378	self._modified_parsers.append(file_parser_tuple)