pymammotion 0.2.35__py3-none-any.whl → 0.2.36__py3-none-any.whl

pymammotion/aliyun/cloud_gateway.py

@@ -586,6 +586,7 @@ class CloudIOTGateway:
             request=request,
             version="1.0",
         )
+        logger.debug(self.converter.printBase64Binary(command))
 
         # send request
         response = client.do_request("/thing/service/invoke", "https", "POST", None, body, RuntimeOptions())

pymammotion/data/state_manager.py

@@ -1,6 +1,6 @@
 """Manage state from notifications into MowingDevice."""
 
-from typing import Awaitable, Callable, Optional
+from typing import Any, Awaitable, Callable, Optional
 
 import betterproto
 
@@ -19,6 +19,7 @@ class StateManager:
         self.gethash_ack_callback: Optional[Callable[[NavGetHashListAck], Awaitable[None]]] = None
         self.get_commondata_ack_callback: Optional[Callable[[NavGetCommDataAck], Awaitable[None]]] = None
         self.on_notification_callback: Optional[Callable[[], Awaitable[None]]] = None
+        self.queue_command_callback: Optional[Callable[[str, dict[str, Any]], Awaitable[bytes]]] = None
 
     def get_device(self) -> MowingDevice:
         """Get device."""
@@ -36,7 +37,7 @@ class StateManager:
             case "nav":
                 await self._update_nav_data(message)
             case "sys":
-                self._update_sys_data(message)
+                await self._update_sys_data(message)
             case "driver":
                 self._update_driver_data(message)
             case "net":
@@ -66,7 +67,7 @@ class StateManager:
                 hash_names: AppGetAllAreaHashName = nav_msg[1]
                 self._device.map.area_name = hash_names.hashnames
 
-    def _update_sys_data(self, message) -> None:
+    async def _update_sys_data(self, message) -> None:
         """Update system."""
         sys_msg = betterproto.which_one_of(message.sys, "SubSysMsg")
         match sys_msg[0]:
@@ -74,6 +75,8 @@ class StateManager:
                 self._device.buffer(sys_msg[1])
             case "toapp_report_data":
                 self._device.update_report_data(sys_msg[1])
+                if self.queue_command_callback:
+                    await self.queue_command_callback("get_report_cfg", stop=True)
             case "mow_to_app_info":
                 self._device.mow_info(sys_msg[1])
             case "system_tard_state_tunnel":

pymammotion/mammotion/commands/messages/system.py

@@ -4,8 +4,20 @@ from abc import ABC
 
 from pymammotion.mammotion.commands.abstract_message import AbstractMessage
 from pymammotion.mammotion.commands.messages.navigation import MessageNavigation
-from pymammotion.proto import luba_msg_pb2, mctrl_sys, mctrl_sys_pb2
-from pymammotion.proto.mctrl_sys import RptInfoType
+from pymammotion.proto.luba_msg import LubaMsg, MsgAttr, MsgCmdType, MsgDevice
+from pymammotion.proto.mctrl_sys import (
+    DeviceProductTypeInfoT,
+    LoraCfgReq,
+    MctlSys,
+    MCtrlSimulationCmdData,
+    ReportInfoCfg,
+    RptAct,
+    RptInfoType,
+    SysCommCmd,
+    SysKnifeControl,
+    SysSetDateTime,
+    TimeCtrlLight,
+)
 from pymammotion.utility.device_type import DeviceType
 
 
@@ -13,37 +25,35 @@ class MessageSystem(AbstractMessage, ABC):
     messageNavigation: MessageNavigation = MessageNavigation()
 
     def send_order_msg_sys(self, sys):
-        luba_msg = luba_msg_pb2.LubaMsg(
-            msgtype=luba_msg_pb2.MSG_CMD_TYPE_EMBED_SYS,
-            sender=luba_msg_pb2.DEV_MOBILEAPP,
-            rcver=luba_msg_pb2.DEV_MAINCTL,
+        luba_msg = LubaMsg(
+            msgtype=MsgCmdType.MSG_CMD_TYPE_EMBED_SYS,
+            sender=MsgDevice.DEV_MOBILEAPP,
+            rcver=MsgDevice.DEV_MAINCTL,
             sys=sys,
         )
 
         return luba_msg.SerializeToString()
 
     def reset_system(self):
-        build = mctrl_sys_pb2.MctlSys(todev_reset_system=1)
+        build = MctlSys(todev_reset_system=1)
         print("Send command - send factory reset")
         return self.send_order_msg_sys(build)
 
     def set_blade_control(self, on_off: int):
-        mctlsys = mctrl_sys_pb2.MctlSys()
-        sys_knife_control = mctrl_sys_pb2.SysKnifeControl()
+        mctlsys = MctlSys()
+        sys_knife_control = SysKnifeControl()
         sys_knife_control.knife_status = on_off
-        mctlsys.todev_knife_ctrl.CopyFrom(sys_knife_control)
+        mctlsys.todev_knife_ctrl = sys_knife_control
 
         return self.send_order_msg_sys(mctlsys)
 
     def get_device_product_model(self):
-        return self.send_order_msg_sys(
-            mctrl_sys_pb2.MctlSys(device_product_type_info=mctrl_sys_pb2.device_product_type_info_t())
-        )
+        return self.send_order_msg_sys(MctlSys(device_product_type_info=DeviceProductTypeInfoT()))
 
     def read_and_set_sidelight(self, is_sidelight: bool, operate: int):
         """Read state of sidelight as well as set it."""
         if is_sidelight:
-            build = mctrl_sys_pb2.TimeCtrlLight(
+            build = TimeCtrlLight(
                 operate=operate,
                 enable=0,
                 action=0,
@@ -53,7 +63,7 @@ class MessageSystem(AbstractMessage, ABC):
                 end_min=0,
             )
         else:
-            build = mctrl_sys_pb2.TimeCtrlLight(
+            build = TimeCtrlLight(
                 operate=operate,
                 enable=1,
                 action=0,
@@ -64,16 +74,16 @@ class MessageSystem(AbstractMessage, ABC):
             )
         print(f"Send read and write sidelight command is_sidelight:{
             is_sidelight}, operate:{operate}")
-        build2 = mctrl_sys_pb2.MctlSys(todev_time_ctrl_light=build)
+        build2 = MctlSys(todev_time_ctrl_light=build)
         print(f"Send command - send read and write sidelight command is_sidelight:{
             is_sidelight}, operate:{operate}, timeCtrlLight:{build}")
         return self.send_order_msg_sys(build2)
 
     def test_tool_order_to_sys(self, sub_cmd: int, param_id: int, param_value: list[int]):
-        build = mctrl_sys_pb2.mCtrlSimulationCmdData(sub_cmd=sub_cmd, param_id=param_id, param_value=param_value)
+        build = MCtrlSimulationCmdData(sub_cmd=sub_cmd, param_id=param_id, param_value=param_value)
         print(f"Send tool test command: subCmd={sub_cmd}, param_id:{
             param_id}, param_value={param_value}")
-        build2 = mctrl_sys_pb2.MctlSys(simulation_cmd=build)
+        build2 = MctlSys(simulation_cmd=build)
         print(f"Send tool test command: subCmd={sub_cmd}, param_id:{
             param_id}, param_value={param_value}")
         return self.send_order_msg_sys(build2)
@@ -81,15 +91,13 @@ class MessageSystem(AbstractMessage, ABC):
     def read_and_set_rtk_paring_code(self, op: int, cgf: str):
         print(f"Send read and write base station configuration quality op:{
             op}, cgf:{cgf}")
-        return self.send_order_msg_sys(
-            mctrl_sys_pb2.MctlSys(todev_lora_cfg_req=mctrl_sys_pb2.LoraCfgReq(op=op, cfg=cgf))
-        )
+        return self.send_order_msg_sys(MctlSys(todev_lora_cfg_req=LoraCfgReq(op=op, cfg=cgf)))
 
     def allpowerfull_rw(self, id: int, context: int, rw: int):
         if (id == 6 or id == 3 or id == 7) and DeviceType.is_luba_2(self.get_device_name()):
             self.messageNavigation.allpowerfull_rw_adapter_x3(id, context, rw)
             return
-        build = mctrl_sys_pb2.MctlSys(bidire_comm_cmd=mctrl_sys_pb2.SysCommCmd(id=id, context=context, rw=rw))
+        build = MctlSys(bidire_comm_cmd=SysCommCmd(id=id, context=context, rw=rw))
         print(f"Send command - 9 general read and write command id={id}, context={context}, rw={rw}")
         if id == 5:
             # This logic doesnt make snese, but its what they had so..
@@ -98,7 +106,7 @@ class MessageSystem(AbstractMessage, ABC):
 
     # Commented out as not needed and too many refs to try fix up
     # def factory_test_order(self, test_id: int, test_duration: int, expect: str):
-    #     new_builder = mctrl_sys_pb2.mow_to_app_qctools_info_t.Builder()
+    #     new_builder = mow_to_app_qctools_info_t.Builder()
     #     print(f"Factory tool print, expect={expect}")
     #     if not expect:
     #         build = new_builder.set_type_value(
@@ -108,7 +116,7 @@ class MessageSystem(AbstractMessage, ABC):
     #             json_array = json.loads(expect)
     #             z2 = True
     #             for i in range(len(json_array)):
-    #                 new_builder2 = mctrl_sys_pb2.QCAppTestExcept.Builder()
+    #                 new_builder2 = QCAppTestExcept.Builder()
     #                 json_object = json_array[i]
     #                 if "except_type" in json_object:
     #                     string = json_object["except_type"]
@@ -116,7 +124,7 @@ class MessageSystem(AbstractMessage, ABC):
     #                         json_array2 = json_object["conditions"]
     #                         for i2 in range(len(json_array2)):
     #                             json_object2 = json_array2[i2]
-    #                             new_builder3 = mctrl_sys_pb2.QCAppTestConditions.Builder()
+    #                             new_builder3 = QCAppTestConditions.Builder()
     #                             if "cond_type" in json_object2:
     #                                 new_builder3.set_cond_type(
     #                                     json_object2["cond_type"])
@@ -151,7 +159,7 @@ class MessageSystem(AbstractMessage, ABC):
     #                 test_id).set_time_of_duration(test_duration).build()
     #     print(f"Factory tool print, mow_to_app_qctools_info_t={
     #         build.except_count}, mow_to_app_qctools_info_t22={build.except_list}")
-    #     build2 = mctrl_sys_pb2.MctlSys(mow_to_app_qctools_info=build)
+    #     build2 = MctlSys(mow_to_app_qctools_info=build)
     #     print(f"Send command - factory tool test command testId={
     #         test_id}, testDuration={test_duration}", "Factory tool print222", True)
     #     return self.send_order_msg_sys(build2)
@@ -169,8 +177,8 @@ class MessageSystem(AbstractMessage, ABC):
         i9 = 1 if calendar.dst() else 0
         print(f"Print time zone, time zone={
             i8}, daylight saving time={i9} week={i4}")
-        build = mctrl_sys.MctlSys(
-            todev_data_time=mctrl_sys.SysSetDateTime(
+        build = MctlSys(
+            todev_data_time=SysSetDateTime(
                 year=i,
                 month=i2,
                 date=i3,
@@ -191,21 +199,21 @@ class MessageSystem(AbstractMessage, ABC):
         return self.send_order_msg_sys(build)
 
     def get_device_version_info(self):
-        return self.send_order_msg_sys(mctrl_sys_pb2.MctlSys(todev_get_dev_fw_info=1))
+        return self.send_order_msg_sys(MctlSys(todev_get_dev_fw_info=1))
 
     # === sendOrderMsg_Sys2 ===
 
     def request_iot_sys(
         self,
-        rpt_act: mctrl_sys_pb2.rpt_act,
+        rpt_act: RptAct,
         rpt_info_type: list[RptInfoType | str] | None,
         timeout: int,
         period: int,
         no_change_period: int,
         count: int,
     ) -> bytes:
-        build = mctrl_sys_pb2.MctlSys(
-            todev_report_cfg=mctrl_sys_pb2.report_info_cfg(
+        build = MctlSys(
+            todev_report_cfg=ReportInfoCfg(
                 act=rpt_act,
                 sub=rpt_info_type,
                 timeout=timeout,
@@ -218,9 +226,12 @@ class MessageSystem(AbstractMessage, ABC):
             build.todev_report_cfg.act} {build}")
         return self.send_order_msg_sys(build)
 
-    def get_report_cfg(self, timeout: int = 10000, period: int = 1000, no_change_period: int = 2000):
-        mctlsys = mctrl_sys_pb2.MctlSys(
-            todev_report_cfg=mctrl_sys_pb2.report_info_cfg(
+    def get_report_cfg(
+        self, timeout: int = 10000, period: int = 1000, no_change_period: int = 1000, stop: bool = False
+    ):
+        mctlsys = MctlSys(
+            todev_report_cfg=ReportInfoCfg(
+                act=RptAct.RPT_STOP if stop else RptAct.RPT_START,
                 timeout=timeout,
                 period=period,
                 no_change_period=no_change_period,
@@ -233,17 +244,18 @@ class MessageSystem(AbstractMessage, ABC):
         mctlsys.todev_report_cfg.sub.append(RptInfoType.RIT_DEV_LOCAL.value)
         mctlsys.todev_report_cfg.sub.append(RptInfoType.RIT_WORK.value)
         mctlsys.todev_report_cfg.sub.append(RptInfoType.RIT_DEV_STA.value)
+        mctlsys.todev_report_cfg.sub.append(RptInfoType.RIT_MAINTAIN.value)
         mctlsys.todev_report_cfg.sub.append(RptInfoType.RIT_VISION_POINT.value)
         mctlsys.todev_report_cfg.sub.append(RptInfoType.RIT_VIO.value)
         mctlsys.todev_report_cfg.sub.append(RptInfoType.RIT_VISION_STATISTIC.value)
 
-        lubaMsg = luba_msg_pb2.LubaMsg()
-        lubaMsg.msgtype = luba_msg_pb2.MSG_CMD_TYPE_EMBED_SYS
-        lubaMsg.sender = luba_msg_pb2.DEV_MOBILEAPP
-        lubaMsg.rcver = luba_msg_pb2.DEV_MAINCTL
-        lubaMsg.msgattr = luba_msg_pb2.MSG_ATTR_REQ
+        lubaMsg = LubaMsg()
+        lubaMsg.msgtype = MsgCmdType.MSG_CMD_TYPE_EMBED_SYS
+        lubaMsg.sender = MsgDevice.DEV_MOBILEAPP
+        lubaMsg.rcver = MsgDevice.DEV_MAINCTL
+        lubaMsg.msgattr = MsgAttr.MSG_ATTR_REQ
         lubaMsg.seqs = 1
         lubaMsg.version = 1
         lubaMsg.subtype = 1
-        lubaMsg.sys.CopyFrom(mctlsys)
+        lubaMsg.sys = mctlsys
         return lubaMsg.SerializeToString()

pymammotion/mammotion/devices/base.py

@@ -18,7 +18,7 @@ from pymammotion.utility.movement import get_percent, transform_both_speeds
 _LOGGER = logging.getLogger(__name__)
 
 
-def find_next_integer(lst: list[int], current_hash: float) -> int | None:
+def find_next_integer(lst: list[int], current_hash: int) -> int | None:
     try:
         # Find the index of the current integer
         current_index = lst.index(current_hash)
@@ -54,6 +54,9 @@ class MammotionBaseDevice:
     def set_notification_callback(self, func: Callable[[], Awaitable[None]]) -> None:
         self._state_manager.on_notification_callback = func
 
+    def set_queue_callback(self, func: Callable[[str, dict[str, Any]], Awaitable[bytes]]) -> None:
+        self._state_manager.queue_command_callback = func
+
     async def datahash_response(self, hash_ack: NavGetHashListAck) -> None:
         """Handle datahash responses."""
         await self.queue_command("synchronize_hash_data", hash_num=hash_ack.data_couple[0])

pymammotion/mammotion/devices/mammotion.py

@@ -37,7 +37,8 @@ class ConnectionPreference(Enum):
 class MammotionMixedDeviceManager:
     _ble_device: MammotionBaseBLEDevice | None = None
     _cloud_device: MammotionBaseCloudDevice | None = None
-    _mowing_state: MowingDevice = MowingDevice()
+    _mowing_state: MowingDevice
+    preference: ConnectionPreference
 
     def __init__(
         self,
@@ -45,10 +46,13 @@ class MammotionMixedDeviceManager:
         cloud_device: Device | None = None,
         ble_device: BLEDevice | None = None,
         mqtt: MammotionCloud | None = None,
+        preference: ConnectionPreference = ConnectionPreference.BLUETOOTH,
     ) -> None:
         self.name = name
+        self._mowing_state = MowingDevice()
         self.add_ble(ble_device)
         self.add_cloud(cloud_device, mqtt)
+        self.preference = preference
 
     def mower_state(self):
         return self._mowing_state
@@ -101,19 +105,30 @@ class MammotionDevices:
     def get_device(self, mammotion_device_name: str) -> MammotionMixedDeviceManager:
         return self.devices.get(mammotion_device_name)
 
+    def remove_device(self, name) -> None:
+        device_for_removal = self.devices.pop(name)
+        if device_for_removal.has_cloud():
+            should_disconnect = {
+                device
+                for key, device in self.devices.items()
+                if device.cloud() is not None and device.cloud()._mqtt == device_for_removal.cloud()._mqtt
+            }
+            if len(should_disconnect) == 0:
+                device_for_removal.cloud()._mqtt.disconnect()
+
 
 async def create_devices(
     ble_device: BLEDevice,
     cloud_credentials: Credentials | None = None,
     preference: ConnectionPreference = ConnectionPreference.BLUETOOTH,
 ):
-    mammotion = Mammotion(ble_device, preference)
+    mammotion = Mammotion()
+    mammotion.add_ble_device(ble_device, preference)
 
     if cloud_credentials and preference == ConnectionPreference.EITHER or preference == ConnectionPreference.WIFI:
-        cloud_client = await Mammotion.login(
+        await mammotion.login_and_initiate_cloud(
             cloud_credentials.account_id or cloud_credentials.email, cloud_credentials.password
         )
-        await mammotion.initiate_cloud_connection(cloud_client)
 
     return mammotion
 
@@ -123,26 +138,44 @@ class Mammotion:
     """Represents a Mammotion account and its devices."""
 
     devices = MammotionDevices()
-    cloud_client: CloudIOTGateway | None = None
-    mqtt: MammotionCloud | None = None
+    mqtt_list: dict[str, MammotionCloud] = dict()
 
-    def __init__(
-        self, ble_device: BLEDevice, preference: ConnectionPreference = ConnectionPreference.BLUETOOTH
-    ) -> None:
+    _instance = None
+
+    def __new__(cls, *args, **kwargs):
+        if not cls._instance:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self) -> None:
         """Initialize MammotionDevice."""
-        if ble_device:
-            self.devices.add_device(MammotionMixedDeviceManager(name=ble_device.name, ble_device=ble_device))
+        self._login_lock = asyncio.Lock()
 
-        if preference:
-            self._preference = preference
+    def add_ble_device(self, ble_device: BLEDevice, preference: ConnectionPreference = ConnectionPreference.BLUETOOTH) -> None:
+        if ble_device:
+            self.devices.add_device(
+                MammotionMixedDeviceManager(name=ble_device.name, ble_device=ble_device, preference=preference)
+            )
 
-    async def initiate_cloud_connection(self, cloud_client: CloudIOTGateway) -> None:
-        if self.mqtt is not None:
-            if self.mqtt.is_connected:
+    async def login_and_initiate_cloud(self, account, password, force: bool = False) -> None:
+        async with self._login_lock:
+            exists: MammotionCloud | None = self.mqtt_list.get(account)
+            if not exists or force:
+                cloud_client = await self.login(account, password)
+            else:
+                cloud_client = exists.cloud_client
+
+            await self.initiate_cloud_connection(account, cloud_client)
+
+    async def initiate_cloud_connection(self, account: str, cloud_client: CloudIOTGateway) -> None:
+        if self.mqtt_list.get(account) is not None:
+            if self.mqtt_list.get(account).is_connected:
+                # we might have removed a device so readd
+                self.add_cloud_devices(self.mqtt_list.get(account))
                 return
 
         self.cloud_client = cloud_client
-        self.mqtt = MammotionCloud(
+        self.mqtt_list[account] = MammotionCloud(
             MammotionMQTT(
                 region_id=cloud_client.region_response.data.regionId,
                 product_key=cloud_client.aep_response.data.productKey,
@@ -151,23 +184,30 @@ class Mammotion:
                 iot_token=cloud_client.session_by_authcode_response.data.iotToken,
                 client_id=cloud_client.client_id,
                 cloud_client=cloud_client,
-            )
+            ),
+            cloud_client,
         )
 
         loop = asyncio.get_running_loop()
-        await loop.run_in_executor(None, self.mqtt.connect_async)
+        await loop.run_in_executor(None, self.mqtt_list[account].connect_async)
 
-        for device in cloud_client.devices_by_account_response.data.data:
+    def add_cloud_devices(self, mqtt_client: MammotionCloud) -> None:
+        for device in mqtt_client.cloud_client.devices_by_account_response.data.data:
             mower_device = self.devices.get_device(device.deviceName)
             if device.deviceName.startswith(("Luba-", "Yuka-")) and mower_device is None:
                 self.devices.add_device(
-                    MammotionMixedDeviceManager(name=device.deviceName, cloud_device=device, mqtt=self.mqtt)
+                    MammotionMixedDeviceManager(
+                        name=device.deviceName,
+                        cloud_device=device,
+                        mqtt=mqtt_client,
+                        preference=ConnectionPreference.WIFI,
+                    )
                 )
             elif device.deviceName.startswith(("Luba-", "Yuka-")) and mower_device:
                 if mower_device.cloud() is None:
-                    mower_device.add_cloud(cloud_device=device, mqtt=self.mqtt)
-                else:
-                    device.replace_mqtt(self.mqtt)
+                    mower_device.add_cloud(cloud_device=device, mqtt=mqtt_client)
+                elif mqtt_client != mower_device.cloud().mqtt:
+                    mower_device.replace_mqtt(mqtt_client)
 
     def set_disconnect_strategy(self, disconnect: bool) -> None:
         for device_name, device in self.devices.devices:
@@ -175,8 +215,7 @@ class Mammotion:
                 ble_device: MammotionBaseBLEDevice = device.ble()
                 ble_device.set_disconnect_strategy(disconnect)
 
-    @staticmethod
-    async def login(account: str, password: str) -> CloudIOTGateway:
+    async def login(self, account: str, password: str) -> CloudIOTGateway:
         """Login to mammotion cloud."""
         cloud_client = CloudIOTGateway()
         async with ClientSession(MAMMOTION_DOMAIN) as session:
@@ -197,6 +236,9 @@ class Mammotion:
             await loop.run_in_executor(None, cloud_client.list_binding_by_account)
             return cloud_client
 
+    def remove_device(self, name: str) -> None:
+        self.devices.remove_device(name)
+
     def get_device_by_name(self, name: str) -> MammotionMixedDeviceManager:
         return self.devices.get_device(name)
 
@@ -204,9 +246,9 @@ class Mammotion:
         """Send a command to the device."""
         device = self.get_device_by_name(name)
         if device:
-            if self._preference is ConnectionPreference.BLUETOOTH:
+            if device.preference is ConnectionPreference.BLUETOOTH:
                 return await device.ble().command(key)
-            if self._preference is ConnectionPreference.WIFI:
+            if device.preference is ConnectionPreference.WIFI:
                 return await device.cloud().command(key)
             # TODO work with both with EITHER
 
@@ -214,27 +256,27 @@ class Mammotion:
         """Send a command with args to the device."""
         device = self.get_device_by_name(name)
         if device:
-            if self._preference is ConnectionPreference.BLUETOOTH:
+            if device.preference is ConnectionPreference.BLUETOOTH:
                 return await device.ble().command(key, **kwargs)
-            if self._preference is ConnectionPreference.WIFI:
+            if device.preference is ConnectionPreference.WIFI:
                 return await device.cloud().command(key, **kwargs)
             # TODO work with both with EITHER
 
     async def start_sync(self, name: str, retry: int):
         device = self.get_device_by_name(name)
         if device:
-            if self._preference is ConnectionPreference.BLUETOOTH:
+            if device.preference is ConnectionPreference.BLUETOOTH:
                 return await device.ble().start_sync(retry)
-            if self._preference is ConnectionPreference.WIFI:
+            if device.preference is ConnectionPreference.WIFI:
                 return await device.cloud().start_sync(retry)
             # TODO work with both with EITHER
 
     async def start_map_sync(self, name: str):
         device = self.get_device_by_name(name)
         if device:
-            if self._preference is ConnectionPreference.BLUETOOTH:
+            if device.preference is ConnectionPreference.BLUETOOTH:
                 return await device.ble().start_map_sync()
-            if self._preference is ConnectionPreference.WIFI:
+            if device.preference is ConnectionPreference.WIFI:
                 return await device.cloud().start_map_sync()
             # TODO work with both with EITHER
 

pymammotion/mammotion/devices/mammotion_bluetooth.py

@@ -88,6 +88,7 @@ class MammotionBaseBLEDevice(MammotionBaseDevice):
         self._connect_lock = asyncio.Lock()
         self._operation_lock = asyncio.Lock()
         self._key: str | None = None
+        self.set_queue_callback(self.queue_command)
 
     def update_device(self, device: BLEDevice) -> None:
         """Update the BLE device."""

pymammotion/mammotion/devices/mammotion_cloud.py

@@ -7,7 +7,7 @@ from typing import Any, Awaitable, Callable, Optional, cast
 
 import betterproto
 
-from pymammotion import MammotionMQTT
+from pymammotion import CloudIOTGateway, MammotionMQTT
 from pymammotion.aliyun.dataclass.dev_by_account_response import Device
 from pymammotion.data.model.device import MowingDevice
 from pymammotion.data.mqtt.event import ThingEventMessage
@@ -24,7 +24,8 @@ _LOGGER = logging.getLogger(__name__)
 class MammotionCloud:
     """Per account MQTT cloud."""
 
-    def __init__(self, mqtt_client: MammotionMQTT) -> None:
+    def __init__(self, mqtt_client: MammotionMQTT, cloud_client: CloudIOTGateway) -> None:
+        self.cloud_client = cloud_client
         self.loop = asyncio.get_event_loop()
         self._ble_sync_task = None
         self.is_ready = False
@@ -155,6 +156,7 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
         self.currentID = ""
         self._mqtt.mqtt_message_event.add_subscribers(self._parse_message_for_device)
         self._mqtt.on_ready_event.add_subscribers(self.on_ready)
+        self.set_queue_callback(self.queue_command)
 
         if self._mqtt.is_ready:
             self.run_periodic_sync_task()
@@ -244,3 +246,7 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
             if not fut.fut.cancelled():
                 fut.resolve(cast(bytes, binary_data))
         await self._state_manager.notification(new_msg)
+
+    @property
+    def mqtt(self):
+        return self._mqtt

pymammotion/utility/device_type.py

@@ -95,7 +95,6 @@ class DeviceType(Enum):
             elif DeviceType.LUBA.get_name() in substring2 or DeviceType.contain_luba_product_key(product_key):
                 return DeviceType.LUBA
             else:
-                print("unknown device type")
                 return DeviceType.UNKNOWN
         except Exception:
             return DeviceType.UNKNOWN

{pymammotion-0.2.35.dist-info → pymammotion-0.2.36.dist-info}/METADATA

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

{pymammotion-0.2.35.dist-info → pymammotion-0.2.36.dist-info}/RECORD

@@ -1,6 +1,6 @@
 pymammotion/__init__.py,sha256=jHCQrpJaG1jAoID9T4RT3g4JsZc0JpJqIcqjnA7cXd0,1605
 pymammotion/aliyun/__init__.py,sha256=T1lkX7TRYiL4nqYanG4l4MImV-SlavSbuooC-W-uUGw,29
-pymammotion/aliyun/cloud_gateway.py,sha256=Fktzd7ej9b02hr0Dl82_EgUkDCCzWqcp92_wd8D2vaw,22716
+pymammotion/aliyun/cloud_gateway.py,sha256=X6Y9yyIXCwkPwgRqsBESUI5v6j-CKlJGJaEnMINyp8c,22780
 pymammotion/aliyun/cloud_service.py,sha256=px7dUKow5Z7VyebjYzuKkzkm77XbUXYiFiYO_2e-UQ0,2207
 pymammotion/aliyun/dataclass/aep_response.py,sha256=8f6GIP58ve8gd6AL3HBoXxsy0n2q4ygWvjELGnoOnVc,452
 pymammotion/aliyun/dataclass/connect_response.py,sha256=Yz-fEbDzgGPTo5Of2oAjmFkSv08T7ze80pQU4k-gKIU,824
@@ -38,7 +38,7 @@ pymammotion/data/mqtt/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdr
 pymammotion/data/mqtt/event.py,sha256=GKh4NdcaeeaG5pPktzy-eguFKK74Mfxpl0eIAkKU1Vc,4567
 pymammotion/data/mqtt/properties.py,sha256=HkBPghr26L9_b4QaOi1DtPgb0UoPIOGSe9wb3kgnM6Y,2815
 pymammotion/data/mqtt/status.py,sha256=zqnlo-MzejEQZszl0i0Wucoc3E76x6UtI9JLxoBnu54,1067
-pymammotion/data/state_manager.py,sha256=GpVQM78JTFNtjpym2ykFR-Ng7iMXRhfunyAbL-QpENs,3363
+pymammotion/data/state_manager.py,sha256=ZIOB1Th7yDAgCJk17rd-kXjwD50GIqQMsNgf1iFldUs,3615
 pymammotion/event/__init__.py,sha256=mgATR6vPHACNQ-0zH5fi7NdzeTCDV1CZyaWPmtUusi8,115
 pymammotion/event/event.py,sha256=UzYnxV5DfvMDK3E06UvSzvzuBbaXOOUwO6xYt_zn9To,2034
 pymammotion/http/_init_.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -54,15 +54,15 @@ pymammotion/mammotion/commands/messages/media.py,sha256=ps0l06CXy5Ej--gTNCsyKttw
 pymammotion/mammotion/commands/messages/navigation.py,sha256=4rXBL-mViWc38K6x1w5O-GjwV8UWS5xZXkf4aHYjs8A,23684
 pymammotion/mammotion/commands/messages/network.py,sha256=gD7NKVKg8U2KNbPvgOxvTJXbznWdpdPQo9jBsQSx4OI,8027
 pymammotion/mammotion/commands/messages/ota.py,sha256=XkeuWBZtpYMMBze6r8UN7dJXbe2FxUNGNnjwBpXJKM0,1240
-pymammotion/mammotion/commands/messages/system.py,sha256=xm9Nj3wva9leVV1tyzfS_Hf53t-j7Nk8RBlFd00CQFM,10972
+pymammotion/mammotion/commands/messages/system.py,sha256=4ijnn0VPHOIizgjqDGpeD3jVetEscnSDt2E4tIBwkoQ,10888
 pymammotion/mammotion/commands/messages/video.py,sha256=_8lJsU4sLm2CGnc7RDkueA0A51Ysui6x7SqFnhX8O2g,1007
 pymammotion/mammotion/control/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pymammotion/mammotion/control/joystick.py,sha256=QfBVxM_gxpWsZAGO90whtgxCI2tIZ3TTad9wHIPsU9s,5640
 pymammotion/mammotion/devices/__init__.py,sha256=f2qQFPgLGmV85W2hSlMUh5BYuht9o_Ar_JEAAMD4fsE,102
-pymammotion/mammotion/devices/base.py,sha256=zbPpGLP9-0dKZFDt2zgGWtuHwy1h2cXHlR8S2EnpTps,11348
-pymammotion/mammotion/devices/mammotion.py,sha256=mPD8ECsW5AwJdvzuVQBp9QYXjo3YhUxgtP-N8ptthmU,9726
-pymammotion/mammotion/devices/mammotion_bluetooth.py,sha256=3XUjhE2sb_2aZnJlevmwxd99zR_4qZOfaK86h6hKV5E,17303
-pymammotion/mammotion/devices/mammotion_cloud.py,sha256=W0gTdTvqofsL4QxjsVPHcBFYXTlgnzpLwIOAgR2yJA0,9914
+pymammotion/mammotion/devices/base.py,sha256=5k82KHwW2JqZXW-MBYe8SkedZw_bQ2gqShX5RQd_Yio,11504
+pymammotion/mammotion/devices/mammotion.py,sha256=uiKtzLHfVPyk-cdm5gFraI9nkrIX3ZkdZPE7xEyuoTQ,11597
+pymammotion/mammotion/devices/mammotion_bluetooth.py,sha256=sgGeyQeAeA3lQodcalRYS4nDNAzjfFs9SddIB1kadvw,17355
+pymammotion/mammotion/devices/mammotion_cloud.py,sha256=dk49VY9yHO3d-Nb17y-D4YIURs2FTLMzWHUYrxBYhtw,10116
 pymammotion/mqtt/__init__.py,sha256=Ocs5e-HLJvTuDpVXyECEsWIvwsUaxzj7lZ9mSYutNDY,105
 pymammotion/mqtt/mammotion_future.py,sha256=_OWqKOlUGl2yT1xOsXFQYpGd-1zQ63OxqXgy7KRQgYc,710
 pymammotion/mqtt/mammotion_mqtt.py,sha256=QZuqp2G5nywCFSwGNSayPI5JVL789yOxyr0UM0G7wzg,8295
@@ -112,12 +112,12 @@ pymammotion/utility/constant/__init__.py,sha256=tcY0LDeD-qDDHx2LKt55KOyv9ZI0UfCN
 pymammotion/utility/constant/device_constant.py,sha256=rAEK60F52VyJL31uLnq0Y60D-0VK5gVm59yi9kBfndM,7123
 pymammotion/utility/conversions.py,sha256=v3YICy0zZwwBBzrUZgabI7GRfiDBnkiAX2qdtk3NxOY,89
 pymammotion/utility/datatype_converter.py,sha256=SPM_HuaaD_XOawlqEnA8qlRRZXGba3WjA8kGOZgeBlQ,4284
-pymammotion/utility/device_type.py,sha256=6Mmv8oJoJ0DQrfGhRGt3rg20f_GLwIRw4NtpAdF6wcE,9478
+pymammotion/utility/device_type.py,sha256=xOgfIhOkzgcAtoKtlhlB1q8FpiKe1rVVV5BvN7K7zYc,9433
 pymammotion/utility/map.py,sha256=GYscVMg2cX3IPlNpCBNHDW0S55yS1WGRf1iHnNZ7TfQ,2227
 pymammotion/utility/movement.py,sha256=N75oAoAgFydqoaOedYIxGUHmuTCtPzAOtb-d_29tpfI,615
 pymammotion/utility/periodic.py,sha256=MbeSb9cfhxzYmdT_RiE0dZe3H9IfbQW_zSqhmSX2RUc,3321
 pymammotion/utility/rocker_util.py,sha256=6tX7sS87qoQC_tsxbx3NLL-HgS08wtzXiZkhDiz7uo0,7179
-pymammotion-0.2.35.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-pymammotion-0.2.35.dist-info/METADATA,sha256=_VXu85qe7SUTm01E2s-9VVwcoKOZc9cDOuiasv7lUuc,4052
-pymammotion-0.2.35.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-pymammotion-0.2.35.dist-info/RECORD,,
+pymammotion-0.2.36.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+pymammotion-0.2.36.dist-info/METADATA,sha256=oKsEdniFXVqz9dbL-obKVKoZWsKWlS0xDGjaob8n3Lc,4052
+pymammotion-0.2.36.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+pymammotion-0.2.36.dist-info/RECORD,,