lifx-emulator 2.3.0__py3-none-any.whl → 2.4.0__py3-none-any.whl

lifx_emulator/__main__.py

@@ -21,6 +21,7 @@ from lifx_emulator.factories import (
     create_hev_light,
     create_infrared_light,
     create_multizone_light,
+    create_switch,
     create_tile_device,
 )
 from lifx_emulator.products.registry import get_registry
@@ -239,6 +240,7 @@ async def run(
     hev: Annotated[int, cyclopts.Parameter(group=device_group)] = 0,
     multizone: Annotated[int, cyclopts.Parameter(group=device_group)] = 0,
     tile: Annotated[int, cyclopts.Parameter(group=device_group)] = 0,
+    switch: Annotated[int, cyclopts.Parameter(group=device_group)] = 0,
     # Multizone Options
     multizone_zones: Annotated[
         int | None, cyclopts.Parameter(group=multizone_group)
@@ -284,11 +286,12 @@ async def run(
         multizone_extended: Enable extended multizone support (Beam).
             Set --no-multizone-extended for basic multizone (Z) devices.
         tile: Number of tile/matrix chain devices.
+        switch: Number of LIFX Switch devices (relays, no lighting).
         tile_count: Number of tiles per device. Uses product defaults if not
             specified (5 for Tile, 1 for Candle/Ceiling).
-        tile_width: Width of each tile in pixels. Uses product defaults if not
+        tile_width: Width of each tile in zones. Uses product defaults if not
             specified (8 for most devices).
-        tile_height: Height of each tile in pixels. Uses product defaults if
+        tile_height: Height of each tile in zones. Uses product defaults if
             not specified (8 for most devices).
         serial_prefix: Serial number prefix as 6 hex characters.
         serial_start: Starting serial suffix for auto-incrementing device serials.
@@ -310,7 +313,7 @@ async def run(
             lifx-emulator --color 2 --multizone 1 --tile 1 --api --verbose
 
         Create only specific device types:
-            lifx-emulator --color 0 --infrared 3 --hev 2
+            lifx-emulator --color 0 --infrared 3 --hev 2 --switch 2
 
         Custom serial prefix:
             lifx-emulator --serial-prefix cafe00 --color 5
@@ -410,6 +413,7 @@ async def run(
                 and infrared == 0
                 and hev == 0
                 and multizone == 0
+                and switch == 0
             ):
                 color = 0
 
@@ -423,6 +427,7 @@ async def run(
             and hev == 0
             and multizone == 0
             and tile == 0
+            and switch == 0
         ):
             color = 0
 
@@ -467,13 +472,17 @@ async def run(
                 )
             )
 
+        # Create switch devices
+        for _ in range(switch):
+            devices.append(create_switch(get_serial(), storage=storage))
+
     if not devices:
         if persistent:
             logger.warning("No devices configured. Server will run with no devices.")
             logger.info("Use API (--api) or restart with device flags to add devices.")
         else:
             logger.error(
-                "No devices configured. Use --color, --multizone, --tile, "
+                "No devices configured. Use --color, --multizone, --tile, --switch, "
                 "etc. to add devices."
             )
             return

lifx_emulator/api/models.py

@@ -25,10 +25,10 @@ class DeviceCreateRequest(BaseModel):
         None, description="Number of tiles for matrix devices", ge=0, le=100
     )
     tile_width: int | None = Field(
-        None, description="Width of each tile in pixels", ge=1, le=256
+        None, description="Width of each tile in zones", ge=1, le=256
     )
     tile_height: int | None = Field(
-        None, description="Height of each tile in pixels", ge=1, le=256
+        None, description="Height of each tile in zones", ge=1, le=256
     )
     firmware_major: int | None = Field(
         None, description="Firmware major version", ge=0, le=255

lifx_emulator/api/templates/dashboard.html

@@ -163,7 +163,7 @@
             gap: 2px;
             margin-top: 4px;
         }
-        .tile-pixel {
+        .tile-zone {
             width: 8px;
             height: 8px;
             border-radius: 1px;
@@ -644,7 +644,7 @@
                     `;
                 } else if (dev.has_matrix && dev.tile_devices &&
                            dev.tile_devices.length > 0) {
-                    // Render actual tile pixels
+                    // Render actual tile zones
                     const tilesHtml = dev.tile_devices.map((tile, tileIndex) => {
                         if (!tile.colors || tile.colors.length === 0) {
                             return '<div style="color: #666;">No color data</div>';
@@ -652,14 +652,14 @@
 
                         const width = tile.width || 8;
                         const height = tile.height || 8;
-                        const totalPixels = width * height;
+                        const totalzones = width * height;
 
-                        // Create grid of pixels
-                        const slicedColors = tile.colors.slice(0, totalPixels);
-                        const pixelsHtml = slicedColors.map(color => {
+                        // Create grid of zones
+                        const slicedColors = tile.colors.slice(0, totalzones);
+                        const zonesHtml = slicedColors.map(color => {
                             const rgb = hsbkToRgb(color);
                             const bgStyle = `background: ${rgb};`;
-                            return `<div class="tile-pixel" style="${bgStyle}"></div>`;
+                            return `<div class="tile-zone" style="${bgStyle}"></div>`;
                         }).join('');
 
                         const labelStyle = (
@@ -675,7 +675,7 @@
                                     T${tileIndex + 1}
                                 </div>
                                 <div class="tile-grid" style="${gridStyle}">
-                                    ${pixelsHtml}
+                                    ${zonesHtml}
                                 </div>
                             </div>
                         `;

lifx_emulator/devices/device.py

@@ -90,10 +90,10 @@ class EmulatedLifxDevice:
         if self.state.has_matrix and self.state.tile_count > 0:
             if not self.state.tile_devices:
                 for i in range(self.state.tile_count):
-                    pixels = self.state.tile_width * self.state.tile_height
+                    zones = self.state.tile_width * self.state.tile_height
                     tile_colors = [
                         LightHsbk(hue=0, saturation=0, brightness=32768, kelvin=3500)
-                        for _ in range(pixels)
+                        for _ in range(zones)
                     ]
 
                     self.state.tile_devices.append(
@@ -215,6 +215,35 @@ class EmulatedLifxDevice:
         header.size = LIFX_HEADER_SIZE + payload_size
         return header
 
+    def _should_handle_packet(self, pkt_type: int) -> bool:
+        """Check if device should handle a packet type based on capabilities.
+
+        Args:
+            pkt_type: Packet type number
+
+        Returns:
+            True if device should handle, False if should return StateUnhandled
+        """
+        # Device.* packets are always handled (2-59)
+        if 2 <= pkt_type <= 59:
+            return True
+
+        # Light.* packets (101-149) require light capabilities
+        # Switches (devices with relays) don't support light operations
+        if 101 <= pkt_type <= 149:
+            return not self.state.has_relays
+
+        # MultiZone.* packets (501-512) require multizone capability
+        if 501 <= pkt_type <= 512:
+            return self.state.has_multizone
+
+        # Tile.* packets (701-720) require matrix capability
+        if 701 <= pkt_type <= 720:
+            return self.state.has_matrix
+
+        # Unknown packets - let handler decide
+        return True
+
     def process_packet(
         self, header: LifxHeader, packet: Any | None
     ) -> list[tuple[LifxHeader, Any]]:
@@ -229,6 +258,33 @@ class EmulatedLifxDevice:
             logger.info("Dropping packet type %s per scenario", header.pkt_type)
             return responses
 
+        # Check if device should handle this packet type (capability-based filtering)
+        if not self._should_handle_packet(header.pkt_type):
+            # Return StateUnhandled for unsupported packet types
+            state_unhandled = Device.StateUnhandled(unhandled_type=header.pkt_type)
+            unhandled_payload = state_unhandled.pack()
+            unhandled_header = self._create_response_header(
+                header.source,
+                header.sequence,
+                state_unhandled.PKT_TYPE,
+                len(unhandled_payload),
+            )
+            responses.append((unhandled_header, state_unhandled))
+
+            # Still send acknowledgment if requested
+            if header.ack_required:
+                ack_packet = Device.Acknowledgement()
+                ack_payload = ack_packet.pack()
+                ack_header = self._create_response_header(
+                    header.source,
+                    header.sequence,
+                    ack_packet.PKT_TYPE,
+                    len(ack_payload),
+                )
+                responses.append((ack_header, ack_packet))
+
+            return responses
+
         # Update uptime
         self.state.uptime_ns = self.get_uptime_ns()
 

lifx_emulator/devices/states.py

@@ -100,10 +100,10 @@ class TileFramebuffers:
         """Get framebuffer by index, creating it if needed."""
         if fb_index not in self.framebuffers:
             # Initialize with default black color
-            pixels = width * height
+            zones = width * height
             self.framebuffers[fb_index] = [
                 LightHsbk(hue=0, saturation=0, brightness=0, kelvin=3500)
-                for _ in range(pixels)
+                for _ in range(zones)
             ]
         return self.framebuffers[fb_index]
 
@@ -183,6 +183,8 @@ class DeviceState:
     has_extended_multizone: bool = False
     has_matrix: bool = False
     has_hev: bool = False
+    has_relays: bool = False
+    has_buttons: bool = False
 
     # Attribute routing map: maps attribute prefixes to state objects
     # This eliminates ~360 lines of property boilerplate
@@ -347,6 +349,8 @@ class DeviceState:
             "has_extended_multizone",
             "has_matrix",
             "has_hev",
+            "has_relays",
+            "has_buttons",
         } or name.startswith("_"):
             object.__setattr__(self, name, value)
             return

lifx_emulator/factories/__init__.py

@@ -15,6 +15,7 @@ from lifx_emulator.factories.factory import (
     create_hev_light,
     create_infrared_light,
     create_multizone_light,
+    create_switch,
     create_tile_device,
 )
 from lifx_emulator.factories.firmware_config import FirmwareConfig
@@ -32,6 +33,7 @@ __all__ = [
     "create_infrared_light",
     "create_hev_light",
     "create_multizone_light",
+    "create_switch",
     "create_tile_device",
     "create_color_temperature_light",
 ]

lifx_emulator/factories/builder.py

@@ -136,8 +136,8 @@ class DeviceBuilder:
         """Set tile dimensions for matrix devices.
 
         Args:
-            width: Tile width in pixels
-            height: Tile height in pixels
+            width: Tile width in zones
+            height: Tile height in zones
 
         Returns:
             Self for method chaining
@@ -257,6 +257,8 @@ class DeviceBuilder:
             has_extended_multizone=has_extended_multizone,
             has_matrix=self._product_info.has_matrix,
             has_hev=self._product_info.has_hev,
+            has_relays=self._product_info.has_relays,
+            has_buttons=self._product_info.has_buttons,
         )
 
         # 10. Restore saved state if persistence enabled

lifx_emulator/factories/factory.py

@@ -104,8 +104,8 @@ def create_tile_device(
     Args:
         serial: Optional serial
         tile_count: Optional tile count (uses product default)
-        tile_width: Optional tile width in pixels (uses product default)
-        tile_height: Optional tile height in pixels (uses product default)
+        tile_width: Optional tile width in zones (uses product default)
+        tile_height: Optional tile height in zones (uses product default)
         firmware_version: Optional firmware version tuple (major, minor)
         storage: Optional storage for persistence
         scenario_manager: Optional scenario manager
@@ -141,6 +141,37 @@ def create_color_temperature_light(
     )  # LIFX Mini White to Warm
 
 
+def create_switch(
+    serial: str | None = None,
+    product_id: int = 70,
+    firmware_version: tuple[int, int] | None = None,
+    storage: DevicePersistenceAsyncFile | None = None,
+    scenario_manager: HierarchicalScenarioManager | None = None,
+) -> EmulatedLifxDevice:
+    """Create a LIFX Switch device.
+
+    Switches have has_relays and has_buttons capabilities but no lighting.
+    They respond with StateUnhandled (223) to Light, MultiZone, and Tile packets.
+
+    Args:
+        serial: Device serial number (auto-generated if None)
+        product_id: Switch product ID (default: 70 - LIFX Switch)
+        firmware_version: Optional firmware version (major, minor)
+        storage: Optional persistence backend
+        scenario_manager: Optional scenario manager for testing
+
+    Returns:
+        EmulatedLifxDevice configured as a switch
+    """
+    return create_device(
+        product_id,
+        serial=serial,
+        firmware_version=firmware_version,
+        storage=storage,
+        scenario_manager=scenario_manager,
+    )
+
+
 def create_device(
     product_id: int,
     serial: str | None = None,
@@ -164,8 +195,8 @@ def create_device(
         zone_count: Number of zones for multizone devices (auto-determined)
         extended_multizone: Enable extended multizone requests
         tile_count: Number of tiles for matrix devices (default: 5)
-        tile_width: Width of each tile in pixels (default: 8)
-        tile_height: Height of each tile in pixels (default: 8)
+        tile_width: Width of each tile in zones (default: 8)
+        tile_height: Height of each tile in zones (default: 8)
         firmware_version: Optional firmware version tuple (major, minor).
                          If not specified, uses 3.70 for extended_multizone
                          or 2.60 otherwise

lifx_emulator/handlers/light_handlers.py

@@ -7,7 +7,7 @@ from typing import TYPE_CHECKING, Any
 
 from lifx_emulator.handlers.base import PacketHandler
 from lifx_emulator.protocol.packets import Light
-from lifx_emulator.protocol.protocol_types import LightLastHevCycleResult
+from lifx_emulator.protocol.protocol_types import LightHsbk, LightLastHevCycleResult
 
 if TYPE_CHECKING:
     from lifx_emulator.devices import DeviceState
@@ -15,6 +15,72 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
+def _compute_average_color(colors: list[LightHsbk]) -> LightHsbk:
+    """Compute average HSBK color from a list of LightHsbk colors.
+
+    Uses circular mean for hue to correctly handle hue wraparound
+    (e.g., average of 10° and 350° is 0°, not 180°).
+
+    Args:
+        colors: List of LightHsbk colors to average
+
+    Returns:
+        LightHsbk with averaged values using circular mean for hue
+    """
+    import math
+
+    if not colors:
+        return LightHsbk(hue=0, saturation=0, brightness=0, kelvin=3500)
+
+    # Convert uint16 values to proper ranges and calculate circular mean
+    hue_x_total = 0.0
+    hue_y_total = 0.0
+    saturation_total = 0.0
+    brightness_total = 0.0
+    kelvin_total = 0
+
+    for color in colors:
+        # Convert uint16 hue (0-65535) to degrees (0-360)
+        hue_deg = round(float(color.hue) * 360 / 0x10000, 2)
+
+        # Convert uint16 sat/bright (0-65535) to float (0-1)
+        sat_float = round(float(color.saturation) / 0xFFFF, 4)
+        bright_float = round(float(color.brightness) / 0xFFFF, 4)
+
+        # Circular mean calculation for hue using sin/cos
+        hue_x_total += math.sin(hue_deg * 2.0 * math.pi / 360)
+        hue_y_total += math.cos(hue_deg * 2.0 * math.pi / 360)
+
+        # Regular sums for other components
+        saturation_total += sat_float
+        brightness_total += bright_float
+        kelvin_total += color.kelvin
+
+    # Calculate circular mean for hue
+    hue = math.atan2(hue_x_total, hue_y_total) / (2.0 * math.pi)
+    if hue < 0.0:
+        hue += 1.0
+    hue *= 360
+    hue = round(hue, 4)
+
+    # Calculate arithmetic means for other components
+    saturation = round(saturation_total / len(colors), 4)
+    brightness = round(brightness_total / len(colors), 4)
+    kelvin = round(kelvin_total / len(colors))
+
+    # Convert back to uint16 values
+    uint16_hue = int(round(0x10000 * hue) / 360) % 0x10000
+    uint16_saturation = int(round(0xFFFF * saturation))
+    uint16_brightness = int(round(0xFFFF * brightness))
+
+    return LightHsbk(
+        hue=uint16_hue,
+        saturation=uint16_saturation,
+        brightness=uint16_brightness,
+        kelvin=kelvin,
+    )
+
+
 class GetColorHandler(PacketHandler):
     """Handle LightGet (101) -> LightState (107)."""
 
@@ -23,9 +89,24 @@ class GetColorHandler(PacketHandler):
     def handle(
         self, device_state: DeviceState, packet: Any | None, res_required: bool
     ) -> list[Any]:
+        # For multizone/matrix devices, compute average color from all zones
+        # This provides backwards compatibility with clients that don't use
+        # zone-specific or tile-specific packets
+        color_to_return = device_state.color
+
+        if device_state.has_multizone and device_state.zone_colors:
+            # Return average of all zone colors
+            color_to_return = _compute_average_color(device_state.zone_colors)
+        elif device_state.has_matrix and device_state.tile_devices:
+            # Collect all zone colors from all tiles
+            all_zones = []
+            for tile in device_state.tile_devices:
+                all_zones.extend(tile["colors"])
+            color_to_return = _compute_average_color(all_zones)
+
         return [
             Light.StateColor(
-                color=device_state.color,
+                color=color_to_return,
                 power=device_state.power_level,
                 label=device_state.label,
             )
@@ -46,10 +127,36 @@ class SetColorHandler(PacketHandler):
         if packet:
             device_state.color = packet.color
             c = packet.color
-            logger.info(
-                f"Color set to HSBK({c.hue}, {c.saturation}, "
-                f"{c.brightness}, {c.kelvin}), duration={packet.duration}ms"
-            )
+
+            # For backwards compatibility: propagate color to all zones
+            # Multizone devices: update all zone colors
+            if device_state.has_multizone and device_state.zone_colors:
+                for i in range(len(device_state.zone_colors)):
+                    device_state.zone_colors[i] = packet.color
+                logger.info(
+                    f"Color set to HSBK({c.hue}, {c.saturation}, "
+                    f"{c.brightness}, {c.kelvin}) across all "
+                    f"{len(device_state.zone_colors)} zones, "
+                    f"duration={packet.duration}ms"
+                )
+            # Matrix devices: update all tile zones
+            elif device_state.has_matrix and device_state.tile_devices:
+                total_zones = 0
+                for tile in device_state.tile_devices:
+                    for i in range(len(tile["colors"])):
+                        tile["colors"][i] = packet.color
+                    total_zones += len(tile["colors"])
+                logger.info(
+                    f"Color set to HSBK({c.hue}, {c.saturation}, "
+                    f"{c.brightness}, {c.kelvin}) across all {total_zones} zones, "
+                    f"duration={packet.duration}ms"
+                )
+            else:
+                # Simple color device
+                logger.info(
+                    f"Color set to HSBK({c.hue}, {c.saturation}, "
+                    f"{c.brightness}, {c.kelvin}), duration={packet.duration}ms"
+                )
 
         if res_required:
             return [
@@ -120,6 +227,17 @@ class SetWaveformHandler(PacketHandler):
             if not packet.transient:
                 device_state.color = packet.color
 
+                # For backwards compatibility: propagate color to all zones
+                # Multizone devices: update all zone colors
+                if device_state.has_multizone and device_state.zone_colors:
+                    for i in range(len(device_state.zone_colors)):
+                        device_state.zone_colors[i] = packet.color
+                # Matrix devices: update all tile zones
+                elif device_state.has_matrix and device_state.tile_devices:
+                    for tile in device_state.tile_devices:
+                        for i in range(len(tile["colors"])):
+                            tile["colors"][i] = packet.color
+
             logger.info(
                 f"Waveform set: type={packet.waveform}, "
                 f"transient={packet.transient}, period={packet.period}ms, "
@@ -127,13 +245,9 @@ class SetWaveformHandler(PacketHandler):
             )
 
         if res_required:
-            return [
-                Light.StateColor(
-                    color=device_state.color,
-                    power=device_state.power_level,
-                    label=device_state.label,
-                )
-            ]
+            # Use GetColorHandler to get proper averaged color if needed
+            handler = GetColorHandler()
+            return handler.handle(device_state, None, res_required)
         return []
 
 
@@ -168,6 +282,31 @@ class SetWaveformOptionalHandler(PacketHandler):
                 if packet.set_kelvin:
                     device_state.color.kelvin = packet.color.kelvin
 
+                # Backwards compatibility propagates color changes to zones
+                # Multizone devices: update all zone colors
+                if device_state.has_multizone and device_state.zone_colors:
+                    for zone_color in device_state.zone_colors:
+                        if packet.set_hue:
+                            zone_color.hue = packet.color.hue
+                        if packet.set_saturation:
+                            zone_color.saturation = packet.color.saturation
+                        if packet.set_brightness:
+                            zone_color.brightness = packet.color.brightness
+                        if packet.set_kelvin:
+                            zone_color.kelvin = packet.color.kelvin
+                # Matrix devices: update all tile zones
+                elif device_state.has_matrix and device_state.tile_devices:
+                    for tile in device_state.tile_devices:
+                        for zone_color in tile["colors"]:
+                            if packet.set_hue:
+                                zone_color.hue = packet.color.hue
+                            if packet.set_saturation:
+                                zone_color.saturation = packet.color.saturation
+                            if packet.set_brightness:
+                                zone_color.brightness = packet.color.brightness
+                            if packet.set_kelvin:
+                                zone_color.kelvin = packet.color.kelvin
+
             # Store the waveform color (all components)
             device_state.waveform_color = packet.color
 
@@ -180,13 +319,9 @@ class SetWaveformOptionalHandler(PacketHandler):
             )
 
         if res_required:
-            return [
-                Light.StateColor(
-                    color=device_state.color,
-                    power=device_state.power_level,
-                    label=device_state.label,
-                )
-            ]
+            # Use GetColorHandler to get proper averaged color if needed
+            handler = GetColorHandler()
+            return handler.handle(device_state, None, res_required)
         return []
 
 

lifx_emulator/handlers/tile_handlers.py

@@ -142,13 +142,13 @@ class Get64Handler(PacketHandler):
         # regardless of which fb_index is in the request
         tile_colors = tile["colors"]
 
-        # Calculate how many rows fit in 64 pixels
+        # 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 = []
-        pixels_extracted = 0
+        zones_extracted = 0
 
         for row in range(rows_to_return):
             y = rect.y + row
@@ -157,22 +157,22 @@ class Get64Handler(PacketHandler):
 
             for col in range(rect.width):
                 x = rect.x + col
-                if x >= tile_width or pixels_extracted >= 64:
+                if x >= tile_width or zones_extracted >= 64:
                     colors.append(
                         LightHsbk(hue=0, saturation=0, brightness=0, kelvin=3500)
                     )
-                    pixels_extracted += 1
+                    zones_extracted += 1
                     continue
 
-                # Calculate pixel index in flat color array
-                pixel_idx = y * tile_width + x
-                if pixel_idx < len(tile_colors):
-                    colors.append(tile_colors[pixel_idx])
+                # 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)
                     )
-                pixels_extracted += 1
+                zones_extracted += 1
 
         # Pad to exactly 64 colors
         while len(colors) < 64:
@@ -226,11 +226,11 @@ class Set64Handler(PacketHandler):
                 return []
 
         # Update colors in the specified rectangle
-        # Calculate how many rows fit in 64 pixels
+        # Calculate how many rows fit in 64 zones
         rows_to_write = 64 // rect.width if rect.width > 0 else 1
         rows_to_write = min(rows_to_write, tile_height - rect.y)
 
-        pixels_written = 0
+        zones_written = 0
         for row in range(rows_to_write):
             y = rect.y + row
             if y >= tile_height:
@@ -238,20 +238,18 @@ class Set64Handler(PacketHandler):
 
             for col in range(rect.width):
                 x = rect.x + col
-                if x >= tile_width or pixels_written >= 64:
-                    pixels_written += 1
+                if x >= tile_width or zones_written >= 64:
+                    zones_written += 1
                     continue
 
-                # Calculate pixel index in flat color array
-                pixel_idx = y * tile_width + x
-                if pixel_idx < len(target_colors) and pixels_written < len(
-                    packet.colors
-                ):
-                    target_colors[pixel_idx] = packet.colors[pixels_written]
-                pixels_written += 1
+                # Calculate zone index in flat color array
+                zone_idx = y * tile_width + x
+                if zone_idx < len(target_colors) and zones_written < len(packet.colors):
+                    target_colors[zone_idx] = packet.colors[zones_written]
+                zones_written += 1
 
         logger.info(
-            f"Tile {tile_index} FB{fb_index} set {pixels_written} colors at "
+            f"Tile {tile_index} FB{fb_index} set {zones_written} colors at "
             f"({rect.x},{rect.y}), duration={packet.duration}ms"
         )
 
@@ -316,7 +314,7 @@ class CopyFrameBufferHandler(PacketHandler):
         width = packet.width
         height = packet.height
 
-        pixels_copied = 0
+        zones_copied = 0
         for row in range(height):
             src_row = src_y + row
             dst_row = dst_y + row
@@ -336,10 +334,10 @@ class CopyFrameBufferHandler(PacketHandler):
 
                 if src_idx < len(src_colors) and dst_idx < len(dst_colors):
                     dst_colors[dst_idx] = src_colors[src_idx]
-                    pixels_copied += 1
+                    zones_copied += 1
 
         logger.info(
-            f"Tile {tile_index} copied {pixels_copied} pixels from "
+            f"Tile {tile_index} copied {zones_copied} zones from "
             f"FB{src_fb_index}({src_x},{src_y}) to "
             f"FB{dst_fb_index}({dst_x},{dst_y}), "
             f"size={width}x{height}, duration={packet.duration}ms"

lifx_emulator/products/generator.py

@@ -174,7 +174,6 @@ def generate_product_definitions(
     code_lines.append("PRODUCTS: dict[int, ProductInfo] = {")
 
     product_count = 0
-    skipped_count = 0
     for vendor_data in all_vendors:
         vendor_id = vendor_data.get("vid", 1)
         defaults = vendor_data.get("defaults", {})
@@ -186,11 +185,6 @@ def generate_product_definitions(
             name = product["name"]
             features = {**default_features, **product.get("features", {})}
 
-            # Skip switch products (devices with relays) - these are not lights
-            if features.get("relays"):
-                skipped_count += 1
-                continue
-
             # Build capabilities
             capabilities = _build_capabilities(features)
 
@@ -223,8 +217,6 @@ def generate_product_definitions(
     code_lines.append("")
 
     print(f"Generated {product_count} product definitions")
-    if skipped_count > 0:
-        print(f"Skipped {skipped_count} switch products (relays only)")
     return "\n".join(code_lines)
 
 
@@ -373,16 +365,17 @@ class ProductInfo:
         """Format product capabilities as a human-readable string.
 
         Returns:
-            Comma-separated capability string (e.g., "full color, infrared, multizone")
+            Comma-separated capability string (e.g., "color, infrared, multizone")
         """
         caps = []
 
-        # Determine base light type
+        if self.has_buttons:
+            caps.append("buttons")
+
         if self.has_relays:
-            # Devices with relays are switches, not lights
-            caps.append("switch")
+            caps.append("relays")
         elif self.has_color:
-            caps.append("full color")
+            caps.append("color")
         else:
             # Check temperature range to determine white light type
             if self.temperature_range:
@@ -409,9 +402,7 @@ class ProductInfo:
             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"
 
@@ -465,10 +456,6 @@ 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"):
@@ -667,7 +654,7 @@ def _discover_new_products(
     products_data: dict[str, Any] | list[dict[str, Any]],
     existing_specs: dict[int, dict[str, Any]],
 ) -> list[dict[str, Any]]:
-    """Find new multizone or matrix products that need specs templates.
+    """Find new multizone, matrix, or switch products that need specs templates.
 
     Args:
         products_data: Parsed products.json data
@@ -691,21 +678,19 @@ def _discover_new_products(
             pid = product["pid"]
             features = {**default_features, **product.get("features", {})}
 
-            # Skip switch products (devices with relays) - these are not lights
-            if features.get("relays"):
-                continue
-
             # Check if this product needs specs template
             if pid not in existing_specs:
                 is_multizone = features.get("multizone", False)
                 is_matrix = features.get("matrix", False)
+                is_switch = features.get("relays", False)
 
-                if is_multizone or is_matrix:
+                if is_multizone or is_matrix or is_switch:
                     new_product = {
                         "pid": pid,
                         "name": product["name"],
                         "multizone": is_multizone,
                         "matrix": is_matrix,
+                        "switch": is_switch,
                         "extended_multizone": False,
                     }
 
@@ -732,7 +717,12 @@ def _add_product_templates(
     for product in new_products:
         product_name = product["name"].replace('"', '\\"')
 
-        if product["multizone"]:
+        if product["switch"]:
+            existing_specs[product["pid"]] = {
+                "relay_count": 2,
+                "notes": product_name,
+            }
+        elif product["multizone"]:
             existing_specs[product["pid"]] = {
                 "default_zone_count": 16,
                 "min_zone_count": 1,
@@ -752,28 +742,32 @@ def _add_product_templates(
 
 def _categorize_products(
     existing_specs: dict[int, dict[str, Any]],
-) -> tuple[list[int], list[int]]:
-    """Categorize products into multizone and matrix.
+) -> tuple[list[int], list[int], list[int]]:
+    """Categorize products into switch, multizone, and matrix.
 
     Args:
         existing_specs: Product specs dictionary
 
     Returns:
-        Tuple of (sorted_multizone_pids, sorted_matrix_pids)
+        Tuple of (sorted_switch_pids, sorted_multizone_pids, sorted_matrix_pids)
     """
+    switch_pids = []
     multizone_pids = []
     matrix_pids = []
 
     for pid, specs in existing_specs.items():
-        if "tile_width" in specs or "tile_height" in specs:
+        if "relay_count" in specs:
+            switch_pids.append(pid)
+        elif "tile_width" in specs or "tile_height" in specs:
             matrix_pids.append(pid)
         elif "default_zone_count" in specs:
             multizone_pids.append(pid)
 
+    switch_pids.sort()
     multizone_pids.sort()
     matrix_pids.sort()
 
-    return multizone_pids, matrix_pids
+    return switch_pids, multizone_pids, matrix_pids
 
 
 def _generate_yaml_header() -> list[str]:
@@ -806,8 +800,8 @@ def _generate_yaml_header() -> list[str]:
         "#     default_tile_count: <number>      # Default number of tiles in chain",
         "#     min_tile_count: <number>          # Minimum tiles supported",
         "#     max_tile_count: <number>          # Maximum tiles supported",
-        "#     tile_width: <number>              # Width of each tile in pixels",
-        "#     tile_height: <number>             # Height of each tile in pixels",
+        "#     tile_width: <number>              # Width of each tile in zones",
+        "#     tile_height: <number>             # Height of each tile in zones",
         "#",
         "#     # Host firmware version (optional, overrides auto firmware selection)",
         "#     default_firmware_major: <number>  # Firmware major version (e.g., 3)",
@@ -833,6 +827,53 @@ def _generate_yaml_header() -> list[str]:
     ]
 
 
+def _generate_switch_section(
+    switch_pids: list[int], existing_specs: dict[int, dict[str, Any]]
+) -> list[str]:
+    """Generate YAML lines for switch products section.
+
+    Args:
+        switch_pids: Sorted list of switch product IDs
+        existing_specs: Product specs dictionary
+
+    Returns:
+        List of YAML lines
+    """
+    if not switch_pids:
+        return []
+
+    lines = [
+        "  # ========================================",
+        "  # Switch Products (Relays)",
+        "  # ========================================",
+        "",
+    ]
+
+    for pid in switch_pids:
+        specs = existing_specs[pid]
+        name = specs.get("notes", f"Product {pid}").split(" - ")[0]
+
+        lines.append(f"  {pid}:  # {name}")
+        lines.append(f"    relay_count: {specs['relay_count']}")
+
+        # Add firmware version if present
+        if "default_firmware_major" in specs and "default_firmware_minor" in specs:
+            lines.append(
+                f"    default_firmware_major: {specs['default_firmware_major']}"
+            )
+            lines.append(
+                f"    default_firmware_minor: {specs['default_firmware_minor']}"
+            )
+
+        notes = specs.get("notes", "")
+        if notes:
+            notes_escaped = notes.replace('"', '\\"')
+            lines.append(f'    notes: "{notes_escaped}"')
+        lines.append("")
+
+    return lines
+
+
 def _generate_multizone_section(
     multizone_pids: list[int], existing_specs: dict[int, dict[str, Any]]
 ) -> list[str]:
@@ -964,12 +1005,13 @@ def update_specs_file(
     _add_product_templates(new_products, existing_specs)
 
     # Categorize products and sort
-    multizone_pids, matrix_pids = _categorize_products(existing_specs)
+    switch_pids, multizone_pids, matrix_pids = _categorize_products(existing_specs)
 
     # Build YAML content
     lines = _generate_yaml_header()
     lines.extend(_generate_multizone_section(multizone_pids, existing_specs))
     lines.extend(_generate_matrix_section(matrix_pids, existing_specs))
+    lines.extend(_generate_switch_section(switch_pids, existing_specs))
 
     # Write the new file
     with open(specs_path, "w") as f:

lifx_emulator/products/registry.py

@@ -134,16 +134,17 @@ class ProductInfo:
         """Format product capabilities as a human-readable string.
 
         Returns:
-            Comma-separated capability string (e.g., "full color, infrared, multizone")
+            Comma-separated capability string (e.g., "color, infrared, multizone")
         """
         caps = []
 
-        # Determine base light type
+        if self.has_buttons:
+            caps.append("buttons")
+
         if self.has_relays:
-            # Devices with relays are switches, not lights
-            caps.append("switch")
+            caps.append("relays")
         elif self.has_color:
-            caps.append("full color")
+            caps.append("color")
         else:
             # Check temperature range to determine white light type
             if self.temperature_range:
@@ -170,9 +171,6 @@ class ProductInfo:
             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"
 
@@ -505,6 +503,22 @@ 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",
@@ -545,6 +559,14 @@ 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",
@@ -681,6 +703,22 @@ 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",
@@ -1321,10 +1359,6 @@ class ProductRegistry:
                 prod_features = product.get("features", {})
                 features: dict[str, Any] = {**default_features, **prod_features}
 
-                # Skip switch products (devices with relays) - these are not lights
-                if features.get("relays"):
-                    continue
-
                 # Build capabilities bitfield
                 capabilities = 0
                 if features.get("color"):

lifx_emulator/products/specs.py

@@ -25,8 +25,8 @@ class ProductSpecs:
         default_tile_count: Default number of tiles in chain
         min_tile_count: Minimum tiles supported
         max_tile_count: Maximum tiles supported
-        tile_width: Width of each tile in pixels
-        tile_height: Height of each tile in pixels
+        tile_width: Width of each tile in zones
+        tile_height: Height of each tile in zones
         default_firmware_major: Default firmware major version
         default_firmware_minor: Default firmware minor version
         notes: Human-readable notes about this product

lifx_emulator/products/specs.yml

@@ -21,10 +21,10 @@
 #     default_tile_count: <number>      # Default number of tiles in chain
 #     min_tile_count: <number>          # Minimum tiles supported
 #     max_tile_count: <number>          # Maximum tiles supported
-#     tile_width: <number>              # Width of each tile in pixels
-#     tile_height: <number>             # Height of each tile in pixels
+#     tile_width: <number>              # Width of each tile in zones
+#     tile_height: <number>             # Height of each tile in zones
 #
-#     # Host firmware version (optional, overrides automatic firmware selection)
+#     # Host firmware version (optional, overrides auto firmware selection)
 #     default_firmware_major: <number>  # Firmware major version (e.g., 3)
 #     default_firmware_minor: <number>  # Firmware minor version (e.g., 70)
 #
@@ -33,9 +33,9 @@
 #
 # Firmware Version Notes:
 # ----------------------
-# If default_firmware_major and default_firmware_minor are both specified for a
-# product, they will be used as the default firmware version when creating devices
-# of that product type. This overrides the automatic firmware version selection
+# If default_firmware_major and default_firmware_minor are both specified
+# they will be used as the default firmware version when creating devices
+# of that type. This overrides the automatic firmware version selection
 # based on extended_multizone capability (which defaults to 3.70 for extended
 # multizone or 2.60 for non-extended).
 #
@@ -167,29 +167,29 @@ products:
   # Matrix Products (Tiles, Candles, etc.)
   # ========================================
 
-  55:  # LIFX Tile, 8x8 pixel matrix, chainable up to 5
+  55:  # LIFX Tile, 8x8 zone matrix, chainable up to 5
     default_tile_count: 5
     min_tile_count: 1
     max_tile_count: 5
     tile_width: 8
     tile_height: 8
-    notes: LIFX Tile, 8x8 pixel matrix, chainable up to 5
+    notes: LIFX Tile, 8x8 zone matrix, chainable up to 5
 
-  57:  # LIFX Candle, 5x6 pixel matrix, single unit
+  57:  # LIFX Candle, 5x6 zone matrix, single unit
     default_tile_count: 1
     min_tile_count: 1
     max_tile_count: 1
     tile_width: 5
     tile_height: 6
-    notes: LIFX Candle, 5x6 pixel matrix, single unit
+    notes: LIFX Candle, 5x6 zone matrix, single unit
 
-  68:  # LIFX Candle variant, 5x6 pixel matrix
+  68:  # LIFX Candle variant, 5x6 zone matrix
     default_tile_count: 1
     min_tile_count: 1
     max_tile_count: 1
     tile_width: 5
     tile_height: 6
-    notes: LIFX Candle variant, 5x6 pixel matrix
+    notes: LIFX Candle variant, 5x6 zone matrix
 
   137:  # LIFX Candle Color US 5x6 variant
     default_tile_count: 1
@@ -350,3 +350,37 @@ products:
     tile_width: 3
     tile_height: 2
     notes: LIFX Round Path Intl
+
+  # ========================================
+  # Switch Products (Relays)
+  # ========================================
+
+  70:  # LIFX Switch
+    relay_count: 2
+    default_firmware_major: 4
+    default_firmware_minor: 100
+    notes: LIFX Switch
+
+  71:  # LIFX Switch
+    relay_count: 2
+    default_firmware_major: 4
+    default_firmware_minor: 100
+    notes: LIFX Switch
+
+  89:  # LIFX Switch
+    relay_count: 2
+    default_firmware_major: 4
+    default_firmware_minor: 100
+    notes: LIFX Switch
+
+  115:  # LIFX Switch
+    relay_count: 2
+    default_firmware_major: 4
+    default_firmware_minor: 100
+    notes: LIFX Switch
+
+  116:  # LIFX Switch
+    relay_count: 2
+    default_firmware_major: 4
+    default_firmware_minor: 100
+    notes: LIFX Switch

{lifx_emulator-2.3.0.dist-info → lifx_emulator-2.4.0.dist-info}/METADATA

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

{lifx_emulator-2.3.0.dist-info → lifx_emulator-2.4.0.dist-info}/RECORD

@@ -1,10 +1,10 @@
 lifx_emulator/__init__.py,sha256=vjhtpAQRSsUZtaUGCQKbmPALvwZ_BF8Mko8w6jzVqBw,819
-lifx_emulator/__main__.py,sha256=zaul9OQhN5csqOqxGWXkVrlurfo2R_-YvM6URk4QAME,21680
+lifx_emulator/__main__.py,sha256=0rNT1ua1uckq9f2l7g6wIC5VDj9kmWzuL-UZBwm5_tE,22057
 lifx_emulator/constants.py,sha256=DFZkUsdewE-x_3MgO28tMGkjUCWPeYc3xLj_EXViGOw,1032
 lifx_emulator/server.py,sha256=r2JYFcpZIqqhue-Nfq7FbN0KfC3XDf3XDb6b43DsiCk,16438
 lifx_emulator/api/__init__.py,sha256=FoEPw_In5-H_BDQ-XIIONvgj-UqIDVtejIEVRv9qmV8,647
 lifx_emulator/api/app.py,sha256=IxK8sC7MgdtkoLz8iXcEt02nPDaVgdKJgEiGnzTs-YE,4880
-lifx_emulator/api/models.py,sha256=eBx80Ece_4Wv6aqxb1CsZEob9CF0WmR9oJGz3hh14x8,3973
+lifx_emulator/api/models.py,sha256=qFNo0sOl31yuZLtWmLroSW6f6jck-RhP05tx972xsWA,3971
 lifx_emulator/api/mappers/__init__.py,sha256=ZPCOQR9odcwn0C58AjFW6RvBXe5gOll_QS5lAabgorQ,152
 lifx_emulator/api/mappers/device_mapper.py,sha256=EGOpdao9ZS-vT4T8IoV-AoN5WucTnqpQO92dYizo3vw,4151
 lifx_emulator/api/routers/__init__.py,sha256=kbMefnuXrEsYeMA9J4YK_wVs87_XcH7hwkEifR-zgMc,369
@@ -13,33 +13,33 @@ lifx_emulator/api/routers/monitoring.py,sha256=qgVBNm6iMESf1W6EE22DvLalMnxkr0pRb
 lifx_emulator/api/routers/scenarios.py,sha256=0axSQ9r6rByvXLvqRqOU2ma5nTvZgZ0IIzEXdtzoPnM,9743
 lifx_emulator/api/services/__init__.py,sha256=ttjjZfAxbDQC_Ep0LkXjopNiVZOFPsFDSOHhBN98v5s,277
 lifx_emulator/api/services/device_service.py,sha256=r3uFWApC8sVQMCuuzkyjm27K4LDpZnnHmQNgXWX40ok,6294
-lifx_emulator/api/templates/dashboard.html,sha256=YXQ9jrs30DZIxtMWFE4E2HqmsgHQ-NeWTTQxQ-7BfHk,33800
+lifx_emulator/api/templates/dashboard.html,sha256=h-PeOH_La5bVOUBcXmTY2leRlMdL8D8yJ-NCx3S16-A,33792
 lifx_emulator/devices/__init__.py,sha256=QlBTPnFErJcSKLvGyeDwemh7xcpjYvB_L5siKsjr3s8,1089
-lifx_emulator/devices/device.py,sha256=LIVXURglYsYMC6_88sAWzoJKkq_HSZEOu4xruRtcZKs,13650
+lifx_emulator/devices/device.py,sha256=yEOXc_xr1X45bJzG2qB-A-oIHwnA8qqYlIsFialobGc,15780
 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
 lifx_emulator/devices/state_restorer.py,sha256=eDsRSW-2RviP_0Qlk2DHqMaB-zhV0X1cNQECv2lD1qc,9809
 lifx_emulator/devices/state_serializer.py,sha256=aws4LUmXBJS8oBrQziJtlV0XMvCTm5X4dGkGlO_QHcM,6281
-lifx_emulator/devices/states.py,sha256=O__VtgK97-ZHxZ2qgOKp9-fDG8HcmlTVkGYONwot8iQ,12094
-lifx_emulator/factories/__init__.py,sha256=yN8i_Hu_cFEryWZmh0TiOQvWEYFVIApQSs4xeb0EfBk,1170
-lifx_emulator/factories/builder.py,sha256=OaDqQDGkAyZCSO-4HAsFSd5UzsHpHvRyBk-Fotl1mAY,12056
+lifx_emulator/devices/states.py,sha256=kNv-VV1UCDxPduixU1-5xBGKRzeCfE-bYzzEh_1GnUU,12204
+lifx_emulator/factories/__init__.py,sha256=CsryMcf_80hTjOAgrukA6vRZaZow_2VQkSewrpP9gEI,1210
+lifx_emulator/factories/builder.py,sha256=xs3g3_-euUqgdcBu_3umPZb-xlzDeoDeOrwEGJShOwA,12164
 lifx_emulator/factories/default_config.py,sha256=FTcxKDfeTmO49GTSki8nxnEIZQzR0Lg0hL_PwHUrkVQ,4828
-lifx_emulator/factories/factory.py,sha256=VQfU5M8zrpFyNHjpGP1q-3bpek9MltBdoAUSvIvt7Bs,7583
+lifx_emulator/factories/factory.py,sha256=MyGG-pW7EV2BFP5ZzgMuFF5TfNFvfyFDoE5dmd3LC8w,8623
 lifx_emulator/factories/firmware_config.py,sha256=tPN5Hq-uNb1xzW9Q0A9jD-G0-NaGfINcD0i1XZRUMoE,2711
 lifx_emulator/factories/serial_generator.py,sha256=MbaXoommsj76ho8_ZoKuUDnffDf98YvwQiXZSWsUsEs,2507
 lifx_emulator/handlers/__init__.py,sha256=3Hj1hRo3yL3E7GKwG9TaYh33ymk_N3bRiQ8nvqSQULA,1306
 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=Ryz-_fzoVCT6DBkXhW9YCOYJYaMRcBOIguL3HrQXhAw,11471
+lifx_emulator/handlers/light_handlers.py,sha256=255aoiIjSIL63kbHQa6wqUpEwFzFFx7SG6P1nWM9jgU,17769
 lifx_emulator/handlers/multizone_handlers.py,sha256=2dYsitq0KzEaxEAJmz7ixtir1tvFMOAnfkBQqslqbPM,7914
 lifx_emulator/handlers/registry.py,sha256=s1ht4PmPhXhAcwu1hoY4yW39wy3SPJBMY-9Uxd0FWuE,3292
-lifx_emulator/handlers/tile_handlers.py,sha256=tniYndUbtWPTu7YznfMKsWUBu2UmGsSuOYRws5IBL0s,17239
+lifx_emulator/handlers/tile_handlers.py,sha256=L4fNKGTSSIxRuqKrfDrMSrNPvDJr3aIuaEqbhRCOt04,17176
 lifx_emulator/products/__init__.py,sha256=qcNop_kRYFF3zSjNemzQEgu3jPrIxfyQyLv9GsnaLEI,627
-lifx_emulator/products/generator.py,sha256=5zcq0iKgwjtg0gePnBEOdIkumesvfzEcKRdBZFPyGtk,33538
-lifx_emulator/products/registry.py,sha256=qkm2xgGZo_ds3wAbYplLu4gb0cxhjZXjnCc1V8etpHw,46517
-lifx_emulator/products/specs.py,sha256=RxToCvu-iwF6QMcmYgI5CblLOr8hpDZ3k3WT1fZcKe8,8730
-lifx_emulator/products/specs.yml,sha256=eM_r1lTRQHii4dyvnsZWx1P7NzDSZzJl03aR86TY564,9683
+lifx_emulator/products/generator.py,sha256=fvrhw_b7shLCtEtUFxWF5VBEQAeSrsaiXxoGIP5Vn4g,34675
+lifx_emulator/products/registry.py,sha256=1SZ3fXVFFL8jhKYIZBqwtIQDN3qL1Lvf86P3N1_Kdx8,47323
+lifx_emulator/products/specs.py,sha256=epqz2DPyNOOOFHhmI_wlk7iEbgN0vCugHz-hWx9FlAI,8728
+lifx_emulator/products/specs.yml,sha256=6hh7V-953uN4t3WD2rY9Nn8zKFZuQDHgYVo7LgZcGEA,10399
 lifx_emulator/protocol/__init__.py,sha256=-wjC-wBcb7fxi5I-mJr2Ad8K2YRflJFdLLdobfD-W1Q,56
 lifx_emulator/protocol/base.py,sha256=V6t0baSgIXjrsz2dBuUn_V9xwradSqMxBFJHAUtnfCs,15368
 lifx_emulator/protocol/const.py,sha256=ilhv-KcQpHtKh2MDCaIbMLQAsxKO_uTaxyR63v1W8cc,226
@@ -55,8 +55,8 @@ lifx_emulator/scenarios/__init__.py,sha256=CGjudoWvyysvFj2xej11N2cr3mYROGtRb9zVH
 lifx_emulator/scenarios/manager.py,sha256=1esxRdz74UynNk1wb86MGZ2ZFAuMzByuu74nRe3D-Og,11163
 lifx_emulator/scenarios/models.py,sha256=BKS_fGvrbkGe-vK3arZ0w2f9adS1UZhiOoKpu7GENnc,4099
 lifx_emulator/scenarios/persistence.py,sha256=3vjtPNFYfag38tUxuqxkGpWhQ7uBitc1rLroSAuw9N8,8881
-lifx_emulator-2.3.0.dist-info/METADATA,sha256=PsbeOthCdD824wzYnw8vf_rKKze3Yk1DPC6NtpkZv1Q,4549
-lifx_emulator-2.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-lifx_emulator-2.3.0.dist-info/entry_points.txt,sha256=R9C_K_tTgt6yXEmhzH4r2Yx2Tu1rLlnYzeG4RFUVzSc,62
-lifx_emulator-2.3.0.dist-info/licenses/LICENSE,sha256=eBz48GRA3gSiWn3rYZAz2Ewp35snnhV9cSqkVBq7g3k,1832
-lifx_emulator-2.3.0.dist-info/RECORD,,
+lifx_emulator-2.4.0.dist-info/METADATA,sha256=qohy51CSwGIwGXstHI26VBqfY3_aYWgBEQDYE4nEnI8,4549
+lifx_emulator-2.4.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+lifx_emulator-2.4.0.dist-info/entry_points.txt,sha256=R9C_K_tTgt6yXEmhzH4r2Yx2Tu1rLlnYzeG4RFUVzSc,62
+lifx_emulator-2.4.0.dist-info/licenses/LICENSE,sha256=eBz48GRA3gSiWn3rYZAz2Ewp35snnhV9cSqkVBq7g3k,1832
+lifx_emulator-2.4.0.dist-info/RECORD,,