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

lghorizon/__init__.py

@@ -1,6 +1,36 @@
 """Python client for LG Horizon."""
 
-from .lghorizon_api import LGHorizonApi
-from .lghorizon_device import LGHorizonDevice
-from .lghorizon_models import *
-from .exceptions import *
+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

lghorizon/{lghorizon_device_state_processor.py → device_state_processor.py}

@@ -6,9 +6,9 @@ import urllib.parse
 
 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,
@@ -16,20 +16,20 @@ from .lghorizon_models import (
     LGHorizonNDVRSource,
     LGHorizonReviewBufferSource,
 )
-from .lghorizon_models import LGHorizonAuth
-from .lghorizon_models import (
+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:

lghorizon/{lghorizon_api.py → lghorizonapi.py}

@@ -3,21 +3,21 @@
 import logging
 from typing import Any, Dict, cast
 
-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
+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__)
@@ -190,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"
         )

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,

lghorizon/{lghorizon_recording_factory.py → recording_factory.py}

@@ -1,4 +1,4 @@
-from .lghorizon_models import (
+from .models.lghorizon_recordings import (
     LGHorizonRecordingList,
     LGHorizonRecordingSingle,
     LGHorizonRecordingSeason,

{lghorizon-0.9.0b0.dist-info → lghorizon-0.9.0.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lghorizon
-Version: 0.9.0b0
+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

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):
-    """Generic LGHorizon exception."""
-
-
-class LGHorizonApiUnauthorizedError(Exception):
-    """Generic LGHorizon exception."""
-
-
-class LGHorizonApiLockedError(LGHorizonApiUnauthorizedError):
-    """Generic LGHorizon exception."""

lghorizon/lghorizon_device.py

@@ -1,336 +0,0 @@
-"""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))