lghorizon 0.9.0b0__tar.gz → 0.9.0.dev4__tar.gz

{lghorizon-0.9.0b0 → lghorizon-0.9.0.dev4}/.gitignore

@@ -24,4 +24,3 @@ __pycache__/*
 test/nl.py
 secrets.json
 logfile.log
-lghorizon.log

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lghorizon
-Version: 0.9.0b0
+Version: 0.9.0.dev4
 Summary: Python client for Liberty Global Horizon settop boxes
 Home-page: https://github.com/sholofly/LGHorizon-python
 Author: Rudolf Offereins

lghorizon-0.9.0.dev4/lghorizon/__init__.py

@@ -0,0 +1,41 @@
+"""Python client for LG Horizon."""
+
+from .lghorizon_api import LGHorizonApi
+from .models import (
+    LGHorizonBox,
+    LGHorizonRecordingListSeasonShow,
+    LGHorizonRecordingSingle,
+    LGHorizonRecordingShow,
+    LGHorizonRecordingEpisode,
+    LGHorizonCustomer,
+)
+from .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-0.9.0.dev4}/lghorizon/const.py

@@ -38,18 +38,11 @@ RECORDING_TYPE_SEASON = "season"
 
 BE_AUTH_URL = "https://login.prd.telenet.be/openid/login.do"
 
-PLATFORM_TYPES = {
-    "EOS": {"manufacturer": "Arris", "model": "DCX960"},
-    "EOS2": {"manufacturer": "HUMAX", "model": "2008C-STB-TN"},
-    "HORIZON": {"manufacturer": "Arris", "model": "DCX960"},
-    "APOLLO": {"manufacturer": "Arris", "model": "VIP5002W"},
-}
-
 COUNTRY_SETTINGS = {
     "nl": {
         "api_url": "https://spark-prod-nl.gnp.cloud.ziggogo.tv",
         "mqtt_url": "obomsg.prod.nl.horizon.tv",
-        "use_refreshtoken": False,
+        "use_oauth": False,
         "channels": [
             {
                 "channelId": "NL_000073_019506",
@@ -113,7 +106,7 @@ COUNTRY_SETTINGS = {
     },
     "be-nl-preprod": {
         "api_url": "https://spark-preprod-be.gnp.cloud.telenet.tv",
-        "use_refreshtoken": True,
+        "use_oauth": True,
         "oauth_username_fieldname": "j_username",
         "oauth_password_fieldname": "j_password",
         "oauth_add_accept_header": False,
@@ -138,13 +131,13 @@ COUNTRY_SETTINGS = {
     },
     "ie": {
         "api_url": "https://spark-prod-ie.gnp.cloud.virginmediatv.ie",
-        "use_refreshtoken": False,
+        "use_oauth": False,
         "channels": [],
         "language": "en",
     },
     "pl": {
         "api_url": "https://spark-prod-pl.gnp.cloud.upctv.pl",
-        "use_refreshtoken": False,
+        "use_oauth": False,
         "channels": [],
         "language": "pl",
         "platform_types": {

{lghorizon-0.9.0b0 → lghorizon-0.9.0.dev4}/lghorizon/helpers.py

@@ -3,7 +3,7 @@
 import random
 
 
-async def make_id(string_length=10):
+def make_id(string_length=10):
     """Create an id with given length."""
     letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
     return "".join(random.choice(letters) for i in range(string_length))

{lghorizon-0.9.0b0/lghorizon/legacy → lghorizon-0.9.0.dev4/lghorizon}/lghorizon_api.py

@@ -167,6 +167,76 @@ class LGHorizonApi:
         """Set the refresh callback."""
         self._refresh_callback = refresh_callback
 
+    def _authorize_telenet(self):
+        """Authorize telenet users."""
+        try:
+            login_session = Session()
+            # Step 1 - Get Authorization data
+            _logger.debug("Step 1 - Get Authorization data")
+            auth_url = (
+                f"{self._country_settings['api_url']}/auth-service/v1/sso/authorization"
+            )
+            auth_response = login_session.get(auth_url)
+            if not auth_response.ok:
+                raise LGHorizonApiConnectionError("Can't connect to authorization URL")
+            auth_response_json = auth_response.json()
+            authorization_uri = auth_response_json["authorizationUri"]
+            authorization_validity_token = auth_response_json["validityToken"]
+
+            # Step 2 - Get Authorization cookie
+            _logger.debug("Step 2 - Get Authorization cookie")
+
+            auth_cookie_response = login_session.get(authorization_uri)
+            if not auth_cookie_response.ok:
+                raise LGHorizonApiConnectionError("Can't connect to authorization URL")
+
+            _logger.debug("Step 3 - Login")
+
+            username_fieldname = self._country_settings["oauth_username_fieldname"]
+            pasword_fieldname = self._country_settings["oauth_password_fieldname"]
+
+            payload = {
+                username_fieldname: self.username,
+                pasword_fieldname: self.password,
+                "rememberme": "true",
+            }
+
+            login_response = login_session.post(
+                self._country_settings["oauth_url"], payload, allow_redirects=False
+            )
+            if not login_response.ok:
+                raise LGHorizonApiConnectionError("Can't connect to authorization URL")
+            redirect_url = login_response.headers[
+                self._country_settings["oauth_redirect_header"]
+            ]
+
+            if self._identifier is not None:
+                redirect_url += f"&dtv_identifier={self._identifier}"
+            redirect_response = login_session.get(redirect_url, allow_redirects=False)
+            success_url = redirect_response.headers[
+                self._country_settings["oauth_redirect_header"]
+            ]
+            code_matches = re.findall(r"code=(.*)&", success_url)
+
+            authorization_code = code_matches[0]
+
+            new_payload = {
+                "authorizationGrant": {
+                    "authorizationCode": authorization_code,
+                    "validityToken": authorization_validity_token,
+                }
+            }
+            headers = {
+                "content-type": "application/json",
+            }
+            post_result = login_session.post(
+                auth_url, json.dumps(new_payload), headers=headers
+            )
+            self._auth.fill(post_result.json())
+            self._session.cookies["ACCESSTOKEN"] = self._auth.access_token
+        except Exception:
+            pass
+
     def _obtain_mqtt_token(self):
         _logger.debug("Obtain mqtt token...")
         mqtt_auth_url = self._config["authorizationService"]["URL"]

{lghorizon-0.9.0b0/lghorizon/legacy → lghorizon-0.9.0.dev4/lghorizon}/models.py

@@ -703,14 +703,14 @@ class LGHorizonBox:
             f"{self._auth.household_id}/{self.device_id}", payload
         )
 
-    # def _set_unknown_channel_info(self) -> None:
-    #     """Set unknown channel info."""
-    #     _logger.warning("Couldn't set channel. Channel info set to unknown...")
-    #     self.playing_info.set_source_type(BOX_PLAY_STATE_CHANNEL)
-    #     self.playing_info.set_channel(None)
-    #     self.playing_info.set_title("No information available")
-    #     self.playing_info.set_image(None)
-    #     self.playing_info.set_paused(False)
+    def _set_unknown_channel_info(self) -> None:
+        """Set unknown channel info."""
+        _logger.warning("Couldn't set channel. Channel info set to unknown...")
+        self.playing_info.set_source_type(BOX_PLAY_STATE_CHANNEL)
+        self.playing_info.set_channel(None)
+        self.playing_info.set_title("No information available")
+        self.playing_info.set_image(None)
+        self.playing_info.set_paused(False)
 
     def _request_settop_box_state(self) -> None:
         """Send mqtt message to receive state from settop box."""

{lghorizon-0.9.0b0 → lghorizon-0.9.0.dev4}/lghorizon.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lghorizon
-Version: 0.9.0b0
+Version: 0.9.0.dev4
 Summary: Python client for Liberty Global Horizon settop boxes
 Home-page: https://github.com/sholofly/LGHorizon-python
 Author: Rudolf Offereins

{lghorizon-0.9.0b0 → lghorizon-0.9.0.dev4}/lghorizon.egg-info/SOURCES.txt

@@ -5,31 +5,23 @@ LICENSE
 README.md
 instructions.txt
 lib64
-main.py
 pyvenv.cfg
 renovate.json
 secrets_stub.json
 setup.py
+test.py
 .github/workflows/build-on-pr.yml
 .github/workflows/publish-to-pypi.yml
-.vscode/launch.json
 lghorizon/__init__.py
 lghorizon/const.py
 lghorizon/exceptions.py
 lghorizon/helpers.py
 lghorizon/lghorizon_api.py
-lghorizon/lghorizon_device.py
-lghorizon/lghorizon_device_state_processor.py
-lghorizon/lghorizon_message_factory.py
-lghorizon/lghorizon_models.py
-lghorizon/lghorizon_mqtt_client.py
-lghorizon/lghorizon_recording_factory.py
+lghorizon/models.py
 lghorizon/py.typed
 lghorizon.egg-info/PKG-INFO
 lghorizon.egg-info/SOURCES.txt
 lghorizon.egg-info/dependency_links.txt
 lghorizon.egg-info/not-zip-safe
 lghorizon.egg-info/requires.txt
-lghorizon.egg-info/top_level.txt
-lghorizon/legacy/lghorizon_api.py
-lghorizon/legacy/models.py
+lghorizon.egg-info/top_level.txt

lghorizon-0.9.0.dev4/test.py

@@ -0,0 +1,84 @@
+""" "Test the component."""
+
+import json
+import logging
+import time
+from lghorizon import LGHorizonApi
+
+api: LGHorizonApi
+
+logging.basicConfig(
+    level=logging.DEBUG,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+)
+
+_Logger = logging.getLogger()
+
+file_handler = logging.FileHandler("logfile.log", mode="w")
+file_handler.setLevel(logging.DEBUG)
+_Logger.addHandler(file_handler)
+
+console_handler = logging.StreamHandler()
+console_handler.setLevel(logging.DEBUG)
+_Logger.addHandler(console_handler)
+
+secrets: dict[str, str] = None
+
+
+def read_secrets(file_path):
+    """Read secrets from file."""
+    try:
+        with open(file_path, "r", encoding="UTF-8") as file:
+            return json.load(file)
+    except FileNotFoundError:
+        print(f"Error: Secrets file not found at {file_path}")
+        return {}
+    except json.JSONDecodeError:
+        print(f"Error: Unable to decode JSON in {file_path}")
+        return {}
+
+
+def event_loop():
+    """Default event loop."""
+    while True:
+        time.sleep(1)  # Simulate some work
+
+        # Check for a breaking condition
+        if break_condition():
+            break
+
+
+def break_condition():
+    """Break event loop on conditions."""
+    # Implement your breaking condition logic here
+    return False  # Change this condition based on your requirements
+
+
+if __name__ == "__main__":
+    try:
+        secrets = read_secrets("secrets.json")
+
+        refresh_token: str = None
+        if "refresh_token" in secrets:
+            refresh_token = secrets["refresh_token"]
+
+        profile_id: str = None
+        if "profile_id" in secrets:
+            profile_id = secrets["profile_id"]
+
+        api = LGHorizonApi(
+            secrets["username"],
+            secrets["password"],
+            secrets["country"],
+            # identifier="DTV3907048",
+            refresh_token=refresh_token,
+            profile_id=profile_id,
+        )
+        api.connect()
+        event_loop()
+    except KeyboardInterrupt:
+        print("\nScript interrupted by user.")
+    finally:
+        print("Script is exiting.")
+        if api:
+            api.disconnect()

lghorizon-0.9.0b0/.vscode/launch.json

@@ -1,15 +0,0 @@
-{
-  // Use IntelliSense to learn about possible attributes.
-  // Hover to view descriptions of existing attributes.
-  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
-  "version": "0.2.0",
-  "configurations": [
-    {
-      "name": "Python Debugger: Debug LGHorizon",
-      "type": "debugpy",
-      "request": "launch",
-      "program": "main.py",
-      "console": "integratedTerminal"
-    }
-  ]
-}

lghorizon-0.9.0b0/lghorizon/__init__.py

@@ -1,6 +0,0 @@
-"""Python client for LG Horizon."""
-
-from .lghorizon_api import LGHorizonApi
-from .lghorizon_device import LGHorizonDevice
-from .lghorizon_models import *
-from .exceptions import *

lghorizon-0.9.0b0/lghorizon/lghorizon_api.py

@@ -1,270 +0,0 @@
-"""LG Horizon API client."""
-
-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
-
-
-_LOGGER = logging.getLogger(__name__)
-
-
-class LGHorizonApi:
-    """LG Horizon API client."""
-
-    _mqtt_client: LGHorizonMqttClient
-    auth: LGHorizonAuth
-    _service_config: LGHorizonServicesConfig
-    _customer: LGHorizonCustomer
-    _channels: Dict[str, LGHorizonChannel]
-    _entitlements: LGHorizonEntitlements
-    _profile_id: str
-    _initialized: bool = False
-    _devices: Dict[str, LGHorizonDevice] = {}
-    _message_factory: LGHorizonMessageFactory = LGHorizonMessageFactory()
-    _device_state_processor: LGHorizonDeviceStateProcessor | None
-    _recording_factory: LGHorizonRecordingFactory = LGHorizonRecordingFactory()
-
-    def __init__(self, auth: LGHorizonAuth, profile_id: str = "") -> None:
-        """Initialize LG Horizon API client."""
-        self.auth = auth
-        self._profile_id = profile_id
-        self._channels = {}
-        self._device_state_processor = None
-
-    async def initialize(self) -> None:
-        """Initialize the API client."""
-        self._service_config = await self.auth.get_service_config()
-        self._customer = await self._get_customer_info()
-        if self._profile_id == "":
-            self._profile_id = list(self._customer.profiles.keys())[0]
-        await self._refresh_entitlements()
-        await self._refresh_channels()
-        self._mqtt_client = await self._create_mqtt_client()
-        await self._mqtt_client.connect()
-        await self._register_devices()
-        self._device_state_processor = LGHorizonDeviceStateProcessor(
-            self.auth, self._channels, self._customer, self._profile_id
-        )
-        self._initialized = True
-
-    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]:
-        """Get profile IDs."""
-        if not self._initialized:
-            raise RuntimeError("LGHorizonApi not initialized")
-
-        return self._customer.profiles
-
-    async def get_profile_channels(
-        self, profile_id: str
-    ) -> Dict[str, LGHorizonChannel]:
-        """Returns channels to display baed on profile."""
-        # Attempt to retrieve the profile by the given 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 not profile and self._customer.profiles:
-            _LOGGER.debug(
-                "Profile with ID '%s' not found. Defaulting to first available profile.",
-                profile_id,
-            )
-            profile = list(self._customer.profiles.values())[0]
-
-        # If a profile is found and it has favorite channels, filter the main channels list.
-        if profile and profile.favorite_channels:
-            _LOGGER.debug("Returning favorite channels for profile '%s'.", profile.name)
-            # Use a set for faster lookup of favorite channel IDs
-            profile_channel_ids = set(profile.favorite_channels)
-            return {
-                channel.id: channel
-                for channel in self._channels.values()
-                if channel.id in profile_channel_ids
-            }
-
-        # If no profile is found (even after defaulting) or the profile has no favorite channels,
-        # return all available channels.
-        _LOGGER.debug("No specific profile channels found, returning all channels.")
-        return self._channels
-
-    async def _register_devices(self) -> None:
-        """Register devices."""
-        _LOGGER.debug("Registering devices...")
-        self._devices = {}
-        channels = await self.get_profile_channels(self._profile_id)
-        for raw_box in self._customer.assigned_devices:
-            _LOGGER.debug("Creating box for device: %s", raw_box)
-            if self._device_state_processor is None:
-                self._device_state_processor = LGHorizonDeviceStateProcessor(
-                    self.auth, self._channels, self._customer, self._profile_id
-                )
-            device = LGHorizonDevice(
-                raw_box,
-                self._mqtt_client,
-                self._device_state_processor,
-                self.auth,
-                channels,
-            )
-            self._devices[device.device_id] = device
-
-    async def disconnect(self) -> None:
-        """Disconnect the client."""
-        if self._mqtt_client:
-            await self._mqtt_client.disconnect()
-        self._initialized = False
-
-    async def _create_mqtt_client(self) -> LGHorizonMqttClient:
-        mqtt_client = await LGHorizonMqttClient.create(
-            self.auth,
-            self._on_mqtt_connected,
-            self._on_mqtt_message,
-        )
-        return mqtt_client
-
-    async def _on_mqtt_connected(self):
-        """MQTT connected callback."""
-        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
-        )
-        await self._mqtt_client.subscribe(self.auth.household_id + "/+/status")
-        await self._mqtt_client.subscribe(
-            self.auth.household_id + "/+/networkRecordings"
-        )
-        await self._mqtt_client.subscribe(
-            self.auth.household_id + "/+/networkRecordings/capacity"
-        )
-        await self._mqtt_client.subscribe(self.auth.household_id + "/+/localRecordings")
-        await self._mqtt_client.subscribe(
-            self.auth.household_id + "/+/localRecordings/capacity"
-        )
-        await self._mqtt_client.subscribe(self.auth.household_id + "/watchlistService")
-        await self._mqtt_client.subscribe(self.auth.household_id + "/purchaseService")
-        await self._mqtt_client.subscribe(
-            self.auth.household_id + "/personalizationService"
-        )
-        await self._mqtt_client.subscribe(self.auth.household_id + "/recordingStatus")
-        await self._mqtt_client.subscribe(
-            self.auth.household_id + "/recordingStatus/lastUserAction"
-        )
-
-    async def _on_mqtt_message(self, mqtt_message: dict, mqtt_topic: str):
-        """MQTT message callback."""
-        message = await self._message_factory.create_message(mqtt_topic, mqtt_message)
-        match message.message_type:
-            case LGHorizonMessageType.STATUS:
-                message.__class__ = LGHorizonStatusMessage
-                status_message = cast(LGHorizonStatusMessage, message)
-                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[ui_status_message.source]
-                if (
-                    not device.device_state.state
-                    == LGHorizonRunningState.ONLINE_RUNNING
-                ):
-                    return
-                await device.handle_ui_status_message(ui_status_message)
-
-    async def _get_customer_info(self) -> LGHorizonCustomer:
-        service_url = await self._service_config.get_service_url(
-            "personalizationService"
-        )
-        result = await self.auth.request(
-            service_url,
-            f"/v1/customer/{self.auth.household_id}?with=profiles%2Cdevices",
-        )
-        return LGHorizonCustomer(result)
-
-    async def _refresh_entitlements(self) -> Any:
-        """Retrieve entitlements."""
-        _LOGGER.debug("Retrieving entitlements...")
-        service_url = await self._service_config.get_service_url("purchaseService")
-        result = await self.auth.request(
-            service_url,
-            f"/v2/customers/{self.auth.household_id}/entitlements?enableDaypass=true",
-        )
-        self._entitlements = LGHorizonEntitlements(result)
-
-    async def _refresh_channels(self):
-        """Retrieve channels."""
-        _LOGGER.debug("Retrieving channels...")
-        service_url = await self._service_config.get_service_url("linearService")
-        lang = await self._customer.get_profile_lang(self._profile_id)
-        channels_json = await self.auth.request(
-            service_url,
-            f"/v2/channels?cityId={self._customer.city_id}&language={lang}&productClass=Orion-DASH",
-        )
-        for channel_json in channels_json:
-            channel = LGHorizonChannel(channel_json)
-            common_entitlements = list(
-                set(self._entitlements.entitlement_ids) & set(channel.linear_products)
-            )
-
-            if len(common_entitlements) == 0:
-                continue
-
-            self._channels[channel.id] = channel
-
-    async def get_all_recordings(self) -> LGHorizonRecordingList:
-        """Retrieve all recordings."""
-        _LOGGER.debug("Retrieving recordings...")
-        service_url = await self._service_config.get_service_url("recordingService")
-        lang = await self._customer.get_profile_lang(self._profile_id)
-        recordings_json = await self.auth.request(
-            service_url,
-            f"/customers/{self.auth.household_id}/recordings?isAdult=false&offset=0&limit=100&sort=time&sortOrder=desc&profileId={self._profile_id}&language={lang}",
-        )
-        recordings = await self._recording_factory.create_recordings(recordings_json)
-        return recordings
-
-    async def get_show_recordings(
-        self, show_id: str, channel_id: str
-    ) -> 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/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
-
-    async def get_recording_quota(self) -> LGHorizonRecordingQuota:
-        """Refresh recording quota."""
-        _LOGGER.debug("Refreshing recording quota...")
-        service_url = await self._service_config.get_service_url("recordingService")
-        quota_json = await self.auth.request(
-            service_url,
-            f"/customers/{self.auth.household_id}/quota",
-        )
-        return LGHorizonRecordingQuota(quota_json)
-
-
-__all__ = ["LGHorizonApi", "LGHorizonAuth"]