pymammotion 0.5.69__py3-none-any.whl

pymammotion/bluetooth/data/convert.py

@@ -0,0 +1,25 @@
+from google.protobuf.message import DecodeError
+
+from pymammotion.proto import luba_msg_pb2
+
+
+def parse_custom_data(data: bytes):
+    """Convert data into protobuf message."""
+    luba_msg = luba_msg_pb2.LubaMsg()
+    try:
+        luba_msg.ParseFromString(data)
+        return luba_msg
+
+    except DecodeError as err:
+        print(err)
+
+
+def store_sys_data(sys) -> None:
+    if sys.HasField("systemTardStateTunnel"):
+        tard_state_data_list = sys.systemTardStateTunnel.tard_state_data
+        longValue8 = tard_state_data_list[0]
+        longValue9 = tard_state_data_list[1]
+        print("Device status report,deviceState:", longValue8, ",deviceName:", "Luba...")
+        chargeStateTemp = longValue9
+        longValue10 = tard_state_data_list[6]
+        longValue11 = tard_state_data_list[7]

pymammotion/bluetooth/data/framectrldata.py

@@ -0,0 +1,40 @@
+class FrameCtrlData:
+    FRAME_CTRL_POSITION_CHECKSUM = 1
+    FRAME_CTRL_POSITION_DATA_DIRECTION = 2
+    FRAME_CTRL_POSITION_ENCRYPTED = 0
+    FRAME_CTRL_POSITION_FRAG = 4
+    FRAME_CTRL_POSITION_REQUIRE_ACK = 3
+    mValue = 0
+
+    def __init__(self, frameCtrlValue) -> None:
+        self.mValue = frameCtrlValue
+
+    def check(self, position):
+        return ((self.mValue >> position) & 1) == 1
+
+    def isEncrypted(self):
+        return self.check(0)
+
+    def isChecksum(self):
+        return self.check(1)
+
+    def isAckRequirement(self):
+        return self.check(3)
+
+    def hasFrag(self):
+        return self.check(4)
+
+    @staticmethod
+    def getFrameCTRLValue(encrypted, checksum, direction, requireAck, frag):
+        frame = 0
+        if encrypted:
+            frame = 0 | 1
+        if checksum:
+            frame |= 2
+        if direction == 1:
+            frame |= 4
+        if requireAck:
+            frame |= 8
+        if frag:
+            return frame | 16
+        return frame

pymammotion/bluetooth/data/notifydata.py

@@ -0,0 +1,62 @@
+from io import BytesIO
+
+"""Notify data object"""
+
+
+class BlufiNotifyData:
+    """generated source for class BlufiNotifyData"""
+
+    def __init__(self) -> None:
+        self.mDataOS = BytesIO()
+        self.mFrameCtrlValue = 0
+        self.mPkgType = 0
+        self.mSubType = 0
+        self.mTypeValue = 0
+
+    def getType(self):
+        """Generated source for method getType"""
+        return self.mTypeValue
+
+    #  JADX INFO: Access modifiers changed from: package-private
+    def setType(self, i) -> None:
+        """Generated source for method setType"""
+        self.mTypeValue = i
+
+    #  JADX INFO: Access modifiers changed from: package-private
+    def getPkgType(self):
+        """Generated source for method getPkgType"""
+        return self.mPkgType
+
+    #  JADX INFO: Access modifiers changed from: package-private
+    def setPkgType(self, i) -> None:
+        """Generated source for method setPkgType"""
+        self.mPkgType = i
+
+    #  JADX INFO: Access modifiers changed from: package-private
+    def getSubType(self):
+        """Generated source for method getSubType"""
+        return self.mSubType
+
+    #  JADX INFO: Access modifiers changed from: package-private
+    def setSubType(self, i) -> None:
+        """Generated source for method setSubType"""
+        self.mSubType = i
+
+    def getFrameCtrl(self):
+        """Generated source for method getFrameCtrl"""
+        return self.mFrameCtrlValue
+
+    #  JADX INFO: Access modifiers changed from: package-private
+    def setFrameCtrl(self, i) -> None:
+        """Generated source for method setFrameCtrl"""
+        self.mFrameCtrlValue = i
+
+    #  JADX INFO: Access modifiers changed from: package-private
+    def addData(self, bArr, i) -> None:
+        """Generated source for method addData"""
+        self.mDataOS.write(bArr[i:])
+
+    #  JADX INFO: Access modifiers changed from: package-private
+    def getDataArray(self):
+        """Generated source for method getDataArray"""
+        return self.mDataOS.getvalue()

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

@@ -0,0 +1,13 @@
+"""App key and secret as taken from the mammotion android app."""
+
+APP_KEY = "34231230"
+APP_SECRET = "1ba85698bb10e19c6437413b61ba3445"
+APP_VERSION = "1.11.130"
+ALIYUN_DOMAIN = "api.link.aliyun.com"
+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

@@ -0,0 +1,8 @@
+"""data models"""
+
+from .generate_route_information import GenerateRouteInformation
+from .hash_list import HashList
+from .rapid_state import RapidState, RTKStatus
+from .region_data import RegionData
+
+__all__ = ["GenerateRouteInformation", "HashList", "RapidState", "RTKStatus", "RegionData"]

pymammotion/data/model/account.py

@@ -0,0 +1,8 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class Credentials:
+    email: str = None
+    password: str = None
+    account_id: str = None

pymammotion/data/model/device.py

@@ -0,0 +1,192 @@
+"""MowingDevice class to wrap around the betterproto dataclasses."""
+
+from dataclasses import dataclass, field
+
+import betterproto2
+from mashumaro.mixins.orjson import DataClassORJSONMixin
+
+from pymammotion.data.model import HashList, RapidState
+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.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
+
+
+@dataclass
+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 | 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)
+    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?
+                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.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],
+                        buffer_list.update_buf_data[7],
+                        buffer_list.update_buf_data[9],
+                        buffer_list.update_buf_data[11],
+                        buffer_list.update_buf_data[13],
+                        buffer_list.update_buf_data[15],
+                        buffer_list.update_buf_data[17],
+                        buffer_list.update_buf_data[19],
+                        buffer_list.update_buf_data[21],
+                    ]
+                )
+                self.errors.err_code_list_time.extend(
+                    [
+                        buffer_list.update_buf_data[4],
+                        buffer_list.update_buf_data[6],
+                        buffer_list.update_buf_data[8],
+                        buffer_list.update_buf_data[10],
+                        buffer_list.update_buf_data[12],
+                        buffer_list.update_buf_data[14],
+                        buffer_list.update_buf_data[16],
+                        buffer_list.update_buf_data[18],
+                        buffer_list.update_buf_data[20],
+                        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_area_map = 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 = 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
+                    )
+
+        if toapp_report_data.fw_info:
+            self.update_device_firmwares(toapp_report_data.fw_info)
+
+        if (
+            toapp_report_data.work
+            and (toapp_report_data.work.area >> 16) == 0
+            and toapp_report_data.work.path_hash == 0
+        ):
+            self.work.zone_hashs = []
+            self.map.current_mow_path = {}
+            self.map.generated_mow_path_geojson = {}
+
+        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 = 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)
+        )
+        if self.mowing_state.zone_hash:
+            self.location.work_zone = (
+                self.mowing_state.zone_hash if self.report_data.dev.sys_status == WorkMode.MODE_WORKING else 0
+            )
+
+    def mow_info(self, toapp_mow_info: MowToAppInfoT) -> None:
+        """Set mow info."""
+
+    def report_missing_data(self) -> None:
+        """Report missing data so we can refetch it."""
+
+    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 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

@@ -0,0 +1,72 @@
+from dataclasses import dataclass, field
+
+from mashumaro.mixins.orjson import DataClassORJSONMixin
+
+from pymammotion.utility.device_type import DeviceType
+
+
+@dataclass
+class OperationSettings(DataClassORJSONMixin):
+    """Operation settings for a device."""
+
+    is_mow: bool = True
+    is_dump: bool = True
+    is_edge: bool = False
+    collect_grass_frequency: int = 10
+    job_mode: int = 4  # taskMode
+    job_version: int = 0
+    job_id: int = 0
+    speed: float = 0.3
+    ultra_wave: int = 2  # touch no touch etc
+    channel_mode: int = 0  # grid or border first
+    channel_width: int = 25
+    rain_tactics: int = 0
+    blade_height: int = 0
+    path_order: str = ""
+    toward: int = 0  # is just angle
+    toward_included_angle: int = 90
+    toward_mode: int = 0  # angle type relative etc
+    border_mode: int = 0
+    obstacle_laps: int = 1
+    mowing_laps: int = 1  # border laps
+    start_progress: int = 0
+    areas: set[int] = field(default_factory=set)
+
+
+def create_path_order(operation_mode: OperationSettings, device_name: str) -> str:
+    # 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) and not DeviceType.is_yuka_mini(device_name):
+            bArr[5] = calculate_yuka_mode(operation_mode)
+        else:
+            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()
+
+
+def calculate_yuka_mode(operation_mode: OperationSettings) -> int:
+    if operation_mode.is_mow and operation_mode.is_dump and operation_mode.is_edge:
+        return 14
+    if operation_mode.is_mow and operation_mode.is_dump and not operation_mode.is_edge:
+        return 12
+    if operation_mode.is_mow and not operation_mode.is_dump and operation_mode.is_edge:
+        return 10
+    if operation_mode.is_mow and not operation_mode.is_dump and not operation_mode.is_edge:
+        return 8
+    if not operation_mode.is_mow and operation_mode.is_dump and operation_mode.is_edge:
+        return 6
+    if not operation_mode.is_mow and not operation_mode.is_dump and operation_mode.is_edge:
+        return 2
+    if not operation_mode.is_mow and operation_mode.is_dump and not operation_mode.is_edge:
+        return 4
+    return 0

pymammotion/data/model/device_info.py

@@ -0,0 +1,60 @@
+from dataclasses import dataclass, field
+
+from mashumaro.mixins.orjson import DataClassORJSONMixin
+
+
+@dataclass
+class SideLight(DataClassORJSONMixin):
+    operate: int = 0
+    enable: int = 0
+    start_hour: int = 0
+    start_min: int = 0
+    end_hour: int = 0
+    end_min: int = 0
+    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

@@ -0,0 +1,77 @@
+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
+    FLOAT = 2
+    NONE = 3
+    UNKNOWN = 4
+
+    @staticmethod
+    def from_value(value: int) -> "PositionMode":
+        if value == 0:
+            return PositionMode.FIX
+        elif value == 1:
+            return PositionMode.SINGLE
+        elif value == 2:
+            return PositionMode.FLOAT
+        elif value == 3:
+            return PositionMode.NONE
+        else:
+            return PositionMode.UNKNOWN
+
+    def __str__(self) -> str:
+        if self == PositionMode.FIX:
+            return "Fix"
+        elif self == PositionMode.SINGLE:
+            return "Single"
+        elif self == PositionMode.FLOAT:
+            return "Float"
+        elif self == PositionMode.NONE:
+            return "None"
+        else:
+            return "-"
+
+
+class RTKStatus(Enum):
+    NONE = 0
+    SINGLE = 1
+    FIX = 4
+    FLOAT = 5
+    UNKNOWN = 6
+
+    @staticmethod
+    def from_value(value: int) -> "RTKStatus":
+        if value == 0:
+            return RTKStatus.NONE
+        elif value == 1 or value == 2:
+            return RTKStatus.SINGLE
+        elif value == 4:
+            return RTKStatus.FIX
+        elif value == 5:
+            return RTKStatus.FLOAT
+        else:
+            return RTKStatus.UNKNOWN
+
+    def __str__(self) -> str:
+        if self == RTKStatus.NONE:
+            return "None"
+        elif self == RTKStatus.SINGLE:
+            return "Single"
+        elif self == RTKStatus.FIX:
+            return "Fix"
+        elif self == RTKStatus.FLOAT:
+            return "Float"
+        else:
+            return "Unknown"