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

lifx_emulator/handlers/multizone_handlers.py

@@ -1,249 +0,0 @@
-"""MultiZone packet handlers."""
-
-from __future__ import annotations
-
-import logging
-from typing import TYPE_CHECKING, Any
-
-from lifx_emulator.handlers.base import PacketHandler
-from lifx_emulator.protocol.packets import MultiZone
-from lifx_emulator.protocol.protocol_types import (
-    LightHsbk,
-    MultiZoneEffectParameter,
-    MultiZoneEffectSettings,
-    MultiZoneEffectType,
-)
-
-if TYPE_CHECKING:
-    from lifx_emulator.devices import DeviceState
-
-logger = logging.getLogger(__name__)
-
-
-class GetColorZonesHandler(PacketHandler):
-    """Handle MultiZoneGetColorZones (502) -> StateMultiZone (506) packets."""
-
-    PKT_TYPE = MultiZone.GetColorZones.PKT_TYPE
-
-    def handle(
-        self,
-        device_state: DeviceState,
-        packet: MultiZone.GetColorZones | None,
-        res_required: bool,
-    ) -> list[Any]:
-        if not device_state.has_multizone:
-            return []
-
-        start_index = packet.start_index if packet else 0
-        end_index = packet.end_index if packet else 0
-
-        # Return multiple StateMultiZone packets, each containing up to 8 zones
-        responses = []
-
-        # Send packets of up to 8 zones each (StateMultiZone format)
-        index = start_index
-        while index <= end_index and index < device_state.zone_count:
-            # Collect up to 8 zones for this packet
-            colors = []
-            for i in range(8):
-                zone_index = index + i
-                if zone_index < device_state.zone_count and zone_index <= end_index:
-                    zone_color = (
-                        device_state.zone_colors[zone_index]
-                        if zone_index < len(device_state.zone_colors)
-                        else LightHsbk(hue=0, saturation=0, brightness=0, kelvin=3500)
-                    )
-                    colors.append(zone_color)
-                else:
-                    # Pad remaining slots with black
-                    colors.append(
-                        LightHsbk(hue=0, saturation=0, brightness=0, kelvin=3500)
-                    )
-
-            # Pad to exactly 8 colors
-            while len(colors) < 8:
-                colors.append(LightHsbk(hue=0, saturation=0, brightness=0, kelvin=3500))
-
-            packet_obj = MultiZone.StateMultiZone(
-                count=device_state.zone_count, index=index, colors=colors
-            )
-            responses.append(packet_obj)
-
-            index += 8
-
-        return responses
-
-
-class SetColorZonesHandler(PacketHandler):
-    """Handle MultiZoneSetColorZones (501)."""
-
-    PKT_TYPE = MultiZone.SetColorZones.PKT_TYPE
-
-    def handle(
-        self,
-        device_state: DeviceState,
-        packet: MultiZone.SetColorZones | None,
-        res_required: bool,
-    ) -> list[Any]:
-        if not device_state.has_multizone:
-            return []
-
-        if packet:
-            start_index = packet.start_index
-            end_index = packet.end_index
-
-            # Update zone colors
-            for i in range(start_index, min(end_index + 1, device_state.zone_count)):
-                if i < len(device_state.zone_colors):
-                    device_state.zone_colors[i] = packet.color
-
-            logger.info(
-                f"MultiZone set zones {start_index}-{end_index} to color, "
-                f"duration={packet.duration}ms"
-            )
-
-        if res_required and packet:
-            # Create a GetColorZones packet to reuse the get handler
-            get_packet = MultiZone.GetColorZones(
-                start_index=packet.start_index, end_index=packet.end_index
-            )
-            # Reuse GetColorZonesHandler
-            handler = GetColorZonesHandler()
-            return handler.handle(device_state, get_packet, res_required)
-        return []
-
-
-class ExtendedGetColorZonesHandler(PacketHandler):
-    """Handle MultiZoneExtendedGetColorZones (511) -> ExtendedStateMultiZone (512)."""
-
-    PKT_TYPE = MultiZone.ExtendedGetColorZones.PKT_TYPE
-
-    def handle(
-        self, device_state: DeviceState, packet: Any | None, res_required: bool
-    ) -> list[Any]:
-        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,
-            )
-        ]
-
-
-class ExtendedSetColorZonesHandler(PacketHandler):
-    """Handle MultiZoneExtendedSetColorZones (510)."""
-
-    PKT_TYPE = MultiZone.ExtendedSetColorZones.PKT_TYPE
-
-    def handle(
-        self,
-        device_state: DeviceState,
-        packet: MultiZone.ExtendedSetColorZones | None,
-        res_required: bool,
-    ) -> list[Any]:
-        if not device_state.has_multizone:
-            return []
-
-        if packet:
-            # Update zone colors from packet
-            for i, color in enumerate(packet.colors[: packet.colors_count]):
-                zone_index = packet.index + i
-                if zone_index < len(device_state.zone_colors):
-                    device_state.zone_colors[zone_index] = color
-
-            logger.info(
-                f"MultiZone extended set {packet.colors_count} zones "
-                f"from index {packet.index}, duration={packet.duration}ms"
-            )
-
-        if res_required:
-            handler = ExtendedGetColorZonesHandler()
-            return handler.handle(device_state, None, res_required)
-        return []
-
-
-class GetEffectHandler(PacketHandler):
-    """Handle MultiZoneGetEffect (507) -> StateEffect (509)."""
-
-    PKT_TYPE = MultiZone.GetEffect.PKT_TYPE
-
-    def handle(
-        self, device_state: DeviceState, packet: Any | None, res_required: bool
-    ) -> list[Any]:
-        if not device_state.has_multizone:
-            return []
-
-        # Create effect settings
-        parameter = MultiZoneEffectParameter(
-            parameter0=0,
-            parameter1=0,
-            parameter2=0,
-            parameter3=0,
-            parameter4=0,
-            parameter5=0,
-            parameter6=0,
-            parameter7=0,
-        )
-        settings = MultiZoneEffectSettings(
-            instanceid=0,
-            type=MultiZoneEffectType(device_state.multizone_effect_type),
-            speed=device_state.multizone_effect_speed * 1000,  # convert to milliseconds
-            duration=0,  # infinite
-            parameter=parameter,
-        )
-
-        return [MultiZone.StateEffect(settings=settings)]
-
-
-class SetEffectHandler(PacketHandler):
-    """Handle MultiZoneSetEffect (508) -> StateEffect (509)."""
-
-    PKT_TYPE = MultiZone.SetEffect.PKT_TYPE
-
-    def handle(
-        self,
-        device_state: DeviceState,
-        packet: MultiZone.SetEffect | None,
-        res_required: bool,
-    ) -> list[Any]:
-        if not device_state.has_multizone:
-            return []
-
-        if packet:
-            device_state.multizone_effect_type = int(packet.settings.type)
-            device_state.multizone_effect_speed = (
-                packet.settings.speed // 1000
-            )  # convert to seconds
-
-            logger.info(
-                f"MultiZone effect set: type={packet.settings.type}, "
-                f"speed={packet.settings.speed}ms"
-            )
-
-        if res_required:
-            handler = GetEffectHandler()
-            return handler.handle(device_state, None, res_required)
-        return []
-
-
-# List of all multizone handlers for easy registration
-ALL_MULTIZONE_HANDLERS = [
-    GetColorZonesHandler(),
-    SetColorZonesHandler(),
-    ExtendedGetColorZonesHandler(),
-    ExtendedSetColorZonesHandler(),
-    GetEffectHandler(),
-    SetEffectHandler(),
-]

lifx_emulator/handlers/registry.py

@@ -1,110 +0,0 @@
-"""Handler registry for managing packet handlers."""
-
-from __future__ import annotations
-
-import logging
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from lifx_emulator.handlers.base import PacketHandler
-
-logger = logging.getLogger(__name__)
-
-
-class HandlerRegistry:
-    """Registry for packet handlers using Strategy pattern.
-
-    The registry maps packet type numbers to handler instances.
-    Handlers can be registered individually or in bulk.
-
-    Example:
-        >>> registry = HandlerRegistry()
-        >>> registry.register(GetServiceHandler())
-        >>> handler = registry.get_handler(2)  # Device.GetService
-        >>> response = handler.handle(device_state, None, True)
-    """
-
-    def __init__(self):
-        """Initialize an empty handler registry."""
-        self._handlers: dict[int, PacketHandler] = {}
-
-    def register(self, handler: PacketHandler) -> None:
-        """Register a packet handler.
-
-        Args:
-            handler: Handler instance to register
-
-        Raises:
-            ValueError: If handler doesn't have PKT_TYPE attribute
-
-        Note:
-            If a handler for this packet type already exists, it will be replaced.
-        """
-        if not hasattr(handler, "PKT_TYPE"):
-            raise ValueError(
-                f"Handler {handler.__class__.__name__} missing PKT_TYPE attribute"
-            )
-
-        pkt_type = handler.PKT_TYPE
-
-        # Warn if replacing existing handler
-        if pkt_type in self._handlers:
-            old_handler = self._handlers[pkt_type]
-            logger.warning(
-                f"Replacing handler for packet type {pkt_type}: "
-                f"{old_handler.__class__.__name__} -> {handler.__class__.__name__}"
-            )
-
-        self._handlers[pkt_type] = handler
-        logger.debug(
-            f"Registered {handler.__class__.__name__} for packet type {pkt_type}"
-        )
-
-    def register_all(self, handlers: list[PacketHandler]) -> None:
-        """Register multiple handlers at once.
-
-        Args:
-            handlers: List of handler instances to register
-        """
-        for handler in handlers:
-            self.register(handler)
-
-    def get_handler(self, pkt_type: int) -> PacketHandler | None:
-        """Get handler for a packet type.
-
-        Args:
-            pkt_type: Packet type number
-
-        Returns:
-            Handler instance if registered, None otherwise
-        """
-        return self._handlers.get(pkt_type)
-
-    def has_handler(self, pkt_type: int) -> bool:
-        """Check if a handler is registered for a packet type.
-
-        Args:
-            pkt_type: Packet type number
-
-        Returns:
-            True if handler is registered, False otherwise
-        """
-        return pkt_type in self._handlers
-
-    def list_handlers(self) -> list[tuple[int, str]]:
-        """List all registered handlers.
-
-        Returns:
-            List of (packet_type, handler_class_name) tuples
-        """
-        return [
-            (pkt_type, handler.__class__.__name__)
-            for pkt_type, handler in sorted(self._handlers.items())
-        ]
-
-    def __len__(self) -> int:
-        """Return number of registered handlers."""
-        return len(self._handlers)
-
-    def __repr__(self) -> str:
-        return f"HandlerRegistry({len(self)} handlers)"