lifx-emulator-core 3.1.1__tar.gz → 3.3.0__tar.gz

{lifx_emulator_core-3.1.1 → lifx_emulator_core-3.3.0}/.gitignore

@@ -92,3 +92,4 @@ Thumbs.db
 # Local storage
 .notes/
 .claude/settings.local.json
+.envrc

{lifx_emulator_core-3.1.1 → lifx_emulator_core-3.3.0}/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 <!-- version list -->
 
+## v3.3.0 (2026-02-03)
+
+### Bug Fixes
+
+- **device**: Apply error scenarios to unhandled-packet responses
+  ([`7571ab7`](https://github.com/Djelibeybi/lifx-emulator/commit/7571ab7a9d9833c1b79e0941d0d348c82ebcf34c))
+
+### Features
+
+- **server**: Send acks immediately before device processing
+  ([`3d4ec66`](https://github.com/Djelibeybi/lifx-emulator/commit/3d4ec66388099d2b672483cf85d47f100fe67549))
+
+
+## v3.2.0 (2026-02-02)
+
+### Bug Fixes
+
+- **tests**: Replace flaky probabilistic drop rate tests with deterministic mocks
+  ([`5070d6e`](https://github.com/Djelibeybi/lifx-emulator/commit/5070d6e88495dfeffaffb8f54f6eb5e6098d0f43))
+
+### Features
+
+- **core**: Wire partial_responses scenario through packet handlers
+  ([`a799dba`](https://github.com/Djelibeybi/lifx-emulator/commit/a799dba3f2d04501dd5b0694359e3e71e2ed5bbb))
+
+
 ## v3.1.1 (2026-02-01)
 
 ### Bug Fixes

{lifx_emulator_core-3.1.1 → lifx_emulator_core-3.3.0}/PKG-INFO

@@ -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 → lifx_emulator_core-3.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lifx-emulator-core"
-version = "3.1.1"
+version = "3.3.0"
 description = "Core LIFX Emulator library for testing LIFX LAN protocol libraries"
 readme = "README.md"
 requires-python = ">=3.10"

{lifx_emulator_core-3.1.1 → lifx_emulator_core-3.3.0}/src/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_core-3.1.1 → lifx_emulator_core-3.3.0}/src/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_core-3.1.1 → lifx_emulator_core-3.3.0}/src/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_core-3.1.1 → lifx_emulator_core-3.3.0}/src/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_core-3.1.1 → lifx_emulator_core-3.3.0}/src/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 → lifx_emulator_core-3.3.0}/tests/test_device.py

@@ -503,8 +503,12 @@ class TestTileHandlers:
 class TestAcknowledgment:
     """Test acknowledgment packet generation."""
 
-    def test_ack_required_generates_acknowledgment(self, color_device):
-        """Test ack_required flag generates Acknowledgement packet."""
+    def test_ack_not_generated_without_scenario(self, color_device):
+        """Test process_packet does not include ack when no scenario targets acks.
+
+        The server sends acks immediately before calling process_packet,
+        so the device should not include one in its response list.
+        """
         header = LifxHeader(
             source=12345,
             target=color_device.state.get_target_bytes(),
@@ -516,14 +520,75 @@ class TestAcknowledgment:
 
         responses = color_device.process_packet(header, None)
 
-        # Should have at least 2 responses: ACK + StatePower
+        # Should only have StatePower, no ACK (server handles ack)
+        assert len(responses) == 1
+        resp_header, resp_packet = responses[0]
+        assert resp_header.pkt_type == 22  # StatePower
+
+    def test_ack_generated_when_scenario_affects_acks(self, color_device):
+        """Test process_packet includes ack when scenario targets ack behavior."""
+        from lifx_emulator.scenarios import HierarchicalScenarioManager, ScenarioConfig
+
+        scenario_manager = HierarchicalScenarioManager()
+        scenario_manager.set_device_scenario(
+            color_device.state.serial,
+            ScenarioConfig(response_delays={45: 1.0}),
+        )
+        color_device.scenario_manager = scenario_manager
+        color_device.invalidate_scenario_cache()
+
+        header = LifxHeader(
+            source=12345,
+            target=color_device.state.get_target_bytes(),
+            sequence=1,
+            pkt_type=20,  # GetPower
+            ack_required=True,
+            res_required=True,
+        )
+
+        responses = color_device.process_packet(header, None)
+
+        # Should have ACK + StatePower
         assert len(responses) >= 2
+        ack_header, ack_packet = responses[0]
+        assert ack_header.pkt_type == 45
+        assert isinstance(ack_packet, Device.Acknowledgement)
+
+    def test_ack_generated_for_unhandled_packet_when_scenario_affects_acks(
+        self, color_device
+    ):
+        """Test ACK included for unsupported packets when scenario targets acks."""
+        from lifx_emulator.scenarios import HierarchicalScenarioManager, ScenarioConfig
+
+        scenario_manager = HierarchicalScenarioManager()
+        scenario_manager.set_device_scenario(
+            color_device.state.serial,
+            ScenarioConfig(response_delays={45: 1.0}),
+        )
+        color_device.scenario_manager = scenario_manager
+        color_device.invalidate_scenario_cache()
+
+        header = LifxHeader(
+            source=12345,
+            target=color_device.state.get_target_bytes(),
+            sequence=1,
+            pkt_type=501,  # MultiZone.GetColorZones — unsupported on color device
+            ack_required=True,
+            res_required=True,
+        )
+
+        responses = color_device.process_packet(header, None)
 
-        # First response should be ACK
+        # Should have ACK followed by StateUnhandled
+        assert len(responses) == 2
         ack_header, ack_packet = responses[0]
         assert ack_header.pkt_type == 45
         assert isinstance(ack_packet, Device.Acknowledgement)
 
+        unhandled_header, unhandled_packet = responses[1]
+        assert unhandled_header.pkt_type == 223  # StateUnhandled
+        assert unhandled_packet.unhandled_type == 501
+
     def test_no_ack_when_not_required(self, color_device):
         """Test no ACK when ack_required is False."""
         header = LifxHeader(