pymammotion 0.3.8__py3-none-any.whl → 0.4.0a0__py3-none-any.whl

pymammotion/__init__.py

@@ -12,7 +12,7 @@ from pymammotion.aliyun.cloud_gateway import CloudIOTGateway
 
 # works outside HA on its own
 from pymammotion.bluetooth.ble import MammotionBLE
-from pymammotion.http.http import MammotionHTTP, connect_http
+from pymammotion.http.http import MammotionHTTP
 
 # TODO make a working device that will work outside HA too.
 from pymammotion.mqtt import MammotionMQTT
@@ -20,7 +20,7 @@ from pymammotion.mqtt import MammotionMQTT
 logger = logging.getLogger(__name__)
 
 
-__all__ = ["MammotionBLE", "MammotionHTTP", "connect_http", "MammotionMQTT", "logger"]
+__all__ = ["MammotionBLE", "MammotionHTTP", "MammotionMQTT", "logger"]
 
 
 # TODO provide interface to pick between mqtt/cloud/bluetooth

pymammotion/data/model/device.py

@@ -7,21 +7,12 @@ import betterproto
 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.location import Location
 from pymammotion.data.model.report_info import ReportData
 from pymammotion.data.mqtt.properties import ThingPropertiesMessage
 from pymammotion.http.model.http import ErrorInfo
-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,
@@ -44,21 +35,8 @@ class MowingDevice(DataClassORJSONMixin):
     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)
     error_codes: dict[str, ErrorInfo] = field(default_factory=dict)
 
-    @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)
-
     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]:
@@ -135,199 +113,3 @@ class MowingDevice(DataClassORJSONMixin):
 
     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)
-
-
-@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))

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."""

pymammotion/data/model/device_limits.py

@@ -0,0 +1,49 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class RangeLimit:
+    min: float
+    max: float
+
+
+@dataclass
+class DeviceLimits:
+    cutter_height: RangeLimit = RangeLimit(min=30, max=100)
+    working_speed: RangeLimit = RangeLimit(min=0.2, max=1.2)
+    working_path: RangeLimit = RangeLimit(min=15, max=35)
+    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 {
+            "cutter_height": {"min": self.cutter_height.min, "max": self.cutter_height.max},
+            "working_speed": {"min": self.working_speed.min, "max": self.working_speed.max},
+            "working_path": {"min": self.working_path.min, "max": self.working_path.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(
+            cutter_height=RangeLimit(min=data["cutter_height"]["min"], max=data["cutter_height"]["max"]),
+            working_speed=RangeLimit(min=data["working_speed"]["min"], max=data["working_speed"]["max"]),
+            working_path=RangeLimit(min=data["working_path"]["min"], max=data["working_path"]["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.cutter_height.min <= self.cutter_height.max,
+                self.working_speed.min <= self.working_speed.max,
+                self.working_path.min <= self.working_path.max,
+                self.work_area_num_max > 0,
+                self.display_image_type in (0, 1),
+            ]
+        )

pymammotion/data/model/raw_data.py

@@ -0,0 +1,223 @@
+from dataclasses import dataclass, field
+from typing import Optional
+
+from mashumaro.mixins.orjson import DataClassORJSONMixin
+
+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
+
+
+@dataclass
+class RawMowerData:
+    raw: Optional[LubaMsg] = field(default_factory=LubaMsg)
+
+    @classmethod
+    def from_raw(cls, raw: dict) -> "RawMowerData":
+        """Take in raw data to hold in the betterproto dataclass."""
+        return RawMowerData(raw=LubaMsg(**raw))
+
+    def update_raw(self, raw: dict) -> None:
+        """Update the raw LubaMsg data."""
+        self.raw = LubaMsg(**raw)
+
+    @property
+    def net(self):
+        """Will return a wrapped betterproto of net."""
+        return DevNetData(net=self.raw.net)
+
+    @property
+    def sys(self):
+        """Will return a wrapped betterproto of sys."""
+        return SysData(sys=self.raw.sys)
+
+    @property
+    def nav(self):
+        """Will return a wrapped betterproto of nav."""
+        return NavData(nav=self.raw.nav)
+
+    @property
+    def driver(self):
+        """Will return a wrapped betterproto of driver."""
+        return DriverData(driver=self.raw.driver)
+
+    @property
+    def mul(self):
+        """Will return a wrapped betterproto of mul."""
+        return MulData(mul=self.raw.mul)
+
+    @property
+    def ota(self):
+        """Will return a wrapped betterproto of ota."""
+        return OtaData(ota=self.raw.ota)
+
+    @property
+    def pept(self):
+        """Will return a wrapped betterproto of pept."""
+        return PeptData(pept=self.raw.pept)
+
+
+@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))