pymammotion 0.4.56__tar.gz → 0.4.57__tar.gz

{pymammotion-0.4.56 → pymammotion-0.4.57}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pymammotion
-Version: 0.4.56
+Version: 0.4.57
 Summary: 
 License: GPL-3.0
 Author: Michael Arthur

{pymammotion-0.4.56 → pymammotion-0.4.57}/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-0.4.56 → pymammotion-0.4.57}/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-0.4.56 → pymammotion-0.4.57}/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-0.4.56 → pymammotion-0.4.57}/pymammotion/data/state_manager.py

@@ -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)

{pymammotion-0.4.56 → pymammotion-0.4.57}/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,7 +101,7 @@ 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()
@@ -133,7 +134,7 @@ 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()
@@ -153,7 +154,7 @@ 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()
@@ -165,6 +166,40 @@ class MammotionHTTP:
                 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:
             self._password = password
@@ -179,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",
@@ -197,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-0.4.56 → pymammotion-0.4.57}/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-0.4.57/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-0.4.56 → pymammotion-0.4.57}/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-0.4.56 → pymammotion-0.4.57}/pymammotion/mammotion/devices/mammotion.py

@@ -32,7 +32,6 @@ class MammotionMixedDeviceManager:
         name: str,
         iot_id: str,
         cloud_client: CloudIOTGateway,
-        mammotion_http: MammotionHTTP,
         cloud_device: Device,
         ble_device: BLEDevice | None = None,
         mqtt: MammotionCloud | None = None,
@@ -48,16 +47,22 @@ class MammotionMixedDeviceManager:
         self._device: Device = cloud_device
         self.add_ble(ble_device)
         self.add_cloud(mqtt)
-        self.mammotion_http = mammotion_http
+        self.mammotion_http = cloud_client.mammotion_http
         self.preference = preference
         self._state_manager.preference = preference
 
     @property
-    def mower_state(self):
+    def state_manager(self) -> StateManager:
+        """Return the state manager."""
+        return self._state_manager
+
+    @property
+    def state(self):
+        """Return the state of the device."""
         return self._state_manager.get_device()
 
-    @mower_state.setter
-    def mower_state(self, value: MowingDevice) -> None:
+    @state.setter
+    def state(self, value: MowingDevice) -> None:
         self._state_manager.set_device(value)
 
     def ble(self) -> MammotionBaseBLEDevice | None:
@@ -219,13 +224,12 @@ class Mammotion:
                     name=device.deviceName,
                     iot_id=device.iotId,
                     cloud_client=mqtt_client.cloud_client,
-                    mammotion_http=mqtt_client.cloud_client.mammotion_http,
                     cloud_device=device,
                     mqtt=mqtt_client,
                     preference=ConnectionPreference.WIFI,
                 )
-                mixed_device.mower_state.mower_state.product_key = device.productKey
-                mixed_device.mower_state.mower_state.model = (
+                mixed_device.state.mower_state.product_key = device.productKey
+                mixed_device.state.mower_state.model = (
                     device.productName if device.productModel is None else device.productModel
                 )
                 self.device_manager.add_device(mixed_device)
@@ -266,6 +270,18 @@ class Mammotion:
     def get_device_by_name(self, name: str) -> MammotionMixedDeviceManager:
         return self.device_manager.get_device(name)
 
+    def get_or_create_device_by_name(self, device: Device, mqtt_client: MammotionCloud) -> MammotionMixedDeviceManager:
+        if mow_device := self.device_manager.get_device(device.deviceName):
+            return mow_device
+        return MammotionMixedDeviceManager(
+            name=device.deviceName,
+            iot_id=device.iotId,
+            cloud_client=mqtt_client.cloud_client,
+            mqtt=mqtt_client,
+            cloud_device=device,
+            ble_device=None,
+        )
+
     async def send_command(self, name: str, key: str):
         """Send a command to the device."""
         device = self.get_device_by_name(name)
@@ -275,6 +291,7 @@ class Mammotion:
             if device.preference is ConnectionPreference.WIFI:
                 return await device.cloud().command(key)
             # TODO work with both with EITHER
+        return None
 
     async def send_command_with_args(self, name: str, key: str, **kwargs: Any):
         """Send a command with args to the device."""
@@ -285,6 +302,7 @@ class Mammotion:
             if device.preference is ConnectionPreference.WIFI:
                 return await device.cloud().command(key, **kwargs)
             # TODO work with both with EITHER
+        return None
 
     async def start_sync(self, name: str, retry: int):
         device = self.get_device_by_name(name)
@@ -294,6 +312,7 @@ class Mammotion:
             if device.preference is ConnectionPreference.WIFI:
                 return await device.cloud().start_sync(retry)
             # TODO work with both with EITHER
+        return None
 
     async def start_map_sync(self, name: str):
         device = self.get_device_by_name(name)
@@ -303,6 +322,7 @@ class Mammotion:
             if device.preference is ConnectionPreference.WIFI:
                 return await device.cloud().start_map_sync()
             # TODO work with both with EITHER
+        return None
 
     async def get_stream_subscription(self, name: str, iot_id: str) -> Response[StreamSubscriptionResponse] | Any:
         device = self.get_device_by_name(name)
@@ -329,4 +349,5 @@ class Mammotion:
     def mower(self, name: str) -> MowingDevice | None:
         device = self.get_device_by_name(name)
         if device:
-            return device.mower_state
+            return device.state
+        return None

{pymammotion-0.4.56 → pymammotion-0.4.57}/pymammotion/mammotion/devices/mammotion_bluetooth.py

@@ -103,7 +103,7 @@ class MammotionBaseBLEDevice(MammotionBaseDevice):
     def set_notification_callback(self, func: Callable[[tuple[str, Any | None]], Awaitable[None]]) -> None:
         self._state_manager.ble_on_notification_callback = func
 
-    def set_queue_callback(self, func: Callable[[str, dict[str, Any]], Awaitable[bytes]]) -> None:
+    def set_queue_callback(self, func: Callable[[str, dict[str, Any]], Awaitable[None]]) -> None:
         self._state_manager.ble_queue_command_callback = func
 
     def update_device(self, device: BLEDevice) -> None:
@@ -136,7 +136,7 @@ class MammotionBaseBLEDevice(MammotionBaseDevice):
         if self._client is not None and self._client.is_connected:
             await self._client.disconnect()
 
-    async def queue_command(self, key: str, **kwargs: Any) -> bytes | None:
+    async def queue_command(self, key: str, **kwargs: Any) -> None:
         # Create a future to hold the result
         _LOGGER.debug("Queueing command: %s", key)
         future = asyncio.Future()
@@ -144,7 +144,7 @@ class MammotionBaseBLEDevice(MammotionBaseDevice):
         command_bytes = getattr(self._commands, key)(**kwargs)
         await self.command_queue.put((key, command_bytes, future))
         # Wait for the future to be resolved
-        return await future
+        await future
         # return await self._send_command_with_args(key, **kwargs)
 
     async def process_queue(self) -> None: