python-aidot 0.1.0__py3-none-any.whl

aidot/aes_utils.py

@@ -0,0 +1,25 @@
+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): 
+    padder = padding.PKCS7(algorithms.AES.block_size).padder()
+    padded_data = padder.update(plaintext) + padder.finalize()
+
+    cipher = Cipher(algorithms.AES(key), modes.ECB(), backend=default_backend())
+    encryptor = cipher.encryptor()
+
+    ciphertext = encryptor.update(padded_data) + encryptor.finalize()
+
+    return ciphertext
+
+def aes_decrypt(ciphertext, key):
+    cipher = Cipher(algorithms.AES(key), modes.ECB(), backend=default_backend())
+    decryptor = cipher.decryptor()
+
+    decrypted_data = decryptor.update(ciphertext) + decryptor.finalize()
+
+    unpadder = padding.PKCS7(algorithms.AES.block_size).unpadder()
+    plaintext = unpadder.update(decrypted_data) + unpadder.finalize()
+
+    return plaintext.decode()

aidot/discover.py

@@ -0,0 +1,74 @@
+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),  
+        )
+
+
+
+            
+

aidot/lan.py

@@ -0,0 +1,292 @@
+import socket
+import struct
+import binascii
+import time
+from datetime import datetime
+import json
+import threading
+import colorsys
+from time import sleep
+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 = ""
+   
+    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
+
+    @property
+    def brightness(self) -> int:
+        return self._dimming * 255 / 100
+
+    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: 
+            if await self.sendPingAction() == -1 :
+                return
+            await asyncio.sleep(10)
+
+    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()
+        

aidot/login_const.py

@@ -0,0 +1,14 @@
+"""Constants for the aidot integration."""
+
+
+APP_ID = "1383974540041977857"
+BASE_URL = "https://prod-us-api.arnoo.com/v17"
+
+PUBLIC_KEY_PEM = b"""
+-----BEGIN PUBLIC KEY-----
+MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCtQAnPCi8ksPnS1Du6z96PsKfN
+p2Gp/f/bHwlrAdplbX3p7/TnGpnbJGkLq8uRxf6cw+vOthTsZjkPCF7CatRvRnTj
+c9fcy7yE0oXa5TloYyXD6GkxgftBbN/movkJJGQCc7gFavuYoAdTRBOyQoXBtm0m
+kXMSjXOldI/290b9BQIDAQAB
+-----END PUBLIC KEY-----
+"""

aidot/login_control.py

@@ -0,0 +1,164 @@
+"""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
+_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()
+
+    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"
+        )
+
+    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."""
+
+        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)

aidot/login_data.py

@@ -0,0 +1,16 @@
+"""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

python_aidot-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2024 Fabian Affolter <fabian@affolter-engineering.ch>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

python_aidot-0.1.0.dist-info/METADATA

@@ -0,0 +1,16 @@
+Metadata-Version: 2.1
+Name: python-aidot
+Version: 0.1.0
+Summary: aidot control wifi lights
+Author: aidotdev2024
+Classifier: Programming Language :: Python :: 3.11
+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: setuptools
+
+
+aidot is a Python library to control the aidot Wi-Fi Lights with home assistant.

python_aidot-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+aidot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aidot/aes_utils.py,sha256=lCOJ0VXx9REn6ot1jCFK8o-oY-fQ0amcDAbOFwqauu0,950
+aidot/discover.py,sha256=lict_jTNiSRg57Lo_6uixqklUQy0H34G5z46Xgf_hoE,2359
+aidot/lan.py,sha256=g2vjwZViS9EeM7AYc3-mN0ZJ8iXx0TDaNm_IKEzkiVo,9527
+aidot/login_const.py,sha256=-bQBeq_cqGM5IT53hSlvr1SJ2WC8G7NHE7EzI63OXrY,436
+aidot/login_control.py,sha256=WkvdTKJjwuyGSSorTwkLD-rRRy5glwADRVcFo2FsuiA,5610
+aidot/login_data.py,sha256=bw417da8bkd71KnAvlPEgmSgwvjiI3b23mqmyOq3Tfc,351
+python_aidot-0.1.0.dist-info/LICENSE,sha256=EZzvMisn9C0Z2kwzKMqGE_xljuPxjA9bwUetwX_1nwM,1141
+python_aidot-0.1.0.dist-info/METADATA,sha256=nh28oHlMcW_ohQU4JbpXs0Jom7ScT-_rTldBEzm4y8U,495
+python_aidot-0.1.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+python_aidot-0.1.0.dist-info/top_level.txt,sha256=_doNL2OOnXeinm1X72eH2wz26wAkZwbM47KhNB6_QzI,6
+python_aidot-0.1.0.dist-info/RECORD,,

python_aidot-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.43.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

python_aidot-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+aidot