def _create_step(self, node_entry):
"""Creates a Step and Promise with the currently available dependencies of the given Node.
If the dependencies of a Node are not available, returns None.
TODO: Content addressing node and its dependencies should only happen if node is cacheable
or in a multi-process environment.
"""
Node.validate_node(node_entry.node)
# See whether all of the dependencies for the node are available.
deps = dict()
for dep_entry in node_entry.dependencies:
if not dep_entry.is_complete:
return None
deps[dep_entry.node] = dep_entry.state
# Additionally, include Noops for any dependencies that were cyclic.
for dep in node_entry.cyclic_dependencies:
deps[dep] = Noop.cycle(node_entry.node, dep)
# Ready.
self._step_id += 1
step_request = StepRequest(self._step_id,
node_entry.node,
deps,
self._inline_nodes,
self._project_tree)
return (step_request, Promise())
def _create_step(self, node_entry):
"""Creates a Step and Promise with the currently available dependencies of the given Node.
If the dependencies of a Node are not available, returns None.
TODO: Content addressing node and its dependencies should only happen if node is cacheable
or in a multi-process environment.
"""
Node.validate_node(node_entry.node)
# See whether all of the dependencies for the node are available.
deps = dict()
for dep_entry in node_entry.dependencies:
if not dep_entry.is_complete:
return None
deps[dep_entry.node] = dep_entry.state
# Additionally, include Noops for any dependencies that were cyclic.
for dep in node_entry.cyclic_dependencies:
deps[dep] = Noop.cycle(node_entry.node, dep)
# Ready.
self._step_id += 1
step_request = StepRequest(self._step_id,
node_entry.node,
deps,
self._inline_nodes,
self._project_tree)
return (step_request, Promise())
def _trace(entry, level):
if type(entry.state) in (Noop, Return):
return
yield '{}{}'.format(' ' * level, entry.state)
for dep in entry.cyclic_dependencies:
yield '{}{}'.format(' ' * level, Noop.cycle(entry.node, dep))
for dep_entry in entry.dependencies:
for l in _trace(dep_entry, level+1):
yield l
def _trace(entry, level):
if type(entry.state) in (Noop, Return):
return
yield '{}{}'.format(' ' * level, entry.state)
for dep in entry.cyclic_dependencies:
yield '{}{}'.format(' ' * level, Noop.cycle(entry.node, dep))
for dep_entry in entry.dependencies:
for l in _trace(dep_entry, level + 1):
yield l
def _trace(entry, level):
if is_bottom(entry):
return
traced.add(entry)
yield _format(level, entry, entry.state)
for dep in entry.cyclic_dependencies:
yield _format(level, entry, Noop.cycle(entry.node, dep))
for dep_entry in entry.dependencies:
for l in _trace(dep_entry, level+1):
yield l
def _trace(entry, level):
if is_bottom(entry):
return
traced.add(entry)
yield _format(level, entry, entry.state)
for dep in entry.cyclic_dependencies:
yield _format(level, entry, Noop.cycle(entry.node, dep))
for dep_entry in entry.dependencies:
for l in _trace(dep_entry, level + 1):
yield l
def _trace(entry, level):
if type(entry.state) in (Noop, Return) or entry in traced:
return
traced.add(entry)
yield _format(level, entry.node, entry.state)
for dep in entry.cyclic_dependencies:
yield _format(level, entry.node, Noop.cycle(entry.node, dep))
for dep_entry in entry.dependencies:
for l in _trace(dep_entry, level+1):
yield l
def _trace(entry, level):
if type(entry.state) in (Noop, Return) or entry in traced:
return
traced.add(entry)
yield _format(level, entry.node, entry.state)
for dep in entry.cyclic_dependencies:
yield _format(level, entry.node, Noop.cycle(entry.node, dep))
for dep_entry in entry.dependencies:
for l in _trace(dep_entry, level + 1):
yield l
def _attempt_run_step(self, node_entry):
"""Attempt to run a Step with the currently available dependencies of the given Node.
If the currently declared dependencies of a Node are not yet available, returns None. If
they are available, runs a Step and returns the resulting State.
"""
# See whether all of the dependencies for the node are available.
if any(not dep_entry.is_complete for dep_entry in node_entry.dependencies):
return None
# Collect the deps.
deps = dict()
for dep_entry in node_entry.dependencies:
deps[dep_entry.node] = dep_entry.state
# Additionally, include Noops for any dependencies that were cyclic.
for dep in node_entry.cyclic_dependencies:
deps[dep] = Noop.cycle(node_entry.node, dep)
# Run.
step_context = StepContext(self.node_builder, self._project_tree, deps, self._inline_nodes)
return node_entry.node.step(step_context)
def _attempt_run_step(self, node_entry):
"""Attempt to run a Step with the currently available dependencies of the given Node.
If the currently declared dependencies of a Node are not yet available, returns None. If
they are available, runs a Step and returns the resulting State.
"""
# See whether all of the dependencies for the node are available.
if any(not dep_entry.is_complete for dep_entry in node_entry.dependencies):
return None
# Collect the deps.
deps = dict()
for dep_entry in node_entry.dependencies:
deps[dep_entry.node] = dep_entry.state
# Additionally, include Noops for any dependencies that were cyclic.
for dep in node_entry.cyclic_dependencies:
deps[dep] = Noop.cycle(node_entry.node, dep)
# Run.
step_context = StepContext(self.node_builder, self._project_tree, deps, self._inline_nodes)
return node_entry.node.step(step_context)
