pymammotion 0.2.3__tar.gz → 0.2.5__tar.gz

{pymammotion-0.2.3 → pymammotion-0.2.5}/PKG-INFO

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

{pymammotion-0.2.3 → pymammotion-0.2.5}/pymammotion/aliyun/cloud_gateway.py

@@ -522,7 +522,7 @@ class CloudIOTGateway:
             logger.error(
                 "Error in sending cloud command: %s - %s",
                 str(response_body_dict.get("code")),
-                str(response_body_dict["msg"]),
+                str(response_body_dict.get("msg")),
             )
             return ""
 

pymammotion-0.2.5/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-0.2.3 → pymammotion-0.2.5}/pymammotion/mammotion/commands/mammotion_command.py

@@ -1,3 +1,4 @@
+from pymammotion.mammotion.commands.messages.driver import MessageDriver
 from pymammotion.mammotion.commands.messages.navigation import MessageNavigation
 from pymammotion.mammotion.commands.messages.network import MessageNetwork
 from pymammotion.mammotion.commands.messages.ota import MessageOta
@@ -6,7 +7,7 @@ from pymammotion.mammotion.commands.messages.video import MessageVideo
 from pymammotion.proto import dev_net_pb2, luba_msg_pb2
 
 
-class MammotionCommand(MessageSystem, MessageNavigation, MessageNetwork, MessageOta, MessageVideo):
+class MammotionCommand(MessageSystem, MessageNavigation, MessageNetwork, MessageOta, MessageVideo, MessageDriver):
     """MQTT commands for Luba."""
 
     def __init__(self, device_name: str) -> None:

{pymammotion-0.2.3 → pymammotion-0.2.5}/pymammotion/mammotion/devices/mammotion.py

@@ -9,6 +9,7 @@ import json
 import logging
 from abc import abstractmethod
 from enum import Enum
+from functools import cache
 from typing import Any, Callable, Optional, cast
 from uuid import UUID
 
@@ -172,12 +173,13 @@ class MammotionMixedDeviceManager:
 
 class MammotionDevices:
 
-    devices = dict[str, MammotionMixedDeviceManager] = {}
+    devices: dict[str, MammotionMixedDeviceManager] = {}
 
     def add_device(self, mammotion_device: MammotionMixedDeviceManager) -> None:
         exists: MammotionMixedDeviceManager | None = self.devices.get(mammotion_device.name)
-        if not exists:
+        if exists is None:
             self.devices[mammotion_device.name] = mammotion_device
+            return
         if mammotion_device.has_cloud():
             exists.replace_cloud(mammotion_device.cloud())
         if mammotion_device.has_ble():
@@ -186,16 +188,31 @@ class MammotionDevices:
     def get_device(self, mammotion_device_name: str) -> MammotionMixedDeviceManager:
         return self.devices.get(mammotion_device_name)
 
-class Mammotion:
+async def create_devices(ble_device: BLEDevice,
+    cloud_credentials: Credentials | None = None,
+    preference: ConnectionPreference = ConnectionPreference.BLUETOOTH):
+    cloud_client = await Mammotion.login(cloud_credentials.account_id or cloud_credentials.email, cloud_credentials.password)
+    mammotion = Mammotion(ble_device, preference)
+
+    if cloud_credentials:
+        await mammotion.initiate_cloud_connection(cloud_client)
+
+    return mammotion
+
+
+@cache
+class Mammotion(object):
     """Represents a Mammotion device."""
 
     devices = MammotionDevices()
+    _mammotion_mqtt: MammotionMQTT | None = None
+
+
 
     def __init__(
         self,
-        ble_device: BLEDevice,
-        cloud_credentials: Credentials | None = None,
-        preference: ConnectionPreference = ConnectionPreference.BLUETOOTH,
+            ble_device: BLEDevice,
+            preference: ConnectionPreference = ConnectionPreference.BLUETOOTH
     ) -> None:
         """Initialize MammotionDevice."""
         if ble_device:
@@ -204,25 +221,28 @@ class Mammotion:
         if preference:
             self._preference = preference
 
-        if cloud_credentials:
-            self.initiate_cloud_connection(cloud_credentials.account_id or cloud_credentials.email, cloud_credentials.password)
+    async def initiate_cloud_connection(self, cloud_client: CloudIOTGateway) -> None:
+        if self._mammotion_mqtt is not None:
+            if not self._mammotion_mqtt.is_connected:
+                loop = asyncio.get_running_loop()
+                await loop.run_in_executor(None, self._mammotion_mqtt.connect_async)
+            return
 
-    async def initiate_cloud_connection(self, account: str, password: str):
-        cloud_client = await self.login(account, password)
 
-        _mammotion_mqtt = MammotionMQTT(region_id=cloud_client._region.data.regionId,
+        self._mammotion_mqtt = MammotionMQTT(region_id=cloud_client._region.data.regionId,
                                         product_key=cloud_client._aep_response.data.productKey,
                                         device_name=cloud_client._aep_response.data.deviceName,
                                         device_secret=cloud_client._aep_response.data.deviceSecret,
                                         iot_token=cloud_client._session_by_authcode_response.data.iotToken,
                                         client_id=cloud_client._client_id)
 
-        _mammotion_mqtt._cloud_client = cloud_client
-        _mammotion_mqtt.connect_async()
+        self._mammotion_mqtt._cloud_client = cloud_client
+        loop = asyncio.get_running_loop()
+        await loop.run_in_executor(None, self._mammotion_mqtt.connect_async)
 
         for device in cloud_client.listing_dev_by_account_response.data.data:
             if device.deviceName.startswith(("Luba-", "Yuka-")):
-                self.devices.add_device(MammotionMixedDeviceManager(name=device.deviceName, cloud_device=device, mqtt=_mammotion_mqtt))
+                self.devices.add_device(MammotionMixedDeviceManager(name=device.deviceName, cloud_device=device, mqtt=self._mammotion_mqtt))
 
 
     @staticmethod
@@ -234,15 +254,17 @@ class Mammotion:
             country_code = mammotion_http.login_info.userInformation.domainAbbreviation
             _LOGGER.debug("CountryCode: " + country_code)
             _LOGGER.debug("AuthCode: " + mammotion_http.login_info.authorization_code)
-            cloud_client.get_region(country_code, mammotion_http.login_info.authorization_code)
+            loop = asyncio.get_running_loop()
+            await loop.run_in_executor(None, cloud_client.get_region, country_code, mammotion_http.login_info.authorization_code)
             await cloud_client.connect()
             await cloud_client.login_by_oauth(country_code, mammotion_http.login_info.authorization_code)
-            cloud_client.aep_handle()
-            cloud_client.session_by_auth_code()
+            await loop.run_in_executor(None, cloud_client.aep_handle)
+            await loop.run_in_executor(None, cloud_client.session_by_auth_code)
 
-            cloud_client.list_binding_by_account()
+            await loop.run_in_executor(None, cloud_client.list_binding_by_account)
             return cloud_client
 
+
     def get_device_by_name(self, name: str) -> MammotionMixedDeviceManager:
         return self.devices.get_device(name)
 
@@ -256,7 +278,7 @@ class Mammotion:
                 return await device.cloud().command(key)
             # TODO work with both with EITHER
 
-    async def send_command_with_args(self,name: str, key: str, kwargs):
+    async def send_command_with_args(self,name: str, key: str, **kwargs: any):
         """Send a command with args to the device."""
         device = self.get_device_by_name(name)
         if device:
@@ -287,7 +309,7 @@ class Mammotion:
     def mower(self, name: str):
         device = self.get_device_by_name(name)
         if device:
-            return device.mower_state
+            return device.mower_state()
 
 def has_field(message: betterproto.Message) -> bool:
     """Check if the message has any fields serialized on wire."""
@@ -905,22 +927,26 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
         if self.on_ready_callback:
             self.on_ready_callback()
 
+        asyncio.run(self._ble_sync())
+        asyncio.run(self.run_periodic_sync_task())
+
     def on_connected(self):
         """Callback for when MQTT connects."""
-        self._ble_sync()
-        self.run_periodic_sync_task()
+
 
     def on_disconnected(self):
         """Callback for when MQTT disconnects."""
 
-    def _ble_sync(self):
+    async def _ble_sync(self):
         command_bytes = self._commands.send_todev_ble_sync(3)
-        self._mqtt_client.get_cloud_client().send_cloud_command(self.iot_id, command_bytes)
+        loop = asyncio.get_running_loop()
+        await loop.run_in_executor(None, self._mqtt_client.get_cloud_client().send_cloud_command, self.iot_id, command_bytes)
+
 
     async def run_periodic_sync_task(self) -> None:
         """Send ble sync to robot."""
         try:
-            self._ble_sync()
+            await self._ble_sync()
         finally:
             self.schedule_ble_sync()
 
@@ -943,14 +969,14 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
     async def _send_command(self, key: str, retry: int | None = None) -> bytes | None:
         """Send command to device via MQTT and read response."""
         if self._operation_lock.locked():
-            _LOGGER.debug("%s: Operation already in progress, waiting for it to complete;", self.nick_name)
+            _LOGGER.debug("%s: Operation already in progress, waiting for it to complete;", self.device.nickName)
 
         async with self._operation_lock:
             try:
                 command_bytes = getattr(self._commands, key)()
                 return await self._send_command_locked(key, command_bytes)
             except Exception as ex:
-                _LOGGER.exception("%s: error in sending command -  %s", self.nick_name, ex)
+                _LOGGER.exception("%s: error in sending command -  %s", self.device.nickName, ex)
                 raise
 
     async def _send_command_locked(self, key: str, command: bytes) -> bytes:
@@ -962,7 +988,7 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
             await asyncio.sleep(DBUS_ERROR_BACKOFF_TIME)
             _LOGGER.debug(
                 "%s: error in _send_command_locked: %s",
-                self.nick_name,
+                self.device.nickName,
                 ex,
             )
             raise
@@ -972,8 +998,9 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
         assert self._mqtt_client is not None
         self._notify_future = self.loop.create_future()
         self._key = key
-        _LOGGER.debug("%s: Sending command: %s", self.nick_name, key)
-        self._mqtt_client.get_cloud_client().send_cloud_command(self.iot_id, command)
+        _LOGGER.debug("%s: Sending command: %s", self.device.nickName, key)
+        loop = asyncio.get_running_loop()
+        await loop.run_in_executor(None, self._mqtt_client.get_cloud_client().send_cloud_command, self.iot_id, command)
 
         retry_handle = self.loop.call_at(
             self.loop.time() + 20,
@@ -997,20 +1024,20 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
                 retry_handle.cancel()
             self._notify_future = None
 
-        _LOGGER.debug("%s: Message received", self.nick_name)
+        _LOGGER.debug("%s: Message received", self.device.nickName)
 
         return notify_msg
 
     async def _send_command_with_args(self, key: str, **kwargs: any) -> bytes | None:
         """Send command with arguments to device via MQTT and read response."""
         if self._operation_lock.locked():
-            _LOGGER.debug("%s: Operation already in progress, waiting for it to complete;", self.nick_name)
+            _LOGGER.debug("%s: Operation already in progress, waiting for it to complete;", self.device.nickName)
         async with self._operation_lock:
             try:
                 command_bytes = getattr(self._commands, key)(**kwargs)
                 return await self._send_command_locked(key, command_bytes)
             except Exception as ex:
-                _LOGGER.exception("%s: error in sending command -  %s", self.nick_name, ex)
+                _LOGGER.exception("%s: error in sending command -  %s", self.device.nickName, ex)
                 raise
 
     def _extract_message_id(self, payload: dict) -> str:

{pymammotion-0.2.3 → pymammotion-0.2.5}/pymammotion/mqtt/mammotion_mqtt.py

@@ -147,12 +147,11 @@ class MammotionMQTT:
 
         # self._linkkit_client.subscribe_topic(f"/sys/{self._product_key}/{self._device_name}/#")
 
-    def _on_disconnect(self, _client, _userdata, rc: int):
+    def _on_disconnect(self, _client, _userdata):
         """Is called on disconnect."""
         logger.info("Disconnected")
         self.is_connected = False
         self.is_ready = False
-        logger.debug(rc)
         if self.on_disconnected:
             self.on_disconnected()
 

{pymammotion-0.2.3 → pymammotion-0.2.5}/pyproject.toml

@@ -1,10 +1,10 @@
 [project]
 name        = "pymammotion"
-version     = "0.2.3"
+version     = "0.2.5"
 
 [tool.poetry]
 name        = "pymammotion"
-version     = "0.2.3"
+version     = "0.2.5"
 license     = "GNU-3.0"
 description = ""
 readme      = "README.md"
@@ -52,7 +52,7 @@ mypy = "^1.10.0"
 pre-commit = "^3.7.1"
 
 [tool.bumpver]
-current_version = "0.2.3"
+current_version = "0.2.5"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit_message  = "Bump version {old_version} -> {new_version}"
 commit          = true

pymammotion-0.2.3/pymammotion/data/model/account.py

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