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

lghorizon/__init__.py

@@ -2,70 +2,5 @@
 
 from .lghorizon_api import LGHorizonApi
 from .lghorizon_device import LGHorizonDevice
-from .lghorizon_models 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,
-    LGHorizonApiUnauthorizedError,
-    LGHorizonApiLockedError,
-)
-
-__all__ = [
-    "LGHorizonApi",
-    "LGHorizonDevice",
-    "LGHorizonAuth",
-    "LGHorizonChannel",
-    "LGHorizonCustomer",
-    "LGHorizonDeviceState",
-    "LGHorizonProfile",
-    "LGHorizonApiError",
-    "LGHorizonApiConnectionError",
-    "LGHorizonApiUnauthorizedError",
-    "LGHorizonApiLockedError",
-    "LGHorizonRecordingList",
-    "LGHorizonRecordingSeason",
-    "LGHorizonRecordingSingle",
-    "LGHorizonRecordingShow",
-    "LGHorizonRecordingQuota",
-    "LGHorizonRecordingType",
-    "LGHorizonUIStateType",
-    "LGHorizonMessageType",
-    "LGHorizonRunningState",
-    "LGHorizonRecordingSource",
-    "LGHorizonRecordingState",
-    "LGHorizonSourceType",
-    "LGHorizonPlayerState",
-    "LGHorizonAppsState",
-    "LGHorizonUIState",
-    "LGHorizonProfileOptions",
-    "LGHorizonProfile",
-    "LGHorizonAuth",
-    "LGHorizonServicesConfig",
-    "LGHorizonRecording",
-    "LGHorizonShowRecordingList",
-]
+from .lghorizon_models import *
+from .exceptions import *

lghorizon/exceptions.py

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

lghorizon/lghorizon_api.py

@@ -1,7 +1,7 @@
 """LG Horizon API client."""
 
 import logging
-from typing import Any, Dict, cast, Callable, Optional
+from typing import Any, Dict, cast
 
 from .lghorizon_device import LGHorizonDevice
 from .lghorizon_models import LGHorizonChannel
@@ -15,11 +15,7 @@ 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_models import LGHorizonRecordingList, LGHorizonRecordingQuota
 from .lghorizon_recording_factory import LGHorizonRecordingFactory
 from .lghorizon_device_state_processor import LGHorizonDeviceStateProcessor
 
@@ -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
@@ -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_device.py

@@ -1,7 +1,7 @@
 """LG Horizon Device."""
 
 from __future__ import annotations
-import asyncio
+
 import json
 import logging
 from typing import Any, Callable, Coroutine, Dict, Optional
@@ -146,6 +146,8 @@ class LGHorizonDevice:
 
     async def register_mqtt(self) -> None:
         """Register the mqtt connection."""
+        if not self._mqtt_client.is_connected:
+            raise LGHorizonApiConnectionError("MQTT client not connected.")
         topic = f"{self._auth.household_id}/{self._mqtt_client.client_id}/status"
         payload = {
             "source": self._mqtt_client.client_id,
@@ -157,23 +159,14 @@ class LGHorizonDevice:
     async def set_callback(
         self, change_callback: Callable[[str], Coroutine[Any, Any, Any]]
     ) -> None:
-        """Set a callback function to be called when the device state changes.
-
-        Args:
-            change_callback: An asynchronous callable that takes the device ID
-                             as an argument.
-        """
+        """Set a callback function."""
         self._change_callback = change_callback
         await self.register_mqtt()  # type: ignore [assignment] # Callback can be None
 
     async def handle_status_message(
         self, status_message: LGHorizonStatusMessage
     ) -> None:
-        """Handle an incoming status message from the set-top box.
-
-        Args:
-            status_message: The status message received from the device.
-        """
+        """Register a new settop box."""
         old_running_state = self.device_state.state
         new_running_state = status_message.running_state
         if (
@@ -207,11 +200,7 @@ class LGHorizonDevice:
         self.recording_capacity = payload["used"]  # Use the setter
 
     async def _trigger_callback(self):
-        """Trigger the registered callback function.
-
-        This method is called when the device's state changes and a callback is set.
-        """
-        if self._change_callback is not None:
+        if self._change_callback:
             _LOGGER.debug("Callback called from box %s", self.device_id)
             await self._change_callback(self.device_id)
 
@@ -278,100 +267,38 @@ class LGHorizonDevice:
         if self._device_state.state == LGHorizonRunningState.ONLINE_RUNNING:
             await self.send_key_to_box(MEDIA_KEY_RECORD)
 
-    async def set_player_position(self, position: int) -> None:
-        """Set the player position on the settop box."""
-        payload = {
-            "source": self.device_id,
-            "type": "CPE.setPlayerPosition",
-            "runtimeType": "setPlayerposition",
-            "id": await make_id(),
-            "version": "1.3.11",
-            "status": {"relativePosition": position},
-        }
-        payload_str = json.dumps(payload)
-        await self._mqtt_client.publish_message(
-            f"{self._auth.household_id}/{self.device_id}", payload_str
-        )
-
-    async def display_message(self, sourceType: str, message: str) -> None:
-        """Display a message on the set-top box and repeat it for longer visibility.
-
-        # We sturen de payload 3 keer met een kortere tussentijd
-
-        This method sends the message payload multiple times to ensure it stays
-        visible on the screen for a longer duration, as the display time for
-        such messages is typically short.
-
-        Args:
-            sourceType: The type of source for the message (e.g., "linear").
-            message: The message string to display.
-        """
-        for i in range(3):
-            payload = {
-                "id": await make_id(8),
-                "type": "CPE.pushToTV",
-                "source": {
-                    "clientId": self._mqtt_client.client_id,
-                    "friendlyDeviceName": f"\n\n{message}",
-                },
-                "status": {
-                    "sourceType": sourceType,
-                    "source": {"channelId": "1234"},
-                    "title": "Nieuwe melding",
-                    "relativePosition": 0,
-                    "speed": 1,
-                },
-            }
-
-            await self._mqtt_client.publish_message(
-                f"{self._auth.household_id}/{self.device_id}", json.dumps(payload)
-            )
-
-            # Omdat de melding 3 seconden blijft staan, wachten we 3 seconden
-            # voor de volgende 'refresh'.
-            if i < 2:
-                await asyncio.sleep(3)
-
     async 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 = {
-            "id": await make_id(8),
-            "type": "CPE.pushToTV",
-            "source": {
-                "clientId": self._mqtt_client.client_id,
-                "friendlyDeviceName": "Home Assistant",
-            },
-            "status": {
-                "sourceType": "linear",
-                "source": {"channelId": channel.id},
-                "relativePosition": 0,
-                "speed": 1,
-            },
-        }
+        payload = (
+            '{"id":"'
+            + await make_id(8)
+            + '","type":"CPE.pushToTV","source":{"clientId":"'
+            + self._mqtt_client.client_id
+            + '","friendlyDeviceName":"Home Assistant"},'
+            + '"status":{"sourceType":"linear","source":{"channelId":"'
+            + channel.id
+            + '"},"relativePosition":0,"speed":1}}'
+        )
 
         await self._mqtt_client.publish_message(
-            f"{self._auth.household_id}/{self.device_id}", json.dumps(payload)
+            f"{self._auth.household_id}/{self.device_id}", payload
         )
 
     async def play_recording(self, recording_id):
         """Play recording."""
-        payload = {
-            "id": await make_id(8),
-            "type": "CPE.pushToTV",
-            "source": {
-                "clientId": self._mqtt_client.client_id,
-                "friendlyDeviceName": "Home Assistant",
-            },
-            "status": {
-                "sourceType": "nDVR",
-                "source": {"recordingId": recording_id},
-                "relativePosition": 0,
-            },
-        }
-
+        payload = (
+            '{"id":"'
+            + await make_id(8)
+            + '","type":"CPE.pushToTV","source":{"clientId":"'
+            + self._mqtt_client.client_id
+            + '","friendlyDeviceName":"Home Assistant"},'
+            + '"status":{"sourceType":"nDVR","source":{"recordingId":"'
+            + recording_id
+            + '"},"relativePosition":0}}'
+        )
         await self._mqtt_client.publish_message(
-            f"{self._auth.household_id}/{self.device_id}", json.dumps(payload)
+            f"{self._auth.household_id}/{self.device_id}", payload
         )
 
     async def send_key_to_box(self, key: str) -> None:

lghorizon/lghorizon_device_state_processor.py

@@ -3,9 +3,6 @@
 import random
 import json
 import urllib.parse
-from datetime import datetime as dt, timezone
-
-import time
 
 from typing import cast, Dict, Optional
 
@@ -18,10 +15,12 @@ from .lghorizon_models import (
     LGHorizonReplaySource,
     LGHorizonNDVRSource,
     LGHorizonReviewBufferSource,
-    LGHorizonRecordingSource,
 )
 from .lghorizon_models import LGHorizonAuth
-from .lghorizon_models import LGHorizonReplayEvent, LGHorizonVOD, LGHorizonVODType
+from .lghorizon_models import (
+    LGHorizonReplayEvent,
+    LGHorizonVOD,
+)
 
 from .lghorizon_models import LGHorizonRecordingSingle
 from .lghorizon_models import LGHorizonChannel
@@ -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_message_factory.py

@@ -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)