pymammotion 0.5.44__tar.gz → 0.5.49__tar.gz

{pymammotion-0.5.44 → pymammotion-0.5.49}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pymammotion
-Version: 0.5.44
+Version: 0.5.49
 Author: jLynx
 Author-email: Michael Arthur <michael@jumblesoft.co.nz>
 License-Expression: GPL-3.0
@@ -11,7 +11,7 @@ Requires-Dist: alibabacloud-apigateway-util<0.0.3,>=0.0.2
 Requires-Dist: alibabacloud-iot-api-gateway<0.0.5,>=0.0.4
 Requires-Dist: alicloud-gateway-iot<2,>=1.0.0
 Requires-Dist: async-timeout<5,>=4.0.3
-Requires-Dist: betterproto2<0.9,>=0.8.0
+Requires-Dist: betterproto2>=0.9.1
 Requires-Dist: bleak-retry-connector>=3.5.0
 Requires-Dist: bleak>=0.21.0
 Requires-Dist: crcmod~=1.7

{pymammotion-0.5.44 → pymammotion-0.5.49}/pymammotion/aliyun/model/dev_by_account_response.py

@@ -1,7 +1,9 @@
 from dataclasses import dataclass
+from typing import Annotated, Optional
 
 from mashumaro.config import BaseConfig
 from mashumaro.mixins.orjson import DataClassORJSONMixin
+from mashumaro.types import Alias
 
 
 @dataclass
@@ -9,79 +11,47 @@ class Device(DataClassORJSONMixin):
     """Unified device model supporting both Device and ShareNotification data"""
 
     # Core device fields (from Device model)
-    gmt_modified: int
-    node_type: str
-    device_name: str
-    product_name: str
+    gmt_modified: Annotated[int, Alias("gmtModified")]
+    node_type: Annotated[str, Alias("nodeType")]
+    device_name: Annotated[str, Alias("deviceName")]
+    product_name: Annotated[str, Alias("productName")]
     status: int
-    identity_id: str
+    identity_id: Annotated[str, Alias("identityId")]
 
     # Required fields from original Device model
-    net_type: str
-    category_key: str
-    product_key: str
-    is_edge_gateway: bool
-    category_name: str
-    identity_alias: str
-    iot_id: str
-    bind_time: int
+    net_type: Annotated[str, Alias("netType")]
+    category_key: Annotated[str, Alias("categoryKey")]
+    product_key: Annotated[str, Alias("productKey")]
+    is_edge_gateway: Annotated[bool, Alias("isEdgeGateway")]
+    category_name: Annotated[str, Alias("categoryName")]
+    identity_alias: Annotated[str, Alias("identityAlias")]
+    iot_id: Annotated[str, Alias("iotId")]
+    bind_time: Annotated[int, Alias("bindTime")]
     owned: int
-    thing_type: str
+    thing_type: Annotated[str, Alias("thingType")]
 
     # Optional fields (common to both or nullable)
-    nick_name: str | None = None
-    description: str | None = None
-    product_image: str | None = None
-    category_image: str | None = None
-    product_model: str | None = None
+    nick_name: Annotated[Optional[str], Alias("nickName")] = None
+    description: Optional[str] = None
+    product_image: Annotated[Optional[str], Alias("productImage")] = None
+    category_image: Annotated[Optional[str], Alias("categoryImage")] = None
+    product_model: Annotated[Optional[str], Alias("productModel")] = None
 
     # Optional fields from ShareNotification only
-    target_id: str | None = None
-    receiver_identity_id: str | None = None
-    target_type: str | None = None
-    gmt_create: int | None = None
-    batch_id: str | None = None
-    record_id: str | None = None
-    initiator_identity_id: str | None = None
-    is_receiver: int | None = None
-    initiator_alias: str | None = None
-    receiver_alias: str | None = None
+    target_id: Annotated[Optional[str], Alias("targetId")] = None
+    receiver_identity_id: Annotated[Optional[str], Alias("receiverIdentityId")] = None
+    target_type: Annotated[Optional[str], Alias("targetType")] = None
+    gmt_create: Annotated[Optional[int], Alias("gmtCreate")] = None
+    batch_id: Annotated[Optional[str], Alias("batchId")] = None
+    record_id: Annotated[Optional[str], Alias("recordId")] = None
+    initiator_identity_id: Annotated[Optional[str], Alias("initiatorIdentityId")] = None
+    is_receiver: Annotated[Optional[int], Alias("isReceiver")] = None
+    initiator_alias: Annotated[Optional[str], Alias("initiatorAlias")] = None
+    receiver_alias: Annotated[Optional[str], Alias("receiverAlias")] = None
 
     class Config(BaseConfig):
         omit_default = True
-        serialize_by_alias = True
-        aliases = {
-            # Original Device model aliases
-            "gmt_modified": "gmtModified",
-            "net_type": "netType",
-            "category_key": "categoryKey",
-            "product_key": "productKey",
-            "node_type": "nodeType",
-            "is_edge_gateway": "isEdgeGateway",
-            "device_name": "deviceName",
-            "category_name": "categoryName",
-            "identity_alias": "identityAlias",
-            "product_name": "productName",
-            "iot_id": "iotId",
-            "bind_time": "bindTime",
-            "identity_id": "identityId",
-            "thing_type": "thingType",
-            "nick_name": "nickName",
-            "product_image": "productImage",
-            "category_image": "categoryImage",
-            "product_model": "productModel",
-            # ShareNotification specific aliases
-            "target_id": "targetId",
-            "receiver_identity_id": "receiverIdentityId",
-            "target_type": "targetType",
-            "gmt_create": "gmtCreate",
-            "batch_id": "batchId",
-            "record_id": "recordId",
-            "initiator_identity_id": "initiatorIdentityId",
-            "is_receiver": "isReceiver",
-            "initiator_alias": "initiatorAlias",
-            "receiver_alias": "receiverAlias",
-        }
+        allow_deserialization_not_by_alias = True
 
 
 # # Alternative: Keep them separate but with a common base class

{pymammotion-0.5.44 → pymammotion-0.5.49}/pymammotion/data/model/hash_list.py

@@ -440,4 +440,6 @@ class HashList(DataClassORJSONMixin):
 
     def invalidate_maps(self, bol_hash: int) -> None:
         if MurMurHashUtil.hash_unsigned_list(self.hashlist) != bol_hash:
-            self.root_hash_lists = []
+            pass
+
+            # self.root_hash_lists = []

{pymammotion-0.5.44 → pymammotion-0.5.49}/pymammotion/homeassistant/mower_api.py

@@ -27,12 +27,14 @@ class HomeAssistantMowerApi:
     """API for interacting with Mammotion Mowers for Home Assistant."""
 
     def __init__(self) -> None:
+        self._plan_lock = asyncio.Lock()
         self.update_failures = 0
         self._mammotion = Mammotion()
         self._map_lock = asyncio.Lock()
         self._last_call_times: dict[str, datetime] = {}
         self._call_intervals = {
-            "check_maps": timedelta(minutes=1),
+            "check_maps": timedelta(minutes=5),
+            "read_plan": timedelta(minutes=30),
             "read_settings": timedelta(minutes=5),
             "get_errors": timedelta(minutes=1),
             "get_report_cfg": timedelta(seconds=5),
@@ -81,10 +83,19 @@ class HomeAssistantMowerApi:
                 self._map_lock.release()
 
         # Check maps periodically
-        if self._should_call_api("check_maps"):
+        if self._should_call_api("check_maps") and not self._map_lock.locked():
             await self._map_lock.acquire()
             await self.mammotion.start_map_sync(device_name)
             self._mark_api_called("check_maps")
+            return device.state
+
+        if self._should_call_api("read_plan"):
+            if len(device.state.map.plan) == 0 or list(device.state.map.plan.values())[0].total_plan_num != len(
+                device.state.map.plan
+            ):
+                await self.async_send_command(device_name, "read_plan", sub_cmd=2, plan_index=0)
+                self._mark_api_called("read_plan")
+                return device.state
 
         # Read settings less frequently
         if self._should_call_api("read_settings"):
@@ -195,8 +206,8 @@ class HomeAssistantMowerApi:
 
     def is_online(self, device_name: str) -> bool:
         if device := self.mammotion.get_device_by_name(device_name):
-            ble = device.ble
-            return device.state.online or ble is not None and ble.client.is_connected
+            if ble := device.ble:
+                return device.state.online or ble is not None and ble.client.is_connected
         return False
 
     async def update_firmware(self, device_name: str, version: str) -> None:
@@ -242,7 +253,7 @@ class HomeAssistantMowerApi:
     async def async_set_sidelight(self, device_name: str, on_off: int) -> None:
         """Set Sidelight."""
         await self.async_send_command(device_name, "read_and_set_sidelight", is_sidelight=bool(on_off), operate=0)
-        await self.async_read_sidelight()
+        await self.async_read_sidelight(device_name)
 
     async def async_read_sidelight(self, device_name: str) -> None:
         """Set Sidelight."""
@@ -414,7 +425,7 @@ class HomeAssistantMowerApi:
         device = self.mammotion.get_device_by_name(device_name)
 
         if work := device.state.work:
-            operation_settings.areas = work.zone_hashs
+            operation_settings.areas = set(work.zone_hashs)
             operation_settings.toward = work.toward
             operation_settings.toward_mode = work.toward_mode
             operation_settings.toward_included_angle = work.toward_included_angle

{pymammotion-0.5.44 → pymammotion-0.5.49}/pymammotion/homeassistant/rtk_api.py

@@ -20,22 +20,22 @@ class HomeAssistantRTKApi:
         try:
             response = await device.cloud_client.get_device_properties(device.iot_id)
             if response.code == 200:
-                data = response.data
-                if ota_progress := data.otaProgress:
-                    device.update_check = CheckDeviceVersion.from_dict(ota_progress.value)
-                if network_info := data.networkInfo:
-                    network = json.loads(network_info.value)
-                    device.state.wifi_rssi = network["wifi_rssi"]
-                    device.state.wifi_sta_mac = network["wifi_sta_mac"]
-                    device.state.bt_mac = network["bt_mac"]
-                if coordinate := data.coordinate:
-                    coord_val = json.loads(coordinate.value)
-                    if device.state.lat == 0:
-                        device.state.lat = coord_val["lat"]
-                    if device.state.lon == 0:
-                        device.state.lon = coord_val["lon"]
-                if device_version := data.deviceVersion:
-                    device.state.device_version = device_version.value
+                if data := response.data:
+                    if ota_progress := data.otaProgress:
+                        device.state.update_check = CheckDeviceVersion.from_dict(ota_progress.value)
+                    if network_info := data.networkInfo:
+                        network = json.loads(network_info.value)
+                        device.state.wifi_rssi = network["wifi_rssi"]
+                        device.state.wifi_sta_mac = network["wifi_sta_mac"]
+                        device.state.bt_mac = network["bt_mac"]
+                    if coordinate := data.coordinate:
+                        coord_val = json.loads(coordinate.value)
+                        if device.state.lat == 0:
+                            device.state.lat = coord_val["lat"]
+                        if device.state.lon == 0:
+                            device.state.lon = coord_val["lon"]
+                    if device_version := data.deviceVersion:
+                        device.state.device_version = device_version.value
             device.state.online = True
 
             ota_info = await device.cloud_client.mammotion_http.get_device_ota_firmware([device.state.iot_id])

{pymammotion-0.5.44 → pymammotion-0.5.49}/pymammotion/http/http.py

@@ -129,7 +129,7 @@ class MammotionHTTP:
         self._response: Response | None = None
         self.login_info: LoginResponseData | None = None
         self.jwt_info: JWTTokenInfo = JWTTokenInfo("", "")
-        self._headers = {"User-Agent": "okhttp/4.9.3", "App-Version": "Home Assistant,1.14.2.29"}
+        self._headers = {"User-Agent": "okhttp/4.9.3", "App-Version": "Home Assistant,1.15.6.14"}
         self.encryption_utils = EncryptionUtils()
 
         # Add this method to generate a 10-digit random number
@@ -383,6 +383,8 @@ class MammotionHTTP:
                     "Authorization": f"Bearer {self.login_info.access_token}",
                     "Content-Type": "application/json",
                     "User-Agent": "okhttp/4.9.3",
+                    "Client-Id": self.client_id,
+                    "Client-Type": "1",
                 },
             ) as resp:
                 data = await resp.json()
@@ -402,6 +404,8 @@ class MammotionHTTP:
                     "Authorization": f"Bearer {self.login_info.access_token}",
                     "Content-Type": "application/json",
                     "User-Agent": "okhttp/4.9.3",
+                    "Client-Id": self.client_id,
+                    "Client-Type": "1",
                 },
             ) as resp:
                 data = await resp.json()
@@ -428,7 +432,7 @@ class MammotionHTTP:
 
     @refresh_token_decorator
     async def get_user_device_list(self) -> Response[list[DeviceInfo]]:
-        """Fetches device list for a user (owned)."""
+        """Fetches device list for a user (owned not shared, shared returns nothing)."""
         async with ClientSession(MAMMOTION_API_DOMAIN) as session:
             async with session.get(
                 "/device-server/v1/device/list",
@@ -437,6 +441,8 @@ class MammotionHTTP:
                     "Authorization": f"Bearer {self.login_info.access_token}",
                     "Content-Type": "application/json",
                     "User-Agent": "okhttp/4.9.3",
+                    "Client-Id": self.client_id,
+                    "Client-Type": "1",
                 },
             ) as resp:
                 resp_dict = await resp.json()

{pymammotion-0.5.44 → pymammotion-0.5.49}/pymammotion/mammotion/devices/mammotion.py

@@ -186,8 +186,7 @@ class Mammotion:
 
             await mammotion_http.refresh_login()
 
-            if len(mammotion_http.device_info) != 0:
-                await self.connect_iot(exists_aliyun.cloud_client)
+            await self.connect_iot(exists_aliyun.cloud_client)
             if len(mammotion_http.device_records.records) != 0:
                 await mammotion_http.get_mqtt_credentials()
 
@@ -272,7 +271,7 @@ class Mammotion:
             if mqtt.is_connected():
                 await loop.run_in_executor(None, mqtt.disconnect)
 
-        if len(mammotion_http.device_info) != 0:
+        if len(cloud_client.devices_by_account_response.data.data) != 0:
             mammotion_cloud = MammotionCloud(
                 AliyunMQTT(
                     region_id=cloud_client.region_response.data.regionId,
@@ -416,8 +415,7 @@ class Mammotion:
         _LOGGER.debug("device_list: %s", device_list)
         await mammotion_http.get_mqtt_credentials()
         cloud_client = CloudIOTGateway(mammotion_http)
-        if len(device_list.data or []) != 0:
-            await self.connect_iot(cloud_client)
+        await self.connect_iot(cloud_client)
         return cloud_client
 
     @staticmethod
@@ -484,12 +482,12 @@ class Mammotion:
         if device:
             if device.preference is ConnectionPreference.BLUETOOTH and device.ble:
                 return await device.ble.command(key, **kwargs)
-            if device.preference is ConnectionPreference.WIFI:
+            if device.preference is ConnectionPreference.WIFI and device.cloud:
                 return await device.cloud.command(key, **kwargs)
             # TODO work with both with EITHER
         return None
 
-    async def start_map_sync(self, name: str):
+    async def start_map_sync(self, name: str) -> None:
         """Start map sync."""
         device = self.get_device_by_name(name)
         if device:
@@ -500,6 +498,17 @@ class Mammotion:
             # TODO work with both with EITHER
         return None
 
+    async def start_schedule_sync(self, name: str) -> None:
+        """Start map sync."""
+        device = self.get_device_by_name(name)
+        if device:
+            if device.preference is ConnectionPreference.BLUETOOTH and device.ble:
+                return await device.ble.start_schedule_sync()
+            if device.preference is ConnectionPreference.WIFI and device.cloud:
+                return await device.cloud.start_schedule_sync()
+            # TODO work with both with EITHER
+        return None
+
     async def get_stream_subscription(self, name: str, iot_id: str) -> Response[StreamSubscriptionResponse] | Any:
         """Get stream subscription."""
         device = self.get_device_by_name(name)

{pymammotion-0.5.44 → pymammotion-0.5.49}/pymammotion/mammotion/devices/mower_device.py

@@ -87,6 +87,13 @@ class MammotionMowerDevice(MammotionBaseDevice, ABC):
             index = plan.plan_index + 1
             await self.queue_command("read_plan", sub_cmd=2, plan_index=index)
 
+    async def start_schedule_sync(self) -> None:
+        """Start sync of schedule data."""
+        if len(self.mower.map.plan) == 0 or list(self.mower.map.plan.values())[0].total_plan_num != len(
+            self.mower.map.plan
+        ):
+            await self.queue_command("read_plan", sub_cmd=2, plan_index=0)
+
     async def start_map_sync(self) -> None:
         """Start sync of map data."""
         if location := next((loc for loc in self.mower.report_data.locations if loc.pos_type == 5), None):
@@ -94,17 +101,13 @@ class MammotionMowerDevice(MammotionBaseDevice, ABC):
 
         await self.queue_command("send_todev_ble_sync", sync_type=3)
 
+        # TODO correctly check if area names exist for a zone.
         if self._cloud_device and len(self.mower.map.area_name) == 0 and not DeviceType.is_luba1(self.mower.name):
             await self.queue_command("get_area_name_list", device_id=self._cloud_device.iot_id)
 
         if len(self.mower.map.root_hash_lists) == 0 or len(self.mower.map.missing_hashlist()) > 0:
             await self.queue_command("get_all_boundary_hash_list", sub_cmd=0)
 
-        if len(self.mower.map.plan) == 0 or list(self.mower.map.plan.values())[0].total_plan_num != len(
-            self.mower.map.plan
-        ):
-            await self.queue_command("read_plan", sub_cmd=2, plan_index=0)
-
         for hash_id, frame in list(self.mower.map.area.items()):
             missing_frames = self.mower.map.find_missing_frames(frame)
             if len(missing_frames) > 0:

{pymammotion-0.5.44 → pymammotion-0.5.49}/pymammotion/proto/__init__.py

@@ -267,7 +267,7 @@ import betterproto2
 
 from .message_pool import default_message_pool
 
-_COMPILER_VERSION = "0.8.0"
+_COMPILER_VERSION = "0.9.0"
 betterproto2.check_compiler_version(_COMPILER_VERSION)
 
 
@@ -1899,7 +1899,7 @@ class LoraCfgRsp(betterproto2.Message):
 
     cfg: "str" = betterproto2.field(3, betterproto2.TYPE_STRING)
 
-    fac_cfg: "str" = betterproto2.field(4, betterproto2.TYPE_STRING)
+    fac_cfg: "bytes" = betterproto2.field(4, betterproto2.TYPE_BYTES)
 
 
 default_message_pool.register_message("", "LoraCfgRsp", LoraCfgRsp)