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 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 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 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 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 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 _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 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): """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 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 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_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 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 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_install_site_py(self): dist = Distribution() cmd = ei.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') assert 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)
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)
def test_no_find_links(self): # new option '--no-find-links', that blocks find-links added at # the project level dist = Distribution() cmd = ei.easy_install(dist) cmd.check_pth_processing = lambda: True cmd.no_find_links = True cmd.find_links = ['link1', 'link2'] cmd.install_dir = os.path.join(tempfile.mkdtemp(), 'ok') cmd.args = ['ok'] cmd.ensure_finalized() assert cmd.package_index.scanned_urls == {} # let's try without it (default behavior) cmd = ei.easy_install(dist) cmd.check_pth_processing = lambda: True cmd.find_links = ['link1', 'link2'] cmd.install_dir = os.path.join(tempfile.mkdtemp(), 'ok') cmd.args = ['ok'] cmd.ensure_finalized() keys = sorted(cmd.package_index.scanned_urls.keys()) assert keys == ['link1', 'link2']
def test_no_find_links(self): # new option '--no-find-links', that blocks find-links added at # the project level dist = Distribution() cmd = ei.easy_install(dist) cmd.check_pth_processing = lambda: True cmd.no_find_links = True cmd.find_links = ['link1', 'link2'] cmd.install_dir = os.path.join(tempfile.mkdtemp(), 'ok') cmd.args = ['ok'] cmd.ensure_finalized() assert cmd.package_index.scanned_urls == {} # let's try without it (default behavior) cmd = ei.easy_install(dist) cmd.check_pth_processing = lambda: True cmd.find_links = ['link1', 'link2'] cmd.install_dir = os.path.join(tempfile.mkdtemp(), 'ok') cmd.args = ['ok'] cmd.ensure_finalized() keys = sorted(cmd.package_index.scanned_urls.keys()) assert keys == ['link1', 'link2']
def test_no_find_links(self): # new option '--no-find-links', that blocks find-links added at # the project level dist = Distribution() cmd = easy_install(dist) cmd.check_pth_processing = lambda: True cmd.no_find_links = True cmd.find_links = ["link1", "link2"] cmd.install_dir = os.path.join(tempfile.mkdtemp(), "ok") cmd.args = ["ok"] cmd.ensure_finalized() self.assertEquals(cmd.package_index.scanned_urls, {}) # let's try without it (default behavior) cmd = easy_install(dist) cmd.check_pth_processing = lambda: True cmd.find_links = ["link1", "link2"] cmd.install_dir = os.path.join(tempfile.mkdtemp(), "ok") cmd.args = ["ok"] cmd.ensure_finalized() keys = cmd.package_index.scanned_urls.keys() keys.sort() self.assertEquals(keys, ["link1", "link2"])
def test_unicode_filename_in_sdist(self, sdist_unicode, tmpdir, monkeypatch): """ The install command should execute correctly even if the package has unicode filenames. """ 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)
def test_unicode_filename_in_sdist(self, sdist_unicode, tmpdir, monkeypatch): """ The install command should execute correctly even if the package has unicode filenames. """ 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)
def test_script_install(self, sdist_script, tmpdir, monkeypatch): """ Check scripts are installed. """ 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_script) assert (target / 'mypkg_script').exists()
def test_script_install(self, sdist_script, tmpdir, monkeypatch): """ Check scripts are installed. """ 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_script) assert (target / 'mypkg_script').exists()
def test_local_index(self, foo_package, install_target): """ The local index must be used when easy_install locates installed packages. """ dist = Distribution() dist.script_name = 'setup.py' cmd = ei.easy_install(dist) cmd.install_dir = install_target cmd.args = ['foo'] cmd.ensure_finalized() cmd.local_index.scan([foo_package]) res = cmd.easy_install('foo') actual = os.path.normcase(os.path.realpath(res.location)) expected = os.path.normcase(os.path.realpath(foo_package)) assert actual == expected
def test_local_index(self, foo_package, install_target): """ The local index must be used when easy_install locates installed packages. """ dist = Distribution() dist.script_name = 'setup.py' cmd = ei.easy_install(dist) cmd.install_dir = install_target cmd.args = ['foo'] cmd.ensure_finalized() cmd.local_index.scan([foo_package]) res = cmd.easy_install('foo') actual = os.path.normcase(os.path.realpath(res.location)) expected = os.path.normcase(os.path.realpath(foo_package)) assert actual == expected
def install_scripts(distributions): """ Regenerate the entry_points console_scripts for the named distribution. """ try: from setuptools.command import easy_install import pkg_resources except ImportError: raise RuntimeError("'wheel install_scripts' needs setuptools.") for dist in distributions: pkg_resources_dist = pkg_resources.get_distribution(dist) install = wheel.paths.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 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') finally: f.close() sys.path.append(target) old_ppath = os.environ.get('PYTHONPATH') os.environ['PYTHONPATH'] = os.path.pathsep.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') actual = os.path.normcase(os.path.realpath(res.location)) expected = os.path.normcase(os.path.realpath(new_location)) self.assertEqual(actual, expected) finally: sys.path.remove(target) for basedir in [ new_location, target, ]: if not os.path.exists(basedir) or not os.path.isdir(basedir): continue try: shutil.rmtree(basedir) except: pass if old_ppath is not None: os.environ['PYTHONPATH'] = old_ppath else: del os.environ['PYTHONPATH']
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') finally: f.close() sys.path.append(target) old_ppath = os.environ.get('PYTHONPATH') os.environ['PYTHONPATH'] = os.path.pathsep.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') actual = os.path.normcase(os.path.realpath(res.location)) expected = os.path.normcase(os.path.realpath(new_location)) self.assertEqual(actual, expected) finally: sys.path.remove(target) for basedir in [new_location, target, ]: if not os.path.exists(basedir) or not os.path.isdir(basedir): continue try: shutil.rmtree(basedir) except: pass if old_ppath is not None: os.environ['PYTHONPATH'] = old_ppath else: del os.environ['PYTHONPATH']
def _legacy_fetch_build_egg(dist, req): """Fetch an egg needed for building. Legacy path using EasyInstall. """ tmp_dist = dist.__class__({"script_args": ["easy_install"]}) opts = tmp_dist.get_option_dict("easy_install") opts.clear() opts.update((k, v) for k, v in dist.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 dist.dependency_links: links = dist.dependency_links[:] if "find_links" in opts: links = _fixup_find_links(opts["find_links"][1]) + links opts["find_links"] = ("setup", links) install_dir = dist.get_egg_cache_dir() cmd = easy_install( tmp_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): """Fixture to set up temporary installation directory. """ # Save old values so we can restore them. new_cwd = tempfile.mkdtemp() old_cwd = os.getcwd() old_enable_site = site.ENABLE_USER_SITE old_file = easy_install_pkg.__file__ old_base = site.USER_BASE old_site = site.USER_SITE old_ppath = os.environ.get('PYTHONPATH') def fin(): os.chdir(old_cwd) shutil.rmtree(new_cwd) shutil.rmtree(site.USER_BASE) shutil.rmtree(site.USER_SITE) site.USER_BASE = old_base site.USER_SITE = old_site site.ENABLE_USER_SITE = old_enable_site easy_install_pkg.__file__ = old_file os.environ['PYTHONPATH'] = old_ppath or '' request.addfinalizer(fin) # Change the environment and site settings to control where the # files are installed and ensure we do not overwrite anything. site.USER_BASE = tempfile.mkdtemp() site.USER_SITE = tempfile.mkdtemp() easy_install_pkg.__file__ = site.USER_SITE os.chdir(new_cwd) install_dir = tempfile.mkdtemp() sys.path.append(install_dir) os.environ['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 return cmd
def do_egg_install(self): from setuptools.command.easy_install import easy_install cmd = easy_install( self.distribution, args="x", root=self.root, record=self.record, ) cmd.ensure_finalized() # finalize before bdist_egg munges install cmd self.run_command('bdist_egg') args = [self.distribution.get_command_obj('bdist_egg').egg_output] if setuptools.bootstrap_install_from: # Bootstrap self-installation of setuptools args.insert(0, setuptools.bootstrap_install_from) cmd.args = args cmd.run() setuptools.bootstrap_install_from = None
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"] = os.path.pathsep.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) for basedir in [new_location, target]: if not os.path.exists(basedir) or not os.path.isdir(basedir): continue try: shutil.rmtree(basedir) except: pass if old_ppath is not None: os.environ["PYTHONPATH"] = old_ppath else: del os.environ["PYTHONPATH"]
def _legacy_fetch_build_egg(dist, req): """Fetch an egg needed for building. Legacy path using EasyInstall. """ tmp_dist = dist.__class__({'script_args': ['easy_install']}) opts = tmp_dist.get_option_dict('easy_install') opts.clear() opts.update((k, v) for k, v in dist.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 dist.dependency_links: links = dist.dependency_links[:] if 'find_links' in opts: links = opts['find_links'][1] + links opts['find_links'] = ('setup', links) install_dir = dist.get_egg_cache_dir() cmd = easy_install(tmp_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 _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 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): 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) 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() self._egg_fetcher = cmd return cmd.easy_install(req)
babel.compile_catalog = None babel.extract_messages = None babel.init_catalog = None babel.update_catalog = None from distutils.core import setup, Extension from setuptools.command.easy_install import main as easy_install # check the PIL is installed; since its package name isn't the same as # the distribution name, setuptools can't manage it as a dependency try: import Image except ImportError: print "Installing the Python Imaging Library" easy_install(["http://effbot.org/downloads/Imaging-1.1.6.tar.gz"]) # same with the captcha library try: import Captcha except ImportError: print "Installing the PyCaptcha Module" easy_install(["http://svn.navi.cx/misc/trunk/pycaptcha"]) # unfortunately, we use an old version of sqlalchemy right now try: import sqlalchemy vers = sqlalchemy.__version__ assert vers == "0.3.10", \ ("reddit is only compatible with SqlAlchemy 0.3.10 not '%s' " % vers) except ImportError:
babel.extract_messages = None babel.init_catalog = None babel.update_catalog = None from distutils.core import setup, Extension from setuptools.command.easy_install import main as easy_install import os # check the PIL is installed; since its package name isn't the same as # the distribution name, setuptools can't manage it as a dependency try: import Image except ImportError: print "Installing the Python Imaging Library" easy_install(["http://effbot.org/downloads/Imaging-1.1.6.tar.gz"]) # same with the captcha library try: import Captcha except ImportError: print "Installing the PyCaptcha Module" easy_install(["http://svn.navi.cx/misc/trunk/pycaptcha"]) # ditto for pylons try: import pylons vers = pylons.__version__ assert vers.startswith('0.9.6.') or vers == '0.9.6', \ ("reddit is only compatible with pylons 0.9.6, not '%s'" % vers) except ImportError:
babel.extract_messages = None babel.init_catalog = None babel.update_catalog = None from distutils.core import setup, Extension from setuptools.command.easy_install import main as easy_install import os # check the PIL is installed; since its package name isn't the same as # the distribution name, setuptools can't manage it as a dependency try: import Image except ImportError: print "Installing the Python Imaging Library" easy_install(["http://effbot.org/downloads/Imaging-1.1.6.tar.gz"]) # same with the captcha library try: import Captcha except ImportError: print "Installing the PyCaptcha Module" easy_install(["http://svn.navi.cx/misc/trunk/pycaptcha"]) # ditto for pylons try: import pylons vers = pylons.__version__ assert vers.startswith('0.9.6.') or vers == '0.9.6', \ ("reddit is only compatible with pylons 0.9.6, not '%s'" % vers) except ImportError:
babel.compile_catalog = None babel.extract_messages = None babel.init_catalog = None babel.update_catalog = None from distutils.core import setup, Extension from setuptools.command.easy_install import main as easy_install # check the PIL is installed; since its package name isn't the same as # the distribution name, setuptools can't manage it as a dependency try: import Image except ImportError: print "Installing the Python Imaging Library" easy_install(["http://effbot.org/downloads/Imaging-1.1.6.tar.gz"]) # same with the captcha library try: import Captcha except ImportError: print "Installing the PyCaptcha Module" easy_install(["http://svn.navi.cx/misc/trunk/pycaptcha"]) # unfortunately, we use an old version of sqlalchemy right now try: import sqlalchemy vers = sqlalchemy.__version__ assert vers == "0.3.10", "reddit is only compatible with SqlAlchemy 0.3.10 not '%s' " % vers except ImportError:
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) <<<<<<< HEAD install_dir = self.get_egg_cache_dir() cmd = easy_install( dist, args=["x"], install_dir=install_dir, exclude_scripts=True, ======= cmd = easy_install( dist, args=["x"], install_dir=os.curdir, exclude_scripts=True, >>>>>>> e4baf504ede925f4f1e07d823c9b20b3d0dbe14c 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 _set_global_opts_from_features(self): """Add --with-X/--without-X options based on optional features""" go = []