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

lifx_emulator/server.py

@@ -1,464 +0,0 @@
-"""UDP server that emulates LIFX devices."""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-import time
-from collections import defaultdict
-from typing import Any
-
-from lifx_emulator.constants import LIFX_HEADER_SIZE, LIFX_UDP_PORT
-from lifx_emulator.devices import (
-    ActivityLogger,
-    ActivityObserver,
-    EmulatedLifxDevice,
-    IDeviceManager,
-    NullObserver,
-    PacketEvent,
-)
-from lifx_emulator.protocol.header import LifxHeader
-from lifx_emulator.protocol.packets import get_packet_class
-from lifx_emulator.repositories import IScenarioStorageBackend
-from lifx_emulator.scenarios import HierarchicalScenarioManager
-
-logger = logging.getLogger(__name__)
-
-
-def _get_packet_type_name(pkt_type: int) -> str:
-    """Get human-readable name for packet type.
-
-    Args:
-        pkt_type: Packet type number
-
-    Returns:
-        Packet class name or "Unknown"
-    """
-    packet_class = get_packet_class(pkt_type)
-    if packet_class:
-        return packet_class.__qualname__  # e.g., "Device.GetService"
-    return f"Unknown({pkt_type})"
-
-
-def _format_packet_fields(packet: Any) -> str:
-    """Format packet fields for logging, excluding reserved fields.
-
-    Args:
-        packet: Packet instance to format
-
-    Returns:
-        Formatted string with field names and values
-    """
-    if packet is None:
-        return "no payload"
-
-    fields = []
-    for field_item in packet._fields:
-        # Skip reserved fields (no name)
-        if "name" not in field_item:
-            continue
-
-        # Get field value
-        field_name = packet._protocol_to_python_name(field_item["name"])
-        value = getattr(packet, field_name, None)
-
-        # Format value based on type
-        if isinstance(value, bytes):
-            # For bytes, show hex if short, or length if long
-            if len(value) <= 8:
-                value_str = value.hex()
-            else:
-                value_str = f"<{len(value)} bytes>"
-        elif isinstance(value, list):
-            # For lists, show count and sample
-            if len(value) <= 3:
-                value_str = str(value)
-            else:
-                value_str = f"[{len(value)} items]"
-        elif hasattr(value, "__dict__"):
-            # For nested objects, show their string representation
-            value_str = str(value)
-        else:
-            value_str = str(value)
-
-        fields.append(f"{field_name}={value_str}")
-
-    return ", ".join(fields) if fields else "no fields"
-
-
-class EmulatedLifxServer:
-    """UDP server that simulates LIFX devices"""
-
-    def __init__(
-        self,
-        devices: list[EmulatedLifxDevice],
-        device_manager: IDeviceManager,
-        bind_address: str = "127.0.0.1",
-        port: int = LIFX_UDP_PORT,
-        track_activity: bool = True,
-        storage=None,
-        activity_observer: ActivityObserver | None = None,
-        scenario_manager: HierarchicalScenarioManager | None = None,
-        persist_scenarios: bool = False,
-        scenario_storage: IScenarioStorageBackend | None = None,
-    ):
-        # Device manager (required dependency injection)
-        self._device_manager = device_manager
-        self.bind_address = bind_address
-        self.port = port
-        self.transport = None
-        self.storage = storage
-
-        # Scenario storage backend (optional - only needed for persistence)
-        self.scenario_persistence: IScenarioStorageBackend | None = None
-        if persist_scenarios:
-            if scenario_storage is None:
-                raise ValueError(
-                    "scenario_storage is required when persist_scenarios=True"
-                )
-            if scenario_manager is None:
-                raise ValueError(
-                    "scenario_manager is required when persist_scenarios=True "
-                    "(must be pre-loaded from storage before server initialization)"
-                )
-            self.scenario_persistence = scenario_storage
-
-        # Scenario manager (shared across all devices for runtime updates)
-        self.scenario_manager = scenario_manager or HierarchicalScenarioManager()
-
-        # Add initial devices to the device manager
-        for device in devices:
-            self._device_manager.add_device(device, self.scenario_manager)
-
-        # Activity observer - defaults to ActivityLogger if track_activity=True
-        if activity_observer is not None:
-            self.activity_observer = activity_observer
-        elif track_activity:
-            self.activity_observer = ActivityLogger(max_events=100)
-        else:
-            self.activity_observer = NullObserver()
-
-        # Statistics tracking
-        self.start_time = time.time()
-        self.packets_received = 0
-        self.packets_sent = 0
-        self.packets_received_by_type: dict[int, int] = defaultdict(int)
-        self.packets_sent_by_type: dict[int, int] = defaultdict(int)
-        self.error_count = 0
-
-    class LifxProtocol(asyncio.DatagramProtocol):
-        def __init__(self, server):
-            self.server = server
-            self.loop = None
-
-        def connection_made(self, transport):
-            self.transport = transport
-            self.server.transport = transport
-            # Cache event loop reference for optimized task scheduling
-            try:
-                self.loop = asyncio.get_running_loop()
-            except RuntimeError:
-                # No running loop yet (happens in tests or edge cases)
-                self.loop = None
-            logger.info(
-                "LIFX emulated server listening on %s:%s",
-                self.server.bind_address,
-                self.server.port,
-            )
-
-        def datagram_received(self, data, addr):
-            # Use direct loop scheduling for lower task creation overhead
-            # This is faster than asyncio.create_task() for high-frequency packets
-            if self.loop:
-                self.loop.call_soon(
-                    self.loop.create_task, self.server.handle_packet(data, addr)
-                )
-            else:
-                # Fallback for edge case where loop not yet cached
-                asyncio.create_task(self.server.handle_packet(data, addr))
-
-    async def _process_device_packet(
-        self,
-        device: EmulatedLifxDevice,
-        header: LifxHeader,
-        packet: Any | None,
-        addr: tuple[str, int],
-    ):
-        """Process packet for a single device and send responses.
-
-        Args:
-            device: The device to process the packet
-            header: Parsed LIFX header
-            packet: Parsed packet payload (or None)
-            addr: Client address (host, port)
-        """
-        responses = device.process_packet(header, packet)
-
-        # Get resolved scenario for response delays
-        scenario = device._get_resolved_scenario()
-
-        # Send responses with delay if configured
-        for resp_header, resp_packet in responses:
-            delay = scenario.response_delays.get(resp_header.pkt_type, 0.0)
-            if delay > 0:
-                await asyncio.sleep(delay)
-
-            # Pack the response packet
-            resp_payload = resp_packet.pack() if resp_packet else b""
-            response_data = resp_header.pack() + resp_payload
-            if self.transport:
-                self.transport.sendto(response_data, addr)
-
-            # Update statistics
-            self.packets_sent += 1
-            self.packets_sent_by_type[resp_header.pkt_type] += 1
-
-            # Log sent packet with details
-            resp_packet_name = _get_packet_type_name(resp_header.pkt_type)
-            resp_fields_str = _format_packet_fields(resp_packet)
-            logger.debug(
-                "→ TX %s to %s:%s (target=%s, seq=%s) [%s]",
-                resp_packet_name,
-                addr[0],
-                addr[1],
-                device.state.serial,
-                resp_header.sequence,
-                resp_fields_str,
-            )
-
-            # Notify observer
-            self.activity_observer.on_packet_sent(
-                PacketEvent(
-                    timestamp=time.time(),
-                    direction="tx",
-                    packet_type=resp_header.pkt_type,
-                    packet_name=resp_packet_name,
-                    addr=f"{addr[0]}:{addr[1]}",
-                    device=device.state.serial,
-                )
-            )
-
-    async def handle_packet(self, data: bytes, addr: tuple[str, int]):
-        """Handle incoming UDP packet"""
-        try:
-            # Update statistics
-            self.packets_received += 1
-
-            if len(data) < LIFX_HEADER_SIZE:
-                logger.warning("Packet too short: %s bytes from %s", len(data), addr)
-                self.error_count += 1
-                return
-
-            # Parse header
-            header = LifxHeader.unpack(data)
-            payload = (
-                data[LIFX_HEADER_SIZE : header.size]
-                if header.size > LIFX_HEADER_SIZE
-                else b""
-            )
-
-            # Unpack payload into packet object
-            packet = None
-            packet_class = get_packet_class(header.pkt_type)
-
-            # Update packet type statistics
-            self.packets_received_by_type[header.pkt_type] += 1
-
-            if packet_class:
-                if payload:
-                    try:
-                        packet = packet_class.unpack(payload)
-                    except Exception as e:
-                        logger.warning(
-                            "Failed to unpack %s (type %s) from %s:%s: %s",
-                            _get_packet_type_name(header.pkt_type),
-                            header.pkt_type,
-                            addr[0],
-                            addr[1],
-                            e,
-                        )
-                        logger.debug(
-                            "Raw payload (%s bytes): %s", len(payload), payload.hex()
-                        )
-                        return
-                # else: packet_class exists but no payload (valid for some packet types)
-            else:
-                # Unknown packet type - log it with raw payload
-                target_str = "broadcast" if header.tagged else header.target.hex()
-                logger.warning(
-                    "← RX Unknown packet type %s from %s:%s (target=%s, seq=%s)",
-                    header.pkt_type,
-                    addr[0],
-                    addr[1],
-                    target_str,
-                    header.sequence,
-                )
-                if payload:
-                    logger.info(
-                        "Unknown packet payload (%s bytes): %s",
-                        len(payload),
-                        payload.hex(),
-                    )
-                # Continue processing - device might still want to respond or log it
-
-            # Log received packet with details
-            packet_name = _get_packet_type_name(header.pkt_type)
-            target_str = (
-                "broadcast" if header.tagged else header.target.hex().rstrip("0000")
-            )
-            fields_str = _format_packet_fields(packet)
-            logger.debug(
-                "← RX %s from %s:%s (target=%s, seq=%s) [%s]",
-                packet_name,
-                addr[0],
-                addr[1],
-                target_str,
-                header.sequence,
-                fields_str,
-            )
-
-            # Notify observer
-            self.activity_observer.on_packet_received(
-                PacketEvent(
-                    timestamp=time.time(),
-                    direction="rx",
-                    packet_type=header.pkt_type,
-                    packet_name=packet_name,
-                    addr=f"{addr[0]}:{addr[1]}",
-                    target=target_str,
-                )
-            )
-
-            # Determine target devices using device manager
-            target_devices = self._device_manager.resolve_target_devices(header)
-
-            # Process packet for each target device
-            # Use parallel processing for broadcasts to improve scalability
-            if len(target_devices) > 1:
-                # Broadcast: process all devices concurrently (limited by GIL)
-                tasks = [
-                    self._process_device_packet(device, header, packet, addr)
-                    for device in target_devices
-                ]
-                await asyncio.gather(*tasks)
-            elif target_devices:
-                # Single device: process directly without task overhead
-                await self._process_device_packet(
-                    target_devices[0], header, packet, addr
-                )
-
-        except Exception as e:
-            self.error_count += 1
-            logger.error("Error handling packet from %s: %s", addr, e, exc_info=True)
-
-    def add_device(self, device: EmulatedLifxDevice) -> bool:
-        """Add a device to the server.
-
-        Args:
-            device: The device to add
-
-        Returns:
-            True if added, False if device with same serial already exists
-        """
-        return self._device_manager.add_device(device, self.scenario_manager)
-
-    def remove_device(self, serial: str) -> bool:
-        """Remove a device from the server.
-
-        Args:
-            serial: Serial number of device to remove (12 hex chars)
-
-        Returns:
-            True if removed, False if device not found
-        """
-        return self._device_manager.remove_device(serial, self.storage)
-
-    def remove_all_devices(self, delete_storage: bool = False) -> int:
-        """Remove all devices from the server.
-
-        Args:
-            delete_storage: If True, also delete persistent storage files
-
-        Returns:
-            Number of devices removed
-        """
-        return self._device_manager.remove_all_devices(delete_storage, self.storage)
-
-    def get_device(self, serial: str) -> EmulatedLifxDevice | None:
-        """Get a device by serial number.
-
-        Args:
-            serial: Serial number (12 hex chars)
-
-        Returns:
-            Device if found, None otherwise
-        """
-        return self._device_manager.get_device(serial)
-
-    def get_all_devices(self) -> list[EmulatedLifxDevice]:
-        """Get all devices.
-
-        Returns:
-            List of all devices
-        """
-        return self._device_manager.get_all_devices()
-
-    def invalidate_all_scenario_caches(self) -> None:
-        """Invalidate scenario cache for all devices.
-
-        This should be called when scenario configuration changes to ensure
-        devices reload their scenario settings from the scenario manager.
-        """
-        self._device_manager.invalidate_all_scenario_caches()
-
-    def get_stats(self) -> dict[str, Any]:
-        """Get server statistics.
-
-        Returns:
-            Dictionary with statistics
-        """
-        uptime = time.time() - self.start_time
-        return {
-            "uptime_seconds": uptime,
-            "start_time": self.start_time,
-            "device_count": self._device_manager.count_devices(),
-            "packets_received": self.packets_received,
-            "packets_sent": self.packets_sent,
-            "packets_received_by_type": dict(self.packets_received_by_type),
-            "packets_sent_by_type": dict(self.packets_sent_by_type),
-            "error_count": self.error_count,
-            "activity_enabled": isinstance(self.activity_observer, ActivityLogger),
-        }
-
-    def get_recent_activity(self) -> list[dict[str, Any]]:
-        """Get recent activity events.
-
-        Returns:
-            List of activity event dictionaries, or empty list if observer
-            doesn't support activity tracking
-        """
-        if isinstance(self.activity_observer, ActivityLogger):
-            return self.activity_observer.get_recent_activity()
-        return []
-
-    async def start(self):
-        """Start the server"""
-        loop = asyncio.get_running_loop()
-        self.transport, _ = await loop.create_datagram_endpoint(
-            lambda: self.LifxProtocol(self), local_addr=(self.bind_address, self.port)
-        )
-
-    async def stop(self):
-        """Stop the server"""
-        if self.transport:
-            self.transport.close()
-
-    async def __aenter__(self):
-        """Async context manager entry"""
-        await self.start()
-        return self
-
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        """Async context manager exit"""
-        await self.stop()
-        return False

lifx_emulator-2.3.1.dist-info/METADATA

@@ -1,107 +0,0 @@
-Metadata-Version: 2.4
-Name: lifx-emulator
-Version: 2.3.1
-Summary: LIFX Emulator for testing LIFX LAN protocol libraries
-Author-email: Avi Miller <me@dje.li>
-Maintainer-email: Avi Miller <me@dje.li>
-License-Expression: UPL-1.0
-License-File: LICENSE
-Classifier: Framework :: AsyncIO
-Classifier: Framework :: Pytest
-Classifier: Intended Audience :: Developers
-Classifier: Natural Language :: English
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
-Classifier: Topic :: Software Development :: Libraries
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Typing :: Typed
-Requires-Python: >=3.11
-Requires-Dist: cyclopts>=4.2.0
-Requires-Dist: fastapi>=0.115.0
-Requires-Dist: pyyaml>=6.0.3
-Requires-Dist: rich>=14.2.0
-Requires-Dist: uvicorn>=0.34.0
-Description-Content-Type: text/markdown
-
-# LIFX Emulator
-
-> A comprehensive LIFX device emulator for testing LIFX LAN protocol libraries
-
-[![Codecov](https://codecov.io/gh/Djelibeybi/lifx-emulator/branch/main/graph/badge.svg)](https://codecov.io/gh/Djelibeybi/lifx-emulator)
-[![CI](https://github.com/Djelibeybi/lifx-emulator/actions/workflows/ci.yml/badge.svg)](https://github.com/Djelibeybi/lifx-emulator/actions/workflows/ci.yml)
-[![Docs](https://github.com/Djelibeybi/lifx-emulator/workflows/Documentation/badge.svg)](https://Djelibeybi.github.io/lifx-emulator/)
-
-[![GitHub](https://img.shields.io/github/v/release/Djelibeybi/lifx-emulator)](https://github.com/Djelibeybi/lifx-emulator/releases)
-[![PyPI](https://img.shields.io/pypi/v/lifx-emulator)](https://pypi.org/project/lifx-emulator/)
-[![License](https://img.shields.io/badge/License-UPL--1.0-blue.svg)](LICENSE)
-[![Python](https://img.shields.io/badge/python-3.11%20|%203.12%20|%203.13%20|%203.14-blue)](https://www.python.org)
-## Overview
-
-LIFX Emulator implements the complete binary UDP protocol from [lan.developer.lifx.com](https://lan.developer.lifx.com) by providing virtual LIFX devices for testing without physical hardware. The emulator includes a basic web interface and OpenAPI-compliant REST API for device and scenario management at runtime.
-
-## Features
-
-- **Complete Protocol Support**: 44+ packet types from the LIFX LAN protocol
-- **Multiple Device Types**: Color lights, infrared, HEV, multizone strips, matrix tiles
-- **REST API and Web Interface**:  Monitor and manage your virtual devices during testing
-- **Testing Scenarios**: Built-in support for packet loss, delays, malformed responses
-- **Easy Integration**: Simple Python API and comprehensive CLI
-
-
-## Documentation
-
-- **[Installation Guide](https://djelibeybi.github.io/lifx-emulator/getting-started/installation/)** - Get started
-- **[Quick Start](https://djelibeybi.github.io/lifx-emulator/getting-started/quickstart/)** - Your first emulated device
-- **[User Guide](https://djelibeybi.github.io/lifx-emulator/guide/overview/)** - Product specifications and testing scenarios
-- **[Advanced Topics](https://djelibeybi.github.io/lifx-emulator/advanced/device-management-api/)** - REST API and persistent storage
-- **[CLI Reference](https://djelibeybi.github.io/lifx-emulator/getting-started/cli/)** - All CLI options
-- **[Device Types](https://djelibeybi.github.io/lifx-emulator/guide/device-types/)** - Supported devices
-- **[API Reference](https://djelibeybi.github.io/lifx-emulator/api/)** - Complete API docs
-- **[Architecture](https://djelibeybi.github.io/lifx-emulator/architecture/overview/)** - How it works
-
-
-## Use Cases
-
-- **Library Testing**: Test your LIFX library without physical devices
-- **CI/CD Integration**: Run automated tests in pipelines
-- **Protocol Development**: Experiment with LIFX protocol features
-- **Error Simulation**: Test error handling with configurable scenarios
-- **Performance Testing**: Test concurrent device handling
-
-## Development
-
-```bash
-# Clone repository
-git clone https://github.com/Djelibeybi/lifx-emulator.git
-cd lifx-emulator
-
-# Install with uv (recommended)
-uv sync
-
-# Or with pip
-pip install -e ".[dev]"
-
-# Run tests
-uv run pytest
-
-# Run linter
-uv run ruff check .
-
-# Build docs
-uv run mkdocs serve
-```
-
-
-## License
-
-[UPL-1.0](LICENSE)
-
-## Links
-
-- **Documentation**: https://djelibeybi.github.io/lifx-emulator
-- **GitHub**: https://github.com/Djelibeybi/lifx-emulator
-- **PyPI**: https://pypi.org/project/lifx-emulator/
-- **LIFX Protocol**: https://lan.developer.lifx.com

lifx_emulator-2.3.1.dist-info/RECORD

@@ -1,62 +0,0 @@
-lifx_emulator/__init__.py,sha256=vjhtpAQRSsUZtaUGCQKbmPALvwZ_BF8Mko8w6jzVqBw,819
-lifx_emulator/__main__.py,sha256=C1Khr8MdrDJnRUM5Y-CV1MPf7CqS2qM-vynGDJjdMYg,21678
-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=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
-lifx_emulator/api/routers/devices.py,sha256=i0hFxb9-yA3bbNsk1HyDhHfpAB61o5rObH_vC9gDEpk,4210
-lifx_emulator/api/routers/monitoring.py,sha256=qgVBNm6iMESf1W6EE22DvLalMnxkr0pRbGKu_JDDkPw,1456
-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=h-PeOH_La5bVOUBcXmTY2leRlMdL8D8yJ-NCx3S16-A,33792
-lifx_emulator/devices/__init__.py,sha256=QlBTPnFErJcSKLvGyeDwemh7xcpjYvB_L5siKsjr3s8,1089
-lifx_emulator/devices/device.py,sha256=24rknbLw_EWF8dheED89wvovKjvC2CdfifLvG7g3SiQ,13648
-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=szWmarFjTBZO1UljEdjvS4W-nanYOzgE3P5df36T5bY,12092
-lifx_emulator/factories/__init__.py,sha256=yN8i_Hu_cFEryWZmh0TiOQvWEYFVIApQSs4xeb0EfBk,1170
-lifx_emulator/factories/builder.py,sha256=6b0frEUMnM-RE2yjoVJzKUav3xn9bOElJPOETSG4NWk,12054
-lifx_emulator/factories/default_config.py,sha256=FTcxKDfeTmO49GTSki8nxnEIZQzR0Lg0hL_PwHUrkVQ,4828
-lifx_emulator/factories/factory.py,sha256=Q2Yr21EC2bLOWwLyqqoUIsJKwWt7MTNODERhTRH6llk,7579
-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=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=L4fNKGTSSIxRuqKrfDrMSrNPvDJr3aIuaEqbhRCOt04,17176
-lifx_emulator/products/__init__.py,sha256=qcNop_kRYFF3zSjNemzQEgu3jPrIxfyQyLv9GsnaLEI,627
-lifx_emulator/products/generator.py,sha256=WsbAr2dXXMtLyOlFFkt-xM9kT5WpiUzj6_FKRf16Tng,33536
-lifx_emulator/products/registry.py,sha256=qkm2xgGZo_ds3wAbYplLu4gb0cxhjZXjnCc1V8etpHw,46517
-lifx_emulator/products/specs.py,sha256=epqz2DPyNOOOFHhmI_wlk7iEbgN0vCugHz-hWx9FlAI,8728
-lifx_emulator/products/specs.yml,sha256=-91JNzGhwcO_zybOWY8dFBncN2TnnxtSkkHdi31KT94,9675
-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
-lifx_emulator/protocol/generator.py,sha256=LUkf-1Z5570Vg5iA1QhDZDWQOrABqmukUgk9qH-IJmg,49524
-lifx_emulator/protocol/header.py,sha256=RXMJ5YZG1jyxl4Mz46ZGJBYX41Jdp7J95BHuY-scYC0,5499
-lifx_emulator/protocol/packets.py,sha256=Yv4O-Uqbj0CR7n04vXhfalJVCmTTvJTWkvZBkcwPx-U,41553
-lifx_emulator/protocol/protocol_types.py,sha256=WX1p4fmFcNJURmEV_B7ubi7fgu-w9loXQ89q8DdbeSA,23970
-lifx_emulator/protocol/serializer.py,sha256=2bZz7TddxaMRO4_6LujRGCS1w7GxD4E3rRk3r-hpEIE,10738
-lifx_emulator/repositories/__init__.py,sha256=x-ncM6T_Q7jNrwhK4a1uAyMrTGHHGeUzPSLC4O-kEUw,645
-lifx_emulator/repositories/device_repository.py,sha256=KsXVg2sg7PGSTsK_PvDYeHHwEPM9Qx2ZZF_ORncBrYQ,3929
-lifx_emulator/repositories/storage_backend.py,sha256=wEgjhnBvAxl6aO1ZGL3ou0dW9P2hBPnK8jEE03sOlL4,3264
-lifx_emulator/scenarios/__init__.py,sha256=CGjudoWvyysvFj2xej11N2cr3mYROGtRb9zVHcOHGrQ,665
-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.1.dist-info/METADATA,sha256=L3tETYNKBl5pR1wfSXTsWijV0olIPspASI1du2HMO94,4549
-lifx_emulator-2.3.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-lifx_emulator-2.3.1.dist-info/entry_points.txt,sha256=R9C_K_tTgt6yXEmhzH4r2Yx2Tu1rLlnYzeG4RFUVzSc,62
-lifx_emulator-2.3.1.dist-info/licenses/LICENSE,sha256=eBz48GRA3gSiWn3rYZAz2Ewp35snnhV9cSqkVBq7g3k,1832
-lifx_emulator-2.3.1.dist-info/RECORD,,

lifx_emulator-2.3.1.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-lifx-emulator = lifx_emulator.__main__:main

lifx_emulator-2.3.1.dist-info/licenses/LICENSE

@@ -1,35 +0,0 @@
-Copyright (c) 2025 Avi Miller <me@dje.li>
-
-The Universal Permissive License (UPL), Version 1.0
-
-Subject to the condition set forth below, permission is hereby granted to any
-person obtaining a copy of this software, associated documentation and/or data
-(collectively the "Software"), free of charge and under any and all copyright
-rights in the Software, and any and all patent rights owned or freely
-licensable by each licensor hereunder covering either (i) the unmodified
-Software as contributed to or provided by such licensor, or (ii) the Larger
-Works (as defined below), to deal in both
-
-(a) the Software, and
-(b) any piece of software and/or hardware listed in the lrgrwrks.txt file if
-one is included with the Software (each a "Larger Work" to which the Software
-is contributed by such licensors),
-
-without restriction, including without limitation the rights to copy, create
-derivative works of, display, perform, and distribute the Software and make,
-use, sell, offer for sale, import, export, have made, and have sold the
-Software and the Larger Work(s), and to sublicense the foregoing rights on
-either these or other terms.
-
-This license is subject to the following condition:
-The above copyright notice and either this complete permission notice or at
-a minimum a reference to the UPL must be included in all copies or
-substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.