python-aidot 0.2.8__tar.gz → 0.3.0__tar.gz

{python_aidot-0.2.8/python_aidot.egg-info → python_aidot-0.3.0}/PKG-INFO

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

{python_aidot-0.2.8 → python_aidot-0.3.0}/aidot/client.py

@@ -2,7 +2,7 @@
 
 import logging
 from typing import Any, Optional
-from aiohttp import ClientResponseError, ClientSession
+from aiohttp import ClientSession
 import base64
 import aiohttp
 from cryptography.hazmat.backends import default_backend
@@ -25,6 +25,7 @@ from .const import (
     CONF_PASSWORD,
     CONF_CODE,
     CONF_TOKEN,
+    CONF_DEVICE_LIST,
     ServerErrorCode
 )
 from .exceptions import AidotAuthFailed,AidotUserOrPassIncorrect
@@ -207,4 +208,4 @@ class AidotClient:
                         device[CONF_PRODUCT] = product
         except Exception as e:
             raise e
-        return final_device_list
+        return {CONF_DEVICE_LIST:final_device_list}

python_aidot-0.3.0/aidot/discover.py

@@ -0,0 +1,100 @@
+import socket
+import json
+import time
+import logging
+from typing import Any
+
+from .aes_utils import aes_encrypt,aes_decrypt
+import asyncio
+from .const import CONF_ID,CONF_IPADDRESS
+from .exceptions import AidotOSError
+
+_LOGGER = logging.getLogger(__name__)
+
+class BroadcastProtocol:
+    _is_running: bool = True
+    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
+
+        self._discover_cb = callback
+        self.user_id = user_id
+
+    def connection_made(self, transport):
+        self.transport = transport
+        sock = transport.get_extra_info("socket")
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+
+    def send_broadcast(self) -> None:
+        current_timestamp_milliseconds = int(time.time() * 1000)
+        seq = str(current_timestamp_milliseconds + 1)[-9:]
+        message = {
+            "protocolVer":"2.0.0",
+            "service":"device",
+            "method":"devDiscoveryReq",
+            "seq": seq,
+            "srcAddr":f"0.{self.user_id}]",
+            "tst":current_timestamp_milliseconds,
+            "payload":{
+                "extends":{ },
+                "localCtrFlag":1,
+                "timestamp":str(current_timestamp_milliseconds)
+            }
+        }
+        send_data = aes_encrypt(json.dumps(message).encode(),self.aes_key)
+        self.transport.sendto(send_data, ('255.255.255.255', 6666))
+
+    def datagram_received(self, data, addr):
+        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"]):
+                devId = data_json["payload"]["devId"]
+                if self._discover_cb:
+                        self._discover_cb(devId,{CONF_IPADDRESS : addr[0]})
+
+    def error_received(self, exc):
+        _LOGGER.error(f"Error occurred: {exc}")
+    
+    def close(self) -> None:
+        self.transport.close()
+    
+    def connection_lost(self, exc):
+        if exc:
+            _LOGGER.error(f"Connection lost due to error: {exc}")
+        else:
+            _LOGGER.info("Connection closed.")
+
+class Discover:
+    _login_info: dict[str: Any] = None
+    _broadcast_protocol: BroadcastProtocol = None
+    _discovered_device: dict[str: str]
+    def __init__(self,login_info):
+        self._discovered_device = {}
+        self._login_info = login_info
+
+    async def fetch_devices_info(self) -> dict[str: str]:
+        if self._broadcast_protocol is None:
+            self._broadcast_protocol = BroadcastProtocol(self._discover_callback,self._login_info[CONF_ID])
+            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
+
+        self._broadcast_protocol.send_broadcast()
+        await asyncio.sleep(2)
+        return self._discovered_device
+
+    def _discover_callback(self, dev_id, event: dict[str, str]) -> None:
+        self._discovered_device[dev_id] = event[CONF_IPADDRESS]
+    
+    def close(self) -> None:
+        if self._broadcast_protocol is not None:
+            self._broadcast_protocol.close()
+
+

{python_aidot-0.2.8 → python_aidot-0.3.0}/aidot/exceptions.py

@@ -15,8 +15,7 @@ class AidotAuthTokenExpired(AidotError):
     """Authentication failed because token is invalid or expired."""
 
 class AidotAuthFailed(AidotError):
-    """Authentication failed because MFA verification code is required."""
+    """Authentication failed """
 
-class AidotUserOrPassIncorrect(AidotError):
-    """The password or email address is incorrect."""
-    
+class AidotOSError(Exception):
+    """Aidot exception."""

{python_aidot-0.2.8 → python_aidot-0.3.0}/aidot/lan.py

@@ -4,9 +4,6 @@ import binascii
 import time
 from datetime import datetime
 import json
-import threading
-import colorsys
-from time import sleep
 import asyncio
 import logging
 

{python_aidot-0.2.8 → python_aidot-0.3.0/python_aidot.egg-info}/PKG-INFO

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

{python_aidot-0.2.8 → python_aidot-0.3.0}/python_aidot.egg-info/SOURCES.txt

@@ -10,8 +10,6 @@ aidot/discover.py
 aidot/exceptions.py
 aidot/lan.py
 aidot/login_const.py
-aidot/login_control.py
-aidot/login_data.py
 python_aidot.egg-info/PKG-INFO
 python_aidot.egg-info/SOURCES.txt
 python_aidot.egg-info/dependency_links.txt

{python_aidot-0.2.8 → python_aidot-0.3.0}/setup.py

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

python_aidot-0.2.8/aidot/discover.py

@@ -1,74 +0,0 @@
-import socket
-import binascii
-import threading
-import json
-import time
-import logging
-
-from .aes_utils import aes_encrypt,aes_decrypt
-import asyncio
-
-_LOGGER = logging.getLogger(__name__)
-
-class BroadcastProtocol:
-
-    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
-
-        self._discoverCb = callback
-        self.user_id = user_id
-
-    def connection_made(self, transport):
-        self.transport = transport
-        sock = transport.get_extra_info("socket")
-        sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
-        self.discover_task = asyncio.create_task(self.do_discover())
-    
-    async def do_discover(self):
-        while True:
-            current_timestamp_milliseconds = int(time.time() * 1000)
-            seq = str(current_timestamp_milliseconds + 1)[-9:]
-            message = {
-                "protocolVer":"2.0.0",
-                "service":"device",
-                "method":"devDiscoveryReq",
-                "seq": seq,
-                "srcAddr":f"0.{self.user_id}]",
-                "tst":current_timestamp_milliseconds,
-                "payload":{
-                    "extends":{ },
-                    "localCtrFlag":1,
-                    "timestamp":str(current_timestamp_milliseconds)
-                }
-            }
-            send_data = aes_encrypt(json.dumps(message).encode(),self.aes_key)
-            self.transport.sendto(send_data, ('255.255.255.255', 6666))
-            await asyncio.sleep(3)
-
-    def datagram_received(self, data, addr):
-        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"]):
-                devId = data_json["payload"]["devId"]
-                if self._discoverCb:
-                        self._discoverCb(devId,{"ipAddress" : addr[0]})
-
-    def error_received(self, exc):
-        _LOGGER.error(f"Error occurred: {exc}")
-
-class Discover:
-
-    async def broadcast_message(self,callback,user_id):
-        transport, protocol = await asyncio.get_event_loop().create_datagram_endpoint(
-            lambda: BroadcastProtocol(callback,user_id),
-            local_addr=("0.0.0.0", 0),  
-        )
-
-
-
-            
-

python_aidot-0.2.8/aidot/login_control.py

@@ -1,191 +0,0 @@
-"""The aidot integration."""
-
-from homeassistant.core import HomeAssistant
-import aiohttp
-import logging
-from .login_data import LoginData
-
-import base64
-from cryptography.hazmat.backends import default_backend
-from cryptography.hazmat.primitives import serialization
-from cryptography.hazmat.primitives.asymmetric import rsa
-from cryptography.hazmat.primitives.asymmetric import padding
-from cryptography.hazmat.primitives import hashes
-
-from .login_const import APP_ID, PUBLIC_KEY_PEM
-from .const import SUPPORTED_COUNTRYS
-_LOGGER = logging.getLogger(__name__)
-
-def rsa_password_encrypt(message: str):
-    """Get password rsa encrypt."""   
-    public_key = serialization.load_pem_public_key(
-        PUBLIC_KEY_PEM, backend=default_backend()
-    )
-
-    encrypted = public_key.encrypt(
-        message.encode("utf-8"),
-        padding.PKCS1v15(),  
-    )
-
-    encrypted_base64 = base64.b64encode(encrypted).decode("utf-8")
-
-    return encrypted_base64
-
-
-class LoginControl:
-    _instance = None  # singleton
-
-    def __new__(cls, *args, **kwargs):
-        if cls._instance is None:
-            cls._instance = super().__new__(cls)
-        return cls._instance
-
-    def __init__(self) -> None:
-        self.LoginData = LoginData()
-        self.region = "us"
-        self.username = ""
-    
-    def get_identifier(self,house_id: str) -> str:
-        identifier = (
-                    "username:"
-                    + self.username
-                    + ","
-                    + "house_id:"
-                    + house_id 
-                    + ","
-                    + "region:"
-                    + self.region
-                )
-        return identifier
-
-    def change_country_code(self, selected_contry_obj: str):
-        """Do change_country_code."""
-        self.LoginData.baseUrl = (
-            f"https://prod-{selected_contry_obj['region'].lower()}-api.arnoo.com/v17"
-        )
-    
-    def change_country_name(self, selected_contry_name: str):
-        selected_contry_obj = {}
-        for item in SUPPORTED_COUNTRYS:
-            if item["name"] == selected_contry_name:
-                selected_contry_obj = item
-                break
-        selected_region = selected_contry_obj['region']
-        if selected_region is not None:
-            self.region = selected_region.lower()
-            self.LoginData.baseUrl = (f"https://prod-{self.region}-api.arnoo.com/v17")
-
-    async def async_get_products(
-        self, hass: HomeAssistant, token: str, product_ids: str
-    ):
-        """Get device list."""
-        url = f"{self.LoginData.baseUrl}/products/{product_ids}"
-        headers = {
-            "Terminal": "app",
-            "Token": token,
-            "Appid": APP_ID,
-        }
-
-        session = hass.helpers.aiohttp_client.async_get_clientsession()
-
-        try:
-            async with session.get(url, headers=headers) as response:
-                response.raise_for_status()
-                response_data = await response.json()
-                return response_data
-        except aiohttp.ClientError as e:
-            _LOGGER.info("async_get_products ClientError {e}")
-            return None
-
-    async def async_get_devices(self, hass: HomeAssistant, token: str, house_id: str):
-        """Get device list."""
-
-        url = f"{self.LoginData.baseUrl}/devices?houseId={house_id}"
-        headers = {
-            "Terminal": "app",
-            "Token": token,
-            "Appid": APP_ID,
-        }
-
-        session = hass.helpers.aiohttp_client.async_get_clientsession()
-
-        try:
-            async with session.get(url, headers=headers) as response:
-                response.raise_for_status()
-                response_data = await response.json()
-                return response_data
-        except aiohttp.ClientError as e:
-            _LOGGER.info("async_get_devices ClientError {e}")
-            return None
-
-    async def async_get_houses(self, hass: HomeAssistant, token: str):
-        """Get house list."""
-
-        url = f"{self.LoginData.baseUrl}/houses"
-        headers = {
-            "Terminal": "app",
-            "Token": token,
-            "Appid": APP_ID,
-        }
-
-        session = hass.helpers.aiohttp_client.async_get_clientsession()
-
-        try:
-            async with session.get(url, headers=headers) as response:
-                response.raise_for_status()
-                response_data = await response.json()
-                return response_data
-        except aiohttp.ClientError as e:
-            _LOGGER.info("async_get_houses ClientError {e}")
-            return None
-
-    async def async_post_login(self, hass: HomeAssistant, username: str, password: str):
-        """Login the user input allows us to connect."""
-        self.username = username
-        url = f"{self.LoginData.baseUrl}/users/loginWithFreeVerification"
-        headers = {"Appid": APP_ID, "Terminal": "app"}
-        data = {
-            "countryKey": "region:UnitedStates",
-            "username": username,
-            "password": rsa_password_encrypt(password),
-            "terminalId": "gvz3gjae10l4zii00t7y0",
-            "webVersion": "0.5.0",
-            "area": "Asia/Shanghai",
-            "UTC": "UTC+8",
-        }
-        session = hass.helpers.aiohttp_client.async_get_clientsession()
-
-        try:
-            async with session.post(url, headers=headers, json=data) as response:
-                response.raise_for_status()
-                login_response = await response.json()
-                return login_response
-        except aiohttp.ClientError as e:
-            _LOGGER.info("async_post_login ClientError {e}")
-            return None
-
-    async def async_get_all_login_info(
-        self, hass: HomeAssistant, username: str, password: str
-    ):
-        """Get get all login info."""
-        # login in
-        login_response = await self.async_post_login(
-            hass,
-            username,
-            password,
-        )
-        accessToken = login_response["accessToken"]
-
-        # get houses
-        default_house = await self.async_get_houses(hass, accessToken)
-
-        # get device_list
-        device_list = await self.async_get_devices(
-            hass, accessToken, default_house["id"]
-        )
-
-        # get product_list
-        productIds = ",".join([item["productId"] for item in device_list])
-        product_list = await self.async_get_products(hass, accessToken, productIds)
-
-        return (login_response, default_house, device_list, product_list)

python_aidot-0.2.8/aidot/login_data.py

@@ -1,16 +0,0 @@
-"""The aidot integration."""
-
-from .login_const import BASE_URL
-
-
-class LoginData:
-
-    _instance = None  # singleton
-
-    def __new__(cls, *args, **kwargs):
-        if cls._instance is None:
-            cls._instance = super().__new__(cls)
-        return cls._instance
-
-    def __init__(self) -> None:
-        self.baseUrl = BASE_URL