python-aidot 0.3.53__tar.gz → 0.3.54__tar.gz

{python_aidot-0.3.53 → python_aidot-0.3.54}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot
-Version: 0.3.53
+Version: 0.3.54
 Summary: aidot control wifi lights
 Home-page: https://github.com/Aidot-Development-Team/python-aidot
 Author: aidotdev2024

python_aidot-0.3.54/aidot/api/cloud_api.py

@@ -0,0 +1,180 @@
+"""Cloud API for AiDot - static class for HTTP requests."""
+
+import logging
+from typing import Any, Optional
+import aiohttp
+from aiohttp import ClientSession
+
+from ..const import (
+    API_URL_TEMPLATE,
+    CONF_ACCESS_TOKEN,
+    CONF_CODE,
+    CONF_REFRESH_TOKEN,
+    ServerErrorCode,
+)
+from ..exceptions import (
+    AidotAuthFailed,
+    AidotAuthTokenExpired,
+    AidotUserOrPassIncorrect,
+)
+from ..models.auth_model import RequestHeaders, UserInformation
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class CloudApi:
+    """Cloud API - static class for HTTP requests."""
+
+    BASE_URL: str = ""
+    SESSION: Optional[ClientSession] = None
+    USER_INFO: Optional[UserInformation] = None
+    _auth_failed_callback: Optional[callable] = None
+    _token_refreshed_callback: Optional[callable] = None
+
+    def __init__(self) -> None:
+        raise TypeError("CloudApi is a static class and cannot be instantiated")
+
+    @classmethod
+    def set_session(cls, session: ClientSession) -> None:
+        """Set the HTTP session."""
+        cls.SESSION = session
+
+    @classmethod
+    def set_user_info(cls, user_info: "UserInformation") -> None:
+        """Set user info and update base URL."""
+        cls.USER_INFO = user_info
+        cls.BASE_URL = API_URL_TEMPLATE.format(region=user_info.region)
+
+    @classmethod
+    def set_auth_failed_callback(cls, callback: callable) -> None:
+        """Set auth failure callback."""
+        cls._auth_failed_callback = callback
+
+    @classmethod
+    def set_token_refreshed_callback(cls, callback: callable) -> None:
+        """Set token refresh callback."""
+        cls._token_refreshed_callback = callback
+
+    @classmethod
+    def _get_headers(cls) -> dict[str, str]:
+        """Build request headers with access token."""
+        access_token = cls.USER_INFO.accessToken if cls.USER_INFO else None
+        return RequestHeaders.create(access_token)
+
+    @classmethod
+    async def login(cls, data: dict[str, Any]) -> dict[str, Any]:
+        """Login and return tokens."""
+        url = f"{cls.BASE_URL}/users/loginWithFreeVerification"
+        headers = cls._get_headers()
+
+        response_data = {}
+        try:
+            _LOGGER.info("POST %s body=%s", url, data)
+            response = await cls.SESSION.post(url, headers=headers, json=data)
+            response_data = await response.json()
+            response.raise_for_status()
+            _LOGGER.info("POST %s → %s resp=%s", url, response.status, response_data)
+            return response_data
+        except aiohttp.ClientError as e:
+            _LOGGER.error(f"login failed: {e} resp={response_data}")
+            if response_data.get(CONF_CODE) == ServerErrorCode.USER_PWD_INCORRECT:
+                raise AidotUserOrPassIncorrect
+            raise Exception
+
+    @classmethod
+    async def refresh_token(cls) -> dict[str, Any]:
+        """Refresh access token."""
+        if cls.USER_INFO is None:
+            raise AidotAuthFailed("No user info available")
+
+        url = f"{cls.BASE_URL}/users/refreshToken"
+        headers = cls._get_headers()
+        data = {
+            CONF_REFRESH_TOKEN: cls.USER_INFO.refreshToken,
+        }
+
+        response_data = {}
+        try:
+            _LOGGER.info("POST %s body=%s", url, data)
+            response = await cls.SESSION.post(url, headers=headers, json=data)
+            response_data = await response.json()
+            response.raise_for_status()
+
+            # Update tokens and notify
+            cls.USER_INFO.accessToken = response_data.get(CONF_ACCESS_TOKEN, "")
+            if response_data.get(CONF_REFRESH_TOKEN) is not None:
+                cls.USER_INFO.refreshToken = response_data[CONF_REFRESH_TOKEN]
+
+            # Notify callback
+            if cls._token_refreshed_callback:
+                cls._token_refreshed_callback()
+
+            _LOGGER.info("Token refreshed: %s", response_data)
+            return response_data
+        except aiohttp.ClientError as e:
+            _LOGGER.error(f"refresh_token failed: {e} resp={response_data}")
+            code = response_data.get(CONF_CODE)
+            if code == ServerErrorCode.LOGIN_INVALID or code in (21027, 21041):
+                raise AidotAuthFailed
+            return None
+
+    @classmethod
+    async def get(cls, params: str) -> dict[str, Any]:
+        """GET request with auto token refresh on 401."""
+        url = f"{cls.BASE_URL}{params}"
+        headers = cls._get_headers()
+
+        response_data = {}
+        try:
+            _LOGGER.info("GET %s", url)
+            response = await cls.SESSION.get(url, headers=headers)
+            response_data = await response.json()
+            response.raise_for_status()
+            _LOGGER.info("GET %s → %s", url, response.status)
+            return response_data
+        except aiohttp.ClientError as e:
+            _LOGGER.error(f"GET {params} failed: {e} resp={response_data}")
+            code = response_data.get(CONF_CODE)
+            if code == ServerErrorCode.TOKEN_EXPIRED:
+                try:
+                    refresh_data = await cls.refresh_token()
+                    if refresh_data:
+                        _LOGGER.info("Retrying GET %s", url)
+                        headers = cls._get_headers()
+                        response = await cls.SESSION.get(url, headers=headers)
+                        response_data = await response.json()
+                        response.raise_for_status()
+                        _LOGGER.info("GET %s → %s retry=ok", url, response.status)
+                        return response_data
+                except AidotAuthFailed:
+                    if cls._auth_failed_callback:
+                        cls._auth_failed_callback()
+                    raise
+                except Exception as refresh_error:
+                    _LOGGER.error(f"Token refresh failed: {refresh_error}")
+                    if cls._auth_failed_callback:
+                        cls._auth_failed_callback()
+                    raise AidotAuthFailed
+            elif code in (ServerErrorCode.LOGIN_INVALID, 21027, 21041):
+                if cls._auth_failed_callback:
+                    cls._auth_failed_callback()
+                raise AidotAuthFailed
+            raise
+
+    @classmethod
+    async def get_products(cls, product_ids: str) -> list[dict[str, Any]]:
+        """Get products by comma-separated IDs."""
+        params = f"/products/{product_ids}"
+        return await cls.get(params)
+
+    @classmethod
+    async def get_devices(cls, house_id: str) -> list[dict[str, Any]]:
+        """Get devices in a house."""
+        params = f"/devices?houseId={house_id}"
+        return await cls.get(params)
+
+    @classmethod
+    async def get_houses(cls) -> list[dict[str, Any]]:
+        """Get all houses for the user."""
+        params = "/houses"
+        return await cls.get(params)

python_aidot-0.3.54/aidot/client.py

@@ -0,0 +1,208 @@
+"""The aidot integration."""
+
+import asyncio
+import logging
+from aiohttp import ClientSession
+from typing import Any, Optional
+import uuid
+from pathlib import Path
+import hashlib
+
+from .utils import rsa_encrypt
+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 .const import (
+    CONF_ID,
+    CONF_IPADDRESS,
+    CONF_LOGIN_INFO,
+    CONF_DEVICE_LIST,
+    CONF_PRODUCT,
+    CONF_PRODUCT_ID,
+    CONF_IS_OWNER,
+    SUPPORTED_COUNTRYS,
+    CONF_TYPE,
+    CONF_AES_KEY,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class AidotClient:
+    """AiDot client for managing devices and authentication."""
+
+    _device_clients: dict[str, DeviceClient]
+    user_info: UserInformation = None
+    _token_fresh_cb: Optional[callable] = None
+    _products: dict[str, dict[str, Any]] = {}
+
+    def __init__(
+        self,
+        session: Optional[ClientSession],
+        country_code: str | None = None,
+        username: str | None = None,
+        password: str | None = None,
+        token: dict | None = None,
+    ) -> None:
+        _LOGGER.info("Client Version: v0.3.54")
+        self.country_code = country_code
+        self._device_clients = {}
+        self.user_info = UserInformation(
+            username=username, password=password, country_code=country_code
+        )
+
+        # Set region and country from country_code
+        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()
+                break
+
+        # Handle token (existing login info)
+        if token is not None:
+            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)
+
+        # Setup CloudApi
+        CloudApi.set_session(session)
+        CloudApi.set_user_info(self.user_info)
+        CloudApi.set_auth_failed_callback(self._on_auth_failed)
+        CloudApi.set_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()
+
+    def set_token_fresh_cb(self, callback) -> None:
+        """Set callback for token refresh events."""
+        self._token_fresh_cb = callback
+
+    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:
+            try:
+                if file_path.exists():
+                    return file_path.read_text().strip()
+                node = uuid.getnode()
+                is_random = (node >> 40) & 1
+                raw_id = str(uuid.uuid4()) if is_random else format(node, "x")
+                file_path.write_text(raw_id)
+                return raw_id
+            except OSError:
+                return "gvz3gjae10l4zii00t7y0"
+
+        raw_id = await asyncio.to_thread(_read_or_create)
+        return hashlib.md5(raw_id.encode()).hexdigest()
+
+    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 CloudApi.login(login_request.to_dict())
+        self.user_info.update_from_json(response_data)
+        self.setup_discover()
+        return self.user_info.to_dict()
+
+    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()
+        try:
+            houses = await CloudApi.get_houses() or []
+            for house in houses:
+                if house.get(CONF_IS_OWNER) is False:
+                    continue
+                device_list = await CloudApi.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 CloudApi.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])
+
+        except Exception as e:
+            raise e
+        return filter_devices
+
+    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)
+        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)
+        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:
+            return
+
+        _LOGGER.warning("setup_discover")
+
+        def _discover_callback(dev_id: str, 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)
+
+    async def async_close(self) -> None:
+        """Close client and cleanup resources."""
+        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()

{python_aidot-0.3.53 → python_aidot-0.3.54}/aidot/const.py

@@ -188,6 +188,7 @@ CONF_IS_DEFAULT = "isDefault"
 CONF_TYPE = "type"
 CONF_MODEL_ID = "modelId"
 CONF_MAC = "mac"
+CONF_LOGIN_INFO = "loginInfo"
 CONF_AES_KEY = "aesKey"
 CONF_MODEL_ID = "modelId"
 CONF_HARDWARE_VERSION = "hardwareVersion"
@@ -207,6 +208,8 @@ CONF_RGBW = "RGBW"
 CONF_CCT = "CCT"
 CONF_ACK = "ack"
 CONF_IS_OWNER = "isOwner"
+CONF_GET_DEV_ATTR_REQ = "getDevAttrReq"
+CONF_SET_DEV_ATTR_REQ = "setDevAttrReq"
 
 
 class Identity(StrEnum):
@@ -227,3 +230,17 @@ 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-----
+"""