griptape-nodes 0.40.0__py3-none-any.whl → 0.42.0__py3-none-any.whl

griptape_nodes/retained_mode/managers/library_manager.py

@@ -58,6 +58,9 @@ from griptape_nodes.retained_mode.events.library_events import (
     GetNodeMetadataFromLibraryRequest,
     GetNodeMetadataFromLibraryResultFailure,
     GetNodeMetadataFromLibraryResultSuccess,
+    ListCapableLibraryEventHandlersRequest,
+    ListCapableLibraryEventHandlersResultFailure,
+    ListCapableLibraryEventHandlersResultSuccess,
     ListCategoriesInLibraryRequest,
     ListCategoriesInLibraryResultFailure,
     ListCategoriesInLibraryResultSuccess,
@@ -85,19 +88,36 @@ from griptape_nodes.retained_mode.events.library_events import (
     UnloadLibraryFromRegistryResultSuccess,
 )
 from griptape_nodes.retained_mode.events.object_events import ClearAllObjectStateRequest
+from griptape_nodes.retained_mode.events.payload_registry import PayloadRegistry
 from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
 from griptape_nodes.retained_mode.managers.os_manager import OSManager
 
 if TYPE_CHECKING:
+    from collections.abc import Callable
     from types import ModuleType
 
     from griptape_nodes.node_library.advanced_node_library import AdvancedNodeLibrary
-    from griptape_nodes.retained_mode.events.base_events import ResultPayload
+    from griptape_nodes.retained_mode.events.base_events import Payload, RequestPayload, ResultPayload
     from griptape_nodes.retained_mode.managers.event_manager import EventManager
 
 logger = logging.getLogger("griptape_nodes")
 
 
+def _find_griptape_uv_bin() -> str:
+    """Find the uv binary, checking dedicated Griptape installation first, then system uv.
+
+    Returns:
+        Path to the uv binary to use
+    """
+    # Check for dedicated Griptape uv installation first
+    dedicated_uv_path = xdg_data_home() / "griptape_nodes" / "bin" / "uv"
+    if dedicated_uv_path.exists():
+        return str(dedicated_uv_path)
+
+    # Fall back to system uv installation
+    return uv.find_uv_bin()
+
+
 class LibraryManager:
     SANDBOX_LIBRARY_NAME = "Sandbox Library"
 
@@ -124,6 +144,13 @@ class LibraryManager:
 
     _library_file_path_to_info: dict[str, LibraryInfo]
 
+    @dataclass
+    class RegisteredEventHandler:
+        """Information regarding an event handler from a registered library."""
+
+        handler: Callable[[RequestPayload], ResultPayload]
+        library_data: LibrarySchema
+
     # Stable module namespace mappings for workflow serialization
     # These mappings ensure that dynamically loaded modules can be reliably imported
     # in generated workflow code by providing stable, predictable import paths.
@@ -148,10 +175,14 @@ class LibraryManager:
         self._dynamic_to_stable_module_mapping = {}
         self._stable_to_dynamic_module_mapping = {}
         self._library_to_stable_modules = {}
+        self._library_event_handler_mappings: dict[type[Payload], dict[str, LibraryManager.RegisteredEventHandler]] = {}
 
         event_manager.assign_manager_to_request_type(
             ListRegisteredLibrariesRequest, self.on_list_registered_libraries_request
         )
+        event_manager.assign_manager_to_request_type(
+            ListCapableLibraryEventHandlersRequest, self.on_list_capable_event_handlers
+        )
         event_manager.assign_manager_to_request_type(
             ListNodeTypesInLibraryRequest, self.on_list_node_types_in_library_request
         )
@@ -277,6 +308,33 @@ class LibraryManager:
                 return library_info
         return None
 
+    def on_register_event_handler(
+        self,
+        request_type: type[RequestPayload],
+        handler: Callable[[RequestPayload], ResultPayload],
+        library_data: LibrarySchema,
+    ) -> None:
+        """Register an event handler for a specific request type from a library."""
+        if self._library_event_handler_mappings.get(request_type) is None:
+            self._library_event_handler_mappings[request_type] = {}
+        self._library_event_handler_mappings[request_type][library_data.name] = LibraryManager.RegisteredEventHandler(
+            handler=handler, library_data=library_data
+        )
+
+    def get_registered_event_handlers(self, request_type: type[Payload]) -> dict[str, RegisteredEventHandler]:
+        """Get all registered event handlers for a specific request type."""
+        return self._library_event_handler_mappings.get(request_type, {})
+
+    def on_list_capable_event_handlers(self, request: ListCapableLibraryEventHandlersRequest) -> ResultPayload:
+        """Get all registered event handlers for a specific request type."""
+        request_type = PayloadRegistry.get_type(request.request_type)
+        if request_type is None:
+            return ListCapableLibraryEventHandlersResultFailure(
+                exception=KeyError(f"Request type '{request.request_type}' is not registered in the PayloadRegistry.")
+            )
+        handler_mappings = self.get_registered_event_handlers(request_type)
+        return ListCapableLibraryEventHandlersResultSuccess(handlers=list(handler_mappings.keys()))
+
     def on_list_registered_libraries_request(self, _request: ListRegisteredLibrariesRequest) -> ResultPayload:
         # Make a COPY of the list
         snapshot_list = LibraryRegistry.list_libraries()
@@ -742,6 +800,28 @@ class LibraryManager:
                     logger.error(details)
                     return RegisterLibraryFromFileResultFailure()
                 if self._can_write_to_venv_location(library_venv_python_path):
+                    # Check disk space before installing dependencies
+                    config_manager = GriptapeNodes.ConfigManager()
+                    min_space_gb = config_manager.get_config_value("minimum_disk_space_gb_libraries")
+                    if not OSManager.check_available_disk_space(Path(venv_path), min_space_gb):
+                        error_msg = OSManager.format_disk_space_error(Path(venv_path))
+                        logger.error(
+                            "Attempted to load Library JSON from '%s'. Failed when installing dependencies (requires %.1f GB): %s",
+                            json_path,
+                            min_space_gb,
+                            error_msg,
+                        )
+                        self._library_file_path_to_info[file_path] = LibraryManager.LibraryInfo(
+                            library_path=file_path,
+                            library_name=library_data.name,
+                            library_version=library_version,
+                            status=LibraryManager.LibraryStatus.UNUSABLE,
+                            problems=[
+                                f"Insufficient disk space for dependencies (requires {min_space_gb} GB): {error_msg}"
+                            ],
+                        )
+                        return RegisterLibraryFromFileResultFailure()
+
                     # Grab the python executable from the virtual environment so that we can pip install there
                     logger.info(
                         "Installing dependencies for library '%s' with pip in venv at %s", library_data.name, venv_path
@@ -771,6 +851,7 @@ class LibraryManager:
         except subprocess.CalledProcessError as e:
             # Failed to create the library
             error_details = f"return code={e.returncode}, stdout={e.stdout}, stderr={e.stderr}"
+
             self._library_file_path_to_info[file_path] = LibraryManager.LibraryInfo(
                 library_path=file_path,
                 library_name=library_data.name,
@@ -863,10 +944,23 @@ class LibraryManager:
                 logger.error(details)
                 return RegisterLibraryFromRequirementSpecifierResultFailure()
             if self._can_write_to_venv_location(library_python_venv_path):
+                # Check disk space before installing dependencies
+                config_manager = GriptapeNodes.ConfigManager()
+                min_space_gb = config_manager.get_config_value("minimum_disk_space_gb_libraries")
+                if not OSManager.check_available_disk_space(Path(venv_path), min_space_gb):
+                    error_msg = OSManager.format_disk_space_error(Path(venv_path))
+                    logger.error(
+                        "Attempted to install library '%s'. Failed when installing dependencies (requires %.1f GB): %s",
+                        request.requirement_specifier,
+                        min_space_gb,
+                        error_msg,
+                    )
+                    return RegisterLibraryFromRequirementSpecifierResultFailure()
+
                 logger.info("Installing dependency '%s' with pip in venv at %s", package_name, venv_path)
                 subprocess.run(  # noqa: S603
                     [
-                        uv.find_uv_bin(),
+                        _find_griptape_uv_bin(),
                         "pip",
                         "install",
                         request.requirement_specifier,
@@ -922,6 +1016,19 @@ class LibraryManager:
         if library_venv_path.exists():
             logger.debug("Virtual environment already exists at %s", library_venv_path)
         else:
+            # Check disk space before creating virtual environment
+            config_manager = GriptapeNodes.ConfigManager()
+            min_space_gb = config_manager.get_config_value("minimum_disk_space_gb_libraries")
+            if not OSManager.check_available_disk_space(library_venv_path.parent, min_space_gb):
+                error_msg = OSManager.format_disk_space_error(library_venv_path.parent)
+                logger.error(
+                    "Attempted to create virtual environment (requires %.1f GB). Failed: %s", min_space_gb, error_msg
+                )
+                error_message = (
+                    f"Disk space error creating virtual environment (requires {min_space_gb} GB): {error_msg}"
+                )
+                raise RuntimeError(error_message)
+
             try:
                 logger.info("Creating virtual environment at %s with Python %s", library_venv_path, python_version)
                 subprocess.run(  # noqa: S603
@@ -1441,6 +1548,9 @@ class LibraryManager:
         self._remove_missing_libraries_from_config(config_category=user_libraries_section)
 
     def on_app_initialization_complete(self, _payload: AppInitializationComplete) -> None:
+        GriptapeNodes.EngineIdentityManager().initialize_engine_id()
+        GriptapeNodes.SessionManager().get_saved_session_id()
+
         # App just got init'd. See if there are library JSONs to load!
         self.load_all_libraries_from_config()
 

griptape_nodes/retained_mode/managers/node_manager.py

@@ -185,23 +185,24 @@ class NodeManager:
         # Get all connections for this node and update them.
         flow_name = self.get_node_parent_flow_by_name(old_name)
         flow = GriptapeNodes.FlowManager().get_flow_by_name(flow_name)
+        connections = GriptapeNodes.FlowManager().get_connections()
         # Get all incoming and outgoing connections and update them.
-        if old_name in flow.connections.incoming_index:
-            incoming_connections = flow.connections.incoming_index[old_name]
+        if old_name in connections.incoming_index:
+            incoming_connections = connections.incoming_index[old_name]
             for connection_ids in incoming_connections.values():
                 for connection_id in connection_ids:
-                    connection = flow.connections.connections[connection_id]
+                    connection = connections.connections[connection_id]
                     connection.target_node.name = new_name
-            temp = flow.connections.incoming_index.pop(old_name)
-            flow.connections.incoming_index[new_name] = temp
-        if old_name in flow.connections.outgoing_index:
-            outgoing_connections = flow.connections.outgoing_index[old_name]
+            temp = connections.incoming_index.pop(old_name)
+            connections.incoming_index[new_name] = temp
+        if old_name in connections.outgoing_index:
+            outgoing_connections = connections.outgoing_index[old_name]
             for connection_ids in outgoing_connections.values():
                 for connection_id in connection_ids:
-                    connection = flow.connections.connections[connection_id]
+                    connection = connections.connections[connection_id]
                     connection.source_node.name = new_name
-            temp = flow.connections.outgoing_index.pop(old_name)
-            flow.connections.outgoing_index[new_name] = temp
+            temp = connections.outgoing_index.pop(old_name)
+            connections.outgoing_index[new_name] = temp
         # update the node in the flow!
         flow.remove_node(old_name)
         node.name = new_name
@@ -395,11 +396,11 @@ class NodeManager:
             This method also clears the flow queue regardless of whether cancellation occurred,
             to ensure the specified node is not processed in the future.
         """
-        if parent_flow.check_for_existing_running_flow():
+        if GriptapeNodes.FlowManager().check_for_existing_running_flow():
             # get the current node executing / resolving
             # if it's in connected nodes, cancel flow.
             # otherwise, leave it.
-            control_node_name, resolving_node_name = parent_flow.flow_state()
+            control_node_name, resolving_node_name = GriptapeNodes.FlowManager().flow_state(parent_flow)
             connected_nodes = parent_flow.get_all_connected_nodes(node)
             cancelled = False
             if control_node_name is not None:
@@ -423,8 +424,8 @@ class NodeManager:
                         )
                         logger.error(details)
                         return DeleteNodeResultFailure()
-            # Clear the queue, because we don't want to his this node eventually.
-            parent_flow.clear_flow_queue()
+            # Clear the execution queue, because we don't want to hit this node eventually.
+            parent_flow.clear_execution_queue()
         return None
 
     def on_delete_node_request(self, request: DeleteNodeRequest) -> ResultPayload:  # noqa: C901, PLR0911 (complex logic, lots of edge cases)
@@ -640,7 +641,7 @@ class NodeManager:
 
         parent_flow_name = self._name_to_parent_flow_name[node_name]
         try:
-            parent_flow = GriptapeNodes.FlowManager().get_flow_by_name(parent_flow_name)
+            GriptapeNodes.FlowManager().get_flow_by_name(parent_flow_name)
         except KeyError as err:
             details = f"Attempted to list Connections for a Node '{node_name}'. Error: {err}"
             logger.error(details)
@@ -649,7 +650,7 @@ class NodeManager:
             return result
 
         # Kinda gross, but let's do it
-        connection_mgr = parent_flow.connections
+        connection_mgr = GriptapeNodes.FlowManager().get_connections()
         # get outgoing connections
         outgoing_connections_list = []
         if node_name in connection_mgr.outgoing_index:
@@ -1429,7 +1430,7 @@ class NodeManager:
             return SetParameterValueResultFailure()
         if not request.initial_setup and modified:
             try:
-                parent_flow.connections.unresolve_future_nodes(node)
+                GriptapeNodes.FlowManager().get_connections().unresolve_future_nodes(node)
             except Exception as err:
                 details = f"Attempted to set parameter value for '{node_name}.{request.parameter_name}'. Failed because Exception: {err}"
                 logger.error(details)
@@ -1752,12 +1753,12 @@ class NodeManager:
             details = f'Failed to fetch parent flow for "{node_name}"'
             logger.error(details)
             return ResolveNodeResultFailure(validation_exceptions=[])
-        if flow.check_for_existing_running_flow():
+        if GriptapeNodes.FlowManager().check_for_existing_running_flow():
             details = f"Failed to resolve from node '{node_name}'. Flow is already running."
             logger.error(details)
             return ResolveNodeResultFailure(validation_exceptions=[])
         try:
-            flow.connections.unresolve_future_nodes(node)
+            GriptapeNodes.FlowManager().get_connections().unresolve_future_nodes(node)
         except Exception as e:
             details = f'Failed to mark future nodes dirty. Unable to kick off flow from "{node_name}": {e}'
             logger.error(details)
@@ -1783,7 +1784,7 @@ class NodeManager:
             logger.error(details)
             return StartFlowResultFailure(validation_exceptions=[e])
         try:
-            flow.resolve_singular_node(node, debug_mode)
+            GriptapeNodes.FlowManager().resolve_singular_node(flow, node, debug_mode)
         except Exception as e:
             details = f'Failed to resolve "{node_name}".  Error: {e}'
             logger.error(details)
@@ -2098,15 +2099,16 @@ class NodeManager:
             parameter_commands[result.serialized_node_commands.node_uuid] = result.set_parameter_value_commands
             try:
                 flow_name = self.get_node_parent_flow_by_name(node_name)
-                flow = GriptapeNodes.FlowManager().get_flow_by_name(flow_name)
+                GriptapeNodes.FlowManager().get_flow_by_name(flow_name)
             except Exception:
                 details = f"Attempted to serialize a selection of Nodes. Failed to get the flow of node {node_name}. Cannot serialize connections for this node."
                 logger.warning(details)
                 continue
-            if node_name in flow.connections.outgoing_index:
+            connections = GriptapeNodes.FlowManager().get_connections()
+            if node_name in connections.outgoing_index:
                 node_connections = [
-                    flow.connections.connections[connection_id]
-                    for category_dict in flow.connections.outgoing_index[node_name].values()
+                    connections.connections[connection_id]
+                    for category_dict in connections.outgoing_index[node_name].values()
                     for connection_id in category_dict
                 ]
                 for connection in node_connections:
@@ -2215,7 +2217,7 @@ class NodeManager:
             details = "Failed to serialized selected nodes."
             logger.error(details)
             return DuplicateSelectedNodesResultFailure()
-        result = GriptapeNodes.handle_request(DeserializeSelectedNodesFromCommandsRequest(positions=None))
+        result = GriptapeNodes.handle_request(DeserializeSelectedNodesFromCommandsRequest(positions=request.positions))
         if not isinstance(result, DeserializeSelectedNodesFromCommandsResultSuccess):
             details = "Failed to deserialize selected nodes."
             logger.error(details)
@@ -2420,22 +2422,23 @@ class NodeManager:
 
         # Get all connections for this node
         flow_name = self.get_node_parent_flow_by_name(node_name)
-        flow = GriptapeNodes.FlowManager().get_flow_by_name(flow_name)
+        GriptapeNodes.FlowManager().get_flow_by_name(flow_name)
+        connections = GriptapeNodes.FlowManager().get_connections()
 
         # Update connections that reference this parameter
-        if node_name in flow.connections.incoming_index:
-            incoming_connections = flow.connections.incoming_index[node_name]
+        if node_name in connections.incoming_index:
+            incoming_connections = connections.incoming_index[node_name]
             for connection_ids in incoming_connections.values():
                 for connection_id in connection_ids:
-                    connection = flow.connections.connections[connection_id]
+                    connection = connections.connections[connection_id]
                     if connection.target_parameter.name == request.parameter_name:
                         connection.target_parameter.name = request.new_parameter_name
 
-        if node_name in flow.connections.outgoing_index:
-            outgoing_connections = flow.connections.outgoing_index[node_name]
+        if node_name in connections.outgoing_index:
+            outgoing_connections = connections.outgoing_index[node_name]
             for connection_ids in outgoing_connections.values():
                 for connection_id in connection_ids:
-                    connection = flow.connections.connections[connection_id]
+                    connection = connections.connections[connection_id]
                     if connection.source_parameter.name == request.parameter_name:
                         connection.source_parameter.name = request.new_parameter_name
 

griptape_nodes/retained_mode/managers/object_manager.py

@@ -100,7 +100,7 @@ class ObjectManager:
         logger.log(level=log_level, msg=details)
         return RenameObjectResultSuccess(final_name=final_name)
 
-    def on_clear_all_object_state_request(self, request: ClearAllObjectStateRequest) -> ResultPayload:
+    def on_clear_all_object_state_request(self, request: ClearAllObjectStateRequest) -> ResultPayload:  # noqa: C901
         if not request.i_know_what_im_doing:
             logger.warning(
                 "Attempted to clear all object state and delete everything. Failed because they didn't know what they were doing."
@@ -109,14 +109,22 @@ class ObjectManager:
         # Let's try and clear it all.
         # Cancel any running flows.
         flows = self.get_filtered_subset(type=ControlFlow)
-        for flow_name, flow in flows.items():
-            if flow.check_for_existing_running_flow():
+        for flow_name in flows:
+            if GriptapeNodes.FlowManager().check_for_existing_running_flow():
                 result = GriptapeNodes.handle_request(CancelFlowRequest(flow_name=flow_name))
                 if not result.succeeded():
                     details = f"Attempted to clear all object state and delete everything. Failed because running flow '{flow_name}' could not cancel."
                     logger.error(details)
                     return ClearAllObjectStateResultFailure()
 
+        try:
+            # Reset global execution state first to eliminate all references before deletion
+            GriptapeNodes.FlowManager().reset_global_execution_state()
+        except Exception as e:
+            details = f"Attempted to reset global execution state. Failed with exception: {e}"
+            logger.error(details)
+            return ClearAllObjectStateResultFailure()
+
         try:
             # Delete the existing flows, which will clear all nodes and connections.
             GriptapeNodes.clear_data()

griptape_nodes/retained_mode/managers/os_manager.py

@@ -1,9 +1,10 @@
 import logging
 import os
+import shutil
 import subprocess
 import sys
 from pathlib import Path
-from typing import Any
+from typing import Any, NamedTuple
 
 from rich.console import Console
 
@@ -19,6 +20,14 @@ console = Console()
 logger = logging.getLogger("griptape_nodes")
 
 
+class DiskSpaceInfo(NamedTuple):
+    """Disk space information in bytes."""
+
+    total: int
+    used: int
+    free: int
+
+
 class OSManager:
     """A class to manage OS-level scenarios.
 
@@ -129,3 +138,63 @@ class OSManager:
         except Exception as e:
             logger.error("Exception occurred when trying to open file: %s", type(e).__name__)
             return OpenAssociatedFileResultFailure()
+
+    @staticmethod
+    def get_disk_space_info(path: Path) -> DiskSpaceInfo:
+        """Get disk space information for a given path.
+
+        Args:
+            path: The path to check disk space for.
+
+        Returns:
+            DiskSpaceInfo with total, used, and free disk space in bytes.
+        """
+        stat = shutil.disk_usage(path)
+        return DiskSpaceInfo(total=stat.total, used=stat.used, free=stat.free)
+
+    @staticmethod
+    def check_available_disk_space(path: Path, required_gb: float) -> bool:
+        """Check if there is sufficient disk space available.
+
+        Args:
+            path: The path to check disk space for.
+            required_gb: The minimum disk space required in GB.
+
+        Returns:
+            True if sufficient space is available, False otherwise.
+        """
+        try:
+            disk_info = OSManager.get_disk_space_info(path)
+            required_bytes = int(required_gb * 1024 * 1024 * 1024)  # Convert GB to bytes
+            return disk_info.free >= required_bytes  # noqa: TRY300
+        except OSError:
+            return False
+
+    @staticmethod
+    def format_disk_space_error(path: Path, exception: Exception | None = None) -> str:
+        """Format a user-friendly disk space error message.
+
+        Args:
+            path: The path where the disk space issue occurred.
+            exception: The original exception, if any.
+
+        Returns:
+            A formatted error message with disk space information.
+        """
+        try:
+            disk_info = OSManager.get_disk_space_info(path)
+            free_gb = disk_info.free / (1024**3)
+            used_gb = disk_info.used / (1024**3)
+            total_gb = disk_info.total / (1024**3)
+
+            error_msg = f"Insufficient disk space at {path}. "
+            error_msg += f"Available: {free_gb:.2f} GB, Used: {used_gb:.2f} GB, Total: {total_gb:.2f} GB. "
+
+            if exception:
+                error_msg += f"Error: {exception}"
+            else:
+                error_msg += "Please free up disk space and try again."
+
+            return error_msg  # noqa: TRY300
+        except OSError:
+            return f"Disk space error at {path}. Unable to retrieve disk space information."

griptape_nodes/retained_mode/managers/secrets_manager.py

@@ -32,6 +32,10 @@ class SecretsManager:
     def __init__(self, config_manager: ConfigManager, event_manager: EventManager | None = None) -> None:
         self.config_manager = config_manager
 
+        # So that users can access secrets directly via `os.environ`
+        load_dotenv(self.workspace_env_path, override=False)
+        load_dotenv(ENV_VAR_PATH, override=False)
+
         # Register all our listeners.
         if event_manager is not None:
             event_manager.assign_manager_to_request_type(GetSecretValueRequest, self.on_handle_get_secret_request)