python-roborock 0.4.7__tar.gz → 0.4.9__tar.gz

{python_roborock-0.4.7 → python_roborock-0.4.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-roborock
-Version: 0.4.7
+Version: 0.4.9
 Summary: 
 License: GPL-3.0-only
 Author: humbertogontijo

{python_roborock-0.4.7 → python_roborock-0.4.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-roborock"
-version = "0.4.7"
+version = "0.4.9"
 description = ""
 authors = ["humbertogontijo <humbertogontijo@users.noreply.github.com>"]
 license = "GPL-3.0-only"

{python_roborock-0.4.7 → python_roborock-0.4.9}/roborock/api.py

@@ -147,7 +147,7 @@ class RoborockClient:
         }
 
     def _encode_msg(self, device_id, request_id, protocol, timestamp, payload, prefix=None) -> bytes:
-        local_key = self.devices_info[device_id].device.local_key
+        local_key = self.devices_info[device_id].local_key
         aes_key = md5bin(encode_timestamp(timestamp) + local_key + self._salt)
         cipher = AES.new(aes_key, AES.MODE_ECB)
         encrypted = cipher.encrypt(pad(payload, AES.block_size))
@@ -173,7 +173,7 @@ class RoborockClient:
 
     async def on_message(self, device_id, msg) -> bool:
         try:
-            data = self._decode_msg(msg, self.devices_info[device_id].device.local_key)
+            data = self._decode_msg(msg, self.devices_info[device_id].local_key)
             protocol = data.get("protocol")
             if protocol == 102 or protocol == 4:
                 payload = json.loads(data.get("payload").decode())

{python_roborock-0.4.7 → python_roborock-0.4.9}/roborock/cloud_api.py

@@ -5,7 +5,7 @@ import logging
 import secrets
 import threading
 from asyncio import Lock
-from typing import Any, Callable
+from typing import Any
 from urllib.parse import urlparse
 
 import paho.mqtt.client as mqtt
@@ -22,7 +22,7 @@ from .containers import (
 )
 from .roborock_queue import RoborockQueue
 from .typing import (
-    RoborockCommand, RoborockDeviceProp,
+    RoborockCommand, RoborockDeviceProp, RoborockDeviceInfo,
 )
 from .util import run_in_executor
 
@@ -34,10 +34,10 @@ MQTT_KEEPALIVE = 60
 class RoborockMqttClient(RoborockClient, mqtt.Client):
     _thread: threading.Thread
 
-    def __init__(self, user_data: UserData, device_localkey: dict[str, str]) -> None:
+    def __init__(self, user_data: UserData, devices_info: dict[str, RoborockDeviceInfo]) -> None:
         rriot = user_data.rriot
         endpoint = base64.b64encode(md5bin(rriot.endpoint)[8:14]).decode()
-        RoborockClient.__init__(self, endpoint, device_localkey)
+        RoborockClient.__init__(self, endpoint, devices_info)
         mqtt.Client.__init__(self, protocol=mqtt.MQTTv5)
         self._mqtt_user = rriot.user
         self._hashed_user = md5hex(self._mqtt_user + ":" + rriot.endpoint)[2:10]
@@ -192,7 +192,7 @@ class RoborockMqttClient(RoborockClient, mqtt.Client):
         _LOGGER.debug(f"id={request_id} Requesting method {method} with {params}")
         request_protocol = 101
         response_protocol = 301 if method in SPECIAL_COMMANDS else 102
-        msg = super()._encode_msg(device_id, request_protocol, timestamp, payload)
+        msg = super()._encode_msg(device_id, request_id, request_protocol, timestamp, payload)
         self._send_msg_raw(device_id, msg)
         (response, err) = await self._async_response(request_id, response_protocol)
         if err:

{python_roborock-0.4.7 → python_roborock-0.4.9}/roborock/local_api.py

@@ -10,7 +10,7 @@ import async_timeout
 
 from roborock.api import RoborockClient, SPECIAL_COMMANDS
 from roborock.exceptions import RoborockTimeout, CommandVacuumError
-from roborock.typing import RoborockCommand, RoborockDeviceInfo
+from roborock.typing import RoborockCommand, RoborockLocalDeviceInfo
 from roborock.util import get_running_loop_or_create_one
 
 secured_prefix = 199
@@ -35,11 +35,11 @@ class RoborockProtocol(asyncio.DatagramProtocol):
 
 class RoborockLocalClient(RoborockClient):
 
-    def __init__(self, devices_info: dict[str, RoborockDeviceInfo]):
+    def __init__(self, devices_info: dict[str, RoborockLocalDeviceInfo]):
         super().__init__("abc", devices_info)
         self.loop = get_running_loop_or_create_one()
         self.device_listener: dict[str, RoborockSocketListener] = {
-            device_id: RoborockSocketListener(device_info.network_info.ip, device_id, self.on_message)
+            device_id: RoborockSocketListener(device_info.ip, device_id, self.on_message)
             for device_id, device_info in devices_info.items()
         }
         self._mutex = Lock()

python_roborock-0.4.9/roborock/offline/offline.py

@@ -0,0 +1,26 @@
+import asyncio
+import logging
+
+from roborock.local_api import RoborockLocalClient
+from roborock.typing import RoborockLocalDeviceInfo
+
+local_ip = "<local_ip>"
+local_key = "<local_key>"
+device_id = "<device_id>"
+
+
+async def main():
+    logging_config = {
+        "level": logging.DEBUG
+    }
+    logging.basicConfig(**logging_config)
+    client = RoborockLocalClient({
+        device_id: RoborockLocalDeviceInfo(local_key, "model_test", local_ip)
+    })
+    await client.async_connect()
+    props = await client.get_prop(device_id)
+    print(props)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

{python_roborock-0.4.7 → python_roborock-0.4.9}/roborock/typing.py

@@ -4,7 +4,7 @@ from enum import Enum
 
 from .code_mappings import RoborockDockDustCollectionType, RoborockDockWashingModeType
 from .containers import Status, CleanSummary, Consumable, \
-    DNDTimer, CleanRecord, SmartWashParameters, HomeDataDevice, HomeDataProduct, NetworkInfo
+    DNDTimer, CleanRecord, SmartWashParameters
 
 
 class RoborockDevicePropField(str, Enum):
@@ -89,10 +89,14 @@ class RoborockCommand(str, Enum):
     GET_NETWORK_INFO = "get_network_info"
 
 class RoborockDeviceInfo:
-    def __init__(self, device: HomeDataDevice, product: HomeDataProduct, network_info: NetworkInfo = None):
-        self.device = device
-        self.product = product
-        self.network_info: NetworkInfo | None = network_info
+    def __init__(self, local_key: str, model: str):
+        self.local_key = local_key
+        self.model = model
+
+class RoborockLocalDeviceInfo(RoborockDeviceInfo):
+    def __init__(self, local_key: str, model: str, ip: str):
+        super().__init__(local_key, model)
+        self.ip = ip
 
 class RoborockDockSummary:
     def __init__(self, dust_collection_mode: RoborockDockDustCollectionType,

python_roborock-0.4.7/roborock/offline/offline.py

@@ -1,35 +0,0 @@
-import asyncio
-import logging
-
-from roborock.containers import HomeDataDevice, HomeDataDeviceField, HomeDataProduct, HomeDataProductField, NetworkInfo, \
-    NetworkInfoField
-from roborock.local_api import RoborockLocalClient
-from roborock.typing import RoborockDeviceInfo
-
-local_ip = "192.168.1.232"
-local_key = "nXTBj42ej5WxQopO"
-device_id = "1r9W0cAmDZ2COuVekgRhKA"
-
-
-async def main():
-    logging_config = {
-        "level": logging.DEBUG
-    }
-    logging.basicConfig(**logging_config)
-    client = RoborockLocalClient({
-        device_id: RoborockDeviceInfo(HomeDataDevice({
-            HomeDataDeviceField.DUID: device_id,
-            HomeDataDeviceField.LOCAL_KEY: local_key
-        }), HomeDataProduct({
-            HomeDataProductField.MODEL: "test"
-        }), NetworkInfo({
-            NetworkInfoField.IP: local_ip
-        }))
-    })
-    await client.async_connect()
-    props = await client.get_prop(device_id)
-    print(props)
-
-
-if __name__ == "__main__":
-    asyncio.run(main())