def build_docs_and_install(name, version, findlinks): # pragma no cover
tdir = tempfile.mkdtemp()
startdir = os.getcwd()
os.chdir(tdir)
try:
tarpath = download_github_tar('OpenMDAO-Plugins', name, version)
# extract the repo tar file
tar = tarfile.open(tarpath)
tar.extractall()
tar.close()
files = os.listdir('.')
files.remove(os.path.basename(tarpath))
if len(files) != 1:
raise RuntimeError(
"after untarring, found multiple directories: %s" % files)
# build sphinx docs
os.chdir(files[0]) # should be in distrib directory now
check_call(['plugin', 'build_docs', files[0]])
# create an sdist so we can query metadata for distrib dependencies
check_call([sys.executable, 'setup.py', 'sdist', '-d', '.'])
if sys.platform.startswith('win'):
tars = fnmatch.filter(os.listdir('.'), "*.zip")
else:
tars = fnmatch.filter(os.listdir('.'), "*.tar.gz")
if len(tars) != 1:
raise RuntimeError("should have found a single archive file,"
" but found %s instead" % tars)
check_call(['easy_install', '-NZ', tars[0]])
# now install any dependencies
metadict = get_metadata(tars[0])
reqs = metadict.get('requires', [])
done = set()
while reqs:
r = reqs.pop()
if r not in done:
done.add(r)
ws = WorkingSet()
req = Requirement.parse(r)
dist = ws.find(req)
if dist is None:
check_call(['easy_install', '-NZ', '-f', findlinks, r])
dist = ws.find(req)
if dist is None:
raise RuntimeError("Couldn't find distribution '%s'" %
r)
dist.activate()
dct = get_metadata(dist.egg_name().split('-')[0])
for new_r in dct.get('requires', []):
reqs.append(new_r)
finally:
os.chdir(startdir)
shutil.rmtree(tdir, ignore_errors=True)
def build_docs_and_install(name, version, findlinks): # pragma no cover
tdir = tempfile.mkdtemp()
startdir = os.getcwd()
os.chdir(tdir)
try:
tarpath = download_github_tar('OpenMDAO-Plugins', name, version)
# extract the repo tar file
tar = tarfile.open(tarpath)
tar.extractall()
tar.close()
files = os.listdir('.')
files.remove(os.path.basename(tarpath))
if len(files) != 1:
raise RuntimeError("after untarring, found multiple directories: %s"
% files)
# build sphinx docs
os.chdir(files[0]) # should be in distrib directory now
check_call(['plugin', 'build_docs', files[0]])
# create an sdist so we can query metadata for distrib dependencies
check_call([sys.executable, 'setup.py', 'sdist', '-d', '.'])
if sys.platform.startswith('win'):
tars = fnmatch.filter(os.listdir('.'), "*.zip")
else:
tars = fnmatch.filter(os.listdir('.'), "*.tar.gz")
if len(tars) != 1:
raise RuntimeError("should have found a single archive file,"
" but found %s instead" % tars)
check_call(['easy_install', '-NZ', tars[0]])
# now install any dependencies
metadict = get_metadata(tars[0])
reqs = metadict.get('requires', [])
done = set()
while reqs:
r = reqs.pop()
if r not in done:
done.add(r)
ws = WorkingSet()
req = Requirement.parse(r)
dist = ws.find(req)
if dist is None:
check_call(['easy_install', '-NZ', '-f', findlinks, r])
dist = ws.find(req)
if dist is None:
raise RuntimeError("Couldn't find distribution '%s'" % r)
dist.activate()
dct = get_metadata(dist.egg_name().split('-')[0])
for new_r in dct.get('requires', []):
reqs.append(new_r)
finally:
os.chdir(startdir)
shutil.rmtree(tdir, ignore_errors=True)
def test_find_conflicting(self):
ws = WorkingSet([])
Foo = Distribution.from_filename("/foo_dir/Foo-1.2.egg")
ws.add(Foo)
# create a requirement that conflicts with Foo 1.2
req = next(parse_requirements("Foo<1.2"))
with pytest.raises(VersionConflict) as vc:
ws.find(req)
msg = 'Foo 1.2 is installed but Foo<1.2 is required'
assert vc.value.report() == msg
def test_find_conflicting(self):
ws = WorkingSet([])
Foo = Distribution.from_filename("/foo_dir/Foo-1.2.egg")
ws.add(Foo)
# create a requirement that conflicts with Foo 1.2
req = next(parse_requirements("Foo<1.2"))
with pytest.raises(VersionConflict) as vc:
ws.find(req)
msg = 'Foo 1.2 is installed but Foo<1.2 is required'
assert vc.value.report() == msg
def test_LazyModule():
# create an entry point for taurus.core.util.test.dumm
w = WorkingSet()
d = w.find(Requirement.parse('taurus'))
ep = EntryPoint.parse("dummy_mod = taurus.core.util.test.dummy", dist=d)
modname = ep.name
# lazy load the ep module as taurus.fbt
LazyModule.import_ep(modname, "taurus", ep)
# check that lazy-loading did not import the entry point modules
assert modname not in sys.modules
assert ep.module_name not in sys.modules
# import the module and check that it is a LazyModule
import taurus.dummy_mod as lzm
assert isinstance(lzm, LazyModule)
# same again
import taurus.dummy_mod as lzm
assert isinstance(lzm, LazyModule)
# now access a member of the lazy module
assert lzm.foo == 1
# ...and check that any subsequent import will return a "real" module,
# not a lazy one
import taurus.dummy_mod as lzm
assert not isinstance(lzm, LazyModule)
assert isinstance(lzm, ModuleType)
def load_plugins(
build_configuration: BuildConfiguration.Builder,
plugins: List[str],
working_set: WorkingSet,
) -> None:
"""Load named plugins from the current working_set into the supplied build_configuration.
"Loading" a plugin here refers to calling registration methods -- it is assumed each plugin
is already on the path and an error will be thrown if it is not. Plugins should define their
entrypoints in the `pantsbuild.plugin` group when configuring their distribution.
Like source backends, the `build_file_aliases`, and `register_goals` methods are called if
those entry points are defined.
* Plugins are loaded in the order they are provided. *
This is important as loading can add, remove or replace existing tasks installed by other plugins.
If a plugin needs to assert that another plugin is registered before it, it can define an
entrypoint "load_after" which can return a list of plugins which must have been loaded before it
can be loaded. This does not change the order or what plugins are loaded in any way -- it is
purely an assertion to guard against misconfiguration.
:param build_configuration: The BuildConfiguration (for adding aliases).
:param plugins: A list of plugin names optionally with versions, in requirement format.
eg ['widgetpublish', 'widgetgen==1.2'].
:param working_set: A pkg_resources.WorkingSet to load plugins from.
"""
loaded: Dict = {}
for plugin in plugins or []:
req = Requirement.parse(plugin)
dist = working_set.find(req)
if not dist:
raise PluginNotFound(f"Could not find plugin: {req}")
entries = dist.get_entry_map().get("pantsbuild.plugin", {})
if "load_after" in entries:
deps = entries["load_after"].load()()
for dep_name in deps:
dep = Requirement.parse(dep_name)
if dep.key not in loaded:
raise PluginLoadOrderError(
f"Plugin {plugin} must be loaded after {dep}")
if "target_types" in entries:
target_types = entries["target_types"].load()()
build_configuration.register_target_types(target_types)
if "build_file_aliases" in entries:
aliases = entries["build_file_aliases"].load()()
build_configuration.register_aliases(aliases)
if "rules" in entries:
rules = entries["rules"].load()()
build_configuration.register_rules(rules)
loaded[dist.as_requirement().key] = dist
def build_docs_and_install(name, version, findlinks): # pragma no cover
tdir = tempfile.mkdtemp()
startdir = os.getcwd()
os.chdir(tdir)
try:
tarpath = download_github_tar('OpenMDAO-Plugins', name, version)
# extract the repo tar file
tar = tarfile.open(tarpath)
tar.extractall()
tar.close()
files = os.listdir('.')
files.remove(os.path.basename(tarpath))
if len(files) != 1:
raise RuntimeError("after untarring, found multiple directories: %s"
% files)
os.chdir(files[0]) # should be in distrib directory now
cfg = SafeConfigParser(dict_type=OrderedDict)
cfg.readfp(open('setup.cfg', 'r'), 'setup.cfg')
if cfg.has_option('metadata', 'requires-dist'):
reqs = cfg.get('metadata', 'requires-dist').strip()
reqs = reqs.replace(',', ' ')
reqs = [n.strip() for n in reqs.split()]
else:
# couldn't find requires-dist in setup.cfg, so
# create an sdist so we can query metadata for distrib dependencies
tarname = _bld_sdist_and_install(deps=False)
# now find any dependencies
metadict = get_metadata(tarname)
reqs = metadict.get('requires', [])
# install dependencies (some may be needed by sphinx)
ws = WorkingSet()
for r in reqs:
print "Installing dependency '%s'" % r
req = Requirement.parse(r)
dist = ws.find(req)
if dist is None:
try:
check_call(['easy_install', '-Z', '-f', findlinks, r])
except Exception:
traceback.print_exc()
# build sphinx docs
check_call(['plugin', 'build_docs', files[0]])
# make a new sdist with docs in it and install it
tarname = _bld_sdist_and_install()
finally:
os.chdir(startdir)
shutil.rmtree(tdir, ignore_errors=True)
def build_docs_and_install(name, version, findlinks): # pragma no cover
tdir = tempfile.mkdtemp()
startdir = os.getcwd()
os.chdir(tdir)
try:
tarpath = download_github_tar('OpenMDAO-Plugins', name, version)
# extract the repo tar file
tar = tarfile.open(tarpath)
tar.extractall()
tar.close()
files = os.listdir('.')
files.remove(os.path.basename(tarpath))
if len(files) != 1:
raise RuntimeError("after untarring, found multiple directories: %s"
% files)
os.chdir(files[0]) # should be in distrib directory now
cfg = SafeConfigParser(dict_type=OrderedDict)
cfg.readfp(open('setup.cfg', 'r'), 'setup.cfg')
if cfg.has_option('metadata', 'requires-dist'):
reqs = cfg.get('metadata', 'requires-dist').strip()
reqs = reqs.replace(',', ' ')
reqs = [n.strip() for n in reqs.split()]
else:
# couldn't find requires-dist in setup.cfg, so
# create an sdist so we can query metadata for distrib dependencies
tarname = _bld_sdist_and_install(deps=False)
# now find any dependencies
metadict = get_metadata(tarname)
reqs = metadict.get('requires', [])
# install dependencies (some may be needed by sphinx)
ws = WorkingSet()
for r in reqs:
print "Installing dependency '%s'" % r
req = Requirement.parse(r)
dist = ws.find(req)
if dist is None:
try:
check_call(['easy_install', '-Z', '-f', findlinks, r])
except Exception:
traceback.print_exc()
# build sphinx docs
check_call(['plugin', 'build_docs', files[0]])
# make a new sdist with docs in it and install it
tarname = _bld_sdist_and_install()
finally:
os.chdir(startdir)
shutil.rmtree(tdir, ignore_errors=True)
def parse_requirement(pkgstring, comparator='=='):
ins = InstallRequirement.from_line(pkgstring)
pkg_name, specs = ins.name, str(ins.specifier)
if specs:
return pkg_name, specs
req = Requirement.parse(pkg_name)
working_set = WorkingSet()
dist = working_set.find(req)
if dist:
specs = "%s%s" % (comparator, dist.version)
return req.project_name, specs
def check(request):
package_name = settings.HEARTBEAT.get('package_name')
if not package_name:
raise ImproperlyConfigured(
'Missing package_name key from heartbeat configuration')
sys_path_distros = WorkingSet()
package_req = Requirement.parse(package_name)
distro = sys_path_distros.find(package_req)
if not distro:
return dict(error='no distribution found for {}'.format(package_name))
return dict(name=distro.project_name, version=distro.version)
def main(args, options):
from pkg_resources import WorkingSet, Requirement, find_distributions
if not options.site_dir:
app.error('Must supply --site')
distributions = list(find_distributions(options.site_dir))
working_set = WorkingSet()
for dist in distributions:
working_set.add(dist)
for arg in args:
arg_req = Requirement.parse(arg)
found_dist = working_set.find(arg_req)
if not found_dist:
print('Could not find %s!' % arg_req)
out_zip = Distiller(found_dist).distill()
print('Dumped %s => %s' % (arg_req, out_zip))
def main(args, options):
from pkg_resources import WorkingSet, Requirement, find_distributions
if not options.site_dir:
app.error('Must supply --site')
distributions = list(find_distributions(options.site_dir))
working_set = WorkingSet()
for dist in distributions:
working_set.add(dist)
for arg in args:
arg_req = Requirement.parse(arg)
found_dist = working_set.find(arg_req)
if not found_dist:
print('Could not find %s!' % arg_req)
out_zip = Distiller(found_dist).distill()
print('Dumped %s => %s' % (arg_req, out_zip))
def build_docs_and_install(owner, name, version, findlinks): # pragma no cover
tdir = tempfile.mkdtemp()
startdir = os.getcwd()
os.chdir(tdir)
try:
tarpath = download_github_tar(owner, name, version)
# extract the repo tar file
tar = tarfile.open(tarpath)
tar.extractall()
tar.close()
files = os.listdir(".")
files.remove(os.path.basename(tarpath))
if len(files) != 1:
raise RuntimeError("after untarring, found multiple directories: %s" % files)
os.chdir(files[0]) # should be in distrib directory now
cfg = SafeConfigParser(dict_type=OrderedDict)
try:
cfg.readfp(open("setup.cfg", "r"), "setup.cfg")
except IOError as io_error:
raise IOError, "OpenMDAO plugins must have a setup.cfg: {}".format(io_error), sys.exc_info()[2]
try:
reqs = cfg.get("metadata", "requires-dist").strip()
reqs = reqs.replace(",", " ")
reqs = [n.strip() for n in reqs.split()]
try:
flinks = cfg.get("easy_install", "find_links").strip()
flinks = flinks.split("\n")
flinks = [n.strip() for n in flinks]
flinks.append(findlinks)
findlinks = " ".join(flinks)
except (NoSectionError, NoOptionError):
pass
except NoOptionError:
# couldn't find requires-dist in setup.cfg, so
# create an sdist so we can query metadata for distrib dependencies
tarname = _bld_sdist_and_install(deps=False)
# now find any dependencies
metadict = get_metadata(tarname)
reqs = metadict.get("requires", [])
# install dependencies (some may be needed by sphinx)
ws = WorkingSet()
for r in reqs:
print "Installing dependency '%s'" % r
req = Requirement.parse(r)
dist = ws.find(req)
if dist is None:
try:
check_call(["easy_install", "-Z", "-f", findlinks, r])
except Exception:
traceback.print_exc()
# build sphinx docs
check_call(["plugin", "build_docs", files[0]])
# make a new sdist with docs in it and install it
tarname = _bld_sdist_and_install()
finally:
os.chdir(startdir)
shutil.rmtree(tdir, ignore_errors=True)
def load_plugins(
build_configuration: BuildConfiguration,
plugins: List[str],
working_set: WorkingSet,
is_v1_plugin: bool,
) -> None:
"""Load named plugins from the current working_set into the supplied build_configuration.
"Loading" a plugin here refers to calling registration methods -- it is assumed each plugin
is already on the path and an error will be thrown if it is not. Plugins should define their
entrypoints in the `pantsbuild.plugin` group when configuring their distribution.
Like source backends, the `build_file_aliases`, `global_subsystems` and `register_goals` methods
are called if those entry points are defined.
* Plugins are loaded in the order they are provided. *
This is important as loading can add, remove or replace existing tasks installed by other plugins.
If a plugin needs to assert that another plugin is registered before it, it can define an
entrypoint "load_after" which can return a list of plugins which must have been loaded before it
can be loaded. This does not change the order or what plugins are loaded in any way -- it is
purely an assertion to guard against misconfiguration.
:param build_configuration: The BuildConfiguration (for adding aliases).
:param plugins: A list of plugin names optionally with versions, in requirement format.
eg ['widgetpublish', 'widgetgen==1.2'].
:param working_set: A pkg_resources.WorkingSet to load plugins from.
:param is_v1_plugin: Whether this is a v1 or v2 plugin.
"""
loaded: Dict = {}
for plugin in plugins or []:
req = Requirement.parse(plugin)
dist = working_set.find(req)
if not dist:
raise PluginNotFound(f"Could not find plugin: {req}")
entries = dist.get_entry_map().get("pantsbuild.plugin", {})
if "load_after" in entries:
deps = entries["load_after"].load()()
for dep_name in deps:
dep = Requirement.parse(dep_name)
if dep.key not in loaded:
raise PluginLoadOrderError(
f"Plugin {plugin} must be loaded after {dep}")
if is_v1_plugin:
if "register_goals" in entries:
entries["register_goals"].load()()
# TODO: Might v2 plugins need to register global subsystems? Hopefully not.
if "global_subsystems" in entries:
subsystems = entries["global_subsystems"].load()()
build_configuration.register_optionables(subsystems)
# The v2 target API is still TBD, so we keep build_file_aliases as a v1-only thing.
# Having thus no overlap between v1 and v2 backend entrypoints makes things much simpler.
# TODO: Revisit, ideally with a v2-only entry point, once the v2 target API is a thing.
if "build_file_aliases" in entries:
aliases = entries["build_file_aliases"].load()()
build_configuration.register_aliases(aliases)
else:
if "rules" in entries:
rules = entries["rules"].load()()
build_configuration.register_rules(rules)
if "build_file_aliases2" in entries:
build_file_aliases2 = entries["build_file_aliases2"].load()()
build_configuration.register_aliases(build_file_aliases2)
loaded[dist.as_requirement().key] = dist
class SetupEggSubRecipe(BaseDownloadSubRecipe):
@property
@reify
def index_url(self):
return self.options.get(
'index',
self.recipe.buildout['buildout'].get('index', default_index_url))
@property
@reify
def find_links_urls(self):
return self.options.get(
'find-links',
self.recipe.buildout['buildout'].get('find-links', '')).split()
@property
@reify
def source_key_processors(self):
return {
'egg': lambda x: [('egg', x.strip())],
'eggs': lambda x: [('egg', y.strip()) for y in x.splitlines()],
}
@property
@reify
def source_option_processors(self):
ret = super(SetupEggSubRecipe, self).source_option_processors.copy()
ret.update({
'build': string_as_bool,
'build-dependencies': string_as_bool,
'extra-paths': lambda x: [x.strip() for x in x.splitlines()],
'egg-path': lambda x: [x.strip() for x in x.splitlines()],
})
return ret
@property
@reify
def allowed_options(self):
ret = copy(super(SetupEggSubRecipe, self).allowed_options)
ret.extend([
'egg-name',
'find-egg',
'path',
'signature',
'url',
])
for stage in ['after-build']:
ret.extend([
self.resolve_stage('patch', stage=stage),
self.resolve_stage('patch-options', stage=stage),
self.resolve_stage('patch-binary', stage=stage),
])
return ret
def initialize(self):
super(SetupEggSubRecipe, self).initialize()
if self.recipe.options.get_as_bool('split-working-set', False):
self.working_set = WorkingSet([])
else:
self.working_set = self.recipe.working_set
self.index = get_index(self.index_url, self.find_links_urls)
def default_eggs_directory(self, develop=False):
if develop and 'develop-eggs-directory' in self.recipe.buildout['buildout']:
return self.recipe.buildout['buildout']['develop-eggs-directory']
elif 'eggs-directory' in self.recipe.buildout['buildout']:
return self.recipe.buildout['buildout']['eggs-directory']
else:
return os.path.join(os.path.dirname(sys.argv[0]), '..', 'eggs')
def populate_source(self, source, dependency=False):
super(SetupEggSubRecipe, self).populate_source(
source, load_options=not dependency)
if 'egg' not in source:
source['egg'] = self.name
source['requirement'] = Requirement.parse(source['egg'])
source['egg'] = str(source['requirement'])
source['find-requirement'] = Requirement.parse(source['find-egg']) \
if 'find-egg' in source else source['requirement']
source['find-egg'] = str(source['find-requirement'])
source.setdefault('build', True)
egg_directories = []
if 'develop-eggs-directory' in self.recipe.buildout['buildout']:
egg_directories.append(self.recipe.buildout['buildout']['develop-eggs-directory'])
if 'eggs-directory' in self.recipe.buildout['buildout']:
egg_directories.append(self.recipe.buildout['buildout']['eggs-directory'])
source.setdefault('egg-path',
[source['location']] if 'location' in source else [] +
source.get('extra-paths', []) + egg_directories +
buildout_and_setuptools_path)
source.setdefault('location',
self.default_eggs_directory(develop=source.get('develop', False)))
source['egg-environment'] = Environment(source['egg-path'])
source['build-options'] = {}
if not dependency:
for src_key, dst_key in [(key, re.sub('-', '_', key)) for key in
[option for option in self.options
if option in BUILD_EXT_OPTIONS]]:
source['build-options'][dst_key] = self.options[src_key]
source.setdefault('signature', self.resolve_signature(source))
def process_source(self, source):
if self.working_set.find(source['requirement']) is not None:
return
if source['build']:
self.build_source(source)
self.patch_source(source, cwdkey='build-directory',
stage='after-build')
self.install_source(source)
def acquire_source(self, source, destkey='working-directory'):
candidates = self.requirement_match_list(source['egg-environment'], source['requirement'],
strip_signature=source['signature'])
if not candidates or self.recipe.newest:
if 'url' not in source:
if self.recipe.offline:
raise UserError(
'''Couldn't download index "{}" in offline mode.'''.format(self.index))
self.index.find_packages(source['find-requirement'])
distributions = self.requirement_match_list(
self.index, source['find-requirement'],
requirement_type=self.requirement_type(source))
if not distributions:
raise UserError('''No distributions available for requirement "{}".'''.format(
source['find-egg']))
if not candidates or distributions[0].parsed_version > candidates[0].parsed_version:
source['url'] = distributions[0].location
source['egg-name'] = distributions[0].egg_name()
else:
source['source-directory'] = candidates[0].location
source['build'] = False
source['egg-name'] = candidates[0].egg_name()
if 'source-directory' not in source:
self.logger.info("Getting distribution for '{}'.".format(
source['requirement'].project_name))
super(SetupEggSubRecipe, self).acquire_source(source, destkey=destkey)
else:
source['source-directory'] = candidates[0].location
source['build'] = False
source['egg-name'] = candidates[0].egg_name()
if source.get('build-dependencies', True):
sourceenv = Environment([source['source-directory']])
for key in sourceenv:
for dist in sourceenv[key]:
for dependency_requirement in dist.requires():
dependency_source = {'egg': str(
dependency_requirement), 'parent-egg': str(source['egg'])}
self.sources.insert(self.sources.index(
source), dependency_source)
self.populate_source(
dependency_source, dependency=True)
self.prepare_source(dependency_source)
def build_source(self, source):
self.logger.info('''Building: {}'''.format(source['egg-name']))
undo = []
setup_py = os.path.join(source['source-directory'], 'setup.py')
try:
setup_cfg = os.path.join(source['source-directory'], 'setup.cfg')
if os.path.exists(setup_cfg):
os.rename(setup_cfg, setup_cfg + '-develop-aside')
def restore_old_setup():
if os.path.exists(setup_cfg):
os.remove(setup_cfg)
os.rename(setup_cfg + '-develop-aside', setup_cfg)
undo.append(restore_old_setup)
else:
open(setup_cfg, 'w').close()
undo.append(lambda: os.remove(setup_cfg))
updates = {}
if source['build-options']:
updates['build_ext'] = source['build-options']
if source['signature']:
updates['egg_info'] = {
'tag_build': "_{}".format(source['signature']),
}
setuptools_edit_config(setup_cfg, updates)
setup_cmd_fd, setup_cmd = mkstemp(dir=source['source-directory'])
setup_cmd_fh = os.fdopen(setup_cmd_fd, 'w')
undo.append(lambda: os.remove(setup_cmd))
undo.append(setup_cmd_fh.close)
setup_cmd_fh.write((setup_template % dict(
setuptools=setuptools_location,
setupdir=source['source-directory'],
setup=setup_py,
__file__=setup_py,
)).encode())
setup_cmd_fh.flush()
build_directory = mkdtemp('build',
dir=source['source-directory'])
action_args = []
if source.get('develop', False) is True:
action = 'develop'
action_args.append('-Z')
else:
action = 'easy_install'
action_args.append(source['source-directory'])
args = [source['executable'], setup_cmd, action, '-mxNd',
build_directory]
if self.log_level < logging.INFO:
args += ['-v']
elif self.log_level > logging.INFO:
args += ['-q']
args += action_args
self.logger.debug('''Running: {}'''.format(' '.join(args)))
self.recipe.call(*args, stdout_log_level=logging.DEBUG)
source['build-directory'] = build_directory
finally:
for obj in reversed(undo):
obj()
def install_source(self, source, destkey='location'):
if 'build-directory' not in source:
return
env = Environment([source['build-directory']])
self.recipe.mkdir(source[destkey])
for dists in [env[x] for x in env]:
for src_dist in dists:
dst_dist = src_dist.clone(
location=os.path.join(source[destkey],
"{}.{}".format(src_dist.egg_name(), {
EGG_DIST: 'egg',
DEVELOP_DIST: 'egg-link',
}[src_dist.precedence])))
{
EGG_DIST: lambda src, dst:
self.recipe.copy(src, dst)
if os.path.isdir(src) else
self.recipe.extract_archive(src, dst),
DEVELOP_DIST: os.rename,
}[src_dist.precedence](src_dist.location, dst_dist.location)
# redo_pyc(newloc)
self.working_set.add_entry(dst_dist.location)
self.logger.info('''Got {}.'''.format(
str(dst_dist.egg_name())))
@classmethod
def requirement_match_list(cls, index, requirement, requirement_type=None,
prefer_final=True, strip_signature=''):
def mangle_candidate(dist):
if strip_signature:
dist = dist.clone(version=re.sub(
r'_{}$'.format(strip_signature), '', dist.version))
return dist
candidates = [candidate for candidate in index[requirement.project_name]
if mangle_candidate(candidate) in requirement]
if not candidates:
return []
if requirement_type is not None:
candidates = [candidate for candidate in candidates
if candidate.precedence == requirement_type]
if prefer_final:
final_candidates = [candidate for candidate in candidates
if not candidate.parsed_version.is_prerelease]
if final_candidates:
candidates = final_candidates
best = []
bestv = None
for candidate in candidates:
candidatev = candidate.parsed_version
if not bestv or candidatev > bestv:
best = [candidate]
bestv = candidatev
elif candidatev == bestv:
best.append(candidate)
best.sort()
return best
@classmethod
def requirement_type(cls, source):
egg_type = source.get('egg-type', None)
try:
return {
'source': SOURCE_DIST,
'binary': BINARY_DIST,
None: None,
}[egg_type]
except KeyError:
return None
@classmethod
def resolve_signature(cls, source):
struct = []
for key, value in source['build-options'].items():
struct.append((key, value))
for key in ('patches', 'patch-options', 'patch-binary'):
if key in source:
struct.append(source[key])
struct = tuple(struct) # pylint: disable=redefined-variable-type
if not struct:
return None
base = string.digits + string.letters
base_length = len(base)
ret = ''
struct_hash = abs(hash(struct))
while struct_hash > 0:
ret = base[struct_hash % base_length] + ret
struct_hash /= base_length
return "{}_{}".format(SIGNATURE_MARKER, ret)
def load_plugins(
build_configuration: BuildConfiguration,
plugins: List[str],
working_set: WorkingSet,
is_v1_plugin: bool,
) -> None:
"""Load named plugins from the current working_set into the supplied build_configuration.
"Loading" a plugin here refers to calling registration methods -- it is assumed each plugin
is already on the path and an error will be thrown if it is not. Plugins should define their
entrypoints in the `pantsbuild.plugin` group when configuring their distribution.
Like source backends, the `build_file_aliases`, `global_subsystems` and `register_goals` methods
are called if those entry points are defined.
* Plugins are loaded in the order they are provided. *
This is important as loading can add, remove or replace existing tasks installed by other plugins.
If a plugin needs to assert that another plugin is registered before it, it can define an
entrypoint "load_after" which can return a list of plugins which must have been loaded before it
can be loaded. This does not change the order or what plugins are loaded in any way -- it is
purely an assertion to guard against misconfiguration.
:param build_configuration: The BuildConfiguration (for adding aliases).
:param plugins: A list of plugin names optionally with versions, in requirement format.
eg ['widgetpublish', 'widgetgen==1.2'].
:param working_set: A pkg_resources.WorkingSet to load plugins from.
:param is_v1_plugin: Whether this is a v1 or v2 plugin.
"""
loaded: Dict = {}
for plugin in plugins or []:
req = Requirement.parse(plugin)
dist = working_set.find(req)
if not dist:
raise PluginNotFound(f"Could not find plugin: {req}")
entries = dist.get_entry_map().get("pantsbuild.plugin", {})
if "load_after" in entries:
deps = entries["load_after"].load()()
for dep_name in deps:
dep = Requirement.parse(dep_name)
if dep.key not in loaded:
raise PluginLoadOrderError(f"Plugin {plugin} must be loaded after {dep}")
# While the Target API is a V2 concept, we expect V1 plugin authors to still write Target
# API bindings. So, we end up using this entry point regardless of V1 vs. V2.
if "targets2" in entries:
targets = entries["targets2"].load()()
build_configuration.register_targets(targets)
if is_v1_plugin:
if "register_goals" in entries:
entries["register_goals"].load()()
if "global_subsystems" in entries:
subsystems = entries["global_subsystems"].load()()
build_configuration.register_optionables(subsystems)
# For now, `build_file_aliases` is still V1-only. TBD what entry-point we use for
# `objects` and `context_aware_object_factories`.
if "build_file_aliases" in entries:
aliases = entries["build_file_aliases"].load()()
build_configuration.register_aliases(aliases)
else:
if "rules" in entries:
rules = entries["rules"].load()()
build_configuration.register_rules(rules)
if "build_file_aliases2" in entries:
build_file_aliases2 = entries["build_file_aliases2"].load()()
build_configuration.register_aliases(build_file_aliases2)
if "targets2" in entries:
targets = entries["targets2"].load()()
build_configuration.register_targets(targets)
loaded[dist.as_requirement().key] = dist
migrate_dist = get_distribution('sqlalchemy-migrate>=0.6')
migrate = __import__('migrate')
except DistributionNotFound, ImportError:
raise SystemExit(
u"\n"
u"WARNING: 'sqlalchemy-migrate' not found, this is a bug in setup.py file!\n"
u"WARNING: El sistema se ha actualizado pero NO la base de datos. :("
)
cwd = os.path.dirname(os.path.abspath(__file__))
sys_path = copy(sys.path)
if cwd in sys_path:
sys_path.remove(cwd)
req = Requirement.parse(NAME)
ws = WorkingSet(sys_path)
old_nobix = ws.find(req)
new_nobix = get_distribution(NAME)
if not old_nobix:
return
if old_nobix.parsed_version < new_nobix.parsed_version:
database_uri = get_config_db_uri(old_nobix.location)
if database_uri:
print u"\nUpgrading Nobix database %s -> %s ..." % (old_nobix.version, new_nobix.version),
upgrade_db(uri=database_uri)
else:
raise SystemExit(
u"\n"
u"WARNING: No se puede obtener el nombre de la base de datos.\n"
u"WARNING: El sistema se ha actualizado pero NO la base de datos. :("
