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

lghorizon/lghorizon_mqtt_client.py

@@ -1,10 +1,9 @@
 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
 
@@ -12,46 +11,32 @@ _logger = logging.getLogger(__name__)
 
 
 class LGHorizonMqttClient:
-    """Asynchronous-friendly wrapper around Paho MQTT."""
+    """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
 
     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:
+    ):
+        """Initialize the MQTT client."""
         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()
+        self._loop = asyncio.get_event_loop()
 
     @classmethod
     async def create(
@@ -59,277 +44,80 @@ class LGHorizonMqttClient:
         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
+    ):
+        """Create the MQTT client."""
+        instance = cls(auth, on_connected_callback, on_message_callback)
         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.username_pw_set(auth.household_id, instance._mqtt_token)
+        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
-
+        instance._on_connected_callback = on_connected_callback
+        instance._on_message_callback = on_message_callback
         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.
-        """
+    def _on_connect(self, client, userdata, flags, result_code):  # pylint: disable=unused-argument
         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,
-            )
+            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:
-            _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
-            )
+            self._mqtt_client.username_pw_set(self._auth.household_id, self._mqtt_token)
+            asyncio.run_coroutine_threadsafe(self.connect(), 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.error(
+                "Cannot connect to MQTT server with resultCode: %s", result_code
             )
-            _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.
-        """
+    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._message_queue.put((message.topic, message.payload)),
-            self._loop,
+            self._on_client_message(client, userdata, message), 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)
+    async def connect(self) -> None:
+        """Connect the client."""
+        self._mqtt_client.connect(self._mqtt_broker_url, 443)
+        self._mqtt_client.loop_start()
 
-                # Publish is non-blocking
-                self._mqtt_client.publish(topic, payload, qos=2)
+    async def subscribe(self, topic: str) -> None:
+        """Subscribe to a MQTT topic."""
+        self._mqtt_client.subscribe(topic)
 
-            except Exception:
-                _logger.exception("Error publishing MQTT message")
+    async def publish_message(self, topic: str, json_payload: str) -> None:
+        """Publish a MQTT message."""
+        self._mqtt_client.publish(topic, json_payload, qos=2)
 
-            self._publish_queue.task_done()
+    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),
+        )
+        if self._on_message_callback:
+            await self._on_message_callback(json_payload, message.topic)

lghorizon/lghorizon_recording_factory.py

@@ -1,11 +1,9 @@
-from typing import Optional
 from .lghorizon_models import (
     LGHorizonRecordingList,
     LGHorizonRecordingSingle,
     LGHorizonRecordingSeason,
     LGHorizonRecordingShow,
     LGHorizonRecordingType,
-    LGHorizonShowRecordingList,
 )
 
 
@@ -34,22 +32,10 @@ class LGHorizonRecordingFactory:
 
         return LGHorizonRecordingList(recording_list)
 
-    async def create_episodes(self, episode_json: dict) -> LGHorizonShowRecordingList:
+    async def create_episodes(self, episode_json: dict) -> LGHorizonRecordingList:
         """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 LGHorizonShowRecordingList(show_title, show_image, recording_list)
+        return LGHorizonRecordingList(recording_list)

lghorizon-0.9.0b0.dist-info/METADATA

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: lghorizon
+Version: 0.9.0b0
+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 to control multiple LG Horizon boxes

lghorizon-0.9.0b0.dist-info/RECORD

@@ -0,0 +1,17 @@
+lghorizon/__init__.py,sha256=kUPbxGDOnoMwR3TdAeuzt8-vDB2bwRQCX_6yPSH1Rf8,181
+lghorizon/const.py,sha256=HINlbyevEN9ZRnfIBbSGNc6i9J8WkIgpqkLZrwyqpGQ,5307
+lghorizon/exceptions.py,sha256=-6v55KDTogBldGAg1wV9Mrxm5L5BsaVguhBgVMOeJHk,404
+lghorizon/helpers.py,sha256=SGlEN6V0kh2vqw1qCKmM1KhfeO-UvPyyQmnThgFLFhs,272
+lghorizon/lghorizon_api.py,sha256=r3Pc6ju4uHdSZOPZLtu3wxPFDMaoCGFt_3gZ4RNCg-Q,11781
+lghorizon/lghorizon_device.py,sha256=jaxEjTjIx1zI9rBsv9gUwScRsVVNZrJMeM4ygxllBIo,12198
+lghorizon/lghorizon_device_state_processor.py,sha256=R-aLtmS50nqJ3CZ7R5Qdg9w4lvZ3xIWiMskh4ls2sTA,12062
+lghorizon/lghorizon_message_factory.py,sha256=1ZqgoGCERI-fhFh9ralemeHjPcpaPJS2AAkoGIbp9YI,1496
+lghorizon/lghorizon_models.py,sha256=bncfG_gfJaG604xceg-svg8_EUDsplRXSSknqgOqh6k,41141
+lghorizon/lghorizon_mqtt_client.py,sha256=bUWhTM8BJ1V5CbgP8ueJrm-pmopxBB7v_hLHKSwLxUU,4704
+lghorizon/lghorizon_recording_factory.py,sha256=qIVfnfIvXliUv-Gy1LJXYmE6rFg90WhOQn_3P4ji2T0,1755
+lghorizon/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lghorizon-0.9.0b0.dist-info/licenses/LICENSE,sha256=6Dh2tur1gMX3r3rITjVwUONBEJxyyPZDY8p6DZXtimE,1059
+lghorizon-0.9.0b0.dist-info/METADATA,sha256=aGK1F_OuZ-TZJkBMSO58RPWpKKnFylwIscKOorPSOf8,1284
+lghorizon-0.9.0b0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+lghorizon-0.9.0b0.dist-info/top_level.txt,sha256=usii76_AxGfPI6gjrrh-NyZxcQQuF1B8_Q9kd7sID8Q,10
+lghorizon-0.9.0b0.dist-info/RECORD,,