lifx-emulator-core 3.0.1__py3-none-any.whl

lifx_emulator/server.py

@@ -0,0 +1,464 @@
+"""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_core-3.0.1.dist-info/METADATA

@@ -0,0 +1,99 @@
+Metadata-Version: 2.4
+Name: lifx-emulator-core
+Version: 3.0.1
+Summary: Core LIFX Emulator library 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
+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: Topic :: Software Development :: Testing
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: pyyaml>=6.0.3
+Description-Content-Type: text/markdown
+
+# lifx-emulator-core
+
+Core Python library for emulating LIFX devices using the LAN protocol.
+
+This package provides the embeddable library for creating virtual LIFX devices in your own projects. It implements the binary UDP protocol from the [LIFX LAN Protocol](https://lan.developer.lifx.com) specification.
+
+## Installation
+
+```bash
+pip install lifx-emulator-core
+```
+
+## Quick Start
+
+```python
+import asyncio
+from lifx_emulator import EmulatedLifxServer, DeviceManager
+from lifx_emulator.factories import create_color_light
+from lifx_emulator.repositories import DeviceRepository
+
+async def main():
+    # Create devices
+    devices = [
+        create_color_light(serial="d073d5000001"),
+        create_color_light(serial="d073d5000002"),
+    ]
+
+    # Create repository and manager
+    repository = DeviceRepository()
+    manager = DeviceManager(repository)
+
+    # Start the emulator server
+    server = EmulatedLifxServer(
+        devices=devices,
+        device_manager=manager,
+        bind_address="127.0.0.1",
+        port=56700,
+    )
+
+    await server.start()
+    print("LIFX Emulator running on 127.0.0.1:56700")
+
+    # Keep running until interrupted
+    try:
+        await asyncio.Event().wait()
+    finally:
+        await server.stop()
+
+asyncio.run(main())
+```
+
+## Features
+
+- Emulate color lights, multizone strips, tiles, infrared, HEV, and switch devices
+- Full LIFX LAN protocol implementation
+- Persistent device state storage
+- Testing scenarios for simulating edge cases
+- Product registry with 137+ official LIFX products
+
+## Documentation
+
+Full documentation is available at: **https://djelibeybi.github.io/lifx-emulator**
+
+- [Installation Guide](https://djelibeybi.github.io/lifx-emulator/getting-started/installation/)
+- [Quick Start](https://djelibeybi.github.io/lifx-emulator/getting-started/quickstart/)
+- [API Reference](https://djelibeybi.github.io/lifx-emulator/library/)
+- [Architecture](https://djelibeybi.github.io/lifx-emulator/architecture/)
+
+## Related Packages
+
+- **[lifx-emulator](https://pypi.org/project/lifx-emulator/)**: Standalone CLI tool and HTTP management API built on this library
+
+## License
+
+[UPL-1.0](https://opensource.org/licenses/UPL)

lifx_emulator_core-3.0.1.dist-info/RECORD

@@ -0,0 +1,47 @@
+lifx_emulator/__init__.py,sha256=SSnQg0RiCaID7DhHOGZoVIDQ3_8Lyt0J9cA_2StF63s,824
+lifx_emulator/constants.py,sha256=DFZkUsdewE-x_3MgO28tMGkjUCWPeYc3xLj_EXViGOw,1032
+lifx_emulator/server.py,sha256=r2JYFcpZIqqhue-Nfq7FbN0KfC3XDf3XDb6b43DsiCk,16438
+lifx_emulator/devices/__init__.py,sha256=QlBTPnFErJcSKLvGyeDwemh7xcpjYvB_L5siKsjr3s8,1089
+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=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=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=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=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
+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_core-3.0.1.dist-info/METADATA,sha256=9y8uSmGZxFTONknzHLN1dypHQb-UE6F44PA8OPHINLc,3135
+lifx_emulator_core-3.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+lifx_emulator_core-3.0.1.dist-info/RECORD,,

lifx_emulator_core-3.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any