griptape-nodes 0.41.0__py3-none-any.whl → 0.43.0__py3-none-any.whl

griptape_nodes/retained_mode/managers/node_manager.py

@@ -185,23 +185,24 @@ class NodeManager:
         # Get all connections for this node and update them.
         flow_name = self.get_node_parent_flow_by_name(old_name)
         flow = GriptapeNodes.FlowManager().get_flow_by_name(flow_name)
+        connections = GriptapeNodes.FlowManager().get_connections()
         # Get all incoming and outgoing connections and update them.
-        if old_name in flow.connections.incoming_index:
-            incoming_connections = flow.connections.incoming_index[old_name]
+        if old_name in connections.incoming_index:
+            incoming_connections = connections.incoming_index[old_name]
             for connection_ids in incoming_connections.values():
                 for connection_id in connection_ids:
-                    connection = flow.connections.connections[connection_id]
+                    connection = connections.connections[connection_id]
                     connection.target_node.name = new_name
-            temp = flow.connections.incoming_index.pop(old_name)
-            flow.connections.incoming_index[new_name] = temp
-        if old_name in flow.connections.outgoing_index:
-            outgoing_connections = flow.connections.outgoing_index[old_name]
+            temp = connections.incoming_index.pop(old_name)
+            connections.incoming_index[new_name] = temp
+        if old_name in connections.outgoing_index:
+            outgoing_connections = connections.outgoing_index[old_name]
             for connection_ids in outgoing_connections.values():
                 for connection_id in connection_ids:
-                    connection = flow.connections.connections[connection_id]
+                    connection = connections.connections[connection_id]
                     connection.source_node.name = new_name
-            temp = flow.connections.outgoing_index.pop(old_name)
-            flow.connections.outgoing_index[new_name] = temp
+            temp = connections.outgoing_index.pop(old_name)
+            connections.outgoing_index[new_name] = temp
         # update the node in the flow!
         flow.remove_node(old_name)
         node.name = new_name
@@ -217,7 +218,7 @@ class NodeManager:
             if parent_flow_name == old_name:
                 self._name_to_parent_flow_name[node_name] = new_name
 
-    def on_create_node_request(self, request: CreateNodeRequest) -> ResultPayload:  # noqa: C901, PLR0911, PLR0912, PLR0915
+    def on_create_node_request(self, request: CreateNodeRequest) -> ResultPayload:  # noqa: C901, PLR0912, PLR0915
         # Validate as much as possible before we actually create one.
         parent_flow_name = request.override_parent_flow_name
         parent_flow = None
@@ -319,6 +320,7 @@ class NodeManager:
 
         logger.log(level=log_level, msg=details)
 
+        # Special handling for paired classes (e.g., create a Start node and it automatically creates a corresponding End node already connected).
         if isinstance(node, StartLoopNode) and not request.initial_setup:
             # If it's StartLoop, create an EndLoop and connect it to the StartLoop.
             # Get the class name of the node
@@ -331,43 +333,42 @@ class NodeManager:
             # Check and see if the class exists
             libraries_with_node_type = LibraryRegistry.get_libraries_with_node_type(end_class_name)
             if not libraries_with_node_type:
-                msg = f"End class '{end_class_name}' does not exist for start class '{node_class_name}'"
-                logger.error(msg)
-                return CreateNodeResultFailure()
-
-            # Create the EndNode
-            end_loop = GriptapeNodes.handle_request(
-                CreateNodeRequest(
-                    node_type=end_class_name,
-                    metadata={
-                        "position": {"x": node.metadata["position"]["x"] + 650, "y": node.metadata["position"]["y"]}
-                    },
-                    override_parent_flow_name=parent_flow_name,
-                )
-            )
-            if not isinstance(end_loop, CreateNodeResultSuccess):
-                msg = f"Failed to create EndLoop node for StartLoop node '{node.name}'"
-                logger.error(msg)
-                return CreateNodeResultFailure()
-
-            # Create Loop between output and input to the start node.
-            GriptapeNodes.handle_request(
-                CreateConnectionRequest(
-                    source_node_name=node.name,
-                    source_parameter_name="loop",
-                    target_node_name=end_loop.node_name,
-                    target_parameter_name="from_start",
+                msg = f"Attempted to create a paried set of nodes for Node '{final_node_name}'. Failed because paired class '{end_class_name}' does not exist for start class '{node_class_name}'. The corresponding node will have to be created by hand and attached manually."
+                logger.error(msg)  # while this is bad, it's not unsalvageable, so we'll consider this a success.
+            else:
+                # Create the EndNode
+                end_loop = GriptapeNodes.handle_request(
+                    CreateNodeRequest(
+                        node_type=end_class_name,
+                        metadata={
+                            "position": {"x": node.metadata["position"]["x"] + 650, "y": node.metadata["position"]["y"]}
+                        },
+                        override_parent_flow_name=parent_flow_name,
+                    )
                 )
-            )
-            end_node = self.get_node_by_name(end_loop.node_name)
-            if not isinstance(end_node, EndLoopNode):
-                msg = f"End node '{end_loop.node_name}' is not a valid EndLoopNode"
-                logger.error(msg)
-                return CreateNodeResultFailure()
-
-            # create the connection
-            node.end_node = end_node
-            end_node.start_node = node
+                if not isinstance(end_loop, CreateNodeResultSuccess):
+                    msg = f"Attempted to create a paried set of nodes for Node '{final_node_name}'. Failed because paired class '{end_class_name}' failed to get created. The corresponding node will have to be created by hand and attached manually."
+                    logger.error(msg)  # while this is bad, it's not unsalvageable, so we'll consider this a success.
+                else:
+                    # Create Loop between output and input to the start node.
+                    GriptapeNodes.handle_request(
+                        CreateConnectionRequest(
+                            source_node_name=node.name,
+                            source_parameter_name="loop",
+                            target_node_name=end_loop.node_name,
+                            target_parameter_name="from_start",
+                        )
+                    )
+                    end_node = self.get_node_by_name(end_loop.node_name)
+                    if not isinstance(end_node, EndLoopNode):
+                        msg = f"Attempted to create a paried set of nodes for Node '{final_node_name}'. Failed because paired node '{end_loop.node_name}' was not a proper EndLoop instance. The corresponding node will have to be created by hand and attached manually."
+                        logger.error(
+                            msg
+                        )  # while this is bad, it's not unsalvageable, so we'll consider this a success.
+                    else:
+                        # create the connection - only when we've confirmed correct types
+                        node.end_node = end_node
+                        end_node.start_node = node
 
         return CreateNodeResultSuccess(
             node_name=node.name, node_type=node.__class__.__name__, specific_library_name=request.specific_library_name
@@ -395,11 +396,11 @@ class NodeManager:
             This method also clears the flow queue regardless of whether cancellation occurred,
             to ensure the specified node is not processed in the future.
         """
-        if parent_flow.check_for_existing_running_flow():
+        if GriptapeNodes.FlowManager().check_for_existing_running_flow():
             # get the current node executing / resolving
             # if it's in connected nodes, cancel flow.
             # otherwise, leave it.
-            control_node_name, resolving_node_name = parent_flow.flow_state()
+            control_node_name, resolving_node_name = GriptapeNodes.FlowManager().flow_state(parent_flow)
             connected_nodes = parent_flow.get_all_connected_nodes(node)
             cancelled = False
             if control_node_name is not None:
@@ -423,11 +424,11 @@ class NodeManager:
                         )
                         logger.error(details)
                         return DeleteNodeResultFailure()
-            # Clear the queue, because we don't want to his this node eventually.
-            parent_flow.clear_flow_queue()
+            # Clear the execution queue, because we don't want to hit this node eventually.
+            parent_flow.clear_execution_queue()
         return None
 
-    def on_delete_node_request(self, request: DeleteNodeRequest) -> ResultPayload:  # noqa: C901, PLR0911 (complex logic, lots of edge cases)
+    def on_delete_node_request(self, request: DeleteNodeRequest) -> ResultPayload:  # noqa: C901, PLR0911, PLR0912, PLR0915 (complex logic, lots of edge cases)
         node_name = request.node_name
         node = None
         if node_name is None:
@@ -460,41 +461,55 @@ class NodeManager:
             cancel_result = self.cancel_conditionally(parent_flow, parent_flow_name, node)
             if cancel_result is not None:
                 return cancel_result
-            # Remove all connections from this Node.
-            list_node_connections_request = ListConnectionsForNodeRequest(node_name=node_name)
-            list_connections_result = GriptapeNodes.handle_request(request=list_node_connections_request)
-            if not isinstance(list_connections_result, ListConnectionsForNodeResultSuccess):
-                details = f"Attempted to delete a Node '{node_name}'. Failed because it could not gather Connections to the Node."
-                logger.error(details)
-                return DeleteNodeResultFailure()
-
-            # Destroy all the incoming Connections
-            for incoming_connection in list_connections_result.incoming_connections:
-                delete_request = DeleteConnectionRequest(
-                    source_node_name=incoming_connection.source_node_name,
-                    source_parameter_name=incoming_connection.source_parameter_name,
-                    target_node_name=node_name,
-                    target_parameter_name=incoming_connection.target_parameter_name,
-                )
-                delete_result = GriptapeNodes.handle_request(delete_request)
-                if isinstance(delete_result, ResultPayloadFailure):
-                    details = f"Attempted to delete a Node '{node_name}'. Failed when attempting to delete Connection."
+            # Remove all connections from this Node using a loop to handle cascading deletions
+            any_connections_remain = True
+            while any_connections_remain:
+                # Assume we're done
+                any_connections_remain = False
+
+                list_node_connections_request = ListConnectionsForNodeRequest(node_name=node_name)
+                list_connections_result = GriptapeNodes.handle_request(request=list_node_connections_request)
+                if not isinstance(list_connections_result, ListConnectionsForNodeResultSuccess):
+                    details = f"Attempted to delete a Node '{node_name}'. Failed because it could not gather Connections to the Node."
                     logger.error(details)
                     return DeleteNodeResultFailure()
 
-            # Destroy all the outgoing Connections
-            for outgoing_connection in list_connections_result.outgoing_connections:
-                delete_request = DeleteConnectionRequest(
-                    source_node_name=node_name,
-                    source_parameter_name=outgoing_connection.source_parameter_name,
-                    target_node_name=outgoing_connection.target_node_name,
-                    target_parameter_name=outgoing_connection.target_parameter_name,
-                )
-                delete_result = GriptapeNodes.handle_request(delete_request)
-                if isinstance(delete_result, ResultPayloadFailure):
-                    details = f"Attempted to delete a Node '{node_name}'. Failed when attempting to delete Connection."
-                    logger.error(details)
-                    return DeleteNodeResultFailure()
+                # Check incoming connections
+                if list_connections_result.incoming_connections:
+                    any_connections_remain = True
+                    connection = list_connections_result.incoming_connections[0]
+                    delete_request = DeleteConnectionRequest(
+                        source_node_name=connection.source_node_name,
+                        source_parameter_name=connection.source_parameter_name,
+                        target_node_name=node_name,
+                        target_parameter_name=connection.target_parameter_name,
+                    )
+                    delete_result = GriptapeNodes.handle_request(delete_request)
+                    if isinstance(delete_result, ResultPayloadFailure):
+                        details = (
+                            f"Attempted to delete a Node '{node_name}'. Failed when attempting to delete Connection."
+                        )
+                        logger.error(details)
+                        return DeleteNodeResultFailure()
+                    continue  # Refresh connection list after cascading deletions
+
+                # Check outgoing connections
+                if list_connections_result.outgoing_connections:
+                    any_connections_remain = True
+                    connection = list_connections_result.outgoing_connections[0]
+                    delete_request = DeleteConnectionRequest(
+                        source_node_name=node_name,
+                        source_parameter_name=connection.source_parameter_name,
+                        target_node_name=connection.target_node_name,
+                        target_parameter_name=connection.target_parameter_name,
+                    )
+                    delete_result = GriptapeNodes.handle_request(delete_request)
+                    if isinstance(delete_result, ResultPayloadFailure):
+                        details = (
+                            f"Attempted to delete a Node '{node_name}'. Failed when attempting to delete Connection."
+                        )
+                        logger.error(details)
+                        return DeleteNodeResultFailure()
 
         # Remove from the owning Flow
         parent_flow.remove_node(node.name)
@@ -640,7 +655,7 @@ class NodeManager:
 
         parent_flow_name = self._name_to_parent_flow_name[node_name]
         try:
-            parent_flow = GriptapeNodes.FlowManager().get_flow_by_name(parent_flow_name)
+            GriptapeNodes.FlowManager().get_flow_by_name(parent_flow_name)
         except KeyError as err:
             details = f"Attempted to list Connections for a Node '{node_name}'. Error: {err}"
             logger.error(details)
@@ -649,7 +664,7 @@ class NodeManager:
             return result
 
         # Kinda gross, but let's do it
-        connection_mgr = parent_flow.connections
+        connection_mgr = GriptapeNodes.FlowManager().get_connections()
         # get outgoing connections
         outgoing_connections_list = []
         if node_name in connection_mgr.outgoing_index:
@@ -1429,7 +1444,7 @@ class NodeManager:
             return SetParameterValueResultFailure()
         if not request.initial_setup and modified:
             try:
-                parent_flow.connections.unresolve_future_nodes(node)
+                GriptapeNodes.FlowManager().get_connections().unresolve_future_nodes(node)
             except Exception as err:
                 details = f"Attempted to set parameter value for '{node_name}.{request.parameter_name}'. Failed because Exception: {err}"
                 logger.error(details)
@@ -1752,12 +1767,12 @@ class NodeManager:
             details = f'Failed to fetch parent flow for "{node_name}"'
             logger.error(details)
             return ResolveNodeResultFailure(validation_exceptions=[])
-        if flow.check_for_existing_running_flow():
+        if GriptapeNodes.FlowManager().check_for_existing_running_flow():
             details = f"Failed to resolve from node '{node_name}'. Flow is already running."
             logger.error(details)
             return ResolveNodeResultFailure(validation_exceptions=[])
         try:
-            flow.connections.unresolve_future_nodes(node)
+            GriptapeNodes.FlowManager().get_connections().unresolve_future_nodes(node)
         except Exception as e:
             details = f'Failed to mark future nodes dirty. Unable to kick off flow from "{node_name}": {e}'
             logger.error(details)
@@ -1783,7 +1798,7 @@ class NodeManager:
             logger.error(details)
             return StartFlowResultFailure(validation_exceptions=[e])
         try:
-            flow.resolve_singular_node(node, debug_mode)
+            GriptapeNodes.FlowManager().resolve_singular_node(flow, node, debug_mode)
         except Exception as e:
             details = f'Failed to resolve "{node_name}".  Error: {e}'
             logger.error(details)
@@ -2098,15 +2113,16 @@ class NodeManager:
             parameter_commands[result.serialized_node_commands.node_uuid] = result.set_parameter_value_commands
             try:
                 flow_name = self.get_node_parent_flow_by_name(node_name)
-                flow = GriptapeNodes.FlowManager().get_flow_by_name(flow_name)
+                GriptapeNodes.FlowManager().get_flow_by_name(flow_name)
             except Exception:
                 details = f"Attempted to serialize a selection of Nodes. Failed to get the flow of node {node_name}. Cannot serialize connections for this node."
                 logger.warning(details)
                 continue
-            if node_name in flow.connections.outgoing_index:
+            connections = GriptapeNodes.FlowManager().get_connections()
+            if node_name in connections.outgoing_index:
                 node_connections = [
-                    flow.connections.connections[connection_id]
-                    for category_dict in flow.connections.outgoing_index[node_name].values()
+                    connections.connections[connection_id]
+                    for category_dict in connections.outgoing_index[node_name].values()
                     for connection_id in category_dict
                 ]
                 for connection in node_connections:
@@ -2353,7 +2369,7 @@ class NodeManager:
                 node_name=node.name,
             )
             if internal_command is None:
-                details = f"Attempted to serialize set value for parameter'{parameter.name}' on node '{node.name}'. The set value will not be restored in anything that attempts to deserialize or save this node. The value for this parameter was not serialized because it did not match Griptape Nodes' criteria for serializability. To remedy, either update the value's type to support serializaibilty or mark the parameter as not serializable."
+                details = f"Attempted to serialize set value for parameter '{parameter.name}' on node '{node.name}'. The set value will not be restored in anything that attempts to deserialize or save this node. The value for this parameter was not serialized because it did not match Griptape Nodes' criteria for serializability. To remedy, either update the value's type to support serializability or mark the parameter as not serializable."
                 logger.warning(details)
             else:
                 commands.append(internal_command)
@@ -2367,7 +2383,7 @@ class NodeManager:
                 node_name=node.name,
             )
             if output_command is None:
-                details = f"Attempted to serialize output value for parameter '{parameter.name}' on node '{node.name}'. The output value will not be restored in anything that attempts to deserialize or save this node. The value for this parameter was not serialized because it did not match Griptape Nodes' criteria for serializability. To remedy, either update the value's type to support serializaibilty or mark the parameter as not serializable."
+                details = f"Attempted to serialize output value for parameter '{parameter.name}' on node '{node.name}'. The output value will not be restored in anything that attempts to deserialize or save this node. The value for this parameter was not serialized because it did not match Griptape Nodes' criteria for serializability. To remedy, either update the value's type to support serializability or mark the parameter as not serializable."
                 logger.warning(details)
             else:
                 commands.append(output_command)
@@ -2420,22 +2436,23 @@ class NodeManager:
 
         # Get all connections for this node
         flow_name = self.get_node_parent_flow_by_name(node_name)
-        flow = GriptapeNodes.FlowManager().get_flow_by_name(flow_name)
+        GriptapeNodes.FlowManager().get_flow_by_name(flow_name)
+        connections = GriptapeNodes.FlowManager().get_connections()
 
         # Update connections that reference this parameter
-        if node_name in flow.connections.incoming_index:
-            incoming_connections = flow.connections.incoming_index[node_name]
+        if node_name in connections.incoming_index:
+            incoming_connections = connections.incoming_index[node_name]
             for connection_ids in incoming_connections.values():
                 for connection_id in connection_ids:
-                    connection = flow.connections.connections[connection_id]
+                    connection = connections.connections[connection_id]
                     if connection.target_parameter.name == request.parameter_name:
                         connection.target_parameter.name = request.new_parameter_name
 
-        if node_name in flow.connections.outgoing_index:
-            outgoing_connections = flow.connections.outgoing_index[node_name]
+        if node_name in connections.outgoing_index:
+            outgoing_connections = connections.outgoing_index[node_name]
             for connection_ids in outgoing_connections.values():
                 for connection_id in connection_ids:
-                    connection = flow.connections.connections[connection_id]
+                    connection = connections.connections[connection_id]
                     if connection.source_parameter.name == request.parameter_name:
                         connection.source_parameter.name = request.new_parameter_name
 

griptape_nodes/retained_mode/managers/object_manager.py

@@ -100,7 +100,7 @@ class ObjectManager:
         logger.log(level=log_level, msg=details)
         return RenameObjectResultSuccess(final_name=final_name)
 
-    def on_clear_all_object_state_request(self, request: ClearAllObjectStateRequest) -> ResultPayload:
+    def on_clear_all_object_state_request(self, request: ClearAllObjectStateRequest) -> ResultPayload:  # noqa: C901
         if not request.i_know_what_im_doing:
             logger.warning(
                 "Attempted to clear all object state and delete everything. Failed because they didn't know what they were doing."
@@ -109,14 +109,22 @@ class ObjectManager:
         # Let's try and clear it all.
         # Cancel any running flows.
         flows = self.get_filtered_subset(type=ControlFlow)
-        for flow_name, flow in flows.items():
-            if flow.check_for_existing_running_flow():
+        for flow_name in flows:
+            if GriptapeNodes.FlowManager().check_for_existing_running_flow():
                 result = GriptapeNodes.handle_request(CancelFlowRequest(flow_name=flow_name))
                 if not result.succeeded():
                     details = f"Attempted to clear all object state and delete everything. Failed because running flow '{flow_name}' could not cancel."
                     logger.error(details)
                     return ClearAllObjectStateResultFailure()
 
+        try:
+            # Reset global execution state first to eliminate all references before deletion
+            GriptapeNodes.FlowManager().reset_global_execution_state()
+        except Exception as e:
+            details = f"Attempted to reset global execution state. Failed with exception: {e}"
+            logger.error(details)
+            return ClearAllObjectStateResultFailure()
+
         try:
             # Delete the existing flows, which will clear all nodes and connections.
             GriptapeNodes.clear_data()