python-aidot 0.3.55__py3-none-any.whl → 0.3.56__py3-none-any.whl

aidot/aes_utils.py

@@ -0,0 +1,50 @@
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+from cryptography.hazmat.backends import default_backend
+from cryptography.hazmat.primitives import padding
+import json
+from typing import Any, Optional
+
+
+def aes_encrypt(plaintext, key):
+    padder = padding.PKCS7(algorithms.AES.block_size).padder()
+    padded_data = padder.update(plaintext) + padder.finalize()
+
+    cipher = Cipher(algorithms.AES(key), modes.ECB(), backend=default_backend())
+    encryptor = cipher.encryptor()
+
+    ciphertext = encryptor.update(padded_data) + encryptor.finalize()
+
+    return ciphertext
+
+
+def aes_decrypt(ciphertext, key):
+    cipher = Cipher(algorithms.AES(key), modes.ECB(), backend=default_backend())
+    decryptor = cipher.decryptor()
+
+    decrypted_data = decryptor.update(ciphertext) + decryptor.finalize()
+
+    unpadder = padding.PKCS7(algorithms.AES.block_size).unpadder()
+    plaintext = unpadder.update(decrypted_data) + unpadder.finalize()
+
+    return plaintext.decode()
+
+
+def aes_decrypt_to_json(
+    ciphertext: bytes, key: Optional[bytes] = None
+) -> dict[str, Any]:
+    """Decrypt AES encrypted data and parse to JSON.
+
+    Args:
+        ciphertext: AES encrypted data
+        key: AES key (optional, if None, assumes data is already decrypted)
+
+    Returns:
+        Parsed JSON dict
+    """
+    if key:
+        decrypted_data = aes_decrypt(ciphertext, key)
+    else:
+        decrypted_data = (
+            ciphertext.decode() if isinstance(ciphertext, bytes) else ciphertext
+        )
+    return json.loads(decrypted_data)

aidot/client.py

@@ -2,43 +2,63 @@
 
 import asyncio
 import logging
+import base64
+import aiohttp
 from aiohttp import ClientSession
 from typing import Any, Optional
+from cryptography.hazmat.backends import default_backend
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric import padding
 import uuid
 from pathlib import Path
 import hashlib
-
-from .utils import rsa_encrypt
+from .exceptions import AidotAuthFailed, AidotUserOrPassIncorrect
 from .device_client import DeviceClient
-from .models.auth_model import UserInformation, LoginRequest
-from .models.device_model import DeviceModel
-from .api.cloud_api import CloudApi
 from .discover import Discover
-from .const import PUBLIC_KEY_PEM
+from .login_const import APP_ID, PUBLIC_KEY_PEM, API_URL_TEMPLATE, DEFAULT_REGION
 from .const import (
+    CONF_ACCESS_TOKEN,
+    CONF_APP_ID,
+    CONF_CODE,
+    CONF_COUNTRY,
+    CONF_DEVICE_LIST,
     CONF_ID,
     CONF_IPADDRESS,
-    CONF_LOGIN_INFO,
-    CONF_DEVICE_LIST,
+    CONF_PASSWORD,
     CONF_PRODUCT,
     CONF_PRODUCT_ID,
-    CONF_IS_OWNER,
+    CONF_REFRESH_TOKEN,
+    CONF_REGION,
+    CONF_TERMINAL,
+    CONF_TOKEN,
+    CONF_USERNAME,
+    DEFAULT_COUNTRY_NAME,
     SUPPORTED_COUNTRYS,
-    CONF_TYPE,
-    CONF_AES_KEY,
+    DEFAULT_COUNTRY_CODE,
+    CONF_IS_OWNER,
+    CONF_LOGIN_INFO,
+    ServerErrorCode,
 )
 
 _LOGGER = logging.getLogger(__name__)
 
 
-class AidotClient:
-    """AiDot client for managing devices and authentication."""
+def rsa_password_encrypt(message: str) -> str:
+    """Get password rsa encrypt."""
+    public_key = serialization.load_pem_public_key(
+        PUBLIC_KEY_PEM, backend=default_backend()
+    )
+
+    encrypted = public_key.encrypt(
+        message.encode("utf-8"),
+        padding.PKCS1v15(),
+    )
 
-    _device_clients: dict[str, DeviceClient]
-    user_info: UserInformation = None
-    _token_fresh_cb: Optional[callable] = None
-    _products: dict[str, dict[str, Any]] = {}
+    encrypted_base64 = base64.b64encode(encrypted).decode("utf-8")
+    return encrypted_base64
 
+
+class AidotClient:
     def __init__(
         self,
         session: Optional[ClientSession],
@@ -47,55 +67,49 @@ class AidotClient:
         password: str | None = None,
         token: dict | None = None,
     ) -> None:
-        _LOGGER.info("Client Version: v0.3.55")
-        self.country_code = country_code
+        _LOGGER.info("Client Version: v0.3.56")
+        self.session = session
+        self.username = username
+        self.password = password
+        self.country_code = country_code or DEFAULT_COUNTRY_CODE
+        self.country_name = DEFAULT_COUNTRY_NAME
+        self._region = DEFAULT_REGION
+        self._base_url = API_URL_TEMPLATE.format(region=self._region)
+        self.login_info: dict[str, Any] = {}
         self._device_clients = {}
-        self.user_info = UserInformation(
-            username=username, password=password, country_code=country_code
-        )
-
-        # Set region and country from country_code
+        self._discover: Discover | None = None
+        self._token_fresh_cb = None
         for item in SUPPORTED_COUNTRYS:
-            if item[CONF_ID] == self.country_code:
-                self.user_info.country = item["name"]
-                self.user_info.region = item["region"].lower()
+            if item["id"] == self.country_code:
+                self.country_name = item["name"]
+                self._region = item["region"].lower()
+                self._base_url = API_URL_TEMPLATE.format(region=self._region)
                 break
-
-        # Handle token (existing login info)
         if token is not None:
+            # ✅ 兼容性处理: v1.0.8 数据结构迁移到 v1.1.3
+            # 旧版本: config_entry.data[CONF_LOGIN_INFO]
+            # 新版本: config_entry.data
             if token.get(CONF_ID) is None and token.get(CONF_LOGIN_INFO) is not None:
                 token = token.get(CONF_LOGIN_INFO)
-            self.user_info.update_from_json(token)
-
-        self._cloud_api = CloudApi(
-            session=session,
-            user_info=self.user_info,
-            auth_failed_callback=self._on_auth_failed,
-            token_refreshed_callback=self._on_token_refreshed,
-        )
-        self.setup_discover()
 
-    @property
-    def login_info(self) -> dict:
-        return self.user_info.to_dict()
-
-    def _on_auth_failed(self) -> None:
-        """Handle authentication failed event from CloudApi."""
-        _LOGGER.warning("Authentication failed, clearing user info")
-        self.user_info.accessToken = ""
-
-    def _on_token_refreshed(self) -> None:
-        """Handle token refreshed event from CloudApi."""
-        _LOGGER.debug("Token refreshed successfully")
-        if self._token_fresh_cb:
-            self._token_fresh_cb()
+            self.login_info = token.copy()
+            self.username = token[CONF_USERNAME]
+            self.password = token[CONF_PASSWORD]
+            self._region = token[CONF_REGION]
+            self.country_name = token[CONF_COUNTRY]
+            self._base_url = API_URL_TEMPLATE.format(region=self._region)
+        self.setup_discover()
 
     def set_token_fresh_cb(self, callback) -> None:
-        """Set callback for token refresh events."""
         self._token_fresh_cb = callback
 
+    def get_identifier(self) -> str:
+        return f"{self._region}-{self.username}"
+
+    def update_password(self, password: str) -> None:
+        self.password = password
+
     async def get_terminal_id(self) -> str:
-        """Get or create terminal ID for device identification."""
         file_path = Path.home() / ".aidot_terminal_id"
 
         def _read_or_create() -> str:
@@ -115,95 +129,186 @@ class AidotClient:
 
     async def async_post_login(self) -> dict[str, Any]:
         """Login the user input allows us to connect."""
-        terminal_id = await self.get_terminal_id()
-
-        login_request = LoginRequest.create(
-            username=self.user_info.username,
-            encrypted_password=rsa_encrypt(self.user_info.password, PUBLIC_KEY_PEM),
-            country_name=self.user_info.country,
-            terminal_id=terminal_id,
-        )
-
-        response_data = await self._cloud_api.login(login_request.to_dict())
-        self.user_info.update_from_json(response_data)
-        self.setup_discover()
-        return self.user_info.to_dict()
+        url = f"{self._base_url}/users/loginWithFreeVerification"
+        headers = {CONF_APP_ID: APP_ID, CONF_TERMINAL: "app"}
+        # f"{region}:{self.country_name.strip()}",
+        terminalId = await self.get_terminal_id()
+        if terminalId is None:
+            terminalId = "gvz3gjae10l4zii00t7y0"
+        data = {
+            "countryKey": f"region:{self.country_name.strip()}",
+            "username": self.username,
+            "password": rsa_password_encrypt(self.password),
+            "terminalId": terminalId,
+            "webVersion": "0.5.0",
+            "area": "Asia/Shanghai",
+            "UTC": "UTC+8",
+        }
+
+        response_data: dict[str, Any] = {}
+        try:
+            response = await self.session.post(url, headers=headers, json=data)
+            response_data = await response.json()
+            response.raise_for_status()
+            self.login_info = response_data
+            self.login_info[CONF_PASSWORD] = self.password
+            self.login_info[CONF_REGION] = self._region
+            self.login_info[CONF_COUNTRY] = self.country_name
+            self.setup_discover()
+            return self.login_info
+        except aiohttp.ClientError as err:
+            _LOGGER.error("async_post_login ClientError: %s", err)
+            if response_data.get(CONF_CODE) == ServerErrorCode.USER_PWD_INCORRECT:
+                raise AidotUserOrPassIncorrect from err
+            raise
+
+    async def async_refresh_token(self) -> dict[str, Any]:
+        url = f"{self._base_url}/users/refreshToken"
+        headers = {CONF_APP_ID: APP_ID, CONF_TERMINAL: "app"}
+        data = {
+            CONF_REFRESH_TOKEN: self.login_info[CONF_REFRESH_TOKEN],
+        }
+
+        response_data: dict[str, Any] = {}
+        try:
+            response = await self.session.post(url, headers=headers, json=data)
+            response_data = await response.json()
+            response.raise_for_status()
+            self.login_info[CONF_ACCESS_TOKEN] = response_data[CONF_ACCESS_TOKEN]
+            if response_data[CONF_REFRESH_TOKEN] is not None:
+                self.login_info[CONF_REFRESH_TOKEN] = response_data[CONF_REFRESH_TOKEN]
+            _LOGGER.debug(f"refresh token: {response_data}")
+            if self._token_fresh_cb:
+                self._token_fresh_cb()
+            return response_data
+        except aiohttp.ClientError as err:
+            _LOGGER.error("async_refresh_token ClientError: %s %s", err, response_data)
+            if response_data.get(CONF_CODE) == ServerErrorCode.LOGIN_INVALID:
+                raise AidotAuthFailed from err
+            raise
+
+    async def async_session_get(
+        self, params: str, headers: str | None = None
+    ) -> dict[str, Any]:
+        url = f"{self._base_url}{params}"
+        token = self.login_info[CONF_ACCESS_TOKEN]
+        if token is None:
+            raise AidotAuthFailed()
+        if headers is None:
+            headers = {
+                CONF_TERMINAL: "app",
+                CONF_TOKEN: token,
+                CONF_APP_ID: APP_ID,
+            }
+        response_data = {}
+        try:
+            response = await self.session.get(url, headers=headers)
+            response_data = await response.json()
+            response.raise_for_status()
+            return response_data
+        except aiohttp.ClientError as err:
+            _LOGGER.error("async_get ClientError: %s %s", err, response_data)
+            code = response_data.get(CONF_CODE)
+            if code == ServerErrorCode.TOKEN_EXPIRED:
+                try:
+                    await self.async_refresh_token()
+                    return await self.async_session_get(params)
+                except AidotAuthFailed as auth_err:
+                    raise AidotAuthFailed from auth_err
+            elif (
+                code == ServerErrorCode.LOGIN_INVALID or code == 21027 or code == 21041
+            ):
+                self.login_info[CONF_ACCESS_TOKEN] = None
+                raise AidotAuthFailed from err
+            raise
+
+    async def async_get_products(self, product_ids: str) -> list[dict[str, Any]]:
+        """Get device list."""
+        params = f"/products/{product_ids}"
+        return await self.async_session_get(params)
+
+    async def async_get_devices(self, house_id: str) -> list[dict[str, Any]]:
+        """Get device list."""
+        params = f"/devices?houseId={house_id}"
+        return await self.async_session_get(params)
+
+    async def async_get_houses(self) -> list[dict[str, Any]]:
+        """Get house list."""
+        params = "/houses"
+        return await self.async_session_get(params)
 
     async def async_get_all_device(self) -> dict[str, Any]:
-        """Get all devices for the user."""
-        filter_devices: dict[str, Any] = {}
-        filter_product_ids: set[str] = set()
+        final_device_list: list[dict[str, Any]] = []
         try:
-            houses = await self._cloud_api.get_houses() or []
+            houses = await self.async_get_houses()
             for house in houses:
                 if house.get(CONF_IS_OWNER) is False:
                     continue
-                device_list = await self._cloud_api.get_devices(house[CONF_ID]) or []
-                for device in device_list:
-                    filter_device: dict[str, Any] = None
-                    if (
-                        device.get(CONF_TYPE) == "light"
-                        and device.get(CONF_AES_KEY, [None])[0] is not None
-                    ):
-                        filter_device = device
-                    if filter_device is not None:
-                        filter_devices[device[CONF_ID]] = device
-                        filter_product_ids.add(device[CONF_PRODUCT_ID])
-
-            # Get product info and merge into devices
-            if filter_product_ids:
-                product_ids = ",".join(filter_product_ids)
-                product_list = await self._cloud_api.get_products(product_ids) or []
-                product_map = {p[CONF_ID]: p for p in product_list}
-                for device in filter_devices.values():
-                    device[CONF_PRODUCT] = product_map.get(device[CONF_PRODUCT_ID])
+                # get device_list
+                device_list = await self.async_get_devices(house[CONF_ID])
+                if device_list:
+                    final_device_list.extend(device_list)
+
+            # get product_list
+            if not final_device_list:
+                return {CONF_DEVICE_LIST: []}
+            productIds = ",".join([item[CONF_PRODUCT_ID] for item in final_device_list])
+            product_list = await self.async_get_products(productIds)
+
+            for product in product_list:
+                for device in final_device_list:
+                    if device[CONF_PRODUCT_ID] == product[CONF_ID]:
+                        device[CONF_PRODUCT] = product
 
         except Exception as e:
             raise e
-        return filter_devices
+        return {CONF_DEVICE_LIST: final_device_list}
 
     def get_device_client(self, device: dict[str, Any]) -> DeviceClient:
-        """Get or create device client for a device."""
-        _device: DeviceModel = DeviceModel.from_json(data=device)
-        device_client: DeviceClient = self._device_clients.get(_device.id)
+        device_id = device.get(CONF_ID)
+        device_client: DeviceClient = self._device_clients.get(device_id)
         if device_client is None:
-            device_client = DeviceClient(_device, self.user_info)
-            self._device_clients[_device.id] = device_client
-
-        ip = Discover.DISCOVERED_DEVICE.get(_device.id)
-        device_client.update_ip_address(ip)
+            device_client = DeviceClient(device, self.login_info)
+            self._device_clients[device_id] = device_client
+        if self._discover is not None:
+            ip = self._discover.discovered_device.get(device_id)
+            device_client.update_ip_address(ip)
         return device_client
 
     async def remove_device_client(self, dev_id: str) -> None:
-        """Remove and close device client."""
         device_client: DeviceClient = self._device_clients.get(dev_id)
         if device_client is not None:
             await device_client.close()
             del self._device_clients[dev_id]
 
     def setup_discover(self) -> None:
-        """Initialize device discovery after login."""
-        if not self.user_info.id:
+        """初始化完成后调用，启动设备发现"""
+        if self.login_info.get(CONF_ID) is None:
+            return
+        if self._discover is not None:
             return
 
         _LOGGER.warning("setup_discover")
 
-        def _discover_callback(dev_id: str, event: dict[str, str]) -> None:
+        def _discover_callback(dev_id, event: dict[str, str]) -> None:
             device_ip = event[CONF_IPADDRESS]
             device_client: DeviceClient = self._device_clients.get(dev_id)
             if device_client is not None:
                 device_client.update_ip_address(device_ip)
 
-        Discover.set_call_back(_discover_callback)
-        Discover.set_user_info(self.user_info)
+        self._discover = Discover(self.login_info, _discover_callback)
+        self._discover.start_repeat_broadcast()
 
     async def async_close(self) -> None:
-        """Close client and cleanup resources."""
+        """关闭客户端，清理资源"""
+        if self._discover is not None:
+            self._discover.close()
+            self._discover = None
         for client in self._device_clients.values():
             await client.close()
         self._device_clients.clear()
 
     async def async_cleanup(self) -> None:
-        """Cleanup all resources."""
+        """清理所有资源"""
         _LOGGER.debug("async_cleanup")
         await self.async_close()

aidot/const.py

@@ -230,17 +230,3 @@ class ServerErrorCode(IntEnum):
     TOKEN_EXPIRED = 21026
     LOGIN_INVALID = 21025
     USER_PWD_INCORRECT = 560080
-
-
-# Login / API constants
-APP_ID = "1383974540041977857"
-API_URL_TEMPLATE = "https://prod-{region}-api.arnoo.com/v17"
-DEFAULT_REGION = "us"
-PUBLIC_KEY_PEM = b"""
------BEGIN PUBLIC KEY-----
-MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCtQAnPCi8ksPnS1Du6z96PsKfN
-p2Gp/f/bHwlrAdplbX3p7/TnGpnbJGkLq8uRxf6cw+vOthTsZjkPCF7CatRvRnTj
-c9fcy7yE0oXa5TloYyXD6GkxgftBbN/movkJJGQCc7gFavuYoAdTRBOyQoXBtm0m
-kXMSjXOldI/290b9BQIDAQAB
------END PUBLIC KEY-----
-"""