def add_intradependencies(graph):
"""ensure that downstream packages wait for upstream build/test (not use existing
available packages)"""
for node in graph.nodes():
if 'meta' not in graph.node[node]:
continue
# get build dependencies
m = graph.node[node]['meta']
# this is pretty hard. Realistically, we would want to know
# what the build and host platforms are on the build machine.
# However, all we know right now is what machine we're actually
# on (the one calculating the graph).
deps = set(m.ms_depends('build') + m.ms_depends('host') + m.ms_depends('run') +
[conda_interface.MatchSpec(dep) for dep in
ensure_list((m.meta.get('test') or {}).get('requires'))])
for dep in deps:
name_matches = (n for n in graph.nodes() if graph.node[n]['meta'].name() == dep.name)
for matching_node in name_matches:
# are any of these build dependencies also nodes in our graph?
match_meta = graph.node[matching_node]['meta']
if (match_peer_job(conda_interface.MatchSpec(dep), match_meta, m) and
(node, matching_node) not in graph.edges()):
# inside if statement because getting used vars is expensive
shared_vars = set(match_meta.get_used_vars()) & set(m.get_used_vars())
# all vars in variant that they both use must line up
if all(match_meta.config.variant[v] == m.config.variant[v]
for v in shared_vars):
# add edges if they don't already exist
graph.add_edge(node, matching_node)
def add_intradependencies(graph):
"""ensure that downstream packages wait for upstream build/test (not use existing
available packages)"""
for node in graph.nodes():
if 'meta' not in graph.node[node]:
continue
# get build dependencies
m = graph.node[node]['meta']
# this is pretty hard. Realistically, we would want to know
# what the build and host platforms are on the build machine.
# However, all we know right now is what machine we're actually
# on (the one calculating the graph).
deps = set(
m.ms_depends('build') + m.ms_depends('host') +
m.ms_depends('run') + [
conda_interface.MatchSpec(dep)
for dep in m.meta.get('test', {}).get('requires', [])
])
for dep in deps:
name_matches = (n for n in graph.nodes()
if graph.node[n]['meta'].name() == dep.name)
for matching_node in name_matches:
# are any of these build dependencies also nodes in our graph?
if (match_peer_job(conda_interface.MatchSpec(dep),
graph.node[matching_node]['meta'], m)
and (node, matching_node) not in graph.edges()):
# add edges if they don't already exist
graph.add_edge(node, matching_node)
def add_intradependencies(graph):
"""ensure that downstream packages wait for upstream build/test (not use existing
available packages)"""
for node in graph.nodes():
if 'meta' not in graph.nodes[node]:
continue
# get build dependencies
m = graph.nodes[node]['meta']
if hasattr(m, 'other_outputs'):
internal_deps = tuple(i[0] for i in m.other_outputs)
else:
internal_deps = ()
# this is pretty hard. Realistically, we would want to know
# what the build and host platforms are on the build machine.
# However, all we know right now is what machine we're actually
# on (the one calculating the graph).
deps = set(
m.ms_depends('build') + m.ms_depends('host') +
m.ms_depends('run') + [
conda_interface.MatchSpec(dep) for dep in ensure_list(
(m.meta.get('test') or {}).get('requires'))
])
for dep in deps:
# Ignore all dependecies that are outputs of the current recipe.
# These may not always match because of version differents but
# without this recipe with outputs which depend on each other
# cannot be submitted
if dep.name in internal_deps:
continue
name_matches = (n for n in graph.nodes()
if graph.nodes[n]['meta'].name() == dep.name)
for matching_node in name_matches:
# are any of these build dependencies also nodes in our graph?
match_meta = graph.nodes[matching_node]['meta']
if (match_peer_job(conda_interface.MatchSpec(dep), match_meta,
m)
and (node, matching_node) not in graph.edges()):
# inside if statement because getting used vars is expensive
shared_vars = set(match_meta.get_used_vars()) & set(
m.get_used_vars())
# all vars in variant that they both use must line up
if all(match_meta.config.variant[v] == m.config.variant[v]
for v in shared_vars):
# add edges if they don't already exist
graph.add_edge(node, matching_node)
def _installable(name, version, build_string, config, conda_resolve):
"""Can Conda install the package we need?"""
ms = conda_interface.MatchSpec(" ".join([name, _fix_any(version, config),
_fix_any(build_string, config)]))
installable = conda_resolve.find_matches(ms)
if not installable:
log.warn("Dependency {name}, version {ver} is not installable from your "
"channels: {channels} with subdir {subdir}. Seeing if we can build it..."
.format(name=name, ver=version, channels=config.channel_urls,
subdir=config.host_subdir))
return installable
def _buildable(package, version=""):
"""Does the recipe that we have available produce the package we need?"""
available = False
if os.path.isdir(package):
metadata, _, _ = api.render(package)
match_dict = {
'name': metadata.name(),
'version': metadata.version(),
'build': metadata.build_number(),
}
ms = conda_interface.MatchSpec(" ".join([package, version]))
available = ms.match(match_dict)
return available
def _buildable(name, version, recipes_dir, worker, config, finalize):
"""Does the recipe that we have available produce the package we need?"""
possible_dirs = os.listdir(recipes_dir)
packagename_re = re.compile(r'%s(?:\-[0-9]+[\.0-9\_\-a-zA-Z]*)?$' % name)
likely_dirs = (dirname for dirname in possible_dirs if
(os.path.isdir(os.path.join(recipes_dir, dirname)) and
packagename_re.match(dirname)))
metadata_tuples = [m for path in likely_dirs
for (m, _, _) in _get_or_render_metadata(os.path.join(recipes_dir,
path), worker, finalize=finalize)]
# this is our target match
ms = conda_interface.MatchSpec(" ".join([name, _fix_any(version, config)]))
available = False
for m in metadata_tuples:
available = match_peer_job(ms, m)
if available:
break
return m.meta_path if available else False
def _installable(package, version, conda_resolve):
"""Can Conda install the package we need?"""
return conda_resolve.valid(conda_interface.MatchSpec(" ".join(
[package, version])),
filter=conda_resolve.default_filter())
