pymammotion 0.2.62__py3-none-any.whl → 0.5.51__py3-none-any.whl

pymammotion/{aliyun/model/stream_subscription_response.py → http/model/camera_stream.py}

@@ -1,5 +1,4 @@
 from dataclasses import dataclass
-from typing import List
 
 from mashumaro.mixins.orjson import DataClassORJSONMixin
 
@@ -13,7 +12,20 @@ class Camera(DataClassORJSONMixin):
 @dataclass
 class StreamSubscriptionResponse(DataClassORJSONMixin):
     appid: str
-    cameras: List[Camera]
+    cameras: list[Camera]
     channelName: str
     token: str
     uid: int
+    license: str | None = None
+    availableTime: int | None = None
+
+
+@dataclass
+class VideoResourceResponse(DataClassORJSONMixin):
+    id: str
+    deviceId: str
+    deviceName: str
+    cycleType: int
+    usageYearMonth: str
+    totalTime: int
+    availableTime: int

pymammotion/http/model/http.py

@@ -1,15 +1,21 @@
-from dataclasses import dataclass
-from typing import Generic, Literal, Optional, TypeVar
+from dataclasses import dataclass, field
+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
+
+
+class UnauthorizedException(Exception):
+    pass
+
 
 DataT = TypeVar("DataT")
 
 
 @dataclass
-class ErrorInfo:
+class ErrorInfo(DataClassDictMixin):
     code: str
     platform: str
     module: str
@@ -38,18 +44,105 @@ class ErrorInfo:
     nl_solution: str
     da_implication: str
     da_solution: str
+    sr_implication: str
+    sr_solution: str
     sv_implication: str
     sv_solution: str
     sl_implication: str
     sl_solution: str
     pt_implication: str
     pt_solution: str
+    hu_implication: str
+    hu_solution: str
+    hr_implication: str
+    hr_solution: str
+    no_implication: str
+    no_solution: str
+    fi_implication: str
+    fi_solution: str
+    ro_implication: str
+    ro_solution: str
+    bg_implication: str
+    bg_solution: str
+    et_implication: str
+    et_solution: str
+    lv_implication: str
+    lv_solution: str
+    lt_implication: str
+    lt_solution: str
+
+
+@dataclass
+class SettingVo(DataClassORJSONMixin):
+    """Device setting configuration."""
+
+    type: int = 0
+    is_switch: Annotated[int, Alias("isSwitch")] = 0
+
+
+@dataclass
+class LocationVo(DataClassORJSONMixin):
+    """Device location information."""
+
+    date_time: Annotated[str, Alias("dateTime")] = ""
+    date_timestamp: Annotated[int, Alias("dateTimestamp")] = 0
+    location: list[float] = field(default_factory=lambda: [0.0, 0.0])
+
+
+@dataclass
+class DeviceInfo:
+    """Complete device information."""
+
+    iot_id: Annotated[str, Alias("iotId")] = ""
+    device_id: Annotated[str, Alias("deviceId")] = ""
+    device_name: Annotated[str, Alias("deviceName")] = ""
+    device_type: Annotated[str, Alias("deviceType")] = ""
+    series: str = ""
+    product_series: Annotated[str, Alias("productSeries")] = ""
+    icon_code: Annotated[str, Alias("iconCode")] = ""
+    generation: int = 0
+    status: int = 0
+    is_subscribe: Annotated[int, Alias("isSubscribe")] = 0
+    setting_vos: Annotated[list[SettingVo], Alias("settingVos")] = field(default_factory=list)
+    active_time: Annotated[str, Alias("activeTime")] = ""
+    active_timestamp: Annotated[int, Alias("activeTimestamp")] = 0
+    location_vo: Annotated[LocationVo | None, Alias("locationVo")] = None
+
+
+@dataclass
+class DeviceRecord(DataClassORJSONMixin):
+    identity_id: Annotated[str, Alias("identityId")]
+    iot_id: Annotated[str, Alias("iotId")]
+    product_key: Annotated[str, Alias("productKey")]
+    device_name: Annotated[str, Alias("deviceName")]
+    owned: int
+    status: int
+    bind_time: Annotated[int, Alias("bindTime")]
+    create_time: Annotated[str, Alias("createTime")]
+
+
+@dataclass
+class DeviceRecords(DataClassORJSONMixin):
+    records: list[DeviceRecord]
+    total: int
+    size: int
+    current: int
+    pages: int
+
+
+@dataclass
+class MQTTConnection(DataClassORJSONMixin):
+    host: str
+    jwt: str
+    client_id: Annotated[str, Alias("clientId")]
+    username: str
 
 
 @dataclass
-class Response(DataClassDictMixin, Generic[DataT]):
+class Response(DataClassORJSONMixin, Generic[DataT]):
     code: int
     msg: str
+    request_id: Annotated[str, Alias("requestId")] | None = None
     data: DataT | None = None
 
     class Config(BaseConfig):
@@ -60,20 +153,78 @@ class Response(DataClassDictMixin, Generic[DataT]):
 class LoginResponseUserInformation(DataClassORJSONMixin):
     areaCode: str
     domainAbbreviation: str
-    email: Optional[str]
     userId: str
     userAccount: str
     authType: str
+    email: str | None = None
+
+    class Config(BaseConfig):
+        omit_none = True
+
+
+@dataclass
+class JWTTokenInfo(DataClassORJSONMixin):
+    """specifically for newer devices and mqtt"""
+
+    iot: str  # iot domain e.g api-iot-business-eu-dcdn.mammotion.com
+    robot: str  # e.g api-robot-eu.mammotion.com
 
 
 @dataclass
 class LoginResponseData(DataClassORJSONMixin):
     access_token: str
-    token_type: Literal["bearer"]
+    token_type: Literal["bearer", "Bearer"]
     refresh_token: str
     expires_in: int
-    scope: Literal["read"]
-    grant_type: Literal["password"]
     authorization_code: str
     userInformation: LoginResponseUserInformation
-    jti: str
+    jti: str = None
+    grant_type: Literal["password", "Password"] = None
+    scope: Literal["read", "Read"] = None
+
+    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,61 @@
+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):
+    """Deserialize data into a specified target type.
+
+    The function handles deserialization of basic types, lists, and unions. It
+    recursively processes list elements and supports optional types by handling
+    Union[T, None]. For custom types with a `from_dict` method, it calls this
+    method for deserialization. If the target type is unknown or unsupported, it
+    returns the value unchanged.
+
+    Args:
+        value: The data to be deserialized.
+        target_type (type): The desired type into which the data should be deserialized.
+
+    Returns:
+        The deserialized data in the specified 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:
+            target = non_none_types[0]
+            # Handle Response[list[type]] case
+            if get_origin(target) is list and get_args(target):
+                item_type = get_args(target)[0]
+                return [deserialize_data(v, item_type) for v in value]
+            return deserialize_data(value, target)
+
+    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
+    """Create a Response instance from a dictionary."""
+    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/http/model/rtk.py

@@ -0,0 +1,16 @@
+"""RTK device information."""
+from dataclasses import dataclass, field
+
+from mashumaro import field_options
+from mashumaro.mixins.orjson import DataClassORJSONMixin
+
+
+@dataclass
+class RTK(DataClassORJSONMixin):
+    """RTK device information."""
+
+    device_id: str = field(metadata=field_options(alias="deviceId"))
+    device_name: str = field(metadata=field_options(alias="deviceName"))
+    product_key: str = field(metadata=field_options(alias="productKey"))
+    status: int
+    lora: str

pymammotion/mammotion/commands/abstract_message.py

@@ -1,22 +1,24 @@
 from abc import abstractmethod
 
-from pymammotion.proto.luba_msg import MsgCmdType, MsgDevice
+from pymammotion.bluetooth.model.atomic_integer import AtomicInteger
+from pymammotion.proto import MsgCmdType, MsgDevice
 from pymammotion.utility.device_type import DeviceType
 
 
 class AbstractMessage:
+    seqs = AtomicInteger(0)
+    user_account: int
+
     @abstractmethod
     def get_device_name(self) -> str:
         """Get device name."""
 
+    @abstractmethod
     def get_device_product_key(self) -> str:
         """Get device name."""
 
     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.MSG_CMD_TYPE_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/mammotion_command.py

@@ -5,6 +5,7 @@ from pymammotion.mammotion.commands.messages.network import MessageNetwork
 from pymammotion.mammotion.commands.messages.ota import MessageOta
 from pymammotion.mammotion.commands.messages.system import MessageSystem
 from pymammotion.mammotion.commands.messages.video import MessageVideo
+from pymammotion.utility.device_type import DeviceType
 from pymammotion.utility.movement import get_percent, transform_both_speeds
 
 
@@ -13,14 +14,42 @@ class MammotionCommand(
 ):
     """MQTT commands for Luba."""
 
-    def __init__(self, device_name: str) -> None:
+    def __init__(self, device_name: str, user_account: int) -> None:
         self._device_name = device_name
         self._product_key = ""
+        self.user_account = user_account
 
     def get_device_name(self) -> str:
         """Get device name."""
         return self._device_name
 
+    def read_write_device(self, rw_id: int, context: int, rw: int):
+        if (
+            rw_id == 6 or rw_id == 3 or rw_id == 7 or rw_id == 8 or rw_id == 10 or rw_id == 11
+        ) and DeviceType.is_luba_pro(self.get_device_name()):
+            return self.allpowerfull_rw_adapter_x3(rw_id, context, rw)
+        return self.allpowerfull_rw(rw_id, context, rw)
+
+    def traverse_mode(self, context: int) -> bytes:
+        """Sets the traversal mode back to charger."""
+        # setReChargeMode
+        # 0 direct
+        # 1 follow the perimeter
+        return self.read_write_device(7, context, 1)
+
+    def turning_mode(self, context: int) -> bytes:
+        """Sets the traversal mode back to charger."""
+        # setTurnAroundMode
+        # 0 zero turn
+        # 1 multipoint turn
+        return self.read_write_device(6, context, 1)
+
+    def get_error_code(self) -> bytes:
+        return self.read_write_device(5, 2, 1)
+
+    def get_error_timestamp(self) -> bytes:
+        return self.read_write_device(5, 3, 1)
+
     def get_device_product_key(self) -> str:
         return self._product_key
 
@@ -42,11 +71,11 @@ class MammotionCommand(
     def move_left(self, angular: float) -> bytes:
         """Move forward. values 0.0 1.0."""
         angular_percent = get_percent(abs(angular * 100))
-        (linear_speed, angular_speed) = transform_both_speeds(0.0, 0.0, 0.0, angular_percent)
+        (linear_speed, angular_speed) = transform_both_speeds(0.0, 180.0, 0.0, angular_percent)
         return self.send_movement(linear_speed=linear_speed, angular_speed=angular_speed)
 
     def move_right(self, angular: float) -> bytes:
         """Move back. values 0.0 1.0."""
         angular_percent = get_percent(abs(angular * 100))
-        (linear_speed, angular_speed) = transform_both_speeds(0.0, 180.0, 0.0, angular_percent)
+        (linear_speed, angular_speed) = transform_both_speeds(0.0, 0.0, 0.0, angular_percent)
         return self.send_movement(linear_speed=linear_speed, angular_speed=angular_speed)

pymammotion/mammotion/commands/messages/basestation.py

@@ -0,0 +1,43 @@
+"""RTK protobuf commands."""
+
+from abc import ABC
+from logging import getLogger
+import time
+
+from pymammotion.mammotion.commands.abstract_message import AbstractMessage
+from pymammotion.proto import (
+    AppToBaseMqttRtkT,
+    BaseStation,
+    LubaMsg,
+    MsgAttr,
+    MsgCmdType,
+    MsgDevice,
+    RequestBasestationInfoT,
+)
+
+logger = getLogger(__name__)
+
+
+class MessageBasestation(AbstractMessage, ABC):
+    def send_order_msg_basestation(self, driver) -> bytes:
+        return LubaMsg(
+            msgtype=MsgCmdType.BASESTATION,
+            sender=MsgDevice.DEV_MOBILEAPP,
+            rcver=self.get_msg_device(MsgCmdType.BASESTATION, MsgDevice.DEV_MAINCTL),
+            msgattr=MsgAttr.REQ,
+            timestamp=round(time.time() * 1000),
+            seqs=self.seqs.increment_and_get() & 255,
+            version=1,
+            subtype=self.user_account,
+            driver=driver,
+        ).SerializeToString()
+
+    def basestation_info(self) -> bytes:
+        """Build and send a request to get basestation info (request_type=1)."""
+        base = BaseStation(to_dev=RequestBasestationInfoT(request_type=1))
+        return self.send_order_msg_basestation(base)
+
+    def set_base_net_rtk_switch(self, rtk_switch: int) -> bytes:
+        """Set RTK switch via app_to_base_mqtt_rtk_t."""
+        base = BaseStation(app_to_base_mqtt_rtk_msg=AppToBaseMqttRtkT(rtk_switch=rtk_switch))
+        return self.send_order_msg_basestation(base)

pymammotion/mammotion/commands/messages/driver.py

@@ -1,58 +1,90 @@
 # === sendOrderMsg_Driver ===
-import time
 from abc import ABC
 from logging import getLogger
+import time
 
 from pymammotion.mammotion.commands.abstract_message import AbstractMessage
-from pymammotion.proto import mctrl_driver
-from pymammotion.proto.luba_msg import LubaMsg, MsgAttr, MsgCmdType, MsgDevice
+from pymammotion.proto import (
+    AppGetCutterWorkMode,
+    AppSetCutterWorkMode,
+    DrvKnifeHeight,
+    DrvMotionCtrl,
+    DrvMowCtrlByHand,
+    DrvSrSpeed,
+    LubaMsg,
+    MctlDriver,
+    MsgAttr,
+    MsgCmdType,
+    MsgDevice,
+    RtkCfgReqT,
+    RtkSysMaskQueryT,
+)
 
 logger = getLogger(__name__)
 
 
 class MessageDriver(AbstractMessage, ABC):
     def send_order_msg_driver(self, driver) -> bytes:
+        """Build and serialize a driver command message."""
         return LubaMsg(
-            msgtype=MsgCmdType.MSG_CMD_TYPE_EMBED_DRIVER,
+            msgtype=MsgCmdType.EMBED_DRIVER,
             sender=MsgDevice.DEV_MOBILEAPP,
-            rcver=self.get_msg_device(MsgCmdType.MSG_CMD_TYPE_EMBED_DRIVER, MsgDevice.DEV_MAINCTL),
-            msgattr=MsgAttr.MSG_ATTR_REQ,
+            rcver=self.get_msg_device(MsgCmdType.EMBED_DRIVER, MsgDevice.DEV_MAINCTL),
+            msgattr=MsgAttr.REQ,
             timestamp=round(time.time() * 1000),
-            seqs=1,
+            seqs=self.seqs.increment_and_get() & 255,
             version=1,
-            subtype=1,
+            subtype=self.user_account,
             driver=driver,
         ).SerializeToString()
 
-    def set_blade_height(self, height: int):
+    def set_blade_height(self, height: int) -> bytes:
+        """Set mower blade height."""
         logger.debug(f"Send knife height height={height}")
-        build = mctrl_driver.MctlDriver(todev_knife_height_set=mctrl_driver.DrvKnifeHeight(knife_height=height))
+        build = MctlDriver(todev_knife_height_set=DrvKnifeHeight(knife_height=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):
+    def set_speed(self, speed: float) -> bytes:
+        """Set the device speed."""
         logger.debug(f"{self.get_device_name()} set speed, {speed}")
-        build = mctrl_driver.MctlDriver(bidire_speed_read_set=mctrl_driver.DrvSrSpeed(speed=speed, rw=1))
+        build = MctlDriver(bidire_speed_read_set=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.MctlDriver(rtk_sys_mask_query=mctrl_driver.RtkSysMaskQueryT(sat_system=sat_system))
+    def get_cutter_mode(self) -> bytes:
+        """Request the current cutter mode."""
+        build = MctlDriver(current_cutter_mode=AppGetCutterWorkMode())
+        return self.send_order_msg_driver(build)
+
+    def set_cutter_mode(self, cutter_mode: int) -> bytes:
+        """Set blade speed."""
+        """
+        1 slow
+        0 normal
+        2 fast
+        """
+        build = MctlDriver(cutter_mode_ctrl_by_hand=AppSetCutterWorkMode(cutter_mode=cutter_mode))
+        return self.send_order_msg_driver(build)
+
+    def syn_nav_star_point_data(self, sat_system: int) -> bytes:
+        """Synchronize navigation satellite frequency points."""
+        build = MctlDriver(rtk_sys_mask_query=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.MctlDriver(
-            rtk_cfg_req=mctrl_driver.RtkCfgReqT(cmd_req=cmd_req, cmd_length=len(cmd_req) - 1)
-        )
+    def set_nav_star_point(self, cmd_req: str) -> bytes:
+        """Configure navigation satellite frequency points."""
+        build = MctlDriver(rtk_cfg_req=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(
             f"Navigation satellite setting, Send command--Navigation satellite frequency point setting={cmd_req}"
         )
         return self.send_order_msg_driver(build)
 
-    def get_speed(self):
-        build = mctrl_driver.MctlDriver(bidire_speed_read_set=mctrl_driver.DrvSrSpeed(rw=0))
+    def get_speed(self) -> bytes:
+        """Request the current speed value."""
+        build = MctlDriver(bidire_speed_read_set=DrvSrSpeed(rw=0))
         logger.debug("Send command--Get speed value")
         return self.send_order_msg_driver(build)
 
@@ -62,13 +94,14 @@ class MessageDriver(AbstractMessage, ABC):
         cut_knife_ctrl: int,
         cut_knife_height: int,
         max_run_speed: float,
-    ):
-        build = mctrl_driver.MctlDriver(
-            mow_ctrl_by_hand=mctrl_driver.DrvMowCtrlByHand(
+    ) -> bytes:
+        """Send manual mowing control command."""
+        build = MctlDriver(
+            mow_ctrl_by_hand=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(
@@ -78,13 +111,12 @@ class MessageDriver(AbstractMessage, ABC):
 
         return self.send_order_msg_driver(build)
 
-    def send_movement(self, linear_speed: int, angular_speed: int):
+    def send_movement(self, linear_speed: int, angular_speed: int) -> bytes:
+        """Send motion command with linear and angular speeds."""
         logger.debug(f"Control command print, linearSpeed={
         linear_speed} // angularSpeed={angular_speed}")
         return self.send_order_msg_driver(
-            mctrl_driver.MctlDriver(
-                todev_devmotion_ctrl=mctrl_driver.DrvMotionCtrl(
-                    set_linear_speed=linear_speed, set_angular_speed=angular_speed
-                )
+            MctlDriver(
+                todev_devmotion_ctrl=DrvMotionCtrl(set_linear_speed=linear_speed, set_angular_speed=angular_speed)
             )
         )