lghorizon 0.9.0__py3-none-any.whl → 0.9.0.dev1__py3-none-any.whl

lghorizon/lghorizon_mqtt_client.py

@@ -1,335 +0,0 @@
-import asyncio
-import json
-import logging
-from typing import Any, Callable, Coroutine
-
-import paho.mqtt.client as mqtt
-
-from .helpers import make_id
-from .lghorizon_models import LGHorizonAuth
-
-_logger = logging.getLogger(__name__)
-
-
-class LGHorizonMqttClient:
-    """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]],
-        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 = 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(
-        cls,
-        auth: LGHorizonAuth,
-        on_connected_callback: Callable[[], Coroutine[Any, Any, Any]],
-        on_message_callback: Callable[[dict, str], Coroutine[Any, Any, Any]],
-    ) -> "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,
-        )
-
-        # 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._mqtt_client.on_message = instance._on_message
-        instance._mqtt_client.on_disconnect = instance._on_disconnect
-
-        return instance
-
-    async def connect(self) -> None:
-        """Connect the MQTT client to the broker asynchronously."""
-        if not self._mqtt_client:
-            raise RuntimeError("MQTT client not initialized")
-
-        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.info("Attempting initial MQTT connection...")
-        # Blocking connect → executor
-        await self._loop.run_in_executor(
-            None,
-            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 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:
-        """Queue an MQTT message for publishing.
-
-        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.info("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.warning(
-                "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.info("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.info(
-                    "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,
-        )
-
-    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.info("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.info("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.info("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-0.9.0.dist-info/METADATA

@@ -1,191 +0,0 @@
-Metadata-Version: 2.4
-Name: lghorizon
-Version: 0.9.0
-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
-
-# 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.0.dist-info/RECORD

@@ -1,17 +0,0 @@
-lghorizon/__init__.py,sha256=y44i_P6jsl3VV0R4UYIymXpRXIJVYPwb97uQK9pEfYA,1852
-lghorizon/const.py,sha256=HINlbyevEN9ZRnfIBbSGNc6i9J8WkIgpqkLZrwyqpGQ,5307
-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=6BsZkRo3PBf62F2530_FdQ4OMr9w1jiewcv19Y8MWWo,12764
-lghorizon/lghorizon_recording_factory.py,sha256=JaFjmXWChp1jdFzkioe9K-MqzVU0AsOgdKGjm2Seyq0,2318
-lghorizon/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lghorizon-0.9.0.dist-info/licenses/LICENSE,sha256=6Dh2tur1gMX3r3rITjVwUONBEJxyyPZDY8p6DZXtimE,1059
-lghorizon-0.9.0.dist-info/METADATA,sha256=HJvdaN47p25UvHdotYhrI5BIPUeTmqJbFqfad7rJRwY,7471
-lghorizon-0.9.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-lghorizon-0.9.0.dist-info/top_level.txt,sha256=usii76_AxGfPI6gjrrh-NyZxcQQuF1B8_Q9kd7sID8Q,10
-lghorizon-0.9.0.dist-info/RECORD,,