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

lifx_emulator/products/registry.py

@@ -11,6 +11,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from enum import IntEnum
+from functools import cached_property
 
 
 class ProductCapability(IntEnum):
@@ -128,6 +129,53 @@ class ProductInfo:
             return True
         return firmware_version >= self.min_ext_mz_firmware
 
+    @cached_property
+    def caps(self) -> str:
+        """Format product capabilities as a human-readable string.
+
+        Returns:
+            Comma-separated capability string (e.g., "full color, infrared, multizone")
+        """
+        caps = []
+
+        # Determine base light type
+        if self.has_relays:
+            # Devices with relays are switches, not lights
+            caps.append("switch")
+        elif self.has_color:
+            caps.append("full color")
+        else:
+            # Check temperature range to determine white light type
+            if self.temperature_range:
+                if self.temperature_range.min != self.temperature_range.max:
+                    caps.append("color temperature")
+                else:
+                    caps.append("brightness only")
+            else:
+                # No temperature range info, assume basic brightness
+                caps.append("brightness only")
+
+        # Add additional capabilities
+        if self.has_infrared:
+            caps.append("infrared")
+        # Extended multizone is backwards compatible with multizone,
+        # so only show multizone if extended multizone is not present
+        if self.has_extended_multizone:
+            caps.append("extended-multizone")
+        elif self.has_multizone:
+            caps.append("multizone")
+        if self.has_matrix:
+            caps.append("matrix")
+        if self.has_hev:
+            caps.append("HEV")
+        if self.has_chain:
+            caps.append("chain")
+        if self.has_buttons and not self.has_relays:
+            # Only show buttons if not already identified as switch
+            caps.append("buttons")
+
+        return ", ".join(caps) if caps else "unknown"
+
 
 # Pre-generated product definitions
 PRODUCTS: dict[int, ProductInfo] = {
@@ -457,22 +505,6 @@ PRODUCTS: dict[int, ProductInfo] = {
         temperature_range=TemperatureRange(min=1500, max=9000),
         min_ext_mz_firmware=None,
     ),
-    70: ProductInfo(
-        pid=70,
-        name="LIFX Switch",
-        vendor=1,
-        capabilities=ProductCapability.RELAYS | ProductCapability.BUTTONS,
-        temperature_range=None,
-        min_ext_mz_firmware=None,
-    ),
-    71: ProductInfo(
-        pid=71,
-        name="LIFX Switch",
-        vendor=1,
-        capabilities=ProductCapability.RELAYS | ProductCapability.BUTTONS,
-        temperature_range=None,
-        min_ext_mz_firmware=None,
-    ),
     81: ProductInfo(
         pid=81,
         name="LIFX Candle White to Warm",
@@ -513,14 +545,6 @@ PRODUCTS: dict[int, ProductInfo] = {
         temperature_range=TemperatureRange(min=2700, max=2700),
         min_ext_mz_firmware=None,
     ),
-    89: ProductInfo(
-        pid=89,
-        name="LIFX Switch",
-        vendor=1,
-        capabilities=ProductCapability.RELAYS | ProductCapability.BUTTONS,
-        temperature_range=None,
-        min_ext_mz_firmware=None,
-    ),
     90: ProductInfo(
         pid=90,
         name="LIFX Clean",
@@ -657,22 +681,6 @@ PRODUCTS: dict[int, ProductInfo] = {
         temperature_range=TemperatureRange(min=1500, max=9000),
         min_ext_mz_firmware=None,
     ),
-    115: ProductInfo(
-        pid=115,
-        name="LIFX Switch",
-        vendor=1,
-        capabilities=ProductCapability.RELAYS | ProductCapability.BUTTONS,
-        temperature_range=None,
-        min_ext_mz_firmware=None,
-    ),
-    116: ProductInfo(
-        pid=116,
-        name="LIFX Switch",
-        vendor=1,
-        capabilities=ProductCapability.RELAYS | ProductCapability.BUTTONS,
-        temperature_range=None,
-        min_ext_mz_firmware=None,
-    ),
     117: ProductInfo(
         pid=117,
         name="LIFX Z US",
@@ -1313,6 +1321,10 @@ class ProductRegistry:
                 prod_features = product.get("features", {})
                 features: dict[str, Any] = {**default_features, **prod_features}
 
+                # Skip switch products (devices with relays) - these are not lights
+                if features.get("relays"):
+                    continue
+
                 # Build capabilities bitfield
                 capabilities = 0
                 if features.get("color"):

lifx_emulator/products/specs.py

@@ -83,19 +83,18 @@ class SpecsRegistry:
 
         # Parse product specs
         for pid, specs_data in data["products"].items():
-            if isinstance(specs_data, dict):
-                self._specs[int(pid)] = ProductSpecs(
-                    product_id=int(pid),
-                    default_zone_count=specs_data.get("default_zone_count"),
-                    min_zone_count=specs_data.get("min_zone_count"),
-                    max_zone_count=specs_data.get("max_zone_count"),
-                    default_tile_count=specs_data.get("default_tile_count"),
-                    min_tile_count=specs_data.get("min_tile_count"),
-                    max_tile_count=specs_data.get("max_tile_count"),
-                    tile_width=specs_data.get("tile_width"),
-                    tile_height=specs_data.get("tile_height"),
-                    notes=specs_data.get("notes"),
-                )
+            self._specs[int(pid)] = ProductSpecs(
+                product_id=int(pid),
+                default_zone_count=specs_data.get("default_zone_count"),
+                min_zone_count=specs_data.get("min_zone_count"),
+                max_zone_count=specs_data.get("max_zone_count"),
+                default_tile_count=specs_data.get("default_tile_count"),
+                min_tile_count=specs_data.get("min_tile_count"),
+                max_tile_count=specs_data.get("max_tile_count"),
+                tile_width=specs_data.get("tile_width"),
+                tile_height=specs_data.get("tile_height"),
+                notes=specs_data.get("notes"),
+            )
 
         self._loaded = True
 

lifx_emulator/protocol/base.py

@@ -137,7 +137,7 @@ class Packet:
 
             # Unpack field value
             value, current_offset = cls._unpack_field_value(
-                data, field_type, size_bytes, current_offset
+                data, field_type, size_bytes, current_offset, field_name
             )
             field_values[field_name] = value
 
@@ -195,7 +195,10 @@ class Packet:
                     result += item.pack()
                 return result
             elif base_type in ("uint8", "byte"):
-                # Byte array
+                # Check if value is a string (Label fields)
+                if isinstance(value, str):
+                    return serializer.pack_string(value, size_bytes)
+                # Regular byte array
                 return serializer.pack_bytes(value, size_bytes)
             else:
                 # Array of primitives
@@ -211,11 +214,105 @@ class Packet:
             return serializer.pack_value(value, base_type)
 
     @classmethod
-    def _unpack_field_value(
-        cls, data: bytes, field_type: str, size_bytes: int, offset: int
+    def _unpack_array_field(
+        cls,
+        data: bytes,
+        base_type: str,
+        array_count: int,
+        size_bytes: int,
+        offset: int,
+        field_name: str,
+        is_nested: bool,
+        enum_types: dict,
+    ) -> tuple[Any, int]:
+        """Unpack an array field value."""
+        from lifx_emulator.protocol import serializer
+
+        is_enum = is_nested and base_type in enum_types
+
+        if is_enum:
+            result = []
+            current_offset = offset
+            enum_class = enum_types[base_type]
+            for _ in range(array_count):
+                item_raw, current_offset = serializer.unpack_value(
+                    data, "uint8", current_offset
+                )
+                result.append(enum_class(item_raw))
+            return result, current_offset
+        elif is_nested:
+            from lifx_emulator.protocol import protocol_types
+
+            struct_class = getattr(protocol_types, base_type)
+            result = []
+            current_offset = offset
+            for _ in range(array_count):
+                if issubclass(struct_class, cls):
+                    item, current_offset = struct_class._unpack_internal(
+                        data, current_offset
+                    )
+                else:
+                    item_result = struct_class.unpack(data, current_offset)
+                    item, current_offset = item_result  # type: ignore[misc]
+                result.append(item)
+            return result, current_offset
+        elif base_type in ("uint8", "byte"):
+            if field_name.lower().endswith("label"):
+                return serializer.unpack_string(data, size_bytes, offset)
+            return serializer.unpack_bytes(data, size_bytes, offset)
+        else:
+            return serializer.unpack_array(data, base_type, array_count, offset)
+
+    @classmethod
+    def _unpack_single_field(
+        cls,
+        data: bytes,
+        base_type: str,
+        offset: int,
+        is_nested: bool,
+        enum_types: dict,
     ) -> tuple[Any, int]:
-        """Unpack a single field value based on its type."""
+        """Unpack a non-array field value."""
         from lifx_emulator.protocol import serializer
+
+        is_enum = is_nested and base_type in enum_types
+
+        if is_enum:
+            enum_class = enum_types[base_type]
+            value_raw, new_offset = serializer.unpack_value(data, "uint8", offset)
+            return enum_class(value_raw), new_offset
+        elif is_nested:
+            from lifx_emulator.protocol import protocol_types
+
+            struct_class = getattr(protocol_types, base_type)
+            if issubclass(struct_class, cls):
+                return struct_class._unpack_internal(data, offset)
+            else:
+                return struct_class.unpack(data, offset)
+        else:
+            return serializer.unpack_value(data, base_type, offset)
+
+    @classmethod
+    def _unpack_field_value(
+        cls,
+        data: bytes,
+        field_type: str,
+        size_bytes: int,
+        offset: int,
+        field_name: str = "",
+    ) -> tuple[Any, int]:
+        """Unpack a single field value based on its type.
+
+        Args:
+            data: Bytes to unpack from
+            field_type: Protocol field type string
+            size_bytes: Size in bytes
+            offset: Offset in bytes
+            field_name: Optional field name for semantic type detection
+
+        Returns:
+            Tuple of (value, new_offset)
+        """
         from lifx_emulator.protocol.protocol_types import (
             DeviceService,
             LightLastHevCycleResult,
@@ -225,10 +322,8 @@ class Packet:
             MultiZoneExtendedApplicationRequest,
         )
 
-        # Parse field type
         base_type, array_count, is_nested = cls._parse_field_type(field_type)
 
-        # Check if it's an enum (Button/Relay enums excluded)
         enum_types = {
             "DeviceService": DeviceService,
             "LightLastHevCycleResult": LightLastHevCycleResult,
@@ -237,63 +332,22 @@ class Packet:
             "MultiZoneEffectType": MultiZoneEffectType,
             "MultiZoneExtendedApplicationRequest": MultiZoneExtendedApplicationRequest,
         }
-        is_enum = is_nested and base_type in enum_types
 
-        # Handle different field types
         if array_count:
-            if is_enum:
-                # Array of enums
-                result = []
-                current_offset = offset
-                enum_class = enum_types[base_type]
-                for _ in range(array_count):
-                    item_raw, current_offset = serializer.unpack_value(
-                        data, "uint8", current_offset
-                    )
-                    result.append(enum_class(item_raw))
-                return result, current_offset
-            elif is_nested:
-                # Array of nested structures - need to import dynamically
-                from lifx_emulator.protocol import protocol_types
-
-                struct_class = getattr(protocol_types, base_type)
-                result = []
-                current_offset = offset
-                for _ in range(array_count):
-                    # Check if it's a Packet subclass or protocol_types class
-                    if issubclass(struct_class, cls):
-                        item, current_offset = struct_class._unpack_internal(
-                            data, current_offset
-                        )
-                    else:
-                        item_result = struct_class.unpack(data, current_offset)
-                        item, current_offset = item_result  # type: ignore[misc]
-                    result.append(item)
-                return result, current_offset
-            elif base_type in ("uint8", "byte"):
-                # Byte array
-                return serializer.unpack_bytes(data, size_bytes, offset)
-            else:
-                # Array of primitives
-                return serializer.unpack_array(data, base_type, array_count, offset)
-        elif is_enum:
-            # Single enum
-            enum_class = enum_types[base_type]
-            value_raw, new_offset = serializer.unpack_value(data, "uint8", offset)
-            return enum_class(value_raw), new_offset
-        elif is_nested:
-            # Nested structure - import dynamically
-            from lifx_emulator.protocol import protocol_types
-
-            struct_class = getattr(protocol_types, base_type)
-            # Check if it's a Packet subclass or protocol_types class
-            if issubclass(struct_class, cls):
-                return struct_class._unpack_internal(data, offset)
-            else:
-                return struct_class.unpack(data, offset)
+            return cls._unpack_array_field(
+                data,
+                base_type,
+                array_count,
+                size_bytes,
+                offset,
+                field_name,
+                is_nested,
+                enum_types,
+            )
         else:
-            # Primitive type
-            return serializer.unpack_value(data, base_type, offset)
+            return cls._unpack_single_field(
+                data, base_type, offset, is_nested, enum_types
+            )
 
     @staticmethod
     def _parse_field_type(field_type: str) -> tuple[str, int | None, bool]:

lifx_emulator/protocol/generator.py

@@ -300,7 +300,9 @@ def generate_enum_code(enums: dict[str, Any]) -> str:
 
 
 def convert_type_to_python(
-    field_type: str, type_aliases: dict[str, str] | None = None
+    field_type: str,
+    type_aliases: dict[str, str] | None = None,
+    field_name: str | None = None,
 ) -> str:
     """Convert a protocol field type to Python type annotation.
 
@@ -308,6 +310,8 @@ def convert_type_to_python(
         field_type: Protocol field type string
         type_aliases: Optional dict mapping type names to their aliases
                      (for collision resolution)
+        field_name: Optional field name for semantic type detection
+                   (e.g., "Label" fields are strings, not bytes)
 
     Returns:
         Python type annotation string
@@ -323,7 +327,10 @@ def convert_type_to_python(
             type_name = type_aliases.get(base_type, base_type)
             return f"list[{type_name}]"
         elif base_type in ("uint8", "byte"):
-            # Special case: byte arrays
+            # Check if this is a string field (Label fields are UTF-8 strings)
+            if field_name and field_name.lower() == "label":
+                return "str"
+            # Regular byte arrays
             return "bytes"
         else:
             return "list[int]"
@@ -664,7 +671,9 @@ def generate_field_code(
                     protocol_name = field_item["name"]
                     attr_type = field_item["type"]
                     python_name = to_snake_case(protocol_name)
-                    python_type = convert_type_to_python(attr_type)
+                    python_type = convert_type_to_python(
+                        attr_type, field_name=protocol_name
+                    )
 
                     code.append(f"    {python_name}: {python_type}")
                     field_map[python_name] = protocol_name
@@ -673,7 +682,9 @@ def generate_field_code(
             # Convert to new format for pack/unpack generation
             for protocol_name, attr_type in field_def.items():
                 python_name = to_snake_case(protocol_name)
-                python_type = convert_type_to_python(attr_type)
+                python_type = convert_type_to_python(
+                    attr_type, field_name=protocol_name
+                )
                 code.append(f"    {python_name}: {python_type}")
                 field_map[python_name] = protocol_name
                 # Build fields_data for old format
@@ -832,7 +843,9 @@ def generate_nested_packet_code(
                     protocol_name = field_item["name"]
                     field_type = field_item["type"]
                     python_name = to_snake_case(protocol_name)
-                    python_type = convert_type_to_python(field_type, type_aliases)
+                    python_type = convert_type_to_python(
+                        field_type, type_aliases, field_name=protocol_name
+                    )
                     code.append(f"        {python_name}: {python_type}")
                     has_fields = True
 

lifx_emulator/protocol/packets.py

@@ -234,7 +234,7 @@ class Device(Packet):
         _requires_response: ClassVar[bool] = False
 
         group: bytes
-        label: bytes
+        label: str
         updated_at: int
 
     @dataclass
@@ -251,7 +251,7 @@ class Device(Packet):
         _requires_ack: ClassVar[bool] = True
         _requires_response: ClassVar[bool] = False
 
-        label: bytes
+        label: str
 
     @dataclass
     class SetLocation(Packet):
@@ -270,7 +270,7 @@ class Device(Packet):
         _requires_response: ClassVar[bool] = False
 
         location: bytes
-        label: bytes
+        label: str
         updated_at: int
 
     @dataclass
@@ -320,7 +320,7 @@ class Device(Packet):
         _requires_response: ClassVar[bool] = False
 
         group: bytes
-        label: bytes
+        label: str
         updated_at: int
 
     @dataclass
@@ -378,7 +378,7 @@ class Device(Packet):
         _requires_ack: ClassVar[bool] = False
         _requires_response: ClassVar[bool] = False
 
-        label: bytes
+        label: str
 
     @dataclass
     class StateLocation(Packet):
@@ -397,7 +397,7 @@ class Device(Packet):
         _requires_response: ClassVar[bool] = False
 
         location: bytes
-        label: bytes
+        label: str
         updated_at: int
 
     @dataclass
@@ -768,7 +768,7 @@ class Light(Packet):
 
         color: LightHsbk
         power: int
-        label: bytes
+        label: str
 
     @dataclass
     class StateHevCycle(Packet):

lifx_emulator/repositories/__init__.py

@@ -0,0 +1,22 @@
+"""Repository interfaces and implementations for LIFX emulator.
+
+This module defines repository abstractions following the Repository Pattern
+and Dependency Inversion Principle. Repositories encapsulate data access logic
+and provide a clean separation between domain logic and data persistence.
+"""
+
+from lifx_emulator.repositories.device_repository import (
+    DeviceRepository,
+    IDeviceRepository,
+)
+from lifx_emulator.repositories.storage_backend import (
+    IDeviceStorageBackend,
+    IScenarioStorageBackend,
+)
+
+__all__ = [
+    "IDeviceRepository",
+    "DeviceRepository",
+    "IDeviceStorageBackend",
+    "IScenarioStorageBackend",
+]

lifx_emulator/repositories/device_repository.py

@@ -0,0 +1,155 @@
+"""Device repository interface and implementation.
+
+Provides abstraction for device storage and retrieval operations,
+following the Repository Pattern and Dependency Inversion Principle.
+"""
+
+from __future__ import annotations
+
+from typing import Protocol, runtime_checkable
+
+from lifx_emulator.devices import EmulatedLifxDevice
+
+
+@runtime_checkable
+class IDeviceRepository(Protocol):
+    """Interface for device repository operations.
+
+    This protocol defines the contract for managing device storage and retrieval.
+    Concrete implementations can use in-memory storage, databases, or other backends.
+    """
+
+    def add(self, device: EmulatedLifxDevice) -> bool:
+        """Add a device to the repository.
+
+        Args:
+            device: Device to add
+
+        Returns:
+            True if device was added, False if device with same serial already exists
+        """
+        ...
+
+    def remove(self, serial: str) -> bool:
+        """Remove a device from the repository.
+
+        Args:
+            serial: Serial number of device to remove
+
+        Returns:
+            True if device was removed, False if not found
+        """
+        ...
+
+    def get(self, serial: str) -> EmulatedLifxDevice | None:
+        """Get a device by serial number.
+
+        Args:
+            serial: Serial number to look up
+
+        Returns:
+            Device if found, None otherwise
+        """
+        ...
+
+    def get_all(self) -> list[EmulatedLifxDevice]:
+        """Get all devices.
+
+        Returns:
+            List of all devices in the repository
+        """
+        ...
+
+    def clear(self) -> int:
+        """Remove all devices from the repository.
+
+        Returns:
+            Number of devices removed
+        """
+        ...
+
+    def count(self) -> int:
+        """Get the number of devices in the repository.
+
+        Returns:
+            Number of devices
+        """
+        ...
+
+
+class DeviceRepository:
+    """In-memory device repository implementation.
+
+    Stores devices in a dictionary keyed by serial number.
+    This is the default implementation used by EmulatedLifxServer.
+    """
+
+    def __init__(self) -> None:
+        """Initialize empty device repository."""
+        self._devices: dict[str, EmulatedLifxDevice] = {}
+
+    def add(self, device: EmulatedLifxDevice) -> bool:
+        """Add a device to the repository.
+
+        Args:
+            device: Device to add
+
+        Returns:
+            True if device was added, False if device with same serial already exists
+        """
+        serial = device.state.serial
+        if serial in self._devices:
+            return False
+        self._devices[serial] = device
+        return True
+
+    def remove(self, serial: str) -> bool:
+        """Remove a device from the repository.
+
+        Args:
+            serial: Serial number of device to remove
+
+        Returns:
+            True if device was removed, False if not found
+        """
+        if serial in self._devices:
+            del self._devices[serial]
+            return True
+        return False
+
+    def get(self, serial: str) -> EmulatedLifxDevice | None:
+        """Get a device by serial number.
+
+        Args:
+            serial: Serial number to look up
+
+        Returns:
+            Device if found, None otherwise
+        """
+        return self._devices.get(serial)
+
+    def get_all(self) -> list[EmulatedLifxDevice]:
+        """Get all devices.
+
+        Returns:
+            List of all devices in the repository
+        """
+        return list(self._devices.values())
+
+    def clear(self) -> int:
+        """Remove all devices from the repository.
+
+        Returns:
+            Number of devices removed
+        """
+        count = len(self._devices)
+        self._devices.clear()
+        return count
+
+    def count(self) -> int:
+        """Get the number of devices in the repository.
+
+        Returns:
+            Number of devices
+        """
+        return len(self._devices)