lifx-emulator-core 3.1.1__py3-none-any.whl → 3.3.0__py3-none-any.whl

lifx_emulator/devices/device.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import asyncio
 import copy
 import logging
+import random
 import time
 from typing import Any
 
@@ -269,10 +270,8 @@ class EmulatedLifxDevice:
                 state_unhandled.PKT_TYPE,
                 len(unhandled_payload),
             )
-            responses.append((unhandled_header, state_unhandled))
-
-            # Still send acknowledgment if requested
-            if header.ack_required:
+            # Send ack before StateUnhandled when scenario controls ack behavior
+            if header.ack_required and scenario.affects_acks:
                 ack_packet = Device.Acknowledgement()
                 ack_payload = ack_packet.pack()
                 ack_header = self._create_response_header(
@@ -281,15 +280,18 @@ class EmulatedLifxDevice:
                     ack_packet.PKT_TYPE,
                     len(ack_payload),
                 )
-                responses.append((ack_header, ack_packet))
+                responses.append((ack_header, ack_packet, ack_payload))
 
-            return responses
+            responses.append((unhandled_header, state_unhandled, unhandled_payload))
+            return self._apply_error_scenarios(responses, scenario)
 
         # Update uptime
         self.state.uptime_ns = self.get_uptime_ns()
 
         # Handle acknowledgment (packet type 45, no payload)
-        if header.ack_required:
+        # Only generate ack here when a scenario targets ack behavior;
+        # otherwise the server sends the ack immediately before calling us.
+        if header.ack_required and scenario.affects_acks:
             ack_packet = Device.Acknowledgement()
             ack_payload = ack_packet.pack()
             ack_header = self._create_response_header(
@@ -304,6 +306,24 @@ class EmulatedLifxDevice:
 
         # Handle specific packet types - handlers always return list
         response_packets = self._handle_packet_type(header, packet)
+
+        # Apply partial_responses: truncate multi-packet responses to random subset
+        if len(response_packets) > 1:
+            first_pkt = response_packets[0]
+            if (
+                hasattr(first_pkt, "PKT_TYPE")
+                and first_pkt.PKT_TYPE in scenario.partial_responses
+            ):
+                original_count = len(response_packets)
+                partial_count = random.randint(1, original_count - 1)  # nosec
+                response_packets = response_packets[:partial_count]
+                logger.info(
+                    "Sending partial response for packet type %s (%d of %d packets)",
+                    first_pkt.PKT_TYPE,
+                    partial_count,
+                    original_count,
+                )
+
         # Handlers now always return list (empty if no response)
         for resp_packet in response_packets:
             # Cache packed payload to avoid double packing (performance optimization)
@@ -317,16 +337,29 @@ class EmulatedLifxDevice:
             # Store both header and pre-packed payload for error scenario processing
             responses.append((resp_header, resp_packet, resp_payload))
 
-        # Apply error scenarios to responses
-        modified_responses = []
+        return self._apply_error_scenarios(responses, scenario)
+
+    def _apply_error_scenarios(
+        self,
+        responses: list[tuple],
+        scenario: ScenarioConfig,
+    ) -> list[tuple[LifxHeader, Any]]:
+        """Apply malformed/invalid-field error scenarios to response packets.
+
+        Args:
+            responses: List of (header, packet, payload) tuples
+            scenario: Resolved scenario config
+
+        Returns:
+            List of (header, packet) tuples with error scenarios applied
+        """
+        modified_responses: list[tuple[LifxHeader, Any]] = []
         for resp_header, resp_packet, resp_payload in responses:
             # Check if we should send malformed packet (truncate payload)
             if resp_header.pkt_type in scenario.malformed_packets:
-                # For malformed packets, truncate the pre-packed payload
                 truncated_len = len(resp_payload) // 2
                 resp_payload_modified = resp_payload[:truncated_len]
                 resp_header.size = LIFX_HEADER_SIZE + truncated_len + 10  # Wrong size
-                # Convert back to bytes for malformed case
                 modified_responses.append((resp_header, resp_payload_modified))
                 logger.info(
                     "Sending malformed packet type %s (truncated)", resp_header.pkt_type
@@ -335,7 +368,6 @@ class EmulatedLifxDevice:
 
             # Check if we should send invalid field values
             if resp_header.pkt_type in scenario.invalid_field_values:
-                # Corrupt the pre-packed payload
                 resp_payload_modified = b"\xff" * len(resp_payload)
                 modified_responses.append((resp_header, resp_payload_modified))
                 pkt_type = resp_header.pkt_type

lifx_emulator/handlers/multizone_handlers.py

@@ -124,22 +124,26 @@ class ExtendedGetColorZonesHandler(PacketHandler):
         if not device_state.has_multizone:
             return []
 
-        colors_count = min(82, len(device_state.zone_colors))
-        colors = []
-        for i in range(colors_count):
-            colors.append(device_state.zone_colors[i])
-        # Pad to 82 colors
-        while len(colors) < 82:
-            colors.append(LightHsbk(hue=0, saturation=0, brightness=0, kelvin=3500))
-
-        return [
-            MultiZone.ExtendedStateMultiZone(
-                count=device_state.zone_count,
-                index=0,
-                colors_count=colors_count,
-                colors=colors,
+        responses = []
+        index = 0
+        while index < device_state.zone_count:
+            end = min(index + 82, device_state.zone_count)
+            colors_count = end - index
+            colors = list(device_state.zone_colors[index:end])
+            # Pad to 82 colors
+            while len(colors) < 82:
+                colors.append(LightHsbk(hue=0, saturation=0, brightness=0, kelvin=3500))
+            responses.append(
+                MultiZone.ExtendedStateMultiZone(
+                    count=device_state.zone_count,
+                    index=index,
+                    colors_count=colors_count,
+                    colors=colors,
+                )
             )
-        ]
+            index += 82
+
+        return responses
 
 
 class ExtendedSetColorZonesHandler(PacketHandler):

lifx_emulator/handlers/tile_handlers.py

@@ -128,64 +128,71 @@ class Get64Handler(PacketHandler):
         if not device_state.has_matrix or not packet:
             return []
 
-        tile_index = packet.tile_index
         rect = packet.rect
+        length = max(1, packet.length)
 
-        if tile_index >= len(device_state.tile_devices):
-            return []
-
-        tile = device_state.tile_devices[tile_index]
-        tile_width = tile["width"]
-        tile_height = tile["height"]
-
-        # Get64 always returns framebuffer 0 (the visible buffer)
-        # regardless of which fb_index is in the request
-        tile_colors = tile["colors"]
-
-        # Calculate how many rows fit in 64 zones
-        rows_to_return = 64 // rect.width if rect.width > 0 else 1
-        rows_to_return = min(rows_to_return, tile_height - rect.y)
-
-        # Extract colors from the requested rectangle
-        colors = []
-        zones_extracted = 0
-
-        for row in range(rows_to_return):
-            y = rect.y + row
-            if y >= tile_height:
+        responses = []
+        for i in range(length):
+            idx = packet.tile_index + i
+            if idx >= len(device_state.tile_devices):
                 break
 
-            for col in range(rect.width):
-                x = rect.x + col
-                if x >= tile_width or zones_extracted >= 64:
-                    colors.append(
-                        LightHsbk(hue=0, saturation=0, brightness=0, kelvin=3500)
-                    )
+            tile = device_state.tile_devices[idx]
+            tile_width = tile["width"]
+            tile_height = tile["height"]
+
+            # Get64 always returns framebuffer 0 (the visible buffer)
+            # regardless of which fb_index is in the request
+            tile_colors = tile["colors"]
+
+            # Calculate how many rows fit in 64 zones
+            rows_to_return = 64 // rect.width if rect.width > 0 else 1
+            rows_to_return = min(rows_to_return, tile_height - rect.y)
+
+            # Extract colors from the requested rectangle
+            colors = []
+            zones_extracted = 0
+
+            for row in range(rows_to_return):
+                y = rect.y + row
+                if y >= tile_height:
+                    break
+
+                for col in range(rect.width):
+                    x = rect.x + col
+                    if x >= tile_width or zones_extracted >= 64:
+                        colors.append(
+                            LightHsbk(hue=0, saturation=0, brightness=0, kelvin=3500)
+                        )
+                        zones_extracted += 1
+                        continue
+
+                    # Calculate zone index in flat color array
+                    zone_idx = y * tile_width + x
+                    if zone_idx < len(tile_colors):
+                        colors.append(tile_colors[zone_idx])
+                    else:
+                        colors.append(
+                            LightHsbk(hue=0, saturation=0, brightness=0, kelvin=3500)
+                        )
                     zones_extracted += 1
-                    continue
 
-                # Calculate zone index in flat color array
-                zone_idx = y * tile_width + x
-                if zone_idx < len(tile_colors):
-                    colors.append(tile_colors[zone_idx])
-                else:
-                    colors.append(
-                        LightHsbk(hue=0, saturation=0, brightness=0, kelvin=3500)
-                    )
-                zones_extracted += 1
-
-        # Pad to exactly 64 colors
-        while len(colors) < 64:
-            colors.append(LightHsbk(hue=0, saturation=0, brightness=0, kelvin=3500))
-
-        # Return with fb_index forced to 0 (visible buffer)
-        return_rect = TileBufferRect(
-            fb_index=0,  # Always return FB0
-            x=rect.x,
-            y=rect.y,
-            width=rect.width,
-        )
-        return [Tile.State64(tile_index=tile_index, rect=return_rect, colors=colors)]
+            # Pad to exactly 64 colors
+            while len(colors) < 64:
+                colors.append(LightHsbk(hue=0, saturation=0, brightness=0, kelvin=3500))
+
+            # Return with fb_index forced to 0 (visible buffer)
+            return_rect = TileBufferRect(
+                fb_index=0,  # Always return FB0
+                x=rect.x,
+                y=rect.y,
+                width=rect.width,
+            )
+            responses.append(
+                Tile.State64(tile_index=idx, rect=return_rect, colors=colors)
+            )
+
+        return responses
 
 
 class Set64Handler(PacketHandler):

lifx_emulator/scenarios/models.py

@@ -6,6 +6,8 @@ of the application (domain, API, persistence, etc.).
 
 from pydantic import BaseModel, Field, field_validator
 
+ACK_PACKET_TYPE = 45
+
 
 class ScenarioConfig(BaseModel):
     """Scenario configuration for testing LIFX protocol behavior.
@@ -52,6 +54,16 @@ class ScenarioConfig(BaseModel):
         False, description="Send unhandled message responses for unknown packet types"
     )
 
+    @property
+    def affects_acks(self) -> bool:
+        """Whether this scenario configuration modifies acknowledgment behavior."""
+        return (
+            ACK_PACKET_TYPE in self.drop_packets
+            or ACK_PACKET_TYPE in self.response_delays
+            or ACK_PACKET_TYPE in self.malformed_packets
+            or ACK_PACKET_TYPE in self.invalid_field_values
+        )
+
     @field_validator("drop_packets", mode="before")
     @classmethod
     def convert_drop_packets_keys(cls, v):

lifx_emulator/server.py

@@ -18,7 +18,7 @@ from lifx_emulator.devices import (
     PacketEvent,
 )
 from lifx_emulator.protocol.header import LifxHeader
-from lifx_emulator.protocol.packets import get_packet_class
+from lifx_emulator.protocol.packets import Device, get_packet_class
 from lifx_emulator.repositories import IScenarioStorageBackend
 from lifx_emulator.scenarios import HierarchicalScenarioManager
 
@@ -179,6 +179,54 @@ class EmulatedLifxServer:
                 # Fallback for edge case where loop not yet cached
                 asyncio.create_task(self.server.handle_packet(data, addr))
 
+    def _send_ack(
+        self,
+        device: EmulatedLifxDevice,
+        header: LifxHeader,
+        addr: tuple[str, int],
+    ) -> None:
+        """Send an acknowledgment packet immediately via UDP.
+
+        Args:
+            device: The device acknowledging the packet
+            header: Request header (source/sequence are copied)
+            addr: Client address (host, port)
+        """
+        ack_packet = Device.Acknowledgement()
+        ack_payload = ack_packet.pack()
+        ack_header = device._create_response_header(
+            header.source,
+            header.sequence,
+            ack_packet.PKT_TYPE,
+            len(ack_payload),
+        )
+        response_data = ack_header.pack() + ack_payload
+        if self.transport:
+            self.transport.sendto(response_data, addr)
+
+        self.packets_sent += 1
+        self.packets_sent_by_type[ack_header.pkt_type] += 1
+
+        logger.debug(
+            "→ TX %s to %s:%s (target=%s, seq=%s) [no fields]",
+            _get_packet_type_name(ack_header.pkt_type),
+            addr[0],
+            addr[1],
+            device.state.serial,
+            ack_header.sequence,
+        )
+
+        self.activity_observer.on_packet_sent(
+            PacketEvent(
+                timestamp=time.time(),
+                direction="tx",
+                packet_type=ack_header.pkt_type,
+                packet_name=_get_packet_type_name(ack_header.pkt_type),
+                addr=f"{addr[0]}:{addr[1]}",
+                device=device.state.serial,
+            )
+        )
+
     async def _process_device_packet(
         self,
         device: EmulatedLifxDevice,
@@ -194,10 +242,13 @@ class EmulatedLifxServer:
             packet: Parsed packet payload (or None)
             addr: Client address (host, port)
         """
-        responses = device.process_packet(header, packet)
-
-        # Get resolved scenario for response delays
+        # Send ack immediately before device processing when no scenario
+        # targets ack behavior (fast path for the common case)
         scenario = device._get_resolved_scenario()
+        if header.ack_required and not scenario.affects_acks:
+            self._send_ack(device, header, addr)
+
+        responses = device.process_packet(header, packet)
 
         # Send responses with delay if configured
         for resp_header, resp_packet in responses:

{lifx_emulator_core-3.1.1.dist-info → lifx_emulator_core-3.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lifx-emulator-core
-Version: 3.1.1
+Version: 3.3.0
 Summary: Core LIFX Emulator library for testing LIFX LAN protocol libraries
 Author-email: Avi Miller <me@dje.li>
 Maintainer-email: Avi Miller <me@dje.li>

{lifx_emulator_core-3.1.1.dist-info → lifx_emulator_core-3.3.0.dist-info}/RECORD

@@ -1,8 +1,8 @@
 lifx_emulator/__init__.py,sha256=SSnQg0RiCaID7DhHOGZoVIDQ3_8Lyt0J9cA_2StF63s,824
 lifx_emulator/constants.py,sha256=DFZkUsdewE-x_3MgO28tMGkjUCWPeYc3xLj_EXViGOw,1032
-lifx_emulator/server.py,sha256=Fc0AiSeJ43XnF1MMTqWBkeYIW-KOhZpqNp0Y2x4RqEE,16622
+lifx_emulator/server.py,sha256=x-RDfxwmzUfSSROfBzVm2LcGK68sVIM4o7IkcgzkSfI,18363
 lifx_emulator/devices/__init__.py,sha256=QlBTPnFErJcSKLvGyeDwemh7xcpjYvB_L5siKsjr3s8,1089
-lifx_emulator/devices/device.py,sha256=yEOXc_xr1X45bJzG2qB-A-oIHwnA8qqYlIsFialobGc,15780
+lifx_emulator/devices/device.py,sha256=w7Y9VYux3cyGus9mFmruFn6WYtoD7zwhzCL2xrICY-Q,17180
 lifx_emulator/devices/manager.py,sha256=XDrT82um5sgNpNihLj5RsNvHqdVI1bK9YY2eBzWIcf0,8162
 lifx_emulator/devices/observers.py,sha256=-KnUgFcKdhlNo7CNVstP-u0wU2W0JAGg055ZPV15Sj0,3874
 lifx_emulator/devices/persistence.py,sha256=9Mhj46-xrweOmyzjORCi2jKIwa8XJWpQ5CgaKcw6U98,10513
@@ -19,9 +19,9 @@ lifx_emulator/handlers/__init__.py,sha256=3Hj1hRo3yL3E7GKwG9TaYh33ymk_N3bRiQ8nvq
 lifx_emulator/handlers/base.py,sha256=0avCLXY_rNlw16PpJ5JrRCwXNE4uMpBqF3PfSfNJ0b8,1654
 lifx_emulator/handlers/device_handlers.py,sha256=1AmslA4Ut6L7b3SfduDdvnQizTpzUB3KKWBXmp4WYLQ,9462
 lifx_emulator/handlers/light_handlers.py,sha256=255aoiIjSIL63kbHQa6wqUpEwFzFFx7SG6P1nWM9jgU,17769
-lifx_emulator/handlers/multizone_handlers.py,sha256=2dYsitq0KzEaxEAJmz7ixtir1tvFMOAnfkBQqslqbPM,7914
+lifx_emulator/handlers/multizone_handlers.py,sha256=ypv9G7od2bdQc7plRb38hyPyd02ugiMsinUHKCB2cdM,8094
 lifx_emulator/handlers/registry.py,sha256=s1ht4PmPhXhAcwu1hoY4yW39wy3SPJBMY-9Uxd0FWuE,3292
-lifx_emulator/handlers/tile_handlers.py,sha256=L4fNKGTSSIxRuqKrfDrMSrNPvDJr3aIuaEqbhRCOt04,17176
+lifx_emulator/handlers/tile_handlers.py,sha256=TRrXfq1L-1WR35dhYMv3_GE-8pDX9yrYDHZUGbBNlSE,17495
 lifx_emulator/products/__init__.py,sha256=qcNop_kRYFF3zSjNemzQEgu3jPrIxfyQyLv9GsnaLEI,627
 lifx_emulator/products/generator.py,sha256=fvrhw_b7shLCtEtUFxWF5VBEQAeSrsaiXxoGIP5Vn4g,34675
 lifx_emulator/products/registry.py,sha256=1SZ3fXVFFL8jhKYIZBqwtIQDN3qL1Lvf86P3N1_Kdx8,47323
@@ -40,8 +40,8 @@ lifx_emulator/repositories/device_repository.py,sha256=KsXVg2sg7PGSTsK_PvDYeHHwE
 lifx_emulator/repositories/storage_backend.py,sha256=wEgjhnBvAxl6aO1ZGL3ou0dW9P2hBPnK8jEE03sOlL4,3264
 lifx_emulator/scenarios/__init__.py,sha256=CGjudoWvyysvFj2xej11N2cr3mYROGtRb9zVHcOHGrQ,665
 lifx_emulator/scenarios/manager.py,sha256=1esxRdz74UynNk1wb86MGZ2ZFAuMzByuu74nRe3D-Og,11163
-lifx_emulator/scenarios/models.py,sha256=BKS_fGvrbkGe-vK3arZ0w2f9adS1UZhiOoKpu7GENnc,4099
+lifx_emulator/scenarios/models.py,sha256=1cX399JcTYVo29-8Rc4BwYPRty7sMR4fcn0njGfspZg,4504
 lifx_emulator/scenarios/persistence.py,sha256=3vjtPNFYfag38tUxuqxkGpWhQ7uBitc1rLroSAuw9N8,8881
-lifx_emulator_core-3.1.1.dist-info/METADATA,sha256=R36u6hulOrRLCHQH9Zod87RRgmiupFoFEyEGlQE9WzE,3217
-lifx_emulator_core-3.1.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-lifx_emulator_core-3.1.1.dist-info/RECORD,,
+lifx_emulator_core-3.3.0.dist-info/METADATA,sha256=JtFPPtM9n0gsUawt_SHBvR_d67384-wheXW8viWc5Vc,3217
+lifx_emulator_core-3.3.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+lifx_emulator_core-3.3.0.dist-info/RECORD,,