pymammotion 0.4.55__py3-none-any.whl → 0.4.57__py3-none-any.whl

pymammotion/aliyun/client.py

@@ -1,3 +1,4 @@
+from datetime import UTC, datetime
 import time
 
 from Tea.exceptions import UnretryableException
@@ -103,7 +104,7 @@ class Client:
                 _request.headers = TeaCore.merge(
                     {
                         "host": self._domain,
-                        "date": UtilClient.get_date_utcstring(),
+                        "date": datetime.now(UTC).strftime("%a, %d %b %Y %H:%M:%S GMT"),
                         "x-ca-nonce": UtilClient.get_nonce(),
                         "x-ca-key": self._app_key,
                         "x-ca-signaturemethod": "HmacSHA256",

pymammotion/aliyun/cloud_gateway.py

@@ -15,8 +15,8 @@ from aiohttp import ClientSession, ConnectionTimeoutError
 from alibabacloud_iot_api_gateway.models import CommonParams, Config, IoTApiRequest
 from alibabacloud_tea_util.client import Client as UtilClient
 from alibabacloud_tea_util.models import RuntimeOptions
-from Tea.exceptions import UnretryableException
 from orjson.orjson import JSONDecodeError
+from Tea.exceptions import UnretryableException
 
 from pymammotion.aliyun.client import Client
 from pymammotion.aliyun.model.aep_response import AepResponse
@@ -65,6 +65,14 @@ class DeviceOfflineException(Exception):
         self.iot_id = args[1]
 
 
+class FailedRequestException(Exception):
+    """Raise exception when request response is bad."""
+
+    def __init__(self, *args: object) -> None:
+        super().__init__(args)
+        self.iot_id = args[0]
+
+
 class NoConnectionException(UnretryableException):
     """Raise exception when device is unreachable."""
 
@@ -145,7 +153,7 @@ class CloudIOTGateway:
             return json.loads(response_body_str) if response_body_str is not None else {}
         except JSONDecodeError:
             logger.error("Couldn't decode message %s", response_body_str)
-            return {}
+            return {'code': 22000}
 
     def sign(self, data):
         """Generate signature for the given data."""
@@ -739,7 +747,6 @@ class CloudIOTGateway:
         logger.debug(response.body)
         logger.debug(iot_id)
 
-
         response_body_str = response.body.decode("utf-8")
         response_body_dict = self.parse_json_response(response_body_str)
 
@@ -749,6 +756,9 @@ class CloudIOTGateway:
                 str(response_body_dict.get("code")),
                 str(response_body_dict.get("message")),
             )
+            if response_body_dict.get("code") == 22000:
+                logger.error(response)
+                raise FailedRequestException(iot_id)
             if response_body_dict.get("code") == 20056:
                 logger.debug("Gateway timeout.")
                 raise GatewayTimeoutException(response_body_dict.get("code"), iot_id)

pymammotion/data/model/device.py

@@ -12,7 +12,7 @@ from pymammotion.data.model.report_info import ReportData
 from pymammotion.data.model.work import CurrentTaskSettings
 from pymammotion.data.mqtt.properties import ThingPropertiesMessage
 from pymammotion.data.mqtt.status import ThingStatusMessage
-from pymammotion.http.model.http import ErrorInfo
+from pymammotion.http.model.http import CheckDeviceVersion, ErrorInfo
 from pymammotion.proto import DeviceFwInfo, MowToAppInfoT, ReportInfoData, SystemRapidStateTunnelMsg, SystemUpdateBufMsg
 from pymammotion.utility.constant import WorkMode
 from pymammotion.utility.conversions import parse_double
@@ -26,6 +26,7 @@ class MowingDevice(DataClassORJSONMixin):
     name: str = ""
     online: bool = True
     enabled: bool = True
+    update_check: CheckDeviceVersion = field(default_factory=CheckDeviceVersion)
     mower_state: MowerInfo = field(default_factory=MowerInfo)
     mqtt_properties: ThingPropertiesMessage | None = None
     status_properties: ThingStatusMessage | None = None

pymammotion/data/mqtt/properties.py

@@ -15,85 +15,95 @@ class Item(DataClassDictMixin, Generic[DataT]):
 
 @dataclass
 class BatteryPercentageItems(DataClassORJSONMixin):
-    batteryPercentage: Item[int]
+    batteryPercentage: int
 
 
 @dataclass
 class BMSHardwareVersionItems(DataClassORJSONMixin):
-    bmsHardwareVersion: Item[str]
+    bmsHardwareVersion: str
 
 
 @dataclass
 class CoordinateItems(DataClassORJSONMixin):
-    coordinate: Item[str]  # '{"lon":0.303903,"lat":1.051868}'
+    coordinate: str  # '{"lon":0.303903,"lat":1.051868}'
 
 
 @dataclass
 class DeviceStateItems(DataClassORJSONMixin):
-    deviceState: Item[int]
+    deviceState: int
 
 
 @dataclass
 class DeviceVersionItems(DataClassORJSONMixin):
-    deviceVersion: Item[str]
+    deviceVersion: str
 
 
 @dataclass
 class DeviceVersionInfoItems(DataClassORJSONMixin):
-    deviceVersionInfo: Item[str]
+    deviceVersionInfo: str
 
 
 @dataclass
 class ESP32VersionItems(DataClassORJSONMixin):
-    esp32Version: Item[str]
+    esp32Version: str
 
 
 @dataclass
 class LeftMotorBootVersionItems(DataClassORJSONMixin):
-    leftMotorBootVersion: Item[str]
+    leftMotorBootVersion: str
 
 
 @dataclass
 class LeftMotorVersionItems(DataClassORJSONMixin):
-    leftMotorVersion: Item[str]
+    leftMotorVersion: str
 
 
 @dataclass
 class MCBootVersionItems(DataClassORJSONMixin):
-    mcBootVersion: Item[str]
+    mcBootVersion: str
 
 
 @dataclass
 class NetworkInfoItems(DataClassORJSONMixin):
-    networkInfo: Item[str]
+    networkInfo: str
 
 
 @dataclass
 class RightMotorBootVersionItems(DataClassORJSONMixin):
-    rightMotorBootVersion: Item[str]
+    rightMotorBootVersion: str
 
 
 @dataclass
 class RightMotorVersionItems(DataClassORJSONMixin):
-    rightMotorVersion: Item[str]
+    rightMotorVersion: str
 
 
 @dataclass
 class RTKVersionItems(DataClassORJSONMixin):
-    rtkVersion: Item[str]
+    rtkVersion: str
 
 
 @dataclass
 class StationRTKVersionItems(DataClassORJSONMixin):
-    stationRtkVersion: Item[str]
+    stationRtkVersion: str
 
 
 @dataclass
 class STM32H7VersionItems(DataClassORJSONMixin):
-    stm32H7Version: Item[str]
+    stm32H7Version: str
 
 
-Items = Union[
+@dataclass
+class OTAProgressItems(DataClassORJSONMixin):
+    result: int
+    otaId: str
+    progress: int
+    message: str
+    version: str
+    properties: str
+
+
+ItemTypes = Union[
     BatteryPercentageItems,
     BMSHardwareVersionItems,
     CoordinateItems,
@@ -110,43 +120,45 @@ Items = Union[
     RTKVersionItems,
     StationRTKVersionItems,
     STM32H7VersionItems,
+    OTAProgressItems,
 ]
 
 
 @dataclass
 class Item:
     time: int
-    value: int | float | str | dict[str, Any]  # Depending on the type of value
+    value: int | float | str | dict[str, Any] | ItemTypes  # Depending on the type of value
 
 
 @dataclass
 class Items:
-    iotState: Item
-    extMod: Item
-    deviceVersionInfo: Item
-    leftMotorBootVersion: Item
-    knifeHeight: Item
-    rtMrMod: Item
-    iotMsgHz: Item
-    iotMsgTotal: Item
-    loraRawConfig: Item
-    loraGeneralConfig: Item
-    leftMotorVersion: Item
-    intMod: Item
-    coordinate: Item
-    bmsVersion: Item
-    rightMotorVersion: Item
-    stm32H7Version: Item
-    rightMotorBootVersion: Item
-    deviceVersion: Item
-    rtkVersion: Item
-    ltMrMod: Item
-    networkInfo: Item
-    bmsHardwareVersion: Item
-    batteryPercentage: Item
-    deviceState: Item
-    deviceOtherInfo: Item
-    mcBootVersion: Item
+    iotState: Item | None = None
+    extMod: Item | None = None
+    deviceVersionInfo: Item | None = None
+    leftMotorBootVersion: Item | None = None
+    knifeHeight: Item | None = None
+    rtMrMod: Item | None = None
+    iotMsgHz: Item | None = None
+    iotMsgTotal: Item | None = None
+    loraRawConfig: Item | None = None
+    loraGeneralConfig: Item | None = None
+    leftMotorVersion: Item | None = None
+    intMod: Item | None = None
+    coordinate: Item | None = None
+    bmsVersion: Item | None = None
+    rightMotorVersion: Item | None = None
+    stm32H7Version: Item | None = None
+    rightMotorBootVersion: Item | None = None
+    deviceVersion: Item | None = None
+    rtkVersion: Item | None = None
+    ltMrMod: Item | None = None
+    networkInfo: Item | None = None
+    bmsHardwareVersion: Item | None = None
+    batteryPercentage: Item | None = None
+    deviceState: Item | None = None
+    deviceOtherInfo: Item | None = None
+    mcBootVersion: Item | None = None
+    otaProgress: Item | None = None
 
 
 @dataclass

pymammotion/data/state_manager.py

@@ -1,7 +1,7 @@
 """Manage state from notifications into MowingDevice."""
 
 from collections.abc import Awaitable, Callable
-from datetime import datetime
+from datetime import UTC, datetime
 import logging
 from typing import Any
 
@@ -41,7 +41,7 @@ class StateManager:
 
     def __init__(self, device: MowingDevice) -> None:
         self._device: MowingDevice = device
-        self.last_updated_at = datetime.now()
+        self.last_updated_at = datetime.now(UTC)
         self.preference = ConnectionPreference.WIFI
         self.cloud_gethash_ack_callback: Callable[[NavGetHashListAck], Awaitable[None]] | None = None
         self.cloud_get_commondata_ack_callback: (
@@ -49,8 +49,7 @@ class StateManager:
         ) = None
         self.cloud_get_plan_callback: Callable[[NavPlanJobSet], Awaitable[None]] | None = None
         self.cloud_on_notification_callback: Callable[[tuple[str, Any | None]], Awaitable[None]] | None = None
-
-        self.cloud_queue_command_callback: Callable[[str, dict[str, Any]], Awaitable[bytes]] | None = None
+        self.cloud_queue_command_callback: Callable[[str, dict[str, Any]], Awaitable[None]] | None = None
 
         self.ble_gethash_ack_callback: Callable[[NavGetHashListAck], Awaitable[None]] | None = None
         self.ble_get_commondata_ack_callback: Callable[[NavGetCommDataAck | SvgMessageAckT], Awaitable[None]] | None = (
@@ -58,8 +57,10 @@ class StateManager:
         )
         self.ble_get_plan_callback: Callable[[NavPlanJobSet], Awaitable[None]] | None = None
         self.ble_on_notification_callback: Callable[[tuple[str, Any | None]], Awaitable[None]] | None = None
+        self.ble_queue_command_callback: Callable[[str, dict[str, Any]], Awaitable[None]] | None = None
 
-        self.ble_queue_command_callback: Callable[[str, dict[str, Any]], Awaitable[bytes]] | None = None
+        self.properties_callback: Callable[[ThingPropertiesMessage], Awaitable[None]] | None = None
+        self.status_callback: Callable[[ThingStatusMessage], Awaitable[None]] | None = None
 
     def get_device(self) -> MowingDevice:
         """Get device."""
@@ -72,6 +73,7 @@ class StateManager:
     def properties(self, thing_properties: ThingPropertiesMessage) -> None:
         # TODO update device based off thing properties
         self._device.mqtt_properties = thing_properties
+        self.on_properties_callback(thing_properties)
 
     def status(self, thing_status: ThingStatusMessage) -> None:
         if not self._device.online:
@@ -79,6 +81,7 @@ class StateManager:
         self._device.status_properties = thing_status
         if self._device.mower_state.product_key == "":
             self._device.mower_state.product_key = thing_status.params.productKey
+        self.on_status_callback(thing_status)
 
     @property
     def online(self) -> bool:
@@ -100,6 +103,16 @@ class StateManager:
         elif self.ble_on_notification_callback:
             await self.ble_on_notification_callback(res)
 
+    async def on_properties_callback(self, thing_properties: ThingPropertiesMessage) -> None:
+        """Check if we have a callback for properties."""
+        if self.properties_callback:
+            await self.properties_callback(thing_properties)
+
+    async def on_status_callback(self, thing_status: ThingStatusMessage) -> None:
+        """Check if we have a callback for status."""
+        if self.status_callback:
+            await self.status_callback(thing_status)
+
     async def get_commondata_ack_callback(self, comm_data: NavGetCommDataAck | SvgMessageAckT) -> None:
         if self.cloud_get_commondata_ack_callback:
             await self.cloud_get_commondata_ack_callback(comm_data)
@@ -115,7 +128,7 @@ class StateManager:
     async def notification(self, message: LubaMsg) -> None:
         """Handle protobuf notifications."""
         res = betterproto.which_one_of(message, "LubaSubMsg")
-        self.last_updated_at = datetime.now()
+        self.last_updated_at = datetime.now(UTC)
         # additional catch all if we don't get a status update
         if not self._device.online:
             self._device.online = True

pymammotion/http/http.py

@@ -6,7 +6,8 @@ from aiohttp import ClientSession
 from pymammotion.const import MAMMOTION_API_DOMAIN, MAMMOTION_CLIENT_ID, MAMMOTION_CLIENT_SECRET, MAMMOTION_DOMAIN
 from pymammotion.http.encryption import EncryptionUtils
 from pymammotion.http.model.camera_stream import StreamSubscriptionResponse, VideoResourceResponse
-from pymammotion.http.model.http import ErrorInfo, LoginResponseData, Response
+from pymammotion.http.model.http import CheckDeviceVersion, ErrorInfo, LoginResponseData, Response
+from pymammotion.http.model.response_factory import response_factory
 
 
 class MammotionHTTP:
@@ -17,7 +18,7 @@ class MammotionHTTP:
         self._password = None
         self.response: Response | None = None
         self.login_info: LoginResponseData | None = None
-        self._headers = {"User-Agent": "okhttp/3.14.9", "App-Version": "google Pixel 2 XL taimen-Android 11,1.11.332"}
+        self._headers = {"User-Agent": "okhttp/4.9.3", "App-Version": "google Pixel 2 XL taimen-Android 11,1.11.332"}
         self.encryption_utils = EncryptionUtils()
 
     @staticmethod
@@ -100,14 +101,16 @@ class MammotionHTTP:
                 headers={
                     "Authorization": f"Bearer {self.login_info.access_token}",
                     "Content-Type": "application/json",
-                    "User-Agent": "okhttp/3.14.9",
+                    "User-Agent": "okhttp/4.9.3",
                 },
             ) as resp:
                 data = await resp.json()
                 # TODO catch errors from mismatch like token expire etc
                 # Assuming the data format matches the expected structure
                 response = Response[StreamSubscriptionResponse].from_dict(data)
-                response.data = StreamSubscriptionResponse.from_dict(data["data"])
+                if response.code != 0:
+                    return response
+                response.data = StreamSubscriptionResponse.from_dict(data.get("data", {}))
                 return response
 
     async def get_stream_subscription_mini_or_x_series(
@@ -131,14 +134,16 @@ class MammotionHTTP:
                 headers={
                     "Authorization": f"Bearer {self.login_info.access_token}",
                     "Content-Type": "application/json",
-                    "User-Agent": "okhttp/3.14.9",
+                    "User-Agent": "okhttp/4.9.3",
                 },
             ) as resp:
                 data = await resp.json()
                 # TODO catch errors from mismatch like token expire etc
                 # Assuming the data format matches the expected structure
                 response = Response[StreamSubscriptionResponse].from_dict(data)
-                response.data = StreamSubscriptionResponse.from_dict(data["data"])
+                if response.code != 0:
+                    return response
+                response.data = StreamSubscriptionResponse.from_dict(data.get("data", {}))
                 return response
 
     async def get_video_resource(self, iot_id: str) -> Response[VideoResourceResponse]:
@@ -149,13 +154,51 @@ class MammotionHTTP:
                 headers={
                     "Authorization": f"Bearer {self.login_info.access_token}",
                     "Content-Type": "application/json",
-                    "User-Agent": "okhttp/3.14.9",
+                    "User-Agent": "okhttp/4.9.3",
                 },
             ) as resp:
                 data = await resp.json()
                 # TODO catch errors from mismatch like token expire etc
                 # Assuming the data format matches the expected structure
-                return Response[VideoResourceResponse].from_dict(data)
+                response = Response[VideoResourceResponse].from_dict(data)
+                if response.code != 0:
+                    return response
+                response.data = VideoResourceResponse.from_dict(data.get("data", {}))
+                return response
+
+    async def get_device_ota_firmware(self, iot_ids: list[str]) -> Response[list[CheckDeviceVersion]]:
+        """Device firmware upgrade check."""
+        async with ClientSession(MAMMOTION_API_DOMAIN) as session:
+            async with session.post(
+                "/device-server/v1/devices/version/check",
+                json={"deviceIds": iot_ids},
+                headers={
+                    "Authorization": f"Bearer {self.login_info.access_token}",
+                    "Content-Type": "application/json",
+                    "User-Agent": "okhttp/4.9.3",
+                },
+            ) as resp:
+                data = await resp.json()
+                # TODO catch errors from mismatch like token expire etc
+                # Assuming the data format matches the expected structure
+                return response_factory(Response[list[CheckDeviceVersion]], data)
+
+    async def start_ota_upgrade(self, iot_id: str, version: str) -> Response[str]:
+        """Device firmware upgrade."""
+        async with ClientSession(MAMMOTION_API_DOMAIN) as session:
+            async with session.post(
+                "/device-server/v1/ota/device/upgrade",
+                json={"deviceId": iot_id, "version": version},
+                headers={
+                    "Authorization": f"Bearer {self.login_info.access_token}",
+                    "Content-Type": "application/json",
+                    "User-Agent": "okhttp/4.9.3",
+                },
+            ) as resp:
+                data = await resp.json()
+                # TODO catch errors from mismatch like token expire etc
+                # Assuming the data format matches the expected structure
+                return response_factory(Response[str], data)
 
     async def refresh_login(self, account: str, password: str | None = None) -> Response[LoginResponseData]:
         if self._password is None and password is not None:
@@ -171,7 +214,7 @@ class MammotionHTTP:
             async with session.post(
                 "/oauth/token",
                 headers={
-                    "User-Agent": "okhttp/3.14.9",
+                    "User-Agent": "okhttp/4.9.3",
                     "App-Version": "google Pixel 2 XL taimen-Android 11,1.11.332",
                     "Encrypt-Key": self.encryption_utils.encrypt_by_public_key(),
                     "Decrypt-Type": "3",
@@ -189,11 +232,11 @@ class MammotionHTTP:
                     print(resp.json())
                     return Response.from_dict({"code": resp.status, "msg": "Login failed"})
                 data = await resp.json()
-                login_response = Response[LoginResponseData].from_dict(data)
+                login_response = response_factory(Response[LoginResponseData], data)
                 if login_response.data is None:
                     print(login_response)
                     return Response.from_dict({"code": resp.status, "msg": "Login failed"})
-                self.login_info = LoginResponseData.from_dict(login_response.data)
+                self.login_info = login_response.data
                 self._headers["Authorization"] = (
                     f"Bearer {self.login_info.access_token}" if login_response.data else None
                 )

pymammotion/http/model/http.py

@@ -1,9 +1,10 @@
 from dataclasses import dataclass
-from typing import Generic, Literal, TypeVar
+from typing import Annotated, Generic, Literal, TypeVar
 
 from mashumaro import DataClassDictMixin
 from mashumaro.config import BaseConfig
 from mashumaro.mixins.orjson import DataClassORJSONMixin
+from mashumaro.types import Alias
 
 DataT = TypeVar("DataT")
 
@@ -103,3 +104,47 @@ class LoginResponseData(DataClassORJSONMixin):
 
     class Config(BaseConfig):
         omit_none = True
+
+
+@dataclass
+class FirmwareVersions(DataClassORJSONMixin):
+    firmware_version: Annotated[str, Alias("firmwareVersion")] = ""
+    firmware_code: Annotated[str, Alias("firmwareCode")] = ""
+    firmware_latest_version: Annotated[str, Alias("firmwareLatestVersion")] = ""
+    firmware_type: Annotated[str, Alias("firmwareType")] = ""
+
+
+@dataclass
+class ProductVersionInfo(DataClassORJSONMixin):
+    release_note: Annotated[str, Alias("releaseNote")] = ""
+    release_version: Annotated[str, Alias("releaseVersion")] = ""
+    data_location: str | None = None
+
+
+@dataclass
+class CheckDeviceVersion(DataClassORJSONMixin):
+    cause_code: Annotated[int, Alias("causeCode")] = 0
+    product_version_info_vo: Annotated[ProductVersionInfo | None, Alias("productVersionInfoVo")] = None
+    progress: int | None = 0
+    upgradeable: bool = False
+    device_id: Annotated[str, Alias("deviceId")] = ""
+    device_name: Annotated[str | None, Alias("deviceName")] = ""
+    current_version: Annotated[str, Alias("currentVersion")] = ""
+    isupgrading: bool | None = False
+    cause_msg: Annotated[str, Alias("causeMsg")] = ""
+
+    def __eq__(self, other):
+        if not isinstance(other, CheckDeviceVersion):
+            return NotImplemented
+
+        if self.device_id != other.device_id or self.current_version != other.current_version:
+            return False
+
+        if self.product_version_info_vo and other.product_version_info_vo:
+            if self.product_version_info_vo.release_version != other.product_version_info_vo.release_version:
+                return False
+            return True
+        elif self.product_version_info_vo is None and other.product_version_info_vo is None:
+            return False
+        else:
+            return True

pymammotion/http/model/response_factory.py

@@ -0,0 +1,39 @@
+from typing import TypeVar, Union, get_args, get_origin
+
+from pymammotion.http.model.http import Response
+
+T = TypeVar("T")
+
+
+def deserialize_data(value, target_type):
+    if value is None:
+        return None
+
+    origin = get_origin(target_type)
+    args = get_args(target_type)
+
+    if origin is list and args:
+        item_type = args[0]
+        return [deserialize_data(v, item_type) for v in value]
+
+    if origin is Union:
+        # Support Optional[T] = Union[T, None]
+        non_none_types = [t for t in args if t is not type(None)]
+        if len(non_none_types) == 1:
+            return deserialize_data(value, non_none_types[0])
+
+    if hasattr(target_type, "from_dict"):
+        return target_type.from_dict(value)
+
+    return value  # fallback: unknown type, leave as-is
+
+
+def response_factory(response_cls: type[Response[T]], raw_dict: dict) -> Response[T]:
+    # Extract the type of the generic `data` field
+    data_type = get_args(response_cls)[0] if get_args(response_cls) else None
+
+    if data_type:
+        data_value = deserialize_data(raw_dict.get("data"), data_type)
+        return Response(code=raw_dict["code"], msg=raw_dict["msg"], data=data_value)
+    else:
+        return response_cls.from_dict(raw_dict)

pymammotion/mammotion/commands/abstract_message.py

@@ -18,9 +18,6 @@ class AbstractMessage:
 
     def get_msg_device(self, msg_type: MsgCmdType, msg_device: MsgDevice) -> MsgDevice:
         """Changes the rcver name if it's not a luba1."""
-        if (
-            not DeviceType.is_luba1(self.get_device_name(), self.get_device_product_key())
-            and msg_type == MsgCmdType.NAV
-        ):
+        if DeviceType.is_luba_pro(self.get_device_name(), self.get_device_product_key()) and msg_type == MsgCmdType.NAV:
             return MsgDevice.DEV_NAVIGATION
         return msg_device

pymammotion/mammotion/commands/messages/system.py

@@ -202,6 +202,7 @@ class MessageSystem(AbstractMessage, ABC):
     #     return self.send_order_msg_sys(build2)
 
     def send_sys_set_date_time(self) -> bytes:
+        # TODO get HA timezone
         calendar = datetime.datetime.now()
         i = calendar.year
         i2 = calendar.month