First commit

author: Shubham Saini <shubham6405@gmail.com> 2018-12-11 10:01:23 +0000
committer: Shubham Saini <shubham6405@gmail.com> 2018-12-11 10:01:23 +0000
commit: 68df54d6629ec019142eb149dd037774f2d11e7c (patch)
tree: 345bc22d46b4e01a4ba8303b94278952a4ed2b9e /venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_internal/commands/install.py
1 files changed, 502 insertions, 0 deletions
diff --git a/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_internal/commands/install.py b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_internal/commands/install.py
new file mode 100644
index 0000000..057a64e
--- /dev/null
+++ b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_internal/commands/install.py
@@ -0,0 +1,502 @@
+from __future__ import absolute_import
+import errno
+import logging
+import operator
+import os
+import shutil
+from optparse import SUPPRESS_HELP
+from pip._internal import cmdoptions
+from pip._internal.basecommand import RequirementCommand
+from pip._internal.cache import WheelCache
+from pip._internal.exceptions import (
+    CommandError, InstallationError, PreviousBuildDirError,
+)
+from pip._internal.locations import distutils_scheme, virtualenv_no_global
+from pip._internal.operations.check import check_install_conflicts
+from pip._internal.operations.prepare import RequirementPreparer
+from pip._internal.req import RequirementSet, install_given_reqs
+from pip._internal.resolve import Resolver
+from pip._internal.status_codes import ERROR
+from pip._internal.utils.filesystem import check_path_owner
+from pip._internal.utils.misc import ensure_dir, get_installed_version
+from pip._internal.utils.temp_dir import TempDirectory
+from pip._internal.wheel import WheelBuilder
+try:
+    import wheel
+except ImportError:
+    wheel = None
+logger = logging.getLogger(__name__)
+class InstallCommand(RequirementCommand):
+    """
+    Install packages from:
+    - PyPI (and other indexes) using requirement specifiers.
+    - VCS project urls.
+    - Local project directories.
+    - Local or remote source archives.
+    pip also supports installing from "requirements files", which provide
+    an easy way to specify a whole environment to be installed.
+    """
+    name = 'install'
+    usage = """
+      %prog [options] <requirement specifier> [package-index-options] ...
+      %prog [options] -r <requirements file> [package-index-options] ...
+      %prog [options] [-e] <vcs project url> ...
+      %prog [options] [-e] <local project path> ...
+      %prog [options] <archive url/path> ..."""
+    summary = 'Install packages.'
+    def __init__(self, *args, **kw):
+        super(InstallCommand, self).__init__(*args, **kw)
+        cmd_opts = self.cmd_opts
+        cmd_opts.add_option(cmdoptions.requirements())
+        cmd_opts.add_option(cmdoptions.constraints())
+        cmd_opts.add_option(cmdoptions.no_deps())
+        cmd_opts.add_option(cmdoptions.pre())
+        cmd_opts.add_option(cmdoptions.editable())
+        cmd_opts.add_option(
+            '-t', '--target',
+            dest='target_dir',
+            metavar='dir',
+            default=None,
+            help='Install packages into <dir>. '
+                 'By default this will not replace existing files/folders in '
+                 '<dir>. Use --upgrade to replace existing packages in <dir> '
+                 'with new versions.'
+        )
+        cmd_opts.add_option(
+            '--user',
+            dest='use_user_site',
+            action='store_true',
+            help="Install to the Python user install directory for your "
+                 "platform. Typically ~/.local/, or %APPDATA%\\Python on "
+                 "Windows. (See the Python documentation for site.USER_BASE "
+                 "for full details.)")
+        cmd_opts.add_option(
+            '--no-user',
+            dest='use_user_site',
+            action='store_false',
+            help=SUPPRESS_HELP)
+        cmd_opts.add_option(
+            '--root',
+            dest='root_path',
+            metavar='dir',
+            default=None,
+            help="Install everything relative to this alternate root "
+                 "directory.")
+        cmd_opts.add_option(
+            '--prefix',
+            dest='prefix_path',
+            metavar='dir',
+            default=None,
+            help="Installation prefix where lib, bin and other top-level "
+                 "folders are placed")
+        cmd_opts.add_option(cmdoptions.build_dir())
+        cmd_opts.add_option(cmdoptions.src())
+        cmd_opts.add_option(
+            '-U', '--upgrade',
+            dest='upgrade',
+            action='store_true',
+            help='Upgrade all specified packages to the newest available '
+                 'version. The handling of dependencies depends on the '
+                 'upgrade-strategy used.'
+        )
+        cmd_opts.add_option(
+            '--upgrade-strategy',
+            dest='upgrade_strategy',
+            default='only-if-needed',
+            choices=['only-if-needed', 'eager'],
+            help='Determines how dependency upgrading should be handled '
+                 '[default: %default]. '
+                 '"eager" - dependencies are upgraded regardless of '
+                 'whether the currently installed version satisfies the '
+                 'requirements of the upgraded package(s). '
+                 '"only-if-needed" -  are upgraded only when they do not '
+                 'satisfy the requirements of the upgraded package(s).'
+        )
+        cmd_opts.add_option(
+            '--force-reinstall',
+            dest='force_reinstall',
+            action='store_true',
+            help='Reinstall all packages even if they are already '
+                 'up-to-date.')
+        cmd_opts.add_option(
+            '-I', '--ignore-installed',
+            dest='ignore_installed',
+            action='store_true',
+            help='Ignore the installed packages (reinstalling instead).')
+        cmd_opts.add_option(cmdoptions.ignore_requires_python())
+        cmd_opts.add_option(cmdoptions.no_build_isolation())
+        cmd_opts.add_option(cmdoptions.install_options())
+        cmd_opts.add_option(cmdoptions.global_options())
+        cmd_opts.add_option(
+            "--compile",
+            action="store_true",
+            dest="compile",
+            default=True,
+            help="Compile Python source files to bytecode",
+        )
+        cmd_opts.add_option(
+            "--no-compile",
+            action="store_false",
+            dest="compile",
+            help="Do not compile Python source files to bytecode",
+        )
+        cmd_opts.add_option(
+            "--no-warn-script-location",
+            action="store_false",
+            dest="warn_script_location",
+            default=True,
+            help="Do not warn when installing scripts outside PATH",
+        )
+        cmd_opts.add_option(
+            "--no-warn-conflicts",
+            action="store_false",
+            dest="warn_about_conflicts",
+            default=True,
+            help="Do not warn about broken dependencies",
+        )
+        cmd_opts.add_option(cmdoptions.no_binary())
+        cmd_opts.add_option(cmdoptions.only_binary())
+        cmd_opts.add_option(cmdoptions.no_clean())
+        cmd_opts.add_option(cmdoptions.require_hashes())
+        cmd_opts.add_option(cmdoptions.progress_bar())
+        index_opts = cmdoptions.make_option_group(
+            cmdoptions.index_group,
+            self.parser,
+        )
+        self.parser.insert_option_group(0, index_opts)
+        self.parser.insert_option_group(0, cmd_opts)
+    def run(self, options, args):
+        cmdoptions.check_install_build_global(options)
+        upgrade_strategy = "to-satisfy-only"
+        if options.upgrade:
+            upgrade_strategy = options.upgrade_strategy
+        if options.build_dir:
+            options.build_dir = os.path.abspath(options.build_dir)
+        options.src_dir = os.path.abspath(options.src_dir)
+        install_options = options.install_options or []
+        if options.use_user_site:
+            if options.prefix_path:
+                raise CommandError(
+                    "Can not combine '--user' and '--prefix' as they imply "
+                    "different installation locations"
+                )
+            if virtualenv_no_global():
+                raise InstallationError(
+                    "Can not perform a '--user' install. User site-packages "
+                    "are not visible in this virtualenv."
+                )
+            install_options.append('--user')
+            install_options.append('--prefix=')
+        target_temp_dir = TempDirectory(kind="target")
+        if options.target_dir:
+            options.ignore_installed = True
+            options.target_dir = os.path.abspath(options.target_dir)
+            if (os.path.exists(options.target_dir) and not
+                    os.path.isdir(options.target_dir)):
+                raise CommandError(
+                    "Target path exists but is not a directory, will not "
+                    "continue."
+                )
+            # Create a target directory for using with the target option
+            target_temp_dir.create()
+            install_options.append('--home=' + target_temp_dir.path)
+        global_options = options.global_options or []
+        with self._build_session(options) as session:
+            finder = self._build_package_finder(options, session)
+            build_delete = (not (options.no_clean or options.build_dir))
+            wheel_cache = WheelCache(options.cache_dir, options.format_control)
+            if options.cache_dir and not check_path_owner(options.cache_dir):
+                logger.warning(
+                    "The directory '%s' or its parent directory is not owned "
+                    "by the current user and caching wheels has been "
+                    "disabled. check the permissions and owner of that "
+                    "directory. If executing pip with sudo, you may want "
+                    "sudo's -H flag.",
+                    options.cache_dir,
+                )
+                options.cache_dir = None
+            with TempDirectory(
+                options.build_dir, delete=build_delete, kind="install"
+            ) as directory:
+                requirement_set = RequirementSet(
+                    require_hashes=options.require_hashes,
+                )
+                try:
+                    self.populate_requirement_set(
+                        requirement_set, args, options, finder, session,
+                        self.name, wheel_cache
+                    )
+                    preparer = RequirementPreparer(
+                        build_dir=directory.path,
+                        src_dir=options.src_dir,
+                        download_dir=None,
+                        wheel_download_dir=None,
+                        progress_bar=options.progress_bar,
+                        build_isolation=options.build_isolation,
+                    )
+                    resolver = Resolver(
+                        preparer=preparer,
+                        finder=finder,
+                        session=session,
+                        wheel_cache=wheel_cache,
+                        use_user_site=options.use_user_site,
+                        upgrade_strategy=upgrade_strategy,
+                        force_reinstall=options.force_reinstall,
+                        ignore_dependencies=options.ignore_dependencies,
+                        ignore_requires_python=options.ignore_requires_python,
+                        ignore_installed=options.ignore_installed,
+                        isolated=options.isolated_mode,
+                    )
+                    resolver.resolve(requirement_set)
+                    # If caching is disabled or wheel is not installed don't
+                    # try to build wheels.
+                    if wheel and options.cache_dir:
+                        # build wheels before install.
+                        wb = WheelBuilder(
+                            finder, preparer, wheel_cache,
+                            build_options=[], global_options=[],
+                        )
+                        # Ignore the result: a failed wheel will be
+                        # installed from the sdist/vcs whatever.
+                        wb.build(
+                            requirement_set.requirements.values(),
+                            session=session, autobuilding=True
+                        )
+                    to_install = resolver.get_installation_order(
+                        requirement_set
+                    )
+                    # Consistency Checking of the package set we're installing.
+                    should_warn_about_conflicts = (
+                        not options.ignore_dependencies and
+                        options.warn_about_conflicts
+                    )
+                    if should_warn_about_conflicts:
+                        self._warn_about_conflicts(to_install)
+                    # Don't warn about script install locations if
+                    # --target has been specified
+                    warn_script_location = options.warn_script_location
+                    if options.target_dir:
+                        warn_script_location = False
+                    installed = install_given_reqs(
+                        to_install,
+                        install_options,
+                        global_options,
+                        root=options.root_path,
+                        home=target_temp_dir.path,
+                        prefix=options.prefix_path,
+                        pycompile=options.compile,
+                        warn_script_location=warn_script_location,
+                        use_user_site=options.use_user_site,
+                    )
+                    possible_lib_locations = get_lib_location_guesses(
+                        user=options.use_user_site,
+                        home=target_temp_dir.path,
+                        root=options.root_path,
+                        prefix=options.prefix_path,
+                        isolated=options.isolated_mode,
+                    )
+                    reqs = sorted(installed, key=operator.attrgetter('name'))
+                    items = []
+                    for req in reqs:
+                        item = req.name
+                        try:
+                            installed_version = get_installed_version(
+                                req.name, possible_lib_locations
+                            )
+                            if installed_version:
+                                item += '-' + installed_version
+                        except Exception:
+                            pass
+                        items.append(item)
+                    installed = ' '.join(items)
+                    if installed:
+                        logger.info('Successfully installed %s', installed)
+                except EnvironmentError as error:
+                    show_traceback = (self.verbosity >= 1)
+                    message = create_env_error_message(
+                        error, show_traceback, options.use_user_site,
+                    )
+                    logger.error(message, exc_info=show_traceback)
+                    return ERROR
+                except PreviousBuildDirError:
+                    options.no_clean = True
+                    raise
+                finally:
+                    # Clean up
+                    if not options.no_clean:
+                        requirement_set.cleanup_files()
+                        wheel_cache.cleanup()
+        if options.target_dir:
+            self._handle_target_dir(
+                options.target_dir, target_temp_dir, options.upgrade
+            )
+        return requirement_set
+    def _handle_target_dir(self, target_dir, target_temp_dir, upgrade):
+        ensure_dir(target_dir)
+        # Checking both purelib and platlib directories for installed
+        # packages to be moved to target directory
+        lib_dir_list = []
+        with target_temp_dir:
+            # Checking both purelib and platlib directories for installed
+            # packages to be moved to target directory
+            scheme = distutils_scheme('', home=target_temp_dir.path)
+            purelib_dir = scheme['purelib']
+            platlib_dir = scheme['platlib']
+            data_dir = scheme['data']
+            if os.path.exists(purelib_dir):
+                lib_dir_list.append(purelib_dir)
+            if os.path.exists(platlib_dir) and platlib_dir != purelib_dir:
+                lib_dir_list.append(platlib_dir)
+            if os.path.exists(data_dir):
+                lib_dir_list.append(data_dir)
+            for lib_dir in lib_dir_list:
+                for item in os.listdir(lib_dir):
+                    if lib_dir == data_dir:
+                        ddir = os.path.join(data_dir, item)
+                        if any(s.startswith(ddir) for s in lib_dir_list[:-1]):
+                            continue
+                    target_item_dir = os.path.join(target_dir, item)
+                    if os.path.exists(target_item_dir):
+                        if not upgrade:
+                            logger.warning(
+                                'Target directory %s already exists. Specify '
+                                '--upgrade to force replacement.',
+                                target_item_dir
+                            )
+                            continue
+                        if os.path.islink(target_item_dir):
+                            logger.warning(
+                                'Target directory %s already exists and is '
+                                'a link. Pip will not automatically replace '
+                                'links, please remove if replacement is '
+                                'desired.',
+                                target_item_dir
+                            )
+                            continue
+                        if os.path.isdir(target_item_dir):
+                            shutil.rmtree(target_item_dir)
+                        else:
+                            os.remove(target_item_dir)
+                    shutil.move(
+                        os.path.join(lib_dir, item),
+                        target_item_dir
+                    )
+    def _warn_about_conflicts(self, to_install):
+        package_set, _dep_info = check_install_conflicts(to_install)
+        missing, conflicting = _dep_info
+        # NOTE: There is some duplication here from pip check
+        for project_name in missing:
+            version = package_set[project_name][0]
+            for dependency in missing[project_name]:
+                logger.critical(
+                    "%s %s requires %s, which is not installed.",
+                    project_name, version, dependency[1],
+                )
+        for project_name in conflicting:
+            version = package_set[project_name][0]
+            for dep_name, dep_version, req in conflicting[project_name]:
+                logger.critical(
+                    "%s %s has requirement %s, but you'll have %s %s which is "
+                    "incompatible.",
+                    project_name, version, req, dep_name, dep_version,
+                )
+def get_lib_location_guesses(*args, **kwargs):
+    scheme = distutils_scheme('', *args, **kwargs)
+    return [scheme['purelib'], scheme['platlib']]
+def create_env_error_message(error, show_traceback, using_user_site):
+    """Format an error message for an EnvironmentError
+    It may occur anytime during the execution of the install command.
+    """
+    parts = []
+    # Mention the error if we are not going to show a traceback
+    parts.append("Could not install packages due to an EnvironmentError")
+    if not show_traceback:
+        parts.append(": ")
+        parts.append(str(error))
+    else:
+        parts.append(".")
+    # Spilt the error indication from a helper message (if any)
+    parts[-1] += "\n"
+    # Suggest useful actions to the user:
+    #  (1) using user site-packages or (2) verifying the permissions
+    if error.errno == errno.EACCES:
+        user_option_part = "Consider using the `--user` option"
+        permissions_part = "Check the permissions"
+        if not using_user_site:
+            parts.extend([
+                user_option_part, " or ",
+                permissions_part.lower(),
+            ])
+        else:
+            parts.append(permissions_part)
+        parts.append(".\n")
+    return "".join(parts).strip() + "\n"
author	Shubham Saini <shubham6405@gmail.com>	2018-12-11 10:01:23 +0000
committer	Shubham Saini <shubham6405@gmail.com>	2018-12-11 10:01:23 +0000
commit	68df54d6629ec019142eb149dd037774f2d11e7c (patch)
tree	345bc22d46b4e01a4ba8303b94278952a4ed2b9e /venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_internal/commands/install.py

diff --git a/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_internal/commands/install.py b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_internal/commands/install.py new file mode 100644 index 0000000..057a64e --- /dev/null +++ b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_internal/commands/install.py
@@ -0,0 +1,502 @@
	1	from __future__ import absolute_import
	2
	3	import errno
	4	import logging
	5	import operator
	6	import os
	7	import shutil
	8	from optparse import SUPPRESS_HELP
	9
	10	from pip._internal import cmdoptions
	11	from pip._internal.basecommand import RequirementCommand
	12	from pip._internal.cache import WheelCache
	13	from pip._internal.exceptions import (
	14	CommandError, InstallationError, PreviousBuildDirError,
	15	)
	16	from pip._internal.locations import distutils_scheme, virtualenv_no_global
	17	from pip._internal.operations.check import check_install_conflicts
	18	from pip._internal.operations.prepare import RequirementPreparer
	19	from pip._internal.req import RequirementSet, install_given_reqs
	20	from pip._internal.resolve import Resolver
	21	from pip._internal.status_codes import ERROR
	22	from pip._internal.utils.filesystem import check_path_owner
	23	from pip._internal.utils.misc import ensure_dir, get_installed_version
	24	from pip._internal.utils.temp_dir import TempDirectory
	25	from pip._internal.wheel import WheelBuilder
	26
	27	try:
	28	import wheel
	29	except ImportError:
	30	wheel = None
	31
	32
	33	logger = logging.getLogger(__name__)
	34
	35
	36	class InstallCommand(RequirementCommand):
	37	"""
	38	Install packages from:
	39
	40	- PyPI (and other indexes) using requirement specifiers.
	41	- VCS project urls.
	42	- Local project directories.
	43	- Local or remote source archives.
	44
	45	pip also supports installing from "requirements files", which provide
	46	an easy way to specify a whole environment to be installed.
	47	"""
	48	name = 'install'
	49
	50	usage = """
	51	%prog [options] <requirement specifier> [package-index-options] ...
	52	%prog [options] -r <requirements file> [package-index-options] ...
	53	%prog [options] [-e] <vcs project url> ...
	54	%prog [options] [-e] <local project path> ...
	55	%prog [options] <archive url/path> ..."""
	56
	57	summary = 'Install packages.'
	58
	59	def __init__(self, args, *kw):
	60	super(InstallCommand, self).__init__(args, *kw)
	61
	62	cmd_opts = self.cmd_opts
	63
	64	cmd_opts.add_option(cmdoptions.requirements())
	65	cmd_opts.add_option(cmdoptions.constraints())
	66	cmd_opts.add_option(cmdoptions.no_deps())
	67	cmd_opts.add_option(cmdoptions.pre())
	68
	69	cmd_opts.add_option(cmdoptions.editable())
	70	cmd_opts.add_option(
	71	'-t', '--target',
	72	dest='target_dir',
	73	metavar='dir',
	74	default=None,
	75	help='Install packages into <dir>. '
	76	'By default this will not replace existing files/folders in '
	77	'<dir>. Use --upgrade to replace existing packages in <dir> '
	78	'with new versions.'
	79	)
	80	cmd_opts.add_option(
	81	'--user',
	82	dest='use_user_site',
	83	action='store_true',
	84	help="Install to the Python user install directory for your "
	85	"platform. Typically ~/.local/, or %APPDATA%\\Python on "
	86	"Windows. (See the Python documentation for site.USER_BASE "
	87	"for full details.)")
	88	cmd_opts.add_option(
	89	'--no-user',
	90	dest='use_user_site',
	91	action='store_false',
	92	help=SUPPRESS_HELP)
	93	cmd_opts.add_option(
	94	'--root',
	95	dest='root_path',
	96	metavar='dir',
	97	default=None,
	98	help="Install everything relative to this alternate root "
	99	"directory.")
	100	cmd_opts.add_option(
	101	'--prefix',
	102	dest='prefix_path',
	103	metavar='dir',
	104	default=None,
	105	help="Installation prefix where lib, bin and other top-level "
	106	"folders are placed")
	107
	108	cmd_opts.add_option(cmdoptions.build_dir())
	109
	110	cmd_opts.add_option(cmdoptions.src())
	111
	112	cmd_opts.add_option(
	113	'-U', '--upgrade',
	114	dest='upgrade',
	115	action='store_true',
	116	help='Upgrade all specified packages to the newest available '
	117	'version. The handling of dependencies depends on the '
	118	'upgrade-strategy used.'
	119	)
	120
	121	cmd_opts.add_option(
	122	'--upgrade-strategy',
	123	dest='upgrade_strategy',
	124	default='only-if-needed',
	125	choices=['only-if-needed', 'eager'],
	126	help='Determines how dependency upgrading should be handled '
	127	'[default: %default]. '
	128	'"eager" - dependencies are upgraded regardless of '
	129	'whether the currently installed version satisfies the '
	130	'requirements of the upgraded package(s). '
	131	'"only-if-needed" - are upgraded only when they do not '
	132	'satisfy the requirements of the upgraded package(s).'
	133	)
	134
	135	cmd_opts.add_option(
	136	'--force-reinstall',
	137	dest='force_reinstall',
	138	action='store_true',
	139	help='Reinstall all packages even if they are already '
	140	'up-to-date.')
	141
	142	cmd_opts.add_option(
	143	'-I', '--ignore-installed',
	144	dest='ignore_installed',
	145	action='store_true',
	146	help='Ignore the installed packages (reinstalling instead).')
	147
	148	cmd_opts.add_option(cmdoptions.ignore_requires_python())
	149	cmd_opts.add_option(cmdoptions.no_build_isolation())
	150
	151	cmd_opts.add_option(cmdoptions.install_options())
	152	cmd_opts.add_option(cmdoptions.global_options())
	153
	154	cmd_opts.add_option(
	155	"--compile",
	156	action="store_true",
	157	dest="compile",
	158	default=True,
	159	help="Compile Python source files to bytecode",
	160	)
	161
	162	cmd_opts.add_option(
	163	"--no-compile",
	164	action="store_false",
	165	dest="compile",
	166	help="Do not compile Python source files to bytecode",
	167	)
	168
	169	cmd_opts.add_option(
	170	"--no-warn-script-location",
	171	action="store_false",
	172	dest="warn_script_location",
	173	default=True,
	174	help="Do not warn when installing scripts outside PATH",
	175	)
	176	cmd_opts.add_option(
	177	"--no-warn-conflicts",
	178	action="store_false",
	179	dest="warn_about_conflicts",
	180	default=True,
	181	help="Do not warn about broken dependencies",
	182	)
	183
	184	cmd_opts.add_option(cmdoptions.no_binary())
	185	cmd_opts.add_option(cmdoptions.only_binary())
	186	cmd_opts.add_option(cmdoptions.no_clean())
	187	cmd_opts.add_option(cmdoptions.require_hashes())
	188	cmd_opts.add_option(cmdoptions.progress_bar())
	189
	190	index_opts = cmdoptions.make_option_group(
	191	cmdoptions.index_group,
	192	self.parser,
	193	)
	194
	195	self.parser.insert_option_group(0, index_opts)
	196	self.parser.insert_option_group(0, cmd_opts)
	197
	198	def run(self, options, args):
	199	cmdoptions.check_install_build_global(options)
	200
	201	upgrade_strategy = "to-satisfy-only"
	202	if options.upgrade:
	203	upgrade_strategy = options.upgrade_strategy
	204
	205	if options.build_dir:
	206	options.build_dir = os.path.abspath(options.build_dir)
	207
	208	options.src_dir = os.path.abspath(options.src_dir)
	209	install_options = options.install_options or []
	210	if options.use_user_site:
	211	if options.prefix_path:
	212	raise CommandError(
	213	"Can not combine '--user' and '--prefix' as they imply "
	214	"different installation locations"
	215	)
	216	if virtualenv_no_global():
	217	raise InstallationError(
	218	"Can not perform a '--user' install. User site-packages "
	219	"are not visible in this virtualenv."
	220	)
	221	install_options.append('--user')
	222	install_options.append('--prefix=')
	223
	224	target_temp_dir = TempDirectory(kind="target")
	225	if options.target_dir:
	226	options.ignore_installed = True
	227	options.target_dir = os.path.abspath(options.target_dir)
	228	if (os.path.exists(options.target_dir) and not
	229	os.path.isdir(options.target_dir)):
	230	raise CommandError(
	231	"Target path exists but is not a directory, will not "
	232	"continue."
	233	)
	234
	235	# Create a target directory for using with the target option
	236	target_temp_dir.create()
	237	install_options.append('--home=' + target_temp_dir.path)
	238
	239	global_options = options.global_options or []
	240
	241	with self._build_session(options) as session:
	242	finder = self._build_package_finder(options, session)
	243	build_delete = (not (options.no_clean or options.build_dir))
	244	wheel_cache = WheelCache(options.cache_dir, options.format_control)
	245
	246	if options.cache_dir and not check_path_owner(options.cache_dir):
	247	logger.warning(
	248	"The directory '%s' or its parent directory is not owned "
	249	"by the current user and caching wheels has been "
	250	"disabled. check the permissions and owner of that "
	251	"directory. If executing pip with sudo, you may want "
	252	"sudo's -H flag.",
	253	options.cache_dir,
	254	)
	255	options.cache_dir = None
	256
	257	with TempDirectory(
	258	options.build_dir, delete=build_delete, kind="install"
	259	) as directory:
	260	requirement_set = RequirementSet(
	261	require_hashes=options.require_hashes,
	262	)
	263
	264	try:
	265	self.populate_requirement_set(
	266	requirement_set, args, options, finder, session,
	267	self.name, wheel_cache
	268	)
	269	preparer = RequirementPreparer(
	270	build_dir=directory.path,
	271	src_dir=options.src_dir,
	272	download_dir=None,
	273	wheel_download_dir=None,
	274	progress_bar=options.progress_bar,
	275	build_isolation=options.build_isolation,
	276	)
	277
	278	resolver = Resolver(
	279	preparer=preparer,
	280	finder=finder,
	281	session=session,
	282	wheel_cache=wheel_cache,
	283	use_user_site=options.use_user_site,
	284	upgrade_strategy=upgrade_strategy,
	285	force_reinstall=options.force_reinstall,
	286	ignore_dependencies=options.ignore_dependencies,
	287	ignore_requires_python=options.ignore_requires_python,
	288	ignore_installed=options.ignore_installed,
	289	isolated=options.isolated_mode,
	290	)
	291	resolver.resolve(requirement_set)
	292
	293	# If caching is disabled or wheel is not installed don't
	294	# try to build wheels.
	295	if wheel and options.cache_dir:
	296	# build wheels before install.
	297	wb = WheelBuilder(
	298	finder, preparer, wheel_cache,
	299	build_options=[], global_options=[],
	300	)
	301	# Ignore the result: a failed wheel will be
	302	# installed from the sdist/vcs whatever.
	303	wb.build(
	304	requirement_set.requirements.values(),
	305	session=session, autobuilding=True
	306	)
	307
	308	to_install = resolver.get_installation_order(
	309	requirement_set
	310	)
	311
	312	# Consistency Checking of the package set we're installing.
	313	should_warn_about_conflicts = (
	314	not options.ignore_dependencies and
	315	options.warn_about_conflicts
	316	)
	317	if should_warn_about_conflicts:
	318	self._warn_about_conflicts(to_install)
	319
	320	# Don't warn about script install locations if
	321	# --target has been specified
	322	warn_script_location = options.warn_script_location
	323	if options.target_dir:
	324	warn_script_location = False
	325
	326	installed = install_given_reqs(
	327	to_install,
	328	install_options,
	329	global_options,
	330	root=options.root_path,
	331	home=target_temp_dir.path,
	332	prefix=options.prefix_path,
	333	pycompile=options.compile,
	334	warn_script_location=warn_script_location,
	335	use_user_site=options.use_user_site,
	336	)
	337
	338	possible_lib_locations = get_lib_location_guesses(
	339	user=options.use_user_site,
	340	home=target_temp_dir.path,
	341	root=options.root_path,
	342	prefix=options.prefix_path,
	343	isolated=options.isolated_mode,
	344	)
	345	reqs = sorted(installed, key=operator.attrgetter('name'))
	346	items = []
	347	for req in reqs:
	348	item = req.name
	349	try:
	350	installed_version = get_installed_version(
	351	req.name, possible_lib_locations
	352	)
	353	if installed_version:
	354	item += '-' + installed_version
	355	except Exception:
	356	pass
	357	items.append(item)
	358	installed = ' '.join(items)
	359	if installed:
	360	logger.info('Successfully installed %s', installed)
	361	except EnvironmentError as error:
	362	show_traceback = (self.verbosity >= 1)
	363
	364	message = create_env_error_message(
	365	error, show_traceback, options.use_user_site,
	366	)
	367	logger.error(message, exc_info=show_traceback)
	368
	369	return ERROR
	370	except PreviousBuildDirError:
	371	options.no_clean = True
	372	raise
	373	finally:
	374	# Clean up
	375	if not options.no_clean:
	376	requirement_set.cleanup_files()
	377	wheel_cache.cleanup()
	378
	379	if options.target_dir:
	380	self._handle_target_dir(
	381	options.target_dir, target_temp_dir, options.upgrade
	382	)
	383	return requirement_set
	384
	385	def _handle_target_dir(self, target_dir, target_temp_dir, upgrade):
	386	ensure_dir(target_dir)
	387
	388	# Checking both purelib and platlib directories for installed
	389	# packages to be moved to target directory
	390	lib_dir_list = []
	391
	392	with target_temp_dir:
	393	# Checking both purelib and platlib directories for installed
	394	# packages to be moved to target directory
	395	scheme = distutils_scheme('', home=target_temp_dir.path)
	396	purelib_dir = scheme['purelib']
	397	platlib_dir = scheme['platlib']
	398	data_dir = scheme['data']
	399
	400	if os.path.exists(purelib_dir):
	401	lib_dir_list.append(purelib_dir)
	402	if os.path.exists(platlib_dir) and platlib_dir != purelib_dir:
	403	lib_dir_list.append(platlib_dir)
	404	if os.path.exists(data_dir):
	405	lib_dir_list.append(data_dir)
	406
	407	for lib_dir in lib_dir_list:
	408	for item in os.listdir(lib_dir):
	409	if lib_dir == data_dir:
	410	ddir = os.path.join(data_dir, item)
	411	if any(s.startswith(ddir) for s in lib_dir_list[:-1]):
	412	continue
	413	target_item_dir = os.path.join(target_dir, item)
	414	if os.path.exists(target_item_dir):
	415	if not upgrade:
	416	logger.warning(
	417	'Target directory %s already exists. Specify '
	418	'--upgrade to force replacement.',
	419	target_item_dir
	420	)
	421	continue
	422	if os.path.islink(target_item_dir):
	423	logger.warning(
	424	'Target directory %s already exists and is '
	425	'a link. Pip will not automatically replace '
	426	'links, please remove if replacement is '
	427	'desired.',
	428	target_item_dir
	429	)
	430	continue
	431	if os.path.isdir(target_item_dir):
	432	shutil.rmtree(target_item_dir)
	433	else:
	434	os.remove(target_item_dir)
	435
	436	shutil.move(
	437	os.path.join(lib_dir, item),
	438	target_item_dir
	439	)
	440
	441	def _warn_about_conflicts(self, to_install):
	442	package_set, _dep_info = check_install_conflicts(to_install)
	443	missing, conflicting = _dep_info
	444
	445	# NOTE: There is some duplication here from pip check
	446	for project_name in missing:
	447	version = package_set[project_name][0]
	448	for dependency in missing[project_name]:
	449	logger.critical(
	450	"%s %s requires %s, which is not installed.",
	451	project_name, version, dependency[1],
	452	)
	453
	454	for project_name in conflicting:
	455	version = package_set[project_name][0]
	456	for dep_name, dep_version, req in conflicting[project_name]:
	457	logger.critical(
	458	"%s %s has requirement %s, but you'll have %s %s which is "
	459	"incompatible.",
	460	project_name, version, req, dep_name, dep_version,
	461	)
	462
	463
	464	def get_lib_location_guesses(args, *kwargs):
	465	scheme = distutils_scheme('', args, *kwargs)
	466	return [scheme['purelib'], scheme['platlib']]
	467
	468
	469	def create_env_error_message(error, show_traceback, using_user_site):
	470	"""Format an error message for an EnvironmentError
	471
	472	It may occur anytime during the execution of the install command.
	473	"""
	474	parts = []
	475
	476	# Mention the error if we are not going to show a traceback
	477	parts.append("Could not install packages due to an EnvironmentError")
	478	if not show_traceback:
	479	parts.append(": ")
	480	parts.append(str(error))
	481	else:
	482	parts.append(".")
	483
	484	# Spilt the error indication from a helper message (if any)
	485	parts[-1] += "\n"
	486
	487	# Suggest useful actions to the user:
	488	# (1) using user site-packages or (2) verifying the permissions
	489	if error.errno == errno.EACCES:
	490	user_option_part = "Consider using the `--user` option"
	491	permissions_part = "Check the permissions"
	492
	493	if not using_user_site:
	494	parts.extend([
	495	user_option_part, " or ",
	496	permissions_part.lower(),
	497	])
	498	else:
	499	parts.append(permissions_part)
	500	parts.append(".\n")
	501
	502	return "".join(parts).strip() + "\n"