griptape-nodes 0.35.0__py3-none-any.whl → 0.36.0__py3-none-any.whl

griptape_nodes/bootstrap/bootstrap_script.py

@@ -1,34 +1,10 @@
 import argparse
-import importlib.util
 import json
 import logging
-import os
-import sys
-from pathlib import Path
-from queue import Queue
-from typing import Any
 
 from dotenv import load_dotenv
-from griptape.artifacts import TextArtifact
-from griptape.drivers.event_listener.griptape_cloud_event_listener_driver import GriptapeCloudEventListenerDriver
-from griptape.events import BaseEvent, EventBus, EventListener, FinishStructureRunEvent
-from register_libraries_script import (  # type: ignore[import] - This import is used in the runtime environment
-    PATHS,
-    register_libraries,
-)
 
-from griptape_nodes.exe_types.flow import ControlFlow
-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.parameter_events import SetParameterValueRequest
-from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+from griptape_nodes.bootstrap.workflow_runners.bootstrap_workflow_runner import BootstrapWorkflowRunner
 
 logging.basicConfig(
     level=logging.INFO,
@@ -38,211 +14,6 @@ logger.setLevel(logging.INFO)
 
 load_dotenv()
 
-queue = Queue()
-
-
-def _load_user_workflow(path_to_workflow: str) -> None:
-    # Ensure file_path is a Path object
-    file_path = Path(path_to_workflow)
-
-    # Generate a unique module name
-    module_name = f"dynamic_module_{file_path.name.replace('.', '_')}_{hash(str(file_path))}"
-
-    # Load the module specification
-    spec = importlib.util.spec_from_file_location(module_name, file_path)
-    if spec is None or spec.loader is None:
-        msg = f"Could not load module specification from {file_path}"
-        raise ImportError(msg)
-
-    # Create the module
-    module = importlib.util.module_from_spec(spec)
-
-    # Add to sys.modules to handle recursive imports
-    sys.modules[module_name] = module
-
-    # Execute the module
-    spec.loader.exec_module(module)
-
-
-def _load_flow_for_workflow() -> ControlFlow:
-    context_manager = GriptapeNodes.ContextManager()
-    return context_manager.get_current_flow()
-
-
-def _set_workflow_context(workflow_name: str) -> None:
-    context_manager = GriptapeNodes.ContextManager()
-    context_manager.push_workflow(workflow_name=workflow_name)
-
-
-def _handle_event(event: BaseEvent) -> None:
-    try:
-        if isinstance(event, GriptapeNodeEvent):
-            __handle_node_event(event)
-        elif isinstance(event, ExecutionGriptapeNodeEvent):
-            __handle_execution_node_event(event)
-        elif isinstance(event, ProgressEvent):
-            __handle_progress_event(event)
-        elif isinstance(event, AppEvent):
-            __handle_app_event(event)
-        else:
-            msg = f"Unknown event type: {type(event)}"
-            logger.info(msg)
-            queue.put(event)
-    except Exception as e:
-        logger.info(e)
-
-
-def __handle_node_event(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(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))
-        GriptapeNodes.handle_request(event_request.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)
-
-    queue.put(event)
-
-
-def __handle_progress_event(gt_event: ProgressEvent) -> None:
-    event_log = f"ProgressEvent: {gt_event}"
-    logger.info(event_log)
-
-
-def __handle_app_event(event: AppEvent) -> None:
-    event_log = f"AppEvent: {event.payload}"
-    logger.info(event_log)
-
-
-def _submit_output(output: dict) -> None:
-    if "GT_CLOUD_STRUCTURE_RUN_ID" in os.environ:
-        kwargs: dict = {
-            "batched": False,
-        }
-        if "GT_CLOUD_BASE_URL" in os.environ:
-            base_url = os.environ["GT_CLOUD_BASE_URL"]
-            if "http://localhost" in base_url or "http://127.0.0.1" in base_url:
-                kwargs["headers"] = {}
-        gtc_event_listener = GriptapeCloudEventListenerDriver(**kwargs)
-        gtc_event_listener.try_publish_event_payload(
-            FinishStructureRunEvent(output_task_output=TextArtifact(json.dumps(output))).to_dict()
-        )
-
-
-def _set_input_for_flow(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():
-        if isinstance(node, StartNode):
-            param_map: dict | None = flow_input.get(node_name)
-            if param_map is not None:
-                for parameter_name, parameter_value in param_map.items():
-                    set_parameter_value_request = SetParameterValueRequest(
-                        parameter_name=parameter_name,
-                        value=parameter_value,
-                        node_name=node_name,
-                    )
-                    set_parameter_value_result = GriptapeNodes.handle_request(set_parameter_value_request)
-
-                    if set_parameter_value_result.failed():
-                        msg = f"Failed to set parameter {parameter_name} for node {node_name}."
-                        raise ValueError(msg)
-
-
-def _get_output_for_flow(flow_name: str) -> dict:
-    control_flow = GriptapeNodes.FlowManager().get_flow_by_name(flow_name)
-    nodes = control_flow.nodes
-    output = {}
-    for node_name, node in nodes.items():
-        if isinstance(node, EndNode):
-            output[node_name] = node.parameter_values
-
-    return output
-
-
-def run(workflow_name: str, flow_input: Any) -> None:
-    """Executes a published workflow.
-
-    Executes a workflow by setting up event listeners, registering libraries,
-    loading the user-defined workflow, and running the specified workflow.
-
-    Parameters:
-        workflow_name: The name of the workflow to execute.
-        flow_input: Input data for the flow, typically a dictionary.
-
-    Returns:
-        None
-    """
-    EventBus.add_event_listener(
-        event_listener=EventListener(
-            on_event=_handle_event,
-        )
-    )
-
-    # Register all of our relevant libraries
-    register_libraries(PATHS)
-
-    # Required to set the workflow_context before loading the workflow
-    # or nothing works. The name can be anything, but how about the workflow_name.
-    _set_workflow_context(workflow_name=workflow_name)
-    _load_user_workflow("workflow.py")
-    flow = _load_flow_for_workflow()
-    flow_name = flow.name
-    # Now let's set the input to the flow
-    _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)
-
-    if start_flow_result.failed():
-        msg = f"Failed to start flow {workflow_name}"
-        raise ValueError(msg)
-
-    logger.info("Workflow started!")
-
-    # Wait for the control flow to finish
-    is_flow_finished = False
-    while not is_flow_finished:
-        try:
-            event = queue.get(block=True)
-            if isinstance(event, ExecutionGriptapeNodeEvent):
-                result_event = event.wrapped_event
-
-                if type(result_event.payload).__name__ == "ControlFlowResolvedEvent":
-                    _submit_output(_get_output_for_flow(flow_name=flow_name))
-                    is_flow_finished = True
-                    logger.info("Workflow finished!")
-
-            queue.task_done()
-
-        except Exception as e:
-            msg = f"Error handling queue event: {e}"
-            logger.info(msg)
-
 
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
@@ -258,10 +29,17 @@ if __name__ == "__main__":
         default=None,
         help="The input to the flow",
     )
+    parser.add_argument(
+        "-s",
+        "--storage-backend",
+        default="local",
+        help="The storage backend to use",
+    )
 
     args = parser.parse_args()
     workflow_name = args.workflow_name
     flow_input = args.input
+    storage_backend = args.storage_backend
 
     try:
         flow_input = json.loads(flow_input) if flow_input else {}
@@ -270,4 +48,7 @@ if __name__ == "__main__":
         logger.info(msg)
         raise
 
-    run(workflow_name=workflow_name, flow_input=flow_input)
+    workflow_runner = BootstrapWorkflowRunner()
+    workflow_runner.run(
+        workflow_path="workflow.py", workflow_name=workflow_name, flow_input=flow_input, storage_backend=storage_backend
+    )

griptape_nodes/bootstrap/workflow_runners/__init__.py

@@ -0,0 +1 @@
+"""Workflow runners package."""

griptape_nodes/bootstrap/workflow_runners/bootstrap_workflow_runner.py

@@ -0,0 +1,28 @@
+import json
+import os
+
+from griptape.artifacts import TextArtifact
+from griptape.drivers.event_listener.griptape_cloud_event_listener_driver import GriptapeCloudEventListenerDriver
+from griptape.events import FinishStructureRunEvent
+from register_libraries_script import PATHS  # type: ignore[import] - This import is used in the runtime environment
+
+from griptape_nodes.bootstrap.workflow_runners.local_workflow_runner import LocalWorkflowRunner
+
+
+class BootstrapWorkflowRunner(LocalWorkflowRunner):
+    def __init__(self) -> None:
+        super().__init__(libraries=PATHS)
+
+    def _submit_output(self, output: dict) -> None:
+        if "GT_CLOUD_STRUCTURE_RUN_ID" in os.environ:
+            kwargs: dict = {
+                "batched": False,
+            }
+            if "GT_CLOUD_BASE_URL" in os.environ:
+                base_url = os.environ["GT_CLOUD_BASE_URL"]
+                if "http://localhost" in base_url or "http://127.0.0.1" in base_url:
+                    kwargs["headers"] = {}
+            gtc_event_listener = GriptapeCloudEventListenerDriver(**kwargs)
+            gtc_event_listener.try_publish_event_payload(
+                FinishStructureRunEvent(output_task_output=TextArtifact(json.dumps(output))).to_dict()
+            )

griptape_nodes/bootstrap/workflow_runners/local_workflow_runner.py

@@ -0,0 +1,237 @@
+import importlib.util
+import logging
+import sys
+from pathlib import Path
+from queue import Queue
+from typing import Any
+
+from griptape.events import BaseEvent, EventBus, EventListener
+
+from griptape_nodes.bootstrap.register_libraries_script import register_libraries
+from griptape_nodes.bootstrap.workflow_runners.workflow_runner import WorkflowRunner
+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.parameter_events import SetParameterValueRequest
+from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+
+logger = logging.getLogger(__name__)
+
+
+class LocalWorkflowRunner(WorkflowRunner):
+    def __init__(self, libraries: list[Path]) -> None:
+        self.registered_libraries = False
+        self.libraries = libraries
+        self.queue = Queue()
+
+    def _load_user_workflow(self, path_to_workflow: str) -> None:
+        # Ensure file_path is a Path object
+        file_path = Path(path_to_workflow)
+
+        # Generate a unique module name
+        module_name = f"dynamic_module_{file_path.name.replace('.', '_')}_{hash(str(file_path))}"
+
+        # Load the module specification
+        spec = importlib.util.spec_from_file_location(module_name, file_path)
+        if spec is None or spec.loader is None:
+            msg = f"Could not load module specification from {file_path}"
+            raise ImportError(msg)
+
+        # Create the module
+        module = importlib.util.module_from_spec(spec)
+
+        # Add to sys.modules to handle recursive imports
+        sys.modules[module_name] = module
+
+        # Execute the module
+        spec.loader.exec_module(module)
+
+    def _load_flow_for_workflow(self) -> str:
+        context_manager = GriptapeNodes.ContextManager()
+        return context_manager.get_current_flow().name
+
+    def _set_storage_backend(self, storage_backend: str) -> None:
+        from griptape_nodes.retained_mode.managers.config_manager import ConfigManager
+
+        config_manager = ConfigManager()
+        config_manager.set_config_value(
+            key="storage_backend",
+            value=storage_backend,
+        )
+
+    def _register_libraries(self) -> None:
+        if not self.registered_libraries:
+            register_libraries([str(p) for p in self.libraries])
+            self.registered_libraries = True
+
+    def _set_workflow_context(self, workflow_name: str) -> None:
+        context_manager = GriptapeNodes.ContextManager()
+        context_manager.push_workflow(workflow_name=workflow_name)
+
+    def _handle_event(self, event: BaseEvent) -> None:
+        try:
+            if isinstance(event, GriptapeNodeEvent):
+                self.__handle_node_event(event)
+            elif isinstance(event, ExecutionGriptapeNodeEvent):
+                self.__handle_execution_node_event(event)
+            elif isinstance(event, ProgressEvent):
+                self.__handle_progress_event(event)
+            elif isinstance(event, AppEvent):
+                self.__handle_app_event(event)
+            else:
+                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))
+            GriptapeNodes.handle_request(event_request.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:
+        control_flow = GriptapeNodes.FlowManager().get_flow_by_name(flow_name)
+        nodes = control_flow.nodes
+        for node_name, node in nodes.items():
+            if isinstance(node, StartNode):
+                param_map: dict | None = flow_input.get(node_name)
+                if param_map is not None:
+                    for parameter_name, parameter_value in param_map.items():
+                        set_parameter_value_request = SetParameterValueRequest(
+                            parameter_name=parameter_name,
+                            value=parameter_value,
+                            node_name=node_name,
+                        )
+                        set_parameter_value_result = GriptapeNodes.handle_request(set_parameter_value_request)
+
+                        if set_parameter_value_result.failed():
+                            msg = f"Failed to set parameter {parameter_name} for node {node_name}."
+                            raise ValueError(msg)
+
+    def _get_output_for_flow(self, flow_name: str) -> dict:
+        control_flow = GriptapeNodes.FlowManager().get_flow_by_name(flow_name)
+        nodes = control_flow.nodes
+        output = {}
+        for node_name, node in nodes.items():
+            if isinstance(node, EndNode):
+                output[node_name] = node.parameter_values
+
+        return output
+
+    def run(self, workflow_path: str, workflow_name: str, flow_input: Any, storage_backend: str = "local") -> None:
+        """Executes a published workflow.
+
+        Executes a workflow by setting up event listeners, registering libraries,
+        loading the user-defined workflow, and running the specified workflow.
+
+        Parameters:
+            workflow_name: The name of the workflow to execute.
+            flow_input: Input data for the flow, typically a dictionary.
+
+        Returns:
+            None
+        """
+        EventBus.add_event_listener(
+            event_listener=EventListener(
+                on_event=self._handle_event,
+            )
+        )
+
+        # Set the storage backend
+        self._set_storage_backend(storage_backend=storage_backend)
+
+        # Register all of our relevant libraries
+        self._register_libraries()
+
+        # Required to set the workflow_context before loading the workflow
+        # or nothing works. The name can be anything, but how about the workflow_name.
+        self._set_workflow_context(workflow_name=workflow_name)
+        self._load_user_workflow(workflow_path)
+        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)
+
+        # 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)
+
+        if start_flow_result.failed():
+            msg = f"Failed to start flow {workflow_name}"
+            raise ValueError(msg)
+
+        logger.info("Workflow started!")
+
+        # Wait for the control flow to finish
+        is_flow_finished = False
+        error: Exception | None = None
+        while not is_flow_finished:
+            try:
+                event = self.queue.get(block=True)
+
+                if 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 = ValueError(msg)
+
+                self.queue.task_done()
+
+            except Exception as e:
+                msg = f"Error handling queue event: {e}"
+                logger.info(msg)
+
+        if error is not None:
+            raise error

griptape_nodes/bootstrap/workflow_runners/subprocess_workflow_runner.py

@@ -0,0 +1,58 @@
+import logging
+import threading
+from multiprocessing import Process, Queue
+from pathlib import Path
+from typing import Any
+
+from griptape_nodes.app.app import _serve_static_server
+from griptape_nodes.bootstrap.workflow_runners.local_workflow_runner import LocalWorkflowRunner
+from griptape_nodes.bootstrap.workflow_runners.workflow_runner import WorkflowRunner
+
+
+class SubprocessWorkflowRunner(WorkflowRunner):
+    def __init__(self, libraries: list[Path]) -> None:
+        self.libraries = libraries
+
+    @staticmethod
+    def _subprocess_entry(
+        exception_queue: Queue,
+        libraries: list[Path],
+        workflow_path: str,
+        workflow_name: str,
+        flow_input: Any,
+    ) -> None:
+        # Reset logging to avoid duplicate logs in tests - this does not remove logs
+        # because griptape nodes is doing some configuration of its own that seems
+        # difficult to control.
+        logger = logging.getLogger()
+        for handler in logger.handlers[:]:
+            logger.removeHandler(handler)
+        logger.setLevel(logging.NOTSET)
+
+        try:
+            threading.Thread(target=_serve_static_server, daemon=True).start()
+            workflow_runner = LocalWorkflowRunner(libraries)
+            workflow_runner.run(workflow_path, workflow_name, flow_input, "local")
+        except Exception as e:
+            exception_queue.put(e)
+            raise
+
+    def run(self, workflow_path: str, workflow_name: str, flow_input: Any, storage_backend: str = "local") -> None:  # noqa: ARG002
+        exception_queue = Queue()
+        process = Process(
+            target=self._subprocess_entry,
+            args=(exception_queue, self.libraries, workflow_path, workflow_name, flow_input),
+        )
+        process.start()
+        process.join()
+
+        if not exception_queue.empty():
+            exception = exception_queue.get_nowait()
+            if isinstance(exception, Exception):
+                raise exception
+            msg = f"Expected an Exception but got: {type(exception)}"
+            raise RuntimeError(msg)
+
+        if process.exitcode != 0:
+            msg = f"Process exited with code {process.exitcode} but no exception was raised."
+            raise RuntimeError(msg)

griptape_nodes/bootstrap/workflow_runners/workflow_runner.py

@@ -0,0 +1,11 @@
+import logging
+from abc import ABC, abstractmethod
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+class WorkflowRunner(ABC):
+    @abstractmethod
+    def run(self, workflow_path: str, workflow_name: str, flow_input: Any, storage_backend: str = "local") -> None:
+        pass

griptape_nodes/exe_types/core_types.py

@@ -11,6 +11,7 @@ if TYPE_CHECKING:
     from collections.abc import Callable
     from types import TracebackType
 
+    from griptape_nodes.exe_types.node_types import BaseNode
 T = TypeVar("T", bound="Parameter")
 N = TypeVar("N", bound="BaseNodeElement")
 
@@ -271,6 +272,31 @@ class BaseNodeElement:
         """Return the element on top of the stack, or None if no active element."""
         return cls._stack[-1] if cls._stack else None
 
+    def to_event(self, node: BaseNode) -> dict:
+        """Serializes the node element and its children into a dictionary representation.
+
+        This method is used to create a data payload for AlterElementEvent to communicate changes or the current state of an element.
+        The resulting dictionary includes the element's ID, type, name, the name of the
+        provided BaseNode, and a recursively serialized list of its children.
+
+        For new BaseNodeElement types that require different serialization logic and fields, this method should be overridden to provide the necessary data.
+
+        Args:
+            node: The BaseNode instance to which this element is associated.
+                  Used to include the node's name in the event data.
+
+        Returns:
+            A dictionary containing the serialized data of the element and its children.
+        """
+        event_data = {
+            "element_id": self.element_id,
+            "element_type": self.element_type,
+            "name": self.name,
+            "node_name": node.name,
+            "children": [child.to_event(node) for child in self.children],
+        }
+        return event_data
+
 
 @dataclass(kw_only=True)
 class ParameterMessage(BaseNodeElement):
@@ -327,6 +353,13 @@ class ParameterMessage(BaseNodeElement):
 
         return data
 
+    def to_event(self, node: BaseNode) -> dict:
+        event_data = super().to_event(node)
+        dict_data = self.to_dict()
+        # Combine them both to get what we need for the UI.
+        event_data.update(dict_data)
+        return event_data
+
 
 @dataclass(kw_only=True)
 class ParameterGroup(BaseNodeElement):
@@ -359,6 +392,11 @@ class ParameterGroup(BaseNodeElement):
         our_dict["ui_options"] = self.ui_options
         return our_dict
 
+    def to_event(self, node: BaseNode) -> dict:
+        event_data = super().to_event(node)
+        event_data["ui_options"] = self.ui_options
+        return event_data
+
     def equals(self, other: ParameterGroup) -> dict:
         self_dict = {"name": self.name, "ui_options": self.ui_options}
         other_dict = {"name": other.name, "ui_options": other.ui_options}
@@ -545,6 +583,18 @@ class Parameter(BaseNodeElement):
 
         return our_dict
 
+    def to_event(self, node: BaseNode) -> dict:
+        event_dict = self.to_dict()
+        event_data = super().to_event(node)
+        event_dict.update(event_data)
+        # Update for our name with the right values
+        name = event_dict.pop("name")
+        event_dict["parameter_name"] = name
+        # Update with value
+        if node is not None:
+            event_dict["value"] = node.get_parameter_value(self.name)
+        return event_dict
+
     @property
     def type(self) -> str:
         return self._custom_getter_for_property_type()