Vishesh 'ironeagle' Bangotra
a32eeaf2b4
- collect.py copies each repo's built site contents directly to a top-level <repo>/ dir (was libs|apis|wiki/<repo>/site nesting) - nginx uses `index index.html lib/index.html api/index.html` so /dagpipe/ -> lib/index.html, /auth-server/ -> api/index.html are served internally with no redirects - _index regenerates links against the flat layout (/dagpipe/lib/, /auth-server/api/, /mongo-ops/, /blog/...) - config.yml static entries point at vendored blog/ + media-manager/ - Dockerfile copies per-repo dirs flat into the nginx html root - removed stale libs/, apis/, wiki/, tutorials/ category trees
485 lines
28 KiB
JSON
485 lines
28 KiB
JSON
{
|
||
"module": "dagpipe.engine",
|
||
"content": {
|
||
"path": "dagpipe.engine",
|
||
"docstring": "# Summary\n\nExecution engine responsible for running pipelines and graphs.\n\nThe `Engine` executes `Node` objects and propagates immutable `State` instances\nthrough either a linear sequence or a directed acyclic graph (`Graph`).\nIt orchestrates execution order, branching, and state propagation.\n\n---\n\n# Guarantees\n\n- Deterministic execution and consistent state lineage.\n- Orchestrates execution without modifying `Graph`, `Node`, or `State` objects.",
|
||
"objects": {
|
||
"deque": {
|
||
"name": "deque",
|
||
"kind": "alias",
|
||
"path": "dagpipe.engine.deque",
|
||
"signature": "<bound method Alias.signature of Alias('deque', 'collections.deque')>",
|
||
"docstring": null
|
||
},
|
||
"AsyncIterator": {
|
||
"name": "AsyncIterator",
|
||
"kind": "alias",
|
||
"path": "dagpipe.engine.AsyncIterator",
|
||
"signature": "<bound method Alias.signature of Alias('AsyncIterator', 'collections.abc.AsyncIterator')>",
|
||
"docstring": null
|
||
},
|
||
"Awaitable": {
|
||
"name": "Awaitable",
|
||
"kind": "alias",
|
||
"path": "dagpipe.engine.Awaitable",
|
||
"signature": "<bound method Alias.signature of Alias('Awaitable', 'collections.abc.Awaitable')>",
|
||
"docstring": null
|
||
},
|
||
"Callable": {
|
||
"name": "Callable",
|
||
"kind": "alias",
|
||
"path": "dagpipe.engine.Callable",
|
||
"signature": "<bound method Alias.signature of Alias('Callable', 'collections.abc.Callable')>",
|
||
"docstring": null
|
||
},
|
||
"Iterator": {
|
||
"name": "Iterator",
|
||
"kind": "alias",
|
||
"path": "dagpipe.engine.Iterator",
|
||
"signature": "<bound method Alias.signature of Alias('Iterator', 'collections.abc.Iterator')>",
|
||
"docstring": null
|
||
},
|
||
"Sequence": {
|
||
"name": "Sequence",
|
||
"kind": "alias",
|
||
"path": "dagpipe.engine.Sequence",
|
||
"signature": "<bound method Alias.signature of Alias('Sequence', 'collections.abc.Sequence')>",
|
||
"docstring": null
|
||
},
|
||
"Any": {
|
||
"name": "Any",
|
||
"kind": "alias",
|
||
"path": "dagpipe.engine.Any",
|
||
"signature": "<bound method Alias.signature of Alias('Any', 'typing.Any')>",
|
||
"docstring": null
|
||
},
|
||
"Optional": {
|
||
"name": "Optional",
|
||
"kind": "alias",
|
||
"path": "dagpipe.engine.Optional",
|
||
"signature": "<bound method Alias.signature of Alias('Optional', 'typing.Optional')>",
|
||
"docstring": null
|
||
},
|
||
"Graph": {
|
||
"name": "Graph",
|
||
"kind": "class",
|
||
"path": "dagpipe.engine.Graph",
|
||
"signature": "<bound method Alias.signature of Alias('Graph', 'dagpipe.graph.Graph')>",
|
||
"docstring": "Directed Acyclic Graph defining execution topology of `Node` objects.\n\nNotes:\n **Responsibilities:**\n\n - Stores node connectivity and validates that the topology remains acyclic.\n - Structure determines how `State` flows between nodes during execution.\n\n **Guarantees:**\n\n - Topology is acyclic. Node relationships remain consistent.\n - Thread-safe for concurrent reads after construction.",
|
||
"members": {
|
||
"add_edge": {
|
||
"name": "add_edge",
|
||
"kind": "function",
|
||
"path": "dagpipe.engine.Graph.add_edge",
|
||
"signature": "<bound method Alias.signature of Alias('add_edge', 'dagpipe.graph.Graph.add_edge')>",
|
||
"docstring": "Add a directed edge from `src` to `dst`.\n\nArgs:\n src (Node):\n Source node.\n\n dst (Node):\n Destination node.\n\nRaises:\n TypeError:\n If `src` or `dst` is not a `Node`.\n\n ValueError:\n If the edge would create a cycle or if `src` and `dst` are common.\n\nNotes:\n - Validates node types.\n - Prevents cycles.\n - Registers nodes if not present.\n - Updates parent and child mappings."
|
||
},
|
||
"add_root": {
|
||
"name": "add_root",
|
||
"kind": "function",
|
||
"path": "dagpipe.engine.Graph.add_root",
|
||
"signature": "<bound method Alias.signature of Alias('add_root', 'dagpipe.graph.Graph.add_root')>",
|
||
"docstring": "Add a root node with no parents.\n\nArgs:\n node (Node):\n Node to add as a root.\n\nRaises:\n TypeError:\n If node is not a Node instance."
|
||
},
|
||
"children": {
|
||
"name": "children",
|
||
"kind": "function",
|
||
"path": "dagpipe.engine.Graph.children",
|
||
"signature": "<bound method Alias.signature of Alias('children', 'dagpipe.graph.Graph.children')>",
|
||
"docstring": "Return child nodes of a node.\n\nArgs:\n node (Node):\n Node to query.\n\nReturns:\n Tuple[Node, ...]:\n Outgoing neighbors."
|
||
},
|
||
"parents": {
|
||
"name": "parents",
|
||
"kind": "function",
|
||
"path": "dagpipe.engine.Graph.parents",
|
||
"signature": "<bound method Alias.signature of Alias('parents', 'dagpipe.graph.Graph.parents')>",
|
||
"docstring": "Return parent nodes of a node.\n\nArgs:\n node (Node):\n Node to query.\n\nReturns:\n Tuple[Node, ...]:\n Incoming neighbors."
|
||
},
|
||
"roots": {
|
||
"name": "roots",
|
||
"kind": "function",
|
||
"path": "dagpipe.engine.Graph.roots",
|
||
"signature": "<bound method Alias.signature of Alias('roots', 'dagpipe.graph.Graph.roots')>",
|
||
"docstring": "Return root nodes (nodes with no incoming edges).\n\nReturns:\n Tuple[Node, ...]:\n Entry point nodes."
|
||
},
|
||
"nodes": {
|
||
"name": "nodes",
|
||
"kind": "function",
|
||
"path": "dagpipe.engine.Graph.nodes",
|
||
"signature": "<bound method Alias.signature of Alias('nodes', 'dagpipe.graph.Graph.nodes')>",
|
||
"docstring": "Return all nodes in the graph.\n\nReturns:\n Tuple[Node, ...]:\n All registered nodes."
|
||
}
|
||
}
|
||
},
|
||
"AsyncNode": {
|
||
"name": "AsyncNode",
|
||
"kind": "class",
|
||
"path": "dagpipe.engine.AsyncNode",
|
||
"signature": "<bound method Alias.signature of Alias('AsyncNode', 'dagpipe.node.AsyncNode')>",
|
||
"docstring": "Base class for nodes whose execution is asynchronous.\n\nSubclasses implement `resolve_async` (an async generator yielding derived\n`State` objects). The engine dispatches to `resolve_async` when running an\nasync traversal (see `Engine.run_async`).\n\nSync-only engines (and the base `Node.run`) treat an `AsyncNode` as a no-op\nconsumer: calling `run` on an `AsyncNode` returns no states, signalling that\nan async engine is required.",
|
||
"members": {
|
||
"resolve": {
|
||
"name": "resolve",
|
||
"kind": "function",
|
||
"path": "dagpipe.engine.AsyncNode.resolve",
|
||
"signature": "<bound method Alias.signature of Alias('resolve', 'dagpipe.node.AsyncNode.resolve')>",
|
||
"docstring": null
|
||
},
|
||
"resolve_async": {
|
||
"name": "resolve_async",
|
||
"kind": "function",
|
||
"path": "dagpipe.engine.AsyncNode.resolve_async",
|
||
"signature": "<bound method Alias.signature of Alias('resolve_async', 'dagpipe.node.AsyncNode.resolve_async')>",
|
||
"docstring": "Execute node logic asynchronously.\n\nArgs:\n state (State):\n Input execution state.\n\nReturns:\n Iterable[State]:\n Derived execution state(s).\n\nNotes:\n Subclasses implement this. Must not mutate the input state.\n Should use `fork()` to create child states."
|
||
},
|
||
"run_async": {
|
||
"name": "run_async",
|
||
"kind": "function",
|
||
"path": "dagpipe.engine.AsyncNode.run_async",
|
||
"signature": "<bound method Alias.signature of Alias('run_async', 'dagpipe.node.AsyncNode.run_async')>",
|
||
"docstring": "Execute this node asynchronously on a state, validating outputs."
|
||
}
|
||
}
|
||
},
|
||
"Node": {
|
||
"name": "Node",
|
||
"kind": "class",
|
||
"path": "dagpipe.engine.Node",
|
||
"signature": "<bound method Alias.signature of Alias('Node', 'dagpipe.node.Node')>",
|
||
"docstring": "Base class for all dagpipe execution nodes.\n\nAttributes:\n id (str):\n Unique identifier of the node (snake_case dotted format).\n\n name (str):\n Human-readable display name.\n\nNotes:\n **Responsibilities:**\n\n - Represents a deterministic unit of execution in the pipeline graph.\n - Consumes one `State` and produces zero, one, or many derived states.\n - Defines execution logic and enables branching, filtering, and transformation.\n\n **Guarantees:**\n\n - Nodes must never mutate the input `State`.\n - Instances are singletons per subclass and reused across executions.",
|
||
"members": {
|
||
"id": {
|
||
"name": "id",
|
||
"kind": "attribute",
|
||
"path": "dagpipe.engine.Node.id",
|
||
"signature": "<bound method Alias.signature of Alias('id', 'dagpipe.node.Node.id')>",
|
||
"docstring": null
|
||
},
|
||
"name": {
|
||
"name": "name",
|
||
"kind": "attribute",
|
||
"path": "dagpipe.engine.Node.name",
|
||
"signature": "<bound method Alias.signature of Alias('name', 'dagpipe.node.Node.name')>",
|
||
"docstring": null
|
||
},
|
||
"node_id_to_name": {
|
||
"name": "node_id_to_name",
|
||
"kind": "function",
|
||
"path": "dagpipe.engine.Node.node_id_to_name",
|
||
"signature": "<bound method Alias.signature of Alias('node_id_to_name', 'dagpipe.node.Node.node_id_to_name')>",
|
||
"docstring": "Convert a dotted snake_case node ID into a human-readable name.\n\nArgs:\n node_id (str):\n Unique node identifier (e.g., 'entity.resolve.numeric_merchant').\n\nReturns:\n str:\n Human-readable display name (e.g., 'Entity › Resolve › Numeric Merchant')."
|
||
},
|
||
"clean_id_and_name": {
|
||
"name": "clean_id_and_name",
|
||
"kind": "function",
|
||
"path": "dagpipe.engine.Node.clean_id_and_name",
|
||
"signature": "<bound method Alias.signature of Alias('clean_id_and_name', 'dagpipe.node.Node.clean_id_and_name')>",
|
||
"docstring": "Normalize and validate node ID and display name.\n\nRaises:\n TypeError:\n If ID is not a string.\n ValueError:\n If ID format is invalid.\n\nNotes:\n **Guarantees:**\n\n - Generates ID from module and class name if missing.\n - Validates ID format.\n - Generates human-readable name if missing."
|
||
},
|
||
"run": {
|
||
"name": "run",
|
||
"kind": "function",
|
||
"path": "dagpipe.engine.Node.run",
|
||
"signature": "<bound method Alias.signature of Alias('run', 'dagpipe.node.Node.run')>",
|
||
"docstring": "Execute this node on a `State`.\n\nArgs:\n state (State):\n Input execution state.\n\nReturns:\n tuple[State, ...]:\n Derived execution states.\n\nRaises:\n TypeError:\n If `resolve()` yields a non-`State` object."
|
||
},
|
||
"fork": {
|
||
"name": "fork",
|
||
"kind": "function",
|
||
"path": "dagpipe.engine.Node.fork",
|
||
"signature": "<bound method Alias.signature of Alias('fork', 'dagpipe.node.Node.fork')>",
|
||
"docstring": "Create a child `State` attributed to this node.\n\nArgs:\n state (State):\n Parent execution state.\n\n payload_update (Mapping[str, Any], optional):\n Dot-path payload updates.\n\n confidence_delta (float, optional):\n Confidence adjustment.\n\n metadata_update (Mapping[str, Any], optional):\n Metadata updates.\n\nReturns:\n State:\n New child execution state.\n\nNotes:\n **Responsibilities:**\n\n - Convenience wrapper around `State.fork()` that automatically\n records this node's ID in state history."
|
||
},
|
||
"resolve": {
|
||
"name": "resolve",
|
||
"kind": "function",
|
||
"path": "dagpipe.engine.Node.resolve",
|
||
"signature": "<bound method Alias.signature of Alias('resolve', 'dagpipe.node.Node.resolve')>",
|
||
"docstring": "Execute node logic.\n\nArgs:\n state (State):\n Input execution state.\n\nYields:\n State:\n Derived execution state(s).\n\nNotes:\n **Responsibilities:**\n\n - Subclasses implement specific resolution behavior.\n - Must not mutate input state.\n - Should use `fork()` to create child states.\n - May yield zero states to terminate a branch."
|
||
},
|
||
"is_async": {
|
||
"name": "is_async",
|
||
"kind": "function",
|
||
"path": "dagpipe.engine.Node.is_async",
|
||
"signature": "<bound method Alias.signature of Alias('is_async', 'dagpipe.node.Node.is_async')>",
|
||
"docstring": "Return whether this node executes asynchronously."
|
||
}
|
||
}
|
||
},
|
||
"State": {
|
||
"name": "State",
|
||
"kind": "class",
|
||
"path": "dagpipe.engine.State",
|
||
"signature": "<bound method Alias.signature of Alias('State', 'dagpipe.state.State')>",
|
||
"docstring": "Immutable execution state propagated through dagpipe pipeline.\n\nAttributes:\n payload (Payload):\n Execution data container.\n\n schema (ClassVar[Schema]):\n Payload validation schema.\n\n confidence (float):\n Execution confidence score.\n\n parent (Optional[State]):\n Parent state reference.\n\n depth (int):\n Execution depth.\n\n history (Tuple[str, ...]):\n Ordered node execution lineage.\n\n metadata (Dict[str, Any]):\n Execution metadata.\n\nNotes:\n **Responsibilities:**\n\n - Represents a complete execution snapshot at a specific point in\n pipeline traversal.\n - Fundamental unit of execution in `dagpipe`.\n - Fully thread-safe due to immutability.",
|
||
"members": {
|
||
"payload": {
|
||
"name": "payload",
|
||
"kind": "attribute",
|
||
"path": "dagpipe.engine.State.payload",
|
||
"signature": "<bound method Alias.signature of Alias('payload', 'dagpipe.state.State.payload')>",
|
||
"docstring": null
|
||
},
|
||
"schema": {
|
||
"name": "schema",
|
||
"kind": "attribute",
|
||
"path": "dagpipe.engine.State.schema",
|
||
"signature": "<bound method Alias.signature of Alias('schema', 'dagpipe.state.State.schema')>",
|
||
"docstring": null
|
||
},
|
||
"confidence": {
|
||
"name": "confidence",
|
||
"kind": "attribute",
|
||
"path": "dagpipe.engine.State.confidence",
|
||
"signature": "<bound method Alias.signature of Alias('confidence', 'dagpipe.state.State.confidence')>",
|
||
"docstring": null
|
||
},
|
||
"parent": {
|
||
"name": "parent",
|
||
"kind": "attribute",
|
||
"path": "dagpipe.engine.State.parent",
|
||
"signature": "<bound method Alias.signature of Alias('parent', 'dagpipe.state.State.parent')>",
|
||
"docstring": null
|
||
},
|
||
"depth": {
|
||
"name": "depth",
|
||
"kind": "attribute",
|
||
"path": "dagpipe.engine.State.depth",
|
||
"signature": "<bound method Alias.signature of Alias('depth', 'dagpipe.state.State.depth')>",
|
||
"docstring": null
|
||
},
|
||
"history": {
|
||
"name": "history",
|
||
"kind": "attribute",
|
||
"path": "dagpipe.engine.State.history",
|
||
"signature": "<bound method Alias.signature of Alias('history', 'dagpipe.state.State.history')>",
|
||
"docstring": null
|
||
},
|
||
"metadata": {
|
||
"name": "metadata",
|
||
"kind": "attribute",
|
||
"path": "dagpipe.engine.State.metadata",
|
||
"signature": "<bound method Alias.signature of Alias('metadata', 'dagpipe.state.State.metadata')>",
|
||
"docstring": null
|
||
},
|
||
"fork": {
|
||
"name": "fork",
|
||
"kind": "function",
|
||
"path": "dagpipe.engine.State.fork",
|
||
"signature": "<bound method Alias.signature of Alias('fork', 'dagpipe.state.State.fork')>",
|
||
"docstring": "Create a new child `State` derived from this state.\n\nArgs:\n payload_update (Mapping[str, Any], optional):\n Dot-path updates applied to the payload.\n\n confidence_delta (float, optional):\n Adjustment applied to current confidence.\n\n node_id (str, optional):\n Identifier of the node creating this state.\n\n metadata_update (Mapping[str, Any], optional):\n Updates merged into state metadata.\n\nReturns:\n State:\n A new immutable `State` instance.\n\nNotes:\n **Guarantees:**\n\n - This is the only supported mechanism for modifying execution data.\n - Validates payload updates, preserves lineage, increments depth,\n and appends to history."
|
||
},
|
||
"lineage": {
|
||
"name": "lineage",
|
||
"kind": "function",
|
||
"path": "dagpipe.engine.State.lineage",
|
||
"signature": "<bound method Alias.signature of Alias('lineage', 'dagpipe.state.State.lineage')>",
|
||
"docstring": "Return lineage from root to this State.\n\nReturns:\n Tuple[State, ...]:\n Ordered execution lineage (root first)."
|
||
},
|
||
"get": {
|
||
"name": "get",
|
||
"kind": "function",
|
||
"path": "dagpipe.engine.State.get",
|
||
"signature": "<bound method Alias.signature of Alias('get', 'dagpipe.state.State.get')>",
|
||
"docstring": "Retrieve payload value.\n\nArgs:\n key (str):\n Dot-path key.\n default (Any, optional):\n Fallback value.\n\nReturns:\n Any:\n Stored value or default."
|
||
},
|
||
"has": {
|
||
"name": "has",
|
||
"kind": "function",
|
||
"path": "dagpipe.engine.State.has",
|
||
"signature": "<bound method Alias.signature of Alias('has', 'dagpipe.state.State.has')>",
|
||
"docstring": "Check whether payload contains key.\n\nArgs:\n key (str):\n Dot-path key.\n\nReturns:\n bool:\n Existence of the key."
|
||
}
|
||
}
|
||
},
|
||
"StepHook": {
|
||
"name": "StepHook",
|
||
"kind": "attribute",
|
||
"path": "dagpipe.engine.StepHook",
|
||
"signature": null,
|
||
"docstring": null
|
||
},
|
||
"AsyncStepHook": {
|
||
"name": "AsyncStepHook",
|
||
"kind": "attribute",
|
||
"path": "dagpipe.engine.AsyncStepHook",
|
||
"signature": null,
|
||
"docstring": null
|
||
},
|
||
"ProgressMessage": {
|
||
"name": "ProgressMessage",
|
||
"kind": "class",
|
||
"path": "dagpipe.engine.ProgressMessage",
|
||
"signature": "<bound method Class.signature of Class('ProgressMessage', 33, 82)>",
|
||
"docstring": "Lightweight progress payload emitted by engine step hooks.\n\nMirrors the imperative `ProgressMessage` used by the legacy orchestrator so\ncallers can surface counts/lines/errors without coupling the engine to pydantic.",
|
||
"members": {
|
||
"lines": {
|
||
"name": "lines",
|
||
"kind": "attribute",
|
||
"path": "dagpipe.engine.ProgressMessage.lines",
|
||
"signature": null,
|
||
"docstring": null
|
||
},
|
||
"blocks": {
|
||
"name": "blocks",
|
||
"kind": "attribute",
|
||
"path": "dagpipe.engine.ProgressMessage.blocks",
|
||
"signature": null,
|
||
"docstring": null
|
||
},
|
||
"count": {
|
||
"name": "count",
|
||
"kind": "attribute",
|
||
"path": "dagpipe.engine.ProgressMessage.count",
|
||
"signature": null,
|
||
"docstring": null
|
||
},
|
||
"unit": {
|
||
"name": "unit",
|
||
"kind": "attribute",
|
||
"path": "dagpipe.engine.ProgressMessage.unit",
|
||
"signature": null,
|
||
"docstring": null
|
||
},
|
||
"raw_ocr_line": {
|
||
"name": "raw_ocr_line",
|
||
"kind": "attribute",
|
||
"path": "dagpipe.engine.ProgressMessage.raw_ocr_line",
|
||
"signature": null,
|
||
"docstring": null
|
||
},
|
||
"error": {
|
||
"name": "error",
|
||
"kind": "attribute",
|
||
"path": "dagpipe.engine.ProgressMessage.error",
|
||
"signature": null,
|
||
"docstring": null
|
||
},
|
||
"step": {
|
||
"name": "step",
|
||
"kind": "attribute",
|
||
"path": "dagpipe.engine.ProgressMessage.step",
|
||
"signature": null,
|
||
"docstring": null
|
||
},
|
||
"status": {
|
||
"name": "status",
|
||
"kind": "attribute",
|
||
"path": "dagpipe.engine.ProgressMessage.status",
|
||
"signature": null,
|
||
"docstring": null
|
||
},
|
||
"as_dict": {
|
||
"name": "as_dict",
|
||
"kind": "function",
|
||
"path": "dagpipe.engine.ProgressMessage.as_dict",
|
||
"signature": "<bound method Function.signature of Function('as_dict', 72, 82)>",
|
||
"docstring": null
|
||
}
|
||
}
|
||
},
|
||
"StepResult": {
|
||
"name": "StepResult",
|
||
"kind": "class",
|
||
"path": "dagpipe.engine.StepResult",
|
||
"signature": "<bound method Class.signature of Class('StepResult', 85, 103)>",
|
||
"docstring": "A single checkpointed step within an async/resumable engine run.\n\nAttributes:\n index (int): Ordinal index of the step.\n node_id (str): Identifier of the node associated with this step.\n states (Tuple[State, ...]): States produced by running this step.\n completed (bool): Whether this step succeeded (vs. paused/interrupted).",
|
||
"members": {
|
||
"index": {
|
||
"name": "index",
|
||
"kind": "attribute",
|
||
"path": "dagpipe.engine.StepResult.index",
|
||
"signature": null,
|
||
"docstring": null
|
||
},
|
||
"node_id": {
|
||
"name": "node_id",
|
||
"kind": "attribute",
|
||
"path": "dagpipe.engine.StepResult.node_id",
|
||
"signature": null,
|
||
"docstring": null
|
||
},
|
||
"states": {
|
||
"name": "states",
|
||
"kind": "attribute",
|
||
"path": "dagpipe.engine.StepResult.states",
|
||
"signature": null,
|
||
"docstring": null
|
||
},
|
||
"completed": {
|
||
"name": "completed",
|
||
"kind": "attribute",
|
||
"path": "dagpipe.engine.StepResult.completed",
|
||
"signature": null,
|
||
"docstring": null
|
||
}
|
||
}
|
||
},
|
||
"Engine": {
|
||
"name": "Engine",
|
||
"kind": "class",
|
||
"path": "dagpipe.engine.Engine",
|
||
"signature": "<bound method Class.signature of Class('Engine', 106, 537)>",
|
||
"docstring": "Execution engine responsible for running pipeline logic.\n\nNotes:\n **Responsibilities:**\n\n - Accepts either a linear sequence of `Node` objects or a `Graph`\n defining execution topology.\n - Propagates immutable `State` objects through `Node` objects and\n collects terminal states.\n - Supports synchronous (`run`) and asynchronous (`run_async`)\n execution, dispatching per-node.\n - Supports step-wise / resumable execution and progress hooks.\n\n **Guarantees:**\n\n - Never mutates `State`, `Node`, or `Graph` instances.\n - `State` objects are never modified in place; each branch produces\n independent instances.\n - Execution order is deterministic and follows graph or pipeline topology.\n - Thread-safe for concurrent execution.",
|
||
"members": {
|
||
"MODE_LINEAR": {
|
||
"name": "MODE_LINEAR",
|
||
"kind": "attribute",
|
||
"path": "dagpipe.engine.Engine.MODE_LINEAR",
|
||
"signature": null,
|
||
"docstring": null
|
||
},
|
||
"MODE_GRAPH": {
|
||
"name": "MODE_GRAPH",
|
||
"kind": "attribute",
|
||
"path": "dagpipe.engine.Engine.MODE_GRAPH",
|
||
"signature": null,
|
||
"docstring": null
|
||
},
|
||
"run": {
|
||
"name": "run",
|
||
"kind": "function",
|
||
"path": "dagpipe.engine.Engine.run",
|
||
"signature": "<bound method Function.signature of Function('run', 165, 200)>",
|
||
"docstring": "Execute the pipeline starting from a root `State`.\n\nArgs:\n root (State):\n Initial execution state.\n\nReturns:\n list[State]:\n Terminal execution states produced by the pipeline.\n\nRaises:\n TypeError:\n If `root` is not a `State` instance.\n\n RuntimeError:\n If the engine execution mode is invalid.\n\nNotes:\n **Responsibilities:**\n\n - Selects execution mode, propagates state through nodes, creates\n new instances for branches, and collects terminal states."
|
||
},
|
||
"run_async": {
|
||
"name": "run_async",
|
||
"kind": "function",
|
||
"path": "dagpipe.engine.Engine.run_async",
|
||
"signature": "<bound method Function.signature of Function('run_async', 206, 232)>",
|
||
"docstring": "Execute the pipeline starting from `root`, dispatching sync vs async nodes.\n\nArgs:\n root (State):\n Initial execution state.\n\nReturns:\n list[State]:\n Terminal execution states produced by the pipeline.\n\nNotes:\n Each node is executed with `Node.run` when synchronous and\n `AsyncNode.run_async` when asynchronous. Linear and graph topologies\n are both supported."
|
||
},
|
||
"run_steps": {
|
||
"name": "run_steps",
|
||
"kind": "function",
|
||
"path": "dagpipe.engine.Engine.run_steps",
|
||
"signature": "<bound method Function.signature of Function('run_steps', 322, 384)>",
|
||
"docstring": "Execute the pipeline step-by-step, yielding one `StepResult` per step.\n\nArgs:\n root (State):\n Initial execution state.\n\n resume_from (int, optional):\n Skip steps at index < `resume_from` (for resume-after-partial).\n Steps are 0-indexed.\n\n on_step (StepHook, optional):\n Callback `(step, status, message)` invoked per step; falls back\n to the engine-level hook when unset.\n\nYields:\n StepResult:\n One per executed node/step, carrying the produced states.\n\nNotes:\n This is a synchronous, generator-based checkpoint interface compatible\n with the imperative resume-by-step behaviour of the legacy\n orchestrator. Use `run_steps_async` for async nodes."
|
||
},
|
||
"run_steps_async": {
|
||
"name": "run_steps_async",
|
||
"kind": "function",
|
||
"path": "dagpipe.engine.Engine.run_steps_async",
|
||
"signature": "<bound method Function.signature of Function('run_steps_async', 386, 440)>",
|
||
"docstring": "Async variant of `run_steps` supporting `AsyncNode` execution.\n\nArgs:\n root (State):\n Initial execution state.\n\n resume_from (int, optional):\n Skip steps at index < `resume_from`.\n\n on_step (AsyncStepHook, optional):\n Async callback `(step, status, message)` invoked per step.\n\nYields:\n StepResult:\n One per executed node/step."
|
||
},
|
||
"nodes": {
|
||
"name": "nodes",
|
||
"kind": "attribute",
|
||
"path": "dagpipe.engine.Engine.nodes",
|
||
"signature": null,
|
||
"docstring": "Return nodes managed by this engine.\n\nReturns:\n tuple[Node, ...]:\n Ordered sequence in linear mode or all nodes in graph mode."
|
||
}
|
||
}
|
||
},
|
||
"Incomplete": {
|
||
"name": "Incomplete",
|
||
"kind": "alias",
|
||
"path": "dagpipe.engine.Incomplete",
|
||
"signature": "<bound method Alias.signature of Alias('Incomplete', '_typeshed.Incomplete')>",
|
||
"docstring": null
|
||
}
|
||
}
|
||
}
|
||
} |