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

griptape_nodes/retained_mode/events/node_events.py

@@ -303,6 +303,7 @@ class GetAllNodeInfoResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess)
 
     metadata: dict
     node_resolution_state: str
+    locked: bool
     connections: ListConnectionsForNodeResultSuccess
     element_id_to_value: dict[str, ParameterInfoValue]
     root_node_element: dict[str, Any]
@@ -317,6 +318,39 @@ class GetAllNodeInfoResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure)
     """
 
 
+@dataclass
+@PayloadRegistry.register
+class SetLockNodeStateRequest(WorkflowNotAlteredMixin, RequestPayload):
+    """Lock a node.
+
+    Use when: Implementing locking functionality, preventing changes to nodes.
+
+    Args:
+        node_name: Name of the node to lock
+        lock: Whether to lock or unlock the node. If true, the node will be locked, otherwise it will be unlocked.
+
+    Results: SetLockNodeStateResultSuccess (node locked) | SetLockNodeStateResultFailure (node not found)
+    """
+
+    node_name: str | None
+    lock: bool
+
+
+@dataclass
+@PayloadRegistry.register
+class SetLockNodeStateResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
+    """Node locked successfully."""
+
+    node_name: str
+    locked: bool
+
+
+@dataclass
+@PayloadRegistry.register
+class SetLockNodeStateResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
+    """Node failed to lock."""
+
+
 # A Node's state can be serialized to a sequence of commands that the engine runs.
 @dataclass
 class SerializedNodeCommands:
@@ -354,6 +388,7 @@ class SerializedNodeCommands:
     create_node_command: CreateNodeRequest
     element_modification_commands: list[RequestPayload]
     node_library_details: LibraryNameAndVersion
+    lock_node_command: SetLockNodeStateRequest | None = None
     node_uuid: NodeUUID = field(default_factory=lambda: SerializedNodeCommands.NodeUUID(str(uuid4())))
 
 
@@ -477,6 +512,7 @@ class SerializedSelectedNodesCommands:
     set_parameter_value_commands: dict[
         SerializedNodeCommands.NodeUUID, list[SerializedNodeCommands.IndirectSetParameterValueCommand]
     ]
+    set_lock_commands_per_node: dict[SerializedNodeCommands.NodeUUID, SetLockNodeStateRequest]
     serialized_connection_commands: list[IndirectConnectionSerialization]
 
 

griptape_nodes/retained_mode/events/os_events.py

@@ -18,21 +18,23 @@ class FileSystemEntry:
     is_dir: bool
     size: int
     modified_time: float
+    mime_type: str | None = None  # None for directories, mimetype for files
 
 
 @dataclass
 @PayloadRegistry.register
 class OpenAssociatedFileRequest(RequestPayload):
-    """Open a file using the operating system's associated application.
+    """Open a file or directory using the operating system's associated application.
 
     Use when: Opening generated files, launching external applications,
-    providing file viewing capabilities, implementing file associations.
+    providing file viewing capabilities, implementing file associations,
+    opening folders in system explorer.
 
     Args:
-        path_to_file: Path to the file to open (mutually exclusive with file_entry)
+        path_to_file: Path to the file or directory to open (mutually exclusive with file_entry)
         file_entry: FileSystemEntry object from directory listing (mutually exclusive with path_to_file)
 
-    Results: OpenAssociatedFileResultSuccess | OpenAssociatedFileResultFailure (file not found, no association)
+    Results: OpenAssociatedFileResultSuccess | OpenAssociatedFileResultFailure (path not found, no association)
     """
 
     path_to_file: str | None = None
@@ -42,13 +44,13 @@ class OpenAssociatedFileRequest(RequestPayload):
 @dataclass
 @PayloadRegistry.register
 class OpenAssociatedFileResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
-    """File opened successfully with associated application."""
+    """File or directory opened successfully with associated application."""
 
 
 @dataclass
 @PayloadRegistry.register
 class OpenAssociatedFileResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
-    """File opening failed. Common causes: file not found, no associated application, permission denied."""
+    """File or directory opening failed. Common causes: path not found, no associated application, permission denied."""
 
 
 @dataclass
@@ -138,3 +140,93 @@ class ReadFileResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
 @PayloadRegistry.register
 class ReadFileResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
     """File reading failed. Common causes: file not found, permission denied, encoding error."""
+
+
+@dataclass
+@PayloadRegistry.register
+class CreateFileRequest(RequestPayload):
+    """Create a new file or directory.
+
+    Use when: Creating files/directories through file picker,
+    implementing file creation functionality.
+
+    Args:
+        path: Path where the file/directory should be created (legacy, use directory_path + name instead)
+        directory_path: Directory where to create the file/directory (mutually exclusive with path)
+        name: Name of the file/directory to create (mutually exclusive with path)
+        is_directory: True to create a directory, False for a file
+        content: Initial content for files (optional)
+        encoding: Text encoding for file content (default: 'utf-8')
+        workspace_only: If True, constrain to workspace directory
+
+    Results: CreateFileResultSuccess | CreateFileResultFailure
+    """
+
+    path: str | None = None
+    directory_path: str | None = None
+    name: str | None = None
+    is_directory: bool = False
+    content: str | None = None
+    encoding: str = "utf-8"
+    workspace_only: bool | None = True
+
+    def get_full_path(self) -> str:
+        """Get the full path, constructing from directory_path + name if path is not provided."""
+        if self.path is not None:
+            return self.path
+        if self.directory_path is not None and self.name is not None:
+            from pathlib import Path
+
+            return str(Path(self.directory_path) / self.name)
+        msg = "Either 'path' or both 'directory_path' and 'name' must be provided"
+        raise ValueError(msg)
+
+
+@dataclass
+@PayloadRegistry.register
+class CreateFileResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
+    """File/directory created successfully."""
+
+    created_path: str
+
+
+@dataclass
+@PayloadRegistry.register
+class CreateFileResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
+    """File/directory creation failed."""
+
+
+@dataclass
+@PayloadRegistry.register
+class RenameFileRequest(RequestPayload):
+    """Rename a file or directory.
+
+    Use when: Renaming files/directories through file picker,
+    implementing file rename functionality.
+
+    Args:
+        old_path: Current path of the file/directory to rename
+        new_path: New path for the file/directory
+        workspace_only: If True, constrain to workspace directory
+
+    Results: RenameFileResultSuccess | RenameFileResultFailure
+    """
+
+    old_path: str
+    new_path: str
+    workspace_only: bool | None = True
+
+
+@dataclass
+@PayloadRegistry.register
+class RenameFileResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
+    """File/directory renamed successfully."""
+
+    old_path: str
+    new_path: str
+
+
+@dataclass
+@PayloadRegistry.register
+class RenameFileResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
+    """File/directory rename failed."""

griptape_nodes/retained_mode/griptape_nodes.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import importlib.metadata
 import logging
 import os
 import re
@@ -46,6 +45,7 @@ from griptape_nodes.retained_mode.events.flow_events import (
     DeleteFlowRequest,
 )
 from griptape_nodes.utils.metaclasses import SingletonMeta
+from griptape_nodes.utils.version_utils import engine_version
 
 if TYPE_CHECKING:
     from griptape_nodes.retained_mode.managers.agent_manager import AgentManager
@@ -78,9 +78,6 @@ if TYPE_CHECKING:
 logger = logging.getLogger("griptape_nodes")
 
 
-engine_version = importlib.metadata.version("griptape_nodes")
-
-
 @dataclass
 class Version:
     major: int

griptape_nodes/retained_mode/managers/config_manager.py

@@ -254,7 +254,7 @@ class ConfigManager:
         existing_workflows = self.get_config_value(config_loc)
         if not existing_workflows:
             existing_workflows = []
-        existing_workflows.append(workflow_file_name)
+        existing_workflows.append(workflow_file_name) if workflow_file_name not in existing_workflows else None
         self.set_config_value(config_loc, existing_workflows)
 
     def delete_user_workflow(self, workflow_file_name: str) -> None:

griptape_nodes/retained_mode/managers/flow_manager.py

@@ -1338,6 +1338,7 @@ class FlowManager:
 
             serialized_node_commands = []
             set_parameter_value_commands_per_node = {}  # Maps a node UUID to a list of set parameter value commands
+            set_lock_commands_per_node = {}  # Maps a node UUID to a set Lock command, if it exists.
 
             # Now each of the child nodes in the flow.
             node_name_to_uuid = {}
@@ -1379,6 +1380,10 @@ class FlowManager:
                     node_libraries_in_use.add(serialized_node.node_library_details)
                     # Get the list of set value commands for THIS node.
                     set_value_commands_list = serialize_node_result.set_parameter_value_commands
+                    if serialize_node_result.serialized_node_commands.lock_node_command is not None:
+                        set_lock_commands_per_node[serialized_node.node_uuid] = (
+                            serialize_node_result.serialized_node_commands.lock_node_command
+                        )
                     set_parameter_value_commands_per_node[serialized_node.node_uuid] = set_value_commands_list
 
             # We'll have to do a patch-up of all the connections, since we can't predict all of the node names being accurate
@@ -1461,6 +1466,7 @@ class FlowManager:
             serialized_connections=create_connection_commands,
             unique_parameter_uuid_to_values=unique_parameter_uuid_to_values,
             set_parameter_value_commands=set_parameter_value_commands_per_node,
+            set_lock_commands_per_node=set_lock_commands_per_node,
             sub_flows_commands=sub_flow_commands,
             node_libraries_used=node_libraries_in_use,
             referenced_workflows=referenced_workflows_in_use,

griptape_nodes/retained_mode/managers/library_manager.py

@@ -96,6 +96,7 @@ from griptape_nodes.retained_mode.managers.library_lifecycle.library_provenance.
 )
 from griptape_nodes.retained_mode.managers.library_lifecycle.library_status import LibraryStatus
 from griptape_nodes.retained_mode.managers.os_manager import OSManager
+from griptape_nodes.utils.version_utils import get_complete_version_string
 
 if TYPE_CHECKING:
     from collections.abc import Callable
@@ -1594,14 +1595,7 @@ class LibraryManager:
         GriptapeNodes.WorkflowManager().on_libraries_initialization_complete()
 
         # Print the engine ready message
-        engine_version_request = GetEngineVersionRequest()
-        engine_version_result = GriptapeNodes.get_instance().handle_engine_version_request(engine_version_request)
-        if isinstance(engine_version_result, GetEngineVersionResultSuccess):
-            engine_version = (
-                f"v{engine_version_result.major}.{engine_version_result.minor}.{engine_version_result.patch}"
-            )
-        else:
-            engine_version = "<UNKNOWN ENGINE VERSION>"
+        engine_version = get_complete_version_string()
 
         # Get current session ID
         session_id = GriptapeNodes.get_session_id()

griptape_nodes/retained_mode/managers/node_manager.py

@@ -81,6 +81,9 @@ from griptape_nodes.retained_mode.events.node_events import (
     SerializeNodeToCommandsResultSuccess,
     SerializeSelectedNodesToCommandsRequest,
     SerializeSelectedNodesToCommandsResultSuccess,
+    SetLockNodeStateRequest,
+    SetLockNodeStateResultFailure,
+    SetLockNodeStateResultSuccess,
     SetNodeMetadataRequest,
     SetNodeMetadataResultFailure,
     SetNodeMetadataResultSuccess,
@@ -178,6 +181,7 @@ class NodeManager:
             DeserializeSelectedNodesFromCommandsRequest, self.on_deserialize_selected_nodes_from_commands
         )
         event_manager.assign_manager_to_request_type(DuplicateSelectedNodesRequest, self.on_duplicate_selected_nodes)
+        event_manager.assign_manager_to_request_type(SetLockNodeStateRequest, self.on_toggle_lock_node_request)
 
     def handle_node_rename(self, old_name: str, new_name: str) -> None:
         # Get the node itself
@@ -781,6 +785,13 @@ class NodeManager:
                 result = AddParameterToNodeResultFailure()
                 return result
 
+        # Check if node is locked
+        if node.lock:
+            details = f"Attempted to add Parameter '{request.parameter_name}' to Node '{node_name}'. Failed because the Node was locked."
+            logger.error(details)
+            result = AddParameterToNodeResultFailure()
+            return result
+
         if request.parent_container_name and not request.initial_setup:
             parameter = node.get_parameter_by_name(request.parent_container_name)
             if parameter is None:
@@ -923,7 +934,13 @@ class NodeManager:
 
                 result = RemoveParameterFromNodeResultFailure()
                 return result
+        # Check if the node is locked
+        if node.lock:
+            details = f"Attempted to remove Element '{request.parameter_name}' from Node '{node_name}'. Failed because the Node was locked."
+            logger.error(details)
 
+            result = RemoveParameterFromNodeResultFailure()
+            return result
         # Does the Element actually exist on the Node?
         element = node.get_element_by_name_and_type(request.parameter_name)
         if element is None:
@@ -1246,7 +1263,7 @@ class NodeManager:
 
         return None
 
-    def on_alter_parameter_details_request(self, request: AlterParameterDetailsRequest) -> ResultPayload:  # noqa: C901
+    def on_alter_parameter_details_request(self, request: AlterParameterDetailsRequest) -> ResultPayload:  # noqa: C901, PLR0911
         node_name = request.node_name
         node = None
 
@@ -1269,6 +1286,12 @@ class NodeManager:
 
                 return AlterParameterDetailsResultFailure()
 
+        # Is the node locked?
+        if node.lock:
+            details = f"Attempted to alter details for Parameter '{request.parameter_name}' from Node '{node_name}'. Failed because the Node was locked."
+            logger.error(details)
+            return AlterParameterDetailsResultFailure()
+
         # Does the Element actually exist on the Node?
         element = node.get_element_by_name_and_type(request.parameter_name)
         if element is None:
@@ -1397,6 +1420,12 @@ class NodeManager:
                 logger.error(details)
                 return SetParameterValueResultFailure()
 
+        # Is the node locked?
+        if node.lock:
+            details = f"Attempted to set parameter '{param_name}' value on node '{node_name}'. Failed because the Node was locked."
+            logger.error(details)
+            return SetParameterValueResultFailure()
+
         # Does the Parameter actually exist on the Node?
         parameter = node.get_parameter_by_name(param_name)
         if parameter is None:
@@ -1596,6 +1625,7 @@ class NodeManager:
         result = GetAllNodeInfoResultSuccess(
             metadata=get_metadata_success.metadata,
             node_resolution_state=get_resolution_state_success.state,
+            locked=node.lock,
             connections=list_connections_success,
             element_id_to_value=element_id_to_value,
             root_node_element=element_details,
@@ -1837,7 +1867,7 @@ class NodeManager:
             validation_succeeded=(len(all_exceptions) == 0), exceptions=all_exceptions
         )
 
-    def on_serialize_node_to_commands(self, request: SerializeNodeToCommandsRequest) -> ResultPayload:  # noqa: C901, PLR0912
+    def on_serialize_node_to_commands(self, request: SerializeNodeToCommandsRequest) -> ResultPayload:  # noqa: C901, PLR0912, PLR0915
         node_name = request.node_name
         node = None
 
@@ -1923,12 +1953,19 @@ class NodeManager:
                 )
                 if set_param_value_requests is not None:
                     set_value_commands.extend(set_param_value_requests)
-
+                else:
+                    create_node_request.resolution = NodeResolutionState.UNRESOLVED.value
+        # now check if locked
+        if node.lock:
+            lock_command = SetLockNodeStateRequest(node_name=None, lock=True)
+        else:
+            lock_command = None
         # Hooray
         serialized_node_commands = SerializedNodeCommands(
             create_node_command=create_node_request,
             element_modification_commands=element_modification_commands,
             node_library_details=library_details,
+            lock_node_command=lock_command,
         )
         details = f"Successfully serialized node '{node_name}' into commands."
         logger.debug(details)
@@ -2073,7 +2110,6 @@ class NodeManager:
                     details = f"Attempted to deserialize a serialized set of Node Creation commands. Failed to execute an element command for node '{node_name}'."
                     logger.error(details)
                     return DeserializeNodeFromCommandsResultFailure()
-
         details = f"Successfully deserialized a serialized set of Node Creation commands for node '{node_name}'."
         logger.debug(details)
         return DeserializeNodeFromCommandsResultSuccess(node_name=node_name)
@@ -2091,6 +2127,8 @@ class NodeManager:
         connections_to_serialize = []
         # This is also node_uuid to the parameter serialization command.
         parameter_commands = {}
+        # This is node_uuid to lock commands.
+        lock_commands = {}
         # I need to store node names and parameter names to UUID
         unique_uuid_to_values = {}
         # And track how values map into that map.
@@ -2111,6 +2149,7 @@ class NodeManager:
             node_commands[node_name] = result.serialized_node_commands
             node_name_to_uuid[node_name] = result.serialized_node_commands.node_uuid
             parameter_commands[result.serialized_node_commands.node_uuid] = result.set_parameter_value_commands
+            lock_commands[result.serialized_node_commands.node_uuid] = result.serialized_node_commands.lock_node_command
             try:
                 flow_name = self.get_node_parent_flow_by_name(node_name)
                 GriptapeNodes.FlowManager().get_flow_by_name(flow_name)
@@ -2146,6 +2185,7 @@ class NodeManager:
             serialized_node_commands=list(node_commands.values()),
             serialized_connection_commands=serialized_connections,
             set_parameter_value_commands=parameter_commands,
+            set_lock_commands_per_node=lock_commands,
         )
         # Set everything in the clipboard!
         GriptapeNodes.ContextManager()._clipboard.node_commands = final_result
@@ -2209,6 +2249,12 @@ class NodeManager:
                         if not set_parameter_result.succeeded():
                             details = f"Failed to set parameter value for {param_request.parameter_name} on node {param_request.node_name}"
                             logger.warning(details)
+                lock_command = commands.set_lock_commands_per_node[node_command.node_uuid]
+                if lock_command is not None:
+                    lock_node_result = GriptapeNodes.handle_request(lock_command)
+                    if not lock_node_result.succeeded():
+                        details = f"Failed to lock node {lock_command.node_name}"
+                        logger.warning(details)
         # create Connections
         for connection_command in connections:
             connection_request = CreateConnectionRequest(
@@ -2389,7 +2435,7 @@ class NodeManager:
                 commands.append(output_command)
         return commands if commands else None
 
-    def on_rename_parameter_request(self, request: RenameParameterRequest) -> ResultPayload:  # noqa: C901, PLR0912
+    def on_rename_parameter_request(self, request: RenameParameterRequest) -> ResultPayload:  # noqa: C901, PLR0911, PLR0912
         """Handle renaming a parameter on a node.
 
         Args:
@@ -2415,6 +2461,12 @@ class NodeManager:
                 logger.error(details)
                 return RenameParameterResultFailure()
 
+        # Is the node locked?
+        if node.lock:
+            details = f"Attempted to rename Parameter '{request.parameter_name}' on Node '{node_name}'. Failed because the Node is locked."
+            logger.error(details)
+            return RenameParameterResultFailure()
+
         # Get the parameter
         parameter = node.get_parameter_by_name(request.parameter_name)
         if parameter is None:
@@ -2469,3 +2521,22 @@ class NodeManager:
         return RenameParameterResultSuccess(
             old_parameter_name=old_name, new_parameter_name=request.new_parameter_name, node_name=node_name
         )
+
+    def on_toggle_lock_node_request(self, request: SetLockNodeStateRequest) -> ResultPayload:
+        node_name = request.node_name
+        if node_name is None:
+            if not GriptapeNodes.ContextManager().has_current_node():
+                details = "Attempted to lock node in the Current Context. Failed because the Current Context was empty."
+                logger.error(details)
+                return SetLockNodeStateResultFailure()
+            node = GriptapeNodes.ContextManager().get_current_node()
+            node_name = node.name
+        else:
+            try:
+                node = self.get_node_by_name(node_name)
+            except ValueError as err:
+                details = f"Attempted to lock node '{request.node_name}'. Failed because the Node could not be found. Error: {err}"
+                logger.error(details)
+                return SetLockNodeStateResultFailure()
+        node.lock = request.lock
+        return SetLockNodeStateResultSuccess(node_name=node_name, locked=node.lock)