griptape-nodes 0.50.0__tar.gz → 0.51.0__tar.gz

{griptape_nodes-0.50.0 → griptape_nodes-0.51.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: griptape-nodes
-Version: 0.50.0
+Version: 0.51.0
 Summary: Add your description here
 Requires-Dist: griptape>=1.8.0
 Requires-Dist: pydantic>=2.10.6

{griptape_nodes-0.50.0 → griptape_nodes-0.51.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "griptape-nodes"
-version = "0.50.0"
+version = "0.51.0"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.12.0, <3.13"

{griptape_nodes-0.50.0 → griptape_nodes-0.51.0}/src/griptape_nodes/exe_types/node_types.py

@@ -1175,8 +1175,8 @@ class ErrorProxyNode(BaseNode):
             f"\nfrom the '{self.original_library_name}' library."
             f"\nIt encountered a problem when loading."
             f"\nThe technical issue:\n{self.failure_reason}\n\n"
-            f"Your original node will be restored once the issue above is fixed"
-            f"(which may require registering the appropriate library, or getting"
+            f"Your original node will be restored once the issue above is fixed "
+            f"(which may require registering the appropriate library, or getting "
             f"a code fix from the node author)."
         )
 

{griptape_nodes-0.50.0 → griptape_nodes-0.51.0}/src/griptape_nodes/retained_mode/events/node_events.py

@@ -265,6 +265,50 @@ class SetNodeMetadataResultFailure(ResultPayloadFailure):
     """Metadata update failed. Common causes: node not found, no current context, invalid metadata format."""
 
 
+@dataclass
+@PayloadRegistry.register
+class BatchSetNodeMetadataRequest(RequestPayload):
+    """Update metadata for multiple nodes in a single request.
+
+    Use when: Updating positions for multiple nodes at once, applying bulk styling changes,
+    implementing multi-node selection operations, optimizing performance for UI updates.
+    Supports partial updates - only specified metadata fields are updated for each node.
+
+    Args:
+        node_metadata_updates: Dictionary mapping node names to their metadata updates.
+                              Each node's metadata is merged with existing metadata (partial update).
+                              If a node name is None, uses the current context node.
+
+    Results: BatchSetNodeMetadataResultSuccess | BatchSetNodeMetadataResultFailure (some nodes not found, update errors)
+    """
+
+    node_metadata_updates: dict[str | None, dict[str, Any]]
+
+
+@dataclass
+@PayloadRegistry.register
+class BatchSetNodeMetadataResultSuccess(WorkflowAlteredMixin, ResultPayloadSuccess):
+    """Batch node metadata update completed successfully.
+
+    Args:
+        updated_nodes: List of node names that were successfully updated
+        failed_nodes: Dictionary mapping failed node names to error descriptions (if any)
+    """
+
+    updated_nodes: list[str]
+    failed_nodes: dict[str, str] = field(default_factory=dict)
+
+
+@dataclass
+@PayloadRegistry.register
+class BatchSetNodeMetadataResultFailure(ResultPayloadFailure):
+    """Batch metadata update failed.
+
+    Common causes: all nodes not found, no current context, invalid metadata format,
+    or other systemic errors preventing the batch operation.
+    """
+
+
 # Get all info via a "jumbo" node event. Batches multiple info requests for, say, a GUI.
 # ...jumbode?
 @dataclass

{griptape_nodes-0.50.0 → griptape_nodes-0.51.0}/src/griptape_nodes/retained_mode/managers/flow_manager.py

@@ -1905,6 +1905,7 @@ class FlowManager:
         valid_data_nodes = []
         start_nodes = []
         control_nodes = []
+        cn_mgr = self.get_connections()
         for node in all_nodes:
             # if it's a start node, start here! Return the first one!
             if isinstance(node, StartNode):
@@ -1915,15 +1916,21 @@ class FlowManager:
             control_param = False
             for parameter in node.parameters:
                 if ParameterTypeBuiltin.CONTROL_TYPE.value == parameter.output_type:
-                    control_param = True
-                    break
+                    # Check if the control parameters are being used at all. If they are not, treat it as a data node.
+                    incoming_control = (
+                        node.name in cn_mgr.incoming_index and parameter.name in cn_mgr.incoming_index[node.name]
+                    )
+                    outgoing_control = (
+                        node.name in cn_mgr.outgoing_index and parameter.name in cn_mgr.outgoing_index[node.name]
+                    )
+                    if incoming_control or outgoing_control:
+                        control_param = True
+                        break
             if not control_param:
                 # saving this for later
                 data_nodes.append(node)
                 # If this node doesn't have a control connection..
                 continue
-
-            cn_mgr = self.get_connections()
             # check if it has an incoming connection. If it does, it's not a start node
             has_control_connection = False
             if node.name in cn_mgr.incoming_index:
@@ -1931,10 +1938,19 @@ class FlowManager:
                     param = node.get_parameter_by_name(param_name)
                     if param and ParameterTypeBuiltin.CONTROL_TYPE.value == param.output_type:
                         # there is a control connection coming in
+                        # If the node is a StartLoopNode, it may have an incoming hidden connection from it's EndLoopNode for iteration.
+                        if isinstance(node, StartLoopNode):
+                            connection_id = cn_mgr.incoming_index[node.name][param_name][0]
+                            connection = cn_mgr.connections[connection_id]
+                            connected_node = connection.get_source_node()
+                            # Check if the source node is the end loop node associated with this StartLoopNode.
+                            # If it is, then this could still be the first node in the control flow.
+                            if connected_node == node.end_node:
+                                continue
                         has_control_connection = True
                         break
             # if there is a connection coming in, isn't a start.
-            if has_control_connection and not isinstance(node, StartLoopNode):
+            if has_control_connection:
                 continue
             # Does it have an outgoing connection?
             if node.name in cn_mgr.outgoing_index:

{griptape_nodes-0.50.0 → griptape_nodes-0.51.0}/src/griptape_nodes/retained_mode/managers/node_manager.py

@@ -53,6 +53,9 @@ from griptape_nodes.retained_mode.events.library_events import (
     GetLibraryMetadataResultSuccess,
 )
 from griptape_nodes.retained_mode.events.node_events import (
+    BatchSetNodeMetadataRequest,
+    BatchSetNodeMetadataResultFailure,
+    BatchSetNodeMetadataResultSuccess,
     CreateNodeRequest,
     CreateNodeResultFailure,
     CreateNodeResultSuccess,
@@ -152,6 +155,9 @@ class NodeManager:
         )
         event_manager.assign_manager_to_request_type(GetNodeMetadataRequest, self.on_get_node_metadata_request)
         event_manager.assign_manager_to_request_type(SetNodeMetadataRequest, self.on_set_node_metadata_request)
+        event_manager.assign_manager_to_request_type(
+            BatchSetNodeMetadataRequest, self.on_batch_set_node_metadata_request
+        )
         event_manager.assign_manager_to_request_type(
             ListConnectionsForNodeRequest, self.on_list_connections_for_node_request
         )
@@ -665,6 +671,46 @@ class NodeManager:
         result = SetNodeMetadataResultSuccess()
         return result
 
+    def on_batch_set_node_metadata_request(self, request: BatchSetNodeMetadataRequest) -> ResultPayload:
+        updated_nodes = []
+        failed_nodes = {}
+
+        for node_name, metadata_update in request.node_metadata_updates.items():
+            # Resolve node name and get node object
+            node = None
+            if node_name is None:
+                # Get from current context
+                if not GriptapeNodes.ContextManager().has_current_node():
+                    failed_nodes["current_context"] = "No current context node available"
+                    continue
+                node = GriptapeNodes.ContextManager().get_current_node()
+                actual_node_name = node.name
+            else:
+                actual_node_name = node_name
+
+            # Look up node if we don't have it yet
+            if node is None:
+                obj_mgr = GriptapeNodes.ObjectManager()
+                node = obj_mgr.attempt_get_object_by_name_as_type(actual_node_name, BaseNode)
+                if node is None:
+                    failed_nodes[actual_node_name] = f"Node '{actual_node_name}' not found"
+                    continue
+
+            single_request = SetNodeMetadataRequest(node_name=actual_node_name, metadata=metadata_update)
+            result = self.on_set_node_metadata_request(single_request)
+
+            if isinstance(result, SetNodeMetadataResultSuccess):
+                updated_nodes.append(actual_node_name)
+            else:
+                failed_nodes[actual_node_name] = result.result_details
+
+        if not updated_nodes:
+            return BatchSetNodeMetadataResultFailure(
+                result_details=f"Failed to update any nodes. Failed nodes: {failed_nodes}"
+            )
+
+        return BatchSetNodeMetadataResultSuccess(updated_nodes=updated_nodes, failed_nodes=failed_nodes)
+
     def on_list_connections_for_node_request(self, request: ListConnectionsForNodeRequest) -> ResultPayload:
         node_name = request.node_name
         node = None