lghorizon 0.7.1__tar.gz → 0.7.3__tar.gz

{lghorizon-0.7.1 → lghorizon-0.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lghorizon
-Version: 0.7.1
+Version: 0.7.3
 Summary: Python client for Liberty Global Horizon settop boxes
 Home-page: https://github.com/sholofly/LGHorizon-python
 Author: Rudolf Offereins

lghorizon-0.7.3/lghorizon/__init__.py

@@ -0,0 +1,23 @@
+"""Python client for LG Horizon."""
+
+from .lghorizon_api import LGHorizonApi
+from .models import (
+    LGHorizonBox,
+    LGHorizonRecordingListSeasonShow,
+    LGHorizonRecordingSingle,
+    LGHorizonRecordingShow,
+    LGHorizonRecordingEpisode,
+    LGHorizonCustomer,
+)
+from .exceptions import (
+    LGHorizonApiUnauthorizedError,
+    LGHorizonApiConnectionError,
+    LGHorizonApiLockedError,
+)
+from .const import (
+    ONLINE_RUNNING,
+    ONLINE_STANDBY,
+    RECORDING_TYPE_SHOW,
+    RECORDING_TYPE_SEASON,
+    RECORDING_TYPE_SINGLE,
+)  # noqa

lghorizon-0.7.3/lghorizon/exceptions.py

@@ -0,0 +1,17 @@
+"""Exceptions for the LGHorizon API."""
+
+
+class LGHorizonApiError(Exception):
+    """Generic LGHorizon exception."""
+
+
+class LGHorizonApiConnectionError(LGHorizonApiError):
+    """Generic LGHorizon exception."""
+
+
+class LGHorizonApiUnauthorizedError(Exception):
+    """Generic LGHorizon exception."""
+
+
+class LGHorizonApiLockedError(LGHorizonApiUnauthorizedError):
+    """Generic LGHorizon exception."""

{lghorizon-0.7.1 → lghorizon-0.7.3}/lghorizon/lghorizon_api.py

@@ -3,7 +3,11 @@
 import logging
 import json
 import sys, traceback
-from .exceptions import LGHorizonApiUnauthorizedError, LGHorizonApiConnectionError
+from .exceptions import (
+    LGHorizonApiUnauthorizedError,
+    LGHorizonApiConnectionError,
+    LGHorizonApiLockedError,
+)
 import backoff
 from requests import Session, exceptions as request_exceptions
 from paho.mqtt.client import WebsocketConnectionError
@@ -35,7 +39,7 @@ from .const import (
     RECORDING_TYPE_SEASON,
     RECORDING_TYPE_SHOW,
 )
-from typing import Any, Dict, List
+from typing import Any, Callable, Dict, List
 
 _logger = logging.getLogger(__name__)
 _supported_platforms = ["EOS", "EOS2", "HORIZON", "APOLLO"]
@@ -47,7 +51,7 @@ class LGHorizonApi:
     _auth: LGHorizonAuth = None
     _session: Session = None
     settop_boxes: Dict[str, LGHorizonBox] = None
-    _customer: LGHorizonCustomer = None
+    customer: LGHorizonCustomer = None
     _mqttClient: LGHorizonMqttClient = None
     _channels: Dict[str, LGHorizonChannel] = None
     _country_settings = None
@@ -56,6 +60,8 @@ class LGHorizonApi:
     _entitlements: List[str] = None
     _identifier: str = None
     _config: str = None
+    _refresh_callback: Callable = None
+    _profile_id: str = None
 
     def __init__(
         self,
@@ -64,6 +70,7 @@ class LGHorizonApi:
         country_code: str = "nl",
         identifier: str = None,
         refresh_token=None,
+        profile_id=None,
     ) -> None:
         """Create LGHorizon API."""
         self.username = username
@@ -77,10 +84,8 @@ class LGHorizonApi:
         self._channels = {}
         self._entitlements = []
         self._identifier = identifier
+        self._profile_id = profile_id
 
-    @backoff.on_exception(
-        backoff.expo, LGHorizonApiConnectionError, max_tries=3, logger=_logger
-    )
     def _authorize(self) -> None:
         ctry_code = self._country_code[0:2]
         if ctry_code == "be":
@@ -107,6 +112,8 @@ class LGHorizonApi:
             error = error_json["error"]
             if error and error["statusCode"] == 97401:
                 raise LGHorizonApiUnauthorizedError("Invalid credentials")
+            elif error and error["statusCode"] == 97117:
+                raise LGHorizonApiLockedError("Account locked")
             elif error:
                 raise LGHorizonApiConnectionError(error["message"])
             else:
@@ -146,8 +153,15 @@ class LGHorizonApi:
         self._auth.fill(auth_response.json())
         self.refresh_token = self._auth.refreshToken
         self._session.cookies["ACCESSTOKEN"] = self._auth.accessToken
+
+        if self._refresh_callback:
+            self._refresh_callback()
+
         _logger.debug("Authorization succeeded")
 
+    def set_callback(self, refresh_callback: Callable) -> None:
+        self._refresh_callback = refresh_callback
+
     def authorize_telenet(self):
         try:
             login_session = Session()
@@ -225,7 +239,14 @@ class LGHorizonApi:
         _logger.debug(f"MQTT token: {self._auth.mqttToken}")
 
     @backoff.on_exception(
-        backoff.expo, BaseException, jitter=None, max_time=600, logger=_logger
+        backoff.expo,
+        BaseException,
+        jitter=None,
+        max_tries=3,
+        logger=_logger,
+        giveup=lambda e: isinstance(
+            e, (LGHorizonApiLockedError, LGHorizonApiUnauthorizedError)
+        ),
     )
     def connect(self) -> None:
         self._config = self._get_config(self._country_code)
@@ -238,13 +259,14 @@ class LGHorizonApi:
             self._on_mqtt_connected,
             self._on_mqtt_message,
         )
+
         self._register_customer_and_boxes()
         self._mqttClient.connect()
 
     def disconnect(self):
         """Disconnect."""
         _logger.debug("Disconnect from API")
-        if not self._mqttClient.is_connected:
+        if not self._mqttClient or not self._mqttClient.is_connected:
             return
         self._mqttClient.disconnect()
 
@@ -255,8 +277,18 @@ class LGHorizonApi:
             box.register_mqtt()
 
     def _on_mqtt_message(self, message: str, topic: str) -> None:
-        if "source" in message:
+        if "action" in message and message["action"] == "OPS.getProfilesUpdate":
+            self._update_customer()
+            self._channels.clear()
+            self._get_channels()
+            box: LGHorizonBox
+            for box in self.settop_boxes.values():
+                box.update_channels(self._channels)
+        elif "source" in message:
             deviceId = message["source"]
+            if not isinstance(deviceId, str):
+                _logger.debug("ignoring message - not a string")
+                return
             if not deviceId in self.settop_boxes.keys():
                 return
             try:
@@ -264,6 +296,7 @@ class LGHorizonApi:
                     self.settop_boxes[deviceId].update_state(message)
                 if "status" in message:
                     self._handle_box_update(deviceId, message)
+
             except Exception:
                 _logger.exception("Could not handle status message")
                 _logger.warning(f"Full message: {str(message)}")
@@ -335,7 +368,7 @@ class LGHorizonApi:
                 last_speed_change_time = playerState["lastSpeedChangeTime"]
                 relative_position = playerState["relativePosition"]
                 raw_vod = self._do_api_call(
-                    f"{self._config['vodService']['URL']}/v2/detailscreen/{titleId}?language={self._country_settings['language']}&profileId=4504e28d-c1cb-4284-810b-f5eaab06f034&cityId={self._customer.cityId}"
+                    f"{self._config['vodService']['URL']}/v2/detailscreen/{titleId}?language={self._country_settings['language']}&profileId=4504e28d-c1cb-4284-810b-f5eaab06f034&cityId={self.customer.cityId}"
                 )
                 vod = LGHorizonVod(raw_vod)
                 self.settop_boxes[deviceId].update_with_vod(
@@ -363,40 +396,50 @@ class LGHorizonApi:
         return json_response
 
     def _register_customer_and_boxes(self):
-        _logger.info("Get personalisation info...")
-        personalisation_result = self._do_api_call(
-            f"{self._config['personalizationService']['URL']}/v1/customer/{self._auth.householdId}?with=profiles%2Cdevices"
-        )
-        _logger.debug(f"Personalisation result: {personalisation_result}")
-        self._customer = LGHorizonCustomer(personalisation_result)
+        self._update_customer()
         self._get_channels()
-        if not "assignedDevices" in personalisation_result:
+        if len(self.customer.settop_boxes) == 0:
             _logger.warning("No boxes found.")
             return
         _logger.info("Registering boxes")
-        for device in personalisation_result["assignedDevices"]:
+        for device in self.customer.settop_boxes:
             platform_type = device["platformType"]
-            if not platform_type in _supported_platforms:
+            if platform_type not in _supported_platforms:
                 continue
             if (
                 "platform_types" in self._country_settings
                 and platform_type in self._country_settings["platform_types"]
             ):
-                platformType = self._country_settings["platform_types"][platform_type]
+                platform_type = self._country_settings["platform_types"][platform_type]
             else:
-                platformType = None
+                platform_type = None
             box = LGHorizonBox(
-                device, platformType, self._mqttClient, self._auth, self._channels
+                device, platform_type, self._mqttClient, self._auth, self._channels
             )
             self.settop_boxes[box.deviceId] = box
-            _logger.info(f"Box {box.deviceId} registered...")
+            _logger.info("Box %s registered...", box.deviceId)
+
+    def _update_customer(self):
+        _logger.info("Get customer data")
+        personalisation_result = self._do_api_call(
+            f"{self._config['personalizationService']['URL']}/v1/customer/{self._auth.householdId}?with=profiles%2Cdevices"
+        )
+        _logger.debug("Personalisation result: %s ", personalisation_result)
+        self.customer = LGHorizonCustomer(personalisation_result)
 
     def _get_channels(self):
         self._update_entitlements()
         _logger.info("Retrieving channels...")
         channels_result = self._do_api_call(
-            f"{self._config['linearService']['URL']}/v2/channels?cityId={self._customer.cityId}&language={self._country_settings['language']}&productClass=Orion-DASH"
+            f"{self._config['linearService']['URL']}/v2/channels?cityId={self.customer.cityId}&language={self._country_settings['language']}&productClass=Orion-DASH"
         )
+        profile_channels = []
+        if self._profile_id and self._profile_id in self.customer.profiles:
+            profile_channels = self.customer.profiles[
+                self._profile_id
+            ].favorite_channels
+
+        has_profile_channels = len(profile_channels) > 0
         for channel in channels_result:
             if "isRadio" in channel and channel["isRadio"]:
                 continue
@@ -406,6 +449,9 @@ class LGHorizonApi:
             if len(common_entitlements) == 0:
                 continue
             channel_id = channel["id"]
+            if has_profile_channels and channel_id not in profile_channels:
+                continue
+
             self._channels[channel_id] = LGHorizonChannel(channel)
         _logger.info(f"{len(self._channels)} retrieved.")
 
@@ -420,6 +466,10 @@ class LGHorizonApi:
 
     def get_recording_capacity(self) -> int:
         """Returns remaining recording capacity"""
+        ctry_code = self._country_code[0:2]
+        if ctry_code == "gb":
+            _logger.debug("GB: not supported")
+            return None
         try:
             _logger.info("Retrieving recordingcapacity...")
             quota_content = self._do_api_call(

{lghorizon-0.7.1 → lghorizon-0.7.3}/lghorizon/models.py

@@ -438,6 +438,9 @@ class LGHorizonBox:
             self.manufacturer = platform_type["manufacturer"]
             self.model = platform_type["model"]
 
+    def update_channels(self, channels: Dict[str, LGHorizonChannel]):
+        self._channels = channels
+
     def register_mqtt(self) -> None:
         if not self._mqtt_client.is_connected:
             raise Exception("MQTT client not connected.")
@@ -677,17 +680,32 @@ class LGHorizonBox:
         self._mqtt_client.publish_message(topic, json.dumps(payload))
 
 
+class LGHorizonProfile:
+    profile_id: str = None
+    name: str = None
+    favorite_channels: [] = None
+
+    def __init__(self, json_payload):
+        self.profile_id = json_payload["profileId"]
+        self.name = json_payload["name"]
+        self.favorite_channels = json_payload["favoriteChannels"]
+
+
 class LGHorizonCustomer:
     customerId: str = None
     hashedCustomerId: str = None
     countryId: str = None
     cityId: int = 0
-    settop_boxes: Dict[str, LGHorizonBox] = None
+    settop_boxes: [] = None
+    profiles: Dict[str, LGHorizonProfile] = {}
 
     def __init__(self, json_payload):
         self.customerId = json_payload["customerId"]
         self.hashedCustomerId = json_payload["hashedCustomerId"]
         self.countryId = json_payload["countryId"]
         self.cityId = json_payload["cityId"]
-        if not "assignedDevices" in json_payload:
-            return
+        if "assignedDevices" in json_payload:
+            self.settop_boxes = json_payload["assignedDevices"]
+        if "profiles" in json_payload:
+            for profile in json_payload["profiles"]:
+                self.profiles[profile["profileId"]] = LGHorizonProfile(profile)

{lghorizon-0.7.1 → lghorizon-0.7.3}/lghorizon.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lghorizon
-Version: 0.7.1
+Version: 0.7.3
 Summary: Python client for Liberty Global Horizon settop boxes
 Home-page: https://github.com/sholofly/LGHorizon-python
 Author: Rudolf Offereins

lghorizon-0.7.3/secrets_stub.json

@@ -0,0 +1,7 @@
+{
+    "username": "your_username",
+    "password": "your_password",
+    "country": "your_country_code",
+    "profile_id":"your_profile_id"
+
+}

{lghorizon-0.7.1 → lghorizon-0.7.3}/test.py

@@ -57,12 +57,17 @@ if __name__ == "__main__":
         if "refresh_token" in secrets:
             refresh_token = secrets["refresh_token"]
 
+        profile_id = None
+        if "profile_id" in secrets:
+            profile_id = secrets["profile_id"]
+
         api = LGHorizonApi(
             secrets["username"],
             secrets["password"],
             secrets["country"],
             # identifier="DTV3907048",
-            refresh_token = refresh_token,
+            refresh_token=refresh_token,
+            profile_id=profile_id
         )
         api.connect()
         event_loop()

lghorizon-0.7.1/lghorizon/__init__.py

@@ -1,5 +0,0 @@
-"""Python client for LG Horizon."""
-from .lghorizon_api import LGHorizonApi
-from .models import LGHorizonBox, LGHorizonRecordingListSeasonShow, LGHorizonRecordingSingle, LGHorizonRecordingShow, LGHorizonRecordingEpisode
-from .exceptions import LGHorizonApiUnauthorizedError, LGHorizonApiConnectionError
-from .const import ONLINE_RUNNING, ONLINE_STANDBY, RECORDING_TYPE_SHOW, RECORDING_TYPE_SEASON, RECORDING_TYPE_SINGLE# noqa

lghorizon-0.7.1/lghorizon/exceptions.py

@@ -1,11 +0,0 @@
-"""Exceptions for the LGHorizon API."""
-
-class LGHorizonApiError(Exception):
-    """Generic GeocachingApi exception."""
-
-class LGHorizonApiConnectionError(LGHorizonApiError):
-    """Generic GeocachingApi exception."""
-
-class LGHorizonApiUnauthorizedError(Exception):
-    """Generic GeocachingApi exception."""
-        

lghorizon-0.7.1/secrets_stub.json

@@ -1,5 +0,0 @@
-{
-    "username": "your_username",
-    "password": "your_password",
-    "country": "your_country_code"
-}