pymammotion 0.4.18__tar.gz → 0.4.19__tar.gz

{pymammotion-0.4.18 → pymammotion-0.4.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pymammotion
-Version: 0.4.18
+Version: 0.4.19
 Summary: 
 License: GPL-3.0
 Author: Michael Arthur

{pymammotion-0.4.18 → pymammotion-0.4.19}/pymammotion/aliyun/client.py

@@ -1,9 +1,10 @@
 import time
 
-from Tea.core import TeaCore
 from Tea.exceptions import UnretryableException
 from Tea.request import TeaRequest
 
+from pymammotion.aliyun.tea.core import TeaCore
+
 try:
     from typing import Dict
 except ImportError:

{pymammotion-0.4.18 → pymammotion-0.4.19}/pymammotion/aliyun/cloud_gateway.py

@@ -102,7 +102,6 @@ class CloudIOTGateway:
         dev_by_account: ListingDevByAccountResponse | None = None,
     ) -> None:
         """Initialize the CloudIOTGateway."""
-        self._iot_token_issued_at = None
         self.mammotion_http: MammotionHTTP | None = None
         self._app_key = APP_KEY
         self._app_secret = APP_SECRET
@@ -117,6 +116,13 @@ class CloudIOTGateway:
         self._session_by_authcode_response = session_by_authcode_response
         self._region_response = region_response
         self._devices_by_account_response = dev_by_account
+        self._iot_token_issued_at = int(time.time())
+        if self._session_by_authcode_response:
+            self._iot_token_issued_at = (
+                self._session_by_authcode_response.token_issued_at
+                if self._session_by_authcode_response.token_issued_at is not None
+                else int(time.time())
+            )
 
     @staticmethod
     def generate_random_string(length: int):

{pymammotion-0.4.18 → pymammotion-0.4.19}/pymammotion/aliyun/model/session_by_authcode_response.py

@@ -16,3 +16,4 @@ class SessionOauthToken(DataClassORJSONMixin):
 class SessionByAuthCodeResponse(DataClassORJSONMixin):
     code: int
     data: SessionOauthToken | None = None
+    token_issued_at: int | None = None

pymammotion-0.4.19/pymammotion/aliyun/tea/core.py

@@ -0,0 +1,295 @@
+import asyncio
+import logging
+import os
+import ssl
+import time
+from typing import Any
+from urllib.parse import urlencode, urlparse
+
+import aiohttp
+import certifi
+from requests import PreparedRequest, adapters, status_codes
+from Tea.exceptions import RequiredArgumentException, RetryError
+from Tea.model import TeaModel
+from Tea.request import TeaRequest
+from Tea.response import TeaResponse
+from Tea.stream import BaseStream
+
+DEFAULT_CONNECT_TIMEOUT = 5000
+DEFAULT_READ_TIMEOUT = 10000
+DEFAULT_POOL_SIZE = 10
+
+logger = logging.getLogger("alibabacloud-tea")
+logger.setLevel(logging.DEBUG)
+ch = logging.StreamHandler()
+logger.addHandler(ch)
+
+
+class TeaCore:
+    http_adapter = adapters.HTTPAdapter(pool_connections=DEFAULT_POOL_SIZE, pool_maxsize=DEFAULT_POOL_SIZE * 4)
+    https_adapter = adapters.HTTPAdapter(pool_connections=DEFAULT_POOL_SIZE, pool_maxsize=DEFAULT_POOL_SIZE * 4)
+
+    @staticmethod
+    def get_adapter(prefix):
+        if prefix.upper() == "HTTP":
+            return TeaCore.http_adapter
+        else:
+            return TeaCore.https_adapter
+
+    @staticmethod
+    def _prepare_http_debug(request, symbol):
+        base = ""
+        for key, value in request.headers.items():
+            base += f"\n{symbol} {key} : {value}"
+        return base
+
+    @staticmethod
+    def _do_http_debug(request, response) -> None:
+        # logger the request
+        url = urlparse(request.url)
+        request_base = f"\n> {request.method.upper()} {url.path + url.query} HTTP/1.1"
+        logger.debug(request_base + TeaCore._prepare_http_debug(request, ">"))
+
+        # logger the response
+        response_base = (
+            f"\n< HTTP/1.1 {response.status_code}" f" {status_codes._codes.get(response.status_code)[0].upper()}"
+        )
+        logger.debug(response_base + TeaCore._prepare_http_debug(response, "<"))
+
+    @staticmethod
+    def compose_url(request):
+        host = request.headers.get("host")
+        if not host:
+            raise RequiredArgumentException("endpoint")
+        else:
+            host = host.rstrip("/")
+        protocol = f"{request.protocol.lower()}://"
+        pathname = request.pathname
+
+        if host.startswith(("http://", "https://")):
+            protocol = ""
+
+        if request.port == 80:
+            port = ""
+        else:
+            port = f":{request.port}"
+
+        url = protocol + host + port + pathname
+
+        if request.query:
+            if "?" in url:
+                if not url.endswith("&"):
+                    url += "&"
+            else:
+                url += "?"
+
+            encode_query = {}
+            for key in request.query:
+                value = request.query[key]
+                if value is not None:
+                    encode_query[key] = str(value)
+            url += urlencode(encode_query)
+        return url.rstrip("?&")
+
+    @staticmethod
+    async def async_do_action(request: TeaRequest, runtime_option=None) -> TeaResponse:
+        runtime_option = runtime_option or {}
+
+        url = TeaCore.compose_url(request)
+        verify = not runtime_option.get("ignoreSSL", False)
+
+        timeout = runtime_option.get("timeout")
+        connect_timeout = runtime_option.get("connectTimeout") or timeout or DEFAULT_CONNECT_TIMEOUT
+        read_timeout = runtime_option.get("readTimeout") or timeout or DEFAULT_READ_TIMEOUT
+
+        connect_timeout, read_timeout = (int(connect_timeout) / 1000, int(read_timeout) / 1000)
+
+        proxy = None
+        if request.protocol.upper() == "HTTP":
+            proxy = runtime_option.get("httpProxy")
+            if not proxy:
+                proxy = os.environ.get("HTTP_PROXY") or os.environ.get("http_proxy")
+        elif request.protocol.upper() == "HTTPS":
+            proxy = runtime_option.get("httpsProxy")
+            if not proxy:
+                proxy = os.environ.get("HTTPS_PROXY") or os.environ.get("https_proxy")
+
+        connector = None
+        ca_cert = certifi.where()
+        if ca_cert and request.protocol.upper() == "HTTPS":
+            loop = asyncio.get_event_loop()
+
+            ssl_context = await loop.run_in_executor(None, ssl.create_default_context, ssl.Purpose.SERVER_AUTH)
+            await loop.run_in_executor(None, ssl_context.load_verify_locations, ca_cert)
+            connector = aiohttp.TCPConnector(
+                ssl=ssl_context,
+            )
+        else:
+            verify = False
+
+        timeout = aiohttp.ClientTimeout(sock_read=read_timeout, sock_connect=connect_timeout)
+        async with aiohttp.ClientSession(connector=connector) as s:
+            body = b""
+            if isinstance(request.body, BaseStream):
+                for content in request.body:
+                    body += content
+            elif isinstance(request.body, str):
+                body = request.body.encode("utf-8")
+            else:
+                body = request.body
+            try:
+                async with s.request(
+                    request.method, url, data=body, headers=request.headers, ssl=verify, proxy=proxy, timeout=timeout
+                ) as response:
+                    tea_resp = TeaResponse()
+                    tea_resp.body = await response.read()
+                    tea_resp.headers = {k.lower(): v for k, v in response.headers.items()}
+                    tea_resp.status_code = response.status
+                    tea_resp.status_message = response.reason
+                    tea_resp.response = response
+            except OSError as e:
+                raise RetryError(str(e))
+        return tea_resp
+
+    @staticmethod
+    def do_action(request: TeaRequest, runtime_option=None) -> TeaResponse:
+        url = TeaCore.compose_url(request)
+
+        runtime_option = runtime_option or {}
+
+        verify = not runtime_option.get("ignoreSSL", False)
+        if verify:
+            verify = runtime_option.get("ca", True) if runtime_option.get("ca", True) is not None else True
+        cert = runtime_option.get("cert", None)
+
+        timeout = runtime_option.get("timeout")
+        connect_timeout = runtime_option.get("connectTimeout") or timeout or DEFAULT_CONNECT_TIMEOUT
+        read_timeout = runtime_option.get("readTimeout") or timeout or DEFAULT_READ_TIMEOUT
+
+        timeout = (int(connect_timeout) / 1000, int(read_timeout) / 1000)
+
+        if isinstance(request.body, str):
+            request.body = request.body.encode("utf-8")
+
+        p = PreparedRequest()
+        p.prepare(
+            method=request.method.upper(),
+            url=url,
+            data=request.body,
+            headers=request.headers,
+        )
+
+        proxies = {}
+        http_proxy = runtime_option.get("httpProxy")
+        https_proxy = runtime_option.get("httpsProxy")
+        no_proxy = runtime_option.get("noProxy")
+
+        if not http_proxy:
+            http_proxy = os.environ.get("HTTP_PROXY") or os.environ.get("http_proxy")
+        if not https_proxy:
+            https_proxy = os.environ.get("HTTPS_PROXY") or os.environ.get("https_proxy")
+
+        if http_proxy:
+            proxies["http"] = http_proxy
+        if https_proxy:
+            proxies["https"] = https_proxy
+        if no_proxy:
+            proxies["no_proxy"] = no_proxy
+
+        adapter = TeaCore.get_adapter(request.protocol)
+        try:
+            resp = adapter.send(
+                p,
+                proxies=proxies,
+                timeout=timeout,
+                verify=verify,
+                cert=cert,
+            )
+        except OSError as e:
+            raise RetryError(str(e))
+
+        debug = runtime_option.get("debug") or os.getenv("DEBUG")
+        if debug and debug.lower() == "sdk":
+            TeaCore._do_http_debug(p, resp)
+
+        response = TeaResponse()
+        response.status_message = resp.reason
+        response.status_code = resp.status_code
+        response.headers = {k.lower(): v for k, v in resp.headers.items()}
+        response.body = resp.content
+        response.response = resp
+        return response
+
+    @staticmethod
+    def get_response_body(resp) -> str:
+        return resp.content.decode("utf-8")
+
+    @staticmethod
+    def allow_retry(dic, retry_times, now=None) -> bool:
+        if retry_times == 0:
+            return True
+        if dic is None or not dic.__contains__("maxAttempts") or dic.get("retryable") is not True and retry_times >= 1:
+            return False
+        else:
+            retry = 0 if dic.get("maxAttempts") is None else int(dic.get("maxAttempts"))
+        return retry >= retry_times
+
+    @staticmethod
+    def get_backoff_time(dic, retry_times) -> int:
+        default_back_off_time = 0
+        if dic is None or not dic.get("policy") or dic.get("policy") == "no":
+            return default_back_off_time
+
+        back_off_time = dic.get("period", default_back_off_time)
+        if not isinstance(back_off_time, int) and not (isinstance(back_off_time, str) and back_off_time.isdigit()):
+            return default_back_off_time
+
+        back_off_time = int(back_off_time)
+        if back_off_time < 0:
+            return retry_times
+
+        return back_off_time
+
+    @staticmethod
+    async def sleep_async(t) -> None:
+        await asyncio.sleep(t)
+
+    @staticmethod
+    def sleep(t) -> None:
+        time.sleep(t)
+
+    @staticmethod
+    def is_retryable(ex) -> bool:
+        return isinstance(ex, RetryError)
+
+    @staticmethod
+    def bytes_readable(body):
+        return body
+
+    @staticmethod
+    def merge(*dic_list) -> dict:
+        dic_result = {}
+        for item in dic_list:
+            if isinstance(item, dict):
+                dic_result.update(item)
+            elif isinstance(item, TeaModel):
+                dic_result.update(item.to_map())
+        return dic_result
+
+    @staticmethod
+    def to_map(model: TeaModel | None) -> dict[str, Any]:
+        if isinstance(model, TeaModel):
+            return model.to_map()
+        else:
+            return dict()
+
+    @staticmethod
+    def from_map(model: TeaModel, dic: dict[str, Any]) -> TeaModel:
+        if isinstance(model, TeaModel):
+            try:
+                return model.from_map(dic)
+            except Exception:
+                model._map = dic
+                return model
+        else:
+            return model

{pymammotion-0.4.18 → pymammotion-0.4.19}/pymammotion/data/model/hash_list.py

@@ -12,6 +12,7 @@ class PathType(IntEnum):
     AREA = 0
     OBSTACLE = 1
     PATH = 2
+    LINE = 10
     DUMP = 12
     SVG = 13
 
@@ -83,6 +84,32 @@ class FrameList(DataClassORJSONMixin):
     data: list[NavGetCommData | SvgMessage] = field(default_factory=list)
 
 
+@dataclass
+class Plan(DataClassORJSONMixin):
+    sub_cmd: int = 2
+    version: str = ""
+    user_id: str = ""
+    device_id: str = ""
+    plan_id: str = ""
+    task_id: str = ""
+    start_time: str = "00:00"
+    knife_height: int = 0
+    model: int = 0
+    edge_mode: int = 0
+    route_model: int = 0
+    route_spacing: int = 0
+    ultrasonic_barrier: int = 0
+    total_plan_num: int = 0
+    speed: float = 0.0
+    task_name: str = ""
+    zone_hashs: list[str] = field(default_factory=list)
+    reserved: str = ""
+    start_date: str = ""
+    trigger_type: int = 0
+    remained_seconds: str = "-1"
+    toward_included_angle: int = 0
+
+
 @dataclass(eq=False, repr=False)
 class NavGetHashListData(DataClassORJSONMixin):
     """Dataclass for NavGetHashListData."""
@@ -124,8 +151,10 @@ class HashList(DataClassORJSONMixin):
     area: dict[int, FrameList] = field(default_factory=dict)  # type 0
     path: dict[int, FrameList] = field(default_factory=dict)  # type 2
     obstacle: dict[int, FrameList] = field(default_factory=dict)  # type 1
-    dump: dict[int, FrameList] = field(default_factory=dict)  # type 12?
+    dump: dict[int, FrameList] = field(default_factory=dict)  # type 12? / sub cmd 4
     svg: dict[int, FrameList] = field(default_factory=dict)  # type 13
+    line: dict[int, FrameList] = field(default_factory=dict)  # type 10 possibly breakpoint? / sub cmd 3
+    plan: dict[int, Plan] = field(default_factory=dict)
     area_name: list[AreaHashNameList] = field(default_factory=list)
 
     def update_hash_lists(self, hashlist: list[int]) -> None:
@@ -152,6 +181,8 @@ class HashList(DataClassORJSONMixin):
         all_hash_ids = set(self.area.keys()).union(
             self.path.keys(), self.obstacle.keys(), self.dump.keys(), self.svg.keys()
         )
+        if sub_cmd == 3:
+            all_hash_ids = set(self.line.keys())
         return [
             i
             for root_list in self.root_hash_lists
@@ -174,7 +205,7 @@ class HashList(DataClassORJSONMixin):
         if target_root_list is None:
             return []
 
-        return self._find_missing_frames(target_root_list)
+        return self.find_missing_frames(target_root_list)
 
     def update_root_hash_list(self, hash_list: NavGetHashListData) -> None:
         target_root_list = next(
@@ -206,26 +237,29 @@ class HashList(DataClassORJSONMixin):
         missing_frames = []
         filtered_lists = [rl for rl in self.root_hash_lists if rl.sub_cmd == hash_ack.sub_cmd]
         for root_list in filtered_lists:
-            missing = self._find_missing_frames(root_list)
+            missing = self.find_missing_frames(root_list)
             if missing:
                 missing_frames.extend(missing)
         return missing_frames
 
     def missing_frame(self, hash_data: NavGetCommDataAck | SvgMessageAckT) -> list[int]:
         if hash_data.type == PathType.AREA:
-            return self._find_missing_frames(self.area.get(hash_data.hash))
+            return self.find_missing_frames(self.area.get(hash_data.hash))
 
         if hash_data.type == PathType.OBSTACLE:
-            return self._find_missing_frames(self.obstacle.get(hash_data.hash))
+            return self.find_missing_frames(self.obstacle.get(hash_data.hash))
 
         if hash_data.type == PathType.PATH:
-            return self._find_missing_frames(self.path.get(hash_data.hash))
+            return self.find_missing_frames(self.path.get(hash_data.hash))
+
+        if hash_data.type == PathType.LINE:
+            return self.find_missing_frames(self.line.get(hash_data.hash))
 
         if hash_data.type == PathType.DUMP:
-            return self._find_missing_frames(self.dump.get(hash_data.hash))
+            return self.find_missing_frames(self.dump.get(hash_data.hash))
 
         if hash_data.type == PathType.SVG:
-            return self._find_missing_frames(self.svg.get(hash_data.data_hash))
+            return self.find_missing_frames(self.svg.get(hash_data.data_hash))
 
         return []
 
@@ -247,6 +281,9 @@ class HashList(DataClassORJSONMixin):
         if hash_data.type == PathType.PATH:
             return self._add_hash_data(self.path, hash_data)
 
+        if hash_data.type == PathType.LINE:
+            return self._add_hash_data(self.line, hash_data)
+
         if hash_data.type == PathType.DUMP:
             return self._add_hash_data(self.dump, hash_data)
 
@@ -256,7 +293,7 @@ class HashList(DataClassORJSONMixin):
         return False
 
     @staticmethod
-    def _find_missing_frames(frame_list: FrameList | RootHashList) -> list[int]:
+    def find_missing_frames(frame_list: FrameList | RootHashList) -> list[int]:
         if frame_list is None:
             return []
 

{pymammotion-0.4.18 → pymammotion-0.4.19}/pymammotion/mammotion/commands/messages/navigation.py

@@ -297,7 +297,7 @@ class MessageNavigation(AbstractMessage, ABC):
 
     def synchronize_hash_data(self, hash_num: int) -> bytes:
         build = MctlNav(todev_get_commondata=NavGetCommData(pver=1, action=8, hash=hash_num, sub_cmd=1))
-        logger.debug(f"Send command--209,hash synchronize area data hash:{hash}")
+        logger.debug(f"Send command--209,hash synchronize area data hash:{hash_num}")
         return self.send_order_msg_nav(build)
 
     def get_area_to_be_transferred(self) -> bytes:

{pymammotion-0.4.18 → pymammotion-0.4.19}/pymammotion/mammotion/devices/base.py

@@ -44,19 +44,19 @@ class MammotionBaseDevice:
         self._cloud_device = cloud_device
 
     async def datahash_response(self, hash_ack: NavGetHashListAck) -> None:
-        """Handle datahash responses."""
+        """Handle datahash responses for root level hashs."""
+        current_frame = hash_ack.current_frame
 
         missing_frames = self.mower.map.missing_root_hash_frame(hash_ack)
         if len(missing_frames) == 0:
-            for sub_cmd in [0, 3]:
-                if len(self.mower.map.missing_hashlist(sub_cmd)) > 0:
-                    # data_hash = self.mower.map.missing_hashlist(hash_ack.sub_cmd).pop()
-                    for data_hash in self.mower.map.missing_hashlist(hash_ack.sub_cmd):
-                        await self.queue_command("synchronize_hash_data", hash_num=data_hash)
+            if len(self.mower.map.missing_hashlist(0)) > 0:
+                data_hash = self.mower.map.missing_hashlist(hash_ack.sub_cmd).pop()
+                await self.queue_command("synchronize_hash_data", hash_num=data_hash)
             return
 
-        for frame in missing_frames:
-            await self.queue_command("get_hash_response", total_frame=hash_ack.total_frame, current_frame=frame - 1)
+        if current_frame != missing_frames[0] - 1:
+            current_frame = missing_frames[0] - 1
+        await self.queue_command("get_hash_response", total_frame=hash_ack.total_frame, current_frame=current_frame)
 
     async def commdata_response(self, common_data: NavGetCommDataAck | SvgMessageAckT) -> None:
         """Handle common data responses."""
@@ -211,25 +211,49 @@ class MammotionBaseDevice:
 
         self.mower.map.update_hash_lists(self.mower.map.hashlist)
 
+        await self.queue_command("send_todev_ble_sync", sync_type=3)
+
         if self._cloud_device and len(self.mower.map.area_name) == 0 and not DeviceType.is_luba1(self.mower.name):
             await self.queue_command("get_area_name_list", device_id=self._cloud_device.iotId)
 
         await self.queue_command("read_plan", sub_cmd=2, plan_index=0)
 
-        await self.queue_command("get_all_boundary_hash_list", sub_cmd=0)
+        if len(self.mower.map.root_hash_lists) == 0:
+            await self.queue_command("get_all_boundary_hash_list", sub_cmd=0)
+
+        for hash, frame in self.mower.map.area.items():
+            missing_frames = self.mower.map.find_missing_frames(frame)
+            if len(missing_frames) > 0:
+                del self.mower.map.area[hash]
+
+        for hash, frame in self.mower.map.path.items():
+            missing_frames = self.mower.map.find_missing_frames(frame)
+            if len(missing_frames) > 0:
+                del self.mower.map.path[hash]
+
+        for hash, frame in self.mower.map.obstacle.items():
+            missing_frames = self.mower.map.find_missing_frames(frame)
+            if len(missing_frames) > 0:
+                del self.mower.map.obstacle[hash]
+
+        # for hash, frame in self.mower.map.svg.items():
+        #     missing_frames = self.mower.map.find_missing_frames(frame)
+        #     if len(missing_frames) > 0:
+        #         del self.mower.map.svg[hash]
+
         if len(self.mower.map.missing_hashlist()) > 0:
             data_hash = self.mower.map.missing_hashlist().pop()
             await self.queue_command("synchronize_hash_data", hash_num=data_hash)
 
-        if len(self.mower.map.missing_hashlist(3)) > 0:
-            data_hash = self.mower.map.missing_hashlist().pop()
-            await self.queue_command("synchronize_hash_data", hash_num=data_hash)
+        # if len(self.mower.map.missing_hashlist(3)) > 0:
+        #     data_hash = self.mower.map.missing_hashlist(3).pop()
+        #     await self.queue_command("synchronize_hash_data", hash_num=data_hash)
 
         # sub_cmd 3 is job hashes??
         # sub_cmd 4 is dump location (yuka)
         # jobs list
         #
-        await self.queue_command("get_all_boundary_hash_list", sub_cmd=3)
+        # await self.queue_command("get_all_boundary_hash_list", sub_cmd=3)
 
     async def async_read_settings(self) -> None:
         """Read settings from device."""

{pymammotion-0.4.18 → pymammotion-0.4.19}/pymammotion/mammotion/devices/mammotion_bluetooth.py

@@ -368,7 +368,7 @@ class MammotionBaseBLEDevice(MammotionBaseDevice):
         _LOGGER.debug("%s: Sending command: %s", self.name, key)
         await self._message.post_custom_data_bytes(command)
 
-        timeout = 2
+        timeout = 1
         timeout_handle = self.loop.call_at(self.loop.time() + timeout, _handle_timeout, self._notify_future)
         timeout_expired = False
         try:

{pymammotion-0.4.18 → pymammotion-0.4.19}/pymammotion/mammotion/devices/mammotion_cloud.py

@@ -5,7 +5,7 @@ from collections import deque
 from collections.abc import Awaitable, Callable
 import json
 import logging
-from typing import Any, cast
+from typing import Any
 
 import betterproto
 from Tea.exceptions import UnretryableException
@@ -20,7 +20,6 @@ from pymammotion.data.state_manager import StateManager
 from pymammotion.event.event import DataEvent
 from pymammotion.mammotion.commands.mammotion_command import MammotionCommand
 from pymammotion.mammotion.devices.base import MammotionBaseDevice
-from pymammotion.mqtt.mammotion_future import MammotionFuture
 from pymammotion.proto import LubaMsg, has_field
 
 _LOGGER = logging.getLogger(__name__)
@@ -96,25 +95,12 @@ class MammotionCloud:
                 # Mark the task as done
                 self.command_queue.task_done()
 
-    async def _execute_command_locked(self, iot_id: str, key: str, command: bytes) -> bytes:
+    async def _execute_command_locked(self, iot_id: str, key: str, command: bytes) -> None:
         """Execute command and read response."""
         assert self._mqtt_client is not None
         self._key = key
         _LOGGER.debug("Sending command: %s", key)
-
         await self._mqtt_client.get_cloud_client().send_cloud_command(iot_id, command)
-        future = MammotionFuture(iot_id)
-        self._waiting_queue.append(future)
-        timeout = 5
-        try:
-            notify_msg = await future.async_get(timeout)
-        except asyncio.TimeoutError:
-            _LOGGER.debug("command_locked TimeoutError")
-            notify_msg = b""
-
-        _LOGGER.debug("%s: Message received", iot_id)
-
-        return notify_msg
 
     async def _on_mqtt_message(self, topic: str, payload: str, iot_id: str) -> None:
         """Handle incoming MQTT messages."""
@@ -242,11 +228,11 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
 
     async def _ble_sync(self) -> None:
         command_bytes = self._commands.send_todev_ble_sync(3)
-        loop = asyncio.get_running_loop()
         try:
             await self._mqtt.send_command(self.iot_id, command_bytes)
         except (CheckSessionException, SetupException):
-            self._ble_sync_task.cancel()
+            if self._ble_sync_task:
+                self._ble_sync_task.cancel()
 
     async def run_periodic_sync_task(self) -> None:
         """Send ble sync to robot."""
@@ -264,7 +250,7 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
                 160, lambda: asyncio.ensure_future(self.run_periodic_sync_task())
             )
 
-    async def queue_command(self, key: str, **kwargs: Any) -> bytes:
+    async def queue_command(self, key: str, **kwargs: Any) -> None:
         # Create a future to hold the result
         _LOGGER.debug("Queueing command: %s", key)
         future = asyncio.Future()
@@ -311,7 +297,6 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
         self.state_manager.status(status)
 
     async def _parse_message_for_device(self, event: ThingEventMessage) -> None:
-        _LOGGER.debug("_parse_message_for_device")
         params = event.params
         new_msg = LubaMsg()
         if event.params.iotId != self.iot_id:
@@ -335,15 +320,6 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
 
         await self._state_manager.notification(new_msg)
 
-        if len(self._mqtt.waiting_queue) > 0:
-            fut: MammotionFuture = self.dequeue_by_iot_id(self._mqtt.waiting_queue, self.iot_id)
-            if fut is None:
-                return
-            while fut is None or fut.fut.cancelled() and len(self._mqtt.waiting_queue) > 0:
-                fut = self.dequeue_by_iot_id(self._mqtt.waiting_queue, self.iot_id)
-            if fut is not None and not fut.fut.cancelled():
-                fut.resolve(cast(bytes, binary_data))
-
     @property
     def mqtt(self):
         return self._mqtt

{pymammotion-0.4.18 → pymammotion-0.4.19}/pymammotion/mqtt/mammotion_mqtt.py

@@ -194,12 +194,13 @@ class MammotionMQTT:
 
     def _on_disconnect(self, _client, _userdata) -> None:
         """Is called on disconnect."""
-        logger.info("Disconnected")
-        self.is_connected = False
-        self.is_ready = False
-        if self.on_disconnected:
-            future = asyncio.run_coroutine_threadsafe(self.on_disconnected(), self.loop)
-            asyncio.wrap_future(future, loop=self.loop)
+        if self._linkkit_client.check_state() is LinkKit.LinkKitState.DISCONNECTED:
+            logger.info("Disconnected")
+            self.is_connected = False
+            self.is_ready = False
+            if 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) -> None:
         """Is called when message is received."""