Merge pull request #3 from strohganoff/dispatch-to-action

Update code to handle dispatching events only to their related action

Author: strohganoff

README.md

@@ -64,6 +64,9 @@ def handle_will_appear(event):
     print("Will Appear event received:", event)
 ```
 
+!!!INFO Handlers for action-specific events are dispatched only if the event is triggered by the associated action, ensuring isolation and predictability. For other types of events that are not associated with a specific action, handlers are dispatched without such restrictions.
+
+
 
 ### Writing Logs
 

streamdeck/actions.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from collections import defaultdict
+from functools import cached_property
 from logging import getLogger
 from typing import TYPE_CHECKING
 
@@ -51,6 +52,11 @@ def __init__(self, uuid: str):
 
         self._events: dict[EventNameStr, set[EventHandlerFunc]] = defaultdict(set)
 
+    @cached_property
+    def name(self) -> str:
+        """The name of the action, derived from the last part of the UUID."""
+        return self.uuid.split(".")[-1]
+
     def on(self, event_name: EventNameStr, /) -> Callable[[EventHandlerFunc], EventHandlerFunc]:
         """Register an event handler for a specific event.
 
@@ -90,14 +96,13 @@ def get_event_handlers(self, event_name: EventNameStr, /) -> Generator[EventHand
             msg = f"Provided event name for pulling handlers from action does not exist: {event_name}"
             raise KeyError(msg)
 
-        for event in self._events[event_name]:
-            yield event
+        yield from self._events[event_name]
 
 
 class ActionRegistry:
     """Manages the registration and retrieval of actions and their event handlers."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         """Initialize an ActionRegistry instance."""
         self._plugin_actions: list[Action] = []
 
@@ -109,18 +114,21 @@ def register(self, action: Action) -> None:
         """
         self._plugin_actions.append(action)
 
-    def get_action_handlers(self, event_name: EventNameStr) -> Generator[EventHandlerFunc, None, None]:
+    def get_action_handlers(self, event_name: EventNameStr, event_action_uuid: str | None = None) -> Generator[EventHandlerFunc, None, None]:
         """Get all event handlers for a specific event from all registered actions.
 
         Args:
             event_name (EventName): The name of the event to retrieve handlers for.
+            event_action_uuid (str | None): The action UUID to get handlers for. 
+                If None (i.e., the event is not action-specific), get all handlers for the event.
 
         Yields:
             EventHandlerFunc: The event handler functions for the specified event.
         """
         for action in self._plugin_actions:
-            yield from action.get_event_handlers(event_name)
-
-
-
+            # If the event is action-specific, only get handlers for that action, as we don't want to trigger
+            # and pass this event to handlers for other actions.
+            if event_action_uuid is not None and event_action_uuid != action.uuid:
+                continue
 
+            yield from action.get_event_handlers(event_name)

streamdeck/manager.py

@@ -2,7 +2,7 @@
 
 import logging
 from logging import getLogger
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, cast
 
 from streamdeck.actions import ActionRegistry
 from streamdeck.command_sender import StreamDeckCommandSender
@@ -82,6 +82,9 @@ def run(self) -> None:
                 data: EventBase = event_adapter.validate_json(message)
                 logger.debug("Event received: %s", data.event)
 
-                for handler in self._registry.get_action_handlers(data.event): # type: ignore
+                # If the event is action-specific, we'll pass the action's uuid to the handler to ensure only the correct action is triggered.
+                event_action_uuid: str | None = cast(str, data.action) if data.is_action_specific() else None
+
+                for handler in self._registry.get_action_handlers(event_name=data.event, event_action_uuid=event_action_uuid):
                     # TODO: from contextual event occurences, save metadata to the action's properties.
                     handler(data)

streamdeck/models/events.py

@@ -17,8 +17,9 @@ class EventBase(BaseModel, ABC):
     """Name of the event used to identify what occurred."""
 
     @classmethod
-    def is_action_specific(cls):
-        return "context" in cls.model_fields
+    def is_action_specific(cls) -> bool:
+        """Check if the event is specific to an action instance (i.e. the event has an "action" field)."""
+        return "action" in cls.model_fields
 
 
 class ApplicationDidLaunchEvent(EventBase):

tests/test_action_registry.py

@@ -1,13 +1,20 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
-
 import pytest
+from polyfactory.factories.pydantic_factory import ModelFactory
 from streamdeck.actions import Action, ActionRegistry
+from streamdeck.models import events
+
+
+class DialUpEventFactory(ModelFactory[events.DialUpEvent]):
+    """Polyfactory factory for creating a fake dialUp event message based on our Pydantic model."""
 
+class DialDownEventFactory(ModelFactory[events.DialDownEvent]):
+    """Polyfactory factory for creating a fake dialDown event message based on our Pydantic model."""
+
+class KeyUpEventFactory(ModelFactory[events.KeyUpEvent]):
+    """Polyfactory factory for creating a fake keyUp event message based on our Pydantic model."""
 
-if TYPE_CHECKING:
-    from streamdeck.models.events import EventBase
 
 
 
@@ -30,7 +37,8 @@ def test_get_action_handlers_no_handlers():
 
     registry.register(action)
 
-    handlers = list(registry.get_action_handlers("dialUp"))
+    fake_event_data: events.DialUpEvent = DialUpEventFactory.build()
+    handlers = list(registry.get_action_handlers(event_name=fake_event_data.event, event_action_uuid=fake_event_data.action))
     assert len(handlers) == 0
 
 
@@ -40,11 +48,14 @@ def test_get_action_handlers_with_handlers():
     action = Action("my-fake-action-uuid")
 
     @action.on("dialDown")
-    def dial_down_handler(event: EventBase):
+    def dial_down_handler(event: events.EventBase):
         pass
 
     registry.register(action)
-    handlers = list(registry.get_action_handlers("dialDown"))
+
+    fake_event_data: events.DialDownEvent = DialDownEventFactory.build(action=action.uuid)
+    handlers = list(registry.get_action_handlers(event_name=fake_event_data.event, event_action_uuid=fake_event_data.action))
+    # handlers = list(registry.get_action_handlers("dialDown"))
     assert len(handlers) == 1
     assert handlers[0] == dial_down_handler
 
@@ -67,7 +78,10 @@ def key_up_handler2(event):
     registry.register(action1)
     registry.register(action2)
 
-    handlers = list(registry.get_action_handlers("keyUp"))
+    fake_event_data: events.KeyUpEvent = KeyUpEventFactory.build(action=action1.uuid)
+    # Notice no action uuid is passed in here, so we should get all handlers for the event.
+    handlers = list(registry.get_action_handlers(event_name=fake_event_data.event))
+
     assert len(handlers) == 2
     assert key_up_handler1 in handlers
     assert key_up_handler2 in handlers

tests/test_plugin_manager.py

@@ -32,7 +32,7 @@ def plugin_manager(port_number: int) -> PluginManager:
         plugin_uuid=plugin_uuid,
         plugin_registration_uuid=plugin_registration_uuid,
         register_event=register_event,
-        info=info
+        info=info,
     )
 
 
@@ -51,7 +51,7 @@ def patch_websocket_client(monkeypatch: pytest.MonkeyPatch) -> tuple[MagicMock,
     mock_websocket_client.__enter__.return_value = mock_websocket_client
 
     # Create a fake event message, and convert it to a json string to be passed back by the client.listen_forever() method.
-    fake_event_message = DialRotateEventFactory.build()
+    fake_event_message: DialRotateEvent = DialRotateEventFactory.build()
     mock_websocket_client.listen_forever.return_value = [fake_event_message.model_dump_json()]
 
     monkeypatch.setattr("streamdeck.manager.WebSocketClient", lambda port: mock_websocket_client)
@@ -75,7 +75,9 @@ def mock_command_sender(mocker: pytest_mock.MockerFixture) -> Mock:
 
 
 @pytest.fixture
-def _spy_action_registry_get_action_handlers(mocker: pytest_mock.MockerFixture, plugin_manager: PluginManager) -> None:
+def _spy_action_registry_get_action_handlers(
+    mocker: pytest_mock.MockerFixture, plugin_manager: PluginManager
+) -> None:
     """Fixture that wraps and spies on the get_action_handlers method of the action_registry.
 
     Args:
@@ -113,7 +115,9 @@ def test_plugin_manager_register_action(plugin_manager: PluginManager):
 
 
 @pytest.mark.usefixtures("patch_websocket_client")
-def test_plugin_manager_sends_registration_event(mock_command_sender: Mock, plugin_manager: PluginManager):
+def test_plugin_manager_sends_registration_event(
+    mock_command_sender: Mock, plugin_manager: PluginManager
+):
     """Test that StreamDeckCommandSender.send_action_registration() method is called with correct arguments within the PluginManager.run() method."""
     plugin_manager.run()
 
@@ -125,16 +129,26 @@ def test_plugin_manager_sends_registration_event(mock_command_sender: Mock, plug
 
 @pytest.mark.usefixtures("_spy_action_registry_get_action_handlers")
 @pytest.mark.usefixtures("_spy_event_adapter_validate_json")
-def test_plugin_manager_process_event(patch_websocket_client: tuple[MagicMock, EventBase], plugin_manager: PluginManager):
+def test_plugin_manager_process_event(
+    patch_websocket_client: tuple[MagicMock, EventBase], plugin_manager: PluginManager
+):
     """Test that PluginManager processes events correctly, calling event_adapter.validate_json and action_registry.get_action_handlers."""
     mock_websocket_client, fake_event_message = patch_websocket_client
 
     plugin_manager.run()
 
+    # First check that the WebSocketClient's listen_forever() method was called.
+    # This has been stubbed to return the fake_event_message's json string.
     mock_websocket_client.listen_forever.assert_called_once()
 
+    # Check that the event_adapter.validate_json method was called with the stub json string returned by listen_forever().
     spied_event_adapter_validate_json = cast(Mock, event_adapter.validate_json)
     spied_event_adapter_validate_json.assert_called_once_with(fake_event_message.model_dump_json())
+    # Check that the validate_json method returns the same event type model as the fake_event_message.
     assert spied_event_adapter_validate_json.spy_return == fake_event_message
 
-    cast(Mock, plugin_manager._registry.get_action_handlers).assert_called_once_with(fake_event_message.event)
+    # Check that the action_registry.get_action_handlers method was called with the event name and action uuid.
+    cast(Mock, plugin_manager._registry.get_action_handlers).assert_called_once_with(
+        event_name=fake_event_message.event, event_action_uuid=fake_event_message.action
+    )
+