From 8fa01343bcb27b4512c93e26918ea16a44d714a5 Mon Sep 17 00:00:00 2001 From: Andre Basche Date: Sun, 9 Apr 2023 18:13:50 +0200 Subject: [PATCH 1/7] Use connection handler --- pyhon/__init__.py | 2 +- pyhon/__main__.py | 6 +- pyhon/{device.py => appliance.py} | 2 +- pyhon/connection/__init__.py | 0 pyhon/{ => connection}/api.py | 168 ++++++++++++------------------ pyhon/{ => connection}/auth.py | 73 ++++++------- pyhon/connection/connection.py | 100 ++++++++++++++++++ pyhon/connection/device.py | 36 +++++++ 8 files changed, 247 insertions(+), 140 deletions(-) mode change 100755 => 100644 pyhon/__main__.py rename pyhon/{device.py => appliance.py} (99%) create mode 100644 pyhon/connection/__init__.py rename pyhon/{ => connection}/api.py (50%) rename pyhon/{ => connection}/auth.py (68%) create mode 100644 pyhon/connection/connection.py create mode 100644 pyhon/connection/device.py diff --git a/pyhon/__init__.py b/pyhon/__init__.py index b13705c..c761612 100644 --- a/pyhon/__init__.py +++ b/pyhon/__init__.py @@ -1 +1 @@ -from .api import HonConnection +from .connection.api import HonAPI diff --git a/pyhon/__main__.py b/pyhon/__main__.py old mode 100755 new mode 100644 index e5843d4..cc0c1be --- a/pyhon/__main__.py +++ b/pyhon/__main__.py @@ -11,7 +11,7 @@ from pprint import pprint if __name__ == "__main__": sys.path.insert(0, str(Path(__file__).parent.parent)) -from pyhon import HonConnection +from pyhon import HonAPI _LOGGER = logging.getLogger(__name__) @@ -85,7 +85,7 @@ def create_command(commands, concat=False): async def translate(language, json_output=False): - async with HonConnection() as hon: + async with HonAPI() as hon: keys = await hon.translation_keys(language) if json_output: print(json.dumps(keys, indent=4)) @@ -104,7 +104,7 @@ async def main(): user = input("User for hOn account: ") if not (password := args["password"]): password = getpass("Password for hOn account: ") - async with HonConnection(user, password) as hon: + async with HonAPI(user, password) as hon: for device in hon.devices: print("=" * 10, device.appliance_type, "-", device.nick_name, "=" * 10) if args.get("keys"): diff --git a/pyhon/device.py b/pyhon/appliance.py similarity index 99% rename from pyhon/device.py rename to pyhon/appliance.py index 711b7e1..4137466 100644 --- a/pyhon/device.py +++ b/pyhon/appliance.py @@ -5,7 +5,7 @@ from pyhon.commands import HonCommand from pyhon.parameter import HonParameterFixed -class HonDevice: +class HonAppliance: def __init__(self, connector, appliance): if attributes := appliance.get("attributes"): appliance["attributes"] = {v["parName"]: v["parValue"] for v in attributes} diff --git a/pyhon/connection/__init__.py b/pyhon/connection/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/pyhon/api.py b/pyhon/connection/api.py similarity index 50% rename from pyhon/api.py rename to pyhon/connection/api.py index 4a72274..62196a3 100644 --- a/pyhon/api.py +++ b/pyhon/connection/api.py @@ -1,74 +1,58 @@ import asyncio import json import logging -import secrets from datetime import datetime from typing import List -import aiohttp as aiohttp - from pyhon import const -from pyhon.auth import HonAuth -from pyhon.device import HonDevice +from pyhon.appliance import HonAppliance +from pyhon.connection.connection import HonConnectionHandler, HonAnonymousConnectionHandler _LOGGER = logging.getLogger() -class HonConnection: - def __init__(self, email="", password="", session=None) -> None: +class HonAPI: + def __init__(self, email="", password="") -> None: super().__init__() self._email = email self._password = password - self._request_headers = {"Content-Type": "application/json"} - self._session = session self._devices = [] - self._mobile_id = secrets.token_hex(8) + self._hon = None + self._hon_anonymous = HonAnonymousConnectionHandler() async def __aenter__(self): - self._session = aiohttp.ClientSession() - if self._email and self._password: - await self.setup() + self._hon = HonConnectionHandler(self._email, self._password) + await self._hon.create() + await self.setup() + return self async def __aexit__(self, exc_type, exc_val, exc_tb): - await self._session.close() + await self._hon.close() @property - def devices(self) -> List[HonDevice]: + def devices(self) -> List[HonAppliance]: return self._devices - @property - async def _headers(self): - if "cognito-token" not in self._request_headers or "id-token" not in self._request_headers: - auth = HonAuth() - if await auth.authorize(self._email, self._password, self._mobile_id): - self._request_headers["cognito-token"] = auth.cognito_token - self._request_headers["id-token"] = auth.id_token - else: - raise PermissionError("Can't Login") - return self._request_headers - async def setup(self): - async with aiohttp.ClientSession() as session: - async with session.get(f"{const.API_URL}/commands/v1/appliance", - headers=await self._headers) as resp: - try: - appliances = (await resp.json())["payload"]["appliances"] - for appliance in appliances: - device = HonDevice(self, appliance) - if device.mac_address is None: - continue - await asyncio.gather(*[ - device.load_attributes(), - device.load_commands(), - device.load_statistics()]) - self._devices.append(device) - except json.JSONDecodeError: - _LOGGER.error("No JSON Data after GET: %s", await resp.text()) - return False + async with self._hon.get(f"{const.API_URL}/commands/v1/appliance") as resp: + try: + appliances = (await resp.json())["payload"]["appliances"] + for appliance in appliances: + device = HonAppliance(self, appliance) + if device.mac_address is None: + continue + await asyncio.gather(*[ + device.load_attributes(), + device.load_commands(), + device.load_statistics()]) + self._devices.append(device) + except json.JSONDecodeError: + _LOGGER.error("No JSON Data after GET: %s", await resp.text()) + return False return True - async def load_commands(self, device: HonDevice): + async def load_commands(self, device: HonAppliance): params = { "applianceType": device.appliance_type, "code": device.appliance["code"], @@ -81,84 +65,46 @@ class HonConnection: "series": device.appliance["series"], } url = f"{const.API_URL}/commands/v1/retrieve" - async with self._session.get(url, params=params, headers=await self._headers) as response: + async with self._hon.get(url, params=params) as response: result = (await response.json()).get("payload", {}) if not result or result.pop("resultCode") != "0": return {} return result - async def command_history(self, device: HonDevice): + async def command_history(self, device: HonAppliance): url = f"{const.API_URL}/commands/v1/appliance/{device.mac_address}/history" - async with self._session.get(url, headers=await self._headers) as response: + async with self._hon.get(url) as response: result = await response.json() if not result or not result.get("payload"): return {} return result["payload"]["history"] - async def last_activity(self, device: HonDevice): + async def last_activity(self, device: HonAppliance): url = f"{const.API_URL}/commands/v1/retrieve-last-activity" params = {"macAddress": device.mac_address} - async with self._session.get(url, params=params, headers=await self._headers) as response: + async with self._hon.get(url, params=params) as response: result = await response.json() if result and (activity := result.get("attributes")): return activity return {} - async def appliance_configuration(self): - url = f"{const.API_URL}/config/v1/appliance-configuration" - headers = {"x-api-key": const.API_KEY, "content-type": "application/json"} - async with self._session.get(url, headers=headers) as response: - result = await response.json() - if result and (data := result.get("payload")): - return data - return {} - - async def app_config(self, language="en", beta=True): - headers = {"x-api-key": const.API_KEY, "content-type": "application/json"} - url = f"{const.API_URL}/app-config" - payload = { - "languageCode": language, - "beta": beta, - "appVersion": const.APP_VERSION, - "os": const.OS - } - payload = json.dumps(payload, separators=(',', ':')) - async with self._session.post(url, headers=headers, data=payload) as response: - if (result := await response.json()) and (data := result.get("payload")): - return data - return {} - - async def translation_keys(self, language="en"): - headers = {"x-api-key": const.API_KEY, "content-type": "application/json"} - config = await self.app_config(language=language) - if url := config.get("language", {}).get("jsonPath"): - async with self._session.get(url, headers=headers) as response: - if result := await response.json(): - return result - return {} - - async def load_attributes(self, device: HonDevice, loop=False): + async def load_attributes(self, device: HonAppliance): params = { "macAddress": device.mac_address, "applianceType": device.appliance_type, "category": "CYCLE" } url = f"{const.API_URL}/commands/v1/context" - async with self._session.get(url, params=params, headers=await self._headers) as response: - if response.status == 403 and not loop: - _LOGGER.error("%s - Error %s - %s", url, response.status, await response.text()) - self._request_headers.pop("cognito-token", None) - self._request_headers.pop("id-token", None) - return await self.load_attributes(device, loop=True) + async with self._hon.get(url, params=params) as response: return (await response.json()).get("payload", {}) - async def load_statistics(self, device: HonDevice): + async def load_statistics(self, device: HonAppliance): params = { "macAddress": device.mac_address, "applianceType": device.appliance_type } url = f"{const.API_URL}/commands/v1/statistics" - async with self._session.get(url, params=params, headers=await self._headers) as response: + async with self._hon.get(url, params=params) as response: return (await response.json()).get("payload", {}) async def send_command(self, device, command, parameters, ancillary_parameters): @@ -169,13 +115,7 @@ class HonConnection: "commandName": command, "transactionId": f"{device.mac_address}_{now[:-3]}Z", "applianceOptions": device.commands_options, - "device": { - "mobileId": self._mobile_id, - "mobileOs": const.OS, - "osVersion": const.OS_VERSION, - "appVersion": const.APP_VERSION, - "deviceModel": const.DEVICE_MODEL - }, + "device": self._hon.device.get(), "attributes": { "channel": "mobileApp", "origin": "standardProgram", @@ -186,7 +126,7 @@ class HonConnection: "applianceType": device.appliance_type } url = f"{const.API_URL}/commands/v1/send" - async with self._session.post(url, headers=await self._headers, json=data) as resp: + async with self._hon.post(url, json=data) as resp: try: json_data = await resp.json() except json.JSONDecodeError: @@ -194,3 +134,33 @@ class HonConnection: if json_data["payload"]["resultCode"] == "0": return True return False + + async def appliance_configuration(self): + url = f"{const.API_URL}/config/v1/appliance-configuration" + async with self._hon_anonymous.get(url) as response: + result = await response.json() + if result and (data := result.get("payload")): + return data + return {} + + async def app_config(self, language="en", beta=True): + url = f"{const.API_URL}/app-config" + payload = { + "languageCode": language, + "beta": beta, + "appVersion": const.APP_VERSION, + "os": const.OS + } + payload = json.dumps(payload, separators=(',', ':')) + async with self._hon_anonymous.post(url, data=payload) as response: + if (result := await response.json()) and (data := result.get("payload")): + return data + return {} + + async def translation_keys(self, language="en"): + config = await self.app_config(language=language) + if url := config.get("language", {}).get("jsonPath"): + async with self._hon_anonymous.get(url) as response: + if result := await response.json(): + return result + return {} diff --git a/pyhon/auth.py b/pyhon/connection/auth.py similarity index 68% rename from pyhon/auth.py rename to pyhon/connection/auth.py index 1baca58..72a7426 100644 --- a/pyhon/auth.py +++ b/pyhon/connection/auth.py @@ -3,9 +3,9 @@ import logging import re import secrets import urllib +from pprint import pprint from urllib import parse -import aiohttp as aiohttp from yarl import URL from pyhon import const @@ -14,11 +14,15 @@ _LOGGER = logging.getLogger() class HonAuth: - def __init__(self) -> None: + def __init__(self, session, email, password, device) -> None: + self._session = session + self._email = email + self._password = password self._access_token = "" self._refresh_token = "" self._cognito_token = "" self._id_token = "" + self._device = device @property def cognito_token(self): @@ -36,7 +40,7 @@ class HonAuth: def refresh_token(self): return self._refresh_token - async def _load_login(self, session): + async def _load_login(self): nonce = secrets.token_hex(16) nonce = f"{nonce[:8]}-{nonce[8:12]}-{nonce[12:16]}-{nonce[16:20]}-{nonce[20:]}" params = { @@ -48,16 +52,16 @@ class HonAuth: "nonce": nonce } params = "&".join([f"{k}={v}" for k, v in params.items()]) - async with session.get(f"{const.AUTH_API}/services/oauth2/authorize/expid_Login?{params}") as resp: + async with self._session.get(f"{const.AUTH_API}/services/oauth2/authorize/expid_Login?{params}") as resp: if not (login_url := re.findall("url = '(.+?)'", await resp.text())): return False - async with session.get(login_url[0], allow_redirects=False) as redirect1: + async with self._session.get(login_url[0], allow_redirects=False) as redirect1: if not (url := redirect1.headers.get("Location")): return False - async with session.get(url, allow_redirects=False) as redirect2: + async with self._session.get(url, allow_redirects=False) as redirect2: if not (url := redirect2.headers.get("Location") + "&System=IoT_Mobile_App&RegistrationSubChannel=hOn"): return False - async with session.get(URL(url, encoded=True)) as login_screen: + async with self._session.get(URL(url, encoded=True)) as login_screen: if context := re.findall('"fwuid":"(.*?)","loaded":(\\{.*?})', await login_screen.text()): fw_uid, loaded_str = context[0] loaded = json.loads(loaded_str) @@ -65,7 +69,7 @@ class HonAuth: return fw_uid, loaded, login_url return False - async def _login(self, session, email, password, fw_uid, loaded, login_url): + async def _login(self, fw_uid, loaded, login_url): data = { "message": { "actions": [ @@ -74,8 +78,8 @@ class HonAuth: "descriptor": "apex://LightningLoginCustomController/ACTION$login", "callingDescriptor": "markup://c:loginForm", "params": { - "username": email, - "password": password, + "username": self._email, + "password": self._password, "startUrl": parse.unquote(login_url.split("startURL=")[-1]).split("%3D")[0] } } @@ -93,7 +97,7 @@ class HonAuth: "aura.token": None} params = {"r": 3, "other.LightningLoginCustom.login": 1} - async with session.post( + async with self._session.post( const.AUTH_API + "/s/sfsites/aura", headers={"Content-Type": "application/x-www-form-urlencoded"}, data="&".join(f"{k}={json.dumps(v)}" for k, v in data.items()), @@ -107,19 +111,19 @@ class HonAuth: _LOGGER.error("Unable to login: %s\n%s", response.status, await response.text()) return "" - async def _get_token(self, session, url): - async with session.get(url) as resp: + async def _get_token(self, url): + async with self._session.get(url) as resp: if resp.status != 200: _LOGGER.error("Unable to get token: %s", resp.status) return False url = re.findall("href\\s*=\\s*[\"'](.*?)[\"']", await resp.text()) - async with session.get(url[0]) as resp: + async with self._session.get(url[0]) as resp: if resp.status != 200: _LOGGER.error("Unable to get token: %s", resp.status) return False url = re.findall("href\\s*=\\s*[\"'](.*?)[\"']", await resp.text()) url = "/".join(const.AUTH_API.split("/")[:-1]) + url[0] - async with session.get(url) as resp: + async with self._session.get(url) as resp: if resp.status != 200: _LOGGER.error("Unable to connect to the login service: %s", resp.status) return False @@ -132,26 +136,23 @@ class HonAuth: self._id_token = id_token[0] return True - async def authorize(self, email, password, mobile_id): - headers = {"user-agent": const.USER_AGENT} - async with aiohttp.ClientSession(headers=headers) as session: - if login_site := await self._load_login(session): - fw_uid, loaded, login_url = login_site - else: - return False - if not (url := await self._login(session, email, password, fw_uid, loaded, login_url)): - return False - if not await self._get_token(session, url): - return False + async def authorize(self): + if login_site := await self._load_login(): + fw_uid, loaded, login_url = login_site + else: + return False + if not (url := await self._login(fw_uid, loaded, login_url)): + return False + if not await self._get_token(url): + return False - post_headers = {"Content-Type": "application/json", "id-token": self._id_token} - data = {"appVersion": const.APP_VERSION, "mobileId": mobile_id, "osVersion": const.OS_VERSION, - "os": const.OS, "deviceModel": const.DEVICE_MODEL} - async with session.post(f"{const.API_URL}/auth/v1/login", headers=post_headers, json=data) as resp: - try: - json_data = await resp.json() - except json.JSONDecodeError: - _LOGGER.error("No JSON Data after POST: %s", await resp.text()) - return False - self._cognito_token = json_data["cognitoUser"]["Token"] + post_headers = {"Content-Type": "application/json", "id-token": self._id_token} + data = self._device.get() + async with self._session.post(f"{const.API_URL}/auth/v1/login", headers=post_headers, json=data) as resp: + try: + json_data = await resp.json() + except json.JSONDecodeError: + _LOGGER.error("No JSON Data after POST: %s", await resp.text()) + return False + self._cognito_token = json_data["cognitoUser"]["Token"] return True diff --git a/pyhon/connection/connection.py b/pyhon/connection/connection.py new file mode 100644 index 0000000..6c9bf56 --- /dev/null +++ b/pyhon/connection/connection.py @@ -0,0 +1,100 @@ +from contextlib import asynccontextmanager + +import aiohttp + +from pyhon import const +from pyhon.connection.auth import HonAuth, _LOGGER +from pyhon.connection.device import HonDevice + + +class HonBaseConnectionHandler: + _HEADERS = {"user-agent": const.USER_AGENT, "Content-Type": "application/json"} + + def __init__(self): + self._session = None + self._auth = None + + async def __aenter__(self): + await self.create() + return self + + async def __aexit__(self, exc_type, exc_val, exc_tb): + await self.close() + + async def create(self): + self._session = aiohttp.ClientSession(headers=self._HEADERS) + + @asynccontextmanager + async def get(self, *args, **kwargs): + raise NotImplemented + + @asynccontextmanager + async def post(self, *args, **kwargs): + raise NotImplemented + + async def close(self): + await self._session.close() + + +class HonConnectionHandler(HonBaseConnectionHandler): + def __init__(self, email, password): + super().__init__() + self._device = HonDevice() + self._email = email + self._password = password + if not self._email: + raise PermissionError("Login-Error - An email address must be specified") + if not self._password: + raise PermissionError("Login-Error - A password address must be specified") + self._request_headers = {} + + @property + def device(self): + return self._device + + async def create(self): + await super().create() + self._auth = HonAuth(self._session, self._email, self._password, self._device) + + async def _check_headers(self, headers): + if "cognito-token" not in self._request_headers or "id-token" not in self._request_headers: + if await self._auth.authorize(): + self._request_headers["cognito-token"] = self._auth.cognito_token + self._request_headers["id-token"] = self._auth.id_token + else: + raise PermissionError("Can't Login") + return {h: v for h, v in self._request_headers.items() if h not in headers} + + @asynccontextmanager + async def get(self, *args, loop=0, **kwargs): + kwargs["headers"] = await self._check_headers(kwargs.get("headers", {})) + async with self._session.get(*args, **kwargs) as response: + if response.status == 403 and not loop: + _LOGGER.warning("%s - Error %s - %s", response.request_info.url, response.status, await response.text()) + await self.create() + yield await self.get(*args, loop=loop + 1, **kwargs) + elif loop >= 2: + _LOGGER.error("%s - Error %s - %s", response.request_info.url, response.status, await response.text()) + raise PermissionError() + else: + yield response + + @asynccontextmanager + async def post(self, *args, **kwargs): + kwargs["headers"] = await self._check_headers(kwargs.get("headers", {})) + async with self._session.post(*args, **kwargs) as response: + yield response + + +class HonAnonymousConnectionHandler(HonBaseConnectionHandler): + _HEADERS = HonBaseConnectionHandler._HEADERS | {"x-api-key": const.API_KEY} + + @asynccontextmanager + async def get(self, *args, **kwargs): + async with self._session.post(*args, **kwargs) as response: + yield response + + @asynccontextmanager + async def post(self, *args, **kwargs): + async with self._session.post(*args, **kwargs) as response: + yield response diff --git a/pyhon/connection/device.py b/pyhon/connection/device.py new file mode 100644 index 0000000..f817885 --- /dev/null +++ b/pyhon/connection/device.py @@ -0,0 +1,36 @@ +import secrets + +from pyhon import const + + +class HonDevice: + def __init__(self): + self._app_version = const.APP_VERSION + self._os_version = const.OS_VERSION + self._os = const.OS + self._device_model = const.DEVICE_MODEL + self._mobile_id = secrets.token_hex(8) + + @property + def app_version(self): + return self._app_version + + @property + def os_version(self): + return self._os_version + + @property + def os(self): + return self._os + + @property + def device_model(self): + return self._device_model + + @property + def mobile_id(self): + return self._mobile_id + + def get(self): + return {"appVersion": self.app_version, "mobileId": self.mobile_id, "osVersion": self.os_version, + "os": self.os, "deviceModel": self.device_model} From eb6741145a7d00febe29bf7a3366445110c1d720 Mon Sep 17 00:00:00 2001 From: Andre Basche Date: Sun, 9 Apr 2023 18:43:57 +0200 Subject: [PATCH 2/7] Get new token via refresh-token #10 --- pyhon/connection/auth.py | 18 +++++++++++++++++- pyhon/connection/connection.py | 20 ++++++++++++++------ 2 files changed, 31 insertions(+), 7 deletions(-) diff --git a/pyhon/connection/auth.py b/pyhon/connection/auth.py index 72a7426..3066555 100644 --- a/pyhon/connection/auth.py +++ b/pyhon/connection/auth.py @@ -1,3 +1,4 @@ +import datetime import json import logging import re @@ -146,7 +147,7 @@ class HonAuth: if not await self._get_token(url): return False - post_headers = {"Content-Type": "application/json", "id-token": self._id_token} + post_headers = {"id-token": self._id_token} data = self._device.get() async with self._session.post(f"{const.API_URL}/auth/v1/login", headers=post_headers, json=data) as resp: try: @@ -156,3 +157,18 @@ class HonAuth: return False self._cognito_token = json_data["cognitoUser"]["Token"] return True + + async def refresh(self): + params = { + "client_id": const.CLIENT_ID, + "refresh_token": self._refresh_token, + "grant_type": "refresh_token" + } + async with self._session.post(f"{const.AUTH_API}/services/oauth2/token", params=params) as resp: + if resp.status >= 400: + return False + data = await resp.json() + self._id_token = data["id_token"] + self._access_token = data["access_token"] + + diff --git a/pyhon/connection/connection.py b/pyhon/connection/connection.py index 6c9bf56..66deb5b 100644 --- a/pyhon/connection/connection.py +++ b/pyhon/connection/connection.py @@ -66,23 +66,31 @@ class HonConnectionHandler(HonBaseConnectionHandler): return {h: v for h, v in self._request_headers.items() if h not in headers} @asynccontextmanager - async def get(self, *args, loop=0, **kwargs): + async def _intercept(self, method, *args, loop=0, **kwargs): kwargs["headers"] = await self._check_headers(kwargs.get("headers", {})) - async with self._session.get(*args, **kwargs) as response: + async with method(*args, **kwargs) as response: if response.status == 403 and not loop: + _LOGGER.info("Try refreshing token...") + await self._auth.refresh() + yield await self._intercept(method, *args, loop=loop + 1, **kwargs) + elif response.status == 403 and loop < 2: _LOGGER.warning("%s - Error %s - %s", response.request_info.url, response.status, await response.text()) await self.create() - yield await self.get(*args, loop=loop + 1, **kwargs) + yield await self._intercept(method, *args, loop=loop + 1, **kwargs) elif loop >= 2: _LOGGER.error("%s - Error %s - %s", response.request_info.url, response.status, await response.text()) - raise PermissionError() + raise PermissionError("Login failure") else: yield response + @asynccontextmanager + async def get(self, *args, **kwargs): + async with self._intercept(self._session.get, *args, **kwargs) as response: + yield response + @asynccontextmanager async def post(self, *args, **kwargs): - kwargs["headers"] = await self._check_headers(kwargs.get("headers", {})) - async with self._session.post(*args, **kwargs) as response: + async with self._intercept(self._session.post, *args, **kwargs) as response: yield response From 36fad84ee206ff7ed12daff7e05a684efa8295a7 Mon Sep 17 00:00:00 2001 From: Andre Basche Date: Sun, 9 Apr 2023 20:50:28 +0200 Subject: [PATCH 3/7] Refactor api access --- pyhon/__init__.py | 1 + pyhon/__main__.py | 6 +- pyhon/appliance.py | 40 ++++---- pyhon/connection/api.py | 93 +++++++------------ pyhon/connection/auth.py | 2 - .../connection/{connection.py => handler.py} | 14 ++- pyhon/hon.py | 36 +++++++ 7 files changed, 107 insertions(+), 85 deletions(-) rename pyhon/connection/{connection.py => handler.py} (90%) create mode 100644 pyhon/hon.py diff --git a/pyhon/__init__.py b/pyhon/__init__.py index c761612..e2b5e87 100644 --- a/pyhon/__init__.py +++ b/pyhon/__init__.py @@ -1 +1,2 @@ from .connection.api import HonAPI +from hon import Hon diff --git a/pyhon/__main__.py b/pyhon/__main__.py index cc0c1be..aed3a5d 100644 --- a/pyhon/__main__.py +++ b/pyhon/__main__.py @@ -11,7 +11,7 @@ from pprint import pprint if __name__ == "__main__": sys.path.insert(0, str(Path(__file__).parent.parent)) -from pyhon import HonAPI +from pyhon import Hon, HonAPI _LOGGER = logging.getLogger(__name__) @@ -104,8 +104,8 @@ async def main(): user = input("User for hOn account: ") if not (password := args["password"]): password = getpass("Password for hOn account: ") - async with HonAPI(user, password) as hon: - for device in hon.devices: + async with Hon(user, password) as hon: + for device in hon.appliances: print("=" * 10, device.appliance_type, "-", device.nick_name, "=" * 10) if args.get("keys"): data = device.data.copy() diff --git a/pyhon/appliance.py b/pyhon/appliance.py index 4137466..1670980 100644 --- a/pyhon/appliance.py +++ b/pyhon/appliance.py @@ -6,11 +6,11 @@ from pyhon.parameter import HonParameterFixed class HonAppliance: - def __init__(self, connector, appliance): - if attributes := appliance.get("attributes"): - appliance["attributes"] = {v["parName"]: v["parValue"] for v in attributes} - self._appliance = appliance - self._connector = connector + def __init__(self, api, info): + if attributes := info.get("attributes"): + info["attributes"] = {v["parName"]: v["parValue"] for v in attributes} + self._info = info + self._api = api self._appliance_model = {} self._commands = {} @@ -36,7 +36,7 @@ class HonAppliance: return self.data[item] if item in self.attributes["parameters"]: return self.attributes["parameters"].get(item) - return self.appliance[item] + return self.info[item] def get(self, item, default=None): try: @@ -46,23 +46,23 @@ class HonAppliance: @property def appliance_model_id(self): - return self._appliance.get("applianceModelId") + return self._info.get("applianceModelId") @property def appliance_type(self): - return self._appliance.get("applianceTypeName") + return self._info.get("applianceTypeName") @property def mac_address(self): - return self._appliance.get("macAddress") + return self._info.get("macAddress") @property def model_name(self): - return self._appliance.get("modelName") + return self._info.get("modelName") @property def nick_name(self): - return self._appliance.get("nickName") + return self._info.get("nickName") @property def commands_options(self): @@ -81,11 +81,11 @@ class HonAppliance: return self._statistics @property - def appliance(self): - return self._appliance + def info(self): + return self._info async def _recover_last_command_states(self, commands): - command_history = await self._connector.command_history(self) + command_history = await self._api.command_history(self) for name, command in commands.items(): last = next((index for (index, d) in enumerate(command_history) if d.get("command", {}).get("commandName") == name), None) if last is None: @@ -100,19 +100,19 @@ class HonAppliance: data.value = parameters.get(key) async def load_commands(self): - raw = await self._connector.load_commands(self) + raw = await self._api.load_commands(self) self._appliance_model = raw.pop("applianceModel") for item in ["settings", "options", "dictionaryId"]: raw.pop(item) commands = {} for command, attr in raw.items(): if "parameters" in attr: - commands[command] = HonCommand(command, attr, self._connector, self) + commands[command] = HonCommand(command, attr, self._api, self) elif "parameters" in attr[list(attr)[0]]: multi = {} for program, attr2 in attr.items(): program = program.split(".")[-1].lower() - cmd = HonCommand(command, attr2, self._connector, self, multi=multi, program=program) + cmd = HonCommand(command, attr2, self._api, self, multi=multi, program=program) multi[program] = cmd commands[command] = cmd self._commands = commands @@ -137,19 +137,19 @@ class HonAppliance: return result async def load_attributes(self): - self._attributes = await self._connector.load_attributes(self) + self._attributes = await self._api.load_attributes(self) for name, values in self._attributes.pop("shadow").get("parameters").items(): self._attributes.setdefault("parameters", {})[name] = values["parNewVal"] async def load_statistics(self): - self._statistics = await self._connector.load_statistics(self) + self._statistics = await self._api.load_statistics(self) async def update(self): await self.load_attributes() @property def data(self): - result = {"attributes": self.attributes, "appliance": self.appliance, "statistics": self.statistics, + result = {"attributes": self.attributes, "appliance": self.info, "statistics": self.statistics, **self.parameters} if self._extra: return self._extra.data(result) diff --git a/pyhon/connection/api.py b/pyhon/connection/api.py index 62196a3..34566cc 100644 --- a/pyhon/connection/api.py +++ b/pyhon/connection/api.py @@ -1,12 +1,10 @@ -import asyncio import json import logging from datetime import datetime -from typing import List from pyhon import const from pyhon.appliance import HonAppliance -from pyhon.connection.connection import HonConnectionHandler, HonAnonymousConnectionHandler +from pyhon.connection.handler import HonConnectionHandler, HonAnonymousConnectionHandler _LOGGER = logging.getLogger() @@ -16,53 +14,34 @@ class HonAPI: super().__init__() self._email = email self._password = password - self._devices = [] self._hon = None self._hon_anonymous = HonAnonymousConnectionHandler() async def __aenter__(self): - self._hon = HonConnectionHandler(self._email, self._password) - await self._hon.create() - await self.setup() - - return self + return await self.create() async def __aexit__(self, exc_type, exc_val, exc_tb): await self._hon.close() - @property - def devices(self) -> List[HonAppliance]: - return self._devices + async def create(self): + self._hon = await HonConnectionHandler(self._email, self._password).create() + return self - async def setup(self): + async def load_appliances(self): async with self._hon.get(f"{const.API_URL}/commands/v1/appliance") as resp: - try: - appliances = (await resp.json())["payload"]["appliances"] - for appliance in appliances: - device = HonAppliance(self, appliance) - if device.mac_address is None: - continue - await asyncio.gather(*[ - device.load_attributes(), - device.load_commands(), - device.load_statistics()]) - self._devices.append(device) - except json.JSONDecodeError: - _LOGGER.error("No JSON Data after GET: %s", await resp.text()) - return False - return True + return await resp.json() - async def load_commands(self, device: HonAppliance): + async def load_commands(self, appliance: HonAppliance): params = { - "applianceType": device.appliance_type, - "code": device.appliance["code"], - "applianceModelId": device.appliance_model_id, - "firmwareId": device.appliance["eepromId"], - "macAddress": device.mac_address, - "fwVersion": device.appliance["fwVersion"], + "applianceType": appliance.appliance_type, + "code": appliance.info["code"], + "applianceModelId": appliance.appliance_model_id, + "firmwareId": appliance.info["eepromId"], + "macAddress": appliance.mac_address, + "fwVersion": appliance.info["fwVersion"], "os": const.OS, "appVersion": const.APP_VERSION, - "series": device.appliance["series"], + "series": appliance.info["series"], } url = f"{const.API_URL}/commands/v1/retrieve" async with self._hon.get(url, params=params) as response: @@ -71,51 +50,51 @@ class HonAPI: return {} return result - async def command_history(self, device: HonAppliance): - url = f"{const.API_URL}/commands/v1/appliance/{device.mac_address}/history" + async def command_history(self, appliance: HonAppliance): + url = f"{const.API_URL}/commands/v1/appliance/{appliance.mac_address}/history" async with self._hon.get(url) as response: result = await response.json() if not result or not result.get("payload"): return {} return result["payload"]["history"] - async def last_activity(self, device: HonAppliance): + async def last_activity(self, appliance: HonAppliance): url = f"{const.API_URL}/commands/v1/retrieve-last-activity" - params = {"macAddress": device.mac_address} + params = {"macAddress": appliance.mac_address} async with self._hon.get(url, params=params) as response: result = await response.json() if result and (activity := result.get("attributes")): return activity return {} - async def load_attributes(self, device: HonAppliance): + async def load_attributes(self, appliance: HonAppliance): params = { - "macAddress": device.mac_address, - "applianceType": device.appliance_type, + "macAddress": appliance.mac_address, + "applianceType": appliance.appliance_type, "category": "CYCLE" } url = f"{const.API_URL}/commands/v1/context" async with self._hon.get(url, params=params) as response: return (await response.json()).get("payload", {}) - async def load_statistics(self, device: HonAppliance): + async def load_statistics(self, appliance: HonAppliance): params = { - "macAddress": device.mac_address, - "applianceType": device.appliance_type + "macAddress": appliance.mac_address, + "applianceType": appliance.appliance_type } url = f"{const.API_URL}/commands/v1/statistics" async with self._hon.get(url, params=params) as response: return (await response.json()).get("payload", {}) - async def send_command(self, device, command, parameters, ancillary_parameters): + async def send_command(self, appliance, command, parameters, ancillary_parameters): now = datetime.utcnow().isoformat() data = { - "macAddress": device.mac_address, + "macAddress": appliance.mac_address, "timestamp": f"{now[:-3]}Z", "commandName": command, - "transactionId": f"{device.mac_address}_{now[:-3]}Z", - "applianceOptions": device.commands_options, - "device": self._hon.device.get(), + "transactionId": f"{appliance.mac_address}_{now[:-3]}Z", + "applianceOptions": appliance.commands_options, + "appliance": self._hon.device.get(), "attributes": { "channel": "mobileApp", "origin": "standardProgram", @@ -123,15 +102,12 @@ class HonAPI: }, "ancillaryParameters": ancillary_parameters, "parameters": parameters, - "applianceType": device.appliance_type + "applianceType": appliance.appliance_type } url = f"{const.API_URL}/commands/v1/send" async with self._hon.post(url, json=data) as resp: - try: - json_data = await resp.json() - except json.JSONDecodeError: - return False - if json_data["payload"]["resultCode"] == "0": + json_data = await resp.json() + if json_data.get("payload", {}).get("resultCode") == "0": return True return False @@ -164,3 +140,6 @@ class HonAPI: if result := await response.json(): return result return {} + + async def close(self): + await self._hon.close() diff --git a/pyhon/connection/auth.py b/pyhon/connection/auth.py index 3066555..86960bc 100644 --- a/pyhon/connection/auth.py +++ b/pyhon/connection/auth.py @@ -1,10 +1,8 @@ -import datetime import json import logging import re import secrets import urllib -from pprint import pprint from urllib import parse from yarl import URL diff --git a/pyhon/connection/connection.py b/pyhon/connection/handler.py similarity index 90% rename from pyhon/connection/connection.py rename to pyhon/connection/handler.py index 66deb5b..2a3cf55 100644 --- a/pyhon/connection/connection.py +++ b/pyhon/connection/handler.py @@ -1,3 +1,4 @@ +import json from contextlib import asynccontextmanager import aiohttp @@ -15,14 +16,14 @@ class HonBaseConnectionHandler: self._auth = None async def __aenter__(self): - await self.create() - return self + return await self.create() async def __aexit__(self, exc_type, exc_val, exc_tb): await self.close() async def create(self): self._session = aiohttp.ClientSession(headers=self._HEADERS) + return self @asynccontextmanager async def get(self, *args, **kwargs): @@ -55,6 +56,7 @@ class HonConnectionHandler(HonBaseConnectionHandler): async def create(self): await super().create() self._auth = HonAuth(self._session, self._email, self._password, self._device) + return self async def _check_headers(self, headers): if "cognito-token" not in self._request_headers or "id-token" not in self._request_headers: @@ -81,7 +83,13 @@ class HonConnectionHandler(HonBaseConnectionHandler): _LOGGER.error("%s - Error %s - %s", response.request_info.url, response.status, await response.text()) raise PermissionError("Login failure") else: - yield response + try: + await response.json() + yield response + except json.JSONDecodeError: + _LOGGER.warning("%s - JsonDecodeError %s - %s", response.request_info.url, response.status, + await response.text()) + yield {} @asynccontextmanager async def get(self, *args, **kwargs): diff --git a/pyhon/hon.py b/pyhon/hon.py new file mode 100644 index 0000000..f30783c --- /dev/null +++ b/pyhon/hon.py @@ -0,0 +1,36 @@ +import asyncio +from typing import List + +from pyhon import HonAPI +from pyhon.appliance import HonAppliance + + +class Hon: + def __init__(self, email, password): + self._email = email + self._password = password + self._appliances = [] + self._api = None + + async def __aenter__(self): + self._api = await HonAPI(self._email, self._password).create() + await self.setup() + return self + + async def __aexit__(self, exc_type, exc_val, exc_tb): + await self._api.close() + + @property + def appliances(self) -> List[HonAppliance]: + return self._appliances + + async def setup(self): + for appliance in (await self._api.load_appliances())["payload"]["appliances"]: + appliance = HonAppliance(self._api, appliance) + if appliance.mac_address is None: + continue + await asyncio.gather(*[ + appliance.load_attributes(), + appliance.load_commands(), + appliance.load_statistics()]) + self._appliances.append(appliance) From 8dc6cd71cda0c9401d63591f05b347c1a4914062 Mon Sep 17 00:00:00 2001 From: Andre Basche Date: Sun, 9 Apr 2023 20:55:36 +0200 Subject: [PATCH 4/7] Format with black --- pyhon/__main__.py | 21 +++++++++--- pyhon/appliance.py | 30 +++++++++++++---- pyhon/appliances/ov.py | 2 +- pyhon/commands.py | 35 +++++++++++++++----- pyhon/connection/api.py | 12 +++---- pyhon/connection/auth.py | 64 ++++++++++++++++++++++++------------- pyhon/connection/device.py | 9 ++++-- pyhon/connection/handler.py | 27 +++++++++++++--- pyhon/hon.py | 11 ++++--- pyhon/parameter.py | 12 +++++-- setup.py | 8 ++--- 11 files changed, 166 insertions(+), 65 deletions(-) diff --git a/pyhon/__main__.py b/pyhon/__main__.py index aed3a5d..7eac5b6 100644 --- a/pyhon/__main__.py +++ b/pyhon/__main__.py @@ -25,8 +25,12 @@ def get_arguments(): keys = subparser.add_parser("keys", help="print as key format") keys.add_argument("keys", help="print as key format", action="store_true") keys.add_argument("--all", help="print also full keys", action="store_true") - translate = subparser.add_parser("translate", help="print available translation keys") - translate.add_argument("translate", help="language (de, en, fr...)", metavar="LANGUAGE") + translate = subparser.add_parser( + "translate", help="print available translation keys" + ) + translate.add_argument( + "translate", help="language (de, en, fr...)", metavar="LANGUAGE" + ) translate.add_argument("--json", help="print as json", action="store_true") return vars(parser.parse_args()) @@ -51,7 +55,9 @@ def pretty_print(data, key="", intend=0, is_list=False): else: pretty_print(value, key=key, intend=intend) else: - print(f"{' ' * intend}{'- ' if is_list else ''}{key}{': ' if key else ''}{data}") + print( + f"{' ' * intend}{'- ' if is_list else ''}{key}{': ' if key else ''}{data}" + ) def key_print(data, key="", start=True): @@ -90,7 +96,12 @@ async def translate(language, json_output=False): if json_output: print(json.dumps(keys, indent=4)) else: - clean_keys = json.dumps(keys).replace("\\n", "\\\\n").replace("\\\\r", "").replace("\\r", "") + clean_keys = ( + json.dumps(keys) + .replace("\\n", "\\\\n") + .replace("\\\\r", "") + .replace("\\r", "") + ) keys = json.loads(clean_keys) pretty_print(keys) @@ -126,5 +137,5 @@ def start(): print("Aborted.") -if __name__ == '__main__': +if __name__ == "__main__": start() diff --git a/pyhon/appliance.py b/pyhon/appliance.py index 1670980..5ce7db3 100644 --- a/pyhon/appliance.py +++ b/pyhon/appliance.py @@ -18,7 +18,9 @@ class HonAppliance: self._attributes = {} try: - self._extra = importlib.import_module(f'pyhon.appliances.{self.appliance_type.lower()}').Appliance() + self._extra = importlib.import_module( + f"pyhon.appliances.{self.appliance_type.lower()}" + ).Appliance() except ModuleNotFoundError: self._extra = None @@ -87,7 +89,14 @@ class HonAppliance: async def _recover_last_command_states(self, commands): command_history = await self._api.command_history(self) for name, command in commands.items(): - last = next((index for (index, d) in enumerate(command_history) if d.get("command", {}).get("commandName") == name), None) + last = next( + ( + index + for (index, d) in enumerate(command_history) + if d.get("command", {}).get("commandName") == name + ), + None, + ) if last is None: continue parameters = command_history[last].get("command", {}).get("parameters", {}) @@ -95,7 +104,10 @@ class HonAppliance: command.set_program(parameters.pop("program").split(".")[-1].lower()) command = self.commands[name] for key, data in command.settings.items(): - if not isinstance(data, HonParameterFixed) and parameters.get(key) is not None: + if ( + not isinstance(data, HonParameterFixed) + and parameters.get(key) is not None + ): with suppress(ValueError): data.value = parameters.get(key) @@ -112,7 +124,9 @@ class HonAppliance: multi = {} for program, attr2 in attr.items(): program = program.split(".")[-1].lower() - cmd = HonCommand(command, attr2, self._api, self, multi=multi, program=program) + cmd = HonCommand( + command, attr2, self._api, self, multi=multi, program=program + ) multi[program] = cmd commands[command] = cmd self._commands = commands @@ -149,8 +163,12 @@ class HonAppliance: @property def data(self): - result = {"attributes": self.attributes, "appliance": self.info, "statistics": self.statistics, - **self.parameters} + result = { + "attributes": self.attributes, + "appliance": self.info, + "statistics": self.statistics, + **self.parameters, + } if self._extra: return self._extra.data(result) return result diff --git a/pyhon/appliances/ov.py b/pyhon/appliances/ov.py index 0d3fe18..54eb7a9 100644 --- a/pyhon/appliances/ov.py +++ b/pyhon/appliances/ov.py @@ -4,7 +4,7 @@ from pyhon.parameter import HonParameterEnum class Appliance: def __init__(self): filters = ["receipt", "standard, special"] - data = {'defaultValue': filters[0], 'enumValues': filters} + data = {"defaultValue": filters[0], "enumValues": filters} self._program_filter = HonParameterEnum("program_filter", data) def data(self, data): diff --git a/pyhon/commands.py b/pyhon/commands.py index 7c1e9ee..b12493a 100644 --- a/pyhon/commands.py +++ b/pyhon/commands.py @@ -1,4 +1,9 @@ -from pyhon.parameter import HonParameterFixed, HonParameterEnum, HonParameterRange, HonParameterProgram +from pyhon.parameter import ( + HonParameterFixed, + HonParameterEnum, + HonParameterRange, + HonParameterProgram, +) class HonCommand: @@ -10,7 +15,9 @@ class HonCommand: self._program = program self._description = attributes.get("description", "") self._parameters = self._create_parameters(attributes.get("parameters", {})) - self._ancillary_parameters = self._create_parameters(attributes.get("ancillaryParameters", {})) + self._ancillary_parameters = self._create_parameters( + attributes.get("ancillaryParameters", {}) + ) def __repr__(self): return f"{self._name} command" @@ -35,11 +42,18 @@ class HonCommand: @property def ancillary_parameters(self): - return {key: parameter.value for key, parameter in self._ancillary_parameters.items()} + return { + key: parameter.value + for key, parameter in self._ancillary_parameters.items() + } async def send(self): - parameters = {name: parameter.value for name, parameter in self._parameters.items()} - return await self._connector.send_command(self._device, self._name, parameters, self.ancillary_parameters) + parameters = { + name: parameter.value for name, parameter in self._parameters.items() + } + return await self._connector.send_command( + self._device, self._name, parameters, self.ancillary_parameters + ) def get_programs(self): return self._multi @@ -61,11 +75,16 @@ class HonCommand: def setting_keys(self): if not self._multi: return self._get_settings_keys() - result = [key for cmd in self._multi.values() for key in self._get_settings_keys(cmd)] + result = [ + key for cmd in self._multi.values() for key in self._get_settings_keys(cmd) + ] return list(set(result + ["program"])) @property def settings(self): """Parameters with typology enum and range""" - return {s: self._parameters.get(s) for s in self.setting_keys if self._parameters.get(s) is not None} - + return { + s: self._parameters.get(s) + for s in self.setting_keys + if self._parameters.get(s) is not None + } diff --git a/pyhon/connection/api.py b/pyhon/connection/api.py index 34566cc..c67a7e7 100644 --- a/pyhon/connection/api.py +++ b/pyhon/connection/api.py @@ -71,7 +71,7 @@ class HonAPI: params = { "macAddress": appliance.mac_address, "applianceType": appliance.appliance_type, - "category": "CYCLE" + "category": "CYCLE", } url = f"{const.API_URL}/commands/v1/context" async with self._hon.get(url, params=params) as response: @@ -80,7 +80,7 @@ class HonAPI: async def load_statistics(self, appliance: HonAppliance): params = { "macAddress": appliance.mac_address, - "applianceType": appliance.appliance_type + "applianceType": appliance.appliance_type, } url = f"{const.API_URL}/commands/v1/statistics" async with self._hon.get(url, params=params) as response: @@ -98,11 +98,11 @@ class HonAPI: "attributes": { "channel": "mobileApp", "origin": "standardProgram", - "energyLabel": "0" + "energyLabel": "0", }, "ancillaryParameters": ancillary_parameters, "parameters": parameters, - "applianceType": appliance.appliance_type + "applianceType": appliance.appliance_type, } url = f"{const.API_URL}/commands/v1/send" async with self._hon.post(url, json=data) as resp: @@ -125,9 +125,9 @@ class HonAPI: "languageCode": language, "beta": beta, "appVersion": const.APP_VERSION, - "os": const.OS + "os": const.OS, } - payload = json.dumps(payload, separators=(',', ':')) + payload = json.dumps(payload, separators=(",", ":")) async with self._hon_anonymous.post(url, data=payload) as response: if (result := await response.json()) and (data := result.get("payload")): return data diff --git a/pyhon/connection/auth.py b/pyhon/connection/auth.py index 86960bc..2404102 100644 --- a/pyhon/connection/auth.py +++ b/pyhon/connection/auth.py @@ -45,26 +45,37 @@ class HonAuth: params = { "response_type": "token+id_token", "client_id": const.CLIENT_ID, - "redirect_uri": urllib.parse.quote(f"{const.APP}://mobilesdk/detect/oauth/done"), + "redirect_uri": urllib.parse.quote( + f"{const.APP}://mobilesdk/detect/oauth/done" + ), "display": "touch", "scope": "api openid refresh_token web", - "nonce": nonce + "nonce": nonce, } params = "&".join([f"{k}={v}" for k, v in params.items()]) - async with self._session.get(f"{const.AUTH_API}/services/oauth2/authorize/expid_Login?{params}") as resp: + async with self._session.get( + f"{const.AUTH_API}/services/oauth2/authorize/expid_Login?{params}" + ) as resp: if not (login_url := re.findall("url = '(.+?)'", await resp.text())): return False async with self._session.get(login_url[0], allow_redirects=False) as redirect1: if not (url := redirect1.headers.get("Location")): return False async with self._session.get(url, allow_redirects=False) as redirect2: - if not (url := redirect2.headers.get("Location") + "&System=IoT_Mobile_App&RegistrationSubChannel=hOn"): + if not ( + url := redirect2.headers.get("Location") + + "&System=IoT_Mobile_App&RegistrationSubChannel=hOn" + ): return False async with self._session.get(URL(url, encoded=True)) as login_screen: - if context := re.findall('"fwuid":"(.*?)","loaded":(\\{.*?})', await login_screen.text()): + if context := re.findall( + '"fwuid":"(.*?)","loaded":(\\{.*?})', await login_screen.text() + ): fw_uid, loaded_str = context[0] loaded = json.loads(loaded_str) - login_url = login_url[0].replace("/".join(const.AUTH_API.split("/")[:-1]), "") + login_url = login_url[0].replace( + "/".join(const.AUTH_API.split("/")[:-1]), "" + ) return fw_uid, loaded, login_url return False @@ -79,8 +90,10 @@ class HonAuth: "params": { "username": self._email, "password": self._password, - "startUrl": parse.unquote(login_url.split("startURL=")[-1]).split("%3D")[0] - } + "startUrl": parse.unquote( + login_url.split("startURL=")[-1] + ).split("%3D")[0], + }, } ] }, @@ -91,23 +104,28 @@ class HonAuth: "loaded": loaded, "dn": [], "globals": {}, - "uad": False}, + "uad": False, + }, "aura.pageURI": login_url, - "aura.token": None} - + "aura.token": None, + } params = {"r": 3, "other.LightningLoginCustom.login": 1} async with self._session.post( - const.AUTH_API + "/s/sfsites/aura", - headers={"Content-Type": "application/x-www-form-urlencoded"}, - data="&".join(f"{k}={json.dumps(v)}" for k, v in data.items()), - params=params + const.AUTH_API + "/s/sfsites/aura", + headers={"Content-Type": "application/x-www-form-urlencoded"}, + data="&".join(f"{k}={json.dumps(v)}" for k, v in data.items()), + params=params, ) as response: if response.status == 200: try: - return (await response.json())["events"][0]["attributes"]["values"]["url"] + return (await response.json())["events"][0]["attributes"]["values"][ + "url" + ] except json.JSONDecodeError: pass - _LOGGER.error("Unable to login: %s\n%s", response.status, await response.text()) + _LOGGER.error( + "Unable to login: %s\n%s", response.status, await response.text() + ) return "" async def _get_token(self, url): @@ -147,7 +165,9 @@ class HonAuth: post_headers = {"id-token": self._id_token} data = self._device.get() - async with self._session.post(f"{const.API_URL}/auth/v1/login", headers=post_headers, json=data) as resp: + async with self._session.post( + f"{const.API_URL}/auth/v1/login", headers=post_headers, json=data + ) as resp: try: json_data = await resp.json() except json.JSONDecodeError: @@ -160,13 +180,13 @@ class HonAuth: params = { "client_id": const.CLIENT_ID, "refresh_token": self._refresh_token, - "grant_type": "refresh_token" + "grant_type": "refresh_token", } - async with self._session.post(f"{const.AUTH_API}/services/oauth2/token", params=params) as resp: + async with self._session.post( + f"{const.AUTH_API}/services/oauth2/token", params=params + ) as resp: if resp.status >= 400: return False data = await resp.json() self._id_token = data["id_token"] self._access_token = data["access_token"] - - diff --git a/pyhon/connection/device.py b/pyhon/connection/device.py index f817885..f7399d9 100644 --- a/pyhon/connection/device.py +++ b/pyhon/connection/device.py @@ -32,5 +32,10 @@ class HonDevice: return self._mobile_id def get(self): - return {"appVersion": self.app_version, "mobileId": self.mobile_id, "osVersion": self.os_version, - "os": self.os, "deviceModel": self.device_model} + return { + "appVersion": self.app_version, + "mobileId": self.mobile_id, + "osVersion": self.os_version, + "os": self.os, + "deviceModel": self.device_model, + } diff --git a/pyhon/connection/handler.py b/pyhon/connection/handler.py index 2a3cf55..428e52d 100644 --- a/pyhon/connection/handler.py +++ b/pyhon/connection/handler.py @@ -59,7 +59,10 @@ class HonConnectionHandler(HonBaseConnectionHandler): return self async def _check_headers(self, headers): - if "cognito-token" not in self._request_headers or "id-token" not in self._request_headers: + if ( + "cognito-token" not in self._request_headers + or "id-token" not in self._request_headers + ): if await self._auth.authorize(): self._request_headers["cognito-token"] = self._auth.cognito_token self._request_headers["id-token"] = self._auth.id_token @@ -76,19 +79,33 @@ class HonConnectionHandler(HonBaseConnectionHandler): await self._auth.refresh() yield await self._intercept(method, *args, loop=loop + 1, **kwargs) elif response.status == 403 and loop < 2: - _LOGGER.warning("%s - Error %s - %s", response.request_info.url, response.status, await response.text()) + _LOGGER.warning( + "%s - Error %s - %s", + response.request_info.url, + response.status, + await response.text(), + ) await self.create() yield await self._intercept(method, *args, loop=loop + 1, **kwargs) elif loop >= 2: - _LOGGER.error("%s - Error %s - %s", response.request_info.url, response.status, await response.text()) + _LOGGER.error( + "%s - Error %s - %s", + response.request_info.url, + response.status, + await response.text(), + ) raise PermissionError("Login failure") else: try: await response.json() yield response except json.JSONDecodeError: - _LOGGER.warning("%s - JsonDecodeError %s - %s", response.request_info.url, response.status, - await response.text()) + _LOGGER.warning( + "%s - JsonDecodeError %s - %s", + response.request_info.url, + response.status, + await response.text(), + ) yield {} @asynccontextmanager diff --git a/pyhon/hon.py b/pyhon/hon.py index f30783c..0b7c88f 100644 --- a/pyhon/hon.py +++ b/pyhon/hon.py @@ -29,8 +29,11 @@ class Hon: appliance = HonAppliance(self._api, appliance) if appliance.mac_address is None: continue - await asyncio.gather(*[ - appliance.load_attributes(), - appliance.load_commands(), - appliance.load_statistics()]) + await asyncio.gather( + *[ + appliance.load_attributes(), + appliance.load_commands(), + appliance.load_statistics(), + ] + ) self._appliances.append(appliance) diff --git a/pyhon/parameter.py b/pyhon/parameter.py index 647fb5d..0814823 100644 --- a/pyhon/parameter.py +++ b/pyhon/parameter.py @@ -79,7 +79,9 @@ class HonParameterRange(HonParameter): if self._min <= value <= self._max and not value % self._step: self._value = value else: - raise ValueError(f"Allowed: min {self._min} max {self._max} step {self._step}") + raise ValueError( + f"Allowed: min {self._min} max {self._max} step {self._step}" + ) class HonParameterEnum(HonParameter): @@ -138,4 +140,10 @@ class HonParameterProgram(HonParameterEnum): @property def values(self): - return sorted([str(value) for value in self._values if not self._filter or self._filter in str(value)]) + return sorted( + [ + str(value) + for value in self._values + if not self._filter or self._filter in str(value) + ] + ) diff --git a/setup.py b/setup.py index df6672c..dfbfbeb 100644 --- a/setup.py +++ b/setup.py @@ -11,7 +11,7 @@ setup( author="Andre Basche", description="Control hOn devices with python", long_description=long_description, - long_description_content_type='text/markdown', + long_description_content_type="text/markdown", project_urls={ "GitHub": "https://github.com/Andre0512/pyhOn", "PyPI": "https://pypi.org/project/pyhOn", @@ -33,8 +33,8 @@ setup( "Topic :: Software Development :: Libraries :: Python Modules", ], entry_points={ - 'console_scripts': [ - 'pyhOn = pyhon.__main__:start', + "console_scripts": [ + "pyhOn = pyhon.__main__:start", ] - } + }, ) From e8531f3fafe02a6edfe01d7e59a0a8e25bbc9083 Mon Sep 17 00:00:00 2001 From: Andre Basche Date: Sun, 9 Apr 2023 23:47:33 +0200 Subject: [PATCH 5/7] Small fixes, Add checks --- .github/workflows/python-check.yml | 39 ++++++++++++++++++++++++++++++ README.md | 16 ++++++------ pyhon/__init__.py | 4 ++- pyhon/__main__.py | 1 - pyhon/connection/api.py | 9 ++++--- pyhon/connection/handler.py | 4 +-- 6 files changed, 58 insertions(+), 15 deletions(-) create mode 100644 .github/workflows/python-check.yml mode change 100644 => 100755 pyhon/__main__.py diff --git a/.github/workflows/python-check.yml b/.github/workflows/python-check.yml new file mode 100644 index 0000000..b5b6b8f --- /dev/null +++ b/.github/workflows/python-check.yml @@ -0,0 +1,39 @@ +name: Python check + +on: + push: + branches: [ "main", "refactor" ] + pull_request: + branches: [ "main" ] + +jobs: + build: + + runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + python-version: ["3.10", "3.11"] + + steps: + - uses: actions/checkout@v3 + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v3 + with: + python-version: ${{ matrix.python-version }} + - name: Install dependencies + run: | + python -m pip install --upgrade pip + python -m pip install -r requirements.txt + python -m pip install flake8 pylint black + - name: Lint with flake8 + run: | + # stop the build if there are Python syntax errors or undefined names + flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics + flake8 . --count --exit-zero --max-complexity=10 --max-line-length=88 --statistics + # - name: Analysing the code with pylint + # run: | + # pylint --max-line-length 88 $(git ls-files '*.py') + - name: Check black style + run: | + black . --check diff --git a/README.md b/README.md index 46cfb42..b28df60 100644 --- a/README.md +++ b/README.md @@ -47,28 +47,28 @@ settings: ### List devices ```python import asyncio -from pyhon import HonConnection +from pyhon import Hon async def devices_example(): - async with HonConnection(USER, PASSWORD) as hon: - for device in hon.devices: - print(device.nick_name) + async with Hon(USER, PASSWORD) as hon: + for appliance in hon.appliances: + print(appliance.nick_name) asyncio.run(devices_example()) ``` ### Execute a command ```python -async with HonConnection(USER, PASSWORD) as hon: - washing_machine = hon.devices[0] +async with Hon(USER, PASSWORD) as hon: + washing_machine = hon.appliances[0] pause_command = washing_machine.commands["pauseProgram"] await pause_command.send() ``` ### Set command parameter ```python -async with HonConnection(USER, PASSWORD) as hon: - washing_machine = hon.devices[0] +async with Hon(USER, PASSWORD) as hon: + washing_machine = hon.appliances[0] start_command = washing_machine.commands["startProgram"] for name, setting in start_command.settings: print("Setting", name) diff --git a/pyhon/__init__.py b/pyhon/__init__.py index e2b5e87..93728b7 100644 --- a/pyhon/__init__.py +++ b/pyhon/__init__.py @@ -1,2 +1,4 @@ from .connection.api import HonAPI -from hon import Hon +from .hon import Hon + +__all__ = ["Hon", "HonAPI"] diff --git a/pyhon/__main__.py b/pyhon/__main__.py old mode 100644 new mode 100755 index 7eac5b6..a7afac8 --- a/pyhon/__main__.py +++ b/pyhon/__main__.py @@ -6,7 +6,6 @@ import logging import sys from getpass import getpass from pathlib import Path -from pprint import pprint if __name__ == "__main__": sys.path.insert(0, str(Path(__file__).parent.parent)) diff --git a/pyhon/connection/api.py b/pyhon/connection/api.py index c67a7e7..afe8591 100644 --- a/pyhon/connection/api.py +++ b/pyhon/connection/api.py @@ -10,12 +10,13 @@ _LOGGER = logging.getLogger() class HonAPI: - def __init__(self, email="", password="") -> None: + def __init__(self, email="", password="", anonymous=False) -> None: super().__init__() self._email = email self._password = password + self._anonymous = anonymous self._hon = None - self._hon_anonymous = HonAnonymousConnectionHandler() + self._hon_anonymous = None async def __aenter__(self): return await self.create() @@ -24,7 +25,9 @@ class HonAPI: await self._hon.close() async def create(self): - self._hon = await HonConnectionHandler(self._email, self._password).create() + self._hon_anonymous = HonAnonymousConnectionHandler() + if not self._anonymous: + self._hon = await HonConnectionHandler(self._email, self._password).create() return self async def load_appliances(self): diff --git a/pyhon/connection/handler.py b/pyhon/connection/handler.py index 428e52d..a239a69 100644 --- a/pyhon/connection/handler.py +++ b/pyhon/connection/handler.py @@ -27,11 +27,11 @@ class HonBaseConnectionHandler: @asynccontextmanager async def get(self, *args, **kwargs): - raise NotImplemented + raise NotImplementedError @asynccontextmanager async def post(self, *args, **kwargs): - raise NotImplemented + raise NotImplementedError async def close(self): await self._session.close() From 3e3fc7ad66c541449110908813dace0ddc2519a7 Mon Sep 17 00:00:00 2001 From: Andre Basche Date: Mon, 10 Apr 2023 06:34:19 +0200 Subject: [PATCH 6/7] Fix translation command --- pyhon/__main__.py | 2 +- pyhon/connection/api.py | 18 ++++++++++++----- pyhon/connection/handler.py | 40 ++++++++++++++++--------------------- pyhon/hon.py | 19 +++++++++++++----- 4 files changed, 45 insertions(+), 34 deletions(-) diff --git a/pyhon/__main__.py b/pyhon/__main__.py index a7afac8..38e6958 100755 --- a/pyhon/__main__.py +++ b/pyhon/__main__.py @@ -90,7 +90,7 @@ def create_command(commands, concat=False): async def translate(language, json_output=False): - async with HonAPI() as hon: + async with HonAPI(anonymous=True) as hon: keys = await hon.translation_keys(language) if json_output: print(json.dumps(keys, indent=4)) diff --git a/pyhon/connection/api.py b/pyhon/connection/api.py index afe8591..dfa2b65 100644 --- a/pyhon/connection/api.py +++ b/pyhon/connection/api.py @@ -10,24 +10,29 @@ _LOGGER = logging.getLogger() class HonAPI: - def __init__(self, email="", password="", anonymous=False) -> None: + def __init__(self, email="", password="", anonymous=False, session=None) -> None: super().__init__() self._email = email self._password = password self._anonymous = anonymous self._hon = None self._hon_anonymous = None + self._session = session async def __aenter__(self): return await self.create() async def __aexit__(self, exc_type, exc_val, exc_tb): - await self._hon.close() + await self.close() async def create(self): - self._hon_anonymous = HonAnonymousConnectionHandler() + self._hon_anonymous = await HonAnonymousConnectionHandler( + self._session + ).create() if not self._anonymous: - self._hon = await HonConnectionHandler(self._email, self._password).create() + self._hon = await HonConnectionHandler( + self._email, self._password, self._session + ).create() return self async def load_appliances(self): @@ -145,4 +150,7 @@ class HonAPI: return {} async def close(self): - await self._hon.close() + if self._hon: + await self._hon.close() + if self._hon_anonymous: + await self._hon_anonymous.close() diff --git a/pyhon/connection/handler.py b/pyhon/connection/handler.py index a239a69..b16f48a 100644 --- a/pyhon/connection/handler.py +++ b/pyhon/connection/handler.py @@ -11,8 +11,8 @@ from pyhon.connection.device import HonDevice class HonBaseConnectionHandler: _HEADERS = {"user-agent": const.USER_AGENT, "Content-Type": "application/json"} - def __init__(self): - self._session = None + def __init__(self, session=None): + self._session = session self._auth = None async def __aenter__(self): @@ -26,20 +26,26 @@ class HonBaseConnectionHandler: return self @asynccontextmanager - async def get(self, *args, **kwargs): + async def _intercept(self, method, *args, loop=0, **kwargs): raise NotImplementedError + @asynccontextmanager + async def get(self, *args, **kwargs): + async with self._intercept(self._session.get, *args, **kwargs) as response: + yield response + @asynccontextmanager async def post(self, *args, **kwargs): - raise NotImplementedError + async with self._intercept(self._session.post, *args, **kwargs) as response: + yield response async def close(self): await self._session.close() class HonConnectionHandler(HonBaseConnectionHandler): - def __init__(self, email, password): - super().__init__() + def __init__(self, email, password, session=None): + super().__init__(session=session) self._device = HonDevice() self._email = email self._password = password @@ -108,26 +114,14 @@ class HonConnectionHandler(HonBaseConnectionHandler): ) yield {} - @asynccontextmanager - async def get(self, *args, **kwargs): - async with self._intercept(self._session.get, *args, **kwargs) as response: - yield response - - @asynccontextmanager - async def post(self, *args, **kwargs): - async with self._intercept(self._session.post, *args, **kwargs) as response: - yield response - class HonAnonymousConnectionHandler(HonBaseConnectionHandler): _HEADERS = HonBaseConnectionHandler._HEADERS | {"x-api-key": const.API_KEY} @asynccontextmanager - async def get(self, *args, **kwargs): - async with self._session.post(*args, **kwargs) as response: - yield response - - @asynccontextmanager - async def post(self, *args, **kwargs): - async with self._session.post(*args, **kwargs) as response: + async def _intercept(self, method, *args, loop=0, **kwargs): + kwargs["headers"] = kwargs.pop("headers", {}) | self._HEADERS + async with method(*args, **kwargs) as response: + if response.status == 403: + print("Can't authorize") yield response diff --git a/pyhon/hon.py b/pyhon/hon.py index 0b7c88f..322b077 100644 --- a/pyhon/hon.py +++ b/pyhon/hon.py @@ -6,19 +6,25 @@ from pyhon.appliance import HonAppliance class Hon: - def __init__(self, email, password): + def __init__(self, email, password, session=None): self._email = email self._password = password + self._session = session self._appliances = [] self._api = None async def __aenter__(self): - self._api = await HonAPI(self._email, self._password).create() - await self.setup() - return self + return await self.create() async def __aexit__(self, exc_type, exc_val, exc_tb): - await self._api.close() + await self.close() + + async def create(self): + self._api = await HonAPI( + self._email, self._password, session=self._session + ).create() + await self.setup() + return self @property def appliances(self) -> List[HonAppliance]: @@ -37,3 +43,6 @@ class Hon: ] ) self._appliances.append(appliance) + + async def close(self): + await self._api.close() From ba208ffd98aa8c47731cc12d71f90164bfc52eb3 Mon Sep 17 00:00:00 2001 From: Andre Basche Date: Mon, 10 Apr 2023 06:42:40 +0200 Subject: [PATCH 7/7] Improve logging --- pyhon/connection/auth.py | 20 ++++++++++++++------ setup.py | 2 +- 2 files changed, 15 insertions(+), 7 deletions(-) diff --git a/pyhon/connection/auth.py b/pyhon/connection/auth.py index 2404102..b6e0d5e 100644 --- a/pyhon/connection/auth.py +++ b/pyhon/connection/auth.py @@ -3,6 +3,7 @@ import logging import re import secrets import urllib +from pprint import pformat from urllib import parse from yarl import URL @@ -118,11 +119,14 @@ class HonAuth: ) as response: if response.status == 200: try: - return (await response.json())["events"][0]["attributes"]["values"][ - "url" - ] + data = await response.json() + return data["events"][0]["attributes"]["values"]["url"] except json.JSONDecodeError: pass + except KeyError: + _LOGGER.error( + "Can't get login url - %s", pformat(await response.json()) + ) _LOGGER.error( "Unable to login: %s\n%s", response.status, await response.text() ) @@ -133,7 +137,10 @@ class HonAuth: if resp.status != 200: _LOGGER.error("Unable to get token: %s", resp.status) return False - url = re.findall("href\\s*=\\s*[\"'](.*?)[\"']", await resp.text()) + url = re.findall("href\\s*=\\s*[\"'](http.+?)[\"']", await resp.text()) + if not url: + _LOGGER.error("Can't get login url - \n%s", await resp.text()) + raise PermissionError async with self._session.get(url[0]) as resp: if resp.status != 200: _LOGGER.error("Unable to get token: %s", resp.status) @@ -188,5 +195,6 @@ class HonAuth: if resp.status >= 400: return False data = await resp.json() - self._id_token = data["id_token"] - self._access_token = data["access_token"] + self._id_token = data["id_token"] + self._access_token = data["access_token"] + return True diff --git a/setup.py b/setup.py index dfbfbeb..83d4176 100644 --- a/setup.py +++ b/setup.py @@ -7,7 +7,7 @@ with open("README.md", "r") as f: setup( name="pyhOn", - version="0.5.0", + version="0.6.0", author="Andre Basche", description="Control hOn devices with python", long_description=long_description,