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

griptape_nodes/retained_mode/griptape_nodes.py

@@ -36,9 +36,7 @@ from griptape_nodes.retained_mode.events.app_events import (
     SetEngineNameResultSuccess,
 )
 from griptape_nodes.retained_mode.events.base_events import (
-    AppPayload,
-    RequestPayload,
-    ResultPayload,
+    GriptapeNodeEvent,
     ResultPayloadFailure,
 )
 from griptape_nodes.retained_mode.events.flow_events import (
@@ -48,6 +46,11 @@ from griptape_nodes.utils.metaclasses import SingletonMeta
 from griptape_nodes.utils.version_utils import engine_version
 
 if TYPE_CHECKING:
+    from griptape_nodes.retained_mode.events.base_events import (
+        AppPayload,
+        RequestPayload,
+        ResultPayload,
+    )
     from griptape_nodes.retained_mode.managers.agent_manager import AgentManager
     from griptape_nodes.retained_mode.managers.arbitrary_code_exec_manager import (
         ArbitraryCodeExecManager,
@@ -70,6 +73,9 @@ if TYPE_CHECKING:
         StaticFilesManager,
     )
     from griptape_nodes.retained_mode.managers.sync_manager import SyncManager
+    from griptape_nodes.retained_mode.managers.variable_manager import (
+        VariablesManager,
+    )
     from griptape_nodes.retained_mode.managers.version_compatibility_manager import (
         VersionCompatibilityManager,
     )
@@ -132,6 +138,7 @@ class GriptapeNodes(metaclass=SingletonMeta):
     _context_manager: ContextManager
     _library_manager: LibraryManager
     _workflow_manager: WorkflowManager
+    _workflow_variables_manager: VariablesManager
     _arbitrary_code_exec_manager: ArbitraryCodeExecManager
     _operation_depth_manager: OperationDepthManager
     _static_files_manager: StaticFilesManager
@@ -164,6 +171,9 @@ class GriptapeNodes(metaclass=SingletonMeta):
             StaticFilesManager,
         )
         from griptape_nodes.retained_mode.managers.sync_manager import SyncManager
+        from griptape_nodes.retained_mode.managers.variable_manager import (
+            VariablesManager,
+        )
         from griptape_nodes.retained_mode.managers.version_compatibility_manager import (
             VersionCompatibilityManager,
         )
@@ -183,6 +193,7 @@ class GriptapeNodes(metaclass=SingletonMeta):
             self._context_manager = ContextManager(self._event_manager)
             self._library_manager = LibraryManager(self._event_manager)
             self._workflow_manager = WorkflowManager(self._event_manager)
+            self._workflow_variables_manager = VariablesManager(self._event_manager)
             self._arbitrary_code_exec_manager = ArbitraryCodeExecManager(self._event_manager)
             self._operation_depth_manager = OperationDepthManager(self._config_manager)
             self._static_files_manager = StaticFilesManager(
@@ -226,33 +237,53 @@ class GriptapeNodes(metaclass=SingletonMeta):
     def handle_request(
         cls,
         request: RequestPayload,
-        *,
-        response_topic: str | None = None,
-        request_id: str | None = None,
     ) -> ResultPayload:
+        """Synchronous request handler."""
         event_mgr = GriptapeNodes.EventManager()
-        obj_depth_mgr = GriptapeNodes.OperationDepthManager()
-        workflow_mgr = GriptapeNodes.WorkflowManager()
+
         try:
-            return event_mgr.handle_request(
-                request=request,
-                operation_depth_mgr=obj_depth_mgr,
-                workflow_mgr=workflow_mgr,
-                response_topic=response_topic,
-                request_id=request_id,
-            )
+            result_event = event_mgr.handle_request(request=request)
+            event_mgr.put_event(GriptapeNodeEvent(wrapped_event=result_event))
         except Exception as e:
             logger.exception(
                 "Unhandled exception while processing request of type %s. "
-                "Consider saving your work and restarting the engine if issues persist.",
+                "Consider saving your work and restarting the engine if issues persist."
+                "Request: %s",
                 type(request).__name__,
+                request,
             )
             return ResultPayloadFailure(exception=e)
+        else:
+            return result_event.result
 
     @classmethod
-    def broadcast_app_event(cls, app_event: AppPayload) -> None:
+    async def ahandle_request(cls, request: RequestPayload) -> ResultPayload:
+        """Asynchronous request handler.
+
+        Args:
+            request: The request payload to handle.
+        """
+        event_mgr = GriptapeNodes.EventManager()
+
+        try:
+            result_event = await event_mgr.ahandle_request(request=request)
+            await event_mgr.aput_event(GriptapeNodeEvent(wrapped_event=result_event))
+        except Exception as e:
+            logger.exception(
+                "Unhandled exception while processing async request of type %s. "
+                "Consider saving your work and restarting the engine if issues persist."
+                "Request: %s",
+                type(request).__name__,
+                request,
+            )
+            return ResultPayloadFailure(exception=e)
+        else:
+            return result_event.result
+
+    @classmethod
+    async def broadcast_app_event(cls, app_event: AppPayload) -> None:
         event_mgr = GriptapeNodes.get_instance()._event_manager
-        return event_mgr.broadcast_app_event(app_event)
+        await event_mgr.broadcast_app_event(app_event)
 
     @classmethod
     def get_session_id(cls) -> str | None:
@@ -334,6 +365,10 @@ class GriptapeNodes(metaclass=SingletonMeta):
     def SyncManager(cls) -> SyncManager:
         return GriptapeNodes.get_instance()._sync_manager
 
+    @classmethod
+    def VariablesManager(cls) -> VariablesManager:
+        return GriptapeNodes.get_instance()._workflow_variables_manager
+
     @classmethod
     def clear_data(cls) -> None:
         # Get canvas
@@ -357,16 +392,16 @@ class GriptapeNodes(metaclass=SingletonMeta):
             msg = "Failed to successfully delete all objects"
             raise ValueError(msg)
 
-    def on_app_connection_established(self, _payload: AppConnectionEstablished) -> None:
+    async def on_app_connection_established(self, _payload: AppConnectionEstablished) -> None:
         from griptape_nodes.app.app import subscribe_to_topic
 
         # Subscribe to request topic (engine discovery)
-        subscribe_to_topic("request")
+        await subscribe_to_topic("request")
 
         # Get engine ID and subscribe to engine_id/request
         engine_id = GriptapeNodes.get_engine_id()
         if engine_id:
-            subscribe_to_topic(f"engines/{engine_id}/request")
+            await subscribe_to_topic(f"engines/{engine_id}/request")
         else:
             logger.warning("Engine ID not available for subscription")
 
@@ -374,7 +409,7 @@ class GriptapeNodes(metaclass=SingletonMeta):
         session_id = GriptapeNodes.get_session_id()
         if session_id:
             topic = f"sessions/{session_id}/request"
-            subscribe_to_topic(topic)
+            await subscribe_to_topic(topic)
         else:
             logger.info("No session ID available for subscription")
 
@@ -395,7 +430,7 @@ class GriptapeNodes(metaclass=SingletonMeta):
             logger.error(details)
             return GetEngineVersionResultFailure(result_details=details)
 
-    def handle_session_start_request(self, request: AppStartSessionRequest) -> ResultPayload:  # noqa: ARG002
+    async def handle_session_start_request(self, request: AppStartSessionRequest) -> ResultPayload:  # noqa: ARG002
         from griptape_nodes.app.app import subscribe_to_topic
 
         current_session_id = GriptapeNodes.SessionManager().get_active_session_id()
@@ -409,12 +444,12 @@ class GriptapeNodes(metaclass=SingletonMeta):
             details = f"Session '{current_session_id}' already active. Joining..."
 
         topic = f"sessions/{current_session_id}/request"
-        subscribe_to_topic(topic)
+        await subscribe_to_topic(topic)
         logger.info("Subscribed to new session topic: %s", topic)
 
         return AppStartSessionResultSuccess(current_session_id)
 
-    def handle_session_end_request(self, _: AppEndSessionRequest) -> ResultPayload:
+    async def handle_session_end_request(self, _: AppEndSessionRequest) -> ResultPayload:
         from griptape_nodes.app.app import unsubscribe_from_topic
 
         try:
@@ -428,7 +463,7 @@ class GriptapeNodes(metaclass=SingletonMeta):
                 GriptapeNodes.SessionManager().clear_saved_session()
 
             unsubscribe_topic = f"sessions/{previous_session_id}/request"
-            unsubscribe_from_topic(unsubscribe_topic)
+            await unsubscribe_from_topic(unsubscribe_topic)
 
             return AppEndSessionResultSuccess(session_id=previous_session_id)
         except Exception as err:

griptape_nodes/retained_mode/managers/agent_manager.py

@@ -1,7 +1,7 @@
+import asyncio
 import json
 import logging
 import os
-import threading
 import uuid
 from typing import TYPE_CHECKING
 
@@ -10,7 +10,7 @@ from griptape.artifacts import ErrorArtifact, ImageUrlArtifact, JsonArtifact
 from griptape.drivers.image_generation import BaseImageGenerationDriver
 from griptape.drivers.image_generation.griptape_cloud import GriptapeCloudImageGenerationDriver
 from griptape.drivers.prompt.griptape_cloud import GriptapeCloudPromptDriver
-from griptape.events import EventBus, EventListener, FinishTaskEvent, TextChunkEvent
+from griptape.events import FinishTaskEvent, TextChunkEvent
 from griptape.loaders import ImageLoader
 from griptape.memory.structure import ConversationMemory
 from griptape.rules import Rule, Ruleset
@@ -38,6 +38,7 @@ from griptape_nodes.retained_mode.events.agent_events import (
     RunAgentResultSuccess,
 )
 from griptape_nodes.retained_mode.events.base_events import ExecutionEvent, ExecutionGriptapeNodeEvent, ResultPayload
+from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
 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
@@ -128,14 +129,14 @@ class AgentManager:
         }
         return MCPTool(connection=connection)
 
-    def on_handle_run_agent_request(self, request: RunAgentRequest) -> ResultPayload:
+    async def on_handle_run_agent_request(self, request: RunAgentRequest) -> ResultPayload:
         if self.prompt_driver is None:
             self.prompt_driver = self._initialize_prompt_driver()
         if self.image_tool is None:
             self.image_tool = self._initialize_image_tool()
         if self.mcp_tool is None:
             self.mcp_tool = self._initialize_mcp_tool()
-        threading.Thread(target=self._on_handle_run_agent_request, args=(request, EventBus.event_listeners)).start()
+        await asyncio.to_thread(self._on_handle_run_agent_request, request)
         return RunAgentResultStarted()
 
     def _create_agent(self) -> Agent:
@@ -168,10 +169,8 @@ class AgentManager:
             ],
         )
 
-    def _on_handle_run_agent_request(
-        self, request: RunAgentRequest, event_listeners: list[EventListener]
-    ) -> ResultPayload:
-        EventBus.event_listeners = event_listeners
+    def _on_handle_run_agent_request(self, request: RunAgentRequest) -> ResultPayload:
+        # EventBus functionality removed - events now go directly to event queue
         try:
             artifacts = [
                 ImageLoader().parse(ImageUrlArtifact.from_dict(url_artifact).to_bytes())
@@ -190,7 +189,7 @@ class AgentManager:
                         if "conversation_output" in result_json:
                             new_conversation_output = result_json["conversation_output"]
                             if new_conversation_output != last_conversation_output:
-                                EventBus.publish_event(
+                                GriptapeNodes.EventManager().put_event(
                                     ExecutionGriptapeNodeEvent(
                                         wrapped_event=ExecutionEvent(
                                             payload=AgentStreamEvent(

griptape_nodes/retained_mode/managers/event_manager.py

@@ -1,10 +1,12 @@
+from __future__ import annotations
+
+import asyncio
+import inspect
 from collections import defaultdict
-from collections.abc import Callable
 from dataclasses import fields
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, cast
 
-from griptape.events import EventBus
-from typing_extensions import TypeVar
+from typing_extensions import TypedDict, TypeVar
 
 from griptape_nodes.retained_mode.events.base_events import (
     AppPayload,
@@ -12,37 +14,99 @@ from griptape_nodes.retained_mode.events.base_events import (
     EventResultFailure,
     EventResultSuccess,
     FlushParameterChangesRequest,
-    GriptapeNodeEvent,
     RequestPayload,
     ResultPayload,
     WorkflowAlteredMixin,
 )
+from griptape_nodes.utils.async_utils import call_function
 
 if TYPE_CHECKING:
-    from griptape_nodes.retained_mode.griptape_nodes import WorkflowManager
-    from griptape_nodes.retained_mode.managers.operation_manager import OperationDepthManager
+    from collections.abc import Awaitable, Callable
+
 
 RP = TypeVar("RP", bound=RequestPayload, default=RequestPayload)
 AP = TypeVar("AP", bound=AppPayload, default=AppPayload)
 
 
+class ResultContext(TypedDict, total=False):
+    response_topic: str | None
+    request_id: str | None
+
+
 class EventManager:
     def __init__(self) -> None:
         # Dictionary to store the SPECIFIC manager for each request type
         self._request_type_to_manager: dict[type[RequestPayload], Callable] = defaultdict(list)  # pyright: ignore[reportAttributeAccessIssue]
         # Dictionary to store ALL SUBSCRIBERS to app events.
         self._app_event_listeners: dict[type[AppPayload], set[Callable]] = {}
-        self.current_active_node: str | None = None
         # Boolean that lets us know if there is currently a FlushParameterChangesRequest in the event queue.
         self._flush_in_queue: bool = False
+        # Event queue for publishing events
+        self._event_queue: asyncio.Queue | None = None
+
+    @property
+    def event_queue(self) -> asyncio.Queue:
+        if self._event_queue is None:
+            msg = "Event queue has not been initialized. Please call 'initialize_queue' with an asyncio.Queue instance before accessing the event queue."
+            raise ValueError(msg)
+        return self._event_queue
 
     def clear_flush_in_queue(self) -> None:
         self._flush_in_queue = False
 
+    def initialize_queue(self, queue: asyncio.Queue | None = None) -> None:
+        """Set the event queue for this manager.
+
+        Args:
+            queue: The asyncio.Queue to use for events, or None to clear
+        """
+        if queue is not None:
+            self._event_queue = queue
+        else:
+            try:
+                self._event_queue = asyncio.Queue()
+            except RuntimeError:
+                # Defer queue creation until we're in an event loop
+                self._event_queue = None
+
+    def put_event(self, event: Any) -> None:
+        """Put event into async queue from sync context (non-blocking).
+
+        Args:
+            event: The event to publish to the queue
+        """
+        if self._event_queue is None:
+            return
+
+        self._event_queue.put_nowait(event)
+
+    async def aput_event(self, event: Any) -> None:
+        """Put event into async queue from async context.
+
+        Args:
+            event: The event to publish to the queue
+        """
+        if self._event_queue is None:
+            return
+
+        await self._event_queue.put(event)
+
+    def put_event_threadsafe(self, loop: Any, event: Any) -> None:
+        """Put event into async queue from sync context in a thread-safe manner.
+
+        Args:
+            loop: The asyncio event loop to use for thread-safe operation
+            event: The event to publish to the queue
+        """
+        if self._event_queue is None:
+            return
+
+        loop.call_soon_threadsafe(self._event_queue.put_nowait, event)
+
     def assign_manager_to_request_type(
         self,
         request_type: type[RP],
-        callback: Callable[[RP], ResultPayload],
+        callback: Callable[[RP], ResultPayload] | Callable[[RP], Awaitable[ResultPayload]],
     ) -> None:
         """Assign a manager to handle a request.
 
@@ -65,79 +129,154 @@ class EventManager:
         if request_type in self._request_type_to_manager:
             del self._request_type_to_manager[request_type]
 
-    def handle_request(
+    def _handle_request_core(
+        self,
+        request: RP,
+        callback_result: ResultPayload,
+        *,
+        context: ResultContext,
+    ) -> EventResultSuccess | EventResultFailure:
+        """Core logic for handling requests, shared between sync and async methods."""
+        from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+
+        operation_depth_mgr = GriptapeNodes.OperationDepthManager()
+        workflow_mgr = GriptapeNodes.WorkflowManager()
+
+        with operation_depth_mgr as depth_manager:
+            # Now see if the WorkflowManager was asking us to squelch altered_workflow_state commands
+            # This prevents situations like loading a workflow (which naturally alters the workflow state)
+            # from coming in and immediately being flagged as being dirty.
+            if workflow_mgr.should_squelch_workflow_altered():
+                callback_result.altered_workflow_state = False
+
+            retained_mode_str = None
+            # If request_id exists, that means it's a direct request from the GUI (not internal), and should be echoed by retained mode.
+            if depth_manager.is_top_level() and context.get("request_id") is not None:
+                retained_mode_str = depth_manager.request_retained_mode_translation(request)
+
+            # Some requests have fields marked as "omit_from_result" which should be removed from the request
+            for field in fields(request):
+                if field.metadata.get("omit_from_result", False):
+                    setattr(request, field.name, None)
+            if callback_result.succeeded():
+                result_event = EventResultSuccess(
+                    request=request,
+                    request_id=context.get("request_id"),
+                    result=callback_result,
+                    retained_mode=retained_mode_str,
+                    response_topic=context.get("response_topic"),
+                )
+            else:
+                result_event = EventResultFailure(
+                    request=request,
+                    request_id=context.get("request_id"),
+                    result=callback_result,
+                    retained_mode=retained_mode_str,
+                    response_topic=context.get("response_topic"),
+                )
+
+        return result_event
+
+    async def ahandle_request(
         self,
         request: RP,
         *,
-        operation_depth_mgr: "OperationDepthManager",
-        workflow_mgr: "WorkflowManager",
-        response_topic: str | None = None,
-        request_id: str | None = None,
-    ) -> ResultPayload:
+        result_context: ResultContext | None = None,
+    ) -> EventResultSuccess | EventResultFailure:
         """Publish an event to the manager assigned to its type.
 
         Args:
             request: The request to handle
-            operation_depth_mgr: The operation depth manager to use
-            workflow_mgr: The workflow manager to use
-            response_topic: The topic to send the response to (optional)
-            request_id: The ID of the request to correlate with the response (optional)
+            result_context: The result context containing response_topic and request_id
         """
+        from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+
+        operation_depth_mgr = GriptapeNodes.OperationDepthManager()
+        if result_context is None:
+            result_context = ResultContext()
+
         # Notify the manager of the event type
-        with operation_depth_mgr as depth_manager:
-            request_type = type(request)
-            callback = self._request_type_to_manager.get(request_type)
-            if callback:
-                # Actually make the handler callback:
-                result_payload = callback(request)
-
-                # Now see if the WorkflowManager was asking us to squelch altered_workflow_state commands
-                # This prevents situations like loading a workflow (which naturally alters the workflow state)
-                # from coming in and immediately being flagged as being dirty.
-                if workflow_mgr.should_squelch_workflow_altered():
-                    result_payload.altered_workflow_state = False
-
-                retained_mode_str = None
-                # If request_id exists, that means it's a direct request from the GUI (not internal), and should be echoed by retained mode.
-                if depth_manager.is_top_level() and request_id is not None:
-                    retained_mode_str = depth_manager.request_retained_mode_translation(request)
-
-                # Some requests have fields marked as "omit_from_result" which should be removed from the request
-                for field in fields(request):
-                    if field.metadata.get("omit_from_result", False):
-                        setattr(request, field.name, None)
-                if result_payload.succeeded():
-                    result_event = EventResultSuccess(
-                        request=request,
-                        request_id=request_id,
-                        result=result_payload,
-                        retained_mode=retained_mode_str,
-                        response_topic=response_topic,
-                    )
-                    # If the result is a success, and the WorkflowAlteredMixin is present, that means the flow has been changed in some way.
-                    # In that case, we need to flush the element changes, so we add one to the event queue.
-                    if isinstance(result_event.result, WorkflowAlteredMixin) and not self._flush_in_queue:
-                        from griptape_nodes.app.app import event_queue
-
-                        event_queue.put(EventRequest(request=FlushParameterChangesRequest()))
-                        self._flush_in_queue = True
-                else:
-                    result_event = EventResultFailure(
-                        request=request,
-                        request_id=request_id,
-                        result=result_payload,
-                        retained_mode=retained_mode_str,
-                        response_topic=response_topic,
-                    )
-                wrapped_event = GriptapeNodeEvent(wrapped_event=result_event)
-                EventBus.publish_event(wrapped_event)
-            else:
-                msg = f"No manager found to handle request of type '{request_type.__name__}."
-                raise TypeError(msg)
+        request_type = type(request)
+        callback = self._request_type_to_manager.get(request_type)
+        if not callback:
+            msg = f"No manager found to handle request of type '{request_type.__name__}'."
+            raise TypeError(msg)
+
+        # Actually make the handler callback (support both sync and async):
+        result_payload: ResultPayload = await call_function(callback, request)
+
+        # Handle workflow alteration events for async context
+        with operation_depth_mgr:
+            if (
+                result_payload.succeeded()
+                and isinstance(result_payload, WorkflowAlteredMixin)
+                and not self._flush_in_queue
+            ):
+                await self.aput_event(EventRequest(request=FlushParameterChangesRequest()))
+                self._flush_in_queue = True
+
+        return self._handle_request_core(
+            request,
+            cast("ResultPayload", result_payload),
+            context=result_context,
+        )
+
+    def handle_request(
+        self,
+        request: RP,
+        *,
+        result_context: ResultContext | None = None,
+    ) -> EventResultSuccess | EventResultFailure:
+        """Publish an event to the manager assigned to its type (sync version).
+
+        Args:
+            request: The request to handle
+            result_context: The result context containing response_topic and request_id
+        """
+        from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
 
-        return result_payload
+        operation_depth_mgr = GriptapeNodes.OperationDepthManager()
+        if result_context is None:
+            result_context = ResultContext()
 
-    def add_listener_to_app_event(self, app_event_type: type[AP], callback: Callable[[AP], None]) -> None:
+        # Notify the manager of the event type
+        request_type = type(request)
+        callback = self._request_type_to_manager.get(request_type)
+        if not callback:
+            msg = f"No manager found to handle request of type '{request_type.__name__}'."
+            raise TypeError(msg)
+
+        # Support async callbacks for sync method ONLY if there is no running event loop
+        if inspect.iscoroutinefunction(callback):
+            try:
+                asyncio.get_running_loop()
+                msg = "Async handler cannot be called with sync handle_request. Use ahandle_request instead."
+                raise ValueError(msg)
+            except RuntimeError:
+                # No event loop running, safe to use asyncio.run
+                result_payload: ResultPayload = asyncio.run(callback(request))
+        else:
+            result_payload: ResultPayload = callback(request)
+
+        # Handle workflow alteration events for sync context
+        with operation_depth_mgr:
+            if (
+                result_payload.succeeded()
+                and isinstance(result_payload, WorkflowAlteredMixin)
+                and not self._flush_in_queue
+            ):
+                self.put_event(EventRequest(request=FlushParameterChangesRequest()))
+                self._flush_in_queue = True
+
+        return self._handle_request_core(
+            request,
+            cast("ResultPayload", result_payload),
+            context=result_context,
+        )
+
+    def add_listener_to_app_event(
+        self, app_event_type: type[AP], callback: Callable[[AP], None] | Callable[[AP], Awaitable[None]]
+    ) -> None:
         listener_set = self._app_event_listeners.get(app_event_type)
         if listener_set is None:
             listener_set = set()
@@ -145,13 +284,15 @@ class EventManager:
 
         listener_set.add(callback)
 
-    def remove_listener_for_app_event(self, app_event_type: type[AP], callback: Callable[[AP], None]) -> None:
+    def remove_listener_for_app_event(
+        self, app_event_type: type[AP], callback: Callable[[AP], None] | Callable[[AP], Awaitable[None]]
+    ) -> None:
         listener_set = self._app_event_listeners[app_event_type]
         listener_set.remove(callback)
 
-    def broadcast_app_event(self, app_event: AP) -> None:
+    async def broadcast_app_event(self, app_event: AP) -> None:
         app_event_type = type(app_event)
         if app_event_type in self._app_event_listeners:
             listener_set = self._app_event_listeners[app_event_type]
             for listener_callback in listener_set:
-                listener_callback(app_event)
+                await call_function(listener_callback, app_event)