pymammotion 0.5.4__tar.gz → 0.5.6__tar.gz

{pymammotion-0.5.4 → pymammotion-0.5.6}/PKG-INFO

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

{pymammotion-0.5.4 → pymammotion-0.5.6}/pymammotion/data/model/device.py

@@ -7,12 +7,14 @@ from mashumaro.mixins.orjson import DataClassORJSONMixin
 
 from pymammotion.data.model import HashList, RapidState
 from pymammotion.data.model.device_info import DeviceFirmwares, DeviceNonWorkingHours, MowerInfo
+from pymammotion.data.model.errors import DeviceErrors
 from pymammotion.data.model.location import Location
 from pymammotion.data.model.report_info import ReportData
 from pymammotion.data.model.work import CurrentTaskSettings
+from pymammotion.data.mqtt.event import ThingEventMessage
 from pymammotion.data.mqtt.properties import ThingPropertiesMessage
 from pymammotion.data.mqtt.status import ThingStatusMessage
-from pymammotion.http.model.http import CheckDeviceVersion, ErrorInfo
+from pymammotion.http.model.http import CheckDeviceVersion
 from pymammotion.proto import DeviceFwInfo, MowToAppInfoT, ReportInfoData, SystemRapidStateTunnelMsg, SystemUpdateBufMsg
 from pymammotion.utility.constant import WorkMode
 from pymammotion.utility.conversions import parse_double
@@ -30,15 +32,14 @@ class MowingDevice(DataClassORJSONMixin):
     mower_state: MowerInfo = field(default_factory=MowerInfo)
     mqtt_properties: ThingPropertiesMessage | None = None
     status_properties: ThingStatusMessage | None = None
+    device_event: ThingEventMessage | None = None
     map: HashList = field(default_factory=HashList)
     work: CurrentTaskSettings = field(default_factory=CurrentTaskSettings)
     location: Location = field(default_factory=Location)
     mowing_state: RapidState = field(default_factory=RapidState)
     report_data: ReportData = field(default_factory=ReportData)
     device_firmwares: DeviceFirmwares = field(default_factory=DeviceFirmwares)
-    err_code_list: list = field(default_factory=list)
-    err_code_list_time: list | None = field(default_factory=list)
-    error_codes: dict[str, ErrorInfo] = field(default_factory=dict)
+    errors: DeviceErrors = field(default_factory=DeviceErrors)
     non_work_hours: DeviceNonWorkingHours = field(default_factory=DeviceNonWorkingHours)
 
     def buffer(self, buffer_list: SystemUpdateBufMsg) -> None:

{pymammotion-0.5.4 → pymammotion-0.5.6}/pymammotion/data/mqtt/properties.py

@@ -125,13 +125,13 @@ ItemTypes = Union[
 
 
 @dataclass
-class Item:
+class Item(DataClassDictMixin):
     time: int
     value: int | float | str | dict[str, Any] | ItemTypes  # Depending on the type of value
 
 
 @dataclass
-class Items:
+class Items(DataClassDictMixin):
     iotState: Item | None = None
     extMod: Item | None = None
     deviceVersionInfo: Item | None = None
@@ -163,12 +163,12 @@ class Items:
 
 @dataclass
 class Params(DataClassORJSONMixin):
-    deviceType: Literal["LawnMower"]
+    deviceType: Literal["LawnMower", "Tracker"]
     checkFailedData: dict
     groupIdList: list[str]
     _tenantId: str
     groupId: str
-    categoryKey: Literal["LawnMower"]
+    categoryKey: Literal["LawnMower", "Tracker"]
     batchId: str
     gmtCreate: int
     productKey: str

{pymammotion-0.5.4 → pymammotion-0.5.6}/pymammotion/data/state_manager.py

@@ -12,6 +12,7 @@ from pymammotion.data.model.device_info import SideLight
 from pymammotion.data.model.enums import ConnectionPreference
 from pymammotion.data.model.hash_list import AreaHashNameList, NavGetCommData, NavGetHashListData, Plan, SvgMessage
 from pymammotion.data.model.work import CurrentTaskSettings
+from pymammotion.data.mqtt.event import ThingEventMessage
 from pymammotion.data.mqtt.properties import ThingPropertiesMessage
 from pymammotion.data.mqtt.status import ThingStatusMessage
 from pymammotion.event.event import DataEvent
@@ -62,6 +63,7 @@ class StateManager:
 
         self.properties_callback = DataEvent()
         self.status_callback = DataEvent()
+        self.device_event_callback = DataEvent()
 
     def get_device(self) -> MowingDevice:
         """Get device."""
@@ -84,6 +86,10 @@ class StateManager:
             self._device.mower_state.product_key = thing_status.params.productKey
         await self.on_status_callback(thing_status)
 
+    async def device_event(self, device_event: ThingEventMessage) -> None:
+        self._device.mqtt_device_event = device_event
+        await self.on_device_event_callback(device_event)
+
     @property
     def online(self) -> bool:
         return self._device.online
@@ -114,6 +120,11 @@ class StateManager:
         if self.status_callback:
             await self.status_callback.data_event(thing_status)
 
+    async def on_device_event_callback(self, device_event: ThingEventMessage) -> None:
+        """Execute the status callback if it is set."""
+        if self.device_event_callback:
+            await self.device_event_callback.data_event(device_event)
+
     async def get_commondata_ack_callback(self, comm_data: NavGetCommDataAck | SvgMessageAckT) -> None:
         """Asynchronously calls the appropriate callback based on available handlers."""
         if self.cloud_get_commondata_ack_callback:

{pymammotion-0.5.4 → pymammotion-0.5.6}/pymammotion/mammotion/devices/mammotion_cloud.py

@@ -31,6 +31,7 @@ class MammotionCloud:
     """Per account MQTT cloud."""
 
     def __init__(self, mqtt_client: MammotionMQTT, cloud_client: CloudIOTGateway) -> None:
+        """Initialize MammotionCloud."""
         self.cloud_client = cloud_client
         self.loop = asyncio.get_event_loop()
         self.is_ready = False
@@ -39,6 +40,7 @@ class MammotionCloud:
         self.mqtt_message_event = DataEvent()
         self.mqtt_properties_event = DataEvent()
         self.mqtt_status_event = DataEvent()
+        self.mqtt_device_event = DataEvent()
         self.on_ready_event = DataEvent()
         self.on_disconnected_event = DataEvent()
         self.on_connected_event = DataEvent()
@@ -49,9 +51,6 @@ class MammotionCloud:
         self._mqtt_client.on_message = self._on_mqtt_message
         self._mqtt_client.on_ready = self.on_ready
 
-        # temporary for testing only
-        # self._start_sync_task = self.loop.call_later(30, lambda: asyncio.ensure_future(self.start_sync(0)))
-
     async def on_ready(self) -> None:
         loop = asyncio.get_event_loop()
         loop.create_task(self.process_queue())
@@ -129,6 +128,8 @@ class MammotionCloud:
                 _LOGGER.debug("Protobuf event")
                 # Call the callbacks for each cloudDevice
                 await self.mqtt_message_event.data_event(event)
+            if event.method == "thing.events":
+                await self.mqtt_device_event.data_event(event)
             if event.method == "thing.properties":
                 await self.mqtt_properties_event.data_event(event)
                 _LOGGER.debug(event)
@@ -170,6 +171,7 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
         self._mqtt.mqtt_message_event.add_subscribers(self._parse_message_for_device)
         self._mqtt.mqtt_properties_event.add_subscribers(self._parse_message_properties_for_device)
         self._mqtt.mqtt_status_event.add_subscribers(self._parse_message_status_for_device)
+        self._mqtt.mqtt_device_event.add_subscribers(self._parse_device_event_for_device)
         self._mqtt.on_ready_event.add_subscribers(self.on_ready)
         self._mqtt.on_disconnected_event.add_subscribers(self.on_disconnect)
         self._mqtt.on_connected_event.add_subscribers(self.on_connect)
@@ -188,6 +190,7 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
         self._mqtt.mqtt_message_event.remove_subscribers(self._parse_message_for_device)
         self._mqtt.mqtt_properties_event.remove_subscribers(self._parse_message_properties_for_device)
         self._mqtt.mqtt_status_event.remove_subscribers(self._parse_message_status_for_device)
+        self._mqtt.mqtt_device_event.remove_subscribers(self._parse_device_event_for_device)
         self._state_manager.cloud_gethash_ack_callback = None
         self._state_manager.cloud_get_commondata_ack_callback = None
         self._state_manager.cloud_get_plan_callback = None
@@ -319,6 +322,11 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
             return
         await self.state_manager.status(status)
 
+    async def _parse_device_event_for_device(self, status: ThingStatusMessage) -> None:
+        if status.params.iotId != self.iot_id:
+            return
+        await self.state_manager.device_event(status)
+
     async def _parse_message_for_device(self, event: ThingEventMessage) -> None:
         params = event.params
         new_msg = LubaMsg()

{pymammotion-0.5.4 → pymammotion-0.5.6}/pymammotion/mqtt/linkkit/linkkit.py

@@ -713,7 +713,7 @@ UxeCp6
         self.__on_ota_message_arrived = None
 
         if self.__just_for_pycharm_autocomplete:
-            self.__mqtt_client = mqtt.Client(CallbackAPIVersion.VERSION2)
+            self.__mqtt_client = mqtt.Client(CallbackAPIVersion.VERSION1)
 
         # device interface info
         self.__device_info_topic = "/sys/%s/%s/thing/deviceinfo/update" % (self.__product_key, self.__device_name)
@@ -1311,10 +1311,7 @@ UxeCp6
         elif self.__mqtt_protocol == "MQTTv31":
             mqtt_protocol_version = mqtt.MQTTv31
         self.__mqtt_client = mqtt.Client(
-            callback_api_version=CallbackAPIVersion.VERSION2,
-            client_id=client_id,
-            clean_session=self.__mqtt_clean_session,
-            protocol=mqtt_protocol_version,
+            client_id=client_id, clean_session=self.__mqtt_clean_session, protocol=mqtt_protocol_version
         )
 
         if self.__link_log.is_enabled():
@@ -1570,13 +1567,13 @@ UxeCp6
             else:
                 return 1, None
 
-    def __on_internal_connect_safe(self, client, userdata, flags, reason_code, properties) -> None:
-        if reason_code == 0:
+    def __on_internal_connect_safe(self, client, user_data, session_flag, rc) -> None:
+        if rc == 0:
             self.__reset_reconnect_wait()
             self.__force_reconnect = False
-        session_flag_internal = {"session present": flags}
+        session_flag_internal = {"session present": session_flag}
         self.__handler_task.post_message(
-            self.__handler_task_cmd_on_connect, (client, userdata, session_flag_internal, reason_code, properties)
+            self.__handler_task_cmd_on_connect, (client, user_data, session_flag_internal, rc)
         )
 
     def __loop_forever_internal(self):
@@ -1609,7 +1606,7 @@ UxeCp6
         except ssl.SSLError as e:
             self.__link_log.error("config mqtt raise exception:" + str(e))
             self.__linkkit_state = LinkKit.LinkKitState.INITIALIZED
-            self.__on_internal_connect_safe(None, None, 0, 6, {})
+            self.__on_internal_connect_safe(None, None, 0, 6)
             return
 
         try:
@@ -1619,7 +1616,7 @@ UxeCp6
         except Exception as e:
             self.__link_log.error("__loop_forever_internal connect raise exception:" + str(e))
             self.__linkkit_state = LinkKit.LinkKitState.INITIALIZED
-            self.__on_internal_connect_safe(None, None, 0, 7, {})
+            self.__on_internal_connect_safe(None, None, 0, 7)
             return
         while True:
             if self.__worker_loop_exit_req:
@@ -1642,7 +1639,7 @@ UxeCp6
                 #     return
                 if self.__linkkit_state == LinkKit.LinkKitState.CONNECTING:
                     self.__linkkit_state = LinkKit.LinkKitState.DISCONNECTED
-                self.__on_internal_connect_safe(None, None, 0, 9, {})
+                self.__on_internal_connect_safe(None, None, 0, 9)
                 if self.__linkkit_state == LinkKit.LinkKitState.DESTRUCTING:
                     self.__handler_task.stop()
                     self.__linkkit_state = LinkKit.LinkKitState.DESTRUCTED
@@ -1664,7 +1661,7 @@ UxeCp6
                     break
 
             if self.__linkkit_state == LinkKit.LinkKitState.CONNECTED:
-                self.__on_internal_disconnect(None, None, 1, {})
+                self.__on_internal_disconnect(None, None, 1)
             self.__link_log.info("loop return:%r" % rc)
 
             if self.__worker_loop_exit_req:
@@ -2539,25 +2536,23 @@ UxeCp6
         client, user_data, message = value
         self.__on_internal_async_message(message)
 
-    def __on_internal_connect(self, client, userdata, flags, reason_code, properties) -> None:
+    def __on_internal_connect(self, client, user_data, session_flag, rc) -> None:
         self.__link_log.info("__on_internal_connect")
-        if reason_code == 0:
+        if rc == 0:
             self.__reset_reconnect_wait()
             # self.__upload_device_interface_info()
-            self.__handler_task.post_message(
-                self.__handler_task_cmd_on_connect, (client, userdata, flags, reason_code, properties)
-            )
+            self.__handler_task.post_message(self.__handler_task_cmd_on_connect, (client, user_data, session_flag, rc))
 
     def __handler_task_on_connect_callback(self, value) -> None:
-        client, userdata, flags, reason_code = value
+        client, user_data, session_flag, rc = value
         self.__link_log.info("__on_internal_connect enter")
-        self.__link_log.debug("session:%d, return code:%d" % (flags["session present"], reason_code))
+        self.__link_log.debug("session:%d, return code:%d" % (session_flag["session present"], rc))
         if rc == 0:
             self.__linkkit_state = LinkKit.LinkKitState.CONNECTED
             # self.__worker_thread.start()
         if self.__on_connect is not None:
             try:
-                self.__on_connect(flags["session present"], reason_code, self.__user_data)
+                self.__on_connect(session_flag["session present"], rc, self.__user_data)
             except Exception as e:
                 self.__link_log.error("on_connect process raise exception:%r" % e)
         if self.__thing_setup_state:
@@ -2565,7 +2560,7 @@ UxeCp6
             if self.__on_thing_enable:
                 self.__on_thing_enable(self.__user_data)
 
-    def __on_internal_disconnect(self, client, userdata, flags, reason_code, properties) -> None:
+    def __on_internal_disconnect(self, client, user_data, rc) -> None:
         self.__link_log.info("__on_internal_disconnect enter")
         if self.__linkkit_state == LinkKit.LinkKitState.DESTRUCTING:
             self.__linkkit_state = LinkKit.LinkKitState.DESTRUCTED
@@ -2598,15 +2593,13 @@ UxeCp6
         self.__device_info_mid.clear()
         self.__thing_update_device_info_up_mid.clear()
         self.__thing_delete_device_info_up_mid.clear()
-        self.__handler_task.post_message(
-            self.__handler_task_cmd_on_disconnect, (client, userdata, reason_code, properties)
-        )
+        self.__handler_task.post_message(self.__handler_task_cmd_on_disconnect, (client, user_data, rc))
         if self.__linkkit_state == LinkKit.LinkKitState.DESTRUCTED:
             self.__handler_task.stop()
 
     def __handler_task_on_disconnect_callback(self, value) -> None:
         self.__link_log.info("__handler_task_on_disconnect_callback enter")
-        client, userdata, reason_code = value
+        client, user_data, rc = value
         if self.__thing_setup_state:
             if self.__thing_enable_state:
                 self.__thing_enable_state = False
@@ -2617,7 +2610,7 @@ UxeCp6
                         self.__link_log.error("on_thing_disable process raise exception:%r" % e)
         if self.__on_disconnect is not None:
             try:
-                self.__on_disconnect(reason_code, self.__user_data)
+                self.__on_disconnect(rc, self.__user_data)
             except Exception as e:
                 self.__link_log.error("on_disconnect process raise exception:%r" % e)
 

{pymammotion-0.5.4 → pymammotion-0.5.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name        = "pymammotion"
-version     = "0.5.4"
+version     = "0.5.6"
 license     = "GPL-3.0"
 description = ""
 readme      = "README.md"
@@ -66,7 +66,7 @@ autotyping = "^24.3.0"
 ipython = "^9.0.2"
 
 [tool.bumpver]
-current_version = "0.5.4"
+current_version = "0.5.6"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit_message  = "Bump version {old_version} -> {new_version}"
 commit          = true