lghorizon 0.7.5b2__py3-none-any.whl → 0.8.0b2__py3-none-any.whl

lghorizon/__init__.py

@@ -20,4 +20,22 @@ from .const import (
     RECORDING_TYPE_SHOW,
     RECORDING_TYPE_SEASON,
     RECORDING_TYPE_SINGLE,
-)  # noqa
+)
+
+__all__ = [
+    "LGHorizonApi",
+    "LGHorizonBox",
+    "LGHorizonRecordingListSeasonShow",
+    "LGHorizonRecordingSingle",
+    "LGHorizonRecordingShow",
+    "LGHorizonRecordingEpisode",
+    "LGHorizonCustomer",
+    "LGHorizonApiUnauthorizedError",
+    "LGHorizonApiConnectionError",
+    "LGHorizonApiLockedError",
+    "ONLINE_RUNNING",
+    "ONLINE_STANDBY",
+    "RECORDING_TYPE_SHOW",
+    "RECORDING_TYPE_SEASON",
+    "RECORDING_TYPE_SINGLE",
+]  # noqa

lghorizon/helpers.py

@@ -1,8 +1,9 @@
 """Helper functions."""
+
 import random
 
 
-def make_id(stringLength=10):
+def make_id(string_length=10):
     """Create an id with given length."""
     letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
-    return "".join(random.choice(letters) for i in range(stringLength))
+    return "".join(random.choice(letters) for i in range(string_length))

lghorizon/lghorizon_api.py

@@ -1,17 +1,22 @@
 """Python client for LGHorizon."""
+# pylint: disable=broad-exception-caught
+# pylint: disable=line-too-long
 
 import logging
 import json
-import sys, traceback
+import re
+
+from typing import Any, Callable, Dict, List
+import backoff
+
+from requests import Session, exceptions as request_exceptions
+
 from .exceptions import (
     LGHorizonApiUnauthorizedError,
     LGHorizonApiConnectionError,
     LGHorizonApiLockedError,
 )
-import backoff
-from requests import Session, exceptions as request_exceptions
-from paho.mqtt.client import WebsocketConnectionError
-import re
+
 from .models import (
     LGHorizonAuth,
     LGHorizonBox,
@@ -39,7 +44,7 @@ from .const import (
     RECORDING_TYPE_SEASON,
     RECORDING_TYPE_SHOW,
 )
-from typing import Any, Callable, Dict, List
+
 
 _logger = logging.getLogger(__name__)
 _supported_platforms = ["EOS", "EOS2", "HORIZON", "APOLLO"]
@@ -52,7 +57,7 @@ class LGHorizonApi:
     _session: Session = None
     settop_boxes: Dict[str, LGHorizonBox] = None
     customer: LGHorizonCustomer = None
-    _mqttClient: LGHorizonMqttClient = None
+    _mqtt_client: LGHorizonMqttClient = None
     _channels: Dict[str, LGHorizonChannel] = None
     _country_settings = None
     _country_code: str = None
@@ -89,11 +94,9 @@ class LGHorizonApi:
     def _authorize(self) -> None:
         ctry_code = self._country_code[0:2]
         if ctry_code == "be":
-            self.authorize_telenet()
+            self._authorize_telenet()
         elif ctry_code in ("gb", "ch"):
-            self.authorize_with_refreshtoken()
-            # elif ctry_code == "ch":
-            #     self.authorize_sunrise()
+            self._authorize_with_refresh_token()
         else:
             self._authorize_default()
 
@@ -124,7 +127,8 @@ class LGHorizonApi:
         self._auth.fill(auth_response.json())
         _logger.debug("Authorization succeeded")
 
-    def authorize_with_refreshtoken(self) -> None:
+    def _authorize_with_refresh_token(self) -> None:
+        """Handle authorizzationg using request token."""
         _logger.debug("Authorizing via refresh")
         refresh_url = (
             f"{self._country_settings['api_url']}/auth-service/v1/authorization/refresh"
@@ -153,8 +157,8 @@ class LGHorizonApi:
                 raise LGHorizonApiConnectionError("Unknown connection error")
 
         self._auth.fill(auth_response.json())
-        self.refresh_token = self._auth.refreshToken
-        self._session.cookies["ACCESSTOKEN"] = self._auth.accessToken
+        self.refresh_token = self._auth.refresh_token
+        self._session.cookies["ACCESSTOKEN"] = self._auth.access_token
 
         if self._refresh_callback:
             self._refresh_callback()
@@ -162,9 +166,11 @@ class LGHorizonApi:
         _logger.debug("Authorization succeeded")
 
     def set_callback(self, refresh_callback: Callable) -> None:
+        """Set the refresh callback."""
         self._refresh_callback = refresh_callback
 
-    def authorize_telenet(self):
+    def _authorize_telenet(self):
+        """Authorize telenet users."""
         try:
             login_session = Session()
             # Step 1 - Get Authorization data
@@ -176,13 +182,13 @@ class LGHorizonApi:
             if not auth_response.ok:
                 raise LGHorizonApiConnectionError("Can't connect to authorization URL")
             auth_response_json = auth_response.json()
-            authorizationUri = auth_response_json["authorizationUri"]
-            authValidtyToken = auth_response_json["validityToken"]
+            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(authorizationUri)
+            auth_cookie_response = login_session.get(authorization_uri)
             if not auth_cookie_response.ok:
                 raise LGHorizonApiConnectionError("Can't connect to authorization URL")
 
@@ -206,20 +212,20 @@ class LGHorizonApi:
                 self._country_settings["oauth_redirect_header"]
             ]
 
-            if not self._identifier is None:
+            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"]
             ]
-            codeMatches = re.findall(r"code=(.*)&", success_url)
+            code_matches = re.findall(r"code=(.*)&", success_url)
 
-            authorizationCode = codeMatches[0]
+            authorization_code = code_matches[0]
 
             new_payload = {
                 "authorizationGrant": {
-                    "authorizationCode": authorizationCode,
-                    "validityToken": authValidtyToken,
+                    "authorizationCode": authorization_code,
+                    "validityToken": authorization_validity_token,
                 }
             }
             headers = {
@@ -229,8 +235,8 @@ class LGHorizonApi:
                 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:
+            self._session.cookies["ACCESSTOKEN"] = self._auth.access_token
+        except Exception:
             pass
 
     def _obtain_mqtt_token(self):
@@ -238,7 +244,7 @@ class LGHorizonApi:
         mqtt_auth_url = self._config["authorizationService"]["URL"]
         mqtt_response = self._do_api_call(f"{mqtt_auth_url}/v1/mqtt/token")
         self._auth.mqttToken = mqtt_response["token"]
-        _logger.debug(f"MQTT token: {self._auth.mqttToken}")
+        _logger.debug("MQTT token: %s", self._auth.mqttToken)
 
     @backoff.on_exception(
         backoff.expo,
@@ -251,11 +257,12 @@ class LGHorizonApi:
         ),
     )
     def connect(self) -> None:
+        """Start connection process."""
         self._config = self._get_config(self._country_code)
         _logger.debug("Connect to API")
         self._authorize()
         self._obtain_mqtt_token()
-        self._mqttClient = LGHorizonMqttClient(
+        self._mqtt_client = LGHorizonMqttClient(
             self._auth,
             self._config["mqttBroker"]["URL"],
             self._on_mqtt_connected,
@@ -263,14 +270,14 @@ class LGHorizonApi:
         )
 
         self._register_customer_and_boxes()
-        self._mqttClient.connect()
+        self._mqtt_client.connect()
 
     def disconnect(self):
         """Disconnect."""
         _logger.debug("Disconnect from API")
-        if not self._mqttClient or not self._mqttClient.is_connected:
+        if not self._mqtt_client or not self._mqtt_client.is_connected:
             return
-        self._mqttClient.disconnect()
+        self._mqtt_client.disconnect()
 
     def _on_mqtt_connected(self) -> None:
         _logger.debug("Connected to MQTT server. Registering all boxes...")
@@ -281,47 +288,46 @@ class LGHorizonApi:
     def _on_mqtt_message(self, message: str, topic: str) -> None:
         if "action" in message and message["action"] == "OPS.getProfilesUpdate":
             self._update_customer()
-            box: LGHorizonBox
         elif "source" in message:
-            deviceId = message["source"]
-            if not isinstance(deviceId, str):
+            device_id = message["source"]
+            if not isinstance(device_id, str):
                 _logger.debug("ignoring message - not a string")
                 return
-            if not deviceId in self.settop_boxes.keys():
+            if device_id not in self.settop_boxes:
                 return
             try:
                 if "deviceType" in message and message["deviceType"] == "STB":
-                    self.settop_boxes[deviceId].update_state(message)
+                    self.settop_boxes[device_id].update_state(message)
                 if "status" in message:
-                    self._handle_box_update(deviceId, message)
+                    self._handle_box_update(device_id, message)
 
             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)
+                _logger.warning("Full message: %s", str(message))
+                self.settop_boxes[device_id].playing_info.reset()
+                self.settop_boxes[device_id].playing_info.set_paused(False)
         elif "CPE.capacity" in message:
             splitted_topic = topic.split("/")
             if len(splitted_topic) != 4:
                 return
-            deviceId = splitted_topic[1]
-            if not deviceId in self.settop_boxes.keys():
+            device_id = splitted_topic[1]
+            if device_id not in self.settop_boxes:
                 return
-            self.settop_boxes[deviceId].update_recording_capacity(message)
+            self.settop_boxes[device_id].update_recording_capacity(message)
 
-    def _handle_box_update(self, deviceId: str, raw_message: Any) -> None:
-        statusPayload = raw_message["status"]
-        if "uiStatus" not in statusPayload:
+    def _handle_box_update(self, device_id: str, raw_message: Any) -> None:
+        status_payload = raw_message["status"]
+        if "uiStatus" not in status_payload:
             return
-        uiStatus = statusPayload["uiStatus"]
-        if uiStatus == "mainUI":
-            playerState = statusPayload["playerState"]
-            if "sourceType" not in playerState or "source" not in playerState:
+        ui_status = status_payload["uiStatus"]
+        if ui_status == "mainUI":
+            player_state = status_payload["playerState"]
+            if "sourceType" not in player_state or "source" not in player_state:
                 return
-            source_type = playerState["sourceType"]
-            state_source = playerState["source"]
-            self.settop_boxes[deviceId].playing_info.set_paused(
-                playerState["speed"] == 0
+            source_type = player_state["sourceType"]
+            state_source = player_state["source"]
+            self.settop_boxes[device_id].playing_info.set_paused(
+                player_state["speed"] == 0
             )
             if (
                 source_type
@@ -332,27 +338,27 @@ class LGHorizonApi:
                 )
                 and "eventId" in state_source
             ):
-                eventId = state_source["eventId"]
+                event_id = state_source["eventId"]
                 raw_replay_event = self._do_api_call(
-                    f"{self._config['linearService']['URL']}/v2/replayEvent/{eventId}?returnLinearContent=true&language={self._country_settings['language']}"
+                    f"{self._config['linearService']['URL']}/v2/replayEvent/{event_id}?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
+                replay_event = LGHorizonReplayEvent(raw_replay_event)
+                channel = self._channels[replay_event.channel_id]
+                self.settop_boxes[device_id].update_with_replay_event(
+                    source_type, replay_event, channel
                 )
             elif source_type == BOX_PLAY_STATE_DVR:
-                recordingId = state_source["recordingId"]
+                recording_id = 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"]
+                last_speed_change_time = player_state["lastSpeedChangeTime"]
+                relative_position = player_state["relativePosition"]
                 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']}"
+                    f"{self._config['recordingService']['URL']}/customers/{self._auth.household_id}/details/single/{recording_id}?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(
+                channel = self._channels[recording.channel_id]
+                self.settop_boxes[device_id].update_with_recording(
                     source_type,
                     recording,
                     channel,
@@ -362,35 +368,35 @@ class LGHorizonApi:
                     relative_position,
                 )
             elif source_type == BOX_PLAY_STATE_VOD:
-                titleId = state_source["titleId"]
-                last_speed_change_time = playerState["lastSpeedChangeTime"]
-                relative_position = playerState["relativePosition"]
+                title_id = state_source["titleId"]
+                last_speed_change_time = player_state["lastSpeedChangeTime"]
+                relative_position = player_state["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/{title_id}?language={self._country_settings['language']}&profileId=4504e28d-c1cb-4284-810b-f5eaab06f034&cityId={self.customer.city_id}"
                 )
                 vod = LGHorizonVod(raw_vod)
-                self.settop_boxes[deviceId].update_with_vod(
+                self.settop_boxes[device_id].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)
+        elif ui_status == "apps":
+            app = LGHorizonApp(status_payload["appsState"])
+            self.settop_boxes[device_id].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:
-        _logger.info(f"Executing API call to {url}")
+    def _do_api_call(self, url: str) -> str:
+        _logger.info("Executing API call to %s", url)
         try:
             api_response = self._session.get(url)
             api_response.raise_for_status()
             json_response = api_response.json()
-        except request_exceptions.HTTPError as httpEx:
+        except request_exceptions.HTTPError as http_ex:
             self._authorize()
             raise LGHorizonApiConnectionError(
-                f"Unable to call {url}. Error:{str(httpEx)}"
-            )
-        _logger.debug(f"Result API call: {json_response}")
+                f"Unable to call {url}. Error:{str(http_ex)}"
+            ) from http_ex
+        _logger.debug("Result API call: %s", json_response)
         return json_response
 
     def _register_customer_and_boxes(self):
@@ -412,15 +418,15 @@ class LGHorizonApi:
             else:
                 platform_type = None
             box = LGHorizonBox(
-                device, platform_type, self._mqttClient, self._auth, self._channels
+                device, platform_type, self._mqtt_client, self._auth, self._channels
             )
-            self.settop_boxes[box.deviceId] = box
-            _logger.info("Box %s registered...", box.deviceId)
+            self.settop_boxes[box.device_id] = box
+            _logger.info("Box %s registered...", box.device_id)
 
     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"
+            f"{self._config['personalizationService']['URL']}/v1/customer/{self._auth.household_id}?with=profiles%2Cdevices"
         )
         _logger.debug("Personalisation result: %s ", personalisation_result)
         self.customer = LGHorizonCustomer(personalisation_result)
@@ -429,7 +435,7 @@ class LGHorizonApi:
         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.city_id}&language={self._country_settings['language']}&productClass=Orion-DASH"
         )
         for channel in channels_result:
             if "isRadio" in channel and channel["isRadio"]:
@@ -441,9 +447,10 @@ class LGHorizonApi:
                 continue
             channel_id = channel["id"]
             self._channels[channel_id] = LGHorizonChannel(channel)
-        _logger.info(f"{len(self._channels)} retrieved.")
+        _logger.info("%s retrieved.", len(self._channels))
 
     def get_display_channels(self):
+        """Returns channels to display baed on profile."""
         all_channels = self._channels.values()
         if not self._profile_id or self._profile_id not in self.customer.profiles:
             return all_channels
@@ -455,11 +462,11 @@ class LGHorizonApi:
             channel for channel in all_channels if channel.id in profile_channel_ids
         ]
 
-    def _get_replay_event(self, listingId) -> Any:
+    def _get_replay_event(self, listing_id) -> Any:
         """Get listing."""
         _logger.info("Retrieving replay event details...")
         response = self._do_api_call(
-            f"{self._config['linearService']['URL']}/v2/replayEvent/{listingId}?returnLinearContent=true&language={self._country_settings['language']}"
+            f"{self._config['linearService']['URL']}/v2/replayEvent/{listing_id}?returnLinearContent=true&language={self._country_settings['language']}"
         )
         _logger.info("Replay event details retrieved")
         return response
@@ -473,38 +480,40 @@ class LGHorizonApi:
         try:
             _logger.info("Retrieving recordingcapacity...")
             quota_content = self._do_api_call(
-                f"{self._config['recordingService']['URL']}/customers/{self._auth.householdId}/quota"
+                f"{self._config['recordingService']['URL']}/customers/{self._auth.household_id}/quota"
             )
-            if not "quota" in quota_content and not "occupied" in quota_content:
+            if "quota" not in quota_content and "occupied" not in quota_content:
                 _logger.error("Unable to fetch recording capacity...")
                 return None
             capacity = (quota_content["occupied"] / quota_content["quota"]) * 100
             self.recording_capacity = round(capacity)
-            _logger.debug(f"Remaining recordingcapacity {self.recording_capacity}%")
+            _logger.debug("Remaining recordingcapacity %s %%", self.recording_capacity)
             return self.recording_capacity
-        except:
+        except Exception:
             _logger.error("Unable to fetch recording capacity...")
             return None
 
     def get_recordings(self) -> List[LGHorizonBaseRecording]:
+        """Returns recordings."""
         _logger.info("Retrieving recordings...")
         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']}"
+            f"{self._config['recordingService']['URL']}/customers/{self._auth.household_id}/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:
+            recording_type = recording_data_item["type"]
+            if recording_type == RECORDING_TYPE_SINGLE:
                 recordings.append(LGHorizonRecordingSingle(recording_data_item))
-            elif type in (RECORDING_TYPE_SEASON, RECORDING_TYPE_SHOW):
+            elif recording_type in (RECORDING_TYPE_SEASON, RECORDING_TYPE_SHOW):
                 recordings.append(LGHorizonRecordingListSeasonShow(recording_data_item))
-        _logger.info(f"{len(recordings)} recordings retrieved...")
+        _logger.info("%s recordings retrieved...", len(recordings))
         return recordings
 
-    def get_recording_show(self, showId: str) -> list[LGHorizonRecordingSingle]:
+    def get_recording_show(self, show_id: str) -> list[LGHorizonRecordingSingle]:
+        """Returns show recording"""
         _logger.info("Retrieving show recordings...")
         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"
+            f"{self._config['recordingService']['URL']}/customers/{self._auth.household_id}/episodes/shows/{show_id}?source=recording&language=nl&sort=time&sortOrder=asc"
         )
         recordings = []
         for item in show_recording_content["data"]:
@@ -512,21 +521,21 @@ class LGHorizonApi:
                 recordings.append(LGHorizonRecordingShow(item))
             else:
                 recordings.append(LGHorizonRecordingEpisode(item))
-        _logger.info(f"{len(recordings)} showrecordings retrieved...")
+        _logger.info("%s showrecordings retrieved...", len(recordings))
         return recordings
 
     def _update_entitlements(self) -> None:
         _logger.info("Retrieving entitlements...")
         entitlements_json = self._do_api_call(
-            f"{self._config['purchaseService']['URL']}/v2/customers/{self._auth.householdId}/entitlements?enableDaypass=true"
+            f"{self._config['purchaseService']['URL']}/v2/customers/{self._auth.household_id}/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"
+        base_country_code = country_code[0:2]
+        config_url = f"{self._country_settings['api_url']}/{base_country_code}/en/config-service/conf/web/backoffice.json"
         result = self._do_api_call(config_url)
         _logger.debug(result)
         return result

lghorizon/models.py

@@ -1,14 +1,15 @@
+"""Models for LGHorizon API."""
+
+# pylint: disable=broad-exception-caught
+# pylint: disable=broad-exception-raised
 from datetime import datetime
-from typing import Any, Callable, Dict, List
+from typing import Callable, Dict
+import json
+import logging
 import paho.mqtt.client as mqtt
-import requests
+
 from .const import (
-    BOX_PLAY_STATE_BUFFER,
     BOX_PLAY_STATE_CHANNEL,
-    BOX_PLAY_STATE_DVR,
-    BOX_PLAY_STATE_REPLAY,
-    BOX_PLAY_STATE_APP,
-    BOX_PLAY_STATE_VOD,
     ONLINE_STANDBY,
     ONLINE_RUNNING,
     MEDIA_KEY_POWER,
@@ -21,46 +22,47 @@ from .const import (
     MEDIA_KEY_FAST_FORWARD,
     MEDIA_KEY_RECORD,
     RECORDING_TYPE_SEASON,
-    RECORDING_TYPE_SHOW,
 )
 
-import json
 from .helpers import make_id
-import logging
 
 _logger = logging.getLogger(__name__)
 
 
 class LGHorizonAuth:
-    householdId: str
-    accessToken: str
-    refreshToken: str
-    refreshTokenExpiry: datetime
+    """Class to hold LGHorizon authentication."""
+
+    household_id: str
+    access_token: str
+    refresh_token: str
+    refresh_token_expiry: datetime
     username: str
-    mqttToken: str = None
-    accessToken: str = None
+    mqtt_token: str = None
+    access_token: str = None
 
     def __init__(self):
         """Initialize a session."""
-        pass
 
     def fill(self, auth_json) -> None:
-        self.householdId = auth_json["householdId"]
-        self.accessToken = auth_json["accessToken"]
-        self.refreshToken = auth_json["refreshToken"]
+        """Fill the object."""
+        self.household_id = auth_json["householdId"]
+        self.access_token = auth_json["accessToken"]
+        self.refresh_token = auth_json["refreshToken"]
         self.username = auth_json["username"]
         try:
-            self.refreshTokenExpiry = datetime.fromtimestamp(
+            self.refresh_token_expiry = 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(
+            # 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.refresh_token_expiry = datetime.fromtimestamp(
                 auth_json["refreshTokenExpiry"] // 1000
             )
 
     def is_expired(self) -> bool:
-        return self.refreshTokenExpiry
+        """Check if refresh token is expired."""
+        return self.refresh_token_expiry
 
 
 class LGHorizonPlayingInfo:
@@ -78,7 +80,6 @@ class LGHorizonPlayingInfo:
 
     def __init__(self):
         """Initialize the playing info."""
-        pass
 
     def set_paused(self, paused: bool):
         """Set pause state."""
@@ -117,11 +118,13 @@ class LGHorizonPlayingInfo:
         self.last_position_update = last_position_update
 
     def reset_progress(self):
+        """Reset the progress."""
         self.last_position_update = None
         self.duration = None
         self.position = None
 
     def reset(self):
+        """Reset the channel"""
         self.channel_id = None
         self.title = None
         self.image = None
@@ -152,6 +155,7 @@ class LGHorizonChannel:
         self.channel_number = channel_json["logicalChannelNumber"]
 
     def get_stream_image(self, channel_json) -> str:
+        """Returns the stream image."""
         image_stream = channel_json["imageStream"]
         if "full" in image_stream:
             return image_stream["full"]
@@ -163,47 +167,56 @@ class LGHorizonChannel:
 
 
 class LGHorizonReplayEvent:
-    episodeNumber: int = None
-    channelId: str = None
-    eventId: str = None
-    seasonNumber: int = None
+    """LGhorizon replay event."""
+
+    episode_number: int = None
+    channel_id: str = None
+    event_id: str = None
+    season_number: int = None
     title: str = None
-    episodeName: str = None
+    episode_name: str = None
 
     def __init__(self, raw_json: str):
-        self.channelId = raw_json["channelId"]
-        self.eventId = raw_json["eventId"]
+        self.channel_id = raw_json["channelId"]
+        self.event_id = raw_json["eventId"]
         self.title = raw_json["title"]
         if "episodeName" in raw_json:
-            self.episodeName = raw_json["episodeName"]
+            self.episode_name = raw_json["episodeName"]
         if "episodeNumber" in raw_json:
-            self.episodeNumber = raw_json["episodeNumber"]
+            self.episode_number = raw_json["episodeNumber"]
         if "seasonNumber" in raw_json:
-            self.seasonNumber = raw_json["seasonNumber"]
+            self.season_number = raw_json["seasonNumber"]
 
 
 class LGHorizonBaseRecording:
-    id: str = None
+    """LgHorizon base recording."""
+
+    recording_id: str = None
     title: str = None
     image: str = None
-    type: str = None
-    channelId: str = None
+    recording_type: str = None
+    channel_id: str = None
 
     def __init__(
-        self, id: str, title: str, image: str, channelId: str, type: str
+        self,
+        recording_id: str,
+        title: str,
+        image: str,
+        channel_id: str,
+        recording_type: str,
     ) -> None:
-        self.id = id
+        self.recording_id = recording_id
         self.title = title
         self.image = image
-        self.channelId = channelId
-        self.type = type
+        self.channel_id = channel_id
+        self.recording_type = recording_type
 
 
 class LGHorizonRecordingSingle(LGHorizonBaseRecording):
     """Represents a single recording."""
 
-    seasonNumber: int = None
-    episodeNumber: int = None
+    season_number: int = None
+    episode_number: int = None
 
     def __init__(self, recording_json):
         """Init the single recording."""
@@ -219,32 +232,32 @@ class LGHorizonRecordingSingle(LGHorizonBaseRecording):
             recording_json["type"],
         )
         if "seasonNumber" in recording_json:
-            self.seasonNumber = recording_json["seasonNumber"]
+            self.season_number = recording_json["seasonNumber"]
         if "episodeNumber" in recording_json:
-            self.episodeNumber = recording_json["episodeNumber"]
+            self.episode_number = recording_json["episodeNumber"]
 
 
 class LGHorizonRecordingEpisode:
     """Represents a single recording."""
 
-    episodeId: str = None
-    episodeTitle: str = None
-    seasonNumber: int = None
-    episodeNumber: int = None
-    showTitle: str = None
-    recordingState: str = None
+    episode_id: str = None
+    episode_title: str = None
+    season_number: int = None
+    episode_number: int = None
+    show_title: str = None
+    recording_state: str = None
     image: str = None
 
     def __init__(self, recording_json):
         """Init the single recording."""
-        self.episodeId = recording_json["episodeId"]
-        self.episodeTitle = recording_json["episodeTitle"]
-        self.showTitle = recording_json["showTitle"]
-        self.recordingState = recording_json["recordingState"]
+        self.episode_id = recording_json["episodeId"]
+        self.episode_title = recording_json["episodeTitle"]
+        self.show_title = recording_json["showTitle"]
+        self.recording_state = recording_json["recordingState"]
         if "seasonNumber" in recording_json:
-            self.seasonNumber = recording_json["seasonNumber"]
+            self.season_number = recording_json["seasonNumber"]
         if "episodeNumber" in recording_json:
-            self.episodeNumber = recording_json["episodeNumber"]
+            self.episode_number = recording_json["episodeNumber"]
         if "poster" in recording_json and "url" in recording_json["poster"]:
             self.image = recording_json["poster"]["url"]
 
@@ -252,28 +265,30 @@ class LGHorizonRecordingEpisode:
 class LGHorizonRecordingShow:
     """Represents a single recording."""
 
-    episodeId: str = None
-    showTitle: str = None
-    seasonNumber: int = None
-    episodeNumber: int = None
-    recordingState: str = None
+    episode_id: str = None
+    show_title: str = None
+    season_number: int = None
+    episode_number: int = None
+    recording_state: str = None
     image: str = None
 
     def __init__(self, recording_json):
         """Init the single recording."""
-        self.episodeId = recording_json["episodeId"]
-        self.showTitle = recording_json["showTitle"]
-        self.recordingState = recording_json["recordingState"]
+        self.episode_id = recording_json["episodeId"]
+        self.show_title = recording_json["showTitle"]
+        self.recording_state = recording_json["recordingState"]
         if "seasonNumber" in recording_json:
-            self.seasonNumber = recording_json["seasonNumber"]
+            self.season_number = recording_json["seasonNumber"]
         if "episodeNumber" in recording_json:
-            self.episodeNumber = recording_json["episodeNumber"]
+            self.episode_number = recording_json["episodeNumber"]
         if "poster" in recording_json and "url" in recording_json["poster"]:
             self.image = recording_json["poster"]["url"]
 
 
 class LGHorizonRecordingListSeasonShow(LGHorizonBaseRecording):
-    showId: str = None
+    """LGHorizon Season show list."""
+
+    show_id: str = None
 
     def __init__(self, recording_season_json):
         """Init the single recording."""
@@ -286,13 +301,15 @@ class LGHorizonRecordingListSeasonShow(LGHorizonBaseRecording):
             recording_season_json["channelId"],
             recording_season_json["type"],
         )
-        if self.type == RECORDING_TYPE_SEASON:
-            self.showId = recording_season_json["showId"]
+        if self.recording_type == RECORDING_TYPE_SEASON:
+            self.show_id = recording_season_json["showId"]
         else:
-            self.showId = recording_season_json["id"]
+            self.show_id = recording_season_json["id"]
 
 
 class LGHorizonVod:
+    """LGHorizon video on demand."""
+
     title: str = None
     image: str = None
     duration: float = None
@@ -303,6 +320,8 @@ class LGHorizonVod:
 
 
 class LGHorizonApp:
+    """LGHorizon App."""
+
     title: str = None
     image: str = None
 
@@ -314,15 +333,18 @@ class LGHorizonApp:
 
 
 class LGHorizonMqttClient:
-    _brokerUrl: str = None
+    """LGHorizon MQTT client."""
+
+    _broker_url: str = None
     _mqtt_client: mqtt.Client
     _auth: LGHorizonAuth
-    clientId: str = None
+    client_id: str = None
     _on_connected_callback: Callable = None
     _on_message_callback: Callable[[str, str], None] = None
 
     @property
     def is_connected(self):
+        """Is client connected."""
         return self._mqtt_client.is_connected
 
     def __init__(
@@ -333,80 +355,95 @@ class LGHorizonMqttClient:
         on_message_callback: Callable[[str], None] = None,
     ):
         self._auth = auth
-        self._brokerUrl = mqtt_broker_url.replace("wss://", "").replace(":443/mqtt", "")
-        self.clientId = make_id()
-        self._mqtt_client = mqtt.Client(self.clientId, transport="websockets")
+        self._broker_url = mqtt_broker_url.replace("wss://", "").replace(
+            ":443/mqtt", ""
+        )
+        self.client_id = make_id()
+        self._mqtt_client = mqtt.Client(
+            mqtt.CallbackAPIVersion.VERSION1,
+            client_id=self.client_id,
+            transport="websockets",
+        )
 
         self._mqtt_client.ws_set_options(
             headers={"Sec-WebSocket-Protocol": "mqtt, mqttv3.1, mqttv3.11"}
         )
-        self._mqtt_client.username_pw_set(self._auth.householdId, self._auth.mqttToken)
+        self._mqtt_client.username_pw_set(
+            self._auth.household_id, self._auth.mqtt_token
+        )
         self._mqtt_client.tls_set()
         self._mqtt_client.enable_logger(_logger)
         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:
+    def _on_mqtt_connect(self, client, userdata, flags, result_code):  # pylint: disable=unused-argument
+        if result_code == 0:
             self._mqtt_client.on_message = self._on_client_message
-            self._mqtt_client.subscribe(self._auth.householdId)
-            self._mqtt_client.subscribe(self._auth.householdId + "/#")
-            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.household_id)
+            self._mqtt_client.subscribe(self._auth.household_id + "/#")
+            self._mqtt_client.subscribe(self._auth.household_id + "/" + self.client_id)
+            self._mqtt_client.subscribe(self._auth.household_id + "/+/status")
+            self._mqtt_client.subscribe(
+                self._auth.household_id + "/+/networkRecordings"
+            )
             self._mqtt_client.subscribe(
-                self._auth.householdId + "/+/networkRecordings/capacity"
+                self._auth.household_id + "/+/networkRecordings/capacity"
             )
-            self._mqtt_client.subscribe(self._auth.householdId + "/+/localRecordings")
+            self._mqtt_client.subscribe(self._auth.household_id + "/+/localRecordings")
             self._mqtt_client.subscribe(
-                self._auth.householdId + "/+/localRecordings/capacity"
+                self._auth.household_id + "/+/localRecordings/capacity"
             )
-            self._mqtt_client.subscribe(self._auth.householdId + "/watchlistService")
-            self._mqtt_client.subscribe(self._auth.householdId + "/purchaseService")
+            self._mqtt_client.subscribe(self._auth.household_id + "/watchlistService")
+            self._mqtt_client.subscribe(self._auth.household_id + "/purchaseService")
             self._mqtt_client.subscribe(
-                self._auth.householdId + "/personalizationService"
+                self._auth.household_id + "/personalizationService"
             )
-            self._mqtt_client.subscribe(self._auth.householdId + "/recordingStatus")
+            self._mqtt_client.subscribe(self._auth.household_id + "/recordingStatus")
             self._mqtt_client.subscribe(
-                self._auth.householdId + "/recordingStatus/lastUserAction"
+                self._auth.household_id + "/recordingStatus/lastUserAction"
             )
             if self._on_connected_callback:
                 self._on_connected_callback()
-        elif resultCode == 5:
+        elif result_code == 5:
             self._mqtt_client.username_pw_set(
-                self._auth.householdId, self._auth.mqttToken
+                self._auth.household_id, self._auth.mqtt_token
             )
             self.connect()
         else:
             _logger.error(
-                f"Cannot connect to MQTT server with resultCode: {resultCode}"
+                "Cannot connect to MQTT server with resultCode: %s", result_code
             )
 
     def connect(self) -> None:
-        self._mqtt_client.connect(self._brokerUrl, 443)
+        """Connect the client."""
+        self._mqtt_client.connect(self._broker_url, 443)
         self._mqtt_client.loop_start()
 
-    def _on_client_message(self, client, userdata, message):
+    def _on_client_message(self, client, userdata, message):  # pylint: disable=unused-argument
         """Handle messages received by mqtt client."""
-        _logger.debug(f"Received MQTT message. Topic: {message.topic}")
-        jsonPayload = json.loads(message.payload)
-        _logger.debug(f"Message: {jsonPayload}")
+        _logger.debug("Received MQTT message. Topic: %s", message.topic)
+        json_payload = json.loads(message.payload)
+        _logger.debug("Message: %s", json_payload)
         if self._on_message_callback:
-            self._on_message_callback(jsonPayload, message.topic)
+            self._on_message_callback(json_payload, message.topic)
 
     def publish_message(self, topic: str, json_payload: str) -> None:
+        """Publish a MQTT message."""
         self._mqtt_client.publish(topic, json_payload, qos=2)
 
     def disconnect(self) -> None:
-        if self._mqtt_client.is_connected:
+        """Disconnect the client."""
+        if self._mqtt_client.is_connected():
             self._mqtt_client.disconnect()
 
 
 class LGHorizonBox:
-    deviceId: str = None
-    hashedCPEId: str = None
-    deviceFriendlyName: str = None
+    """The LGHorizon box."""
+
+    device_id: str = None
+    hashed_cpe_id: str = None
+    device_friendly_name: str = None
     state: str = None
     playing_info: LGHorizonPlayingInfo = None
     manufacturer: str = None
@@ -427,9 +464,9 @@ class LGHorizonBox:
         auth: LGHorizonAuth,
         channels: Dict[str, LGHorizonChannel],
     ):
-        self.deviceId = box_json["deviceId"]
-        self.hashedCPEId = box_json["hashedCPEId"]
-        self.deviceFriendlyName = box_json["settings"]["deviceFriendlyName"]
+        self.device_id = box_json["deviceId"]
+        self.hashed_cpe_id = box_json["hashedCPEId"]
+        self.device_friendly_name = box_json["settings"]["deviceFriendlyName"]
         self._mqtt_client = mqtt_client
         self._auth = auth
         self._channels = channels
@@ -439,20 +476,23 @@ class LGHorizonBox:
             self.model = platform_type["model"]
 
     def update_channels(self, channels: Dict[str, LGHorizonChannel]):
+        """Update the channels list."""
         self._channels = channels
 
     def register_mqtt(self) -> None:
+        """Register the mqtt connection."""
         if not self._mqtt_client.is_connected:
             raise Exception("MQTT client not connected.")
-        topic = f"{self._auth.householdId}/{self._mqtt_client.clientId}/status"
+        topic = f"{self._auth.household_id}/{self._mqtt_client.client_id}/status"
         payload = {
-            "source": self._mqtt_client.clientId,
+            "source": self._mqtt_client.client_id,
             "state": ONLINE_RUNNING,
             "deviceType": "HGO",
         }
         self._mqtt_client.publish_message(topic, json.dumps(payload))
 
     def set_callback(self, change_callback: Callable) -> None:
+        """Set a callback function."""
         self._change_callback = change_callback
 
     def update_state(self, payload):
@@ -464,25 +504,27 @@ class LGHorizonBox:
         if state == ONLINE_STANDBY:
             self.playing_info.reset()
             if self._change_callback:
-                self._change_callback(self.deviceId)
+                self._change_callback(self.device_id)
         else:
             self._request_settop_box_state()
         self._request_settop_box_recording_capacity()
 
     def update_recording_capacity(self, payload) -> None:
-        if not "CPE.capacity" in payload or not "used" in payload:
+        """Updates the recording capacity."""
+        if "CPE.capacity" not in payload or "used" not in payload:
             return
         self.recording_capacity = payload["used"]
 
     def update_with_replay_event(
         self, source_type: str, event: LGHorizonReplayEvent, channel: LGHorizonChannel
     ) -> None:
+        """Update box with replay event."""
         self.playing_info.set_source_type(source_type)
         self.playing_info.set_channel(channel.id)
         self.playing_info.set_channel_title(channel.title)
         title = event.title
-        if event.episodeName:
-            title += f": {event.episodeName}"
+        if event.episode_name:
+            title += f": {event.episode_name}"
         self.playing_info.set_title(title)
         self.playing_info.set_image(channel.stream_image)
         self.playing_info.reset_progress()
@@ -498,6 +540,7 @@ class LGHorizonBox:
         last_speed_change: float,
         relative_position: float,
     ) -> None:
+        """Update box with recording."""
         self.playing_info.set_source_type(source_type)
         self.playing_info.set_channel(channel.id)
         self.playing_info.set_channel_title(channel.title)
@@ -519,6 +562,7 @@ class LGHorizonBox:
         last_speed_change: float,
         relative_position: float,
     ) -> None:
+        """Update box with vod."""
         self.playing_info.set_source_type(source_type)
         self.playing_info.set_channel(None)
         self.playing_info.set_channel_title(None)
@@ -531,6 +575,7 @@ class LGHorizonBox:
         self._trigger_callback()
 
     def update_with_app(self, source_type: str, app: LGHorizonApp) -> None:
+        """Update box with app."""
         self.playing_info.set_source_type(source_type)
         self.playing_info.set_channel(None)
         self.playing_info.set_channel_title(app.title)
@@ -541,8 +586,8 @@ class LGHorizonBox:
 
     def _trigger_callback(self):
         if self._change_callback:
-            _logger.debug(f"Callback called from box {self.deviceId}")
-            self._change_callback(self.deviceId)
+            _logger.debug("Callback called from box %s", self.device_id)
+            self._change_callback(self.device_id)
 
     def turn_on(self) -> None:
         """Turn the settop box on."""
@@ -620,10 +665,10 @@ class LGHorizonBox:
         )
 
         self._mqtt_client.publish_message(
-            f"{self._auth.householdId}/{self.deviceId}", payload
+            f"{self._auth.household_id}/{self.device_id}", payload
         )
 
-    def play_recording(self, recordingId):
+    def play_recording(self, recording_id):
         """Play recording."""
         payload = (
             '{"id":"'
@@ -632,11 +677,11 @@ class LGHorizonBox:
             + self._mqtt_client.clientId
             + '","friendlyDeviceName":"Home Assistant"},'
             + '"status":{"sourceType":"nDVR","source":{"recordingId":"'
-            + recordingId
+            + recording_id
             + '"},"relativePosition":0}}'
         )
         self._mqtt_client.publish_message(
-            f"{self._auth.householdId}/{self.deviceId}", payload
+            f"{self._auth.household_id}/{self.device_id}", payload
         )
 
     def send_key_to_box(self, key: str) -> None:
@@ -647,7 +692,7 @@ class LGHorizonBox:
             + '","eventType":"keyDownUp"}}'
         )
         self._mqtt_client.publish_message(
-            f"{self._auth.householdId}/{self.deviceId}", payload
+            f"{self._auth.household_id}/{self.device_id}", payload
         )
 
     def _set_unknown_channel_info(self) -> None:
@@ -661,29 +706,31 @@ class LGHorizonBox:
 
     def _request_settop_box_state(self) -> None:
         """Send mqtt message to receive state from settop box."""
-        topic = f"{self._auth.householdId}/{self.deviceId}"
+        topic = f"{self._auth.household_id}/{self.device_id}"
         payload = {
             "id": make_id(8),
             "type": "CPE.getUiStatus",
-            "source": self._mqtt_client.clientId,
+            "source": self._mqtt_client.client_id,
         }
         self._mqtt_client.publish_message(topic, json.dumps(payload))
 
     def _request_settop_box_recording_capacity(self) -> None:
         """Send mqtt message to receive state from settop box."""
-        topic = f"{self._auth.householdId}/{self.deviceId}"
+        topic = f"{self._auth.household_id}/{self.device_id}"
         payload = {
             "id": make_id(8),
             "type": "CPE.capacity",
-            "source": self._mqtt_client.clientId,
+            "source": self._mqtt_client.client_id,
         }
         self._mqtt_client.publish_message(topic, json.dumps(payload))
 
 
 class LGHorizonProfile:
+    """LGHorizon profile."""
+
     profile_id: str = None
     name: str = None
-    favorite_channels: [] = None
+    favorite_channels: list[str] = None
 
     def __init__(self, json_payload):
         self.profile_id = json_payload["profileId"]
@@ -692,18 +739,20 @@ class LGHorizonProfile:
 
 
 class LGHorizonCustomer:
-    customerId: str = None
-    hashedCustomerId: str = None
-    countryId: str = None
-    cityId: int = 0
-    settop_boxes: [] = None
+    """LGHorizon customer"""
+
+    customer_id: str = None
+    hashed_customer_id: str = None
+    country_id: str = None
+    city_id: int = 0
+    settop_boxes: list[str] = 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"]
+        self.customer_id = json_payload["customerId"]
+        self.hashed_customer_id = json_payload["hashedCustomerId"]
+        self.country_id = json_payload["countryId"]
+        self.city_id = json_payload["cityId"]
         if "assignedDevices" in json_payload:
             self.settop_boxes = json_payload["assignedDevices"]
         if "profiles" in json_payload:

{lghorizon-0.7.5b2.dist-info → lghorizon-0.8.0b2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lghorizon
-Version: 0.7.5b2
+Version: 0.8.0b2
 Summary: Python client for Liberty Global Horizon settop boxes
 Home-page: https://github.com/sholofly/LGHorizon-python
 Author: Rudolf Offereins
@@ -20,7 +20,7 @@ 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 >=2.0.0
 Requires-Dist: requests >=2.22.0
 Requires-Dist: backoff >=1.9.0
 

lghorizon-0.8.0b2.dist-info/RECORD

@@ -0,0 +1,12 @@
+lghorizon/__init__.py,sha256=GrctR8IIj0G7Sps_N_YjvKsrvMcbhp3O0KxE7yi-_R8,991
+lghorizon/const.py,sha256=8P-4cwRRg0wKtrzr5DTOuGb618HKjGRPMnIfmc6-VSM,4700
+lghorizon/exceptions.py,sha256=-6v55KDTogBldGAg1wV9Mrxm5L5BsaVguhBgVMOeJHk,404
+lghorizon/helpers.py,sha256=W7ppV9MJ1MyXH_49GliNtiu_kA7h1KRzMdmRdrC5kaw,266
+lghorizon/lghorizon_api.py,sha256=xl2ISDPgkuLrdZtxXIBfBYjg2JfKIwBMY-BbMMqmmU0,22343
+lghorizon/models.py,sha256=NSgQd2Zb-YE8VkbhJP6g5mHKMGEBFQiIB1DYqa7IhSI,25990
+lghorizon/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lghorizon-0.8.0b2.dist-info/LICENSE,sha256=6Dh2tur1gMX3r3rITjVwUONBEJxyyPZDY8p6DZXtimE,1059
+lghorizon-0.8.0b2.dist-info/METADATA,sha256=CHR9mTAzm2v4nsBDFxdaVjq0il3Da_T57UD9pY3vpYI,1040
+lghorizon-0.8.0b2.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
+lghorizon-0.8.0b2.dist-info/top_level.txt,sha256=usii76_AxGfPI6gjrrh-NyZxcQQuF1B8_Q9kd7sID8Q,10
+lghorizon-0.8.0b2.dist-info/RECORD,,

lghorizon-0.7.5b2.dist-info/RECORD

@@ -1,12 +0,0 @@
-lghorizon/__init__.py,sha256=XqePG0hj8NnudOcfCtEWqPsWP5l2headzrQhkfuDlv8,544
-lghorizon/const.py,sha256=8P-4cwRRg0wKtrzr5DTOuGb618HKjGRPMnIfmc6-VSM,4700
-lghorizon/exceptions.py,sha256=-6v55KDTogBldGAg1wV9Mrxm5L5BsaVguhBgVMOeJHk,404
-lghorizon/helpers.py,sha256=ZWpi7B3hBvwGV02KWQQHVyj7FLLUDtIvKc-Iqsj5VHA,263
-lghorizon/lghorizon_api.py,sha256=ZrHHp-fSYLs566_KKi10n52P6T4vlaRyPh50UJqZWno,21993
-lghorizon/models.py,sha256=S_Pq8z9PpaN10b17aoi2j-mCIdZf-TK411pBGRPDkvc,24542
-lghorizon/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lghorizon-0.7.5b2.dist-info/LICENSE,sha256=6Dh2tur1gMX3r3rITjVwUONBEJxyyPZDY8p6DZXtimE,1059
-lghorizon-0.7.5b2.dist-info/METADATA,sha256=ftEhgIKdN1Nq257eTBw8-DPhqXHquorzEpl2IJtknJU,1039
-lghorizon-0.7.5b2.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
-lghorizon-0.7.5b2.dist-info/top_level.txt,sha256=usii76_AxGfPI6gjrrh-NyZxcQQuF1B8_Q9kd7sID8Q,10
-lghorizon-0.7.5b2.dist-info/RECORD,,