pymammotion 0.0.37__py3-none-any.whl

pymammotion/data/model/device.py

@@ -0,0 +1,157 @@
+"""MowingDevice class to wrap around the betterproto dataclasses."""
+
+from dataclasses import dataclass
+
+from pyluba.proto.dev_net import DevNet
+from pyluba.proto.luba_msg import LubaMsg
+from pyluba.proto.luba_mul import SocMul
+from pyluba.proto.mctrl_driver import MctlDriver
+from pyluba.proto.mctrl_nav import MctlNav
+from pyluba.proto.mctrl_ota import MctlOta
+from pyluba.proto.mctrl_pept import MctlPept
+from pyluba.proto.mctrl_sys import MctlSys
+
+
+@dataclass
+class MowingDevice:
+    """Wraps the betterproto dataclasses so we can bypass the groups for keeping all data."""
+
+    device: LubaMsg
+
+    @classmethod
+    def from_raw(cls, raw: dict) -> "MowingDevice":
+        """Take in raw data to hold in the betterproto dataclass."""
+        return MowingDevice(device=LubaMsg(**raw))
+
+    @property
+    def net(self):
+        """Will return a wrapped betterproto of net."""
+        return DevNetData(net=self.device.net)
+
+    @property
+    def sys(self):
+        """Will return a wrapped betterproto of sys."""
+        return SysData(sys=self.device.sys)
+
+    @property
+    def nav(self):
+        """Will return a wrapped betterproto of nav."""
+        return NavData(nav=self.device.nav)
+
+    @property
+    def driver(self):
+        """Will return a wrapped betterproto of driver."""
+        return DriverData(driver=self.device.driver)
+
+    @property
+    def mul(self):
+        """Will return a wrapped betterproto of mul."""
+        return MulData(mul=self.device.mul)
+
+    @property
+    def ota(self):
+        """Will return a wrapped betterproto of ota."""
+        return OtaData(ota=self.device.ota)
+
+    @property
+    def pept(self):
+        """Will return a wrapped betterproto of pept."""
+        return PeptData(pept=self.device.pept)
+
+
+@dataclass
+class DevNetData:
+    """Wrapping class around LubaMsg to return a dataclass from the raw dict."""
+
+    net: DevNet
+
+    def __getattr__(self, item):
+        """Intercept call to get net in dict and return a betterproto dataclass."""
+        if not isinstance(self.net[item], dict):
+            return self.net[item]
+
+        return DevNet().__getattribute__(item).from_dict(value=self.net[item])
+
+
+@dataclass
+class SysData:
+    """Wrapping class around LubaMsg to return a dataclass from the raw dict."""
+
+    sys: MctlSys
+
+    def __getattr__(self, item):
+        """Intercept call to get net in dict and return a betterproto dataclass."""
+        if not isinstance(self.sys[item], dict):
+            return self.sys[item]
+
+        return MctlSys().__getattribute__(item).from_dict(value=self.sys[item])
+
+
+@dataclass
+class NavData:
+    """Wrapping class around LubaMsg to return a dataclass from the raw dict."""
+
+    nav: MctlNav
+
+    def __getattr__(self, item):
+        """Intercept call to get nav in dict and return a betterproto dataclass."""
+        if not isinstance(self.nav[item], dict):
+            return self.nav[item]
+
+        return MctlNav().__getattribute__(item).from_dict(value=self.nav[item])
+
+
+@dataclass
+class DriverData:
+    """Wrapping class around LubaMsg to return a dataclass from the raw dict."""
+
+    driver: MctlDriver
+
+    def __getattr__(self, item):
+        """Intercept call to get driver in dict and return a betterproto dataclass."""
+        if not isinstance(self.driver[item], dict):
+            return self.driver[item]
+
+        return MctlDriver().__getattribute__(item).from_dict(value=self.driver[item])
+
+
+@dataclass
+class MulData:
+    """Wrapping class around LubaMsg to return a dataclass from the raw dict."""
+
+    mul: SocMul
+
+    def __getattr__(self, item):
+        """Intercept call to get mul in dict and return a betterproto dataclass."""
+        if not isinstance(self.mul[item], dict):
+            return self.mul[item]
+
+        return SocMul().__getattribute__(item).from_dict(value=self.mul[item])
+
+
+@dataclass
+class OtaData:
+    """Wrapping class around LubaMsg to return a dataclass from the raw dict."""
+
+    ota: MctlOta
+
+    def __getattr__(self, item):
+        """Intercept call to get ota in dict and return a betterproto dataclass."""
+        if not isinstance(self.ota[item], dict):
+            return self.ota[item]
+
+        return MctlOta().__getattribute__(item).from_dict(value=self.ota[item])
+
+
+@dataclass
+class PeptData:
+    """Wrapping class around LubaMsg to return a dataclass from the raw dict."""
+
+    pept: MctlPept
+
+    def __getattr__(self, item):
+        """Intercept call to get pept in dict and return a betterproto dataclass."""
+        if not isinstance(self.pept[item], dict):
+            return self.pept[item]
+
+        return MctlPept().__getattribute__(item).from_dict(value=self.pept[item])

pymammotion/data/model/enums.py

@@ -0,0 +1,67 @@
+from enum import Enum
+
+
+class PositionMode(Enum):
+    FIX = 0
+    SINGLE = 1
+    FLOAT = 2
+    NONE = 3
+    UNKNOWN = 4
+
+    @staticmethod
+    def from_value(value):
+        if value == 0:
+            return PositionMode.FIX
+        elif value == 1:
+            return PositionMode.SINGLE
+        elif value == 2:
+            return PositionMode.FLOAT
+        elif value == 3:
+            return PositionMode.NONE
+        else:
+            return PositionMode.UNKNOWN
+
+    def __str__(self):
+        if self == PositionMode.FIX:
+            return "Fix"
+        elif self == PositionMode.SINGLE:
+            return "Single"
+        elif self == PositionMode.FLOAT:
+            return "Float"
+        elif self == PositionMode.NONE:
+            return "None"
+        else:
+            return "-"
+
+
+class RTKStatus(Enum):
+    NONE = 0
+    SINGLE = 1
+    FIX = 4
+    FLOAT = 5
+    UNKNOWN = 6
+
+    @staticmethod
+    def from_value(value):
+        if value == 0:
+            return RTKStatus.NONE
+        elif value == 1 or value == 2:
+            return RTKStatus.SINGLE
+        elif value == 4:
+            return RTKStatus.FIX
+        elif value == 5:
+            return RTKStatus.FLOAT
+        else:
+            return RTKStatus.UNKNOWN
+
+    def __str__(self):
+        if self == RTKStatus.NONE:
+            return "None"
+        elif self == RTKStatus.SINGLE:
+            return "Single"
+        elif self == RTKStatus.FIX:
+            return "Fix"
+        elif self == RTKStatus.FLOAT:
+            return "Float"
+        else:
+            return "Unknown"

pymammotion/data/model/excute_boarder_params.py

@@ -0,0 +1,48 @@
+class ExecuteBorderParams:
+    """generated source for class ExecuteBorderParamsBean"""
+
+    border = list()
+    currentFrame = 0
+    jobIndex = ""
+
+    def __init__(self, i, str_, list_):
+        """Generated source for method __init__"""
+        self.currentFrame = i
+        self.border = list_
+        self.jobIndex = str_
+
+    def get_current_frame(self):
+        """Generated source for method getCurrentFrame"""
+        return self.currentFrame
+
+    def set_current_frame(self, i):
+        """Generated source for method setCurrentFrame"""
+        self.currentFrame = i
+
+    def get_job_index(self):
+        """Generated source for method getJobIndex"""
+        return self.jobIndex
+
+    def set_job_index(self, str_):
+        """Generated source for method setJobIndex"""
+        self.jobIndex = str_
+
+    def get_border(self):
+        """Generated source for method getBorder"""
+        return self.border
+
+    def set_border(self, border_list):
+        """Generated source for method setBorder"""
+        self.border = border_list
+
+    def __str__(self):
+        """Generated source for method toString"""
+        return (
+            "ExecuteBorderParamsBean{currentFrame="
+            + self.currentFrame
+            + ", jobIndex='"
+            + self.jobIndex
+            + "', border="
+            + self.border
+            + "}"
+        )

pymammotion/data/model/execute_boarder.py

@@ -0,0 +1,36 @@
+from jsonic.serializable import Serializable
+
+from .excute_boarder_params import ExecuteBorderParams
+
+
+class ExecuteBorder(Serializable):
+    """generated source for class ExecuteBorderBean"""
+
+    cmd = 0
+    params = ExecuteBorderParams(None, None, None)
+
+    def __init__(self, i, execute_border_params: ExecuteBorderParams):
+        """Generated source for method __init__"""
+        super().__init__()
+        self.cmd = i
+        self.params = execute_border_params
+
+    def get_cmd(self):
+        """Generated source for method getCmd"""
+        return self.cmd
+
+    def set_cmd(self, i):
+        """Generated source for method setCmd"""
+        self.cmd = i
+
+    def get_params(self):
+        """Generated source for method getParams"""
+        return self.params
+
+    def set_params(self, execute_border_params):
+        """Generated source for method setParams"""
+        self.params = execute_border_params
+
+    def __str__(self):
+        """Generated source for method toString"""
+        return "ExecuteBean{cmd=" + self.cmd + ", params=" + self.params + "}"

pymammotion/data/model/generate_route_information.py

@@ -0,0 +1,133 @@
+import logging
+from typing import List
+
+logger = logging.getLogger(__name__)
+
+
+class GenerateRouteInformation:
+    """Creates a model for generating route information and mowing plan before starting a job."""
+
+    def __init__(
+        self,
+        one_hashs: List[int],
+        job_mode: int,
+        channel_width: int,
+        speed: float,
+        ultra_wave: int,
+        channel_mode: int,
+        rain_tactics: int,
+        toward: int,
+        knife_height: int,
+        path_order: str,
+        toward_included_angle: int,
+    ):
+        self.path_order = ""
+        self.toward_mode = 0
+        self.one_hashs = one_hashs
+        self.rain_tactics = rain_tactics
+        self.job_mode = job_mode
+        self.knife_height = knife_height
+        self.speed = speed
+        self.ultra_wave = ultra_wave
+        self.channel_width = channel_width
+        self.channel_mode = channel_mode
+        self.toward = toward
+        self.edge_mode = rain_tactics
+        self.path_order = path_order
+        self.toward_included_angle = toward_included_angle
+        logger.debug(
+            f"Mode route command parameters jobMode={job_mode}//channelWidth={channel_width}//speed={speed}//UltraWave={ultra_wave}//channelMode={channel_mode}//edgeMode={rain_tactics}//knifeHeight={knife_height}  pathOrder:{path_order.encode('utf-8')}"
+        )
+
+    def get_job_id(self) -> int:
+        return self.job_id
+
+    def set_job_id(self, job_id: int) -> None:
+        self.job_id = job_id
+
+    def get_job_ver(self) -> int:
+        return self.job_ver
+
+    def set_job_ver(self, job_ver: int) -> None:
+        self.job_ver = job_ver
+
+    def get_rain_tactics(self) -> int:
+        return self.rain_tactics
+
+    def set_rain_tactics(self, rain_tactics: int) -> None:
+        self.rain_tactics = rain_tactics
+
+    def get_job_mode(self) -> int:
+        return self.job_mode
+
+    def set_job_mode(self, job_mode: int) -> None:
+        self.job_mode = job_mode
+
+    def get_knife_height(self) -> int:
+        return self.knife_height
+
+    def set_knife_height(self, knife_height: int) -> None:
+        self.knife_height = knife_height
+
+    def get_speed(self) -> float:
+        return self.speed
+
+    def set_speed(self, speed: float) -> None:
+        self.speed = speed
+
+    def get_ultra_wave(self) -> int:
+        return self.ultra_wave
+
+    def set_ultra_wave(self, ultra_wave: int) -> None:
+        self.ultra_wave = ultra_wave
+
+    def get_channel_width(self) -> int:
+        return self.channel_width
+
+    def set_channel_width(self, channel_width: int) -> None:
+        self.channel_width = channel_width
+
+    def get_channel_mode(self) -> int:
+        return self.channel_mode
+
+    def set_channel_mode(self, channel_mode: int) -> None:
+        self.channel_mode = channel_mode
+
+    def get_toward(self) -> int:
+        return self.toward
+
+    def set_toward(self, toward: int) -> None:
+        self.toward = toward
+
+    def get_one_hashs(self) -> List[int]:
+        return self.one_hashs if self.one_hashs else []
+
+    def set_one_hashs(self, one_hashs: List[int]) -> None:
+        self.one_hashs = one_hashs
+
+    def get_path_order(self) -> str:
+        return self.path_order
+
+    def set_path_order(self, path_order: str) -> None:
+        self.path_order = path_order
+
+    def get_toward_included_angle(self) -> int:
+        return self.toward_included_angle
+
+    def set_toward_included_angle(self, toward_included_angle: int) -> None:
+        self.toward_included_angle = toward_included_angle
+
+    def get_toward_mode(self) -> int:
+        return self.toward_mode
+
+    def get_edge_mode(self) -> int:
+        return self.edge_mode
+
+    def set_edge_mode(self, edge_mode: int) -> None:
+        self.edge_mode = edge_mode
+
+    def __str__(self) -> str:
+        try:
+            return f"GenerateRouteInformation{{oneHashs={self.one_hashs}, jobId={self.job_id}, jobVer={self.job_ver}, rainTactics={self.rain_tactics}, jobMode={self.job_mode}, knifeHeight={self.knife_height}, speed={self.speed}, UltraWave={self.ultra_wave}, channelWidth={self.channel_width}, channelMode={self.channel_mode}, toward={self.toward}, pathOrder='{self.path_order.encode('utf-8')}', edgeMode={self.edge_mode}, towardIncludedAngle={self.toward_included_angle}}}"
+        except Exception as e:
+            return str(e)

pymammotion/data/model/hash_list.py

@@ -0,0 +1,17 @@
+import typing
+
+
+class HashList:
+    def __init__(self):
+        self.pver: int = 0
+        self.subCmd: int = 0
+        self.totalFrame: int = 0
+        self.currentFrame: int = 0
+        self.dataHash: int = 0
+        self.path: typing.List[int] = []
+
+    def __str__(self) -> str:
+        return (
+            f"HashBean{{pver={self.pver}, subCmd={self.subCmd}, totalFrame={self.totalFrame}, "
+            + f"currentFrame={self.currentFrame}, dataHash={self.dataHash}, path={self.path}}}"
+        )

pymammotion/data/model/mowing_modes.py

@@ -0,0 +1,37 @@
+from enum import IntEnum
+
+
+class CuttingMode(IntEnum):
+    """job_mode"""
+
+    single_grid = 0
+    double_grid = 1
+    segment_grid = 2
+    no_grid = 3
+
+
+class BorderPatrolMode(IntEnum):
+    """"""
+
+    none = 0
+    one = 1
+    two = 2
+    three = 3
+    four = 4
+
+
+class ObstacleLapsMode(IntEnum):
+    """mowingLaps"""
+
+    none = 0
+    one = 1
+    two = 2
+    three = 3
+    four = 4
+
+
+class MowOrder(IntEnum):
+    """path_order"""
+
+    border_first = 0
+    grid_first = 1

pymammotion/data/model/plan.py

@@ -0,0 +1,58 @@
+from typing import List
+
+
+class Plan:
+    def __init__(self):
+        self.pver: int = 0
+        self.sub_cmd: int = 0
+        self.area: int = 0
+        self.work_time: int = 0
+        self.version: str = ""
+        self.id: str = ""
+        self.user_id: str = ""
+        self.device_id: str = ""
+        self.plan_id: str = ""
+        self.task_id: str = ""
+        self.job_id: str = ""
+        self.start_time: str = ""
+        self.end_time: str = ""
+        self.week: int = 0
+        self.knife_height: int = 0
+        self.model: int = 0
+        self.edge_mode: int = 0
+        self.required_time: int = 0
+        self.route_angle: int = 0
+        self.route_model: int = 0
+        self.route_spacing: int = 0
+        self.ultrasonic_barrier: int = 0
+        self.total_plan_num: int = 0
+        self.plan_index: int = 0
+        self.result: int = 0
+        self.speed: float = 0.0
+        self.task_name: str = ""
+        self.job_name: str = ""
+        self.zone_hashs: List[int] = []
+        self.reserved: str = ""
+        self.weeks: List[int] = []
+        self.start_date: str = ""
+        self.end_date: str = ""
+        self.job_type: int = 0
+        self.interval_days: int = 0
+        self.count_down: int = 0
+        self.is_enable: bool = True
+        self.is_mow_work: bool = True
+        self.is_sweeping_work: bool = True
+        self.mowing_laps: int = 0
+        self.path_order: int = 0
+        self.demond_angle: int = 90
+
+    def __str__(self):
+        return f"Plan(pver={self.pver}, sub_cmd={self.sub_cmd}, area={self.area}, work_time={self.work_time}, version='{self.version}', id='{self.id}', user_id='{self.user_id}', device_id='{self.device_id}', plan_id='{self.plan_id}', task_id='{self.task_id}', job_id='{self.job_id}', start_time='{self.start_time}', end_time='{self.end_time}', week={self.week}, knife_height={self.knife_height}, model={self.model}, edge_mode={self.edge_mode}, required_time={self.required_time}, route_angle={self.route_angle}, route_model={self.route_model}, route_spacing={self.route_spacing}, ultrasonic_barrier={self.ultrasonic_barrier}, total_plan_num={self.total_plan_num}, plan_index={self.plan_index}, result={self.result}, speed={self.speed}, task_name='{self.task_name}', job_name='{self.job_name}', zone_hashs={self.zone_hashs}, reserved='{self.reserved}', weeks={self.weeks}, start_date='{self.start_date}', end_date='{self.end_date}', job_type={self.job_type}, interval_days={self.interval_days}, count_down={self.count_down}, is_enable={self.is_enable}, mowing_laps={self.mowing_laps}, path_order={self.path_order}, demond_angle={self.demond_angle}, is_mow_work={self.is_mow_work}, is_sweeping_work={self.is_sweeping_work})"
+
+    def __eq__(self, other):
+        if isinstance(other, Plan):
+            return self.plan_id == other.plan_id
+        return False
+
+    def __hash__(self):
+        return hash(self.plan_id)

pymammotion/data/model/rapid_state.py

@@ -0,0 +1,45 @@
+from dataclasses import dataclass
+from enum import Enum
+
+
+class RTKStatus(Enum):
+    NONE = 0
+    BAD = 1
+    FINE = 4
+
+
+@dataclass
+class RapidState:
+    pos_x: float
+    pos_y: float
+    rtk_status: RTKStatus
+    toward: float
+    satellites_total: int
+    satellites_l2: int
+    rtk_age: float
+    lat_std: float
+    lon_std: float
+    pos_type: int
+    zone_hash: int
+    pos_level: int
+
+    @classmethod
+    def from_raw(cls, raw: list[int]) -> "RapidState":
+        return RapidState(
+            rtk_status=RTKStatus.FINE
+            if raw[0] == 4
+            else RTKStatus.BAD
+            if raw[0] in (1, 5)
+            else RTKStatus.NONE,
+            pos_level=raw[1],
+            satellites_total=raw[2],
+            rtk_age=raw[3] / 10000,
+            lat_std=raw[4] / 10000,
+            lon_std=raw[5] / 10000,
+            satellites_l2=raw[6],
+            pos_x=raw[7] / 10000,
+            pos_y=raw[8] / 10000,
+            toward=raw[9] / 10000,
+            pos_type=raw[10],
+            zone_hash=raw[11],
+        )