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

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/workflow_manager.py

@@ -91,6 +91,7 @@ if TYPE_CHECKING:
     from griptape_nodes.exe_types.core_types import Parameter
     from griptape_nodes.node_library.library_registry import LibraryNameAndVersion
     from griptape_nodes.retained_mode.events.base_events import ResultPayload
+    from griptape_nodes.retained_mode.events.node_events import SetLockNodeStateRequest
     from griptape_nodes.retained_mode.managers.event_manager import EventManager
 
 
@@ -1064,6 +1065,7 @@ class WorkflowManager:
             or len(serialized_flow_commands.serialized_connections) > 0
             or len(serialized_flow_commands.set_parameter_value_commands) > 0
             or len(serialized_flow_commands.sub_flows_commands) > 0
+            or len(serialized_flow_commands.set_lock_commands_per_node) > 0
         )
 
         if not is_referenced_workflow and has_content_to_serialize:
@@ -1110,6 +1112,7 @@ class WorkflowManager:
             # Now generate all the set parameter value code and add it to the flow context.
             set_parameter_value_asts = self._generate_set_parameter_value_code(
                 set_parameter_value_commands=serialized_flow_commands.set_parameter_value_commands,
+                lock_commands=serialized_flow_commands.set_lock_commands_per_node,
                 node_uuid_to_node_variable_name=node_uuid_to_node_variable_name,
                 unique_values_dict_name="top_level_unique_values_dict",
                 import_recorder=import_recorder,
@@ -2503,6 +2506,7 @@ class WorkflowManager:
         set_parameter_value_commands: dict[
             SerializedNodeCommands.NodeUUID, list[SerializedNodeCommands.IndirectSetParameterValueCommand]
         ],
+        lock_commands: dict[SerializedNodeCommands.NodeUUID, SetLockNodeStateRequest],
         node_uuid_to_node_variable_name: dict[SerializedNodeCommands.NodeUUID, str],
         unique_values_dict_name: str,
         import_recorder: ImportRecorder,
@@ -2510,9 +2514,14 @@ class WorkflowManager:
         parameter_value_asts = []
         for node_uuid, indirect_set_parameter_value_commands in set_parameter_value_commands.items():
             node_variable_name = node_uuid_to_node_variable_name[node_uuid]
+            lock_node_command = lock_commands.get(node_uuid)
             parameter_value_asts.extend(
                 self._generate_set_parameter_value_for_node(
-                    node_variable_name, indirect_set_parameter_value_commands, unique_values_dict_name, import_recorder
+                    node_variable_name,
+                    indirect_set_parameter_value_commands,
+                    unique_values_dict_name,
+                    import_recorder,
+                    lock_node_command,
                 )
             )
         return parameter_value_asts
@@ -2523,13 +2532,15 @@ class WorkflowManager:
         indirect_set_parameter_value_commands: list[SerializedNodeCommands.IndirectSetParameterValueCommand],
         unique_values_dict_name: str,
         import_recorder: ImportRecorder,
+        lock_node_command: SetLockNodeStateRequest | None = None,
     ) -> list[ast.stmt]:
-        if not indirect_set_parameter_value_commands:
+        if not indirect_set_parameter_value_commands and lock_node_command is None:
             return []
 
-        import_recorder.add_from_import(
-            "griptape_nodes.retained_mode.events.parameter_events", "SetParameterValueRequest"
-        )
+        if indirect_set_parameter_value_commands:
+            import_recorder.add_from_import(
+                "griptape_nodes.retained_mode.events.parameter_events", "SetParameterValueRequest"
+            )
 
         set_parameter_value_asts = []
         with_node_context = ast.With(
@@ -2613,6 +2624,44 @@ class WorkflowManager:
             )
             with_node_context.body.append(set_parameter_value_request_call)
 
+        # Add lock command as the LAST command in the with context
+        if lock_node_command is not None:
+            import_recorder.add_from_import(
+                "griptape_nodes.retained_mode.events.node_events", "SetLockNodeStateRequest"
+            )
+
+            lock_node_call_ast = ast.Expr(
+                value=ast.Call(
+                    func=ast.Attribute(
+                        value=ast.Name(id="GriptapeNodes", ctx=ast.Load(), lineno=1, col_offset=0),
+                        attr="handle_request",
+                        ctx=ast.Load(),
+                        lineno=1,
+                        col_offset=0,
+                    ),
+                    args=[
+                        ast.Call(
+                            func=ast.Name(id="SetLockNodeStateRequest", ctx=ast.Load(), lineno=1, col_offset=0),
+                            args=[],
+                            keywords=[
+                                ast.keyword(arg="node_name", value=ast.Constant(value=None, lineno=1, col_offset=0)),
+                                ast.keyword(
+                                    arg="lock", value=ast.Constant(value=lock_node_command.lock, lineno=1, col_offset=0)
+                                ),
+                            ],
+                            lineno=1,
+                            col_offset=0,
+                        )
+                    ],
+                    keywords=[],
+                    lineno=1,
+                    col_offset=0,
+                ),
+                lineno=1,
+                col_offset=0,
+            )
+            with_node_context.body.append(lock_node_call_ast)
+
         set_parameter_value_asts.append(with_node_context)
         return set_parameter_value_asts
 

griptape_nodes/traits/file_system_picker.py

@@ -18,6 +18,8 @@ class FileSystemPicker(Trait):
     min_file_size: int | None = None
     workspace_only: bool = True
     initial_path: str | None = None
+    allow_create: bool = False
+    allow_rename: bool = False
     element_id: str = field(default_factory=lambda: "FileSystemPicker")
 
     def __init__(  # noqa: PLR0913
@@ -34,6 +36,8 @@ class FileSystemPicker(Trait):
         min_file_size: int | None = None,
         workspace_only: bool = True,
         initial_path: str | None = None,
+        allow_create: bool = False,
+        allow_rename: bool = False,
     ) -> None:
         super().__init__()
         self.allow_files = allow_files
@@ -47,6 +51,8 @@ class FileSystemPicker(Trait):
         self.min_file_size = min_file_size
         self.workspace_only = workspace_only
         self.initial_path = initial_path
+        self.allow_create = allow_create
+        self.allow_rename = allow_rename
 
     @classmethod
     def get_trait_keys(cls) -> list[str]:
@@ -59,6 +65,8 @@ class FileSystemPicker(Trait):
             "allowDirectories": self.allow_directories,
             "multiple": self.multiple,
             "workspaceOnly": self.workspace_only,
+            "allowCreate": self.allow_create,
+            "allowRename": self.allow_rename,
         }
 
         # Add file types/extensions
@@ -94,6 +102,16 @@ class FileSystemPicker(Trait):
                 msg = "At least one of allow_files or allow_directories must be True"
                 raise ValueError(msg)
 
+            # Validate that creation is only allowed when appropriate selection types are enabled
+            if self.allow_create and not self.allow_files and not self.allow_directories:
+                msg = "allow_create requires at least one of allow_files or allow_directories to be True"
+                raise ValueError(msg)
+
+            # Validate that rename is only allowed when appropriate selection types are enabled
+            if self.allow_rename and not self.allow_files and not self.allow_directories:
+                msg = "allow_rename requires at least one of allow_files or allow_directories to be True"
+                raise ValueError(msg)
+
             # Validate file size limits
             if (
                 self.max_file_size is not None

griptape_nodes/utils/version_utils.py

@@ -0,0 +1,51 @@
+"""Version utilities for Griptape Nodes."""
+
+from __future__ import annotations
+
+import importlib.metadata
+import json
+from typing import Literal
+
+engine_version = importlib.metadata.version("griptape_nodes")
+
+
+def get_current_version() -> str:
+    """Returns the current version of the Griptape Nodes package."""
+    return f"v{engine_version}"
+
+
+def get_install_source() -> tuple[Literal["git", "file", "pypi"], str | None]:
+    """Determines the install source of the Griptape Nodes package.
+
+    Returns:
+        tuple: A tuple containing the install source and commit ID (if applicable).
+    """
+    dist = importlib.metadata.distribution("griptape_nodes")
+    direct_url_text = dist.read_text("direct_url.json")
+    # installing from pypi doesn't have a direct_url.json file
+    if direct_url_text is None:
+        return "pypi", None
+
+    direct_url_info = json.loads(direct_url_text)
+    url = direct_url_info.get("url")
+    if url and url.startswith("file://"):
+        return "file", None
+    if "vcs_info" in direct_url_info:
+        return "git", direct_url_info["vcs_info"].get("commit_id")[:7]
+    # Fall back to pypi if no other source is found
+    return "pypi", None
+
+
+def get_complete_version_string() -> str:
+    """Returns the complete version string including install source and commit ID.
+
+    Format: v1.2.3 (source) or v1.2.3 (source - commit_id)
+
+    Returns:
+        Complete version string with source and commit info.
+    """
+    version = get_current_version()
+    source, commit_id = get_install_source()
+    if commit_id is None:
+        return f"{version} ({source})"
+    return f"{version} ({source} - {commit_id})"

{griptape_nodes-0.43.1.dist-info → griptape_nodes-0.44.0.dist-info}/METADATA

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