Parallel node definition. More...
Inheritance diagram for lib.nodes.parallel.Parallel:
Public Member Functions | |
| def | __attrs_post_init__ (self) |
| Assigns node's name and id. More... | |
| def | __repr__ (self) |
| def | make_sequence (self) |
| Builds this sequence execution graph. More... | |
 Public Member Functions inherited from lib.nodes.sequence.Sequence | |
| def | __iter__ (self) |
| def | context (self) |
| Get context dictionary, preferably from root node. More... | |
| def | context (self, ctx) |
| def | seq (self) |
| Retrieves the sequence list. More... | |
| def | seq (self, s) |
| List used to create the Sequence's graph. More... | |
| def | G (self) |
| returns the graph object More... | |
| def | start_step (self) |
| def | end_step (self) |
| def | start_node (self) |
| Returns the start node. More... | |
| def | end_node (self) |
| Returns the end node. More... | |
| def | append (self, s) |
| Appends a node to the Sequence. More... | |
| def | create_node_tasks (self, resume=False) |
| Creates Task object associated to this node. More... | |
| def | reschedule_node (self, node_id) |
| Reschedule a node for execution. More... | |
| def | start (self, make_sequence=True, resume=False) |
| This is the entry point for Sequence execution. More... | |
| def | run (self) |
| def | execute (self, resume=False) |
| def | resume (self) |
| def | main_task (self) |
| Returns the objective node of the sequence – the end node. More... | |
| def | __call__ (self, resume=False) |
| def | abort (self) |
| Aborts the sequence. More... | |
| def | nodes (self) |
| Return nodes from Graph. More... | |
| def | get_node (self, node_id) |
| Get node by id. More... | |
| def | get_task (self, node_id) |
| Get task by node_id. More... | |
| def | state (self) |
| Gets the node state. More... | |
| def | state (self, value) |
| Sets the node state. More... | |
| def | publish_state (self) |
| def | state (self, value) |
| Sets the node state. More... | |
| Public Member Functions inherited from lib.nodes.interface._BaseNode | |
| def | result (self) |
| Node's result. More... | |
| def | result (self, val) |
| def | full_state (self) |
| Gets the node state. More... | |
| def | in_error (self) |
| def | skip (self) |
| def | skip (self, flag=True) |
| def | in_error (self, flag=True) |
| def | make_task (self, node, input_list, resume) |
| Creates the task object that executes the node. More... | |
| def | pause (self) |
Static Public Member Functions | |
| def | create (*args, **kw) |
Creates a :class:Parallel node. More... | |
| Static Public Member Functions inherited from lib.nodes.sequence.Sequence | |
| def | get_context () |
Public Attributes | |
| name | |
| seq | |
| Public Attributes inherited from lib.nodes.sequence.Sequence | |
| name | |
| id | |
| serial_number | |
| state | |
| node state More... | |
| in_error | |
| runtime_flags | |
| t_start | |
| skip | |
| exception | |
| t_end | |
Static Public Attributes | |
| seq_args = attr.ib(kw_only=True, default=attr.Factory(list), repr=False) | |
| Static Public Attributes inherited from lib.nodes.sequence.Sequence | |
| graph = attr.ib(init=False, default=attr.Factory(nx.DiGraph), repr=False) | |
| debug = attr.ib(init=False, default=False, repr=False) | |
| current_tpl = cv.ContextVar("current_tpl", default=None) | |
| root = cv.ContextVar("root", default=None) | |
| Static Public Attributes inherited from lib.nodes.interface._BaseNode | |
| serial_number = attr.ib(default=0, kw_only=True) | |
| id = attr.ib(default=None, kw_only=True) | |
| name = attr.ib(default=None, kw_only=True) | |
| runtime_flags = attr.ib(default=0, init=False) | |
| deps = attr.ib(default=attr.Factory(list), repr=False, kw_only=True, init=False) | |
| description = attr.ib(default="", kw_only=True) | |
| exception = attr.ib(init=False, default=None, repr=False) | |
| can_skip = attr.ib(default=True, init=False) | |
| hide = attr.ib(default=False, init=False) | |
| t_start = attr.ib(init=False, default=None, repr=False) | |
| t_end = attr.ib(init=False, default=None, repr=False) | |
| running_checkpoint | |
Detailed Description
Parallel node definition.
Use the :meth:create method to build properly :class:Parallel nodes. Since it inherits from :class:Sequence it has access to the same context variables.
Examples
One can access the running Sequence using Sequence.current_tpl context variable.
>>> s = Parallel.create(a,b, name="my sequence")
# execute Sequence
>>> await s.start()
# Get running Sequence from Inside function a():
>>> def a():
... current_tpl = Sequence.current_tpl
... # now current_tpl is the node s
... assert current_tpl == s
Member Function Documentation
◆ __attrs_post_init__()
| def lib.nodes.parallel.Parallel.__attrs_post_init__ | ( | self | ) |
Assigns node's name and id.
Reimplemented from lib.nodes.sequence.Sequence.
◆ __repr__()
| def lib.nodes.parallel.Parallel.__repr__ | ( | self | ) |
◆ create()
|
static |
Creates a :class:Parallel node.
*args: Variable length list of nodes or coroutines that compose the sequence.
- Parameters
-
id Node id name node name
Reimplemented from lib.nodes.sequence.Sequence.
◆ make_sequence()
| def lib.nodes.parallel.Parallel.make_sequence | ( | self | ) |
Builds this sequence execution graph.
Reimplemented from lib.nodes.sequence.Sequence.
Member Data Documentation
◆ name
| lib.nodes.parallel.Parallel.name |
◆ seq
| lib.nodes.parallel.Parallel.seq |
◆ seq_args
|
static |
The documentation for this class was generated from the following file:
- seq/seqlib/src/seq/lib/nodes/parallel.py
