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

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 (
@@ -22,6 +24,11 @@ from .const import (
     CONF_CODE,
     CONF_COUNTRY,
     CONF_DEVICE_LIST,
+    CONF_DIYS,
+    CONF_EFFECTS,
+    CONF_EFFECT_SELECTION,
+    CONF_EFFECT_SOURCE,
+    CONF_FAV_PRESETS,
     CONF_ID,
     CONF_IPADDRESS,
     CONF_PASSWORD,
@@ -38,6 +45,17 @@ 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,
+    DEFAULT_EFFECT_SOURCE,
+    EFFECT_SOURCE_MANUAL,
+    EFFECT_SOURCE_RECOMMENDED,
 )
 
 _LOGGER = logging.getLogger(__name__)
@@ -66,9 +84,13 @@ class AidotClient:
         username: str | None = None,
         password: str | None = None,
         token: dict | None = None,
+        options: dict[str, Any] | None = None,
+        effect_source: str = DEFAULT_EFFECT_SOURCE,
     ) -> None:
-        _LOGGER.info("Client Version: v0.3.56")
+        _LOGGER.info("Client Version: v0.3.59")
         self.session = session
+        self.options = options.copy() if options is not None else {}
+        self.effect_source = self.options.get(CONF_EFFECT_SOURCE, effect_source)
         self.username = username
         self.password = password
         self.country_code = country_code or DEFAULT_COUNTRY_CODE
@@ -77,6 +99,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 +247,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 +301,253 @@ 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 and store raw effect sources on the device."""
+        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
+        ]
+
+        device[CONF_DIYS] = diy_list
+        device[CONF_FAV_PRESETS] = fav_preset
+        device[CONF_PRESETS] = preset_list
+        return self.get_filtered_effects(device)
+
+    def get_filtered_effects(
+        self, device: dict[str, Any]
+    ) -> dict[str, FavoriteEffectPrimitive]:
+        """Get final effects for Home Assistant from raw device effect sources."""
+        diy_list = device.get(CONF_DIYS, [])
+        fav_preset = device.get(CONF_FAV_PRESETS, [])
+        preset_list = device.get(CONF_PRESETS, [])
+
+        if self.effect_source == EFFECT_SOURCE_MANUAL:
+            return self._merge_effects_by_unique_name(
+                self._filter_manual_effects(device, diy_list),
+                self._filter_manual_effects(device, fav_preset),
+                self._filter_manual_effects(device, preset_list),
+            )
+
+        return self._merge_effects_by_unique_name(
+            diy_list,
+            fav_preset,
+            self._filter_preset_list(preset_list),
+        )
+
+    def get_all_cached_effects(
+        self, device: dict[str, Any]
+    ) -> dict[str, FavoriteEffectPrimitive]:
+        """Get all effects from cached raw device effect sources."""
+        return self._merge_effects_by_unique_name(
+            device.get(CONF_DIYS, []),
+            device.get(CONF_FAV_PRESETS, []),
+            device.get(CONF_PRESETS, []),
+        )
+
+    def _filter_manual_effects(
+        self, device: dict[str, Any], effect_list: list[FavoriteEffectPrimitive]
+    ) -> list[FavoriteEffectPrimitive]:
+        """Filter effect list by manual device selection."""
+        selected_ids = self._get_manual_effect_ids(device)
+        return [
+            effect
+            for effect in effect_list
+            if self._get_effect_ids(effect) & selected_ids
+        ]
+
+    def _get_manual_effect_ids(self, device: dict[str, Any]) -> set[str]:
+        """Get manually selected effect ids for a device."""
+        effect_selection = self.options.get(CONF_EFFECT_SELECTION, {})
+        selected_ids = effect_selection.get(device.get(CONF_ID), [])
+        return {effect_id for effect_id in selected_ids if effect_id}
+
+    @staticmethod
+    def _get_effect_ids(effect: FavoriteEffectPrimitive) -> set[str]:
+        """Get selectable ids for an effect."""
+        return {
+            effect_id
+            for effect_id in (effect.primitiveEffectId, effect.favoriteId)
+            if effect_id
+        }
+
+    def _filter_preset_list(
+        self, preset_list: list[FavoriteEffectPrimitive]
+    ) -> list[FavoriteEffectPrimitive]:
+        """Filter preset effects by configured source."""
+        if self.effect_source != EFFECT_SOURCE_RECOMMENDED:
+            return preset_list
+
+        recommended = [
+            effect for effect in preset_list if self._is_recommended_effect(effect)
+        ]
+        if recommended:
+            return recommended
+        return preset_list[:10]
+
+    @staticmethod
+    def _is_recommended_effect(effect: FavoriteEffectPrimitive) -> bool:
+        """Return whether an effect should be included in recommended presets."""
+        return effect.tag not in (None, "") and effect.tag.strip() != "New"
+
+    @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 +571,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_EFFECTS] = await self.async_get_all_effects(device)
+
         except Exception as e:
             raise e
         return {CONF_DEVICE_LIST: final_device_list}
@@ -268,7 +587,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)

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,24 @@ 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_EFFECTS = "effects"
+CONF_EFFECT_SOURCE = "effect_source"
+CONF_EFFECT_SELECTION = "effect_selection"
+EFFECT_SOURCE_ALL = "all"
+EFFECT_SOURCE_RECOMMENDED = "recommended"
+EFFECT_SOURCE_MANUAL = "manual"
+DEFAULT_EFFECT_SOURCE = EFFECT_SOURCE_ALL
+CONF_VERSION = "version"
+CONF_LIGHT_SCRIPT_FLAGS = "lightScriptFlags"
+CONF_PRIMITIVE = "primitive"
 
 
 class Identity(StrEnum):

aidot/device_client.py

@@ -7,7 +7,8 @@ import time
 import json
 import asyncio
 import logging
-from typing import Any
+from ipaddress import ip_address
+from typing import TYPE_CHECKING, Any
 
 from .aes_utils import aes_encrypt, aes_decrypt_to_json
 from .models.device_client_model import (
@@ -21,6 +22,7 @@ from .models.device_client_model import (
 from .const import (
     CONF_AES_KEY,
     CONF_CCT,
+    CONF_EFFECTS,
     CONF_HARDWARE_VERSION,
     CONF_ID,
     CONF_IDENTITY,
@@ -32,6 +34,7 @@ from .const import (
     CONF_ON_OFF,
     CONF_DIMMING,
     CONF_PASSWORD,
+    CONF_PRESETS,
     CONF_PRODUCT,
     CONF_PROPERTIES,
     CONF_RGBW,
@@ -39,10 +42,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 +58,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 +69,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 +84,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 +99,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 +108,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_EFFECTS, 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 +138,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 +152,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 +175,28 @@ class DeviceClient(object):
         self.device_id = device.get(CONF_ID)
         self._simpleVersion = device.get("simpleVersion")
         self._TAG = f"{self.device_id}"
-        if self.info.model_id == "lk.WIFI-RGBWLight-D0006":
+        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}")
+        else:
+            properties = device.get(CONF_PROPERTIES)
+            if properties is not None:
+                ip_address = self._get_valid_ip(properties.get("ipAddress"))
+                self.update_ip_address(ip_address)
+
+        # _LOGGER.warning(f"{self._TAG}:{device}")
+
+    @staticmethod
+    def _get_valid_ip(ip: str | None) -> str | None:
+        """Return a valid IP address string."""
+        if not ip:
+            return None
+        try:
+            return str(ip_address(ip))
+        except ValueError:
+            return None
 
     async def connect(self, ip_address) -> None:
         _LOGGER.warning(f"{self._TAG}:connect device: {ip_address}")
@@ -291,8 +329,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 +376,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})
 

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"""

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",
 ]

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

aidot/models/device_model.py

@@ -81,3 +81,61 @@ 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
+    tag: 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.dist-info → python_aidot-0.3.59.dist-info}/METADATA

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

python_aidot-0.3.59.dist-info/RECORD

@@ -0,0 +1,17 @@
+aidot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aidot/aes_utils.py,sha256=bGKuC8B6-d2rrNt5Mj7M9gQsaK8C2BDtTisHSnxjgA4,1554
+aidot/client.py,sha256=evj6AXCcduUStAk-jlMdotY3_h6B-I-cSyddoH0VjO8,24026
+aidot/const.py,sha256=Ly-OGX7Nth4ydy8Lq4JYSUg_RJ-NIoTxNkSmJnnVWP8,12957
+aidot/device_client.py,sha256=SnDcRaptYznxHR86PAJfz-iiCVp3wwygo7HwSU_eCgk,17397
+aidot/discover.py,sha256=1hGBPnPcYRvy72yty5ZMTth_mdZuAYgcSaXf6Z68jow,4944
+aidot/exceptions.py,sha256=VJl_HOxpa9B_5vEA4ORNllDPSo28BBcMlV-mF8NiAk4,663
+aidot/login_const.py,sha256=pjXF9ORsY18m_N8oR4WMfaCDBDvLzDXmmKaEmmup_BE,511
+aidot/models/__init__.py,sha256=vdiTDsMQh7TAODvDS7IMAQp1CS7fK2C_f1CKyjLycqU,849
+aidot/models/device_client_model.py,sha256=4Tjeq0L1NUp2Rf4mbGPkvMWE-lhLU8oHDVHkLxn-FRg,5116
+aidot/models/device_model.py,sha256=630L_eezZWfDujpPQvseRpDC5csmKuOdcymrj8ao7HU,3425
+aidot/models/discover_model.py,sha256=fQ77TbubypYFN12myHgXyXGF0yHEffHdD1HIpEwY4r8,2480
+python_aidot-0.3.59.dist-info/licenses/LICENSE,sha256=5k6Ccd7T5u39Y8730J0qr1ahoaEkd1cahwEccuUZ2Dc,1079
+python_aidot-0.3.59.dist-info/METADATA,sha256=M4HvkuUb8JH4enM8cpwuJnTAA8ICV53Xh9s5a8vGjxY,739
+python_aidot-0.3.59.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+python_aidot-0.3.59.dist-info/top_level.txt,sha256=_doNL2OOnXeinm1X72eH2wz26wAkZwbM47KhNB6_QzI,6
+python_aidot-0.3.59.dist-info/RECORD,,

{python_aidot-0.3.56.dist-info → python_aidot-0.3.59.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (83.0.0)
+Generator: setuptools (84.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

python_aidot-0.3.56.dist-info/RECORD

@@ -1,17 +0,0 @@
-aidot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-aidot/aes_utils.py,sha256=bGKuC8B6-d2rrNt5Mj7M9gQsaK8C2BDtTisHSnxjgA4,1554
-aidot/client.py,sha256=10JDvwaL-qyUVDHwIayBjp33kZQGGGqBoJQMisfz7TE,11902
-aidot/const.py,sha256=101OdNMZ5MOWCaxkq3dL541UIY19k0bJRiT96yeay64,12456
-aidot/device_client.py,sha256=gQGr44iCewWMiZYyeucilubIAaFZPll8wxKvFCtaCqU,15016
-aidot/discover.py,sha256=1hGBPnPcYRvy72yty5ZMTth_mdZuAYgcSaXf6Z68jow,4944
-aidot/exceptions.py,sha256=VJl_HOxpa9B_5vEA4ORNllDPSo28BBcMlV-mF8NiAk4,663
-aidot/login_const.py,sha256=NihUuRWd7W9KDfGZQ6RDE9vdbBQE0qIbgUnETxQY93Q,511
-aidot/models/__init__.py,sha256=PEKlm3-3Ke6K4UeAUD0AngOwNhPsjZeJuugg4l6w8tc,689
-aidot/models/device_client_model.py,sha256=Ge8I2TnQRT-gavGwwh9-TZ9QFl0UcAQdhrRB-xpMHdI,5058
-aidot/models/device_model.py,sha256=HF4VPxym3ziVcLiaGZUbACIJqmlHF1QY9_qrb3tNYY4,1980
-aidot/models/discover_model.py,sha256=fQ77TbubypYFN12myHgXyXGF0yHEffHdD1HIpEwY4r8,2480
-python_aidot-0.3.56.dist-info/licenses/LICENSE,sha256=5k6Ccd7T5u39Y8730J0qr1ahoaEkd1cahwEccuUZ2Dc,1079
-python_aidot-0.3.56.dist-info/METADATA,sha256=U7jwtPIsKOew0VMFLOyFvPJus2GwWrQzN4tIDCaVwJw,739
-python_aidot-0.3.56.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-python_aidot-0.3.56.dist-info/top_level.txt,sha256=_doNL2OOnXeinm1X72eH2wz26wAkZwbM47KhNB6_QzI,6
-python_aidot-0.3.56.dist-info/RECORD,,