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

lghorizon/__init__.py

@@ -1,5 +1,74 @@
 """Python client for LG Horizon."""
 
 from .lghorizon_api import LGHorizonApi
-from .lghorizon_models import *
-from .exceptions import *
+from .lghorizon_device import LGHorizonDevice
+from .lghorizon_models import (
+    LGHorizonAuth,
+    LGHorizonChannel,
+    LGHorizonCustomer,
+    LGHorizonDeviceState,
+    LGHorizonProfile,
+    LGHorizonRecording,
+    LGHorizonRecordingList,
+    LGHorizonShowRecordingList,
+    LGHorizonRecordingSeason,
+    LGHorizonRecordingSingle,
+    LGHorizonRecordingShow,
+    LGHorizonRecordingQuota,
+    LGHorizonRecordingType,
+    LGHorizonUIStateType,
+    LGHorizonMessageType,
+    LGHorizonRunningState,
+    LGHorizonRecordingSource,
+    LGHorizonRecordingState,
+    LGHorizonSourceType,
+    LGHorizonPlayerState,
+    LGHorizonAppsState,
+    LGHorizonUIState,
+    LGHorizonProfileOptions,
+    LGHorizonServicesConfig,
+)
+from .exceptions import (
+    LGHorizonApiError,
+    LGHorizonApiConnectionError,
+    LGHorizonApiUnauthorizedError,
+    LGHorizonApiLockedError,
+)
+
+from .const import COUNTRY_SETTINGS
+
+__all__ = [
+    "LGHorizonApi",
+    "LGHorizonDevice",
+    "LGHorizonAuth",
+    "LGHorizonChannel",
+    "LGHorizonCustomer",
+    "LGHorizonDeviceState",
+    "LGHorizonProfile",
+    "LGHorizonApiError",
+    "LGHorizonApiConnectionError",
+    "LGHorizonApiUnauthorizedError",
+    "LGHorizonApiLockedError",
+    "LGHorizonRecordingList",
+    "LGHorizonRecordingSeason",
+    "LGHorizonRecordingSingle",
+    "LGHorizonRecordingShow",
+    "LGHorizonRecordingQuota",
+    "LGHorizonRecordingType",
+    "LGHorizonUIStateType",
+    "LGHorizonMessageType",
+    "LGHorizonRunningState",
+    "LGHorizonRecordingSource",
+    "LGHorizonRecordingState",
+    "LGHorizonSourceType",
+    "LGHorizonPlayerState",
+    "LGHorizonAppsState",
+    "LGHorizonUIState",
+    "LGHorizonProfileOptions",
+    "LGHorizonProfile",
+    "LGHorizonAuth",
+    "LGHorizonServicesConfig",
+    "LGHorizonRecording",
+    "LGHorizonShowRecordingList",
+    "COUNTRY_SETTINGS",
+]

lghorizon/const.py

@@ -50,106 +50,41 @@ COUNTRY_SETTINGS = {
         "api_url": "https://spark-prod-nl.gnp.cloud.ziggogo.tv",
         "mqtt_url": "obomsg.prod.nl.horizon.tv",
         "use_refreshtoken": False,
-        "channels": [
-            {
-                "channelId": "NL_000073_019506",
-                "channelName": "Netflix",
-                "channelNumber": "150",
-            },
-            {
-                "channelId": "NL_000074_019507",
-                "channelName": "Videoland",
-                "channelNumber": "151",
-            },
-            {
-                "channelId": "NL_000194_019352",
-                "channelName": "NPO",
-                "channelNumber": "152",
-            },
-            {
-                "channelId": "NL_000199_019356",
-                "channelName": "Prime Video",
-                "channelNumber": "153",
-            },
-        ],
-        "platform_types": {
-            "EOS": {"manufacturer": "Arris", "model": "DCX960"},
-            "APOLLO": {"manufacturer": "Arris", "model": "VIP5002W"},
-        },
-        "language": "nl",
+        "name": "Ziggo",
     },
     "ch": {
         "api_url": "https://spark-prod-ch.gnp.cloud.sunrisetv.ch",
-        "channels": [],
-        "language": "de",
+        "use_refreshtoken": True,
+        "name": "UPC Switzerland",
     },
     "be-basetv": {
         "api_url": "https://spark-prod-be.gnp.cloud.base.tv",
-        "channels": [],
-        "language": "nl",
-        "platform_types": {
-            "EOS": {"manufacturer": "Arris", "model": "DCX960"},
-            "HORIZON": {"manufacturer": "Arris", "model": "VIP5002W"},
-        },
+        "use_refreshtoken": True,
+        "name": "BASE TV (BE)",
     },
     "be-nl": {
         "api_url": "https://spark-prod-be.gnp.cloud.telenet.tv",
-        "oauth_username_fieldname": "j_username",
-        "oauth_password_fieldname": "j_password",
-        "oauth_add_accept_header": False,
-        "oauth_url": "https://login.prd.telenet.be/openid/login.do",
-        "oauth_quote_login": False,
-        "oauth_redirect_header": "Location",
-        "channels": [
-            {"channelId": "netflix", "channelName": "Netflix", "channelNumber": "600"},
-            {"channelId": "youtube", "channelName": "Youtube", "channelNumber": "-1"},
-        ],
-        "platform_types": {
-            "EOS": {"manufacturer": "Arris", "model": "DCX960"},
-            "HORIZON": {"manufacturer": "Arris", "model": "DCX960"},
-            "EOS2": {"manufacturer": "HUMAX", "model": "2008C-STB-TN"},
-        },
-        "language": "nl",
+        "use_refreshtoken": True,
+        "name": "Telenet (BE)",
     },
     "be-nl-preprod": {
         "api_url": "https://spark-preprod-be.gnp.cloud.telenet.tv",
         "use_refreshtoken": True,
-        "oauth_username_fieldname": "j_username",
-        "oauth_password_fieldname": "j_password",
-        "oauth_add_accept_header": False,
-        "oauth_url": "https://login.prd.telenet.be/openid/login.do",
-        "oauth_quote_login": False,
-        "oauth_redirect_header": "Location",
-        "channels": [
-            {"channelId": "netflix", "channelName": "Netflix", "channelNumber": "600"},
-            {"channelId": "youtube", "channelName": "Youtube", "channelNumber": "-1"},
-        ],
-        "platform_types": {
-            "EOS": {"manufacturer": "Arris", "model": "DCX960"},
-            "HORIZON": {"manufacturer": "Arris", "model": "DCX960"},
-            "EOS2": {"manufacturer": "HUMAX", "model": "2008C-STB-TN"},
-        },
-        "language": "nl",
+        "name": "Telenet (BE, PREPROD)",
     },
     "gb": {
         "api_url": "https://spark-prod-gb.gnp.cloud.virgintvgo.virginmedia.com",
-        "channels": [],
-        "language": "en",
+        "use_refreshtoken": True,
+        "name": "Virgin Media (GB)",
     },
     "ie": {
         "api_url": "https://spark-prod-ie.gnp.cloud.virginmediatv.ie",
         "use_refreshtoken": False,
-        "channels": [],
-        "language": "en",
+        "name": "Virgin Media (IE)",
     },
     "pl": {
         "api_url": "https://spark-prod-pl.gnp.cloud.upctv.pl",
         "use_refreshtoken": False,
-        "channels": [],
-        "language": "pl",
-        "platform_types": {
-            "EOS": {"manufacturer": "Arris", "model": "DCX960"},
-            "APOLLO": {"manufacturer": "Arris", "model": "VIP5002W"},
-        },
+        "name": "UPC (PL)",
     },
 }

lghorizon/exceptions.py

@@ -6,12 +6,12 @@ class LGHorizonApiError(Exception):
 
 
 class LGHorizonApiConnectionError(LGHorizonApiError):
-    """Generic LGHorizon exception."""
+    """Exception for connection-related errors with the LG Horizon API."""
 
 
 class LGHorizonApiUnauthorizedError(Exception):
-    """Generic LGHorizon exception."""
+    """Exception for unauthorized access to the LG Horizon API."""
 
 
 class LGHorizonApiLockedError(LGHorizonApiUnauthorizedError):
-    """Generic LGHorizon exception."""
+    """Exception for locked account errors with the LG Horizon API."""

lghorizon/lghorizon_api.py

@@ -1,7 +1,7 @@
 """LG Horizon API client."""
 
 import logging
-from typing import Any, Dict, cast
+from typing import Any, Dict, cast, Callable, Optional
 
 from .lghorizon_device import LGHorizonDevice
 from .lghorizon_models import LGHorizonChannel
@@ -15,7 +15,11 @@ from .lghorizon_models import LGHorizonMessageType
 from .lghorizon_message_factory import LGHorizonMessageFactory
 from .lghorizon_models import LGHorizonStatusMessage, LGHorizonUIStatusMessage
 from .lghorizon_models import LGHorizonRunningState
-from .lghorizon_models import LGHorizonRecordingList, LGHorizonRecordingQuota
+from .lghorizon_models import (
+    LGHorizonRecordingList,
+    LGHorizonRecordingQuota,
+    LGHorizonShowRecordingList,
+)
 from .lghorizon_recording_factory import LGHorizonRecordingFactory
 from .lghorizon_device_state_processor import LGHorizonDeviceStateProcessor
 
@@ -26,7 +30,7 @@ _LOGGER = logging.getLogger(__name__)
 class LGHorizonApi:
     """LG Horizon API client."""
 
-    _mqtt_client: LGHorizonMqttClient
+    _mqtt_client: LGHorizonMqttClient | None
     auth: LGHorizonAuth
     _service_config: LGHorizonServicesConfig
     _customer: LGHorizonCustomer
@@ -41,10 +45,18 @@ class LGHorizonApi:
 
     def __init__(self, auth: LGHorizonAuth, profile_id: str = "") -> None:
         """Initialize LG Horizon API client."""
+        """Initialize LG Horizon API client.
+
+        Args:
+            auth: The authentication object for API requests.
+            profile_id: The ID of the user profile to use (optional).
+        """
         self.auth = auth
         self._profile_id = profile_id
         self._channels = {}
         self._device_state_processor = None
+        self._mqtt_client = None
+        self._initialized = False
 
     async def initialize(self) -> None:
         """Initialize the API client."""
@@ -62,14 +74,20 @@ class LGHorizonApi:
         )
         self._initialized = True
 
-    async def get_devices(self) -> Dict[str, LGHorizonDevice]:
+    async def set_token_refresh_callback(
+        self, token_refresh_callback: Callable[str, None]
+    ) -> None:
+        """Set the token refresh callback."""
+        self.auth.token_refresh_callback = token_refresh_callback
+
+    async def get_devices(self) -> dict[str, LGHorizonDevice]:
         """Get devices."""
         if not self._initialized:
             raise RuntimeError("LGHorizonApi not initialized")
 
         return self._devices
 
-    async def get_profiles(self) -> Dict[str, LGHorizonProfile]:
+    async def get_profiles(self) -> dict[str, LGHorizonProfile]:
         """Get profile IDs."""
         if not self._initialized:
             raise RuntimeError("LGHorizonApi not initialized")
@@ -77,14 +95,16 @@ class LGHorizonApi:
         return self._customer.profiles
 
     async def get_profile_channels(
-        self, profile_id: str
+        self, profile_id: Optional[str] = None
     ) -> Dict[str, LGHorizonChannel]:
         """Returns channels to display baed on profile."""
         # Attempt to retrieve the profile by the given profile_id
+        if not profile_id:
+            profile_id = self._profile_id
         profile = self._customer.profiles.get(profile_id)
 
         # If the specified profile is not found, and there are other profiles available,
-        # default to the first profile in the customer's list.
+        # default to the first profile in the customer's list if available.
         if not profile and self._customer.profiles:
             _LOGGER.debug(
                 "Profile with ID '%s' not found. Defaulting to first available profile.",
@@ -135,6 +155,10 @@ class LGHorizonApi:
         self._initialized = False
 
     async def _create_mqtt_client(self) -> LGHorizonMqttClient:
+        """Create and configure the MQTT client.
+
+        Returns: An initialized LGHorizonMqttClient instance.
+        """
         mqtt_client = await LGHorizonMqttClient.create(
             self.auth,
             self._on_mqtt_connected,
@@ -144,8 +168,10 @@ class LGHorizonApi:
 
     async def _on_mqtt_connected(self):
         """MQTT connected callback."""
+        await self._mqtt_client.subscribe("#")
         await self._mqtt_client.subscribe(self.auth.household_id)
         # await self._mqtt_client.subscribe(self.auth.household_id + "/#")
+        # await self._mqtt_client.subscribe(self.auth.household_id + "/+/#")
         await self._mqtt_client.subscribe(
             self.auth.household_id + "/" + self._mqtt_client.client_id
         )
@@ -177,12 +203,16 @@ class LGHorizonApi:
             case LGHorizonMessageType.STATUS:
                 message.__class__ = LGHorizonStatusMessage
                 status_message = cast(LGHorizonStatusMessage, message)
-                device = self._devices[status_message.source]
+                device = self._devices.get(status_message.source, None)
+                if not device:
+                    return
                 await device.handle_status_message(status_message)
             case LGHorizonMessageType.UI_STATUS:
                 message.__class__ = LGHorizonUIStatusMessage
                 ui_status_message = cast(LGHorizonUIStatusMessage, message)
-                device = self._devices[ui_status_message.source]
+                device = self._devices.get(ui_status_message.source, None)
+                if not device:
+                    return
                 if (
                     not device.device_state.state
                     == LGHorizonRunningState.ONLINE_RUNNING
@@ -190,7 +220,7 @@ class LGHorizonApi:
                     return
                 await device.handle_ui_status_message(ui_status_message)
 
-    async def _get_customer_info(self) -> Any:
+    async def _get_customer_info(self) -> LGHorizonCustomer:
         service_url = await self._service_config.get_service_url(
             "personalizationService"
         )
@@ -244,14 +274,14 @@ class LGHorizonApi:
 
     async def get_show_recordings(
         self, show_id: str, channel_id: str
-    ) -> LGHorizonRecordingList:
+    ) -> LGHorizonShowRecordingList:  # type: ignore[valid-type]
         """Retrieve all recordings."""
         _LOGGER.debug("Retrieving recordings fro show...")
         service_url = await self._service_config.get_service_url("recordingService")
         lang = await self._customer.get_profile_lang(self._profile_id)
         episodes_json = await self.auth.request(
             service_url,
-            f"/customers/8436830_nl/episodes/shows/{show_id}?source=recording&isAdult=false&offset=0&limit=100&profileId={self._profile_id}&language={lang}&channelId={channel_id}&sort=time&sortOrder=asc",
+            f"/customers/{self.auth.household_id}/episodes/shows/{show_id}?source=recording&isAdult=false&offset=0&limit=100&profileId={self._profile_id}&language={lang}&channelId={channel_id}&sort=time&sortOrder=asc",
         )
         recordings = await self._recording_factory.create_episodes(episodes_json)
         return recordings

lghorizon/lghorizon_device.py

@@ -1,7 +1,7 @@
 """LG Horizon Device."""
 
 from __future__ import annotations
-
+import asyncio
 import json
 import logging
 from typing import Any, Callable, Coroutine, Dict, Optional
@@ -146,8 +146,6 @@ class LGHorizonDevice:
 
     async def register_mqtt(self) -> None:
         """Register the mqtt connection."""
-        if not self._mqtt_client.is_connected:
-            raise LGHorizonApiConnectionError("MQTT client not connected.")
         topic = f"{self._auth.household_id}/{self._mqtt_client.client_id}/status"
         payload = {
             "source": self._mqtt_client.client_id,
@@ -159,14 +157,23 @@ class LGHorizonDevice:
     async def set_callback(
         self, change_callback: Callable[[str], Coroutine[Any, Any, Any]]
     ) -> None:
-        """Set a callback function."""
+        """Set a callback function to be called when the device state changes.
+
+        Args:
+            change_callback: An asynchronous callable that takes the device ID
+                             as an argument.
+        """
         self._change_callback = change_callback
         await self.register_mqtt()  # type: ignore [assignment] # Callback can be None
 
     async def handle_status_message(
         self, status_message: LGHorizonStatusMessage
     ) -> None:
-        """Register a new settop box."""
+        """Handle an incoming status message from the set-top box.
+
+        Args:
+            status_message: The status message received from the device.
+        """
         old_running_state = self.device_state.state
         new_running_state = status_message.running_state
         if (
@@ -200,7 +207,11 @@ class LGHorizonDevice:
         self.recording_capacity = payload["used"]  # Use the setter
 
     async def _trigger_callback(self):
-        if self._change_callback:
+        """Trigger the registered callback function.
+
+        This method is called when the device's state changes and a callback is set.
+        """
+        if self._change_callback is not None:
             _LOGGER.debug("Callback called from box %s", self.device_id)
             await self._change_callback(self.device_id)
 
@@ -267,38 +278,100 @@ class LGHorizonDevice:
         if self._device_state.state == LGHorizonRunningState.ONLINE_RUNNING:
             await self.send_key_to_box(MEDIA_KEY_RECORD)
 
+    async def set_player_position(self, position: int) -> None:
+        """Set the player position on the settop box."""
+        payload = {
+            "source": self.device_id,
+            "type": "CPE.setPlayerPosition",
+            "runtimeType": "setPlayerposition",
+            "id": await make_id(),
+            "version": "1.3.11",
+            "status": {"relativePosition": position},
+        }
+        payload_str = json.dumps(payload)
+        await self._mqtt_client.publish_message(
+            f"{self._auth.household_id}/{self.device_id}", payload_str
+        )
+
+    async def display_message(self, sourceType: str, message: str) -> None:
+        """Display a message on the set-top box and repeat it for longer visibility.
+
+        # We sturen de payload 3 keer met een kortere tussentijd
+
+        This method sends the message payload multiple times to ensure it stays
+        visible on the screen for a longer duration, as the display time for
+        such messages is typically short.
+
+        Args:
+            sourceType: The type of source for the message (e.g., "linear").
+            message: The message string to display.
+        """
+        for i in range(3):
+            payload = {
+                "id": await make_id(8),
+                "type": "CPE.pushToTV",
+                "source": {
+                    "clientId": self._mqtt_client.client_id,
+                    "friendlyDeviceName": f"\n\n{message}",
+                },
+                "status": {
+                    "sourceType": sourceType,
+                    "source": {"channelId": "1234"},
+                    "title": "Nieuwe melding",
+                    "relativePosition": 0,
+                    "speed": 1,
+                },
+            }
+
+            await self._mqtt_client.publish_message(
+                f"{self._auth.household_id}/{self.device_id}", json.dumps(payload)
+            )
+
+            # Omdat de melding 3 seconden blijft staan, wachten we 3 seconden
+            # voor de volgende 'refresh'.
+            if i < 2:
+                await asyncio.sleep(3)
+
     async def set_channel(self, source: str) -> None:
         """Change te channel from the settopbox."""
         channel = [src for src in self._channels.values() if src.title == source][0]
-        payload = (
-            '{"id":"'
-            + await make_id(8)
-            + '","type":"CPE.pushToTV","source":{"clientId":"'
-            + self._mqtt_client.client_id
-            + '","friendlyDeviceName":"Home Assistant"},'
-            + '"status":{"sourceType":"linear","source":{"channelId":"'
-            + channel.id
-            + '"},"relativePosition":0,"speed":1}}'
-        )
+        payload = {
+            "id": await make_id(8),
+            "type": "CPE.pushToTV",
+            "source": {
+                "clientId": self._mqtt_client.client_id,
+                "friendlyDeviceName": "Home Assistant",
+            },
+            "status": {
+                "sourceType": "linear",
+                "source": {"channelId": channel.id},
+                "relativePosition": 0,
+                "speed": 1,
+            },
+        }
 
         await self._mqtt_client.publish_message(
-            f"{self._auth.household_id}/{self.device_id}", payload
+            f"{self._auth.household_id}/{self.device_id}", json.dumps(payload)
         )
 
     async def play_recording(self, recording_id):
         """Play recording."""
-        payload = (
-            '{"id":"'
-            + await make_id(8)
-            + '","type":"CPE.pushToTV","source":{"clientId":"'
-            + self._mqtt_client.client_id
-            + '","friendlyDeviceName":"Home Assistant"},'
-            + '"status":{"sourceType":"nDVR","source":{"recordingId":"'
-            + recording_id
-            + '"},"relativePosition":0}}'
-        )
+        payload = {
+            "id": await make_id(8),
+            "type": "CPE.pushToTV",
+            "source": {
+                "clientId": self._mqtt_client.client_id,
+                "friendlyDeviceName": "Home Assistant",
+            },
+            "status": {
+                "sourceType": "nDVR",
+                "source": {"recordingId": recording_id},
+                "relativePosition": 0,
+            },
+        }
+
         await self._mqtt_client.publish_message(
-            f"{self._auth.household_id}/{self.device_id}", payload
+            f"{self._auth.household_id}/{self.device_id}", json.dumps(payload)
         )
 
     async def send_key_to_box(self, key: str) -> None: