def _check_deps(self, metadata): plugins = {k.__name__.replace('_', '-'): Distribution( os.path.dirname(k.__file__), None, k.__name__, k.__version__, None, SOURCE_DIST) for k in veles.__plugins__} failed_general = set() failed_veles = set() for rreq in metadata["requires"]: req = Requirement.parse(rreq) if req.project_name in plugins: if plugins[req.project_name] not in req: failed_veles.add(req) else: try: working_set.find(req).project_name except (AttributeError, VersionConflict): failed_general.add(req) if len(failed_general) > 0: print("Unsatisfied package requirements:", file=sys.stderr) print(", ".join((str(f) for f in failed_general)), file=sys.stderr) if len(failed_veles): print("Unsatisfied VELES requirements:", file=sys.stderr) print(", ".join((str(f) for f in failed_veles)), file=sys.stderr)
def run(self): self.run_command("egg_info") if self.distribution.scripts: _install_scripts.run(self) # run first to set up self.outfiles else: self.outfiles = [] if self.no_ep: # don't install entry point scripts into .egg file! return ei_cmd = self.get_finalized_command("egg_info") dist = Distribution( ei_cmd.egg_base, PathMetadata(ei_cmd.egg_base, ei_cmd.egg_info), ei_cmd.egg_name, ei_cmd.egg_version, ) bs_cmd = self.get_finalized_command('build_scripts') executable = getattr(bs_cmd, 'executable', sys_executable) for args in get_script_args(dist, executable): self.write_script(*args)
def run(self): import setuptools.command.easy_install as ei self.run_command("egg_info") if self.distribution.scripts: orig.install_scripts.run(self) # run first to set up self.outfiles else: self.outfiles = [] if self.no_ep: # don't install entry point scripts into .egg file! return ei_cmd = self.get_finalized_command("egg_info") dist = Distribution( ei_cmd.egg_base, PathMetadata(ei_cmd.egg_base, ei_cmd.egg_info), ei_cmd.egg_name, ei_cmd.egg_version, ) bs_cmd = self.get_finalized_command("build_scripts") exec_param = getattr(bs_cmd, "executable", None) try: bw_cmd = self.get_finalized_command("bdist_wininst") is_wininst = getattr(bw_cmd, "_is_running", False) except ImportError: is_wininst = False writer = ei.ScriptWriter if is_wininst: exec_param = "python.exe" writer = ei.WindowsScriptWriter if exec_param == sys.executable: # In case the path to the Python executable contains a space, wrap # it so it's not split up. exec_param = [exec_param] # resolve the writer to the environment writer = writer.best() cmd = writer.command_spec_class.best().from_param(exec_param) for args in writer.get_args(dist, cmd.as_header()): self.write_script(*args)
def finalize_options(self): ei = self.get_finalized_command("egg_info") if ei.broken_egg_info: raise DistutilsError( "Please rename %r to %r before using 'develop'" % (ei.egg_info, ei.broken_egg_info)) self.args = [ei.egg_name] easy_install.finalize_options(self) # pick up setup-dir .egg files only: no .egg-info self.package_index.scan(glob.glob('*.egg')) self.egg_link = os.path.join(self.install_dir, ei.egg_name + '.egg-link') self.egg_base = ei.egg_base if self.egg_path is None: self.egg_path = os.path.abspath(ei.egg_base) target = normalize_path(self.egg_base) if normalize_path(os.path.join(self.install_dir, self.egg_path)) != target: raise DistutilsOptionError( "--egg-path must be a relative path from the install" " directory to " + target) # Make a distribution for the package's source self.dist = Distribution(target, PathMetadata(target, os.path.abspath(ei.egg_info)), project_name=ei.egg_name) p = self.egg_base.replace(os.sep, '/') if p != os.curdir: p = '../' * (p.count('/') + 1) self.setup_path = p p = normalize_path(os.path.join(self.install_dir, self.egg_path, p)) if p != normalize_path(os.curdir): raise DistutilsOptionError( "Can't get a consistent path to setup script from" " installation directory", p, normalize_path(os.curdir))
def finalize_options(self): ei = self.get_finalized_command("egg_info") if ei.broken_egg_info: template = "Please rename %r to %r before using 'develop'" args = ei.egg_info, ei.broken_egg_info raise DistutilsError(template % args) self.args = [ei.egg_name] easy_install.finalize_options(self) self.expand_basedirs() self.expand_dirs() # pick up setup-dir .egg files only: no .egg-info self.package_index.scan(glob.glob('*.egg')) egg_link_fn = ei.egg_name + '.egg-link' self.egg_link = os.path.join(self.install_dir, egg_link_fn) self.egg_base = ei.egg_base if self.egg_path is None: self.egg_path = os.path.abspath(ei.egg_base) target = normalize_path(self.egg_base) egg_path = normalize_path(os.path.join(self.install_dir, self.egg_path)) if egg_path != target: raise DistutilsOptionError( "--egg-path must be a relative path from the install" " directory to " + target) # Make a distribution for the package's source self.dist = Distribution(target, PathMetadata(target, os.path.abspath(ei.egg_info)), project_name=ei.egg_name) self.setup_path = self._resolve_setup_path( self.egg_base, self.install_dir, self.egg_path, )
def test_no_valid_file(self): working_set = mocks.WorkingSet( { 'nunja.mold': [ 'nunja.testing.badmold = nunja.testing:badmold', ] }, dist=Distribution(project_name='nunjatesting', version='0.0')) with pretty_logging(logger='nunja', stream=mocks.StringIO()) as stream: registry = MoldRegistry('nunja.mold', _working_set=working_set) records = registry.get_records_for_package('nunjatesting') self.assertEqual( sorted(records.keys()), ['text!nunja.testing.badmold/nomold/empty.nja'], ) self.assertIn('1 templates', stream.getvalue()) self.assertIn('0 scripts', stream.getvalue()) self.assertIn('generated 0 molds', stream.getvalue())
def finalize_options(self): ei_cmd = self.ei_cmd = self.get_finalized_command("egg_info") self.egg_info = ei_cmd.egg_info if self.bdist_dir is None: bdist_base = self.get_finalized_command('bdist').bdist_base self.bdist_dir = os.path.join(bdist_base, 'egg') if self.plat_name is None: self.plat_name = get_build_platform() self.set_undefined_options('bdist', ('dist_dir', 'dist_dir')) if self.egg_output is None: # Compute filename of the output egg basename = Distribution( None, None, ei_cmd.egg_name, ei_cmd.egg_version, get_python_version(), self.distribution.has_ext_modules() and self.plat_name).egg_name() self.egg_output = os.path.join(self.dist_dir, basename + '.egg')
def main(): from distutils.dist import Distribution from optparse import OptionParser parser = OptionParser(usage='usage: %prog [options] test_suite ...', version='%%prog %s' % VERSION) parser.add_option('-o', '--xml-output', action='store', dest='xml_output', metavar='FILE', help='write XML test results to FILE') parser.add_option('-d', '--coverage-dir', action='store', dest='coverage_dir', metavar='DIR', help='store coverage results in DIR') parser.add_option('-s', '--coverage-summary', action='store', dest='coverage_summary', metavar='FILE', help='write coverage summary to FILE') options, args = parser.parse_args() if len(args) < 1: parser.error('incorrect number of arguments') cmd = unittest(Distribution()) cmd.initialize_options() cmd.test_suite = args[0] if hasattr(options, 'xml_output'): cmd.xml_output = options.xml_output if hasattr(options, 'coverage_summary'): cmd.coverage_summary = options.coverage_summary if hasattr(options, 'coverage_dir'): cmd.coverage_dir = options.coverage_dir cmd.finalize_options() cmd.run()
def interpret_distro_name(location, basename, metadata, py_version=None, precedence=SOURCE_DIST, platform=None): """Generate alternative interpretations of a source distro name Note: if `location` is a filesystem filename, you should call ``pkg_resources.normalize_path()`` on it before passing it to this routine! """ # Generate alternative interpretations of a source distro name # Because some packages are ambiguous as to name/versions split # e.g. "adns-python-1.1.0", "egenix-mx-commercial", etc. # So, we generate each possible interepretation (e.g. "adns, python-1.1.0" # "adns-python, 1.1.0", and "adns-python-1.1.0, no version"). In practice, # the spurious interpretations should be ignored, because in the event # there's also an "adns" package, the spurious "python-1.1.0" version will # compare lower than any numeric version number, and is therefore unlikely # to match a request for it. It's still a potential problem, though, and # in the long run PyPI and the distutils should go for "safe" names and # versions in distribution archive names (sdist and bdist). parts = basename.split("-") if not py_version and any(re.match(r"py\d\.\d$", p) for p in parts[2:]): # it is a bdist_dumb, not an sdist -- bail out return for p in range(1, len(parts) + 1): yield Distribution( location, metadata, "-".join(parts[:p]), "-".join(parts[p:]), py_version=py_version, precedence=precedence, platform=platform, )
class test_link_package_versions(object): # patch this for travis which has distribute in it's base env for now @patch('pip.wheel.pkg_resources.get_distribution', lambda x: Distribution(project_name='setuptools', version='0.9')) def setup(self): self.version = '1.0' self.parsed_version = parse_version(self.version) self.search_name = 'pytest' self.finder = PackageFinder([], [], use_wheel=True) def test_link_package_versions_match_wheel(self): """Test that 'pytest' archives match for 'pytest'""" # TODO: Uncomment these, when #1217 is fixed # link = Link('http:/yo/pytest-1.0.tar.gz') # result = self.finder._link_package_versions(link, self.search_name) # assert result == [(self.parsed_version, link, self.version)], result link = Link('http:/yo/pytest-1.0-py2.py3-none-any.whl') result = self.finder._link_package_versions(link, self.search_name) assert result == [(self.parsed_version, link, self.version)], result def test_link_package_versions_substring_fails(self): """Test that 'pytest<something> archives won't match for 'pytest'""" # TODO: Uncomment these, when #1217 is fixed # link = Link('http:/yo/pytest-xdist-1.0.tar.gz') # result = self.finder._link_package_versions(link, self.search_name) # assert result == [], result # link = Link('http:/yo/pytest2-1.0.tar.gz') # result = self.finder._link_package_versions(link, self.search_name) # assert result == [], result link = Link('http:/yo/pytest_xdist-1.0-py2.py3-none-any.whl') result = self.finder._link_package_versions(link, self.search_name) assert result == [], result
def test_registry_autoreload_base_support(self): # This is just to test the setup of the relevant entry correctly # but does not actually deal with the more dynamic functionality # that molds offer. setup_tmp_module(self) entry_points = ['tmp = tmp:mold'] working_set = mocks.WorkingSet({'nunja.tmpl': entry_points}, dist=Distribution( project_name='nunjatesting', version='0.0')) registry = JinjaTemplateRegistry.create(_working_set=working_set, auto_reload=False) self.assertFalse(registry.tracked_entry_points) with self.assertRaises(KeyError): registry.lookup_path('tmp/itemlist') registry = JinjaTemplateRegistry.create(_working_set=working_set, auto_reload=True) self.assertEqual(str(registry.tracked_entry_points['tmp']), entry_points[0])
def test_list_one_installed(environment: Environment): env = Environment(search_path=[]) environment.return_value = env metadata = """Metadata-Version: 2.1 Name: chaostoolkit-some-stuff Version: 0.1.0 Summary: Chaos Toolkit some package Home-page: http://chaostoolkit.org Author: chaostoolkit Team Author-email: [email protected] License: Apache License 2.0 """ env.add( Distribution(project_name="chaostoolkit-some-stuff", version="0.1.0", metadata=InMemoryMetadata({"PKG-INFO": metadata}))) extensions = list_extensions() assert len(extensions) == 1 ext = extensions[0] assert ext.name == "chaostoolkit-some-stuff" assert ext.version == "0.1.0"
def _venv_match(self, installed, requirements): """Return True if what is installed satisfies the requirements. This method has multiple exit-points, but only for False (because if *anything* is not satisified, the venv is no good). Only after all was checked, and it didn't exit, the venv is ok so return True. """ if not requirements: # special case for no requirements, where we can't actually # check anything: the venv is useful if nothing installed too return not bool(installed) useful_inst = set() for repo, req_deps in requirements.items(): if repo not in installed: # the venv doesn't even have the repo return False inst_deps = { Distribution(project_name=dep, version=ver) for (dep, ver) in installed[repo].items() } for req in req_deps: for inst in inst_deps: if inst in req: useful_inst.add(inst) break else: # nothing installed satisfied that requirement return False # assure *all* that is installed is useful for the requirements if useful_inst != inst_deps: return False # it did it through! return True
def get_distrib(*dep_ver_pairs): """Build some Distributions with indicated info.""" return [ Distribution(project_name=dep, version=ver) for dep, ver in dep_ver_pairs ]
def distRequires(self, txt): return Distribution("/foo", metadata=Metadata(('depends.txt', txt)))
def distribution(self): return Distribution(project_name=self._interpreter, version='.'.join(map(str, self._version)))
def __init__(self, name, module_name): super(MockEntryPoint, self).__init__(name, module_name, dist=Distribution(version='1.2.3'))
def create_fake_distribution(name): return Distribution(project_name="cerberus", version="1.2.3")
def finalize_options(self): ei = self.get_finalized_command("egg_info") if ei.broken_egg_info: raise DistutilsError( "Please rename %r to %r before using 'develop'" % (ei.egg_info, ei.broken_egg_info) ) self.args = [ei.egg_name] py_version = sys.version.split()[0] prefix, exec_prefix = get_config_vars('prefix', 'exec_prefix') self.config_vars = {'dist_name': self.distribution.get_name(), 'dist_version': self.distribution.get_version(), 'dist_fullname': self.distribution.get_fullname(), 'py_version': py_version, 'py_version_short': py_version[0:3], 'py_version_nodot': py_version[0] + py_version[2], 'sys_prefix': prefix, 'prefix': prefix, 'sys_exec_prefix': exec_prefix, 'exec_prefix': exec_prefix, } if HAS_USER_SITE: self.config_vars['userbase'] = self.install_userbase self.config_vars['usersite'] = self.install_usersite # fix the install_dir if "--user" was used if self.user: self.create_home_path() if self.install_userbase is None: raise DistutilsPlatformError( "User base directory is not specified") self.install_base = self.install_platbase = self.install_userbase if os.name == 'posix': self.select_scheme("unix_user") else: self.select_scheme(os.name + "_user") self.expand_basedirs() self.expand_dirs() if self.user and self.install_purelib: self.install_dir = self.install_purelib self.script_dir = self.install_scripts easy_install.finalize_options(self) # pick up setup-dir .egg files only: no .egg-info self.package_index.scan(glob.glob('*.egg')) self.egg_link = os.path.join(self.install_dir, ei.egg_name+'.egg-link') self.egg_base = ei.egg_base if self.egg_path is None: self.egg_path = os.path.abspath(ei.egg_base) target = normalize_path(self.egg_base) if normalize_path(os.path.join(self.install_dir, self.egg_path)) != target: raise DistutilsOptionError( "--egg-path must be a relative path from the install" " directory to "+target ) # Make a distribution for the package's source self.dist = Distribution( target, PathMetadata(target, os.path.abspath(ei.egg_info)), project_name = ei.egg_name ) p = self.egg_base.replace(os.sep,'/') if p!= os.curdir: p = '../' * (p.count('/')+1) self.setup_path = p p = normalize_path(os.path.join(self.install_dir, self.egg_path, p)) if p != normalize_path(os.curdir): raise DistutilsOptionError( "Can't get a consistent path to setup script from" " installation directory", p, normalize_path(os.curdir))
def _mock_distribution(name): return Distribution(version='1.2.3')
def get_mock_plugin(name, version, reg=None, alias=None, after=None, rules=None, target_types=None): """Make a fake Distribution (optionally with entry points) Note the entry points do not actually point to code in the returned distribution -- the distribution does not even have a location and does not contain any code, just metadata. A module is synthesized on the fly and installed into sys.modules under a random name. If optional entry point callables are provided, those are added as methods to the module and their name (foo/bar/baz in fake module) is added as the requested entry point to the mocked metadata added to the returned dist. :param string name: project_name for distribution (see pkg_resources) :param string version: version for distribution (see pkg_resources) :param callable reg: Optional callable for goal registration entry point :param callable alias: Optional callable for build_file_aliases entry point :param callable after: Optional callable for load_after list entry point :param callable rules: Optional callable for rules entry point :param callable target_types: Optional callable for target_types entry point """ plugin_pkg = f"demoplugin{uuid.uuid4().hex}" pkg = types.ModuleType(plugin_pkg) sys.modules[plugin_pkg] = pkg module_name = f"{plugin_pkg}.demo" plugin = types.ModuleType(module_name) setattr(pkg, "demo", plugin) sys.modules[module_name] = plugin metadata = {} entry_lines = [] if reg is not None: setattr(plugin, "foo", reg) entry_lines.append(f"register_goals = {module_name}:foo\n") if alias is not None: setattr(plugin, "bar", alias) entry_lines.append(f"build_file_aliases = {module_name}:bar\n") if after is not None: setattr(plugin, "baz", after) entry_lines.append(f"load_after = {module_name}:baz\n") if rules is not None: setattr(plugin, "qux", rules) entry_lines.append(f"rules = {module_name}:qux\n") if target_types is not None: setattr(plugin, "tofu", target_types) entry_lines.append(f"target_types = {module_name}:tofu\n") if entry_lines: entry_data = "[pantsbuild.plugin]\n{}\n".format( "\n".join(entry_lines)) metadata = {"entry_points.txt": entry_data} return Distribution(project_name=name, version=version, metadata=MockMetadata(metadata))
def get_mock_plugin(self, name, version, reg=None, alias=None, after=None, rules=None): """Make a fake Distribution (optionally with entry points) Note the entry points do not actually point to code in the returned distribution -- the distribution does not even have a location and does not contain any code, just metadata. A module is synthesized on the fly and installed into sys.modules under a random name. If optional entry point callables are provided, those are added as methods to the module and their name (foo/bar/baz in fake module) is added as the requested entry point to the mocked metadata added to the returned dist. :param string name: project_name for distribution (see pkg_resources) :param string version: version for distribution (see pkg_resources) :param callable reg: Optional callable for goal registration entry point :param callable alias: Optional callable for build_file_aliases entry point :param callable after: Optional callable for load_after list entry point :param callable rules: Optional callable for rules entry point """ plugin_pkg = 'demoplugin{0}'.format(uuid.uuid4().hex) if PY2: plugin_pkg = plugin_pkg.encode('utf-8') pkg = types.ModuleType(plugin_pkg) sys.modules[plugin_pkg] = pkg module_name = '{0}.{1}'.format(plugin_pkg, 'demo') if PY2: module_name = module_name.encode('utf-8') plugin = types.ModuleType(module_name) setattr(pkg, 'demo', plugin) sys.modules[module_name] = plugin metadata = {} entry_lines = [] if reg is not None: setattr(plugin, 'foo', reg) entry_lines.append('register_goals = {}:foo\n'.format(module_name)) if alias is not None: setattr(plugin, 'bar', alias) entry_lines.append( 'build_file_aliases = {}:bar\n'.format(module_name)) if after is not None: setattr(plugin, 'baz', after) entry_lines.append('load_after = {}:baz\n'.format(module_name)) if rules is not None: setattr(plugin, 'qux', rules) entry_lines.append('rules = {}:qux\n'.format(module_name)) if entry_lines: entry_data = '[pantsbuild.plugin]\n{}\n'.format( '\n'.join(entry_lines)) metadata = {'entry_points.txt': entry_data} return Distribution(project_name=name, version=version, metadata=MockMetadata(metadata))
def _get_egg_name(self): ei_cmd = self.get_finalized_command("egg_info") return Distribution( None, None, ei_cmd.egg_name, ei_cmd.egg_version, get_python_version(), self.distribution.has_ext_modules() and self.plat_name).egg_name()
def distribution(self): return Distribution(project_name=self.interpreter, version=self.version_str)
def test_distribution_as_key(self): mapping = base.PackageKeyMapping() mapping[Distribution(project_name='not_normalized')] = 1 self.assertEqual(1, mapping['not_normalized']) self.assertEqual(1, mapping[safe_name('not_normalized')])
def egg_name(self): return Distribution( project_name=self.project_name, version=self.version, platform=(None if self.platform == 'any' else get_platform()), ).egg_name() + '.egg'
#!/usr/bin/python # Copyright (C) 2008, Charles Wang <*****@*****.**> # Author: Charles Wang <*****@*****.**> # License: BSD import os.path import shutil import sys from pkg_resources import Distribution from pypi2pkgsys.package_system import package_system from pypi2pkgsys.pypi_objects import pypicache if len(sys.argv) < 4: print 'Usage: %s CACHE_ROOT CACHE_URL FILENAME,DISTNAME ...' % sys.argv[0] sys.exit(-1) cacheroot = sys.argv[1] cacheurl = sys.argv[2] downloads = os.path.join(cacheroot, 'downloads') distlist = [] for arg in sys.argv[3:]: filename, distname = arg.split(',') dlfname = os.path.join(downloads, os.path.basename(filename)) print 'Copy %s %s ...' % (filename, dlfname) shutil.copyfile(filename, dlfname) dist = Distribution(dlfname, None, project_name=distname) distlist.append(dist) cache = pypicache(package_system(), cacheroot, cacheurl) cache.add_packages(distlist) del (cache)
import unittest from os import path from pkg_resources import Distribution, EntryPoint from nichtparasoup.imagecrawler import KnownImageCrawlers from .testdata_imagecrawler_plugin import ( BaseLoadableImageCrawlerA, LoadableImageCrawlerA, LoadableImageCrawlerB, StandaloneLoadableImageCrawlerA, ) _TEST_PLUGIN_DIST = Distribution( location=path.abspath('testdata_imagecrawler_plugin'), project_name='testdata-imagecrawler-plugin') _TEST_PLUGIN_CLASS = LoadableImageCrawlerA _TEST_PLUGIN_ENTRY = EntryPoint('Test', _TEST_PLUGIN_CLASS.__module__, attrs=(_TEST_PLUGIN_CLASS.__name__, ), dist=_TEST_PLUGIN_DIST) class KnownImageCrawlersLoadTest(unittest.TestCase): def test_success(self) -> None: # arrange entry = _TEST_PLUGIN_ENTRY # act loaded = KnownImageCrawlers._load(entry) # assert
assert_equal( parse_editable('.[extras]', 'git'), (None, 'file://' + "/some/path", ('extras',)) ) normcase_mock.return_value = "/some/path/foo" assert_equal( parse_editable('foo[bar,baz]', 'git'), (None, 'file:///some/path/foo', ('bar', 'baz')) ) def test_remote_reqs_parse(): """ Test parsing a simple remote requirements file """ # this requirements file just contains a comment # previously this has failed in py3 (https://github.com/pypa/pip/issues/760) for req in parse_requirements('https://raw.github.com/pypa/pip-test-package/master/tests/req_just_comment.txt'): pass # patch this for travis which has distribute in it's base env for now @patch('pip.wheel.pkg_resources.get_distribution', lambda x: Distribution(project_name='setuptools', version='0.9')) def test_req_file_parse_use_wheel(): """ Test parsing --use-wheel from a req file """ reqfile = os.path.join(tests_data, 'reqfiles', 'supported_options.txt') finder = PackageFinder([], []) for req in parse_requirements(reqfile, finder): pass assert finder.use_wheel
# -*- coding: utf-8 -*- import io from pkg_resources import Distribution from pkg_resources import EntryPoint from pkg_resources import EmptyProvider from setuptools.command.egg_info import egg_info _dist = Distribution() dummy = object() class WorkingSet(object): def __init__(self, items, dist=_dist): self.items = items self.dist = dist def iter_entry_points(self, name): items = self.items.get(name, []) for item in items: entry_point = item if isinstance( item, EntryPoint) else EntryPoint.parse(item) entry_point.dist = self.dist yield entry_point def find(self, name): # just always return the dist. return self.dist