예제 #1
0
def install_requirements():
    from pip.commands.install import InstallCommand
    from pkg_resources import ContextualVersionConflict

    requirements = [
        os.path.abspath(
            os.path.join(os.path.dirname(__file__), 'requirements.txt'))
    ]
    options = InstallCommand().parse_args([])[0]
    options.use_user_site = root_check() and not virtualenv_check()
    options.requirements = requirements
    options.cache_dir = None
    options.upgrade = True
    options.quiet = 1
    options.pre = True

    # install/upgrade all requirements for sickrage
    print("Installing SiCKRAGE requirement packages, please stand by ...")

    attempts = 0
    while attempts < 3:
        try:
            options.ignore_dependencies = True
            InstallCommand().run(options, [])
            options.ignore_dependencies = False
            InstallCommand().run(options, [])
        except ContextualVersionConflict:
            attempts += 1
            time.sleep(1)
        finally:
            break
예제 #2
0
def package_finder(argv):
    """Return a PackageFinder respecting command-line options.

    :arg argv: Everything after the subcommand

    """
    # We instantiate an InstallCommand and then use some of its private
    # machinery--its arg parser--for our own purposes, like a virus. This
    # approach is portable across many pip versions, where more fine-grained
    # ones are not. Ignoring options that don't exist on the parser (for
    # instance, --use-wheel) gives us a straightforward method of backward
    # compatibility.
    try:
        command = InstallCommand()
    except TypeError:
        # This is likely pip 1.3.0's "__init__() takes exactly 2 arguments (1
        # given)" error. In that version, InstallCommand takes a top=level
        # parser passed in from outside.
        from pip.baseparser import create_main_parser
        command = InstallCommand(create_main_parser())
    # The downside is that it essentially ruins the InstallCommand class for
    # further use. Calling out to pip.main() within the same interpreter, for
    # example, would result in arguments parsed this time turning up there.
    # Thus, we deepcopy the arg parser so we don't trash its singletons. Of
    # course, deepcopy doesn't work on these objects, because they contain
    # uncopyable regex patterns, so we pickle and unpickle instead. Fun!
    options, _ = loads(dumps(command.parser)).parse_args(argv)

    # Carry over PackageFinder kwargs that have [about] the same names as
    # options attr names:
    possible_options = [
        'find_links', 'use_wheel', 'allow_external',
        'allow_unverified', 'allow_all_external',
        ('allow_all_prereleases', 'pre'), 'process_dependency_links'
    ]
    kwargs = {}
    for option in possible_options:
        kw, attr = option if isinstance(option, tuple) else (option, option)
        value = getattr(options, attr, MARKER)
        if value is not MARKER:
            kwargs[kw] = value

    # Figure out index_urls:
    index_urls = [options.index_url] + options.extra_index_urls
    if options.no_index:
        index_urls = []
    index_urls += getattr(options, 'mirrors', [])

    # If pip is new enough to have a PipSession, initialize one, since
    # PackageFinder requires it:
    if hasattr(command, '_build_session'):
        kwargs['session'] = command._build_session(options)

    return PackageFinder(index_urls=index_urls, **kwargs)
예제 #3
0
def install(reqs,
            index_urls=None,
            upgrade=False,
            pre_releases=False,
            no_cache=False,
            reinstall=False):
    _ensure_patch_pip_get_entry_points()
    cmd = InstallCommand()
    args = []
    if pre_releases:
        args.append("--pre")
    if not virtualenv_no_global():
        args.append("--user")
    if upgrade:
        args.append("--upgrade")
    if no_cache:
        args.append("--no-cache-dir")
    if reinstall:
        args.append("--force-reinstall")
    if index_urls:
        args.extend(["--index-url", index_urls[0]])
        for url in index_urls[1:]:
            args.extend(["--extra-index-url", url])
    args.extend(reqs)
    options, cmd_args = cmd.parse_args(args)
    try:
        cmd.run(options, cmd_args)
    except InstallationError as e:
        raise InstallError(str(e))
예제 #4
0
def install_missing_requirements(module):
    """
    Some of the modules require external packages to be installed. This gets
    the list from the `REQUIREMENTS` module attribute and attempts to
    install the requirements using pip.
    :param module: GPIO module
    :type module: ModuleType
    :return: None
    :rtype: NoneType
    """
    reqs = getattr(module, "REQUIREMENTS", [])
    if not reqs:
        _LOG.info("Module %r has no extra requirements to install." % module)
        return
    import pkg_resources
    pkgs_installed = pkg_resources.WorkingSet()
    pkgs_required = []
    for req in reqs:
        if pkgs_installed.find(pkg_resources.Requirement.parse(req)) is None:
            pkgs_required.append(req)
    if pkgs_required:
        from pip.commands.install import InstallCommand
        from pip.status_codes import SUCCESS
        cmd = InstallCommand()
        result = cmd.main(pkgs_required)
        if result != SUCCESS:
            raise CannotInstallModuleRequirements(
                "Unable to install packages for module %r (%s)..." %
                (module, pkgs_required))
예제 #5
0
 def activate(self, leaf):
     params = get_params()
     if 'name' in leaf.object:
         params.append(leaf.object['name'])
     else:
         params.append(str(leaf.object))
     InstallCommand().main(params)
예제 #6
0
def check():
    # find missing packages
    from importlib.util import find_spec
    missing = [
        requirement for requirement in requirements
        if not (find_spec(requirement))
    ]
    if not missing:
        return
    # install missing packages
    sys.stdout.write("Installing" + ','.join(missing) + ".\n")
    # redirect out to nothing so no installing messages will be seen.
    sys_stdout = sys.stdout
    sys_stderr = sys.stderr
    sys.stdout = None
    sys.stderr = None
    from pip.commands.install import InstallCommand
    from pip.status_codes import SUCCESS
    cmd = InstallCommand()
    for requirement in requirements:
        try:
            if cmd.main([requirement]) is not SUCCESS:
                sys_stderr.write("Can not install " + requirement +
                                 ", program aborts.\n")
                sys.exit()
        # this might occur because of redirection of stdout and stderr
        except AttributeError:
            pass
    # direct out back to normal
    sys.stdout = sys_stdout
    sys.stderr = sys_stderr
    sys.stdout.write("All packages are installed, starting game...")
    sys.stdout.flush()
예제 #7
0
    def test_installed_files_tracking(self):
        """
        Verify that tracking of installed files works correctly.

        This tests the :py:func:`~pip_accel.bdist.BinaryDistributionManager.update_installed_files()`
        method.

        When pip installs a Python package it also creates a file called
        ``installed-files.txt`` that contains the pathnames of the files that
        were installed. This file enables pip to uninstall Python packages
        later on. Because pip-accel implements its own package installation it
        also creates the ``installed-files.txt`` file, in order to enable the
        user to uninstall a package with pip even if the package was installed
        using pip-accel.
        """
        # Prevent unsuspecting users from accidentally running the find_files()
        # tests below on their complete `/usr' or `/usr/local' tree :-).
        if not hasattr(sys, 'real_prefix'):
            logger.warning("Skipping installed files tracking test (not running in a recognized virtual environment).")
            return
        # Install the iPython 1.0 source distribution using pip.
        command = InstallCommand()
        opts, args = command.parse_args([
            '--ignore-installed', '--no-use-wheel', 'ipython==1.0'
        ])
        command.run(opts, args)
        # Make sure the iPython program works after installation using pip.
        try_program('ipython3' if sys.version_info[0] == 3 else 'ipython')
        # Find the iPython related files installed by pip.
        files_installed_using_pip = set(find_files(sys.prefix, 'ipython'))
        assert len(files_installed_using_pip) > 0, \
            "It looks like pip didn't install iPython where we expected it to do so?!"
        logger.debug("Found %i files installed using pip: %s",
                     len(files_installed_using_pip), files_installed_using_pip)
        # Remove the iPython installation.
        uninstall('ipython')
        # Install the iPython 1.0 source distribution using pip-accel.
        accelerator = self.initialize_pip_accel()
        num_installed = accelerator.install_from_arguments([
            '--ignore-installed', '--no-use-wheel', 'ipython==1.0'
        ])
        assert num_installed == 1, "Expected pip-accel to install exactly one package!"
        # Make sure the iPython program works after installation using pip-accel.
        try_program('ipython3' if sys.version_info[0] == 3 else 'ipython')
        # Find the iPython related files installed by pip-accel.
        files_installed_using_pip_accel = set(find_files(sys.prefix, 'ipython'))
        assert len(files_installed_using_pip_accel) > 0, \
            "It looks like pip-accel didn't install iPython where we expected it to do so?!"
        logger.debug("Found %i files installed using pip-accel: %s",
                     len(files_installed_using_pip_accel), files_installed_using_pip_accel)
        # Test that pip and pip-accel installed exactly the same files.
        assert files_installed_using_pip == files_installed_using_pip_accel, \
            "It looks like pip and pip-accel installed different files for iPython!"
        # Test that pip knows how to uninstall iPython installed by pip-accel
        # due to the installed-files.txt file generated by pip-accel.
        uninstall('ipython')
        # Make sure all files related to iPython were uninstalled by pip.
        assert len(list(find_files(sys.prefix, 'ipython'))) == 0, \
            "It looks like pip didn't properly uninstall iPython after installation using pip-accel!"
예제 #8
0
def _pip_needs_system():
    """Determine whether pip3 defaults to --user, needing --system to turn it off."""
    try:
        from pip.commands.install import InstallCommand
        return InstallCommand().cmd_opts.get_option('--system') is not None
    except (ImportError, AttributeError, TypeError):
        # probably not the bionic pip version then
        return False
예제 #9
0
    def install(params):
        """
        Install third-party Mod
        """
        from pip import main as pip_main
        from pip.commands.install import InstallCommand

        params = [param for param in params]

        options, mod_list = InstallCommand().parse_args(params)

        params = ["install"] + params

        for mod_name in mod_list:
            mod_name_index = params.index(mod_name)
            if mod_name.startswith("rqalpha_mod_sys_"):
                six.print_('System Mod can not be installed or uninstalled')
                return
            if "rqalpha_mod_" in mod_name:
                lib_name = mod_name
            else:
                lib_name = "rqalpha_mod_" + mod_name
            params[mod_name_index] = lib_name

        # Install Mod
        installed_result = pip_main(params)

        # Export config
        mod_config_path = get_mod_config_path(generate=True)
        mod_config = load_mod_config(mod_config_path, loader=yaml.Loader)

        if installed_result == 0:
            # 如果为0,则说明安装成功
            if len(mod_list) == 0:
                """
                主要是方便 `pip install -e .` 这种方式 本地调试 Mod 使用,需要满足以下条件:
                1.  `rqalpha mod install -e .` 命令是在对应 自定义 Mod 的根目录下
                2.  该 Mod 必须包含 `setup.py` 文件(否则也不能正常的 `pip install -e .` 来安装)
                3.  该 Mod 包名必须按照 RQAlpha 的规范来命名,具体规则如下
                    *   必须以 `rqalpha-mod-` 来开头,比如 `rqalpha-mod-xxx-yyy`
                    *   对应import的库名必须要 `rqalpha_mod_` 来开头,并且需要和包名后半部分一致,但是 `-` 需要替换为 `_`, 比如 `rqalpha_mod_xxx_yyy`
                """
                mod_name = _detect_package_name_from_dir()
                mod_name = mod_name.replace("-",
                                            "_").replace("rqalpha_mod_", "")
                mod_list.append(mod_name)

            for mod_name in mod_list:
                if "rqalpha_mod_" in mod_name:
                    mod_name = mod_name.replace("rqalpha_mod_", "")
                if "==" in mod_name:
                    mod_name = mod_name.split('==')[0]
                mod_config['mod'][mod_name] = {}
                mod_config['mod'][mod_name]['enabled'] = False

            dump_config(mod_config_path, mod_config)
        list({})
        return installed_result
예제 #10
0
    def install_requirements(self, requirements, **kw):
        """
        Manually install a requirement set from binary and/or wheel distributions.

        :param requirements: A list of :class:`pip_accel.req.Requirement` objects.
        :param kw: Any keyword arguments are passed on to
                   :func:`~pip_accel.bdist.BinaryDistributionManager.install_binary_dist()`.
        :returns: The number of packages that were just installed (an integer).
        """
        install_timer = Timer()
        install_types = []
        if any(not req.is_wheel for req in requirements):
            install_types.append('binary')
        if any(req.is_wheel for req in requirements):
            install_types.append('wheel')
        logger.info("Installing from %s distributions ..",
                    concatenate(install_types))
        # Track installed files by default (unless the caller specifically opted out).
        kw.setdefault('track_installed_files', True)
        num_installed = 0
        for requirement in requirements:
            # If we're upgrading over an older version, first remove the
            # old version to make sure we don't leave files from old
            # versions around.
            if is_installed(requirement.name):
                uninstall(requirement.name)
            # When installing setuptools we need to uninstall distribute,
            # otherwise distribute will shadow setuptools and all sorts of
            # strange issues can occur (e.g. upgrading to the latest
            # setuptools to gain wheel support and then having everything
            # blow up because distribute doesn't know about wheels).
            if requirement.name == 'setuptools' and is_installed('distribute'):
                uninstall('distribute')
            if requirement.is_editable:
                logger.debug("Installing %s in editable form using pip.",
                             requirement)
                command = InstallCommand()
                opts, args = command.parse_args(
                    ['--no-deps', '--editable', requirement.source_directory])
                command.run(opts, args)
            elif requirement.is_wheel:
                logger.info("Installing %s wheel distribution using pip ..",
                            requirement)
                wheel_version = pip_wheel_module.wheel_version(
                    requirement.source_directory)
                pip_wheel_module.check_compatibility(wheel_version,
                                                     requirement.name)
                requirement.pip_requirement.move_wheel_files(
                    requirement.source_directory)
            else:
                binary_distribution = self.bdists.get_binary_dist(requirement)
                self.bdists.install_binary_dist(binary_distribution, **kw)
            num_installed += 1
        logger.info("Finished installing %s in %s.",
                    pluralize(num_installed, "requirement"), install_timer)
        return num_installed
예제 #11
0
 def install_package(self, packages, params=None):
     # type: (str, Optional[str]) -> int
     try:
         # For pip <= 19.1.1
         install = InstallCommand()
     except TypeError:
         # For pip > 19.1.1
         install = InstallCommand("Pippel",
                                  "Backend server for the Pippel service.")
     assert packages, "`packages` should not be an empty string."
     for package in packages.split():
         if self.in_virtual_env():
             args = [package, "--upgrade"]
         elif params:
             args = [package, "--upgrade", "--target", params]
         else:
             args = [package, "--upgrade", "--user"]
         k = install.main(args)
     return k
예제 #12
0
 def install_package(self, packages):
     install = InstallCommand()
     pkg_list = packages.split(" ")
     for pkg in pkg_list:
         # virtualenv active ?
         if hasattr(sys, 'real_prefix'):
             options, args = install.parse_args([pkg, '--upgrade'])
         else:
             options, args = install.parse_args(
                 [pkg, '--upgrade', '--user'])
         install.run(options, args)
예제 #13
0
def install(reqs, index_urls=None, upgrade=False):
    cmd = InstallCommand()
    args = ["--user"]
    if upgrade:
        args.append("--upgrade")
    if index_urls:
        args.append("--index-url", index_urls[0])
        for url in index_urls[1:]:
            args.append("--extra-index-url", url)
    args.extend(reqs)
    cmd.run(*cmd.parse_args(args))
예제 #14
0
    def update(self):
        """
        Performs pip upgrade
        """
        # Notify update successful
        sickrage.srCore.srLogger.info("Updating SiCKRAGE from PyPi servers")
        srNotifiers.notify_version_update(sickrage.srCore.NEWEST_VERSION_STRING)

        from pip.commands.install import InstallCommand
        options = InstallCommand().parse_args([])[0]
        options.use_user_site = all([not sickrage.isElevatedUser(), not sickrage.isVirtualEnv()])
        options.cache_dir = None
        options.upgrade = True
        options.quiet = 1

        options.ignore_dependencies = True
        InstallCommand().run(options, ['sickrage'])
        options.ignore_dependencies = False
        InstallCommand().run(options, ['sickrage'])

        return True
예제 #15
0
파일: test_req.py 프로젝트: eternal1025/pip
 def test_missing_hash_with_require_hashes_in_reqs_file(self, data, tmpdir):
     """--require-hashes in a requirements file should make its way to the
     RequirementSet.
     """
     req_set = self.basic_reqset(require_hashes=False)
     session = PipSession()
     finder = PackageFinder([data.find_links], [], session=session)
     command = InstallCommand()
     with requirements_file('--require-hashes', tmpdir) as reqs_file:
         options, args = command.parse_args(['-r', reqs_file])
         command.populate_requirement_set(
             req_set, args, options, finder, session, command.name,
             wheel_cache=None)
     assert req_set.require_hashes
예제 #16
0
def install(params):
    """
    Install third-party Mod
    """
    from pip import main as pip_main
    from pip.commands.install import InstallCommand

    params = [param for param in params]

    options, mod_list = InstallCommand().parse_args(params)

    params = ["install"] + params

    for mod_name in mod_list:
        mod_name_index = params.index(mod_name)
        if mod_name in system_mod:
            print('System Mod can not be installed or uninstalled')
            return
        if "rqalpha_mod_" in mod_name:
            lib_name = mod_name
            mod_name = lib_name.replace("rqalpha_mod_", "")
        else:
            lib_name = "rqalpha_mod_" + mod_name
        params[mod_name_index] = lib_name

    # Install Mod
    pip_main(params)

    # Export config
    config_path = get_default_config_path()
    config = load_config(config_path, loader=yaml.RoundTripLoader)

    for mod_name in mod_list:
        if "rqalpha_mod_" in mod_name:
            lib_name = mod_name
            mod_name = lib_name.replace("rqalpha_mod_", "")
        else:
            lib_name = "rqalpha_mod_" + mod_name

        mod = import_module(lib_name)

        mod_config = yaml.load(mod.__mod_config__, yaml.RoundTripLoader)

        config['mod'][mod_name] = mod_config
        config['mod'][mod_name]['lib'] = lib_name
        config['mod'][mod_name]['enabled'] = False
        config['mod'][mod_name]['priority'] = 1000

    dump_config(config_path, config)
예제 #17
0
 def install(self, **opts):
     """Call on pip to install the package if not yet installed"""
     installed, new_style, ivers = self.test_installed()
     if installed:
         return True
     if not self.pip_url:
         raise Exception('The plugin author did not provide an automatic install link')
     from pip.commands.install import InstallCommand
     ic = InstallCommand()
     opts, args = ic.parser.parse_args()
     args.append(self.pip_url)
     for k, v in opts.__dict__.iteritems():
         setattr(opts, k, v)
     req_set = ic.run(opts, args)
     req_set.install(opts)
     return self.test_installed()
예제 #18
0
 def _update_pyxelrest(self):
     self.updating_queue.put((PYTHON_STEP, IN_PROGRESS))
     result = InstallCommand().main([
         'pyxelrest', '--upgrade', '--disable-pip-version-check', '--log',
         default_log_file_path, '--pre'
     ])
     create_logger()  # PyxelRest logger is lost while trying to update
     if result == 0:
         self.updating_queue.put((PYTHON_STEP, DONE))
         logger.info('PyxelRest package updated.')
         if self._update_addin():
             # Only perform configuration update when we are sure that latest version is installed
             self._update_configuration()
     else:
         logger.warning('PyxelRest package update failed.')
         self.updating_queue.put((PYTHON_STEP, FAILURE))
예제 #19
0
파일: __init__.py 프로젝트: gbsnaker/confp
def install_missing_requirements(module):
    """
    Some of the modules require external packages to be installed. This gets
    the list from the `REQUIREMENTS` module attribute and attempts to
    install the requirements using pip.
    :param module: Backend module
    :type module: ModuleType
    :return: None
    :rtype: NoneType
    """
    reqs = getattr(module, "REQUIREMENTS", [])
    if not reqs:
        print("Module %r has no extra requirements to install." % module)
        return
    import pkg_resources
    pkgs_installed = pkg_resources.WorkingSet()
    pkgs_required = []
    for req in reqs:
        if req.startswith("git+"):
            url = urlparse(req)
            params = {
                x[0]: x[1]
                for x in map(lambda y: y.split('='), url.fragment.split('&'))
            }
            try:
                pkg = params["egg"]
            except KeyError:
                raise CannotInstallModuleRequirements(
                    "Package %r in module %r must include '#egg=<pkgname>'" %
                    (req, module))
        else:
            pkg = req
        if pkgs_installed.find(pkg_resources.Requirement.parse(pkg)) is None:
            pkgs_required.append(req)
    if pkgs_required:
        from pip.commands.install import InstallCommand
        from pip.status_codes import SUCCESS
        cmd = InstallCommand()
        result = cmd.main(pkgs_required)
        if result != SUCCESS:
            raise CannotInstallModuleRequirements(
                "Unable to install packages for module %r (%s)..." %
                (module, pkgs_required))
예제 #20
0
    def install(params):
        """
        Install third-party Mod
        """
        from pip import main as pip_main
        from pip.commands.install import InstallCommand

        params = [param for param in params]

        options, mod_list = InstallCommand().parse_args(params)

        params = ["install"] + params

        for mod_name in mod_list:
            mod_name_index = params.index(mod_name)
            if mod_name.startswith("rqalpha_mod_sys_"):
                print('System Mod can not be installed or uninstalled')
                return
            if "rqalpha_mod_" in mod_name:
                lib_name = mod_name
                mod_name = lib_name.replace("rqalpha_mod_", "")
            else:
                lib_name = "rqalpha_mod_" + mod_name
            params[mod_name_index] = lib_name

        # Install Mod
        pip_main(params)

        # Export config
        mod_config_path = get_default_config_path("mod_config")
        mod_config = load_config(mod_config_path,
                                 loader=yaml.RoundTripLoader,
                                 verify_version=False)

        for mod_name in mod_list:
            mod_config['mod'][mod_name] = {}
            mod_config['mod'][mod_name]['enabled'] = False

        dump_config(mod_config_path, mod_config)
        list({})
예제 #21
0
파일: pip-date.py 프로젝트: lucywi/spaCy
if installed_packages:
    pip = UninstallCommand()
    options, args = pip.parse_args(installed_packages)
    options.yes = True

    try:
        pip.run(options, args)
    except OSError as e:
        if e.errno != 13:
            raise e
        print("You lack permissions to uninstall this package. Perhaps run with sudo? Exiting.")
        exit(13)


date = parse_iso8601(sys.argv[1])
packages = {p: select_version(date, p) for p in sys.argv[2:]}
args = ['=='.join(a) for a in packages.items()]

cmd = InstallCommand()
options, args = cmd.parse_args(args)
options.ignore_installed = True
options.force_reinstall = True

try:
    print(cmd.run(options, args))
except OSError as e:
    if e.errno != 13:
        raise e
    print("You lack permissions to uninstall this package. Perhaps run with sudo? Exiting.")
    exit(13)
예제 #22
0
    def get_pip_requirement_set(self, arguments, use_remote_index, use_wheels=False):
        """
        Get the unpacked requirement(s) specified by the caller by running pip.

        :param arguments: The command line arguments to ``pip install ..`` (a
                          list of strings).
        :param use_remote_index: A boolean indicating whether pip is allowed to
                                 connect to the main package index
                                 (http://pypi.python.org by default).
        :param use_wheels: Whether pip and pip-accel are allowed to use wheels_
                           (``False`` by default for backwards compatibility
                           with callers that use pip-accel as a Python API).
        :returns: A :py:class:`pip.req.RequirementSet` object created by pip.
        :raises: Any exceptions raised by pip.
        """
        # Compose the pip command line arguments. This is where a lot of the
        # core logic of pip-accel is hidden and it uses some esoteric features
        # of pip so this method is heavily commented.
        command_line = []
        # Use `--download' to instruct pip to download requirement(s) into
        # pip-accel's local source distribution index directory. This has the
        # following documented side effects (see `pip install --help'):
        #  1. It disables the installation of requirements (without using the
        #     `--no-install' option which is deprecated and slated for removal
        #     in pip 7.x).
        #  2. It ignores requirements that are already installed (because
        #     pip-accel doesn't actually need to re-install requirements that
        #     are already installed we will have work around this later, but
        #     that seems fairly simple to do).
        command_line.append('--download=%s' % self.config.source_index)
        # Use `--find-links' to point pip at pip-accel's local source
        # distribution index directory. This ensures that source distribution
        # archives are never downloaded more than once (regardless of the HTTP
        # cache that was introduced in pip 6.x).
        command_line.append('--find-links=file://%s' % self.config.source_index)
        # Use `--no-use-wheel' to ignore wheel distributions by default in
        # order to preserve backwards compatibility with callers that expect a
        # requirement set consisting only of source distributions that can be
        # converted to `dumb binary distributions'.
        if not use_wheels and '--no-use-wheel' not in arguments:
            command_line.append('--no-use-wheel')
        # Use `--no-index' to force pip to only consider source distribution
        # archives contained in pip-accel's local source distribution index
        # directory. This enables pip-accel to ask pip "Can the local source
        # distribution index satisfy all requirements in the given requirement
        # set?" which enables pip-accel to keep pip off the internet unless
        # absolutely necessary :-).
        if not use_remote_index:
            command_line.append('--no-index')
        # Use `--no-clean' to instruct pip to unpack the source distribution
        # archives and *not* clean up the unpacked source distributions
        # afterwards. This enables pip-accel to replace pip's installation
        # logic with cached binary distribution archives.
        command_line.append('--no-clean')
        # Use `--build-directory' to instruct pip to unpack the source
        # distribution archives to a temporary directory managed by pip-accel.
        # We will clean up the build directory when we're done using the
        # unpacked source distributions.
        command_line.append('--build-directory=%s' % self.build_directory)
        # Append the user's `pip install ...' arguments to the command line
        # that we just assembled.
        command_line.extend(arguments)
        logger.info("Executing command: pip install %s", ' '.join(command_line))
        # Clear the build directory to prevent PreviousBuildDirError exceptions.
        self.clear_build_directory()
        # During the pip 6.x upgrade pip-accel switched to using `pip install
        # --download' which can produce an interactive prompt as described in
        # issue 51 [1]. The documented way [2] to get rid of this interactive
        # prompt is pip's --exists-action option, but due to what is most
        # likely a bug in pip this doesn't actually work. The environment
        # variable $PIP_EXISTS_ACTION does work however, so if the user didn't
        # set it we will set a reasonable default for them.
        # [1] https://github.com/paylogic/pip-accel/issues/51
        # [2] https://pip.pypa.io/en/latest/reference/pip.html#exists-action-option
        os.environ.setdefault('PIP_EXISTS_ACTION', 'w')
        # Initialize and run the `pip install' command.
        command = InstallCommand()
        opts, args = command.parse_args(command_line)
        if not opts.ignore_installed:
            # If the user didn't supply the -I, --ignore-installed option we
            # will forcefully disable the option. Refer to the documentation of
            # the AttributeOverrides class for further details.
            opts = AttributeOverrides(opts, ignore_installed=False)
        requirement_set = command.run(opts, args)
        # Make sure the output of pip and pip-accel are not intermingled.
        sys.stdout.flush()
        if requirement_set is None:
            raise NothingToDoError("""
                pip didn't generate a requirement set, most likely you
                specified an empty requirements file?
            """)
        else:
            return self.transform_pip_requirement_set(requirement_set)