pyhOn/pyhon/connection/api.py

322 lines
12 KiB
Python
Raw Normal View History

2023-02-13 01:41:38 +01:00
import json
import logging
from datetime import datetime
2023-06-25 17:29:04 +02:00
from pathlib import Path
2023-06-09 02:09:20 +02:00
from pprint import pformat
2023-06-28 19:02:11 +02:00
from types import TracebackType
from typing import Dict, Optional, Any, List, no_type_check, Type
2023-02-13 01:41:38 +01:00
2023-04-13 23:25:49 +02:00
from aiohttp import ClientSession
2023-04-15 23:02:37 +02:00
from typing_extensions import Self
2023-04-13 23:25:49 +02:00
from pyhon import const, exceptions
2023-04-09 18:13:50 +02:00
from pyhon.appliance import HonAppliance
2023-04-13 23:25:49 +02:00
from pyhon.connection.auth import HonAuth
2023-04-15 14:22:04 +02:00
from pyhon.connection.handler.anonym import HonAnonymousConnectionHandler
2023-04-15 23:02:37 +02:00
from pyhon.connection.handler.hon import HonConnectionHandler
2023-02-13 01:41:38 +01:00
2023-04-23 20:14:52 +02:00
_LOGGER = logging.getLogger(__name__)
2023-02-13 01:41:38 +01:00
2023-04-09 18:13:50 +02:00
class HonAPI:
2023-04-13 23:25:49 +02:00
def __init__(
self,
email: str = "",
password: str = "",
anonymous: bool = False,
session: Optional[ClientSession] = None,
) -> None:
2023-02-13 01:41:38 +01:00
super().__init__()
2023-04-13 23:25:49 +02:00
self._email: str = email
self._password: str = password
self._anonymous: bool = anonymous
self._hon_handler: Optional[HonConnectionHandler] = None
self._hon_anonymous_handler: Optional[HonAnonymousConnectionHandler] = None
self._session: Optional[ClientSession] = session
async def __aenter__(self) -> Self:
2023-04-09 20:50:28 +02:00
return await self.create()
2023-02-13 01:41:38 +01:00
2023-06-28 19:02:11 +02:00
async def __aexit__(
self,
exc_type: Optional[Type[BaseException]],
exc: Optional[BaseException],
traceback: Optional[TracebackType],
) -> None:
2023-04-10 06:34:19 +02:00
await self.close()
2023-02-13 01:41:38 +01:00
2023-04-13 23:25:49 +02:00
@property
def auth(self) -> HonAuth:
if self._hon is None or self._hon.auth is None:
raise exceptions.NoAuthenticationException
return self._hon.auth
@property
2023-06-28 19:02:11 +02:00
def _hon(self) -> HonConnectionHandler:
2023-04-13 23:25:49 +02:00
if self._hon_handler is None:
raise exceptions.NoAuthenticationException
return self._hon_handler
@property
2023-06-28 19:02:11 +02:00
def _hon_anonymous(self) -> HonAnonymousConnectionHandler:
2023-04-13 23:25:49 +02:00
if self._hon_anonymous_handler is None:
raise exceptions.NoAuthenticationException
return self._hon_anonymous_handler
async def create(self) -> Self:
self._hon_anonymous_handler = await HonAnonymousConnectionHandler(
2023-04-10 06:34:19 +02:00
self._session
).create()
2023-04-09 23:47:33 +02:00
if not self._anonymous:
2023-04-13 23:25:49 +02:00
self._hon_handler = await HonConnectionHandler(
2023-04-10 06:34:19 +02:00
self._email, self._password, self._session
).create()
2023-04-09 20:50:28 +02:00
return self
2023-02-13 01:41:38 +01:00
2023-06-25 17:29:04 +02:00
async def load_appliances(self) -> List[Dict[str, Any]]:
2023-04-09 18:13:50 +02:00
async with self._hon.get(f"{const.API_URL}/commands/v1/appliance") as resp:
2023-07-01 14:59:09 +02:00
result = await resp.json()
if result:
appliances: List[Dict[str, Any]] = result.get("payload", {}).get(
"appliances", {}
)
return appliances
2023-06-25 17:29:04 +02:00
return []
2023-04-09 20:50:28 +02:00
2023-06-25 17:29:04 +02:00
async def load_commands(self, appliance: HonAppliance) -> Dict[str, Any]:
2023-06-28 19:02:11 +02:00
params: Dict[str, str | int] = {
2023-04-09 20:50:28 +02:00
"applianceType": appliance.appliance_type,
"applianceModelId": appliance.appliance_model_id,
"macAddress": appliance.mac_address,
2023-02-13 01:41:38 +01:00
"os": const.OS,
"appVersion": const.APP_VERSION,
2023-05-20 13:24:24 +02:00
"code": appliance.code,
2023-02-13 01:41:38 +01:00
}
2023-04-23 14:40:39 +02:00
if firmware_id := appliance.info.get("eepromId"):
params["firmwareId"] = firmware_id
2023-04-23 19:28:56 +02:00
if firmware_version := appliance.info.get("fwVersion"):
params["fwVersion"] = firmware_version
2023-05-20 13:24:24 +02:00
if series := appliance.info.get("series"):
params["series"] = series
2023-04-13 23:25:49 +02:00
url: str = f"{const.API_URL}/commands/v1/retrieve"
2023-04-09 18:13:50 +02:00
async with self._hon.get(url, params=params) as response:
2023-06-28 19:02:11 +02:00
result: Dict[str, Any] = (await response.json()).get("payload", {})
2023-02-13 01:41:38 +01:00
if not result or result.pop("resultCode") != "0":
2023-05-20 13:24:24 +02:00
_LOGGER.error(await response.json())
2023-02-13 01:41:38 +01:00
return {}
return result
2023-06-25 17:29:04 +02:00
async def load_command_history(
self, appliance: HonAppliance
) -> List[Dict[str, Any]]:
2023-04-13 23:25:49 +02:00
url: str = (
f"{const.API_URL}/commands/v1/appliance/{appliance.mac_address}/history"
)
2023-04-09 18:13:50 +02:00
async with self._hon.get(url) as response:
2023-06-28 19:02:11 +02:00
result: Dict[str, Any] = await response.json()
2023-07-01 14:59:09 +02:00
if not result or not result.get("payload"):
return []
command_history: List[Dict[str, Any]] = result["payload"]["history"]
return command_history
2023-03-11 02:31:56 +01:00
2023-06-25 17:29:04 +02:00
async def load_favourites(self, appliance: HonAppliance) -> List[Dict[str, Any]]:
2023-05-14 23:04:36 +02:00
url: str = (
f"{const.API_URL}/commands/v1/appliance/{appliance.mac_address}/favourite"
)
async with self._hon.get(url) as response:
2023-06-28 19:02:11 +02:00
result: Dict[str, Any] = await response.json()
2023-07-01 14:59:09 +02:00
if not result or not result.get("payload"):
return []
favourites: List[Dict[str, Any]] = result["payload"]["favourites"]
return favourites
2023-05-14 23:04:36 +02:00
2023-06-25 17:29:04 +02:00
async def load_last_activity(self, appliance: HonAppliance) -> Dict[str, Any]:
2023-04-13 23:25:49 +02:00
url: str = f"{const.API_URL}/commands/v1/retrieve-last-activity"
2023-06-28 19:02:11 +02:00
params: Dict[str, str] = {"macAddress": appliance.mac_address}
2023-04-09 18:13:50 +02:00
async with self._hon.get(url, params=params) as response:
2023-06-28 19:02:11 +02:00
result: Dict[str, Any] = await response.json()
2023-07-01 14:59:09 +02:00
if result:
activity: Dict[str, Any] = result.get("attributes", "")
if activity:
return activity
2023-03-19 01:08:54 +01:00
return {}
2023-06-25 17:29:04 +02:00
async def load_appliance_data(self, appliance: HonAppliance) -> Dict[str, Any]:
2023-05-06 16:07:28 +02:00
url: str = f"{const.API_URL}/commands/v1/appliance-model"
2023-06-28 19:02:11 +02:00
params: Dict[str, str] = {
2023-06-25 17:29:04 +02:00
"code": appliance.code,
2023-05-06 16:07:28 +02:00
"macAddress": appliance.mac_address,
}
async with self._hon.get(url, params=params) as response:
2023-06-28 19:02:11 +02:00
result: Dict[str, Any] = await response.json()
2023-06-25 17:29:04 +02:00
if result:
2023-07-01 14:59:09 +02:00
appliance_data: Dict[str, Any] = result.get("payload", {}).get(
"applianceModel", {}
)
return appliance_data
2023-05-06 16:07:28 +02:00
return {}
2023-06-25 17:29:04 +02:00
async def load_attributes(self, appliance: HonAppliance) -> Dict[str, Any]:
2023-06-28 19:02:11 +02:00
params: Dict[str, str] = {
2023-04-09 20:50:28 +02:00
"macAddress": appliance.mac_address,
"applianceType": appliance.appliance_type,
2023-04-09 20:55:36 +02:00
"category": "CYCLE",
2023-02-13 01:41:38 +01:00
}
2023-04-13 23:25:49 +02:00
url: str = f"{const.API_URL}/commands/v1/context"
2023-04-09 18:13:50 +02:00
async with self._hon.get(url, params=params) as response:
2023-07-01 14:59:09 +02:00
attributes: Dict[str, Any] = (await response.json()).get("payload", {})
return attributes
2023-02-13 01:41:38 +01:00
2023-06-25 17:29:04 +02:00
async def load_statistics(self, appliance: HonAppliance) -> Dict[str, Any]:
2023-06-28 19:02:11 +02:00
params: Dict[str, str] = {
2023-04-09 20:50:28 +02:00
"macAddress": appliance.mac_address,
2023-04-09 20:55:36 +02:00
"applianceType": appliance.appliance_type,
2023-02-13 01:41:38 +01:00
}
2023-04-13 23:25:49 +02:00
url: str = f"{const.API_URL}/commands/v1/statistics"
2023-04-09 18:13:50 +02:00
async with self._hon.get(url, params=params) as response:
2023-07-01 14:59:09 +02:00
statistics: Dict[str, Any] = (await response.json()).get("payload", {})
return statistics
2023-02-13 01:41:38 +01:00
2023-06-25 17:29:04 +02:00
async def load_maintenance(self, appliance: HonAppliance) -> Dict[str, Any]:
2023-05-13 00:16:52 +02:00
url = f"{const.API_URL}/commands/v1/maintenance-cycle"
params = {"macAddress": appliance.mac_address}
async with self._hon.get(url, params=params) as response:
2023-07-01 14:59:09 +02:00
maintenance: Dict[str, Any] = (await response.json()).get("payload", {})
return maintenance
2023-05-13 00:16:52 +02:00
2023-04-13 23:25:49 +02:00
async def send_command(
self,
appliance: HonAppliance,
command: str,
2023-06-28 19:02:11 +02:00
parameters: Dict[str, Any],
ancillary_parameters: Dict[str, Any],
2023-04-13 23:25:49 +02:00
) -> bool:
now: str = datetime.utcnow().isoformat()
2023-06-28 19:02:11 +02:00
data: Dict[str, Any] = {
2023-04-09 20:50:28 +02:00
"macAddress": appliance.mac_address,
2023-02-13 01:41:38 +01:00
"timestamp": f"{now[:-3]}Z",
"commandName": command,
2023-04-09 20:50:28 +02:00
"transactionId": f"{appliance.mac_address}_{now[:-3]}Z",
2023-05-21 02:25:43 +02:00
"applianceOptions": appliance.options,
2023-04-15 00:29:24 +02:00
"device": self._hon.device.get(mobile=True),
2023-02-13 01:41:38 +01:00
"attributes": {
"channel": "mobileApp",
"origin": "standardProgram",
2023-04-09 20:55:36 +02:00
"energyLabel": "0",
2023-02-13 01:41:38 +01:00
},
"ancillaryParameters": ancillary_parameters,
"parameters": parameters,
2023-04-09 20:55:36 +02:00
"applianceType": appliance.appliance_type,
2023-02-13 01:41:38 +01:00
}
2023-04-13 23:25:49 +02:00
url: str = f"{const.API_URL}/commands/v1/send"
2023-04-15 00:29:24 +02:00
async with self._hon.post(url, json=data) as response:
2023-06-28 19:02:11 +02:00
json_data: Dict[str, Any] = await response.json()
2023-04-09 20:50:28 +02:00
if json_data.get("payload", {}).get("resultCode") == "0":
2023-02-13 01:41:38 +01:00
return True
2023-04-15 00:29:24 +02:00
_LOGGER.error(await response.text())
2023-06-09 02:09:20 +02:00
_LOGGER.error("%s - Payload:\n%s", url, pformat(data))
2023-02-13 01:41:38 +01:00
return False
2023-04-09 18:13:50 +02:00
2023-06-25 17:29:04 +02:00
async def appliance_configuration(self) -> Dict[str, Any]:
2023-05-06 16:07:28 +02:00
url: str = f"{const.API_URL}/config/v1/program-list-rules"
2023-04-09 18:13:50 +02:00
async with self._hon_anonymous.get(url) as response:
2023-06-28 19:02:11 +02:00
result: Dict[str, Any] = await response.json()
2023-07-01 14:59:09 +02:00
data: Dict[str, Any] = result.get("payload", {})
return data
2023-04-09 18:13:50 +02:00
2023-06-25 17:29:04 +02:00
async def app_config(
self, language: str = "en", beta: bool = True
) -> Dict[str, Any]:
2023-04-13 23:25:49 +02:00
url: str = f"{const.API_URL}/app-config"
2023-06-28 19:02:11 +02:00
payload_data: Dict[str, str | int] = {
2023-04-09 18:13:50 +02:00
"languageCode": language,
"beta": beta,
"appVersion": const.APP_VERSION,
2023-04-09 20:55:36 +02:00
"os": const.OS,
2023-04-09 18:13:50 +02:00
}
2023-04-13 23:25:49 +02:00
payload: str = json.dumps(payload_data, separators=(",", ":"))
2023-04-09 18:13:50 +02:00
async with self._hon_anonymous.post(url, data=payload) as response:
2023-07-01 14:59:09 +02:00
result = await response.json()
data: Dict[str, Any] = result.get("payload", {})
return data
2023-04-09 18:13:50 +02:00
2023-06-25 17:29:04 +02:00
async def translation_keys(self, language: str = "en") -> Dict[str, Any]:
2023-04-09 18:13:50 +02:00
config = await self.app_config(language=language)
2023-07-01 14:59:09 +02:00
if not (url := config.get("language", {}).get("jsonPath")):
return {}
async with self._hon_anonymous.get(url) as response:
result: Dict[str, Any] = await response.json()
return result
2023-04-09 20:50:28 +02:00
2023-04-13 23:25:49 +02:00
async def close(self) -> None:
if self._hon_handler is not None:
await self._hon_handler.close()
if self._hon_anonymous_handler is not None:
await self._hon_anonymous_handler.close()
2023-06-25 17:29:04 +02:00
class TestAPI(HonAPI):
2023-06-28 19:02:11 +02:00
def __init__(self, path: Path):
2023-06-25 17:29:04 +02:00
super().__init__()
self._anonymous = True
self._path: Path = path
2023-06-28 19:02:11 +02:00
def _load_json(self, appliance: HonAppliance, file: str) -> Dict[str, Any]:
2023-06-25 17:29:04 +02:00
directory = f"{appliance.appliance_type}_{appliance.appliance_model_id}".lower()
2023-07-01 14:59:09 +02:00
if not (path := self._path / directory / f"{file}.json").exists():
_LOGGER.warning("Can't open %s", str(path))
return {}
with open(path, "r", encoding="utf-8") as json_file:
2023-07-09 23:58:55 +02:00
text = json_file.read()
try:
data: Dict[str, Any] = json.loads(text)
return data
except json.decoder.JSONDecodeError as error:
_LOGGER.error("%s - %s", str(path), error)
return {}
2023-06-25 17:29:04 +02:00
async def load_appliances(self) -> List[Dict[str, Any]]:
result = []
for appliance in self._path.glob("*/"):
with open(
appliance / "appliance_data.json", "r", encoding="utf-8"
) as json_file:
result.append(json.loads(json_file.read()))
return result
async def load_commands(self, appliance: HonAppliance) -> Dict[str, Any]:
return self._load_json(appliance, "commands")
@no_type_check
async def load_command_history(
self, appliance: HonAppliance
) -> List[Dict[str, Any]]:
return self._load_json(appliance, "command_history")
async def load_favourites(self, appliance: HonAppliance) -> List[Dict[str, Any]]:
return []
async def load_last_activity(self, appliance: HonAppliance) -> Dict[str, Any]:
return {}
async def load_appliance_data(self, appliance: HonAppliance) -> Dict[str, Any]:
return self._load_json(appliance, "appliance_data")
async def load_attributes(self, appliance: HonAppliance) -> Dict[str, Any]:
return self._load_json(appliance, "attributes")
async def load_statistics(self, appliance: HonAppliance) -> Dict[str, Any]:
return self._load_json(appliance, "statistics")
async def load_maintenance(self, appliance: HonAppliance) -> Dict[str, Any]:
return self._load_json(appliance, "maintenance")
async def send_command(
self,
appliance: HonAppliance,
command: str,
2023-06-28 19:02:11 +02:00
parameters: Dict[str, Any],
ancillary_parameters: Dict[str, Any],
2023-06-25 17:29:04 +02:00
) -> bool:
return True