pymammotion 0.2.7__py3-none-any.whl → 0.2.9__py3-none-any.whl

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 = None, login_by_oauth_response: LoginByOAuthResponse | None = None, aep_response: AepResponse | None = None, session_by_authcode_response: SessionByAuthCodeResponse | None = None, region_response: RegionResponse | None = None, dev_by_account: ListingDevByAccountResponse | None = 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)
@@ -537,4 +597,4 @@ class CloudIOTGateway:
 
     @property
     def listing_dev_by_account_response(self):
-        return self._listing_dev_by_account_response
+        return self._devices_by_account_response

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/data/model/location.py

@@ -21,10 +21,6 @@ class Dock(Point):
 
     rotation: int = 0
 
-    def __init__(self):
-        super().__init__()
-        self.rotation = 0
-
 
 @dataclass
 class Location:

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/mammotion/devices/mammotion.py

@@ -13,7 +13,7 @@ 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
@@ -212,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
 
 
 
@@ -229,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_response.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:
@@ -331,22 +332,24 @@ class MammotionBaseDevice:
 
     _mower: MowingDevice
     _state_manager: StateManager
+    _cloud_device: Device | None = None
 
-    def __init__(self, device: MowingDevice) -> None:
+    def __init__(self, device: MowingDevice, cloud_device: Device | None = None) -> None:
         """Initialize MammotionBaseDevice."""
         self.loop = asyncio.get_event_loop()
         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
+        self._cloud_device = cloud_device
 
     async def datahash_response(self, hash_ack: NavGetHashListAck):
         """Handle datahash responses."""
         result_hash = 0
         while hash_ack.data_couple[0] != result_hash:
-            data = await self._send_command_with_args("synchronize_hash_data", hash_num=hash_ack.data_couple[0])
+            data = await self.queue_command("synchronize_hash_data", hash_num=hash_ack.data_couple[0])
             msg = LubaMsg().parse(data)
             if betterproto.serialized_on_wire(msg.nav.toapp_get_commondata_ack):
                 result_hash = msg.nav.toapp_get_commondata_ack.hash
@@ -364,7 +367,7 @@ class MammotionBaseDevice:
                 return
             result_hash = 0
             while data_hash != result_hash:
-                data = await self._send_command_with_args("synchronize_hash_data", hash_num=data_hash)
+                data = await self.queue_command("synchronize_hash_data", hash_num=data_hash)
                 msg = LubaMsg().parse(data)
                 if betterproto.serialized_on_wire(msg.nav.toapp_get_commondata_ack):
                     result_hash = msg.nav.toapp_get_commondata_ack.hash
@@ -376,7 +379,7 @@ class MammotionBaseDevice:
             region_data.type = common_data.type
             region_data.total_frame = total_frame
             region_data.current_frame = current_frame
-            await self._send_command_with_args("get_regional_data", regional_data=region_data)
+            await self.queue_command("get_regional_data", regional_data=region_data)
 
     def _update_raw_data(self, data: bytes) -> None:
         """Update raw and model data from notifications."""
@@ -474,6 +477,10 @@ class MammotionBaseDevice:
         """Get the LubaMsg of the device."""
         return self._mower
 
+    @abstractmethod
+    async def queue_command(self, key: str,  **kwargs: any) -> bytes:
+        """Queue commands to mower."""
+
     @abstractmethod
     async def _send_command(self, key: str, retry: int | None = None) -> bytes | None:
         """Send command to device and read response."""
@@ -504,9 +511,15 @@ class MammotionBaseDevice:
 
         await self._send_command_with_args("get_hash_response", total_frame=1, current_frame=1)
 
-        await self._send_command_with_args(
-            "get_area_name_list", device_id=self._mower.device.net.toapp_wifi_iot_status.devicename
-        )
+        if self._cloud_device:
+            await self._send_command_with_args(
+                "get_area_name_list", device_id=self._cloud_device.deviceName
+            )
+        if has_field(self._mower.net.toapp_wifi_iot_status):
+            await self._send_command_with_args(
+                "get_area_name_list", device_id=self._mower.net.toapp_wifi_iot_status.devicename
+            )
+
 
         # sub_cmd 3 is job hashes??
         # sub_cmd 4 is dump location (yuka)
@@ -585,6 +598,9 @@ class MammotionBaseBLEDevice(MammotionBaseDevice):
                 130, lambda: asyncio.ensure_future(self.run_periodic_sync_task())
             )
 
+    async def queue_command(self, key: str, **kwargs: any) -> bytes | None:
+        return await self._send_command_with_args(key, **kwargs)
+
     async def _send_command_with_args(self, key: str, **kwargs) -> bytes | None:
         """Send command to device and read response."""
         if self._operation_lock.locked():
@@ -654,7 +670,7 @@ class MammotionBaseBLEDevice(MammotionBaseDevice):
     def rssi(self) -> int:
         """Return RSSI of device."""
         try:
-            return self._mower.device.sys.toapp_report_data.connect.ble_rssi
+            return self._mower.sys.toapp_report_data.connect.ble_rssi
         finally:
             return 0
 
@@ -937,9 +953,11 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
         mowing_state: MowingDevice
     ) -> None:
         """Initialize MammotionBaseCloudDevice."""
-        super().__init__(mowing_state)
+        super().__init__(mowing_state, cloud_device)
         self._ble_sync_task = None
         self.is_ready = False
+        self.command_queue = asyncio.Queue()
+        self.processing_task = asyncio.create_task(self._process_queue())
         self._mqtt_client = mqtt_client
         self.iot_id = cloud_device.iotId
         self.device = cloud_device
@@ -947,8 +965,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.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
@@ -964,7 +983,7 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
     async def on_ready(self):
         """Callback for when MQTT is subscribed to events."""
         if self.on_ready_callback:
-            self.on_ready_callback()
+            await self.on_ready_callback()
 
         await self._ble_sync()
         await self.run_periodic_sync_task()
@@ -996,9 +1015,35 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
                 160, lambda: asyncio.ensure_future(self.run_periodic_sync_task())
             )
 
+    async def queue_command(self, key: str, **kwargs: any) -> bytes:
+        # Create a future to hold the result
+        _LOGGER.debug("Queueing command: %s", key)
+        future = asyncio.Future()
+        # Put the command in the queue as a tuple (key, command, future)
+        command_bytes = getattr(self._commands, key)(**kwargs)
+        await self.command_queue.put((key, command_bytes, future))
+        # Wait for the future to be resolved
+        return await future
+
+    async def _process_queue(self):
+        while True:
+            # Get the next item from the queue
+            key, command, future = await self.command_queue.get()
+            try:
+                # Process the command using _execute_command_locked
+                result = await self._execute_command_locked(key, command)
+                # Set the result on the future
+                future.set_result(result)
+            except Exception as ex:
+                # Set the exception on the future if something goes wrong
+                future.set_exception(ex)
+            finally:
+                # Mark the task as done
+                self.command_queue.task_done()
+
     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, iot_id)
+        _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)
@@ -1007,13 +1052,18 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
 
     async def _send_command(self, key: str, retry: int | None = None) -> bytes | None:
         """Send command to device via MQTT and read response."""
-
-        try:
-            command_bytes = getattr(self._commands, key)()
-            return await self._send_command_locked(key, command_bytes)
-        except Exception as ex:
-            _LOGGER.exception("%s: error in sending command -  %s", self.device.nickName, ex)
-            raise
+        if self._operation_lock.locked():
+            _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)
+            except Exception as ex:
+                _LOGGER.exception("%s: error in sending command -  %s", self.device.nickName, ex)
+                raise
 
     async def _send_command_locked(self, key: str, command: bytes) -> bytes:
         """Send command to device and read response."""
@@ -1049,12 +1099,18 @@ 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."""
-        try:
-            command_bytes = getattr(self._commands, key)(**kwargs)
-            return await self._send_command_locked(key, command_bytes)
-        except Exception as ex:
-            _LOGGER.exception("%s: error in sending command -  %s", self.device.nickName, ex)
-            raise
+        if self._operation_lock.locked():
+            _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)
+            except Exception as ex:
+                _LOGGER.exception("%s: error in sending command -  %s", self.device.nickName, ex)
+                raise
 
     def _extract_message_id(self, payload: dict) -> str:
         """Extract the message ID from the payload."""
@@ -1091,6 +1147,8 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
 
                 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)
 
@@ -1102,3 +1160,4 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
         """Disconnect the MQTT client."""
         self._mqtt_client.disconnect()
 
+

pymammotion/mqtt/mammotion_mqtt.py

@@ -57,7 +57,7 @@ class MammotionMQTT:
         ).hexdigest()
 
         self._client_id = client_id
-        self.loop = asyncio.get_event_loop()
+        self.loop = asyncio.get_running_loop()
 
         self._linkkit_client = LinkKit(
             region_id,
@@ -80,6 +80,8 @@ class MammotionMQTT:
     def connect_async(self):
         """Connect async to MQTT Server."""
         logger.info("Connecting...")
+        if self._linkkit_client.check_state() is LinkKit.LinkKitState.INITIALIZED:
+            self._linkkit_client.thing_setup()
         self._linkkit_client.connect_async()
 
 
@@ -121,8 +123,7 @@ class MammotionMQTT:
 
         if self.on_ready:
             self.is_ready = True
-            future = asyncio.run_coroutine_threadsafe(self.on_ready(), self.loop)
-            asyncio.wrap_future(future, loop=self.loop)
+            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())
@@ -139,7 +140,7 @@ class MammotionMQTT:
         iot_id = payload.get("params", {}).get("iotId", "")
         if iot_id != "" and self.on_message:
             future = asyncio.run_coroutine_threadsafe(self.on_message(topic, payload, iot_id), self.loop)
-            return asyncio.wrap_future(future, loop=self.loop)
+            asyncio.wrap_future(future, loop=self.loop)
 
 
     def _thing_on_connect(self, session_flag, rc, user_data):

{pymammotion-0.2.7.dist-info → pymammotion-0.2.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pymammotion
-Version: 0.2.7
+Version: 0.2.9
 Summary: 
 License: GNU-3.0
 Author: Michael Arthur

{pymammotion-0.2.7.dist-info → pymammotion-0.2.9.dist-info}/RECORD

@@ -1,13 +1,13 @@
 pymammotion/__init__.py,sha256=kmnjdt3AEMejIz5JK7h1tTJj5ZriAgKwZBa3ScA4-Ao,1516
 pymammotion/aliyun/__init__.py,sha256=T1lkX7TRYiL4nqYanG4l4MImV-SlavSbuooC-W-uUGw,29
-pymammotion/aliyun/cloud_gateway.py,sha256=ZjGSRdfxujOEHgL2gr8rZsGsYlJtGdS2YWGEWLXaEhg,18681
+pymammotion/aliyun/cloud_gateway.py,sha256=IqmxgjDIgRoZvJvQnwYGOSl4XaCV4MoMKTlfhC9-6Ys,21830
 pymammotion/aliyun/cloud_service.py,sha256=YWcKuKK6iRWy5mTnBYgHxcCusiRGGzQt3spSf7dGDss,2183
 pymammotion/aliyun/dataclass/aep_response.py,sha256=8f6GIP58ve8gd6AL3HBoXxsy0n2q4ygWvjELGnoOnVc,452
 pymammotion/aliyun/dataclass/connect_response.py,sha256=Yz-fEbDzgGPTo5Of2oAjmFkSv08T7ze80pQU4k-gKIU,824
 pymammotion/aliyun/dataclass/dev_by_account_response.py,sha256=DtGeMCzoiFrfSniHoL6db9xcheQgmcTvGySkGBjKdKE,977
 pymammotion/aliyun/dataclass/login_by_oauth_response.py,sha256=6TQYAMyQ1jf_trsnTST007qlNXve3BqsvpV0Dwp7CFA,1245
 pymammotion/aliyun/dataclass/regions_response.py,sha256=CVPpdFhDD6_emWHyLRzOdp2j3HLPtP8tlNyzGnr8AcI,690
-pymammotion/aliyun/dataclass/session_by_authcode_response.py,sha256=wLGSX2nHkA7crmyYeE_dYly_lDtoYWAiIZjQ0C6m44o,358
+pymammotion/aliyun/dataclass/session_by_authcode_response.py,sha256=_5vsyIxocoecEqygPTmhOQnzjwaK845ssIqbTeaLcmk,406
 pymammotion/aliyun/tmp_constant.py,sha256=M4Hq_lrGB3LZdX6R2XohRPFoK1NDnNV-pTJwJcJ9838,6650
 pymammotion/bluetooth/__init__.py,sha256=LAl8jqZ1fPh-3mLmViNQsP3s814C1vsocYUa6oSaXt0,36
 pymammotion/bluetooth/ble.py,sha256=9fA8yw5xXNJRSbC68SdOMf2QJnHoD7RhhCjLFoF0c0I,2404
@@ -28,7 +28,7 @@ pymammotion/data/model/excute_boarder_params.py,sha256=kadSth4y-VXlXIZ6R-Ng-kDvB
 pymammotion/data/model/execute_boarder.py,sha256=oDb2h5tFtOQIa8OCNYaDugqCgCZBLjQRzQTNVcJVAGQ,1072
 pymammotion/data/model/generate_route_information.py,sha256=5w1MM1-gXGXb_AoEap_I5xTxAFbNSzXuqQFEkw4NmDs,4301
 pymammotion/data/model/hash_list.py,sha256=z4y0mzbW8LQ5nsaHbMlt1y6uS4suB4D_VljAyIEjFR0,1171
-pymammotion/data/model/location.py,sha256=mXiJUnD2AIpcN7HgV8OLVL3QFLNAiVWqaVDFGmDjFXU,807
+pymammotion/data/model/location.py,sha256=qO3G0U_eWP9alswbZXTpmYImIcXJeteBVHX1cGZGbHg,729
 pymammotion/data/model/mowing_modes.py,sha256=2GAF-xaHpv6CSGobYoNtfSi2if8_jW0nonCqN50SNx0,665
 pymammotion/data/model/plan.py,sha256=7JvqAo0a9Yg1Vtifd4J3Dx3StEppxrMOfmq2-877kYg,2891
 pymammotion/data/model/rapid_state.py,sha256=_e9M-65AbkvIqXyMYzLKBxbNvpso42qD8R-JSt66THY,986
@@ -38,7 +38,7 @@ pymammotion/data/mqtt/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdr
 pymammotion/data/mqtt/event.py,sha256=7hq-dl-HdKJB-TQ2kKfYfrebR_8qWE_lF2nQLlPyphU,3437
 pymammotion/data/mqtt/properties.py,sha256=HkBPghr26L9_b4QaOi1DtPgb0UoPIOGSe9wb3kgnM6Y,2815
 pymammotion/data/mqtt/status.py,sha256=zqnlo-MzejEQZszl0i0Wucoc3E76x6UtI9JLxoBnu54,1067
-pymammotion/data/state_manager.py,sha256=ItihtkmJCeIdXOYD3YRBp241cP29oMABbSISyC5A7tw,2805
+pymammotion/data/state_manager.py,sha256=mNIAhP8f1Cb6-wFm2R5e-NlZauj-71iDGz8oZvdTq3Y,2826
 pymammotion/event/__init__.py,sha256=mgATR6vPHACNQ-0zH5fi7NdzeTCDV1CZyaWPmtUusi8,115
 pymammotion/event/event.py,sha256=Fy5-I1p92AO_D67VW4eHQqA4pOt7MZsrP--tVfIVUz8,1820
 pymammotion/http/_init_.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -58,10 +58,10 @@ pymammotion/mammotion/commands/messages/video.py,sha256=_8lJsU4sLm2CGnc7RDkueA0A
 pymammotion/mammotion/control/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pymammotion/mammotion/control/joystick.py,sha256=EWV20MMzQuhbLlNlXbsyZKSEpeM7x1CQL7saU4Pn0-g,6165
 pymammotion/mammotion/devices/__init__.py,sha256=T72jt0ejtMjo1rPmn_FeMF3pmp0LLeRRpc9WcDKEYYY,126
-pymammotion/mammotion/devices/mammotion.py,sha256=zoFNPcZGgucFUCpPKE4m_5U7TW6kMGsgyYmXHibNT40,44308
+pymammotion/mammotion/devices/mammotion.py,sha256=IqOPXLVDcq8VQ2mm33qHrauzkS9XAKOVFE0-TOk-q4k,46909
 pymammotion/mqtt/__init__.py,sha256=Ocs5e-HLJvTuDpVXyECEsWIvwsUaxzj7lZ9mSYutNDY,105
 pymammotion/mqtt/mammotion_future.py,sha256=WKnHqeHiS2Ut-SaDBNOxqh1jDLeTiyLTsJ7PNUexrjk,687
-pymammotion/mqtt/mammotion_mqtt.py,sha256=eCAdOx7ikDiaetXyy9wusisds3klCx6n3DNH-8ZQaHA,8002
+pymammotion/mqtt/mammotion_mqtt.py,sha256=K9TokiQWYJloWu5Hom00g7cfGhWHDSWqbcU9AqW4C9Q,8071
 pymammotion/proto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pymammotion/proto/basestation.proto,sha256=_x5gAz3FkZXS1jtq4GgZgaDCuRU-UV-7HTFdsfQ3zbo,1034
 pymammotion/proto/basestation.py,sha256=js64_N2xQYRxWPRdVNEapO0qe7vBlfYnjW5sE8hi7hw,2026
@@ -111,7 +111,7 @@ pymammotion/utility/device_type.py,sha256=KYawu2glZMVlPmxRbA4kVFujXz3miHp3rJiOWR
 pymammotion/utility/map.py,sha256=aoi-Luzuph02hKynTofMoq3mnPstanx75MDAVv49CuY,2211
 pymammotion/utility/periodic.py,sha256=9wJMfwXPlx6Mbp3Fws7LLTI34ZDKphH1bva_Ggyk32g,3281
 pymammotion/utility/rocker_util.py,sha256=syPL0QN4zMzHiTIkUKS7RXBBptjdbkfNlPddwUD5V3A,7171
-pymammotion-0.2.7.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-pymammotion-0.2.7.dist-info/METADATA,sha256=WPR_bP14ZVgPXEUbRRSNOLP_cI75tPF0rVZBle-6pwU,3968
-pymammotion-0.2.7.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-pymammotion-0.2.7.dist-info/RECORD,,
+pymammotion-0.2.9.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+pymammotion-0.2.9.dist-info/METADATA,sha256=sUQS-JHi__zyOgzpZzSQDKZpkCJ4yzl4UjNQdGE73M0,3968
+pymammotion-0.2.9.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+pymammotion-0.2.9.dist-info/RECORD,,