lifx-emulator 1.0.2__py3-none-any.whl → 2.1.0__py3-none-any.whl

lifx_emulator/factories/factory.py

@@ -0,0 +1,221 @@
+"""Factory functions for creating emulated LIFX devices."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from lifx_emulator.devices import EmulatedLifxDevice
+from lifx_emulator.factories.builder import DeviceBuilder
+from lifx_emulator.products.registry import get_product
+
+if TYPE_CHECKING:
+    from lifx_emulator.devices import DevicePersistenceAsyncFile
+    from lifx_emulator.scenarios import HierarchicalScenarioManager
+
+
+def create_color_light(
+    serial: str | None = None,
+    firmware_version: tuple[int, int] | None = None,
+    storage: DevicePersistenceAsyncFile | None = None,
+    scenario_manager: HierarchicalScenarioManager | None = None,
+) -> EmulatedLifxDevice:
+    """Create a regular color light (LIFX Color)"""
+    return create_device(
+        91,
+        serial=serial,
+        firmware_version=firmware_version,
+        storage=storage,
+        scenario_manager=scenario_manager,
+    )  # LIFX Color
+
+
+def create_infrared_light(
+    serial: str | None = None,
+    firmware_version: tuple[int, int] | None = None,
+    storage: DevicePersistenceAsyncFile | None = None,
+    scenario_manager: HierarchicalScenarioManager | None = None,
+) -> EmulatedLifxDevice:
+    """Create an infrared-enabled light (LIFX A19 Night Vision)"""
+    return create_device(
+        29,
+        serial=serial,
+        firmware_version=firmware_version,
+        storage=storage,
+        scenario_manager=scenario_manager,
+    )  # LIFX A19 Night Vision
+
+
+def create_hev_light(
+    serial: str | None = None,
+    firmware_version: tuple[int, int] | None = None,
+    storage: DevicePersistenceAsyncFile | None = None,
+    scenario_manager: HierarchicalScenarioManager | None = None,
+) -> EmulatedLifxDevice:
+    """Create an HEV-enabled light (LIFX Clean)"""
+    return create_device(
+        90,
+        serial=serial,
+        firmware_version=firmware_version,
+        storage=storage,
+        scenario_manager=scenario_manager,
+    )  # LIFX Clean
+
+
+def create_multizone_light(
+    serial: str | None = None,
+    zone_count: int | None = None,
+    extended_multizone: bool = True,
+    firmware_version: tuple[int, int] | None = None,
+    storage: DevicePersistenceAsyncFile | None = None,
+    scenario_manager: HierarchicalScenarioManager | None = None,
+) -> EmulatedLifxDevice:
+    """Create a multizone light (LIFX Beam)
+
+    Args:
+        serial: Optional serial
+        zone_count: Optional zone count (uses product default if not specified)
+        extended_multizone: enables support for extended multizone requests
+        firmware_version: Optional firmware version tuple (major, minor)
+        storage: Optional storage for persistence
+        scenario_manager: Optional scenario manager
+    """
+    return create_device(
+        38,
+        serial=serial,
+        zone_count=zone_count,
+        extended_multizone=extended_multizone,
+        firmware_version=firmware_version,
+        storage=storage,
+        scenario_manager=scenario_manager,
+    )
+
+
+def create_tile_device(
+    serial: str | None = None,
+    tile_count: int | None = None,
+    tile_width: int | None = None,
+    tile_height: int | None = None,
+    firmware_version: tuple[int, int] | None = None,
+    storage: DevicePersistenceAsyncFile | None = None,
+    scenario_manager: HierarchicalScenarioManager | None = None,
+) -> EmulatedLifxDevice:
+    """Create a tile device (LIFX Tile)
+
+    Args:
+        serial: Optional serial
+        tile_count: Optional tile count (uses product default)
+        tile_width: Optional tile width in pixels (uses product default)
+        tile_height: Optional tile height in pixels (uses product default)
+        firmware_version: Optional firmware version tuple (major, minor)
+        storage: Optional storage for persistence
+        scenario_manager: Optional scenario manager
+    """
+    return create_device(
+        55,
+        serial=serial,
+        tile_count=tile_count,
+        tile_width=tile_width,
+        tile_height=tile_height,
+        firmware_version=firmware_version,
+        storage=storage,
+        scenario_manager=scenario_manager,
+    )  # LIFX Tile
+
+
+def create_color_temperature_light(
+    serial: str | None = None,
+    firmware_version: tuple[int, int] | None = None,
+    storage: DevicePersistenceAsyncFile | None = None,
+    scenario_manager: HierarchicalScenarioManager | None = None,
+) -> EmulatedLifxDevice:
+    """Create a color temperature light (LIFX Mini White to Warm).
+
+    Variable color temperature, no RGB.
+    """
+    return create_device(
+        50,
+        serial=serial,
+        firmware_version=firmware_version,
+        storage=storage,
+        scenario_manager=scenario_manager,
+    )  # LIFX Mini White to Warm
+
+
+def create_device(
+    product_id: int,
+    serial: str | None = None,
+    zone_count: int | None = None,
+    extended_multizone: bool | None = None,
+    tile_count: int | None = None,
+    tile_width: int | None = None,
+    tile_height: int | None = None,
+    firmware_version: tuple[int, int] | None = None,
+    storage: DevicePersistenceAsyncFile | None = None,
+    scenario_manager: HierarchicalScenarioManager | None = None,
+) -> EmulatedLifxDevice:
+    """Create a device for any LIFX product using the product registry.
+
+    This function uses the DeviceBuilder pattern to construct devices with
+    clean separation of concerns and testable components.
+
+    Args:
+        product_id: Product ID from the LIFX product registry
+        serial: Optional serial (auto-generated if not provided)
+        zone_count: Number of zones for multizone devices (auto-determined)
+        extended_multizone: Enable extended multizone requests
+        tile_count: Number of tiles for matrix devices (default: 5)
+        tile_width: Width of each tile in pixels (default: 8)
+        tile_height: Height of each tile in pixels (default: 8)
+        firmware_version: Optional firmware version tuple (major, minor).
+                         If not specified, uses 3.70 for extended_multizone
+                         or 2.60 otherwise
+        storage: Optional storage for persistence
+        scenario_manager: Optional scenario manager for testing
+
+    Returns:
+        EmulatedLifxDevice configured for the specified product
+
+    Raises:
+        ValueError: If product_id is not found in registry
+
+    Examples:
+        >>> # Create LIFX A19 (PID 27)
+        >>> device = create_device(27)
+        >>> # Create LIFX Z strip (PID 32) with 24 zones
+        >>> strip = create_device(32, zone_count=24)
+        >>> # Create LIFX Tile (PID 55) with 10 tiles
+        >>> tiles = create_device(55, tile_count=10)
+    """
+    # Get product info from registry
+    product_info = get_product(product_id)
+    if product_info is None:
+        raise ValueError(f"Unknown product ID: {product_id}")
+
+    # Build device using builder pattern
+    builder = DeviceBuilder(product_info)
+
+    if serial is not None:
+        builder.with_serial(serial)
+
+    if zone_count is not None:
+        builder.with_zone_count(zone_count)
+
+    if extended_multizone is not None:
+        builder.with_extended_multizone(extended_multizone)
+
+    if tile_count is not None:
+        builder.with_tile_count(tile_count)
+
+    if tile_width is not None and tile_height is not None:
+        builder.with_tile_dimensions(tile_width, tile_height)
+
+    if firmware_version is not None:
+        builder.with_firmware_version(*firmware_version)
+
+    if storage is not None:
+        builder.with_storage(storage)
+
+    if scenario_manager is not None:
+        builder.with_scenario_manager(scenario_manager)
+
+    return builder.build()

lifx_emulator/factories/firmware_config.py

@@ -0,0 +1,59 @@
+"""Firmware version configuration for devices."""
+
+from __future__ import annotations
+
+
+class FirmwareConfig:
+    """Determines firmware versions for devices.
+
+    Extended multizone support requires firmware 3.70+.
+    Devices without extended multizone use firmware 2.60.
+
+    Examples:
+        >>> config = FirmwareConfig()
+        >>> major, minor = config.get_firmware_version(extended_multizone=True)
+        >>> (major, minor)
+        (3, 70)
+        >>> major, minor = config.get_firmware_version(extended_multizone=False)
+        >>> (major, minor)
+        (2, 60)
+    """
+
+    # Firmware versions
+    VERSION_EXTENDED = (3, 70)  # Extended multizone support
+    VERSION_LEGACY = (2, 60)  # Legacy firmware
+
+    def get_firmware_version(
+        self,
+        extended_multizone: bool | None = None,
+        override: tuple[int, int] | None = None,
+    ) -> tuple[int, int]:
+        """Get firmware version based on extended multizone support.
+
+        Args:
+            extended_multizone: Whether device supports extended multizone.
+                               None or True defaults to 3.70, False gives 2.60
+            override: Optional explicit firmware version to use
+
+        Returns:
+            Tuple of (major, minor) firmware version
+
+        Examples:
+            >>> config = FirmwareConfig()
+            >>> config.get_firmware_version(extended_multizone=True)
+            (3, 70)
+            >>> config.get_firmware_version(extended_multizone=False)
+            (2, 60)
+            >>> config.get_firmware_version(override=(4, 0))
+            (4, 0)
+        """
+        # Explicit override takes precedence
+        if override is not None:
+            return override
+
+        # None or True defaults to extended (3.70)
+        # Only explicit False gives legacy (2.60)
+        if extended_multizone is False:
+            return self.VERSION_LEGACY
+        else:
+            return self.VERSION_EXTENDED

lifx_emulator/factories/serial_generator.py

@@ -0,0 +1,82 @@
+"""Serial number generation service for LIFX devices."""
+
+from __future__ import annotations
+
+import random
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from lifx_emulator.products.registry import ProductInfo
+
+
+class SerialGenerator:
+    """Generates serial numbers for emulated LIFX devices.
+
+    Serial numbers are 12-character hex strings with different prefixes
+    based on device capabilities for easier identification.
+
+    Prefixes:
+        - d073d9: Matrix/Tile devices
+        - d073d8: Multizone devices (strips/beams)
+        - d073d7: HEV devices
+        - d073d6: Infrared devices
+        - d073d5: Regular color/temperature lights
+
+    Examples:
+        >>> generator = SerialGenerator()
+        >>> serial = generator.generate(product_info)
+        >>> len(serial)
+        12
+        >>> serial.startswith("d073d")
+        True
+    """
+
+    # Device type prefixes for easy identification
+    PREFIX_MATRIX = "d073d9"
+    PREFIX_MULTIZONE = "d073d8"
+    PREFIX_HEV = "d073d7"
+    PREFIX_INFRARED = "d073d6"
+    PREFIX_DEFAULT = "d073d5"
+
+    def generate(self, product_info: ProductInfo) -> str:
+        """Generate a serial number based on product capabilities.
+
+        Args:
+            product_info: Product information from registry
+
+        Returns:
+            12-character hex serial number
+
+        Examples:
+            >>> from lifx_emulator.products.registry import get_product
+            >>> generator = SerialGenerator()
+            >>> product = get_product(55)  # LIFX Tile
+            >>> serial = generator.generate(product)
+            >>> serial.startswith("d073d9")  # Matrix prefix
+            True
+        """
+        prefix = self._determine_prefix(product_info)
+        suffix = random.randint(100000, 999999)  # nosec
+        return f"{prefix}{suffix:06x}"
+
+    def _determine_prefix(self, product_info: ProductInfo) -> str:
+        """Determine the prefix based on product capabilities.
+
+        Precedence: matrix > multizone > hev > infrared > default
+
+        Args:
+            product_info: Product information from registry
+
+        Returns:
+            6-character hex prefix
+        """
+        if product_info.has_matrix:
+            return self.PREFIX_MATRIX
+        elif product_info.has_multizone:
+            return self.PREFIX_MULTIZONE
+        elif product_info.has_hev:
+            return self.PREFIX_HEV
+        elif product_info.has_infrared:
+            return self.PREFIX_INFRARED
+        else:
+            return self.PREFIX_DEFAULT

lifx_emulator/handlers/base.py

@@ -6,7 +6,7 @@ from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
-    from lifx_emulator.device import DeviceState
+    from lifx_emulator.devices import DeviceState
 
 
 class PacketHandler(ABC):

lifx_emulator/handlers/device_handlers.py

@@ -11,7 +11,7 @@ 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
+    from lifx_emulator.devices import DeviceState
 
 logger = logging.getLogger(__name__)
 
@@ -75,8 +75,7 @@ class GetLabelHandler(PacketHandler):
     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)]
+        return [Device.StateLabel(label=device_state.label)]
 
 
 class SetLabelHandler(PacketHandler):
@@ -91,14 +90,11 @@ class SetLabelHandler(PacketHandler):
         res_required: bool,
     ) -> list[Any]:
         if packet:
-            device_state.label = packet.label.rstrip(b"\x00").decode(
-                "utf-8", errors="replace"
-            )
+            device_state.label = packet.label
             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 [Device.StateLabel(label=device_state.label)]
         return []
 
 
@@ -169,13 +165,10 @@ class GetLocationHandler(PacketHandler):
     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,
+                label=device_state.location_label,
                 updated_at=device_state.location_updated_at,
             )
         ]
@@ -194,9 +187,7 @@ class SetLocationHandler(PacketHandler):
     ) -> 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_label = packet.label
             device_state.location_updated_at = packet.updated_at
             loc_id = packet.location.hex()[:8]
             logger.info(
@@ -204,13 +195,10 @@ class SetLocationHandler(PacketHandler):
             )
 
         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,
+                    label=device_state.location_label,
                     updated_at=device_state.location_updated_at,
                 )
             ]
@@ -225,11 +213,10 @@ class GetGroupHandler(PacketHandler):
     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,
+                label=device_state.group_label,
                 updated_at=device_state.group_updated_at,
             )
         ]
@@ -248,9 +235,7 @@ class SetGroupHandler(PacketHandler):
     ) -> 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_label = packet.label
             device_state.group_updated_at = packet.updated_at
             grp_id = packet.group.hex()[:8]
             logger.info(
@@ -258,13 +243,10 @@ class SetGroupHandler(PacketHandler):
             )
 
         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,
+                    label=device_state.group_label,
                     updated_at=device_state.group_updated_at,
                 )
             ]

lifx_emulator/handlers/light_handlers.py

@@ -10,7 +10,7 @@ from lifx_emulator.protocol.packets import Light
 from lifx_emulator.protocol.protocol_types import LightLastHevCycleResult
 
 if TYPE_CHECKING:
-    from lifx_emulator.device import DeviceState
+    from lifx_emulator.devices import DeviceState
 
 logger = logging.getLogger(__name__)
 
@@ -23,12 +23,11 @@ class GetColorHandler(PacketHandler):
     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,
+                label=device_state.label,
             )
         ]
 
@@ -53,12 +52,11 @@ class SetColorHandler(PacketHandler):
             )
 
         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,
+                    label=device_state.label,
                 )
             ]
         return []
@@ -129,12 +127,11 @@ class SetWaveformHandler(PacketHandler):
             )
 
         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,
+                    label=device_state.label,
                 )
             ]
         return []
@@ -183,12 +180,11 @@ class SetWaveformOptionalHandler(PacketHandler):
             )
 
         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,
+                    label=device_state.label,
                 )
             ]
         return []

lifx_emulator/handlers/multizone_handlers.py

@@ -15,7 +15,7 @@ from lifx_emulator.protocol.protocol_types import (
 )
 
 if TYPE_CHECKING:
-    from lifx_emulator.device import DeviceState
+    from lifx_emulator.devices import DeviceState
 
 logger = logging.getLogger(__name__)
 

lifx_emulator/handlers/tile_handlers.py

@@ -19,7 +19,7 @@ from lifx_emulator.protocol.protocol_types import (
 )
 
 if TYPE_CHECKING:
-    from lifx_emulator.device import DeviceState
+    from lifx_emulator.devices import DeviceState
 
 logger = logging.getLogger(__name__)
 
@@ -237,16 +237,24 @@ class GetEffectHandler(PacketHandler):
         while len(palette) < 16:
             palette.append(LightHsbk(hue=0, saturation=0, brightness=0, kelvin=3500))
 
-        # Create effect settings
+        # Create effect settings with Sky parameters
+        from lifx_emulator.protocol.protocol_types import TileEffectSkyType
+
+        # Use defaults for SKY effect (type=5), otherwise use stored values
+        effect_type = device_state.tile_effect_type
+        if effect_type == 5:  # SKY effect
+            sky_type = device_state.tile_effect_sky_type or 2  # Default to CLOUDS
+            cloud_sat_min = device_state.tile_effect_cloud_sat_min or 50
+            cloud_sat_max = device_state.tile_effect_cloud_sat_max or 180
+        else:
+            sky_type = device_state.tile_effect_sky_type
+            cloud_sat_min = device_state.tile_effect_cloud_sat_min
+            cloud_sat_max = device_state.tile_effect_cloud_sat_max
+
         parameter = TileEffectParameter(
-            parameter0=0,
-            parameter1=0,
-            parameter2=0,
-            parameter3=0,
-            parameter4=0,
-            parameter5=0,
-            parameter6=0,
-            parameter7=0,
+            sky_type=TileEffectSkyType(sky_type),
+            cloud_saturation_min=cloud_sat_min,
+            cloud_saturation_max=cloud_sat_max,
         )
         settings = TileEffectSettings(
             instanceid=0,
@@ -285,10 +293,22 @@ class SetEffectHandler(PacketHandler):
             )
             device_state.tile_effect_palette_count = packet.settings.palette_count
 
+            # Save Sky effect parameters
+            device_state.tile_effect_sky_type = int(packet.settings.parameter.sky_type)
+            device_state.tile_effect_cloud_sat_min = (
+                packet.settings.parameter.cloud_saturation_min
+            )
+            device_state.tile_effect_cloud_sat_max = (
+                packet.settings.parameter.cloud_saturation_max
+            )
+
             logger.info(
                 f"Tile effect set: type={packet.settings.type}, "
                 f"speed={packet.settings.speed}ms, "
-                f"palette_count={packet.settings.palette_count}"
+                f"palette_count={packet.settings.palette_count}, "
+                f"sky_type={packet.settings.parameter.sky_type}, "
+                f"cloud_sat=[{packet.settings.parameter.cloud_saturation_min}, "
+                f"{packet.settings.parameter.cloud_saturation_max}]"
             )
 
         if res_required: