pymammotion 0.5.69__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

@@ -0,0 +1,102 @@
+from dataclasses import dataclass
+
+from mashumaro.mixins.orjson import DataClassORJSONMixin
+
+
+@dataclass
+class RegionData(DataClassORJSONMixin):
+    def __init__(self) -> None:
+        self.hash: int = 0
+        self.action: int = 0
+        self.current_frame: int = 0
+        self.data_hash: int = 0
+        self.data_len: int = 0
+        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
+        self.total_frame: int = 0
+        self.type: int = 0
+
+    def set_hash(self, hash: int) -> None:
+        self.hash = hash
+
+    def get_data_len(self) -> int:
+        return self.data_len
+
+    def set_data_len(self, data_len: int) -> None:
+        self.data_len = data_len
+
+    def get_pver(self) -> int:
+        return self.pver
+
+    def set_pver(self, pver: int) -> None:
+        self.pver = pver
+
+    def get_sub_cmd(self) -> int:
+        return self.sub_cmd
+
+    def set_sub_cmd(self, sub_cmd: int) -> None:
+        self.sub_cmd = sub_cmd
+
+    def get_result(self) -> int:
+        return self.result
+
+    def set_result(self, result: int) -> None:
+        self.result = result
+
+    def get_action(self) -> int:
+        return self.action
+
+    def set_action(self, action: int) -> None:
+        self.action = action
+
+    def get_type(self) -> int:
+        return self.type
+
+    def set_type(self, type: int) -> None:
+        self.type = type
+
+    def get_total_frame(self) -> int:
+        return self.total_frame
+
+    def set_total_frame(self, total_frame: int) -> None:
+        self.total_frame = total_frame
+
+    def get_current_frame(self) -> int:
+        return self.current_frame
+
+    def set_current_frame(self, current_frame: int) -> None:
+        self.current_frame = current_frame
+
+    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) -> int | None:
+        return self.hash
+
+    def set_data_hash(self, data_hash: int) -> None:
+        self.data_hash = data_hash
+
+    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) -> 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) -> int | None:
+        return self.p_hash_b
+
+    def __str__(self) -> str:
+        return f"RegionData{{pver={self.pver}, sub_cmd={self.sub_cmd}, result={self.result}, action={self.action}, type={self.type}, Hash={self.hash}, total_frame={self.total_frame}, current_frame={self.current_frame}, data_hash={self.data_hash}, p_hash_a={self.p_hash_a}, p_hash_b={self.p_hash_b}, data_len={self.data_len}, path={self.path}}}"

pymammotion/data/model/report_info.py

@@ -0,0 +1,182 @@
+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
+class CollectorStatus(DataClassORJSONMixin):
+    collector_installation_status: int = 0
+
+
+@dataclass
+class MnetInfo(DataClassORJSONMixin):
+    model: str = ""
+    revision: str = ""
+    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
+    charge_state: int = 0
+    battery_val: int = 0
+    sensor_status: int = 0
+    last_status: int = 0
+    sys_time_stamp: str = ""
+    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
+class RTKDisStatus(DataClassORJSONMixin):
+    pos_status: int = 0
+    precision: int = 0
+    device_signal: int = 0
+    l1: int = 0
+    l2: int = 0
+    connection_to_ref: int = 0
+    rtk_signal: int = 0
+
+
+@dataclass
+class RTKData(DataClassORJSONMixin):
+    status: int = 0
+    pos_level: int = 0
+    gps_stars: int = 0
+    dis_status: int = 0
+    co_view_stars: int = 0
+
+    def get_dis_status(self) -> RTKDisStatus:
+        rtk_dis_status = RTKDisStatus()
+        rtk_dis_status.pos_status = ((int)(self.dis_status >> 8)) & 255
+        rtk_dis_status.precision = ((int)(self.dis_status >> 56)) & 255
+        rtk_dis_status.device_signal = ((int)(self.dis_status >> 32)) & 255
+        rtk_dis_status.l1 = ((int)(self.dis_status >> 16)) & 255
+        rtk_dis_status.l2 = ((int)(self.dis_status >> 24)) & 255
+        rtk_dis_status.connection_to_ref = ((int)(self.dis_status >> 48)) & 255
+        rtk_dis_status.rtk_signal = ((int)(self.dis_status >> 40)) & 255
+        return rtk_dis_status
+
+
+@dataclass
+class LocationData(DataClassORJSONMixin):
+    real_pos_x: int = 0
+    real_pos_y: int = 0
+    real_toward: int = 0
+    pos_type: int = 0
+    bol_hash: int = 0
+
+
+@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 HeadingState(DataClassORJSONMixin):
+    heading_state: int = 0
+
+
+@dataclass
+class WorkData(DataClassORJSONMixin):
+    path: int = 0
+    path_hash: int = 0
+    progress: int = 0
+    area: int = 0
+    bp_info: int = 0
+    bp_hash: int = 0
+    bp_pos_x: int = 0
+    bp_pos_y: int = 0
+    real_path_num: int = 0
+    path_pos_x: int = 0
+    path_pos_y: int = 0
+    ub_zone_hash: int = 0
+    ub_path_hash: int = 0
+    init_cfg_hash: int = 0
+    ub_ecode_hash: int = 0
+    nav_run_mode: int = 0
+    test_mode_status: int = 0
+    man_run_speed: int = 0
+    nav_edit_status: int = 0
+    knife_height: int = 0
+    nav_heading_state: HeadingState = field(default_factory=HeadingState)
+    cutter_offset: float = 0.0
+    cutter_width: float = 0.0
+
+
+@dataclass
+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)
+
+    def update(self, data: dict) -> None:
+        locations = self.locations
+        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", 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", 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