griptape-nodes 0.53.0__py3-none-any.whl → 0.54.1__py3-none-any.whl

griptape_nodes/retained_mode/managers/node_manager.py

@@ -357,9 +357,9 @@ class NodeManager:
         else:
             details = f"Successfully created Node '{final_node_name}' in Flow '{parent_flow_name}'"
 
-        log_level = "DEBUG"
+        log_level = logging.DEBUG
         if remapped_requested_node_name:
-            log_level = "WARNING"
+            log_level = logging.WARNING
             details = f"{details}. WARNING: Had to rename from original node name requested '{request.node_name}' as an object with this name already existed."
 
         # Special handling for paired classes (e.g., create a Start node and it automatically creates a corresponding End node already connected).
@@ -445,28 +445,27 @@ class NodeManager:
             # get the current node executing / resolving
             # if it's in connected nodes, cancel flow.
             # otherwise, leave it.
-            control_node_name, resolving_node_name = GriptapeNodes.FlowManager().flow_state(parent_flow)
+            control_node_names, resolving_node_names = GriptapeNodes.FlowManager().flow_state(parent_flow)
             connected_nodes = parent_flow.get_all_connected_nodes(node)
             cancelled = False
-            if control_node_name is not None:
-                control_node = GriptapeNodes.ObjectManager().get_object_by_name(control_node_name)
-                if control_node in connected_nodes:
-                    result = GriptapeNodes.handle_request(CancelFlowRequest(flow_name=parent_flow_name))
-                    cancelled = True
-                    if not result.succeeded():
-                        details = (
-                            f"Attempted to delete a Node '{node.name}'. Failed because running flow could not cancel."
-                        )
-                        return DeleteNodeResultFailure(result_details=details)
-            if resolving_node_name is not None and not cancelled:
-                resolving_node = GriptapeNodes.ObjectManager().get_object_by_name(resolving_node_name)
-                if resolving_node in connected_nodes:
-                    result = GriptapeNodes.handle_request(CancelFlowRequest(flow_name=parent_flow_name))
-                    if not result.succeeded():
-                        details = (
-                            f"Attempted to delete a Node '{node.name}'. Failed because running flow could not cancel."
-                        )
-                        return DeleteNodeResultFailure(result_details=details)
+            if control_node_names is not None:
+                for control_node_name in control_node_names:
+                    control_node = GriptapeNodes.ObjectManager().get_object_by_name(control_node_name)
+                    if control_node in connected_nodes:
+                        result = GriptapeNodes.handle_request(CancelFlowRequest(flow_name=parent_flow_name))
+                        cancelled = True
+                        if not result.succeeded():
+                            details = f"Attempted to delete a Node '{node.name}'. Failed because running flow could not cancel."
+                            return DeleteNodeResultFailure(result_details=details)
+            if resolving_node_names is not None and not cancelled:
+                for resolving_node_name in resolving_node_names:
+                    resolving_node = GriptapeNodes.ObjectManager().get_object_by_name(resolving_node_name)
+                    if resolving_node in connected_nodes:
+                        result = GriptapeNodes.handle_request(CancelFlowRequest(flow_name=parent_flow_name))
+                        if not result.succeeded():
+                            details = f"Attempted to delete a Node '{node.name}'. Failed because running flow could not cancel."
+                            return DeleteNodeResultFailure(result_details=details)
+                        break  # Only need to cancel once
             # Clear the execution queue, because we don't want to hit this node eventually.
             parent_flow.clear_execution_queue()
         return None
@@ -1326,7 +1325,7 @@ class NodeManager:
                 # Early return with warning - we're just preserving the original changes
                 details = f"Parameter '{request.parameter_name}' alteration recorded for ErrorProxyNode '{node_name}'. Original node '{node.original_node_type}' had loading errors - preserving changes for correct recreation when dependency '{node.original_library_name}' is resolved."
 
-                result_details = ResultDetails(message=details, level="WARNING")
+                result_details = ResultDetails(message=details, level=logging.WARNING)
                 return AlterParameterDetailsResultSuccess(result_details=result_details)
 
             # Reject runtime parameter alterations on ErrorProxy
@@ -1359,7 +1358,7 @@ class NodeManager:
                 # TODO: https://github.com/griptape-ai/griptape-nodes/issues/826
                 details = f"Attempted to alter details for Element '{request.parameter_name}' from Node '{node_name}'. Could only alter some values because the Element was not user-defined (i.e., critical to the Node implementation). Only user-defined Elements can be totally modified from a Node."
                 return AlterParameterDetailsResultSuccess(
-                    result_details=ResultDetails(message=details, level="WARNING")
+                    result_details=ResultDetails(message=details, level=logging.WARNING)
                 )
             self.modify_key_parameter_fields(request, element)
 
@@ -1521,8 +1520,9 @@ class NodeManager:
             return result
 
         # Validate that parameters can be set at all (note: we want the value to be set during initial setup, but not after)
-        # This check comes after before_value_set to allow nodes to temporarily modify settable state
-        if not parameter.settable and not request.initial_setup:
+        # We skip this if it's a passthru from a connection or if we're on initial setup; those always trump settable.
+        # This check comes *AFTER* before_value_set() to allow nodes to temporarily modify settable state
+        if not parameter.settable and not incoming_node_set 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."
             result = SetParameterValueResultFailure(result_details=details)
             return result

griptape_nodes/retained_mode/managers/object_manager.py

@@ -102,7 +102,7 @@ class ObjectManager:
             details += " WARNING: Originally requested the name '{request.requested_name}', but that was taken."
             log_level = logging.WARNING
         if log_level == logging.WARNING:
-            result_details = ResultDetails(message=details, level="WARNING")
+            result_details = ResultDetails(message=details, level=logging.WARNING)
         else:
             result_details = details
         return RenameObjectResultSuccess(final_name=final_name, result_details=result_details)

griptape_nodes/retained_mode/managers/os_manager.py

@@ -1,4 +1,5 @@
 import base64
+import logging
 import mimetypes
 import os
 import shutil
@@ -516,15 +517,14 @@ class OSManager:
 
         # Check if file is already in the static files directory
         config_manager = GriptapeNodes.ConfigManager()
-        static_files_directory = config_manager.get_config_value("static_files_directory", default="staticfiles")
-        static_dir = config_manager.workspace_path / static_files_directory
+        static_dir = config_manager.workspace_path
 
         try:
             # Check if file is within the static files directory
             file_relative_to_static = file_path.relative_to(static_dir)
             # File is in static directory, construct URL directly
-            static_url = f"http://localhost:8124/static/{file_relative_to_static}"
-            msg = f"Image already in static directory, returning URL: {static_url}"
+            static_url = f"http://localhost:8124/workspace/{file_relative_to_static}"
+            msg = f"Image already in workspace directory, returning URL: {static_url}"
             logger.debug(msg)
         except ValueError:
             # File is not in static directory, create small preview
@@ -767,7 +767,7 @@ class OSManager:
             if file_path.exists():
                 msg = f"Path already exists: {file_path}"
                 return CreateFileResultSuccess(
-                    created_path=str(file_path), result_details=ResultDetails(message=msg, level="WARNING")
+                    created_path=str(file_path), result_details=ResultDetails(message=msg, level=logging.WARNING)
                 )
 
             # Create parent directories if needed
@@ -836,7 +836,7 @@ class OSManager:
             return RenameFileResultSuccess(
                 old_path=str(old_path),
                 new_path=str(new_path),
-                result_details=ResultDetails(message=details, level="INFO"),
+                result_details=ResultDetails(message=details, level=logging.INFO),
             )
 
         except Exception as e:

griptape_nodes/retained_mode/managers/settings.py

@@ -2,7 +2,41 @@ from enum import StrEnum
 from pathlib import Path
 from typing import Any, Literal
 
-from pydantic import BaseModel, ConfigDict, Field, field_validator
+from pydantic import BaseModel, ConfigDict, field_validator
+from pydantic import Field as PydanticField
+
+
+class Category(BaseModel):
+    """A category with name and optional description."""
+
+    name: str
+    description: str | None = None
+
+    def __str__(self) -> str:
+        return self.name
+
+
+# Predefined categories to avoid repetition
+FILE_SYSTEM = Category(name="File System", description="Directories and file paths for the application")
+APPLICATION_EVENTS = Category(name="Application Events", description="Configuration for application lifecycle events")
+API_KEYS = Category(name="API Keys", description="API keys and authentication credentials")
+EXECUTION = Category(name="Execution", description="Workflow execution and processing settings")
+STORAGE = Category(name="Storage", description="Data storage and persistence configuration")
+SYSTEM_REQUIREMENTS = Category(name="System Requirements", description="System resource requirements and limits")
+
+
+def Field(category: str | Category = "General", **kwargs) -> Any:
+    """Enhanced Field with default category that can be overridden."""
+    if "json_schema_extra" not in kwargs:
+        # Convert Category to dict or use string directly
+        if isinstance(category, Category):
+            category_dict = {"name": category.name}
+            if category.description:
+                category_dict["description"] = category.description
+            kwargs["json_schema_extra"] = {"category": category_dict}
+        else:
+            kwargs["json_schema_extra"] = {"category": category}
+    return PydanticField(**kwargs)
 
 
 class WorkflowExecutionMode(StrEnum):
@@ -12,9 +46,20 @@ class WorkflowExecutionMode(StrEnum):
     PARALLEL = "parallel"
 
 
+class LogLevel(StrEnum):
+    """Logging level for the application."""
+
+    CRITICAL = "CRITICAL"
+    ERROR = "ERROR"
+    WARNING = "WARNING"
+    INFO = "INFO"
+    DEBUG = "DEBUG"
+
+
 class AppInitializationComplete(BaseModel):
     libraries_to_register: list[str] = Field(default_factory=list)
     workflows_to_register: list[str] = Field(default_factory=list)
+    models_to_download: list[str] = Field(default_factory=list)
 
 
 class AppEvents(BaseModel):
@@ -49,17 +94,26 @@ class AppEvents(BaseModel):
 class Settings(BaseModel):
     model_config = ConfigDict(extra="allow")
 
-    workspace_directory: str = Field(default=str(Path().cwd() / "GriptapeNodes"))
+    workspace_directory: str = Field(
+        category=FILE_SYSTEM,
+        default=str(Path().cwd() / "GriptapeNodes"),
+    )
     static_files_directory: str = Field(
+        category=FILE_SYSTEM,
         default="staticfiles",
         description="Path to the static files directory, relative to the workspace directory.",
     )
     sandbox_library_directory: str = Field(
+        category=FILE_SYSTEM,
         default="sandbox_library",
         description="Path to the sandbox library directory (useful while developing nodes). If presented as just a directory (e.g., 'sandbox_library') it will be interpreted as being relative to the workspace directory.",
     )
-    app_events: AppEvents = Field(default_factory=AppEvents)
+    app_events: AppEvents = Field(
+        category=APPLICATION_EVENTS,
+        default_factory=AppEvents,
+    )
     nodes: dict[str, Any] = Field(
+        category=API_KEYS,
         default_factory=lambda: {
             "Griptape": {"GT_CLOUD_API_KEY": "$GT_CLOUD_API_KEY"},
             "OpenAI": {"OPENAI_API_KEY": "$OPENAI_API_KEY"},
@@ -94,11 +148,13 @@ class Settings(BaseModel):
             },
             "Tavily": {"TAVILY_API_KEY": "$TAVILY_API_KEY"},
             "Serper": {"SERPER_API_KEY": "$SERPER_API_KEY"},
-        }
+        },
     )
-    log_level: str = Field(default="INFO")
+    log_level: LogLevel = Field(category=EXECUTION, default=LogLevel.INFO)
     workflow_execution_mode: WorkflowExecutionMode = Field(
-        default=WorkflowExecutionMode.SEQUENTIAL, description="Workflow execution mode for node processing"
+        category=EXECUTION,
+        default=WorkflowExecutionMode.SEQUENTIAL,
+        description="Workflow execution mode for node processing",
     )
 
     @field_validator("workflow_execution_mode", mode="before")
@@ -117,18 +173,40 @@ class Settings(BaseModel):
             # Return default for any other type
             return WorkflowExecutionMode.SEQUENTIAL
 
+    @field_validator("log_level", mode="before")
+    @classmethod
+    def validate_log_level(cls, v: Any) -> LogLevel:
+        """Convert string values to LogLevel enum."""
+        if isinstance(v, str):
+            try:
+                return LogLevel(v.upper())
+            except ValueError:
+                # Return default if invalid string
+                return LogLevel.INFO
+        elif isinstance(v, LogLevel):
+            return v
+        else:
+            # Return default for any other type
+            return LogLevel.INFO
+
     max_nodes_in_parallel: int | None = Field(
-        default=5, description="Maximum number of nodes executing at a time for parallel execution."
+        category=EXECUTION,
+        default=5,
+        description="Maximum number of nodes executing at a time for parallel execution.",
     )
-    storage_backend: Literal["local", "gtc"] = Field(default="local")
+    storage_backend: Literal["local", "gtc"] = Field(category=STORAGE, default="local")
     minimum_disk_space_gb_libraries: float = Field(
+        category=SYSTEM_REQUIREMENTS,
         default=10.0,
         description="Minimum disk space in GB required for library installation and virtual environment operations",
     )
     minimum_disk_space_gb_workflows: float = Field(
-        default=1.0, description="Minimum disk space in GB required for saving workflows"
+        category=SYSTEM_REQUIREMENTS,
+        default=1.0,
+        description="Minimum disk space in GB required for saving workflows",
     )
     synced_workflows_directory: str = Field(
+        category=FILE_SYSTEM,
         default="synced_workflows",
         description="Path to the synced workflows directory, relative to the workspace directory.",
     )

griptape_nodes/retained_mode/managers/static_files_manager.py

@@ -1,6 +1,8 @@
 import base64
 import binascii
 import logging
+import threading
+from pathlib import Path
 
 import httpx
 from xdg_base_dirs import xdg_config_home
@@ -8,6 +10,7 @@ from xdg_base_dirs import xdg_config_home
 from griptape_nodes.drivers.storage import StorageBackend
 from griptape_nodes.drivers.storage.griptape_cloud_storage_driver import GriptapeCloudStorageDriver
 from griptape_nodes.drivers.storage.local_storage_driver import LocalStorageDriver
+from griptape_nodes.retained_mode.events.app_events import AppInitializationComplete
 from griptape_nodes.retained_mode.events.static_file_events import (
     CreateStaticFileDownloadUrlRequest,
     CreateStaticFileDownloadUrlResultFailure,
@@ -22,6 +25,7 @@ from griptape_nodes.retained_mode.events.static_file_events import (
 from griptape_nodes.retained_mode.managers.config_manager import ConfigManager
 from griptape_nodes.retained_mode.managers.event_manager import EventManager
 from griptape_nodes.retained_mode.managers.secrets_manager import SecretsManager
+from griptape_nodes.servers.static import start_static_server
 
 logger = logging.getLogger("griptape_nodes")
 
@@ -46,9 +50,10 @@ class StaticFilesManager:
         """
         self.config_manager = config_manager
 
-        storage_backend = config_manager.get_config_value("storage_backend", default=StorageBackend.LOCAL)
+        self.storage_backend = config_manager.get_config_value("storage_backend", default=StorageBackend.LOCAL)
+        workspace_directory = Path(config_manager.get_config_value("workspace_directory"))
 
-        match storage_backend:
+        match self.storage_backend:
             case StorageBackend.GTC:
                 bucket_id = secrets_manager.get_secret("GT_CLOUD_BUCKET_ID", should_error_on_not_found=False)
 
@@ -56,20 +61,21 @@ class StaticFilesManager:
                     logger.warning(
                         "GT_CLOUD_BUCKET_ID secret is not available, falling back to local storage. Run `gtn init` to set it up."
                     )
-                    self.storage_driver = LocalStorageDriver()
+                    self.storage_driver = LocalStorageDriver(workspace_directory)
                 else:
                     static_files_directory = config_manager.get_config_value(
                         "static_files_directory", default="staticfiles"
                     )
                     self.storage_driver = GriptapeCloudStorageDriver(
+                        workspace_directory,
                         bucket_id=bucket_id,
                         api_key=secrets_manager.get_secret("GT_CLOUD_API_KEY"),
                         static_files_directory=static_files_directory,
                     )
             case StorageBackend.LOCAL:
-                self.storage_driver = LocalStorageDriver()
+                self.storage_driver = LocalStorageDriver(workspace_directory)
             case _:
-                msg = f"Invalid storage backend: {storage_backend}"
+                msg = f"Invalid storage backend: {self.storage_backend}"
                 raise ValueError(msg)
 
         if event_manager is not None:
@@ -82,6 +88,11 @@ class StaticFilesManager:
             event_manager.assign_manager_to_request_type(
                 CreateStaticFileDownloadUrlRequest, self.on_handle_create_static_file_download_url_request
             )
+            event_manager.add_listener_to_app_event(
+                AppInitializationComplete,
+                self.on_app_initialization_complete,
+            )
+            # TODO: Listen for shutdown event (https://github.com/griptape-ai/griptape-nodes/issues/2149) to stop static server
 
     def on_handle_create_static_file_request(
         self,
@@ -118,8 +129,12 @@ class StaticFilesManager:
             A result object indicating success or failure.
         """
         file_name = request.file_name
+
+        resolved_directory = self._get_static_files_directory()
+        full_file_path = Path(resolved_directory) / file_name
+
         try:
-            response = self.storage_driver.create_signed_upload_url(file_name)
+            response = self.storage_driver.create_signed_upload_url(full_file_path)
         except ValueError as e:
             msg = f"Failed to create presigned URL for file {file_name}: {e}"
             logger.error(msg)
@@ -145,8 +160,12 @@ class StaticFilesManager:
             A result object indicating success or failure.
         """
         file_name = request.file_name
+
+        resolved_directory = self._get_static_files_directory()
+        full_file_path = Path(resolved_directory) / file_name
+
         try:
-            url = self.storage_driver.create_signed_download_url(file_name)
+            url = self.storage_driver.create_signed_download_url(full_file_path)
         except ValueError as e:
             msg = f"Failed to create presigned URL for file {file_name}: {e}"
             logger.error(msg)
@@ -156,6 +175,11 @@ class StaticFilesManager:
             url=url, result_details="Successfully created static file download URL"
         )
 
+    def on_app_initialization_complete(self, _payload: AppInitializationComplete) -> None:
+        # Start static server in daemon thread if enabled
+        if self.storage_backend == StorageBackend.LOCAL:
+            threading.Thread(target=start_static_server, daemon=True, name="static-server").start()
+
     def save_static_file(self, data: bytes, file_name: str) -> str:
         """Saves a static file to the workspace directory.
 
@@ -168,7 +192,10 @@ class StaticFilesManager:
         Returns:
             The URL of the saved file.
         """
-        response = self.storage_driver.create_signed_upload_url(file_name)
+        resolved_directory = self._get_static_files_directory()
+        file_path = Path(resolved_directory) / file_name
+
+        response = self.storage_driver.create_signed_upload_url(file_path)
 
         try:
             response = httpx.request(
@@ -180,6 +207,47 @@ class StaticFilesManager:
             logger.error(msg)
             raise ValueError(msg) from e
 
-        url = self.storage_driver.create_signed_download_url(file_name)
+        url = self.storage_driver.create_signed_download_url(file_path)
 
         return url
+
+    def _get_static_files_directory(self) -> str:
+        """Get the appropriate static files directory based on the current workflow context.
+
+        Returns:
+            The directory path to use for static files, relative to the workspace directory.
+            If a workflow is active, returns the staticfiles subdirectory within the
+            workflow's directory relative to workspace. Otherwise, returns the staticfiles
+            subdirectory relative to workspace.
+        """
+        from griptape_nodes.node_library.workflow_registry import WorkflowRegistry
+        from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+
+        workspace_path = self.config_manager.workspace_path
+        static_files_subdir = self.config_manager.get_config_value("static_files_directory", default="staticfiles")
+
+        # Check if there's an active workflow context
+        context_manager = GriptapeNodes.ContextManager()
+        if context_manager.has_current_workflow():
+            try:
+                # Get the current workflow name and its file path
+                workflow_name = context_manager.get_current_workflow_name()
+                workflow = WorkflowRegistry.get_workflow_by_name(workflow_name)
+
+                # Get the directory containing the workflow file
+                workflow_file_path = Path(WorkflowRegistry.get_complete_file_path(workflow.file_path))
+                workflow_directory = workflow_file_path.parent
+
+                # Make the workflow directory relative to workspace
+                relative_workflow_dir = workflow_directory.relative_to(workspace_path)
+                return str(relative_workflow_dir / static_files_subdir)
+
+            except (KeyError, AttributeError) as e:
+                # If anything goes wrong getting workflow info, fall back to workspace-relative
+                logger.warning("Failed to get workflow directory for static files, using workspace: %s", e)
+            except ValueError as e:
+                # If workflow directory is not within workspace, fall back to workspace-relative
+                logger.warning("Workflow directory is outside workspace, using workspace-relative static files: %s", e)
+
+        # If no workflow context or workflow lookup failed, return just the static files subdirectory
+        return static_files_subdir

griptape_nodes/retained_mode/managers/sync_manager.py

@@ -133,7 +133,9 @@ class SyncManager:
                 return StartSyncAllCloudWorkflowsResultSuccess(
                     sync_directory=str(sync_dir),
                     total_workflows=0,
-                    result_details=ResultDetails(message="No workflow files found in cloud storage.", level="INFO"),
+                    result_details=ResultDetails(
+                        message="No workflow files found in cloud storage.", level=logging.INFO
+                    ),
                 )
 
             # Start background sync with unique ID
@@ -209,7 +211,10 @@ class SyncManager:
             msg = "Cloud storage api_key not configured. Set GT_CLOUD_API_KEY secret."
             raise RuntimeError(msg)
 
+        workspace_directory = Path(self._config_manager.get_config_value("workspace_directory"))
+
         return GriptapeCloudStorageDriver(
+            workspace_directory,
             bucket_id=bucket_id,
             base_url=base_url,
             api_key=api_key,
@@ -232,7 +237,7 @@ class SyncManager:
             sync_dir = self._sync_dir
 
             # Download file content from cloud
-            file_content = storage_driver.download_file(filename)
+            file_content = storage_driver.download_file(Path(filename))
 
             # Write to local sync directory
             local_file_path = sync_dir / filename
@@ -283,7 +288,7 @@ class SyncManager:
 
             # Upload to cloud storage using the upload_file method
             filename = file_path.name
-            storage_driver.upload_file(filename, file_content)
+            storage_driver.upload_file(Path(filename), file_content)
 
             logger.info("Successfully uploaded workflow file to cloud: %s", filename)
 
@@ -301,7 +306,7 @@ class SyncManager:
             filename = file_path.name
 
             # Use the storage driver's delete method
-            storage_driver.delete_file(filename)
+            storage_driver.delete_file(Path(filename))
             logger.info("Successfully deleted workflow file from cloud: %s", filename)
 
         except Exception as e:
@@ -388,7 +393,7 @@ class SyncManager:
         """
         try:
             # Download file content
-            file_content = storage_driver.download_file(file_name)
+            file_content = storage_driver.download_file(Path(file_name))
 
             # Extract just the filename (remove any directory prefixes)
             local_filename = Path(file_name).name