def get_easy_install_cmd(self, build_only=False, **kwargs):
        """ Returns a correctly setup easy_install cmd class for passing
            into `pkglib.setuptools.buildout.install`.
            Lifted from `setuptools.dist`

            Parameters
            ----------
            build_only : `bool`
                Configured for build and testing packages - these will be installed into the
                directory returned from `pkglib.manage.get_build_egg_dir`

            kwargs:
                Other kwargs to pass to easy_install constructor

            Returns
            -------
            cmd : `setuptools.Command`
                Configured command-class
        """
        dist = self.distribution.__class__({'script_args': ['easy_install']})
        dist.parse_config_files()

        if build_only:
            cmd = easy_install(
                dist, args=["x"], install_dir=manage.get_build_egg_dir(), exclude_scripts=True,
                always_copy=False, build_directory=None, editable=False,
                upgrade=False, multi_version=True, no_report=True, **kwargs)
        else:
            cmd = easy_install(dist, args=['x'], **kwargs)

        cmd.ensure_finalized()
        return cmd

def install_scripts(distributions):
    """
    Regenerate the entry_points console_scripts for the named distribution.
    """
    try:
        if "__PEX_UNVENDORED__" in __import__("os").environ:
          from setuptools.command import easy_install  # vendor:skip
        else:
          from pex.third_party.setuptools.command import easy_install

        if "__PEX_UNVENDORED__" in __import__("os").environ:
          import pkg_resources  # vendor:skip
        else:
          import pex.third_party.pkg_resources as pkg_resources

    except ImportError:
        raise RuntimeError("'wheel install_scripts' needs setuptools.")

    for dist in distributions:
        pkg_resources_dist = pkg_resources.get_distribution(dist)
        install = get_install_command(dist)
        command = easy_install.easy_install(install.distribution)
        command.args = ['wheel']  # dummy argument
        command.finalize_options()
        command.install_egg_scripts(pkg_resources_dist)

	def fetch_build_egg(self, req):
		""" Specialized version of Distribution.fetch_build_egg
		that respects respects allow_hosts and index_url. """
		from setuptools.command.easy_install import easy_install
		dist = Distribution({'script_args': ['easy_install']})
		dist.parse_config_files()
		opts = dist.get_option_dict('easy_install')
		keep = (
			'find_links', 'site_dirs', 'index_url', 'optimize',
			'site_dirs', 'allow_hosts'
		)
		for key in list(opts):
			if key not in keep:
				del opts[key]  # don't use any other settings
		if self.dependency_links:
			links = self.dependency_links[:]
			if 'find_links' in opts:
				links = opts['find_links'][1].split() + links
			opts['find_links'] = ('setup', links)
		if self.allow_hosts:
			opts['allow_hosts'] = ('test', self.allow_hosts)
		if self.index_url:
			opts['index_url'] = ('test', self.index_url)
		install_dir_func = getattr(self, 'get_egg_cache_dir', _os.getcwd)
		install_dir = install_dir_func()
		cmd = easy_install(
			dist, args=["x"], install_dir=install_dir,
			exclude_scripts=True,
			always_copy=False, build_directory=None, editable=False,
			upgrade=False, multi_version=True, no_report=True, user=False
		)
		cmd.ensure_finalized()
		return cmd.easy_install(req)

def install_context(request, tmpdir, monkeypatch):
    """Fixture to set up temporary installation directory.
    """
    # Save old values so we can restore them.
    new_cwd = tmpdir.mkdir("cwd")
    user_base = tmpdir.mkdir("user_base")
    user_site = tmpdir.mkdir("user_site")
    install_dir = tmpdir.mkdir("install_dir")

    def fin():
        # undo the monkeypatch, particularly needed under
        # windows because of kept handle on cwd
        monkeypatch.undo()
        new_cwd.remove()
        user_base.remove()
        user_site.remove()
        install_dir.remove()

    request.addfinalizer(fin)

    # Change the environment and site settings to control where the
    # files are installed and ensure we do not overwrite anything.
    monkeypatch.chdir(new_cwd)
    monkeypatch.setattr(easy_install_pkg, "__file__", user_site.strpath)
    monkeypatch.setattr("site.USER_BASE", user_base.strpath)
    monkeypatch.setattr("site.USER_SITE", user_site.strpath)
    monkeypatch.setattr("sys.path", sys.path + [install_dir.strpath])
    monkeypatch.setenv("PYTHONPATH", os.path.pathsep.join(sys.path))

    # Set up the command for performing the installation.
    dist = Distribution()
    cmd = easy_install(dist)
    cmd.install_dir = install_dir.strpath
    return cmd

 def _build_egg_fetcher(self):
     """Build an egg fetcher that respects index_url and allow_hosts"""
     # modified from setuptools.dist:Distribution.fetch_build_egg
     from setuptools.command.easy_install import easy_install
     main_dist = self.distribution
     # construct a fake distribution to store the args for easy_install
     dist = main_dist.__class__({'script_args': ['easy_install']})
     dist.parse_config_files()
     opts = dist.get_option_dict('easy_install')
     keep = (
         'find_links', 'site_dirs', 'index_url', 'optimize',
         'site_dirs', 'allow_hosts'
     )
     for key in opts.keys():
         if key not in keep:
             del opts[key]   # don't use any other settings
     if main_dist.dependency_links:
         links = main_dist.dependency_links[:]
         if 'find_links' in opts:
             links = opts['find_links'][1].split() + links
         opts['find_links'] = ('setup', links)
     if self.allow_hosts:
         opts['allow_hosts'] = ('test', self.allow_hosts)
     if self.index_url:
         opts['index_url'] = ('test', self.index_url)
     install_dir_func = getattr(dist, 'get_egg_cache_dir', os.getcwd)
     install_dir = install_dir_func()
     cmd = easy_install(
         dist, args=["x"], install_dir=install_dir, exclude_scripts=True,
         always_copy=False, build_directory=None, editable=False,
         upgrade=False, multi_version=True, no_report = True
     )
     cmd.ensure_finalized()
     main_dist._egg_fetcher = cmd

 def test_install_site_py(self, tmpdir):
     dist = Distribution()
     cmd = ei.easy_install(dist)
     cmd.sitepy_installed = False
     cmd.install_dir = str(tmpdir)
     cmd.install_site_py()
     assert (tmpdir / 'site.py').exists()

def install_context(request, tmpdir, monkeypatch):
    """Fixture to set up temporary installation directory.
    """
    # Save old values so we can restore them.
    new_cwd = tmpdir.mkdir('cwd')
    user_base = tmpdir.mkdir('user_base')
    user_site = tmpdir.mkdir('user_site')
    install_dir = tmpdir.mkdir('install_dir')

    def fin():
        new_cwd.remove()
        user_base.remove()
        user_site.remove()
        install_dir.remove()
    request.addfinalizer(fin)

    # Change the environment and site settings to control where the
    # files are installed and ensure we do not overwrite anything.
    monkeypatch.chdir(new_cwd)
    monkeypatch.setattr(easy_install_pkg, '__file__', user_site.strpath)
    monkeypatch.setattr('site.USER_BASE', user_base.strpath)
    monkeypatch.setattr('site.USER_SITE', user_site.strpath)
    monkeypatch.setattr('sys.path', sys.path + [install_dir.strpath])
    monkeypatch.setenv('PYTHONPATH', os.path.pathsep.join(sys.path))

    # Set up the command for performing the installation.
    dist = Distribution()
    cmd = easy_install(dist)
    cmd.install_dir = install_dir.strpath
    return cmd

    def fetch_build_egg(self, req):
        """Fetch an egg needed for building"""
        try:
            cmd = self._egg_fetcher
        except AttributeError:
            from setuptools.command.easy_install import easy_install

            dist = self.__class__({"script_args": ["easy_install"]})
            dist.parse_config_files()
            opts = dist.get_option_dict("easy_install")
            keep = ("find_links", "site_dirs", "index_url", "optimize", "site_dirs", "allow_hosts")
            for key in opts.keys():
                if key not in keep:
                    del opts[key]  # don't use any other settings
            if self.dependency_links:
                links = self.dependency_links[:]
                if "find_links" in opts:
                    links = opts["find_links"][1].split() + links
                opts["find_links"] = ("setup", links)
            cmd = easy_install(
                dist,
                args=["x"],
                install_dir=os.curdir,
                exclude_scripts=True,
                always_copy=False,
                build_directory=None,
                editable=False,
                upgrade=False,
                multi_version=True,
                no_report=True,
            )
            cmd.ensure_finalized()
            self._egg_fetcher = cmd
        return cmd.easy_install(req)

    def fetch_build_egg(self, req):
        """Fetch an egg needed for building"""

        try:
            cmd = self._egg_fetcher
            cmd.package_index.to_scan = []
        except AttributeError:
            from setuptools.command.easy_install import easy_install
            dist = self.__class__({'script_args':['easy_install']})
            dist.parse_config_files()
            opts = dist.get_option_dict('easy_install')
            keep = (
                'find_links', 'site_dirs', 'index_url', 'optimize',
                'site_dirs', 'allow_hosts'
            )
            for key in list(opts.keys()):
                if key not in keep:
                    del opts[key]   # don't use any other settings
            if self.dependency_links:
                links = self.dependency_links[:]
                if 'find_links' in opts:
                    links = opts['find_links'][1].split() + links
                opts['find_links'] = ('setup', links)
            cmd = easy_install(
                dist, args=["x"], install_dir=os.curdir, exclude_scripts=True,
                always_copy=False, build_directory=None, editable=False,
                upgrade=False, multi_version=True, no_report=True, user=False
            )
            cmd.ensure_finalized()
            self._egg_fetcher = cmd
        return cmd.easy_install(req)

 def fetch_build_egg(self, req):
     """Fetch an egg needed for building"""
     from setuptools.command.easy_install import easy_install
     dist = self.__class__({'script_args': ['easy_install']})
     opts = dist.get_option_dict('easy_install')
     opts.clear()
     opts.update(
         (k, v)
         for k, v in self.get_option_dict('easy_install').items()
         if k in (
             # don't use any other settings
             'find_links', 'site_dirs', 'index_url',
             'optimize', 'site_dirs', 'allow_hosts',
         ))
     if self.dependency_links:
         links = self.dependency_links[:]
         if 'find_links' in opts:
             links = opts['find_links'][1] + links
         opts['find_links'] = ('setup', links)
     install_dir = self.get_egg_cache_dir()
     cmd = easy_install(
         dist, args=["x"], install_dir=install_dir,
         exclude_scripts=True,
         always_copy=False, build_directory=None, editable=False,
         upgrade=False, multi_version=True, no_report=True, user=False
     )
     cmd.ensure_finalized()
     return cmd.easy_install(req)

    def test_local_index(self):
        # make sure the local index is used
        # when easy_install looks for installed
        # packages
        new_location = tempfile.mkdtemp()
        target = tempfile.mkdtemp()
        egg_file = os.path.join(new_location, 'foo-1.0.egg-info')
        f = open(egg_file, 'w')
        try:
            f.write('Name: foo\n')
        except:
            f.close()

        sys.path.append(target)
        old_ppath = os.environ.get('PYTHONPATH')
        os.environ['PYTHONPATH'] = ':'.join(sys.path)
        try:
            dist = Distribution()
            dist.script_name = 'setup.py'
            cmd = easy_install(dist)
            cmd.install_dir = target
            cmd.args = ['foo']
            cmd.ensure_finalized()
            cmd.local_index.scan([new_location])
            res = cmd.easy_install('foo')
            self.assertEquals(res.location, new_location)
        finally:
            sys.path.remove(target)
            shutil.rmtree(new_location)
            shutil.rmtree(target)
            if old_ppath is not None:
                os.environ['PYTHONPATH'] = old_ppath
            else:
                del os.environ['PYTHONPATH']

 def assert_not_user_site():
     # create a finalized easy_install command
     dist = Distribution()
     dist.script_name = 'setup.py'
     cmd = ei.easy_install(dist)
     cmd.args = ['py']
     cmd.ensure_finalized()
     assert not cmd.user, 'user should not be implied'

 def test_write_exception(self):
     """
     Test that `cant_write_to_target` is rendered as a DistutilsError.
     """
     dist = Distribution()
     cmd = ei.easy_install(dist)
     cmd.install_dir = os.getcwd()
     with pytest.raises(distutils.errors.DistutilsError):
         cmd.cant_write_to_target()

 def test_user_install_implied(self):
     site.ENABLE_USER_SITE = True # disabled sometimes
     #XXX: replace with something meaningfull
     dist = Distribution()
     dist.script_name = 'setup.py'
     cmd = easy_install(dist)
     cmd.args = ['py']
     cmd.ensure_finalized()
     self.assertTrue(cmd.user, 'user should be implied')

 def test_user_install_not_implied_without_usersite_enabled(self):
     site.ENABLE_USER_SITE = False # usually enabled
     #XXX: replace with something meaningfull
     dist = Distribution()
     dist.script_name = 'setup.py'
     cmd = easy_install(dist)
     cmd.args = ['py']
     cmd.initialize_options()
     assert not cmd.user, 'NOT user should be implied'

 def fetch_build_egg(self, req):
     try:
         cmd = self._egg_fetcher
     except AttributeError:
         dist = self.__class__({'script_args': ['easy_install']})
         dist.parse_config_files()
         cmd = easy_install.easy_install(dist, args=['x'],
                                         index_url=get_index_url())
         cmd.ensure_finalized()
         self._egg_fetcher = cmd
     return cmd.easy_install(req)

 def test_install_site_py(self):
     dist = Distribution()
     cmd = easy_install(dist)
     cmd.sitepy_installed = False
     cmd.install_dir = tempfile.mkdtemp()
     try:
         cmd.install_site_py()
         sitepy = os.path.join(cmd.install_dir, 'site.py')
         self.assertTrue(os.path.exists(sitepy))
     finally:
         shutil.rmtree(cmd.install_dir)

 def test_user_install_not_implied_without_usersite_enabled(self):
     easy_install_pkg.HAS_USER_SITE = False # usually enabled
     #XXX: replace with something meaningfull
     if sys.version < "2.6":
         return #SKIP
     dist = Distribution()
     dist.script_name = 'setup.py'
     cmd = easy_install(dist)
     cmd.args = ['py']
     cmd.initialize_options()
     self.assertFalse(cmd.user, 'NOT user should be implied')

 def test_user_install_implied(self):
     easy_install_pkg.HAS_USER_SITE = True # disabled sometimes
     #XXX: replace with something meaningfull
     if sys.version < "2.6":
         return #SKIP
     dist = Distribution()
     dist.script_name = 'setup.py'
     cmd = easy_install(dist)
     cmd.args = ['py']
     cmd.ensure_finalized()
     self.assertTrue(cmd.user, 'user should be implied')

 def test_unicode_content_in_sdist(
         self, sdist_unicode_in_script, tmpdir, monkeypatch):
     """
     The install command should execute correctly even if
     the package has unicode in scripts.
     """
     dist = Distribution({"script_args": ["easy_install"]})
     target = (tmpdir / "target").ensure_dir()
     cmd = ei.easy_install(dist, install_dir=str(target), args=["x"])
     monkeypatch.setitem(os.environ, "PYTHONPATH", str(target))
     cmd.ensure_finalized()
     cmd.easy_install(sdist_unicode_in_script)