lifx-emulator 1.0.2__py3-none-any.whl → 2.1.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

@@ -10,10 +10,13 @@ Performance optimizations:
 
 from __future__ import annotations
 
+import logging
 import re
-from dataclasses import dataclass
+from dataclasses import asdict, dataclass
 from typing import Any, ClassVar
 
+_LOGGER = logging.getLogger(__name__)
+
 # Performance optimization: Pre-compiled regex patterns
 _CAMEL_TO_SNAKE_PATTERN = re.compile(r"(?<!^)(?=[A-Z])")
 _ARRAY_TYPE_PATTERN = re.compile(r"\[(\d+)\](.+)")
@@ -39,6 +42,11 @@ class Packet:
     _fields: ClassVar[list[dict[str, Any]]]
     _field_info: ClassVar[list[tuple[str, str, int]] | None] = None
 
+    @property
+    def as_dict(self) -> dict[str, Any]:
+        """Return packet as dictionary."""
+        return asdict(self)
+
     def pack(self) -> bytes:
         """Pack packet to bytes using field metadata.
 
@@ -76,9 +84,25 @@ class Packet:
             offset: Offset in bytes to start unpacking
 
         Returns:
-            Packet instance
+            Packet instance with label fields decoded to strings
         """
         packet, _ = cls._unpack_internal(data, offset)
+
+        # Decode label fields from bytes to string in-place
+        # This ensures all State packets have human-readable labels
+        cls._decode_labels_inplace(packet)
+
+        # Log packet values after unpacking and decoding labels
+        packet_values = asdict(packet)
+        _LOGGER.debug(
+            {
+                "class": "Packet",
+                "method": "unpack",
+                "packet_type": type(packet).__name__,
+                "values": packet_values,
+            }
+        )
+
         return packet
 
     @classmethod
@@ -137,7 +161,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
 
@@ -177,6 +201,9 @@ class Packet:
             "MultiZoneApplicationRequest",
             "MultiZoneEffectType",
             "MultiZoneExtendedApplicationRequest",
+            "TileEffectSkyPalette",
+            "TileEffectSkyType",
+            "TileEffectType",
         }
         is_enum = is_nested and base_type in enum_types
 
@@ -195,7 +222,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 +241,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,
@@ -223,12 +347,13 @@ class Packet:
             MultiZoneApplicationRequest,
             MultiZoneEffectType,
             MultiZoneExtendedApplicationRequest,
+            TileEffectSkyPalette,
+            TileEffectSkyType,
+            TileEffectType,
         )
 
-        # 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,
@@ -236,64 +361,26 @@ class Packet:
             "MultiZoneApplicationRequest": MultiZoneApplicationRequest,
             "MultiZoneEffectType": MultiZoneEffectType,
             "MultiZoneExtendedApplicationRequest": MultiZoneExtendedApplicationRequest,
+            "TileEffectSkyPalette": TileEffectSkyPalette,
+            "TileEffectSkyType": TileEffectSkyType,
+            "TileEffectType": TileEffectType,
         }
-        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]:
@@ -332,3 +419,28 @@ class Packet:
         # Cache the result
         _FIELD_TYPE_CACHE[field_type] = result
         return result
+
+    @staticmethod
+    def _decode_labels_inplace(packet: object) -> None:
+        """Decode label fields from bytes to string in-place.
+
+        Automatically finds and decodes any field named 'label' or ending with '_label'
+        for all State packets. This ensures human-readable labels in all contexts.
+
+        Args:
+            packet: Packet instance to process (modified in-place)
+        """
+        from dataclasses import fields, is_dataclass
+
+        if not is_dataclass(packet):
+            return
+
+        for field_info in fields(packet):
+            # Check if this looks like a label field
+            if field_info.name == "label" or field_info.name.endswith("_label"):
+                value = getattr(packet, field_info.name)
+                if isinstance(value, bytes):
+                    # Decode: strip null terminator, decode UTF-8
+                    decoded = value.rstrip(b"\x00").decode("utf-8")
+                    # Use object.__setattr__ to bypass frozen dataclass if needed
+                    object.__setattr__(packet, field_info.name, decoded)

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):