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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot
-Version: 0.3.54b2
+Version: 0.3.54b4
 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.54b4}/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.54b4}/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.54b4}/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.54b4}/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.warning(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.warning(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.54b4/aidot/models/__init__.py

@@ -0,0 +1,37 @@
+"""Models for AiDot."""
+
+from .device_client_model import (
+    DeviceAck,
+    DeviceAttr,
+    DeviceAttrPayload,
+    DeviceResponse,
+    DeviceActionPayload,
+    DeviceActionRequest,
+    LoginPayload,
+    LoginRequest,
+    PingRequest,
+    PingResponse,
+)
+from .device_model import (
+    DeviceFading,
+    DeviceProperties,
+    DeviceProduct,
+    DeviceInformation,
+)
+
+__all__ = [
+    "DeviceAck",
+    "DeviceAttr",
+    "DeviceAttrPayload",
+    "DeviceResponse",
+    "DeviceActionPayload",
+    "DeviceActionRequest",
+    "LoginPayload",
+    "LoginRequest",
+    "PingRequest",
+    "PingResponse",
+    "DeviceFading",
+    "DeviceProperties",
+    "DeviceProduct",
+    "DeviceInformation",
+]

python_aidot-0.3.54b4/aidot/models/device_client_model.py

@@ -0,0 +1,210 @@
+"""Models for AiDot device client."""
+
+from dataclasses import dataclass, asdict, field
+from typing import Any, Optional
+
+from dacite import Config, from_dict
+
+
+@dataclass
+class PingRequest:
+    """Ping request (heartbeat)."""
+
+    service: str = "test"
+    method: str = "pingreq"
+    seq: str = "123456"
+    srcAddr: str = "123456"
+    payload: dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary."""
+        return asdict(self)
+
+
+@dataclass
+class PingResponse:
+    """Ping response."""
+
+    service: str = None
+    method: str = None
+    seq: str = None
+    srcAddr: str = None
+    payload: dict[str, Any] = None
+
+    @staticmethod
+    def from_json(data: dict[str, Any]) -> "PingResponse":
+        """Create PingResponse from JSON dict."""
+        return from_dict(
+            data_class=PingResponse, data=data, config=Config(check_types=False)
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary."""
+        return asdict(self)
+
+
+@dataclass
+class LoginPayload:
+    """Login request payload."""
+
+    userId: str = None
+    password: str = None
+    timestamp: str = field(default=None)
+    ascNumber: int = 1
+
+    def __post_init__(self):
+        """Auto-generate timestamp if not provided."""
+        if self.timestamp is None:
+            from datetime import datetime
+            self.timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")
+
+
+@dataclass
+class LoginRequest:
+    """Login request."""
+
+    service: str = "device"
+    method: str = "loginReq"
+    seq: str = None
+    srcAddr: str = None
+    deviceId: str = None
+    payload: LoginPayload = None
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary."""
+        return asdict(self)
+
+@dataclass
+class DeviceAck:
+    """Device response ack."""
+
+    code: int = 0
+    tst: str = ""
+
+
+@dataclass
+class DeviceAttr:
+    """Device attribute."""
+
+    OnOff: int = None
+    Dimming: int = None
+    RGBW: int = None
+    CCT: int = None
+
+
+@dataclass
+class DeviceAttrPayload:
+    """Device payload."""
+
+    devId: str = ""
+    parentId: str = ""
+    userId: str = ""
+    password: str = ""
+    timestamp: str = ""
+    channel: str = ""
+    ascNumber: int = 0
+    attr: Optional[DeviceAttr] = None
+
+
+@dataclass
+class DeviceResponse:
+    """Generic device response."""
+
+    service: str = ""
+    method: str = ""
+    seq: str = ""
+    srcAddr: str = ""
+    deviceId: str = ""
+    clientId: str = ""
+    payload: DeviceAttrPayload = field(default_factory=DeviceAttrPayload)
+    ack: DeviceAck = field(default_factory=DeviceAck)
+    tst: int = 0
+
+    @staticmethod
+    def from_json(data: dict[str, Any]) -> "DeviceResponse":
+        """Create DeviceResponse from JSON dict."""
+        return from_dict(
+            data_class=DeviceResponse, data=data, config=Config(check_types=False)
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary."""
+        return asdict(self)
+
+
+@dataclass
+class DeviceActionPayload:
+    """Device action payload."""
+
+    devId: str = ""
+    parentId: str = ""
+    userId: str = ""
+    password: str = ""
+    attr: dict[str, Any] = field(default_factory=dict)
+    channel: str = "tcp"
+    ascNumber: int = 0
+
+
+@dataclass
+class DeviceActionRequest:
+    """Device action request."""
+
+    method: str = ""
+    service: str = "device"
+    clientId: str = ""
+    srcAddr: str = ""
+    seq: str = ""
+    payload: DeviceActionPayload = field(default_factory=DeviceActionPayload)
+    tst: int = 0
+    deviceId: str = ""
+
+    def __post_init__(self):
+        """Auto-generate timestamp if not provided."""
+        if self.tst == 0:
+            import time
+            self.tst = int(time.time() * 1000)
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary."""
+        return asdict(self)
+
+    @staticmethod
+    def from_params(
+        method: str,
+        user_id: str,
+        device_id: str,
+        password: str,
+        ascNumber: int,
+        attr: dict[str, Any],
+        seq: str,
+        simpleVersion: str = None,
+    ) -> "DeviceActionRequest":
+        """Create DeviceActionRequest from params."""
+        if simpleVersion is not None:
+            return DeviceActionRequest(
+                method=method,
+                clientId="ha-" + user_id,
+                srcAddr="0." + user_id,
+                seq=seq,
+                payload=DeviceActionPayload(
+                    devId=device_id,
+                    parentId=device_id,
+                    userId=user_id,
+                    password=password,
+                    attr=attr,
+                    ascNumber=ascNumber,
+                ),
+                deviceId=device_id,
+            )
+        else:
+            return DeviceActionRequest(
+                method=method,
+                srcAddr="0." + user_id,
+                seq=seq,
+                payload=DeviceActionPayload(
+                    attr=attr,
+                    ascNumber=ascNumber,
+                ),
+                deviceId=device_id,
+            )
+        

python_aidot-0.3.54b4/aidot/models/device_model.py

@@ -0,0 +1,83 @@
+"""Models for AiDot device."""
+
+from dataclasses import dataclass, asdict, field
+from typing import Any, Optional, List
+
+from dacite import Config, from_dict
+
+
+@dataclass
+class DeviceFading:
+    """Device fading config."""
+
+    in_value: Optional[int] = field(default=None, metadata={"alias": "in"})
+    out: Optional[int] = None
+
+
+@dataclass
+class DeviceProperties:
+    """Device properties."""
+
+    ssidName: str = None
+    ipAddress: str = None
+    macAddress: str = None
+    networkRssi: str = None
+    networkSecurity: str = None
+    wifiChannel: str = None
+    OnOff: str = None
+    Dimming: str = None
+    CCT: str = None
+    RGBW: str = None
+    EffectMode: str = None
+    Area: str = None
+    city: str = None
+    CityTimezone: str = None
+    lastNotifyCctRgbw: str = None
+
+
+@dataclass
+class DeviceProduct:
+    """Device product info."""
+
+    id: str = None
+    name: str = None
+    type: str = None
+    modelId: str = None
+    picture: str = None
+    icon: str = None
+    isDirectDevice: int = None
+
+
+@dataclass
+class DeviceInformation:
+    """Device information."""
+
+    id: str = None
+    name: str = None
+    mac: str = None
+    type: str = None
+    modelId: str = None
+    productId: str = None
+    houseId: str = None
+    roomId: str = None
+    online: bool = None
+    firmwareVersion: str = None
+    hardwareVersion: str = None
+    protocolVersion: str = None
+    picture: str = None
+    aesKey: List[str] = field(default_factory=list)
+    password: str = None
+    fading: Optional[DeviceFading] = None
+    properties: Optional[DeviceProperties] = None
+    product: Optional[DeviceProduct] = None
+
+    @staticmethod
+    def from_json(data: dict[str, Any]) -> "DeviceInformation":
+        """Create DeviceInformation from JSON dict."""
+        return from_dict(
+            data_class=DeviceInformation, data=data, config=Config(check_types=False)
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary."""
+        return asdict(self)

python_aidot-0.3.54b4/aidot/models/discover_model.py

@@ -0,0 +1,102 @@
+"""Models for AiDot discover."""
+import time
+from dataclasses import dataclass, asdict, field
+from typing import Any, Optional
+
+from dacite import Config, from_dict
+
+
+@dataclass
+class DiscoverAck:
+    """Discover response ack."""
+
+    code: int = None
+    tst: str = None
+
+
+@dataclass
+class DiscoverExtends:
+    """Discover payload extends."""
+
+    srvHost: str = None
+
+
+@dataclass
+class DiscoverPayload:
+    """Discover response payload."""
+
+    ip: str = None
+    mac: str = None
+    devId: str = None
+    productModel: str = None
+    bindFlag: int = None
+    conMode: int = None
+    lanMode: int = None
+    wifiMode: int = None
+    wifiBand: int = None
+    version: int = None
+    extends: Optional[DiscoverExtends] = None
+
+
+@dataclass
+class DiscoverResponse:
+    """Discover device response."""
+
+    srcAddr: str = None
+    seq: str = None
+    service: str = None
+    method: str = None
+    ack: DiscoverAck = None
+    protocolVer: str = None
+    payload: DiscoverPayload = None
+
+    @staticmethod
+    def from_json(data: dict[str, Any]) -> "DiscoverResponse":
+        """Create DiscoverResponse from JSON dict."""
+        return from_dict(
+            data_class=DiscoverResponse, data=data, config=Config(check_types=False)
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary."""
+        return asdict(self)
+
+
+@dataclass
+class DiscoverRequestPayload:
+    """Discover request payload."""
+
+    extends: dict[str, Any] = field(default_factory=dict)
+    localCtrFlag: int = 1
+    timestamp: str = None
+
+
+@dataclass
+class DiscoverRequest:
+    """Discover device request."""
+
+    protocolVer: str = "2.0.0"
+    service: str = "device"
+    method: str = "devDiscoveryReq"
+    seq: str = None
+    srcAddr: str = None
+    tst: int = None
+    payload: DiscoverRequestPayload = field(default_factory=DiscoverRequestPayload)
+
+    @staticmethod
+    def from_params(userId: str) -> "DiscoverResponse":
+        """Create DiscoverResponse from JSON dict."""
+        current_timestamp_milliseconds = int(time.time() * 1000)
+        seq = str(current_timestamp_milliseconds + 1)[-9:]
+        return DiscoverRequest(
+            seq=seq,
+            srcAddr=f"0.{userId}",
+            tst=current_timestamp_milliseconds,
+            payload=DiscoverRequestPayload(
+                timestamp=str(current_timestamp_milliseconds)
+            )
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary."""
+        return asdict(self)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot
-Version: 0.3.54b2
+Version: 0.3.54b4
 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.54b4}/python_aidot.egg-info/SOURCES.txt

@@ -10,6 +10,10 @@ aidot/device_client.py
 aidot/discover.py
 aidot/exceptions.py
 aidot/login_const.py
+aidot/models/__init__.py
+aidot/models/device_client_model.py
+aidot/models/device_model.py
+aidot/models/discover_model.py
 python_aidot.egg-info/PKG-INFO
 python_aidot.egg-info/SOURCES.txt
 python_aidot.egg-info/dependency_links.txt

{python_aidot-0.3.54b2 → python_aidot-0.3.54b4}/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.54b4",
     author="aidotdev2024",
     url='https://github.com/Aidot-Development-Team/python-aidot',
     description="aidot control wifi lights",