python-aidot 0.3.56__tar.gz → 0.3.58__tar.gz

{python_aidot-0.3.56/python_aidot.egg-info → python_aidot-0.3.58}/PKG-INFO

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

{python_aidot-0.3.56 → python_aidot-0.3.58}/aidot/client.py

@@ -3,6 +3,7 @@
 import asyncio
 import logging
 import base64
+import random
 import aiohttp
 from aiohttp import ClientSession
 from typing import Any, Optional
@@ -14,6 +15,7 @@ from pathlib import Path
 import hashlib
 from .exceptions import AidotAuthFailed, AidotUserOrPassIncorrect
 from .device_client import DeviceClient
+from .models.device_model import EffectResp, FavoriteEffectPrimitive
 from .discover import Discover
 from .login_const import APP_ID, PUBLIC_KEY_PEM, API_URL_TEMPLATE, DEFAULT_REGION
 from .const import (
@@ -38,6 +40,14 @@ from .const import (
     CONF_IS_OWNER,
     CONF_LOGIN_INFO,
     ServerErrorCode,
+    CONF_MODEL_ID,
+    CONF_PROPERTIES,
+    CONF_LIGHT_SCRIPT_FLAGS,
+    CONF_PRESETS,
+    CONF_TYPE,
+    CONF_AES_KEY,
+    CONF_FIRMWARE_VERSION,
+    CONF_PRIMITIVE,
 )
 
 _LOGGER = logging.getLogger(__name__)
@@ -67,7 +77,7 @@ class AidotClient:
         password: str | None = None,
         token: dict | None = None,
     ) -> None:
-        _LOGGER.info("Client Version: v0.3.56")
+        _LOGGER.info("Client Version: v0.3.57")
         self.session = session
         self.username = username
         self.password = password
@@ -77,6 +87,9 @@ class AidotClient:
         self._base_url = API_URL_TEMPLATE.format(region=self._region)
         self.login_info: dict[str, Any] = {}
         self._device_clients = {}
+        self._effect_mode_params_cache: dict[
+            tuple[str, str, str, bool], dict[str, Any]
+        ] = {}
         self._discover: Discover | None = None
         self._token_fresh_cb = None
         for item in SUPPORTED_COUNTRYS:
@@ -222,6 +235,45 @@ class AidotClient:
                 raise AidotAuthFailed from err
             raise
 
+    async def async_session_post(
+        self,
+        params: str,
+        data: Any,
+        headers: dict[str, str] | None = None,
+    ) -> dict[str, Any]:
+        """Post data to AiDot API."""
+        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.post(url, headers=headers, json=data)
+            response_data = await response.json()
+            response.raise_for_status()
+            return response_data
+        except aiohttp.ClientError as err:
+            _LOGGER.error("async_post 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_post(params, data)
+                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}"
@@ -237,6 +289,173 @@ class AidotClient:
         params = "/houses"
         return await self.async_session_get(params)
 
+    async def async_get_diy_list(
+        self, device: dict[str, Any]
+    ) -> list[FavoriteEffectPrimitive]:
+        """Get favorite list."""
+        params = f"/devices/{device[CONF_ID]}/v4.0/favoriteEffectMode"
+        resp = await self.async_session_get(params)
+        return EffectResp.from_json(resp).primitive
+
+    async def async_get_fav_presets(
+        self, device: dict[str, Any]
+    ) -> list[FavoriteEffectPrimitive]:
+        """Get favorite list."""
+        # https://prod-us-api.arnoo.com/v35/devices/8a040e2233a243e7a07eb6a1b7a210a7/v4.0/favoriteEffectMode?libraryId=aidot.preset
+
+        params = (
+            f"/devices/{device[CONF_ID]}/v4.0/favoriteEffectMode?libraryId=aidot.preset"
+        )
+        resp = await self.async_session_get(params)
+        return EffectResp.from_json(resp).primitive
+
+    async def async_get_presets(
+        self, device: dict[str, Any]
+    ) -> list[FavoriteEffectPrimitive]:
+        """Get preset list."""
+        # https://prod-us-api.arnoo.com/v35/models/LK.light.A001855/v3.0/effectModes?libraryId=aidot.preset&version=3.30.09&lightScriptFlags=0002140503140500000062
+
+        params = (
+            f"/models/{device[CONF_MODEL_ID]}/v3.0/effectModes?libraryId=aidot.preset"
+        )
+        properties = device.get(CONF_PROPERTIES, {})
+        light_script_flags = properties.get(CONF_LIGHT_SCRIPT_FLAGS)
+        if light_script_flags:
+            params = (
+                f"{params}&version={device[CONF_FIRMWARE_VERSION]}"
+                f"&lightScriptFlags={light_script_flags}"
+            )
+        resp = await self.async_session_get(params)
+        return EffectResp.from_json(resp).primitive
+
+    async def async_get_effect_mode_params(
+        self,
+        device_id: str,
+        primitive: FavoriteEffectPrimitive,
+    ) -> dict[str, Any]:
+        """Get effect mode params."""
+        primitive_effect_id = primitive.primitiveEffectId
+        favorite_id = primitive.favoriteId
+        library_id = primitive.libraryId
+        if favorite_id is not None:
+            effect_query = f"favoriteIds={favorite_id}"
+            effect_cache_id = favorite_id
+        elif primitive_effect_id is not None:
+            effect_query = f"primitiveEffectIds={primitive_effect_id}"
+            effect_cache_id = primitive_effect_id
+        else:
+            raise ValueError(
+                "Effect primitive must have favoriteId or primitiveEffectId"
+            )
+        if library_id is None:
+            raise ValueError("Effect primitive must have libraryId")
+
+        cache_key = (device_id, effect_cache_id, library_id, primitive.isOldParams)
+        if cache_key in self._effect_mode_params_cache:
+            return self._effect_mode_params_cache[cache_key]
+
+        params = (
+            f"/devices/{device_id}/v3.0/effectModeParams"
+            f"?{effect_query}"
+            f"&isOldParams={primitive.isOldParams}"
+            f"&libraryId={library_id}"
+        )
+        resp = await self.async_session_get(params)
+        effect_primitives = resp.get(CONF_PRIMITIVE) or []
+        if not effect_primitives:
+            raise ValueError("Effect mode params response has no primitive")
+
+        effect_params = effect_primitives[0]
+        self._effect_mode_params_cache[cache_key] = effect_params
+        return effect_params
+
+    async def async_execute_diff_command(
+        self,
+        device_id: str,
+        primitive: FavoriteEffectPrimitive,
+    ) -> dict[str, Any]:
+        """Execute diff command."""
+        # effect_params = await self.async_get_effect_mode_params(device_id, primitive)
+        data = [
+            {
+                "devId": device_id,
+                "effectUniqueID": primitive.primitiveEffectId,
+                "action": "runLScript",
+                "in": [
+                    {
+                        "sessionId": random.randint(1, 2_147_483_647),
+                        # "params": effect_params["params"],
+                    }
+                ],
+            }
+        ]
+        return await self.async_session_post("/devices/execute/diffCommand", data)
+
+    async def async_get_all_effects(
+        self, device: dict[str, Any]
+    ) -> dict[str, FavoriteEffectPrimitive]:
+        """Get all effects list."""
+        diy_list: list[FavoriteEffectPrimitive] = []
+        fav_preset: list[FavoriteEffectPrimitive] = []
+        preset_list: list[FavoriteEffectPrimitive] = []
+
+        try:
+            diy_list = await self.async_get_diy_list(device)
+        except Exception as err:
+            _LOGGER.warning(
+                "Failed to get DIY effects for %s: %s", device[CONF_ID], err
+            )
+
+        try:
+            fav_preset = await self.async_get_fav_presets(device)
+        except Exception as err:
+            _LOGGER.warning(
+                "Failed to get favorite preset effects for %s: %s",
+                device[CONF_ID],
+                err,
+            )
+
+        try:
+            preset_list = await self.async_get_presets(device)
+        except Exception as err:
+            _LOGGER.warning(
+                "Failed to get preset effects for %s: %s", device[CONF_ID], err
+            )
+
+        fav_preset_ids = {
+            item.primitiveEffectId
+            for item in fav_preset
+            if item.primitiveEffectId is not None
+        }
+        preset_list = [
+            item for item in preset_list if item.primitiveEffectId not in fav_preset_ids
+        ]
+        return self._merge_effects_by_unique_name(diy_list, fav_preset, preset_list)
+
+    @staticmethod
+    def _merge_effects_by_unique_name(
+        *effect_lists: list[FavoriteEffectPrimitive],
+    ) -> dict[str, FavoriteEffectPrimitive]:
+        """Merge effect lists into a dict with unique display names."""
+        effects: dict[str, FavoriteEffectPrimitive] = {}
+        name_counts: dict[str, int] = {}
+
+        for effect_list in effect_lists:
+            for effect in effect_list:
+                name = (
+                    effect.name
+                    or effect.primitiveEffectId
+                    or effect.favoriteId
+                    or "Effect"
+                )
+                name_counts[name] = name_counts.get(name, 0) + 1
+                unique_name = (
+                    name if name_counts[name] == 1 else f"{name} ({name_counts[name]})"
+                )
+                effects[unique_name] = effect
+
+        return effects
+
     async def async_get_all_device(self) -> dict[str, Any]:
         final_device_list: list[dict[str, Any]] = []
         try:
@@ -260,6 +479,14 @@ class AidotClient:
                     if device[CONF_PRODUCT_ID] == product[CONF_ID]:
                         device[CONF_PRODUCT] = product
 
+            for device in final_device_list:
+                if (
+                    device[CONF_TYPE] == "light"
+                    and CONF_AES_KEY in device
+                    and device[CONF_AES_KEY][0] is not None
+                ):
+                    device[CONF_PRESETS] = await self.async_get_all_effects(device)
+
         except Exception as e:
             raise e
         return {CONF_DEVICE_LIST: final_device_list}
@@ -268,7 +495,7 @@ class AidotClient:
         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.login_info)
+            device_client = DeviceClient(device, self.login_info, self)
             self._device_clients[device_id] = device_client
         if self._discover is not None:
             ip = self._discover.discovered_device.get(device_id)

{python_aidot-0.3.56 → python_aidot-0.3.58}/aidot/const.py

@@ -192,6 +192,7 @@ CONF_LOGIN_INFO = "loginInfo"
 CONF_AES_KEY = "aesKey"
 CONF_MODEL_ID = "modelId"
 CONF_HARDWARE_VERSION = "hardwareVersion"
+CONF_FIRMWARE_VERSION = "firmwareVersion"
 CONF_SERVICE_MODULES = "serviceModules"
 CONF_IDENTITY = "identity"
 CONF_PROPERTIES = "properties"
@@ -206,10 +207,17 @@ CONF_ON_OFF = "OnOff"
 CONF_DIMMING = "Dimming"
 CONF_RGBW = "RGBW"
 CONF_CCT = "CCT"
+CONF_EFFECT_MODE = "EffectMode"
 CONF_ACK = "ack"
 CONF_IS_OWNER = "isOwner"
 CONF_GET_DEV_ATTR_REQ = "getDevAttrReq"
 CONF_SET_DEV_ATTR_REQ = "setDevAttrReq"
+CONF_DIYS = "diys"
+CONF_PRESETS = "presets"
+CONF_FAV_PRESETS = "favoritePresets"
+CONF_VERSION = "version"
+CONF_LIGHT_SCRIPT_FLAGS = "lightScriptFlags"
+CONF_PRIMITIVE = "primitive"
 
 
 class Identity(StrEnum):

{python_aidot-0.3.56 → python_aidot-0.3.58}/aidot/device_client.py

@@ -7,7 +7,7 @@ import time
 import json
 import asyncio
 import logging
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from .aes_utils import aes_encrypt, aes_decrypt_to_json
 from .models.device_client_model import (
@@ -32,6 +32,7 @@ from .const import (
     CONF_ON_OFF,
     CONF_DIMMING,
     CONF_PASSWORD,
+    CONF_PRESETS,
     CONF_PRODUCT,
     CONF_PROPERTIES,
     CONF_RGBW,
@@ -39,10 +40,14 @@ from .const import (
     CONF_GET_DEV_ATTR_REQ,
     CONF_SET_DEV_ATTR_REQ,
     Identity,
+    CONF_EFFECT_MODE,
 )
 
 _LOGGER = logging.getLogger(__name__)
 
+if TYPE_CHECKING:
+    from .client import AidotClient
+
 
 class DeviceStatusData:
     online: bool = False
@@ -51,6 +56,7 @@ class DeviceStatusData:
     rgbw: tuple[int, int, int, int] = (255, 0, 0, 0)
     cct: int = 2700
     dimming: int = 100
+    effect: str = ""
 
     def update(self, attr: DeviceAttr) -> None:
         """Update status from DeviceAttr model."""
@@ -61,6 +67,7 @@ class DeviceStatusData:
         if attr.Dimming is not None:
             self.dimming = int(attr.Dimming * 255 / 100)
         if attr.RGBW is not None:
+            self.effect = ""
             rgbw_value = attr.RGBW
             # If RGBW is 0, set default red color (255, 0, 0, 0)
             if rgbw_value == 0:
@@ -75,6 +82,7 @@ class DeviceStatusData:
             w = rgbw & 0xFF
             self.rgbw = (r, g, b, w)
         if attr.CCT is not None:
+            self.effect = ""
             self.cct = attr.CCT
 
 
@@ -89,6 +97,8 @@ class DeviceInformation:
     model_id: str
     name: str
     hw_version: str
+    presets: dict[str, Any]
+    preset_names: list[str]
 
     def __init__(self, device: dict[str, Any]) -> None:
         self.dev_id = device.get(CONF_ID)
@@ -96,6 +106,8 @@ class DeviceInformation:
         self.model_id = device.get(CONF_MODEL_ID)
         self.name = device.get(CONF_NAME)
         self.hw_version = device.get(CONF_HARDWARE_VERSION)
+        self.presets = device.get(CONF_PRESETS, {})
+        self.preset_names = list(self.presets)
         if CONF_PRODUCT in device and CONF_SERVICE_MODULES in device[CONF_PRODUCT]:
             for service in device[CONF_PRODUCT][CONF_SERVICE_MODULES]:
                 if service[CONF_IDENTITY] == Identity.RGBW:
@@ -124,7 +136,8 @@ class DeviceClient(object):
     _ping_timer: Any = None
     writer: Any = None
     reader: Any = None
-    syncProperties = [CONF_ON_OFF, CONF_DIMMING, CONF_RGBW, CONF_CCT]
+    # syncProperties = [CONF_ON_OFF, CONF_DIMMING, CONF_RGBW, CONF_CCT, CONF_EFFECT_MODE]
+    syncProperties: Any = None
     heart_time = 30
     ping_data = PingRequest().to_dict()
     _TAG: str = "DeviceClient"
@@ -137,10 +150,16 @@ class DeviceClient(object):
     def connecting(self) -> bool:
         return self._connecting
 
-    def __init__(self, device: dict[str, Any], user_info: dict[str, Any]) -> None:
+    def __init__(
+        self,
+        device: dict[str, Any],
+        user_info: dict[str, Any],
+        client: "AidotClient",
+    ) -> None:
         self.ping_count = 0
         self.status = DeviceStatusData()
         self.info = DeviceInformation(device)
+        self.client = client
         self.user_id = user_info.get(CONF_ID)
 
         if CONF_AES_KEY in device:
@@ -154,11 +173,13 @@ class DeviceClient(object):
         self.device_id = device.get(CONF_ID)
         self._simpleVersion = device.get("simpleVersion")
         self._TAG = f"{self.device_id}"
+        self.syncProperties = []
         if self.info.model_id == "lk.WIFI-RGBWLight-D0006":
+            self.syncProperties = [CONF_ON_OFF, CONF_DIMMING, CONF_RGBW, CONF_CCT]
             self.ping_data = None
             self.heart_time = 10
 
-        _LOGGER.warning(f"{self._TAG}:{device}")
+        # _LOGGER.warning(f"{self._TAG}:{device}")
 
     async def connect(self, ip_address) -> None:
         _LOGGER.warning(f"{self._TAG}:connect device: {ip_address}")
@@ -291,8 +312,26 @@ class DeviceClient(object):
                     self.ascNumber = response.payload.ascNumber
                 if response.payload.attr:
                     self.status.update(response.payload.attr)
+                    effect_name = self._get_effect_name_by_unique_id(
+                        response.payload.attr.effectUniqueID
+                    )
+                    if effect_name is not None:
+                        self.status.effect = effect_name
                     self._notify_status_update()
 
+    def _get_effect_name_by_unique_id(self, effect_unique_id: str | None) -> str | None:
+        """Get effect display name by primitive effect id."""
+        if not effect_unique_id:
+            return None
+
+        for effect_name, effect in self.info.presets.items():
+            if (
+                effect.primitiveEffectId == effect_unique_id
+                or effect.favoriteId == effect_unique_id
+            ):
+                return effect_name
+        return None
+
     def _schedule_ping(self):
         loop = asyncio.get_running_loop()
         loop.create_task(self.send_ping_action())
@@ -320,6 +359,17 @@ class DeviceClient(object):
         final_rgbw = (rgbw[0] << 24) | (rgbw[1] << 16) | (rgbw[2] << 8) | rgbw[3]
         await self.send_dev_attr({CONF_RGBW: ctypes.c_int32(final_rgbw).value})
 
+    async def async_set_effect(self, effect: str) -> None:
+        effect_item = self.info.presets.get(effect)
+        if effect_item is None:
+            raise ValueError(f"Unknown effect: {effect}")
+        if effect_item.primitiveEffectId is None:
+            raise ValueError(f"Effect has no primitiveEffectId: {effect}")
+
+        await self.client.async_execute_diff_command(
+            device_id=self.device_id, primitive=effect_item
+        )
+
     async def async_set_cct(self, cct: int) -> None:
         await self.send_dev_attr({CONF_CCT: cct})
 

{python_aidot-0.3.56 → python_aidot-0.3.58}/aidot/login_const.py

@@ -3,7 +3,7 @@
 APP_ID = "1383974540041977857"
 
 # API URL template - use .format(region="us") to construct
-API_URL_TEMPLATE = "https://prod-{region}-api.arnoo.com/v17"
+API_URL_TEMPLATE = "https://prod-{region}-api.arnoo.com/v35"
 DEFAULT_REGION = "us"
 
 PUBLIC_KEY_PEM = b"""

{python_aidot-0.3.56 → python_aidot-0.3.58}/aidot/models/__init__.py

@@ -17,6 +17,9 @@ from .device_model import (
     DeviceProperties,
     DeviceProduct,
     DeviceInformation,
+    FavoriteEffectMode,
+    FavoriteEffectPrimitive,
+    FavoriteEffectTags,
 )
 
 __all__ = [
@@ -34,4 +37,7 @@ __all__ = [
     "DeviceProperties",
     "DeviceProduct",
     "DeviceInformation",
+    "FavoriteEffectMode",
+    "FavoriteEffectPrimitive",
+    "FavoriteEffectTags",
 ]

{python_aidot-0.3.56 → python_aidot-0.3.58}/aidot/models/device_client_model.py

@@ -92,6 +92,8 @@ class DeviceAttr:
     Dimming: int = None
     RGBW: int = None
     CCT: int = None
+    effectUniqueID: str = None
+    EffectMode: str = None
 
 
 @dataclass

{python_aidot-0.3.56 → python_aidot-0.3.58}/aidot/models/device_model.py

@@ -81,3 +81,60 @@ class DeviceInformation:
     def to_dict(self) -> dict[str, Any]:
         """Convert to dictionary."""
         return asdict(self)
+
+
+@dataclass
+class FavoriteEffectTags:
+    """Favorite effect tags."""
+
+    advanced: str = None
+    directional: str = None
+
+
+@dataclass
+class FavoriteEffectPrimitive:
+    """Favorite primitive effect mode."""
+
+    primitiveEffectId: str = None
+    favoriteId: str = None
+    icon: str = None
+    libraryId: str = "aidot.preset"
+    name: str = None
+    tags: Optional[FavoriteEffectTags] = None
+    scriptSize: int = None
+    secondShareFlag: bool = None
+    changeFlag: bool = None
+    createTime: int = None
+    imageUrl: str = None
+    videoUrl: str = None
+    sharedUserName: str = None
+    sharedUserHeadImg: str = None
+    sharedTime: int = None
+    shareId: str = None
+    isOldParams: bool = False
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary."""
+        return asdict(self)
+
+
+@dataclass
+class FavoriteEffectMode:
+    """Favorite effect mode response."""
+
+    data: list[Any] = field(default_factory=list)
+    primitive: list[FavoriteEffectPrimitive] = field(default_factory=list)
+
+    @staticmethod
+    def from_json(data: dict[str, Any]) -> "FavoriteEffectMode":
+        """Create FavoriteEffectMode from JSON dict."""
+        return from_dict(
+            data_class=FavoriteEffectMode, data=data, config=Config(check_types=False)
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary."""
+        return asdict(self)
+
+
+EffectResp = FavoriteEffectMode

{python_aidot-0.3.56 → python_aidot-0.3.58/python_aidot.egg-info}/PKG-INFO

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

{python_aidot-0.3.56 → python_aidot-0.3.58}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="python-aidot",
-    version="0.3.56",
+    version="0.3.58",
     author="aidotdev2024",
     url="https://github.com/Aidot-Development-Team/python-aidot",
     description="aidot control wifi lights",