pymammotion 0.2.6__tar.gz → 0.2.8__tar.gz

{pymammotion-0.2.6 → pymammotion-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pymammotion
-Version: 0.2.6
+Version: 0.2.8
 Summary: 
 License: GNU-3.0
 Author: Michael Arthur
@@ -17,6 +17,7 @@ Requires-Dist: alibabacloud-iot-api-gateway (>=0.0.4,<0.0.5)
 Requires-Dist: alicloud-gateway-iot (>=1.0.0,<2.0.0)
 Requires-Dist: aliyun-iot-linkkit (>=1.2.12,<2.0.0)
 Requires-Dist: aliyun-python-sdk-iot (>=8.57.0,<9.0.0)
+Requires-Dist: async-timeout (>=4.0.3,<5.0.0)
 Requires-Dist: betterproto (>=1.2.5,<2.0.0)
 Requires-Dist: bleak (>=0.21.0)
 Requires-Dist: bleak-retry-connector (>=3.5.0,<4.0.0)

{pymammotion-0.2.6 → pymammotion-0.2.8}/pymammotion/aliyun/cloud_gateway.py

@@ -10,6 +10,7 @@ import string
 import time
 import uuid
 from logging import getLogger, exception
+from datetime import datetime
 
 from aiohttp import ClientSession
 from alibabacloud_iot_api_gateway.client import Client
@@ -48,6 +49,9 @@ MOVE_HEADERS = (
 class SetupException(Exception):
     pass
 
+class AuthRefreshException(Exception):
+    """Raise exception when library cannot refresh token."""
+
 
 class CloudIOTGateway:
     """Class for interacting with Aliyun Cloud IoT Gateway."""
@@ -56,16 +60,18 @@ class CloudIOTGateway:
     _device_sn = ""
     _utdid = ""
 
-    _connect_response = None
-    _login_by_oauth_response = None
-    _aep_response = None
-    _session_by_authcode_response = None
-    _listing_dev_by_account_response = None
-    _region = None
+    _connect_response: ConnectResponse | None = None
+    _login_by_oauth_response: LoginByOAuthResponse | None = None
+    _aep_response: AepResponse | None = None
+    _session_by_authcode_response: SessionByAuthCodeResponse | None = None
+    _devices_by_account_response: ListingDevByAccountResponse | None = None
+    _region_response = None
+
+    _iot_token_issued_at : int = None
 
     converter = DatatypeConverter()
 
-    def __init__(self):
+    def __init__(self, connect_response: ConnectResponse | None, login_by_oauth_response: LoginByOAuthResponse | None, aep_response: AepResponse | None, session_by_authcode_response: SessionByAuthCodeResponse | None, region_response: RegionResponse | None, dev_by_account: ListingDevByAccountResponse | None):
         """Initialize the CloudIOTGateway."""
         self._app_key = APP_KEY
         self._app_secret = APP_SECRET
@@ -74,6 +80,12 @@ class CloudIOTGateway:
         self._client_id = self.generate_hardware_string(8)  # 8 characters
         self._device_sn = self.generate_hardware_string(32)  # 32 characters
         self._utdid = self.generate_hardware_string(32)  # 32 characters
+        self._connect_response = connect_response
+        self._login_by_oauth_response = login_by_oauth_response
+        self._aep_response = aep_response
+        self._session_by_authcode_response = session_by_authcode_response
+        self._region_response = region_response
+        self._devices_by_account_response = dev_by_account
 
     @staticmethod
     def generate_random_string(length):
@@ -102,6 +114,24 @@ class CloudIOTGateway:
             hashlib.sha1,
         ).hexdigest()
 
+    def get_connect_response(self):
+        return self._connect_response
+
+    def get_login_by_oauth_response(self):
+        return self._login_by_oauth_response
+
+    def get_aep_response(self):
+        return self._aep_response
+
+    def get_session_by_authcode_response(self):
+        return self._session_by_authcode_response
+
+    def get_devices_by_account_response(self):
+        return self._devices_by_account_response
+
+    def get_region_response(self):
+        return self._region_response
+
     def get_region(self, country_code: str, auth_code: str):
         """Get the region based on country code and auth code."""
         config = Config(
@@ -140,8 +170,8 @@ class CloudIOTGateway:
         if int(response_body_dict.get("code")) != 200:
             raise Exception("Error in getting regions: " + response_body_dict["msg"])
 
-        self._region = RegionResponse.from_dict(response_body_dict)
-        logger.debug("Endpoint: %s", self._region.data.mqttEndpoint)
+        self._region_response = RegionResponse.from_dict(response_body_dict)
+        logger.debug("Endpoint: %s", self._region_response.data.mqttEndpoint)
 
         return response.body
 
@@ -149,8 +179,8 @@ class CloudIOTGateway:
         """Handle AEP authentication."""
         aep_domain = self.domain
 
-        if self._region.data.apiGatewayEndpoint is not None:
-            aep_domain = self._region.data.apiGatewayEndpoint
+        if self._region_response.data.apiGatewayEndpoint is not None:
+            aep_domain = self._region_response.data.apiGatewayEndpoint
 
         config = Config(
             app_key=self._app_key,
@@ -275,7 +305,7 @@ class CloudIOTGateway:
 
     async def login_by_oauth(self, country_code: str, auth_code: str):
         """Login by OAuth."""
-        region_url = self._region.data.oaApiGatewayEndpoint
+        region_url = self._region_response.data.oaApiGatewayEndpoint
 
         async with ClientSession() as session:
             headers = {
@@ -347,7 +377,7 @@ class CloudIOTGateway:
         config = Config(
             app_key=self._app_key,
             app_secret=self._app_secret,
-            domain=self._region.data.apiGatewayEndpoint,
+            domain=self._region_response.data.apiGatewayEndpoint,
         )
         client = Client(config)
 
@@ -390,15 +420,17 @@ class CloudIOTGateway:
             raise Exception("Error in creating session: " + response_body_dict["msg"])
 
         self._session_by_authcode_response = SessionByAuthCodeResponse.from_dict(response_body_dict)
+        self._iot_token_issued_at  = int(time.time())
 
         return response.body
 
     def check_or_refresh_session(self):
         """Check or refresh the session."""
+        logger.debug("Try to refresh token")
         config = Config(
             app_key=self._app_key,
             app_secret=self._app_secret,
-            domain=self._region.data.apiGatewayEndpoint,
+            domain=self._region_response.data.apiGatewayEndpoint,
         )
         client = Client(config)
 
@@ -431,19 +463,36 @@ class CloudIOTGateway:
         logger.debug(response.status_code)
         logger.debug(response.body)
 
-        # self._region = response.body.data
-        # Decodifica il corpo della risposta
+        # Decode the response body
         response_body_str = response.body.decode("utf-8")
 
-        # Carica la stringa JSON in un dizionario
-        json.loads(response_body_str)
+        # Load the JSON string into a dictionary
+        response_body_dict = json.loads(response_body_str)
+
+        if int(response_body_dict.get("code")) != 200:
+            raise Exception("Error check or refresh token: " + response_body_dict.get('msg', ''))
+
+        identityId = response_body_dict.get('data', {}).get('identityId', None)
+        refreshTokenExpire = response_body_dict.get('data', {}).get('refreshTokenExpire', None)
+        iotToken = response_body_dict.get('data', {}).get('iotToken', None)
+        iotTokenExpire = response_body_dict.get('data', {}).get('iotTokenExpire', None)
+        refreshToken = response_body_dict.get('data', {}).get('refreshToken', None)
+
+
+        if (identityId is None or refreshTokenExpire is None or iotToken is None or iotTokenExpire is None or refreshToken is None):
+            raise Exception("Error check or refresh token: Parameters not correct")
+
+        self._session_by_authcode_response = SessionByAuthCodeResponse.from_dict(response_body_dict)
+        self._iot_token_issued_at  = int(time.time())
+
+        
 
     def list_binding_by_account(self) -> ListingDevByAccountResponse:
         """List bindings by account."""
         config = Config(
             app_key=self._app_key,
             app_secret=self._app_secret,
-            domain=self._region.data.apiGatewayEndpoint,
+            domain=self._region_response.data.apiGatewayEndpoint,
         )
 
         client = Client(config)
@@ -477,15 +526,26 @@ class CloudIOTGateway:
         if int(response_body_dict.get("code")) != 200:
             raise Exception("Error in creating session: " + response_body_dict["msg"])
 
-        self._listing_dev_by_account_response = ListingDevByAccountResponse.from_dict(response_body_dict)
-        return self._listing_dev_by_account_response
+        self._devices_by_account_response = ListingDevByAccountResponse.from_dict(response_body_dict)
+        return self._devices_by_account_response
 
     def send_cloud_command(self, iot_id: str, command: bytes) -> str:
         """Send a cloud command to the specified IoT device."""
+
+        """Check if iotToken is expired"""
+        if self._iot_token_issued_at + self._session_by_authcode_response.data.iotTokenExpire <= (int(time.time()) + (5 * 3600)):
+            """Token expired - Try to refresh - Check if refreshToken is not expired"""
+            if self._iot_token_issued_at + self._session_by_authcode_response.data.refreshTokenExpire > (int(time.time())):
+                self.check_or_refresh_session()
+            else:
+                raise AuthRefreshException("Refresh token expired. Please re-login")
+                
+            
+
         config = Config(
             app_key=self._app_key,
             app_secret=self._app_secret,
-            domain=self._region.data.apiGatewayEndpoint,
+            domain=self._region_response.data.apiGatewayEndpoint,
         )
 
         client = Client(config)
@@ -530,9 +590,11 @@ class CloudIOTGateway:
             )
             if response_body_dict.get("code") == 29003:
                 raise SetupException(response_body_dict.get("code"))
+            if response_body_dict.get("code") == 6205:
+                """Device is offline."""
 
         return message_id
 
     @property
     def listing_dev_by_account_response(self):
-        return self._listing_dev_by_account_response
+        return self._devices_by_account_response

{pymammotion-0.2.6 → pymammotion-0.2.8}/pymammotion/aliyun/dataclass/session_by_authcode_response.py

@@ -1,18 +1,18 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
+from datetime import time
 
 from mashumaro.mixins.orjson import DataClassORJSONMixin
 
 
 @dataclass
-class TokenData(DataClassORJSONMixin):
+class SessionOauthToken(DataClassORJSONMixin):
     identityId: str
     refreshTokenExpire: int
     iotToken: str
     iotTokenExpire: int
     refreshToken: str
 
-
 @dataclass
 class SessionByAuthCodeResponse(DataClassORJSONMixin):
     code: int
-    data: TokenData
+    data: SessionOauthToken

{pymammotion-0.2.6 → pymammotion-0.2.8}/pymammotion/data/model/location.py

@@ -7,8 +7,8 @@ from dataclasses import dataclass
 class Point:
     """Returns a lat long."""
 
-    latitude: float
-    longitude: float
+    latitude: float = 0.0
+    longitude: float = 0.0
 
     def __init__(self, latitude=0.0, longitude=0.0):
         self.latitude = latitude
@@ -19,11 +19,7 @@ class Point:
 class Dock(Point):
     """Stores robot dock position."""
 
-    rotation: int
-
-    def __init__(self):
-        super().__init__()
-        self.rotation = 0
+    rotation: int = 0
 
 
 @dataclass
@@ -33,8 +29,8 @@ class Location:
     device: Point
     RTK: Point
     dock: Dock
-    position_type: int
-    orientation: int  # 360 degree rotation +-
+    position_type: int = 0
+    orientation: int = 0 # 360 degree rotation +-
 
     def __init__(self):
         self.device = Point()

{pymammotion-0.2.6 → pymammotion-0.2.8}/pymammotion/data/state_manager.py

@@ -1,24 +1,22 @@
 """Manage state from notifications into MowingDevice."""
+from typing import Optional, Callable, Awaitable
 
 import betterproto
 
 from pymammotion.data.model.device import MowingDevice
-from pymammotion.event.event import DataEvent
 from pymammotion.proto.luba_msg import LubaMsg
-from pymammotion.proto.mctrl_nav import NavGetCommDataAck
+from pymammotion.proto.mctrl_nav import NavGetCommDataAck, NavGetHashListAck
 
 
 class StateManager:
     """Manage state."""
 
     _device: MowingDevice
-    gethash_ack_callback: DataEvent
-    get_commondata_ack_callback: DataEvent
 
     def __init__(self, device: MowingDevice):
         self._device = device
-        self.gethash_ack_callback = DataEvent()
-        self.get_commondata_ack_callback = DataEvent()
+        self.gethash_ack_callback: Optional[Callable[[NavGetHashListAck],Awaitable[None]]] = None
+        self.get_commondata_ack_callback: Optional[Callable[[NavGetCommDataAck],Awaitable[None]]] = None
 
     def get_device(self) -> MowingDevice:
         """Get device."""
@@ -54,12 +52,12 @@ class StateManager:
                 self._device.map.obstacle = dict()
                 self._device.map.area = dict()
                 self._device.map.path = dict()
-                await self.gethash_ack_callback.data_event(nav_msg[1])
+                await self.gethash_ack_callback(nav_msg[1])
             case "toapp_get_commondata_ack":
                 common_data: NavGetCommDataAck = nav_msg[1]
                 updated = self._device.map.update(common_data)
                 if updated:
-                    await self.get_commondata_ack_callback.data_event(common_data)
+                    await self.get_commondata_ack_callback(common_data)
 
     def _update_sys_data(self, message):
         """Update system."""

{pymammotion-0.2.6 → pymammotion-0.2.8}/pymammotion/mammotion/devices/mammotion.py

@@ -2,15 +2,18 @@
 
 from __future__ import annotations
 
+import queue
+import threading
 import asyncio
 import base64
 import codecs
 import json
 import logging
 from abc import abstractmethod
+from collections import deque
 from enum import Enum
 from functools import cache
-from typing import Any, Callable, Optional, cast
+from typing import Any, Callable, Optional, cast, Awaitable
 from uuid import UUID
 
 import betterproto
@@ -38,6 +41,7 @@ from pymammotion.data.state_manager import StateManager
 from pymammotion.http.http import connect_http
 from pymammotion.mammotion.commands.mammotion_command import MammotionCommand
 from pymammotion.mqtt import MammotionMQTT
+from pymammotion.mqtt.mammotion_future import MammotionFuture
 from pymammotion.proto.luba_msg import LubaMsg
 from pymammotion.proto.mctrl_nav import NavGetCommDataAck, NavGetHashListAck
 from pymammotion.utility.rocker_util import RockerControlUtil
@@ -88,10 +92,10 @@ def slashescape(err):
 codecs.register_error("slashescape", slashescape)
 
 
-def find_next_integer(lst: list[int], current_int: int) -> int | None:
+def find_next_integer(lst: list[int], current_hash: float) -> int | None:
     try:
         # Find the index of the current integer
-        current_index = lst.index(current_int)
+        current_index = lst.index(current_hash)
 
         # Check if there is a next integer in the list
         if current_index + 1 < len(lst):
@@ -115,12 +119,12 @@ async def _handle_retry(fut: asyncio.Future[None], func, command: bytes) -> None
         await func(command)
 
 
-async def _handle_retry_cloud(fut: asyncio.Future[None], func, iotId: str, command: bytes) -> None:
+async def _handle_retry_cloud(self, fut: asyncio.Future[None], func, iot_id: str, command: bytes) -> None:
     """Handle a retry."""
 
     if not fut.done():
-        loop = asyncio.get_running_loop()
-        await loop.run_in_executor(None, func, iotId, command)
+        self._operation_lock.release()
+        await self.loop.run_in_executor(None, func, iot_id, command)
 
 
 class ConnectionPreference(Enum):
@@ -208,7 +212,8 @@ class Mammotion(object):
     """Represents a Mammotion device."""
 
     devices = MammotionDevices()
-    _mammotion_mqtt: MammotionMQTT | None = None
+    cloud_client: CloudIOTGateway | None = None
+    mqtt: MammotionMQTT | None = None
 
 
 
@@ -225,25 +230,25 @@ class Mammotion(object):
             self._preference = preference
 
     async def initiate_cloud_connection(self, cloud_client: CloudIOTGateway) -> None:
-        if self._mammotion_mqtt is not None:
-            if self._mammotion_mqtt.is_connected:
+        if self.mqtt is not None:
+            if self.mqtt.is_connected:
                 return
 
-
-        self._mammotion_mqtt = MammotionMQTT(region_id=cloud_client._region.data.regionId,
+        self.cloud_client = cloud_client
+        self.mqtt = MammotionMQTT(region_id=cloud_client._region.data.regionId,
                                         product_key=cloud_client._aep_response.data.productKey,
                                         device_name=cloud_client._aep_response.data.deviceName,
                                         device_secret=cloud_client._aep_response.data.deviceSecret,
                                         iot_token=cloud_client._session_by_authcode_response.data.iotToken,
                                         client_id=cloud_client._client_id)
 
-        self._mammotion_mqtt._cloud_client = cloud_client
+        self.mqtt._cloud_client = cloud_client
         loop = asyncio.get_running_loop()
-        await loop.run_in_executor(None, self._mammotion_mqtt.connect_async)
+        await loop.run_in_executor(None, self.mqtt.connect_async)
 
         for device in cloud_client.listing_dev_by_account_response.data.data:
             if device.deviceName.startswith(("Luba-", "Yuka-")):
-                self.devices.add_device(MammotionMixedDeviceManager(name=device.deviceName, cloud_device=device, mqtt=self._mammotion_mqtt))
+                self.devices.add_device(MammotionMixedDeviceManager(name=device.deviceName, cloud_device=device, mqtt=self.mqtt))
 
     def set_disconnect_strategy(self, disconnect: bool):
         for device_name, device in self.devices.devices:
@@ -334,9 +339,8 @@ class MammotionBaseDevice:
         self._raw_data = LubaMsg().to_dict(casing=betterproto.Casing.SNAKE)
         self._mower = device
         self._state_manager = StateManager(self._mower)
-
-        self._state_manager.gethash_ack_callback.add_subscribers(self.datahash_response)
-        self._state_manager.get_commondata_ack_callback.add_subscribers(self.commdata_response)
+        self._state_manager.gethash_ack_callback = self.datahash_response
+        self._state_manager.get_commondata_ack_callback = self.commdata_response
         self._notify_future: asyncio.Future[bytes] | None = None
 
     async def datahash_response(self, hash_ack: NavGetHashListAck):
@@ -944,8 +948,9 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
         self._command_futures = {}
         self._commands: MammotionCommand = MammotionCommand(cloud_device.deviceName)
         self.currentID = ""
-        self.on_ready_callback: Optional[Callable[[], None]] = None
-        self._operation_lock = asyncio.Lock()
+        self.on_ready_callback: Optional[Callable[[], Awaitable[None]]] = None
+        self._waiting_queue = deque()
+        self._operation_lock = threading.Lock()
 
         self._mqtt_client.on_connected = self.on_connected
         self._mqtt_client.on_disconnected = self.on_disconnected
@@ -958,19 +963,19 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
         # temporary for testing only
         # self._start_sync_task = self.loop.call_later(30, lambda: asyncio.ensure_future(self.start_sync(0)))
 
-    def on_ready(self):
+    async def on_ready(self):
         """Callback for when MQTT is subscribed to events."""
         if self.on_ready_callback:
             self.on_ready_callback()
 
-        asyncio.run(self._ble_sync())
-        asyncio.run(self.run_periodic_sync_task())
+        await self._ble_sync()
+        await self.run_periodic_sync_task()
 
-    def on_connected(self):
+    async def on_connected(self):
         """Callback for when MQTT connects."""
 
 
-    def on_disconnected(self):
+    async def on_disconnected(self):
         """Callback for when MQTT disconnects."""
 
     async def _ble_sync(self):
@@ -993,21 +998,23 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
                 160, lambda: asyncio.ensure_future(self.run_periodic_sync_task())
             )
 
-    def _on_mqtt_message(self, topic: str, payload: str, iot_id: str) -> None:
+    async def _on_mqtt_message(self, topic: str, payload: str, iot_id: str) -> None:
         """Handle incoming MQTT messages."""
-        _LOGGER.debug("MQTT message received on topic %s: %s", topic, payload)
+        _LOGGER.debug("MQTT message received on topic %s: %s, iot_id: %s", topic, payload, iot_id)
 
         json_str = json.dumps(payload)
         payload = json.loads(json_str)
 
-        self._handle_mqtt_message(topic, payload)
+        await self._handle_mqtt_message(topic, payload)
 
     async def _send_command(self, key: str, retry: int | None = None) -> bytes | None:
         """Send command to device via MQTT and read response."""
         if self._operation_lock.locked():
-            _LOGGER.debug("%s: Operation already in progress, waiting for it to complete;", self.device.nickName)
-
-        async with self._operation_lock:
+            _LOGGER.debug(
+                "%s: Operation already in progress, waiting for it to complete;",
+                self.device.nickName
+            )
+        with self._operation_lock:
             try:
                 command_bytes = getattr(self._commands, key)()
                 return await self._send_command_locked(key, command_bytes)
@@ -1032,33 +1039,16 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
     async def _execute_command_locked(self, key: str, command: bytes) -> bytes:
         """Execute command and read response."""
         assert self._mqtt_client is not None
-        self._notify_future = self.loop.create_future()
         self._key = key
         _LOGGER.debug("%s: Sending command: %s", self.device.nickName, key)
-        loop = asyncio.get_running_loop()
-        await loop.run_in_executor(None, self._mqtt_client.get_cloud_client().send_cloud_command, self.iot_id, command)
-
-        retry_handle = self.loop.call_at(
-            self.loop.time() + 10,
-            lambda: asyncio.ensure_future(
-                _handle_retry_cloud(
-                    self._notify_future, self._mqtt_client.get_cloud_client().send_cloud_command, self.iot_id, command
-                )
-            ),
-        )
+        await self.loop.run_in_executor(None, self._mqtt_client.get_cloud_client().send_cloud_command, self.iot_id, command)
+        future = MammotionFuture()
+        self._waiting_queue.append(future)
         timeout = 20
-        timeout_handle = self.loop.call_at(self.loop.time() + timeout, _handle_timeout, self._notify_future)
-        timeout_expired = False
         try:
-            notify_msg = await self._notify_future
+            notify_msg = await future.async_get(timeout)
         except asyncio.TimeoutError:
-            timeout_expired = True
             raise
-        finally:
-            if not timeout_expired:
-                timeout_handle.cancel()
-                retry_handle.cancel()
-            self._notify_future = None
 
         _LOGGER.debug("%s: Message received", self.device.nickName)
 
@@ -1067,8 +1057,11 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
     async def _send_command_with_args(self, key: str, **kwargs: any) -> bytes | None:
         """Send command with arguments to device via MQTT and read response."""
         if self._operation_lock.locked():
-            _LOGGER.debug("%s: Operation already in progress, waiting for it to complete;", self.device.nickName)
-        async with self._operation_lock:
+            _LOGGER.debug(
+                "%s: Operation already in progress, waiting for it to complete;",
+                self.device.nickName
+            )
+        with self._operation_lock:
             try:
                 command_bytes = getattr(self._commands, key)(**kwargs)
                 return await self._send_command_locked(key, command_bytes)
@@ -1089,7 +1082,7 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
             _LOGGER.error("Error extracting encoded message. Payload: %s", payload)
             return ""
 
-    def _parse_mqtt_response(self, topic: str, payload: dict) -> None:
+    async def _parse_mqtt_response(self, topic: str, payload: dict) -> None:
         """Parse the MQTT response."""
         if topic.endswith("/app/down/thing/events"):
             _LOGGER.debug("Thing event received")
@@ -1100,14 +1093,28 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
                 binary_data = base64.b64decode(params.value.get("content", ""))
                 self._update_raw_data(cast(bytes, binary_data))
                 new_msg = LubaMsg().parse(cast(bytes, binary_data))
-                if self._notify_future and not self._notify_future.done():
-                    self._notify_future.set_result(new_msg)
-                asyncio.run(self._state_manager.notification(new_msg))
 
-    def _handle_mqtt_message(self, topic: str, payload: dict) -> None:
+                if self._commands.get_device_product_key() == "" and self._commands.get_device_name() == event.params.deviceName:
+                    self._commands.set_device_product_key(event.params.productKey)
+
+                if betterproto.serialized_on_wire(new_msg.net):
+                    if new_msg.net.todev_ble_sync != 0 or has_field(new_msg.net.toapp_wifi_iot_status):
+                        return
+
+
+                if len(self._waiting_queue) > 0:
+                    fut: MammotionFuture = self._waiting_queue.popleft()
+                    while fut.fut.cancelled():
+                        fut: MammotionFuture = self._waiting_queue.popleft()
+                    fut.resolve(cast(bytes, binary_data))
+                await self._state_manager.notification(new_msg)
+
+    async def _handle_mqtt_message(self, topic: str, payload: dict) -> None:
         """Async handler for incoming MQTT messages."""
-        self._parse_mqtt_response(topic=topic, payload=payload)
+        await self._parse_mqtt_response(topic=topic, payload=payload)
 
-    async def _disconnect(self):
+    def _disconnect(self):
         """Disconnect the MQTT client."""
         self._mqtt_client.disconnect()
+
+

pymammotion-0.2.8/pymammotion/mqtt/mammotion_future.py

@@ -0,0 +1,25 @@
+from asyncio import Future
+from typing import Any
+
+import async_timeout
+
+
+class MammotionFuture:
+    """Create futures for each MQTT Message."""
+    def __init__(self):
+        self.fut: Future = Future()
+        self.loop = self.fut.get_loop()
+
+    def _resolve(self, item: bytes) -> None:
+        if not self.fut.cancelled():
+            self.fut.set_result(item)
+
+    def resolve(self, item: bytes) -> None:
+        self.loop.call_soon_threadsafe(self._resolve, item)
+
+    async def async_get(self, timeout: float | int) -> bytes:
+        try:
+            async with async_timeout.timeout(timeout):
+                return await self.fut
+        finally:
+            self.fut.cancel()

{pymammotion-0.2.6 → pymammotion-0.2.8}/pymammotion/mqtt/mammotion_mqtt.py

@@ -5,7 +5,7 @@ import hmac
 import json
 import logging
 from logging import getLogger
-from typing import Callable, Optional, cast
+from typing import Callable, Optional, cast, Awaitable
 
 from linkkit.linkkit import LinkKit
 from paho.mqtt.client import MQTTMessage
@@ -36,11 +36,11 @@ class MammotionMQTT:
         self._cloud_client = None
         self.is_connected = False
         self.is_ready = False
-        self.on_connected: Optional[Callable[[], None]] = None
-        self.on_ready: Optional[Callable[[], None]] = None
-        self.on_error: Optional[Callable[[str], None]] = None
-        self.on_disconnected: Optional[Callable[[], None]] = None
-        self.on_message: Optional[Callable[[str, str, str], None]] = None
+        self.on_connected: Optional[Callable[[],Awaitable[None]]] = None
+        self.on_ready: Optional[Callable[[],Awaitable[None]]] = None
+        self.on_error: Optional[Callable[[str],Awaitable[None]]] = None
+        self.on_disconnected: Optional[Callable[[],Awaitable[None]]] = None
+        self.on_message: Optional[Callable[[str, str, str],Awaitable[None]]] = None
 
         self._product_key = product_key
         self._device_name = device_name
@@ -57,6 +57,7 @@ class MammotionMQTT:
         ).hexdigest()
 
         self._client_id = client_id
+        self.loop = asyncio.get_event_loop()
 
         self._linkkit_client = LinkKit(
             region_id,
@@ -79,7 +80,8 @@ class MammotionMQTT:
     def connect_async(self):
         """Connect async to MQTT Server."""
         logger.info("Connecting...")
-        self._linkkit_client.thing_setup()
+        if self._linkkit_client.check_state() is LinkKit.LinkKitState.INITIALIZED:
+            self._linkkit_client.thing_setup()
         self._linkkit_client.connect_async()
 
 
@@ -121,7 +123,7 @@ class MammotionMQTT:
 
         if self.on_ready:
             self.is_ready = True
-            self.on_ready()
+            asyncio.run_coroutine_threadsafe(self.on_ready(), self.loop).result()
         # self._linkkit_client.query_ota_firmware()
         # command = MammotionCommand(device_name="Luba")
         # self._cloud_client.send_cloud_command(command.get_report_cfg())
@@ -137,13 +139,16 @@ class MammotionMQTT:
         payload = json.loads(payload)
         iot_id = payload.get("params", {}).get("iotId", "")
         if iot_id != "" and self.on_message:
-            self.on_message(topic, payload, iot_id)
+            asyncio.run_coroutine_threadsafe(self.on_message(topic, payload, iot_id), self.loop).result()
+
 
     def _thing_on_connect(self, session_flag, rc, user_data):
         """Is called on thing connect."""
         self.is_connected = True
         if self.on_connected is not None:
-            self.on_connected()
+            future = asyncio.run_coroutine_threadsafe(self.on_connected(), self.loop)
+            asyncio.wrap_future(future, loop=self.loop)
+
         logger.debug("on_connect, session_flag:%d, rc:%d", session_flag, rc)
 
         # self._linkkit_client.subscribe_topic(f"/sys/{self._product_key}/{self._device_name}/#")
@@ -154,7 +159,9 @@ class MammotionMQTT:
         self.is_connected = False
         self.is_ready = False
         if self.on_disconnected:
-            self.on_disconnected()
+            future = asyncio.run_coroutine_threadsafe(self.on_disconnected(), self.loop)
+            asyncio.wrap_future(future, loop=self.loop)
+
 
     def _on_message(self, _client, _userdata, message: MQTTMessage):
         """Is called when message is received."""
@@ -185,3 +192,4 @@ class MammotionMQTT:
     def get_cloud_client(self) -> Optional[CloudIOTGateway]:
         """Return internal cloud client."""
         return self._cloud_client
+

{pymammotion-0.2.6 → pymammotion-0.2.8}/pyproject.toml

@@ -1,10 +1,10 @@
 [project]
 name        = "pymammotion"
-version     = "0.2.6"
+version     = "0.2.8"
 
 [tool.poetry]
 name        = "pymammotion"
-version     = "0.2.6"
+version     = "0.2.8"
 license     = "GNU-3.0"
 description = ""
 readme      = "README.md"
@@ -36,6 +36,7 @@ betterproto = "^1.2.5"
 pyjoystick = "^1.2.4"
 nest-asyncio = "^1.6.0"
 numpy = "^1.26.0"
+async-timeout = "^4.0.3"
 
 
 [tool.poetry.group.dev.dependencies]
@@ -52,7 +53,7 @@ mypy = "^1.10.0"
 pre-commit = "^3.7.1"
 
 [tool.bumpver]
-current_version = "0.2.6"
+current_version = "0.2.8"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit_message  = "Bump version {old_version} -> {new_version}"
 commit          = true