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

lifx_emulator/devices/state_serializer.py

@@ -1,157 +0,0 @@
-"""Shared serialization logic for device state."""
-
-from __future__ import annotations
-
-from typing import Any
-
-from lifx_emulator.protocol.protocol_types import LightHsbk
-
-
-def serialize_hsbk(hsbk: LightHsbk) -> dict[str, int]:
-    """Serialize LightHsbk to dict."""
-    return {
-        "hue": hsbk.hue,
-        "saturation": hsbk.saturation,
-        "brightness": hsbk.brightness,
-        "kelvin": hsbk.kelvin,
-    }
-
-
-def deserialize_hsbk(data: dict[str, int]) -> LightHsbk:
-    """Deserialize dict to LightHsbk."""
-    return LightHsbk(
-        hue=data["hue"],
-        saturation=data["saturation"],
-        brightness=data["brightness"],
-        kelvin=data["kelvin"],
-    )
-
-
-def serialize_device_state(device_state: Any) -> dict[str, Any]:
-    """Serialize DeviceState to dict.
-
-    Note: Accesses state via properties for backward compatibility with composed state.
-    """
-    state_dict = {
-        "serial": device_state.serial,
-        "label": device_state.label,
-        "product": device_state.product,
-        "power_level": device_state.power_level,
-        "color": serialize_hsbk(device_state.color),
-        "location_id": device_state.location_id.hex(),
-        "location_label": device_state.location_label,
-        "location_updated_at": device_state.location_updated_at,
-        "group_id": device_state.group_id.hex(),
-        "group_label": device_state.group_label,
-        "group_updated_at": device_state.group_updated_at,
-        "has_color": device_state.has_color,
-        "has_infrared": device_state.has_infrared,
-        "has_multizone": device_state.has_multizone,
-        "has_matrix": device_state.has_matrix,
-        "has_hev": device_state.has_hev,
-    }
-
-    if device_state.has_infrared:
-        state_dict["infrared_brightness"] = device_state.infrared_brightness
-
-    if device_state.has_hev:
-        state_dict["hev_cycle_duration_s"] = device_state.hev_cycle_duration_s
-        state_dict["hev_cycle_remaining_s"] = device_state.hev_cycle_remaining_s
-        state_dict["hev_cycle_last_power"] = device_state.hev_cycle_last_power
-        state_dict["hev_indication"] = device_state.hev_indication
-        state_dict["hev_last_result"] = device_state.hev_last_result
-
-    if device_state.has_multizone:
-        state_dict["zone_count"] = device_state.zone_count
-        state_dict["zone_colors"] = [
-            serialize_hsbk(c) for c in device_state.zone_colors
-        ]
-        state_dict["multizone_effect_type"] = device_state.multizone_effect_type
-        state_dict["multizone_effect_speed"] = device_state.multizone_effect_speed
-
-    if device_state.has_matrix:
-        state_dict["tile_count"] = device_state.tile_count
-        state_dict["tile_width"] = device_state.tile_width
-        state_dict["tile_height"] = device_state.tile_height
-        state_dict["tile_effect_type"] = device_state.tile_effect_type
-        state_dict["tile_effect_speed"] = device_state.tile_effect_speed
-        state_dict["tile_effect_palette_count"] = device_state.tile_effect_palette_count
-        state_dict["tile_effect_palette"] = [
-            serialize_hsbk(c) for c in device_state.tile_effect_palette
-        ]
-        state_dict["tile_devices"] = [
-            {
-                "accel_meas_x": t["accel_meas_x"],
-                "accel_meas_y": t["accel_meas_y"],
-                "accel_meas_z": t["accel_meas_z"],
-                "user_x": t["user_x"],
-                "user_y": t["user_y"],
-                "width": t["width"],
-                "height": t["height"],
-                "device_version_vendor": t["device_version_vendor"],
-                "device_version_product": t["device_version_product"],
-                "firmware_build": t["firmware_build"],
-                "firmware_version_minor": t["firmware_version_minor"],
-                "firmware_version_major": t["firmware_version_major"],
-                "colors": [serialize_hsbk(c) for c in t["colors"]],
-            }
-            for t in device_state.tile_devices
-        ]
-        # Serialize tile framebuffers (non-visible framebuffers 1-7)
-        state_dict["tile_framebuffers"] = [
-            {
-                "tile_index": fb.tile_index,
-                "framebuffers": {
-                    str(fb_idx): [serialize_hsbk(c) for c in colors]
-                    for fb_idx, colors in fb.framebuffers.items()
-                },
-            }
-            for fb in device_state.tile_framebuffers
-        ]
-
-    return state_dict
-
-
-def deserialize_device_state(state_dict: dict[str, Any]) -> dict[str, Any]:
-    """Deserialize device state dict (convert hex strings and nested objects)."""
-    # Deserialize bytes fields
-    state_dict["location_id"] = bytes.fromhex(state_dict["location_id"])
-    state_dict["group_id"] = bytes.fromhex(state_dict["group_id"])
-
-    # Deserialize color
-    state_dict["color"] = deserialize_hsbk(state_dict["color"])
-
-    # Deserialize zone colors if present
-    if "zone_colors" in state_dict:
-        state_dict["zone_colors"] = [
-            deserialize_hsbk(c) for c in state_dict["zone_colors"]
-        ]
-
-    # Deserialize tile effect palette if present
-    if "tile_effect_palette" in state_dict:
-        state_dict["tile_effect_palette"] = [
-            deserialize_hsbk(c) for c in state_dict["tile_effect_palette"]
-        ]
-
-    # Deserialize tile devices if present
-    if "tile_devices" in state_dict:
-        for tile_dict in state_dict["tile_devices"]:
-            tile_dict["colors"] = [deserialize_hsbk(c) for c in tile_dict["colors"]]
-
-    # Deserialize tile framebuffers if present (for backwards compatibility)
-    if "tile_framebuffers" in state_dict:
-        from lifx_emulator.devices.states import TileFramebuffers
-
-        deserialized_fbs = []
-        for fb_dict in state_dict["tile_framebuffers"]:
-            tile_fb = TileFramebuffers(tile_index=fb_dict["tile_index"])
-            # Deserialize each framebuffer's colors
-            for fb_idx_str, colors_list in fb_dict["framebuffers"].items():
-                fb_idx = int(fb_idx_str)
-                tile_fb.framebuffers[fb_idx] = [
-                    deserialize_hsbk(c) for c in colors_list
-                ]
-            deserialized_fbs.append(tile_fb)
-        state_dict["tile_framebuffers"] = deserialized_fbs
-
-    return state_dict

lifx_emulator/devices/states.py

@@ -1,381 +0,0 @@
-"""Focused state dataclasses following Single Responsibility Principle."""
-
-from __future__ import annotations
-
-import time
-import uuid
-from dataclasses import dataclass, field
-from typing import Any
-
-from lifx_emulator.constants import LIFX_UDP_PORT
-from lifx_emulator.protocol.protocol_types import LightHsbk
-
-
-@dataclass
-class CoreDeviceState:
-    """Core device identification and basic state."""
-
-    serial: str
-    label: str
-    power_level: int
-    color: LightHsbk
-    vendor: int
-    product: int
-    version_major: int
-    version_minor: int
-    build_timestamp: int
-    uptime_ns: int = 0
-    mac_address: bytes = field(default_factory=lambda: bytes.fromhex("d073d5123456"))
-    port: int = LIFX_UDP_PORT
-
-
-@dataclass
-class NetworkState:
-    """Network and connectivity state."""
-
-    wifi_signal: float = -45.0
-
-
-@dataclass
-class LocationState:
-    """Device location metadata."""
-
-    location_id: bytes = field(default_factory=lambda: uuid.uuid4().bytes)
-    location_label: str = "Test Location"
-    location_updated_at: int = field(default_factory=lambda: int(time.time() * 1e9))
-
-
-@dataclass
-class GroupState:
-    """Device group metadata."""
-
-    group_id: bytes = field(default_factory=lambda: uuid.uuid4().bytes)
-    group_label: str = "Test Group"
-    group_updated_at: int = field(default_factory=lambda: int(time.time() * 1e9))
-
-
-@dataclass
-class InfraredState:
-    """Infrared capability state."""
-
-    infrared_brightness: int = 0  # 0-65535
-
-
-@dataclass
-class HevState:
-    """HEV (germicidal UV) capability state."""
-
-    hev_cycle_duration_s: int = 7200  # 2 hours default
-    hev_cycle_remaining_s: int = 0
-    hev_cycle_last_power: bool = False
-    hev_indication: bool = True
-    hev_last_result: int = 0  # 0=success
-
-
-@dataclass
-class MultiZoneState:
-    """Multizone (strip/beam) capability state."""
-
-    zone_count: int
-    zone_colors: list[LightHsbk]
-    effect_type: int = 0  # 0=OFF, 1=MOVE, 2=RESERVED
-    effect_speed: int = 5  # Duration of one cycle in seconds
-
-
-@dataclass
-class TileFramebuffers:
-    """Internal storage for non-visible tile framebuffers (1-7).
-
-    Framebuffer 0 is stored in tile_devices[i]["colors"] (the visible buffer).
-    Framebuffers 1-7 are stored here for Set64/CopyFrameBuffer operations.
-    Each framebuffer is a list of LightHsbk colors with length = width * height.
-    """
-
-    tile_index: int  # Which tile this belongs to
-    framebuffers: dict[int, list[LightHsbk]] = field(default_factory=dict)
-
-    def get_framebuffer(
-        self, fb_index: int, width: int, height: int
-    ) -> list[LightHsbk]:
-        """Get framebuffer by index, creating it if needed."""
-        if fb_index not in self.framebuffers:
-            # Initialize with default black color
-            zones = width * height
-            self.framebuffers[fb_index] = [
-                LightHsbk(hue=0, saturation=0, brightness=0, kelvin=3500)
-                for _ in range(zones)
-            ]
-        return self.framebuffers[fb_index]
-
-
-@dataclass
-class MatrixState:
-    """Matrix (tile/candle) capability state."""
-
-    tile_count: int
-    tile_devices: list[dict[str, Any]]
-    tile_width: int
-    tile_height: int
-    effect_type: int = 0  # 0=OFF, 2=MORPH, 3=FLAME, 5=SKY
-    effect_speed: int = 5  # Duration of one cycle in seconds
-    effect_palette_count: int = 0
-    effect_palette: list[LightHsbk] = field(default_factory=list)
-    effect_sky_type: int = 0  # 0=SUNRISE, 1=SUNSET, 2=CLOUDS (only when effect_type=5)
-    effect_cloud_sat_min: int = (
-        0  # Min cloud saturation 0-200 (only when effect_type=5)
-    )
-    effect_cloud_sat_max: int = (
-        0  # Max cloud saturation 0-200 (only when effect_type=5)
-    )
-    # Internal storage for non-visible framebuffers (1-7) per tile
-    # Framebuffer 0 remains in tile_devices[i]["colors"]
-    tile_framebuffers: list[TileFramebuffers] = field(default_factory=list)
-
-
-@dataclass
-class WaveformState:
-    """Waveform effect state."""
-
-    waveform_active: bool = False
-    waveform_type: int = 0
-    waveform_transient: bool = False
-    waveform_color: LightHsbk = field(
-        default_factory=lambda: LightHsbk(
-            hue=0, saturation=0, brightness=0, kelvin=3500
-        )
-    )
-    waveform_period_ms: int = 0
-    waveform_cycles: float = 0
-    waveform_duty_cycle: int = 0
-    waveform_skew_ratio: int = 0
-
-
-@dataclass
-class DeviceState:
-    """Composed device state following Single Responsibility Principle.
-
-    Each aspect of device state is managed by a focused sub-state object.
-    Properties are automatically delegated to the appropriate state object
-    using __getattr__ and __setattr__ magic methods.
-
-    Examples:
-        >>> state.label  # Delegates to state.core.label
-        >>> state.location_label  # Delegates to state.location.location_label
-        >>> state.zone_count  # Delegates to state.multizone.zone_count (if present)
-    """
-
-    core: CoreDeviceState
-    network: NetworkState
-    location: LocationState
-    group: GroupState
-    waveform: WaveformState
-
-    # Optional capability-specific state
-    infrared: InfraredState | None = None
-    hev: HevState | None = None
-    multizone: MultiZoneState | None = None
-    matrix: MatrixState | None = None
-
-    # Capability flags (kept for convenience)
-    has_color: bool = True
-    has_infrared: bool = False
-    has_multizone: bool = False
-    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
-    _ATTRIBUTE_ROUTES = {
-        # Core properties (no prefix)
-        "serial": "core",
-        "label": "core",
-        "power_level": "core",
-        "color": "core",
-        "vendor": "core",
-        "product": "core",
-        "version_major": "core",
-        "version_minor": "core",
-        "build_timestamp": "core",
-        "uptime_ns": "core",
-        "mac_address": "core",
-        "port": "core",
-        # Network properties
-        "wifi_signal": "network",
-        # Location properties
-        "location_id": "location",
-        "location_label": "location",
-        "location_updated_at": "location",
-        # Group properties
-        "group_id": "group",
-        "group_label": "group",
-        "group_updated_at": "group",
-        # Waveform properties
-        "waveform_active": "waveform",
-        "waveform_type": "waveform",
-        "waveform_transient": "waveform",
-        "waveform_color": "waveform",
-        "waveform_period_ms": "waveform",
-        "waveform_cycles": "waveform",
-        "waveform_duty_cycle": "waveform",
-        "waveform_skew_ratio": "waveform",
-        # Infrared properties
-        "infrared_brightness": "infrared",
-        # HEV properties
-        "hev_cycle_duration_s": "hev",
-        "hev_cycle_remaining_s": "hev",
-        "hev_cycle_last_power": "hev",
-        "hev_indication": "hev",
-        "hev_last_result": "hev",
-        # Multizone properties
-        "zone_count": "multizone",
-        "zone_colors": "multizone",
-        "multizone_effect_type": ("multizone", "effect_type"),
-        "multizone_effect_speed": ("multizone", "effect_speed"),
-        # Matrix/Tile properties
-        "tile_count": "matrix",
-        "tile_devices": "matrix",
-        "tile_width": "matrix",
-        "tile_height": "matrix",
-        "tile_effect_type": ("matrix", "effect_type"),
-        "tile_effect_speed": ("matrix", "effect_speed"),
-        "tile_effect_palette_count": ("matrix", "effect_palette_count"),
-        "tile_effect_palette": ("matrix", "effect_palette"),
-        "tile_effect_sky_type": ("matrix", "effect_sky_type"),
-        "tile_effect_cloud_sat_min": ("matrix", "effect_cloud_sat_min"),
-        "tile_effect_cloud_sat_max": ("matrix", "effect_cloud_sat_max"),
-        "tile_framebuffers": "matrix",
-    }
-
-    # Default values for optional state attributes when state object is None
-    _OPTIONAL_DEFAULTS = {
-        "infrared_brightness": 0,
-        "hev_cycle_duration_s": 0,
-        "hev_cycle_remaining_s": 0,
-        "hev_cycle_last_power": False,
-        "hev_indication": False,
-        "hev_last_result": 0,
-        "zone_count": 0,
-        "zone_colors": [],
-        "multizone_effect_type": 0,
-        "multizone_effect_speed": 0,
-        "tile_count": 0,
-        "tile_devices": [],
-        "tile_width": 8,
-        "tile_height": 8,
-        "tile_effect_type": 0,
-        "tile_effect_speed": 0,
-        "tile_effect_palette_count": 0,
-        "tile_effect_palette": [],
-        "tile_effect_sky_type": 0,
-        "tile_effect_cloud_sat_min": 0,
-        "tile_effect_cloud_sat_max": 0,
-        "tile_framebuffers": [],
-    }
-
-    def get_target_bytes(self) -> bytes:
-        """Get target bytes for this device."""
-        return bytes.fromhex(self.core.serial) + b"\x00\x00"
-
-    def __getattr__(self, name: str) -> Any:
-        """Dynamically delegate attribute access to appropriate state object.
-
-        This eliminates ~180 lines of @property boilerplate.
-
-        Args:
-            name: Attribute name being accessed
-
-        Returns:
-            Attribute value from the appropriate state object
-
-        Raises:
-            AttributeError: If attribute is not found
-        """
-        # Check if this attribute has a routing rule
-        if name in self._ATTRIBUTE_ROUTES:
-            route = self._ATTRIBUTE_ROUTES[name]
-
-            # Route can be either 'state_name' or ('state_name', 'attr_name')
-            if isinstance(route, tuple):
-                state_name, attr_name = route
-            else:
-                state_name = route
-                attr_name = name
-
-            # Get the state object
-            state_obj = object.__getattribute__(self, state_name)
-
-            # Handle optional state objects (infrared, hev, multizone, matrix)
-            if state_obj is None:
-                # Return default value for optional attributes
-                return self._OPTIONAL_DEFAULTS.get(name)
-
-            # Delegate to the state object
-            return getattr(state_obj, attr_name)
-
-        # If not in routing map, raise AttributeError
-        raise AttributeError(
-            f"'{type(self).__name__}' object has no attribute '{name}'"
-        )
-
-    def __setattr__(self, name: str, value: Any) -> None:
-        """Dynamically delegate attribute writes to appropriate state object.
-
-        This eliminates ~180 lines of @property.setter boilerplate.
-
-        Args:
-            name: Attribute name being set
-            value: Value to set
-
-        Note:
-            Dataclass fields and private attributes bypass delegation.
-        """
-        # Dataclass fields and private attributes use normal assignment
-        if name in {
-            "core",
-            "network",
-            "location",
-            "group",
-            "waveform",
-            "infrared",
-            "hev",
-            "multizone",
-            "matrix",
-            "has_color",
-            "has_infrared",
-            "has_multizone",
-            "has_extended_multizone",
-            "has_matrix",
-            "has_hev",
-            "has_relays",
-            "has_buttons",
-        } or name.startswith("_"):
-            object.__setattr__(self, name, value)
-            return
-
-        # Check if this attribute has a routing rule
-        if name in self._ATTRIBUTE_ROUTES:
-            route = self._ATTRIBUTE_ROUTES[name]
-
-            # Route can be either 'state_name' or ('state_name', 'attr_name')
-            if isinstance(route, tuple):
-                state_name, attr_name = route
-            else:
-                state_name = route
-                attr_name = name
-
-            # Get the state object
-            state_obj = object.__getattribute__(self, state_name)
-
-            # Handle optional state objects - silently ignore writes if None
-            if state_obj is None:
-                return
-
-            # Delegate to the state object
-            setattr(state_obj, attr_name, value)
-            return
-
-        # For unknown attributes, use normal assignment (allows adding new attributes)
-        object.__setattr__(self, name, value)

lifx_emulator/factories/__init__.py

@@ -1,39 +0,0 @@
-"""Device factory for creating emulated LIFX devices.
-
-This package provides a clean, testable API for creating LIFX devices using:
-- Builder pattern for flexible device construction
-- Separate services for serial generation, color config, firmware config
-- Product registry integration for accurate device specifications
-"""
-
-from lifx_emulator.factories.builder import DeviceBuilder
-from lifx_emulator.factories.default_config import DefaultColorConfig
-from lifx_emulator.factories.factory import (
-    create_color_light,
-    create_color_temperature_light,
-    create_device,
-    create_hev_light,
-    create_infrared_light,
-    create_multizone_light,
-    create_switch,
-    create_tile_device,
-)
-from lifx_emulator.factories.firmware_config import FirmwareConfig
-from lifx_emulator.factories.serial_generator import SerialGenerator
-
-__all__ = [
-    # Builder and helpers
-    "DeviceBuilder",
-    "SerialGenerator",
-    "DefaultColorConfig",
-    "FirmwareConfig",
-    # Factory functions
-    "create_device",
-    "create_color_light",
-    "create_infrared_light",
-    "create_hev_light",
-    "create_multizone_light",
-    "create_switch",
-    "create_tile_device",
-    "create_color_temperature_light",
-]