pymammotion 0.4.56__tar.gz → 0.5.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pymammotion
-Version: 0.4.56
+Version: 0.5.0
 Summary: 
 License: GPL-3.0
 Author: Michael Arthur
@@ -18,7 +18,7 @@ Requires-Dist: alicloud-gateway-iot (>=1.0.0,<2.0.0)
 Requires-Dist: async-timeout (>=4.0.3,<5.0.0)
 Requires-Dist: betterproto (>=1.2.5,<2.0.0)
 Requires-Dist: bleak (>=0.21.0)
-Requires-Dist: bleak-retry-connector (>=3.5.0,<4.0.0)
+Requires-Dist: bleak-retry-connector (>=3.5.0)
 Requires-Dist: crcmod (>=1.7,<2.0)
 Requires-Dist: cryptography (>=43.0.1)
 Requires-Dist: jsonic (>=1.0.0,<2.0.0)

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

@@ -14,6 +14,7 @@ from pymammotion.data.model.hash_list import AreaHashNameList, NavGetCommData, N
 from pymammotion.data.model.work import CurrentTaskSettings
 from pymammotion.data.mqtt.properties import ThingPropertiesMessage
 from pymammotion.data.mqtt.status import ThingStatusMessage
+from pymammotion.event.event import DataEvent
 from pymammotion.proto import (
     AppGetAllAreaHashName,
     DeviceFwInfo,
@@ -47,19 +48,20 @@ class StateManager:
         self.cloud_get_commondata_ack_callback: (
             Callable[[NavGetCommDataAck | SvgMessageAckT], Awaitable[None]] | None
         ) = 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_on_notification_callback = DataEvent()
+        self.cloud_queue_command_callback = DataEvent()
 
+        self.cloud_get_plan_callback: Callable[[NavPlanJobSet], 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 = (
             None
         )
         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_on_notification_callback = DataEvent()
+        self.ble_queue_command_callback = DataEvent()
 
-        self.ble_queue_command_callback: Callable[[str, dict[str, Any]], Awaitable[bytes]] | None = None
+        self.properties_callback = DataEvent()
+        self.status_callback = DataEvent()
 
     def get_device(self) -> MowingDevice:
         """Get device."""
@@ -72,6 +74,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 +82,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:
@@ -96,9 +100,19 @@ class StateManager:
 
     async def on_notification_callback(self, res: tuple[str, Any | None]) -> None:
         if self.cloud_on_notification_callback:
-            await self.cloud_on_notification_callback(res)
+            await self.cloud_on_notification_callback.data_event(res)
         elif self.ble_on_notification_callback:
-            await self.ble_on_notification_callback(res)
+            await self.ble_on_notification_callback.data_event(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.data_event(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.data_event(thing_status)
 
     async def get_commondata_ack_callback(self, comm_data: NavGetCommDataAck | SvgMessageAckT) -> None:
         if self.cloud_get_commondata_ack_callback:

{pymammotion-0.4.56 → pymammotion-0.5.0}/pymammotion/event/event.py

@@ -1,21 +1,42 @@
 import asyncio
+from collections.abc import Callable
+from types import MethodType
 from typing import Any
+import weakref
 
 
 class Event:
     def __init__(self) -> None:
-        self.__eventhandlers = []
+        self.__eventhandlers: list[weakref.ReferenceType] = []
 
-    def __iadd__(self, handler):
-        self.__eventhandlers.append(handler)
+    def __iadd__(self, handler: Callable) -> "Event":
+        if isinstance(handler, MethodType):
+            # Instance method, use WeakMethod
+            ref = weakref.WeakMethod(handler)
+        else:
+            # Function or static method, use weakref.ref
+            ref = weakref.ref(handler)
+        self.__eventhandlers.append(ref)
         return self
 
-    def __isub__(self, handler):
-        self.__eventhandlers.remove(handler)
+    def __isub__(self, handler: Callable) -> "Event":
+        self.__eventhandlers = [ref for ref in self.__eventhandlers if ref() is not handler]
         return self
 
     async def __call__(self, *args: Any, **kwargs: Any) -> None:
-        await asyncio.gather(*[handler(*args, **kwargs) for handler in self.__eventhandlers])
+        live_handlers = []
+        for ref in self.__eventhandlers:
+            func = ref()
+            if func is not None:
+                live_handlers.append(func(*args, **kwargs))
+        await asyncio.gather(*live_handlers)
+
+        # Clean up dead references
+        self.__eventhandlers = [ref for ref in self.__eventhandlers if ref() is not None]
+
+    def has_dead_handlers(self) -> bool:
+        """Check if any handlers have been garbage collected."""
+        return any(ref() is None for ref in self.__eventhandlers)
 
 
 class MoveEvent:

{pymammotion-0.4.56 → pymammotion-0.5.0}/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.5.0}/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.5.0/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.5.0}/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