pymammotion 0.5.34__py3-none-any.whl → 0.5.44__py3-none-any.whl

pymammotion/data/model/hash_list.py

@@ -4,6 +4,7 @@ from enum import IntEnum
 from mashumaro.mixins.orjson import DataClassORJSONMixin
 
 from pymammotion.proto import NavGetCommDataAck, NavGetHashListAck, SvgMessageAckT
+from pymammotion.utility.mur_mur_hash import MurMurHashUtil
 
 
 class PathType(IntEnum):
@@ -28,6 +29,13 @@ class AreaLabelName(DataClassORJSONMixin):
     label: str = ""
 
 
+@dataclass
+class NavNameTime(DataClassORJSONMixin):
+    name: str = ""
+    create_time: int = 0
+    modify_time: int = 0
+
+
 @dataclass
 class NavGetCommData(DataClassORJSONMixin):
     pver: int = 0
@@ -44,7 +52,35 @@ class NavGetCommData(DataClassORJSONMixin):
     data_len: int = 0
     data_couple: list["CommDataCouple"] = field(default_factory=list)
     reserved: str = ""
-    area_label: "AreaLabelName" = field(default_factory=AreaLabelName)
+    name_time: NavNameTime = field(default_factory=NavNameTime)
+
+
+@dataclass
+class MowPathPacket(DataClassORJSONMixin):
+    path_hash: int = 0
+    path_type: int = 0
+    path_total: int = 0
+    path_cur: int = 0
+    zone_hash: int = 0
+    data_couple: list["CommDataCouple"] = field(default_factory=list)
+
+
+@dataclass
+class MowPath(DataClassORJSONMixin):
+    pver: int = 0
+    sub_cmd: int = 0
+    result: int = 0
+    area: int = 0
+    time: int = 0
+    total_frame: int = 0
+    current_frame: int = 0
+    total_path_num: int = 0
+    valid_path_num: int = 0
+    data_hash: int = 0
+    transaction_id: int = 0
+    reserved: list[int] = field(default_factory=list)
+    data_len: int = 0
+    path_packets: list[MowPathPacket] = field(default_factory=list)
 
 
 @dataclass
@@ -172,13 +208,24 @@ class HashList(DataClassORJSONMixin):
     line: dict[int, FrameList] = field(default_factory=dict)  # type 10 possibly breakpoint? / sub cmd 3
     plan: dict[str, Plan] = field(default_factory=dict)
     area_name: list[AreaHashNameList] = field(default_factory=list)
+    current_mow_path: dict[int, MowPath] = field(default_factory=dict)
 
-    def update_hash_lists(self, hashlist: list[int]) -> None:
+    def update_hash_lists(self, hashlist: list[int], bol_hash: str | None = None) -> None:
+        if bol_hash:
+            self.invalidate_maps(int(bol_hash))
         self.area = {hash_id: frames for hash_id, frames in self.area.items() if hash_id in hashlist}
         self.path = {hash_id: frames for hash_id, frames in self.path.items() if hash_id in hashlist}
         self.obstacle = {hash_id: frames for hash_id, frames in self.obstacle.items() if hash_id in hashlist}
         self.dump = {hash_id: frames for hash_id, frames in self.dump.items() if hash_id in hashlist}
         self.svg = {hash_id: frames for hash_id, frames in self.svg.items() if hash_id in hashlist}
+
+        area_hashes = list(self.area.keys())
+        for hash_id, plan_task in self.plan.copy().items():
+            for item in plan_task.zone_hashs:
+                if item not in area_hashes:
+                    self.plan.pop(hash_id)
+                    break
+
         self.area_name = [
             area_item
             for area_item in self.area_name
@@ -259,61 +306,90 @@ class HashList(DataClassORJSONMixin):
         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))
-
-        if hash_data.type == PathType.OBSTACLE:
-            return self.find_missing_frames(self.obstacle.get(hash_data.hash))
+        frame_list = self._get_frame_list_by_type_and_hash(hash_data)
+        return self.find_missing_frames(frame_list)
 
-        if hash_data.type == PathType.PATH:
-            return self.find_missing_frames(self.path.get(hash_data.hash))
+    def _get_frame_list_by_type_and_hash(self, hash_data: NavGetCommDataAck | SvgMessageAckT) -> FrameList | None:
+        """Get the appropriate FrameList based on hash_data type and hash."""
+        path_type_mapping = self._get_path_type_mapping()
+        target_dict = path_type_mapping.get(hash_data.type)
 
-        if hash_data.type == PathType.LINE:
-            return self.find_missing_frames(self.line.get(hash_data.hash))
+        if target_dict is None:
+            return None
 
-        if hash_data.type == PathType.DUMP:
-            return self.find_missing_frames(self.dump.get(hash_data.hash))
+        # Handle SvgMessage with data_hash attribute
+        if isinstance(hash_data, SvgMessageAckT):
+            return target_dict.get(hash_data.data_hash)
 
-        if hash_data.type == PathType.SVG:
-            return self.find_missing_frames(self.svg.get(hash_data.data_hash))
-
-        return []
+        # Handle NavGetCommDataAck with hash attribute
+        return target_dict.get(hash_data.hash)
 
     def update_plan(self, plan: Plan) -> None:
         if plan.total_plan_num != 0:
             self.plan[plan.plan_id] = plan
 
+    def _get_path_type_mapping(self) -> dict[int, dict[int, FrameList]]:
+        """Return mapping of PathType to corresponding hash dictionary."""
+        return {
+            PathType.AREA: self.area,
+            PathType.OBSTACLE: self.obstacle,
+            PathType.PATH: self.path,
+            PathType.LINE: self.line,
+            PathType.DUMP: self.dump,
+            PathType.SVG: self.svg,
+        }
+
     def update(self, hash_data: NavGetCommData | SvgMessage) -> bool:
         """Update the map data."""
 
-        if hash_data.type == PathType.AREA:
+        if hash_data.type == PathType.AREA and isinstance(hash_data, NavGetCommData):
             existing_name = next((area for area in self.area_name if area.hash == hash_data.hash), None)
             if not existing_name:
-                name = f"area {len(self.area_name)+1}" if hash_data.area_label is None else hash_data.area_label.label
+                name = f"area {len(self.area_name)+1}"
                 self.area_name.append(AreaHashNameList(name=name, hash=hash_data.hash))
             result = self._add_hash_data(self.area, hash_data)
             self.update_hash_lists(self.hashlist)
             return result
 
-        if hash_data.type == PathType.OBSTACLE:
-            return self._add_hash_data(self.obstacle, hash_data)
+        path_type_mapping = self._get_path_type_mapping()
+        target_dict = path_type_mapping.get(hash_data.type)
 
-        if hash_data.type == PathType.PATH:
-            return self._add_hash_data(self.path, hash_data)
+        if target_dict is not None:
+            return self._add_hash_data(target_dict, hash_data)
 
-        if hash_data.type == PathType.LINE:
-            return self._add_hash_data(self.line, hash_data)
+        return False
 
-        if hash_data.type == PathType.DUMP:
-            return self._add_hash_data(self.dump, hash_data)
+    def find_missing_mow_path_frames(self) -> list[int]:
+        """Find missing frames in current_mow_path based on total_frame."""
+        if not self.current_mow_path:
+            return []
 
-        if hash_data.type == PathType.SVG:
-            return self._add_hash_data(self.svg, hash_data)
+        # Get total_frame from any MowPath object (they should all have the same total_frame)
+        total_frame = next(iter(self.current_mow_path.values())).total_frame
 
-        return False
+        if total_frame == 0:
+            return []
+
+        if total_frame == len(self.current_mow_path):
+            return []
+
+        # Generate list of expected frame numbers (1 to total_frame)
+        expected_frames = set(range(1, total_frame + 1))
+
+        # Get current frame numbers from dictionary keys
+        current_frames = set(self.current_mow_path.keys())
+
+        # Return sorted list of missing frames
+        missing_frames = sorted(expected_frames - current_frames)
+        return missing_frames
+
+    def update_mow_path(self, path: MowPath) -> None:
+        """Update the current_mow_path with the latest MowPath data."""
+        # TODO check if we need to clear the current_mow_path first
+        self.current_mow_path[path.current_frame] = path
 
     @staticmethod
-    def find_missing_frames(frame_list: FrameList | RootHashList) -> list[int]:
+    def find_missing_frames(frame_list: FrameList | RootHashList | None) -> list[int]:
         if frame_list is None:
             return []
 
@@ -328,7 +404,7 @@ class HashList(DataClassORJSONMixin):
     @staticmethod
     def _add_hash_data(hash_dict: dict[int, FrameList], hash_data: NavGetCommData | SvgMessage) -> bool:
         if isinstance(hash_data, SvgMessage):
-            if hash_dict.get(hash_data.data_hash) is None:
+            if hash_dict.get(hash_data.data_hash, None) is None:
                 hash_dict[hash_data.data_hash] = FrameList(total_frame=hash_data.total_frame, data=[hash_data])
                 return True
 
@@ -347,7 +423,7 @@ class HashList(DataClassORJSONMixin):
                 return True
             return False
 
-        if hash_dict.get(hash_data.hash) is None:
+        if hash_dict.get(hash_data.hash, None) is None:
             hash_dict[hash_data.hash] = FrameList(total_frame=hash_data.total_frame, data=[hash_data])
             return True
 
@@ -361,3 +437,7 @@ class HashList(DataClassORJSONMixin):
             hash_dict[hash_data.hash].data.append(hash_data)
             return True
         return False
+
+    def invalidate_maps(self, bol_hash: int) -> None:
+        if MurMurHashUtil.hash_unsigned_list(self.hashlist) != bol_hash:
+            self.root_hash_lists = []

pymammotion/data/model/region_data.py

@@ -6,13 +6,13 @@ from mashumaro.mixins.orjson import DataClassORJSONMixin
 @dataclass
 class RegionData(DataClassORJSONMixin):
     def __init__(self) -> None:
-        self.hash: int | None = None
+        self.hash: int = 0
         self.action: int = 0
         self.current_frame: int = 0
-        self.data_hash: int | None = None
+        self.data_hash: int = 0
         self.data_len: int = 0
-        self.p_hash_a: int | None = None
-        self.p_hash_b: int | None = None
+        self.p_hash_a: int = 0
+        self.p_hash_b: int = 0
         self.path: list[list[float]] | None = None
         self.pver: int = 0
         self.result: int = 0

pymammotion/data/{state_manager.py → mower_state_manager.py}

@@ -9,8 +9,14 @@ import betterproto2
 
 from pymammotion.data.model.device import MowingDevice
 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.hash_list import (
+    AreaHashNameList,
+    MowPath,
+    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
@@ -20,6 +26,7 @@ from pymammotion.proto import (
     AppGetAllAreaHashName,
     AppGetCutterWorkMode,
     AppSetCutterWorkMode,
+    CoverPathUploadT,
     DeviceFwInfo,
     DeviceProductTypeInfoT,
     DrvDevInfoResp,
@@ -41,14 +48,13 @@ from pymammotion.proto import (
 logger = logging.getLogger(__name__)
 
 
-class StateManager:
+class MowerStateManager:
     """Manage state."""
 
     def __init__(self, device: MowingDevice) -> None:
         """Initialize state manager with a device."""
         self._device: MowingDevice = device
         self.last_updated_at = datetime.now(UTC)
-        self.preference = ConnectionPreference.WIFI
         self.cloud_gethash_ack_callback: Callable[[NavGetHashListAck], Awaitable[None]] | None = None
         self.cloud_get_commondata_ack_callback: (
             Callable[[NavGetCommDataAck | SvgMessageAckT], Awaitable[None]] | None
@@ -132,7 +138,7 @@ class StateManager:
             await self.status_callback.data_event(thing_status)
 
     async def on_device_event_callback(self, device_event: ThingEventMessage) -> None:
-        """Executes the status callback if it is set."""
+        """Executes the event callback if it is set."""
         if self.device_event_callback:
             await self.device_event_callback.data_event(device_event)
 
@@ -191,6 +197,10 @@ class StateManager:
                 )
                 if updated:
                     await self.get_commondata_ack_callback(common_data)
+            case "cover_path_upload":
+                mow_path: CoverPathUploadT = nav_msg[1]
+                self._device.map.update_mow_path(MowPath.from_dict(mow_path.to_dict(casing=betterproto2.Casing.SNAKE)))
+
             case "todev_planjob_set":
                 planjob: NavPlanJobSet = nav_msg[1]
                 self._device.map.update_plan(Plan.from_dict(planjob.to_dict(casing=betterproto2.Casing.SNAKE)))
@@ -263,8 +273,8 @@ class StateManager:
                 self._device.mower_state.cutter_mode = cutter_work_mode.current_cutter_mode
                 self._device.mower_state.cutter_rpm = cutter_work_mode.current_cutter_rpm
             case "cutter_mode_ctrl_by_hand":
-                cutter_work_mode: AppSetCutterWorkMode = driver_msg[1]
-                self._device.mower_state.cutter_mode = cutter_work_mode.cutter_mode
+                cutter_work_mode_set: AppSetCutterWorkMode = driver_msg[1]
+                self._device.mower_state.cutter_mode = cutter_work_mode_set.cutter_mode
 
     def _update_net_data(self, message) -> None:
         """Update network data."""

pymammotion/data/mqtt/event.py

@@ -1,10 +1,10 @@
 from base64 import b64decode
 from dataclasses import dataclass
-from typing import Any, Literal
+from typing import Annotated, Any, Literal
 
 from google.protobuf import json_format
 from mashumaro.mixins.orjson import DataClassORJSONMixin
-from mashumaro.types import SerializableType
+from mashumaro.types import Alias, SerializableType
 
 from pymammotion.proto import luba_msg_pb2
 
@@ -73,34 +73,35 @@ class DeviceBizReqEventValue(DataClassORJSONMixin):
 
 @dataclass
 class GeneralParams(DataClassORJSONMixin):
-    groupIdList: list[str]
-    groupId: str
-    categoryKey: Literal["LawnMower", "Tracker"]
-    batchId: str
-    gmtCreate: int
-    productKey: str
+    group_id_list: Annotated[list[str], Alias("groupIdList")]
+    group_id: Annotated[str, Alias("groupId")]
+    category_key: Annotated[Literal["LawnMower", "Tracker"], Alias("categoryKey")]
+    batch_id: Annotated[str, Alias("batchId")]
+    gmt_create: Annotated[int, Alias("gmtCreate")]
+    product_key: Annotated[str, Alias("productKey")]
     type: str
-    deviceName: str
-    iotId: str
-    checkLevel: int
+    device_name: Annotated[str, Alias("deviceName")]
+    iot_id: Annotated[str, Alias("iotId")]
+    check_level: Annotated[int, Alias("checkLevel")]
     namespace: str
-    tenantId: str
+    tenant_id: Annotated[str, Alias("tenantId")]
     name: str
-    thingType: Literal["DEVICE"]
+    thing_type: Annotated[Literal["DEVICE"], Alias("thingType")]
     time: int
-    tenantInstanceId: str
+    tenant_instance_id: Annotated[str, Alias("tenantInstanceId")]
     value: Any
 
+    # Optional fields
     identifier: str | None = None
-    checkFailedData: dict | None = None
-    _tenantId: str | None = None
-    generateTime: int | None = None
-    JMSXDeliveryCount: int | None = None
+    check_failed_data: Annotated[dict | None, Alias("checkFailedData")] = None
+    _tenant_id: Annotated[str | None, Alias("_tenantId")] = None
+    generate_time: Annotated[int | None, Alias("generateTime")] = None
+    jmsx_delivery_count: Annotated[int | None, Alias("JMSXDeliveryCount")] = None
     qos: int | None = None
-    requestId: str | None = None
-    _categoryKey: str | None = None
-    deviceType: str | None = None
-    _traceId: str | None = None
+    request_id: Annotated[str | None, Alias("requestId")] = None
+    _category_key: Annotated[str | None, Alias("_categoryKey")] = None
+    device_type: Annotated[str | None, Alias("deviceType")] = None
+    _trace_id: Annotated[str | None, Alias("_traceId")] = None
 
 
 @dataclass
@@ -196,3 +197,27 @@ class ThingEventMessage(DataClassORJSONMixin):
             raise ValueError(f"Unknown identifier: {identifier} {params_dict}")
 
         return cls(method=method, id=event_id, params=params_obj, version=version)
+
+
+@dataclass
+class MammotionProtoMsgParams(DataClassORJSONMixin, SerializableType):
+    value: DeviceProtobufMsgEventValue
+    iot_id: str = ""
+    product_key: str = ""
+    device_name: str = ""
+
+    @classmethod
+    def _deserialize(cls, d: dict[str, Any]) -> "MammotionProtoMsgParams":
+        """Override from_dict to allow dict manipulation before conversion."""
+        proto: str = d["content"]
+
+        return cls(value=DeviceProtobufMsgEventValue(content=proto))
+
+
+@dataclass
+class MammotionEventMessage(DataClassORJSONMixin):
+    id: str
+    version: str
+    sys: dict
+    params: MammotionProtoMsgParams
+    method: str

pymammotion/data/mqtt/mammotion_properties.py

@@ -0,0 +1,257 @@
+from dataclasses import dataclass
+from typing import Annotated
+
+from mashumaro.config import BaseConfig
+from mashumaro.mixins.orjson import DataClassORJSONMixin
+from mashumaro.types import Alias
+
+
+@dataclass
+class FirmwareInfo(DataClassORJSONMixin):
+    t: str
+    c: str
+    v: str
+
+
+@dataclass
+class DeviceVersionInfo(DataClassORJSONMixin):
+    dev_ver: Annotated[str, Alias("devVer")]
+    whole: int
+    fw_info: Annotated[list[FirmwareInfo], Alias("fwInfo")]
+
+
+@dataclass
+class Coordinate(DataClassORJSONMixin):
+    lon: float
+    lat: float
+
+
+@dataclass
+class InternalNavigation(DataClassORJSONMixin):
+    nav: Annotated[str, Alias("NAV")]
+    pau: Annotated[str, Alias("Pau")]
+    r_pau: Annotated[str, Alias("rPau")]
+    mcu: Annotated[str, Alias("MCU")]
+    app: Annotated[str, Alias("APP")]
+    w_slp: Annotated[str, Alias("wSlp")]
+    i_slp: Annotated[str, Alias("iSlp")]
+
+
+@dataclass
+class BandwidthTraffic(DataClassORJSONMixin):
+    iot: Annotated[str, Alias("IoT")]
+    roi: Annotated[str, Alias("RoI")]
+    fpv: Annotated[str, Alias("FPV")]
+    inav: InternalNavigation
+
+
+@dataclass
+class TrafficPeriod(DataClassORJSONMixin):
+    r: str
+    t: str
+    s: str
+
+
+@dataclass
+class TrafficData(DataClassORJSONMixin):
+    upt: str
+    hour: Annotated[dict[str, TrafficPeriod], Alias("Hour")]
+    day: Annotated[dict[str, TrafficPeriod], Alias("Day")]
+    mon: Annotated[dict[str, TrafficPeriod], Alias("Mon")]
+
+
+@dataclass
+class NetworkInfo(DataClassORJSONMixin):
+    ssid: str
+    ip: str
+    wifi_sta_mac: str
+    wifi_rssi: int
+    wifi_available: int
+    bt_mac: str
+    mnet_model: str
+    imei: str
+    fw_ver: str
+    sim: str
+    imsi: str
+    iccid: str
+    sim_source: str
+    mnet_rssi: int
+    signal: int
+    mnet_link: int
+    mnet_option: str
+    mnet_ip: str
+    mnet_reg: str
+    mnet_rsrp: str
+    mnet_snr: str
+    mnet_enable: int
+    apn_num: int
+    apn_info: str
+    apn_cid: int
+    used_net: int
+    hub_reset: int
+    mnet_dis: int
+    airplane_times: int
+    lsusb_num: int
+    b_tra: Annotated[BandwidthTraffic, Alias("bTra")]
+    bw_tra: Annotated[BandwidthTraffic, Alias("bwTra")]
+    mnet_rx: str
+    mnet_tx: str
+    m_tra: Annotated[TrafficData, Alias("mTra")]
+    mnet_uniot: int
+    mnet_un_getiot: int
+    ssh_flag: str
+    mileage: str
+    work_time: str
+    wt_sec: int
+    bat_cycles: str
+
+
+@dataclass
+class DeviceOtherInfo(DataClassORJSONMixin):
+    soc_up_time: Annotated[int, Alias("socUpTime")]
+    mcu_up_time: Annotated[int, Alias("mcuUpTime")]
+    soc_loads: Annotated[str, Alias("socLoads")]
+    soc_mem_free: Annotated[int, Alias("socMemFree")]
+    soc_mem_total: Annotated[int, Alias("socMemTotal")]
+    soc_mmc_life_time: Annotated[int, Alias("socMmcLifeTime")]
+    usb_dis_cnt: Annotated[int, Alias("usbDisCnt")]
+    soc_pstore: Annotated[int, Alias("socPstore")]
+    soc_coredump: Annotated[int, Alias("socCoredump")]
+    soc_tmp: Annotated[int, Alias("socTmp")]
+    mc_mcu: Annotated[str, Alias("mcMcu")]
+    tilt_degree: str
+    i_msg_free: Annotated[int, Alias("iMsgFree")]
+    i_msg_limit: Annotated[int, Alias("iMsgLimit")]
+    i_msg_raw: Annotated[int, Alias("iMsgRaw")]
+    i_msg_prop: Annotated[int, Alias("iMsgprop")]
+    i_msg_serv: Annotated[int, Alias("iMsgServ")]
+    i_msg_info: Annotated[int, Alias("iMsgInfo")]
+    i_msg_warn: Annotated[int, Alias("iMsgWarn")]
+    i_msg_fault: Annotated[int, Alias("iMsgFault")]
+    i_msg_ota_stage: Annotated[int, Alias("iMsgOtaStage")]
+    i_msg_protobuf: Annotated[int, Alias("iMsgProtobuf")]
+    i_msg_notify: Annotated[int, Alias("iMsgNotify")]
+    i_msg_log_prog: Annotated[int, Alias("iMsgLogProg")]
+    i_msg_biz_req: Annotated[int, Alias("iMsgBizReq")]
+    i_msg_cfg_req: Annotated[int, Alias("iMsgCfgReq")]
+    i_msg_voice: Annotated[int, Alias("iMsgVoice")]
+    i_msg_warn_code: Annotated[int, Alias("iMsgWarnCode")]
+    pb_net: Annotated[int, Alias("pbNet")]
+    pb_sys: Annotated[int, Alias("pbSys")]
+    pb_nav: Annotated[int, Alias("pbNav")]
+    pb_local: Annotated[int, Alias("pbLocal")]
+    pb_plan: Annotated[int, Alias("pbPlan")]
+    pb_e_drv: Annotated[int, Alias("pbEDrv")]
+    pb_e_sys: Annotated[int, Alias("pbESys")]
+    pb_midware: Annotated[int, Alias("pbMidware")]
+    pb_ota: Annotated[int, Alias("pbOta")]
+    pb_appl: Annotated[int, Alias("pbAppl")]
+    pb_mul: Annotated[int, Alias("pbMul")]
+    pb_other: Annotated[int, Alias("pbOther")]
+    lora_connect: Annotated[int, Alias("loraConnect")]
+    base_status: Annotated[int, Alias("Basestatus")]
+    mqtt_rtk_switch: int
+    mqtt_rtk_channel: int
+    mqtt_rtk_status: int
+    mqtt_rtcm_cnt: int
+    mqtt_conn_cnt: int
+    mqtt_disconn_cnt: int
+    mqtt_rtk_hb_flag: int
+    mqtt_rtk_hb_count: int
+    mqtt_start_cnt: int
+    mqtt_close_cnt: int
+    mqtt_rtk_ssl_fail: int
+    mqtt_rtk_wifi_config: int
+    nrtk_svc_prov: int
+    nrtk_svc_err: int
+    base_stn_id: int
+    rtk_status: int
+    charge_status: int
+    chassis_state: int
+    nav: str
+    ins_fusion: str
+    perception: str
+    vision_proxy: str
+    vslam_vio: str
+    iot_con_timeout: int
+    iot_con: int
+    iot_con_fail_max: str
+    iot_con_fail_min: Annotated[str, Alias("iot_con__fail_min")]
+    iot_url_count: int
+    iot_url_max: str
+    iot_url_min: str
+    iot_cn: int
+    iot_ap: int
+    iot_us: int
+    iot_eu: int
+    task_area: float
+    task_count: int
+    task_hash: str
+    systemio_boot_time: Annotated[str, Alias("systemioBootTime")]
+    dds_no_gdc: int
+
+
+@dataclass
+class CheckData(DataClassORJSONMixin):
+    result: str
+    error: Annotated[list[int], Alias("Error")]
+    warn: Annotated[list[int], Alias("Warn")]
+    ok: Annotated[list[int], Alias("OK")]
+
+
+@dataclass
+class DeviceProperties(DataClassORJSONMixin):
+    device_state: Annotated[int, Alias("deviceState")]
+    battery_percentage: Annotated[int, Alias("batteryPercentage")]
+    device_version: Annotated[str, Alias("deviceVersion")]
+    knife_height: Annotated[int, Alias("knifeHeight")]
+    lora_general_config: Annotated[str, Alias("loraGeneralConfig")]
+    ext_mod: Annotated[str, Alias("extMod")]
+    int_mod: Annotated[str, Alias("intMod")]
+    iot_state: Annotated[int, Alias("iotState")]
+    iot_msg_total: Annotated[int, Alias("iotMsgTotal")]
+    iot_msg_hz: Annotated[int, Alias("iotMsgHz")]
+    lt_mr_mod: Annotated[str, Alias("ltMrMod")]
+    rt_mr_mod: Annotated[str, Alias("rtMrMod")]
+    bms_hardware_version: Annotated[str, Alias("bmsHardwareVersion")]
+    stm32_h7_version: Annotated[str, Alias("stm32H7Version")]
+    left_motor_version: Annotated[str, Alias("leftMotorVersion")]
+    right_motor_version: Annotated[str, Alias("rightMotorVersion")]
+    rtk_version: Annotated[str, Alias("rtkVersion")]
+    bms_version: Annotated[str, Alias("bmsVersion")]
+    mc_boot_version: Annotated[str, Alias("mcBootVersion")]
+    left_motor_boot_version: Annotated[str, Alias("leftMotorBootVersion")]
+    right_motor_boot_version: Annotated[str, Alias("rightMotorBootVersion")]
+
+    # Nested JSON objects
+    device_version_info: Annotated[DeviceVersionInfo, Alias("deviceVersionInfo")]
+    coordinate: Coordinate
+    device_other_info: Annotated[DeviceOtherInfo, Alias("deviceOtherInfo")]
+    network_info: Annotated[NetworkInfo, Alias("networkInfo")]
+    check_data: Annotated[CheckData, Alias("checkData")]
+    iot_id: str = ""
+
+    class Config(BaseConfig):
+        # Custom deserializer for nested JSON strings
+        serialization_strategy = {
+            DeviceVersionInfo: {
+                "deserialize": lambda x: DeviceVersionInfo.from_json(x) if isinstance(x, str) else x,
+                "serialize": lambda x: x.to_json() if hasattr(x, "to_json") else x,
+            },
+            Coordinate: {
+                "deserialize": lambda x: Coordinate.from_json(x) if isinstance(x, str) else x,
+                "serialize": lambda x: x.to_json() if hasattr(x, "to_json") else x,
+            },
+            DeviceOtherInfo: {
+                "deserialize": lambda x: DeviceOtherInfo.from_json(x) if isinstance(x, str) else x,
+                "serialize": lambda x: x.to_json() if hasattr(x, "to_json") else x,
+            },
+            NetworkInfo: {
+                "deserialize": lambda x: NetworkInfo.from_json(x) if isinstance(x, str) else x,
+                "serialize": lambda x: x.to_json() if hasattr(x, "to_json") else x,
+            },
+            CheckData: {
+                "deserialize": lambda x: CheckData.from_json(x) if isinstance(x, str) else x,
+                "serialize": lambda x: x.to_json() if hasattr(x, "to_json") else x,
+            },
+        }