pymammotion 0.5.69__py3-none-any.whl

pymammotion/http/model/camera_stream.py

@@ -0,0 +1,31 @@
+from dataclasses import dataclass
+
+from mashumaro.mixins.orjson import DataClassORJSONMixin
+
+
+@dataclass
+class Camera(DataClassORJSONMixin):
+    cameraId: int
+    token: str
+
+
+@dataclass
+class StreamSubscriptionResponse(DataClassORJSONMixin):
+    appid: str
+    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

@@ -0,0 +1,249 @@
+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(DataClassDictMixin):
+    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
+    ja_implication: str
+    ja_solution: str
+    es_implication: str
+    es_solution: str
+    cs_implication: str
+    cs_solution: str
+    ko_implication: str
+    ko_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
+    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
+
+    class Config(BaseConfig):
+        allow_deserialization_not_by_alias = True
+
+
+@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")]
+
+    class Config(BaseConfig):
+        allow_deserialization_not_by_alias = True
+
+
+@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(DataClassORJSONMixin, Generic[DataT]):
+    code: int
+    msg: str
+    request_id: Annotated[str, Alias("requestId")] | None = None
+    data: DataT | None = None
+
+    class Config(BaseConfig):
+        omit_default = True
+
+
+@dataclass
+class LoginResponseUserInformation(DataClassORJSONMixin):
+    areaCode: str
+    domainAbbreviation: 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", "Bearer"]
+    refresh_token: str
+    expires_in: int
+    authorization_code: str
+    userInformation: LoginResponseUserInformation
+    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")] = ""
+
+    class Config(BaseConfig):
+        allow_deserialization_not_by_alias = True
+
+
+@dataclass
+class ProductVersionInfo(DataClassORJSONMixin):
+    release_note: Annotated[str, Alias("releaseNote")] = ""
+    release_version: Annotated[str, Alias("releaseVersion")] = ""
+    data_location: str | None = None
+
+    class Config(BaseConfig):
+        allow_deserialization_not_by_alias = True
+
+
+@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")] = ""
+
+    class Config(BaseConfig):
+        allow_deserialization_not_by_alias = True
+
+    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

@@ -0,0 +1,24 @@
+from abc import abstractmethod
+
+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 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

@@ -0,0 +1,81 @@
+from pymammotion.mammotion.commands.messages.driver import MessageDriver
+from pymammotion.mammotion.commands.messages.media import MessageMedia
+from pymammotion.mammotion.commands.messages.navigation import MessageNavigation
+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
+
+
+class MammotionCommand(
+    MessageSystem, MessageNavigation, MessageNetwork, MessageOta, MessageVideo, MessageMedia, MessageDriver
+):
+    """MQTT commands for Luba."""
+
+    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
+
+    def set_device_product_key(self, product_key: str) -> None:
+        self._product_key = product_key
+
+    def move_forward(self, linear: float) -> bytes:
+        """Move forward. values 0.0 1.0."""
+        linear_percent = get_percent(abs(linear * 100))
+        (linear_speed, angular_speed) = transform_both_speeds(90.0, 0.0, linear_percent, 0.0)
+        return self.send_movement(linear_speed=linear_speed, angular_speed=angular_speed)
+
+    def move_back(self, linear: float) -> bytes:
+        """Move back. values 0.0 1.0."""
+        linear_percent = get_percent(abs(linear * 100))
+        (linear_speed, angular_speed) = transform_both_speeds(270.0, 0.0, linear_percent, 0.0)
+        return self.send_movement(linear_speed=linear_speed, angular_speed=angular_speed)
+
+    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, 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, 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

@@ -0,0 +1,122 @@
+# === sendOrderMsg_Driver ===
+from abc import ABC
+from logging import getLogger
+import time
+
+from pymammotion.mammotion.commands.abstract_message import AbstractMessage
+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.EMBED_DRIVER,
+            sender=MsgDevice.DEV_MOBILEAPP,
+            rcver=self.get_msg_device(MsgCmdType.EMBED_DRIVER, 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 set_blade_height(self, height: int) -> bytes:
+        """Set mower blade height."""
+        logger.debug(f"Send knife height 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) -> bytes:
+        """Set the device speed."""
+        logger.debug(f"{self.get_device_name()} set speed, {speed}")
+        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 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) -> 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) -> 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)
+
+    def operate_on_device(
+        self,
+        main_ctrl: int,
+        cut_knife_ctrl: int,
+        cut_knife_height: int,
+        max_run_speed: float,
+    ) -> 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,
+            )
+        )
+        logger.debug(
+            f"Send command--Manual mowing command, main_ctrl:{main_ctrl}, cut_knife_ctrl:{cut_knife_ctrl}, "
+            f"cut_knife_height:{cut_knife_height}, max_run_speed:{max_run_speed}"
+        )
+
+        return self.send_order_msg_driver(build)
+
+    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(
+            MctlDriver(
+                todev_devmotion_ctrl=DrvMotionCtrl(set_linear_speed=linear_speed, set_angular_speed=angular_speed)
+            )
+        )