griptape-nodes 0.53.0__py3-none-any.whl → 0.54.0__py3-none-any.whl

griptape_nodes/retained_mode/managers/event_manager.py

@@ -294,5 +294,11 @@ class EventManager:
         app_event_type = type(app_event)
         if app_event_type in self._app_event_listeners:
             listener_set = self._app_event_listeners[app_event_type]
-            for listener_callback in listener_set:
-                await call_function(listener_callback, app_event)
+
+            await asyncio.gather(
+                *[
+                    asyncio.create_task(call_function(listener_callback, app_event))
+                    for listener_callback in listener_set
+                ],
+                return_exceptions=True,
+            )

griptape_nodes/retained_mode/managers/flow_manager.py

@@ -16,6 +16,9 @@ from griptape_nodes.exe_types.core_types import (
 from griptape_nodes.exe_types.flow import ControlFlow
 from griptape_nodes.exe_types.node_types import BaseNode, ErrorProxyNode, NodeResolutionState, StartLoopNode, StartNode
 from griptape_nodes.machines.control_flow import CompleteState, ControlFlowMachine
+from griptape_nodes.machines.dag_builder import DagBuilder
+from griptape_nodes.machines.parallel_resolution import ParallelResolutionMachine
+from griptape_nodes.machines.sequential_resolution import SequentialResolutionMachine
 from griptape_nodes.retained_mode.events.base_events import (
     ExecutionEvent,
     ExecutionGriptapeNodeEvent,
@@ -144,6 +147,7 @@ class FlowManager:
     _global_flow_queue: Queue[QueueItem]
     _global_control_flow_machine: ControlFlowMachine | None
     _global_single_node_resolution: bool
+    _global_dag_builder: DagBuilder
 
     def __init__(self, event_manager: EventManager) -> None:
         event_manager.assign_manager_to_request_type(CreateFlowRequest, self.on_create_flow_request)
@@ -187,11 +191,20 @@ class FlowManager:
         self._global_flow_queue = Queue[QueueItem]()
         self._global_control_flow_machine = None  # Track the current control flow machine
         self._global_single_node_resolution = False
+        self._global_dag_builder = DagBuilder()
+
+    @property
+    def global_single_node_resolution(self) -> bool:
+        return self._global_single_node_resolution
 
     @property
     def global_flow_queue(self) -> Queue[QueueItem]:
         return self._global_flow_queue
 
+    @property
+    def global_dag_builder(self) -> DagBuilder:
+        return self._global_dag_builder
+
     def get_connections(self) -> Connections:
         """Get the connections instance."""
         return self._connections
@@ -416,10 +429,10 @@ class FlowManager:
 
         # Success
         details = f"Successfully created Flow '{final_flow_name}'."
-        log_level = "DEBUG"
+        log_level = logging.DEBUG
         if (request.flow_name is not None) and (final_flow_name != request.flow_name):
             details = f"{details} WARNING: Had to rename from original Flow requested '{request.flow_name}' as an object with this name already existed."
-            log_level = "WARNING"
+            log_level = logging.WARNING
 
         result = CreateFlowResultSuccess(
             flow_name=final_flow_name, result_details=ResultDetails(message=details, level=log_level)
@@ -513,6 +526,7 @@ class FlowManager:
 
             # Clean up ControlFlowMachine and DAG orchestrator for this flow
             self._global_control_flow_machine = None
+            self._global_dag_builder.clear()
 
         details = f"Successfully deleted Flow '{flow_name}'."
         result = DeleteFlowResultSuccess(result_details=details)
@@ -1076,14 +1090,14 @@ class FlowManager:
             details = f"Could not get flow state. Error: {err}"
             return GetFlowStateResultFailure(result_details=details)
         try:
-            control_node, resolving_node = self.flow_state(flow)
+            control_nodes, resolving_nodes = self.flow_state(flow)
         except Exception as e:
             details = f"Failed to get flow state of flow with name {flow_name}. Exception occurred: {e} "
             logger.exception(details)
             return GetFlowStateResultFailure(result_details=details)
         details = f"Successfully got flow state for flow with name {flow_name}."
         return GetFlowStateResultSuccess(
-            control_node=control_node, resolving_node=resolving_node, result_details=details
+            control_nodes=control_nodes, resolving_node=resolving_nodes, result_details=details
         )
 
     def on_cancel_flow_request(self, request: CancelFlowRequest) -> ResultPayload:
@@ -1588,7 +1602,8 @@ class FlowManager:
             start_node = queue_item.node
             self._global_flow_queue.task_done()
 
-        # Initialize global control flow machine if needed
+        # Initialize global control flow machine and DAG builder
+
         self._global_control_flow_machine = ControlFlowMachine(flow.name)
         try:
             await self._global_control_flow_machine.start_flow(start_node, debug_mode)
@@ -1618,6 +1633,7 @@ class FlowManager:
         if self._global_control_flow_machine is not None:
             self._global_control_flow_machine.reset_machine(cancel=True)
         self._global_single_node_resolution = False
+        self._global_dag_builder.clear()
         logger.debug("Cancelling flow run")
 
         GriptapeNodes.EventManager().put_event(
@@ -1702,19 +1718,23 @@ class FlowManager:
             # If flow already exists, throw an error
             errormsg = f"This workflow is already in progress. Please wait for the current process to finish before starting {node.name} again."
             raise RuntimeError(errormsg)
+
         self._global_single_node_resolution = True
 
         # Get or create machine
         self._global_control_flow_machine = ControlFlowMachine(flow.name)
-        self._global_control_flow_machine.context.current_node = node
+        self._global_control_flow_machine.context.current_nodes = [node]
         resolution_machine = self._global_control_flow_machine.resolution_machine
         resolution_machine.change_debug_mode(debug_mode=debug_mode)
         node.state = NodeResolutionState.UNRESOLVED
-        # Resolve the node
+        # Build the DAG for the node
+        if isinstance(resolution_machine, ParallelResolutionMachine):
+            self._global_dag_builder.add_node_with_dependencies(node)
+            resolution_machine.context.dag_builder = self._global_dag_builder
         await resolution_machine.resolve_node(node)
         if resolution_machine.is_complete():
             self._global_single_node_resolution = False
-            self._global_control_flow_machine.context.current_node = None
+            self._global_control_flow_machine.context.current_nodes = []
 
     async def single_execution_step(self, flow: ControlFlow, change_debug_mode: bool) -> None:  # noqa: FBT001
         # do a granular step
@@ -1772,19 +1792,30 @@ class FlowManager:
             # Clear entry control parameter for new execution
             node.set_entry_control_parameter(None)
 
-    def flow_state(self, flow: ControlFlow) -> tuple[str | None, str | None]:  # noqa: ARG002
+    def flow_state(self, flow: ControlFlow) -> tuple[list[str] | None, list[str] | None]:  # noqa: ARG002
         if not self.check_for_existing_running_flow():
             msg = "Flow hasn't started."
             raise RuntimeError(msg)
         if self._global_control_flow_machine is None:
             return None, None
         control_flow_context = self._global_control_flow_machine.context
-        current_control_node = (
-            control_flow_context.current_node.name if control_flow_context.current_node is not None else None
+        current_control_nodes = (
+            [control_flow_node.name for control_flow_node in control_flow_context.current_nodes]
+            if control_flow_context.current_nodes is not None
+            else None
         )
-        focus_stack_for_node = self._global_control_flow_machine.resolution_machine.context.focus_stack
-        current_resolving_node = focus_stack_for_node[-1].node.name if len(focus_stack_for_node) else None
-        return current_control_node, current_resolving_node
+        # focus_stack is no longer available in the new architecture
+        if isinstance(control_flow_context.resolution_machine, ParallelResolutionMachine):
+            current_resolving_nodes = [
+                node.node_reference.name
+                for node in control_flow_context.resolution_machine.context.task_to_node.values()
+            ]
+            return current_control_nodes, current_resolving_nodes
+        if isinstance(control_flow_context.resolution_machine, SequentialResolutionMachine):
+            focus_stack_for_node = control_flow_context.resolution_machine.context.focus_stack
+            current_resolving_node = focus_stack_for_node[-1].node.name if len(focus_stack_for_node) else None
+            return current_control_nodes, [current_resolving_node] if current_resolving_node else None
+        return current_control_nodes, None
 
     def get_start_node_from_node(self, flow: ControlFlow, node: BaseNode) -> BaseNode | None:
         # backwards chain in control outputs.

griptape_nodes/retained_mode/managers/library_manager.py

@@ -914,12 +914,12 @@ class LibraryManager:
             case LibraryStatus.GOOD:
                 details = f"Successfully loaded Library '{library_data.name}' from JSON file at {json_path}"
                 return RegisterLibraryFromFileResultSuccess(
-                    library_name=library_data.name, result_details=ResultDetails(message=details, level="INFO")
+                    library_name=library_data.name, result_details=ResultDetails(message=details, level=logging.INFO)
                 )
             case LibraryStatus.FLAWED:
                 details = f"Successfully loaded Library JSON file from '{json_path}', but one or more nodes failed to load. Check the log for more details."
                 return RegisterLibraryFromFileResultSuccess(
-                    library_name=library_data.name, result_details=ResultDetails(message=details, level="WARNING")
+                    library_name=library_data.name, result_details=ResultDetails(message=details, level=logging.WARNING)
                 )
             case LibraryStatus.UNUSABLE:
                 details = f"Attempted to load Library JSON file from '{json_path}'. Failed because no nodes were loaded. Check the log for more details."
@@ -2040,4 +2040,4 @@ class LibraryManager:
         details = (
             "Successfully reloaded all libraries. All object state was cleared and previous libraries were unloaded."
         )
-        return ReloadAllLibrariesResultSuccess(result_details=ResultDetails(message=details, level="INFO"))
+        return ReloadAllLibrariesResultSuccess(result_details=ResultDetails(message=details, level=logging.INFO))