python-aidot 0.3.54b2__tar.gz → 0.3.54b3__tar.gz

{python_aidot-0.3.54b2 → python_aidot-0.3.54b3}/PKG-INFO

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

{python_aidot-0.3.54b2 → python_aidot-0.3.54b3}/aidot/aes_utils.py

@@ -1,6 +1,8 @@
 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):
@@ -25,3 +27,20 @@ def aes_decrypt(ciphertext, key):
     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)

{python_aidot-0.3.54b2 → python_aidot-0.3.54b3}/aidot/client.py

@@ -36,6 +36,8 @@ from .const import (
     SUPPORTED_COUNTRYS,
     DEFAULT_COUNTRY_CODE,
     CONF_IS_OWNER,
+    CONF_TYPE,
+    CONF_AES_KEY,
     ServerErrorCode,
 )
 
@@ -77,7 +79,7 @@ class AidotClient:
         password: str | None = None,
         token: dict | None = None,
     ) -> None:
-        _LOGGER.info("Client Version: v0.3.52")
+        _LOGGER.info("Client Version: v0.3.54b3")
         self.session = session
         self.username = username
         self.password = password
@@ -258,6 +260,7 @@ class AidotClient:
                 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 {CONF_DEVICE_LIST: final_device_list}
@@ -286,6 +289,7 @@ class AidotClient:
         if self._discover is not None:
             return
 
+        _LOGGER.warning(f"setup_discover")
         def _discover_callback(dev_id, event: dict[str, str]) -> None:
             device_ip = event[CONF_IPADDRESS]
             device_client: DeviceClient = self._device_clients.get(dev_id)

{python_aidot-0.3.54b2 → python_aidot-0.3.54b3}/aidot/device_client.py

@@ -11,7 +11,8 @@ from datetime import datetime
 from typing import Any
 
 from .exceptions import AidotNotLogin
-from .aes_utils import aes_encrypt, aes_decrypt
+from .aes_utils import aes_encrypt, aes_decrypt_to_json
+from .models.device_client_model import PingRequest, LoginRequest, LoginPayload, DeviceResponse, DeviceAttr, DeviceActionRequest
 from .const import (
     CONF_AES_KEY,
     CONF_ASCNUMBER,
@@ -51,15 +52,16 @@ class DeviceStatusData:
     cct: int = 2700
     dimming: int = 100
 
-    def update(self, attr: dict[str, Any]) -> None:
+    def update(self, attr: DeviceAttr) -> None:
+        """Update status from DeviceAttr model."""
         if attr is None:
             return
-        if attr.get(CONF_ON_OFF) is not None:
-            self.on = attr.get(CONF_ON_OFF)
-        if attr.get(CONF_DIMMING) is not None:
-            self.dimming = int(attr.get(CONF_DIMMING) * 255 / 100)
-        if attr.get(CONF_RGBW) is not None:
-            rgbw_value = attr.get(CONF_RGBW)
+        if attr.OnOff is not None:
+            self.on = attr.OnOff
+        if attr.Dimming is not None:
+            self.dimming = int(attr.Dimming * 255 / 100)
+        if attr.RGBW is not None:
+            rgbw_value = attr.RGBW
             # If RGBW is 0, set default red color (255, 0, 0, 0)
             if rgbw_value == 0:
                 self.rgdb = 0xFF000000  # Red in int: 4278190080
@@ -72,8 +74,8 @@ class DeviceStatusData:
             b = (rgbw >> 8) & 0xFF
             w = rgbw & 0xFF
             self.rgbw = (r, g, b, w)
-        if attr.get(CONF_CCT) is not None:
-            self.cct = attr.get(CONF_CCT)
+        if attr.CCT is not None:
+            self.cct = attr.CCT
 
 
 class DeviceInformation:
@@ -123,8 +125,8 @@ class DeviceClient(object):
     writer: Any = None
     reader: Any = None
     syncProperties = [CONF_ON_OFF, CONF_DIMMING, CONF_RGBW, CONF_CCT]
-    heart_time = 10
-    # syncProperties = []
+    heart_time = 30
+    ping_data = PingRequest().to_dict()
     _TAG: str = "DeviceClient"
     @property
     def connect_and_login(self) -> bool:
@@ -151,9 +153,10 @@ 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 = [CONF_ON_OFF, CONF_DIMMING, CONF_RGBW, CONF_CCT]
-        
+        if self.info.model_id == 'lk.WIFI-RGBWLight-D0006':
+            self.ping_data = None
+            self.heart_time = 10
+
         _LOGGER.warning(f"{self._TAG}:{device}")
 
     async def connect(self, ip_address) -> None:
@@ -209,37 +212,34 @@ class DeviceClient(object):
     async def login(self) -> None:
         login_seq = str(int(time.time() * 1000) + self._login_uuid)[-9:]
         self._login_uuid += 1
-        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")
-        message = {
-            "service": "device",
-            "method": "loginReq",
-            "seq": login_seq,
-            "srcAddr": self.user_id,
-            "deviceId": self.device_id,
-            "payload": {
-                "userId": self.user_id,
-                "password": self.password,
-                "timestamp": timestamp,
-                "ascNumber": 1,
-            },
-        }
+        
+        login_request = LoginRequest(
+            seq=login_seq,
+            srcAddr=self.user_id,
+            deviceId=self.device_id,
+            payload=LoginPayload(
+                userId=self.user_id,
+                password=self.password,
+            ),
+        )
+        message = login_request.to_dict()
         try:
             self.writer.write(self.get_send_packet(json.dumps(message).encode(), 1))
             await self.writer.drain()
             header = await self.reader.readexactly(8)
             magic, msgtype, bodysize = struct.unpack(">HHI", header)
             body = await self.reader.readexactly(bodysize)
-            decrypted_data = aes_decrypt(body, self.aes_key) if self.aes_key else body
-            json_data = json.loads(decrypted_data)
-            code = json_data[CONF_ACK][CONF_CODE]
-        
-            if code != 200:
+            json_data = aes_decrypt_to_json(body, self.aes_key)
+            _LOGGER.warning(f"{self._TAG}:login result: {json_data}")
+            
+            response = DeviceResponse.from_json(json_data)
+            if response.ack.code != 200:
                 # 登录失败
-                _LOGGER.error(f"{self._TAG}:login error, code: {code}")
+                _LOGGER.error(f"{self._TAG}:login error, code: {response.ack.code}")
                 await self.reset()
                 return
 
-            self.ascNumber = json_data[CONF_PAYLOAD][CONF_ASCNUMBER] + 1
+            self.ascNumber = response.payload.ascNumber + 1
             self.status.online = True
             self._notify_status_update()
             self._receive_task = asyncio.create_task(
@@ -265,8 +265,7 @@ class DeviceClient(object):
                 magic, msgtype, bodysize = struct.unpack(">HHI", header)
                 self.ping_count = 0 #有读到数据就把ping清零
                 body = await self.reader.readexactly(bodysize)
-                decrypted_data = aes_decrypt(body, self.aes_key)
-                json_data = json.loads(decrypted_data)
+                json_data = aes_decrypt_to_json(body, self.aes_key)
                 _LOGGER.warning(f"{self._TAG}:reveive_data : {json_data}")
             except asyncio.CancelledError:
                 _LOGGER.debug(f"{self._TAG}:Receive task cancelled")
@@ -279,19 +278,18 @@ class DeviceClient(object):
                 return
             except Exception as e:
                 _LOGGER.error(f"{self._TAG}:recv error: {e}")
-                self.ping_count = 0
                 continue
 
-            if "service" in json_data:
-                if "test" == json_data["service"]:
-                    self.ping_count = 0
-                    continue
-
-            payload = json_data.get(CONF_PAYLOAD)
-            if payload is not None:
-                self.ascNumber = payload.get(CONF_ASCNUMBER)
-                self.status.update(payload.get(CONF_ATTR))
-                self._notify_status_update()
+            response = DeviceResponse.from_json(json_data)
+            if response.service == "test":
+                continue
+            
+            if response.payload:
+                if response.payload.ascNumber:
+                    self.ascNumber = response.payload.ascNumber
+                if response.payload.attr:
+                    self.status.update(response.payload.attr)
+                    self._notify_status_update()
     
     def _schedule_ping(self):
         loop = asyncio.get_running_loop()
@@ -324,42 +322,19 @@ class DeviceClient(object):
         await self.send_dev_attr({CONF_CCT: cct})
 
     async def send_action(self, attr, method) -> None:
-        current_timestamp_milliseconds = int(time.time() * 1000)
         self.seq_num += 1
-        seq = "ha93" + str(self.seq_num).zfill(5)
-
-        if self._simpleVersion is not None:
-            action = {
-                "method": method,
-                "service": "device",
-                "clientId": "ha-" + self.user_id,
-                "srcAddr": "0." + self.user_id,
-                "seq": "" + seq,
-                CONF_PAYLOAD: {
-                    "devId": self.device_id,
-                    "parentId": self.device_id,
-                    "userId": self.user_id,
-                    "password": self.password,
-                    "attr": attr,
-                    "channel": "tcp",
-                    "ascNumber": self.ascNumber,
-                },
-                "tst": current_timestamp_milliseconds,
-                "deviceId": self.device_id,
-            }
-        else:
-            action = {
-                "method": method,
-                "service": "device",
-                "seq": "" + seq,
-                "srcAddr": "0." + self.user_id,
-                CONF_PAYLOAD: {
-                    "attr": attr,
-                    "ascNumber": self.ascNumber,
-                },
-                "tst": current_timestamp_milliseconds,
-                "deviceId": self.device_id,
-            }
+        action_request = DeviceActionRequest.from_params(
+            method=method,
+            user_id=self.user_id,
+            device_id=self.device_id,
+            password=self.password,
+            ascNumber=self.ascNumber,
+            attr=attr,
+            seq="ha93" + str(self.seq_num).zfill(5),
+            simpleVersion=self._simpleVersion,
+        )
+        
+        action = action_request.to_dict()
         _LOGGER.warning(f"{self.device_id} send_action {action}")
         try:
             self.writer.write(self.get_send_packet(json.dumps(action).encode(), 1))
@@ -373,14 +348,6 @@ class DeviceClient(object):
     async def send_ping_action(self) -> int:
         if self._is_close:
             return -1
-        ping = {
-            "service": "test",
-            "method": "pingreq",
-            "seq": "123456",
-            "srcAddr": "123456",
-            CONF_PAYLOAD: {},
-        }
-        _LOGGER.warning(f"{self.device_id} send_ping_action {ping}")
         try:
             if self.ping_count >= 3:
                 _LOGGER.error(
@@ -390,10 +357,15 @@ class DeviceClient(object):
                 return -1
             if self._connect_and_login is False:
                 return -1
-            # self.writer.write(self.get_send_packet(json.dumps(ping).encode(), 2))
-            # await self.writer.drain()
+            
             self.ping_count += 1
-            await self.send_action(self.syncProperties, CONF_GET_DEV_ATTR_REQ)
+            if self.ping_data is not None:
+                _LOGGER.warning(f"{self.device_id} send_ping {self.ping_data}")
+                self.writer.write(self.get_send_packet(json.dumps(self.ping_data).encode(), 2))
+                await self.writer.drain()
+            else:
+                _LOGGER.warning(f"{self.device_id} send_ping {self.syncProperties}")
+                await self.send_action(self.syncProperties, CONF_GET_DEV_ATTR_REQ)
             return 1
         except Exception as e:
             _LOGGER.error(f"{self.device_id} ping error {e}")
@@ -420,7 +392,7 @@ class DeviceClient(object):
                 await self.writer.wait_closed()
         except Exception as e:
             _LOGGER.error(f"{self.device_id} writer/reader close error {e}")
-        self.writer = self.reader = None;
+        self.writer = self.reader = None
 
         self._connect_and_login = False
         self.status.online = False

{python_aidot-0.3.54b2 → python_aidot-0.3.54b3}/aidot/discover.py

@@ -8,10 +8,9 @@ from typing import Any
 from .aes_utils import aes_encrypt, aes_decrypt
 from .const import CONF_ID, CONF_IPADDRESS
 from .exceptions import AidotOSError
+from aidot.models.discover_model import DiscoverResponse, DiscoverRequest
 
 _LOGGER = logging.getLogger(__name__)
-# _DISCOVER_TIME = 15
-
 _DISCOVER_FAST = 6      # 启动时快速发现
 _DISCOVER_SLOW = 120    # 稳定后慢速维持
 
@@ -19,10 +18,7 @@ class BroadcastProtocol:
     _is_closed = False
 
     def __init__(self, callback, user_id) -> None:
-        self.aes_key = bytearray(32)
-        key_string = "T54uednca587"
-        key_bytes = key_string.encode()
-        self.aes_key[: len(key_bytes)] = key_bytes
+        self.aes_key = bytearray(b"T54uednca587".ljust(32, b'\x00'))
 
         self._discover_cb = callback
         self.user_id = user_id
@@ -36,37 +32,25 @@ class BroadcastProtocol:
         if self._is_closed is True:
             _LOGGER.error(f"{self.user_id}:Connection is closed")
             return
-        current_timestamp_milliseconds = int(time.time() * 1000)
-        seq = str(current_timestamp_milliseconds + 1)[-9:]
-        message = {
-            "protocolVer": "2.0.0",
-            "service": "device",
-            "method": "devDiscoveryReq",
-            "seq": seq,
-            "srcAddr": f"0.{self.user_id}]",
-            "tst": current_timestamp_milliseconds,
-            "payload": {
-                "extends": {},
-                "localCtrFlag": 1,
-                "timestamp": str(current_timestamp_milliseconds),
-            },
-        }
-        _LOGGER.info(f"send_broadcast {message}")
-        send_data = aes_encrypt(json.dumps(message).encode(), self.aes_key)
         try:
+            request = DiscoverRequest.from_params(userId=self.user_id)
+            message = request.to_dict()
+            _LOGGER.info(f"send_broadcast {message}")
+            send_data = aes_encrypt(json.dumps(message).encode(), self.aes_key)
             self.transport.sendto(send_data, ("255.255.255.255", 6666))
         except Exception as error:
             _LOGGER.error(f"{self.user_id}:Connection lost due to error: {error}")
 
     def datagram_received(self, data, addr) -> None:
-        data_str = aes_decrypt(data, self.aes_key)
-        data_json = json.loads(data_str)
-        _LOGGER.info(f"datagram_received {data_json}")
-        if "payload" in data_json:
-            if "mac" in data_json["payload"]:
-                devId = data_json["payload"]["devId"]
-                if self._discover_cb:
-                    self._discover_cb(devId, {CONF_IPADDRESS: addr[0]})
+        try:
+            data_str = aes_decrypt(data, self.aes_key)
+            data_json = json.loads(data_str)
+            response = DiscoverResponse.from_json(data=data_json)
+            _LOGGER.info(f"datagram_received {data_json}")
+            if response.payload and response.payload.devId and self._discover_cb:
+                self._discover_cb(response.payload.devId, {CONF_IPADDRESS: addr[0]})
+        except Exception as error:
+            _LOGGER.error(f"datagram_received error: {error}")
 
     def error_received(self, exc) -> None:
         _LOGGER.error(f"{self.user_id}:Error occurred: {exc}")
@@ -115,7 +99,7 @@ class Discover:
         self._schedule_broadcast()
 
     def _schedule_broadcast(self) -> None:
-        _LOGGER.debug(f"_schedule_broadcast")
+        _LOGGER.warning(f"_schedule_broadcast")
         # 前几次快速发现，之后慢速
         if self._fast_discover_count > 0:
             interval = _DISCOVER_FAST

{python_aidot-0.3.54b2 → python_aidot-0.3.54b3}/python_aidot.egg-info/PKG-INFO

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

{python_aidot-0.3.54b2 → python_aidot-0.3.54b3}/setup.py

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