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

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):
@@ -45,23 +45,25 @@ class DeviceWarningEventValue(DataClassORJSONMixin):
     # (see resources/res/values-en-rUS/strings.xml in APK)
     code: int
 
+
 @dataclass
 class DeviceConfigurationRequestValue(DataClassORJSONMixin):
     code: int
     bizId: str
     params: str
 
+
 @dataclass
 class DeviceNotificationEventCode(DataClassORJSONMixin):
     localTime: int
     code: str
 
+
 @dataclass
 class DeviceNotificationEventValue(DataClassORJSONMixin):
     data: DeviceNotificationEventCode
 
 
-
 @dataclass
 class GeneralParams(DataClassORJSONMixin):
     groupIdList: list[str]
@@ -100,6 +102,7 @@ class DeviceProtobufMsgEventParams(GeneralParams):
     type: Literal["info"]
     value: DeviceProtobufMsgEventValue
 
+
 @dataclass
 class DeviceNotificationEventParams(GeneralParams):
     """Device notification event.
@@ -111,12 +114,14 @@ class DeviceNotificationEventParams(GeneralParams):
     type: Literal["info"]
     value: DeviceNotificationEventValue
 
+
 @dataclass
 class DeviceWarningEventParams(GeneralParams):
     identifier: Literal["device_warning_event"]
     type: Literal["alert"]
     value: DeviceWarningEventValue
 
+
 @dataclass
 class DeviceConfigurationRequestEvent(GeneralParams):
     type: Literal["info"]
@@ -127,7 +132,7 @@ class DeviceConfigurationRequestEvent(GeneralParams):
 class ThingEventMessage(DataClassORJSONMixin):
     method: Literal["thing.events", "thing.properties"]
     id: str
-    params: Union[DeviceProtobufMsgEventParams, DeviceWarningEventParams, str]
+    params: Union[DeviceProtobufMsgEventParams, DeviceWarningEventParams, dict]
     version: Literal["1.0"]
 
     @classmethod

pymammotion/data/state_manager.py

@@ -1,4 +1,5 @@
 """Manage state from notifications into MowingDevice."""
+
 from typing import Optional, Callable, Awaitable
 
 import betterproto
@@ -13,21 +14,21 @@ 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
-        self.on_notification_callback: Optional[Callable[[],Awaitable[None]]] = None
+        self.gethash_ack_callback: Optional[Callable[[NavGetHashListAck], Awaitable[None]]] = None
+        self.get_commondata_ack_callback: Optional[Callable[[NavGetCommDataAck], Awaitable[None]]] = None
+        self.on_notification_callback: Optional[Callable[[], Awaitable[None]]] = None
 
     def get_device(self) -> MowingDevice:
         """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")
 
@@ -48,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]:
@@ -62,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]:
@@ -75,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,59 +1,48 @@
-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) -> list[ErrorInfo]:
+        async with ClientSession(MAMMOTION_API_DOMAIN) as session:
+            async with session.post(
+                "/user-server/v1/code/record/export-data",
+                headers=self._headers,
+            ) as 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]:
         async with session.post(
@@ -66,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
                 )
             )
         )