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

pymammotion/aliyun/cloud_gateway.py

@@ -9,7 +9,7 @@ import random
 import string
 import time
 import uuid
-from logging import getLogger
+from logging import getLogger, exception
 
 from aiohttp import ClientSession
 from alibabacloud_iot_api_gateway.client import Client
@@ -45,6 +45,10 @@ MOVE_HEADERS = (
 )
 
 
+class SetupException(Exception):
+    pass
+
+
 class CloudIOTGateway:
     """Class for interacting with Aliyun Cloud IoT Gateway."""
 
@@ -524,7 +528,10 @@ class CloudIOTGateway:
                 str(response_body_dict.get("code")),
                 str(response_body_dict.get("msg")),
             )
-            return ""
+            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
 

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,7 +19,7 @@ class Point:
 class Dock(Point):
     """Stores robot dock position."""
 
-    rotation: int
+    rotation: int = 0
 
     def __init__(self):
         super().__init__()
@@ -33,8 +33,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/mammotion/devices/mammotion.py

@@ -2,12 +2,15 @@
 
 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
@@ -38,8 +41,10 @@ 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
 
 
 class CharacteristicMissingError(Exception):
@@ -87,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):
@@ -114,10 +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():
-        func(iotId, command)
+        self._operation_lock.release()
+        await self.loop.run_in_executor(None, func, iot_id, command)
 
 
 class ConnectionPreference(Enum):
@@ -223,10 +230,8 @@ class Mammotion(object):
 
     async def initiate_cloud_connection(self, cloud_client: CloudIOTGateway) -> None:
         if self._mammotion_mqtt is not None:
-            if not self._mammotion_mqtt.is_connected:
-                loop = asyncio.get_running_loop()
-                await loop.run_in_executor(None, self._mammotion_mqtt.connect_async)
-            return
+            if self._mammotion_mqtt.is_connected:
+                return
 
 
         self._mammotion_mqtt = MammotionMQTT(region_id=cloud_client._region.data.regionId,
@@ -244,6 +249,11 @@ class Mammotion(object):
             if device.deviceName.startswith(("Luba-", "Yuka-")):
                 self.devices.add_device(MammotionMixedDeviceManager(name=device.deviceName, cloud_device=device, mqtt=self._mammotion_mqtt))
 
+    def set_disconnect_strategy(self, disconnect: bool):
+        for device_name, device in self.devices.devices:
+            if device.ble() is not None:
+                ble_device: MammotionBaseBLEDevice = device.ble()
+                ble_device.set_disconnect_strategy(disconnect)
 
     @staticmethod
     async def login(account: str, password: str) -> CloudIOTGateway:
@@ -328,7 +338,6 @@ 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._notify_future: asyncio.Future[bytes] | None = None
@@ -504,6 +513,28 @@ class MammotionBaseDevice:
         # jobs list
         # hash_list_result = await self._send_command_with_args("get_all_boundary_hash_list", sub_cmd=3)
 
+    async def move_forward(self):
+        linear_speed = 1.0
+        angular_speed = 0.0
+        transfrom3 = RockerControlUtil.getInstance().transfrom3(90, 1000)
+        transform4 = RockerControlUtil.getInstance().transfrom3(0, 0)
+
+        if transfrom3 is not None and len(transfrom3) > 0:
+            linear_speed = transfrom3[0] * 10
+            angular_speed = int(transform4[1] * 4.5)
+        await self._send_command_with_args("send_movement", linear_speed=linear_speed, angular_speed=angular_speed)
+
+    async def move_stop(self):
+        linear_speed = 0.0
+        angular_speed = 0.0
+        transfrom3 = RockerControlUtil.getInstance().transfrom3(0, 0)
+        transform4 = RockerControlUtil.getInstance().transfrom3(0, 0)
+
+        if transfrom3 is not None and len(transfrom3) > 0:
+            linear_speed = transfrom3[0] * 10
+            angular_speed = int(transform4[1] * 4.5)
+        await self._send_command_with_args("send_movement", linear_speed=linear_speed, angular_speed=angular_speed)
+
     async def command(self, key: str, **kwargs):
         """Send a command to the device."""
         return await self._send_command_with_args(key, **kwargs)
@@ -515,6 +546,7 @@ class MammotionBaseBLEDevice(MammotionBaseDevice):
     def __init__(self, mowing_state: MowingDevice, device: BLEDevice, interface: int = 0, **kwargs: Any) -> None:
         """Initialize MammotionBaseBLEDevice."""
         super().__init__(mowing_state)
+        self._disconnect_strategy = True
         self._ble_sync_task = None
         self._prev_notification = None
         self._interface = f"hci{interface}"
@@ -621,7 +653,10 @@ class MammotionBaseBLEDevice(MammotionBaseDevice):
     @property
     def rssi(self) -> int:
         """Return RSSI of device."""
-        return 0
+        try:
+            return self._mower.device.sys.toapp_report_data.connect.ble_rssi
+        finally:
+            return 0
 
     async def _ensure_connected(self):
         """Ensure connection to device is established."""
@@ -651,12 +686,11 @@ class MammotionBaseBLEDevice(MammotionBaseDevice):
                 return
             _LOGGER.debug("%s: Connecting; RSSI: %s", self.name, self.rssi)
             client: BleakClientWithServiceCache = await establish_connection(
-                BleakClient,
+                BleakClientWithServiceCache,
                 self._device,
                 self.name,
                 self._disconnected,
                 max_attempts=10,
-                use_services_cache=True,
                 ble_device_callback=lambda: self._device,
             )
             _LOGGER.debug("%s: Connected; RSSI: %s", self.name, self.rssi)
@@ -838,6 +872,8 @@ class MammotionBaseBLEDevice(MammotionBaseDevice):
 
     async def _execute_timed_disconnect(self) -> None:
         """Execute timed disconnection."""
+        if not self._disconnect_strategy:
+            return
         _LOGGER.debug(
             "%s: Executing timed disconnect after timeout of %s",
             self.name,
@@ -887,6 +923,9 @@ class MammotionBaseBLEDevice(MammotionBaseDevice):
         if self._client is not None:
             return await self._client.disconnect()
 
+    def set_disconnect_strategy(self, disconnect):
+        self._disconnect_strategy = disconnect
+
 
 class MammotionBaseCloudDevice(MammotionBaseDevice):
     """Base class for Mammotion Cloud devices."""
@@ -909,7 +948,7 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
         self._commands: MammotionCommand = MammotionCommand(cloud_device.deviceName)
         self.currentID = ""
         self.on_ready_callback: Optional[Callable[[], None]] = None
-        self._operation_lock = asyncio.Lock()
+        self._waiting_queue = deque()
 
         self._mqtt_client.on_connected = self.on_connected
         self._mqtt_client.on_disconnected = self.on_disconnected
@@ -922,19 +961,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):
@@ -957,27 +996,24 @@ 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", 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:
-            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
+        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."""
@@ -996,33 +1032,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() + 20,
-            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)
 
@@ -1030,15 +1049,12 @@ 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:
-            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
+        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."""
@@ -1053,7 +1069,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")
@@ -1064,14 +1080,25 @@ 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()
+                    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/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/mqtt/mammotion_mqtt.py

@@ -1,11 +1,11 @@
 """MammotionMQTT."""
-
+import asyncio
 import hashlib
 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,9 +80,8 @@ class MammotionMQTT:
     def connect_async(self):
         """Connect async to MQTT Server."""
         logger.info("Connecting...")
-        self._linkkit_client.thing_setup()
         self._linkkit_client.connect_async()
-        self._linkkit_client.start_worker_loop()
+
 
     def disconnect(self):
         """Disconnect from MQTT Server."""
@@ -91,6 +91,7 @@ class MammotionMQTT:
     def _thing_on_thing_enable(self, user_data):
         """Is called when Thing is enabled."""
         logger.debug("on_thing_enable")
+        self.is_connected = True
         # logger.debug('subscribe_topic, topic:%s' % echo_topic)
         # self._linkkit_client.subscribe_topic(echo_topic, 0)
         self._linkkit_client.subscribe_topic(
@@ -120,7 +121,8 @@ class MammotionMQTT:
 
         if self.on_ready:
             self.is_ready = True
-            self.on_ready()
+            future = asyncio.run_coroutine_threadsafe(self.on_ready(), self.loop)
+            asyncio.wrap_future(future, loop=self.loop)
         # self._linkkit_client.query_ota_firmware()
         # command = MammotionCommand(device_name="Luba")
         # self._cloud_client.send_cloud_command(command.get_report_cfg())
@@ -136,13 +138,17 @@ 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)
+            future = asyncio.run_coroutine_threadsafe(self.on_message(topic, payload, iot_id), self.loop)
+            return asyncio.wrap_future(future, loop=self.loop)
+
 
     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}/#")
@@ -153,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."""
@@ -184,3 +192,4 @@ class MammotionMQTT:
     def get_cloud_client(self) -> Optional[CloudIOTGateway]:
         """Return internal cloud client."""
         return self._cloud_client
+

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pymammotion
-Version: 0.2.5
+Version: 0.2.7
 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.5.dist-info → pymammotion-0.2.7.dist-info}/RECORD

@@ -1,6 +1,6 @@
 pymammotion/__init__.py,sha256=kmnjdt3AEMejIz5JK7h1tTJj5ZriAgKwZBa3ScA4-Ao,1516
 pymammotion/aliyun/__init__.py,sha256=T1lkX7TRYiL4nqYanG4l4MImV-SlavSbuooC-W-uUGw,29
-pymammotion/aliyun/cloud_gateway.py,sha256=1-VgNDJCG1XJl-P3OnQ1FaKiF8OhAT0N-HMs0ZZV3WE,18427
+pymammotion/aliyun/cloud_gateway.py,sha256=ZjGSRdfxujOEHgL2gr8rZsGsYlJtGdS2YWGEWLXaEhg,18681
 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
@@ -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=Fw6r4PFCjBmbUPsI6b0Swke6RgUlzoW7NXjR8EGjgzk,784
+pymammotion/data/model/location.py,sha256=mXiJUnD2AIpcN7HgV8OLVL3QFLNAiVWqaVDFGmDjFXU,807
 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
@@ -58,9 +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=M8DYRH0sSjGIM9hYmsSUCf4BHaJgNSwD3zdGeLiT118,43221
+pymammotion/mammotion/devices/mammotion.py,sha256=zoFNPcZGgucFUCpPKE4m_5U7TW6kMGsgyYmXHibNT40,44308
 pymammotion/mqtt/__init__.py,sha256=Ocs5e-HLJvTuDpVXyECEsWIvwsUaxzj7lZ9mSYutNDY,105
-pymammotion/mqtt/mammotion_mqtt.py,sha256=DzNF29VCbIHa4SpUqH0mPgh_PiIDcPEX-Tx-l-YMh1k,7489
+pymammotion/mqtt/mammotion_future.py,sha256=WKnHqeHiS2Ut-SaDBNOxqh1jDLeTiyLTsJ7PNUexrjk,687
+pymammotion/mqtt/mammotion_mqtt.py,sha256=eCAdOx7ikDiaetXyy9wusisds3klCx6n3DNH-8ZQaHA,8002
 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
@@ -110,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.5.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-pymammotion-0.2.5.dist-info/METADATA,sha256=6ykL_7ot9ackweOAJcco8C_LxfNsMWJNCvbH15RKuE0,3922
-pymammotion-0.2.5.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-pymammotion-0.2.5.dist-info/RECORD,,
+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,,