python-aidot 0.3.45__tar.gz → 0.3.47__tar.gz

{python_aidot-0.3.45 → python_aidot-0.3.47}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: python-aidot
-Version: 0.3.45
+Version: 0.3.47
 Summary: aidot control wifi lights
 Home-page: https://github.com/Aidot-Development-Team/python-aidot
 Author: aidotdev2024
@@ -16,6 +16,7 @@ Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: summary
 

{python_aidot-0.3.45 → python_aidot-0.3.47}/aidot/client.py

@@ -9,7 +9,9 @@ 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
-
+import uuid
+from pathlib import Path
+import hashlib
 from .exceptions import AidotAuthFailed, AidotUserOrPassIncorrect
 from .device_client import DeviceClient
 from .discover import Discover
@@ -75,6 +77,7 @@ class AidotClient:
         password: str | None = None,
         token: dict | None = None,
     ) -> None:
+        _LOGGER.info(f"Aidot Client Version: v0.3.46")
         self.session = session
         self.username = username
         self.password = password
@@ -93,7 +96,7 @@ class AidotClient:
             self._region = token[CONF_REGION]
             self.country_name = token[CONF_COUNTRY]
             self._base_url = f"https://prod-{self._region}-api.arnoo.com/v17"
-
+        self.setup_discover()
     def set_token_fresh_cb(self, callback) -> None:
         self._token_fresh_cb = callback
 
@@ -102,17 +105,35 @@ class AidotClient:
 
     def update_password(self, password: str) -> None:
         self.password = password
+    
+    def get_terminal_id(self) -> str:
+        file_path = Path.home() / ".aidot_terminal_id"
+        if file_path.exists():
+            raw_id = file_path.read_text().strip()
+        else:
+            node = uuid.getnode()
+            is_random = (node >> 40) & 1
+            
+            if is_random:
+                raw_id = str(uuid.uuid4())
+            else:
+                raw_id = format(node, 'x')
+            file_path.write_text(raw_id)
+        return hashlib.md5(raw_id.encode()).hexdigest()
 
     async def async_post_login(self) -> dict[str, Any]:
         """Login the user input allows us to connect."""
         url = f"{self._base_url}/users/loginWithFreeVerification"
         headers = {CONF_APP_ID: APP_ID, CONF_TERMINAL: "app"}
         # f"{region}:{self.country_name.strip()}",
+        terminalId = self.get_terminal_id()
+        if terminalId is None:
+            terminalId = "gvz3gjae10l4zii00t7y0"
         data = {
             "countryKey": f"region:{self.country_name.strip()}",
             "username": self.username,
             "password": rsa_password_encrypt(self.password),
-            "terminalId": "gvz3gjae10l4zii00t7y0",
+            "terminalId": terminalId,
             "webVersion": "0.5.0",
             "area": "Asia/Shanghai",
             "UTC": "UTC+8",
@@ -126,6 +147,7 @@ class AidotClient:
             self.login_info[CONF_PASSWORD] = self.password
             self.login_info[CONF_REGION] = self._region
             self.login_info[CONF_COUNTRY] = self.country_name
+            self.setup_discover()
             return self.login_info
         except aiohttp.ClientError as e:
             _LOGGER.info(f"async_post_login ClientError {e}")
@@ -237,7 +259,6 @@ class AidotClient:
         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)
@@ -249,7 +270,10 @@ class AidotClient:
             await device_client.close()
             del self._device_clients[dev_id]
 
-    def start_discover(self) -> None:
+    def setup_discover(self) -> None:
+        """初始化完成后调用，启动设备发现"""
+        if self.login_info.get(CONF_ID) is None:
+            return
         if self._discover is not None:
             return
 
@@ -260,14 +284,18 @@ class AidotClient:
                 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())
+        self._discover.start_repeat_broadcast()
 
-    def stop_discover(self) -> None:
-        self._discover.close()
-        self._discover = None
-
-    def cleanup(self) -> None:
-        self.stop_discover()
+    async def async_close(self) -> None:
+        """关闭客户端，清理资源"""
+        if self._discover is not None:
+            self._discover.close()
+            self._discover = None
         for client in self._device_clients.values():
-            asyncio.get_running_loop().create_task(client.close())
+            await client.close()
         self._device_clients.clear()
+
+    async def async_cleanup(self) -> None:
+        """清理所有资源"""
+        _LOGGER.info(f"async_cleanup")
+        await self.async_close()

{python_aidot-0.3.45 → python_aidot-0.3.47}/aidot/device_client.py

@@ -107,7 +107,14 @@ class DeviceClient(object):
     _ip_address: str = None
     device_id: str
     _is_close: bool = False
-    _status_fresh_cb: Any = None
+    on_status_update: Any = None
+    _receive_task: Any = None
+    _login_task: Any = None
+    _reconnect_handle: Any = None
+    _ping_timer: Any = None
+    writer: Any = None
+    reader: Any = None
+    _TAG: str = "DeviceClient"
     @property
     def connect_and_login(self) -> bool:
         return self._connect_and_login
@@ -132,9 +139,11 @@ class DeviceClient(object):
         self.password = device.get(CONF_PASSWORD)
         self.device_id = device.get(CONF_ID)
         self._simpleVersion = device.get("simpleVersion")
+        self._TAG = f"{self.device_id}";
+        _LOGGER.warning(f"{self._TAG}:{device}")
 
     async def connect(self, ip_address) -> None:
-        _LOGGER.info(f"connect device : {ip_address}")
+        _LOGGER.warning(f"{self._TAG}:connect device: {ip_address}")
         self.reader = self.writer = None
         self._connecting = True
         try:
@@ -154,7 +163,8 @@ class DeviceClient(object):
             return
         self._ip_address = ip
         if self._connecting is not True and self._connect_and_login is not True:
-            asyncio.get_running_loop().create_task(self.async_login())
+            self._login_task = asyncio.create_task(self.async_login())
+
         
     async def async_login(self) -> None:
         if self._ip_address is None:
@@ -175,6 +185,11 @@ class DeviceClient(object):
         packet = magic + _msgtype + bodysize + send_data
 
         return packet
+    
+    def _notify_status_update(self) -> None:
+        if self.on_status_update:
+            self.on_status_update(self.status)
+        
 
     async def login(self) -> None:
         login_seq = str(int(time.time() * 1000) + self._login_uuid)[-9:]
@@ -196,68 +211,60 @@ class DeviceClient(object):
         try:
             self.writer.write(self.get_send_packet(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
-        
-        try:
-            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
-
+            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:
                 # 登录失败
-                _LOGGER.error(f"{self.device_id} login error, code: {code}")
+                _LOGGER.error(f"{self._TAG}:login error, code: {code}")
                 await self.reset()
                 return
 
-            self.ascNumber = json_data[CONF_PAYLOAD][CONF_ASCNUMBER]
-            self.ascNumber += 1
+            self.ascNumber = json_data[CONF_PAYLOAD][CONF_ASCNUMBER] + 1
             self.status.online = True
-            asyncio.get_running_loop().create_task(self.reveive_data())
-            _LOGGER.info(f"connect device success: {self._ip_address}")
+            self._receive_task = asyncio.create_task(
+                self.receive_data(),
+                name=f"aidot_receive_{self.device_id}"
+            )
+            if self._ping_timer:
+                self._ping_timer.cancel()
+            if self._reconnect_handle:
+                self._reconnect_handle.cancel()
+                self._reconnect_handle = None
+            self._schedule_ping()
+            _LOGGER.warning(f"{self._TAG}:connect success: {self._ip_address}")
             await self.send_action({}, "getDevAttrReq")
-        except Exception as e:
-            _LOGGER.error(f"connect device error : {e}")
-            return
-
-        
+        except (BrokenPipeError, ConnectionResetError, Exception) as e:
+            _LOGGER.error(f"{self.device_id} login read status error {e}")
 
-    async def reveive_data(self) -> None:
+    # TCP容易拼包，需要谨慎处理
+    async def receive_data(self) -> None:
         while True:
             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
-            except Exception as e:
-                _LOGGER.error(f"recv data error {e}")
-                return
-            data_len = len(data)
-            if data_len <= 0:
-                _LOGGER.error("recv data error len, exit socket")
-                await self.reset()
-                self.status.online = False
-                return
-            try:
-                magic, msgtype, bodysize = struct.unpack(">HHI", data[:8])
-                decrypted_data = aes_decrypt(data[8:], self.aes_key)
+                header = await self.reader.readexactly(8)
+                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)
+                _LOGGER.warning(f"{self._TAG}:reveive_data : {json_data}")
+            except asyncio.CancelledError:
+                _LOGGER.debug(f"{self._TAG}:Receive task cancelled")
+                raise
+            except (BrokenPipeError, ConnectionResetError, asyncio.IncompleteReadError) as e:
+                _LOGGER.error(f"{self._TAG}:read status error {e}")
+                # await self.reset()
+                syncio.get_running_loop().call_soon(
+                    lambda: asyncio.create_task(self.reset())
+                )
+                return
             except Exception as e:
-                _LOGGER.error(f"recv json error : {e}")
+                _LOGGER.error(f"{self._TAG}:recv error: {e}")
+                self.ping_count = 0
                 continue
 
             if "service" in json_data:
@@ -269,56 +276,12 @@ class DeviceClient(object):
             if payload is not None:
                 self.ascNumber = payload.get(CONF_ASCNUMBER)
                 self.status.update(payload.get(CONF_ATTR))
-                # _LOGGER.info(f"recv status : {payload}")
-                if self._status_fresh_cb:
-                    self._status_fresh_cb(self.status)
-    def set_status_fresh_cb(self, callback) -> None:
-        self._status_fresh_cb = callback
-    async def read_status(self) -> DeviceStatusData:
-        # 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) -> None:
-        while True:
-            if self._is_close:
-                return
-            await asyncio.sleep(5)
-            await self.send_ping_action()
-            await asyncio.sleep(5)
+                self._notify_status_update()
+    
+    def _schedule_ping(self):
+        loop = asyncio.get_running_loop()
+        loop.create_task(self.send_ping_action())
+        self._ping_timer = loop.call_later(30, self._schedule_ping)
 
     async def send_dev_attr(self, dev_attr) -> None:
         if not self._connect_and_login:
@@ -387,12 +350,14 @@ class DeviceClient(object):
             self.writer.write(self.get_send_packet(json.dumps(action).encode(), 1))
             await self.writer.drain()
         except (BrokenPipeError, ConnectionResetError) as e:
-            _LOGGER.error(f"{self.device_id} send action error {e}")
+            _LOGGER.error(f"{self._TAG}:send action error {e}")
             await self.reset()
         except Exception as e:
-            _LOGGER.error(f"{self.device_id} send action error {e}")
+            _LOGGER.error(f"{self._TAG}:send action error {e}")
 
     async def send_ping_action(self) -> int:
+        if self._is_close:
+            return -1
         ping = {
             "service": "test",
             "method": "pingreq",
@@ -400,10 +365,11 @@ class DeviceClient(object):
             "srcAddr": "x.xxxxxxx",
             CONF_PAYLOAD: {},
         }
+        # _LOGGER.info(f"{self.device_id} send_ping_action {ping}")
         try:
-            if self.ping_count >= 2:
+            if self.ping_count >= 3:
                 _LOGGER.error(
-                    f"Last ping did not return within 20 seconds. device id:{self.device_id}"
+                    f"{self._TAG}:Device unresponsive within 90 seconds, disconnecting."
                 )
                 await self.reset()
                 return -1
@@ -419,17 +385,47 @@ class DeviceClient(object):
             return -1
 
     async def reset(self) -> None:
+        if self._ping_timer:
+            self._ping_timer.cancel()
+        if self._reconnect_handle:
+            self._reconnect_handle.cancel()
+            self._reconnect_handle = None
+
+        if self._receive_task and not self._receive_task.done():
+            self._receive_task.cancel()
+            try:
+                await self._receive_task
+            except asyncio.CancelledError as e:
+                _LOGGER.error(f"{self.device_id} writer close error {e}")
+                pass
         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}")
+            _LOGGER.error(f"{self.device_id} writer/reader close error {e}")
+        self.writer = self.reader = None;
+
         self._connect_and_login = False
         self.status.online = False
         self.ping_count = 0
+        self._notify_status_update()
+        # 自动重连（如果没有主动关闭）
+        if not self._is_close and self._ip_address:
+            self._schedule_reconnect()
 
     async def close(self) -> None:
         self._is_close = True
         await self.reset()
         _LOGGER.info(f"{self.device_id} connect close by user")
+
+    def _schedule_reconnect(self) -> None:
+        """延迟重连"""
+        _LOGGER.info(f"{self.device_id} _schedule_reconnect")
+        loop = asyncio.get_running_loop()
+        # self._reconnect_handle = loop.call_later(
+        #     10,  # 10秒后重连
+        #     lambda: asyncio.create_task(self.async_login())
+        # )
+        self._reconnect_handle = loop.call_later(15, self._schedule_reconnect)
+        self._login_task = asyncio.create_task(self.async_login())

{python_aidot-0.3.45 → python_aidot-0.3.47}/aidot/discover.py

@@ -10,8 +10,10 @@ from .const import CONF_ID, CONF_IPADDRESS
 from .exceptions import AidotOSError
 
 _LOGGER = logging.getLogger(__name__)
-_DISCOVER_TIME = 5
+# _DISCOVER_TIME = 15
 
+_DISCOVER_FAST = 10      # 启动时快速发现
+_DISCOVER_SLOW = 120    # 稳定后慢速维持
 
 class BroadcastProtocol:
     _is_closed = False
@@ -49,6 +51,7 @@ class BroadcastProtocol:
                 "timestamp": str(current_timestamp_milliseconds),
             },
         }
+        _LOGGER.info(f"send_broadcast {message}")
         send_data = aes_encrypt(json.dumps(message).encode(), self.aes_key)
         try:
             self.transport.sendto(send_data, ("255.255.255.255", 6666))
@@ -58,6 +61,7 @@ class BroadcastProtocol:
     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"]
@@ -85,47 +89,51 @@ class Discover:
     _login_info: dict[str, Any] = None
     _broadcast_protocol: BroadcastProtocol = None
     discovered_device: dict[str, str]
-    _is_close: bool = False
+    _timer_handle: asyncio.TimerHandle | None = None
 
     def __init__(self, login_info, callback):
         self.discovered_device = {}
         self._login_info = login_info
         self._callback = callback
-
+    
     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]
+        if self._broadcast_protocol is not None:
+            return
+        try:
+            protocol = BroadcastProtocol(self._discover_callback, self._login_info[CONF_ID])
+            self._transport, _ = await asyncio.get_running_loop().create_datagram_endpoint(
+                lambda: protocol,
+                local_addr=("0.0.0.0", 0),
             )
-            try:
-                (
-                    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._broadcast_protocol = protocol  # 成功后再赋值
+        except OSError:
+            raise AidotOSError
+
+    def start_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
+        self._fast_discover_count = 3  # 前三次快速
+        self._schedule_broadcast()
+
+    def _schedule_broadcast(self) -> None:
+        _LOGGER.debug(f"_schedule_broadcast")
+        # 前几次快速发现，之后慢速
+        if self._fast_discover_count > 0:
+            interval = _DISCOVER_FAST
+            self._fast_discover_count -= 1
+        else:
+            interval = _DISCOVER_SLOW
+        
+        loop = asyncio.get_running_loop()
+        asyncio.create_task(self._do_broadcast())
+        self._timer_handle = loop.call_later(interval, self._schedule_broadcast)
+
+    async def _do_broadcast(self) -> None:
+        """执行广播"""
+        try:
+            await self.try_create_broadcast()
+            self._broadcast_protocol.send_broadcast()
+        except Exception as e:
+            _LOGGER.error(f"Broadcast failed: {e}")
 
     def _discover_callback(self, dev_id, event: dict[str, str]) -> None:
         self.discovered_device[dev_id] = event[CONF_IPADDRESS]
@@ -133,7 +141,9 @@ class Discover:
             self._callback(dev_id, event)
 
     def close(self) -> None:
-        self._is_close = True
+        if self._timer_handle is not None:
+            self._timer_handle.cancel()
+            self._timer_handle = None
         if self._broadcast_protocol is not None:
             self._broadcast_protocol.close()
             self._broadcast_protocol = None

{python_aidot-0.3.45 → python_aidot-0.3.47}/python_aidot.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: python-aidot
-Version: 0.3.45
+Version: 0.3.47
 Summary: aidot control wifi lights
 Home-page: https://github.com/Aidot-Development-Team/python-aidot
 Author: aidotdev2024
@@ -16,6 +16,7 @@ Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: summary
 

{python_aidot-0.3.45 → python_aidot-0.3.47}/setup.py

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