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

pymammotion/bluetooth/model/atomic_integer.py

@@ -0,0 +1,54 @@
+from threading import Lock
+
+
+class AtomicInteger:
+    """Thread-safe atomic integer implementation."""
+
+    def __init__(self, initial_value: int = 0) -> None:
+        """Initialize atomic integer with given value."""
+        self._value = initial_value
+        self._lock = Lock()
+
+    def get(self) -> int:
+        """Get the current value."""
+        with self._lock:
+            return self._value
+
+    def set(self, value: int) -> None:
+        """Set a new value."""
+        with self._lock:
+            self._value = value
+
+    def increment_and_get(self) -> int:
+        """Increment the value and return the new value."""
+        with self._lock:
+            self._value += 1
+            return self._value
+
+    def decrement_and_get(self) -> int:
+        """Decrement the value and return the new value."""
+        with self._lock:
+            self._value -= 1
+            return self._value
+
+    def add_and_get(self, delta: int) -> int:
+        """Add delta to value and return the new value."""
+        with self._lock:
+            self._value += delta
+            return self._value
+
+    def compare_and_set(self, expect: int, update: int) -> bool:
+        """Compare value with expected and set to update if they match."""
+        with self._lock:
+            if self._value == expect:
+                self._value = update
+                return True
+            return False
+
+    def __str__(self) -> str:
+        """Returns string representation of the atomic integer."""
+        return str(self.get())
+
+    def __repr__(self) -> str:
+        """Detailed string representation of the atomic integer."""
+        return f"AtomicInteger({self.get()})"

pymammotion/const.py

@@ -8,3 +8,6 @@ MAMMOTION_DOMAIN = "https://id.mammotion.com"
 MAMMOTION_API_DOMAIN = "https://domestic.mammotion.com"
 MAMMOTION_CLIENT_ID = "MADKALUBAS"
 MAMMOTION_CLIENT_SECRET = "GshzGRZJjuMUgd2sYHM7"
+
+MAMMOTION_OUATH2_CLIENT_ID = "GxebgSt8si6pKqR"
+MAMMOTION_OUATH2_CLIENT_SECRET = "JP0508SRJFa0A90ADpzLINDBxMa4Vj"

pymammotion/data/model/__init__.py

@@ -2,8 +2,7 @@
 
 from .generate_route_information import GenerateRouteInformation
 from .hash_list import HashList
-from .plan import Plan
 from .rapid_state import RapidState, RTKStatus
 from .region_data import RegionData
 
-__all__ = ["GenerateRouteInformation", "HashList", "Plan", "RapidState", "RTKStatus", "RegionData"]
+__all__ = ["GenerateRouteInformation", "HashList", "RapidState", "RTKStatus", "RegionData"]

pymammotion/data/model/device.py

@@ -1,31 +1,22 @@
 """MowingDevice class to wrap around the betterproto dataclasses."""
 
 from dataclasses import dataclass, field
-from typing import Optional
 
-import betterproto
+import betterproto2
 from mashumaro.mixins.orjson import DataClassORJSONMixin
 
 from pymammotion.data.model import HashList, RapidState
-from pymammotion.data.model.device_config import DeviceLimits
-from pymammotion.data.model.device_info import MowerInfo
+from pymammotion.data.model.device_info import DeviceFirmwares, DeviceNonWorkingHours, MowerInfo
+from pymammotion.data.model.errors import DeviceErrors
+from pymammotion.data.model.events import Events
 from pymammotion.data.model.location import Location
 from pymammotion.data.model.report_info import ReportData
+from pymammotion.data.model.work import CurrentTaskSettings
+from pymammotion.data.mqtt.event import ThingEventMessage
 from pymammotion.data.mqtt.properties import ThingPropertiesMessage
-from pymammotion.proto.dev_net import DevNet
-from pymammotion.proto.luba_msg import LubaMsg
-from pymammotion.proto.luba_mul import SocMul
-from pymammotion.proto.mctrl_driver import MctlDriver
-from pymammotion.proto.mctrl_nav import MctlNav
-from pymammotion.proto.mctrl_ota import MctlOta
-from pymammotion.proto.mctrl_pept import MctlPept
-from pymammotion.proto.mctrl_sys import (
-    MctlSys,
-    MowToAppInfoT,
-    ReportInfoData,
-    SystemRapidStateTunnelMsg,
-    SystemUpdateBufMsg,
-)
+from pymammotion.data.mqtt.status import ThingStatusMessage
+from pymammotion.http.model.http import CheckDeviceVersion
+from pymammotion.proto import DeviceFwInfo, MowToAppInfoT, ReportInfoData, SystemRapidStateTunnelMsg, SystemUpdateBufMsg
 from pymammotion.utility.constant import WorkMode
 from pymammotion.utility.conversions import parse_double
 from pymammotion.utility.map import CoordinateConverter
@@ -35,42 +26,42 @@ from pymammotion.utility.map import CoordinateConverter
 class MowingDevice(DataClassORJSONMixin):
     """Wraps the betterproto dataclasses, so we can bypass the groups for keeping all data."""
 
+    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 = field(default_factory=ThingPropertiesMessage)
+    mqtt_properties: ThingPropertiesMessage | None = None
+    status_properties: ThingStatusMessage | None = None
+    device_event: ThingEventMessage | None = None
     map: HashList = field(default_factory=HashList)
+    work: CurrentTaskSettings = field(default_factory=CurrentTaskSettings)
     location: Location = field(default_factory=Location)
     mowing_state: RapidState = field(default_factory=RapidState)
     report_data: ReportData = field(default_factory=ReportData)
-    err_code_list: list = field(default_factory=list)
-    err_code_list_time: Optional[list] = field(default_factory=list)
-    limits: DeviceLimits = field(default_factory=DeviceLimits)
-    device: Optional[LubaMsg] = field(default_factory=LubaMsg)
-
-    @classmethod
-    def from_raw(cls, raw: dict) -> "MowingDevice":
-        """Take in raw data to hold in the betterproto dataclass."""
-        mowing_device = MowingDevice()
-        mowing_device.device = LubaMsg(**raw)
-        return mowing_device
-
-    def update_raw(self, raw: dict) -> None:
-        """Update the raw LubaMsg data."""
-        self.device = LubaMsg(**raw)
+    device_firmwares: DeviceFirmwares = field(default_factory=DeviceFirmwares)
+    errors: DeviceErrors = field(default_factory=DeviceErrors)
+    non_work_hours: DeviceNonWorkingHours = field(default_factory=DeviceNonWorkingHours)
+    events: Events = field(default_factory=Events)
 
     def buffer(self, buffer_list: SystemUpdateBufMsg) -> None:
         """Update the device based on which buffer we are reading from."""
         match buffer_list.update_buf_data[0]:
             case 1:
-                # 4 speed
-                self.location.RTK.latitude = parse_double(buffer_list.update_buf_data[5], 8.0)
-                self.location.RTK.longitude = parse_double(buffer_list.update_buf_data[6], 8.0)
-                self.location.dock.latitude = parse_double(buffer_list.update_buf_data[7], 4.0)
-                self.location.dock.longitude = parse_double(buffer_list.update_buf_data[8], 4.0)
-                self.location.dock.rotation = buffer_list.update_buf_data[3] + 180
+                # 4 speed?
+                if buffer_list.update_buf_data[5] != 0:
+                    self.location.RTK.latitude = parse_double(buffer_list.update_buf_data[5], 8.0)
+                    self.location.RTK.longitude = parse_double(buffer_list.update_buf_data[6], 8.0)
+                if buffer_list.update_buf_data[7] != 0:
+                    # latitude Y longitude X
+                    self.location.dock.longitude = parse_double(buffer_list.update_buf_data[7], 4.0)
+                    self.location.dock.latitude = parse_double(buffer_list.update_buf_data[8], 4.0)
+                    self.location.dock.rotation = buffer_list.update_buf_data[3]
+
             case 2:
-                self.err_code_list.clear()
-                self.err_code_list_time.clear()
-                self.err_code_list.extend(
+                self.errors.err_code_list.clear()
+                self.errors.err_code_list_time.clear()
+                self.errors.err_code_list.extend(
                     [
                         buffer_list.update_buf_data[3],
                         buffer_list.update_buf_data[5],
@@ -84,7 +75,7 @@ class MowingDevice(DataClassORJSONMixin):
                         buffer_list.update_buf_data[21],
                     ]
                 )
-                self.err_code_list_time.extend(
+                self.errors.err_code_list_time.extend(
                     [
                         buffer_list.update_buf_data[4],
                         buffer_list.update_buf_data[6],
@@ -98,28 +89,48 @@ class MowingDevice(DataClassORJSONMixin):
                         buffer_list.update_buf_data[22],
                     ]
                 )
+            case 3:
+                # task state event
+                task_area_map: dict[int, int] = {}
+                task_area_ids = []
+
+                for i in range(3, len(buffer_list.update_buf_data), 2):
+                    area_id = buffer_list.update_buf_data[i]
+
+                    if area_id != 0:
+                        area_value = int(buffer_list.update_buf_data[i + 1])
+                        task_area_map[area_id] = area_value
+                        task_area_ids.append(area_id)
+                self.events.work_tasks_event.hash_list = task_area_map
+                self.events.work_tasks_event.ids = task_area_ids
 
     def update_report_data(self, toapp_report_data: ReportInfoData) -> None:
+        """Set report data for the mower."""
         coordinate_converter = CoordinateConverter(self.location.RTK.latitude, self.location.RTK.longitude)
         for index, location in enumerate(toapp_report_data.locations):
             if index == 0 and location.real_pos_y != 0:
                 self.location.position_type = location.pos_type
-                self.location.orientation = location.real_toward / 10000
+                self.location.orientation = int(location.real_toward / 10000)
                 self.location.device = coordinate_converter.enu_to_lla(
                     parse_double(location.real_pos_y, 4.0), parse_double(location.real_pos_x, 4.0)
                 )
+                self.map.invalidate_maps(location.bol_hash)
                 if location.zone_hash:
                     self.location.work_zone = (
                         location.zone_hash if self.report_data.dev.sys_status == WorkMode.MODE_WORKING else 0
                     )
 
-        self.report_data.update(toapp_report_data.to_dict(casing=betterproto.Casing.SNAKE))
+        if toapp_report_data.fw_info:
+            self.update_device_firmwares(toapp_report_data.fw_info)
+
+        self.report_data.update(toapp_report_data.to_dict(casing=betterproto2.Casing.SNAKE))
 
     def run_state_update(self, rapid_state: SystemRapidStateTunnelMsg) -> None:
+        """Set lat long, work zone of RTK and robot."""
         coordinate_converter = CoordinateConverter(self.location.RTK.latitude, self.location.RTK.longitude)
         self.mowing_state = RapidState().from_raw(rapid_state.rapid_state_data)
         self.location.position_type = self.mowing_state.pos_type
-        self.location.orientation = self.mowing_state.toward / 10000
+        self.location.orientation = int(self.mowing_state.toward / 10000)
         self.location.device = coordinate_converter.enu_to_lla(
             parse_double(self.mowing_state.pos_y, 4.0), parse_double(self.mowing_state.pos_x, 4.0)
         )
@@ -129,203 +140,44 @@ class MowingDevice(DataClassORJSONMixin):
             )
 
     def mow_info(self, toapp_mow_info: MowToAppInfoT) -> None:
-        pass
+        """Set mow info."""
 
     def report_missing_data(self) -> None:
         """Report missing data so we can refetch it."""
 
-    @property
-    def net(self):
-        """Will return a wrapped betterproto of net."""
-        return DevNetData(net=self.device.net)
-
-    @property
-    def sys(self):
-        """Will return a wrapped betterproto of sys."""
-        return SysData(sys=self.device.sys)
-
-    @property
-    def nav(self):
-        """Will return a wrapped betterproto of nav."""
-        return NavData(nav=self.device.nav)
-
-    @property
-    def driver(self):
-        """Will return a wrapped betterproto of driver."""
-        return DriverData(driver=self.device.driver)
-
-    @property
-    def mul(self):
-        """Will return a wrapped betterproto of mul."""
-        return MulData(mul=self.device.mul)
-
-    @property
-    def ota(self):
-        """Will return a wrapped betterproto of ota."""
-        return OtaData(ota=self.device.ota)
-
-    @property
-    def pept(self):
-        """Will return a wrapped betterproto of pept."""
-        return PeptData(pept=self.device.pept)
+    def update_device_firmwares(self, fw_info: DeviceFwInfo) -> None:
+        """Set firmware versions on all parts of the robot or RTK."""
+        for mod in fw_info.mod:
+            match mod.type:
+                case 1:
+                    self.device_firmwares.main_controller = mod.version
+                case 3:
+                    self.device_firmwares.left_motor_driver = mod.version
+                case 4:
+                    self.device_firmwares.right_motor_driver = mod.version
+                case 5:
+                    self.device_firmwares.rtk_rover_station = mod.version
+                case 101:
+                    # RTK main board
+                    self.device_firmwares.main_controller = mod.version
+                case 102:
+                    self.device_firmwares.rtk_version = mod.version
+                case 103:
+                    self.device_firmwares.lora_version = mod.version
 
 
 @dataclass
-class DevNetData(DataClassORJSONMixin):
-    """Wrapping class around LubaMsg to return a dataclass from the raw dict."""
-
-    net: dict
-
-    def __init__(self, net: DevNet) -> None:
-        if isinstance(net, dict):
-            self.net = net
-        else:
-            self.net = net.to_dict()
-
-    def __getattr__(self, item):
-        """Intercept call to get net in dict and return a betterproto dataclass."""
-        if self.net.get(item) is None:
-            return DevNet().__getattribute__(item)
-
-        if not isinstance(self.net.get(item), dict):
-            return self.net.get(item)
-
-        return DevNet().__getattribute__(item).from_dict(value=self.net.get(item))
-
-
-@dataclass
-class SysData(DataClassORJSONMixin):
-    """Wrapping class around LubaMsg to return a dataclass from the raw dict."""
-
-    sys: dict
-
-    def __init__(self, sys: MctlSys) -> None:
-        if isinstance(sys, dict):
-            self.sys = sys
-        else:
-            self.sys = sys.to_dict()
-
-    def __getattr__(self, item: str):
-        """Intercept call to get sys in dict and return a betterproto dataclass."""
-        if self.sys.get(item) is None:
-            return MctlSys().__getattribute__(item)
-
-        if not isinstance(self.sys.get(item), dict):
-            return self.sys.get(item)
-
-        return MctlSys().__getattribute__(item).from_dict(value=self.sys.get(item))
-
-
-@dataclass
-class NavData(DataClassORJSONMixin):
-    """Wrapping class around LubaMsg to return a dataclass from the raw dict."""
-
-    nav: dict
-
-    def __init__(self, nav: MctlNav) -> None:
-        if isinstance(nav, dict):
-            self.nav = nav
-        else:
-            self.nav = nav.to_dict()
-
-    def __getattr__(self, item: str):
-        """Intercept call to get nav in dict and return a betterproto dataclass."""
-        if self.nav.get(item) is None:
-            return MctlNav().__getattribute__(item)
-
-        if not isinstance(self.nav.get(item), dict):
-            return self.nav.get(item)
-
-        return MctlNav().__getattribute__(item).from_dict(value=self.nav.get(item))
-
-
-@dataclass
-class DriverData(DataClassORJSONMixin):
-    """Wrapping class around LubaMsg to return a dataclass from the raw dict."""
-
-    driver: dict
-
-    def __init__(self, driver: MctlDriver) -> None:
-        if isinstance(driver, dict):
-            self.driver = driver
-        else:
-            self.driver = driver.to_dict()
-
-    def __getattr__(self, item: str):
-        """Intercept call to get driver in dict and return a betterproto dataclass."""
-        if self.driver.get(item) is None:
-            return MctlDriver().__getattribute__(item)
-
-        if not isinstance(self.driver.get(item), dict):
-            return self.driver.get(item)
-
-        return MctlDriver().__getattribute__(item).from_dict(value=self.driver.get(item))
-
-
-@dataclass
-class MulData(DataClassORJSONMixin):
-    """Wrapping class around LubaMsg to return a dataclass from the raw dict."""
-
-    mul: dict
-
-    def __init__(self, mul: SocMul) -> None:
-        if isinstance(mul, dict):
-            self.mul = mul
-        else:
-            self.mul = mul.to_dict()
-
-    def __getattr__(self, item: str):
-        """Intercept call to get mul in dict and return a betterproto dataclass."""
-        if self.mul.get(item) is None:
-            return SocMul().__getattribute__(item)
-
-        if not isinstance(self.mul.get(item), dict):
-            return self.mul.get(item)
-
-        return SocMul().__getattribute__(item).from_dict(value=self.mul.get(item))
-
-
-@dataclass
-class OtaData(DataClassORJSONMixin):
-    """Wrapping class around LubaMsg to return a dataclass from the raw dict."""
-
-    ota: dict
-
-    def __init__(self, ota: MctlOta) -> None:
-        if isinstance(ota, dict):
-            self.ota = ota
-        else:
-            self.ota = ota.to_dict()
-
-    def __getattr__(self, item: str):
-        """Intercept call to get ota in dict and return a betterproto dataclass."""
-        if self.ota.get(item) is None:
-            return MctlOta().__getattribute__(item)
-
-        if not isinstance(self.ota.get(item), dict):
-            return self.ota.get(item)
-
-        return MctlOta().__getattribute__(item).from_dict(value=self.ota.get(item))
-
-
-@dataclass
-class PeptData(DataClassORJSONMixin):
-    """Wrapping class around LubaMsg to return a dataclass from the raw dict."""
-
-    pept: dict
-
-    def __init__(self, pept: MctlPept) -> None:
-        if isinstance(pept, dict):
-            self.pept = pept
-        else:
-            self.pept = pept.to_dict()
-
-    def __getattr__(self, item: str):
-        """Intercept call to get pept in dict and return a betterproto dataclass."""
-        if self.pept.get(item) is None:
-            return MctlPept().__getattribute__(item)
-
-        if not isinstance(self.pept.get(item), dict):
-            return self.pept.get(item)
-
-        return MctlPept().__getattribute__(item).from_dict(value=self.pept.get(item))
+class RTKDevice(DataClassORJSONMixin):
+    name: str
+    iot_id: str
+    product_key: str
+    online: bool = True
+    lat: float = 0.0
+    lon: float = 0.0
+    lora: str = ""
+    wifi_rssi: int = 0
+    device_version: str = ""
+    lora_version: str = ""
+    wifi_sta_mac: str = ""
+    bt_mac: str = ""
+    update_check: CheckDeviceVersion = field(default_factory=CheckDeviceVersion)

pymammotion/data/model/device_config.py

@@ -5,16 +5,6 @@ from mashumaro.mixins.orjson import DataClassORJSONMixin
 from pymammotion.utility.device_type import DeviceType
 
 
-@dataclass
-class DeviceLimits(DataClassORJSONMixin):
-    blade_height_min: int = 30
-    blade_height_max: int = 100
-    working_speed_min: float = 0.2
-    working_speed_max: float = 1.2
-    working_path_min: int = 15
-    working_path_max: int = 35
-
-
 @dataclass
 class OperationSettings(DataClassORJSONMixin):
     """Operation settings for a device."""
@@ -36,33 +26,29 @@ class OperationSettings(DataClassORJSONMixin):
     toward: int = 0  # is just angle
     toward_included_angle: int = 90
     toward_mode: int = 0  # angle type relative etc
-    border_mode: int = 1  # border laps
+    border_mode: int = 0
     obstacle_laps: int = 1
-    mowing_laps: int = 1
+    mowing_laps: int = 1  # border laps
     start_progress: int = 0
-    areas: list[int] = field(default_factory=list)
+    areas: set[int] = field(default_factory=set)
 
 
 def create_path_order(operation_mode: OperationSettings, device_name: str) -> str:
-    i = 8
+    # TODO add scheduling logic from getReserved() WorkSettingViewModel.java
     bArr = bytearray(8)
     bArr[0] = operation_mode.border_mode
     bArr[1] = operation_mode.obstacle_laps
     bArr[3] = int(operation_mode.start_progress)
     bArr[2] = 0
-
+    bArr[5] = 0
     if not DeviceType.is_luba1(device_name):
         bArr[4] = 0
-        if DeviceType.is_yuka(device_name):
-            i = calculate_yuka_mode(operation_mode)
-        elif not DeviceType.is_luba_2(device_name):
-            i = 0
-        bArr[5] = i
-        if operation_mode.is_dump:
-            b = int(operation_mode.collect_grass_frequency)
+        if DeviceType.is_yuka(device_name) and not DeviceType.is_yuka_mini(device_name):
+            bArr[5] = calculate_yuka_mode(operation_mode)
         else:
-            b = 10
-        bArr[6] = b
+            bArr[5] = 8 if DeviceType.is_luba_pro(device_name) else 0
+
+        bArr[6] = int(operation_mode.collect_grass_frequency) if operation_mode.is_dump else 10
     if DeviceType.is_luba1(device_name):
         bArr[4] = operation_mode.toward_mode
     return bArr.decode()

pymammotion/data/model/device_info.py

@@ -14,12 +14,47 @@ class SideLight(DataClassORJSONMixin):
     action: int = 0
 
 
+@dataclass
+class DeviceNonWorkingHours(DataClassORJSONMixin):
+    sub_cmd: int = 0
+    start_time: str = ""
+    end_time: str = ""
+
+
+@dataclass
+class LampInfo(DataClassORJSONMixin):
+    lamp_bright: int = 0
+    manual_light: bool = False
+    night_light: bool = False
+
+
 @dataclass
 class MowerInfo(DataClassORJSONMixin):
     blade_status: bool = False
+    rain_detection: bool = False
+    traversal_mode: int = 0
+    turning_mode: int = 0
+    blade_mode: int = 0
+    blade_rpm: int = 0
     side_led: SideLight = field(default_factory=SideLight)
     collector_installation_status: bool = False
     model: str = ""
     swversion: str = ""
     product_key: str = ""
     model_id: str = ""
+    sub_model_id: str = ""
+    ble_mac: str = ""
+    wifi_mac: str = ""
+    lamp_info: LampInfo = field(default_factory=LampInfo)
+
+
+@dataclass
+class DeviceFirmwares(DataClassORJSONMixin):
+    device_version: str = ""
+    left_motor_driver: str = ""
+    lora_version: str = ""
+    main_controller: str = ""
+    model_name: str = ""
+    right_motor_driver: str = ""
+    rtk_rover_station: str = ""
+    rtk_version: str = ""

pymammotion/data/model/device_limits.py

@@ -0,0 +1,49 @@
+from dataclasses import dataclass, field
+
+
+@dataclass
+class RangeLimit:
+    min: float
+    max: float
+
+
+@dataclass
+class DeviceLimits:
+    blade_height: RangeLimit = field(default_factory=RangeLimit)
+    working_speed: RangeLimit = field(default_factory=RangeLimit)
+    path_spacing: RangeLimit = field(default_factory=RangeLimit)
+    work_area_num_max: int = 60
+    display_image_type: int = 0
+
+    def to_dict(self) -> dict:
+        """Convert the device limits to a dictionary format."""
+        return {
+            "blade_height": {"min": self.blade_height.min, "max": self.blade_height.max},
+            "working_speed": {"min": self.working_speed.min, "max": self.working_speed.max},
+            "path_spacing": {"min": self.path_spacing.min, "max": self.path_spacing.max},
+            "work_area_num_max": self.work_area_num_max,
+            "display_image_type": self.display_image_type,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "DeviceLimits":
+        """Create a DeviceLimits instance from a dictionary."""
+        return cls(
+            blade_height=RangeLimit(min=data["blade_height"]["min"], max=data["blade_height"]["max"]),
+            working_speed=RangeLimit(min=data["working_speed"]["min"], max=data["working_speed"]["max"]),
+            path_spacing=RangeLimit(min=data["path_spacing"]["min"], max=data["path_spacing"]["max"]),
+            work_area_num_max=data["work_area_num_max"],
+            display_image_type=data["display_image_type"],
+        )
+
+    def validate(self) -> bool:
+        """Validate that all ranges are logical (min <= max)."""
+        return all(
+            [
+                self.blade_height.min <= self.blade_height.max,
+                self.working_speed.min <= self.working_speed.max,
+                self.path_spacing.min <= self.path_spacing.max,
+                self.work_area_num_max > 0,
+                self.display_image_type in (0, 1),
+            ]
+        )

pymammotion/data/model/enums.py

@@ -1,6 +1,16 @@
 from enum import Enum
 
 
+class ConnectionPreference(Enum):
+    """Enum for connection preference."""
+
+    ANY = 0
+    WIFI = 1
+    BLUETOOTH = 2
+    PREFER_WIFI = 3
+    PREFER_BLUETOOTH = 4
+
+
 class PositionMode(Enum):
     FIX = 0
     SINGLE = 1
@@ -9,7 +19,7 @@ class PositionMode(Enum):
     UNKNOWN = 4
 
     @staticmethod
-    def from_value(value: int):
+    def from_value(value: int) -> "PositionMode":
         if value == 0:
             return PositionMode.FIX
         elif value == 1:
@@ -42,7 +52,7 @@ class RTKStatus(Enum):
     UNKNOWN = 6
 
     @staticmethod
-    def from_value(value: int):
+    def from_value(value: int) -> "RTKStatus":
         if value == 0:
             return RTKStatus.NONE
         elif value == 1 or value == 2: