griptape-nodes 0.43.1__py3-none-any.whl → 0.45.0__py3-none-any.whl

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:
@@ -1406,8 +1435,8 @@ class NodeManager:
             result = SetParameterValueResultFailure()
             return result
 
-        # Validate that parameters can be set at all
-        if not parameter.settable:
+        # Validate that parameters can be set at all (note: we want the value to be set during initial setup, but not after)
+        if not parameter.settable and not request.initial_setup:
             details = f"Attempted to set parameter value for '{node_name}.{request.parameter_name}'. Failed because that Parameter was flagged as not settable."
             logger.error(details)
             result = SetParameterValueResultFailure()
@@ -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)

griptape_nodes/retained_mode/managers/operation_manager.py

@@ -45,6 +45,7 @@ if TYPE_CHECKING:
         GetNodeMetadataRequest,
         GetNodeResolutionStateRequest,
         ListParametersOnNodeRequest,
+        SetLockNodeStateRequest,
         SetNodeMetadataRequest,
     )
     from griptape_nodes.retained_mode.events.parameter_events import (
@@ -417,6 +418,12 @@ class PayloadConverter:
         """Handle RenameParameterRequest payloads."""
         return f"""cmd.rename_param(node_name="{payload.node_name}",parameter_name="{payload.parameter_name}",new_parameter_name="{payload.new_parameter_name}")"""
 
+    @staticmethod
+    def _handle_SetLockNodeStateRequest(payload: SetLockNodeStateRequest) -> str:
+        """Handle SetLockNodeStateRequest payloads."""
+        node_name_param = f'node_name="{payload.node_name}"' if payload.node_name is not None else "node_name=None"
+        return f"""cmd.set_lock_node_state({node_name_param}, lock={payload.lock})"""
+
     # GENERIC HANDLERS FOR PAYLOADS WITHOUT SPECIFIC HANDLERS
 
 

griptape_nodes/retained_mode/managers/os_manager.py

@@ -13,6 +13,9 @@ from rich.console import Console
 
 from griptape_nodes.retained_mode.events.base_events import ResultPayload
 from griptape_nodes.retained_mode.events.os_events import (
+    CreateFileRequest,
+    CreateFileResultFailure,
+    CreateFileResultSuccess,
     FileSystemEntry,
     ListDirectoryRequest,
     ListDirectoryResultFailure,
@@ -23,6 +26,9 @@ from griptape_nodes.retained_mode.events.os_events import (
     ReadFileRequest,
     ReadFileResultFailure,
     ReadFileResultSuccess,
+    RenameFileRequest,
+    RenameFileResultFailure,
+    RenameFileResultSuccess,
 )
 from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes, logger
 from griptape_nodes.retained_mode.managers.event_manager import EventManager
@@ -59,6 +65,14 @@ class OSManager:
                 request_type=ReadFileRequest, callback=self.on_read_file_request
             )
 
+            event_manager.assign_manager_to_request_type(
+                request_type=CreateFileRequest, callback=self.on_create_file_request
+            )
+
+            event_manager.assign_manager_to_request_type(
+                request_type=RenameFileRequest, callback=self.on_rename_file_request
+            )
+
     def _get_workspace_path(self) -> Path:
         """Get the workspace path from config."""
         return GriptapeNodes.ConfigManager().workspace_path
@@ -235,7 +249,7 @@ class OSManager:
             logger.error(msg)
             return OpenAssociatedFileResultFailure()
 
-        # Sanitize and validate the file path
+        # Sanitize and validate the path (file or directory)
         try:
             # Resolve the path (no workspace fallback for open requests)
             path = self._resolve_file_path(file_path_str, workspace_only=False)
@@ -244,12 +258,12 @@ class OSManager:
             logger.info(details)
             return OpenAssociatedFileResultFailure()
 
-        if not path.exists() or not path.is_file():
-            details = f"File does not exist: '{path}'"
+        if not path.exists():
+            details = f"Path does not exist: '{path}'"
             logger.info(details)
             return OpenAssociatedFileResultFailure()
 
-        logger.info("Attempting to open: %s on platform: %s", path, sys.platform)
+        logger.info("Attempting to open path: %s on platform: %s", path, sys.platform)
 
         try:
             platform_name = sys.platform
@@ -257,7 +271,7 @@ class OSManager:
                 # Linter complains but this is the recommended way on Windows
                 # We can ignore this warning as we've validated the path
                 os.startfile(str(path))  # noqa: S606 # pyright: ignore[reportAttributeAccessIssue]
-                logger.info("Started file on Windows: %s", path)
+                logger.info("Opened path on Windows: %s", path)
             elif self.is_mac():
                 # On macOS, open should be in a standard location
                 subprocess.run(  # noqa: S603
@@ -266,7 +280,7 @@ class OSManager:
                     capture_output=True,
                     text=True,
                 )
-                logger.info("Started file on macOS: %s", path)
+                logger.info("Opened path on macOS: %s", path)
             elif self.is_linux():
                 # Use full path to xdg-open to satisfy linter
                 # Common locations for xdg-open:
@@ -283,7 +297,7 @@ class OSManager:
                     capture_output=True,
                     text=True,
                 )
-                logger.info("Started file on Linux: %s", path)
+                logger.info("Opened path on Linux: %s", path)
             else:
                 details = f"Unsupported platform: '{platform_name}'"
                 logger.info(details)
@@ -299,9 +313,24 @@ class OSManager:
             )
             return OpenAssociatedFileResultFailure()
         except Exception as e:
-            logger.error("Exception occurred when trying to open file: %s", type(e).__name__)
+            logger.error("Exception occurred when trying to open path: %s", type(e).__name__)
             return OpenAssociatedFileResultFailure()
 
+    def _detect_mime_type(self, file_path: Path) -> str | None:
+        """Detect MIME type for a file. Returns None for directories or if detection fails."""
+        if file_path.is_dir():
+            return None
+
+        try:
+            mime_type, _ = mimetypes.guess_type(str(file_path), strict=True)
+            if mime_type is None:
+                mime_type = "text/plain"
+            return mime_type  # noqa: TRY300
+        except Exception as e:
+            msg = f"MIME type detection failed for {file_path}: {e}"
+            logger.warning(msg)
+            return "text/plain"
+
     def on_list_directory_request(self, request: ListDirectoryRequest) -> ResultPayload:  # noqa: C901, PLR0911
         """Handle a request to list directory contents."""
         try:
@@ -345,6 +374,7 @@ class OSManager:
                         stat = entry.stat()
                         # Get path relative to workspace if within workspace
                         is_entry_in_workspace, entry_path = self._validate_workspace_path(entry)
+                        mime_type = self._detect_mime_type(entry)
                         entries.append(
                             FileSystemEntry(
                                 name=entry.name,
@@ -352,6 +382,7 @@ class OSManager:
                                 is_dir=entry.is_dir(),
                                 size=stat.st_size,
                                 modified_time=stat.st_mtime,
+                                mime_type=mime_type,
                             )
                         )
                     except (OSError, PermissionError) as e:
@@ -703,3 +734,97 @@ class OSManager:
             logger.error("Attempted to clean up old files from %s, but no files could be deleted.")
 
         return removed_count > 0
+
+    def on_create_file_request(self, request: CreateFileRequest) -> ResultPayload:
+        """Handle a request to create a file or directory."""
+        try:
+            # Get the full path using the new method
+            full_path_str = request.get_full_path()
+
+            # Determine if path is absolute (not constrained to workspace)
+            is_absolute = Path(full_path_str).is_absolute()
+
+            # If workspace_only is True and path is absolute, it's outside workspace
+            if request.workspace_only and is_absolute:
+                msg = f"Absolute path is outside workspace: {full_path_str}"
+                logger.error(msg)
+                return CreateFileResultFailure()
+
+            # Resolve path - if absolute, use as-is; if relative, align to workspace
+            if is_absolute:
+                file_path = Path(full_path_str).resolve()
+            else:
+                file_path = (self._get_workspace_path() / full_path_str).resolve()
+
+            # Check if it already exists - warn but treat as success
+            if file_path.exists():
+                msg = f"Path already exists: {file_path}"
+                logger.warning(msg)
+                return CreateFileResultSuccess(created_path=str(file_path))
+
+            # Create parent directories if needed
+            file_path.parent.mkdir(parents=True, exist_ok=True)
+
+            if request.is_directory:
+                file_path.mkdir()
+                logger.info("Created directory: %s", file_path)
+            # Create file with optional content
+            elif request.content is not None:
+                with file_path.open("w", encoding=request.encoding) as f:
+                    f.write(request.content)
+                logger.info("Created file with content: %s", file_path)
+            else:
+                file_path.touch()
+                logger.info("Created empty file: %s", file_path)
+
+            return CreateFileResultSuccess(created_path=str(file_path))
+
+        except Exception as e:
+            path_info = request.get_full_path() if hasattr(request, "get_full_path") else str(request.path)
+            msg = f"Failed to create {'directory' if request.is_directory else 'file'} at {path_info}: {e}"
+            logger.error(msg)
+            return CreateFileResultFailure()
+
+    def on_rename_file_request(self, request: RenameFileRequest) -> ResultPayload:
+        """Handle a request to rename a file or directory."""
+        try:
+            # Resolve and validate old path
+            old_path = self._resolve_file_path(request.old_path, workspace_only=request.workspace_only is True)
+
+            # Resolve and validate new path
+            new_path = self._resolve_file_path(request.new_path, workspace_only=request.workspace_only is True)
+
+            # Check if old path exists
+            if not old_path.exists():
+                msg = f"Source path does not exist: {old_path}"
+                logger.error(msg)
+                return RenameFileResultFailure()
+
+            # Check if new path already exists
+            if new_path.exists():
+                msg = f"Destination path already exists: {new_path}"
+                logger.error(msg)
+                return RenameFileResultFailure()
+
+            # Check workspace constraints for both paths
+            is_old_in_workspace, _ = self._validate_workspace_path(old_path)
+            is_new_in_workspace, _ = self._validate_workspace_path(new_path)
+
+            if request.workspace_only and (not is_old_in_workspace or not is_new_in_workspace):
+                msg = f"One or both paths are outside workspace: {old_path} -> {new_path}"
+                logger.error(msg)
+                return RenameFileResultFailure()
+
+            # Create parent directories for new path if needed
+            new_path.parent.mkdir(parents=True, exist_ok=True)
+
+            # Perform the rename operation
+            old_path.rename(new_path)
+            logger.info("Renamed: %s -> %s", old_path, new_path)
+
+            return RenameFileResultSuccess(old_path=str(old_path), new_path=str(new_path))
+
+        except Exception as e:
+            msg = f"Failed to rename {request.old_path} to {request.new_path}: {e}"
+            logger.error(msg)
+            return RenameFileResultFailure()

griptape_nodes/retained_mode/managers/settings.py

@@ -33,6 +33,7 @@ class AppEvents(BaseModel):
             "SingleExecutionStepRequest",
             "SingleNodeStepRequest",
             "ContinueExecutionStepRequest",
+            "SetLockNodeStateRequest",
         ]
     )
 
@@ -95,3 +96,7 @@ class Settings(BaseModel):
     minimum_disk_space_gb_workflows: float = Field(
         default=1.0, description="Minimum disk space in GB required for saving workflows"
     )
+    synced_workflows_directory: str = Field(
+        default="synced_workflows",
+        description="Path to the synced workflows directory, relative to the workspace directory.",
+    )