lghorizon 0.8.0b2__tar.gz → 0.9.0b0__tar.gz

{lghorizon-0.8.0b2 → lghorizon-0.9.0b0}/.github/workflows/build-on-pr.yml

@@ -13,7 +13,7 @@ jobs:
     - name: Set up Python 3.10
       uses: actions/setup-python@v5
       with:
-        python-version: '3.10'
+        python-version: '3.13'
     - name: Install pypa/build
       run: >-
         python -m

{lghorizon-0.8.0b2 → lghorizon-0.9.0b0}/.github/workflows/publish-to-pypi.yml

@@ -7,12 +7,14 @@ jobs:
   build-n-publish:
     name: Publish Python 🐍 distribution 📦 to Pypi
     runs-on: ubuntu-24.04
+    permissions:
+      id-token: write
     steps:
     - uses: actions/checkout@master
     - name: Set up Python 3.10
       uses: actions/setup-python@v5
       with:
-        python-version: '3.10'
+        python-version: '3.13'
 
     - name: Install pypa/build
       run: >-
@@ -29,5 +31,3 @@ jobs:
         --outdir dist/
     - name: Publish distribution 📦 to PyPI
       uses: pypa/gh-action-pypi-publish@release/v1
-      with:
-        password: ${{ secrets.PYPI_API_TOKEN }}

{lghorizon-0.8.0b2 → lghorizon-0.9.0b0}/.gitignore

@@ -24,3 +24,4 @@ __pycache__/*
 test/nl.py
 secrets.json
 logfile.log
+lghorizon.log

lghorizon-0.9.0b0/.vscode/launch.json

@@ -0,0 +1,15 @@
+{
+  // Use IntelliSense to learn about possible attributes.
+  // Hover to view descriptions of existing attributes.
+  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Python Debugger: Debug LGHorizon",
+      "type": "debugpy",
+      "request": "launch",
+      "program": "main.py",
+      "console": "integratedTerminal"
+    }
+  ]
+}

{lghorizon-0.8.0b2 → lghorizon-0.9.0b0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: lghorizon
-Version: 0.8.0b2
+Version: 0.9.0b0
 Summary: Python client for Liberty Global Horizon settop boxes
 Home-page: https://github.com/sholofly/LGHorizon-python
 Author: Rudolf Offereins
@@ -20,9 +20,21 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: paho-mqtt>=2.0.0
+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
 

lghorizon-0.9.0b0/lghorizon/__init__.py

@@ -0,0 +1,6 @@
+"""Python client for LG Horizon."""
+
+from .lghorizon_api import LGHorizonApi
+from .lghorizon_device import LGHorizonDevice
+from .lghorizon_models import *
+from .exceptions import *

{lghorizon-0.8.0b2 → lghorizon-0.9.0b0}/lghorizon/const.py

@@ -38,11 +38,18 @@ RECORDING_TYPE_SEASON = "season"
 
 BE_AUTH_URL = "https://login.prd.telenet.be/openid/login.do"
 
+PLATFORM_TYPES = {
+    "EOS": {"manufacturer": "Arris", "model": "DCX960"},
+    "EOS2": {"manufacturer": "HUMAX", "model": "2008C-STB-TN"},
+    "HORIZON": {"manufacturer": "Arris", "model": "DCX960"},
+    "APOLLO": {"manufacturer": "Arris", "model": "VIP5002W"},
+}
+
 COUNTRY_SETTINGS = {
     "nl": {
         "api_url": "https://spark-prod-nl.gnp.cloud.ziggogo.tv",
         "mqtt_url": "obomsg.prod.nl.horizon.tv",
-        "use_oauth": False,
+        "use_refreshtoken": False,
         "channels": [
             {
                 "channelId": "NL_000073_019506",
@@ -76,6 +83,15 @@ COUNTRY_SETTINGS = {
         "channels": [],
         "language": "de",
     },
+    "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"},
+        },
+    },
     "be-nl": {
         "api_url": "https://spark-prod-be.gnp.cloud.telenet.tv",
         "oauth_username_fieldname": "j_username",
@@ -97,7 +113,7 @@ COUNTRY_SETTINGS = {
     },
     "be-nl-preprod": {
         "api_url": "https://spark-preprod-be.gnp.cloud.telenet.tv",
-        "use_oauth": True,
+        "use_refreshtoken": True,
         "oauth_username_fieldname": "j_username",
         "oauth_password_fieldname": "j_password",
         "oauth_add_accept_header": False,
@@ -122,13 +138,13 @@ COUNTRY_SETTINGS = {
     },
     "ie": {
         "api_url": "https://spark-prod-ie.gnp.cloud.virginmediatv.ie",
-        "use_oauth": False,
+        "use_refreshtoken": False,
         "channels": [],
         "language": "en",
     },
     "pl": {
         "api_url": "https://spark-prod-pl.gnp.cloud.upctv.pl",
-        "use_oauth": False,
+        "use_refreshtoken": False,
         "channels": [],
         "language": "pl",
         "platform_types": {

{lghorizon-0.8.0b2 → lghorizon-0.9.0b0}/lghorizon/helpers.py

@@ -3,7 +3,7 @@
 import random
 
 
-def make_id(string_length=10):
+async def make_id(string_length=10):
     """Create an id with given length."""
     letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
     return "".join(random.choice(letters) for i in range(string_length))

{lghorizon-0.8.0b2/lghorizon → lghorizon-0.9.0b0/lghorizon/legacy}/lghorizon_api.py

@@ -93,9 +93,7 @@ class LGHorizonApi:
 
     def _authorize(self) -> None:
         ctry_code = self._country_code[0:2]
-        if ctry_code == "be":
-            self._authorize_telenet()
-        elif ctry_code in ("gb", "ch"):
+        if ctry_code in ("gb", "ch", "be"):
             self._authorize_with_refresh_token()
         else:
             self._authorize_default()
@@ -169,76 +167,6 @@ class LGHorizonApi:
         """Set the refresh callback."""
         self._refresh_callback = refresh_callback
 
-    def _authorize_telenet(self):
-        """Authorize telenet users."""
-        try:
-            login_session = Session()
-            # Step 1 - Get Authorization data
-            _logger.debug("Step 1 - Get Authorization data")
-            auth_url = (
-                f"{self._country_settings['api_url']}/auth-service/v1/sso/authorization"
-            )
-            auth_response = login_session.get(auth_url)
-            if not auth_response.ok:
-                raise LGHorizonApiConnectionError("Can't connect to authorization URL")
-            auth_response_json = auth_response.json()
-            authorization_uri = auth_response_json["authorizationUri"]
-            authorization_validity_token = auth_response_json["validityToken"]
-
-            # Step 2 - Get Authorization cookie
-            _logger.debug("Step 2 - Get Authorization cookie")
-
-            auth_cookie_response = login_session.get(authorization_uri)
-            if not auth_cookie_response.ok:
-                raise LGHorizonApiConnectionError("Can't connect to authorization URL")
-
-            _logger.debug("Step 3 - Login")
-
-            username_fieldname = self._country_settings["oauth_username_fieldname"]
-            pasword_fieldname = self._country_settings["oauth_password_fieldname"]
-
-            payload = {
-                username_fieldname: self.username,
-                pasword_fieldname: self.password,
-                "rememberme": "true",
-            }
-
-            login_response = login_session.post(
-                self._country_settings["oauth_url"], payload, allow_redirects=False
-            )
-            if not login_response.ok:
-                raise LGHorizonApiConnectionError("Can't connect to authorization URL")
-            redirect_url = login_response.headers[
-                self._country_settings["oauth_redirect_header"]
-            ]
-
-            if self._identifier is not None:
-                redirect_url += f"&dtv_identifier={self._identifier}"
-            redirect_response = login_session.get(redirect_url, allow_redirects=False)
-            success_url = redirect_response.headers[
-                self._country_settings["oauth_redirect_header"]
-            ]
-            code_matches = re.findall(r"code=(.*)&", success_url)
-
-            authorization_code = code_matches[0]
-
-            new_payload = {
-                "authorizationGrant": {
-                    "authorizationCode": authorization_code,
-                    "validityToken": authorization_validity_token,
-                }
-            }
-            headers = {
-                "content-type": "application/json",
-            }
-            post_result = login_session.post(
-                auth_url, json.dumps(new_payload), headers=headers
-            )
-            self._auth.fill(post_result.json())
-            self._session.cookies["ACCESSTOKEN"] = self._auth.access_token
-        except Exception:
-            pass
-
     def _obtain_mqtt_token(self):
         _logger.debug("Obtain mqtt token...")
         mqtt_auth_url = self._config["authorizationService"]["URL"]

{lghorizon-0.8.0b2/lghorizon → lghorizon-0.9.0b0/lghorizon/legacy}/models.py

@@ -293,11 +293,17 @@ class LGHorizonRecordingListSeasonShow(LGHorizonBaseRecording):
     def __init__(self, recording_season_json):
         """Init the single recording."""
 
+        poster_url = None
+        if (
+            "poster" in recording_season_json
+            and "url" in recording_season_json["poster"]
+        ):
+            poster_url = recording_season_json["poster"]["url"]
         LGHorizonBaseRecording.__init__(
             self,
             recording_season_json["id"],
             recording_season_json["title"],
-            recording_season_json["poster"]["url"],
+            poster_url,
             recording_season_json["channelId"],
             recording_season_json["type"],
         )
@@ -360,7 +366,6 @@ class LGHorizonMqttClient:
         )
         self.client_id = make_id()
         self._mqtt_client = mqtt.Client(
-            mqtt.CallbackAPIVersion.VERSION1,
             client_id=self.client_id,
             transport="websockets",
         )
@@ -657,7 +662,7 @@ class LGHorizonBox:
             '{"id":"'
             + make_id(8)
             + '","type":"CPE.pushToTV","source":{"clientId":"'
-            + self._mqtt_client.clientId
+            + self._mqtt_client.client_id
             + '","friendlyDeviceName":"Home Assistant"},'
             + '"status":{"sourceType":"linear","source":{"channelId":"'
             + channel.id
@@ -674,7 +679,7 @@ class LGHorizonBox:
             '{"id":"'
             + make_id(8)
             + '","type":"CPE.pushToTV","source":{"clientId":"'
-            + self._mqtt_client.clientId
+            + self._mqtt_client.client_id
             + '","friendlyDeviceName":"Home Assistant"},'
             + '"status":{"sourceType":"nDVR","source":{"recordingId":"'
             + recording_id
@@ -686,23 +691,26 @@ class LGHorizonBox:
 
     def send_key_to_box(self, key: str) -> None:
         """Send emulated (remote) key press to settopbox."""
-        payload = (
-            '{"type":"CPE.KeyEvent","status":{"w3cKey":"'
-            + key
-            + '","eventType":"keyDownUp"}}'
-        )
+        payload_dict = {
+            "type": "CPE.KeyEvent",
+            "runtimeType": "key",
+            "id": "ha",
+            "source": self.device_id.lower(),
+            "status": {"w3cKey": key, "eventType": "keyDownUp"},
+        }
+        payload = json.dumps(payload_dict)
         self._mqtt_client.publish_message(
             f"{self._auth.household_id}/{self.device_id}", payload
         )
 
-    def _set_unknown_channel_info(self) -> None:
-        """Set unknown channel info."""
-        _logger.warning("Couldn't set channel. Channel info set to unknown...")
-        self.playing_info.set_source_type(BOX_PLAY_STATE_CHANNEL)
-        self.playing_info.set_channel(None)
-        self.playing_info.set_title("No information available")
-        self.playing_info.set_image(None)
-        self.playing_info.set_paused(False)
+    # def _set_unknown_channel_info(self) -> None:
+    #     """Set unknown channel info."""
+    #     _logger.warning("Couldn't set channel. Channel info set to unknown...")
+    #     self.playing_info.set_source_type(BOX_PLAY_STATE_CHANNEL)
+    #     self.playing_info.set_channel(None)
+    #     self.playing_info.set_title("No information available")
+    #     self.playing_info.set_image(None)
+    #     self.playing_info.set_paused(False)
 
     def _request_settop_box_state(self) -> None:
         """Send mqtt message to receive state from settop box."""

lghorizon-0.9.0b0/lghorizon/lghorizon_api.py

@@ -0,0 +1,270 @@
+"""LG Horizon API client."""
+
+import logging
+from typing import Any, Dict, cast
+
+from .lghorizon_device import LGHorizonDevice
+from .lghorizon_models import LGHorizonChannel
+from .lghorizon_models import LGHorizonAuth
+from .lghorizon_models import LGHorizonCustomer
+from .lghorizon_mqtt_client import LGHorizonMqttClient
+from .lghorizon_models import LGHorizonServicesConfig
+from .lghorizon_models import LGHorizonEntitlements
+from .lghorizon_models import LGHorizonProfile
+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_recording_factory import LGHorizonRecordingFactory
+from .lghorizon_device_state_processor import LGHorizonDeviceStateProcessor
+
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class LGHorizonApi:
+    """LG Horizon API client."""
+
+    _mqtt_client: LGHorizonMqttClient
+    auth: LGHorizonAuth
+    _service_config: LGHorizonServicesConfig
+    _customer: LGHorizonCustomer
+    _channels: Dict[str, LGHorizonChannel]
+    _entitlements: LGHorizonEntitlements
+    _profile_id: str
+    _initialized: bool = False
+    _devices: Dict[str, LGHorizonDevice] = {}
+    _message_factory: LGHorizonMessageFactory = LGHorizonMessageFactory()
+    _device_state_processor: LGHorizonDeviceStateProcessor | None
+    _recording_factory: LGHorizonRecordingFactory = LGHorizonRecordingFactory()
+
+    def __init__(self, auth: LGHorizonAuth, profile_id: str = "") -> None:
+        """Initialize LG Horizon API client."""
+        self.auth = auth
+        self._profile_id = profile_id
+        self._channels = {}
+        self._device_state_processor = None
+
+    async def initialize(self) -> None:
+        """Initialize the API client."""
+        self._service_config = await self.auth.get_service_config()
+        self._customer = await self._get_customer_info()
+        if self._profile_id == "":
+            self._profile_id = list(self._customer.profiles.keys())[0]
+        await self._refresh_entitlements()
+        await self._refresh_channels()
+        self._mqtt_client = await self._create_mqtt_client()
+        await self._mqtt_client.connect()
+        await self._register_devices()
+        self._device_state_processor = LGHorizonDeviceStateProcessor(
+            self.auth, self._channels, self._customer, self._profile_id
+        )
+        self._initialized = True
+
+    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]:
+        """Get profile IDs."""
+        if not self._initialized:
+            raise RuntimeError("LGHorizonApi not initialized")
+
+        return self._customer.profiles
+
+    async def get_profile_channels(
+        self, profile_id: str
+    ) -> Dict[str, LGHorizonChannel]:
+        """Returns channels to display baed on profile."""
+        # Attempt to retrieve the profile by the given 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.
+        if not profile and self._customer.profiles:
+            _LOGGER.debug(
+                "Profile with ID '%s' not found. Defaulting to first available profile.",
+                profile_id,
+            )
+            profile = list(self._customer.profiles.values())[0]
+
+        # If a profile is found and it has favorite channels, filter the main channels list.
+        if profile and profile.favorite_channels:
+            _LOGGER.debug("Returning favorite channels for profile '%s'.", profile.name)
+            # Use a set for faster lookup of favorite channel IDs
+            profile_channel_ids = set(profile.favorite_channels)
+            return {
+                channel.id: channel
+                for channel in self._channels.values()
+                if channel.id in profile_channel_ids
+            }
+
+        # If no profile is found (even after defaulting) or the profile has no favorite channels,
+        # return all available channels.
+        _LOGGER.debug("No specific profile channels found, returning all channels.")
+        return self._channels
+
+    async def _register_devices(self) -> None:
+        """Register devices."""
+        _LOGGER.debug("Registering devices...")
+        self._devices = {}
+        channels = await self.get_profile_channels(self._profile_id)
+        for raw_box in self._customer.assigned_devices:
+            _LOGGER.debug("Creating box for device: %s", raw_box)
+            if self._device_state_processor is None:
+                self._device_state_processor = LGHorizonDeviceStateProcessor(
+                    self.auth, self._channels, self._customer, self._profile_id
+                )
+            device = LGHorizonDevice(
+                raw_box,
+                self._mqtt_client,
+                self._device_state_processor,
+                self.auth,
+                channels,
+            )
+            self._devices[device.device_id] = device
+
+    async def disconnect(self) -> None:
+        """Disconnect the client."""
+        if self._mqtt_client:
+            await self._mqtt_client.disconnect()
+        self._initialized = False
+
+    async def _create_mqtt_client(self) -> LGHorizonMqttClient:
+        mqtt_client = await LGHorizonMqttClient.create(
+            self.auth,
+            self._on_mqtt_connected,
+            self._on_mqtt_message,
+        )
+        return mqtt_client
+
+    async def _on_mqtt_connected(self):
+        """MQTT connected callback."""
+        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
+        )
+        await self._mqtt_client.subscribe(self.auth.household_id + "/+/status")
+        await self._mqtt_client.subscribe(
+            self.auth.household_id + "/+/networkRecordings"
+        )
+        await self._mqtt_client.subscribe(
+            self.auth.household_id + "/+/networkRecordings/capacity"
+        )
+        await self._mqtt_client.subscribe(self.auth.household_id + "/+/localRecordings")
+        await self._mqtt_client.subscribe(
+            self.auth.household_id + "/+/localRecordings/capacity"
+        )
+        await self._mqtt_client.subscribe(self.auth.household_id + "/watchlistService")
+        await self._mqtt_client.subscribe(self.auth.household_id + "/purchaseService")
+        await self._mqtt_client.subscribe(
+            self.auth.household_id + "/personalizationService"
+        )
+        await self._mqtt_client.subscribe(self.auth.household_id + "/recordingStatus")
+        await self._mqtt_client.subscribe(
+            self.auth.household_id + "/recordingStatus/lastUserAction"
+        )
+
+    async def _on_mqtt_message(self, mqtt_message: dict, mqtt_topic: str):
+        """MQTT message callback."""
+        message = await self._message_factory.create_message(mqtt_topic, mqtt_message)
+        match message.message_type:
+            case LGHorizonMessageType.STATUS:
+                message.__class__ = LGHorizonStatusMessage
+                status_message = cast(LGHorizonStatusMessage, message)
+                device = self._devices[status_message.source]
+                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]
+                if (
+                    not device.device_state.state
+                    == LGHorizonRunningState.ONLINE_RUNNING
+                ):
+                    return
+                await device.handle_ui_status_message(ui_status_message)
+
+    async def _get_customer_info(self) -> LGHorizonCustomer:
+        service_url = await self._service_config.get_service_url(
+            "personalizationService"
+        )
+        result = await self.auth.request(
+            service_url,
+            f"/v1/customer/{self.auth.household_id}?with=profiles%2Cdevices",
+        )
+        return LGHorizonCustomer(result)
+
+    async def _refresh_entitlements(self) -> Any:
+        """Retrieve entitlements."""
+        _LOGGER.debug("Retrieving entitlements...")
+        service_url = await self._service_config.get_service_url("purchaseService")
+        result = await self.auth.request(
+            service_url,
+            f"/v2/customers/{self.auth.household_id}/entitlements?enableDaypass=true",
+        )
+        self._entitlements = LGHorizonEntitlements(result)
+
+    async def _refresh_channels(self):
+        """Retrieve channels."""
+        _LOGGER.debug("Retrieving channels...")
+        service_url = await self._service_config.get_service_url("linearService")
+        lang = await self._customer.get_profile_lang(self._profile_id)
+        channels_json = await self.auth.request(
+            service_url,
+            f"/v2/channels?cityId={self._customer.city_id}&language={lang}&productClass=Orion-DASH",
+        )
+        for channel_json in channels_json:
+            channel = LGHorizonChannel(channel_json)
+            common_entitlements = list(
+                set(self._entitlements.entitlement_ids) & set(channel.linear_products)
+            )
+
+            if len(common_entitlements) == 0:
+                continue
+
+            self._channels[channel.id] = channel
+
+    async def get_all_recordings(self) -> LGHorizonRecordingList:
+        """Retrieve all recordings."""
+        _LOGGER.debug("Retrieving recordings...")
+        service_url = await self._service_config.get_service_url("recordingService")
+        lang = await self._customer.get_profile_lang(self._profile_id)
+        recordings_json = await self.auth.request(
+            service_url,
+            f"/customers/{self.auth.household_id}/recordings?isAdult=false&offset=0&limit=100&sort=time&sortOrder=desc&profileId={self._profile_id}&language={lang}",
+        )
+        recordings = await self._recording_factory.create_recordings(recordings_json)
+        return recordings
+
+    async def get_show_recordings(
+        self, show_id: str, channel_id: str
+    ) -> LGHorizonRecordingList:
+        """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",
+        )
+        recordings = await self._recording_factory.create_episodes(episodes_json)
+        return recordings
+
+    async def get_recording_quota(self) -> LGHorizonRecordingQuota:
+        """Refresh recording quota."""
+        _LOGGER.debug("Refreshing recording quota...")
+        service_url = await self._service_config.get_service_url("recordingService")
+        quota_json = await self.auth.request(
+            service_url,
+            f"/customers/{self.auth.household_id}/quota",
+        )
+        return LGHorizonRecordingQuota(quota_json)
+
+
+__all__ = ["LGHorizonApi", "LGHorizonAuth"]