python-aidot 0.3.2__tar.gz → 0.3.4__tar.gz

{python_aidot-0.3.2 → python_aidot-0.3.4}/PKG-INFO

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

{python_aidot-0.3.2 → python_aidot-0.3.4}/aidot/aes_utils.py

@@ -2,7 +2,8 @@ from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
 from cryptography.hazmat.backends import default_backend
 from cryptography.hazmat.primitives import padding
 
-def aes_encrypt(plaintext, key): 
+
+def aes_encrypt(plaintext, key):
     padder = padding.PKCS7(algorithms.AES.block_size).padder()
     padded_data = padder.update(plaintext) + padder.finalize()
 
@@ -13,6 +14,7 @@ def aes_encrypt(plaintext, key):
 
     return ciphertext
 
+
 def aes_decrypt(ciphertext, key):
     cipher = Cipher(algorithms.AES(key), modes.ECB(), backend=default_backend())
     decryptor = cipher.decryptor()
@@ -22,4 +24,4 @@ def aes_decrypt(ciphertext, key):
     unpadder = padding.PKCS7(algorithms.AES.block_size).unpadder()
     plaintext = unpadder.update(decrypted_data) + unpadder.finalize()
 
-    return plaintext.decode()
+    return plaintext.decode()

{python_aidot-0.3.2 → python_aidot-0.3.4}/aidot/client.py

@@ -1,34 +1,39 @@
 """The aidot integration."""
 
+import asyncio
 import logging
-from typing import Any, Optional
-from aiohttp import ClientSession
 import base64
 import aiohttp
+from aiohttp import ClientSession
+from typing import Any, Optional
 from cryptography.hazmat.backends import default_backend
 from cryptography.hazmat.primitives import serialization
 from cryptography.hazmat.primitives.asymmetric import padding
+
+from .exceptions import AidotAuthFailed, AidotUserOrPassIncorrect
+from .device_client import DeviceClient
+from .discover import Discover
 from .login_const import APP_ID, PUBLIC_KEY_PEM, BASE_URL
 from .const import (
-    SUPPORTED_COUNTRYS,
-    DEFAULT_COUNTRY_NAME,
-    CONF_PRODUCT_ID,
-    CONF_ID,
-    CONF_PRODUCT,
     CONF_ACCESS_TOKEN,
-    CONF_REFRESH_TOKEN,
-    CONF_TERMINAL,
     CONF_APP_ID,
-    CONF_REGION,
+    CONF_CODE,
     CONF_COUNTRY,
-    CONF_USERNAME,
+    CONF_DEVICE_LIST,
+    CONF_ID,
+    CONF_IPADDRESS,
     CONF_PASSWORD,
-    CONF_CODE,
+    CONF_PRODUCT,
+    CONF_PRODUCT_ID,
+    CONF_REFRESH_TOKEN,
+    CONF_REGION,
+    CONF_TERMINAL,
     CONF_TOKEN,
-    CONF_DEVICE_LIST,
-    ServerErrorCode
+    CONF_USERNAME,
+    DEFAULT_COUNTRY_NAME,
+    SUPPORTED_COUNTRYS,
+    ServerErrorCode,
 )
-from .exceptions import AidotAuthFailed,AidotUserOrPassIncorrect
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -56,6 +61,8 @@ class AidotClient:
     password: str = ""
     country_name: str = DEFAULT_COUNTRY_NAME
     login_info: dict[str, Any] = {}
+    _device_clients: dict[str:DeviceClient]
+    _discover: Discover = None
 
     def __init__(
         self,
@@ -69,13 +76,14 @@ class AidotClient:
         self.country_name = country_name
         self.username = username
         self.password = password
-        self.login_info = token
+        self._device_clients = {}
         for item in SUPPORTED_COUNTRYS:
             if item["name"] == self.country_name:
                 self._region = item["region"].lower()
                 self._base_url = f"https://prod-{self._region}-api.arnoo.com/v17"
                 break
         if token is not None:
+            self.login_info = token.copy()
             self.username = token[CONF_USERNAME]
             self.password = token[CONF_PASSWORD]
             self._region = token[CONF_REGION]
@@ -86,7 +94,7 @@ class AidotClient:
 
     def get_identifier(self) -> str:
         return f"{self._region}-{self.username}"
-    
+
     def update_password(self, password: str):
         self.password = password
 
@@ -154,6 +162,7 @@ class AidotClient:
                 CONF_TOKEN: token,
                 CONF_APP_ID: APP_ID,
             }
+        response_data = {}
         try:
             response = await self.session.get(url, headers=headers)
             response_data = await response.json()
@@ -161,17 +170,19 @@ class AidotClient:
             return response_data
         except aiohttp.ClientError as e:
             _LOGGER.info(f"async_get ClientError {e}")
-            code = response_data[CONF_CODE]
+            code = response_data.get(CONF_CODE)
             if code == ServerErrorCode.TOKEN_EXPIRED:
                 try:
                     await self.async_refresh_token()
                     return await self.async_session_get(params)
                 except AidotAuthFailed:
                     raise AidotAuthFailed
-            elif code == ServerErrorCode.LOGIN_INVALID or code == 21027 or code == 21041:
+            elif (
+                code == ServerErrorCode.LOGIN_INVALID or code == 21027 or code == 21041
+            ):
                 self.login_info[CONF_ACCESS_TOKEN] = None
                 raise AidotAuthFailed
-            return None
+            return aiohttp.ClientError
 
     async def async_get_products(self, product_ids: str):
         """Get device list."""
@@ -208,4 +219,39 @@ class AidotClient:
                         device[CONF_PRODUCT] = product
         except Exception as e:
             raise e
-        return {CONF_DEVICE_LIST:final_device_list}
+        return {CONF_DEVICE_LIST: final_device_list}
+
+    def get_device_client(self, device: dict[str:Any]) -> DeviceClient:
+        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)
+            self._device_clients[device_id] = device_client
+            asyncio.get_running_loop().create_task(device_client.ping_task())
+        if self._discover is not None:
+            ip = self._discover.discovered_device.get(device_id)
+            device_client.update_ip_address(ip)
+        return device_client
+
+    def start_discover(self) -> None:
+        if self._discover is not None:
+            return
+
+        def _discover_callback(dev_id, event: dict[str, str]) -> None:
+            device_ip = event[CONF_IPADDRESS]
+            device_client: DeviceClient = self._device_clients.get(dev_id)
+            if device_client is not None:
+                device_client.update_ip_address(device_ip)
+
+        self._discover = Discover(self.login_info, _discover_callback)
+        asyncio.get_running_loop().create_task(self._discover.repeat_broadcast())
+
+    def stop_discover(self) -> None:
+        self._discover.close()
+        self._discover = None
+
+    def cleanup(self) -> None:
+        self.stop_discover()
+        for client in self._device_clients.values():
+            asyncio.get_running_loop().create_task(client.close())
+        self._device_clients.clear()

{python_aidot-0.3.2 → python_aidot-0.3.4}/aidot/const.py

@@ -1,4 +1,5 @@
-from enum import StrEnum,IntEnum
+from enum import StrEnum, IntEnum
+
 SUPPORTED_COUNTRYS = [
     {"_id": "1-0", "id": "AL", "name": "Albania", "ext": "", "region": "EU"},
     {
@@ -195,17 +196,30 @@ CONF_MINVALUE = "minValue"
 CONF_MAXVALUE = "maxValue"
 CONF_IPADDRESS = "ipAddress"
 CONF_CODE = "code"
+CONF_PAYLOAD = "payload"
+CONF_ASCNUMBER = "ascNumber"
+CONF_ATTR = "attr"
+CONF_ON_OFF = "OnOff"
+CONF_DIMMING = "Dimming"
+CONF_RGBW = "RGBW"
+CONF_CCT = "CCT"
+
+
 class Identity(StrEnum):
     """Available entity identity."""
+
     RGBW = "control.light.rgbw"
     CCT = "control.light.cct"
 
+
 class Attribute(StrEnum):
     """Available entity attributes."""
+
     RGBW = "rgbw"
     CCT = "cct"
 
+
 class ServerErrorCode(IntEnum):
     TOKEN_EXPIRED = 21026
     LOGIN_INVALID = 21025
-    USER_PWD_INCORRECT = 560080
+    USER_PWD_INCORRECT = 560080

python_aidot-0.3.4/aidot/device_client.py

@@ -0,0 +1,372 @@
+"""The aidot integration."""
+
+import ctypes
+import socket
+import struct
+import time
+import json
+import asyncio
+import logging
+from datetime import datetime
+from typing import Any
+
+from .exceptions import AidotNotLogin
+from .aes_utils import aes_encrypt, aes_decrypt
+from .const import (
+    CONF_AES_KEY,
+    CONF_ASCNUMBER,
+    CONF_ATTR,
+    CONF_CCT,
+    CONF_HARDWARE_VERSION,
+    CONF_ID,
+    CONF_IDENTITY,
+    CONF_MAC,
+    CONF_MAXVALUE,
+    CONF_MINVALUE,
+    CONF_MODEL_ID,
+    CONF_NAME,
+    CONF_ON_OFF,
+    CONF_DIMMING,
+    CONF_PASSWORD,
+    CONF_PAYLOAD,
+    CONF_PRODUCT,
+    CONF_PROPERTIES,
+    CONF_RGBW,
+    CONF_SERVICE_MODULES,
+    Identity,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class DeviceStatusData:
+    online: bool = False
+    on: bool = False
+    rgdb: int = None
+    rgbw: tuple[int, int, int, int] = None
+    cct: int = None
+    dimming: int = None
+
+    def update(self, attr: dict[str, Any]) -> None:
+        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:
+            self.rgdb = attr.get(CONF_RGBW)
+            rgbw = ctypes.c_uint32(self.rgdb).value
+            r = (rgbw >> 24) & 0xFF
+            g = (rgbw >> 16) & 0xFF
+            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)
+
+
+class DeviceInformation:
+    enable_rgbw: bool = False
+    enable_dimming: bool = True
+    enable_cct: bool = False
+    cct_min: int
+    cct_max: int
+    dev_id: str
+    mac: str
+    model_id: str
+    name: str
+    hw_version: str
+
+    def __init__(self, device: dict[str:Any]):
+        self.dev_id = device.get(CONF_ID)
+        self.mac = device.get(CONF_MAC) if device.get(CONF_MAC) is not None else ""
+        self.model_id = device.get(CONF_MODEL_ID)
+        self.name = device.get(CONF_NAME)
+        self.hw_version = device.get(CONF_HARDWARE_VERSION)
+        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:
+                    self.enable_rgbw = True
+                    self.enable_cct = True
+                elif service[CONF_IDENTITY] == Identity.CCT:
+                    self.cct_min = int(service[CONF_PROPERTIES][0][CONF_MINVALUE])
+                    self.cct_max = int(service[CONF_PROPERTIES][0][CONF_MAXVALUE])
+                    self.enable_cct = True
+
+
+class DeviceClient(object):
+    status: DeviceStatusData
+    info: DeviceInformation
+    _login_uuid = 0
+    _connect_and_login: bool = False
+    _connecting: bool = False
+    _simpleVersion: str = ""
+    _ip_address: str
+    device_id: str
+    _is_close: bool = False
+
+    @property
+    def connect_and_login(self) -> bool:
+        return self._connect_and_login
+
+    @property
+    def connecting(self) -> bool:
+        return self._connecting
+
+    def __init__(self, device: dict, user_info: dict) -> None:
+        self.ping_count = 0
+        self.status = DeviceStatusData()
+        self.info = DeviceInformation(device)
+        self.user_id = user_info.get(CONF_ID)
+
+        if CONF_AES_KEY in device:
+            key_string = device[CONF_AES_KEY][0]
+            if key_string is not None:
+                self.aes_key = bytearray(16)
+                key_bytes = key_string.encode()
+                self.aes_key[: len(key_bytes)] = key_bytes
+
+        self.password = device.get(CONF_PASSWORD)
+        self.device_id = device.get(CONF_ID)
+        self._simpleVersion = device.get("simpleVersion")
+
+    async def connect(self, ip_address):
+        self.reader = self.writer = None
+        self._connecting = True
+        try:
+            self.reader, self.writer = await asyncio.open_connection(ip_address, 10000)
+            sock: socket.socket = self.writer.get_extra_info("socket")
+            sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+            self.seq_num = 1
+            await self.login()
+            self._connect_and_login = True
+        except Exception as e:
+            self._connect_and_login = False
+        finally:
+            self._connecting = False
+
+    def update_ip_address(self, ip: str) -> None:
+        self._ip_address = ip
+
+    async def async_login(self) -> None:
+        if self._ip_address is None:
+            return
+        if self._connecting is not True and self._connect_and_login is not True:
+            await self.connect(self._ip_address)
+
+    def getSendPacket(self, message, msgtype):
+        magic = struct.pack(">H", 0x1EED)
+        _msgtype = struct.pack(">h", msgtype)
+
+        if self.aes_key is not None:
+            send_data = aes_encrypt(message, self.aes_key)
+        else:
+            send_data = message
+
+        bodysize = struct.pack(">i", len(send_data))
+        packet = magic + _msgtype + bodysize + send_data
+
+        return packet
+
+    async def login(self):
+        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,
+            },
+        }
+        try:
+            self.writer.write(self.getSendPacket(json.dumps(message).encode(), 1))
+            await self.writer.drain()
+            data = await self.reader.read(1024)
+        except (BrokenPipeError, ConnectionResetError) as e:
+            _LOGGER.error(f"{self.device_id} login read status error {e}")
+        except Exception as e:
+            _LOGGER.error(f"recv data error {e}")
+
+        data_len = len(data)
+        if data_len <= 0:
+            return
+
+        magic, msgtype, bodysize = struct.unpack(">HHI", data[:8])
+        encrypted_data = data[8:]
+        if self.aes_key is not None:
+            decrypted_data = aes_decrypt(encrypted_data, self.aes_key)
+        else:
+            decrypted_data = encrypted_data
+
+        json_data = json.loads(decrypted_data)
+
+        self.ascNumber = json_data[CONF_PAYLOAD][CONF_ASCNUMBER]
+        self.ascNumber += 1
+        self.status.online = True
+        await self.send_action({}, "getDevAttrReq")
+
+    async def read_status(self):
+        if self._connect_and_login is False:
+            await asyncio.sleep(2)
+            raise AidotNotLogin
+        try:
+            data = await self.reader.read(1024)
+        except (BrokenPipeError, ConnectionResetError) as e:
+            _LOGGER.error(f"{self.device_id} read status error {e}")
+            await self.reset()
+            self.status.online = False
+            return self.status
+        except Exception as e:
+            _LOGGER.error(f"recv data error {e}")
+            return self.status
+        data_len = len(data)
+        if data_len <= 0:
+            _LOGGER.error("recv data error len")
+            await self.reset()
+            self.status.online = False
+            return self.status
+        try:
+            magic, msgtype, bodysize = struct.unpack(">HHI", data[:8])
+            decrypted_data = aes_decrypt(data[8:], self.aes_key)
+            json_data = json.loads(decrypted_data)
+        except Exception as e:
+            _LOGGER.error(f"recv json error : {e}")
+            return await self.read_status()
+
+        if "service" in json_data:
+            if "test" == json_data["service"]:
+                self.ping_count = 0
+                return await self.read_status()
+        payload = json_data.get(CONF_PAYLOAD)
+        if payload is not None:
+            self.ascNumber = payload.get(CONF_ASCNUMBER)
+            self.status.update(payload.get(CONF_ATTR))
+        return self.status
+
+    async def ping_task(self):
+        while True:
+            if self._is_close:
+                return
+            await asyncio.sleep(5)
+            await self.send_ping_action()
+            await asyncio.sleep(5)
+
+    async def send_dev_attr(self, dev_attr):
+        await self.send_action(dev_attr, "setDevAttrReq")
+
+    async def async_turn_off(self) -> None:
+        await self.send_dev_attr({CONF_ON_OFF: 0})
+
+    async def async_turn_on(self) -> None:
+        await self.send_dev_attr({CONF_ON_OFF: 1})
+
+    async def async_set_brightness(self, brightness: int) -> None:
+        final_dimming = int(brightness * 100 / 255)
+        await self.send_dev_attr({CONF_DIMMING: final_dimming})
+
+    async def async_set_rgbw(self, rgbw: tuple[int, int, int, int]) -> None:
+        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_cct(self, cct: int) -> None:
+        await self.send_dev_attr({CONF_CCT: cct})
+
+    async def send_action(self, attr, method):
+        current_timestamp_milliseconds = int(time.time() * 1000)
+        self.seq_num += 1
+        seq = "ha93" + str(self.seq_num).zfill(5)
+        if not self.status.on and not CONF_ON_OFF in attr:
+            self.status.on = True
+            attr[CONF_ON_OFF] = 1
+
+        if self._simpleVersion is not None:
+            action = {
+                "method": method,
+                "service": "device",
+                "clientId": "ha-" + self.user_id,
+                "srcAddr": "0." + self.user_id,
+                "seq": "" + seq,
+                "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,
+                "payload": {
+                    "attr": attr,
+                    "ascNumber": self.ascNumber,
+                },
+                "tst": current_timestamp_milliseconds,
+                "deviceId": self.device_id,
+            }
+
+        try:
+            self.writer.write(self.getSendPacket(json.dumps(action).encode(), 1))
+            await self.writer.drain()
+        except (BrokenPipeError, ConnectionResetError) as e:
+            _LOGGER.error(f"{self.device_id} send action error {e}")
+            await self.reset()
+        except Exception as e:
+            _LOGGER.error(f"{self.device_id} send action error {e}")
+
+    async def send_ping_action(self):
+        ping = {
+            "service": "test",
+            "method": "pingreq",
+            "seq": "123456",
+            "srcAddr": "x.xxxxxxx",
+            CONF_PAYLOAD: {},
+        }
+        try:
+            if self.ping_count >= 2:
+                _LOGGER.error(
+                    f"Last ping did not return within 20 seconds. device id:{self.device_id}"
+                )
+                await self.reset()
+                return -1
+            if self._connect_and_login is False:
+                return -1
+            self.writer.write(self.getSendPacket(json.dumps(ping).encode(), 2))
+            await self.writer.drain()
+            self.ping_count += 1
+            return 1
+        except Exception as e:
+            _LOGGER.error(f"{self.device_id} ping error {e}")
+            await self.reset()
+            return -1
+
+    async def reset(self):
+        try:
+            if self.writer:
+                self.writer.close()
+                await self.writer.wait_closed()
+        except Exception as e:
+            _LOGGER.error(f"{self.device_id} writer close error {e}")
+        self._connect_and_login = False
+        self.status.online = False
+        self.ping_count = 0
+
+    async def close(self):
+        self._is_close = True
+        await self.reset()
+        _LOGGER.info(f"{self.device_id} connect close by user")

{python_aidot-0.3.2 → python_aidot-0.3.4}/aidot/discover.py

@@ -2,22 +2,24 @@ import socket
 import json
 import time
 import logging
+import asyncio
 from typing import Any
 
-from .aes_utils import aes_encrypt,aes_decrypt
-import asyncio
-from .const import CONF_ID,CONF_IPADDRESS
+from .aes_utils import aes_encrypt, aes_decrypt
+from .const import CONF_ID, CONF_IPADDRESS
 from .exceptions import AidotOSError
 
 _LOGGER = logging.getLogger(__name__)
+_DISCOVER_TIME = 5
 
 class BroadcastProtocol:
     _is_closed = False
-    def __init__(self,callback,user_id):
+
+    def __init__(self, callback, user_id):
         self.aes_key = bytearray(32)
         key_string = "T54uednca587"
-        key_bytes = key_string.encode()     
-        self.aes_key[:len(key_bytes)] = key_bytes
+        key_bytes = key_string.encode()
+        self.aes_key[: len(key_bytes)] = key_bytes
 
         self._discover_cb = callback
         self.user_id = user_id
@@ -34,43 +36,42 @@ class BroadcastProtocol:
         current_timestamp_milliseconds = int(time.time() * 1000)
         seq = str(current_timestamp_milliseconds + 1)[-9:]
         message = {
-            "protocolVer":"2.0.0",
-            "service":"device",
-            "method":"devDiscoveryReq",
+            "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)
-            }
+            "srcAddr": f"0.{self.user_id}]",
+            "tst": current_timestamp_milliseconds,
+            "payload": {
+                "extends": {},
+                "localCtrFlag": 1,
+                "timestamp": str(current_timestamp_milliseconds),
+            },
         }
-        send_data = aes_encrypt(json.dumps(message).encode(),self.aes_key)
+        send_data = aes_encrypt(json.dumps(message).encode(), self.aes_key)
         try:
-            self.transport.sendto(send_data, ('255.255.255.255', 6666))
+            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):
-        data_str = aes_decrypt(data,self.aes_key)
+        data_str = aes_decrypt(data, self.aes_key)
         data_json = json.loads(data_str)
-        if("payload" in data_json):
-            if("mac" in data_json["payload"]):
+        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]})
+                    self._discover_cb(devId, {CONF_IPADDRESS: addr[0]})
 
     def error_received(self, exc):
         _LOGGER.error(f"{self.user_id}:Error occurred: {exc}")
-    
+
     def close(self) -> None:
         try:
             self.transport.close()
         except Exception as error:
             _LOGGER.error(f"Connection lost due to error: {error}")
-        
-    
+
     def connection_lost(self, exc):
         self._is_closed = True
         if exc:
@@ -78,33 +79,60 @@ class BroadcastProtocol:
         else:
             _LOGGER.info("{self.user_id}:Connection closed.")
 
+
 class Discover:
-    _login_info: dict[str: Any] = None
+    _login_info: dict[str:Any] = None
     _broadcast_protocol: BroadcastProtocol = None
-    _discovered_device: dict[str: str]
-    def __init__(self,login_info):
-        self._discovered_device = {}
+    discovered_device: dict[str:str]
+    _is_close: bool = False
+
+    def __init__(self, login_info, callback):
+        self.discovered_device = {}
         self._login_info = login_info
+        self._callback = callback
 
-    async def fetch_devices_info(self) -> dict[str: str]:
+    async def try_create_broadcast(self) -> None:
         if self._broadcast_protocol is None:
-            self._broadcast_protocol = BroadcastProtocol(self._discover_callback,self._login_info[CONF_ID])
+            self._broadcast_protocol = BroadcastProtocol(
+                self._discover_callback, self._login_info[CONF_ID]
+            )
             try:
-                transport, protocol = await asyncio.get_event_loop().create_datagram_endpoint(
+                (
+                    transport,
+                    protocol,
+                ) = await asyncio.get_event_loop().create_datagram_endpoint(
                     lambda: self._broadcast_protocol,
                     local_addr=("0.0.0.0", 0),
                 )
             except OSError:
                 raise AidotOSError
 
+    async def send_broadcast(self) -> None:
+        await self.try_create_broadcast()
+        self._broadcast_protocol.send_broadcast()
+
+    async def repeat_broadcast(self) -> None:
+        self._is_close = False
+        while True:
+            await self.send_broadcast()
+            for i in range(_DISCOVER_TIME):
+                await asyncio.sleep(1)  # 每秒检查一次是否需要取消任务
+                if self._is_close is True:
+                    return
+
+    async def fetch_devices_info(self) -> dict[str:str]:
+        self.try_create_broadcast()
         self._broadcast_protocol.send_broadcast()
         await asyncio.sleep(2)
-        return self._discovered_device
+        return self.discovered_device
 
     def _discover_callback(self, dev_id, event: dict[str, str]) -> None:
-        self._discovered_device[dev_id] = event[CONF_IPADDRESS]
-    
+        self.discovered_device[dev_id] = event[CONF_IPADDRESS]
+        if self._callback:
+            self._callback(dev_id, event)
+
     def close(self) -> None:
+        self._is_close = True
         if self._broadcast_protocol is not None:
             self._broadcast_protocol.close()
-        self._broadcast_protocol.send_broadcast()
+            self._broadcast_protocol = None

{python_aidot-0.3.2 → python_aidot-0.3.4}/aidot/exceptions.py

@@ -1,24 +1,37 @@
 """aidot Exceptions."""
+
+
 class AidotError(Exception):
     """Aidot api exception."""
 
+
 class InvalidURL(AidotError):
     """Invalid url exception."""
 
+
 class HTTPError(AidotError):
     """Invalid host exception."""
 
+
 class InvalidHost(AidotError):
     """Invalid host exception."""
 
+
 class AidotAuthTokenExpired(AidotError):
     """Authentication failed because token is invalid or expired."""
 
+
 class AidotAuthFailed(AidotError):
     """Authentication failed"""
 
+
+class AidotNotLogin(AidotError):
+    """Aidot not login"""
+
+
 class AidotUserOrPassIncorrect(AidotError):
     """Authentication failed"""
 
+
 class AidotOSError(Exception):
     """Aidot exception."""

{python_aidot-0.3.2 → python_aidot-0.3.4}/aidot/login_const.py

@@ -1,6 +1,5 @@
 """Constants for the aidot integration."""
 
-
 APP_ID = "1383974540041977857"
 BASE_URL = "https://prod-us-api.arnoo.com/v17"
 
@@ -11,4 +10,4 @@ p2Gp/f/bHwlrAdplbX3p7/TnGpnbJGkLq8uRxf6cw+vOthTsZjkPCF7CatRvRnTj
 c9fcy7yE0oXa5TloYyXD6GkxgftBbN/movkJJGQCc7gFavuYoAdTRBOyQoXBtm0m
 kXMSjXOldI/290b9BQIDAQAB
 -----END PUBLIC KEY-----
-"""
+"""

{python_aidot-0.3.2 → python_aidot-0.3.4}/python_aidot.egg-info/PKG-INFO

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

{python_aidot-0.3.2 → python_aidot-0.3.4}/python_aidot.egg-info/SOURCES.txt

@@ -6,9 +6,9 @@ aidot/__init__.py
 aidot/aes_utils.py
 aidot/client.py
 aidot/const.py
+aidot/device_client.py
 aidot/discover.py
 aidot/exceptions.py
-aidot/lan.py
 aidot/login_const.py
 python_aidot.egg-info/PKG-INFO
 python_aidot.egg-info/SOURCES.txt

{python_aidot-0.3.2 → python_aidot-0.3.4}/setup.py

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

python_aidot-0.3.2/aidot/lan.py

@@ -1,318 +0,0 @@
-import socket
-import struct
-import binascii
-import time
-from datetime import datetime
-import json
-import asyncio
-import logging
-
-from .aes_utils import aes_encrypt,aes_decrypt
-_LOGGER = logging.getLogger(__name__)
-
-class Lan(object):
-
-    _is_on : bool = False
-    _dimming = 0
-    _rgdb : int
-    _cct : int
-    _login_uuid = 0
-    _available : bool = False
-
-    _connectAndLogin : bool = False
-    _connecting = False
-    _simpleVersion = ""
-    _colorMode = ""
-
-    @property
-    def is_on(self) -> bool:
-        return self._is_on
-
-    @property
-    def brightness(self) -> int:
-        return self._dimming * 255 / 100
-
-    @property
-    def rgdb(self) -> int:
-        return self._rgdb
-
-    @property
-    def cct(self) -> int:
-        return self._cct
-
-    @property
-    def available(self) -> bool:
-        return self._available
-
-    @property
-    def connectAndLogin(self) -> bool:
-        return self._connectAndLogin
-
-    @property
-    def connecting(self) -> bool:
-        return self._connecting
-
-    @property
-    def colorMode(self) -> str:
-        return self._colorMode
-
-    def __init__(self,device:dict,user_info:dict) -> None:
-        self.ping_count = 0
-
-        if "id" in user_info:
-            self.user_id = user_info["id"]
-
-        if "aesKey" in device :
-            key_string = device["aesKey"][0]
-            if key_string is not None:
-                self.aes_key = bytearray(16)
-                key_bytes = key_string.encode()
-                self.aes_key[:len(key_bytes)] = key_bytes
-
-        if "password" in device:
-            self.password = device["password"]
-
-        if "id" in device:
-            self.device_id = device["id"]
-
-        if "simpleVersion" in device:
-            self._simpleVersion = device["simpleVersion"]
-
-    async def connect(self,ipAddress):
-        self.reader = self.writer = None
-        self._connecting = True
-        try:
-            self.reader, self.writer = await asyncio.open_connection(ipAddress, 10000)
-            sock: socket.socket = self.writer.get_extra_info("socket")
-            sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
-            self.seq_num = 1
-            await self.login()
-            self._connectAndLogin = True
-        except Exception as e:
-            self._connectAndLogin = False
-        finally:
-            self._connecting = False
-
-    def setUpdateDeviceCb(self,callback):
-        self._updateDeviceCb = callback
-
-    def printfHex(self,packet):
-        hex_representation = binascii.hexlify(packet).decode()
-
-    def getSendPacket(self,message,msgtype):
-        magic = struct.pack('>H', 0x1eed)
-        _msgtype = struct.pack('>h', msgtype)
-
-        if self.aes_key is not None:
-            send_data = aes_encrypt(message,self.aes_key)
-        else :
-            send_data = message
-
-        bodysize = struct.pack('>i', len(send_data))
-        packet = magic + _msgtype + bodysize + send_data
-
-        return packet
-
-    async def login(self):
-        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
-            }
-        }
-        self.writer.write(self.getSendPacket(json.dumps(message).encode(),1))
-        await self.writer.drain()
-
-        data = await self.reader.read(1024)
-        data_len = len(data)
-        if(data_len <= 0):
-            return
-
-        magic, msgtype, bodysize = struct.unpack('>HHI', data[:8])
-        encrypted_data = data[8:]
-        if self.aes_key is not None:
-            decrypted_data = aes_decrypt(encrypted_data, self.aes_key)
-        else :
-            decrypted_data = encrypted_data
-
-        json_data = json.loads(decrypted_data)
-
-        self.ascNumber = json_data["payload"]["ascNumber"]
-        self.ascNumber += 1
-
-        self._available = True
-
-        await self.sendAction({},"getDevAttrReq")
-
-    async def recvData(self):
-        while True:
-            try :
-                data = await self.reader.read(1024)
-            except Exception as e:
-                _LOGGER.error(f"recv data error {e}")
-                await asyncio.sleep(3)
-                continue
-            data_len = len(data)
-            if(data_len <= 0):
-                break
-
-            try:
-                magic, msgtype, bodysize = struct.unpack('>HHI', data[:8])
-                encrypted_data = data[8:]
-                decrypted_data = aes_decrypt(encrypted_data, self.aes_key)
-
-                json_data = json.loads(decrypted_data)
-            except Exception as e:
-                _LOGGER.error(f"recv json error : {e}")
-                await asyncio.sleep(3)
-                continue
-
-            if "service" in json_data:
-                if "test" == json_data["service"]:
-                    self.ping_count = 0
-
-            if "payload" in json_data:
-                if "ascNumber" in json_data["payload"]:
-                    self.ascNumber = json_data["payload"]["ascNumber"]
-                if "attr" in json_data["payload"]:
-                    if "OnOff" in json_data["payload"]["attr"]:
-                        self._is_on = json_data["payload"]["attr"]["OnOff"]
-                    if "Dimming" in json_data["payload"]["attr"]:
-                        self._dimming = json_data["payload"]["attr"]["Dimming"]
-                    if "RGBW" in json_data["payload"]["attr"]:
-                        self._rgdb = json_data["payload"]["attr"]["RGBW"]
-                        self._colorMode = "rgbw"
-                    if "CCT" in json_data["payload"]["attr"]:
-                        self._cct = json_data["payload"]["attr"]["CCT"]
-                        self._colorMode = "cct"
-                    if self._updateDeviceCb:
-                        await self._updateDeviceCb()
-
-    async def ping_task(self):
-        while True:
-            await asyncio.sleep(5) #加个延迟，不然遇到查状态和发ping同时出现状态回不来，暂时不知道什么原因
-            if await self.sendPingAction() == -1 :
-                return
-            await asyncio.sleep(5)
-
-    def getOnOffAction(self,OnOff):
-        self._is_on = OnOff
-        return {"OnOff": self._is_on}
-
-    def getDimingAction(self,brightness):
-        self._dimming = int(brightness * 100 / 255)
-        return {"Dimming": self._dimming}
-
-    def getCCTAction(self,cct):
-        self._cct = cct
-        self._colorMode = "cct"
-        return {"CCT": self._cct}
-
-    def getRGBWAction(self,rgbw):
-        self._rgdb = rgbw
-        self._colorMode = "rgbw"
-        return {"RGBW": rgbw}
-
-    async def sendDevAttr(self,devAttr):
-        await self.sendAction(devAttr,"setDevAttrReq")
-
-    async def sendAction(self,attr,method):
-
-        current_timestamp_milliseconds = int(time.time() * 1000)
-
-        self.seq_num += 1
-
-        seq = "ha93" + str(self.seq_num).zfill(5)
-
-        if not self._is_on and not "OnOff" in attr:
-            attr["OnOff"] = 1
-            self._is_on = 1
-
-        if self._simpleVersion is not None:
-            action = {
-                "method": method,
-                "service": "device",
-                "clientId": "ha-" + self.user_id,
-                "srcAddr": "0." + self.user_id,
-                "seq": "" + seq,
-                "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,
-                # "tid": "homeassistant",
-                "deviceId": self.device_id,
-            }
-        else :
-            action = {
-                "method": method,
-                "service": "device",
-                "seq": "" + seq,
-                "srcAddr": "0." + self.user_id,
-                "payload": {
-                    "attr": attr,
-                    "ascNumber":self.ascNumber,
-                },
-                "tst": current_timestamp_milliseconds,
-                # "tid": "homeassistant",
-                "deviceId": self.device_id,
-            }
-
-        try:
-            self.writer.write(self.getSendPacket(json.dumps(action).encode(),1))
-            await self.writer.drain()
-        except BrokenPipeError as e :
-            _LOGGER.error(f"{self.device_id} send action error {e}")
-        except Exception as e:
-            _LOGGER.error(f"{self.device_id} send action error {e}")
-
-    async def sendPingAction(self):
-        ping = {
-            "service": "test",
-            "method": "pingreq",
-            "seq": "123456",
-            "srcAddr": "x.xxxxxxx",
-            "payload": {}
-        }
-        try:
-            if self.ping_count >= 2 :
-                _LOGGER.error(f"Last ping did not return within 20 seconds. device id:{self.device_id}")
-                await self.reset()
-                return -1
-            self.writer.write(self.getSendPacket(json.dumps(ping).encode(),2))
-            await self.writer.drain()
-            self.ping_count += 1
-            return 1
-        except Exception as e:
-            _LOGGER.error(f"{self.device_id} ping error {e}")
-            await self.reset()
-            return -1
-
-    async def reset(self):
-        try:
-            if self.writer:
-                self.writer.close()
-                await self.writer.wait_closed()
-        except Exception as e:
-            _LOGGER.error(f"{self.device_id} writer close error {e}")
-        self._connectAndLogin = False
-        self._available = False
-        self.ping_count = 0
-        if self._updateDeviceCb:
-            await self._updateDeviceCb()
-