pymammotion 0.0.49__tar.gz → 0.0.51__tar.gz

{pymammotion-0.0.49 → pymammotion-0.0.51}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pymammotion
-Version: 0.0.49
+Version: 0.0.51
 Summary: 
 License: GNU-3.0
 Author: Michael Arthur

{pymammotion-0.0.49 → pymammotion-0.0.51}/pymammotion/data/model/device.py

@@ -2,6 +2,8 @@
 
 from dataclasses import dataclass
 
+import betterproto
+
 from pymammotion.data.model import HashList
 from pymammotion.data.model.location import Location
 from pymammotion.proto.dev_net import DevNet
@@ -122,95 +124,137 @@ class MowingDevice:
 class DevNetData:
     """Wrapping class around LubaMsg to return a dataclass from the raw dict."""
 
-    net: DevNet
+    net: dict
+
+    def __init__(self, net: DevNet):
+        self.net = net.to_dict()
 
     def __getattr__(self, item):
         """Intercept call to get net in dict and return a betterproto dataclass."""
-        if not isinstance(self.net[item], dict):
-            return self.net[item]
+        if self.net.get(item) is None:
+            return DevNet().__getattribute__(item)
 
-        return DevNet().__getattribute__(item).from_dict(value=self.net[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:
     """Wrapping class around LubaMsg to return a dataclass from the raw dict."""
 
-    sys: MctlSys
+    sys: dict
+
+    def __init__(self, sys: MctlSys):
+        self.sys = sys.to_dict()
 
     def __getattr__(self, item):
-        """Intercept call to get net in dict and return a betterproto dataclass."""
-        if not isinstance(self.sys[item], dict):
-            return self.sys[item]
+        """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[item])
+        return MctlSys().__getattribute__(item).from_dict(value=self.sys.get(item))
 
 
 @dataclass
 class NavData:
     """Wrapping class around LubaMsg to return a dataclass from the raw dict."""
 
-    nav: MctlNav
+    nav: dict
+
+    def __init__(self, nav: MctlNav):
+        self.nav = nav.to_dict()
 
     def __getattr__(self, item):
         """Intercept call to get nav in dict and return a betterproto dataclass."""
-        if not isinstance(self.nav[item], dict):
-            return self.nav[item]
+        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[item])
+        return MctlNav().__getattribute__(item).from_dict(value=self.nav.get(item))
 
 
 @dataclass
 class DriverData:
     """Wrapping class around LubaMsg to return a dataclass from the raw dict."""
 
-    driver: MctlDriver
+    driver: dict
+
+    def __init__(self, driver: MctlDriver):
+        self.driver = driver.to_dict()
 
     def __getattr__(self, item):
         """Intercept call to get driver in dict and return a betterproto dataclass."""
-        if not isinstance(self.driver[item], dict):
-            return self.driver[item]
+        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[item])
+        return MctlDriver().__getattribute__(item).from_dict(value=self.driver.get(item))
 
 
 @dataclass
 class MulData:
     """Wrapping class around LubaMsg to return a dataclass from the raw dict."""
 
-    mul: SocMul
+    mul: dict
+
+    def __init__(self, mul: SocMul):
+        self.mul = mul.to_dict()
 
     def __getattr__(self, item):
         """Intercept call to get mul in dict and return a betterproto dataclass."""
-        if not isinstance(self.mul[item], dict):
-            return self.mul[item]
+        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[item])
+        return SocMul().__getattribute__(item).from_dict(value=self.mul.get(item))
 
 
 @dataclass
 class OtaData:
     """Wrapping class around LubaMsg to return a dataclass from the raw dict."""
 
-    ota: MctlOta
+    ota: dict
+
+    def __init__(self, ota: MctlOta):
+        self.ota = ota.to_dict()
 
     def __getattr__(self, item):
         """Intercept call to get ota in dict and return a betterproto dataclass."""
-        if not isinstance(self.ota[item], dict):
-            return self.ota[item]
+        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[item])
+        return MctlOta().__getattribute__(item).from_dict(value=self.ota.get(item))
 
 
 @dataclass
 class PeptData:
     """Wrapping class around LubaMsg to return a dataclass from the raw dict."""
 
-    pept: MctlPept
+    pept: dict
+
+    def __init__(self, pept: MctlPept):
+        self.pept = pept.to_dict()
 
     def __getattr__(self, item):
         """Intercept call to get pept in dict and return a betterproto dataclass."""
-        if not isinstance(self.pept[item], dict):
-            return self.pept[item]
+        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[item])
+        return MctlPept().__getattribute__(item).from_dict(value=self.pept.get(item))

{pymammotion-0.0.49 → pymammotion-0.0.51}/pymammotion/mammotion/devices/mammotion.py

@@ -318,7 +318,6 @@ class MammotionBaseBLEDevice(MammotionBaseDevice):
     def __init__(self, device: BLEDevice, interface: int = 0, **kwargs: Any) -> None:
         """Initialize MammotionBaseBLEDevice."""
         super().__init__()
-        self._pong_count = None
         self._ble_sync_task = None
         self._prev_notification = None
         self._interface = f"hci{interface}"
@@ -526,16 +525,13 @@ class MammotionBaseBLEDevice(MammotionBaseDevice):
         new_msg = LubaMsg().parse(data)
         if betterproto.serialized_on_wire(new_msg.net):
             if new_msg.net.todev_ble_sync != 0 or has_field(new_msg.net.toapp_wifi_iot_status):
-                self._pong_count += 1
-
-                if self._pong_count < 3:
-                    return
+                return
 
         # may or may not be correct, some work could be done here to correctly match responses
         if self._notify_future and not self._notify_future.done():
-            self._pong_count = 0
             self._notify_future.set_result(data)
 
+        self._reset_disconnect_timer()
         await self._state_manager.notification(new_msg)
 
     async def _start_notify(self) -> None:
@@ -668,7 +664,7 @@ class MammotionBaseBLEDevice(MammotionBaseDevice):
         _LOGGER.debug("%s: Disconnecting", self.name)
         try:
             """We reset what command the robot last heard before disconnecting."""
-            if client.is_connected:
+            if client is not None and client.is_connected:
                 command_bytes = self._commands.send_todev_ble_sync(2)
                 await self._message.post_custom_data_bytes(command_bytes)
                 await client.stop_notify(self._read_char)

{pymammotion-0.0.49 → pymammotion-0.0.51}/pymammotion/utility/constant/device_constant.py

@@ -209,7 +209,7 @@ class WorkMode:
     MODE_WORKING = 13
 
 
-def device_mode(value):
+def device_mode(value) -> str:
     """Return the mode corresponding to the given value.
 
     This function takes a value and returns the corresponding mode from a

{pymammotion-0.0.49 → pymammotion-0.0.51}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name        = "pymammotion"
-version     = "0.0.49"
+version     = "0.0.51"
 license     = "GNU-3.0"
 description = ""
 readme      = "README.md"
@@ -46,9 +46,8 @@ ruff = "^0.4.6"
 mypy = "^1.10.0"
 pre-commit = "^3.7.1"
 
-
 [tool.bumpver]
-current_version = "0.0.49"
+current_version = "0.0.51"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit_message  = "Bump version {old_version} -> {new_version}"
 commit          = true