lghorizon 0.9.0.dev3__py3-none-any.whl → 0.9.1__py3-none-any.whl

lghorizon/lghorizon_mqtt_client.py

@@ -1,9 +1,10 @@
 import asyncio
 import json
 import logging
+from typing import Any, Callable, Coroutine
 
 import paho.mqtt.client as mqtt
-from typing import Any, Callable, Coroutine
+
 from .helpers import make_id
 from .lghorizon_models import LGHorizonAuth
 
@@ -11,32 +12,46 @@ _logger = logging.getLogger(__name__)
 
 
 class LGHorizonMqttClient:
-    """LGHorizon MQTT client."""
-
-    _mqtt_broker_url: str = ""
-    _mqtt_client: mqtt.Client
-    _auth: LGHorizonAuth
-    _mqtt_token: str = ""
-    client_id: str = ""
-    _on_connected_callback: Callable[[], Coroutine[Any, Any, Any]]
-    _on_message_callback: Callable[[dict, str], Coroutine[Any, Any, Any]]
-
-    @property
-    def is_connected(self):
-        """Is client connected."""
-        return self._mqtt_client.is_connected
+    """Asynchronous-friendly wrapper around Paho MQTT."""
 
     def __init__(
         self,
         auth: LGHorizonAuth,
         on_connected_callback: Callable[[], Coroutine[Any, Any, Any]],
         on_message_callback: Callable[[dict, str], Coroutine[Any, Any, Any]],
-    ):
-        """Initialize the MQTT client."""
+        loop: asyncio.AbstractEventLoop,
+    ) -> None:
         self._auth = auth
+        """Initialize the LGHorizonMqttClient.
+
+        Args:
+            auth: The authentication object for obtaining MQTT tokens.
+            on_connected_callback: An async callback function for MQTT connection events.
+            on_message_callback: An async callback function for MQTT message events.
+            loop: The asyncio event loop.
+        """
         self._on_connected_callback = on_connected_callback
         self._on_message_callback = on_message_callback
-        self._loop = asyncio.get_event_loop()
+        self._loop = loop
+
+        self._mqtt_client: mqtt.Client | None = None
+        self._mqtt_broker_url: str = ""
+        self._mqtt_token: str = ""
+        self.client_id: str = ""
+        self._reconnect_task: asyncio.Task | None = None
+        self._disconnect_requested: bool = False
+
+        # FIFO queues
+        self._message_queue: asyncio.Queue = asyncio.Queue()
+        self._publish_queue: asyncio.Queue = asyncio.Queue()
+
+        # Worker tasks
+        self._message_worker_task: asyncio.Task | None = None
+        self._publish_worker_task: asyncio.Task | None = None
+
+    @property
+    def is_connected(self) -> bool:
+        return self._mqtt_client is not None and self._mqtt_client.is_connected()
 
     @classmethod
     async def create(
@@ -44,80 +59,277 @@ class LGHorizonMqttClient:
         auth: LGHorizonAuth,
         on_connected_callback: Callable[[], Coroutine[Any, Any, Any]],
         on_message_callback: Callable[[dict, str], Coroutine[Any, Any, Any]],
-    ):
-        """Create the MQTT client."""
-        instance = cls(auth, on_connected_callback, on_message_callback)
+    ) -> "LGHorizonMqttClient":
+        """Asynchronously create and initialize an LGHorizonMqttClient instance."""
+
+        loop = asyncio.get_running_loop()
+        instance = cls(auth, on_connected_callback, on_message_callback, loop)
+
+        # Service config ophalen
         service_config = await auth.get_service_config()
         mqtt_broker_url = await service_config.get_service_url("mqttBroker")
         instance._mqtt_broker_url = mqtt_broker_url.replace("wss://", "").replace(
             ":443/mqtt", ""
         )
+
         instance.client_id = await make_id()
+
+        # Paho client
         instance._mqtt_client = mqtt.Client(
             client_id=instance.client_id,
             transport="websockets",
         )
-
         instance._mqtt_client.ws_set_options(
             headers={"Sec-WebSocket-Protocol": "mqtt, mqttv3.1, mqttv3.11"}
         )
+
+        # Token ophalen
         instance._mqtt_token = await auth.get_mqtt_token()
-        instance._mqtt_client.username_pw_set(auth.household_id, instance._mqtt_token)
-        instance._mqtt_client.tls_set()
+        instance._mqtt_client.username_pw_set(
+            auth.household_id,
+            instance._mqtt_token,
+        )
+
+        # TLS instellen (blocking → executor)
+        await loop.run_in_executor(None, instance._mqtt_client.tls_set)
+
         instance._mqtt_client.enable_logger(_logger)
         instance._mqtt_client.on_connect = instance._on_connect
-        instance._on_connected_callback = on_connected_callback
-        instance._on_message_callback = on_message_callback
+        instance._mqtt_client.on_message = instance._on_message
+        instance._mqtt_client.on_disconnect = instance._on_disconnect
+
         return instance
 
-    def _on_connect(self, client, userdata, flags, result_code):  # pylint: disable=unused-argument
-        if result_code == 0:
-            self._mqtt_client.on_message = self._on_message
-            if self._on_connected_callback:
-                asyncio.run_coroutine_threadsafe(
-                    self._on_connected_callback(), self._loop
-                )
-        elif result_code == 5:
-            self._mqtt_client.username_pw_set(self._auth.household_id, self._mqtt_token)
-            asyncio.run_coroutine_threadsafe(self.connect(), self._loop)
-        else:
-            _logger.error(
-                "Cannot connect to MQTT server with resultCode: %s", result_code
-            )
+    async def connect(self) -> None:
+        """Connect the MQTT client to the broker asynchronously."""
+        if not self._mqtt_client:
+            raise RuntimeError("MQTT client not initialized")
 
-    def _on_message(self, client, userdata, message):  # pylint: disable=unused-argument
-        """Wrapper for handling MQTT messages in a thread-safe manner."""
-        asyncio.run_coroutine_threadsafe(
-            self._on_client_message(client, userdata, message), self._loop
+        if self.is_connected:
+            _logger.debug("MQTT client is already connected.")
+            return
+
+        self._disconnect_requested = False  # Reset flag for new connection attempt
+
+        # Cancel any ongoing reconnect task if connect() is called manually
+        if self._reconnect_task and not self._reconnect_task.done():
+            _logger.debug("Cancelling existing reconnect task before manual connect.")
+            self._reconnect_task.cancel()
+            self._reconnect_task = None
+
+        _logger.debug("Attempting initial MQTT connection...")
+        # Blocking connect → executor
+        await self._loop.run_in_executor(
+            None,
+            self._mqtt_client.connect,
+            self._mqtt_broker_url,
+            443,
         )
 
-    async def connect(self) -> None:
-        """Connect the client."""
-        self._mqtt_client.connect(self._mqtt_broker_url, 443)
+        # Start Paho thread
         self._mqtt_client.loop_start()
 
+        # Start workers
+        self._message_worker_task = asyncio.create_task(self._message_worker())
+        self._publish_worker_task = asyncio.create_task(self._publish_worker())
+
+    async def disconnect(self) -> None:
+        """Disconnect the MQTT client from the broker asynchronously."""
+        if not self._mqtt_client:
+            return
+
+        # Stop workers
+        if self._message_worker_task:
+            self._message_worker_task.cancel()
+            self._message_worker_task = None
+
+        if self._publish_worker_task:
+            self._publish_worker_task.cancel()
+            self._publish_worker_task = None
+
+        # Blocking disconnect → executor
+        await self._loop.run_in_executor(None, self._mqtt_client.disconnect)
+        self._mqtt_client.loop_stop()
+
     async def subscribe(self, topic: str) -> None:
-        """Subscribe to a MQTT topic."""
+        """Subscribe to an MQTT topic.
+
+        Args:
+            topic: The MQTT topic to subscribe to.
+        """
+        if not self._mqtt_client:
+            raise RuntimeError("MQTT client not initialized")
+
         self._mqtt_client.subscribe(topic)
 
     async def publish_message(self, topic: str, json_payload: str) -> None:
-        """Publish a MQTT message."""
-        self._mqtt_client.publish(topic, json_payload, qos=2)
+        """Queue an MQTT message for publishing.
 
-    async def disconnect(self) -> None:
-        """Disconnect the client."""
-        if self._mqtt_client.is_connected():
-            self._mqtt_client.disconnect()
-
-    async def _on_client_message(self, client, userdata, message):  # pylint: disable=unused-argument
-        """Handle messages received by mqtt client."""
-        json_payload = await self._loop.run_in_executor(
-            None, json.loads, message.payload
-        )
-        _logger.debug(
-            "Received MQTT message \n\ntopic: %s\npayload:\n\n%s\n",
-            message.topic,
-            json.dumps(json_payload, indent=2),
+        Args:
+            topic: The MQTT topic to publish to.
+            json_payload: The JSON payload as a string.
+        """
+        await self._publish_queue.put((topic, json_payload))
+
+    # -------------------------
+    # INTERNAL CALLBACKS
+    # -------------------------
+
+    def _on_connect(self, client, userdata, flags, result_code):
+        """Callback for when the MQTT client connects to the broker.
+
+        Args:
+            client: The Paho MQTT client instance.
+            userdata: User data passed to the client.
+            flags: Response flags from the broker.
+            result_code: The connection result code.
+        """
+        if result_code == 0:
+            _logger.debug("MQTT client connected successfully.")
+            # If a reconnect task was running, it means we successfully reconnected.
+            # Cancel it as we are now connected.
+            if self._reconnect_task:
+                self._reconnect_task.cancel()
+                self._reconnect_task = None  # Clear the reference
+            asyncio.run_coroutine_threadsafe(
+                self._on_connected_callback(),
+                self._loop,
+            )
+        elif result_code == 5:
+            _logger.debug(
+                "MQTT connection failed: Token expired. Attempting to refresh token and reconnect."
+            )
+            # Schedule the token refresh and reconnect in the main event loop
+            asyncio.run_coroutine_threadsafe(
+                self._handle_token_refresh_and_reconnect(), self._loop
+            )
+        else:
+            _logger.error("MQTT connect error: %s", result_code)
+            # For other errors, Paho's _on_disconnect will typically be called,
+            # which will then trigger the general reconnect loop.
+
+    async def _handle_token_refresh_and_reconnect(self):
+        """Refreshes the MQTT token and attempts to reconnect the client."""
+        try:
+            # Get new token
+            self._mqtt_token = await self._auth.get_mqtt_token()
+            self._mqtt_client.username_pw_set(
+                self._auth.household_id,
+                self._mqtt_token,
+            )
+            _logger.debug("MQTT token refreshed. Attempting to reconnect.")
+            # Call connect. If it fails, _on_disconnect will be triggered,
+            # and the _reconnect_loop will take over.
+            await self.connect()
+        except Exception as e:
+            _logger.error("Failed to refresh MQTT token or initiate reconnect: %s", e)
+            # If token refresh itself fails, or connect() raises an exception
+            # before _on_disconnect can be called, ensure reconnect loop starts.
+            if not self._disconnect_requested and (
+                not self._reconnect_task or self._reconnect_task.done()
+            ):
+                _logger.debug(
+                    "Scheduling MQTT reconnect after token refresh/connect failure."
+                )
+                self._reconnect_task = asyncio.create_task(self._reconnect_loop())
+
+    def _on_message(self, client, userdata, message):
+        """Callback for when an MQTT message is received.
+
+        Args:
+            client: The Paho MQTT client instance.
+            userdata: User data passed to the client.
+            message: The MQTTMessage object containing topic and payload.
+        """
+        asyncio.run_coroutine_threadsafe(
+            self._message_queue.put((message.topic, message.payload)),
+            self._loop,
         )
-        if self._on_message_callback:
-            await self._on_message_callback(json_payload, message.topic)
+
+    def _on_disconnect(self, client, userdata, result_code):
+        """Callback for when the MQTT client disconnects from the broker.
+
+        Args:
+            client: The Paho MQTT client instance.
+            userdata: User data passed to the client.
+            result_code: The disconnection result code.
+        """
+        _logger.warning("MQTT disconnected with result code: %s", result_code)
+        if not self._disconnect_requested:
+            _logger.debug("Unexpected MQTT disconnection. Initiating reconnect loop.")
+            if not self._reconnect_task or self._reconnect_task.done():
+                self._reconnect_task = asyncio.run_coroutine_threadsafe(
+                    self._reconnect_loop(), self._loop
+                )
+            else:
+                _logger.debug("Reconnect loop already active.")
+        else:
+            _logger.debug("MQTT disconnected as requested.")
+
+    async def _reconnect_loop(self):
+        """Manages the MQTT reconnection process with exponential backoff."""
+        retries = 0
+        while not self._disconnect_requested:
+            if self.is_connected:
+                _logger.debug(
+                    "MQTT client reconnected within loop, stopping reconnect attempts."
+                )
+                break  # Already connected, stop trying
+
+            delay = min(2**retries, 60)  # Exponential backoff, max 60 seconds
+            _logger.debug(
+                "Waiting %s seconds before MQTT reconnect attempt %s",
+                delay,
+                retries + 1,
+            )
+            await asyncio.sleep(delay)
+
+            try:
+                _logger.debug("Attempting MQTT reconnect...")
+                await self.connect()
+                # If connect() succeeds, _on_connect will be called, which will cancel this task.
+                # If connect() fails, _on_disconnect will be called again, and this loop continues.
+                break  # If connect() doesn't raise, assume it's handled by _on_connect
+            except Exception as e:
+                _logger.error("MQTT reconnect attempt failed: %s", e)
+                retries += 1
+        self._reconnect_task = None  # Clear task when loop finishes or is cancelled.
+
+    # -------------------------
+    # MESSAGE WORKER (FIFO)
+    # -------------------------
+
+    async def _message_worker(self):
+        """Worker task to process incoming MQTT messages from the queue."""
+        while True:
+            topic, payload = await self._message_queue.get()
+
+            try:
+                json_payload = json.loads(payload)
+                await self._on_message_callback(json_payload, topic)
+            except Exception:
+                _logger.exception("Error processing MQTT message")
+
+            self._message_queue.task_done()
+
+    # -------------------------
+    # PUBLISH WORKER (FIFO)
+    # -------------------------
+
+    async def _publish_worker(self):
+        """Worker task to process outgoing MQTT publish commands from the queue."""
+        while True:
+            topic, payload = await self._publish_queue.get()
+
+            try:
+                # Wacht tot MQTT echt connected is
+                while not self.is_connected:
+                    await asyncio.sleep(0.1)
+
+                # Publish is non-blocking
+                self._mqtt_client.publish(topic, payload, qos=2)
+
+            except Exception:
+                _logger.exception("Error publishing MQTT message")
+
+            self._publish_queue.task_done()

lghorizon/lghorizon_recording_factory.py

@@ -1,9 +1,11 @@
+from typing import Optional
 from .lghorizon_models import (
     LGHorizonRecordingList,
     LGHorizonRecordingSingle,
     LGHorizonRecordingSeason,
     LGHorizonRecordingShow,
     LGHorizonRecordingType,
+    LGHorizonShowRecordingList,
 )
 
 
@@ -32,10 +34,22 @@ class LGHorizonRecordingFactory:
 
         return LGHorizonRecordingList(recording_list)
 
-    async def create_episodes(self, episode_json: dict) -> LGHorizonRecordingList:
+    async def create_episodes(self, episode_json: dict) -> LGHorizonShowRecordingList:
         """Create a LGHorizonRecording list based for episodes."""
         recording_list = []
+        show_title: Optional[str] = None
+        if "images" in episode_json:
+            images = episode_json["images"]
+            show_image = next(
+                (img["url"] for img in images if img.get("type") == "titleTreatment"),
+                images[0]["url"] if images else None,
+            )
+        else:
+            show_image = None
+
         for recording in episode_json["data"]:
             recording_single = LGHorizonRecordingSingle(recording)
+            if show_title is None:
+                show_title = recording_single.show_title or recording_single.title
             recording_list.append(recording_single)
-        return LGHorizonRecordingList(recording_list)
+        return LGHorizonShowRecordingList(show_title, show_image, recording_list)

lghorizon-0.9.1.dist-info/METADATA

@@ -0,0 +1,189 @@
+Metadata-Version: 2.4
+Name: lghorizon
+Version: 0.9.1
+Summary: Python client for Liberty Global Horizon settop boxes
+Home-page: https://github.com/sholofly/LGHorizon-python
+Author: Rudolf Offereins
+Author-email: r.offereins@gmail.com
+License: MIT license
+Keywords: LG,Horizon,API,Settop box
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Natural Language :: English
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: paho-mqtt
+Requires-Dist: requests>=2.22.0
+Requires-Dist: backoff>=1.9.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# LG Horizon API Python Library
+
+A Python library to interact with and control LG Horizon set-top boxes. This library provides functionalities for authentication, real-time device status monitoring via MQTT, and various control commands for your Horizon devices.
+
+## Features
+
+- **Authentication**: Supports authentication using username/password or a refresh token. The library automatically handles access token refreshing.
+- **Device Management**: Discover and manage multiple LG Horizon set-top boxes associated with your account.
+- **Real-time Status**: Monitor device status (online/running/standby) and current playback information (channel, show, VOD, recording, app) through MQTT.
+- **Channel Information**: Retrieve a list of available channels and profile-specific favorite channels.
+- **Recording Management**:
+  - Get a list of all recordings.
+  - Retrieve recordings for specific shows.
+  - Check recording quota and usage.
+- **Device Control**: Send various commands to your set-top box:
+  - Power on/off.
+  - Play, pause, stop, rewind, fast forward.
+  - Change channels (up/down, direct channel selection).
+  - Record current program.
+  - Set player position for VOD/recordings.
+  - Display custom messages on the TV screen.
+  - Send emulated remote control key presses.
+- **Robustness**: Includes automatic MQTT reconnection with exponential backoff and token refresh logic to maintain a stable connection.
+
+## Installation
+
+```bash
+pip install lghorizon-python # (Replace with actual package name if different)
+```
+
+## Usage
+
+Here's a basic example of how to use the library to connect to your LG Horizon devices and monitor their state:
+
+First, create a `secrets.json` file in the root of your project with your LG Horizon credentials:
+
+```json
+{
+  "username": "your_username",
+  "password": "your_password",
+  "country": "nl" // e.g., "nl" for Netherlands, "be" for Belgium
+}
+```
+
+Then, you can use the library as follows:
+
+```python
+import asyncio
+import json
+import logging
+import aiohttp
+
+from lghorizon.lghorizon_api import LGHorizonApi
+from lghorizon.lghorizon_models import LGHorizonAuth
+
+_LOGGER = logging.getLogger(__name__)
+
+async def main():
+    logging.basicConfig(level=logging.INFO) # Set to DEBUG for more verbose output
+
+    with open("secrets.json", encoding="utf-8") as f:
+        secrets = json.load(f)
+        username = secrets.get("username")
+        password = secrets.get("password")
+        country = secrets.get("country", "nl")
+
+    async with aiohttp.ClientSession() as session:
+        auth = LGHorizonAuth(session, country, username=username, password=password)
+        api = LGHorizonApi(auth)
+
+        async def device_state_changed_callback(device_id: str):
+            device = devices[device_id]
+            _LOGGER.info(
+                f"Device {device.device_friendly_name} ({device.device_id}) state changed:\n"
+                f"  State: {device.device_state.state.value}\n"
+                f"  UI State: {device.device_state.ui_state_type.value}\n"
+                f"  Source Type: {device.device_state.source_type.value}\n"
+                f"  Channel: {device.device_state.channel_name or 'N/A'} ({device.device_state.channel_id or 'N/A'})\n"
+                f"  Show: {device.device_state.show_title or 'N/A'}\n"
+                f"  Episode: {device.device_state.episode_title or 'N/A'}\n"
+                f"  Position: {device.device_state.position or 'N/A'} / {device.device_state.duration or 'N/A'}\n"
+            )
+
+        try:
+            _LOGGER.info("Initializing LG Horizon API...")
+            await api.initialize()
+            devices = await api.get_devices()
+
+            for device in devices.values():
+                _LOGGER.info(f"Registering callback for device: {device.device_friendly_name}")
+                await device.set_callback(device_state_changed_callback)
+
+            _LOGGER.info("API initialized. Monitoring device states. Press Ctrl+C to exit.")
+            # Keep the script running to receive MQTT updates
+            while True:
+                await asyncio.sleep(3600) # Sleep for a long time, MQTT callbacks will still fire
+
+        except Exception as e:
+            _LOGGER.error(f"An error occurred: {e}", exc_info=True)
+        finally:
+            _LOGGER.info("Disconnecting from LG Horizon API.")
+            await api.disconnect()
+            _LOGGER.info("Disconnected.")
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Authentication
+
+The `LGHorizonAuth` class handles authentication. You can initialize it with a username and password, or directly with a refresh token if you have one. The library automatically refreshes access tokens as needed.
+
+```python
+# Using username and password
+auth = LGHorizonAuth(session, "nl", username="your_username", password="your_password")
+
+# Using a refresh token (e.g., if you've saved it from a previous session)
+# auth = LGHorizonAuth(session, "nl", refresh_token="your_refresh_token")
+```
+
+You can also set a callback to receive the updated refresh token when it's refreshed, allowing you to persist it for future sessions:
+
+```python
+def token_updated_callback(new_refresh_token: str):
+    print(f"New refresh token received: {new_refresh_token}")
+    # Here you would typically save this new_refresh_token
+    # to your secrets.json or other persistent storage.
+
+# After initializing LGHorizonApi:
+# api.set_token_refresh_callback(token_updated_callback)
+```
+
+## Error Handling
+
+The library defines custom exceptions for common error scenarios:
+
+- `LGHorizonApiError`: Base exception for all API-related errors.
+- `LGHorizonApiConnectionError`: Raised for network or connection issues.
+- `LGHorizonApiUnauthorizedError`: Raised when authentication fails (e.g., invalid credentials).
+- `LGHorizonApiLockedError`: A specific type of `LGHorizonApiUnauthorizedError` indicating a locked account.
+
+These exceptions allow for more granular error handling in your application.
+
+## Development
+
+To run the example script (`main.py`) from the repository:
+
+1.  Clone this repository.
+2.  Install dependencies: `pip install -r requirements.txt` (ensure `requirements.txt` is up-to-date).
+3.  Create a `secrets.json` file as described in the Usage section.
+4.  Run `python main.py`.

lghorizon-0.9.1.dist-info/RECORD

@@ -0,0 +1,17 @@
+lghorizon/__init__.py,sha256=wowOg2VYhvb1Nzbpx02aNyc4tiUjCfZgV680smPASXE,1913
+lghorizon/const.py,sha256=TrEptIbYSf4eoW9llb7vvyDdUFJ0ObvX0M0qay6kaHY,2694
+lghorizon/exceptions.py,sha256=4cnnPRuKBtqXiTlOZK4xmP1WADikk5NvCsy293mijT8,500
+lghorizon/helpers.py,sha256=SGlEN6V0kh2vqw1qCKmM1KhfeO-UvPyyQmnThgFLFhs,272
+lghorizon/lghorizon_api.py,sha256=_yP7X3LIei3OPc_byPPZg22QrPkDQdRyMoR6GLg3c3M,12881
+lghorizon/lghorizon_device.py,sha256=HfpbOnmiN44Y0ObSj-lCP8vYQ85WBYU8rbBaqvDzri8,14767
+lghorizon/lghorizon_device_state_processor.py,sha256=LW_Gavhg7bSSeZJiprAi1YJqOcUhZcB-2GdHn9hMj-o,15380
+lghorizon/lghorizon_message_factory.py,sha256=BkJrVgcTsidcugrM9Pt5brvdw5_WI4PRAHvWQyHurz8,1435
+lghorizon/lghorizon_models.py,sha256=-xhTIz1UC5efR5HJtXf2a59EspDbZKGp967flYvhryM,46435
+lghorizon/lghorizon_mqtt_client.py,sha256=e1gyaF0awyVyQZRdJHyZmYcY9omlWnoUwVrvQ5CdMtY,12769
+lghorizon/lghorizon_recording_factory.py,sha256=JaFjmXWChp1jdFzkioe9K-MqzVU0AsOgdKGjm2Seyq0,2318
+lghorizon/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lghorizon-0.9.1.dist-info/licenses/LICENSE,sha256=6Dh2tur1gMX3r3rITjVwUONBEJxyyPZDY8p6DZXtimE,1059
+lghorizon-0.9.1.dist-info/METADATA,sha256=OOtLMZiWEW9gqy5kaRVlnbTzfdObTgASQ2HIz5m0u60,7453
+lghorizon-0.9.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+lghorizon-0.9.1.dist-info/top_level.txt,sha256=usii76_AxGfPI6gjrrh-NyZxcQQuF1B8_Q9kd7sID8Q,10
+lghorizon-0.9.1.dist-info/RECORD,,