lghorizon 0.9.0__py3-none-any.whl → 0.9.0.dev1__py3-none-any.whl

lghorizon/__init__.py

@@ -1,71 +1,36 @@
 """Python client for LG Horizon."""
 
-from .lghorizon_api import LGHorizonApi
-from .lghorizon_device import LGHorizonDevice
-from .lghorizon_models import (
+from .lghorizonapi import LGHorizonApi
+from .models.lghorizon_auth import (
     LGHorizonAuth,
-    LGHorizonChannel,
-    LGHorizonCustomer,
-    LGHorizonDeviceState,
-    LGHorizonProfile,
-    LGHorizonRecording,
-    LGHorizonRecordingList,
-    LGHorizonShowRecordingList,
-    LGHorizonRecordingSeason,
-    LGHorizonRecordingSingle,
-    LGHorizonRecordingShow,
-    LGHorizonRecordingQuota,
-    LGHorizonRecordingType,
-    LGHorizonUIStateType,
-    LGHorizonMessageType,
-    LGHorizonRunningState,
-    LGHorizonRecordingSource,
-    LGHorizonRecordingState,
-    LGHorizonSourceType,
-    LGHorizonPlayerState,
-    LGHorizonAppsState,
-    LGHorizonUIState,
-    LGHorizonProfileOptions,
-    LGHorizonServicesConfig,
 )
-from .exceptions import (
-    LGHorizonApiError,
-    LGHorizonApiConnectionError,
+from .models.exceptions import (
     LGHorizonApiUnauthorizedError,
+    LGHorizonApiConnectionError,
     LGHorizonApiLockedError,
 )
+from .const import (
+    ONLINE_RUNNING,
+    ONLINE_STANDBY,
+    RECORDING_TYPE_SHOW,
+    RECORDING_TYPE_SEASON,
+    RECORDING_TYPE_SINGLE,
+)
 
 __all__ = [
     "LGHorizonApi",
-    "LGHorizonDevice",
-    "LGHorizonAuth",
-    "LGHorizonChannel",
+    "LGHorizonBox",
+    "LGHorizonRecordingListSeasonShow",
+    "LGHorizonRecordingSingle",
+    "LGHorizonRecordingShow",
+    "LGHorizonRecordingEpisode",
     "LGHorizonCustomer",
-    "LGHorizonDeviceState",
-    "LGHorizonProfile",
-    "LGHorizonApiError",
-    "LGHorizonApiConnectionError",
     "LGHorizonApiUnauthorizedError",
+    "LGHorizonApiConnectionError",
     "LGHorizonApiLockedError",
-    "LGHorizonRecordingList",
-    "LGHorizonRecordingSeason",
-    "LGHorizonRecordingSingle",
-    "LGHorizonRecordingShow",
-    "LGHorizonRecordingQuota",
-    "LGHorizonRecordingType",
-    "LGHorizonUIStateType",
-    "LGHorizonMessageType",
-    "LGHorizonRunningState",
-    "LGHorizonRecordingSource",
-    "LGHorizonRecordingState",
-    "LGHorizonSourceType",
-    "LGHorizonPlayerState",
-    "LGHorizonAppsState",
-    "LGHorizonUIState",
-    "LGHorizonProfileOptions",
-    "LGHorizonProfile",
-    "LGHorizonAuth",
-    "LGHorizonServicesConfig",
-    "LGHorizonRecording",
-    "LGHorizonShowRecordingList",
-]
+    "ONLINE_RUNNING",
+    "ONLINE_STANDBY",
+    "RECORDING_TYPE_SHOW",
+    "RECORDING_TYPE_SEASON",
+    "RECORDING_TYPE_SINGLE",
+]  # noqa

lghorizon/{lghorizon_device_state_processor.py → device_state_processor.py}

@@ -3,34 +3,33 @@
 import random
 import json
 import urllib.parse
-from datetime import datetime as dt, timezone
-
-import time
 
 from typing import cast, Dict, Optional
 
-from .lghorizon_models import LGHorizonDeviceState, LGHorizonRunningState
-from .lghorizon_models import LGHorizonStatusMessage, LGHorizonUIStatusMessage
-from .lghorizon_models import (
+from .models.lghorizon_device_state import LGHorizonDeviceState, LGHorizonRunningState
+from .models.lghorizon_message import LGHorizonStatusMessage, LGHorizonUIStatusMessage
+from .models.lghorizon_sources import (
     LGHorizonSourceType,
     LGHorizonLinearSource,
     LGHorizonVODSource,
     LGHorizonReplaySource,
     LGHorizonNDVRSource,
     LGHorizonReviewBufferSource,
-    LGHorizonRecordingSource,
 )
-from .lghorizon_models import LGHorizonAuth
-from .lghorizon_models import LGHorizonReplayEvent, LGHorizonVOD, LGHorizonVODType
+from .models.lghorizon_auth import LGHorizonAuth
+from .models.lghorizon_events import (
+    LGHorizonReplayEvent,
+    LGHorizonVOD,
+)
 
-from .lghorizon_models import LGHorizonRecordingSingle
-from .lghorizon_models import LGHorizonChannel
-from .lghorizon_models import (
+from .models.lghorizon_recordings import LGHorizonRecordingSingle
+from .models.lghorizon_channel import LGHorizonChannel
+from .models.lghorizon_ui_status import (
     LGHorizonUIStateType,
     LGHorizonAppsState,
     LGHorizonPlayerState,
 )
-from .lghorizon_models import LGHorizonCustomer
+from .models.lghorizon_customer import LGHorizonCustomer
 
 
 class LGHorizonDeviceStateProcessor:
@@ -100,9 +99,6 @@ class LGHorizonDeviceStateProcessor:
             return
         await device_state.reset()
         device_state.source_type = player_state.source_type
-        device_state.ui_state_type = LGHorizonUIStateType.MAINUI
-        device_state.speed = player_state.speed
-
         match player_state.source_type:
             case LGHorizonSourceType.LINEAR:
                 await self._process_linear_state(device_state, player_state)
@@ -120,10 +116,9 @@ class LGHorizonDeviceStateProcessor:
         device_state: LGHorizonDeviceState,
         apps_state: LGHorizonAppsState,
     ) -> None:
-        device_state.id = apps_state.id
-        device_state.show_title = apps_state.app_name
+        device_state.channel_id = apps_state.id
+        device_state.title = apps_state.app_name
         device_state.image = apps_state.logo_path
-        device_state.ui_state_type = LGHorizonUIStateType.APPS
 
     async def _process_linear_state(
         self,
@@ -145,22 +140,12 @@ class LGHorizonDeviceStateProcessor:
             service_path,
         )
         replay_event = LGHorizonReplayEvent(event_json)
-        device_state.id = replay_event.event_id
         channel = self._channels[replay_event.channel_id]
         device_state.source_type = source.source_type
-        device_state.channel_id = channel.id
+        device_state.channel_id = channel.channel_number
         device_state.channel_name = channel.title
-        device_state.episode_title = replay_event.episode_name
-        device_state.season_number = replay_event.season_number
-        device_state.episode_number = replay_event.episode_number
-        device_state.show_title = replay_event.title
-        now_in_ms = int(time.time() * 1000)
-
-        device_state.last_position_update = int(time.time() * 1000)
-        device_state.start_time = replay_event.start_time
-        device_state.end_time = replay_event.end_time
-        device_state.duration = replay_event.end_time - replay_event.start_time
-        device_state.position = now_in_ms - int(replay_event.start_time * 1000)
+        device_state.title = replay_event.title
+        device_state.sub_title = replay_event.full_episode_title
 
         # Add random number to url to force refresh
         join_param = "?"
@@ -170,6 +155,7 @@ class LGHorizonDeviceStateProcessor:
             f"{channel.stream_image}{join_param}{str(random.randrange(1000000))}"
         )
         device_state.image = image_url
+        await device_state.reset_progress()
 
     async def _process_reviewbuffer_state(
         self,
@@ -191,20 +177,13 @@ class LGHorizonDeviceStateProcessor:
             service_path,
         )
         replay_event = LGHorizonReplayEvent(event_json)
-        device_state.id = replay_event.event_id
         channel = self._channels[replay_event.channel_id]
         device_state.source_type = source.source_type
-        device_state.channel_id = channel.id
+        device_state.channel_id = channel.channel_number
         device_state.channel_name = channel.title
-        device_state.episode_title = replay_event.episode_name
-        device_state.season_number = replay_event.season_number
-        device_state.episode_number = replay_event.episode_number
-        device_state.show_title = replay_event.title
-        device_state.last_position_update = player_state.last_speed_change_time
-        device_state.position = player_state.relative_position
-        device_state.start_time = replay_event.start_time
-        device_state.end_time = replay_event.end_time
-        device_state.duration = replay_event.end_time - replay_event.start_time
+        device_state.title = replay_event.title
+        device_state.sub_title = replay_event.full_episode_title
+
         # Add random number to url to force refresh
         join_param = "?"
         if join_param in channel.stream_image:
@@ -213,6 +192,7 @@ class LGHorizonDeviceStateProcessor:
             f"{channel.stream_image}{join_param}{str(random.randrange(1000000))}"
         )
         device_state.image = image_url
+        await device_state.reset_progress()
 
     async def _process_replay_state(
         self,
@@ -234,27 +214,15 @@ class LGHorizonDeviceStateProcessor:
             service_path,
         )
         replay_event = LGHorizonReplayEvent(event_json)
-        device_state.id = replay_event.event_id
-        # Iets met buffer doen
-        channel = self._channels[replay_event.channel_id]
-        padding = channel.replay_pre_padding + channel.replay_post_padding
         device_state.source_type = source.source_type
-        device_state.channel_id = channel.id
-        device_state.episode_title = replay_event.episode_name
-        device_state.season_number = replay_event.season_number
-        device_state.episode_number = replay_event.episode_number
-        device_state.show_title = replay_event.title
-        device_state.last_position_update = int(time.time() * 1000)
-        device_state.start_time = replay_event.start_time
-        device_state.end_time = replay_event.end_time
-        device_state.duration = (
-            replay_event.end_time - replay_event.start_time + padding
-        )
-        device_state.position = (
-            player_state.relative_position + channel.replay_pre_padding
-        )
+        device_state.channel_id = None
+        device_state.title = replay_event.title
+        if replay_event.full_episode_title:
+            device_state.sub_title = replay_event.full_episode_title
+
         # Add random number to url to force refresh
         device_state.image = await self._get_intent_image_url(replay_event.event_id)
+        await device_state.reset_progress()
 
     async def _process_vod_state(
         self,
@@ -276,20 +244,11 @@ class LGHorizonDeviceStateProcessor:
             service_path,
         )
         vod = LGHorizonVOD(vod_json)
-        device_state.id = vod.id
-        if vod.vod_type == LGHorizonVODType.EPISODE:
-            device_state.show_title = vod.series_title
-            device_state.episode_title = vod.title
-            device_state.season_number = vod.season
-            device_state.episode_number = vod.episode
-        else:
-            device_state.show_title = vod.title
-
+        device_state.title = vod.title
+        device_state.sub_title = vod.full_episode_title
         device_state.duration = vod.duration
-        device_state.last_position_update = int(time.time() * 1000)
-        device_state.position = player_state.relative_position
-
         device_state.image = await self._get_intent_image_url(vod.id)
+        await device_state.reset_progress()
 
     async def _process_ndvr_state(
         self, device_state: LGHorizonDeviceState, player_state: LGHorizonPlayerState
@@ -308,36 +267,13 @@ class LGHorizonDeviceStateProcessor:
             service_path,
         )
         recording = LGHorizonRecordingSingle(recording_json)
-        device_state.id = recording.id
+        device_state.title = recording.title
+        device_state.sub_title = recording.full_episode_title
         device_state.channel_id = recording.channel_id
         if recording.channel_id:
             channel = self._channels[recording.channel_id]
             device_state.channel_name = channel.title
 
-        device_state.episode_title = recording.episode_title
-        device_state.season_number = recording.season_number
-        device_state.episode_number = recording.episode_number
-        device_state.last_position_update = player_state.last_speed_change_time
-        device_state.position = player_state.relative_position
-        if recording.start_time:
-            device_state.start_time = int(
-                dt.fromisoformat(
-                    recording.start_time.replace("Z", "+00:00")
-                ).timestamp()
-            )
-        if recording.end_time:
-            device_state.end_time = int(
-                dt.fromisoformat(recording.end_time.replace("Z", "+00:00")).timestamp()
-            )
-        if recording.start_time and recording.end_time:
-            device_state.duration = device_state.end_time - device_state.start_time
-        if recording.source == LGHorizonRecordingSource.SHOW:
-            device_state.show_title = recording.title
-        else:
-            device_state.show_title = recording.show_title
-
-        device_state.image = await self._get_intent_image_url(recording.id)
-
     async def _get_intent_image_url(self, intent_id: str) -> Optional[str]:
         """Get intent image url."""
         service_config = await self._auth.get_service_config()

lghorizon/{lghorizon_api.py → lghorizonapi.py}

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

lghorizon/{lghorizon_message_factory.py → message_factory.py}

@@ -1,6 +1,6 @@
 "LG Horizon Message Factory."
 
-from .lghorizon_models import (
+from .models.lghorizon_message import (
     LGHorizonMessage,
     LGHorizonStatusMessage,
     LGHorizonUnknownMessage,
@@ -22,6 +22,7 @@ class LGHorizonMessageFactory:
             case LGHorizonMessageType.STATUS:
                 return LGHorizonStatusMessage(payload, topic)
             case LGHorizonMessageType.UI_STATUS:
+                # Placeholder for UI_STATUS message handling
                 return LGHorizonUIStatusMessage(payload, topic)
             case LGHorizonMessageType.UNKNOWN:
                 return LGHorizonUnknownMessage(payload, topic)

lghorizon/{lghorizon_recording_factory.py → recording_factory.py}

@@ -1,11 +1,9 @@
-from typing import Optional
-from .lghorizon_models import (
+from .models.lghorizon_recordings import (
     LGHorizonRecordingList,
     LGHorizonRecordingSingle,
     LGHorizonRecordingSeason,
     LGHorizonRecordingShow,
     LGHorizonRecordingType,
-    LGHorizonShowRecordingList,
 )
 
 
@@ -34,22 +32,10 @@ class LGHorizonRecordingFactory:
 
         return LGHorizonRecordingList(recording_list)
 
-    async def create_episodes(self, episode_json: dict) -> LGHorizonShowRecordingList:
+    async def create_episodes(self, episode_json: dict) -> LGHorizonRecordingList:
         """Create a LGHorizonRecording list based for episodes."""
         recording_list = []
-        show_title: Optional[str] = None
-        if "images" in episode_json:
-            images = episode_json["images"]
-            show_image = next(
-                (img["url"] for img in images if img.get("type") == "titleTreatment"),
-                images[0]["url"] if images else None,
-            )
-        else:
-            show_image = None
-
         for recording in episode_json["data"]:
             recording_single = LGHorizonRecordingSingle(recording)
-            if show_title is None:
-                show_title = recording_single.show_title or recording_single.title
             recording_list.append(recording_single)
-        return LGHorizonShowRecordingList(show_title, show_image, recording_list)
+        return LGHorizonRecordingList(recording_list)

lghorizon-0.9.0.dev1.dist-info/METADATA

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: lghorizon
+Version: 0.9.0.dev1
+Summary: Python client for Liberty Global Horizon settop boxes
+Home-page: https://github.com/sholofly/LGHorizon-python
+Author: Rudolf Offereins
+Author-email: r.offereins@gmail.com
+License: MIT license
+Keywords: LG,Horizon,API,Settop box
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Natural Language :: English
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: paho-mqtt
+Requires-Dist: requests>=2.22.0
+Requires-Dist: backoff>=1.9.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# LG Horizon Api
+
+Python library to control multiple LG Horizon boxes

lghorizon-0.9.0.dev1.dist-info/RECORD

@@ -0,0 +1,13 @@
+lghorizon/__init__.py,sha256=Hv5lGe6Nb0OlkugLpNA0gyIPFRHOGkdnUvhLS0Sn0eA,863
+lghorizon/const.py,sha256=HINlbyevEN9ZRnfIBbSGNc6i9J8WkIgpqkLZrwyqpGQ,5307
+lghorizon/device_state_processor.py,sha256=MuItTJoXDUeSXHW5QjmPjbdQ72JFBGLWfuo6iMKOTYk,12141
+lghorizon/helpers.py,sha256=SGlEN6V0kh2vqw1qCKmM1KhfeO-UvPyyQmnThgFLFhs,272
+lghorizon/lghorizonapi.py,sha256=eZmcIlbA_Xgtcq65ShVSiBXAapFdAVUIxYuBOKVV8h8,11841
+lghorizon/message_factory.py,sha256=Bk0k6fZSJNgpmcN_IxPL26lwc6V1fCbQe7acd65Km0g,1504
+lghorizon/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lghorizon/recording_factory.py,sha256=xcEVzchn2SSV1ojRo9N17VfaEDlD9AaYLEo92uNNgaA,1766
+lghorizon-0.9.0.dev1.dist-info/licenses/LICENSE,sha256=6Dh2tur1gMX3r3rITjVwUONBEJxyyPZDY8p6DZXtimE,1059
+lghorizon-0.9.0.dev1.dist-info/METADATA,sha256=zwM_v9XJf8B7v5H32jxRv3Qpt_aphskTKturNLIcnk4,1287
+lghorizon-0.9.0.dev1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+lghorizon-0.9.0.dev1.dist-info/top_level.txt,sha256=usii76_AxGfPI6gjrrh-NyZxcQQuF1B8_Q9kd7sID8Q,10
+lghorizon-0.9.0.dev1.dist-info/RECORD,,

lghorizon/exceptions.py

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