lifx-emulator 1.0.0__py3-none-any.whl

lifx_emulator/handlers/device_handlers.py

@@ -0,0 +1,340 @@
+"""Device packet handlers."""
+
+from __future__ import annotations
+
+import logging
+import time
+from typing import TYPE_CHECKING, Any
+
+from lifx_emulator.handlers.base import PacketHandler
+from lifx_emulator.protocol.packets import Device
+from lifx_emulator.protocol.protocol_types import DeviceService as ProtocolDeviceService
+
+if TYPE_CHECKING:
+    from lifx_emulator.device import DeviceState
+
+logger = logging.getLogger(__name__)
+
+
+class GetServiceHandler(PacketHandler):
+    """Handle DeviceGetService (2) -> DeviceStateService (3)."""
+
+    PKT_TYPE = Device.GetService.PKT_TYPE
+
+    def handle(
+        self, device_state: DeviceState, packet: Any | None, res_required: bool
+    ) -> list[Any]:
+        logger.debug(
+            "Sending StateService: %s [%s]",
+            ProtocolDeviceService.UDP,
+            device_state.port,
+        )
+        return [
+            Device.StateService(
+                service=ProtocolDeviceService.UDP, port=device_state.port
+            )
+        ]
+
+
+class GetPowerHandler(PacketHandler):
+    """Handle DeviceGetPower (20) -> DeviceStatePower (22)."""
+
+    PKT_TYPE = Device.GetPower.PKT_TYPE
+
+    def handle(
+        self, device_state: DeviceState, packet: Any | None, res_required: bool
+    ) -> list[Any]:
+        return [Device.StatePower(level=device_state.power_level)]
+
+
+class SetPowerHandler(PacketHandler):
+    """Handle DeviceSetPower (21) -> DeviceStatePower (22)."""
+
+    PKT_TYPE = Device.SetPower.PKT_TYPE
+
+    def handle(
+        self,
+        device_state: DeviceState,
+        packet: Device.SetPower | None,
+        res_required: bool,
+    ) -> list[Any]:
+        if packet:
+            device_state.power_level = packet.level
+            logger.info("Power set to %s", device_state.power_level)
+
+        if res_required:
+            return [Device.StatePower(level=device_state.power_level)]
+        return []
+
+
+class GetLabelHandler(PacketHandler):
+    """Handle DeviceGetLabel (23) -> DeviceStateLabel (25)."""
+
+    PKT_TYPE = Device.GetLabel.PKT_TYPE
+
+    def handle(
+        self, device_state: DeviceState, packet: Any | None, res_required: bool
+    ) -> list[Any]:
+        label_bytes = device_state.label.encode("utf-8")[:32].ljust(32, b"\x00")
+        return [Device.StateLabel(label=label_bytes)]
+
+
+class SetLabelHandler(PacketHandler):
+    """Handle DeviceSetLabel (24) -> DeviceStateLabel (25)."""
+
+    PKT_TYPE = Device.SetLabel.PKT_TYPE
+
+    def handle(
+        self,
+        device_state: DeviceState,
+        packet: Device.SetLabel | None,
+        res_required: bool,
+    ) -> list[Any]:
+        if packet:
+            device_state.label = packet.label.rstrip(b"\x00").decode(
+                "utf-8", errors="replace"
+            )
+            logger.info("Label set to '%s'", device_state.label)
+
+        if res_required:
+            label_bytes = device_state.label.encode("utf-8")[:32].ljust(32, b"\x00")
+            return [Device.StateLabel(label=label_bytes)]
+        return []
+
+
+class GetVersionHandler(PacketHandler):
+    """Handle DeviceGetVersion (32) -> DeviceStateVersion (33)."""
+
+    PKT_TYPE = Device.GetVersion.PKT_TYPE
+
+    def handle(
+        self, device_state: DeviceState, packet: Any | None, res_required: bool
+    ) -> list[Any]:
+        return [
+            Device.StateVersion(
+                vendor=device_state.vendor, product=device_state.product
+            )
+        ]
+
+
+class GetInfoHandler(PacketHandler):
+    """Handle DeviceGetInfo (34) -> DeviceStateInfo (35)."""
+
+    PKT_TYPE = Device.GetInfo.PKT_TYPE
+
+    def handle(
+        self, device_state: DeviceState, packet: Any | None, res_required: bool
+    ) -> list[Any]:
+        current_time = int(time.time() * 1e9)  # nanoseconds
+        return [
+            Device.StateInfo(
+                time=current_time, uptime=device_state.uptime_ns, downtime=0
+            )
+        ]
+
+
+class GetHostFirmwareHandler(PacketHandler):
+    """Handle DeviceGetHostFirmware (14) -> DeviceStateHostFirmware (15)."""
+
+    PKT_TYPE = Device.GetHostFirmware.PKT_TYPE
+
+    def handle(
+        self, device_state: DeviceState, packet: Any | None, res_required: bool
+    ) -> list[Any]:
+        return [
+            Device.StateHostFirmware(
+                build=device_state.build_timestamp,
+                version_minor=device_state.version_minor,
+                version_major=device_state.version_major,
+            )
+        ]
+
+
+class GetWifiInfoHandler(PacketHandler):
+    """Handle DeviceGetWifiInfo (16) -> DeviceStateWifiInfo (17)."""
+
+    PKT_TYPE = Device.GetWifiInfo.PKT_TYPE
+
+    def handle(
+        self, device_state: DeviceState, packet: Any | None, res_required: bool
+    ) -> list[Any]:
+        return [Device.StateWifiInfo(signal=device_state.wifi_signal)]
+
+
+class GetLocationHandler(PacketHandler):
+    """Handle DeviceGetLocation (48) -> DeviceStateLocation (50)."""
+
+    PKT_TYPE = Device.GetLocation.PKT_TYPE
+
+    def handle(
+        self, device_state: DeviceState, packet: Any | None, res_required: bool
+    ) -> list[Any]:
+        label_bytes = device_state.location_label.encode("utf-8")[:32].ljust(
+            32, b"\x00"
+        )
+        return [
+            Device.StateLocation(
+                location=device_state.location_id,
+                label=label_bytes,
+                updated_at=device_state.location_updated_at,
+            )
+        ]
+
+
+class SetLocationHandler(PacketHandler):
+    """Handle DeviceSetLocation (49) -> DeviceStateLocation (50)."""
+
+    PKT_TYPE = Device.SetLocation.PKT_TYPE
+
+    def handle(
+        self,
+        device_state: DeviceState,
+        packet: Device.SetLocation | None,
+        res_required: bool,
+    ) -> list[Any]:
+        if packet:
+            device_state.location_id = packet.location
+            device_state.location_label = packet.label.rstrip(b"\x00").decode(
+                "utf-8", errors="replace"
+            )
+            device_state.location_updated_at = packet.updated_at
+            loc_id = packet.location.hex()[:8]
+            logger.info(
+                "Location set to '%s' (id=%s...)", device_state.location_label, loc_id
+            )
+
+        if res_required:
+            label_bytes = device_state.location_label.encode("utf-8")[:32].ljust(
+                32, b"\x00"
+            )
+            return [
+                Device.StateLocation(
+                    location=device_state.location_id,
+                    label=label_bytes,
+                    updated_at=device_state.location_updated_at,
+                )
+            ]
+        return []
+
+
+class GetGroupHandler(PacketHandler):
+    """Handle DeviceGetGroup (51) -> DeviceStateGroup (53)."""
+
+    PKT_TYPE = Device.GetGroup.PKT_TYPE
+
+    def handle(
+        self, device_state: DeviceState, packet: Any | None, res_required: bool
+    ) -> list[Any]:
+        label_bytes = device_state.group_label.encode("utf-8")[:32].ljust(32, b"\x00")
+        return [
+            Device.StateGroup(
+                group=device_state.group_id,
+                label=label_bytes,
+                updated_at=device_state.group_updated_at,
+            )
+        ]
+
+
+class SetGroupHandler(PacketHandler):
+    """Handle DeviceSetGroup (52) -> DeviceStateGroup (53)."""
+
+    PKT_TYPE = Device.SetGroup.PKT_TYPE
+
+    def handle(
+        self,
+        device_state: DeviceState,
+        packet: Device.SetGroup | None,
+        res_required: bool,
+    ) -> list[Any]:
+        if packet:
+            device_state.group_id = packet.group
+            device_state.group_label = packet.label.rstrip(b"\x00").decode(
+                "utf-8", errors="replace"
+            )
+            device_state.group_updated_at = packet.updated_at
+            grp_id = packet.group.hex()[:8]
+            logger.info(
+                "Group set to '%s' (id=%s...)", device_state.group_label, grp_id
+            )
+
+        if res_required:
+            label_bytes = device_state.group_label.encode("utf-8")[:32].ljust(
+                32, b"\x00"
+            )
+            return [
+                Device.StateGroup(
+                    group=device_state.group_id,
+                    label=label_bytes,
+                    updated_at=device_state.group_updated_at,
+                )
+            ]
+        return []
+
+
+class EchoRequestHandler(PacketHandler):
+    """Handle DeviceEchoRequest (58) -> DeviceEchoResponse (59)."""
+
+    PKT_TYPE = Device.EchoRequest.PKT_TYPE
+
+    def handle(
+        self,
+        device_state: DeviceState,
+        packet: Device.EchoRequest | None,
+        res_required: bool,
+    ) -> list[Any]:
+        payload = packet.payload if packet else b"\x00" * 64
+        return [Device.EchoResponse(payload=payload[:64].ljust(64, b"\x00"))]
+
+
+class GetWifiFirmwareHandler(PacketHandler):
+    """Handle DeviceGetWifiFirmware (18) -> DeviceStateWifiFirmware (19)."""
+
+    PKT_TYPE = Device.GetWifiFirmware.PKT_TYPE
+
+    def handle(
+        self, device_state: DeviceState, packet: Any | None, res_required: bool
+    ) -> list[Any]:
+        build = int(time.time()) - 1000000000  # Example build timestamp
+        return [
+            Device.StateWifiFirmware(
+                build=build,
+                version_minor=device_state.version_minor,
+                version_major=device_state.version_major,
+            )
+        ]
+
+
+class SetRebootHandler(PacketHandler):
+    """Handle DeviceSetReboot (38) - just acknowledge, don't actually reboot."""
+
+    PKT_TYPE = Device.SetReboot.PKT_TYPE
+
+    def handle(
+        self, device_state: DeviceState, packet: Any | None, res_required: bool
+    ) -> list[Any]:
+        serial = device_state.serial
+        logger.info("Device %s: Received reboot request (ignored in emulator)", serial)
+        # In a real device, this would trigger a reboot
+        # In emulator, we just acknowledge it
+        return []
+
+
+# List of all device handlers for easy registration
+ALL_DEVICE_HANDLERS = [
+    GetServiceHandler(),
+    GetPowerHandler(),
+    SetPowerHandler(),
+    GetLabelHandler(),
+    SetLabelHandler(),
+    GetVersionHandler(),
+    GetInfoHandler(),
+    GetHostFirmwareHandler(),
+    GetWifiInfoHandler(),
+    GetLocationHandler(),
+    SetLocationHandler(),
+    GetGroupHandler(),
+    SetGroupHandler(),
+    EchoRequestHandler(),
+    GetWifiFirmwareHandler(),
+    SetRebootHandler(),
+]

lifx_emulator/handlers/light_handlers.py

@@ -0,0 +1,372 @@
+"""Light packet handlers."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+from lifx_emulator.handlers.base import PacketHandler
+from lifx_emulator.protocol.packets import Light
+from lifx_emulator.protocol.protocol_types import LightLastHevCycleResult
+
+if TYPE_CHECKING:
+    from lifx_emulator.device import DeviceState
+
+logger = logging.getLogger(__name__)
+
+
+class GetColorHandler(PacketHandler):
+    """Handle LightGet (101) -> LightState (107)."""
+
+    PKT_TYPE = Light.GetColor.PKT_TYPE
+
+    def handle(
+        self, device_state: DeviceState, packet: Any | None, res_required: bool
+    ) -> list[Any]:
+        label_bytes = device_state.label.encode("utf-8")[:32].ljust(32, b"\x00")
+        return [
+            Light.StateColor(
+                color=device_state.color,
+                power=device_state.power_level,
+                label=label_bytes,
+            )
+        ]
+
+
+class SetColorHandler(PacketHandler):
+    """Handle LightSetColor (102) -> LightState (107)."""
+
+    PKT_TYPE = Light.SetColor.PKT_TYPE
+
+    def handle(
+        self,
+        device_state: DeviceState,
+        packet: Light.SetColor | None,
+        res_required: bool,
+    ) -> list[Any]:
+        if packet:
+            device_state.color = packet.color
+            c = packet.color
+            logger.info(
+                f"Color set to HSBK({c.hue}, {c.saturation}, "
+                f"{c.brightness}, {c.kelvin}), duration={packet.duration}ms"
+            )
+
+        if res_required:
+            label_bytes = device_state.label.encode("utf-8")[:32].ljust(32, b"\x00")
+            return [
+                Light.StateColor(
+                    color=device_state.color,
+                    power=device_state.power_level,
+                    label=label_bytes,
+                )
+            ]
+        return []
+
+
+class GetPowerHandler(PacketHandler):
+    """Handle LightGetPower (116) -> LightStatePower (118)."""
+
+    PKT_TYPE = Light.GetPower.PKT_TYPE
+
+    def handle(
+        self, device_state: DeviceState, packet: Any | None, res_required: bool
+    ) -> list[Any]:
+        return [Light.StatePower(level=device_state.power_level)]
+
+
+class SetPowerHandler(PacketHandler):
+    """Handle LightSetPower (117) -> LightStatePower (118)."""
+
+    PKT_TYPE = Light.SetPower.PKT_TYPE
+
+    def handle(
+        self,
+        device_state: DeviceState,
+        packet: Light.SetPower | None,
+        res_required: bool,
+    ) -> list[Any]:
+        if packet:
+            device_state.power_level = packet.level
+            logger.info(
+                f"Light power set to {packet.level}, duration={packet.duration}ms"
+            )
+
+        if res_required:
+            return [Light.StatePower(level=device_state.power_level)]
+        return []
+
+
+class SetWaveformHandler(PacketHandler):
+    """Handle LightSetWaveform (103) -> LightState (107)."""
+
+    PKT_TYPE = Light.SetWaveform.PKT_TYPE
+
+    def handle(
+        self,
+        device_state: DeviceState,
+        packet: Light.SetWaveform | None,
+        res_required: bool,
+    ) -> list[Any]:
+        if packet:
+            # Store waveform state
+            device_state.waveform_active = True
+            device_state.waveform_transient = packet.transient
+            device_state.waveform_color = packet.color
+            device_state.waveform_period_ms = packet.period
+            device_state.waveform_cycles = packet.cycles
+            device_state.waveform_skew_ratio = packet.skew_ratio
+            device_state.waveform_type = int(packet.waveform)
+
+            # If not transient, update the color state
+            if not packet.transient:
+                device_state.color = packet.color
+
+            logger.info(
+                f"Waveform set: type={packet.waveform}, "
+                f"transient={packet.transient}, period={packet.period}ms, "
+                f"cycles={packet.cycles}, skew={packet.skew_ratio}"
+            )
+
+        if res_required:
+            label_bytes = device_state.label.encode("utf-8")[:32].ljust(32, b"\x00")
+            return [
+                Light.StateColor(
+                    color=device_state.color,
+                    power=device_state.power_level,
+                    label=label_bytes,
+                )
+            ]
+        return []
+
+
+class SetWaveformOptionalHandler(PacketHandler):
+    """Handle LightSetWaveformOptional (119) -> LightState (107)."""
+
+    PKT_TYPE = Light.SetWaveformOptional.PKT_TYPE
+
+    def handle(
+        self,
+        device_state: DeviceState,
+        packet: Light.SetWaveformOptional | None,
+        res_required: bool,
+    ) -> list[Any]:
+        if packet:
+            # Store waveform state
+            device_state.waveform_active = True
+            device_state.waveform_transient = packet.transient
+            device_state.waveform_period_ms = packet.period
+            device_state.waveform_cycles = packet.cycles
+            device_state.waveform_skew_ratio = packet.skew_ratio
+            device_state.waveform_type = int(packet.waveform)
+
+            # Apply color components selectively based on flags
+            if not packet.transient:
+                if packet.set_hue:
+                    device_state.color.hue = packet.color.hue
+                if packet.set_saturation:
+                    device_state.color.saturation = packet.color.saturation
+                if packet.set_brightness:
+                    device_state.color.brightness = packet.color.brightness
+                if packet.set_kelvin:
+                    device_state.color.kelvin = packet.color.kelvin
+
+            # Store the waveform color (all components)
+            device_state.waveform_color = packet.color
+
+            logger.info(
+                f"Waveform optional set: type={packet.waveform}, "
+                f"transient={packet.transient}, period={packet.period}ms, "
+                f"cycles={packet.cycles}, components=[H:{packet.set_hue},"
+                f"S:{packet.set_saturation},B:{packet.set_brightness},"
+                f"K:{packet.set_kelvin}]"
+            )
+
+        if res_required:
+            label_bytes = device_state.label.encode("utf-8")[:32].ljust(32, b"\x00")
+            return [
+                Light.StateColor(
+                    color=device_state.color,
+                    power=device_state.power_level,
+                    label=label_bytes,
+                )
+            ]
+        return []
+
+
+class GetInfraredHandler(PacketHandler):
+    """Handle LightGetInfrared (120) -> LightStateInfrared (121)."""
+
+    PKT_TYPE = Light.GetInfrared.PKT_TYPE
+
+    def handle(
+        self, device_state: DeviceState, packet: Any | None, res_required: bool
+    ) -> list[Any]:
+        if not device_state.has_infrared:
+            return []
+        return [Light.StateInfrared(brightness=device_state.infrared_brightness)]
+
+
+class SetInfraredHandler(PacketHandler):
+    """Handle LightSetInfrared (122) -> LightStateInfrared (121)."""
+
+    PKT_TYPE = Light.SetInfrared.PKT_TYPE
+
+    def handle(
+        self,
+        device_state: DeviceState,
+        packet: Light.SetInfrared | None,
+        res_required: bool,
+    ) -> list[Any]:
+        if not device_state.has_infrared:
+            return []
+        if packet:
+            device_state.infrared_brightness = packet.brightness
+            logger.info("Infrared brightness set to %s", packet.brightness)
+
+        if res_required:
+            return [Light.StateInfrared(brightness=device_state.infrared_brightness)]
+        return []
+
+
+class GetHevCycleHandler(PacketHandler):
+    """Handle LightGetHevCycle (142) -> LightStateHevCycle (144)."""
+
+    PKT_TYPE = Light.GetHevCycle.PKT_TYPE
+
+    def handle(
+        self, device_state: DeviceState, packet: Any | None, res_required: bool
+    ) -> list[Any]:
+        if not device_state.has_hev:
+            return []
+        return [
+            Light.StateHevCycle(
+                duration_s=device_state.hev_cycle_duration_s,
+                remaining_s=device_state.hev_cycle_remaining_s,
+                last_power=device_state.hev_cycle_last_power,
+            )
+        ]
+
+
+class SetHevCycleHandler(PacketHandler):
+    """Handle LightSetHevCycle (143) -> LightStateHevCycle (144)."""
+
+    PKT_TYPE = Light.SetHevCycle.PKT_TYPE
+
+    def handle(
+        self,
+        device_state: DeviceState,
+        packet: Light.SetHevCycle | None,
+        res_required: bool,
+    ) -> list[Any]:
+        if not device_state.has_hev:
+            return []
+        if packet:
+            device_state.hev_cycle_duration_s = packet.duration_s
+            if packet.enable:
+                device_state.hev_cycle_remaining_s = packet.duration_s
+            else:
+                device_state.hev_cycle_remaining_s = 0
+            logger.info(
+                f"HEV cycle set: enable={packet.enable}, duration={packet.duration_s}s"
+            )
+
+        if res_required:
+            return [
+                Light.StateHevCycle(
+                    duration_s=device_state.hev_cycle_duration_s,
+                    remaining_s=device_state.hev_cycle_remaining_s,
+                    last_power=device_state.hev_cycle_last_power,
+                )
+            ]
+        return []
+
+
+class GetHevCycleConfigurationHandler(PacketHandler):
+    """Handle LightGetHevCycleConfiguration (145).
+
+    Returns LightStateHevCycleConfiguration (147).
+    """
+
+    PKT_TYPE = Light.GetHevCycleConfiguration.PKT_TYPE
+
+    def handle(
+        self, device_state: DeviceState, packet: Any | None, res_required: bool
+    ) -> list[Any]:
+        if not device_state.has_hev:
+            return []
+        return [
+            Light.StateHevCycleConfiguration(
+                indication=device_state.hev_indication,
+                duration_s=device_state.hev_cycle_duration_s,
+            )
+        ]
+
+
+class SetHevCycleConfigurationHandler(PacketHandler):
+    """Handle LightSetHevCycleConfiguration (146).
+
+    Returns LightStateHevCycleConfiguration (147).
+    """
+
+    PKT_TYPE = Light.SetHevCycleConfiguration.PKT_TYPE
+
+    def handle(
+        self,
+        device_state: DeviceState,
+        packet: Light.SetHevCycleConfiguration | None,
+        res_required: bool,
+    ) -> list[Any]:
+        if not device_state.has_hev:
+            return []
+        if packet:
+            device_state.hev_indication = packet.indication
+            device_state.hev_cycle_duration_s = packet.duration_s
+            logger.info(
+                f"HEV config set: indication={packet.indication}, "
+                f"duration={packet.duration_s}s"
+            )
+
+        if res_required:
+            return [
+                Light.StateHevCycleConfiguration(
+                    indication=device_state.hev_indication,
+                    duration_s=device_state.hev_cycle_duration_s,
+                )
+            ]
+        return []
+
+
+class GetLastHevCycleResultHandler(PacketHandler):
+    """Handle LightGetLastHevCycleResult (148) -> LightStateLastHevCycleResult (149)."""
+
+    PKT_TYPE = Light.GetLastHevCycleResult.PKT_TYPE
+
+    def handle(
+        self, device_state: DeviceState, packet: Any | None, res_required: bool
+    ) -> list[Any]:
+        if not device_state.has_hev:
+            return []
+        return [
+            Light.StateLastHevCycleResult(
+                result=LightLastHevCycleResult(device_state.hev_last_result)
+            )
+        ]
+
+
+# List of all light handlers for easy registration
+ALL_LIGHT_HANDLERS = [
+    GetColorHandler(),
+    SetColorHandler(),
+    GetPowerHandler(),
+    SetPowerHandler(),
+    SetWaveformHandler(),
+    SetWaveformOptionalHandler(),
+    GetInfraredHandler(),
+    SetInfraredHandler(),
+    GetHevCycleHandler(),
+    SetHevCycleHandler(),
+    GetHevCycleConfigurationHandler(),
+    SetHevCycleConfigurationHandler(),
+    GetLastHevCycleResultHandler(),
+]