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

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/hash_list.py

@@ -30,7 +30,7 @@ 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}

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
 
@@ -33,7 +33,7 @@ class Location:
     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/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),

pymammotion/data/mqtt/event.py

@@ -10,7 +10,7 @@ from pymammotion.proto import luba_msg_pb2
 
 
 class Base64EncodedProtobuf(SerializableType):
-    def __init__(self, proto: str):
+    def __init__(self, proto: str) -> None:
         self.proto = proto
 
     def _serialize(self):

pymammotion/data/state_manager.py

@@ -14,7 +14,7 @@ class StateManager:
 
     _device: MowingDevice
 
-    def __init__(self, device: MowingDevice):
+    def __init__(self, device: MowingDevice) -> None:
         self._device = device
         self.gethash_ack_callback: Optional[Callable[[NavGetHashListAck], Awaitable[None]]] = None
         self.get_commondata_ack_callback: Optional[Callable[[NavGetCommDataAck], Awaitable[None]]] = None
@@ -24,11 +24,11 @@ class StateManager:
         """Get device."""
         return self._device
 
-    def set_device(self, device: MowingDevice):
+    def set_device(self, device: MowingDevice) -> None:
         """Set device."""
         self._device = device
 
-    async def notification(self, message: LubaMsg):
+    async def notification(self, message: LubaMsg) -> None:
         """Handle protobuf notifications."""
         res = betterproto.which_one_of(message, "LubaSubMsg")
 
@@ -49,7 +49,7 @@ class StateManager:
         if self.on_notification_callback:
             await self.on_notification_callback()
 
-    async def _update_nav_data(self, message):
+    async def _update_nav_data(self, message) -> None:
         """Update nav data."""
         nav_msg = betterproto.which_one_of(message.nav, "SubNavMsg")
         match nav_msg[0]:
@@ -63,7 +63,7 @@ class StateManager:
                 if updated:
                     await self.get_commondata_ack_callback(common_data)
 
-    def _update_sys_data(self, message):
+    def _update_sys_data(self, message) -> None:
         """Update system."""
         sys_msg = betterproto.which_one_of(message.sys, "SubSysMsg")
         match sys_msg[0]:
@@ -76,14 +76,14 @@ class StateManager:
             case "system_tard_state_tunnel":
                 self._device.run_state_update(sys_msg[1])
 
-    def _update_driver_data(self, message):
+    def _update_driver_data(self, message) -> None:
         pass
 
-    def _update_net_data(self, message):
+    def _update_net_data(self, message) -> None:
         pass
 
-    def _update_mul_data(self, message):
+    def _update_mul_data(self, message) -> None:
         pass
 
-    def _update_ota_data(self, message):
+    def _update_ota_data(self, message) -> None:
         pass

pymammotion/event/event.py

@@ -2,7 +2,7 @@ import asyncio
 
 
 class Event:
-    def __init__(self):
+    def __init__(self) -> None:
         self.__eventhandlers = []
 
     def __iadd__(self, handler):
@@ -13,53 +13,53 @@ class Event:
         self.__eventhandlers.remove(handler)
         return self
 
-    async def __call__(self, *args, **kwargs):
+    async def __call__(self, *args, **kwargs) -> None:
         await asyncio.gather(*[handler(*args, **kwargs) for handler in self.__eventhandlers])
 
 
 class MoveEvent:
-    def __init__(self):
+    def __init__(self) -> None:
         self.OnMoveFinished = Event()
 
-    async def MoveFinished(self):
+    async def MoveFinished(self) -> None:
         # This function will be executed once blufi finishes after a movement command and will
         # raise an event
         await self.OnMoveFinished()
 
-    def AddSubscribersForMoveFinishedEvent(self, objMethod):
+    def AddSubscribersForMoveFinishedEvent(self, objMethod) -> None:
         self.OnMoveFinished += objMethod
 
-    def RemoveSubscribersForMoveFinishedEvent(self, objMethod):
+    def RemoveSubscribersForMoveFinishedEvent(self, objMethod) -> None:
         self.OnMoveFinished -= objMethod
 
 
 class BleNotificationEvent:
-    def __init__(self):
+    def __init__(self) -> None:
         self.OnBleNotification = Event()
 
-    async def BleNotification(self, data: bytearray):
+    async def BleNotification(self, data: bytearray) -> None:
         # This function will be executed when data is received.
         await self.OnBleNotification(data)
 
-    def AddSubscribersForBleNotificationEvent(self, objMethod):
+    def AddSubscribersForBleNotificationEvent(self, objMethod) -> None:
         self.OnBleNotification += objMethod
 
-    def RemoveSubscribersForBleNotificationEvent(self, objMethod):
+    def RemoveSubscribersForBleNotificationEvent(self, objMethod) -> None:
         self.OnBleNotification -= objMethod
 
 
 class DataEvent:
     """Callbacks for data events."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.on_data_event = Event()
 
-    async def data_event(self, data):
+    async def data_event(self, data) -> None:
         # This function will be executed when data is received.
         await self.on_data_event(data)
 
-    def add_subscribers(self, obj_method):
+    def add_subscribers(self, obj_method) -> None:
         self.on_data_event += obj_method
 
-    def remove_subscribers(self, obj_method):
+    def remove_subscribers(self, obj_method) -> None:
         self.on_data_event -= obj_method

pymammotion/http/http.py

@@ -1,68 +1,47 @@
-from dataclasses import dataclass
-from typing import Generic, Literal, Optional, TypeVar
+import csv
+from typing import cast
 
 from aiohttp import ClientSession
-from aiohttp.hdrs import AUTHORIZATION
-from mashumaro import DataClassDictMixin
-from mashumaro.mixins.orjson import DataClassORJSONMixin
 
-from pymammotion.aliyun.dataclass.connect_response import Device
 from pymammotion.const import (
+    MAMMOTION_API_DOMAIN,
     MAMMOTION_CLIENT_ID,
     MAMMOTION_CLIENT_SECRET,
     MAMMOTION_DOMAIN,
 )
-
-DataT = TypeVar("DataT")
-
-
-@dataclass
-class Response(DataClassDictMixin, Generic[DataT]):
-    code: int
-    msg: str
-    data: DataT | None = None
-
-
-@dataclass
-class LoginResponseUserInformation(DataClassORJSONMixin):
-    areaCode: str
-    domainAbbreviation: str
-    email: Optional[str]
-    userId: str
-    userAccount: str
-    authType: str
-
-
-@dataclass
-class LoginResponseData(DataClassORJSONMixin):
-    access_token: str
-    token_type: Literal["bearer"]
-    refresh_token: str
-    expires_in: int
-    scope: Literal["read"]
-    grant_type: Literal["password"]
-    authorization_code: str
-    userInformation: LoginResponseUserInformation
-    jti: str
+from pymammotion.http.model.http import ErrorInfo, LoginResponseData, Response
 
 
 class MammotionHTTP:
-    def __init__(self, response: Response):
+    def __init__(self, response: Response) -> None:
         self._headers = dict()
         self.login_info = LoginResponseData.from_dict(response.data) if response.data else None
         self._headers["Authorization"] = f"Bearer {self.login_info.access_token}" if response.data else None
         self.msg = response.msg
         self.code = response.code
 
-    async def get_all_error_codes(self):
-        async with ClientSession() as session:
+    async def get_all_error_codes(self) -> list[ErrorInfo]:
+        async with ClientSession(MAMMOTION_API_DOMAIN) as session:
             async with session.post(
-                "code/record/export-data",
+                "/user-server/v1/code/record/export-data",
                 headers=self._headers,
             ) as resp:
-                if resp.status == 200:
-                    data = await resp.json()
-                print(resp)
+                data = await resp.json()
+                reader = csv.DictReader(data.get("data", "").split("\n"), delimiter=",")
+                codes = []
+                for row in reader:
+                    codes.append(ErrorInfo(**cast(row, dict)))
+                return codes
+
+    async def oauth_check(self) -> None:
+        """Check if token is valid.
+
+        Returns 401 if token is invalid. We then need to re-authenticate, can try to refresh token first
+        """
+        async with ClientSession(MAMMOTION_API_DOMAIN) as session:
+            async with session.post("/user-server/v1/user/oauth/check") as resp:
+                data = await resp.json()
+                response = Response.from_dict(data)
 
     @classmethod
     async def login(cls, session: ClientSession, username: str, password: str) -> Response[LoginResponseData]:
@@ -76,12 +55,11 @@ class MammotionHTTP:
                 grant_type="password",
             ),
         ) as resp:
-            if resp.status == 200:
-                data = await resp.json()
-                response = Response.from_dict(data)
-                # TODO catch errors from mismatch user / password elsewhere
-                # Assuming the data format matches the expected structure
-                return response
+            data = await resp.json()
+            response = Response.from_dict(data)
+            # TODO catch errors from mismatch user / password elsewhere
+            # Assuming the data format matches the expected structure
+            return response
 
 
 async def connect_http(username: str, password: str) -> MammotionHTTP:

pymammotion/http/model/http.py

@@ -0,0 +1,75 @@
+from dataclasses import dataclass
+from typing import Generic, Literal, Optional, TypeVar
+
+from mashumaro import DataClassDictMixin
+from mashumaro.mixins.orjson import DataClassORJSONMixin
+
+DataT = TypeVar("DataT")
+
+
+@dataclass
+class ErrorInfo:
+    code: str
+    platform: str
+    module: str
+    variant: str
+    level: str
+    description: str
+    en_implication: str
+    en_solution: str
+    zh_implication: str
+    zh_solution: str
+    de_implication: str
+    de_solution: str
+    fr_implication: str
+    fr_solution: str
+    it_implication: str
+    it_solution: str
+    es_implication: str
+    es_solution: str
+    cs_implication: str
+    cs_solution: str
+    sk_implication: str
+    sk_solution: str
+    pl_implication: str
+    pl_solution: str
+    nl_implication: str
+    nl_solution: str
+    da_implication: str
+    da_solution: str
+    sv_implication: str
+    sv_solution: str
+    sl_implication: str
+    sl_solution: str
+    pt_implication: str
+    pt_solution: str
+
+
+@dataclass
+class Response(DataClassDictMixin, Generic[DataT]):
+    code: int
+    msg: str
+    data: DataT | None = None
+
+
+@dataclass
+class LoginResponseUserInformation(DataClassORJSONMixin):
+    areaCode: str
+    domainAbbreviation: str
+    email: Optional[str]
+    userId: str
+    userAccount: str
+    authType: str
+
+
+@dataclass
+class LoginResponseData(DataClassORJSONMixin):
+    access_token: str
+    token_type: Literal["bearer"]
+    refresh_token: str
+    expires_in: int
+    scope: Literal["read"]
+    grant_type: Literal["password"]
+    authorization_code: str
+    userInformation: LoginResponseUserInformation
+    jti: str

pymammotion/mammotion/commands/messages/driver.py

@@ -4,7 +4,8 @@ from abc import ABC
 from logging import getLogger
 
 from pymammotion.mammotion.commands.abstract_message import AbstractMessage
-from pymammotion.proto import luba_msg_pb2, mctrl_driver_pb2
+from pymammotion.proto import mctrl_driver
+from pymammotion.proto.luba_msg import LubaMsg, MsgAttr, MsgCmdType, MsgDevice
 
 logger = getLogger(__name__)
 
@@ -12,42 +13,38 @@ logger = getLogger(__name__)
 class MessageDriver(AbstractMessage, ABC):
     @staticmethod
     def send_order_msg_driver(driver):
-        luba_msg = luba_msg_pb2.LubaMsg(
-            msgtype=luba_msg_pb2.MSG_CMD_TYPE_EMBED_DRIVER,
-            sender=luba_msg_pb2.DEV_MOBILEAPP,
-            rcver=luba_msg_pb2.DEV_MAINCTL,
-            msgattr=luba_msg_pb2.MSG_ATTR_REQ,
+        return LubaMsg(
+            msgtype=MsgCmdType.MSG_CMD_TYPE_EMBED_DRIVER,
+            sender=MsgDevice.DEV_MOBILEAPP,
+            rcver=MsgDevice.DEV_MAINCTL,
+            msgattr=MsgAttr.MSG_ATTR_REQ,
             timestamp=round(time.time() * 1000),
             seqs=1,
             version=1,
             subtype=1,
             driver=driver,
-        )
-
-        return luba_msg.SerializeToString()
+        ).SerializeToString()
 
     def set_blade_height(self, height: int):
         logger.debug(f"Send knife height height={height}")
-        build = mctrl_driver_pb2.MctlDriver(todev_knife_height_set=mctrl_driver_pb2.DrvKnifeHeight(knifeHeight=height))
+        build = mctrl_driver.MctlDriver(todev_knife_height_set=mctrl_driver.DrvKnifeHeight(knifeHeight=height))
         logger.debug(f"Send command--Knife motor height setting height={height}")
         return self.send_order_msg_driver(build)
 
     def set_speed(self, speed: float):
         logger.debug(f"{self.get_device_name()} set speed, {speed}")
-        build = mctrl_driver_pb2.MctlDriver(bidire_speed_read_set=mctrl_driver_pb2.DrvSrSpeed(speed=speed, rw=1))
+        build = mctrl_driver.MctlDriver(bidire_speed_read_set=mctrl_driver.DrvSrSpeed(speed=speed, rw=1))
         logger.debug(f"Send command--Speed setting speed={speed}")
         return self.send_order_msg_driver(build)
 
     def syn_nav_star_point_data(self, sat_system: int):
-        build = mctrl_driver_pb2.MctlDriver(
-            rtk_sys_mask_query=mctrl_driver_pb2.rtk_sys_mask_query_t(sat_system=sat_system)
-        )
+        build = mctrl_driver.MctlDriver(rtk_sys_mask_query=mctrl_driver.RtkSysMaskQueryT(sat_system=sat_system))
         logger.debug(f"Send command--Navigation satellite frequency point synchronization={sat_system}")
         return self.send_order_msg_driver(build)
 
     def set_nav_star_point(self, cmd_req: str):
-        build = mctrl_driver_pb2.MctlDriver(
-            rtk_cfg_req=mctrl_driver_pb2.rtk_cfg_req_t(cmd_req=cmd_req, cmd_length=len(cmd_req) - 1)
+        build = mctrl_driver.MctlDriver(
+            rtk_cfg_req=mctrl_driver.RtkCfgReqT(cmd_req=cmd_req, cmd_length=len(cmd_req) - 1)
         )
         logger.debug(f"Send command--Navigation satellite frequency point setting={cmd_req}")
         logger.debug(
@@ -56,7 +53,7 @@ class MessageDriver(AbstractMessage, ABC):
         return self.send_order_msg_driver(build)
 
     def get_speed(self):
-        build = mctrl_driver_pb2.MctlDriver(bidire_speed_read_set=mctrl_driver_pb2.DrvSrSpeed(rw=0))
+        build = mctrl_driver.MctlDriver(bidire_speed_read_set=mctrl_driver.DrvSrSpeed(rw=0))
         logger.debug("Send command--Get speed value")
         return self.send_order_msg_driver(build)
 
@@ -67,12 +64,12 @@ class MessageDriver(AbstractMessage, ABC):
         cut_knife_height: int,
         max_run_speed: float,
     ):
-        build = mctrl_driver_pb2.MctlDriver(
-            mow_ctrl_by_hand=mctrl_driver_pb2.DrvMowCtrlByHand(
+        build = mctrl_driver.MctlDriver(
+            mow_ctrl_by_hand=mctrl_driver.DrvMowCtrlByHand(
                 main_ctrl=main_ctrl,
                 cut_knife_ctrl=cut_knife_ctrl,
                 cut_knife_height=cut_knife_height,
-                max_run_Speed=max_run_speed,
+                max_run__speed=max_run_speed,
             )
         )
         logger.debug(
@@ -86,9 +83,9 @@ class MessageDriver(AbstractMessage, ABC):
         logger.debug(f"Control command print, linearSpeed={
         linear_speed} // angularSpeed={angular_speed}")
         return self.send_order_msg_driver(
-            mctrl_driver_pb2.MctlDriver(
-                todev_devmotion_ctrl=mctrl_driver_pb2.DrvMotionCtrl(
-                    setLinearSpeed=linear_speed, setAngularSpeed=angular_speed
+            mctrl_driver.MctlDriver(
+                todev_devmotion_ctrl=mctrl_driver.DrvMotionCtrl(
+                    set_linear_speed=linear_speed, set_angular_speed=angular_speed
                 )
             )
         )