griptape-nodes 0.51.2__py3-none-any.whl → 0.52.0__py3-none-any.whl

griptape_nodes/bootstrap/workflow_executors/local_workflow_executor.py

@@ -1,21 +1,18 @@
 import logging
-from queue import Queue
 from typing import Any
 
-from griptape.events import BaseEvent, EventBus, EventListener
-
 from griptape_nodes.bootstrap.workflow_executors.workflow_executor import WorkflowExecutor
 from griptape_nodes.drivers.storage import StorageBackend
 from griptape_nodes.exe_types.node_types import EndNode, StartNode
 from griptape_nodes.retained_mode.events.base_events import (
-    AppEvent,
     EventRequest,
     ExecutionGriptapeNodeEvent,
-    GriptapeNodeEvent,
-    ProgressEvent,
 )
-from griptape_nodes.retained_mode.events.execution_events import SingleExecutionStepRequest, StartFlowRequest
+from griptape_nodes.retained_mode.events.execution_events import StartFlowRequest
 from griptape_nodes.retained_mode.events.parameter_events import SetParameterValueRequest
+from griptape_nodes.retained_mode.events.workflow_events import (
+    RunWorkflowFromScratchRequest,
+)
 from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
 
 logger = logging.getLogger(__name__)
@@ -26,10 +23,6 @@ class LocalExecutorError(Exception):
 
 
 class LocalWorkflowExecutor(WorkflowExecutor):
-    def __init__(self) -> None:
-        self.queue = Queue()
-        self.output: dict | None = None
-
     def _load_flow_for_workflow(self) -> str:
         try:
             context_manager = GriptapeNodes.ContextManager()
@@ -53,69 +46,10 @@ class LocalWorkflowExecutor(WorkflowExecutor):
             logger.exception(msg)
             raise LocalExecutorError(msg) from e
 
-    def _handle_event(self, event: BaseEvent) -> None:
-        try:
-            match event:
-                case GriptapeNodeEvent():
-                    self.__handle_node_event(event)
-                case ExecutionGriptapeNodeEvent():
-                    self.__handle_execution_node_event(event)
-                case ProgressEvent():
-                    self.__handle_progress_event(event)
-                case AppEvent():
-                    self.__handle_app_event(event)
-                case _:
-                    msg = f"Unknown event type: {type(event)}"
-                    logger.info(msg)
-                    self.queue.put(event)
-        except Exception as e:
-            logger.info(e)
-
-    def __handle_node_event(self, event: GriptapeNodeEvent) -> None:
-        result_event = event.wrapped_event
-        event_json = result_event.json()
-        event_log = f"GriptapeNodeEvent: {event_json}"
-        logger.info(event_log)
-
-    def __handle_execution_node_event(self, event: ExecutionGriptapeNodeEvent) -> None:
-        result_event = event.wrapped_event
-        if type(result_event.payload).__name__ == "NodeStartProcessEvent":
-            event_log = f"NodeStartProcessEvent: {result_event.payload}"
-            logger.info(event_log)
-
-        elif type(result_event.payload).__name__ == "ResumeNodeProcessingEvent":
-            event_log = f"ResumeNodeProcessingEvent: {result_event.payload}"
-            logger.info(event_log)
-
-            # Here we need to handle the resume event since this is the callback mechanism
-            # for the flow to be resumed for any Node that yields a generator in its process method.
-            node_name = result_event.payload.node_name
-            flow_name = GriptapeNodes.NodeManager().get_node_parent_flow_by_name(node_name)
-            event_request = EventRequest(request=SingleExecutionStepRequest(flow_name=flow_name))
-            self.queue.put(event_request)
-
-        elif type(result_event.payload).__name__ == "NodeFinishProcessEvent":
-            event_log = f"NodeFinishProcessEvent: {result_event.payload}"
-            logger.info(event_log)
-
-        else:
-            event_log = f"ExecutionGriptapeNodeEvent: {result_event.payload}"
-            logger.info(event_log)
-
-        self.queue.put(event)
-
-    def __handle_progress_event(self, gt_event: ProgressEvent) -> None:
-        event_log = f"ProgressEvent: {gt_event}"
-        logger.info(event_log)
-
-    def __handle_app_event(self, event: AppEvent) -> None:
-        event_log = f"AppEvent: {event.payload}"
-        logger.info(event_log)
-
     def _submit_output(self, output: dict) -> None:
         self.output = output
 
-    def _set_input_for_flow(self, flow_name: str, flow_input: dict[str, dict]) -> None:
+    async def _set_input_for_flow(self, flow_name: str, flow_input: dict[str, dict]) -> None:
         control_flow = GriptapeNodes.FlowManager().get_flow_by_name(flow_name)
         nodes = control_flow.nodes
         for node_name, node in nodes.items():
@@ -128,7 +62,7 @@ class LocalWorkflowExecutor(WorkflowExecutor):
                             value=parameter_value,
                             node_name=node_name,
                         )
-                        set_parameter_value_result = GriptapeNodes.handle_request(set_parameter_value_request)
+                        set_parameter_value_result = await GriptapeNodes.ahandle_request(set_parameter_value_request)
 
                         if set_parameter_value_result.failed():
                             msg = f"Failed to set parameter {parameter_name} for node {node_name}."
@@ -144,12 +78,54 @@ class LocalWorkflowExecutor(WorkflowExecutor):
 
         return output
 
-    def run(
+    async def _load_workflow_from_path(self, workflow_path: str) -> None:
+        """Load a workflow from a file path."""
+
+        def _raise_load_error(msg: str) -> None:
+            raise LocalExecutorError(msg)
+
+        try:
+            # Use the RunWorkflowFromScratchRequest to load the workflow
+            request = RunWorkflowFromScratchRequest(file_path=workflow_path)
+            result = await GriptapeNodes.ahandle_request(request)
+
+            logger.info("Successfully loaded workflow from %s", workflow_path)
+        except Exception as e:
+            msg = f"Error loading workflow from path {workflow_path}: {e}"
+            logger.exception(msg)
+            raise LocalExecutorError(msg) from e
+
+        if result.failed():
+            msg = f"Failed to load workflow from path {workflow_path}"
+            _raise_load_error(msg)
+
+    async def _handle_event_request(self, event: EventRequest) -> None:
+        """Handle EventRequest objects by processing them through GriptapeNodes."""
+        await GriptapeNodes.ahandle_request(event.request)
+
+    async def _handle_execution_event(
+        self, event: ExecutionGriptapeNodeEvent, flow_name: str
+    ) -> tuple[bool, Exception | None]:
+        """Handle ExecutionGriptapeNodeEvent and return (is_finished, error)."""
+        result_event = event.wrapped_event
+
+        if type(result_event.payload).__name__ == "ControlFlowResolvedEvent":
+            self._submit_output(self._get_output_for_flow(flow_name=flow_name))
+            logger.info("Workflow finished!")
+            return True, None
+        if type(result_event.payload).__name__ == "ControlFlowCancelledEvent":
+            msg = "Control flow cancelled"
+            logger.error(msg)
+            return True, LocalExecutorError(msg)
+
+        return False, None
+
+    async def arun(
         self,
         workflow_name: str,
         flow_input: Any,
         storage_backend: StorageBackend = StorageBackend.LOCAL,
-        **kwargs: Any,  # noqa: ARG002
+        **kwargs: Any,
     ) -> None:
         """Executes a local workflow.
 
@@ -165,23 +141,24 @@ class LocalWorkflowExecutor(WorkflowExecutor):
             None
         """
         logger.info("Executing workflow: %s", workflow_name)
-
-        EventBus.add_event_listener(
-            event_listener=EventListener(
-                on_event=self._handle_event,
-            )
-        )
+        GriptapeNodes.EventManager().initialize_queue()
 
         # Set the storage backend
         self._set_storage_backend(storage_backend=storage_backend)
+
+        # Load workflow from file if workflow_path is provided
+        workflow_path = kwargs.get("workflow_path")
+        if workflow_path:
+            await self._load_workflow_from_path(workflow_path)
+
         # Load the flow
         flow_name = self._load_flow_for_workflow()
         # Now let's set the input to the flow
-        self._set_input_for_flow(flow_name=flow_name, flow_input=flow_input)
+        await self._set_input_for_flow(flow_name=flow_name, flow_input=flow_input)
 
         # Now send the run command to actually execute it
         start_flow_request = StartFlowRequest(flow_name=flow_name)
-        start_flow_result = GriptapeNodes.handle_request(start_flow_request)
+        start_flow_result = await GriptapeNodes.ahandle_request(start_flow_request)
 
         if start_flow_result.failed():
             msg = f"Failed to start flow {flow_name}"
@@ -192,32 +169,18 @@ class LocalWorkflowExecutor(WorkflowExecutor):
         # Wait for the control flow to finish
         is_flow_finished = False
         error: Exception | None = None
+
+        event_queue = GriptapeNodes.EventManager().event_queue
         while not is_flow_finished:
             try:
-                event = self.queue.get(block=True)
+                event = await event_queue.get()
 
                 if isinstance(event, EventRequest):
-                    # Handle EventRequest objects by processing them through GriptapeNodes
-                    request_payload = event.request
-                    GriptapeNodes.handle_request(
-                        request_payload, response_topic=event.response_topic, request_id=event.request_id
-                    )
+                    await self._handle_event_request(event)
                 elif isinstance(event, ExecutionGriptapeNodeEvent):
-                    result_event = event.wrapped_event
-
-                    if type(result_event.payload).__name__ == "ControlFlowResolvedEvent":
-                        self._submit_output(self._get_output_for_flow(flow_name=flow_name))
-                        is_flow_finished = True
-                        logger.info("Workflow finished!")
-                    elif type(result_event.payload).__name__ == "ControlFlowCancelledEvent":
-                        msg = "Control flow cancelled"
-                        is_flow_finished = True
-                        logger.error(msg)
-                        error = LocalExecutorError(msg)
-                else:
-                    logger.info("Unknown event type encountered: %s", type(event))
-
-                self.queue.task_done()
+                    is_flow_finished, error = await self._handle_execution_event(event, flow_name)
+
+                event_queue.task_done()
 
             except Exception as e:
                 msg = f"Error handling queue event: {e}"

griptape_nodes/bootstrap/workflow_executors/workflow_executor.py

@@ -1,5 +1,6 @@
+import asyncio
 import logging
-from abc import ABC, abstractmethod
+from abc import abstractmethod
 from typing import Any
 
 from griptape_nodes.drivers.storage import StorageBackend
@@ -7,8 +8,10 @@ from griptape_nodes.drivers.storage import StorageBackend
 logger = logging.getLogger(__name__)
 
 
-class WorkflowExecutor(ABC):
-    @abstractmethod
+class WorkflowExecutor:
+    def __init__(self) -> None:
+        self.output: dict | None = None
+
     def run(
         self,
         workflow_name: str,
@@ -16,4 +19,13 @@ class WorkflowExecutor(ABC):
         storage_backend: StorageBackend = StorageBackend.LOCAL,
         **kwargs: Any,
     ) -> None:
-        pass
+        return asyncio.run(self.arun(workflow_name, flow_input, storage_backend, **kwargs))
+
+    @abstractmethod
+    async def arun(
+        self,
+        workflow_name: str,
+        flow_input: Any,
+        storage_backend: StorageBackend = StorageBackend.LOCAL,
+        **kwargs: Any,
+    ) -> None: ...

griptape_nodes/exe_types/core_types.py

@@ -12,6 +12,7 @@ if TYPE_CHECKING:
     from types import TracebackType
 
     from griptape_nodes.exe_types.node_types import BaseNode
+
 T = TypeVar("T", bound="Parameter")
 N = TypeVar("N", bound="BaseNodeElement")
 
@@ -253,11 +254,12 @@ class BaseNodeElement:
 
     def _emit_alter_element_event_if_possible(self) -> None:
         """Emit an AlterElementEvent if we have node context and the necessary dependencies."""
+        from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+
         if self._node_context is None:
             return
 
         # Import here to avoid circular dependencies
-        from griptape.events import EventBus
 
         from griptape_nodes.retained_mode.events.base_events import ExecutionEvent, ExecutionGriptapeNodeEvent
         from griptape_nodes.retained_mode.events.parameter_events import AlterElementEvent
@@ -281,7 +283,8 @@ class BaseNodeElement:
         event = ExecutionGriptapeNodeEvent(
             wrapped_event=ExecutionEvent(payload=AlterElementEvent(element_details=event_data))
         )
-        EventBus.publish_event(event)
+
+        GriptapeNodes.EventManager().put_event(event)
         self._changes.clear()
 
     def to_dict(self) -> dict[str, Any]:
@@ -712,7 +715,7 @@ class Parameter(BaseNodeElement, UIOptionsMixin):
 
     # "settable" here means whether it can be assigned to during regular business operation.
     # During save/load, this value IS still serialized to save its proper state.
-    settable: bool = True
+    _settable: bool = True
 
     # "serializable" controls whether parameter values should be serialized during save/load operations.
     # Set to False for parameters containing non-serializable types (ImageDrivers, PromptDrivers, file handles, etc.)
@@ -768,7 +771,7 @@ class Parameter(BaseNodeElement, UIOptionsMixin):
         self.tooltip_as_input = tooltip_as_input
         self.tooltip_as_property = tooltip_as_property
         self.tooltip_as_output = tooltip_as_output
-        self.settable = settable
+        self._settable = settable
         self.serializable = serializable
         self.user_defined = user_defined
         if allowed_modes is None:
@@ -909,6 +912,15 @@ class Parameter(BaseNodeElement, UIOptionsMixin):
             self._changes["mode_allowed_output"] = ParameterMode.OUTPUT in value
             self._changes["mode_allowed_property"] = ParameterMode.PROPERTY in value
 
+    @property
+    def settable(self) -> bool:
+        return self._settable
+
+    @settable.setter
+    @BaseNodeElement.emits_update_on_write
+    def settable(self, value: bool) -> None:
+        self._settable = value
+
     @property
     def ui_options(self) -> dict:
         ui_options = {}

griptape_nodes/exe_types/node_types.py

@@ -1,13 +1,13 @@
 from __future__ import annotations
 
+import asyncio
 import logging
 from abc import ABC, abstractmethod
 from collections.abc import Callable, Generator, Iterable
+from concurrent.futures import ThreadPoolExecutor
 from enum import StrEnum, auto
 from typing import Any, NamedTuple, TypeVar
 
-from griptape.events import BaseEvent, EventBus
-
 from griptape_nodes.exe_types.core_types import (
     BaseNodeElement,
     ControlParameterInput,
@@ -120,11 +120,14 @@ class BaseNode(ABC):
     # This is gross and we need to have a universal pass on resolution state changes and emission of events. That's what this ticket does!
     # https://github.com/griptape-ai/griptape-nodes/issues/994
     def make_node_unresolved(self, current_states_to_trigger_change_event: set[NodeResolutionState] | None) -> None:
+        from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+
         # See if the current state is in the set of states to trigger a change event.
         if current_states_to_trigger_change_event is not None and self.state in current_states_to_trigger_change_event:
             # Trigger the change event.
             # Send an event to the GUI so it knows this node has changed resolution state.
-            EventBus.publish_event(
+
+            GriptapeNodes.EventManager().put_event(
                 ExecutionGriptapeNodeEvent(
                     wrapped_event=ExecutionEvent(payload=NodeUnresolvedEvent(node_name=self.name))
                 )
@@ -284,10 +287,6 @@ class BaseNode(ABC):
         # Waiting for https://github.com/griptape-ai/griptape-nodes/issues/1309
         return
 
-    def on_griptape_event(self, event: BaseEvent) -> None:  # noqa: ARG002
-        """Callback for when a Griptape Event comes destined for this Node."""
-        return
-
     def on_node_message_received(
         self,
         optional_element_name: str | None,  # noqa: ARG002
@@ -435,6 +434,9 @@ class BaseNode(ABC):
             if traits:
                 trait = traits[0]  # Take the first Options trait
                 trait.choices = choices
+                # Update the manually set UI options to include the new simple_dropdown
+                if hasattr(parameter, "_ui_options") and parameter._ui_options:
+                    parameter._ui_options["simple_dropdown"] = choices
 
                 if default in choices:
                     parameter.default_value = default
@@ -443,9 +445,6 @@ class BaseNode(ABC):
                     msg = f"Default model '{default}' is not in the provided choices."
                     raise ValueError(msg)
 
-                # Update the manually set UI options to include the new simple_dropdown
-                if hasattr(parameter, "_ui_options") and parameter._ui_options:
-                    parameter._ui_options["simple_dropdown"] = choices
             else:
                 msg = f"No Options trait found for parameter '{param}'."
                 raise ValueError(msg)
@@ -565,7 +564,13 @@ class BaseNode(ABC):
         return None
 
     def set_parameter_value(
-        self, param_name: str, value: Any, *, initial_setup: bool = False, emit_change: bool = True
+        self,
+        param_name: str,
+        value: Any,
+        *,
+        initial_setup: bool = False,
+        emit_change: bool = True,
+        skip_before_value_set: bool = False,
     ) -> None:
         """Attempt to set a Parameter's value.
 
@@ -586,6 +591,7 @@ class BaseNode(ABC):
             value: the value intended to be set
             emit_change: whether to emit a parameter lifecycle event, defaults to True
             initial_setup: Whether this value is being set as the initial setup on the node, defaults to False. When True, the value is not given to any before/after hooks.
+            skip_before_value_set: Whether to skip the before_value_set hook, defaults to False. Used when before_value_set has already been called earlier in the flow.
 
         Returns:
             A set of parameter names within this node that were modified as a result
@@ -614,7 +620,10 @@ class BaseNode(ABC):
         # Allow custom node logic to prepare and possibly mutate the value before it is actually set.
         # Record any parameters modified for cascading.
         if not initial_setup:
-            final_value = self.before_value_set(parameter=parameter, value=candidate_value)
+            if not skip_before_value_set:
+                final_value = self.before_value_set(parameter=parameter, value=candidate_value)
+            else:
+                final_value = candidate_value
             # ACTUALLY SET THE NEW VALUE
             self.parameter_values[param_name] = final_value
 
@@ -710,6 +719,41 @@ class BaseNode(ABC):
     def process[T](self) -> AsyncResult | None:
         pass
 
+    async def aprocess(self) -> None:
+        """Async version of process().
+
+        Default implementation wraps the existing process() method to maintain backwards compatibility.
+        Subclasses can override this method to provide direct async implementation.
+        """
+        result = self.process()
+
+        if result is None:
+            # Simple synchronous node - nothing to do
+            return
+
+        if isinstance(result, Generator):
+            # Handle generator pattern asynchronously using the same logic as before
+            loop = asyncio.get_running_loop()
+
+            try:
+                # Start the generator
+                func = next(result)
+
+                while True:
+                    # Run callable in thread pool (preserving existing behavior)
+                    with ThreadPoolExecutor() as executor:
+                        future_result = await loop.run_in_executor(executor, func)
+
+                    # Send result back and get next callable
+                    func = result.send(future_result)
+
+            except StopIteration:
+                # Generator is done
+                return
+        else:
+            # Some other return type - log warning but continue
+            logger.warning("Node %s process() returned unexpected type: %s", self.name, type(result))
+
     # if not implemented, it will return no issues.
     def validate_before_workflow_run(self) -> list[Exception] | None:
         """Runs before the entire workflow is run."""
@@ -768,6 +812,8 @@ class BaseNode(ABC):
         self.current_spotlight_parameter = None
 
     def append_value_to_parameter(self, parameter_name: str, value: Any) -> None:
+        from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+
         # Add the value to the node
         if parameter_name in self.parameter_output_values:
             try:
@@ -781,9 +827,14 @@ class BaseNode(ABC):
         else:
             self.parameter_output_values[parameter_name] = value
         # Publish the event up!
-        EventBus.publish_event(ProgressEvent(value=value, node_name=self.name, parameter_name=parameter_name))
+
+        GriptapeNodes.EventManager().put_event(
+            ProgressEvent(value=value, node_name=self.name, parameter_name=parameter_name)
+        )
 
     def publish_update_to_parameter(self, parameter_name: str, value: Any) -> None:
+        from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+
         parameter = self.get_parameter_by_name(parameter_name)
         if parameter:
             data_type = parameter.type
@@ -794,7 +845,10 @@ class BaseNode(ABC):
                 data_type=data_type,
                 value=TypeValidator.safe_serialize(value),
             )
-            EventBus.publish_event(ExecutionGriptapeNodeEvent(wrapped_event=ExecutionEvent(payload=payload)))
+
+            GriptapeNodes.EventManager().put_event(
+                ExecutionGriptapeNodeEvent(wrapped_event=ExecutionEvent(payload=payload))
+            )
         else:
             msg = f"Parameter '{parameter_name} doesn't exist on {self.name}'"
             raise RuntimeError(msg)
@@ -907,6 +961,7 @@ class BaseNode(ABC):
         """Emit an AlterElementEvent for parameter add/remove operations."""
         from griptape_nodes.retained_mode.events.base_events import ExecutionEvent, ExecutionGriptapeNodeEvent
         from griptape_nodes.retained_mode.events.parameter_events import AlterElementEvent
+        from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
 
         # Create event data using the parameter's to_event method
         if remove:
@@ -920,7 +975,8 @@ class BaseNode(ABC):
             event = ExecutionGriptapeNodeEvent(
                 wrapped_event=ExecutionEvent(payload=AlterElementEvent(element_details=event_data))
             )
-        EventBus.publish_event(event)
+
+        GriptapeNodes.EventManager().put_event(event)
 
     def _get_element_name(self, element: str | int, element_names: list[str]) -> str:
         """Convert an element identifier (name or index) to its name.
@@ -1061,6 +1117,7 @@ class TrackedParameterOutputValues(dict[str, Any]):
         if parameter is not None:
             from griptape_nodes.retained_mode.events.base_events import ExecutionEvent, ExecutionGriptapeNodeEvent
             from griptape_nodes.retained_mode.events.parameter_events import AlterElementEvent
+            from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
 
             # Create event data using the parameter's to_event method
             event_data = parameter.to_event(self._node)
@@ -1073,7 +1130,8 @@ class TrackedParameterOutputValues(dict[str, Any]):
             event = ExecutionGriptapeNodeEvent(
                 wrapped_event=ExecutionEvent(payload=AlterElementEvent(element_details=event_data))
             )
-            EventBus.publish_event(event)
+
+            GriptapeNodes.EventManager().put_event(event)
 
 
 class ControlNode(BaseNode):