lifx-emulator 1.0.2__py3-none-any.whl → 2.1.0__py3-none-any.whl

lifx_emulator/{scenario_persistence.py → scenarios/persistence.py}

@@ -1,46 +1,75 @@
-"""Persistence layer for scenario configurations.
+"""Async persistent storage for scenario configurations.
 
-This module provides JSON serialization and deserialization for scenarios,
-allowing them to persist across emulator restarts.
+This module provides async JSON serialization and deserialization for scenarios,
+allowing them to persist across emulator restarts without blocking the event loop.
 """
 
+from __future__ import annotations
+
+import asyncio
 import json
 import logging
+from concurrent.futures import ThreadPoolExecutor
 from pathlib import Path
 from typing import Any
 
-from lifx_emulator.scenario_manager import HierarchicalScenarioManager, ScenarioConfig
+from lifx_emulator.scenarios.manager import HierarchicalScenarioManager, ScenarioConfig
 
 logger = logging.getLogger(__name__)
 
+DEFAULT_STORAGE_DIR = Path.home() / ".lifx-emulator"
+
 
-class ScenarioPersistence:
-    """Handles scenario persistence to disk.
+class ScenarioPersistenceAsyncFile:
+    """Async persistent storage for scenario configurations.
 
+    Non-blocking asynchronous I/O for scenario persistence.
     Scenarios are stored in JSON format at ~/.lifx-emulator/scenarios.json
     with separate sections for each scope level.
+
+    Features:
+    - Async I/O operations (no event loop blocking)
+    - Executor-based I/O for file operations
+    - Atomic writes (write to temp file, then rename)
+    - Graceful error handling and recovery
     """
 
-    def __init__(self, storage_path: Path | None = None):
-        """Initialize scenario persistence.
+    def __init__(self, storage_path: Path | str | None = None):
+        """Initialize async scenario persistence.
 
         Args:
             storage_path: Directory to store scenarios.json
                          Defaults to ~/.lifx-emulator
         """
         if storage_path is None:
-            storage_path = Path.home() / ".lifx-emulator"
+            storage_path = DEFAULT_STORAGE_DIR
 
         self.storage_path = Path(storage_path)
         self.scenario_file = self.storage_path / "scenarios.json"
 
-    def load(self) -> HierarchicalScenarioManager:
-        """Load scenarios from disk.
+        # Single-thread executor for serialized I/O operations
+        self.executor = ThreadPoolExecutor(
+            max_workers=1, thread_name_prefix="scenario-io"
+        )
+
+        logger.debug("Async scenario storage initialized at %s", self.storage_path)
+
+    async def load(self) -> HierarchicalScenarioManager:
+        """Load scenarios from disk (async).
 
         Returns:
             HierarchicalScenarioManager with loaded scenarios.
             If file doesn't exist, returns empty manager.
         """
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(self.executor, self._sync_load)
+
+    def _sync_load(self) -> HierarchicalScenarioManager:
+        """Synchronous load operation (runs in executor).
+
+        Returns:
+            HierarchicalScenarioManager with loaded scenarios
+        """
         manager = HierarchicalScenarioManager()
 
         if not self.scenario_file.exists():
@@ -53,12 +82,14 @@ class ScenarioPersistence:
 
             # Load global scenario
             if "global" in data and data["global"]:
-                manager.global_scenario = ScenarioConfig.from_dict(data["global"])
+                manager.global_scenario = ScenarioConfig.model_validate(data["global"])
                 logger.debug("Loaded global scenario")
 
             # Load device-specific scenarios
             for serial, config_data in data.get("devices", {}).items():
-                manager.device_scenarios[serial] = ScenarioConfig.from_dict(config_data)
+                manager.device_scenarios[serial] = ScenarioConfig.model_validate(
+                    config_data
+                )
             if manager.device_scenarios:
                 logger.debug(
                     "Loaded %s device scenario(s)", len(manager.device_scenarios)
@@ -66,7 +97,7 @@ class ScenarioPersistence:
 
             # Load type-specific scenarios
             for device_type, config_data in data.get("types", {}).items():
-                manager.type_scenarios[device_type] = ScenarioConfig.from_dict(
+                manager.type_scenarios[device_type] = ScenarioConfig.model_validate(
                     config_data
                 )
             if manager.type_scenarios:
@@ -74,7 +105,7 @@ class ScenarioPersistence:
 
             # Load location-specific scenarios
             for location, config_data in data.get("locations", {}).items():
-                manager.location_scenarios[location] = ScenarioConfig.from_dict(
+                manager.location_scenarios[location] = ScenarioConfig.model_validate(
                     config_data
                 )
             if manager.location_scenarios:
@@ -84,7 +115,9 @@ class ScenarioPersistence:
 
             # Load group-specific scenarios
             for group, config_data in data.get("groups", {}).items():
-                manager.group_scenarios[group] = ScenarioConfig.from_dict(config_data)
+                manager.group_scenarios[group] = ScenarioConfig.model_validate(
+                    config_data
+                )
             if manager.group_scenarios:
                 logger.debug(
                     "Loaded %s group scenario(s)", len(manager.group_scenarios)
@@ -100,8 +133,17 @@ class ScenarioPersistence:
             logger.error("Failed to load scenarios from %s: %s", self.scenario_file, e)
             return manager
 
-    def save(self, manager: HierarchicalScenarioManager) -> None:
-        """Save scenarios to disk.
+    async def save(self, manager: HierarchicalScenarioManager) -> None:
+        """Save scenarios to disk (async).
+
+        Args:
+            manager: HierarchicalScenarioManager to save
+        """
+        loop = asyncio.get_running_loop()
+        await loop.run_in_executor(self.executor, self._sync_save, manager)
+
+    def _sync_save(self, manager: HierarchicalScenarioManager) -> None:
+        """Synchronous save operation (runs in executor).
 
         Args:
             manager: HierarchicalScenarioManager to save
@@ -156,8 +198,17 @@ class ScenarioPersistence:
             logger.error("Failed to save scenarios to %s: %s", self.scenario_file, e)
             raise
 
-    def delete(self) -> bool:
-        """Delete the scenario file.
+    async def delete(self) -> bool:
+        """Delete the scenario file (async).
+
+        Returns:
+            True if file was deleted, False if it didn't exist
+        """
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(self.executor, self._sync_delete)
+
+    def _sync_delete(self) -> bool:
+        """Synchronous delete operation (runs in executor).
 
         Returns:
             True if file was deleted, False if it didn't exist
@@ -172,35 +223,19 @@ class ScenarioPersistence:
                 raise
         return False
 
+    async def shutdown(self) -> None:
+        """Gracefully shutdown executor.
 
-def _deserialize_response_delays(data: dict[str, Any]) -> dict[int, float]:
-    """Convert string keys back to integers for response_delays.
-
-    JSON only supports string keys, so we convert them back to ints.
-
-    Args:
-        data: Dictionary with string keys
-
-    Returns:
-        Dictionary with integer keys
-    """
-    if not data:
-        return {}
-    return {int(k): v for k, v in data.items()}
-
-
-# Monkey-patch ScenarioConfig.from_dict to handle string keys
-_original_from_dict = ScenarioConfig.from_dict
+        This should be called before the application exits.
+        """
+        logger.info("Shutting down async scenario storage...")
 
+        # Shutdown executor (non-blocking to avoid hanging on Windows)
+        loop = asyncio.get_running_loop()
+        await loop.run_in_executor(None, self.executor.shutdown, True)
 
-@classmethod
-def _from_dict_with_conversion(cls, data: dict[str, Any]) -> ScenarioConfig:
-    """Create from dictionary with int key conversion."""
-    # Convert response_delays string keys to ints
-    if "response_delays" in data and data["response_delays"]:
-        data = data.copy()
-        data["response_delays"] = _deserialize_response_delays(data["response_delays"])
-    return _original_from_dict(data)
+        logger.info("Async scenario storage shutdown complete")
 
 
-ScenarioConfig.from_dict = _from_dict_with_conversion  # type: ignore
+# Note: Pydantic's field_validators in ScenarioConfig handle string-to-int
+# key conversion automatically, so no additional deserialization logic is needed.

lifx_emulator/server.py

@@ -9,17 +9,18 @@ from collections import defaultdict
 from typing import Any
 
 from lifx_emulator.constants import LIFX_HEADER_SIZE, LIFX_UDP_PORT
-from lifx_emulator.device import EmulatedLifxDevice
-from lifx_emulator.observers import (
+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.scenario_manager import HierarchicalScenarioManager
-from lifx_emulator.scenario_persistence import ScenarioPersistence
+from lifx_emulator.repositories import IScenarioStorageBackend
+from lifx_emulator.scenarios import HierarchicalScenarioManager
 
 logger = logging.getLogger(__name__)
 
@@ -91,6 +92,7 @@ class EmulatedLifxServer:
     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,
@@ -98,30 +100,35 @@ class EmulatedLifxServer:
         activity_observer: ActivityObserver | None = None,
         scenario_manager: HierarchicalScenarioManager | None = None,
         persist_scenarios: bool = False,
+        scenario_storage: IScenarioStorageBackend | None = None,
     ):
-        self.devices = {dev.state.serial: dev for dev in devices}
+        # 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 persistence (optional)
-        self.scenario_persistence: ScenarioPersistence | None = None
+        # Scenario storage backend (optional - only needed for persistence)
+        self.scenario_persistence: IScenarioStorageBackend | None = None
         if persist_scenarios:
-            self.scenario_persistence = ScenarioPersistence()
-            # Load scenarios from disk if available
+            if scenario_storage is None:
+                raise ValueError(
+                    "scenario_storage is required when persist_scenarios=True"
+                )
             if scenario_manager is None:
-                scenario_manager = self.scenario_persistence.load()
-                logger.info("Loaded scenarios from persistent storage")
+                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()
 
-        # Share scenario manager with all initial devices
+        # Add initial devices to the device manager
         for device in devices:
-            if isinstance(device.scenario_manager, HierarchicalScenarioManager):
-                device.scenario_manager = self.scenario_manager
-                device.invalidate_scenario_cache()
+            self._device_manager.add_device(device, self.scenario_manager)
 
         # Activity observer - defaults to ActivityLogger if track_activity=True
         if activity_observer is not None:
@@ -210,7 +217,7 @@ class EmulatedLifxServer:
             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 (device=%s, seq=%s) [%s]",
+                "→ TX %s to %s:%s (target=%s, seq=%s) [%s]",
                 resp_packet_name,
                 addr[0],
                 addr[1],
@@ -296,7 +303,9 @@ class EmulatedLifxServer:
 
             # Log received packet with details
             packet_name = _get_packet_type_name(header.pkt_type)
-            target_str = "broadcast" if header.tagged else header.target.hex()
+            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]",
@@ -320,18 +329,8 @@ class EmulatedLifxServer:
                 )
             )
 
-            # Determine target devices
-            target_devices = []
-            if header.tagged or header.target == b"\x00" * 8:
-                # Broadcast to all devices
-                target_devices = list(self.devices.values())
-            else:
-                # Specific device - convert target bytes to serial string
-                # Target is 8 bytes: 6-byte MAC + 2 null bytes
-                target_serial = header.target[:6].hex()
-                device = self.devices.get(target_serial)
-                if device:
-                    target_devices = [device]
+            # 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
@@ -361,18 +360,7 @@ class EmulatedLifxServer:
         Returns:
             True if added, False if device with same serial already exists
         """
-        serial = device.state.serial
-        if serial in self.devices:
-            return False
-
-        # If device is using HierarchicalScenarioManager, share the server's manager
-        if isinstance(device.scenario_manager, HierarchicalScenarioManager):
-            device.scenario_manager = self.scenario_manager
-            device.invalidate_scenario_cache()
-
-        self.devices[serial] = device
-        logger.info("Added device: %s (product=%s)", serial, device.state.product)
-        return True
+        return self._device_manager.add_device(device, self.scenario_manager)
 
     def remove_device(self, serial: str) -> bool:
         """Remove a device from the server.
@@ -383,16 +371,7 @@ class EmulatedLifxServer:
         Returns:
             True if removed, False if device not found
         """
-        if serial not in self.devices:
-            return False
-        self.devices.pop(serial)
-        logger.info("Removed device: %s", serial)
-
-        # Delete persistent storage if enabled
-        if self.storage:
-            self.storage.delete_device_state(serial)
-
-        return True
+        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.
@@ -403,18 +382,7 @@ class EmulatedLifxServer:
         Returns:
             Number of devices removed
         """
-        device_count = len(self.devices)
-
-        # Clear devices dict
-        self.devices.clear()
-        logger.info("Removed all %s device(s) from server", device_count)
-
-        # Delete persistent storage if requested
-        if delete_storage and self.storage:
-            deleted = self.storage.delete_all_device_states()
-            logger.info("Deleted %s device state(s) from persistent storage", deleted)
-
-        return device_count
+        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.
@@ -425,7 +393,7 @@ class EmulatedLifxServer:
         Returns:
             Device if found, None otherwise
         """
-        return self.devices.get(serial)
+        return self._device_manager.get_device(serial)
 
     def get_all_devices(self) -> list[EmulatedLifxDevice]:
         """Get all devices.
@@ -433,7 +401,15 @@ class EmulatedLifxServer:
         Returns:
             List of all devices
         """
-        return list(self.devices.values())
+        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.
@@ -445,7 +421,7 @@ class EmulatedLifxServer:
         return {
             "uptime_seconds": uptime,
             "start_time": self.start_time,
-            "device_count": len(self.devices),
+            "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),

{lifx_emulator-1.0.2.dist-info → lifx_emulator-2.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lifx-emulator
-Version: 1.0.2
+Version: 2.1.0
 Summary: LIFX Emulator for testing LIFX LAN protocol libraries
 Author-email: Avi Miller <me@dje.li>
 Maintainer-email: Avi Miller <me@dje.li>

lifx_emulator-2.1.0.dist-info/RECORD

@@ -0,0 +1,62 @@
+lifx_emulator/__init__.py,sha256=vjhtpAQRSsUZtaUGCQKbmPALvwZ_BF8Mko8w6jzVqBw,819
+lifx_emulator/__main__.py,sha256=zaul9OQhN5csqOqxGWXkVrlurfo2R_-YvM6URk4QAME,21680
+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=eBx80Ece_4Wv6aqxb1CsZEob9CF0WmR9oJGz3hh14x8,3973
+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=YXQ9jrs30DZIxtMWFE4E2HqmsgHQ-NeWTTQxQ-7BfHk,33800
+lifx_emulator/devices/__init__.py,sha256=QlBTPnFErJcSKLvGyeDwemh7xcpjYvB_L5siKsjr3s8,1089
+lifx_emulator/devices/device.py,sha256=LMdg__95n6geG_32j7qp5yl51WNS3ZbCXn-xMfVVikE,13294
+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=O4Cp3bbGkd4eZf5jzb0MKzWDTgiNhrSGgypmMWaB4dg,5097
+lifx_emulator/devices/states.py,sha256=mVZz7FQeIHLpv2SokmhlQlSBIyVj3GuhGMHBVoFlJqk,10836
+lifx_emulator/factories/__init__.py,sha256=yN8i_Hu_cFEryWZmh0TiOQvWEYFVIApQSs4xeb0EfBk,1170
+lifx_emulator/factories/builder.py,sha256=ZSz5apcorsKpuPsdjFE4VLC1p41jVY8MWs1-nRBOLMk,11996
+lifx_emulator/factories/default_config.py,sha256=FTcxKDfeTmO49GTSki8nxnEIZQzR0Lg0hL_PwHUrkVQ,4828
+lifx_emulator/factories/factory.py,sha256=VQfU5M8zrpFyNHjpGP1q-3bpek9MltBdoAUSvIvt7Bs,7583
+lifx_emulator/factories/firmware_config.py,sha256=AzvPvR4pfwjK1yNsaua1L9V1gLVItUVySjcGrXIWnEw,1932
+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=Ryz-_fzoVCT6DBkXhW9YCOYJYaMRcBOIguL3HrQXhAw,11471
+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=-DU4PufPgE7vfvKsZfxP_7vBtI3EtAeBF3-U2-1zyaQ,11294
+lifx_emulator/products/__init__.py,sha256=qcNop_kRYFF3zSjNemzQEgu3jPrIxfyQyLv9GsnaLEI,627
+lifx_emulator/products/generator.py,sha256=NYInVSGyYIxAYMpTihqBtXP06lAYVfbSYe0Wv5Hg9vQ,31758
+lifx_emulator/products/registry.py,sha256=qkm2xgGZo_ds3wAbYplLu4gb0cxhjZXjnCc1V8etpHw,46517
+lifx_emulator/products/specs.py,sha256=pfmQMrQxlCGqORs3MbsH_vmCvxdaDwjVzXUCVZCjFCI,7093
+lifx_emulator/products/specs.yml,sha256=uxzdKFREAHphk8XSPiCHvQE2vwoPfT2m1xy-zC4ZIl4,8552
+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.1.0.dist-info/METADATA,sha256=cen3ovCv4G8WJyDQpy46bpFndEZ1OZH09NFuaoE0-mw,4549
+lifx_emulator-2.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+lifx_emulator-2.1.0.dist-info/entry_points.txt,sha256=R9C_K_tTgt6yXEmhzH4r2Yx2Tu1rLlnYzeG4RFUVzSc,62
+lifx_emulator-2.1.0.dist-info/licenses/LICENSE,sha256=eBz48GRA3gSiWn3rYZAz2Ewp35snnhV9cSqkVBq7g3k,1832
+lifx_emulator-2.1.0.dist-info/RECORD,,