lifx-emulator 4.0.0__py3-none-any.whl → 4.2.0__py3-none-any.whl

lifx_emulator_app/api/routers/scenarios.py

@@ -9,15 +9,17 @@ from fastapi import APIRouter, HTTPException
 if TYPE_CHECKING:
     from lifx_emulator.server import EmulatedLifxServer
 
-from lifx_emulator_app.api.models import ScenarioConfig, ScenarioResponse
-
+    from lifx_emulator_app.api.services.websocket_manager import WebSocketManager
 
-def _validate_device_serial(serial: str) -> bool:
-    """Validate that serial is a properly formatted 12-character hex string."""
-    return len(serial) == 12 and all(c in "0123456789abcdefABCDEF" for c in serial)
+from lifx_emulator_app.api.models import ScenarioConfig, ScenarioResponse
+from lifx_emulator_app.api.services.scenario_service import (
+    InvalidDeviceSerialError,
+    ScenarioNotFoundError,
+    ScenarioService,
+)
 
 
-def _add_global_endpoints(router: APIRouter, server: EmulatedLifxServer, persist_fn):
+def _add_global_endpoints(router: APIRouter, service: ScenarioService):
     """Add global scenario endpoints to router."""
 
     @router.get(
@@ -29,7 +31,7 @@ def _add_global_endpoints(router: APIRouter, server: EmulatedLifxServer, persist
         ),
     )
     async def get_global_scenario():
-        config = server.scenario_manager.get_global_scenario()
+        config = service.get_global_scenario()
         return ScenarioResponse(scope="global", identifier=None, scenario=config)
 
     @router.put(
@@ -41,8 +43,7 @@ def _add_global_endpoints(router: APIRouter, server: EmulatedLifxServer, persist
         ),
     )
     async def set_global_scenario(scenario: ScenarioConfig):
-        server.scenario_manager.set_global_scenario(scenario)
-        await persist_fn()
+        await service.set_global_scenario(scenario)
         return ScenarioResponse(scope="global", identifier=None, scenario=scenario)
 
     @router.delete(
@@ -52,11 +53,10 @@ def _add_global_endpoints(router: APIRouter, server: EmulatedLifxServer, persist
         description="Clears the global scenario, resetting it to defaults.",
     )
     async def clear_global_scenario():
-        server.scenario_manager.clear_global_scenario()
-        await persist_fn()
+        await service.clear_global_scenario()
 
 
-def _add_device_endpoints(router: APIRouter, server: EmulatedLifxServer, persist_fn):
+def _add_device_endpoints(router: APIRouter, service: ScenarioService):
     """Add device-specific scenario endpoints to router."""
 
     @router.get(
@@ -67,8 +67,9 @@ def _add_device_endpoints(router: APIRouter, server: EmulatedLifxServer, persist
         responses={404: {"description": "Device scenario not set"}},
     )
     async def get_device_scenario(serial: str):
-        config = server.scenario_manager.get_device_scenario(serial)
-        if config is None:
+        try:
+            config = service.get_scope_scenario("device", serial)
+        except ScenarioNotFoundError:
             raise HTTPException(404, f"No scenario set for device {serial}")
         return ScenarioResponse(scope="device", identifier=serial, scenario=config)
 
@@ -80,10 +81,10 @@ def _add_device_endpoints(router: APIRouter, server: EmulatedLifxServer, persist
         responses={404: {"description": "Invalid device serial format"}},
     )
     async def set_device_scenario(serial: str, scenario: ScenarioConfig):
-        if not _validate_device_serial(serial):
+        try:
+            await service.set_scope_scenario("device", serial, scenario)
+        except InvalidDeviceSerialError:
             raise HTTPException(404, f"Invalid device serial format: {serial}.")
-        server.scenario_manager.set_device_scenario(serial, scenario)
-        await persist_fn()
         return ScenarioResponse(scope="device", identifier=serial, scenario=scenario)
 
     @router.delete(
@@ -94,12 +95,13 @@ def _add_device_endpoints(router: APIRouter, server: EmulatedLifxServer, persist
         responses={404: {"description": "Device scenario not found"}},
     )
     async def clear_device_scenario(serial: str):
-        if not server.scenario_manager.delete_device_scenario(serial):
+        try:
+            await service.delete_scope_scenario("device", serial)
+        except ScenarioNotFoundError:
             raise HTTPException(404, f"No scenario set for device {serial}")
-        await persist_fn()
 
 
-def _add_type_endpoints(router: APIRouter, server: EmulatedLifxServer, persist_fn):
+def _add_type_endpoints(router: APIRouter, service: ScenarioService):
     """Add type-specific scenario endpoints to router."""
 
     @router.get(
@@ -110,8 +112,9 @@ def _add_type_endpoints(router: APIRouter, server: EmulatedLifxServer, persist_f
         responses={404: {"description": "Type scenario not set"}},
     )
     async def get_type_scenario(device_type: str):
-        config = server.scenario_manager.get_type_scenario(device_type)
-        if config is None:
+        try:
+            config = service.get_scope_scenario("type", device_type)
+        except ScenarioNotFoundError:
             raise HTTPException(404, f"No scenario set for type {device_type}")
         return ScenarioResponse(scope="type", identifier=device_type, scenario=config)
 
@@ -122,8 +125,7 @@ def _add_type_endpoints(router: APIRouter, server: EmulatedLifxServer, persist_f
         description="Sets the scenario for all devices of a specific type.",
     )
     async def set_type_scenario(device_type: str, scenario: ScenarioConfig):
-        server.scenario_manager.set_type_scenario(device_type, scenario)
-        await persist_fn()
+        await service.set_scope_scenario("type", device_type, scenario)
         return ScenarioResponse(scope="type", identifier=device_type, scenario=scenario)
 
     @router.delete(
@@ -134,12 +136,13 @@ def _add_type_endpoints(router: APIRouter, server: EmulatedLifxServer, persist_f
         responses={404: {"description": "Type scenario not found"}},
     )
     async def clear_type_scenario(device_type: str):
-        if not server.scenario_manager.delete_type_scenario(device_type):
+        try:
+            await service.delete_scope_scenario("type", device_type)
+        except ScenarioNotFoundError:
             raise HTTPException(404, f"No scenario set for type {device_type}")
-        await persist_fn()
 
 
-def _add_location_endpoints(router: APIRouter, server: EmulatedLifxServer, persist_fn):
+def _add_location_endpoints(router: APIRouter, service: ScenarioService):
     """Add location-based scenario endpoints to router."""
 
     @router.get(
@@ -150,8 +153,9 @@ def _add_location_endpoints(router: APIRouter, server: EmulatedLifxServer, persi
         responses={404: {"description": "Location scenario not set"}},
     )
     async def get_location_scenario(location: str):
-        config = server.scenario_manager.get_location_scenario(location)
-        if config is None:
+        try:
+            config = service.get_scope_scenario("location", location)
+        except ScenarioNotFoundError:
             raise HTTPException(404, f"No scenario set for location {location}")
         return ScenarioResponse(scope="location", identifier=location, scenario=config)
 
@@ -162,8 +166,7 @@ def _add_location_endpoints(router: APIRouter, server: EmulatedLifxServer, persi
         description="Sets the scenario for all devices in a location.",
     )
     async def set_location_scenario(location: str, scenario: ScenarioConfig):
-        server.scenario_manager.set_location_scenario(location, scenario)
-        await persist_fn()
+        await service.set_scope_scenario("location", location, scenario)
         return ScenarioResponse(
             scope="location", identifier=location, scenario=scenario
         )
@@ -176,12 +179,13 @@ def _add_location_endpoints(router: APIRouter, server: EmulatedLifxServer, persi
         responses={404: {"description": "Location scenario not found"}},
     )
     async def clear_location_scenario(location: str):
-        if not server.scenario_manager.delete_location_scenario(location):
+        try:
+            await service.delete_scope_scenario("location", location)
+        except ScenarioNotFoundError:
             raise HTTPException(404, f"No scenario set for location {location}")
-        await persist_fn()
 
 
-def _add_group_endpoints(router: APIRouter, server: EmulatedLifxServer, persist_fn):
+def _add_group_endpoints(router: APIRouter, service: ScenarioService):
     """Add group-based scenario endpoints to router."""
 
     @router.get(
@@ -192,8 +196,9 @@ def _add_group_endpoints(router: APIRouter, server: EmulatedLifxServer, persist_
         responses={404: {"description": "Group scenario not set"}},
     )
     async def get_group_scenario(group: str):
-        config = server.scenario_manager.get_group_scenario(group)
-        if config is None:
+        try:
+            config = service.get_scope_scenario("group", group)
+        except ScenarioNotFoundError:
             raise HTTPException(404, f"No scenario set for group {group}")
         return ScenarioResponse(scope="group", identifier=group, scenario=config)
 
@@ -204,8 +209,7 @@ def _add_group_endpoints(router: APIRouter, server: EmulatedLifxServer, persist_
         description="Sets the scenario for all devices in a group.",
     )
     async def set_group_scenario(group: str, scenario: ScenarioConfig):
-        server.scenario_manager.set_group_scenario(group, scenario)
-        await persist_fn()
+        await service.set_scope_scenario("group", group, scenario)
         return ScenarioResponse(scope="group", identifier=group, scenario=scenario)
 
     @router.delete(
@@ -216,32 +220,31 @@ def _add_group_endpoints(router: APIRouter, server: EmulatedLifxServer, persist_
         responses={404: {"description": "Group scenario not found"}},
     )
     async def clear_group_scenario(group: str):
-        if not server.scenario_manager.delete_group_scenario(group):
+        try:
+            await service.delete_scope_scenario("group", group)
+        except ScenarioNotFoundError:
             raise HTTPException(404, f"No scenario set for group {group}")
-        await persist_fn()
 
 
-def create_scenarios_router(server: EmulatedLifxServer) -> APIRouter:
+def create_scenarios_router(
+    server: EmulatedLifxServer, ws_manager: WebSocketManager | None = None
+) -> APIRouter:
     """Create scenarios router with server dependency.
 
     Args:
         server: The LIFX emulator server instance
+        ws_manager: Optional WebSocket manager for real-time updates
 
     Returns:
         Configured APIRouter for scenario endpoints
     """
     router = APIRouter(prefix="/api/scenarios", tags=["scenarios"])
+    service = ScenarioService(server, ws_manager)
 
-    async def persist():
-        """Helper to invalidate device caches and persist scenarios."""
-        server.invalidate_all_scenario_caches()
-        if server.scenario_persistence:
-            await server.scenario_persistence.save(server.scenario_manager)
-
-    _add_global_endpoints(router, server, persist)
-    _add_device_endpoints(router, server, persist)
-    _add_type_endpoints(router, server, persist)
-    _add_location_endpoints(router, server, persist)
-    _add_group_endpoints(router, server, persist)
+    _add_global_endpoints(router, service)
+    _add_device_endpoints(router, service)
+    _add_type_endpoints(router, service)
+    _add_location_endpoints(router, service)
+    _add_group_endpoints(router, service)
 
     return router

lifx_emulator_app/api/routers/websocket.py

@@ -0,0 +1,70 @@
+"""WebSocket endpoint for real-time updates."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from fastapi import APIRouter, WebSocket, WebSocketDisconnect
+
+if TYPE_CHECKING:
+    from lifx_emulator_app.api.services.websocket_manager import WebSocketManager
+
+logger = logging.getLogger(__name__)
+
+
+def create_websocket_router(ws_manager: WebSocketManager) -> APIRouter:
+    """Create WebSocket router with manager dependency.
+
+    Args:
+        ws_manager: The WebSocket manager instance
+
+    Returns:
+        Configured APIRouter for WebSocket endpoint
+    """
+    router = APIRouter(tags=["websocket"])
+
+    @router.websocket("/ws")
+    async def websocket_endpoint(websocket: WebSocket):
+        """WebSocket endpoint for real-time updates.
+
+        Clients connect and send messages to subscribe to topics:
+
+        ```json
+        {"type": "subscribe", "topics": ["stats", "devices", "activity", "scenarios"]}
+        ```
+
+        Available topics:
+        - stats: Server statistics (pushed every second)
+        - devices: Device add/remove/update events
+        - activity: Packet activity events
+        - scenarios: Scenario configuration changes
+
+        To request a full state sync:
+
+        ```json
+        {"type": "sync"}
+        ```
+
+        Server pushes messages in the format:
+
+        ```json
+        {"type": "<message_type>", "data": {...}}
+        ```
+
+        Where message_type is one of: stats, device_added, device_removed,
+        device_updated, activity, scenario_changed.
+        """
+        await ws_manager.connect(websocket)
+        try:
+            while True:
+                data = await websocket.receive_json()
+                await ws_manager.handle_message(websocket, data)
+        except WebSocketDisconnect:
+            logger.debug("WebSocket client disconnected normally")
+        except Exception:
+            logger.exception("WebSocket error")
+        finally:
+            await ws_manager.disconnect(websocket)
+
+    return router

lifx_emulator_app/api/services/__init__.py

@@ -1,8 +1,25 @@
 """Business logic services for API endpoints."""
 
 from lifx_emulator_app.api.services.device_service import DeviceService
+from lifx_emulator_app.api.services.event_bridge import (
+    StatsBroadcaster,
+    WebSocketActivityObserver,
+    wire_device_events,
+)
+from lifx_emulator_app.api.services.scenario_service import ScenarioService
+from lifx_emulator_app.api.services.websocket_manager import (
+    MessageType,
+    Topic,
+    WebSocketManager,
+)
 
-# TODO: Create ScenarioService (Phase 1.1b completion)
-# from lifx_emulator_app.api.services.scenario_service import ScenarioService
-
-__all__ = ["DeviceService"]
+__all__ = [
+    "DeviceService",
+    "MessageType",
+    "ScenarioService",
+    "StatsBroadcaster",
+    "Topic",
+    "WebSocketManager",
+    "WebSocketActivityObserver",
+    "wire_device_events",
+]

lifx_emulator_app/api/services/device_service.py

@@ -11,12 +11,20 @@ import logging
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
+    from lifx_emulator.devices import EmulatedLifxDevice
     from lifx_emulator.server import EmulatedLifxServer
 
 from lifx_emulator.factories import create_device
+from lifx_emulator.protocol.protocol_types import LightHsbk
 
 from lifx_emulator_app.api.mappers import DeviceMapper
-from lifx_emulator_app.api.models import DeviceCreateRequest, DeviceInfo
+from lifx_emulator_app.api.models import (
+    ColorHsbk,
+    DeviceCreateRequest,
+    DeviceInfo,
+    DeviceStateUpdate,
+    TileColorUpdate,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -43,6 +51,12 @@ class DeviceCreationError(Exception):
     pass
 
 
+class DeviceStateUpdateError(Exception):
+    """Raised when a device state update fails due to capability mismatch."""
+
+    pass
+
+
 class DeviceService:
     """Service for managing emulated LIFX devices.
 
@@ -197,3 +211,176 @@ class DeviceService:
         count = self.server.remove_all_devices(delete_storage=delete_storage)
         logger.info("Cleared %d devices (delete_storage=%s)", count, delete_storage)
         return count
+
+    def update_device_state(self, serial: str, update: DeviceStateUpdate) -> DeviceInfo:
+        """Update the state of an existing device.
+
+        Args:
+            serial: The device serial number
+            update: The state update to apply
+
+        Returns:
+            Updated DeviceInfo
+
+        Raises:
+            DeviceNotFoundError: If no device with the given serial exists
+            DeviceStateUpdateError: If update is invalid for the device's capabilities
+        """
+        device = self.server.get_device(serial)
+        if not device:
+            raise DeviceNotFoundError(serial)
+
+        if update.power_level is not None:
+            device.state.power_level = update.power_level
+
+        if update.color is not None:
+            self._apply_color(device, update.color)
+
+        if update.zone_colors is not None:
+            self._apply_zone_colors(device, serial, update.zone_colors)
+
+        if update.tile_colors is not None:
+            self._apply_tile_colors(device, serial, update.tile_colors)
+
+        return DeviceMapper.to_device_info(device)
+
+    @staticmethod
+    def _to_hsbk(c: ColorHsbk) -> LightHsbk:
+        return LightHsbk(
+            hue=c.hue,
+            saturation=c.saturation,
+            brightness=c.brightness,
+            kelvin=c.kelvin,
+        )
+
+    @staticmethod
+    def _fill_hsbk(hsbk: LightHsbk, count: int) -> list[LightHsbk]:
+        return [
+            LightHsbk(
+                hue=hsbk.hue,
+                saturation=hsbk.saturation,
+                brightness=hsbk.brightness,
+                kelvin=hsbk.kelvin,
+            )
+            for _ in range(count)
+        ]
+
+    @staticmethod
+    def _pad_and_truncate(colors: list[LightHsbk], target: int) -> list[LightHsbk]:
+        if len(colors) < target and len(colors) > 0:
+            last = colors[-1]
+            colors.extend(
+                LightHsbk(
+                    hue=last.hue,
+                    saturation=last.saturation,
+                    brightness=last.brightness,
+                    kelvin=last.kelvin,
+                )
+                for _ in range(target - len(colors))
+            )
+        return colors[:target]
+
+    def _apply_color(self, device: EmulatedLifxDevice, color: ColorHsbk) -> None:
+        hsbk = self._to_hsbk(color)
+        device.state.color = hsbk
+
+        if device.state.has_multizone and device.state.multizone is not None:
+            zone_count = device.state.multizone.zone_count
+            device.state.multizone.zone_colors = self._fill_hsbk(hsbk, zone_count)
+
+        if device.state.has_matrix and device.state.matrix is not None:
+            for tile in device.state.matrix.tile_devices:
+                width = tile.get("width", 8)
+                height = tile.get("height", 8)
+                tile["colors"] = self._fill_hsbk(hsbk, width * height)
+
+    def _apply_zone_colors(
+        self,
+        device: EmulatedLifxDevice,
+        serial: str,
+        zone_colors: list[ColorHsbk],
+    ) -> None:
+        if not device.state.has_multizone or device.state.multizone is None:
+            raise DeviceStateUpdateError(f"Device {serial} does not support multizone")
+        zone_count = device.state.multizone.zone_count
+        colors = [self._to_hsbk(c) for c in zone_colors]
+        device.state.multizone.zone_colors = self._pad_and_truncate(colors, zone_count)
+
+    def _apply_tile_colors(
+        self,
+        device: EmulatedLifxDevice,
+        serial: str,
+        tile_colors: list[TileColorUpdate],
+    ) -> None:
+        if not device.state.has_matrix or device.state.matrix is None:
+            raise DeviceStateUpdateError(f"Device {serial} does not support matrix")
+        for tile_update in tile_colors:
+            idx = tile_update.tile_index
+            if idx >= len(device.state.matrix.tile_devices):
+                raise DeviceStateUpdateError(
+                    f"Tile index {idx} out of range "
+                    f"(device has {len(device.state.matrix.tile_devices)} tiles)"
+                )
+            tile = device.state.matrix.tile_devices[idx]
+            width = tile.get("width", 8)
+            height = tile.get("height", 8)
+            colors = [self._to_hsbk(c) for c in tile_update.colors]
+            tile["colors"] = self._pad_and_truncate(colors, width * height)
+
+    def create_devices_bulk(
+        self, requests: list[DeviceCreateRequest]
+    ) -> list[DeviceInfo]:
+        """Create multiple devices at once.
+
+        Args:
+            requests: List of device creation requests
+
+        Returns:
+            List of DeviceInfo objects for the newly created devices
+
+        Raises:
+            DeviceAlreadyExistsError: If any serial conflicts with existing or batch
+            DeviceCreationError: If any device creation fails
+        """
+        # Validate no duplicate serials within the batch
+        serials_in_batch: list[str] = []
+        for req in requests:
+            if req.serial is not None:
+                if req.serial in serials_in_batch:
+                    raise DeviceAlreadyExistsError(req.serial)
+                # Check against existing devices
+                if self.server.get_device(req.serial):
+                    raise DeviceAlreadyExistsError(req.serial)
+                serials_in_batch.append(req.serial)
+
+        created: list[DeviceInfo] = []
+        created_serials: list[str] = []
+        try:
+            for req in requests:
+                info = self.create_device(req)
+                created.append(info)
+                created_serials.append(info.serial)
+        except Exception:
+            # Roll back: remove already-added devices
+            for serial in created_serials:
+                self.server.remove_device(serial)
+            raise
+
+        return created
+
+    def list_devices_paginated(
+        self, offset: int, limit: int
+    ) -> tuple[list[DeviceInfo], int]:
+        """Get a paginated list of devices.
+
+        Args:
+            offset: Number of devices to skip
+            limit: Maximum number of devices to return
+
+        Returns:
+            Tuple of (device info list, total device count)
+        """
+        devices = self.server.get_all_devices()
+        total = len(devices)
+        sliced = devices[offset : offset + limit]
+        return DeviceMapper.to_device_info_list(sliced), total