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

lghorizon/__init__.py

@@ -1,36 +1,3 @@
 """Python client for LG Horizon."""
 
-from .lghorizonapi import LGHorizonApi
-from .models.lghorizon_auth import (
-    LGHorizonAuth,
-)
-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",
-    "LGHorizonBox",
-    "LGHorizonRecordingListSeasonShow",
-    "LGHorizonRecordingSingle",
-    "LGHorizonRecordingShow",
-    "LGHorizonRecordingEpisode",
-    "LGHorizonCustomer",
-    "LGHorizonApiUnauthorizedError",
-    "LGHorizonApiConnectionError",
-    "LGHorizonApiLockedError",
-    "ONLINE_RUNNING",
-    "ONLINE_STANDBY",
-    "RECORDING_TYPE_SHOW",
-    "RECORDING_TYPE_SEASON",
-    "RECORDING_TYPE_SINGLE",
-]  # noqa
+pass

lghorizon/exceptions.py

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

lghorizon/{lghorizonapi.py → lghorizon_api.py}

@@ -3,21 +3,21 @@
 import logging
 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
+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
+from .lghorizon_recording_factory import LGHorizonRecordingFactory
+from .lghorizon_device_state_processor import LGHorizonDeviceStateProcessor
 
 
 _LOGGER = logging.getLogger(__name__)

lghorizon/lghorizon_device.py

@@ -0,0 +1,336 @@
+"""LG Horizon Device."""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any, Callable, Coroutine, Dict, Optional
+from .lghorizon_models import (
+    LGHorizonRunningState,
+    LGHorizonStatusMessage,
+    LGHorizonUIStatusMessage,
+    LGHorizonDeviceState,
+    LGHorizonAuth,
+    LGHorizonChannel,
+)
+
+from .exceptions import LGHorizonApiConnectionError
+from .helpers import make_id
+from .lghorizon_device_state_processor import LGHorizonDeviceStateProcessor
+from .lghorizon_mqtt_client import LGHorizonMqttClient
+from .const import (
+    MEDIA_KEY_CHANNEL_DOWN,
+    MEDIA_KEY_CHANNEL_UP,
+    MEDIA_KEY_ENTER,
+    MEDIA_KEY_FAST_FORWARD,
+    MEDIA_KEY_PLAY_PAUSE,
+    MEDIA_KEY_POWER,
+    MEDIA_KEY_RECORD,
+    MEDIA_KEY_REWIND,
+    MEDIA_KEY_STOP,
+    ONLINE_RUNNING,
+    PLATFORM_TYPES,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class LGHorizonDevice:
+    """The LG Horizon device (set-top box)."""
+
+    _device_id: str
+    _hashed_cpe_id: str
+    _device_friendly_name: str
+    _platform_type: str
+    _device_state: LGHorizonDeviceState
+    _manufacturer: Optional[str]
+    _model: Optional[str]
+    _recording_capacity: Optional[int]
+    _device_state_processor: LGHorizonDeviceStateProcessor
+    _mqtt_client: LGHorizonMqttClient
+    _change_callback: Callable[[str], Coroutine[Any, Any, Any]]
+    _auth: LGHorizonAuth
+    _channels: Dict[str, LGHorizonChannel]
+    _last_ui_message_timestamp: int = 0
+
+    def __init__(
+        self,
+        device_json,
+        mqtt_client: LGHorizonMqttClient,
+        device_state_processor: LGHorizonDeviceStateProcessor,
+        auth: LGHorizonAuth,
+        channels: Dict[str, LGHorizonChannel],
+    ):
+        """Initialize the LG Horizon device."""
+        self._device_id = device_json["deviceId"]
+        self._hashed_cpe_id = device_json["hashedCPEId"]
+        self._device_friendly_name = device_json["settings"]["deviceFriendlyName"]
+        self._platform_type = device_json.get("platformType")
+        self._mqtt_client = mqtt_client
+        self._auth = auth
+        self._channels = channels
+        self._device_state = LGHorizonDeviceState()  # Initialize state
+        self._manufacturer = None
+        self._model = None
+        self._recording_capacity = None
+        self._device_state_processor = device_state_processor
+
+    @property
+    def device_id(self) -> str:
+        """Return the device ID."""
+        return self._device_id
+
+    @property
+    def platform_type(self) -> str:
+        """Return the device ID."""
+        return self._platform_type
+
+    @property
+    def manufacturer(self) -> str:
+        """Return the manufacturer of the settop box."""
+        platform_info = PLATFORM_TYPES.get(self._platform_type, dict())
+        return platform_info.get("manufacturer", "unknown")
+
+    @property
+    def model(self) -> str:
+        """Return the model of the settop box."""
+        platform_info = PLATFORM_TYPES.get(self._platform_type, dict())
+        return platform_info.get("model", "unknown")
+
+    @property
+    def is_available(self) -> bool:
+        """Return the availability of the settop box."""
+        return self._device_state.state in (
+            LGHorizonRunningState.ONLINE_RUNNING,
+            LGHorizonRunningState.ONLINE_STANDBY,
+        )
+
+    @property
+    def hashed_cpe_id(self) -> str:
+        """Return the hashed CPE ID."""
+        return self._hashed_cpe_id
+
+    @property
+    def device_friendly_name(self) -> str:
+        """Return the device friendly name."""
+        return self._device_friendly_name
+
+    @property
+    def device_state(self) -> LGHorizonDeviceState:
+        """Return the current playing information."""
+        return self._device_state
+
+    @property
+    def recording_capacity(self) -> Optional[int]:
+        """Return the recording capacity used."""
+        return self._recording_capacity
+
+    @recording_capacity.setter
+    def recording_capacity(self, value: int) -> None:
+        """Set the recording capacity used."""
+        self._recording_capacity = value
+
+    @property
+    def last_ui_message_timestamp(self) -> int:
+        """Return the last ui message timestamp."""
+        return self._last_ui_message_timestamp
+
+    @last_ui_message_timestamp.setter
+    def last_ui_message_timestamp(self, value: int) -> None:
+        """Set the last ui message timestamp."""
+        self._last_ui_message_timestamp = value
+
+    async def update_channels(self, channels: Dict[str, LGHorizonChannel]):
+        """Update the channels list."""
+        self._channels = channels
+
+    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,
+            "state": ONLINE_RUNNING,
+            "deviceType": "HGO",
+        }
+        await self._mqtt_client.publish_message(topic, json.dumps(payload))
+
+    async def set_callback(
+        self, change_callback: Callable[[str], Coroutine[Any, Any, Any]]
+    ) -> None:
+        """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:
+        """Register a new settop box."""
+        old_running_state = self.device_state.state
+        new_running_state = status_message.running_state
+        if (
+            old_running_state == new_running_state
+        ):  # Access backing field for comparison
+            return
+        await self._device_state_processor.process_state(
+            self.device_state, status_message
+        )  # Use the setter
+        if self._device_state.state == LGHorizonRunningState.ONLINE_RUNNING:
+            await self._request_settop_box_state()
+
+        await self._trigger_callback()
+        await self._request_settop_box_recording_capacity()
+
+    async def handle_ui_status_message(
+        self, status_message: LGHorizonUIStatusMessage
+    ) -> None:
+        """Handle UI status message."""
+
+        await self._device_state_processor.process_ui_state(
+            self.device_state, status_message
+        )
+        self.last_ui_message_timestamp = status_message.message_timestamp
+        await self._trigger_callback()
+
+    async def update_recording_capacity(self, payload) -> None:
+        """Updates the recording capacity."""
+        if "CPE.capacity" not in payload or "used" not in payload:
+            return
+        self.recording_capacity = payload["used"]  # Use the setter
+
+    async def _trigger_callback(self):
+        if self._change_callback:
+            _LOGGER.debug("Callback called from box %s", self.device_id)
+            await self._change_callback(self.device_id)
+
+    async def turn_on(self) -> None:
+        """Turn the settop box on."""
+
+        if self._device_state.state == LGHorizonRunningState.ONLINE_STANDBY:
+            await self.send_key_to_box(MEDIA_KEY_POWER)
+
+    async def turn_off(self) -> None:
+        """Turn the settop box off."""
+        if self._device_state.state == LGHorizonRunningState.ONLINE_RUNNING:
+            await self.send_key_to_box(MEDIA_KEY_POWER)
+            await self._device_state.reset()
+
+    async def pause(self) -> None:
+        """Pause the given settopbox."""
+        if (
+            self._device_state.state == LGHorizonRunningState.ONLINE_RUNNING
+            and not self._device_state.paused
+        ):
+            await self.send_key_to_box(MEDIA_KEY_PLAY_PAUSE)
+
+    async def play(self) -> None:
+        """Resume the settopbox."""
+        if (
+            self._device_state.state == LGHorizonRunningState.ONLINE_RUNNING
+            and self._device_state.paused
+        ):
+            await self.send_key_to_box(MEDIA_KEY_PLAY_PAUSE)
+
+    async def stop(self) -> None:
+        """Stop the settopbox."""
+        if self._device_state.state == LGHorizonRunningState.ONLINE_RUNNING:
+            await self.send_key_to_box(MEDIA_KEY_STOP)
+
+    async def next_channel(self):
+        """Select the next channel for given settop box."""
+        if self._device_state.state == LGHorizonRunningState.ONLINE_RUNNING:
+            await self.send_key_to_box(MEDIA_KEY_CHANNEL_UP)
+
+    async def previous_channel(self) -> None:
+        """Select the previous channel for given settop box."""
+        if self._device_state.state == LGHorizonRunningState.ONLINE_RUNNING:
+            await self.send_key_to_box(MEDIA_KEY_CHANNEL_DOWN)
+
+    async def press_enter(self) -> None:
+        """Press enter on the settop box."""
+        if self._device_state.state == LGHorizonRunningState.ONLINE_RUNNING:
+            await self.send_key_to_box(MEDIA_KEY_ENTER)
+
+    async def rewind(self) -> None:
+        """Rewind the settop box."""
+        if self._device_state.state == LGHorizonRunningState.ONLINE_RUNNING:
+            await self.send_key_to_box(MEDIA_KEY_REWIND)
+
+    async def fast_forward(self) -> None:
+        """Fast forward the settop box."""
+        if self._device_state.state == LGHorizonRunningState.ONLINE_RUNNING:
+            await self.send_key_to_box(MEDIA_KEY_FAST_FORWARD)
+
+    async def record(self):
+        """Record on the settop box."""
+        if self._device_state.state == LGHorizonRunningState.ONLINE_RUNNING:
+            await self.send_key_to_box(MEDIA_KEY_RECORD)
+
+    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}}'
+        )
+
+        await self._mqtt_client.publish_message(
+            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}}'
+        )
+        await self._mqtt_client.publish_message(
+            f"{self._auth.household_id}/{self.device_id}", payload
+        )
+
+    async def send_key_to_box(self, key: str) -> None:
+        """Send emulated (remote) key press to settopbox."""
+        payload_dict = {
+            "type": "CPE.KeyEvent",
+            "runtimeType": "key",
+            "id": "ha",
+            "source": self.device_id.lower(),
+            "status": {"w3cKey": key, "eventType": "keyDownUp"},
+        }
+        payload = json.dumps(payload_dict)
+        await self._mqtt_client.publish_message(
+            f"{self._auth.household_id}/{self.device_id}", payload
+        )
+
+    async def _request_settop_box_state(self) -> None:
+        """Send mqtt message to receive state from settop box."""
+        topic = f"{self._auth.household_id}/{self.device_id}"
+        payload = {
+            "id": await make_id(8),
+            "type": "CPE.getUiStatus",
+            "source": self._mqtt_client.client_id,
+        }
+        await self._mqtt_client.publish_message(topic, json.dumps(payload))
+
+    async def _request_settop_box_recording_capacity(self) -> None:
+        """Send mqtt message to receive state from settop box."""
+        topic = f"{self._auth.household_id}/{self.device_id}"
+        payload = {
+            "id": await make_id(8),
+            "type": "CPE.capacity",
+            "source": self._mqtt_client.client_id,
+        }
+        await self._mqtt_client.publish_message(topic, json.dumps(payload))

lghorizon/{device_state_processor.py → lghorizon_device_state_processor.py}

@@ -6,9 +6,9 @@ import urllib.parse
 
 from typing import cast, Dict, Optional
 
-from .models.lghorizon_device_state import LGHorizonDeviceState, LGHorizonRunningState
-from .models.lghorizon_message import LGHorizonStatusMessage, LGHorizonUIStatusMessage
-from .models.lghorizon_sources import (
+from .lghorizon_models import LGHorizonDeviceState, LGHorizonRunningState
+from .lghorizon_models import LGHorizonStatusMessage, LGHorizonUIStatusMessage
+from .lghorizon_models import (
     LGHorizonSourceType,
     LGHorizonLinearSource,
     LGHorizonVODSource,
@@ -16,20 +16,20 @@ from .models.lghorizon_sources import (
     LGHorizonNDVRSource,
     LGHorizonReviewBufferSource,
 )
-from .models.lghorizon_auth import LGHorizonAuth
-from .models.lghorizon_events import (
+from .lghorizon_models import LGHorizonAuth
+from .lghorizon_models import (
     LGHorizonReplayEvent,
     LGHorizonVOD,
 )
 
-from .models.lghorizon_recordings import LGHorizonRecordingSingle
-from .models.lghorizon_channel import LGHorizonChannel
-from .models.lghorizon_ui_status import (
+from .lghorizon_models import LGHorizonRecordingSingle
+from .lghorizon_models import LGHorizonChannel
+from .lghorizon_models import (
     LGHorizonUIStateType,
     LGHorizonAppsState,
     LGHorizonPlayerState,
 )
-from .models.lghorizon_customer import LGHorizonCustomer
+from .lghorizon_models import LGHorizonCustomer
 
 
 class LGHorizonDeviceStateProcessor:

lghorizon/{message_factory.py → lghorizon_message_factory.py}

@@ -1,6 +1,6 @@
 "LG Horizon Message Factory."
 
-from .models.lghorizon_message import (
+from .lghorizon_models import (
     LGHorizonMessage,
     LGHorizonStatusMessage,
     LGHorizonUnknownMessage,