pymammotion 0.0.37__py3-none-any.whl

pymammotion/data/model/region_data.py

@@ -0,0 +1,99 @@
+from typing import List, Optional
+
+
+class RegionData:
+    def __init__(self):
+        self.hash: Optional[int] = None
+        self.action: int = 0
+        self.current_frame: int = 0
+        self.data_hash: Optional[int] = None
+        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.pver: int = 0
+        self.result: int = 0
+        self.sub_cmd: int = 0
+        self.total_frame: int = 0
+        self.type: int = 0
+
+    def set_hash(self, hash: int) -> None:
+        self.hash = hash
+
+    def get_data_len(self) -> int:
+        return self.data_len
+
+    def set_data_len(self, data_len: int) -> None:
+        self.data_len = data_len
+
+    def get_pver(self) -> int:
+        return self.pver
+
+    def set_pver(self, pver: int) -> None:
+        self.pver = pver
+
+    def get_sub_cmd(self) -> int:
+        return self.sub_cmd
+
+    def set_sub_cmd(self, sub_cmd: int) -> None:
+        self.sub_cmd = sub_cmd
+
+    def get_result(self) -> int:
+        return self.result
+
+    def set_result(self, result: int) -> None:
+        self.result = result
+
+    def get_action(self) -> int:
+        return self.action
+
+    def set_action(self, action: int) -> None:
+        self.action = action
+
+    def get_type(self) -> int:
+        return self.type
+
+    def set_type(self, type: int) -> None:
+        self.type = type
+
+    def get_total_frame(self) -> int:
+        return self.total_frame
+
+    def set_total_frame(self, total_frame: int) -> None:
+        self.total_frame = total_frame
+
+    def get_current_frame(self) -> int:
+        return self.current_frame
+
+    def set_current_frame(self, current_frame: int) -> None:
+        self.current_frame = current_frame
+
+    def get_path(self) -> Optional[List[List[float]]]:
+        return self.path
+
+    def set_path(self, path: List[List[float]]) -> None:
+        self.path = path
+
+    def get_hash(self) -> Optional[int]:
+        return self.hash
+
+    def set_data_hash(self, data_hash: int) -> None:
+        self.data_hash = data_hash
+
+    def get_data_hash(self) -> Optional[int]:
+        return self.data_hash
+
+    def set_p_hash_a(self, p_hash_a: int) -> None:
+        self.p_hash_a = p_hash_a
+
+    def get_p_hash_a(self) -> Optional[int]:
+        return self.p_hash_a
+
+    def set_p_hash_b(self, p_hash_b: int) -> None:
+        self.p_hash_b = p_hash_b
+
+    def get_p_hash_b(self) -> Optional[int]:
+        return self.p_hash_b
+
+    def __str__(self) -> str:
+        return f"RegionData{{pver={self.pver}, sub_cmd={self.sub_cmd}, result={self.result}, action={self.action}, type={self.type}, Hash={self.hash}, total_frame={self.total_frame}, current_frame={self.current_frame}, data_hash={self.data_hash}, p_hash_a={self.p_hash_a}, p_hash_b={self.p_hash_b}, data_len={self.data_len}, path={self.path}}}"

pymammotion/data/mqtt/__init__.py

@@ -0,0 +1 @@
+

pymammotion/data/mqtt/event.py

@@ -0,0 +1,90 @@
+from base64 import b64decode
+from dataclasses import dataclass
+from typing import Any, Literal, Union
+
+from google.protobuf import json_format
+from mashumaro.mixins.orjson import DataClassORJSONMixin
+from mashumaro.types import SerializableType
+
+from pyluba.proto import luba_msg_pb2
+
+
+class Base64EncodedProtobuf(SerializableType):
+    def __init__(self, proto: str):
+        self.proto = proto
+
+    def _serialize(self):
+        return self.proto
+
+    @classmethod
+    def _deserialize(cls, value):
+        return cls(*value)
+
+    @classmethod
+    def __get_validators__(cls):
+        yield cls.validate
+
+    @classmethod
+    def validate(cls, v: str):
+        if not isinstance(v, str):
+            raise TypeError("string required")
+        binary = b64decode(v, validate=True)
+        data = luba_msg_pb2.LubaMsg()
+        data.ParseFromString(binary)
+        return json_format.MessageToDict(data)
+
+
+@dataclass
+class DeviceProtobufMsgEventValue(DataClassORJSONMixin):
+    content: Base64EncodedProtobuf
+
+
+@dataclass
+class DeviceWarningEventValue(DataClassORJSONMixin):
+    # TODO: enum for error codes
+    # (see resources/res/values-en-rUS/strings.xml in APK)
+    code: int
+
+
+@dataclass
+class GeneralParams(DataClassORJSONMixin):
+    identifier: str
+    groupIdList: list[str]
+    groupId: str
+    categoryKey: Literal["LawnMower"]
+    batchId: str
+    gmtCreate: int
+    productKey: str
+    type: str
+    deviceName: str
+    iotId: str
+    checkLevel: int
+    namespace: str
+    tenantId: str
+    name: str
+    thingType: Literal["DEVICE"]
+    time: int
+    tenantInstanceId: str
+    value: Any
+
+
+@dataclass
+class DeviceProtobufMsgEventParams(GeneralParams):
+    identifier: Literal["device_protobuf_msg_event"]
+    type: Literal["info"]
+    value: DeviceProtobufMsgEventValue
+
+
+@dataclass
+class DeviceWarningEventParams(GeneralParams):
+    identifier: Literal["device_warning_event"]
+    type: Literal["alert"]
+    value: DeviceWarningEventValue
+
+
+@dataclass
+class ThingEventMessage(DataClassORJSONMixin):
+    method: Literal["thing.events"]
+    id: str
+    params: Union[DeviceProtobufMsgEventParams, DeviceWarningEventParams]
+    version: Literal["1.0"]

pymammotion/data/mqtt/properties.py

@@ -0,0 +1,140 @@
+from dataclasses import dataclass
+from typing import Generic, Literal, TypeVar, Union
+
+from mashumaro import DataClassDictMixin
+from mashumaro.mixins.orjson import DataClassORJSONMixin
+
+DataT = TypeVar("DataT")
+
+
+@dataclass
+class Item(DataClassDictMixin, Generic[DataT]):
+    time: int
+    value: DataT
+
+
+@dataclass
+class BatteryPercentageItems(DataClassORJSONMixin):
+    batteryPercentage: Item[int]
+
+
+@dataclass
+class BMSHardwareVersionItems(DataClassORJSONMixin):
+    bmsHardwareVersion: Item[str]
+
+
+@dataclass
+class CoordinateItems(DataClassORJSONMixin):
+    coordinate: Item[str]  # '{"lon":0.303903,"lat":1.051868}'
+
+
+@dataclass
+class DeviceStateItems(DataClassORJSONMixin):
+    deviceState: Item[int]
+
+
+@dataclass
+class DeviceVersionItems(DataClassORJSONMixin):
+    deviceVersion: Item[str]
+
+
+@dataclass
+class DeviceVersionInfoItems(DataClassORJSONMixin):
+    deviceVersionInfo: Item[str]
+
+
+@dataclass
+class ESP32VersionItems(DataClassORJSONMixin):
+    esp32Version: Item[str]
+
+
+@dataclass
+class LeftMotorBootVersionItems(DataClassORJSONMixin):
+    leftMotorBootVersion: Item[str]
+
+
+@dataclass
+class LeftMotorVersionItems(DataClassORJSONMixin):
+    leftMotorVersion: Item[str]
+
+
+@dataclass
+class MCBootVersionItems(DataClassORJSONMixin):
+    mcBootVersion: Item[str]
+
+
+@dataclass
+class NetworkInfoItems(DataClassORJSONMixin):
+    networkInfo: Item[str]
+
+
+@dataclass
+class RightMotorBootVersionItems(DataClassORJSONMixin):
+    rightMotorBootVersion: Item[str]
+
+
+@dataclass
+class RightMotorVersionItems(DataClassORJSONMixin):
+    rightMotorVersion: Item[str]
+
+
+@dataclass
+class RTKVersionItems(DataClassORJSONMixin):
+    rtkVersion: Item[str]
+
+
+@dataclass
+class StationRTKVersionItems(DataClassORJSONMixin):
+    stationRtkVersion: Item[str]
+
+
+@dataclass
+class STM32H7VersionItems(DataClassORJSONMixin):
+    stm32H7Version: Item[str]
+
+
+Items = Union[
+    BatteryPercentageItems,
+    BMSHardwareVersionItems,
+    CoordinateItems,
+    DeviceStateItems,
+    DeviceVersionItems,
+    DeviceVersionInfoItems,
+    ESP32VersionItems,
+    LeftMotorBootVersionItems,
+    LeftMotorVersionItems,
+    MCBootVersionItems,
+    NetworkInfoItems,
+    RightMotorBootVersionItems,
+    RightMotorVersionItems,
+    RTKVersionItems,
+    StationRTKVersionItems,
+    STM32H7VersionItems,
+]
+
+
+@dataclass
+class Params(DataClassORJSONMixin):
+    checkFailedData: dict
+    groupIdList: list[str]
+    groupId: str
+    categoryKey: Literal["LawnMower"]
+    batchId: str
+    gmtCreate: int
+    productKey: str
+    deviceName: str
+    iotId: str
+    checkLevel: int
+    namespace: str
+    tenantId: str
+    thingType: Literal["DEVICE"]
+    items: Items
+    tenantInstanceId: str
+
+
+@dataclass
+class ThingPropertiesMessage(DataClassORJSONMixin):
+    method: Literal["thing.properties"]
+    id: str
+    params: Params
+    version: Literal["1.0"]

pymammotion/data/mqtt/status.py

@@ -0,0 +1,52 @@
+from dataclasses import dataclass
+from enum import Enum
+from typing import Literal
+
+from mashumaro.mixins.orjson import DataClassORJSONMixin
+
+
+@dataclass
+class GroupIdListItem(DataClassORJSONMixin):
+    groupId: str
+    groupType: Literal["ISOLATION"]
+
+
+# are there other values?
+class StatusType(Enum):
+    CONNECTED = 1
+    DISCONNECTED = 3
+
+
+@dataclass
+class Status(DataClassORJSONMixin):
+    time: int
+    value: StatusType
+
+
+@dataclass
+class Params(DataClassORJSONMixin):
+    groupIdList: list[GroupIdListItem]
+    netType: Literal["NET_WIFI"]
+    activeTime: int
+    ip: str
+    aliyunCommodityCode: Literal["iothub_senior"]
+    categoryKey: Literal["LawnMower"]
+    nodeType: Literal["DEVICE"]
+    productKey: str
+    statusLast: int
+    deviceName: str
+    iotId: str
+    namespace: str
+    tenantId: str
+    thingType: Literal["DEVICE"]
+    tenantInstanceId: str
+    categoryId: int
+    status: Status
+
+
+@dataclass
+class ThingStatusMessage(DataClassORJSONMixin):
+    method: Literal["thing.status"]
+    id: str
+    params: Params
+    version: Literal["1.0"]

pymammotion/event/__init__.py

@@ -0,0 +1,6 @@
+# __init__.py
+
+# version of Luba Desktop
+__version__ = "0.0.1"
+
+from .event import BleNotificationEvent, MoveEvent

pymammotion/event/event.py

@@ -0,0 +1,50 @@
+import asyncio
+
+
+class Event:
+    def __init__(self):
+        self.__eventhandlers = []
+
+    def __iadd__(self, handler):
+        self.__eventhandlers.append(handler)
+        return self
+
+    def __isub__(self, handler):
+        self.__eventhandlers.remove(handler)
+        return self
+
+    async def __call__(self, *args, **kwargs):
+        await asyncio.gather(
+            *[handler(*args, **kwargs) for handler in self.__eventhandlers]
+        )
+
+
+class MoveEvent:
+    def __init__(self):
+        self.OnMoveFinished = Event()
+
+    async def MoveFinished(self):
+        # This function will be executed once blufi finishes after a movement command and will
+        # raise an event
+        await self.OnMoveFinished()
+
+    def AddSubscribersForMoveFinishedEvent(self, objMethod):
+        self.OnMoveFinished += objMethod
+
+    def RemoveSubscribersForMoveFinishedEvent(self, objMethod):
+        self.OnMoveFinished -= objMethod
+
+
+class BleNotificationEvent:
+    def __init__(self):
+        self.OnBleNotification = Event()
+
+    async def BleNotification(self, data: bytearray):
+        # This function will be executed when data is received.
+        await self.OnBleNotification(data)
+
+    def AddSubscribersForBleNotificationEvent(self, objMethod):
+        self.OnBleNotification += objMethod
+
+    def RemoveSubscribersForBleNotificationEvent(self, objMethod):
+        self.OnBleNotification -= objMethod

pymammotion/http/http.py

@@ -0,0 +1,76 @@
+from dataclasses import dataclass
+from typing import Generic, Literal, TypeVar
+
+from aiohttp import ClientSession
+from mashumaro import DataClassDictMixin
+from mashumaro.mixins.orjson import DataClassORJSONMixin
+
+from pyluba.const import MAMMOTION_CLIENT_ID, MAMMOTION_CLIENT_SECRET, MAMMOTION_DOMAIN
+
+DataT = TypeVar("DataT")
+
+
+@dataclass
+class Response(DataClassDictMixin, Generic[DataT]):
+    data: DataT
+    code: int
+    msg: str
+
+
+@dataclass
+class LoginResponseUserInformation(DataClassORJSONMixin):
+    areaCode: str
+    domainAbbreviation: str
+    email: 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
+
+
+class LubaHTTP:
+    def __init__(self, session: ClientSession, login: LoginResponseData):
+        self._session = session
+        self._session.headers["Authorization"] = f"Bearer {login.access_token}"
+        self._login = login
+
+    @classmethod
+    async def login(
+        cls, session: ClientSession, username: str, password: str
+    ) -> Response[LoginResponseData]:
+        async with session.post(
+            "/user-server/v1/user/oauth/token",
+            params=dict(
+                username=username,
+                password=password,
+                client_id=MAMMOTION_CLIENT_ID,
+                client_secret=MAMMOTION_CLIENT_SECRET,
+                grant_type="password",
+            ),
+        ) as resp:
+            data = await resp.json()
+            print(data)
+            # TODO catch errors from mismatch user / password
+            # Assuming the data format matches the expected structure
+            login_response_data = LoginResponseData.from_dict(data["data"])
+            return Response(
+                data=login_response_data, code=data["code"], msg=data["msg"]
+            )
+
+
+async def connect_http(username: str, password: str) -> LubaHTTP:
+    async with ClientSession(MAMMOTION_DOMAIN) as session:
+        login_response = await LubaHTTP.login(session, username, password)
+        return LubaHTTP(session, login_response.data)

pymammotion/luba/base.py

@@ -0,0 +1,52 @@
+from typing import Callable, Optional
+
+from pyluba.data.model.rapid_state import RapidState, RTKStatus
+from pyluba.data.mqtt.status import StatusType
+
+
+class BaseLuba:
+    def __init__(self):
+        self._rapid_state: Optional[RapidState] = None
+        self.on_pos_change: Optional[Callable[[float, float, float], None]] = None
+        self.on_rtk_change: Optional[Callable[[RTKStatus, float, int, int], None]] = (
+            None
+        )
+
+        self.on_warning: Optional[Callable[[int], None]] = None
+
+        self._status: Optional[StatusType] = None
+        self.on_status_change: Optional[Callable[[StatusType], None]] = None
+
+    def _set_rapid_state(self, state: RapidState):
+        old_state = self._rapid_state
+        self._rapid_state = state
+        if old_state:
+            if (
+                old_state.pos_x != state.pos_x
+                or old_state.pos_y != state.pos_y
+                or old_state.toward != state.toward
+            ):
+                if self.on_pos_change:
+                    self.on_pos_change(state.pos_x, state.pos_y, state.toward)
+            if (
+                old_state.rtk_status != state.rtk_status
+                or old_state.rtk_age != state.rtk_age
+                or old_state.satellites_total != state.satellites_total
+                or old_state.satellites_l2 != state.satellites_l2
+            ):
+                if self.on_rtk_change:
+                    self.on_rtk_change(
+                        state.rtk_status,
+                        state.rtk_age,
+                        state.satellites_total,
+                        state.satellites_l2,
+                    )
+
+    def _set_status(self, status: StatusType):
+        self._status = status
+        if self.on_status_change:
+            self.on_status_change(status)
+
+    @property
+    def status(self) -> Optional[StatusType]:
+        return self._status

pymammotion/mammotion/commands/abstract_message.py

@@ -0,0 +1,7 @@
+from abc import abstractmethod
+
+
+class AbstractMessage:
+    @abstractmethod
+    def get_device_name(self) -> str:
+        """Get device name."""

pymammotion/mammotion/commands/mammotion_command.py

@@ -0,0 +1,34 @@
+from pyluba.mammotion.commands.messages.navigation import MessageNavigation
+from pyluba.mammotion.commands.messages.network import MessageNetwork
+from pyluba.mammotion.commands.messages.ota import MessageOta
+from pyluba.mammotion.commands.messages.system import MessageSystem
+from pyluba.mammotion.commands.messages.video import MessageVideo
+from pyluba.proto import dev_net_pb2, luba_msg_pb2
+
+
+class MammotionCommand(
+    MessageSystem, MessageNavigation, MessageNetwork, MessageOta, MessageVideo
+):
+    """MQTT commands for Luba."""
+
+    def __init__(self, device_name: str) -> None:
+        self._device_name = device_name
+
+    def get_device_name(self) -> str:
+        """Get device name."""
+        return self._device_name
+
+    """BLE commands for Luba."""
+
+    def send_todev_ble_sync(self, sync_type: int) -> bytes:
+        commEsp = dev_net_pb2.DevNet(todev_ble_sync=sync_type)
+
+        lubaMsg = luba_msg_pb2.LubaMsg()
+        lubaMsg.msgtype = luba_msg_pb2.MSG_CMD_TYPE_ESP
+        lubaMsg.sender = luba_msg_pb2.DEV_MOBILEAPP
+        lubaMsg.msgattr = luba_msg_pb2.MSG_ATTR_REQ
+        lubaMsg.seqs = 1
+        lubaMsg.version = 1
+        lubaMsg.subtype = 1
+        lubaMsg.net.CopyFrom(commEsp)
+        return lubaMsg.SerializeToString()