lifx-async 5.1.0__py3-none-any.whl → 5.1.1__py3-none-any.whl

lifx/animation/packets.py

@@ -51,7 +51,7 @@ ACK_REQUIRED = 0
 RES_REQUIRED = 0
 
 
-@dataclass
+@dataclass(slots=True)
 class PacketTemplate:
     """Prebaked packet template for zero-allocation animation.
 
@@ -63,12 +63,14 @@ class PacketTemplate:
         color_offset: Byte offset where color data starts
         color_count: Number of HSBK colors in this packet
         hsbk_start: Starting index in the input HSBK array
+        fmt: Pre-computed struct format string for bulk color packing
     """
 
     data: bytearray
     color_offset: int
     color_count: int
     hsbk_start: int
+    fmt: str
 
 
 def _build_header(
@@ -103,9 +105,8 @@ def _build_header(
     # Frame Address (16 bytes)
     # target (8 bytes) + reserved (6 bytes) + flags (1 byte) + sequence (1 byte)
     target_padded = target + b"\x00\x00" if len(target) == 6 else target
-    target_int = int.from_bytes(target_padded, byteorder="little")
     flags = (RES_REQUIRED & 0b1) | ((ACK_REQUIRED & 0b1) << 1)
-    struct.pack_into("<Q6sBB", header, 8, target_int, b"\x00" * 6, flags, 0)
+    struct.pack_into("<8s6sBB", header, 8, target_padded, b"\x00" * 6, flags, 0)
 
     # Protocol Header (12 bytes)
     struct.pack_into("<QHH", header, 24, 0, pkt_type, 0)
@@ -277,12 +278,14 @@ class MatrixPacketGenerator(PacketGenerator):
             # Combine header + payload
             packet = header + payload
 
+            color_count = min(self._pixels_per_tile, 64)
             templates.append(
                 PacketTemplate(
                     data=packet,
                     color_offset=HEADER_SIZE + self._COLORS_OFFSET_IN_PAYLOAD,
-                    color_count=min(self._pixels_per_tile, 64),
+                    color_count=color_count,
                     hsbk_start=tile_idx * self._pixels_per_tile,
+                    fmt=f"<{'HHHH' * color_count}",
                 )
             )
 
@@ -338,6 +341,7 @@ class MatrixPacketGenerator(PacketGenerator):
                         color_offset=HEADER_SIZE + self._COLORS_OFFSET_IN_PAYLOAD,
                         color_count=color_count,
                         hsbk_start=tile_pixel_start + color_start,
+                        fmt=f"<{'HHHH' * color_count}",
                     )
                 )
 
@@ -369,6 +373,7 @@ class MatrixPacketGenerator(PacketGenerator):
                     color_offset=0,  # No colors
                     color_count=0,
                     hsbk_start=0,
+                    fmt="",
                 )
             )
 
@@ -387,10 +392,13 @@ class MatrixPacketGenerator(PacketGenerator):
             if tmpl.color_count == 0:
                 continue  # Skip CopyFrameBuffer packets
 
-            for i in range(tmpl.color_count):
-                h, s, b, k = hsbk[tmpl.hsbk_start + i]
-                offset = tmpl.color_offset + i * 8
-                struct.pack_into("<HHHH", tmpl.data, offset, h, s, b, k)
+            # Flatten HSBK tuples and pack in one bulk call
+            start = tmpl.hsbk_start
+            end = start + tmpl.color_count
+            flat: list[int] = []
+            for h, s, b, k in hsbk[start:end]:
+                flat.extend((h, s, b, k))
+            struct.pack_into(tmpl.fmt, tmpl.data, tmpl.color_offset, *flat)
 
 
 class MultiZonePacketGenerator(PacketGenerator):
@@ -476,6 +484,7 @@ class MultiZonePacketGenerator(PacketGenerator):
                     color_offset=HEADER_SIZE + self._COLORS_OFFSET_IN_PAYLOAD,
                     color_count=zone_count,
                     hsbk_start=zone_start,
+                    fmt=f"<{'HHHH' * zone_count}",
                 )
             )
 
@@ -491,7 +500,10 @@ class MultiZonePacketGenerator(PacketGenerator):
             hsbk: Protocol-ready HSBK data for all zones
         """
         for tmpl in templates:
-            for i in range(tmpl.color_count):
-                h, s, b, k = hsbk[tmpl.hsbk_start + i]
-                offset = tmpl.color_offset + i * 8
-                struct.pack_into("<HHHH", tmpl.data, offset, h, s, b, k)
+            # Flatten HSBK tuples and pack in one bulk call
+            start = tmpl.hsbk_start
+            end = start + tmpl.color_count
+            flat: list[int] = []
+            for h, s, b, k in hsbk[start:end]:
+                flat.extend((h, s, b, k))
+            struct.pack_into(tmpl.fmt, tmpl.data, tmpl.color_offset, *flat)

lifx/devices/base.py

@@ -710,29 +710,29 @@ class Device(Generic[StateT]):
 
         return self._mac_address
 
-    async def _ensure_capabilities(self) -> None:
-        """Ensure device capabilities are populated.
+    def _process_capabilities(
+        self, version: DeviceVersion, host_firmware: FirmwareInfo
+    ) -> None:
+        """Process device capabilities from already-fetched version and firmware data.
 
-        This fetches the device version and firmware to determine product capabilities.
-        If the device claims extended_multizone support but firmware is too old,
-        the capability is removed.
+        Looks up product info from version.product, checks extended_multizone firmware
+        requirement, and sets self._capabilities. No-op if capabilities already set.
 
-        Called automatically when entering context manager, but can be called manually.
+        Args:
+            version: Device version info (vendor, product)
+            host_firmware: Host firmware info for extended multizone check
         """
-        if self._capabilities is not None:  # pragma: no cover
+        if self._capabilities is not None:
             return
 
-        # Get device version to determine product ID
-        version = await self.get_version()
         self._capabilities = get_product(version.product)
 
         # If device has extended_multizone with minimum firmware requirement, verify it
         if self._capabilities and self._capabilities.has_extended_multizone:
             if self._capabilities.min_ext_mz_firmware is not None:
-                firmware = await self.get_host_firmware()
                 firmware_version = (
-                    firmware.version_major << 16
-                ) | firmware.version_minor
+                    host_firmware.version_major << 16
+                ) | host_firmware.version_minor
 
                 # If firmware is too old, remove the extended_multizone capability
                 if (
@@ -744,6 +744,23 @@ class Device(Generic[StateT]):
                         ~ProductCapability.EXTENDED_MULTIZONE
                     )
 
+    async def _ensure_capabilities(self) -> None:
+        """Ensure device capabilities are populated.
+
+        This fetches the device version and firmware to determine product capabilities.
+        If the device claims extended_multizone support but firmware is too old,
+        the capability is removed.
+
+        Called automatically when entering context manager, but can be called manually.
+        """
+        if self._capabilities is not None:  # pragma: no cover
+            return
+
+        # Get device version to determine product ID
+        version = await self.get_version()
+        host_firmware = await self.get_host_firmware()
+        self._process_capabilities(version, host_firmware)
+
     @property
     def capabilities(self) -> ProductInfo | None:
         """Get device product capabilities.
@@ -1661,32 +1678,62 @@ class Device(Generic[StateT]):
         This is an all-or-nothing operation - either all state is fetched successfully
         or an exception is raised.
 
+        When capabilities are not pre-loaded, get_version() runs in parallel with the
+        other GET requests to save one network round-trip.
+
         Raises:
             LifxTimeoutError: If device does not respond within timeout
             LifxDeviceNotFoundError: If device cannot be reached
             LifxProtocolError: If responses are invalid
         """
-        # Ensure capabilities are loaded
-        await self._ensure_capabilities()
-        capabilities = self._create_capabilities()
-
-        # Fetch semi-static and volatile state in parallel
-        # get_color returns color, power, and label in one request
-        (
-            label,
-            power,
-            host_firmware,
-            wifi_firmware,
-            location_info,
-            group_info,
-        ) = await asyncio.gather(
-            self.get_label(),
-            self.get_power(),
-            self.get_host_firmware(),
-            self.get_wifi_firmware(),
-            self.get_location(),
-            self.get_group(),
-        )
+        if self._capabilities is not None:
+            # Capabilities pre-loaded: skip get_version(), run 6 requests in parallel
+            capabilities = self._create_capabilities()
+
+            (
+                label,
+                power,
+                host_firmware,
+                wifi_firmware,
+                location_info,
+                group_info,
+            ) = await asyncio.gather(
+                self.get_label(),
+                self.get_power(),
+                self.get_host_firmware(),
+                self.get_wifi_firmware(),
+                self.get_location(),
+                self.get_group(),
+            )
+        else:
+            # Capabilities not loaded: include get_version() in parallel batch
+            # Schedule get_version() concurrently alongside the 6-arg gather
+            version_task = asyncio.ensure_future(self.get_version())
+            try:
+                (
+                    label,
+                    power,
+                    host_firmware,
+                    wifi_firmware,
+                    location_info,
+                    group_info,
+                ) = await asyncio.gather(
+                    self.get_label(),
+                    self.get_power(),
+                    self.get_host_firmware(),
+                    self.get_wifi_firmware(),
+                    self.get_location(),
+                    self.get_group(),
+                )
+                version = await version_task
+            except Exception:
+                if not version_task.done():
+                    version_task.cancel()
+                # Await to consume cancellation and avoid leaked task warnings
+                await asyncio.gather(version_task, return_exceptions=True)
+                raise
+            self._process_capabilities(version, host_firmware)
+            capabilities = self._create_capabilities()
 
         # Get MAC address (already calculated in get_host_firmware)
         mac_address = await self.get_mac_address()

lifx/devices/light.py

@@ -946,9 +946,8 @@ class Light(Device[LightState]):
         """Initialize light state transactionally.
 
         Extends base implementation to fetch color in addition to base state.
-
-        Args:
-            timeout: Timeout for state initialization
+        When capabilities are not pre-loaded, get_version() runs in parallel with
+        the other GET requests to save one network round-trip.
 
         Raises:
             LifxTimeoutError: If device does not respond within timeout
@@ -957,26 +956,50 @@ class Light(Device[LightState]):
         """
         import time
 
-        # Ensure capabilities are loaded
-        await self._ensure_capabilities()
-        capabilities = self._create_capabilities()
-
-        # Fetch semi-static and volatile state in parallel
-        # get_color returns color, power, and label in one request
         try:
-            (
-                (color, power, label),
-                host_firmware,
-                wifi_firmware,
-                location_info,
-                group_info,
-            ) = await asyncio.gather(
-                self.get_color(),
-                self.get_host_firmware(),
-                self.get_wifi_firmware(),
-                self.get_location(),
-                self.get_group(),
-            )
+            if self._capabilities is not None:
+                # Capabilities pre-loaded: skip get_version()
+                capabilities = self._create_capabilities()
+
+                (
+                    (color, power, label),
+                    host_firmware,
+                    wifi_firmware,
+                    location_info,
+                    group_info,
+                ) = await asyncio.gather(
+                    self.get_color(),
+                    self.get_host_firmware(),
+                    self.get_wifi_firmware(),
+                    self.get_location(),
+                    self.get_group(),
+                )
+            else:
+                # Capabilities not loaded: include get_version() in parallel batch
+                version_task = asyncio.ensure_future(self.get_version())
+                try:
+                    (
+                        (color, power, label),
+                        host_firmware,
+                        wifi_firmware,
+                        location_info,
+                        group_info,
+                    ) = await asyncio.gather(
+                        self.get_color(),
+                        self.get_host_firmware(),
+                        self.get_wifi_firmware(),
+                        self.get_location(),
+                        self.get_group(),
+                    )
+                    version = await version_task
+                except Exception:
+                    if not version_task.done():
+                        version_task.cancel()
+                    # Await to consume cancellation and avoid leaked task warnings
+                    await asyncio.gather(version_task, return_exceptions=True)
+                    raise
+                self._process_capabilities(version, host_firmware)
+                capabilities = self._create_capabilities()
 
             # Get MAC address (already calculated in get_host_firmware)
             mac_address = await self.get_mac_address()

lifx/network/connection.py

@@ -110,6 +110,21 @@ class DeviceConnection:
         self._is_open = False
         self._is_opening = False  # Flag to prevent concurrent open() calls
 
+        # Pre-compute serial bytes for fast comparison in background receiver
+        self._is_discovery = serial == "000000000000"
+        if not self._is_discovery:
+            serial_obj = Serial.from_string(serial)
+            self._target_bytes: bytes | None = serial_obj.to_protocol()
+        else:
+            self._target_bytes = None
+
+        # Pre-compute target bytes for send_packet() to avoid
+        # re-parsing on every send
+        if self._target_bytes is not None:
+            self._send_target: bytes = self._target_bytes
+        else:
+            self._send_target: bytes = b"\x00" * 8
+
         # Background receiver task infrastructure
         # Key: (source, sequence, serial) → Queue of (header, payload) tuples
         self._pending_requests: dict[
@@ -262,12 +277,11 @@ class DeviceConnection:
         if source is None:
             source = self._allocate_source()
 
-        target = Serial.from_string(self.serial).to_protocol()
         message = create_message(
             packet=packet,
             source=source,
             sequence=sequence,
-            target=target,
+            target=self._send_target,
             ack_required=ack_required,
             res_required=res_required,
         )
@@ -360,12 +374,19 @@ class DeviceConnection:
                 )
 
                 # Compute correlation key (includes serial for defense-in-depth)
-                # For discovery connections (self.serial == "000000000000"), always use
-                # "000000000000" for correlation regardless of response serial
-                if self.serial == "000000000000":
+                # For discovery connections, always use "000000000000" for correlation
+                # regardless of response serial
+                if self._is_discovery:
                     serial = "000000000000"
                 else:
-                    serial = Serial.from_protocol(header.target).to_string()
+                    # Compare target bytes directly to avoid string conversion
+                    if (
+                        self._target_bytes is not None
+                        and header.target == self._target_bytes
+                    ):
+                        serial = self.serial
+                    else:
+                        serial = Serial.from_protocol(header.target).to_string()
                 key = (header.source, header.sequence, serial)
 
                 # Route to waiting request
@@ -572,11 +593,14 @@ class DeviceConnection:
 
                         # Validate correlation (defense in depth)
                         # For discovery connections, skip serial validation
-                        if self.serial != "000000000000":
-                            response_serial = Serial.from_protocol(
-                                header.target
-                            ).to_string()
-                            if response_serial != self.serial:
+                        if not self._is_discovery:
+                            if (
+                                self._target_bytes is not None
+                                and header.target != self._target_bytes
+                            ):
+                                response_serial = Serial.from_protocol(
+                                    header.target
+                                ).to_string()
                                 raise LifxProtocolError(
                                     f"Response serial mismatch: "
                                     f"expected {self.serial}, got {response_serial}"
@@ -710,16 +734,21 @@ class DeviceConnection:
                     )
 
                 # Validate correlation
+                serial_mismatch = (
+                    self._target_bytes is not None
+                    and header.target != self._target_bytes
+                )
                 if (
                     header.source != request_source
                     or header.sequence != sequence
-                    or Serial.from_protocol(header.target).to_string() != self.serial
+                    or serial_mismatch
                 ):
+                    response_serial = Serial.from_protocol(header.target).to_string()
                     raise LifxProtocolError(
                         f"ACK correlation mismatch: "
                         f"expected ({request_source}, {sequence}, {self.serial}), "
                         f"got ({header.source}, {header.sequence}, "
-                        f"{Serial.from_protocol(header.target).to_string()})"
+                        f"{response_serial})"
                     )
 
                 # Check for StateUnhandled - return False to indicate unsupported
@@ -848,6 +877,10 @@ class DeviceConnection:
                 serial = Serial(value=header.target_serial).to_string()
                 if self.serial == "000000000000" and serial != self.serial:
                     self.serial = serial
+                    # Refresh cached fields now that we know the real serial
+                    self._is_discovery = False
+                    self._target_bytes = Serial.from_string(serial).to_protocol()
+                    self._send_target = self._target_bytes
 
                 # Unpack (labels are automatically decoded by Packet.unpack())
                 response_packet = packet_class.unpack(payload)

lifx/protocol/base.py

@@ -6,8 +6,42 @@ Provides generic pack/unpack functionality for all packet types.
 from __future__ import annotations
 
 import logging
+import re
 from dataclasses import asdict, dataclass
-from typing import Any, ClassVar
+from typing import TYPE_CHECKING, Any, ClassVar
+
+if TYPE_CHECKING:
+    from types import ModuleType
+
+# Lazy-cached module references to avoid circular imports at module load time.
+# These modules import from each other indirectly through packets.py, so we
+# defer the import to first use and cache the result at module level.
+_serializer: ModuleType | None = None
+_protocol_types: ModuleType | None = None
+
+
+def _get_serializer() -> ModuleType:
+    """Get the serializer module, importing on first use."""
+    global _serializer  # noqa: PLW0603
+    if _serializer is None:
+        from lifx.protocol import serializer
+
+        _serializer = serializer
+    return _serializer
+
+
+def _get_protocol_types() -> ModuleType:
+    """Get the protocol_types module, importing on first use."""
+    global _protocol_types  # noqa: PLW0603
+    if _protocol_types is None:
+        from lifx.protocol import protocol_types
+
+        _protocol_types = protocol_types
+    return _protocol_types
+
+
+_ARRAY_PATTERN = re.compile(r"\[(\d+)\](.+)")
+_PASCAL_TO_SNAKE = re.compile(r"(?<!^)(?=[A-Z])")
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -37,7 +71,7 @@ class Packet:
         Returns:
             Packed bytes ready to send in a LIFX message payload
         """
-        from lifx.protocol import serializer
+        serializer = _get_serializer()
 
         result = b""
 
@@ -154,14 +188,12 @@ class Packet:
     @staticmethod
     def _protocol_to_python_name(name: str) -> str:
         """Convert protocol name (PascalCase) to Python name (snake_case)."""
-        import re
-
-        snake = re.sub(r"(?<!^)(?=[A-Z])", "_", name)
+        snake = _PASCAL_TO_SNAKE.sub("_", name)
         return snake.lower()
 
     def _pack_field_value(self, value: Any, field_type: str, size_bytes: int) -> bytes:
         """Pack a single field value based on its type."""
-        from lifx.protocol import serializer
+        serializer = _get_serializer()
 
         # Parse field type
         base_type, array_count, is_nested = self._parse_field_type(field_type)
@@ -211,25 +243,19 @@ class Packet:
         cls, data: bytes, field_type: str, size_bytes: int, offset: int
     ) -> tuple[Any, int]:
         """Unpack a single field value based on its type."""
-        from lifx.protocol import serializer
-        from lifx.protocol.protocol_types import (
-            DeviceService,
-            FirmwareEffect,
-            LightLastHevCycleResult,
-            LightWaveform,
-            MultiZoneApplicationRequest,
-        )
+        serializer = _get_serializer()
+        protocol_types = _get_protocol_types()
 
         # 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,
-            "LightWaveform": LightWaveform,
-            "MultiZoneApplicationRequest": MultiZoneApplicationRequest,
-            "FirmwareEffect": FirmwareEffect,
+            "DeviceService": protocol_types.DeviceService,
+            "LightLastHevCycleResult": protocol_types.LightLastHevCycleResult,
+            "LightWaveform": protocol_types.LightWaveform,
+            "MultiZoneApplicationRequest": protocol_types.MultiZoneApplicationRequest,
+            "FirmwareEffect": protocol_types.FirmwareEffect,
         }
         is_enum = is_nested and base_type in enum_types
 
@@ -247,9 +273,7 @@ class Packet:
                     result.append(enum_class(item_raw))
                 return result, current_offset
             elif is_nested:
-                # Array of nested structures - need to import dynamically
-                from lifx.protocol import protocol_types
-
+                # Array of nested structures
                 struct_class = getattr(protocol_types, base_type)
                 result = []
                 current_offset = offset
@@ -276,9 +300,7 @@ class Packet:
             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.protocol import protocol_types
-
+            # Nested structure
             struct_class = getattr(protocol_types, base_type)
             # Check if it's a Packet subclass or protocol_types class
             if issubclass(struct_class, cls):
@@ -324,10 +346,8 @@ class Packet:
         Returns:
             Tuple of (base_type, array_count, is_nested)
         """
-        import re
-
         # Check for array: [N]type
-        array_match = re.match(r"\[(\d+)\](.+)", field_type)
+        array_match = _ARRAY_PATTERN.match(field_type)
         if array_match:
             count = int(array_match.group(1))
             inner_type = array_match.group(2)

lifx/protocol/header.py

@@ -141,8 +141,8 @@ class LifxHeader:
         flags = (int(self.res_required) & 0b1) | ((int(self.ack_required) & 0b1) << 1)
 
         frame_addr = struct.pack(
-            "<Q6sBB",
-            int.from_bytes(self.target, byteorder="little"),
+            "<8s6sBB",
+            self.target,
             b"\x00" * 6,  # reserved
             flags,
             self.sequence,
@@ -189,8 +189,7 @@ class LifxHeader:
             raise ValueError("Addressable bit must be set")
 
         # Unpack Frame Address (16 bytes)
-        target_int, _reserved, flags, sequence = struct.unpack("<Q6sBB", data[8:24])
-        target = target_int.to_bytes(8, byteorder="little")
+        target, _reserved, flags, sequence = struct.unpack("<8s6sBB", data[8:24])
 
         res_required = bool(flags & 0b1)
         ack_required = bool((flags >> 1) & 0b1)

{lifx_async-5.1.0.dist-info → lifx_async-5.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lifx-async
-Version: 5.1.0
+Version: 5.1.1
 Summary: A modern, type-safe, async Python library for controlling LIFX lights
 Author-email: Avi Miller <me@dje.li>
 Maintainer-email: Avi Miller <me@dje.li>

{lifx_async-5.1.0.dist-info → lifx_async-5.1.1.dist-info}/RECORD

@@ -8,13 +8,13 @@ lifx/animation/__init__.py,sha256=1EqPk26BTEADYR5qLD1UKb7cNnVfnLo5vfAnix6yyu0,23
 lifx/animation/animator.py,sha256=LyruwE4Z0gHnkGJfgug017-Mt0R-3FCrDoEsqGjE5ps,10154
 lifx/animation/framebuffer.py,sha256=ya3mbYtu5hepn2Fxfc3wEck5KhmmAfcbmv0RoIO-yC4,14116
 lifx/animation/orientation.py,sha256=bUMV4czLn5PH3inMObfyvbYD-jaSSH-LWaLOby-mvTs,5839
-lifx/animation/packets.py,sha256=jMNfe0EKb9oMn96UdYqJshlncYTx61IX6OzKo4SjFcg,17017
+lifx/animation/packets.py,sha256=dnbwpmuirCbxph9mK_FNb7WCi7Mju-pRoVKfcIOIfUI,17498
 lifx/devices/__init__.py,sha256=4b5QtO0EFWxIqN2lUYgM8uLjWyHI5hUcReiF9QCjCGw,1061
-lifx/devices/base.py,sha256=mhNLX6FoLBaZtYo9InleneYdb0dk3B2Ze8Z2eqXCNHo,63180
+lifx/devices/base.py,sha256=NV0GxG0-O7VLT55_z6nBqdU-YGHxdmaPs2Ki00EZkRY,65200
 lifx/devices/ceiling.py,sha256=cmGeEyads2O5e2H2VBsk6n0An4dZtT59HQvN2F9b4gA,45771
 lifx/devices/hev.py,sha256=kTRJRYnWyIY8Pkg_jOn978N-_1YXy9fRmBiGgEWscXw,15194
 lifx/devices/infrared.py,sha256=ePk9qxX_s-hv5gQMvio1Vv8FYiCd68HF0ySbWgSrvuU,8130
-lifx/devices/light.py,sha256=ZhC7zuruZ9nzmnAR_st2KMUH8UNQAcNK-eQUYnKXm-8,33833
+lifx/devices/light.py,sha256=9yjmEeUqO4ATK6NaDMnlDzdddHlCouMlJcjotgCZzkI,35074
 lifx/devices/matrix.py,sha256=reB6cS2_cFe3qZKg584oCO-JGLbNTJDWwW9FZ0NLxq0,41693
 lifx/devices/multizone.py,sha256=7Te5Z_X9hDvdypjMqPGGM2TG0P9QltzFVi7UUxRdbGI,33326
 lifx/effects/__init__.py,sha256=4DF31yp7RJic5JoltMlz5dCtF5KQobU6NOUtLUKkVKE,1509
@@ -26,7 +26,7 @@ lifx/effects/models.py,sha256=MS5D-cxD0Ar8XhqbqKAc9q2sk38IP1vPkYwd8V7jCr8,2446
 lifx/effects/pulse.py,sha256=k4dtBhhgVHyuwzqzx89jYVKbSRUVQdZj91cklyKarbE,8455
 lifx/effects/state_manager.py,sha256=iDfYowiCN5IJqcR1s-pM0mQEJpe-RDsMcOOSMmtPVDE,8983
 lifx/network/__init__.py,sha256=uSyA8r8qISG7qXUHbX8uk9A2E8rvDADgCcf94QIZ9so,499
-lifx/network/connection.py,sha256=_DiXNKN80ki266gg2e4kTWvcPxgYQJPJJUP8nVC6woU,38454
+lifx/network/connection.py,sha256=XUPSHBkeR3cLVwglJWmPZqSYUTPoB5_kzRMJXBgzixs,39866
 lifx/network/discovery.py,sha256=J0B3yRkbZKx7g01CCIEnjv3gtqSORhmdTYQ6w0ea4WI,24178
 lifx/network/message.py,sha256=jCLC9v0tbBi54g5CaHLFM_nP1Izu8kJmo2tt23HHBbA,2600
 lifx/network/transport.py,sha256=EykhKmvjAcdiepgCxgzDTj8Fc0b7kAQdyR8AumGXohg,10953
@@ -41,9 +41,9 @@ lifx/products/generator.py,sha256=DsTCJcEVPmn9sfXSbXYdFZjqMfIbodnIQL46DRASs0g,15
 lifx/products/quirks.py,sha256=B8Kb4pxaXmovMbjgXRfPPWre5JEvJrn8d6PAWK_FT1U,2544
 lifx/products/registry.py,sha256=ILIJlQxcxJUzRH-LGU_bnHjV-TxDEucKovuJcWvG4q8,43831
 lifx/protocol/__init__.py,sha256=-wjC-wBcb7fxi5I-mJr2Ad8K2YRflJFdLLdobfD-W1Q,56
-lifx/protocol/base.py,sha256=x4cKT5sbaEmILbmPH3y5Lwk6gj3h9Xv_JvTX91cPQwM,12354
+lifx/protocol/base.py,sha256=xqO3qYpiSMY-_vcR6P2OEgITIbzm0AKRZs1yzOz7Y7M,13078
 lifx/protocol/generator.py,sha256=RWu4zC-b_JhonLM5fbAufQyKxEI2myLyCnt7tu3POMI,60690
-lifx/protocol/header.py,sha256=HaYQ5wEjAMgefO3dIxKb0w4VG4fLcfLj-fnHVwfp1ao,7174
+lifx/protocol/header.py,sha256=8KXe6C-T1XMyzepFV9fJ4_gsnO05HDk07XVtkwhiEU0,7076
 lifx/protocol/models.py,sha256=eOvOSAWbglR1SYWcC_YpicewtsdbVlQ6E2lfcC4NQrk,8172
 lifx/protocol/packets.py,sha256=ENp3irGITdV5rGah3eUzgsXqihI95upAPh7AdTsP7sk,43303
 lifx/protocol/protocol_types.py,sha256=m15A82zVrwAXomTqo-GfNmAIynVRDSV94UqHDkWgiJI,23781
@@ -53,7 +53,7 @@ lifx/theme/canvas.py,sha256=4h7lgN8iu_OdchObGDgbxTqQLCb-FRKC-M-YCWef_i4,8048
 lifx/theme/generators.py,sha256=nq3Yvntq_h-eFHbmmow3LcAdA_hEbRRaP5mv9Bydrjk,6435
 lifx/theme/library.py,sha256=tKlKZNqJp8lRGDnilWyDm_Qr1vCRGGwuvWVS82anNpQ,21326
 lifx/theme/theme.py,sha256=qMEx_8E41C0Cc6f083XHiAXEglTv4YlXW0UFsG1rQKg,5521
-lifx_async-5.1.0.dist-info/METADATA,sha256=bT9ZFTUQCHcsnPwdyskaOeOfBQ_HP71_e-6dvtGn6SE,2660
-lifx_async-5.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-lifx_async-5.1.0.dist-info/licenses/LICENSE,sha256=eBz48GRA3gSiWn3rYZAz2Ewp35snnhV9cSqkVBq7g3k,1832
-lifx_async-5.1.0.dist-info/RECORD,,
+lifx_async-5.1.1.dist-info/METADATA,sha256=Dd2gx4lZLL_JVddm3LeWwOgBWxm_JNAw1FkgWV0u6qw,2660
+lifx_async-5.1.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+lifx_async-5.1.1.dist-info/licenses/LICENSE,sha256=eBz48GRA3gSiWn3rYZAz2Ewp35snnhV9cSqkVBq7g3k,1832
+lifx_async-5.1.1.dist-info/RECORD,,