pymammotion 0.0.40__py3-none-any.whl → 0.0.41__py3-none-any.whl

pymammotion/mqtt/{mqtt.py → mammotion_mqtt.py}

@@ -1,3 +1,5 @@
+"""MammotionMQTT."""
+
 import hashlib
 import hmac
 import json
@@ -8,22 +10,18 @@ from typing import Callable, Optional, cast
 from linkkit.linkkit import LinkKit
 from paho.mqtt.client import Client, MQTTMessage, MQTTv311, connack_string
 
-from pymammotion.data.model import RapidState
+from pymammotion.aliyun.cloud_gateway import CloudIOTGateway
 from pymammotion.data.mqtt.event import ThingEventMessage
 from pymammotion.data.mqtt.properties import ThingPropertiesMessage
 from pymammotion.data.mqtt.status import ThingStatusMessage
-from pymammotion.luba.base import BaseLuba
-from pymammotion.mammotion.commands.mammotion_command import MammotionCommand
 from pymammotion.proto import luba_msg_pb2
 
 logger = getLogger(__name__)
 
 
-# with sqlite3.connect("messages.db") as conn:
-#     conn.execute("CREATE TABLE IF NOT EXISTS messages (topic TEXT, timestamp INTEGER, payload TEXT)")
-
+class MammotionMQTT:
+    """MQTT client for pymammotion."""
 
-class LubaMQTT(BaseLuba):
     _cloud_client = None
 
     def __init__(
@@ -35,11 +33,13 @@ class LubaMQTT(BaseLuba):
         iot_token: str,
         client_id: Optional[str] = None,
     ):
+        """Create instance of MammotionMQTT."""
         super().__init__()
 
         self.on_connected: Optional[Callable[[], None]] = None
         self.on_error: Optional[Callable[[str], None]] = None
         self.on_disconnected: Optional[Callable[[], None]] = None
+        self.on_message: Optional[Callable[[str, str, str], None]] = None
 
         self._product_key = product_key
         self._device_name = device_name
@@ -50,9 +50,7 @@ class LubaMQTT(BaseLuba):
         if client_id is None:
             client_id = f"python-{device_name}"
         self._mqtt_client_id = f"{client_id}|securemode=2,signmethod=hmacsha1|"
-        sign_content = (
-            f"clientId{client_id}deviceName{device_name}productKey{product_key}"
-        )
+        sign_content = f"clientId{client_id}deviceName{device_name}productKey{product_key}"
         self._mqtt_password = hmac.new(
             device_secret.encode("utf-8"), sign_content.encode("utf-8"), hashlib.sha1
         ).hexdigest()
@@ -90,11 +88,13 @@ class LubaMQTT(BaseLuba):
 
     # region Connection handling
     def connect(self):
+        """Connect to MQTT Server."""
         logger.info("Connecting...")
         self._client.connect(host=self._mqtt_host)
         self._client.loop_forever()
 
     def connect_async(self):
+        """Connect async to MQTT Server."""
         logger.info("Connecting...")
         self._linkkit_client.thing_setup()
         self._linkkit_client.connect_async()
@@ -103,14 +103,16 @@ class LubaMQTT(BaseLuba):
         self._linkkit_client.start_worker_loop()
 
     def disconnect(self):
+        """Disconnect from MQTT Server."""
         logger.info("Disconnecting...")
         self._linkkit_client.disconnect()
         self._client.disconnect()
         self._client.loop_stop()
 
     def _thing_on_thing_enable(self, user_data):
-        print("on_thing_enable")
-        # print('subscribe_topic, topic:%s' % echo_topic)
+        """Is called when Thing is enabled."""
+        logger.debug("on_thing_enable")
+        # logger.debug('subscribe_topic, topic:%s' % echo_topic)
         # self._linkkit_client.subscribe_topic(echo_topic, 0)
         self._linkkit_client.subscribe_topic(
             f"/sys/{self._product_key}/{self._device_name}/app/down/account/bind_reply"
@@ -118,15 +120,9 @@ class LubaMQTT(BaseLuba):
         self._linkkit_client.subscribe_topic(
             f"/sys/{self._product_key}/{self._device_name}/app/down/thing/event/property/post_reply"
         )
-        self._linkkit_client.subscribe_topic(
-            f"/sys/{self._product_key}/{self._device_name}/app/down/thing/events"
-        )
-        self._linkkit_client.subscribe_topic(
-            f"/sys/{self._product_key}/{self._device_name}/app/down/thing/status"
-        )
-        self._linkkit_client.subscribe_topic(
-            f"/sys/{self._product_key}/{self._device_name}/app/down/thing/properties"
-        )
+        self._linkkit_client.subscribe_topic(f"/sys/{self._product_key}/{self._device_name}/app/down/thing/events")
+        self._linkkit_client.subscribe_topic(f"/sys/{self._product_key}/{self._device_name}/app/down/thing/status")
+        self._linkkit_client.subscribe_topic(f"/sys/{self._product_key}/{self._device_name}/app/down/thing/properties")
         self._linkkit_client.subscribe_topic(
             f"/sys/{self._product_key}/{self._device_name}/app/down/thing/model/down_raw"
         )
@@ -144,27 +140,34 @@ class LubaMQTT(BaseLuba):
         )
 
         # self._linkkit_client.query_ota_firmware()
-        command = MammotionCommand(device_name="Luba")
-        self._cloud_client.send_cloud_command(command.get_report_cfg())
+        # command = MammotionCommand(device_name="Luba")
+        # self._cloud_client.send_cloud_command(command.get_report_cfg())
 
     def _thing_on_topic_message(self, topic, payload, qos, user_data):
-        print(
-            "on_topic_message, receive message, topic:%s, payload:%s, qos:%d"
-            % (topic, payload, qos)
+        """Is called when thing topic comes in."""
+        logger.debug(
+            "on_topic_message, receive message, topic:%s, payload:%s, qos:%d",
+            topic,
+            payload,
+            qos,
         )
+        payload = json.loads(payload)
+        iot_id = payload.get("params", {}).get("iotId", "")
+        if iot_id != "" and self.on_message:
+            self.on_message(topic, payload, iot_id)
 
     def _thing_on_connect(self, session_flag, rc, user_data):
-        print("on_connect, session_flag:%d, rc:%d" % (session_flag, rc))
+        """Is called on thing connect."""
+        logger.debug("on_connect, session_flag:%d, rc:%d", session_flag, rc)
 
         # self._linkkit_client.subscribe_topic(f"/sys/{self._product_key}/{self._device_name}/#")
 
     def _on_connect(self, _client, _userdata, _flags: dict, rc: int):
+        """Is called when on connect."""
         if rc == 0:
-            logger.info("Connected")
+            logger.debug("Connected")
             self._client.subscribe(f"/sys/{self._product_key}/{self._device_name}/#")
-            self._client.subscribe(
-                f"/sys/{self._product_key}/{self._device_name}/app/down/account/bind_reply"
-            )
+            self._client.subscribe(f"/sys/{self._product_key}/{self._device_name}/app/down/account/bind_reply")
 
             self._client.publish(
                 f"/sys/{self._product_key}/{self._device_name}/app/up/account/bind",
@@ -186,18 +189,15 @@ class LubaMQTT(BaseLuba):
                 self.on_error(connack_string(rc))
 
     def _on_disconnect(self, _client, _userdata, rc: int):
+        """Is called on disconnect."""
         logger.info("Disconnected")
         logger.debug(rc)
         if self.on_disconnected:
             self.on_disconnected()
 
-    # endregion
-
     def _on_message(self, _client, _userdata, message: MQTTMessage):
+        """Is called when message is received."""
         logger.info("Message on topic %s", message.topic)
-        # with sqlite3.connect("messages.db") as conn:
-        #     conn.execute("INSERT INTO messages (topic, timestamp, payload) VALUES (?, ?, ?)",
-        #                  (message.topic, int(message.timestamp), message.payload.decode("utf-8")))
 
         payload = json.loads(message.payload)
         if message.topic.endswith("/app/down/thing/events"):
@@ -205,26 +205,22 @@ class LubaMQTT(BaseLuba):
             params = event.params
             if params.identifier == "device_protobuf_msg_event":
                 content = cast(luba_msg_pb2, params.value.content)
-                if (
-                    content.WhichOneof("subMsg") == "sys"
-                    and content.sys.WhichOneof("subSysMsg") == "systemRapidState"
-                ):
-                    state = RapidState.from_raw(content.sys.systemRapidState.data)
-                    self._set_rapid_state(state)
-                else:
-                    logger.info(
-                        "Unhandled protobuf event: %s", content.WhichOneof("subMsg")
-                    )
+
+                logger.info("Unhandled protobuf event: %s", content.WhichOneof("subMsg"))
             elif params.identifier == "device_warning_event":
-                if self.on_warning:
-                    self.on_warning(params.value.code)
+                logger.debug("identifier event: %s", params.identifier)
             else:
                 logger.info("Unhandled event: %s", params.identifier)
         elif message.topic.endswith("/app/down/thing/status"):
             status = ThingStatusMessage(**payload)
-            self._set_status(status.params.status.value)
+            logger.debug(status.params.status.value)
         elif message.topic.endswith("/app/down/thing/properties"):
             properties = ThingPropertiesMessage(**payload)
+            logger.debug("properties: %s", properties)
         else:
-            logger.info("Unhandled topic: %s", message.topic)
+            logger.debug("Unhandled topic: %s", message.topic)
             logger.debug(payload)
+
+    def get_cloud_client(self) -> Optional[CloudIOTGateway]:
+        """Return internal cloud client."""
+        return self._cloud_client

pymammotion/utility/constant/device_constant.py

@@ -210,6 +210,20 @@ class WorkMode:
 
 
 def device_mode(value):
+    """Return the mode corresponding to the given value.
+
+    This function takes a value and returns the corresponding mode from a
+    predefined dictionary.
+
+    Args:
+        value (int): The value for which mode needs to be determined.
+
+    Returns:
+        str: The mode corresponding to the input value. Returns "Invalid mode" if no
+            mode is found.
+
+    """
+
     modes = {
         0: "MODE_NOT_ACTIVE",
         1: "MODE_ONLINE",

pymammotion/utility/datatype_converter.py

@@ -6,6 +6,19 @@ class DatatypeConverter:
 
     @staticmethod
     def init_encode_map():
+        """Initialize the encode map for DatatypeConverter if it is not already
+        initialized.
+
+        This function initializes the encode map for DatatypeConverter by
+        creating a list of 64 elements and populating it with characters for
+        encoding. If the encode map is already initialized, it returns the
+        existing encode map.
+
+        Returns:
+            list: The encode map for DatatypeConverter.
+
+        """
+
         if DatatypeConverter.encode_map is None:
             cArr = [0] * 64
             for i in range(26):
@@ -33,6 +46,21 @@ class DatatypeConverter:
 
     @staticmethod
     def _printBase64Binary(bArr, i=0, i2=None):
+        """Print the Base64 binary representation of a byte array.
+
+        This function takes a byte array and optional start and end indices to
+        print the Base64 binary representation.
+
+        Args:
+            bArr (list): A list of bytes to be converted to Base64 binary.
+            i (int): The starting index of the byte array (default is 0).
+            i2 (int): The ending index of the byte array (default is the length of bArr).
+
+        Returns:
+            str: The Base64 binary representation of the input byte array.
+
+        """
+
         if i2 is None:
             i2 = len(bArr)
         cArr = [""] * (((i2 + 2) // 3) * 4)
@@ -41,15 +69,32 @@ class DatatypeConverter:
 
     @staticmethod
     def _printBase64Binary_core(bArr, i, i2, cArr, i3):
+        """Encode binary data into Base64 format.
+
+        This function encodes binary data into Base64 format following the
+        Base64 encoding algorithm.
+
+        Args:
+            bArr (list): List of binary data to be encoded.
+            i (int): Starting index of the binary data to be encoded.
+            i2 (int): Length of binary data to be encoded.
+            cArr (list): List to store the encoded Base64 characters.
+            i3 (int): Starting index in the cArr to store the encoded characters.
+
+        Returns:
+            int: The index in cArr where encoding ends.
+
+        Note:
+            This function assumes that DatatypeConverter has a method 'encode' and
+            'init_encode_map' for encoding.
+
+        """
+
         DatatypeConverter.init_encode_map()  # Ensure encode_map is initialized
         while i2 >= 3:
             cArr[i3] = DatatypeConverter.encode(bArr[i] >> 2)
-            cArr[i3 + 1] = DatatypeConverter.encode(
-                ((bArr[i] & 3) << 4) | ((bArr[i + 1] >> 4) & 15)
-            )
-            cArr[i3 + 2] = DatatypeConverter.encode(
-                ((bArr[i + 1] & 15) << 2) | ((bArr[i + 2] >> 6) & 3)
-            )
+            cArr[i3 + 1] = DatatypeConverter.encode(((bArr[i] & 3) << 4) | ((bArr[i + 1] >> 4) & 15))
+            cArr[i3 + 2] = DatatypeConverter.encode(((bArr[i + 1] & 15) << 2) | ((bArr[i + 2] >> 6) & 3))
             cArr[i3 + 3] = DatatypeConverter.encode(bArr[i + 2] & 63)
             i2 -= 3
             i += 3
@@ -63,9 +108,7 @@ class DatatypeConverter:
 
         if i2 == 2:
             cArr[i3] = DatatypeConverter.encode(bArr[i] >> 2)
-            cArr[i3 + 1] = DatatypeConverter.encode(
-                ((bArr[i] & 3) << 4) | ((bArr[i + 1] >> 4) & 15)
-            )
+            cArr[i3 + 1] = DatatypeConverter.encode(((bArr[i] & 3) << 4) | ((bArr[i + 1] >> 4) & 15))
             cArr[i3 + 2] = DatatypeConverter.encode((bArr[i + 1] & 15) << 2)
             cArr[i3 + 3] = "="
 

pymammotion/utility/device_type.py

@@ -30,6 +30,19 @@ class DeviceType(Enum):
 
     @staticmethod
     def valueof(value):
+        """Return the corresponding DeviceType based on the input value.
+
+        This function takes an integer value as input and returns the
+        corresponding DeviceType enum value.
+
+        Args:
+            value (int): An integer representing the device type.
+
+        Returns:
+            DeviceType: The corresponding DeviceType enum value based on the input value.
+
+        """
+
         if value == 0:
             return DeviceType.RTK
         elif value == 1:
@@ -43,6 +56,18 @@ class DeviceType(Enum):
 
     @staticmethod
     def value_of_str(device_name, product_key=""):
+        """Determine the type of device based on the provided device name and
+        product key.
+
+        Args:
+            device_name (str): The name of the device.
+            product_key (str?): The product key associated with the device. Defaults to "".
+
+        Returns:
+            DeviceType: The type of device based on the provided information.
+
+        """
+
         if not device_name and not product_key:
             return DeviceType.UNKNOWN
 
@@ -50,21 +75,13 @@ class DeviceType(Enum):
             substring = device_name[:3]
             substring2 = device_name[:7]
 
-            if DeviceType.RTK.name in substring or DeviceType.contain_rtk_product_key(
-                product_key
-            ):
+            if DeviceType.RTK.name in substring or DeviceType.contain_rtk_product_key(product_key):
                 return DeviceType.RTK
-            elif (
-                DeviceType.LUBA_2.name in substring2
-                or DeviceType.contain_luba_2_product_key(product_key)
-            ):
+            elif DeviceType.LUBA_2.name in substring2 or DeviceType.contain_luba_2_product_key(product_key):
                 return DeviceType.LUBA_2
             elif DeviceType.LUBA_YUKA.name in substring2:
                 return DeviceType.LUBA_YUKA
-            elif (
-                DeviceType.LUBA.name in substring2
-                or DeviceType.contain_luba_product_key(product_key)
-            ):
+            elif DeviceType.LUBA.name in substring2 or DeviceType.contain_luba_product_key(product_key):
                 return DeviceType.LUBA
             else:
                 return DeviceType.UNKNOWN
@@ -73,6 +90,22 @@ class DeviceType(Enum):
 
     @staticmethod
     def has_4g(device_name, product_key=""):
+        """Check if the device has 4G capability based on the device name and
+        optional product key.
+
+        This function determines the device type based on the device name and
+        product key (if provided). It then checks if the device type has a value
+        greater than or equal to the 4G threshold.
+
+        Args:
+            device_name (str): The name of the device.
+            product_key (str?): The product key associated with the device. Defaults to "".
+
+        Returns:
+            bool: True if the device has 4G capability, False otherwise.
+
+        """
+
         if not product_key:
             device_type = DeviceType.value_of_str(device_name)
         else:
@@ -82,6 +115,21 @@ class DeviceType(Enum):
 
     @staticmethod
     def is_luba1(device_name, product_key=""):
+        """Check if the given device is of type LUBA.
+
+        This function determines if the device specified by 'device_name' is of
+        type LUBA. If 'product_key' is provided, it is used to further identify
+        the device type.
+
+        Args:
+            device_name (str): The name of the device.
+            product_key (str?): The product key associated with the device. Defaults to "".
+
+        Returns:
+            bool: True if the device is of type LUBA, False otherwise.
+
+        """
+
         if not product_key:
             device_type = DeviceType.value_of_str(device_name)
         else:
@@ -91,6 +139,18 @@ class DeviceType(Enum):
 
     @staticmethod
     def is_luba_2(device_name, product_key=""):
+        """Check if the device type is LUBA 2 or higher based on the device name
+        and optional product key.
+
+        Args:
+            device_name (str): The name of the device.
+            product_key (str?): The product key associated with the device. Defaults to "".
+
+        Returns:
+            bool: True if the device type is LUBA 2 or higher, False otherwise.
+
+        """
+
         if not product_key:
             device_type = DeviceType.value_of_str(device_name)
         else:
@@ -100,32 +160,71 @@ class DeviceType(Enum):
 
     @staticmethod
     def is_yuka(device_name):
-        return (
-            DeviceType.value_of_str(device_name).get_value()
-            == DeviceType.LUBA_YUKA.get_value()
-        )
+        """Check if the given device name corresponds to a LUBA_YUKA device type.
+
+        Args:
+            device_name (str): The name of the device to be checked.
+
+        Returns:
+            bool: True if the device type is LUBA_YUKA, False otherwise.
+
+        """
+
+        return DeviceType.value_of_str(device_name).get_value() == DeviceType.LUBA_YUKA.get_value()
 
     @staticmethod
     def is_rtk(device_name, product_key=""):
+        """Check if the device type is within the range of RTK devices.
+
+        This function determines if the device type corresponding to the given
+        device name and optional product key falls within the range of RTK
+        (Real-Time Kinematic) devices.
+
+        Args:
+            device_name (str): The name of the device.
+            product_key (str?): The product key associated with the device. Defaults to "".
+
+        Returns:
+            bool: True if the device type is within the RTK range, False otherwise.
+
+        """
+
         if not product_key:
             device_type = DeviceType.value_of_str(device_name)
         else:
             device_type = DeviceType.value_of_str(device_name, product_key)
 
-        return (
-            DeviceType.RTK.get_value()
-            <= device_type.get_value()
-            < DeviceType.LUBA.get_value()
-        )
+        return DeviceType.RTK.get_value() <= device_type.get_value() < DeviceType.LUBA.get_value()
 
     @staticmethod
     def contain_rtk_product_key(product_key):
+        """Check if the given product key is in a predefined list of RTK product
+        keys.
+
+        Args:
+            product_key (str): The product key to be checked.
+
+        Returns:
+            bool: True if the product key is in the predefined list, False otherwise.
+
+        """
+
         if not product_key:
             return False
         return product_key in ["a1qXkZ5P39W", "a1Nc68bGZzX"]
 
     @staticmethod
     def contain_luba_product_key(product_key):
+        """Check if the given product key is in the list of valid product keys.
+
+        Args:
+            product_key (str): The product key to be checked.
+
+        Returns:
+            bool: True if the product key is in the list of valid keys, False otherwise.
+
+        """
+
         if not product_key:
             return False
         return product_key in [
@@ -144,6 +243,16 @@ class DeviceType(Enum):
 
     @staticmethod
     def contain_luba_2_product_key(product_key):
+        """Check if the given product key is present in a predefined list.
+
+        Args:
+            product_key (str): The product key to be checked.
+
+        Returns:
+            bool: True if the product key is in the predefined list, False otherwise.
+
+        """
+
         if not product_key:
             return False
         return product_key in ["a1iMygIwxFC", "a1LLmy1zc0j", "a1LLmy1zc0j"]

pymammotion/utility/periodic.py

@@ -10,12 +10,24 @@ class Periodic:
         self._task = None
 
     def start(self):
+        """Start the task if it is not already started.
+
+        If the task is not already started, it sets the 'is_started' flag to
+        True and initiates a task to call a function periodically using asyncio.
+        """
+
         if not self.is_started:
             self.is_started = True
             # Start task to call func periodically:
             self._task = asyncio.ensure_future(self._run())
 
     async def stop(self):
+        """Stop the task if it is currently running.
+
+        If the task is currently running, it will be cancelled and awaited until
+        it stops.
+        """
+
         if self.is_started:
             self.is_started = False
             # Stop task and await it stopped:
@@ -24,14 +36,67 @@ class Periodic:
                 await self._task
 
     async def _run(self):
+        """Run the specified function at regular intervals using asyncio.
+
+        This method runs the specified function at regular intervals based on
+        the time provided.
+
+        Args:
+            self: The instance of the class.
+
+        """
+
         while True:
             await asyncio.sleep(self.time)
             await self.func()
 
 
 def periodic(period):
+    """Schedule a function to run periodically at a specified time interval.
+
+    This decorator function takes a period (in seconds) as input and returns
+    a scheduler function. The scheduler function, when applied as a
+    decorator to another function, will run the decorated function
+    periodically at the specified time interval.
+
+    Args:
+        period (int): Time interval in seconds at which the decorated function should run
+            periodically.
+
+    Returns:
+        function: A scheduler function that can be used as a decorator to run a function
+            periodically.
+
+    """
+
     def scheduler(fcn):
+        """Schedule the execution of a given async function periodically.
+
+        This function takes an async function as input and returns a new async
+        function that will execute the input function periodically at a
+        specified interval.
+
+        Args:
+            fcn (function): The async function to be scheduled.
+
+        Returns:
+            function: An async function that will execute the input function periodically.
+
+        """
+
         async def wrapper(*args, **kwargs):
+            """Execute the given function periodically using asyncio tasks.
+
+            This function continuously creates an asyncio task to execute the
+            provided function with the given arguments and keyword arguments. It
+            then waits for a specified period of time before creating the next task.
+
+            Args:
+                *args: Variable length argument list to be passed to the function.
+                **kwargs: Arbitrary keyword arguments to be passed to the function.
+
+            """
+
             while True:
                 asyncio.create_task(fcn(*args, **kwargs))
                 await asyncio.sleep(period)