lifx-emulator-core 3.4.0__tar.gz → 3.5.0__tar.gz

{lifx_emulator_core-3.4.0 → lifx_emulator_core-3.5.0}/.gitignore

@@ -12,7 +12,6 @@ dist/
 downloads/
 eggs/
 .eggs/
-lib/
 lib64/
 parts/
 sdist/

{lifx_emulator_core-3.4.0 → lifx_emulator_core-3.5.0}/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 <!-- version list -->
 
+## v3.5.0 (2026-02-03)
+
+### Bug Fixes
+
+- Address CodeRabbit PR review feedback
+  ([`e302407`](https://github.com/Djelibeybi/lifx-emulator/commit/e302407e19f73de9a49361372b5c776b761d61e1))
+
+### Features
+
+- **api**: Complete WebSocket real-time event infrastructure
+  ([`81cfa6f`](https://github.com/Djelibeybi/lifx-emulator/commit/81cfa6f11dfb7d216b40d6672ba73883841be11a))
+
+- **dashboard**: Add scenario panel, pagination, and tabbed interface (Phase 4)
+  ([`a50951d`](https://github.com/Djelibeybi/lifx-emulator/commit/a50951d805592787ea70a86441e44c781e307c1c))
+
+
 ## v3.4.0 (2026-02-03)
 
 ### Features

{lifx_emulator_core-3.4.0 → lifx_emulator_core-3.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lifx-emulator-core
-Version: 3.4.0
+Version: 3.5.0
 Summary: Core LIFX Emulator library for testing LIFX LAN protocol libraries
 Author-email: Avi Miller <me@dje.li>
 Maintainer-email: Avi Miller <me@dje.li>

{lifx_emulator_core-3.4.0 → lifx_emulator_core-3.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lifx-emulator-core"
-version = "3.4.0"
+version = "3.5.0"
 description = "Core LIFX Emulator library for testing LIFX LAN protocol libraries"
 readme = "README.md"
 requires-python = ">=3.10"

{lifx_emulator_core-3.4.0 → lifx_emulator_core-3.5.0}/src/lifx_emulator/devices/__init__.py

@@ -10,7 +10,12 @@ This module contains all device-related functionality including:
 """
 
 from lifx_emulator.devices.device import EmulatedLifxDevice
-from lifx_emulator.devices.manager import DeviceManager, IDeviceManager
+from lifx_emulator.devices.manager import (
+    DeviceAddedCallback,
+    DeviceManager,
+    DeviceRemovedCallback,
+    IDeviceManager,
+)
 from lifx_emulator.devices.observers import (
     ActivityLogger,
     ActivityObserver,
@@ -26,6 +31,8 @@ from lifx_emulator.devices.states import DeviceState
 __all__ = [
     "EmulatedLifxDevice",
     "DeviceManager",
+    "DeviceAddedCallback",
+    "DeviceRemovedCallback",
     "IDeviceManager",
     "DeviceState",
     "DevicePersistenceAsyncFile",

{lifx_emulator_core-3.4.0 → lifx_emulator_core-3.5.0}/src/lifx_emulator/devices/manager.py

@@ -8,6 +8,7 @@ concerns principle by extracting domain logic from the network layer.
 from __future__ import annotations
 
 import logging
+from collections.abc import Callable
 from typing import TYPE_CHECKING, Protocol, runtime_checkable
 
 if TYPE_CHECKING:
@@ -18,6 +19,10 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
+# Type aliases for device lifecycle callbacks
+DeviceAddedCallback = Callable[["EmulatedLifxDevice"], None]
+DeviceRemovedCallback = Callable[[str], None]
+
 
 @runtime_checkable
 class IDeviceManager(Protocol):
@@ -116,15 +121,27 @@ class DeviceManager:
     This class extracts device management logic from EmulatedLifxServer,
     providing a clean separation between domain logic and network I/O.
     It mirrors the architecture of HierarchicalScenarioManager.
+
+    Supports optional callbacks for device lifecycle events, allowing
+    external systems (like WebSocket managers) to be notified of changes.
     """
 
-    def __init__(self, device_repository: IDeviceRepository):
+    def __init__(
+        self,
+        device_repository: IDeviceRepository,
+        on_device_added: DeviceAddedCallback | None = None,
+        on_device_removed: DeviceRemovedCallback | None = None,
+    ):
         """Initialize the device manager.
 
         Args:
             device_repository: Repository for device storage and retrieval
+            on_device_added: Optional callback invoked when a device is added
+            on_device_removed: Optional callback invoked when a device is removed
         """
         self._device_repository = device_repository
+        self.on_device_added = on_device_added
+        self.on_device_removed = on_device_removed
 
     def add_device(
         self,
@@ -152,6 +169,11 @@ class DeviceManager:
         if success:
             serial = device.state.serial
             logger.info("Added device: %s (product=%s)", serial, device.state.product)
+            if self.on_device_added is not None:
+                try:
+                    self.on_device_added(device)
+                except Exception:
+                    logger.exception("Error in on_device_added callback for %s", serial)
         return success
 
     def remove_device(self, serial: str, storage=None) -> bool:
@@ -172,6 +194,14 @@ class DeviceManager:
             if storage:
                 storage.delete_device_state(serial)
 
+            if self.on_device_removed is not None:
+                try:
+                    self.on_device_removed(serial)
+                except Exception:
+                    logger.exception(
+                        "Error in on_device_removed callback for %s", serial
+                    )
+
         return success
 
     def remove_all_devices(self, delete_storage: bool = False, storage=None) -> int:
@@ -184,6 +214,9 @@ class DeviceManager:
         Returns:
             Number of devices removed
         """
+        # Get all device serials before clearing (for callbacks)
+        serials = [d.state.serial for d in self._device_repository.get_all()]
+
         # Clear all devices from repository
         device_count = self._device_repository.clear()
         logger.info("Removed all %s device(s)", device_count)
@@ -193,6 +226,16 @@ class DeviceManager:
             deleted = storage.delete_all_device_states()
             logger.info("Deleted %s device state(s) from persistent storage", deleted)
 
+        # Notify callbacks for each removed device
+        if self.on_device_removed is not None:
+            for serial in serials:
+                try:
+                    self.on_device_removed(serial)
+                except Exception:
+                    logger.exception(
+                        "Error in on_device_removed callback for %s", serial
+                    )
+
         return device_count
 
     def get_device(self, serial: str) -> EmulatedLifxDevice | None:

{lifx_emulator_core-3.4.0 → lifx_emulator_core-3.5.0}/src/lifx_emulator/scenarios/manager.py

@@ -60,8 +60,9 @@ class HierarchicalScenarioManager:
         self.type_scenarios: dict[str, ScenarioConfig] = {}  # type → config
         self.location_scenarios: dict[str, ScenarioConfig] = {}  # location → config
         self.group_scenarios: dict[str, ScenarioConfig] = {}  # group → config
+        # Default global scenario: send_unhandled=True matches real LIFX behavior
         self.global_scenario: ScenarioConfig = ScenarioConfig(
-            firmware_version=None, send_unhandled=False
+            firmware_version=None, send_unhandled=True
         )
 
     def set_device_scenario(self, serial: str, config: ScenarioConfig):
@@ -101,9 +102,9 @@ class HierarchicalScenarioManager:
         return self.group_scenarios.pop(group, None) is not None
 
     def clear_global_scenario(self):
-        """Clear global scenario (reset to empty)."""
+        """Clear global scenario (reset to default with send_unhandled=True)."""
         self.global_scenario = ScenarioConfig(
-            firmware_version=None, send_unhandled=False
+            firmware_version=None, send_unhandled=True
         )
 
     def get_global_scenario(self) -> ScenarioConfig:
@@ -184,8 +185,8 @@ class HierarchicalScenarioManager:
         Returns:
             Merged ScenarioConfig
         """
-        # Start with empty config
-        merged = ScenarioConfig(firmware_version=None, send_unhandled=False)
+        # Start with default config (send_unhandled=True matches real LIFX behavior)
+        merged = ScenarioConfig(firmware_version=None, send_unhandled=True)
 
         # Layer in each scope (general to specific)
         # Later scopes override or merge with earlier ones
@@ -219,8 +220,8 @@ class HierarchicalScenarioManager:
             # Scalars: use most specific non-default value
             if config.firmware_version is not None:
                 merged.firmware_version = config.firmware_version
-            if config.send_unhandled:
-                merged.send_unhandled = True
+            # send_unhandled: most specific scope wins (explicit False overrides)
+            merged.send_unhandled = config.send_unhandled
 
         return merged
 

{lifx_emulator_core-3.4.0 → lifx_emulator_core-3.5.0}/src/lifx_emulator/scenarios/models.py

@@ -51,7 +51,7 @@ class ScenarioConfig(BaseModel):
         description="List of packet types to send with incomplete data",
     )
     send_unhandled: bool = Field(
-        False, description="Send unhandled message responses for unknown packet types"
+        True, description="Send unhandled message responses for unknown packet types"
     )
 
     @property

{lifx_emulator_core-3.4.0 → lifx_emulator_core-3.5.0}/src/lifx_emulator/server.py

@@ -482,7 +482,7 @@ class EmulatedLifxServer:
             "packets_received_by_type": dict(self.packets_received_by_type),
             "packets_sent_by_type": dict(self.packets_sent_by_type),
             "error_count": self.error_count,
-            "activity_enabled": isinstance(self.activity_observer, ActivityLogger),
+            "activity_enabled": hasattr(self.activity_observer, "get_recent_activity"),
         }
 
     def get_recent_activity(self) -> list[dict[str, Any]]:
@@ -492,8 +492,9 @@ class EmulatedLifxServer:
             List of activity event dictionaries, or empty list if observer
             doesn't support activity tracking
         """
-        if isinstance(self.activity_observer, ActivityLogger):
-            return self.activity_observer.get_recent_activity()
+        get_activity = getattr(self.activity_observer, "get_recent_activity", None)
+        if get_activity is not None:
+            return get_activity()
         return []
 
     async def start(self):

{lifx_emulator_core-3.4.0 → lifx_emulator_core-3.5.0}/tests/test_device_manager.py

@@ -285,3 +285,126 @@ class TestDeviceManager:
 
         # Verify storage deletion was NOT called
         mock_storage.delete_all_device_states.assert_not_called()
+
+
+class TestDeviceManagerCallbacks:
+    """Test DeviceManager callback functionality."""
+
+    def test_on_device_added_callback_invoked(self):
+        """on_device_added callback is invoked when device is added."""
+        from unittest.mock import Mock
+
+        callback = Mock()
+        manager = DeviceManager(DeviceRepository(), on_device_added=callback)
+        device = create_color_light("d073d5000001")
+
+        manager.add_device(device)
+
+        callback.assert_called_once_with(device)
+
+    def test_on_device_added_not_called_on_duplicate(self):
+        """on_device_added callback is not called when adding duplicate device."""
+        from unittest.mock import Mock
+
+        callback = Mock()
+        manager = DeviceManager(DeviceRepository(), on_device_added=callback)
+        device = create_color_light("d073d5000001")
+
+        manager.add_device(device)
+        callback.reset_mock()
+
+        # Adding duplicate should not trigger callback
+        manager.add_device(device)
+        callback.assert_not_called()
+
+    def test_on_device_added_callback_exception_logged(self):
+        """Exception in on_device_added callback is logged but doesn't prevent add."""
+        from unittest.mock import Mock
+
+        callback = Mock(side_effect=Exception("callback error"))
+        manager = DeviceManager(DeviceRepository(), on_device_added=callback)
+        device = create_color_light("d073d5000001")
+
+        # Should still succeed despite callback exception
+        result = manager.add_device(device)
+        assert result is True
+        assert manager.count_devices() == 1
+
+    def test_on_device_removed_callback_invoked(self):
+        """on_device_removed callback is invoked when device is removed."""
+        from unittest.mock import Mock
+
+        callback = Mock()
+        manager = DeviceManager(DeviceRepository(), on_device_removed=callback)
+        device = create_color_light("d073d5000001")
+        manager.add_device(device)
+
+        manager.remove_device("d073d5000001")
+
+        callback.assert_called_once_with("d073d5000001")
+
+    def test_on_device_removed_not_called_on_nonexistent(self):
+        """on_device_removed callback is not called when removing nonexistent device."""
+        from unittest.mock import Mock
+
+        callback = Mock()
+        manager = DeviceManager(DeviceRepository(), on_device_removed=callback)
+
+        # Removing nonexistent device should not trigger callback
+        manager.remove_device("d073d5000001")
+        callback.assert_not_called()
+
+    def test_on_device_removed_callback_exception_logged(self):
+        """Exception in callback is logged but doesn't prevent remove."""
+        from unittest.mock import Mock
+
+        callback = Mock(side_effect=Exception("callback error"))
+        manager = DeviceManager(DeviceRepository(), on_device_removed=callback)
+        device = create_color_light("d073d5000001")
+        manager.add_device(device)
+
+        # Should still succeed despite callback exception
+        result = manager.remove_device("d073d5000001")
+        assert result is True
+        assert manager.count_devices() == 0
+
+    def test_remove_all_devices_invokes_callback_for_each(self):
+        """on_device_removed callback is invoked for each device when removing all."""
+        from unittest.mock import Mock
+
+        callback = Mock()
+        manager = DeviceManager(DeviceRepository(), on_device_removed=callback)
+
+        # Add multiple devices
+        manager.add_device(create_color_light("d073d5000001"))
+        manager.add_device(create_color_light("d073d5000002"))
+        manager.add_device(create_color_light("d073d5000003"))
+
+        manager.remove_all_devices()
+
+        assert callback.call_count == 3
+        # Verify all serials were passed to callback
+        called_serials = {call.args[0] for call in callback.call_args_list}
+        assert called_serials == {"d073d5000001", "d073d5000002", "d073d5000003"}
+
+    def test_both_callbacks_can_be_set(self):
+        """Both on_device_added and on_device_removed callbacks can be set."""
+        from unittest.mock import Mock
+
+        add_callback = Mock()
+        remove_callback = Mock()
+        manager = DeviceManager(
+            DeviceRepository(),
+            on_device_added=add_callback,
+            on_device_removed=remove_callback,
+        )
+        device = create_color_light("d073d5000001")
+
+        manager.add_device(device)
+        add_callback.assert_called_once_with(device)
+        remove_callback.assert_not_called()
+
+        add_callback.reset_mock()
+        manager.remove_device("d073d5000001")
+        add_callback.assert_not_called()
+        remove_callback.assert_called_once_with("d073d5000001")

{lifx_emulator_core-3.4.0 → lifx_emulator_core-3.5.0}/tests/test_scenario_manager.py

@@ -26,7 +26,7 @@ class TestScenarioConfig:
         assert config.invalid_field_values == []
         assert config.firmware_version is None
         assert config.partial_responses == []
-        assert config.send_unhandled is False
+        assert config.send_unhandled is True  # Default is on
 
     def test_scenario_config_to_dict(self):
         """Test conversion to dictionary."""

{lifx_emulator_core-3.4.0 → lifx_emulator_core-3.5.0}/tests/test_scenario_persistence.py

@@ -37,7 +37,7 @@ class TestScenarioPersistenceAsyncFile:
                 "invalid_field_values": [],
                 "firmware_version": None,
                 "partial_responses": [],
-                "send_unhandled": False,
+                "send_unhandled": True,  # Default is on
             }
             assert data["devices"] == {}
             assert data["types"] == {}

{lifx_emulator_core-3.4.0 → lifx_emulator_core-3.5.0}/tests/test_server.py

@@ -693,3 +693,101 @@ class TestServerAckBehavior:
         sent_data = server.transport.sendto.call_args_list[0][0][0]
         resp_header = LifxHeader.unpack(sent_data)
         assert resp_header.pkt_type == 25  # StateLabel
+
+
+class TestServerStatsAndActivity:
+    """Tests for server stats and activity tracking."""
+
+    def test_get_stats_with_activity_enabled(self):
+        """Test get_stats() includes activity_enabled when observer supports it."""
+        from lifx_emulator.devices import ActivityLogger
+
+        device_manager = DeviceManager(DeviceRepository())
+        activity_logger = ActivityLogger(max_events=100)
+        server = EmulatedLifxServer(
+            [], device_manager, "127.0.0.1", 56700, activity_observer=activity_logger
+        )
+
+        stats = server.get_stats()
+        assert stats["activity_enabled"] is True
+        assert "uptime_seconds" in stats
+        assert "packets_received" in stats
+
+    def test_get_stats_with_activity_disabled(self):
+        """Test get_stats() shows activity disabled with NullObserver."""
+        device_manager = DeviceManager(DeviceRepository())
+        server = EmulatedLifxServer(
+            [], device_manager, "127.0.0.1", 56700, track_activity=False
+        )
+
+        stats = server.get_stats()
+        assert stats["activity_enabled"] is False
+
+    def test_get_recent_activity_with_logger(self):
+        """Test get_recent_activity() returns events when observer supports it."""
+        from lifx_emulator.devices import ActivityLogger, PacketEvent
+
+        device_manager = DeviceManager(DeviceRepository())
+        activity_logger = ActivityLogger(max_events=100)
+        server = EmulatedLifxServer(
+            [], device_manager, "127.0.0.1", 56700, activity_observer=activity_logger
+        )
+
+        # Add an event
+        event = PacketEvent(
+            timestamp="12:34:56",
+            direction="rx",
+            packet_type=2,
+            packet_name="GetService",
+            target=None,
+            device=None,
+            addr=("192.168.1.100", 56700),
+        )
+        activity_logger.on_packet_received(event)
+
+        activity = server.get_recent_activity()
+        assert len(activity) == 1
+        assert activity[0]["packet_name"] == "GetService"
+
+    def test_get_recent_activity_without_support(self):
+        """Test get_recent_activity() returns empty list with no support."""
+        device_manager = DeviceManager(DeviceRepository())
+        server = EmulatedLifxServer(
+            [], device_manager, "127.0.0.1", 56700, track_activity=False
+        )
+
+        activity = server.get_recent_activity()
+        assert activity == []
+
+    def test_get_recent_activity_with_custom_observer(self):
+        """Test get_recent_activity() with WebSocketActivityObserver."""
+        from lifx_emulator.devices import ActivityLogger
+
+        # This simulates the WebSocketActivityObserver pattern
+        device_manager = DeviceManager(DeviceRepository())
+        inner_logger = ActivityLogger(max_events=50)
+
+        # Create a mock observer that wraps the inner logger
+        class CustomObserver:
+            def __init__(self, inner):
+                self._inner = inner
+
+            def get_recent_activity(self):
+                return self._inner.get_recent_activity()
+
+            def on_packet_received(self, event):
+                self._inner.on_packet_received(event)
+
+            def on_packet_sent(self, event):
+                self._inner.on_packet_sent(event)
+
+        custom_observer = CustomObserver(inner_logger)
+        server = EmulatedLifxServer(
+            [], device_manager, "127.0.0.1", 56700, activity_observer=custom_observer
+        )
+
+        stats = server.get_stats()
+        assert stats["activity_enabled"] is True
+
+        activity = server.get_recent_activity()
+        assert activity == []