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

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

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

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

@@ -38,7 +38,7 @@ from .const import (
 _LOGGER = logging.getLogger(__name__)
 
 
-def rsa_password_encrypt(message: str):
+def rsa_password_encrypt(message: str) -> str:
     """Get password rsa encrypt."""
     public_key = serialization.load_pem_public_key(
         PUBLIC_KEY_PEM, backend=default_backend()
@@ -61,7 +61,7 @@ class AidotClient:
     password: str = ""
     country_name: str = DEFAULT_COUNTRY_NAME
     login_info: dict[str, Any] = {}
-    _device_clients: dict[str:DeviceClient]
+    _device_clients: dict[str, DeviceClient]
     _discover: Discover = None
 
     def __init__(
@@ -89,16 +89,16 @@ class AidotClient:
             self._region = token[CONF_REGION]
             self.country_name = token[CONF_COUNTRY]
 
-    def set_token_fresh_cb(self, callback):
+    def set_token_fresh_cb(self, callback) -> None:
         self._token_fresh_cb = callback
 
     def get_identifier(self) -> str:
         return f"{self._region}-{self.username}"
 
-    def update_password(self, password: str):
+    def update_password(self, password: str) -> None:
         self.password = password
 
-    async def async_post_login(self):
+    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"}
@@ -127,7 +127,7 @@ class AidotClient:
                 raise AidotUserOrPassIncorrect
             raise Exception
 
-    async def async_refresh_token(self):
+    async def async_refresh_token(self) -> dict[str, Any]:
         url = f"{self._base_url}/users/refreshToken"
         headers = {CONF_APP_ID: APP_ID, CONF_TERMINAL: "app"}
         data = {
@@ -151,7 +151,9 @@ class AidotClient:
                 raise AidotAuthFailed
             return None
 
-    async def async_session_get(self, params: str, headers: str | None = None):
+    async def async_session_get(
+        self, params: str, headers: str | None = None
+    ) -> dict[str, Any]:
         url = f"{self._base_url}{params}"
         token = self.login_info[CONF_ACCESS_TOKEN]
         if token is None:
@@ -184,22 +186,22 @@ class AidotClient:
                 raise AidotAuthFailed
             return aiohttp.ClientError
 
-    async def async_get_products(self, product_ids: str):
+    async def async_get_products(self, product_ids: str) -> list[dict[str, Any]]:
         """Get device list."""
         params = f"/products/{product_ids}"
         return await self.async_session_get(params)
 
-    async def async_get_devices(self, house_id: str):
+    async def async_get_devices(self, house_id: str) -> list[dict[str, Any]]:
         """Get device list."""
         params = f"/devices?houseId={house_id}"
         return await self.async_session_get(params)
 
-    async def async_get_houses(self):
+    async def async_get_houses(self) -> list[dict[str, Any]]:
         """Get house list."""
         params = "/houses"
         return await self.async_session_get(params)
 
-    async def async_get_all_device(self):
+    async def async_get_all_device(self) -> dict[str, Any]:
         final_device_list: list[dict[str, Any]] = []
         try:
             houses = await self.async_get_houses()
@@ -221,7 +223,7 @@ class AidotClient:
             raise e
         return {CONF_DEVICE_LIST: final_device_list}
 
-    def get_device_client(self, device: dict[str:Any]) -> DeviceClient:
+    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:
@@ -233,6 +235,12 @@ class AidotClient:
             device_client.update_ip_address(ip)
         return device_client
 
+    async def remove_device_client(self, dev_id: str) -> None:
+        device_client: DeviceClient = self._device_clients.get(dev_id)
+        if device_client is not None:
+            await device_client.close()
+            del self._device_clients[dev_id]
+
     def start_discover(self) -> None:
         if self._discover is not None:
             return

{python_aidot-0.3.4 → python_aidot-0.3.42}/aidot/device_client.py

@@ -78,7 +78,7 @@ class DeviceInformation:
     name: str
     hw_version: str
 
-    def __init__(self, device: dict[str:Any]):
+    def __init__(self, device: dict[str, Any]) -> None:
         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)
@@ -102,10 +102,10 @@ class DeviceClient(object):
     _connect_and_login: bool = False
     _connecting: bool = False
     _simpleVersion: str = ""
-    _ip_address: str
+    _ip_address: str = None
     device_id: str
     _is_close: bool = False
-
+    _status_fresh_cb: Any = None
     @property
     def connect_and_login(self) -> bool:
         return self._connect_and_login
@@ -114,7 +114,7 @@ class DeviceClient(object):
     def connecting(self) -> bool:
         return self._connecting
 
-    def __init__(self, device: dict, user_info: dict) -> None:
+    def __init__(self, device: dict[str, Any], user_info: dict[str, Any]) -> None:
         self.ping_count = 0
         self.status = DeviceStatusData()
         self.info = DeviceInformation(device)
@@ -131,7 +131,8 @@ class DeviceClient(object):
         self.device_id = device.get(CONF_ID)
         self._simpleVersion = device.get("simpleVersion")
 
-    async def connect(self, ip_address):
+    async def connect(self, ip_address) -> None:
+        _LOGGER.info(f"connect device : {ip_address}")
         self.reader = self.writer = None
         self._connecting = True
         try:
@@ -147,15 +148,19 @@ class DeviceClient(object):
             self._connecting = False
 
     def update_ip_address(self, ip: str) -> None:
+        if ip is None:
+            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())
+        
     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):
+    def get_send_packet(self, message, msgtype):
         magic = struct.pack(">H", 0x1EED)
         _msgtype = struct.pack(">h", msgtype)
 
@@ -169,7 +174,7 @@ class DeviceClient(object):
 
         return packet
 
-    async def login(self):
+    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")
@@ -187,7 +192,7 @@ class DeviceClient(object):
             },
         }
         try:
-            self.writer.write(self.getSendPacket(json.dumps(message).encode(), 1))
+            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:
@@ -211,47 +216,87 @@ class DeviceClient(object):
         self.ascNumber = json_data[CONF_PAYLOAD][CONF_ASCNUMBER]
         self.ascNumber += 1
         self.status.online = True
+        asyncio.get_running_loop().create_task(self.reveive_data())
         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))
+    async def reveive_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)
+                json_data = json.loads(decrypted_data)
+            except Exception as e:
+                _LOGGER.error(f"recv json error : {e}")
+
+            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))
+                # _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):
+    async def ping_task(self) -> None:
         while True:
             if self._is_close:
                 return
@@ -259,7 +304,9 @@ class DeviceClient(object):
             await self.send_ping_action()
             await asyncio.sleep(5)
 
-    async def send_dev_attr(self, dev_attr):
+    async def send_dev_attr(self, dev_attr) -> None:
+        if not self._connect_and_login:
+            raise ConnectionError('Device offline')
         await self.send_action(dev_attr, "setDevAttrReq")
 
     async def async_turn_off(self) -> None:
@@ -279,7 +326,7 @@ class DeviceClient(object):
     async def async_set_cct(self, cct: int) -> None:
         await self.send_dev_attr({CONF_CCT: cct})
 
-    async def send_action(self, attr, method):
+    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)
@@ -321,7 +368,7 @@ class DeviceClient(object):
             }
 
         try:
-            self.writer.write(self.getSendPacket(json.dumps(action).encode(), 1))
+            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}")
@@ -329,7 +376,7 @@ class DeviceClient(object):
         except Exception as e:
             _LOGGER.error(f"{self.device_id} send action error {e}")
 
-    async def send_ping_action(self):
+    async def send_ping_action(self) -> int:
         ping = {
             "service": "test",
             "method": "pingreq",
@@ -346,7 +393,7 @@ class DeviceClient(object):
                 return -1
             if self._connect_and_login is False:
                 return -1
-            self.writer.write(self.getSendPacket(json.dumps(ping).encode(), 2))
+            self.writer.write(self.get_send_packet(json.dumps(ping).encode(), 2))
             await self.writer.drain()
             self.ping_count += 1
             return 1
@@ -355,7 +402,7 @@ class DeviceClient(object):
             await self.reset()
             return -1
 
-    async def reset(self):
+    async def reset(self) -> None:
         try:
             if self.writer:
                 self.writer.close()
@@ -366,7 +413,7 @@ class DeviceClient(object):
         self.status.online = False
         self.ping_count = 0
 
-    async def close(self):
+    async def close(self) -> None:
         self._is_close = True
         await self.reset()
         _LOGGER.info(f"{self.device_id} connect close by user")

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

@@ -12,10 +12,11 @@ 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) -> None:
         self.aes_key = bytearray(32)
         key_string = "T54uednca587"
         key_bytes = key_string.encode()
@@ -24,7 +25,7 @@ class BroadcastProtocol:
         self._discover_cb = callback
         self.user_id = user_id
 
-    def connection_made(self, transport):
+    def connection_made(self, transport) -> None:
         self.transport = transport
         sock = transport.get_extra_info("socket")
         sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
@@ -54,7 +55,7 @@ class BroadcastProtocol:
         except Exception as error:
             _LOGGER.error(f"{self.user_id}:Connection lost due to error: {error}")
 
-    def datagram_received(self, data, addr):
+    def datagram_received(self, data, addr) -> None:
         data_str = aes_decrypt(data, self.aes_key)
         data_json = json.loads(data_str)
         if "payload" in data_json:
@@ -63,7 +64,7 @@ class BroadcastProtocol:
                 if self._discover_cb:
                     self._discover_cb(devId, {CONF_IPADDRESS: addr[0]})
 
-    def error_received(self, exc):
+    def error_received(self, exc) -> None:
         _LOGGER.error(f"{self.user_id}:Error occurred: {exc}")
 
     def close(self) -> None:
@@ -72,7 +73,7 @@ class BroadcastProtocol:
         except Exception as error:
             _LOGGER.error(f"Connection lost due to error: {error}")
 
-    def connection_lost(self, exc):
+    def connection_lost(self, exc) -> None:
         self._is_closed = True
         if exc:
             _LOGGER.error(f"{self.user_id}:Connection lost due to error: {exc}")
@@ -81,9 +82,9 @@ class BroadcastProtocol:
 
 
 class Discover:
-    _login_info: dict[str:Any] = None
+    _login_info: dict[str, Any] = None
     _broadcast_protocol: BroadcastProtocol = None
-    discovered_device: dict[str:str]
+    discovered_device: dict[str, str]
     _is_close: bool = False
 
     def __init__(self, login_info, callback):
@@ -120,7 +121,7 @@ class Discover:
                 if self._is_close is True:
                     return
 
-    async def fetch_devices_info(self) -> dict[str:str]:
+    async def fetch_devices_info(self) -> dict[str, str]:
         self.try_create_broadcast()
         self._broadcast_protocol.send_broadcast()
         await asyncio.sleep(2)

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

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

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

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