python-aidot 0.3.54b4__tar.gz → 0.3.56__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot
-Version: 0.3.54b4
+Version: 0.3.56
 Summary: aidot control wifi lights
 Home-page: https://github.com/Aidot-Development-Team/python-aidot
 Author: aidotdev2024
@@ -9,8 +9,10 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: requests
 Requires-Dist: aiohttp
+Requires-Dist: cryptography
+Requires-Dist: dacite
+Requires-Dist: requests
 Dynamic: author
 Dynamic: classifier
 Dynamic: description

{python_aidot-0.3.54b4 → python_aidot-0.3.56}/aidot/aes_utils.py

@@ -29,18 +29,22 @@ def aes_decrypt(ciphertext, key):
     return plaintext.decode()
 
 
-def aes_decrypt_to_json(ciphertext: bytes, key: Optional[bytes] = None) -> dict[str, Any]:
+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
+        decrypted_data = (
+            ciphertext.decode() if isinstance(ciphertext, bytes) else ciphertext
+        )
     return json.loads(decrypted_data)

{python_aidot-0.3.54b4 → python_aidot-0.3.56}/aidot/client.py

@@ -36,8 +36,7 @@ from .const import (
     SUPPORTED_COUNTRYS,
     DEFAULT_COUNTRY_CODE,
     CONF_IS_OWNER,
-    CONF_TYPE,
-    CONF_AES_KEY,
+    CONF_LOGIN_INFO,
     ServerErrorCode,
 )
 
@@ -60,17 +59,6 @@ def rsa_password_encrypt(message: str) -> str:
 
 
 class AidotClient:
-    _base_url: str = API_URL_TEMPLATE.format(region=DEFAULT_REGION)
-    _region: str = DEFAULT_REGION
-    session: Optional[ClientSession] = None
-    username: str = ""
-    password: str = ""
-    country_name: str = DEFAULT_COUNTRY_NAME
-    country_code: str = DEFAULT_COUNTRY_CODE
-    login_info: dict[str, Any] = {}
-    _device_clients: dict[str, DeviceClient]
-    _discover: Discover = None
-
     def __init__(
         self,
         session: Optional[ClientSession],
@@ -79,12 +67,18 @@ class AidotClient:
         password: str | None = None,
         token: dict | None = None,
     ) -> None:
-        _LOGGER.info("Client Version: v0.3.54b3")
+        _LOGGER.info("Client Version: v0.3.56")
         self.session = session
         self.username = username
         self.password = password
-        self.country_code = country_code
+        self.country_code = country_code or DEFAULT_COUNTRY_CODE
+        self.country_name = DEFAULT_COUNTRY_NAME
+        self._region = DEFAULT_REGION
+        self._base_url = API_URL_TEMPLATE.format(region=self._region)
+        self.login_info: dict[str, Any] = {}
         self._device_clients = {}
+        self._discover: Discover | None = None
+        self._token_fresh_cb = None
         for item in SUPPORTED_COUNTRYS:
             if item["id"] == self.country_code:
                 self.country_name = item["name"]
@@ -97,7 +91,7 @@ class AidotClient:
             # 新版本: config_entry.data
             if token.get(CONF_ID) is None and token.get(CONF_LOGIN_INFO) is not None:
                 token = token.get(CONF_LOGIN_INFO)
-            
+
             self.login_info = token.copy()
             self.username = token[CONF_USERNAME]
             self.password = token[CONF_PASSWORD]
@@ -105,6 +99,7 @@ class AidotClient:
             self.country_name = token[CONF_COUNTRY]
             self._base_url = API_URL_TEMPLATE.format(region=self._region)
         self.setup_discover()
+
     def set_token_fresh_cb(self, callback) -> None:
         self._token_fresh_cb = callback
 
@@ -113,7 +108,7 @@ class AidotClient:
 
     def update_password(self, password: str) -> None:
         self.password = password
-    
+
     async def get_terminal_id(self) -> str:
         file_path = Path.home() / ".aidot_terminal_id"
 
@@ -127,7 +122,7 @@ class AidotClient:
                 file_path.write_text(raw_id)
                 return raw_id
             except OSError:
-                return 'gvz3gjae10l4zii00t7y0'
+                return "gvz3gjae10l4zii00t7y0"
 
         raw_id = await asyncio.to_thread(_read_or_create)
         return hashlib.md5(raw_id.encode()).hexdigest()
@@ -150,6 +145,7 @@ class AidotClient:
             "UTC": "UTC+8",
         }
 
+        response_data: dict[str, Any] = {}
         try:
             response = await self.session.post(url, headers=headers, json=data)
             response_data = await response.json()
@@ -160,11 +156,11 @@ class AidotClient:
             self.login_info[CONF_COUNTRY] = self.country_name
             self.setup_discover()
             return self.login_info
-        except aiohttp.ClientError as e:
-            _LOGGER.error(f"async_post_login ClientError: {e}")
-            if response_data[CONF_CODE] == ServerErrorCode.USER_PWD_INCORRECT:
-                raise AidotUserOrPassIncorrect
-            raise Exception
+        except aiohttp.ClientError as err:
+            _LOGGER.error("async_post_login ClientError: %s", err)
+            if response_data.get(CONF_CODE) == ServerErrorCode.USER_PWD_INCORRECT:
+                raise AidotUserOrPassIncorrect from err
+            raise
 
     async def async_refresh_token(self) -> dict[str, Any]:
         url = f"{self._base_url}/users/refreshToken"
@@ -173,6 +169,7 @@ class AidotClient:
             CONF_REFRESH_TOKEN: self.login_info[CONF_REFRESH_TOKEN],
         }
 
+        response_data: dict[str, Any] = {}
         try:
             response = await self.session.post(url, headers=headers, json=data)
             response_data = await response.json()
@@ -184,11 +181,11 @@ class AidotClient:
             if self._token_fresh_cb:
                 self._token_fresh_cb()
             return response_data
-        except aiohttp.ClientError as e:
-            _LOGGER.error(f"async_refresh_token ClientError: {e} {response_data}")
-            if response_data[CONF_CODE] == ServerErrorCode.LOGIN_INVALID:
-                raise AidotAuthFailed
-            return None
+        except aiohttp.ClientError as err:
+            _LOGGER.error("async_refresh_token ClientError: %s %s", err, response_data)
+            if response_data.get(CONF_CODE) == ServerErrorCode.LOGIN_INVALID:
+                raise AidotAuthFailed from err
+            raise
 
     async def async_session_get(
         self, params: str, headers: str | None = None
@@ -209,21 +206,21 @@ class AidotClient:
             response_data = await response.json()
             response.raise_for_status()
             return response_data
-        except aiohttp.ClientError as e:
-            _LOGGER.error(f"async_get ClientError: {e} {response_data}")
+        except aiohttp.ClientError as err:
+            _LOGGER.error("async_get ClientError: %s %s", err, response_data)
             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
+                except AidotAuthFailed as auth_err:
+                    raise AidotAuthFailed from auth_err
             elif (
                 code == ServerErrorCode.LOGIN_INVALID or code == 21027 or code == 21041
             ):
                 self.login_info[CONF_ACCESS_TOKEN] = None
-                raise AidotAuthFailed
-            return aiohttp.ClientError
+                raise AidotAuthFailed from err
+            raise
 
     async def async_get_products(self, product_ids: str) -> list[dict[str, Any]]:
         """Get device list."""
@@ -253,6 +250,8 @@ class AidotClient:
                     final_device_list.extend(device_list)
 
             # get product_list
+            if not final_device_list:
+                return {CONF_DEVICE_LIST: []}
             productIds = ",".join([item[CONF_PRODUCT_ID] for item in final_device_list])
             product_list = await self.async_get_products(productIds)
 
@@ -260,7 +259,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}
@@ -289,7 +288,8 @@ class AidotClient:
         if self._discover is not None:
             return
 
-        _LOGGER.warning(f"setup_discover")
+        _LOGGER.warning("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.54b4 → python_aidot-0.3.56}/aidot/device_client.py

@@ -7,16 +7,19 @@ 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_to_json
-from .models.device_client_model import PingRequest, LoginRequest, LoginPayload, DeviceResponse, DeviceAttr, DeviceActionRequest
+from .models.device_client_model import (
+    PingRequest,
+    LoginRequest,
+    LoginPayload,
+    DeviceResponse,
+    DeviceAttr,
+    DeviceActionRequest,
+)
 from .const import (
     CONF_AES_KEY,
-    CONF_ASCNUMBER,
-    CONF_ATTR,
     CONF_CCT,
     CONF_HARDWARE_VERSION,
     CONF_ID,
@@ -29,13 +32,10 @@ from .const import (
     CONF_ON_OFF,
     CONF_DIMMING,
     CONF_PASSWORD,
-    CONF_PAYLOAD,
     CONF_PRODUCT,
     CONF_PROPERTIES,
     CONF_RGBW,
     CONF_SERVICE_MODULES,
-    CONF_ACK,
-    CONF_CODE,
     CONF_GET_DEV_ATTR_REQ,
     CONF_SET_DEV_ATTR_REQ,
     Identity,
@@ -67,7 +67,7 @@ class DeviceStatusData:
                 self.rgdb = 0xFF000000  # Red in int: 4278190080
             else:
                 self.rgdb = rgbw_value
-            
+
             rgbw = ctypes.c_uint32(self.rgdb).value
             r = (rgbw >> 24) & 0xFF
             g = (rgbw >> 16) & 0xFF
@@ -128,6 +128,7 @@ class DeviceClient(object):
     heart_time = 30
     ping_data = PingRequest().to_dict()
     _TAG: str = "DeviceClient"
+
     @property
     def connect_and_login(self) -> bool:
         return self._connect_and_login
@@ -153,7 +154,7 @@ 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':
+        if self.info.model_id == "lk.WIFI-RGBWLight-D0006":
             self.ping_data = None
             self.heart_time = 10
 
@@ -183,7 +184,6 @@ class DeviceClient(object):
         if self._connecting is not True and self._connect_and_login is not True:
             self._login_task = asyncio.create_task(self.async_login())
 
-        
     async def async_login(self) -> None:
         if self._ip_address is None:
             return
@@ -203,16 +203,15 @@ 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:]
         self._login_uuid += 1
-        
+
         login_request = LoginRequest(
             seq=login_seq,
             srcAddr=self.user_id,
@@ -231,7 +230,7 @@ class DeviceClient(object):
             body = await self.reader.readexactly(bodysize)
             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:
                 # 登录失败
@@ -243,8 +242,7 @@ class DeviceClient(object):
             self.status.online = True
             self._notify_status_update()
             self._receive_task = asyncio.create_task(
-                self.receive_data(),
-                name=f"aidot_receive_{self.device_id}"
+                self.receive_data(), name=f"aidot_receive_{self.device_id}"
             )
             if self._ping_timer:
                 self._ping_timer.cancel()
@@ -263,14 +261,18 @@ class DeviceClient(object):
             try:
                 header = await self.reader.readexactly(8)
                 magic, msgtype, bodysize = struct.unpack(">HHI", header)
-                self.ping_count = 0 #有读到数据就把ping清零
+                self.ping_count = 0  # 有读到数据就把ping清零
                 body = await self.reader.readexactly(bodysize)
                 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")
                 raise
-            except (BrokenPipeError, ConnectionResetError, asyncio.IncompleteReadError) as e:
+            except (
+                BrokenPipeError,
+                ConnectionResetError,
+                asyncio.IncompleteReadError,
+            ) as e:
                 _LOGGER.error(f"{self._TAG}:read status error {e}")
                 asyncio.get_running_loop().call_soon(
                     lambda: asyncio.create_task(self.reset())
@@ -283,14 +285,14 @@ class DeviceClient(object):
             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()
         loop.create_task(self.send_ping_action())
@@ -298,10 +300,10 @@ class DeviceClient(object):
 
     async def send_dev_attr(self, dev_attr) -> None:
         if not self._connect_and_login:
-            raise ConnectionError('Device offline')
-        if not self.status.on and not CONF_ON_OFF in dev_attr:
+            raise ConnectionError("Device offline")
+        if not self.status.on and CONF_ON_OFF not in dev_attr:
             self.status.on = True
-            attr[CONF_ON_OFF] = 1
+            dev_attr[CONF_ON_OFF] = 1
         await self.send_action(dev_attr, CONF_SET_DEV_ATTR_REQ)
 
     async def async_turn_off(self) -> None:
@@ -333,7 +335,7 @@ class DeviceClient(object):
             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:
@@ -357,11 +359,13 @@ class DeviceClient(object):
                 return -1
             if self._connect_and_login is False:
                 return -1
-            
+
             self.ping_count += 1
             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))
+                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}")

{python_aidot-0.3.54b4 → python_aidot-0.3.56}/aidot/discover.py

@@ -1,6 +1,5 @@
 import socket
 import json
-import time
 import logging
 import asyncio
 from typing import Any
@@ -11,14 +10,15 @@ from .exceptions import AidotOSError
 from aidot.models.discover_model import DiscoverResponse, DiscoverRequest
 
 _LOGGER = logging.getLogger(__name__)
-_DISCOVER_FAST = 6      # 启动时快速发现
-_DISCOVER_SLOW = 120    # 稳定后慢速维持
+_DISCOVER_FAST = 6  # 启动时快速发现
+_DISCOVER_SLOW = 120  # 稳定后慢速维持
+
 
 class BroadcastProtocol:
     _is_closed = False
 
     def __init__(self, callback, user_id) -> None:
-        self.aes_key = bytearray(b"T54uednca587".ljust(32, b'\x00'))
+        self.aes_key = bytearray(b"T54uednca587".ljust(32, b"\x00"))
 
         self._discover_cb = callback
         self.user_id = user_id
@@ -79,13 +79,18 @@ class Discover:
         self.discovered_device = {}
         self._login_info = login_info
         self._callback = callback
-    
+
     async def try_create_broadcast(self) -> None:
         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(
+            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),
             )
@@ -99,14 +104,14 @@ class Discover:
         self._schedule_broadcast()
 
     def _schedule_broadcast(self) -> None:
-        _LOGGER.warning(f"_schedule_broadcast")
+        _LOGGER.warning("_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)

{python_aidot-0.3.54b4 → python_aidot-0.3.56}/aidot/login_const.py

@@ -1,16 +1,16 @@
-"""Constants for the aidot login."""
-
-APP_ID = "1383974540041977857"
-
-# API URL template - use .format(region="us") to construct
-API_URL_TEMPLATE = "https://prod-{region}-api.arnoo.com/v17"
-DEFAULT_REGION = "us"
-
-PUBLIC_KEY_PEM = b"""
------BEGIN PUBLIC KEY-----
-MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCtQAnPCi8ksPnS1Du6z96PsKfN
-p2Gp/f/bHwlrAdplbX3p7/TnGpnbJGkLq8uRxf6cw+vOthTsZjkPCF7CatRvRnTj
-c9fcy7yE0oXa5TloYyXD6GkxgftBbN/movkJJGQCc7gFavuYoAdTRBOyQoXBtm0m
-kXMSjXOldI/290b9BQIDAQAB
------END PUBLIC KEY-----
-"""
+"""Constants for the aidot login."""
+
+APP_ID = "1383974540041977857"
+
+# API URL template - use .format(region="us") to construct
+API_URL_TEMPLATE = "https://prod-{region}-api.arnoo.com/v17"
+DEFAULT_REGION = "us"
+
+PUBLIC_KEY_PEM = b"""
+-----BEGIN PUBLIC KEY-----
+MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCtQAnPCi8ksPnS1Du6z96PsKfN
+p2Gp/f/bHwlrAdplbX3p7/TnGpnbJGkLq8uRxf6cw+vOthTsZjkPCF7CatRvRnTj
+c9fcy7yE0oXa5TloYyXD6GkxgftBbN/movkJJGQCc7gFavuYoAdTRBOyQoXBtm0m
+kXMSjXOldI/290b9BQIDAQAB
+-----END PUBLIC KEY-----
+"""

{python_aidot-0.3.54b4 → python_aidot-0.3.56}/aidot/models/device_client_model.py

@@ -56,6 +56,7 @@ class LoginPayload:
         """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")
 
 
@@ -74,6 +75,7 @@ class LoginRequest:
         """Convert to dictionary."""
         return asdict(self)
 
+
 @dataclass
 class DeviceAck:
     """Device response ack."""
@@ -162,6 +164,7 @@ class DeviceActionRequest:
         """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]:
@@ -207,4 +210,3 @@ class DeviceActionRequest:
                 ),
                 deviceId=device_id,
             )
-        

{python_aidot-0.3.54b4 → python_aidot-0.3.56}/aidot/models/discover_model.py

@@ -1,4 +1,5 @@
 """Models for AiDot discover."""
+
 import time
 from dataclasses import dataclass, asdict, field
 from typing import Any, Optional
@@ -94,7 +95,7 @@ class DiscoverRequest:
             tst=current_timestamp_milliseconds,
             payload=DiscoverRequestPayload(
                 timestamp=str(current_timestamp_milliseconds)
-            )
+            ),
         )
 
     def to_dict(self) -> dict[str, Any]:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot
-Version: 0.3.54b4
+Version: 0.3.56
 Summary: aidot control wifi lights
 Home-page: https://github.com/Aidot-Development-Team/python-aidot
 Author: aidotdev2024
@@ -9,8 +9,10 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: requests
 Requires-Dist: aiohttp
+Requires-Dist: cryptography
+Requires-Dist: dacite
+Requires-Dist: requests
 Dynamic: author
 Dynamic: classifier
 Dynamic: description

{python_aidot-0.3.54b4 → python_aidot-0.3.56}/python_aidot.egg-info/SOURCES.txt

@@ -18,4 +18,5 @@ python_aidot.egg-info/PKG-INFO
 python_aidot.egg-info/SOURCES.txt
 python_aidot.egg-info/dependency_links.txt
 python_aidot.egg-info/requires.txt
-python_aidot.egg-info/top_level.txt
+python_aidot.egg-info/top_level.txt
+tests/test_client.py

python_aidot-0.3.56/python_aidot.egg-info/requires.txt

@@ -0,0 +1,4 @@
+aiohttp
+cryptography
+dacite
+requests

{python_aidot-0.3.54b4 → python_aidot-0.3.56}/setup.cfg

@@ -1,5 +1,5 @@
 [metadata]
-desciption-file = README.md
+description_file = README.md
 
 [egg_info]
 tag_build = 

{python_aidot-0.3.54b4 → python_aidot-0.3.56}/setup.py

@@ -1,24 +1,26 @@
-import setuptools
-
-with open("README.md", "r") as fh:
-    long_description = fh.read()
-
-setuptools.setup(
-    name="python-aidot",
-    version="0.3.54b4",
-    author="aidotdev2024",
-    url='https://github.com/Aidot-Development-Team/python-aidot',
-    description="aidot control wifi lights",
-    long_description=long_description,
-    long_description_content_type="text/markdown",
-    packages=setuptools.find_packages(),
-    install_requires=[
-        "requests",
-        "aiohttp",
-    ],
-    classifiers=(
-        "Programming Language :: Python :: 3.12",
-        "License :: OSI Approved :: MIT License",
-        "Operating System :: OS Independent",
-    ),
-)
+import setuptools
+
+with open("README.md", "r") as fh:
+    long_description = fh.read()
+
+setuptools.setup(
+    name="python-aidot",
+    version="0.3.56",
+    author="aidotdev2024",
+    url="https://github.com/Aidot-Development-Team/python-aidot",
+    description="aidot control wifi lights",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    packages=setuptools.find_packages(),
+    install_requires=[
+        "aiohttp",
+        "cryptography",
+        "dacite",
+        "requests",
+    ],
+    classifiers=(
+        "Programming Language :: Python :: 3.12",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ),
+)

python_aidot-0.3.56/tests/test_client.py

@@ -0,0 +1,147 @@
+"""Tests for the AiDot client."""
+
+import unittest
+from typing import Any
+
+import aiohttp
+
+from aidot.client import AidotClient
+from aidot.const import (
+    CONF_ACCESS_TOKEN,
+    CONF_COUNTRY,
+    CONF_ID,
+    CONF_PASSWORD,
+    CONF_REFRESH_TOKEN,
+    CONF_REGION,
+    CONF_USERNAME,
+)
+
+
+class FakeResponse:
+    """Minimal aiohttp response test double."""
+
+    def __init__(self, data: dict[str, Any]) -> None:
+        self._data = data
+
+    async def json(self) -> dict[str, Any]:
+        """Return the response payload."""
+        return self._data
+
+    def raise_for_status(self) -> None:
+        """Represent a successful response."""
+
+
+class FakeSession:
+    """Record requests made by one client."""
+
+    def __init__(self, response: dict[str, Any]) -> None:
+        self._response = response
+        self.post_calls: list[tuple[str, dict[str, str], dict[str, Any]]] = []
+
+    async def post(
+        self,
+        url: str,
+        *,
+        headers: dict[str, str],
+        json: dict[str, Any],
+    ) -> FakeResponse:
+        """Record a POST request."""
+        self.post_calls.append((url, headers, json))
+        return FakeResponse(self._response)
+
+
+class FailingSession:
+    """Raise a typed connection error for every request."""
+
+    async def post(
+        self,
+        url: str,
+        *,
+        headers: dict[str, str],
+        json: dict[str, Any],
+    ) -> FakeResponse:
+        """Simulate a network failure."""
+        raise aiohttp.ClientConnectionError
+
+
+def create_token(
+    *, username: str, region: str, access_token: str, refresh_token: str
+) -> dict[str, Any]:
+    """Create stored login data for a client."""
+    return {
+        CONF_ID: None,
+        CONF_USERNAME: username,
+        CONF_PASSWORD: "password",
+        CONF_COUNTRY: "United States",
+        CONF_REGION: region,
+        CONF_ACCESS_TOKEN: access_token,
+        CONF_REFRESH_TOKEN: refresh_token,
+    }
+
+
+class AidotClientTest(unittest.IsolatedAsyncioTestCase):
+    """Verify client state is isolated by account."""
+
+    async def test_multiple_accounts_keep_state_isolated(self) -> None:
+        """Refreshing one account does not update another account."""
+        first_session = FakeSession(
+            {
+                CONF_ACCESS_TOKEN: "first-new-access",
+                CONF_REFRESH_TOKEN: "first-new-refresh",
+            }
+        )
+        second_session = FakeSession(
+            {
+                CONF_ACCESS_TOKEN: "second-new-access",
+                CONF_REFRESH_TOKEN: "second-new-refresh",
+            }
+        )
+        first_client = AidotClient(
+            session=first_session,
+            token=create_token(
+                username="first@example.com",
+                region="us",
+                access_token="first-access",
+                refresh_token="first-refresh",
+            ),
+        )
+        second_client = AidotClient(
+            session=second_session,
+            token=create_token(
+                username="second@example.com",
+                region="eu",
+                access_token="second-access",
+                refresh_token="second-refresh",
+            ),
+        )
+        refreshed: list[str] = []
+        first_client.set_token_fresh_cb(lambda: refreshed.append("first"))
+        second_client.set_token_fresh_cb(lambda: refreshed.append("second"))
+
+        await first_client.async_refresh_token()
+
+        self.assertIsNot(first_client.login_info, second_client.login_info)
+        self.assertEqual(first_client.login_info[CONF_ACCESS_TOKEN], "first-new-access")
+        self.assertEqual(
+            first_client.login_info[CONF_REFRESH_TOKEN], "first-new-refresh"
+        )
+        self.assertEqual(second_client.login_info[CONF_ACCESS_TOKEN], "second-access")
+        self.assertEqual(second_client.login_info[CONF_REFRESH_TOKEN], "second-refresh")
+        self.assertEqual(second_session.post_calls, [])
+        self.assertEqual(refreshed, ["first"])
+
+    async def test_login_preserves_connection_error(self) -> None:
+        """Login keeps aiohttp connection errors typed for callers."""
+        client = AidotClient(
+            session=FailingSession(),
+            country_code="US",
+            username="user@example.com",
+            password="password",
+        )
+
+        with self.assertRaises(aiohttp.ClientConnectionError):
+            await client.async_post_login()
+
+
+if __name__ == "__main__":
+    unittest.main()

python_aidot-0.3.54b4/python_aidot.egg-info/requires.txt

@@ -1,2 +0,0 @@
-requests
-aiohttp