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

lifx_emulator/factories/factory.py

@@ -1,252 +0,0 @@
-"""Factory functions for creating emulated LIFX devices."""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from lifx_emulator.devices import EmulatedLifxDevice
-from lifx_emulator.factories.builder import DeviceBuilder
-from lifx_emulator.products.registry import get_product
-
-if TYPE_CHECKING:
-    from lifx_emulator.devices import DevicePersistenceAsyncFile
-    from lifx_emulator.scenarios import HierarchicalScenarioManager
-
-
-def create_color_light(
-    serial: str | None = None,
-    firmware_version: tuple[int, int] | None = None,
-    storage: DevicePersistenceAsyncFile | None = None,
-    scenario_manager: HierarchicalScenarioManager | None = None,
-) -> EmulatedLifxDevice:
-    """Create a regular color light (LIFX Color)"""
-    return create_device(
-        91,
-        serial=serial,
-        firmware_version=firmware_version,
-        storage=storage,
-        scenario_manager=scenario_manager,
-    )  # LIFX Color
-
-
-def create_infrared_light(
-    serial: str | None = None,
-    firmware_version: tuple[int, int] | None = None,
-    storage: DevicePersistenceAsyncFile | None = None,
-    scenario_manager: HierarchicalScenarioManager | None = None,
-) -> EmulatedLifxDevice:
-    """Create an infrared-enabled light (LIFX A19 Night Vision)"""
-    return create_device(
-        29,
-        serial=serial,
-        firmware_version=firmware_version,
-        storage=storage,
-        scenario_manager=scenario_manager,
-    )  # LIFX A19 Night Vision
-
-
-def create_hev_light(
-    serial: str | None = None,
-    firmware_version: tuple[int, int] | None = None,
-    storage: DevicePersistenceAsyncFile | None = None,
-    scenario_manager: HierarchicalScenarioManager | None = None,
-) -> EmulatedLifxDevice:
-    """Create an HEV-enabled light (LIFX Clean)"""
-    return create_device(
-        90,
-        serial=serial,
-        firmware_version=firmware_version,
-        storage=storage,
-        scenario_manager=scenario_manager,
-    )  # LIFX Clean
-
-
-def create_multizone_light(
-    serial: str | None = None,
-    zone_count: int | None = None,
-    extended_multizone: bool = True,
-    firmware_version: tuple[int, int] | None = None,
-    storage: DevicePersistenceAsyncFile | None = None,
-    scenario_manager: HierarchicalScenarioManager | None = None,
-) -> EmulatedLifxDevice:
-    """Create a multizone light (LIFX Beam)
-
-    Args:
-        serial: Optional serial
-        zone_count: Optional zone count (uses product default if not specified)
-        extended_multizone: enables support for extended multizone requests
-        firmware_version: Optional firmware version tuple (major, minor)
-        storage: Optional storage for persistence
-        scenario_manager: Optional scenario manager
-    """
-    return create_device(
-        38,
-        serial=serial,
-        zone_count=zone_count,
-        extended_multizone=extended_multizone,
-        firmware_version=firmware_version,
-        storage=storage,
-        scenario_manager=scenario_manager,
-    )
-
-
-def create_tile_device(
-    serial: str | None = None,
-    tile_count: int | None = None,
-    tile_width: int | None = None,
-    tile_height: int | None = None,
-    firmware_version: tuple[int, int] | None = None,
-    storage: DevicePersistenceAsyncFile | None = None,
-    scenario_manager: HierarchicalScenarioManager | None = None,
-) -> EmulatedLifxDevice:
-    """Create a tile device (LIFX Tile)
-
-    Args:
-        serial: Optional serial
-        tile_count: Optional tile count (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
-    """
-    return create_device(
-        55,
-        serial=serial,
-        tile_count=tile_count,
-        tile_width=tile_width,
-        tile_height=tile_height,
-        firmware_version=firmware_version,
-        storage=storage,
-        scenario_manager=scenario_manager,
-    )  # LIFX Tile
-
-
-def create_color_temperature_light(
-    serial: str | None = None,
-    firmware_version: tuple[int, int] | None = None,
-    storage: DevicePersistenceAsyncFile | None = None,
-    scenario_manager: HierarchicalScenarioManager | None = None,
-) -> EmulatedLifxDevice:
-    """Create a color temperature light (LIFX Mini White to Warm).
-
-    Variable color temperature, no RGB.
-    """
-    return create_device(
-        50,
-        serial=serial,
-        firmware_version=firmware_version,
-        storage=storage,
-        scenario_manager=scenario_manager,
-    )  # 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,
-    zone_count: int | None = None,
-    extended_multizone: bool | None = None,
-    tile_count: int | None = None,
-    tile_width: int | None = None,
-    tile_height: int | None = None,
-    firmware_version: tuple[int, int] | None = None,
-    storage: DevicePersistenceAsyncFile | None = None,
-    scenario_manager: HierarchicalScenarioManager | None = None,
-) -> EmulatedLifxDevice:
-    """Create a device for any LIFX product using the product registry.
-
-    This function uses the DeviceBuilder pattern to construct devices with
-    clean separation of concerns and testable components.
-
-    Args:
-        product_id: Product ID from the LIFX product registry
-        serial: Optional serial (auto-generated if not provided)
-        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 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
-        storage: Optional storage for persistence
-        scenario_manager: Optional scenario manager for testing
-
-    Returns:
-        EmulatedLifxDevice configured for the specified product
-
-    Raises:
-        ValueError: If product_id is not found in registry
-
-    Examples:
-        >>> # Create LIFX A19 (PID 27)
-        >>> device = create_device(27)
-        >>> # Create LIFX Z strip (PID 32) with 24 zones
-        >>> strip = create_device(32, zone_count=24)
-        >>> # Create LIFX Tile (PID 55) with 10 tiles
-        >>> tiles = create_device(55, tile_count=10)
-    """
-    # Get product info from registry
-    product_info = get_product(product_id)
-    if product_info is None:
-        raise ValueError(f"Unknown product ID: {product_id}")
-
-    # Build device using builder pattern
-    builder = DeviceBuilder(product_info)
-
-    if serial is not None:
-        builder.with_serial(serial)
-
-    if zone_count is not None:
-        builder.with_zone_count(zone_count)
-
-    if extended_multizone is not None:
-        builder.with_extended_multizone(extended_multizone)
-
-    if tile_count is not None:
-        builder.with_tile_count(tile_count)
-
-    if tile_width is not None and tile_height is not None:
-        builder.with_tile_dimensions(tile_width, tile_height)
-
-    if firmware_version is not None:
-        builder.with_firmware_version(*firmware_version)
-
-    if storage is not None:
-        builder.with_storage(storage)
-
-    if scenario_manager is not None:
-        builder.with_scenario_manager(scenario_manager)
-
-    return builder.build()

lifx_emulator/factories/firmware_config.py

@@ -1,77 +0,0 @@
-"""Firmware version configuration for devices."""
-
-from __future__ import annotations
-
-from lifx_emulator.products.specs import get_default_firmware_version
-
-
-class FirmwareConfig:
-    """Determines firmware versions for devices.
-
-    Extended multizone support requires firmware 3.70+.
-    Devices without extended multizone use firmware 2.60.
-
-    Examples:
-        >>> config = FirmwareConfig()
-        >>> major, minor = config.get_firmware_version(extended_multizone=True)
-        >>> (major, minor)
-        (3, 70)
-        >>> major, minor = config.get_firmware_version(extended_multizone=False)
-        >>> (major, minor)
-        (2, 60)
-    """
-
-    # Firmware versions
-    VERSION_EXTENDED = (3, 70)  # Extended multizone support
-    VERSION_LEGACY = (2, 60)  # Legacy firmware
-
-    def get_firmware_version(
-        self,
-        product_id: int | None = None,
-        extended_multizone: bool | None = None,
-        override: tuple[int, int] | None = None,
-    ) -> tuple[int, int]:
-        """Get firmware version based on product specs or extended multizone support.
-
-        Precedence order:
-        1. Explicit override parameter
-        2. Product-specific default from specs.yml
-        3. Extended multizone flag (3.70 for True/None, 2.60 for False)
-
-        Args:
-            product_id: Optional product ID to check specs for defaults
-            extended_multizone: Whether device supports extended multizone.
-                               None or True defaults to 3.70, False gives 2.60
-            override: Optional explicit firmware version to use
-
-        Returns:
-            Tuple of (major, minor) firmware version
-
-        Examples:
-            >>> config = FirmwareConfig()
-            >>> config.get_firmware_version(extended_multizone=True)
-            (3, 70)
-            >>> config.get_firmware_version(extended_multizone=False)
-            (2, 60)
-            >>> config.get_firmware_version(override=(4, 0))
-            (4, 0)
-            >>> # With product_id, uses specs if defined
-            >>> config.get_firmware_version(product_id=27)  # doctest: +SKIP
-            (3, 70)
-        """
-        # Explicit override takes precedence
-        if override is not None:
-            return override
-
-        # Check product-specific defaults from specs
-        if product_id is not None:
-            specs_version = get_default_firmware_version(product_id)
-            if specs_version is not None:
-                return specs_version
-
-        # None or True defaults to extended (3.70)
-        # Only explicit False gives legacy (2.60)
-        if extended_multizone is False:
-            return self.VERSION_LEGACY
-        else:
-            return self.VERSION_EXTENDED

lifx_emulator/factories/serial_generator.py

@@ -1,82 +0,0 @@
-"""Serial number generation service for LIFX devices."""
-
-from __future__ import annotations
-
-import random
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from lifx_emulator.products.registry import ProductInfo
-
-
-class SerialGenerator:
-    """Generates serial numbers for emulated LIFX devices.
-
-    Serial numbers are 12-character hex strings with different prefixes
-    based on device capabilities for easier identification.
-
-    Prefixes:
-        - d073d9: Matrix/Tile devices
-        - d073d8: Multizone devices (strips/beams)
-        - d073d7: HEV devices
-        - d073d6: Infrared devices
-        - d073d5: Regular color/temperature lights
-
-    Examples:
-        >>> generator = SerialGenerator()
-        >>> serial = generator.generate(product_info)
-        >>> len(serial)
-        12
-        >>> serial.startswith("d073d")
-        True
-    """
-
-    # Device type prefixes for easy identification
-    PREFIX_MATRIX = "d073d9"
-    PREFIX_MULTIZONE = "d073d8"
-    PREFIX_HEV = "d073d7"
-    PREFIX_INFRARED = "d073d6"
-    PREFIX_DEFAULT = "d073d5"
-
-    def generate(self, product_info: ProductInfo) -> str:
-        """Generate a serial number based on product capabilities.
-
-        Args:
-            product_info: Product information from registry
-
-        Returns:
-            12-character hex serial number
-
-        Examples:
-            >>> from lifx_emulator.products.registry import get_product
-            >>> generator = SerialGenerator()
-            >>> product = get_product(55)  # LIFX Tile
-            >>> serial = generator.generate(product)
-            >>> serial.startswith("d073d9")  # Matrix prefix
-            True
-        """
-        prefix = self._determine_prefix(product_info)
-        suffix = random.randint(100000, 999999)  # nosec
-        return f"{prefix}{suffix:06x}"
-
-    def _determine_prefix(self, product_info: ProductInfo) -> str:
-        """Determine the prefix based on product capabilities.
-
-        Precedence: matrix > multizone > hev > infrared > default
-
-        Args:
-            product_info: Product information from registry
-
-        Returns:
-            6-character hex prefix
-        """
-        if product_info.has_matrix:
-            return self.PREFIX_MATRIX
-        elif product_info.has_multizone:
-            return self.PREFIX_MULTIZONE
-        elif product_info.has_hev:
-            return self.PREFIX_HEV
-        elif product_info.has_infrared:
-            return self.PREFIX_INFRARED
-        else:
-            return self.PREFIX_DEFAULT

lifx_emulator/handlers/__init__.py

@@ -1,39 +0,0 @@
-"""Packet handler infrastructure using Strategy pattern.
-
-This module provides the base classes and registry for handling LIFX protocol packets.
-Each packet type has a dedicated handler class that implements the business logic.
-"""
-
-from lifx_emulator.handlers.base import PacketHandler
-from lifx_emulator.handlers.device_handlers import ALL_DEVICE_HANDLERS
-from lifx_emulator.handlers.light_handlers import ALL_LIGHT_HANDLERS
-from lifx_emulator.handlers.multizone_handlers import ALL_MULTIZONE_HANDLERS
-from lifx_emulator.handlers.registry import HandlerRegistry
-from lifx_emulator.handlers.tile_handlers import ALL_TILE_HANDLERS
-
-__all__ = [
-    "PacketHandler",
-    "HandlerRegistry",
-    "ALL_DEVICE_HANDLERS",
-    "ALL_LIGHT_HANDLERS",
-    "ALL_MULTIZONE_HANDLERS",
-    "ALL_TILE_HANDLERS",
-    "create_default_registry",
-]
-
-
-def create_default_registry() -> HandlerRegistry:
-    """Create a handler registry with all default handlers registered.
-
-    Returns:
-        HandlerRegistry with all built-in handlers
-    """
-    registry = HandlerRegistry()
-
-    # Register all handler categories
-    registry.register_all(ALL_DEVICE_HANDLERS)
-    registry.register_all(ALL_LIGHT_HANDLERS)
-    registry.register_all(ALL_MULTIZONE_HANDLERS)
-    registry.register_all(ALL_TILE_HANDLERS)
-
-    return registry

lifx_emulator/handlers/base.py

@@ -1,49 +0,0 @@
-"""Base classes for packet handlers."""
-
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, Any
-
-if TYPE_CHECKING:
-    from lifx_emulator.devices import DeviceState
-
-
-class PacketHandler(ABC):
-    """Base class for all packet handlers.
-
-    Each handler implements the logic for processing a specific packet type
-    and optionally generating a response packet.
-
-    Handlers are stateless and operate on the provided DeviceState.
-    """
-
-    # Subclasses must define the packet type they handle
-    PKT_TYPE: int
-
-    @abstractmethod
-    def handle(
-        self, device_state: DeviceState, packet: Any | None, res_required: bool
-    ) -> list[Any]:
-        """Handle the packet and return response packet(s).
-
-        Args:
-            device_state: Current device state to read/modify
-            packet: Unpacked packet object (None for packets with no payload)
-            res_required: Whether client requested a response (res_required
-                         flag from header)
-
-        Returns:
-            List of response packets (empty list if no response needed).
-            This unified return type simplifies packet processing logic.
-
-        Notes:
-            - Handlers should modify device_state directly for SET operations
-            - Handlers should check device capabilities before processing
-            - Return empty list [] if the device doesn't support this packet type
-            - Always return a list, even for single responses: [packet]
-        """
-        pass
-
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(PKT_TYPE={self.PKT_TYPE})"