pymammotion 0.2.62__py3-none-any.whl → 0.5.51__py3-none-any.whl

pymammotion/data/model/raw_data.py

@@ -0,0 +1,215 @@
+from dataclasses import dataclass, field
+
+from mashumaro.mixins.orjson import DataClassORJSONMixin
+
+from pymammotion.proto import DevNet, LubaMsg, MctlDriver, MctlNav, MctlOta, MctlPept, MctlSys, SocMul
+
+
+@dataclass
+class RawMowerData:
+    raw: LubaMsg | None = field(default_factory=LubaMsg)
+
+    @classmethod
+    def from_raw(cls, raw: dict) -> "RawMowerData":
+        """Take in raw data to hold in the betterproto dataclass."""
+        return RawMowerData(raw=LubaMsg(**raw))
+
+    def update_raw(self, raw: dict) -> None:
+        """Update the raw LubaMsg data."""
+        self.raw = LubaMsg(**raw)
+
+    @property
+    def net(self):
+        """Will return a wrapped betterproto of net."""
+        return DevNetData(net=self.raw.net)
+
+    @property
+    def sys(self):
+        """Will return a wrapped betterproto of sys."""
+        return SysData(sys=self.raw.sys)
+
+    @property
+    def nav(self):
+        """Will return a wrapped betterproto of nav."""
+        return NavData(nav=self.raw.nav)
+
+    @property
+    def driver(self):
+        """Will return a wrapped betterproto of driver."""
+        return DriverData(driver=self.raw.driver)
+
+    @property
+    def mul(self):
+        """Will return a wrapped betterproto of mul."""
+        return MulData(mul=self.raw.mul)
+
+    @property
+    def ota(self):
+        """Will return a wrapped betterproto of ota."""
+        return OtaData(ota=self.raw.ota)
+
+    @property
+    def pept(self):
+        """Will return a wrapped betterproto of pept."""
+        return PeptData(pept=self.raw.pept)
+
+
+@dataclass
+class DevNetData(DataClassORJSONMixin):
+    """Wrapping class around LubaMsg to return a dataclass from the raw dict."""
+
+    net: dict
+
+    def __init__(self, net: DevNet) -> None:
+        if isinstance(net, dict):
+            self.net = net
+        else:
+            self.net = net.to_dict()
+
+    def __getattr__(self, item):
+        """Intercept call to get net in dict and return a betterproto dataclass."""
+        if self.net.get(item) is None:
+            return DevNet().__getattribute__(item)
+
+        if not isinstance(self.net.get(item), dict):
+            return self.net.get(item)
+
+        return DevNet().__getattribute__(item).from_dict(value=self.net.get(item))
+
+
+@dataclass
+class SysData(DataClassORJSONMixin):
+    """Wrapping class around LubaMsg to return a dataclass from the raw dict."""
+
+    sys: dict
+
+    def __init__(self, sys: MctlSys) -> None:
+        if isinstance(sys, dict):
+            self.sys = sys
+        else:
+            self.sys = sys.to_dict()
+
+    def __getattr__(self, item: str):
+        """Intercept call to get sys in dict and return a betterproto dataclass."""
+        if self.sys.get(item) is None:
+            return MctlSys().__getattribute__(item)
+
+        if not isinstance(self.sys.get(item), dict):
+            return self.sys.get(item)
+
+        return MctlSys().__getattribute__(item).from_dict(value=self.sys.get(item))
+
+
+@dataclass
+class NavData(DataClassORJSONMixin):
+    """Wrapping class around LubaMsg to return a dataclass from the raw dict."""
+
+    nav: dict
+
+    def __init__(self, nav: MctlNav) -> None:
+        if isinstance(nav, dict):
+            self.nav = nav
+        else:
+            self.nav = nav.to_dict()
+
+    def __getattr__(self, item: str):
+        """Intercept call to get nav in dict and return a betterproto dataclass."""
+        if self.nav.get(item) is None:
+            return MctlNav().__getattribute__(item)
+
+        if not isinstance(self.nav.get(item), dict):
+            return self.nav.get(item)
+
+        return MctlNav().__getattribute__(item).from_dict(value=self.nav.get(item))
+
+
+@dataclass
+class DriverData(DataClassORJSONMixin):
+    """Wrapping class around LubaMsg to return a dataclass from the raw dict."""
+
+    driver: dict
+
+    def __init__(self, driver: MctlDriver) -> None:
+        if isinstance(driver, dict):
+            self.driver = driver
+        else:
+            self.driver = driver.to_dict()
+
+    def __getattr__(self, item: str):
+        """Intercept call to get driver in dict and return a betterproto dataclass."""
+        if self.driver.get(item) is None:
+            return MctlDriver().__getattribute__(item)
+
+        if not isinstance(self.driver.get(item), dict):
+            return self.driver.get(item)
+
+        return MctlDriver().__getattribute__(item).from_dict(value=self.driver.get(item))
+
+
+@dataclass
+class MulData(DataClassORJSONMixin):
+    """Wrapping class around LubaMsg to return a dataclass from the raw dict."""
+
+    mul: dict
+
+    def __init__(self, mul: SocMul) -> None:
+        if isinstance(mul, dict):
+            self.mul = mul
+        else:
+            self.mul = mul.to_dict()
+
+    def __getattr__(self, item: str):
+        """Intercept call to get mul in dict and return a betterproto dataclass."""
+        if self.mul.get(item) is None:
+            return SocMul().__getattribute__(item)
+
+        if not isinstance(self.mul.get(item), dict):
+            return self.mul.get(item)
+
+        return SocMul().__getattribute__(item).from_dict(value=self.mul.get(item))
+
+
+@dataclass
+class OtaData(DataClassORJSONMixin):
+    """Wrapping class around LubaMsg to return a dataclass from the raw dict."""
+
+    ota: dict
+
+    def __init__(self, ota: MctlOta) -> None:
+        if isinstance(ota, dict):
+            self.ota = ota
+        else:
+            self.ota = ota.to_dict()
+
+    def __getattr__(self, item: str):
+        """Intercept call to get ota in dict and return a betterproto dataclass."""
+        if self.ota.get(item) is None:
+            return MctlOta().__getattribute__(item)
+
+        if not isinstance(self.ota.get(item), dict):
+            return self.ota.get(item)
+
+        return MctlOta().__getattribute__(item).from_dict(value=self.ota.get(item))
+
+
+@dataclass
+class PeptData(DataClassORJSONMixin):
+    """Wrapping class around LubaMsg to return a dataclass from the raw dict."""
+
+    pept: dict
+
+    def __init__(self, pept: MctlPept) -> None:
+        if isinstance(pept, dict):
+            self.pept = pept
+        else:
+            self.pept = pept.to_dict()
+
+    def __getattr__(self, item: str):
+        """Intercept call to get pept in dict and return a betterproto dataclass."""
+        if self.pept.get(item) is None:
+            return MctlPept().__getattribute__(item)
+
+        if not isinstance(self.pept.get(item), dict):
+            return self.pept.get(item)
+
+        return MctlPept().__getattribute__(item).from_dict(value=self.pept.get(item))

pymammotion/data/model/region_data.py

@@ -1,5 +1,4 @@
 from dataclasses import dataclass
-from typing import Optional
 
 from mashumaro.mixins.orjson import DataClassORJSONMixin
 
@@ -7,14 +6,14 @@ from mashumaro.mixins.orjson import DataClassORJSONMixin
 @dataclass
 class RegionData(DataClassORJSONMixin):
     def __init__(self) -> None:
-        self.hash: Optional[int] = None
+        self.hash: int = 0
         self.action: int = 0
         self.current_frame: int = 0
-        self.data_hash: Optional[int] = None
+        self.data_hash: int = 0
         self.data_len: int = 0
-        self.p_hash_a: Optional[int] = None
-        self.p_hash_b: Optional[int] = None
-        self.path: Optional[list[list[float]]] = 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
         self.sub_cmd: int = 0
@@ -72,31 +71,31 @@ class RegionData(DataClassORJSONMixin):
     def set_current_frame(self, current_frame: int) -> None:
         self.current_frame = current_frame
 
-    def get_path(self) -> Optional[list[list[float]]]:
+    def get_path(self) -> list[list[float]] | None:
         return self.path
 
     def set_path(self, path: list[list[float]]) -> None:
         self.path = path
 
-    def get_hash(self) -> Optional[int]:
+    def get_hash(self) -> int | None:
         return self.hash
 
     def set_data_hash(self, data_hash: int) -> None:
         self.data_hash = data_hash
 
-    def get_data_hash(self) -> Optional[int]:
+    def get_data_hash(self) -> int | None:
         return self.data_hash
 
     def set_p_hash_a(self, p_hash_a: int) -> None:
         self.p_hash_a = p_hash_a
 
-    def get_p_hash_a(self) -> Optional[int]:
+    def get_p_hash_a(self) -> int | None:
         return self.p_hash_a
 
     def set_p_hash_b(self, p_hash_b: int) -> None:
         self.p_hash_b = p_hash_b
 
-    def get_p_hash_b(self) -> Optional[int]:
+    def get_p_hash_b(self) -> int | None:
         return self.p_hash_b
 
     def __str__(self) -> str:

pymammotion/data/model/report_info.py

@@ -1,13 +1,27 @@
-from dataclasses import asdict, dataclass, field
+from dataclasses import dataclass, field
+from enum import StrEnum
 
 from mashumaro.mixins.orjson import DataClassORJSONMixin
 
 
+class NetUsedType(StrEnum):
+    NONE = "NONE"
+    WIFI = "WIFI"
+    MNET = "MNET"
+
+
 @dataclass
 class ConnectData(DataClassORJSONMixin):
     connect_type: int = 0
     ble_rssi: int = 0
     wifi_rssi: int = 0
+    link_type: int = 0
+    mnet_rssi: int = 0
+    mnet_inet: int = 0
+    used_net: str = "NONE"
+
+
+#    mnet_cfg:
 
 
 @dataclass
@@ -22,6 +36,16 @@ class MnetInfo(DataClassORJSONMixin):
     imei: str = ""
 
 
+@dataclass
+class LockStateT(DataClassORJSONMixin):
+    lock_state: int = 0
+
+
+@dataclass
+class VioSurvivalInfo(DataClassORJSONMixin):
+    vio_survival_distance: float = 0.0
+
+
 @dataclass
 class DeviceData(DataClassORJSONMixin):
     sys_status: int = 0
@@ -30,8 +54,11 @@ class DeviceData(DataClassORJSONMixin):
     sensor_status: int = 0
     last_status: int = 0
     sys_time_stamp: str = ""
-    collector_status: CollectorStatus = field(default_factory=CollectorStatus)
+    vslam_status: int = 0
     mnet_info: MnetInfo = field(default_factory=MnetInfo)
+    vio_survival_info: VioSurvivalInfo = field(default_factory=VioSurvivalInfo)
+    collector_status: CollectorStatus = field(default_factory=CollectorStatus)
+    lock_state: LockStateT = field(default_factory=LockStateT)
 
 
 @dataclass
@@ -52,6 +79,31 @@ class LocationData(DataClassORJSONMixin):
     bol_hash: str = ""
 
 
+@dataclass
+class BladeUsed(DataClassORJSONMixin):
+    blade_used_time: int = 0
+    blade_used_warn_time: int = 0
+
+
+@dataclass
+class Maintain(DataClassORJSONMixin):
+    blade_used_time: BladeUsed = field(default_factory=BladeUsed)
+    mileage: int = 0
+    work_time: int = 0
+    bat_cycles: int = 0
+
+
+@dataclass
+class VisionInfo(DataClassORJSONMixin):
+    x: float = 0.0
+    y: float = 0.0
+    heading: float = 0.0
+    vio_state: int = 0
+    brightness: int = 0
+    detect_feature_num: int = 0
+    track_feature_num: int = 0
+
+
 @dataclass
 class WorkData(DataClassORJSONMixin):
     path: int = 0
@@ -80,6 +132,8 @@ class WorkData(DataClassORJSONMixin):
 class ReportData(DataClassORJSONMixin):
     connect: ConnectData = field(default_factory=ConnectData)
     dev: DeviceData = field(default_factory=DeviceData)
+    maintenance: Maintain = field(default_factory=Maintain)
+    vision_info: VisionInfo = field(default_factory=VisionInfo)
     rtk: RTKData = field(default_factory=RTKData)
     locations: list[LocationData] = field(default_factory=list)
     work: WorkData = field(default_factory=WorkData)
@@ -89,8 +143,10 @@ class ReportData(DataClassORJSONMixin):
         if data.get("locations") is not None:
             locations = [LocationData.from_dict(loc) for loc in data.get("locations", [])]
 
-        self.connect = ConnectData.from_dict(data.get("connect", asdict(self.connect)))
-        self.dev = DeviceData.from_dict(data.get("dev", asdict(self.dev)))
-        self.rtk = RTKData.from_dict(data.get("rtk", asdict(self.rtk)))
+        self.connect = ConnectData.from_dict(data.get("connect", self.connect.to_dict()))
+        self.dev = DeviceData.from_dict(data.get("dev", self.dev.to_dict()))
+        self.rtk = RTKData.from_dict(data.get("rtk", self.rtk.to_dict()))
+        self.maintenance = Maintain.from_dict(data.get("maintain", self.maintenance.to_dict()))
+        self.vision_info = VisionInfo.from_dict(data.get("vio_to_app_info", VisionInfo().to_dict()))
         self.locations = locations
-        self.work = WorkData.from_dict(data.get("work", asdict(self.work)))
+        self.work = WorkData.from_dict(data.get("work", self.work.to_dict()))

pymammotion/data/model/work.py

@@ -0,0 +1,27 @@
+"""bidire_reqconver_path as a model."""
+
+from dataclasses import dataclass, field
+
+from mashumaro.mixins.orjson import DataClassORJSONMixin
+
+
+@dataclass
+class CurrentTaskSettings(DataClassORJSONMixin):
+    pver: int = 0
+    job_id: int = 0
+    job_ver: int = 0
+    job_mode: int = 0
+    sub_cmd: int = 0
+    edge_mode: int = 0
+    knife_height: int = 0
+    channel_width: int = 0
+    ultra_wave: int = 0
+    channel_mode: int = 0
+    toward: int = 0
+    speed: float = 0.0
+    zone_hashs: list[int] = field(default_factory=list)
+    path_hash: int = 0
+    reserved: str = ""
+    result: int = 0
+    toward_mode: int = 0
+    toward_included_angle: int = 0