lghorizon 0.9.0b0__tar.gz → 0.9.0.dev1__tar.gz

{lghorizon-0.9.0b0 → lghorizon-0.9.0.dev1}/PKG-INFO

@@ -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/lghorizon/__init__.py

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

lghorizon-0.9.0b0/lghorizon/lghorizon_device_state_processor.py → lghorizon-0.9.0.dev1/lghorizon/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-0.9.0b0/lghorizon/lghorizon_api.py → lghorizon-0.9.0.dev1/lghorizon/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-0.9.0b0/lghorizon/lghorizon_message_factory.py → lghorizon-0.9.0.dev1/lghorizon/message_factory.py

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

lghorizon-0.9.0.dev1/lghorizon/models/__init__.py

@@ -0,0 +1,12 @@
+"""Models for LG Horizon."""
+
+from .lghorizon_auth import LGHorizonAuth
+from .lghorizon_config import LGHorizonServicesConfig
+from .lghorizon_message import LGHorizonMessage, LGHorizonStatusMessage
+
+__all__ = [
+    "LGHorizonAuth",
+    "LGHorizonServicesConfig",
+    "LGHorizonMessage",
+    "LGHorizonStatusMessage",
+]

lghorizon-0.9.0.dev1/lghorizon/models/lghorizon_auth.py

@@ -0,0 +1,227 @@
+"""LG Horizon Auth Model."""
+
+import time
+import logging
+import json
+from typing import Any, Optional
+
+import backoff
+from aiohttp import ClientResponseError, ClientSession
+
+from ..const import COUNTRY_SETTINGS
+from .exceptions import LGHorizonApiConnectionError, LGHorizonApiUnauthorizedError
+from .lghorizon_config import LGHorizonServicesConfig
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class LGHorizonAuth:
+    """Class to make authenticated requests."""
+
+    _websession: ClientSession
+    _refresh_token: str
+    _access_token: Optional[str]
+    _username: str
+    _password: str
+    _household_id: str
+    _token_expiry: Optional[int]
+    _country_code: str
+    _host: str
+    _use_refresh_token: bool
+
+    def __init__(
+        self,
+        websession: ClientSession,
+        country_code: str,
+        refresh_token: str = "",
+        username: str = "",
+        password: str = "",
+    ) -> None:
+        """Initialize the auth with refresh token."""
+        self._websession = websession
+        self._refresh_token = refresh_token
+        self._access_token = None
+        self._username = username
+        self._password = password
+        self._household_id = ""
+        self._token_expiry = None
+        self._country_code = country_code
+        self._host = COUNTRY_SETTINGS[country_code]["api_url"]
+        self._use_refresh_token = COUNTRY_SETTINGS[country_code]["use_refreshtoken"]
+        self._service_config = None
+
+    @property
+    def websession(self) -> ClientSession:
+        """Return the aiohttp client session."""
+        return self._websession
+
+    @property
+    def refresh_token(self) -> str:
+        """Return the refresh token."""
+        return self._refresh_token
+
+    @refresh_token.setter
+    def refresh_token(self, value: str) -> None:
+        """Set the refresh token."""
+        self._refresh_token = value
+
+    @property
+    def access_token(self) -> Optional[str]:
+        """Return the access token."""
+        return self._access_token
+
+    @access_token.setter
+    def access_token(self, value: Optional[str]) -> None:
+        """Set the access token."""
+        self._access_token = value
+
+    @property
+    def username(self) -> str:
+        """Return the username."""
+        return self._username
+
+    @username.setter
+    def username(self, value: str) -> None:
+        """Set the username."""
+        self._username = value
+
+    @property
+    def password(self) -> str:
+        """Return the password."""
+        return self._password
+
+    @password.setter
+    def password(self, value: str) -> None:
+        """Set the password."""
+        self._password = value
+
+    @property
+    def household_id(self) -> str:
+        """Return the household ID."""
+        return self._household_id
+
+    @household_id.setter
+    def household_id(self, value: str) -> None:
+        """Set the household ID."""
+        self._household_id = value
+
+    @property
+    def token_expiry(self) -> Optional[int]:
+        """Return the token expiry timestamp."""
+        return self._token_expiry
+
+    @token_expiry.setter
+    def token_expiry(self, value: Optional[int]) -> None:
+        """Set the token expiry timestamp."""
+        self._token_expiry = value
+
+    @property
+    def country_code(self) -> str:
+        """Return the country code."""
+        return self._country_code
+
+    async def is_token_expiring(self) -> bool:
+        """Check if the token is expiring within one day."""
+        if not self.access_token or not self.token_expiry:
+            return True
+        current_unix_time = int(time.time())
+        return current_unix_time >= (self.token_expiry - 86400)
+
+    async def fetch_access_token(self) -> None:
+        """Fetch the access token."""
+        _LOGGER.debug("Fetching access token")
+        headers = dict()
+        headers["content-type"] = "application/json"
+        headers["charset"] = "utf-8"
+
+        if not self._use_refresh_token and self.access_token is None:
+            payload = {"password": self.password, "username": self.username}
+            headers["x-device-code"] = "web"
+            auth_url_path = "/auth-service/v1/authorization"
+        else:
+            payload = {"refreshToken": self.refresh_token}
+            auth_url_path = "/auth-service/v1/authorization/refresh"
+        try:  # Use properties and backing fields
+            auth_response = await self.websession.post(
+                f"{self._host}{auth_url_path}",
+                json=payload,
+                headers=headers,
+            )
+        except Exception as ex:
+            raise LGHorizonApiConnectionError from ex
+        auth_json = await auth_response.json()
+        if not auth_response.ok:
+            error = None
+            if "error" in auth_json:
+                error = auth_json["error"]
+            if error and error["statusCode"] == 97401:
+                raise LGHorizonApiUnauthorizedError("Invalid credentials")
+            elif error:
+                raise LGHorizonApiConnectionError(error["message"])
+            else:
+                raise LGHorizonApiConnectionError("Unknown connection error")
+
+        self.household_id = auth_json["householdId"]
+        self.access_token = auth_json["accessToken"]
+        self.refresh_token = auth_json["refreshToken"]
+        self.username = auth_json["username"]
+        self.token_expiry = auth_json["refreshTokenExpiry"]
+
+    @backoff.on_exception(backoff.expo, LGHorizonApiConnectionError, max_tries=3)
+    async def request(self, host: str, path: str, params=None, **kwargs) -> Any:
+        """Make a request."""
+        if headers := kwargs.pop("headers", {}):
+            headers = dict(headers)
+        request_url = f"{host}{path}"
+        if await self.is_token_expiring():  # Use property
+            _LOGGER.debug("Access token is expiring, fetching a new one")
+            await self.fetch_access_token()
+        try:
+            web_response = await self.websession.request(
+                "GET", request_url, **kwargs, headers=headers, params=params
+            )
+            web_response.raise_for_status()
+            json_response = await web_response.json()
+            _LOGGER.debug(
+                "Response from %s:\n %s",
+                request_url,
+                json.dumps(json_response, indent=2),
+            )
+            return json_response
+        except ClientResponseError as cre:
+            _LOGGER.error("Error response from %s: %s", request_url, str(cre))
+            if cre.status == 401:
+                await self.fetch_access_token()
+            raise LGHorizonApiConnectionError(
+                f"Unable to call {request_url}. Error:{str(cre)}"
+            ) from cre
+
+        except Exception as ex:
+            _LOGGER.error("Error calling %s: %s", request_url, str(ex))
+            raise LGHorizonApiConnectionError(
+                f"Unable to call {request_url}. Error:{str(ex)}"
+            ) from ex
+
+    async def get_mqtt_token(self) -> Any:
+        """Get the MQTT token."""
+        _LOGGER.debug("Fetching MQTT token")
+        config = await self.get_service_config()
+        service_url = await config.get_service_url("authorizationService")
+        result = await self.request(
+            service_url,
+            "/v1/mqtt/token",
+        )
+        return result["token"]
+
+    async def get_service_config(self):
+        """Get the service configuration."""
+        _LOGGER.debug("Fetching service configuration")
+        if self._service_config is None:  # Use property and backing field
+            base_country_code = self.country_code[0:2]
+            result = await self.request(
+                self._host,
+                f"/{base_country_code}/en/config-service/conf/web/backoffice.json",
+            )
+            self._service_config = LGHorizonServicesConfig(result)
+
+        return self._service_config

lghorizon-0.9.0.dev1/lghorizon/models/lghorizon_channel.py

@@ -0,0 +1,53 @@
+"""LG Horizon Channel model."""
+
+
+class LGHorizonChannel:
+    """Class to represent a channel."""
+
+    def __init__(self, channel_json):
+        """Initialize a channel."""
+        self.channel_json = channel_json
+
+    @property
+    def id(self) -> str:
+        """Returns the id."""
+        return self.channel_json["id"]
+
+    @property
+    def channel_number(self) -> str:
+        """Returns the channel number."""
+        return self.channel_json["logicalChannelNumber"]
+
+    @property
+    def is_radio(self) -> bool:
+        """Returns if the channel is a radio channel."""
+        return self.channel_json.get("isRadio", False)
+
+    @property
+    def title(self) -> str:
+        """Returns the title."""
+        return self.channel_json["name"]
+
+    @property
+    def logo_image(self) -> str:
+        """Returns the logo image."""
+        if "logo" in self.channel_json and "focused" in self.channel_json["logo"]:
+            return self.channel_json["logo"]["focused"]
+        return ""
+
+    @property
+    def linear_products(self) -> list[str]:
+        """Returns the linear products."""
+        return self.channel_json.get("linearProducts", [])
+
+    @property
+    def stream_image(self) -> str:
+        """Returns the stream image."""
+        image_stream = self.channel_json["imageStream"]
+        if "full" in image_stream:
+            return image_stream["full"]
+        if "small" in image_stream:
+            return image_stream["small"]
+        if "logo" in self.channel_json and "focused" in self.channel_json["logo"]:
+            return self.channel_json["logo"]["focused"]
+        return ""

lghorizon-0.9.0.dev1/lghorizon/models/lghorizon_config.py

@@ -0,0 +1,65 @@
+"""Configuration handler for LG Horizon services."""
+
+from typing import Any, Optional
+
+
+class LGHorizonServicesConfig:
+    """Handle LG Horizon configuration and service URLs."""
+
+    def __init__(self, config_data: dict[str, Any]) -> None:
+        """Initialize LG Horizon config.
+
+        Args:
+            config_data: Configuration dictionary with service endpoints
+        """
+        self._config = config_data
+
+    async def get_service_url(self, service_name: str) -> str:
+        """Get the URL for a specific service.
+
+        Args:
+            service_name: Name of the service (e.g., 'authService', 'recordingService')
+
+        Returns:
+            URL for the service
+
+        Raises:
+            ValueError: If the service or its URL is not found
+        """
+        if service_name in self._config and "URL" in self._config[service_name]:
+            return self._config[service_name]["URL"]
+        raise ValueError(f"Service URL for '{service_name}' not found in configuration")
+
+    async def get_all_services(self) -> dict[str, str]:
+        """Get all available services and their URLs.
+
+        Returns:
+            Dictionary mapping service names to URLs
+        """
+        return {
+            name: url
+            for name, service in self._config.items()
+            if isinstance(service, dict) and (url := service.get("URL"))
+        }
+
+    async def __getattr__(self, name: str) -> Optional[str]:
+        """Access service URLs as attributes.
+
+        Example: config.authService returns the auth service URL
+
+        Args:
+            name: Service name
+
+        Returns:
+            URL for the service or None if not found
+        """
+        if name.startswith("_"):
+            raise AttributeError(
+                f"'{type(self).__name__}' object has no attribute '{name}'"
+            )
+        return await self.get_service_url(name)
+
+    def __repr__(self) -> str:
+        """Return string representation."""
+        services = list(self._config.keys())
+        return f"LGHorizonConfig({len(services)} services)"

lghorizon-0.9.0.dev1/lghorizon/models/lghorizon_customer.py

@@ -0,0 +1,55 @@
+"""LGHorizon customer model."""
+
+from typing import Dict
+from .lghorizon_profile import LGHorizonProfile
+
+
+class LGHorizonCustomer:
+    """LGHorizon customer."""
+
+    _profiles: Dict[str, LGHorizonProfile] = {}
+
+    def __init__(self, json_payload: dict):
+        """Initialize a customer."""
+        self._json_payload = json_payload
+
+    @property
+    def customer_id(self) -> str:
+        """Return the customer id."""
+        return self._json_payload["customerId"]
+
+    @property
+    def hashed_customer_id(self) -> str:
+        """Return the hashed customer id."""
+        return self._json_payload["hashedCustomerId"]
+
+    @property
+    def country_id(self) -> str:
+        """Return the country id."""
+        return self._json_payload["countryId"]
+
+    @property
+    def city_id(self) -> int:
+        """Return the city id."""
+        return self._json_payload["cityId"]
+
+    @property
+    def assigned_devices(self) -> list[str]:
+        """Return the assigned set-top boxes."""
+        return self._json_payload.get("assignedDevices", [])
+
+    @property
+    def profiles(self) -> Dict[str, LGHorizonProfile]:
+        """Return the profiles."""
+        if not self._profiles or self._profiles == {}:
+            self._profiles = {
+                p["profileId"]: LGHorizonProfile(p)
+                for p in self._json_payload.get("profiles", [])
+            }
+        return self._profiles
+
+    async def get_profile_lang(self, profile_id: str) -> str:
+        """Return the profile language."""
+        if profile_id not in self.profiles:
+            return "nl"
+        return self.profiles[profile_id].options.lang

{lghorizon-0.9.0b0/lghorizon → lghorizon-0.9.0.dev1/lghorizon/models}/lghorizon_device.py

@@ -1,38 +1,44 @@
-"""LG Horizon Device."""
-
-from __future__ import annotations
+"""LG Horizon device (set-top box) model."""
 
 import json
 import logging
-from typing import Any, Callable, Coroutine, Dict, Optional
-from .lghorizon_models import (
-    LGHorizonRunningState,
-    LGHorizonStatusMessage,
-    LGHorizonUIStatusMessage,
-    LGHorizonDeviceState,
-    LGHorizonAuth,
-    LGHorizonChannel,
-)
+from typing import Callable, Dict, Optional, Any, Coroutine
 
-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,
+
+from ..const import (
+    ONLINE_RUNNING,
+    MEDIA_KEY_POWER,
+    MEDIA_KEY_PLAY_PAUSE,
+    MEDIA_KEY_STOP,
     MEDIA_KEY_CHANNEL_UP,
+    MEDIA_KEY_CHANNEL_DOWN,
     MEDIA_KEY_ENTER,
+    MEDIA_KEY_REWIND,
     MEDIA_KEY_FAST_FORWARD,
-    MEDIA_KEY_PLAY_PAUSE,
-    MEDIA_KEY_POWER,
     MEDIA_KEY_RECORD,
-    MEDIA_KEY_REWIND,
-    MEDIA_KEY_STOP,
-    ONLINE_RUNNING,
     PLATFORM_TYPES,
 )
+from ..helpers import make_id
+from .lghorizon_auth import LGHorizonAuth
+from .lghorizon_channel import LGHorizonChannel
+from .lghorizon_mqtt_client import LGHorizonMqttClient  # Added import for type checking
+from .lghorizon_device_state import LGHorizonDeviceState, LGHorizonRunningState
+from .exceptions import LGHorizonApiConnectionError
+from .lghorizon_message import LGHorizonStatusMessage, LGHorizonUIStatusMessage
+
+from ..device_state_processor import LGHorizonDeviceStateProcessor
+
+# Assuming these models are available from legacy or will be moved to models/
+# from ..legacy.models import (
+#     # LGHorizonPlayingInfo,
+#     # LGHorizonPlayerState, # This is now in lghorizon_ui_status.py
+#     # LGHorizonReplayEvent,
+#     # LGHorizonRecordingSingle,
+#     # LGHorizonVod,
+#     # LGHorizonApp,
+# )
 
-_LOGGER = logging.getLogger(__name__)
+_logger = logging.getLogger(__name__)
 
 
 class LGHorizonDevice:
@@ -201,7 +207,7 @@ class LGHorizonDevice:
 
     async def _trigger_callback(self):
         if self._change_callback:
-            _LOGGER.debug("Callback called from box %s", self.device_id)
+            _logger.debug("Callback called from box %s", self.device_id)
             await self._change_callback(self.device_id)
 
     async def turn_on(self) -> None: