lifx-emulator 1.0.1__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,27 +681,13 @@ 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",
         vendor=1,
-        capabilities=ProductCapability.COLOR | ProductCapability.MULTIZONE,
+        capabilities=ProductCapability.COLOR
+        | ProductCapability.MULTIZONE
+        | ProductCapability.EXTENDED_MULTIZONE,
         temperature_range=TemperatureRange(min=1500, max=9000),
         min_ext_mz_firmware=None,
     ),
@@ -685,7 +695,9 @@ PRODUCTS: dict[int, ProductInfo] = {
         pid=118,
         name="LIFX Z Intl",
         vendor=1,
-        capabilities=ProductCapability.COLOR | ProductCapability.MULTIZONE,
+        capabilities=ProductCapability.COLOR
+        | ProductCapability.MULTIZONE
+        | ProductCapability.EXTENDED_MULTIZONE,
         temperature_range=TemperatureRange(min=1500, max=9000),
         min_ext_mz_firmware=None,
     ),
@@ -693,7 +705,9 @@ PRODUCTS: dict[int, ProductInfo] = {
         pid=119,
         name="LIFX Beam US",
         vendor=1,
-        capabilities=ProductCapability.COLOR | ProductCapability.MULTIZONE,
+        capabilities=ProductCapability.COLOR
+        | ProductCapability.MULTIZONE
+        | ProductCapability.EXTENDED_MULTIZONE,
         temperature_range=TemperatureRange(min=1500, max=9000),
         min_ext_mz_firmware=None,
     ),
@@ -701,7 +715,9 @@ PRODUCTS: dict[int, ProductInfo] = {
         pid=120,
         name="LIFX Beam Intl",
         vendor=1,
-        capabilities=ProductCapability.COLOR | ProductCapability.MULTIZONE,
+        capabilities=ProductCapability.COLOR
+        | ProductCapability.MULTIZONE
+        | ProductCapability.EXTENDED_MULTIZONE,
         temperature_range=TemperatureRange(min=1500, max=9000),
         min_ext_mz_firmware=None,
     ),
@@ -853,7 +869,9 @@ PRODUCTS: dict[int, ProductInfo] = {
         pid=141,
         name="LIFX Neon US",
         vendor=1,
-        capabilities=ProductCapability.COLOR | ProductCapability.MULTIZONE,
+        capabilities=ProductCapability.COLOR
+        | ProductCapability.MULTIZONE
+        | ProductCapability.EXTENDED_MULTIZONE,
         temperature_range=TemperatureRange(min=1500, max=9000),
         min_ext_mz_firmware=None,
     ),
@@ -861,7 +879,9 @@ PRODUCTS: dict[int, ProductInfo] = {
         pid=142,
         name="LIFX Neon Intl",
         vendor=1,
-        capabilities=ProductCapability.COLOR | ProductCapability.MULTIZONE,
+        capabilities=ProductCapability.COLOR
+        | ProductCapability.MULTIZONE
+        | ProductCapability.EXTENDED_MULTIZONE,
         temperature_range=TemperatureRange(min=1500, max=9000),
         min_ext_mz_firmware=None,
     ),
@@ -869,7 +889,9 @@ PRODUCTS: dict[int, ProductInfo] = {
         pid=143,
         name="LIFX String US",
         vendor=1,
-        capabilities=ProductCapability.COLOR | ProductCapability.MULTIZONE,
+        capabilities=ProductCapability.COLOR
+        | ProductCapability.MULTIZONE
+        | ProductCapability.EXTENDED_MULTIZONE,
         temperature_range=TemperatureRange(min=1500, max=9000),
         min_ext_mz_firmware=None,
     ),
@@ -877,7 +899,9 @@ PRODUCTS: dict[int, ProductInfo] = {
         pid=144,
         name="LIFX String Intl",
         vendor=1,
-        capabilities=ProductCapability.COLOR | ProductCapability.MULTIZONE,
+        capabilities=ProductCapability.COLOR
+        | ProductCapability.MULTIZONE
+        | ProductCapability.EXTENDED_MULTIZONE,
         temperature_range=TemperatureRange(min=1500, max=9000),
         min_ext_mz_firmware=None,
     ),
@@ -885,7 +909,9 @@ PRODUCTS: dict[int, ProductInfo] = {
         pid=161,
         name="LIFX Outdoor Neon US",
         vendor=1,
-        capabilities=ProductCapability.COLOR | ProductCapability.MULTIZONE,
+        capabilities=ProductCapability.COLOR
+        | ProductCapability.MULTIZONE
+        | ProductCapability.EXTENDED_MULTIZONE,
         temperature_range=TemperatureRange(min=1500, max=9000),
         min_ext_mz_firmware=None,
     ),
@@ -893,7 +919,9 @@ PRODUCTS: dict[int, ProductInfo] = {
         pid=162,
         name="LIFX Outdoor Neon Intl",
         vendor=1,
-        capabilities=ProductCapability.COLOR | ProductCapability.MULTIZONE,
+        capabilities=ProductCapability.COLOR
+        | ProductCapability.MULTIZONE
+        | ProductCapability.EXTENDED_MULTIZONE,
         temperature_range=TemperatureRange(min=1500, max=9000),
         min_ext_mz_firmware=None,
     ),
@@ -1101,7 +1129,9 @@ PRODUCTS: dict[int, ProductInfo] = {
         pid=203,
         name="LIFX String US",
         vendor=1,
-        capabilities=ProductCapability.COLOR | ProductCapability.MULTIZONE,
+        capabilities=ProductCapability.COLOR
+        | ProductCapability.MULTIZONE
+        | ProductCapability.EXTENDED_MULTIZONE,
         temperature_range=TemperatureRange(min=1500, max=9000),
         min_ext_mz_firmware=None,
     ),
@@ -1109,7 +1139,9 @@ PRODUCTS: dict[int, ProductInfo] = {
         pid=204,
         name="LIFX String Intl",
         vendor=1,
-        capabilities=ProductCapability.COLOR | ProductCapability.MULTIZONE,
+        capabilities=ProductCapability.COLOR
+        | ProductCapability.MULTIZONE
+        | ProductCapability.EXTENDED_MULTIZONE,
         temperature_range=TemperatureRange(min=1500, max=9000),
         min_ext_mz_firmware=None,
     ),
@@ -1117,7 +1149,9 @@ PRODUCTS: dict[int, ProductInfo] = {
         pid=205,
         name="LIFX Indoor Neon US",
         vendor=1,
-        capabilities=ProductCapability.COLOR | ProductCapability.MULTIZONE,
+        capabilities=ProductCapability.COLOR
+        | ProductCapability.MULTIZONE
+        | ProductCapability.EXTENDED_MULTIZONE,
         temperature_range=TemperatureRange(min=1500, max=9000),
         min_ext_mz_firmware=None,
     ),
@@ -1125,7 +1159,9 @@ PRODUCTS: dict[int, ProductInfo] = {
         pid=206,
         name="LIFX Indoor Neon Intl",
         vendor=1,
-        capabilities=ProductCapability.COLOR | ProductCapability.MULTIZONE,
+        capabilities=ProductCapability.COLOR
+        | ProductCapability.MULTIZONE
+        | ProductCapability.EXTENDED_MULTIZONE,
         temperature_range=TemperatureRange(min=1500, max=9000),
         min_ext_mz_firmware=None,
     ),
@@ -1133,7 +1169,9 @@ PRODUCTS: dict[int, ProductInfo] = {
         pid=213,
         name="LIFX Permanent Outdoor US",
         vendor=1,
-        capabilities=ProductCapability.COLOR | ProductCapability.MULTIZONE,
+        capabilities=ProductCapability.COLOR
+        | ProductCapability.MULTIZONE
+        | ProductCapability.EXTENDED_MULTIZONE,
         temperature_range=TemperatureRange(min=1500, max=9000),
         min_ext_mz_firmware=None,
     ),
@@ -1141,7 +1179,9 @@ PRODUCTS: dict[int, ProductInfo] = {
         pid=214,
         name="LIFX Permanent Outdoor Intl",
         vendor=1,
-        capabilities=ProductCapability.COLOR | ProductCapability.MULTIZONE,
+        capabilities=ProductCapability.COLOR
+        | ProductCapability.MULTIZONE
+        | ProductCapability.EXTENDED_MULTIZONE,
         temperature_range=TemperatureRange(min=1500, max=9000),
         min_ext_mz_firmware=None,
     ),
@@ -1281,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"):
@@ -1300,16 +1344,22 @@ class ProductRegistry:
                 if features.get("hev"):
                     capabilities |= ProductCapability.HEV
 
-                # Check for extended multizone in upgrades
+                # Check for extended multizone capability
                 min_ext_mz_firmware = None
-                for upgrade in product.get("upgrades", []):
-                    if upgrade.get("features", {}).get("extended_multizone"):
-                        capabilities |= ProductCapability.EXTENDED_MULTIZONE
-                        # Parse firmware version (major.minor format)
-                        major = upgrade.get("major", 0)
-                        minor = upgrade.get("minor", 0)
-                        min_ext_mz_firmware = (major << 16) | minor
-                        break
+
+                # First check if it's a native feature (no firmware requirement)
+                if features.get("extended_multizone"):
+                    capabilities |= ProductCapability.EXTENDED_MULTIZONE
+                else:
+                    # Check if it's available as an upgrade (requires minimum firmware)
+                    for upgrade in product.get("upgrades", []):
+                        if upgrade.get("features", {}).get("extended_multizone"):
+                            capabilities |= ProductCapability.EXTENDED_MULTIZONE
+                            # Parse firmware version (major.minor format)
+                            major = upgrade.get("major", 0)
+                            minor = upgrade.get("minor", 0)
+                            min_ext_mz_firmware = (major << 16) | minor
+                            break
 
                 # Parse temperature range
                 temp_range = None

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