pymammotion 0.2.28__py3-none-any.whl → 0.2.30__py3-none-any.whl

pymammotion/data/model/device.py

@@ -1,6 +1,5 @@
 """MowingDevice class to wrap around the betterproto dataclasses."""
 
-import math
 from dataclasses import dataclass
 
 import betterproto
@@ -16,8 +15,13 @@ from pymammotion.proto.mctrl_driver import MctlDriver
 from pymammotion.proto.mctrl_nav import MctlNav
 from pymammotion.proto.mctrl_ota import MctlOta
 from pymammotion.proto.mctrl_pept import MctlPept
-from pymammotion.proto.mctrl_sys import MctlSys, MowToAppInfoT, ReportInfoData, SystemUpdateBufMsg, \
-    SystemRapidStateTunnelMsg
+from pymammotion.proto.mctrl_sys import (
+    MctlSys,
+    MowToAppInfoT,
+    ReportInfoData,
+    SystemRapidStateTunnelMsg,
+    SystemUpdateBufMsg,
+)
 from pymammotion.utility.constant import WorkMode
 from pymammotion.utility.conversions import parse_double
 from pymammotion.utility.map import CoordinateConverter
@@ -32,7 +36,7 @@ class MowingDevice:
     location: Location
     mowing_state: RapidState
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.device = LubaMsg()
         self.map = HashList(area={}, path={}, obstacle={}, hashlist=[])
         self.location = Location()
@@ -53,7 +57,7 @@ class MowingDevice:
         """Update the raw LubaMsg data."""
         self.device = LubaMsg(**raw)
 
-    def buffer(self, buffer_list: SystemUpdateBufMsg):
+    def buffer(self, buffer_list: SystemUpdateBufMsg) -> None:
         """Update the device based on which buffer we are reading from."""
         match buffer_list.update_buf_data[0]:
             case 1:
@@ -95,7 +99,7 @@ class MowingDevice:
                     ]
                 )
 
-    def update_report_data(self, toapp_report_data: ReportInfoData):
+    def update_report_data(self, toapp_report_data: ReportInfoData) -> None:
         coordinate_converter = CoordinateConverter(self.location.RTK.latitude, self.location.RTK.longitude)
         for index, location in enumerate(toapp_report_data.locations):
             if index == 0 and location.real_pos_y != 0:
@@ -105,18 +109,21 @@ class MowingDevice:
                     parse_double(location.real_pos_y, 4.0), parse_double(location.real_pos_x, 4.0)
                 )
                 if location.zone_hash:
-                    self.location.work_zone = location.zone_hash if self.report_data.dev.sys_status == WorkMode.MODE_WORKING else 0
-
-
+                    self.location.work_zone = (
+                        location.zone_hash if self.report_data.dev.sys_status == WorkMode.MODE_WORKING else 0
+                    )
 
         self.report_data = self.report_data.from_dict(toapp_report_data.to_dict(casing=betterproto.Casing.SNAKE))
 
-    def run_state_update(self, rapid_state: SystemRapidStateTunnelMsg):
+    def run_state_update(self, rapid_state: SystemRapidStateTunnelMsg) -> None:
         self.mowing_state = RapidState().from_raw(rapid_state.rapid_state_data)
 
-    def mow_info(self, toapp_mow_info: MowToAppInfoT):
+    def mow_info(self, toapp_mow_info: MowToAppInfoT) -> None:
         pass
 
+    def report_missing_data(self) -> None:
+        """Report missing data so we can refetch it."""
+
     @property
     def net(self):
         """Will return a wrapped betterproto of net."""
@@ -159,7 +166,7 @@ class DevNetData:
 
     net: dict
 
-    def __init__(self, net: DevNet):
+    def __init__(self, net: DevNet) -> None:
         if isinstance(net, dict):
             self.net = net
         else:
@@ -182,13 +189,13 @@ class SysData:
 
     sys: dict
 
-    def __init__(self, sys: MctlSys):
+    def __init__(self, sys: MctlSys) -> None:
         if isinstance(sys, dict):
             self.sys = sys
         else:
             self.sys = sys.to_dict()
 
-    def __getattr__(self, item):
+    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)
@@ -205,13 +212,13 @@ class NavData:
 
     nav: dict
 
-    def __init__(self, nav: MctlNav):
+    def __init__(self, nav: MctlNav) -> None:
         if isinstance(nav, dict):
             self.nav = nav
         else:
             self.nav = nav.to_dict()
 
-    def __getattr__(self, item):
+    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)
@@ -228,13 +235,13 @@ class DriverData:
 
     driver: dict
 
-    def __init__(self, driver: MctlDriver):
+    def __init__(self, driver: MctlDriver) -> None:
         if isinstance(driver, dict):
             self.driver = driver
         else:
             self.driver = driver.to_dict()
 
-    def __getattr__(self, item):
+    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)
@@ -251,13 +258,13 @@ class MulData:
 
     mul: dict
 
-    def __init__(self, mul: SocMul):
+    def __init__(self, mul: SocMul) -> None:
         if isinstance(mul, dict):
             self.mul = mul
         else:
             self.mul = mul.to_dict()
 
-    def __getattr__(self, item):
+    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)
@@ -274,13 +281,13 @@ class OtaData:
 
     ota: dict
 
-    def __init__(self, ota: MctlOta):
+    def __init__(self, ota: MctlOta) -> None:
         if isinstance(ota, dict):
             self.ota = ota
         else:
             self.ota = ota.to_dict()
 
-    def __getattr__(self, item):
+    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)
@@ -297,13 +304,13 @@ class PeptData:
 
     pept: dict
 
-    def __init__(self, pept: MctlPept):
+    def __init__(self, pept: MctlPept) -> None:
         if isinstance(pept, dict):
             self.pept = pept
         else:
             self.pept = pept.to_dict()
 
-    def __getattr__(self, item):
+    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)

pymammotion/data/model/device_config.py

@@ -1,5 +1,7 @@
 from dataclasses import dataclass
 
+from pymammotion.utility.device_type import DeviceType
+
 
 @dataclass
 class DeviceLimits:
@@ -7,3 +9,72 @@ class DeviceLimits:
     blade_height_max: int
     working_speed_min: float
     working_speed_max: float
+
+
+@dataclass
+class OperationSettings:
+    """Operation settings for a device."""
+
+    is_mow: bool = True
+    is_dump: bool = True
+    is_edge: bool = False
+    collect_grass_frequency: int = 10
+    job_mode: int = 0  # taskMode
+    job_version: int = 0
+    job_id: int = 0
+    speed: float = 0.3
+    ultra_wave: int = 2  # touch no touch etc
+    channel_mode: int = 0  # line mode is grid single double or single2
+    channel_width: int = 25
+    rain_tactics: int = 0
+    blade_height: int = 0
+    path_order: str = ""
+    toward: int = 0  # is just angle
+    toward_included_angle: int = 0
+    toward_mode: int = 0  # angle type relative etc
+    border_mode: int = 1  # border laps
+    obstacle_laps: int = 1
+    start_progress: int = 0
+
+
+def create_path_order(operation_mode: OperationSettings, device_name: str) -> str:
+    i = 8
+    bArr = bytearray(8)
+    bArr[0] = operation_mode.border_mode
+    bArr[1] = operation_mode.obstacle_laps
+    bArr[3] = operation_mode.start_progress
+    bArr[2] = 0
+
+    if not DeviceType.is_luba1(device_name):
+        bArr[4] = 0
+        if DeviceType.is_yuka(device_name):
+            i = calculate_yuka_mode(operation_mode)
+        elif not DeviceType.is_luba_2(device_name):
+            i = 0
+        bArr[5] = i
+        if operation_mode.is_dump:
+            b = operation_mode.collect_grass_frequency
+        else:
+            b = 10
+        bArr[6] = b
+    if DeviceType.is_luba1(device_name):
+        bArr[4] = operation_mode.toward_mode
+    return str(bArr, "UTF-8")
+
+
+def calculate_yuka_mode(operation_mode: OperationSettings) -> int:
+    if operation_mode.is_mow and operation_mode.is_dump and operation_mode.is_edge:
+        return 14
+    if operation_mode.is_mow and operation_mode.is_dump and not operation_mode.is_edge:
+        return 12
+    if operation_mode.is_mow and not operation_mode.is_dump and operation_mode.is_edge:
+        return 10
+    if operation_mode.is_mow and not operation_mode.is_dump and not operation_mode.is_edge:
+        return 8
+    if not operation_mode.is_mow and operation_mode.is_dump and operation_mode.is_edge:
+        return 6
+    if not operation_mode.is_mow and not operation_mode.is_dump and operation_mode.is_edge:
+        return 2
+    if not operation_mode.is_mow and operation_mode.is_dump and not operation_mode.is_edge:
+        return 4
+    return 0

pymammotion/data/model/enums.py

@@ -9,7 +9,7 @@ class PositionMode(Enum):
     UNKNOWN = 4
 
     @staticmethod
-    def from_value(value):
+    def from_value(value: int):
         if value == 0:
             return PositionMode.FIX
         elif value == 1:
@@ -21,7 +21,7 @@ class PositionMode(Enum):
         else:
             return PositionMode.UNKNOWN
 
-    def __str__(self):
+    def __str__(self) -> str:
         if self == PositionMode.FIX:
             return "Fix"
         elif self == PositionMode.SINGLE:
@@ -42,7 +42,7 @@ class RTKStatus(Enum):
     UNKNOWN = 6
 
     @staticmethod
-    def from_value(value):
+    def from_value(value: int):
         if value == 0:
             return RTKStatus.NONE
         elif value == 1 or value == 2:
@@ -54,7 +54,7 @@ class RTKStatus(Enum):
         else:
             return RTKStatus.UNKNOWN
 
-    def __str__(self):
+    def __str__(self) -> str:
         if self == RTKStatus.NONE:
             return "None"
         elif self == RTKStatus.SINGLE:

pymammotion/data/model/excute_boarder_params.py

@@ -5,7 +5,7 @@ class ExecuteBorderParams:
     currentFrame = 0
     jobIndex = ""
 
-    def __init__(self, i, str_, list_):
+    def __init__(self, i, str_, list_) -> None:
         """Generated source for method __init__"""
         self.currentFrame = i
         self.border = list_
@@ -15,7 +15,7 @@ class ExecuteBorderParams:
         """Generated source for method getCurrentFrame"""
         return self.currentFrame
 
-    def set_current_frame(self, i):
+    def set_current_frame(self, i) -> None:
         """Generated source for method setCurrentFrame"""
         self.currentFrame = i
 
@@ -23,7 +23,7 @@ class ExecuteBorderParams:
         """Generated source for method getJobIndex"""
         return self.jobIndex
 
-    def set_job_index(self, str_):
+    def set_job_index(self, str_) -> None:
         """Generated source for method setJobIndex"""
         self.jobIndex = str_
 
@@ -31,11 +31,11 @@ class ExecuteBorderParams:
         """Generated source for method getBorder"""
         return self.border
 
-    def set_border(self, border_list):
+    def set_border(self, border_list) -> None:
         """Generated source for method setBorder"""
         self.border = border_list
 
-    def __str__(self):
+    def __str__(self) -> str:
         """Generated source for method toString"""
         return (
             "ExecuteBorderParamsBean{currentFrame="

pymammotion/data/model/execute_boarder.py

@@ -9,7 +9,7 @@ class ExecuteBorder(Serializable):
     cmd = 0
     params = ExecuteBorderParams(None, None, None)
 
-    def __init__(self, i, execute_border_params: ExecuteBorderParams):
+    def __init__(self, i, execute_border_params: ExecuteBorderParams) -> None:
         """Generated source for method __init__"""
         super().__init__()
         self.cmd = i
@@ -19,7 +19,7 @@ class ExecuteBorder(Serializable):
         """Generated source for method getCmd"""
         return self.cmd
 
-    def set_cmd(self, i):
+    def set_cmd(self, i) -> None:
         """Generated source for method setCmd"""
         self.cmd = i
 
@@ -27,10 +27,10 @@ class ExecuteBorder(Serializable):
         """Generated source for method getParams"""
         return self.params
 
-    def set_params(self, execute_border_params):
+    def set_params(self, execute_border_params) -> None:
         """Generated source for method setParams"""
         self.params = execute_border_params
 
-    def __str__(self):
+    def __str__(self) -> str:
         """Generated source for method toString"""
         return "ExecuteBean{cmd=" + self.cmd + ", params=" + self.params + "}"

pymammotion/data/model/generate_route_information.py

@@ -1,133 +1,27 @@
 import logging
+from dataclasses import dataclass
 from typing import List
 
 logger = logging.getLogger(__name__)
 
 
+@dataclass
 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)
+    one_hashs: list[int] = list
+    job_mode: int = 0  # taskMode
+    job_version: int = 0
+    job_id: int = 0
+    speed: float = 0.3
+    ultra_wave: int = 2  # touch no touch etc
+    channel_mode: int = 0  # line mode is grid single double or single2
+    channel_width: int = 25
+    rain_tactics: int = 0
+    blade_height: int = 0
+    path_order: str = ""
+    toward: int = 0  # is just angle
+    toward_included_angle: int = 0
+    toward_mode: int = 0  # angle type relative etc
+    edge_mode: int = 1  # border laps
+    obstacle_laps: int = 1

pymammotion/data/model/hash_list.py

@@ -6,10 +6,12 @@ from pymammotion.proto.mctrl_nav import NavGetCommDataAck
 
 class PathType(IntEnum):
     """Path types for common data."""
+
     AREA = 0
     OBSTACLE = 1
     PATH = 2
 
+
 @dataclass
 class FrameList:
     total_frame: int
@@ -28,13 +30,12 @@ class HashList:
     obstacle: dict  # type 1
     hashlist: list[int]
 
-    def set_hashlist(self, hashlist: list[int]):
+    def set_hashlist(self, hashlist: list[int]) -> None:
         self.hashlist = hashlist
         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}
 
-
     def missing_frame(self, hash_data: NavGetCommDataAck) -> list[int]:
         if hash_data.type == PathType.AREA:
             return self._find_missing_frames(self.area.get(hash_data.hash))
@@ -45,8 +46,6 @@ class HashList:
         if hash_data.type == PathType.PATH:
             return self._find_missing_frames(self.path.get(hash_data.hash))
 
-
-
     def update(self, hash_data: NavGetCommDataAck) -> bool:
         """Update the map data."""
         if hash_data.type == PathType.AREA:
@@ -58,18 +57,16 @@ class HashList:
         if hash_data.type == PathType.PATH:
             return self._add_hash_data(self.path, hash_data)
 
-
     @staticmethod
     def _find_missing_frames(frame_list: FrameList) -> list[int]:
         if frame_list.total_frame == len(frame_list.data):
             return []
-        number_list = list(range(1, frame_list.total_frame+1))
+        number_list = list(range(1, frame_list.total_frame + 1))
 
         current_frames = {frame.current_frame for frame in frame_list.data}
         missing_numbers = [num for num in number_list if num not in current_frames]
         return missing_numbers
 
-
     @staticmethod
     def _add_hash_data(hash_dict: dict, hash_data: NavGetCommDataAck) -> bool:
         if hash_dict.get(hash_data.hash) is None:

pymammotion/data/model/location.py

@@ -10,7 +10,7 @@ class Point:
     latitude: float = 0.0
     longitude: float = 0.0
 
-    def __init__(self, latitude=0.0, longitude=0.0):
+    def __init__(self, latitude: float = 0.0, longitude: float = 0.0) -> None:
         self.latitude = latitude
         self.longitude = longitude
 
@@ -30,10 +30,10 @@ class Location:
     RTK: Point
     dock: Dock
     position_type: int = 0
-    orientation: int = 0 # 360 degree rotation +-
+    orientation: int = 0  # 360 degree rotation +-
     work_zone: int = 0
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.device = Point()
         self.RTK = Point()
         self.dock = Dock()

pymammotion/data/model/mowing_modes.py

@@ -51,4 +51,4 @@ class PathAngleSetting(IntEnum):
 
     relative_angle = 0
     absolute_angle = 1
-    random_angle = 2 # Luba Pro / Luba 2 Yuka only
+    random_angle = 2  # Luba Pro / Luba 2 Yuka only

pymammotion/data/model/plan.py

@@ -2,7 +2,7 @@ from typing import List
 
 
 class Plan:
-    def __init__(self):
+    def __init__(self) -> None:
         self.pver: int = 0
         self.sub_cmd: int = 0
         self.area: int = 0
@@ -31,9 +31,9 @@ class Plan:
         self.speed: float = 0.0
         self.task_name: str = ""
         self.job_name: str = ""
-        self.zone_hashs: List[int] = []
+        self.zone_hashs: list[int] = []
         self.reserved: str = ""
-        self.weeks: List[int] = []
+        self.weeks: list[int] = []
         self.start_date: str = ""
         self.end_date: str = ""
         self.job_type: int = 0
@@ -46,7 +46,7 @@ class Plan:
         self.path_order: int = 0
         self.demond_angle: int = 90
 
-    def __str__(self):
+    def __str__(self) -> str:
         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):

pymammotion/data/model/region_data.py

@@ -2,7 +2,7 @@ from typing import List, Optional
 
 
 class RegionData:
-    def __init__(self):
+    def __init__(self) -> None:
         self.hash: Optional[int] = None
         self.action: int = 0
         self.current_frame: int = 0
@@ -10,7 +10,7 @@ class RegionData:
         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.path: Optional[list[list[float]]] = None
         self.pver: int = 0
         self.result: int = 0
         self.sub_cmd: int = 0
@@ -68,10 +68,10 @@ class RegionData:
     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) -> Optional[list[list[float]]]:
         return self.path
 
-    def set_path(self, path: List[List[float]]) -> None:
+    def set_path(self, path: list[list[float]]) -> None:
         self.path = path
 
     def get_hash(self) -> Optional[int]:

pymammotion/data/model/report_info.py

@@ -8,7 +8,7 @@ class ConnectData:
     wifi_rssi: int = 0
 
     @classmethod
-    def from_dict(cls, data: dict):
+    def from_dict(cls, data: dict) -> "ConnectData":
         return cls(
             connect_type=data.get("connect_type", 0),
             ble_rssi=data.get("ble_rssi", 0),