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)