lghorizon 0.6.4__py3-none-any.whl → 0.6.6__py3-none-any.whl

lghorizon/const.py

@@ -40,7 +40,6 @@ BE_AUTH_URL = "https://login.prd.telenet.be/openid/login.do"
 COUNTRY_SETTINGS = {
     "nl": {
         "api_url": "https://prod.spark.ziggogo.tv",
-        "personalization_url_format": "https://prod.spark.ziggogo.tv/nld/web/personalization-service/v1/customer/{household_id}/devices",
         "mqtt_url": "obomsg.prod.nl.horizon.tv",
         "use_oauth": False,
         "channels": [
@@ -73,16 +72,12 @@ COUNTRY_SETTINGS = {
     },
     "ch": {
         "api_url": "https://prod.spark.sunrisetv.ch",
-        "personalization_url_format": "https://prod.spark.sunrisetv.ch/eng/web/personalization-service/v1/customer/{householdId}/devices",
-        "mqtt_url": "messagebroker-prod-ch.gnp.cloud.dmdsdp.com",
         "use_oauth": False,
         "channels": [],
         "language": "de",
     },
     "be-nl": {
-        "api_url": "https://prod.spark.telenet.tv",
-        "personalization_url_format": "https://prod.spark.telenettv.be/nld/web/personalization-service/v1/customer/{household_id}/devices",
-        "mqtt_url": "obomsg.prod.be.horizon.tv",
+        "api_url": "https://spark-prod-be.gnp.cloud.telenet.tv",
         "use_oauth": True,
         "oauth_username_fieldname": "j_username",
         "oauth_password_fieldname": "j_password",
@@ -130,18 +125,16 @@ COUNTRY_SETTINGS = {
     #     "oauth_redirect_header": "Location",
     #     "channels": [],
     # },
-    "at": {
-        "api_url": "https://prod.spark.magentatv.at",
-        "personalization_url_format": "https://prod.spark.magentatv.at/deu/web/personalization-service/v1/customer/{householdId}/devices",
-        "mqtt_url": "obomsg.prod.at.horizon.tv",
-        "use_oauth": False,
-        "channels": [],
-        "language": "de",
-    },
+    # "at": {
+    #     "api_url": "https://prod.spark.magentatv.at",
+    #     "personalization_url_format": "https://prod.spark.magentatv.at/deu/web/personalization-service/v1/customer/{householdId}/devices",
+    #     "mqtt_url": "obomsg.prod.at.horizon.tv",
+    #     "use_oauth": False,
+    #     "channels": [],
+    #     "language": "de",
+    # },
     "gb": {
-        "api_url": "https://prod.spark.virginmedia.com",
-        "personalization_url_format": "https://prod.spark.virginmedia.com/eng/web/personalization-service/v1/customer/{household_id}/devices",
-        "mqtt_url": "obomsg.prod.gb.horizon.tv",
+        "api_url": "https://spark-prod-gb.gnp.cloud.virgintvgo.virginmedia.com",
         "oauth_url": "https://id.virginmedia.com/rest/v40/session/start?protocol=oidc&rememberMe=true",
         "channels": [],
         "oesp_url": "https://prod.oesp.virginmedia.com/oesp/v4/GB/eng/web",
@@ -161,17 +154,13 @@ COUNTRY_SETTINGS = {
     #     "channels": [],
     # },
     "ie": {
-        "api_url": "https://prod.spark.virginmediatv.ie",
-        "personalization_url_format": "https://prod.spark.virginmediatv.ie/eng/web/personalization-service/v1/customer/{householdId}/devices",
-        "mqtt_url": "obomsg.prod.ie.horizon.tv",
+        "api_url": "https://spark-prod-ie.gnp.cloud.virginmediatv.ie",
         "use_oauth": False,
         "channels": [],
         "language": "en",
     },
     "pl": {
-        "api_url": "https://prod.spark.upctv.pl/",
-        "personalization_url_format": "https://prod.spark.upctv.pl/pol/web/personalization-service/v1/customer/{householdId}/devices",
-        "mqtt_url": "obomsg.prod.pl.horizon.tv",
+        "api_url": "https://spark-prod-pl.gnp.cloud.upctv.pl",
         "use_oauth": False,
         "channels": [],
         "language": "pl",

lghorizon/lghorizon_api.py

@@ -8,7 +8,7 @@ from requests import Session, exceptions as request_exceptions
 from paho.mqtt.client import WebsocketConnectionError
 import re
 from .models import (
-    LGHorizonAuth, 
+    LGHorizonAuth,
     LGHorizonBox,
     LGHorizonMqttClient,
     LGHorizonCustomer,
@@ -20,8 +20,8 @@ from .models import (
     LGHorizonBaseRecording,
     LGHorizonRecordingListSeasonShow,
     LGHorizonRecordingEpisode,
-    LGHorizonRecordingShow
-    )
+    LGHorizonRecordingShow,
+)
 
 from .const import (
     COUNTRY_SETTINGS,
@@ -32,12 +32,14 @@ from .const import (
     BOX_PLAY_STATE_VOD,
     RECORDING_TYPE_SINGLE,
     RECORDING_TYPE_SEASON,
-    RECORDING_TYPE_SHOW)
+    RECORDING_TYPE_SHOW,
+)
 from typing import Any, Dict, List
 
 _logger = logging.getLogger(__name__)
 _supported_platforms = ["EOS", "EOS2", "HORIZON", "APOLLO"]
 
+
 class LGHorizonApi:
     """Main class for handling connections with LGHorizon Settop boxes."""
 
@@ -48,12 +50,19 @@ class LGHorizonApi:
     _mqttClient: LGHorizonMqttClient = None
     _channels: Dict[str, LGHorizonChannel] = None
     _country_settings = None
-    _country_code:str = None
-    recording_capacity:int = None
-    _entitlements:List[str] = None
-    _identifier:str = None
-
-    def __init__(self, username: str, password: str, country_code: str = "nl", identifier:str = None) -> None:
+    _country_code: str = None
+    recording_capacity: int = None
+    _entitlements: List[str] = None
+    _identifier: str = None
+    _config: str = None
+
+    def __init__(
+        self,
+        username: str,
+        password: str,
+        country_code: str = "nl",
+        identifier: str = None,
+    ) -> None:
         """Create LGHorizon API."""
         self.username = username
         self.password = password
@@ -66,11 +75,13 @@ class LGHorizonApi:
         self._entitlements = []
         self._identifier = identifier
 
-    @backoff.on_exception(backoff.expo, LGHorizonApiConnectionError, max_tries=3, logger=_logger)
+    @backoff.on_exception(
+        backoff.expo, LGHorizonApiConnectionError, max_tries=3, logger=_logger
+    )
     def _authorize(self) -> None:
-        if self._country_code == 'be-nl':
+        if self._country_code == "be-nl":
             self.authorize_telenet()
-        elif self._country_code == 'gb':
+        elif self._country_code == "gb":
             self.authorize_gb()
         else:
             self._authorize_default()
@@ -78,18 +89,15 @@ class LGHorizonApi:
     def _authorize_default(self) -> None:
         _logger.debug("Authorizing")
         auth_url = f"{self._country_settings['api_url']}/auth-service/v1/authorization"
-        auth_headers = {
-            "x-device-code": "web"
-        }
-        auth_payload = {
-            "password": self.password,
-            "username": self.username
-        }
+        auth_headers = {"x-device-code": "web"}
+        auth_payload = {"password": self.password, "username": self.username}
         try:
-            auth_response = self._session.post(auth_url, headers=auth_headers, json=auth_payload)
+            auth_response = self._session.post(
+                auth_url, headers=auth_headers, json=auth_payload
+            )
         except Exception as ex:
             raise LGHorizonApiConnectionError("Unknown connection failure") from ex
-            
+
         if not auth_response.ok:
             error_json = auth_response.json()
             error = error_json["error"]
@@ -104,10 +112,9 @@ class LGHorizonApi:
         _logger.debug("Authorization succeeded")
 
     def authorize_gb(self):
-
         try:
             login_session = Session()
-    ####################################
+            ####################################
             _logger.debug("Step 1 - Get Authorization data")
             auth_url = f"{self._country_settings['oesp_url']}/authorization"
             auth_response = login_session.get(auth_url)
@@ -118,38 +125,36 @@ class LGHorizonApi:
             auth_state = auth_session["state"]
             authorizationUri = auth_session["authorizationUri"]
             authValidityToken = auth_session["validityToken"]
-    ####################################
+            ####################################
             _logger.debug("Step 2 - Get Authorization cookie")
 
             auth_cookie_response = login_session.get(authorizationUri)
             if not auth_cookie_response.ok:
                 raise LGHorizonApiConnectionError("Can't connect to authorization URL")
-    ####################################       
+            ####################################
             _logger.debug("Step 3 - Login")
-            payload = {
-                "username": self.username,
-                "credential": self.password
-            }
-            headers = {
-                "accept": "application/json; charset=UTF-8, */*"
-            }
-            
+            payload = {"username": self.username, "credential": self.password}
+            headers = {"accept": "application/json; charset=UTF-8, */*"}
+
             login_response = login_session.post(
-                self._country_settings["oauth_url"], json.dumps(payload), headers=headers, allow_redirects=False
+                self._country_settings["oauth_url"],
+                json.dumps(payload),
+                headers=headers,
+                allow_redirects=False,
             )
             if not login_response.ok:
                 raise LGHorizonApiConnectionError("Can't connect to authorization URL")
-            
+
             if not "x-redirect-location" in login_response.headers:
                 raise LGHorizonApiConnectionError("No redirect location in headers.")
-            
+
             redirect_url = login_response.headers["x-redirect-location"]
-    ####################################
+            ####################################
             _logger.debug("Step 4 - Follow redirect")
             redirect_response = login_session.get(redirect_url, allow_redirects=False)
             if not "Location" in redirect_response.headers:
                 raise LGHorizonApiConnectionError("No success url in redirect.")
-    ####################################           
+            ####################################
             _logger.debug("Step 5 - Extract auth code")
             success_url = redirect_response.headers["Location"]
             codeMatches = re.findall(r"code=(.*)&", success_url)
@@ -160,36 +165,47 @@ class LGHorizonApi:
             if len(codeMatches) == 0:
                 raise LGHorizonApiConnectionError("No state in redirect headers")
             authorizationState = stateMatches[0]
-            _logger.debug(f"Auth code: {authorizationCode}, Auth state: {authorizationState}")
-    ####################################
+            _logger.debug(
+                f"Auth code: {authorizationCode}, Auth state: {authorizationState}"
+            )
+            ####################################
             _logger.debug("Step 6 - Post auth data with valid code")
             authorization_payload = {
-                "authorizationGrant":{
-                    "authorizationCode":authorizationCode,
-                    "validityToken":authValidityToken,
-                    "state": authorizationState
+                "authorizationGrant": {
+                    "authorizationCode": authorizationCode,
+                    "validityToken": authValidityToken,
+                    "state": authorizationState,
                 }
             }
             headers = {
-                "content-type":"application/json",
+                "content-type": "application/json",
             }
-            # VM requires the client to pass the response from /authorization verbatim to /session?token=true 
-            post_authorization_result = login_session.post(self._country_settings["oesp_url"]+"/authorization", json.dumps(authorization_payload), headers=headers)
-            post_session_result = login_session.post(self._country_settings["oesp_url"]+"/session?token=true", json.dumps(post_authorization_result.json()), headers=headers)
+            # VM requires the client to pass the response from /authorization verbatim to /session?token=true
+            post_authorization_result = login_session.post(
+                self._country_settings["oesp_url"] + "/authorization",
+                json.dumps(authorization_payload),
+                headers=headers,
+            )
+            post_session_result = login_session.post(
+                self._country_settings["oesp_url"] + "/session?token=true",
+                json.dumps(post_authorization_result.json()),
+                headers=headers,
+            )
 
             self._auth.fill(post_session_result.json())
             self._session.cookies["ACCESSTOKEN"] = self._auth.accessToken
-    ####################################          
+        ####################################
         except Exception as ex:
             pass
 
     def authorize_telenet(self):
-
         try:
             login_session = Session()
-            #Step 1 - Get Authorization data
+            # 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_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")
@@ -197,13 +213,13 @@ class LGHorizonApi:
             authorizationUri = auth_response_json["authorizationUri"]
             authValidtyToken = auth_response_json["validityToken"]
 
-            #Step 2 - Get Authorization cookie
+            # Step 2 - Get Authorization cookie
             _logger.debug("Step 2 - Get Authorization cookie")
 
             auth_cookie_response = login_session.get(authorizationUri)
             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"]
@@ -212,43 +228,50 @@ class LGHorizonApi:
             payload = {
                 username_fieldname: self.username,
                 pasword_fieldname: self.password,
-                "rememberme": 'true'
+                "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"]]
-            
+            redirect_url = login_response.headers[
+                self._country_settings["oauth_redirect_header"]
+            ]
+
             if not self._identifier is 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"]]
+            success_url = redirect_response.headers[
+                self._country_settings["oauth_redirect_header"]
+            ]
             codeMatches = re.findall(r"code=(.*)&", success_url)
-            
+
             authorizationCode = codeMatches[0]
 
             new_payload = {
-                "authorizationGrant":{
-                    "authorizationCode":authorizationCode,
-                    "validityToken":authValidtyToken
+                "authorizationGrant": {
+                    "authorizationCode": authorizationCode,
+                    "validityToken": authValidtyToken,
                 }
             }
             headers = {
-                "content-type":"application/json",
+                "content-type": "application/json",
             }
-            post_result = login_session.post(auth_url, json.dumps(new_payload), headers = headers)
+            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.accessToken
         except Exception as ex:
-            pass 
+            pass
 
     def _obtain_mqtt_token(self):
         _logger.debug("Obtain mqtt token...")
-        mqtt_response = self._do_api_call(f"{self._country_settings['api_url']}/auth-service/v1/mqtt/token")
+        mqtt_response = self._do_api_call(
+            f"{self._config['authorizationService']['URL']}/v1/mqtt/token"
+        )
         self._auth.mqttToken = mqtt_response["token"]
         _logger.debug(f"MQTT token: {self._auth.mqttToken}")
 
@@ -257,19 +280,29 @@ class LGHorizonApi:
         self._session.headers["x-oesp-token"] = self._auth.accessToken
         self._session.headers["x-oesp-username"] = self._auth.username
 
-        mqtt_response = self._do_api_call(f"{self._country_settings['oesp_url']}/tokens/jwt")
+        mqtt_response = self._do_api_call(
+            f"{self._country_settings['oesp_url']}/tokens/jwt"
+        )
         self._auth.mqttToken = mqtt_response["token"]
         _logger.debug(f"MQTT token: {self._auth.mqttToken}")
 
-    @backoff.on_exception(backoff.expo, BaseException, jitter=None, max_time=600, logger=_logger)
+    @backoff.on_exception(
+        backoff.expo, BaseException, jitter=None, max_time=600, logger=_logger
+    )
     def connect(self) -> None:
+        self._config = self._get_config(self._country_code)
         _logger.debug("Connect to API")
         self._authorize()
         if self._country_code == "gb":
             self._obtain_mqtt_token_gb()
         else:
             self._obtain_mqtt_token()
-        self._mqttClient = LGHorizonMqttClient(self._auth, self._country_settings, self._on_mqtt_connected, self._on_mqtt_message)
+        self._mqttClient = LGHorizonMqttClient(
+            self._auth,
+            self._config["mqttBroker"]["URL"],
+            self._on_mqtt_connected,
+            self._on_mqtt_message,
+        )
         self._register_customer_and_boxes()
         self._mqttClient.connect()
 
@@ -282,11 +315,11 @@ class LGHorizonApi:
 
     def _on_mqtt_connected(self) -> None:
         _logger.debug("Connected to MQTT server. Registering all boxes...")
-        box:LGHorizonBox
+        box: LGHorizonBox
         for box in self.settop_boxes.values():
             box.register_mqtt()
 
-    def _on_mqtt_message(self, message:str, topic:str)-> None:
+    def _on_mqtt_message(self, message: str, topic: str) -> None:
         if "source" in message:
             deviceId = message["source"]
             if not deviceId in self.settop_boxes.keys():
@@ -296,13 +329,13 @@ class LGHorizonApi:
                     self.settop_boxes[deviceId].update_state(message)
                 if "status" in message:
                     self._handle_box_update(deviceId, message)
-            except Exception as ex:
+            except Exception:
                 _logger.exception("Could not handle status message")
                 _logger.warning(f"Full message: {str(message)}")
                 self.settop_boxes[deviceId].playing_info.reset()
                 self.settop_boxes[deviceId].playing_info.set_paused(False)
         elif "CPE.capacity" in message:
-            splitted_topic = topic.split('/')
+            splitted_topic = topic.split("/")
             if len(splitted_topic) != 4:
                 return
             deviceId = splitted_topic[1]
@@ -310,7 +343,7 @@ class LGHorizonApi:
                 return
             self.settop_boxes[deviceId].update_recording_capacity(message)
 
-    def _handle_box_update(self, deviceId:str, raw_message:Any) -> None:
+    def _handle_box_update(self, deviceId: str, raw_message: Any) -> None:
         statusPayload = raw_message["status"]
         if "uiStatus" not in statusPayload:
             return
@@ -321,40 +354,62 @@ class LGHorizonApi:
                 return
             source_type = playerState["sourceType"]
             state_source = playerState["source"]
-            self.settop_boxes[deviceId].playing_info.set_paused(playerState["speed"] == 0)
+            self.settop_boxes[deviceId].playing_info.set_paused(
+                playerState["speed"] == 0
+            )
             if source_type in (
                 BOX_PLAY_STATE_CHANNEL,
                 BOX_PLAY_STATE_BUFFER,
-                BOX_PLAY_STATE_REPLAY
-                ):
+                BOX_PLAY_STATE_REPLAY,
+            ):
                 eventId = state_source["eventId"]
-                raw_replay_event = self._do_api_call(f"{self._country_settings['api_url']}/eng/web/linear-service/v2/replayEvent/{eventId}?returnLinearContent=true&language={self._country_settings['language']}")
+                raw_replay_event = self._do_api_call(
+                    f"{self._config['linearService']['URL']}/v2/replayEvent/{eventId}?returnLinearContent=true&language={self._country_settings['language']}"
+                )
                 replayEvent = LGHorizonReplayEvent(raw_replay_event)
                 channel = self._channels[replayEvent.channelId]
-                self.settop_boxes[deviceId].update_with_replay_event(source_type, replayEvent, channel)
+                self.settop_boxes[deviceId].update_with_replay_event(
+                    source_type, replayEvent, channel
+                )
             elif source_type == BOX_PLAY_STATE_DVR:
                 recordingId = state_source["recordingId"]
                 session_start_time = state_source["sessionStartTime"]
                 session_end_time = state_source["sessionEndTime"]
                 last_speed_change_time = playerState["lastSpeedChangeTime"]
                 relative_position = playerState["relativePosition"]
-                raw_recording = self._do_api_call(f"{self._country_settings['api_url']}/eng/web/recording-service/customers/{self._auth.householdId}/details/single/{recordingId}?profileId=4504e28d-c1cb-4284-810b-f5eaab06f034&language={self._country_settings['language']}")
+                raw_recording = self._do_api_call(
+                    f"{self._config['recordingService']['URL']}/customers/{self._auth.householdId}/details/single/{recordingId}?profileId=4504e28d-c1cb-4284-810b-f5eaab06f034&language={self._country_settings['language']}"
+                )
                 recording = LGHorizonRecordingSingle(raw_recording)
                 channel = self._channels[recording.channelId]
-                self.settop_boxes[deviceId].update_with_recording(source_type, recording, channel,session_start_time, session_end_time, last_speed_change_time, relative_position)
+                self.settop_boxes[deviceId].update_with_recording(
+                    source_type,
+                    recording,
+                    channel,
+                    session_start_time,
+                    session_end_time,
+                    last_speed_change_time,
+                    relative_position,
+                )
             elif source_type == BOX_PLAY_STATE_VOD:
                 titleId = state_source["titleId"]
                 last_speed_change_time = playerState["lastSpeedChangeTime"]
                 relative_position = playerState["relativePosition"]
-                raw_vod = self._do_api_call(f"{self._country_settings['api_url']}/eng/web/vod-service/v2/detailscreen/{titleId}?language={self._country_settings['language']}&profileId=4504e28d-c1cb-4284-810b-f5eaab06f034&cityId={self._customer.cityId}")
+                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}"
+                )
                 vod = LGHorizonVod(raw_vod)
-                self.settop_boxes[deviceId].update_with_vod(source_type, vod, last_speed_change_time, relative_position)
+                self.settop_boxes[deviceId].update_with_vod(
+                    source_type, vod, last_speed_change_time, relative_position
+                )
         elif uiStatus == "apps":
             app = LGHorizonApp(statusPayload["appsState"])
-            self.settop_boxes[deviceId].update_with_app('app', app)     
+            self.settop_boxes[deviceId].update_with_app("app", app)
 
-    @backoff.on_exception(backoff.expo, LGHorizonApiConnectionError, max_tries=3, logger=_logger)
-    def _do_api_call(self, url:str, tries:int = 0) -> str:
+    @backoff.on_exception(
+        backoff.expo, LGHorizonApiConnectionError, max_tries=3, logger=_logger
+    )
+    def _do_api_call(self, url: str, tries: int = 0) -> str:
         _logger.info(f"Executing API call to {url}")
         try:
             api_response = self._session.get(url)
@@ -362,13 +417,17 @@ class LGHorizonApi:
             json_response = api_response.json()
         except request_exceptions.HTTPError as httpEx:
             self._authorize()
-            raise LGHorizonApiConnectionError(f"Unable to call {url}. Error:{str(httpEx)}")
+            raise LGHorizonApiConnectionError(
+                f"Unable to call {url}. Error:{str(httpEx)}"
+            )
         _logger.debug(f"Result API call: {json_response}")
         return json_response
-       
+
     def _register_customer_and_boxes(self):
         _logger.info("Get personalisation info...")
-        personalisation_result = self._do_api_call(f"{self._country_settings['api_url']}/eng/web/personalization-service/v1/customer/{self._auth.householdId}?with=profiles%2Cdevices")
+        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._get_channels()
@@ -380,79 +439,105 @@ class LGHorizonApi:
             platform_type = device["platformType"]
             if not platform_type in _supported_platforms:
                 continue
-            if "platform_types" in self._country_settings and platform_type in self._country_settings["platform_types"]:
+            if (
+                "platform_types" in self._country_settings
+                and platform_type in self._country_settings["platform_types"]
+            ):
                 platformType = self._country_settings["platform_types"][platform_type]
             else:
                 platformType = None
-            box = LGHorizonBox(device, platformType, self._mqttClient,self._auth, self._channels)
+            box = LGHorizonBox(
+                device, platformType, self._mqttClient, self._auth, self._channels
+            )
             self.settop_boxes[box.deviceId] = box
             _logger.info(f"Box {box.deviceId} registered...")
-            
+
     def _get_channels(self):
         self._update_entitlements()
         _logger.info("Retrieving channels...")
-        channels_result = self._do_api_call(f"{self._country_settings['api_url']}/eng/web/linear-service/v2/channels?cityId={self._customer.cityId}&language={self._country_settings['language']}&productClass=Orion-DASH")
+        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"
+        )
         for channel in channels_result:
             if "isRadio" in channel and channel["isRadio"]:
                 continue
-            common_entitlements = list(set(self._entitlements) & set(channel["linearProducts"]))
+            common_entitlements = list(
+                set(self._entitlements) & set(channel["linearProducts"])
+            )
             if len(common_entitlements) == 0:
                 continue
             channel_id = channel["id"]
             self._channels[channel_id] = LGHorizonChannel(channel)
         _logger.info(f"{len(self._channels)} retrieved.")
 
-    def _get_replay_event(self, listingId) -> Any: 
+    def _get_replay_event(self, listingId) -> Any:
         """Get listing."""
         _logger.info("Retrieving replay event details...")
-        response = self._do_api_call(f"{self._country_settings['api_url']}/eng/web/linear-service/v2/replayEvent/{listingId}?returnLinearContent=true&language={self._country_settings['language']}")
+        response = self._do_api_call(
+            f"{self._config['linearService']['URL']}/v2/replayEvent/{listingId}?returnLinearContent=true&language={self._country_settings['language']}"
+        )
         _logger.info("Replay event details retrieved")
         return response
 
-    def  get_recording_capacity(self) -> int:
+    def get_recording_capacity(self) -> int:
         """Returns remaining recording capacity"""
         try:
             _logger.info("Retrieving recordingcapacity...")
-            quota_content = self._do_api_call(f"{self._country_settings['api_url']}/eng/web/recording-service/customers/{self._auth.householdId}/quota")
+            quota_content = self._do_api_call(
+                f"{self._config['recordingService']['URL']}/customers/{self._auth.householdId}/quota"
+            )
             if not "quota" in quota_content and not "occupied" in quota_content:
                 _logger.error("Unable to fetch recording capacity...")
                 return None
-            capacity =  (quota_content["occupied"] / quota_content["quota"]) * 100
+            capacity = (quota_content["occupied"] / quota_content["quota"]) * 100
             self.recording_capacity = round(capacity)
             _logger.debug(f"Remaining recordingcapacity {self.recording_capacity}%")
             return self.recording_capacity
         except:
             _logger.error("Unable to fetch recording capacity...")
             return None
-    
+
     def get_recordings(self) -> List[LGHorizonBaseRecording]:
         _logger.info("Retrieving recordings...")
-        recording_content = self._do_api_call(f"{self._country_settings['api_url']}/eng/web/recording-service/customers/{self._auth.householdId}/recordings?sort=time&sortOrder=desc&language={self._country_settings['language']}")
-        recordings= []
-        for recording_data_item in recording_content['data']:
-            type = recording_data_item['type']
+        recording_content = self._do_api_call(
+            f"{self._config['recordingService']['URL']}/customers/{self._auth.householdId}/recordings?sort=time&sortOrder=desc&language={self._country_settings['language']}"
+        )
+        recordings = []
+        for recording_data_item in recording_content["data"]:
+            type = recording_data_item["type"]
             if type == RECORDING_TYPE_SINGLE:
                 recordings.append(LGHorizonRecordingSingle(recording_data_item))
             elif type in (RECORDING_TYPE_SEASON, RECORDING_TYPE_SHOW):
                 recordings.append(LGHorizonRecordingListSeasonShow(recording_data_item))
-        _logger.info(F"{len(recordings)} recordings retrieved...")
+        _logger.info(f"{len(recordings)} recordings retrieved...")
         return recordings
 
-    def get_recording_show(self, showId:str) -> list[LGHorizonRecordingSingle]:
+    def get_recording_show(self, showId: str) -> list[LGHorizonRecordingSingle]:
         _logger.info("Retrieving show recordings...")
-        show_recording_content = self._do_api_call(f"{self._country_settings['api_url']}/eng/web/recording-service/customers/{self._auth.householdId}/episodes/shows/{showId}?source=recording&language=nl&sort=time&sortOrder=asc")
+        show_recording_content = self._do_api_call(
+            f"{self._config['recordingService']['URL']}/customers/{self._auth.householdId}/episodes/shows/{showId}?source=recording&language=nl&sort=time&sortOrder=asc"
+        )
         recordings = []
         for item in show_recording_content["data"]:
-            if item['source'] == 'show':
+            if item["source"] == "show":
                 recordings.append(LGHorizonRecordingShow(item))
             else:
                 recordings.append(LGHorizonRecordingEpisode(item))
-        _logger.info(F"{len(recordings)} showrecordings retrieved...")
+        _logger.info(f"{len(recordings)} showrecordings retrieved...")
         return recordings
-    
+
     def _update_entitlements(self) -> None:
         _logger.info("Retrieving entitlements...")
-        entitlements_json = self._do_api_call(f"{self._country_settings['api_url']}/eng/web/purchase-service/v2/customers/{self._auth.householdId}/entitlements?enableDaypass=true")
+        entitlements_json = self._do_api_call(
+            f"{self._config['purchaseService']['URL']}/v2/customers/{self._auth.householdId}/entitlements?enableDaypass=true"
+        )
         self._entitlements.clear()
         for entitlement in entitlements_json["entitlements"]:
             self._entitlements.append(entitlement["id"])
+
+    def _get_config(self, country_code: str):
+        ctryCode = country_code[0:2]
+        config_url = f"{self._country_settings['api_url']}/{ctryCode}/en/config-service/conf/web/backoffice.json"
+        result = self._do_api_call(config_url)
+        _logger.debug(result)
+        return result

lghorizon/models.py

@@ -21,7 +21,7 @@ from .const import (
     MEDIA_KEY_FAST_FORWARD,
     MEDIA_KEY_RECORD,
     RECORDING_TYPE_SEASON,
-    RECORDING_TYPE_SHOW
+    RECORDING_TYPE_SHOW,
 )
 
 import json
@@ -30,6 +30,7 @@ import logging
 
 _logger = logging.getLogger(__name__)
 
+
 class LGHorizonAuth:
     householdId: str
     accessToken: str
@@ -42,22 +43,26 @@ class LGHorizonAuth:
     def __init__(self):
         """Initialize a session."""
         pass
-    
-    def fill(self, auth_json)-> None:
+
+    def fill(self, auth_json) -> None:
         self.householdId = auth_json["householdId"]
         self.accessToken = auth_json["accessToken"]
         self.refreshToken = auth_json["refreshToken"]
         self.username = auth_json["username"]
         try:
-            self.refreshTokenExpiry = datetime.fromtimestamp(auth_json["refreshTokenExpiry"])
+            self.refreshTokenExpiry = datetime.fromtimestamp(
+                auth_json["refreshTokenExpiry"]
+            )
         except ValueError:
             # VM uses milliseconds for the expiry time; if the year is too high to be valid, it assumes it's milliseconds and divides it
-            self.refreshTokenExpiry = datetime.fromtimestamp(auth_json["refreshTokenExpiry"]//1000)
+            self.refreshTokenExpiry = datetime.fromtimestamp(
+                auth_json["refreshTokenExpiry"] // 1000
+            )
 
-    
     def is_expired(self) -> bool:
         return self.refreshTokenExpiry
 
+
 class LGHorizonPlayingInfo:
     """Represent current state of a box."""
 
@@ -98,19 +103,19 @@ class LGHorizonPlayingInfo:
     def set_source_type(self, source_type):
         """Set source type."""
         self.source_type = source_type
-    
+
     def set_duration(self, duration: float):
         """Set duration."""
         self.duration = duration
-    
+
     def set_position(self, position: float):
         """Set position."""
         self.position = position
 
-    def set_last_position_update(self, last_position_update:datetime):
+    def set_last_position_update(self, last_position_update: datetime):
         """Set last position update."""
         self.last_position_update = last_position_update
-    
+
     def reset_progress(self):
         self.last_position_update = None
         self.duration = None
@@ -125,6 +130,7 @@ class LGHorizonPlayingInfo:
         self.channel_title = None
         self.reset_progress()
 
+
 class LGHorizonChannel:
     """Represent a channel."""
 
@@ -142,10 +148,10 @@ class LGHorizonChannel:
         if "logo" in channel_json and "focused" in channel_json["logo"]:
             self.logo_image = channel_json["logo"]["focused"]
         else:
-             self.logo_image = ""
+            self.logo_image = ""
         self.channel_number = channel_json["logicalChannelNumber"]
-    
-    def get_stream_image(self, channel_json)->str:
+
+    def get_stream_image(self, channel_json) -> str:
         image_stream = channel_json["imageStream"]
         if "full" in image_stream:
             return image_stream["full"]
@@ -155,16 +161,16 @@ class LGHorizonChannel:
             return channel_json["logo"]["focused"]
         return ""
 
-class LGHorizonReplayEvent:
 
+class LGHorizonReplayEvent:
     episodeNumber: int = None
     channelId: str = None
     eventId: str = None
-    seasonNumber:int = None
-    title:str = None
-    episodeName:str = None
+    seasonNumber: int = None
+    title: str = None
+    episodeName: str = None
 
-    def __init__(self, raw_json:str):
+    def __init__(self, raw_json: str):
         self.channelId = raw_json["channelId"]
         self.eventId = raw_json["eventId"]
         self.title = raw_json["title"]
@@ -175,22 +181,27 @@ class LGHorizonReplayEvent:
         if "seasonNumber" in raw_json:
             self.seasonNumber = raw_json["seasonNumber"]
 
+
 class LGHorizonBaseRecording:
-    
-    id:str = None
-    title:str = None
-    image:str = None
-    type:str = None
+    id: str = None
+    title: str = None
+    image: str = None
+    type: str = None
     channelId: str = None
-    def __init__(self, id:str, title:str, image:str, channelId: str, type:str) -> None:
+
+    def __init__(
+        self, id: str, title: str, image: str, channelId: str, type: str
+    ) -> None:
         self.id = id
         self.title = title
         self.image = image
         self.channelId = channelId
         self.type = type
 
+
 class LGHorizonRecordingSingle(LGHorizonBaseRecording):
     """Represents a single recording."""
+
     seasonNumber: int = None
     episodeNumber: int = None
 
@@ -202,23 +213,24 @@ class LGHorizonRecordingSingle(LGHorizonBaseRecording):
             recording_json["title"],
             recording_json["poster"]["url"],
             recording_json["channelId"],
-            recording_json["type"]  
-            )
+            recording_json["type"],
+        )
         if "seasonNumber" in recording_json:
             self.seasonNumber = recording_json["seasonNumber"]
         if "episodeNumber" in recording_json:
             self.episodeNumber = recording_json["episodeNumber"]
 
+
 class LGHorizonRecordingEpisode:
     """Represents a single recording."""
-    
+
     episodeId: str = None
-    episodeTitle:str = None
+    episodeTitle: str = None
     seasonNumber: int = None
     episodeNumber: int = None
-    showTitle:str = None
-    recordingState:str = None
-    image:str = None
+    showTitle: str = None
+    recordingState: str = None
+    image: str = None
 
     def __init__(self, recording_json):
         """Init the single recording."""
@@ -233,15 +245,16 @@ class LGHorizonRecordingEpisode:
         if "poster" in recording_json:
             self.image = recording_json["poster"]["url"]
 
+
 class LGHorizonRecordingShow:
     """Represents a single recording."""
-    
+
     episodeId: str = None
-    showTitle:str = None
+    showTitle: str = None
     seasonNumber: int = None
     episodeNumber: int = None
-    recordingState:str = None
-    image:str = None
+    recordingState: str = None
+    image: str = None
 
     def __init__(self, recording_json):
         """Init the single recording."""
@@ -257,55 +270,67 @@ class LGHorizonRecordingShow:
 
 
 class LGHorizonRecordingListSeasonShow(LGHorizonBaseRecording):
-    showId:str = None
+    showId: str = None
+
     def __init__(self, recording_season_json):
         """Init the single recording."""
-        
+
         LGHorizonBaseRecording.__init__(
             self,
             recording_season_json["id"],
             recording_season_json["title"],
             recording_season_json["poster"]["url"],
             recording_season_json["channelId"],
-            recording_season_json["type"]
-            )
+            recording_season_json["type"],
+        )
         if self.type == RECORDING_TYPE_SEASON:
             self.showId = recording_season_json["showId"]
         else:
             self.showId = recording_season_json["id"]
 
+
 class LGHorizonVod:
-    title:str = None
+    title: str = None
     image: str = None
     duration: float = None
+
     def __init__(self, vod_json) -> None:
-        self.title = vod_json['title']
-        self.duration = vod_json['duration']
+        self.title = vod_json["title"]
+        self.duration = vod_json["duration"]
+
 
 class LGHorizonApp:
-    title:str = None
-    image:str = None
-    def __init__(self, app_state_json:str)->None:
+    title: str = None
+    image: str = None
+
+    def __init__(self, app_state_json: str) -> None:
         self.title = app_state_json["appName"]
         self.image = app_state_json["logoPath"]
         if not self.image.startswith("http:"):
-                self.image = "https:" + self.image
+            self.image = "https:" + self.image
+
 
 class LGHorizonMqttClient:
-    _brokerUrl:str = None
-    _mqtt_client :mqtt.Client
+    _brokerUrl: str = None
+    _mqtt_client: mqtt.Client
     _auth: LGHorizonAuth
     clientId: str = None
     _on_connected_callback: Callable = None
-    _on_message_callback: Callable[[str, str],None] = None
+    _on_message_callback: Callable[[str, str], None] = None
 
     @property
     def is_connected(self):
         return self._mqtt_client.is_connected
 
-    def __init__(self, auth:LGHorizonAuth, country_settings:Dict[str,Any], on_connected_callback:Callable = None, on_message_callback:Callable[[str],None] = None):
+    def __init__(
+        self,
+        auth: LGHorizonAuth,
+        mqtt_broker_url: str,
+        on_connected_callback: Callable = None,
+        on_message_callback: Callable[[str], None] = None,
+    ):
         self._auth = auth
-        self._brokerUrl = country_settings["mqtt_url"]
+        self._brokerUrl = mqtt_broker_url.replace("wss://", "").replace(":443/mqtt", "")
         self.clientId = make_id()
         self._mqtt_client = mqtt.Client(self.clientId, transport="websockets")
         self._mqtt_client.username_pw_set(self._auth.householdId, self._auth.mqttToken)
@@ -314,7 +339,7 @@ class LGHorizonMqttClient:
         self._mqtt_client.on_connect = self._on_mqtt_connect
         self._on_connected_callback = on_connected_callback
         self._on_message_callback = on_message_callback
-    
+
     def _on_mqtt_connect(self, client, userdata, flags, resultCode):
         if resultCode == 0:
             self._mqtt_client.on_message = self._on_client_message
@@ -323,26 +348,38 @@ class LGHorizonMqttClient:
             self._mqtt_client.subscribe(self._auth.householdId + "/" + self.clientId)
             self._mqtt_client.subscribe(self._auth.householdId + "/+/status")
             self._mqtt_client.subscribe(self._auth.householdId + "/+/networkRecordings")
-            self._mqtt_client.subscribe(self._auth.householdId + "/+/networkRecordings/capacity")
+            self._mqtt_client.subscribe(
+                self._auth.householdId + "/+/networkRecordings/capacity"
+            )
             self._mqtt_client.subscribe(self._auth.householdId + "/+/localRecordings")
-            self._mqtt_client.subscribe(self._auth.householdId + "/+/localRecordings/capacity")
+            self._mqtt_client.subscribe(
+                self._auth.householdId + "/+/localRecordings/capacity"
+            )
             self._mqtt_client.subscribe(self._auth.householdId + "/watchlistService")
             self._mqtt_client.subscribe(self._auth.householdId + "/purchaseService")
-            self._mqtt_client.subscribe(self._auth.householdId + "/personalizationService")
+            self._mqtt_client.subscribe(
+                self._auth.householdId + "/personalizationService"
+            )
             self._mqtt_client.subscribe(self._auth.householdId + "/recordingStatus")
-            self._mqtt_client.subscribe(self._auth.householdId + "/recordingStatus/lastUserAction")
+            self._mqtt_client.subscribe(
+                self._auth.householdId + "/recordingStatus/lastUserAction"
+            )
             if self._on_connected_callback:
                 self._on_connected_callback()
         elif resultCode == 5:
-            self._mqtt_client.username_pw_set(self._auth.householdId, self._auth.mqttToken)
+            self._mqtt_client.username_pw_set(
+                self._auth.householdId, self._auth.mqttToken
+            )
             self.connect()
         else:
-            _logger.error(f"Cannot connect to MQTT server with resultCode: {resultCode}")
-    
+            _logger.error(
+                f"Cannot connect to MQTT server with resultCode: {resultCode}"
+            )
+
     def connect(self) -> None:
         self._mqtt_client.connect(self._brokerUrl, 443)
         self._mqtt_client.loop_start()
-    
+
     def _on_client_message(self, client, userdata, message):
         """Handle messages received by mqtt client."""
         _logger.debug(f"Received MQTT message. Topic: {message.topic}")
@@ -351,31 +388,38 @@ class LGHorizonMqttClient:
         if self._on_message_callback:
             self._on_message_callback(jsonPayload, message.topic)
 
-    def publish_message(self, topic:str, json_payload:str) -> None:
-        self._mqtt_client.publish(topic, json_payload, qos = 2)
-        
+    def publish_message(self, topic: str, json_payload: str) -> None:
+        self._mqtt_client.publish(topic, json_payload, qos=2)
+
     def disconnect(self) -> None:
         if self._mqtt_client.is_connected:
             self._mqtt_client.disconnect()
 
-class LGHorizonBox:
 
-    deviceId:str = None
-    hashedCPEId:str = None
-    deviceFriendlyName:str = None
+class LGHorizonBox:
+    deviceId: str = None
+    hashedCPEId: str = None
+    deviceFriendlyName: str = None
     state: str = None
     playing_info: LGHorizonPlayingInfo = None
-    manufacturer:str = None
+    manufacturer: str = None
     model: str = None
     recording_capacity: int = None
-    
-    _mqtt_client:LGHorizonMqttClient
+
+    _mqtt_client: LGHorizonMqttClient
     _change_callback: Callable = None
     _auth: LGHorizonAuth = None
-    _channels:Dict[str, LGHorizonChannel] = None
+    _channels: Dict[str, LGHorizonChannel] = None
     _message_stamp = None
-    
-    def __init__(self, box_json:str, platform_type:Dict[str,str], mqtt_client:LGHorizonMqttClient, auth:LGHorizonAuth, channels:Dict[str, LGHorizonChannel]):
+
+    def __init__(
+        self,
+        box_json: str,
+        platform_type: Dict[str, str],
+        mqtt_client: LGHorizonMqttClient,
+        auth: LGHorizonAuth,
+        channels: Dict[str, LGHorizonChannel],
+    ):
         self.deviceId = box_json["deviceId"]
         self.hashedCPEId = box_json["hashedCPEId"]
         self.deviceFriendlyName = box_json["settings"]["deviceFriendlyName"]
@@ -386,8 +430,8 @@ class LGHorizonBox:
         if platform_type:
             self.manufacturer = platform_type["manufacturer"]
             self.model = platform_type["model"]
-        
-    def register_mqtt(self)->None:
+
+    def register_mqtt(self) -> None:
         if not self._mqtt_client.is_connected:
             raise Exception("MQTT client not connected.")
         topic = f"{self._auth.householdId}/{self._mqtt_client.clientId}/status"
@@ -395,10 +439,10 @@ class LGHorizonBox:
             "source": self._mqtt_client.clientId,
             "state": ONLINE_RUNNING,
             "deviceType": "HGO",
-        }   
+        }
         self._mqtt_client.publish_message(topic, json.dumps(payload))
-    
-    def set_callback(self, change_callback:Callable) -> None:
+
+    def set_callback(self, change_callback: Callable) -> None:
         self._change_callback = change_callback
 
     def update_state(self, payload):
@@ -419,8 +463,10 @@ class LGHorizonBox:
         if not "CPE.capacity" in payload or not "used" in payload:
             return
         self.recording_capacity = payload["used"]
-    
-    def update_with_replay_event(self, source_type: str, event:LGHorizonReplayEvent, channel: LGHorizonChannel) -> None:
+
+    def update_with_replay_event(
+        self, source_type: str, event: LGHorizonReplayEvent, channel: LGHorizonChannel
+    ) -> None:
         self.playing_info.set_source_type(source_type)
         self.playing_info.set_channel(channel.id)
         self.playing_info.set_channel_title(channel.title)
@@ -432,7 +478,16 @@ class LGHorizonBox:
         self.playing_info.reset_progress()
         self._trigger_callback()
 
-    def update_with_recording(self, source_type: str, recording:LGHorizonRecordingSingle, channel: LGHorizonChannel, start:float, end: float, last_speed_change:float, relative_position: float) -> None:
+    def update_with_recording(
+        self,
+        source_type: str,
+        recording: LGHorizonRecordingSingle,
+        channel: LGHorizonChannel,
+        start: float,
+        end: float,
+        last_speed_change: float,
+        relative_position: float,
+    ) -> None:
         self.playing_info.set_source_type(source_type)
         self.playing_info.set_channel(channel.id)
         self.playing_info.set_channel_title(channel.title)
@@ -446,20 +501,26 @@ class LGHorizonBox:
         last_update_dt = datetime.fromtimestamp(last_speed_change / 1000.0)
         self.playing_info.set_last_position_update(last_update_dt)
         self._trigger_callback()
-    
-    def update_with_vod(self, source_type: str, vod:LGHorizonVod, last_speed_change:float, relative_position: float) -> None:
+
+    def update_with_vod(
+        self,
+        source_type: str,
+        vod: LGHorizonVod,
+        last_speed_change: float,
+        relative_position: float,
+    ) -> None:
         self.playing_info.set_source_type(source_type)
         self.playing_info.set_channel(None)
         self.playing_info.set_channel_title(None)
         self.playing_info.set_title(vod.title)
         self.playing_info.set_image(None)
         self.playing_info.set_duration(vod.duration)
-        self.playing_info.set_position(relative_position/ 1000.0)
+        self.playing_info.set_position(relative_position / 1000.0)
         last_update_dt = datetime.fromtimestamp(last_speed_change / 1000.0)
         self.playing_info.set_last_position_update(last_update_dt)
         self._trigger_callback()
-    
-    def update_with_app(self, source_type: str, app:LGHorizonApp) -> None:
+
+    def update_with_app(self, source_type: str, app: LGHorizonApp) -> None:
         self.playing_info.set_source_type(source_type)
         self.playing_info.set_channel(None)
         self.playing_info.set_channel_title(app.title)
@@ -467,7 +528,7 @@ class LGHorizonBox:
         self.playing_info.set_image(app.image)
         self.playing_info.reset_progress()
         self._trigger_callback()
-        
+
     def _trigger_callback(self):
         if self._change_callback:
             _logger.debug(f"Callback called from box {self.deviceId}")
@@ -475,7 +536,7 @@ class LGHorizonBox:
 
     def turn_on(self) -> None:
         """Turn the settop box on."""
-        
+
         if self.state == ONLINE_STANDBY:
             self.send_key_to_box(MEDIA_KEY_POWER)
 
@@ -489,7 +550,7 @@ class LGHorizonBox:
         """Pause the given settopbox."""
         if self.state == ONLINE_RUNNING and not self.playing_info.paused:
             self.send_key_to_box(MEDIA_KEY_PLAY_PAUSE)
-    
+
     def play(self) -> None:
         """Resume the settopbox."""
         if self.state == ONLINE_RUNNING and self.playing_info.paused:
@@ -534,7 +595,7 @@ class LGHorizonBox:
         """Return the availability of the settop box."""
         return self.state == ONLINE_RUNNING or self.state == ONLINE_STANDBY
 
-    def set_channel(self, source:str) -> None:
+    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 = (
@@ -548,7 +609,9 @@ class LGHorizonBox:
             + '"},"relativePosition":0,"speed":1}}'
         )
 
-        self._mqtt_client.publish_message(f"{self._auth.householdId}/{self.deviceId}", payload)
+        self._mqtt_client.publish_message(
+            f"{self._auth.householdId}/{self.deviceId}", payload
+        )
 
     def play_recording(self, recordingId):
         """Play recording."""
@@ -562,7 +625,9 @@ class LGHorizonBox:
             + recordingId
             + '"},"relativePosition":0}}'
         )
-        self._mqtt_client.publish_message(f"{self._auth.householdId}/{self.deviceId}", payload)
+        self._mqtt_client.publish_message(
+            f"{self._auth.householdId}/{self.deviceId}", payload
+        )
 
     def send_key_to_box(self, key: str) -> None:
         """Send emulated (remote) key press to settopbox."""
@@ -571,7 +636,9 @@ class LGHorizonBox:
             + key
             + '","eventType":"keyDownUp"}}'
         )
-        self._mqtt_client.publish_message(f"{self._auth.householdId}/{self.deviceId}", payload)
+        self._mqtt_client.publish_message(
+            f"{self._auth.householdId}/{self.deviceId}", payload
+        )
 
     def _set_unknown_channel_info(self) -> None:
         """Set unknown channel info."""
@@ -604,8 +671,8 @@ class LGHorizonBox:
 
 
 class LGHorizonCustomer:
-    customerId:str = None
-    hashedCustomerId:str = None 
+    customerId: str = None
+    hashedCustomerId: str = None
     countryId: str = None
     cityId: int = 0
     settop_boxes: Dict[str, LGHorizonBox] = None
@@ -617,5 +684,3 @@ class LGHorizonCustomer:
         self.cityId = json_payload["cityId"]
         if not "assignedDevices" in json_payload:
             return
-
-

{lghorizon-0.6.4.dist-info → lghorizon-0.6.6.dist-info}/METADATA

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

lghorizon-0.6.6.dist-info/RECORD

@@ -0,0 +1,12 @@
+lghorizon/__init__.py,sha256=_VjVE44ErvJJMnF5QgXdlw_nQzbHZUhGWw5hF40PolQ,426
+lghorizon/const.py,sha256=75Qqmf6XJcBYcOya18cdeRrWq2D_1Q45tz9MLlfQ8Ao,8407
+lghorizon/exceptions.py,sha256=spEjRvbNdce2fauQiOFromAbV1QcfA0uMUt0nRVnnkM,318
+lghorizon/helpers.py,sha256=ZWpi7B3hBvwGV02KWQQHVyj7FLLUDtIvKc-Iqsj5VHA,263
+lghorizon/lghorizon_api.py,sha256=1lNnN6FaPo4oV4x_SLXBA5kLnIILiNz8w3CiRko26Ao,23597
+lghorizon/models.py,sha256=SP12O8y3Bqp-rW47TZQxp25hyptPZAy41UzKnI9lw7E,23549
+lghorizon/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lghorizon-0.6.6.dist-info/LICENSE,sha256=6Dh2tur1gMX3r3rITjVwUONBEJxyyPZDY8p6DZXtimE,1059
+lghorizon-0.6.6.dist-info/METADATA,sha256=76jWhjcQk9sNb4nPcQu1PYAm4b2OiOkiCADqPAHZ6bo,1038
+lghorizon-0.6.6.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+lghorizon-0.6.6.dist-info/top_level.txt,sha256=usii76_AxGfPI6gjrrh-NyZxcQQuF1B8_Q9kd7sID8Q,10
+lghorizon-0.6.6.dist-info/RECORD,,

lghorizon-0.6.4.dist-info/RECORD

@@ -1,12 +0,0 @@
-lghorizon/__init__.py,sha256=_VjVE44ErvJJMnF5QgXdlw_nQzbHZUhGWw5hF40PolQ,426
-lghorizon/const.py,sha256=nHmQqbRnKegPXCI2E3gs5nKvbPR3Mp-ptIZYcSMjmoQ,9429
-lghorizon/exceptions.py,sha256=spEjRvbNdce2fauQiOFromAbV1QcfA0uMUt0nRVnnkM,318
-lghorizon/helpers.py,sha256=ZWpi7B3hBvwGV02KWQQHVyj7FLLUDtIvKc-Iqsj5VHA,263
-lghorizon/lghorizon_api.py,sha256=o1EB22gYtnFrt5hTw3V5zIqOq7dyUHkg1MWjZO92Fcc,22402
-lghorizon/models.py,sha256=dvlMrrUHoLiT6zAydYnPGNMapFiZaOgDBrZyocrd4II,23028
-lghorizon/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lghorizon-0.6.4.dist-info/LICENSE,sha256=6Dh2tur1gMX3r3rITjVwUONBEJxyyPZDY8p6DZXtimE,1059
-lghorizon-0.6.4.dist-info/METADATA,sha256=KFX8-j7IgKZTTQp4as72EjDNabnh3filMrJNi5CnEZE,1038
-lghorizon-0.6.4.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-lghorizon-0.6.4.dist-info/top_level.txt,sha256=usii76_AxGfPI6gjrrh-NyZxcQQuF1B8_Q9kd7sID8Q,10
-lghorizon-0.6.4.dist-info/RECORD,,