machinaos 0.0.78 → 0.0.80

package/server/services/deployment/poll_registry.py

@@ -37,14 +37,10 @@ PollCoroutine = Callable[[asyncio.Queue, Callable[[], bool]], Awaitable[None]]
 PollCoroutineFactory = Callable[[str, Dict[str, Any]], PollCoroutine]
 
 
-_REGISTRY: IdempotentRegistry[str, PollCoroutineFactory] = IdempotentRegistry(
-    "poll_coroutine_factory"
-)
+_REGISTRY: IdempotentRegistry[str, PollCoroutineFactory] = IdempotentRegistry("poll_coroutine_factory")
 
 
-def register_poll_coroutine_factory(
-    node_type: str, factory: PollCoroutineFactory
-) -> None:
+def register_poll_coroutine_factory(node_type: str, factory: PollCoroutineFactory) -> None:
     """Publish a polling-coroutine factory for a trigger node type.
 
     Idempotent on re-import (same callable for the same key is a

package/server/services/deployment/state.py

@@ -8,6 +8,7 @@ from typing import Dict, Any, List, Optional
 @dataclass
 class DeploymentState:
     """Immutable deployment state."""
+
     deployment_id: str
     workflow_id: str
     is_running: bool
@@ -33,6 +34,7 @@ class DeploymentState:
 @dataclass
 class TriggerInfo:
     """Info about a registered trigger."""
+
     node_id: str
     node_type: str
     job_id: Optional[str] = None  # For cron triggers

package/server/services/deployment/triggers.py

@@ -33,8 +33,7 @@ class TriggerManager:
     # CRON TRIGGERS
     # =========================================================================
 
-    def setup_cron(self, node_id: str, cron_expr: str, timezone: str,
-                   on_tick: Callable[[], None]) -> str:
+    def setup_cron(self, node_id: str, cron_expr: str, timezone: str, on_tick: Callable[[], None]) -> str:
         """Setup a cron trigger that calls on_tick on schedule."""
         job_id = f"cron_{node_id}"
 
@@ -43,12 +42,7 @@ class TriggerManager:
                 return
             on_tick()
 
-        cron_scheduler.register_cron_job(
-            job_id=job_id,
-            cron_expression=cron_expr,
-            callback=tick_callback,
-            timezone=timezone
-        )
+        cron_scheduler.register_cron_job(job_id=job_id, cron_expression=cron_expr, callback=tick_callback, timezone=timezone)
 
         self._active_cron_jobs[node_id] = job_id
         logger.info("Cron trigger setup", job_id=job_id, expr=cron_expr)
@@ -81,11 +75,15 @@ class TriggerManager:
     # EVENT TRIGGERS (Webhook, WhatsApp, etc.)
     # =========================================================================
 
-    async def setup_event_trigger(self, node_id: str, node_type: str,
-                                   parameters: Dict[str, Any],
-                                   on_event: Callable[[Dict], Any],
-                                   broadcaster: Any,
-                                   workflow_id: Optional[str] = None) -> None:
+    async def setup_event_trigger(
+        self,
+        node_id: str,
+        node_type: str,
+        parameters: Dict[str, Any],
+        on_event: Callable[[Dict], Any],
+        broadcaster: Any,
+        workflow_id: Optional[str] = None,
+    ) -> None:
         """Setup an event-based trigger with queue-based sequential processing.
 
         Args:
@@ -111,12 +109,12 @@ class TriggerManager:
                         msg = f"Waiting for {config.display_name}..."
                         if queue_size > 0:
                             msg = f"Waiting... ({queue_size} queued)"
-                        await broadcaster.update_node_status(node_id, "waiting", {
-                            "message": msg,
-                            "event_type": config.event_type,
-                            "waiter_id": waiter.id,
-                            "queue_size": queue_size
-                        }, workflow_id=workflow_id)
+                        await broadcaster.update_node_status(
+                            node_id,
+                            "waiting",
+                            {"message": msg, "event_type": config.event_type, "waiter_id": waiter.id, "queue_size": queue_size},
+                            workflow_id=workflow_id,
+                        )
 
                     event_data = await event_waiter.wait_for_event(waiter)
                     if self._is_running:
@@ -143,10 +141,9 @@ class TriggerManager:
                     config = event_waiter.get_trigger_config(node_type)
 
                     # Clear waiting indicator during execution
-                    await broadcaster.update_node_status(node_id, "idle", {
-                        "message": "Graph executing...",
-                        "is_processing": True
-                    }, workflow_id=workflow_id)
+                    await broadcaster.update_node_status(
+                        node_id, "idle", {"message": "Graph executing...", "is_processing": True}, workflow_id=workflow_id
+                    )
 
                     try:
                         await on_event(event_data)
@@ -159,11 +156,9 @@ class TriggerManager:
                     queue_size = event_queue.qsize()
                     name = config.display_name if config else node_type
                     msg = f"Waiting for {name}..." if queue_size == 0 else f"Processing next... ({queue_size} queued)"
-                    await broadcaster.update_node_status(node_id, "waiting", {
-                        "message": msg,
-                        "queue_size": queue_size,
-                        "is_processing": False
-                    }, workflow_id=workflow_id)
+                    await broadcaster.update_node_status(
+                        node_id, "waiting", {"message": msg, "queue_size": queue_size, "is_processing": False}, workflow_id=workflow_id
+                    )
 
                 except asyncio.CancelledError:
                     break
@@ -184,12 +179,16 @@ class TriggerManager:
         task = asyncio.create_task(combined())
         self._active_listeners[node_id] = task
 
-    async def setup_polling_trigger(self, node_id: str, node_type: str,
-                                     parameters: Dict[str, Any],
-                                     poll_coroutine: Callable,
-                                     on_event: Callable[[Dict], Any],
-                                     broadcaster: Any,
-                                     workflow_id: Optional[str] = None) -> None:
+    async def setup_polling_trigger(
+        self,
+        node_id: str,
+        node_type: str,
+        parameters: Dict[str, Any],
+        poll_coroutine: Callable,
+        on_event: Callable[[Dict], Any],
+        broadcaster: Any,
+        workflow_id: Optional[str] = None,
+    ) -> None:
         """Setup a polling-based trigger with queue-based sequential processing.
 
         Unlike event triggers that wait for externally dispatched events via
@@ -211,10 +210,9 @@ class TriggerManager:
         # Broadcast initial "waiting" status immediately
         config = event_waiter.get_trigger_config(node_type)
         display_name = config.display_name if config else node_type
-        await broadcaster.update_node_status(node_id, "waiting", {
-            "message": f"Waiting for {display_name} (polling)...",
-            "is_processing": False
-        }, workflow_id=workflow_id)
+        await broadcaster.update_node_status(
+            node_id, "waiting", {"message": f"Waiting for {display_name} (polling)...", "is_processing": False}, workflow_id=workflow_id
+        )
 
         async def poller():
             """Run the polling coroutine to collect events."""
@@ -238,10 +236,9 @@ class TriggerManager:
                     is_executing = True
                     config = event_waiter.get_trigger_config(node_type)
 
-                    await broadcaster.update_node_status(node_id, "idle", {
-                        "message": "Graph executing...",
-                        "is_processing": True
-                    }, workflow_id=workflow_id)
+                    await broadcaster.update_node_status(
+                        node_id, "idle", {"message": "Graph executing...", "is_processing": True}, workflow_id=workflow_id
+                    )
 
                     try:
                         await on_event(event_data)
@@ -253,11 +250,9 @@ class TriggerManager:
                     queue_size = event_queue.qsize()
                     name = config.display_name if config else node_type
                     msg = f"Waiting for {name} (polling)..." if queue_size == 0 else f"Processing next... ({queue_size} queued)"
-                    await broadcaster.update_node_status(node_id, "waiting", {
-                        "message": msg,
-                        "queue_size": queue_size,
-                        "is_processing": False
-                    }, workflow_id=workflow_id)
+                    await broadcaster.update_node_status(
+                        node_id, "waiting", {"message": msg, "queue_size": queue_size, "is_processing": False}, workflow_id=workflow_id
+                    )
 
                 except asyncio.CancelledError:
                     break
@@ -303,48 +298,48 @@ class TriggerManager:
     @staticmethod
     def build_cron_expression(parameters: Dict[str, Any]) -> Optional[str]:
         """Build cron expression from user-friendly parameters."""
-        frequency = parameters.get('frequency', 'minutes')
-
-        second, minute, hour = '0', '*/5', '*'
-        day, month, weekday = '*', '*', '*'
-
-        if frequency == 'seconds':
-            interval = str(parameters.get('interval', 30))
-            second, minute = f'*/{interval}', '*'
-
-        elif frequency == 'minutes':
-            interval = str(parameters.get('interval_minutes', 5))
-            minute = f'*/{interval}' if interval != '1' else '*'
-
-        elif frequency == 'hours':
-            interval = str(parameters.get('interval_hours', 1))
-            minute = '0'
-            hour = f'*/{interval}' if interval != '1' else '*'
-
-        elif frequency == 'days':
-            time_str = parameters.get('daily_time', '09:00')
-            parts = time_str.split(':')
-            hour = parts[0] if parts else '9'
-            minute = parts[1] if len(parts) > 1 else '0'
-
-        elif frequency == 'weeks':
-            time_str = parameters.get('weekly_time', '09:00')
-            parts = time_str.split(':')
-            hour = parts[0] if parts else '9'
-            minute = parts[1] if len(parts) > 1 else '0'
-            weekday = parameters.get('weekday', '1')
-
-        elif frequency == 'months':
-            time_str = parameters.get('monthly_time', '09:00')
-            parts = time_str.split(':')
-            hour = parts[0] if parts else '9'
-            minute = parts[1] if len(parts) > 1 else '0'
-            day = parameters.get('month_day', '1')
-
-        elif frequency == 'once':
+        frequency = parameters.get("frequency", "minutes")
+
+        second, minute, hour = "0", "*/5", "*"
+        day, month, weekday = "*", "*", "*"
+
+        if frequency == "seconds":
+            interval = str(parameters.get("interval", 30))
+            second, minute = f"*/{interval}", "*"
+
+        elif frequency == "minutes":
+            interval = str(parameters.get("interval_minutes", 5))
+            minute = f"*/{interval}" if interval != "1" else "*"
+
+        elif frequency == "hours":
+            interval = str(parameters.get("interval_hours", 1))
+            minute = "0"
+            hour = f"*/{interval}" if interval != "1" else "*"
+
+        elif frequency == "days":
+            time_str = parameters.get("daily_time", "09:00")
+            parts = time_str.split(":")
+            hour = parts[0] if parts else "9"
+            minute = parts[1] if len(parts) > 1 else "0"
+
+        elif frequency == "weeks":
+            time_str = parameters.get("weekly_time", "09:00")
+            parts = time_str.split(":")
+            hour = parts[0] if parts else "9"
+            minute = parts[1] if len(parts) > 1 else "0"
+            weekday = parameters.get("weekday", "1")
+
+        elif frequency == "months":
+            time_str = parameters.get("monthly_time", "09:00")
+            parts = time_str.split(":")
+            hour = parts[0] if parts else "9"
+            minute = parts[1] if len(parts) > 1 else "0"
+            day = parameters.get("month_day", "1")
+
+        elif frequency == "once":
             return None
 
-        return f'{second} {minute} {hour} {day} {month} {weekday}'
+        return f"{second} {minute} {hour} {day} {month} {weekday}"
 
     @staticmethod
     def find_trigger_nodes(nodes: list, edges: list) -> tuple:
@@ -355,16 +350,15 @@ class TriggerManager:
         after an AI agent). Each trigger listens for its event type and, when fired,
         executes its downstream subgraph independently.
         """
-        trigger_types_no_cron = WORKFLOW_TRIGGER_TYPES - {'cronScheduler'}
-        triggers = [n for n in nodes
-                   if n.get('type') in trigger_types_no_cron]
+        trigger_types_no_cron = WORKFLOW_TRIGGER_TYPES - {"cronScheduler"}
+        triggers = [n for n in nodes if n.get("type") in trigger_types_no_cron]
 
-        start_nodes = [n for n in triggers if n.get('type') == 'start']
-        event_triggers = [n for n in triggers if n.get('type') != 'start']
+        start_nodes = [n for n in triggers if n.get("type") == "start"]
+        event_triggers = [n for n in triggers if n.get("type") != "start"]
 
         return start_nodes, event_triggers
 
     @staticmethod
     def find_cron_nodes(nodes: list) -> list:
         """Find all cron scheduler nodes."""
-        return [n for n in nodes if n.get('type') == 'cronScheduler']
+        return [n for n in nodes if n.get("type") == "cronScheduler"]

package/server/services/event_waiter.py

@@ -7,6 +7,7 @@ Architecture:
 - Redis mode: Events stored in Redis Streams, waiters poll streams with blocking XREAD
 - Memory mode: Events dispatched to in-memory asyncio.Future waiters
 """
+
 import asyncio
 import json
 import uuid
@@ -74,9 +75,11 @@ def is_redis_mode() -> bool:
 # TRIGGER CONFIGURATION REGISTRY
 # =============================================================================
 
+
 @dataclass
 class TriggerConfig:
     """Configuration for a trigger node type."""
+
     node_type: str
     event_type: str  # Event to wait for (e.g., 'whatsapp_message_received')
     display_name: str
@@ -86,26 +89,10 @@ class TriggerConfig:
 # Note: cronScheduler is NOT an event-based trigger - it uses APScheduler directly
 TRIGGER_REGISTRY: Dict[str, TriggerConfig] = {
     # Framework-level triggers — not owned by any plugin domain.
-    'start': TriggerConfig(
-        node_type='start',
-        event_type='deploy_triggered',
-        display_name='Deploy Start'
-    ),
-    'webhookTrigger': TriggerConfig(
-        node_type='webhookTrigger',
-        event_type='webhook_received',
-        display_name='Webhook Request'
-    ),
-    'chatTrigger': TriggerConfig(
-        node_type='chatTrigger',
-        event_type='chat_message_received',
-        display_name='Chat Message'
-    ),
-    'taskTrigger': TriggerConfig(
-        node_type='taskTrigger',
-        event_type='task_completed',
-        display_name='Task Completed'
-    ),
+    "start": TriggerConfig(node_type="start", event_type="deploy_triggered", display_name="Deploy Start"),
+    "webhookTrigger": TriggerConfig(node_type="webhookTrigger", event_type="webhook_received", display_name="Webhook Request"),
+    "chatTrigger": TriggerConfig(node_type="chatTrigger", event_type="chat_message_received", display_name="Chat Message"),
+    "taskTrigger": TriggerConfig(node_type="taskTrigger", event_type="task_completed", display_name="Task Completed"),
     # Plugin-owned trigger entries (whatsappReceive, twitterReceive,
     # telegramReceive, emailReceive, googleGmailReceive) live in their
     # plugin folders' ``_filters.py`` and are backfilled here from each
@@ -175,6 +162,7 @@ def is_trigger_node(node_type: str) -> bool:
     This includes all trigger types: start, cronScheduler, and event-based triggers.
     """
     from constants import WORKFLOW_TRIGGER_TYPES
+
     return node_type in WORKFLOW_TRIGGER_TYPES
 
 
@@ -199,6 +187,7 @@ def get_trigger_config(node_type: str) -> Optional[TriggerConfig]:
 # FILTER BUILDERS - One per trigger type
 # =============================================================================
 
+
 def build_webhook_filter(params: Dict) -> Callable[[Dict], bool]:
     """Build filter function for webhook requests.
 
@@ -210,10 +199,10 @@ def build_webhook_filter(params: Dict) -> Callable[[Dict], bool]:
     Returns:
         Filter function that checks if event path matches
     """
-    webhook_path = params.get('path', '')
+    webhook_path = params.get("path", "")
 
     def matches(data: Dict) -> bool:
-        event_path = data.get('path', '')
+        event_path = data.get("path", "")
         if webhook_path and event_path != webhook_path:
             return False
         return True
@@ -231,11 +220,11 @@ def build_chat_filter(params: Dict) -> Callable[[Dict], bool]:
     Returns:
         Filter function that checks if event session_id matches
     """
-    session_id = params.get('session_id', 'default')
+    session_id = params.get("session_id", "default")
 
     def matches(data: Dict) -> bool:
-        event_session = data.get('session_id', 'default')
-        if session_id != 'default' and event_session != session_id:
+        event_session = data.get("session_id", "default")
+        if session_id != "default" and event_session != session_id:
             return False
         return True
 
@@ -257,33 +246,33 @@ def build_task_completed_filter(params: Dict) -> Callable[[Dict], bool]:
     Returns:
         Filter function that checks if event matches criteria
     """
-    task_id_filter = params.get('task_id', '')
-    agent_name_filter = params.get('agent_name', '')
-    status_filter = params.get('status_filter', 'all')  # all, completed, error
-    parent_node_id = params.get('parent_node_id', '')
+    task_id_filter = params.get("task_id", "")
+    agent_name_filter = params.get("agent_name", "")
+    status_filter = params.get("status_filter", "all")  # all, completed, error
+    parent_node_id = params.get("parent_node_id", "")
 
     def matches(data: Dict) -> bool:
         # Task ID filter (exact match if specified)
         if task_id_filter:
-            if data.get('task_id') != task_id_filter:
+            if data.get("task_id") != task_id_filter:
                 return False
 
         # Agent name filter (contains match)
         if agent_name_filter:
-            event_agent = data.get('agent_name', '')
+            event_agent = data.get("agent_name", "")
             if agent_name_filter.lower() not in event_agent.lower():
                 return False
 
         # Status filter
-        event_status = data.get('status', '')
-        if status_filter == 'completed' and event_status != 'completed':
+        event_status = data.get("status", "")
+        if status_filter == "completed" and event_status != "completed":
             return False
-        if status_filter == 'error' and event_status != 'error':
+        if status_filter == "error" and event_status != "error":
             return False
 
         # Parent node filter (for scoping to specific parent agent)
         if parent_node_id:
-            if data.get('parent_node_id') != parent_node_id:
+            if data.get("parent_node_id") != parent_node_id:
                 return False
 
         return True
@@ -301,17 +290,17 @@ def build_task_completed_filter(params: Dict) -> Callable[[Dict], bool]:
 # googleGmailReceive, emailReceive) live in their plugin folders'
 # ``_filters.py`` and self-register at import time.
 FILTER_BUILDERS: Dict[str, Callable[[Dict], Callable[[Dict], bool]]] = {
-    'webhookTrigger': build_webhook_filter,
-    'chatTrigger': build_chat_filter,
-    'taskTrigger': build_task_completed_filter,
+    "webhookTrigger": build_webhook_filter,
+    "chatTrigger": build_chat_filter,
+    "taskTrigger": build_task_completed_filter,
 }
 
 from services.plugin.registry import IdempotentRegistry as _IdempotentRegistry  # noqa: E402
 
 # Backed by the module-level FILTER_BUILDERS dict so existing readers
 # (e.g. build_filter, _ensure_populated, tests) keep working.
-_FILTER_REGISTRY: _IdempotentRegistry[str, Callable[[Dict], Callable[[Dict], bool]]] = (
-    _IdempotentRegistry("filter_builder", items=FILTER_BUILDERS)
+_FILTER_REGISTRY: _IdempotentRegistry[str, Callable[[Dict], Callable[[Dict], bool]]] = _IdempotentRegistry(
+    "filter_builder", items=FILTER_BUILDERS
 )
 
 
@@ -361,9 +350,7 @@ import inspect as _inspect
 
 _TriggerPrecheck = Callable[[Dict[str, Any]], Any]
 _TRIGGER_PRECHECKS: Dict[str, _TriggerPrecheck] = {}
-_TRIGGER_PRECHECK_REGISTRY: _IdempotentRegistry[str, _TriggerPrecheck] = (
-    _IdempotentRegistry("trigger_precheck", items=_TRIGGER_PRECHECKS)
-)
+_TRIGGER_PRECHECK_REGISTRY: _IdempotentRegistry[str, _TriggerPrecheck] = _IdempotentRegistry("trigger_precheck", items=_TRIGGER_PRECHECKS)
 
 
 def register_trigger_precheck(node_type: str, fn: _TriggerPrecheck) -> None:
@@ -394,6 +381,7 @@ async def run_trigger_precheck(node_type: str, parameters: Dict) -> Any:
 # WAITER DATA STRUCTURES
 # =============================================================================
 
+
 @dataclass
 class Waiter:
     """Single event waiter.
@@ -401,6 +389,7 @@ class Waiter:
     In memory mode: uses asyncio.Future
     In Redis mode: uses stream polling with stored metadata
     """
+
     id: str = field(default_factory=lambda: str(uuid.uuid4()))
     node_id: str = ""
     node_type: str = ""
@@ -433,6 +422,7 @@ def _get_stream_name(event_type: str) -> str:
 # WAITER REGISTRATION
 # =============================================================================
 
+
 async def register(node_type: str, node_id: str, params: Dict) -> Waiter:
     """Register a waiter for a trigger node.
 
@@ -480,7 +470,7 @@ async def register(node_type: str, node_id: str, params: Dict) -> Waiter:
         # Create unique consumer group for this waiter
         # start_id='$' means only new messages from this point forward
         stream_name = _get_stream_name(config.event_type)
-        await cache.stream_create_group(stream_name, consumer_group, start_id='$')
+        await cache.stream_create_group(stream_name, consumer_group, start_id="$")
 
         logger.debug(f"[EventWaiter] Registered {node_type} waiter {waiter.id} (Redis)")
     else:
@@ -560,9 +550,9 @@ async def _wait_redis(waiter: Waiter, timeout: Optional[float]) -> Dict:
             result = await cache.stream_read_group(
                 consumer_group,  # Each waiter has its own group
                 consumer_name,
-                {stream_name: '>'},  # '>' = new messages for this consumer
+                {stream_name: ">"},  # '>' = new messages for this consumer
                 count=10,
-                block=block_ms
+                block=block_ms,
             )
 
             if not result:
@@ -616,6 +606,7 @@ def _cleanup_waiter(waiter_id: str) -> None:
 # EVENT DISPATCH
 # =============================================================================
 
+
 def _unpack_event(
     event: "Any",
     data: Optional[Dict] = None,
@@ -638,10 +629,7 @@ def _unpack_event(
         return event.type, event.data if isinstance(event.data, dict) else {"data": event.data}
     if isinstance(event, str):
         return event, data or {}
-    raise TypeError(
-        f"dispatch expects a WorkflowEvent or (event_type: str, data: Dict); "
-        f"got {type(event).__name__}"
-    )
+    raise TypeError(f"dispatch expects a WorkflowEvent or (event_type: str, data: Dict); " f"got {type(event).__name__}")
 
 
 async def dispatch_async(
@@ -713,14 +701,17 @@ def dispatch(
     resolved = 0
     to_remove = []
 
-    matching_waiters = [(wid, w) for wid, w in _waiters.items()
-                        if w.event_type == event_type and w.future and not w.future.done()]
+    matching_waiters = [(wid, w) for wid, w in _waiters.items() if w.event_type == event_type and w.future and not w.future.done()]
 
     if not matching_waiters:
         logger.debug(f"[EventWaiter] No active waiters for {event_type} (total waiters: {len(_waiters)})")
     else:
-        logger.info(f"[EventWaiter] Dispatching {event_type} to {len(matching_waiters)} waiter(s)",
-                    event_type=event_type, from_id=data.get('from_id'), text=str(data.get('text', ''))[:50])
+        logger.info(
+            f"[EventWaiter] Dispatching {event_type} to {len(matching_waiters)} waiter(s)",
+            event_type=event_type,
+            from_id=data.get("from_id"),
+            text=str(data.get("text", ""))[:50],
+        )
 
     for wid, w in matching_waiters:
         try:
@@ -744,6 +735,7 @@ def dispatch(
 # WAITER CANCELLATION
 # =============================================================================
 
+
 def cancel(waiter_id: str) -> bool:
     """Cancel a waiter by ID."""
     if w := _waiters.pop(waiter_id, None):
@@ -776,6 +768,7 @@ def cancel_for_node(node_id: str) -> int:
 # UTILITY FUNCTIONS
 # =============================================================================
 
+
 def get_active_waiters() -> List[Dict[str, Any]]:
     """Get info about active waiters (for debugging/UI)."""
     return [

package/server/services/events/__init__.py

@@ -32,6 +32,17 @@ from .verifiers import (
     GitHubVerifier,
 )
 
+# Wave 12 D3: publish the Visibility admin WS handlers into the central
+# WS dispatcher on package import. Even though ``admin_handlers.py`` is
+# framework code (not plugin code), routing it through the same
+# ws_handler_registry keeps the router's dispatch surface uniform —
+# the registry queries don't care whether the caller is plugin or
+# framework.
+from .admin_handlers import WS_HANDLERS as _ADMIN_WS_HANDLERS  # noqa: E402
+from services.ws_handler_registry import register_ws_handlers as _register_ws_handlers  # noqa: E402
+
+_register_ws_handlers(_ADMIN_WS_HANDLERS)
+
 __all__ = [
     "BaseTriggerParams",
     "DaemonEventSource",