pymammotion 0.4.0a5__py3-none-any.whl → 0.4.0a7__py3-none-any.whl

pymammotion/mqtt/linkkit/linkkit.py

@@ -16,23 +16,23 @@
 #
 #
 
-import os
-import logging
-import threading
-import queue
-import urllib.request
-import urllib.parse
-import json
 import hashlib
 import hmac
+import json
+import logging
+import os
+import queue
 import random
+import re
 import ssl
-import socket
 import string
-import time
-import re
 import sys
+import threading
+import time
+import urllib.parse
+import urllib.request
 from enum import Enum
+
 import paho.mqtt.client as mqtt
 from paho.mqtt.enums import CallbackAPIVersion
 
@@ -41,17 +41,19 @@ REQUIRED_MINOR_VERSION = 5
 
 
 # check Python version
-def lk_check_python_version(major_version, minor_version):
+def lk_check_python_version(major_version, minor_version) -> None:
     version = sys.version_info
     if version[0] < major_version or (version[0] == major_version and version[1] < minor_version):
-        print("WARNING: linkit requires Python %d.%d or higher, and the current version is %s" % (
-            major_version, minor_version, sys.version))
+        print(
+            "WARNING: linkit requires Python %d.%d or higher, and the current version is %s"
+            % (major_version, minor_version, sys.version)
+        )
 
 
 lk_check_python_version(REQUIRED_MAJOR_VERSION, REQUIRED_MINOR_VERSION)
 
 
-class LinkKit(object):
+class LinkKit:
     TAG_KEY = "attrKey"
     TAG_VALUE = "attrValue"
 
@@ -67,33 +69,32 @@ class LinkKit(object):
     class ErrorCode(Enum):
         SUCCESS = 0
         # 错误码一共三位数，第一位为0表示为mqtt相关的错误码
-        NETWORK_DISCONNECTED = -0x001    # 当前mqtt连接断开
-        INVALID_TOPIC = -0x002            # 输入的topic为空
-        INVALID_QOS = -0x003             # 输入的qos非法
-        PAHO_MQTT_ERROR = -0x004         # 底层的mqtt报错
+        NETWORK_DISCONNECTED = -0x001  # 当前mqtt连接断开
+        INVALID_TOPIC = -0x002  # 输入的topic为空
+        INVALID_QOS = -0x003  # 输入的qos非法
+        PAHO_MQTT_ERROR = -0x004  # 底层的mqtt报错
         # 0x100开头的表示为网关相关的错误码
-        NULL_SUBDEV_ERR = -0x101         # 输入的子设备信息为空错误
-        SUBDEV_NOT_ARRAY_ERR = -0x102    # 输入数据并非数组错误
-        ARRAY_LENGTH_ERR = -0x103        # 数组长度错误
+        NULL_SUBDEV_ERR = -0x101  # 输入的子设备信息为空错误
+        SUBDEV_NOT_ARRAY_ERR = -0x102  # 输入数据并非数组错误
+        ARRAY_LENGTH_ERR = -0x103  # 数组长度错误
         # 0x300开头的表示为动态注册相关的错误码
-        DYNREG_AUTH_FAILED = -0x301      # 预注册动态注册认证失败
+        DYNREG_AUTH_FAILED = -0x301  # 预注册动态注册认证失败
         DYNREG_AUTH_NWL_FAILED = -0x302  # 免白动态注册认证失败
         # 0x400开头表示为OTA有关的错误
-        OTA_INVALID_PARAM = -0x401       # 参数非法
-        OTA_DIGEST_MISMATCH = -0x402     # 校验和不通过
-        OTA_PUB_FAILED = -0x403          # 上报失败
-        OTA_INVALID_SIGN_METHOD = -0x404 # 非法校验方法
-        OTA_DOWNLOAD_FAIL = -0x405       # 下载失败
-        OTA_INVALID_URL = -0X406         # 无法访问HTTP链接
-        OTA_INVALID_PATH = -0X407        # 存储路径打开失败
-
+        OTA_INVALID_PARAM = -0x401  # 参数非法
+        OTA_DIGEST_MISMATCH = -0x402  # 校验和不通过
+        OTA_PUB_FAILED = -0x403  # 上报失败
+        OTA_INVALID_SIGN_METHOD = -0x404  # 非法校验方法
+        OTA_DOWNLOAD_FAIL = -0x405  # 下载失败
+        OTA_INVALID_URL = -0x406  # 无法访问HTTP链接
+        OTA_INVALID_PATH = -0x407  # 存储路径打开失败
 
     class StateError(Exception):
-        def __init__(self, err):
+        def __init__(self, err) -> None:
             Exception.__init__(self, err)
 
-    class Shadow(object):
-        def __init__(self):
+    class Shadow:
+        def __init__(self) -> None:
             self.__version = None
             self.__timestamp = None
             self.__state = None
@@ -114,23 +115,23 @@ class LinkKit(object):
             with self.__latest_shadow_lock:
                 return self.__state
 
-        def set_state(self, state):
+        def set_state(self, state) -> None:
             with self.__latest_shadow_lock:
                 self.__state = state
 
-        def set_metadata(self, metadata):
+        def set_metadata(self, metadata) -> None:
             with self.__latest_shadow_lock:
                 self.__metadata = metadata
 
-        def set_version(self, version):
+        def set_version(self, version) -> None:
             with self.__latest_shadow_lock:
                 self.__version = version
 
-        def set_timestamp(self, timestamp):
+        def set_timestamp(self, timestamp) -> None:
             with self.__latest_shadow_lock:
                 self.__timestamp = timestamp
 
-        def set_latest_recevied_time(self, timestamp):
+        def set_latest_recevied_time(self, timestamp) -> None:
             with self.__latest_shadow_lock:
                 self.__latest_received_time = timestamp
 
@@ -138,7 +139,7 @@ class LinkKit(object):
             with self.__latest_shadow_lock:
                 return self.__latest_received_time
 
-        def set_latest_recevied_payload(self, payload):
+        def set_latest_recevied_payload(self, payload) -> None:
             with self.__latest_shadow_lock:
                 self.__latest_received_payload = payload
 
@@ -147,15 +148,18 @@ class LinkKit(object):
                 return self.__latest_received_payload
 
         def to_dict(self):
-            return {'state': self.__state, 'metadata': self.__metadata, 'version': self.__version,
-                    'timestamp': self.__timestamp}
+            return {
+                "state": self.__state,
+                "metadata": self.__metadata,
+                "version": self.__version,
+                "timestamp": self.__timestamp,
+            }
 
         def to_json_string(self):
             return json.dumps(self.to_dict())
 
-    class __HandlerTask(object):
-
-        def __init__(self, logger=None):
+    class __HandlerTask:
+        def __init__(self, logger=None) -> None:
             self.__logger = logger
             if self.__logger is not None:
                 self.__logger.info("HandlerTask init enter")
@@ -164,21 +168,18 @@ class LinkKit(object):
             self.__started = False
             self.__exited = False
             self.__thread = None
-            pass
 
-        def register_cmd_callback(self, cmd, callback):
+        def register_cmd_callback(self, cmd, callback) -> int:
             if self.__started is False:
                 if cmd != "req_exit":
                     self.__cmd_callback[cmd] = callback
                     return 0
                 else:
                     return 1
-                pass
             else:
                 return 2
-            pass
 
-        def post_message(self, cmd, value):
+        def post_message(self, cmd, value) -> bool:
             self.__logger.debug("post_message :%r " % cmd)
             if self.__started and self.__exited is False:
                 try:
@@ -190,9 +191,8 @@ class LinkKit(object):
                 return True
             self.__logger.debug("post_message fail started:%r,exited:%r" % (self.__started, self.__exited))
             return False
-            pass
 
-        def start(self):
+        def start(self) -> int:
             if self.__logger is not None:
                 self.__logger.info("HandlerTask start")
             if self.__started is False:
@@ -207,16 +207,16 @@ class LinkKit(object):
                 return 0
             return 1
 
-        def stop(self):
+        def stop(self) -> None:
             if self.__started and self.__exited is False:
                 self.__exited = True
                 self.__message_queue.put(("req_exit", None))
 
-        def wait_stop(self):
+        def wait_stop(self) -> None:
             if self.__started is True:
                 self.__thread.join()
 
-        def __thread_runnable(self):
+        def __thread_runnable(self) -> None:
             if self.__logger is not None:
                 self.__logger.debug("thread runnable enter")
             while True:
@@ -233,10 +233,9 @@ class LinkKit(object):
             self.__started = False
             if self.__logger is not None:
                 self.__logger.debug("thread runnable exit")
-            pass
 
-    class LoopThread(object):
-        def __init__(self, logger=None):
+    class LoopThread:
+        def __init__(self, logger=None) -> None:
             self.__logger = logger
             if logger is not None:
                 self.__logger.info("LoopThread init enter")
@@ -247,7 +246,7 @@ class LinkKit(object):
             if logger is not None:
                 self.__logger.info("LoopThread init exit")
 
-        def start(self, callback):
+        def start(self, callback) -> int:
             if self.__started is True:
                 self.__logger.info("LoopThread already ")
                 return 1
@@ -258,11 +257,11 @@ class LinkKit(object):
                 self.__thread.start()
                 return 0
 
-        def stop(self):
+        def stop(self) -> None:
             self.__req_wait.wait()
             self.__req_wait.clear()
 
-        def __thread_main(self):
+        def __thread_main(self) -> None:
             self.__started = True
             try:
                 if self.__logger is not None:
@@ -276,52 +275,51 @@ class LinkKit(object):
             self.__started = False
             self.__req_wait.set()
 
-    def _on_file_upload_start(self, id, upload_file_info, user_data):
+    def _on_file_upload_start(self, id, upload_file_info, user_data) -> None:
         if self.__on_file_upload_begin != None:
             self.__on_file_upload_begin(id, upload_file_info, self.__user_data)
 
-    def _on_file_upload_end(self, id, upload_file_info, upload_file_result, user_data):
+    def _on_file_upload_end(self, id, upload_file_info, upload_file_result, user_data) -> None:
         if self.__on_file_upload_end != None:
             self.__on_file_upload_end(id, upload_file_info, upload_file_result, self.__user_data)
 
-    def _on_file_upload_progress(self, id, upload_file_result, upload_file_info, user_data):
+    def _on_file_upload_progress(self, id, upload_file_result, upload_file_info, user_data) -> None:
         pass
 
-    class __LinkKitLog(object):
-        def __init__(self):
+    class __LinkKitLog:
+        def __init__(self) -> None:
             self.__logger = logging.getLogger("linkkit")
             self.__enabled = False
-            pass
 
-        def enable_logger(self):
+        def enable_logger(self) -> None:
             self.__enabled = True
 
-        def disable_logger(self):
+        def disable_logger(self) -> None:
             self.__enabled = False
 
         def is_enabled(self):
             return self.__enabled
 
-        def config_logger(self, level):
+        def config_logger(self, level) -> None:
             self.__logger.setLevel(level)
 
-        def debug(self, fmt, *args):
+        def debug(self, fmt, *args) -> None:
             if self.__enabled:
                 self.__logger.debug(fmt, *args)
 
-        def warring(self, fmt, *args):
+        def warring(self, fmt, *args) -> None:
             if self.__enabled:
                 self.__logger.warning(fmt, *args)
 
-        def info(self, fmt, *args):
+        def info(self, fmt, *args) -> None:
             if self.__enabled:
                 self.__logger.info(fmt, *args)
 
-        def error(self, fmt, *args):
+        def error(self, fmt, *args) -> None:
             if self.__enabled:
                 self.__logger.error(fmt, *args)
 
-        def critical(self, fmt, *args):
+        def critical(self, fmt, *args) -> None:
             if self.__enabled:
                 self.__logger.critical(fmt, *args)
 
@@ -451,14 +449,24 @@ UxeCp6
 -----END CERTIFICATE-----
     """
 
-    def __init__(self, host_name, product_key, device_name, device_secret, auth_type=None,
-                 username=None, client_id=None, password=None, instance_id=None,
-                 product_secret=None, user_data=None):
-
+    def __init__(
+        self,
+        host_name,
+        product_key,
+        device_name,
+        device_secret,
+        auth_type=None,
+        username=None,
+        client_id=None,
+        password=None,
+        instance_id=None,
+        product_secret=None,
+        user_data=None,
+    ) -> None:
         # logging configs
         self.__just_for_pycharm_autocomplete = False
 
-        def __str_is_empty(value):
+        def __str_is_empty(value) -> bool:
             if value is None or value == "":
                 return True
             else:
@@ -576,49 +584,56 @@ UxeCp6
         self.__user_rrpc_request_max_len = 100
 
         # things topic - Alink
-        self.__thing_topic_prop_post = '/sys/%s/%s/thing/event/property/post' % \
-                                       (self.__product_key, self.__device_name)
+        self.__thing_topic_prop_post = "/sys/%s/%s/thing/event/property/post" % (self.__product_key, self.__device_name)
         self.__thing_topic_prop_post_reply = self.__thing_topic_prop_post + "_reply"
-        self.__thing_topic_prop_set = '/sys/%s/%s/thing/service/property/set' % \
-                                      (self.__product_key, self.__device_name)
+        self.__thing_topic_prop_set = "/sys/%s/%s/thing/service/property/set" % (self.__product_key, self.__device_name)
         self.__thing_topic_prop_set_reply = self.__thing_topic_prop_set + "_reply"
-        self.__thing_topic_prop_get = '/sys/%s/%s/thing/service/property/get' % \
-                                      (self.__product_key, self.__device_name)
-        self.__thing_topic_event_post_pattern = '/sys/%s/%s/thing/event/%s/post'
-        self.__gateway_topic_add_subdev_topo = '/sys/%s/%s/thing/topo/add' % \
-                                               (self.__product_key, self.__device_name)
+        self.__thing_topic_prop_get = "/sys/%s/%s/thing/service/property/get" % (self.__product_key, self.__device_name)
+        self.__thing_topic_event_post_pattern = "/sys/%s/%s/thing/event/%s/post"
+        self.__gateway_topic_add_subdev_topo = "/sys/%s/%s/thing/topo/add" % (self.__product_key, self.__device_name)
         self.__gateway_topic_add_subdev_topo_reply = self.__gateway_topic_add_subdev_topo + "_reply"
 
-        self.__gateway_topic_delete_subdev_topo = '/sys/%s/%s/thing/topo/delete' % \
-                                                  (self.__product_key, self.__device_name)
+        self.__gateway_topic_delete_subdev_topo = "/sys/%s/%s/thing/topo/delete" % (
+            self.__product_key,
+            self.__device_name,
+        )
         self.__gateway_topic_delete_subdev_topo_reply = self.__gateway_topic_delete_subdev_topo + "_reply"
 
-        self.__gateway_topic_login_subdev = '/ext/session/%s/%s/combine/batch_login' % \
-                                            (self.__product_key, self.__device_name)
+        self.__gateway_topic_login_subdev = "/ext/session/%s/%s/combine/batch_login" % (
+            self.__product_key,
+            self.__device_name,
+        )
         self.__gateway_topic_login_subdev_reply = self.__gateway_topic_login_subdev + "_reply"
 
-        self.__gateway_topic_logout_subdev = '/ext/session/%s/%s/combine/batch_logout' % \
-                                             (self.__product_key, self.__device_name)
+        self.__gateway_topic_logout_subdev = "/ext/session/%s/%s/combine/batch_logout" % (
+            self.__product_key,
+            self.__device_name,
+        )
         self.__gateway_topic_logout_subdev_reply = self.__gateway_topic_logout_subdev + "_reply"
 
-        self.__gateway_topic_register_subdev = '/sys/%s/%s/thing/sub/register' % \
-                                               (self.__product_key, self.__device_name)
+        self.__gateway_topic_register_subdev = "/sys/%s/%s/thing/sub/register" % (
+            self.__product_key,
+            self.__device_name,
+        )
         self.__gateway_topic_register_subdev_reply = self.__gateway_topic_register_subdev + "_reply"
 
-        self.__gateway_topic_product_register_subdev = '/sys/%s/%s/thing/proxy/provisioning/product_register' % \
-                                                       (self.__product_key, self.__device_name)
+        self.__gateway_topic_product_register_subdev = "/sys/%s/%s/thing/proxy/provisioning/product_register" % (
+            self.__product_key,
+            self.__device_name,
+        )
         self.__gateway_topic_product_register_subdev_reply = self.__gateway_topic_product_register_subdev + "_reply"
 
-        self.__gateway_topic_topo_change = '/sys/%s/%s/thing/topo/change' % \
-                                           (self.__product_key, self.__device_name)
-        self.__dynamic_register_nwl_topic = '/ext/regnwl'
-        self.__dynamic_register_topic = '/ext/register'
+        self.__gateway_topic_topo_change = "/sys/%s/%s/thing/topo/change" % (self.__product_key, self.__device_name)
+        self.__dynamic_register_nwl_topic = "/ext/regnwl"
+        self.__dynamic_register_topic = "/ext/register"
 
-        self.__ota_report_version_topic = '/ota/device/inform/%s/%s' % (self.__product_key, self.__device_name)
-        self.__ota_push_topic = '/ota/device/upgrade/%s/%s' % (self.__product_key, self.__device_name)
-        self.__ota_pull_topic = '/sys/%s/%s/thing/ota/firmware/get' % (self.__product_key, self.__device_name)
-        self.__ota_pull_reply_topic = '/sys/%s/%s/thing/ota/firmware/get_reply' % (
-            self.__product_key, self.__device_name)
+        self.__ota_report_version_topic = "/ota/device/inform/%s/%s" % (self.__product_key, self.__device_name)
+        self.__ota_push_topic = "/ota/device/upgrade/%s/%s" % (self.__product_key, self.__device_name)
+        self.__ota_pull_topic = "/sys/%s/%s/thing/ota/firmware/get" % (self.__product_key, self.__device_name)
+        self.__ota_pull_reply_topic = "/sys/%s/%s/thing/ota/firmware/get_reply" % (
+            self.__product_key,
+            self.__device_name,
+        )
 
         self.__thing_prop_post_mid = {}
         self.__thing_prop_post_mid_lock = threading.Lock()
@@ -639,15 +654,13 @@ UxeCp6
         self.__thing_event_post_mid = {}
         self.__thing_event_post_mid_lock = threading.Lock()
 
-        self.__thing_topic_shadow_get = '/shadow/get/%s/%s' % \
-                                        (self.__product_key, self.__device_name)
-        self.__thing_topic_shadow_update = '/shadow/update/%s/%s' % \
-                                           (self.__product_key, self.__device_name)
+        self.__thing_topic_shadow_get = "/shadow/get/%s/%s" % (self.__product_key, self.__device_name)
+        self.__thing_topic_shadow_update = "/shadow/update/%s/%s" % (self.__product_key, self.__device_name)
         self.__thing_shadow_mid = {}
         self.__thing_shadow_mid_lock = threading.Lock()
 
         # service topic
-        self.__thing_topic_service_pattern = '/sys/%s/%s/thing/service/%s'
+        self.__thing_topic_service_pattern = "/sys/%s/%s/thing/service/%s"
         self.__thing_topic_services = set()
         self.__thing_topic_services_reply = set()
         self.__thing_services = set()
@@ -655,9 +668,9 @@ UxeCp6
         self.__thing_answer_service_mid_lock = threading.Lock()
 
         # thing topic - raw
-        self.__thing_topic_raw_up = '/sys/%s/%s/thing/model/up_raw' % (self.__product_key, self.__device_name)
+        self.__thing_topic_raw_up = "/sys/%s/%s/thing/model/up_raw" % (self.__product_key, self.__device_name)
         self.__thing_topic_raw_up_reply = self.__thing_topic_raw_up + "_reply"
-        self.__thing_topic_raw_down = '/sys/%s/%s/thing/model/down_raw' % (self.__product_key, self.__device_name)
+        self.__thing_topic_raw_down = "/sys/%s/%s/thing/model/down_raw" % (self.__product_key, self.__device_name)
         self.__thing_topic_raw_down_reply = self.__thing_topic_raw_down + "_reply"
         self.__thing_raw_up_mid = {}
         self.__thing_raw_up_mid_lock = threading.Lock()
@@ -665,11 +678,15 @@ UxeCp6
         self.__thing_raw_down_reply_mid_lock = threading.Lock()
 
         # thing topic - device_info
-        self.__thing_topic_update_device_info_up = '/sys/%s/%s/thing/deviceinfo/update' % (
-        self.__product_key, self.__device_name)
+        self.__thing_topic_update_device_info_up = "/sys/%s/%s/thing/deviceinfo/update" % (
+            self.__product_key,
+            self.__device_name,
+        )
         self.__thing_topic_update_device_info_reply = self.__thing_topic_update_device_info_up + "_reply"
-        self.__thing_topic_delete_device_info_up = '/sys/%s/%s/thing/deviceinfo/delete' % (
-        self.__product_key, self.__device_name)
+        self.__thing_topic_delete_device_info_up = "/sys/%s/%s/thing/deviceinfo/delete" % (
+            self.__product_key,
+            self.__device_name,
+        )
         self.__thing_topic_delete_device_info_reply = self.__thing_topic_delete_device_info_up + "_reply"
         self.__thing_update_device_info_up_mid = {}
         self.__thing_update_device_info_up_mid_lock = threading.Lock()
@@ -721,27 +738,32 @@ UxeCp6
         self.__handler_task_cmd_on_publish = "on_publish"
         self.__handler_task_cmd_on_subscribe = "on_subscribe"
         self.__handler_task_cmd_on_unsubscribe = "on_unsubscribe"
-        self.__handler_task.register_cmd_callback(self.__handler_task_cmd_on_connect,
-                                                  self.__handler_task_on_connect_callback)
-        self.__handler_task.register_cmd_callback(self.__handler_task_cmd_on_disconnect,
-                                                  self.__handler_task_on_disconnect_callback)
-        self.__handler_task.register_cmd_callback(self.__handler_task_cmd_on_message,
-                                                  self.__handler_task_on_message_callback)
-        self.__handler_task.register_cmd_callback(self.__handler_task_cmd_on_publish,
-                                                  self.__handler_task_on_publish_callback)
-        self.__handler_task.register_cmd_callback(self.__handler_task_cmd_on_subscribe,
-                                                  self.__handler_task_on_subscribe_callback)
-        self.__handler_task.register_cmd_callback(self.__handler_task_cmd_on_unsubscribe,
-                                                  self.__handler_task_on_unsubscribe_callback)
+        self.__handler_task.register_cmd_callback(
+            self.__handler_task_cmd_on_connect, self.__handler_task_on_connect_callback
+        )
+        self.__handler_task.register_cmd_callback(
+            self.__handler_task_cmd_on_disconnect, self.__handler_task_on_disconnect_callback
+        )
+        self.__handler_task.register_cmd_callback(
+            self.__handler_task_cmd_on_message, self.__handler_task_on_message_callback
+        )
+        self.__handler_task.register_cmd_callback(
+            self.__handler_task_cmd_on_publish, self.__handler_task_on_publish_callback
+        )
+        self.__handler_task.register_cmd_callback(
+            self.__handler_task_cmd_on_subscribe, self.__handler_task_on_subscribe_callback
+        )
+        self.__handler_task.register_cmd_callback(
+            self.__handler_task_cmd_on_unsubscribe, self.__handler_task_on_unsubscribe_callback
+        )
         self.__handler_task.start()
-        pass
 
     @property
     def on_device_dynamic_register(self):
         return None
 
     @on_device_dynamic_register.setter
-    def on_device_dynamic_register(self, value):
+    def on_device_dynamic_register(self, value) -> None:
         self.__on_device_dynamic_register = value
 
     @property
@@ -749,16 +771,15 @@ UxeCp6
         return self.__on_connect
 
     @on_connect.setter
-    def on_connect(self, value):
+    def on_connect(self, value) -> None:
         self.__on_connect = value
-        pass
 
     @property
     def on_disconnect(self):
         return self.__on_disconnect
 
     @on_disconnect.setter
-    def on_disconnect(self, value):
+    def on_disconnect(self, value) -> None:
         self.__on_disconnect = value
 
     @property
@@ -766,7 +787,7 @@ UxeCp6
         return None
 
     @on_publish_topic.setter
-    def on_publish_topic(self, value):
+    def on_publish_topic(self, value) -> None:
         self.__on_publish_topic = value
 
     @property
@@ -774,7 +795,7 @@ UxeCp6
         return None
 
     @on_subscribe_topic.setter
-    def on_subscribe_topic(self, value):
+    def on_subscribe_topic(self, value) -> None:
         self.__on_subscribe_topic = value
 
     @property
@@ -782,7 +803,7 @@ UxeCp6
         return None
 
     @on_unsubscribe_topic.setter
-    def on_unsubscribe_topic(self, value):
+    def on_unsubscribe_topic(self, value) -> None:
         self.__on_unsubscribe_topic = value
 
     @property
@@ -790,7 +811,7 @@ UxeCp6
         return None
 
     @on_topic_message.setter
-    def on_topic_message(self, value):
+    def on_topic_message(self, value) -> None:
         self.__on_topic_message = value
 
     @property
@@ -798,7 +819,7 @@ UxeCp6
         return None
 
     @on_topic_rrpc_message.setter
-    def on_topic_rrpc_message(self, value):
+    def on_topic_rrpc_message(self, value) -> None:
         self.__on_topic_rrpc_message = value
 
     @property
@@ -806,7 +827,7 @@ UxeCp6
         return None
 
     @on_thing_create.setter
-    def on_thing_create(self, value):
+    def on_thing_create(self, value) -> None:
         self.__on_thing_create = value
 
     @property
@@ -814,7 +835,7 @@ UxeCp6
         return None
 
     @on_thing_enable.setter
-    def on_thing_enable(self, value):
+    def on_thing_enable(self, value) -> None:
         self.__on_thing_enable = value
 
     @property
@@ -822,7 +843,7 @@ UxeCp6
         return None
 
     @on_thing_disable.setter
-    def on_thing_disable(self, value):
+    def on_thing_disable(self, value) -> None:
         self.__on_thing_disable = value
 
     @property
@@ -830,7 +851,7 @@ UxeCp6
         return None
 
     @on_thing_raw_data_arrived.setter
-    def on_thing_raw_data_arrived(self, value):
+    def on_thing_raw_data_arrived(self, value) -> None:
         self.__on_thing_raw_data_arrived = value
 
     @property
@@ -842,7 +863,7 @@ UxeCp6
         return self.__on_thing_device_info_update
 
     @on_thing_device_info_update.setter
-    def on_thing_device_info_update(self, value):
+    def on_thing_device_info_update(self, value) -> None:
         self.__on_thing_device_info_update = value
 
     @property
@@ -850,11 +871,11 @@ UxeCp6
         return self.__on_thing_device_info_delete
 
     @on_thing_device_info_delete.setter
-    def on_thing_device_info_delete(self, value):
+    def on_thing_device_info_delete(self, value) -> None:
         self.__on_thing_device_info_delete = value
 
     @on_thing_raw_data_post.setter
-    def on_thing_raw_data_post(self, value):
+    def on_thing_raw_data_post(self, value) -> None:
         self.__on_thing_raw_data_post = value
 
     @property
@@ -862,7 +883,7 @@ UxeCp6
         return None
 
     @on_thing_call_service.setter
-    def on_thing_call_service(self, value):
+    def on_thing_call_service(self, value) -> None:
         self.__on_thing_call_service = value
 
     @property
@@ -870,7 +891,7 @@ UxeCp6
         return None
 
     @on_thing_prop_changed.setter
-    def on_thing_prop_changed(self, value):
+    def on_thing_prop_changed(self, value) -> None:
         self.__on_thing_prop_changed = value
 
     @property
@@ -878,7 +899,7 @@ UxeCp6
         return self.__on_thing_event_post
 
     @on_thing_event_post.setter
-    def on_thing_event_post(self, value):
+    def on_thing_event_post(self, value) -> None:
         self.__on_thing_event_post = value
 
     @property
@@ -886,7 +907,7 @@ UxeCp6
         return self.__on_thing_prop_post
 
     @on_thing_prop_post.setter
-    def on_thing_prop_post(self, value):
+    def on_thing_prop_post(self, value) -> None:
         self.__on_thing_prop_post = value
 
     @property
@@ -894,7 +915,7 @@ UxeCp6
         return self.__on_thing_shadow_get
 
     @on_thing_shadow_get.setter
-    def on_thing_shadow_get(self, value):
+    def on_thing_shadow_get(self, value) -> None:
         self.__on_thing_shadow_get = value
 
     @property
@@ -902,7 +923,7 @@ UxeCp6
         return self.__on_file_upload_begin
 
     @on_file_upload_begin.setter
-    def on_file_upload_begin(self, value):
+    def on_file_upload_begin(self, value) -> None:
         self.__on_file_upload_begin = value
 
     @property
@@ -910,7 +931,7 @@ UxeCp6
         return self.__on_file_upload_end
 
     @on_file_upload_end.setter
-    def on_file_upload_end(self, value):
+    def on_file_upload_end(self, value) -> None:
         self.__on_file_upload_end = value
 
     @property
@@ -918,7 +939,7 @@ UxeCp6
         return None
 
     @on_gateway_add_subdev_topo_reply.setter
-    def on_gateway_add_subdev_topo_reply(self, value):
+    def on_gateway_add_subdev_topo_reply(self, value) -> None:
         self.__on_gateway_add_subdev_topo_reply = value
 
     @property
@@ -926,7 +947,7 @@ UxeCp6
         return None
 
     @on_gateway_delete_subdev_topo_reply.setter
-    def on_gateway_delete_subdev_topo_reply(self, value):
+    def on_gateway_delete_subdev_topo_reply(self, value) -> None:
         self.__on_gateway_delete_subdev_topo_reply = value
 
     @property
@@ -934,7 +955,7 @@ UxeCp6
         return None
 
     @on_gateway_login_subdev_reply.setter
-    def on_gateway_login_subdev_reply(self, value):
+    def on_gateway_login_subdev_reply(self, value) -> None:
         self.__on_gateway_login_subdev_reply = value
 
     @property
@@ -942,7 +963,7 @@ UxeCp6
         return None
 
     @on_gateway_logout_subdev_reply.setter
-    def on_gateway_logout_subdev_reply(self, value):
+    def on_gateway_logout_subdev_reply(self, value) -> None:
         self.__on_gateway_logout_subdev_reply = value
 
     @property
@@ -950,7 +971,7 @@ UxeCp6
         return None
 
     @on_gateway_register_subdev_reply.setter
-    def on_gateway_register_subdev_reply(self, value):
+    def on_gateway_register_subdev_reply(self, value) -> None:
         self.__on_gateway_register_subdev_reply = value
 
     @property
@@ -958,7 +979,7 @@ UxeCp6
         return None
 
     @on_gateway_product_register_subdev_reply.setter
-    def on_gateway_product_register_subdev_reply(self, value):
+    def on_gateway_product_register_subdev_reply(self, value) -> None:
         self.__on_gateway_product_register_subdev_reply = value
 
     @property
@@ -966,7 +987,7 @@ UxeCp6
         return None
 
     @on_device_dynamic_register_nwl_reply.setter
-    def on_device_dynamic_register_nwl_reply(self, value):
+    def on_device_dynamic_register_nwl_reply(self, value) -> None:
         self.__on_device_dynamic_register_nwl_reply = value
 
     @property
@@ -974,7 +995,7 @@ UxeCp6
         return None
 
     @on_ota_message_arrived.setter
-    def on_ota_message_arrived(self, value):
+    def on_ota_message_arrived(self, value) -> None:
         self.__on_ota_message_arrived = value
 
     @property
@@ -982,22 +1003,22 @@ UxeCp6
         return None
 
     @on_gateway_topo_change.setter
-    def on_gateway_topo_change(self, value):
+    def on_gateway_topo_change(self, value) -> None:
         self.__on_gateway_topo_change = value
 
-    def enable_logger(self, level):
+    def enable_logger(self, level) -> None:
         self.__link_log.config_logger(level)
         self.__link_log.enable_logger()
         if self.__mqtt_client is not None:
             self.__mqtt_client.enable_logger(self.__PahoLog)
         self.__PahoLog.setLevel(level)
 
-    def disable_logger(self):
+    def disable_logger(self) -> None:
         self.__link_log.disable_logger()
         if self.__mqtt_client is not None:
             self.__mqtt_client.disable_logger()
 
-    def config_logger(self, level):
+    def config_logger(self, level) -> None:
         self.__link_log.config_logger(level)
         if self.__mqtt_client is not None:
             self.__PahoLog.setLevel(level)
@@ -1005,14 +1026,22 @@ UxeCp6
     def config_http2(self, endpoint=None):
         raise LinkKit.StateError("not supported any more")
 
-    def config_mqtt(self, port=8883, protocol="MQTTv311", transport="TCP",
-                    secure="TLS", keep_alive=60, clean_session=True,
-                    max_inflight_message=20, max_queued_message=40,
-                    auto_reconnect_min_sec=1,
-                    auto_reconnect_max_sec=60,
-                    cadata=None,
-                    endpoint=None,
-                    check_hostname=True):
+    def config_mqtt(
+        self,
+        port=8883,
+        protocol="MQTTv311",
+        transport="TCP",
+        secure="TLS",
+        keep_alive=60,
+        clean_session=True,
+        max_inflight_message=20,
+        max_queued_message=40,
+        auto_reconnect_min_sec=1,
+        auto_reconnect_max_sec=60,
+        cadata=None,
+        endpoint=None,
+        check_hostname=True,
+    ):
         if self.__linkkit_state is not LinkKit.LinkKitState.INITIALIZED:
             raise LinkKit.StateError("not in INITIALIZED state")
         if port < 1 or port > 65535:
@@ -1066,10 +1095,10 @@ UxeCp6
                 self.__endpoint = endpoint
             if check_hostname is not None:
                 self.__check_hostname = check_hostname
-                if False == check_hostname:
+                if check_hostname == False:
                     self.__link_log.info("skip hostname check")
 
-    def config_device_info(self, interface_info):
+    def config_device_info(self, interface_info) -> int:
         if self.__linkkit_state is not LinkKit.LinkKitState.INITIALIZED:
             raise LinkKit.StateError("LinkKit object not in INITIALIZED")
         if not isinstance(interface_info, str):
@@ -1086,7 +1115,7 @@ UxeCp6
         return self.__device_name
 
     def get_endpoint(self):
-        return self.__endpoint;
+        return self.__endpoint
 
     def get_h2_endpoint(self):
         raise LinkKit.StateError("not supported any more")
@@ -1102,40 +1131,27 @@ UxeCp6
 
     def __to_str(self, payload):
         if type(payload) is bytes:
-            return str(payload, 'utf-8')
+            return str(payload, "utf-8")
         else:
             return payload
 
-    def upload_file_sync(self, local_filename, remote_filename=None, over_write=True,
-                         timeout=None):
+    def upload_file_sync(self, local_filename, remote_filename=None, over_write=True, timeout=None):
         raise LinkKit.StateError("not supported any more")
 
     def upload_file_async(self, local_filename, remote_filename=None, over_write=True):
         raise LinkKit.StateError("not supported any more")
 
-    def __upload_device_interface_info(self):
+    def __upload_device_interface_info(self) -> int:
         request_id = self.__get_thing_request_id()
         payload = {
             "id": request_id,
             "version": "1.0",
             "params": [
-                {
-                    "domain": "SYSTEM",
-                    "attrKey": "SYS_SDK_LANGUAGE",
-                    "attrValue": self.__sdk_program_language
-                },
-                {
-                    "domain": "SYSTEM",
-                    "attrKey": "SYS_LP_SDK_VERSION",
-                    "attrValue": self.__sdk_version
-                },
-                {
-                    "domain": "SYSTEM",
-                    "attrKey": "SYS_SDK_IF_INFO",
-                    "attrValue": self.__device_interface_info
-                },
+                {"domain": "SYSTEM", "attrKey": "SYS_SDK_LANGUAGE", "attrValue": self.__sdk_program_language},
+                {"domain": "SYSTEM", "attrKey": "SYS_LP_SDK_VERSION", "attrValue": self.__sdk_version},
+                {"domain": "SYSTEM", "attrKey": "SYS_SDK_IF_INFO", "attrValue": self.__device_interface_info},
             ],
-            "method": "thing.deviceinfo.update"
+            "method": "thing.deviceinfo.update",
         }
         with self.__device_info_mid_lock:
             rc, mid = self.__mqtt_client.publish(self.__device_info_topic, json.dumps(payload), 0)
@@ -1145,13 +1161,15 @@ UxeCp6
             else:
                 return 1
 
-    def destruct(self):
+    def destruct(self) -> None:
         if self.__linkkit_state is LinkKit.LinkKitState.DESTRUCTED:
             self.__link_log.info("LinkKit object has already destructed")
             return
         self.__link_log.debug("destruct enter")
-        if self.__linkkit_state == LinkKit.LinkKitState.CONNECTED or \
-                self.__linkkit_state == LinkKit.LinkKitState.CONNECTING:
+        if (
+            self.__linkkit_state == LinkKit.LinkKitState.CONNECTED
+            or self.__linkkit_state == LinkKit.LinkKitState.CONNECTING
+        ):
             self.__linkkit_state = LinkKit.LinkKitState.DESTRUCTING
             if self.__connect_async_req:
                 with self.__worker_loop_exit_req_lock:
@@ -1167,9 +1185,8 @@ UxeCp6
             self.__handler_task.stop()
             self.__handler_task.wait_stop()
             self.__linkkit_state = LinkKit.LinkKitState.DESTRUCTED
-        pass
 
-    def destroy(self):
+    def destroy(self) -> None:
         self.destruct()
 
     def check_state(self):
@@ -1177,9 +1194,7 @@ UxeCp6
 
     @staticmethod
     def __generate_random_str(randomlength=16):
-        """
-        generate radom string
-        """
+        """Generate radom string"""
         random_str = ""
         for i in range(randomlength):
             random_str += random.choice(string.digits + string.ascii_letters)
@@ -1194,24 +1209,17 @@ UxeCp6
         context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH, cadata=self.__aliyun_broker_ca_data)
         sign_content = "deviceName%sproductKey%srandom%s" % (dn, pk, random_str)
         sign = hmac.new(ps.encode("utf-8"), sign_content.encode("utf-8"), hashlib.sha256).hexdigest()
-        post_data = {
-            "productKey": pk,
-            "deviceName": dn,
-            "random": random_str,
-            "sign": sign,
-            "signMethod": "hmacsha256"
-        }
+        post_data = {"productKey": pk, "deviceName": dn, "random": random_str, "sign": sign, "signMethod": "hmacsha256"}
         data = urllib.parse.urlencode(post_data)
-        data = data.encode('ascii')
+        data = data.encode("ascii")
         request_url = "https://iot-auth.%s.aliyuncs.com/auth/register/device" % self.__host_name
         with urllib.request.urlopen(request_url, data, context=context) as f:
-            reply_data = f.read().decode('utf-8')
+            reply_data = f.read().decode("utf-8")
             reply_obj = self.__load_json(reply_data)
             if reply_obj["code"] == 200:
                 reply_obj_data = reply_obj["data"]
                 if reply_obj_data is not None:
                     return 0, reply_obj_data["deviceSecret"]
-                    pass
             else:
                 return 1, reply_obj["message"]
 
@@ -1224,27 +1232,38 @@ UxeCp6
         else:
             securemode = 3
         if self.__device_interface_info:
-            sii_option = 'sii=%s,' % (self.__device_interface_info)
+            sii_option = "sii=%s," % (self.__device_interface_info)
         else:
-            sii_option = ''
+            sii_option = ""
 
         # 普通的一机一密认证方式
         if self.__is_valid_str(self.__device_secret):
-            client_id = "%s&%s|securemode=%d,signmethod=hmacsha1,ext=1,_ss=1,lan=%s,_v=%s,%stimestamp=%s|" \
-                        % (self.__product_key, self.__device_name, securemode, self.__sdk_program_language,
-                           self.__sdk_version, sii_option, timestamp)
+            client_id = "%s&%s|securemode=%d,signmethod=hmacsha1,ext=1,_ss=1,lan=%s,_v=%s,%stimestamp=%s|" % (
+                self.__product_key,
+                self.__device_name,
+                securemode,
+                self.__sdk_program_language,
+                self.__sdk_version,
+                sii_option,
+                timestamp,
+            )
             username = self.__device_name + "&" + self.__product_key
             # calc sign
             sign_content = "clientId%sdeviceName%sproductKey%stimestamp%s" % (
                 self.__product_key + "&" + self.__device_name,
                 self.__device_name,
                 self.__product_key,
-                timestamp)
-            password = hmac.new(self.__device_secret.encode("utf-8"), sign_content.encode("utf-8"),
-                                hashlib.sha1).hexdigest()
+                timestamp,
+            )
+            password = hmac.new(
+                self.__device_secret.encode("utf-8"), sign_content.encode("utf-8"), hashlib.sha1
+            ).hexdigest()
         # 通过username, passwd, cilentid直连接入的方式
-        elif self.__is_valid_str(self.__client_id) and self.__is_valid_str(self.__username) and self.__is_valid_str(
-                self.__password):
+        elif (
+            self.__is_valid_str(self.__client_id)
+            and self.__is_valid_str(self.__username)
+            and self.__is_valid_str(self.__password)
+        ):
             # 如果已经通过基于mqtt的免预注册一型一密协议获取到了client_id, user_name, password
             client_id = self.__client_id
             username = self.__username
@@ -1264,14 +1283,24 @@ UxeCp6
             random_str = self.__generate_random_str(15)
             if self.__is_valid_str(self.__instance_id):
                 client_id = "%s.%s|random=%s,authType=%s,securemode=2,signmethod=hmacsha256,instanceId=%s|" % (
-                    self.__device_name, self.__product_key, random_str, auth_type_str, self.__instance_id)
+                    self.__device_name,
+                    self.__product_key,
+                    random_str,
+                    auth_type_str,
+                    self.__instance_id,
+                )
             else:
                 client_id = "%s.%s|random=%s,authType=%s,securemode=2,signmethod=hmacsha256|" % (
-                    self.__device_name, self.__product_key, random_str, auth_type_str)
+                    self.__device_name,
+                    self.__product_key,
+                    random_str,
+                    auth_type_str,
+                )
             username = "%s&%s" % (self.__device_name, self.__product_key)
             password_src = "deviceName%sproductKey%srandom%s" % (self.__device_name, self.__product_key, random_str)
-            password = hmac.new(self.__product_secret.encode("utf-8"), password_src.encode("utf-8"),
-                                hashlib.sha256).hexdigest()
+            password = hmac.new(
+                self.__product_secret.encode("utf-8"), password_src.encode("utf-8"), hashlib.sha256
+            ).hexdigest()
         else:
             raise LinkKit.StateError("unknow auth error")
 
@@ -1281,9 +1310,9 @@ UxeCp6
             mqtt_protocol_version = mqtt.MQTTv311
         elif self.__mqtt_protocol == "MQTTv31":
             mqtt_protocol_version = mqtt.MQTTv31
-        self.__mqtt_client = mqtt.Client(client_id=client_id,
-                                         clean_session=self.__mqtt_clean_session,
-                                         protocol=mqtt_protocol_version)
+        self.__mqtt_client = mqtt.Client(
+            client_id=client_id, clean_session=self.__mqtt_clean_session, protocol=mqtt_protocol_version
+        )
 
         if self.__link_log.is_enabled():
             self.__mqtt_client.enable_logger(self.__PahoLog)
@@ -1316,8 +1345,7 @@ UxeCp6
         elif self.__is_valid_str(self.__instance_id):
             return self.__instance_id + ".mqtt.iothub.aliyuncs.com"
         else:
-            return "%s.iot-as-mqtt.%s.aliyuncs.com" % \
-                   (self.__product_key, self.__host_name)
+            return "%s.iot-as-mqtt.%s.aliyuncs.com" % (self.__product_key, self.__host_name)
 
     def connect(self):
         raise LinkKit.StateError("not supported")
@@ -1331,7 +1359,7 @@ UxeCp6
             self.__worker_loop_exit_req = False
         return self.__loop_thread.start(self.__loop_forever_internal)
 
-    def disconnect(self):
+    def disconnect(self) -> None:
         self.__link_log.debug("disconnect")
         if self.__linkkit_state is not LinkKit.LinkKitState.CONNECTED:
             self.__link_log.info("already disconnected, return")
@@ -1443,8 +1471,8 @@ UxeCp6
             else:
                 return 1, None
 
-    def __make_rrpc_topic(self, topic):
-        return '/ext/rrpc/+%s' % (topic)
+    def __make_rrpc_topic(self, topic) -> str:
+        return "/ext/rrpc/+%s" % (topic)
 
     def subscribe_rrpc_topic(self, topic):
         if self.__linkkit_state is not LinkKit.LinkKitState.CONNECTED:
@@ -1536,13 +1564,14 @@ UxeCp6
             else:
                 return 1, None
 
-    def __on_internal_connect_safe(self, client, user_data, session_flag, rc):
+    def __on_internal_connect_safe(self, client, user_data, session_flag, rc) -> None:
         if rc == 0:
             self.__reset_reconnect_wait()
             self.__force_reconnect = False
-        session_flag_internal = {'session present': session_flag}
-        self.__handler_task.post_message(self.__handler_task_cmd_on_connect,
-                                         (client, user_data, session_flag_internal, rc))
+        session_flag_internal = {"session present": session_flag}
+        self.__handler_task.post_message(
+            self.__handler_task_cmd_on_connect, (client, user_data, session_flag_internal, rc)
+        )
 
     def __loop_forever_internal(self):
         self.__link_log.debug("enter")
@@ -1550,8 +1579,11 @@ UxeCp6
 
         # 为了保持存量设备兼容，保留了基于https的需要预注册的一型一密的预注册
         if not self.__is_valid_str(self.__device_secret) and self.__is_valid_str(self.__product_secret):
-            lack_other_auth_info = not self.__is_valid_str(self.__username) or not self.__is_valid_str(
-                self.__client_id) or not self.__is_valid_str(self.__password)
+            lack_other_auth_info = (
+                not self.__is_valid_str(self.__username)
+                or not self.__is_valid_str(self.__client_id)
+                or not self.__is_valid_str(self.__password)
+            )
             if not self.__is_valid_str(self.__auth_type) and lack_other_auth_info:
                 rc, value = self.__dynamic_register_device()
                 try:
@@ -1575,8 +1607,9 @@ UxeCp6
             return
 
         try:
-            self.__mqtt_client.connect_async(host=self.__host_name_internal, port=self.__mqtt_port,
-                                             keepalive=self.__mqtt_keep_alive)
+            self.__mqtt_client.connect_async(
+                host=self.__host_name_internal, port=self.__mqtt_port, keepalive=self.__mqtt_keep_alive
+            )
         except Exception as e:
             self.__link_log.error("__loop_forever_internal connect raise exception:" + str(e))
             self.__linkkit_state = LinkKit.LinkKitState.INITIALIZED
@@ -1591,7 +1624,7 @@ UxeCp6
             try:
                 self.__linkkit_state = LinkKit.LinkKitState.CONNECTING
                 self.__mqtt_client.reconnect()
-            except (socket.error, OSError) as e:
+            except OSError as e:
                 self.__link_log.error(e)
                 # if isinstance(e, socket.timeout):
                 #     self.__link_log.error("connect timeout")
@@ -1635,22 +1668,23 @@ UxeCp6
                 break
             self.__reconnect_wait()
             # 在mqtt + 一型一密免预注册的情况下，由于三元组不对，导致无法与服务器建连,因此需要退出，否则会一直重试
-            if 1 == self.__dynamic_register_nwl_flag:
+            if self.__dynamic_register_nwl_flag == 1:
                 if self.__on_device_dynamic_register_nwl_reply is not None:
-                    self.__on_device_dynamic_register_nwl_reply(LinkKit.ErrorCode.DYNREG_AUTH_NWL_FAILED.value, None,
-                                                                None, None)
+                    self.__on_device_dynamic_register_nwl_reply(
+                        LinkKit.ErrorCode.DYNREG_AUTH_NWL_FAILED.value, None, None, None
+                    )
                 self.__linkkit_state = LinkKit.LinkKitState.DISCONNECTED
                 self.__dynamic_register_nwl_flag = 0
                 break
             # 在mqtt + 一型一密预注册的情况下，由于三元组不对，导致无法与服务器建连,因此需要退出，否则会一直重试
-            if 1 == self.__dynamic_register_flag:
+            if self.__dynamic_register_flag == 1:
                 if self.__on_device_dynamic_register is not None:
                     self.__on_device_dynamic_register(LinkKit.ErrorCode.DYNREG_AUTH_FAILED.value, None, None)
                 self.__linkkit_state = LinkKit.LinkKitState.DISCONNECTED
                 self.__dynamic_register_flag = 0
                 break
 
-    def __clean_timeout_message(self):
+    def __clean_timeout_message(self) -> None:
         # self.__link_log.debug("__clean_timeout_message enter")
         expire_timestamp = self.__timestamp() - self.__mqtt_request_timeout * 1000
         with self.__thing_prop_post_mid_lock:
@@ -1668,28 +1702,27 @@ UxeCp6
         self.__clean_timeout_message_item(self.__device_info_mid, expire_timestamp)
         # self.__link_log.debug("__clean_timeout_message exit")
 
-    def __clean_timeout_message_item(self, mids, expire_time):
+    def __clean_timeout_message_item(self, mids, expire_time) -> None:
         for mid in list(mids.keys()):
             if mids[mid] < expire_time:
                 timestamp = mids.pop(mid)
                 self.__link_log.error("__clean_timeout_message_item pop:%r,timestamp:%r", mid, timestamp)
 
-    def __reconnect_wait(self):
+    def __reconnect_wait(self) -> None:
         if self.__mqtt_auto_reconnect_sec == 0:
             self.__mqtt_auto_reconnect_sec = self.__mqtt_auto_reconnect_min_sec
         else:
             self.__mqtt_auto_reconnect_sec = min(self.__mqtt_auto_reconnect_sec * 2, self.__mqtt_auto_reconnect_max_sec)
             self.__mqtt_auto_reconnect_sec += random.randint(1, self.__mqtt_auto_reconnect_sec)
         time.sleep(self.__mqtt_auto_reconnect_sec)
-        pass
 
-    def __reset_reconnect_wait(self):
+    def __reset_reconnect_wait(self) -> None:
         self.__mqtt_auto_reconnect_sec = 0
 
-    def start_worker_loop(self):
+    def start_worker_loop(self) -> None:
         pass
 
-    def thing_setup(self, file=None):
+    def thing_setup(self, file=None) -> int:
         if self.__linkkit_state is not LinkKit.LinkKitState.INITIALIZED:
             raise LinkKit.StateError("not in INITIALIZED state")
         if self.__thing_setup_state:
@@ -1699,7 +1732,7 @@ UxeCp6
             self.__thing_setup_state = True
             return 0
         try:
-            with open(file, encoding='utf-8') as f:
+            with open(file, encoding="utf-8") as f:
                 tsl = json.load(f)
                 index = 0
                 while "events" in tsl and index < len(tsl["events"]):
@@ -1733,21 +1766,23 @@ UxeCp6
                             output_data_index += 1
                     else:
                         self.__thing_services.add(identifier)
-                        service_reply_topic = self.__thing_topic_service_pattern % (self.__product_key,
-                                                                                    self.__device_name,
-                                                                                    identifier + "_reply")
+                        service_reply_topic = self.__thing_topic_service_pattern % (
+                            self.__product_key,
+                            self.__device_name,
+                            identifier + "_reply",
+                        )
                         self.__thing_topic_services_reply.add(service_reply_topic)
                     index += 1
 
                 for event in self.__thing_events:
-                    post_topic = self.__thing_topic_event_post_pattern % \
-                                 (self.__product_key, self.__device_name, event)
+                    post_topic = self.__thing_topic_event_post_pattern % (self.__product_key, self.__device_name, event)
                     self.__thing_topic_event_post[event] = post_topic
                     self.__thing_topic_event_post_reply.add(post_topic + "_reply")
                 # service topic
                 for service in self.__thing_services:
-                    self.__thing_topic_services.add(self.__thing_topic_service_pattern %
-                                                    (self.__product_key, self.__device_name, service))
+                    self.__thing_topic_services.add(
+                        self.__thing_topic_service_pattern % (self.__product_key, self.__device_name, service)
+                    )
 
         except Exception as e:
             self.__link_log.info("file open error:" + str(e))
@@ -1786,10 +1821,11 @@ UxeCp6
             return 1, None
         request_id = self.__get_thing_request_id()
         with self.__thing_update_device_info_up_mid_lock:
-            rc, mid = self.__mqtt_client.publish(self.__thing_topic_update_device_info_up,
-                                                 self.__pack_alink_request(request_id, "thing.deviceinfo.update",
-                                                                           payload),
-                                                 0)
+            rc, mid = self.__mqtt_client.publish(
+                self.__thing_topic_update_device_info_up,
+                self.__pack_alink_request(request_id, "thing.deviceinfo.update", payload),
+                0,
+            )
             if rc == mqtt.MQTT_ERR_SUCCESS:
                 self.__thing_update_device_info_up_mid[mid] = self.__timestamp()
                 return rc, request_id
@@ -1803,10 +1839,11 @@ UxeCp6
             return 1
         request_id = self.__get_thing_request_id()
         with self.__thing_delete_device_info_up_mid_lock:
-            rc, mid = self.__mqtt_client.publish(self.__thing_topic_delete_device_info_up,
-                                                 self.__pack_alink_request(request_id, "thing.deviceinfo.delete",
-                                                                           payload),
-                                                 0)
+            rc, mid = self.__mqtt_client.publish(
+                self.__thing_topic_delete_device_info_up,
+                self.__pack_alink_request(request_id, "thing.deviceinfo.delete", payload),
+                0,
+            )
             if rc == mqtt.MQTT_ERR_SUCCESS:
                 self.__thing_delete_device_info_up_mid[mid] = self.__timestamp()
                 return rc, request_id
@@ -1818,7 +1855,7 @@ UxeCp6
             return 1, None
 
         payload = []
-        for (k, v) in tagMap.items():
+        for k, v in tagMap.items():
             payload.append({LinkKit.TAG_KEY: k, LinkKit.TAG_VALUE: v})
         return self.thing_update_device_info(payload)
 
@@ -1833,12 +1870,7 @@ UxeCp6
         return self.thing_delete_device_info(payload)
 
     def __pack_alink_request(self, request_id, method, params):
-        request = {
-            "id": request_id,
-            "version": "1.0",
-            "params": params,
-            "method": method
-        }
+        request = {"id": request_id, "version": "1.0", "params": params, "method": method}
         return json.dumps(request)
 
     def thing_answer_service(self, identifier, request_id, code, data=None):
@@ -1849,19 +1881,17 @@ UxeCp6
             return 1
         if data is None:
             data = {}
-        response = {
-            "id": request_id,
-            "code": code,
-            "data": data
-        }
+        response = {"id": request_id, "code": code, "data": data}
 
-        item = self.__pop_rrpc_service('alink_' + str(request_id))
+        item = self.__pop_rrpc_service("alink_" + str(request_id))
         if item:
-            service_reply_topic = item['topic']
+            service_reply_topic = item["topic"]
         else:
-            service_reply_topic = self.__thing_topic_service_pattern % (self.__product_key,
-                                                                        self.__device_name,
-                                                                        identifier + "_reply")
+            service_reply_topic = self.__thing_topic_service_pattern % (
+                self.__product_key,
+                self.__device_name,
+                identifier + "_reply",
+            )
         with self.__thing_answer_service_mid_lock:
             rc, mid = self.__mqtt_client.publish(service_reply_topic, json.dumps(response), 0)
             if rc == mqtt.MQTT_ERR_SUCCESS:
@@ -1882,19 +1912,19 @@ UxeCp6
                 return str(self.__thing_request_value)
             return None
 
-    def __back_thing_request_id(self, post_id):
+    def __back_thing_request_id(self, post_id) -> None:
         with self.__thing_request_id_lock:
             try:
                 self.__thing_request_id.pop(int(post_id))
             except Exception as e:
                 self.__link_log.error("__back_thing_request_id pop:%r,%r" % (post_id, e))
 
-    def __reset_thing_request_id(self):
+    def __reset_thing_request_id(self) -> None:
         with self.__thing_request_id_lock:
             self.__thing_request_value = 0
             self.__thing_request_id.clear()
 
-    def __clean_thing_timeout_request_id(self):
+    def __clean_thing_timeout_request_id(self) -> None:
         with self.__thing_request_id_lock:
             expire_timestamp = self.__timestamp() - self.__mqtt_request_timeout * 1000
             for request_id in list(self.__thing_request_id.keys()):
@@ -1923,7 +1953,7 @@ UxeCp6
             "params": {
                 "value": params,
             },
-            "method": "thing.event.%s.post" % event
+            "method": "thing.event.%s.post" % event,
         }
         with self.__thing_event_post_mid_lock:
             event_topic = self.__thing_topic_event_post[event]
@@ -1946,12 +1976,7 @@ UxeCp6
         request_id = self.__get_thing_request_id()
         if request_id is None:
             return 1, None
-        request = {
-            "id": request_id,
-            "version": "1.0",
-            "params": request_params,
-            "method": "thing.event.property.post"
-        }
+        request = {"id": request_id, "version": "1.0", "params": request_params, "method": "thing.event.property.post"}
         with self.__thing_prop_post_mid_lock:
             rc, mid = self.__mqtt_client.publish(self.__thing_topic_prop_post, json.dumps(request), 1)
             if rc == mqtt.MQTT_ERR_SUCCESS:
@@ -1959,9 +1984,8 @@ UxeCp6
                 return 0, request_id
             else:
                 return 1, None
-        pass
 
-    def __on_internal_async_message(self, message):
+    def __on_internal_async_message(self, message) -> None:
         self.__link_log.debug("__on_internal_async_message topic:%r" % message.topic)
         triggered_flag = 0
 
@@ -1969,11 +1993,7 @@ UxeCp6
             payload = self.__load_json(message.payload)
             params = payload["params"]
             try:
-                reply = {
-                    "id": payload["id"],
-                    "code": 200,
-                    "data": {}
-                }
+                reply = {"id": payload["id"], "code": 200, "data": {}}
                 with self.__thing_prop_set_reply_mid_lock:
                     rc, mid = self.__mqtt_client.publish(self.__thing_topic_prop_set_reply, json.dumps(reply), 1)
                     if rc == 0:
@@ -1982,7 +2002,6 @@ UxeCp6
                         self.__link_log.info("prop changed reply success")
                     else:
                         self.__link_log.info("prop changed reply fail")
-                    pass
                 if self.__on_thing_prop_changed is not None:
                     triggered_flag = 1
                     self.__on_thing_prop_changed(params, self.__user_data)
@@ -2003,7 +2022,6 @@ UxeCp6
                     self.__on_thing_device_info_update(request_id, code, data, reply_message, self.__user_data)
             except Exception as e:
                 self.__link_log.error("__on_thing_device_info_update process raise exception:%s" % e)
-            pass
         elif message.topic == self.__thing_topic_prop_post_reply:
             payload = self.__load_json(message.payload)
             request_id = payload["id"]
@@ -2017,11 +2035,10 @@ UxeCp6
             except Exception as e:
                 self.__link_log.error("on_thing_prop_post raise exception:%s" % e)
             self.__back_thing_request_id(request_id)
-            pass
         elif message.topic == self.__thing_topic_prop_get:
             pass
         elif message.topic in self.__thing_topic_event_post_reply:
-            event = message.topic.split('/', 7)[6]
+            event = message.topic.split("/", 7)[6]
             payload = self.__load_json(message.payload)
             request_id = payload["id"]
             code = payload["code"]
@@ -2035,9 +2052,8 @@ UxeCp6
             except Exception as e:
                 self.__link_log.error("on_thing_event_post raise exception:%s" % e)
             self.__back_thing_request_id(request_id)
-            pass
         elif message.topic in self.__thing_topic_services:
-            identifier = message.topic.split('/', 6)[6]
+            identifier = message.topic.split("/", 6)[6]
             payload = self.__load_json(message.payload)
             try:
                 request_id = payload["id"]
@@ -2061,7 +2077,6 @@ UxeCp6
                     self.__on_thing_raw_data_post(message.payload, self.__user_data)
             except Exception as e:
                 self.__link_log.error("on_thing_raw_post_data process raise exception:%s" % e)
-            pass
         elif message.topic == self.__thing_topic_update_device_info_reply:
             try:
                 if self.__on_thing_device_info_update is not None:
@@ -2070,11 +2085,10 @@ UxeCp6
                     request_id = payload["id"]
                     code = payload["code"]
                     data = payload["data"]
-                    msg = payload['message']
+                    msg = payload["message"]
                     self.__on_thing_device_info_update(request_id, code, data, msg, self.__user_data)
             except Exception as e:
                 self.__link_log.error("__on_thing_device_info_update process raise exception:%s" % e)
-            pass
         elif message.topic == self.__thing_topic_delete_device_info_reply:
             try:
                 if self.__on_thing_device_info_delete is not None:
@@ -2083,11 +2097,10 @@ UxeCp6
                     request_id = payload["id"]
                     code = payload["code"]
                     data = payload["data"]
-                    msg = payload['message']
+                    msg = payload["message"]
                     self.__on_thing_device_info_delete(request_id, code, data, msg, self.__user_data)
             except Exception as e:
                 self.__link_log.error("__on_thing_device_info_update process raise exception:%s" % e)
-            pass
         elif message.topic == self.__thing_topic_shadow_get:
             self.__try_parse_try_shadow(message.payload)
             try:
@@ -2096,10 +2109,8 @@ UxeCp6
                     self.__on_thing_shadow_get(self.__load_json(message.payload), self.__user_data)
             except Exception as e:
                 self.__link_log.error("__on_thing_shadow_get process raise exception:%s" % e)
-            pass
         elif message.topic.startswith("/ext/rrpc/"):
             triggered_flag = self.__try_parse_rrpc_topic(message)
-            pass
         elif message.topic == self.__gateway_topic_topo_change:
             try:
                 payload = self.__load_json(message.payload)
@@ -2110,7 +2121,6 @@ UxeCp6
                     self.__on_gateway_topo_change(request_id, params, self.__user_data)
             except Exception as e:
                 self.__link_log.error("__on_gateway_topo_change process raise exception:%s" % e)
-            pass
         elif message.topic == self.__gateway_topic_add_subdev_topo_reply:
             try:
                 payload = self.__load_json(message.payload)
@@ -2124,7 +2134,6 @@ UxeCp6
                     self.__on_gateway_add_subdev_topo_reply(request_id, code, data, msg, self.__user_data)
             except Exception as e:
                 self.__link_log.error("__on_gateway_add_subdev_topo_reply process raise exception:%s" % e)
-            pass
         elif message.topic == self.__gateway_topic_delete_subdev_topo_reply:
             try:
                 payload = self.__load_json(message.payload)
@@ -2138,7 +2147,6 @@ UxeCp6
                     self.__on_gateway_delete_subdev_topo_reply(request_id, code, data, msg, self.__user_data)
             except Exception as e:
                 self.__link_log.error("__on_gateway_delete_subdev_topo_reply process raise exception:%s" % e)
-            pass
         elif message.topic == self.__gateway_topic_login_subdev_reply:
             try:
                 payload = self.__load_json(message.payload)
@@ -2152,7 +2160,6 @@ UxeCp6
                     self.__on_gateway_login_subdev_reply(request_id, code, data, msg, self.__user_data)
             except Exception as e:
                 self.__link_log.error("__on_gateway_login_subdev_reply process raise exception:%s" % e)
-            pass
         elif message.topic == self.__gateway_topic_logout_subdev_reply:
             try:
                 payload = self.__load_json(message.payload)
@@ -2166,7 +2173,6 @@ UxeCp6
                     self.__on_gateway_logout_subdev_reply(request_id, code, data, msg, self.__user_data)
             except Exception as e:
                 self.__link_log.error("__on_gateway_logout_subdev_reply process raise exception:%s" % e)
-            pass
         elif message.topic == self.__gateway_topic_register_subdev_reply:
             try:
                 payload = self.__load_json(message.payload)
@@ -2180,21 +2186,19 @@ UxeCp6
                     self.__on_gateway_register_subdev_reply(request_id, code, data, msg, self.__user_data)
             except Exception as e:
                 self.__link_log.error("__on_gateway_register_subdev_reply process raise exception:%s" % e)
-            pass
         elif message.topic == self.__gateway_topic_product_register_subdev_reply:
             try:
                 payload = self.__load_json(message.payload)
                 request_id = payload["id"]
                 code = payload["code"]
                 data = payload["data"]
-                msg = payload['message']
+                msg = payload["message"]
                 self.__back_thing_request_id(request_id)
                 if self.__on_gateway_product_register_subdev_reply is not None:
                     triggered_flag = 1
                     self.__on_gateway_product_register_subdev_reply(request_id, code, data, msg, self.__user_data)
             except Exception as e:
                 self.__link_log.error("__on_gateway_product_register_subdev_reply process raise exception:%s" % e)
-            pass
         elif message.topic == self.__dynamic_register_topic:
             try:
                 payload = self.__load_json(message.payload)
@@ -2206,28 +2210,29 @@ UxeCp6
                     self.__on_device_dynamic_register(LinkKit.ErrorCode.SUCCESS.value, device_secret, None)
             except Exception as e:
                 self.__link_log.error("__on_device_dynamic_register process raise exception:%s" % e)
-            pass
 
         elif message.topic == self.__dynamic_register_nwl_topic:
             # 一型一密免动态注册获取到username和token
             try:
                 payload = self.__load_json(message.payload)
                 client_id = payload["clientId"]
-                client_id = client_id + '|authType=connwl,securemode=-2,_ss=1,ext=3,lan=%s,_v=%s|' % (
-                    self.__sdk_program_language, self.__sdk_version)
+                client_id = client_id + "|authType=connwl,securemode=-2,_ss=1,ext=3,lan=%s,_v=%s|" % (
+                    self.__sdk_program_language,
+                    self.__sdk_version,
+                )
                 product_key = payload["productKey"]
                 device_name = payload["deviceName"]
-                username = device_name + '&' + product_key
-                password = payload['deviceToken']
+                username = device_name + "&" + product_key
+                password = payload["deviceToken"]
                 self.disconnect()
                 self.__dynamic_register_nwl_flag = 0
                 if self.__on_device_dynamic_register_nwl_reply is not None:
                     triggered_flag = 1
-                    self.__on_device_dynamic_register_nwl_reply(LinkKit.ErrorCode.SUCCESS.value, client_id, username,
-                                                                password)
+                    self.__on_device_dynamic_register_nwl_reply(
+                        LinkKit.ErrorCode.SUCCESS.value, client_id, username, password
+                    )
             except Exception as e:
                 self.__link_log.error("__on_device_dynamic_register_nwl_reply process raise exception:%s" % e)
-            pass
         elif message.topic == self.__ota_push_topic or message.topic == self.__ota_pull_reply_topic:
             try:
                 payload = json.loads(self.__to_str(message.payload))
@@ -2244,8 +2249,13 @@ UxeCp6
                 extra = download_info.setdefault("extData", "")
                 module = download_info.setdefault("module", "default")
 
-                if not self.__is_valid_str(url) or not self.__is_valid_str(version) or not self.__is_valid_str(size) \
-                        or not self.__is_valid_str(sign_method) or not self.__is_valid_str(sign):
+                if (
+                    not self.__is_valid_str(url)
+                    or not self.__is_valid_str(version)
+                    or not self.__is_valid_str(size)
+                    or not self.__is_valid_str(sign_method)
+                    or not self.__is_valid_str(sign)
+                ):
                     self.__link_log.error("invalid download params")
                     return
 
@@ -2257,11 +2267,11 @@ UxeCp6
 
                 if self.__on_ota_message_arrived is not None:
                     triggered_flag = 1
-                    self.__on_ota_message_arrived(ota_notice_type, version, size, url, sign_method, sign, module,
-                                                  str(extra))
+                    self.__on_ota_message_arrived(
+                        ota_notice_type, version, size, url, sign_method, sign, module, str(extra)
+                    )
             except Exception as e:
                 self.__link_log.error("__on_ota_message_arrived process raise exception:%s" % e)
-            pass
 
         if triggered_flag == 1:
             return
@@ -2271,10 +2281,8 @@ UxeCp6
                 self.__on_topic_message(message.topic, message.payload, message.qos, self.__user_data)
             except Exception as e:
                 self.__link_log.error("on_topic_message process raise exception:%s" % e)
-            pass
         else:
             self.__link_log.error("receive unscubscibe topic : %s" % message.topic)
-        pass
 
     def query_ota_firmware(self, module=None):
         request_id = self.__get_thing_request_id()
@@ -2282,27 +2290,25 @@ UxeCp6
             request_id = "1"
 
         if self.__is_valid_str(module):
-            payload = "{\"id\": %s, \"params\": {\"module\": \"%s\"}}" % (request_id, module)
+            payload = '{"id": %s, "params": {"module": "%s"}}' % (request_id, module)
         else:
-            payload = "{\"id\": %s, \"params\": {}}" % request_id
-        pass
+            payload = '{"id": %s, "params": {}}' % request_id
 
         rc = self.__mqtt_client.publish(self.__ota_pull_topic, payload, 0)
         if rc == mqtt.MQTT_ERR_SUCCESS:
             return 0
         else:
             return LinkKit.ErrorCode.OTA_PUB_FAILED
-        pass
 
     def __cal_file_sign(self, filename, sign_method):
-        if "Md5" == sign_method:
+        if sign_method == "Md5":
             hash_tool = hashlib.md5()
-        elif "SHA256" == sign_method:
+        elif sign_method == "SHA256":
             hash_tool = hashlib.sha256()
         else:
             return LinkKit.ErrorCode.OTA_INVALID_SIGN_METHOD, -1
 
-        with open(filename, 'rb') as f:
+        with open(filename, "rb") as f:
             while True:
                 chunk = f.read(4096)
                 if not chunk:
@@ -2316,9 +2322,9 @@ UxeCp6
 
         request_id = "1"
         if self.__is_valid_str(module):
-            payload = "{\"id\": %s,\"params\": {\"version\":\"%s\",\"module\": \"%s\"}}" % (request_id, version, module)
+            payload = '{"id": %s,"params": {"version":"%s","module": "%s"}}' % (request_id, version, module)
         else:
-            payload = "{\"id\": %s, \"params\": {\"version\": \"%s\"}}" % (request_id, version)
+            payload = '{"id": %s, "params": {"version": "%s"}}' % (request_id, version)
 
         rc = self.__mqtt_client.publish(self.__ota_report_version_topic, payload, 0)
         if rc == mqtt.MQTT_ERR_SUCCESS:
@@ -2327,8 +2333,12 @@ UxeCp6
             return LinkKit.ErrorCode.OTA_PUB_FAILED
 
     def download_ota_firmware(self, url, local_path, sign_method, sign, download_step=10 * 1024):
-        if not self.__is_valid_str(url) or not self.__is_valid_str(local_path) or not self.__is_valid_str(sign_method) \
-                or not self.__is_valid_str(sign):
+        if (
+            not self.__is_valid_str(url)
+            or not self.__is_valid_str(local_path)
+            or not self.__is_valid_str(sign_method)
+            or not self.__is_valid_str(sign)
+        ):
             return LinkKit.ErrorCode.OTA_INVALID_PARAM
 
         context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH, cadata=self.__aliyun_broker_ca_data)
@@ -2337,16 +2347,16 @@ UxeCp6
             conn = urllib.request.urlopen(url, context=context)
         except Exception as e:
             # Return code error (e.g. 404, 501, ...)
-            self.__link_log.error('HTTPError: {} %s' % e)
+            self.__link_log.error("HTTPError: {} %s" % e)
             return LinkKit.ErrorCode.OTA_INVALID_URL
         else:
             # 200
-            self.__link_log.info('https return 200')
+            self.__link_log.info("https return 200")
 
             try:
-                file = open(local_path, 'wb')
-            except IOError as e:
-                self.__link_log.error('open file error: {}' + e.filename)
+                file = open(local_path, "wb")
+            except OSError as e:
+                self.__link_log.error("open file error: {}" + e.filename)
                 return LinkKit.ErrorCode.OTA_INVALID_PATH
             else:
                 # Download ota file
@@ -2355,7 +2365,7 @@ UxeCp6
                         try:
                             data = conn.read(download_step)
                         except Exception as e:
-                            self.__link_log.error('download exception %s' % e)
+                            self.__link_log.error("download exception %s" % e)
                             return LinkKit.ErrorCode.OTA_DOWNLOAD_FAIL
                         else:
                             if len(data) <= 0:
@@ -2365,15 +2375,15 @@ UxeCp6
 
                 # Compare checksum
                 ret, firmware_sign = self.__cal_file_sign(local_path, sign_method)
-                if LinkKit.ErrorCode.SUCCESS == ret and firmware_sign == sign:
-                    self.__link_log.info('sign match')
+                if ret == LinkKit.ErrorCode.SUCCESS and firmware_sign == sign:
+                    self.__link_log.info("sign match")
                     return LinkKit.ErrorCode.SUCCESS
                 else:
-                    self.__link_log.error('sign mismatch, expect:' + firmware_sign + ", actually:" + sign)
+                    self.__link_log.error("sign mismatch, expect:" + firmware_sign + ", actually:" + sign)
                     return LinkKit.ErrorCode.OTA_DIGEST_MISMATCH
 
     def __parse_raw_topic(self, topic):
-        return re.search('/ext/rrpc/.*?(/.*)', topic).group(1)
+        return re.search("/ext/rrpc/.*?(/.*)", topic).group(1)
 
     def __tidy_topic(self, topic):
         if topic == None:
@@ -2381,27 +2391,27 @@ UxeCp6
         topic = topic.strip()
         if len(topic) == 0:
             return None
-        if topic[0] != '/':
-            topic = '/' + topic
+        if topic[0] != "/":
+            topic = "/" + topic
         return topic
 
-    def __push_rrpc_service(self, item):
+    def __push_rrpc_service(self, item) -> None:
         with self.__user_rrpc_request_ids_lock:
             if len(self.__user_rrpc_request_ids) > self.__user_rrpc_request_max_len:
                 removed_item = self.__user_rrpc_request_ids.pop(0)
-                del self.__user_rrpc_request_id_index_map[removed_item['id']]
+                del self.__user_rrpc_request_id_index_map[removed_item["id"]]
 
         self.__user_rrpc_request_ids.append(item)
-        self.__user_rrpc_request_id_index_map[item['id']] = 0
+        self.__user_rrpc_request_id_index_map[item["id"]] = 0
 
     def __pop_rrpc_service(self, id):
         with self.__user_rrpc_request_ids_lock:
             if id not in self.__user_rrpc_request_id_index_map:
                 return None
             del self.__user_rrpc_request_id_index_map[id]
-            for index in range(0, len(self.__user_rrpc_request_ids)):
+            for index in range(len(self.__user_rrpc_request_ids)):
                 item = self.__user_rrpc_request_ids[index]
-                if item['id'] == id:
+                if item["id"] == id:
                     del self.__user_rrpc_request_ids[index]
                     return item
             return None
@@ -2411,24 +2421,29 @@ UxeCp6
         if item == None:
             self.__link_log.error("answer_rrpc_topic, the id does not exist: %s" % id)
             return 1, None
-        rc, mid = self.__mqtt_client.publish(item['topic'], response, 0)
-        self.__link_log.debug('reply topic:%s' % item['topic'])
+        rc, mid = self.__mqtt_client.publish(item["topic"], response, 0)
+        self.__link_log.debug("reply topic:%s" % item["topic"])
         return rc, mid
 
     def __try_parse_rrpc_topic(self, message):
-        self.__link_log.debug('receive a rrpc topic:%s' % message.topic)
+        self.__link_log.debug("receive a rrpc topic:%s" % message.topic)
         raw_topic = self.__parse_raw_topic(message.topic)
         triggered = 0
         # if it is a service, log it...
-        if raw_topic.startswith('/sys') and raw_topic in self.__thing_topic_services:
-            identifier = raw_topic.split('/', 6)[6]
+        if raw_topic.startswith("/sys") and raw_topic in self.__thing_topic_services:
+            identifier = raw_topic.split("/", 6)[6]
             payload = self.__load_json(self.__to_str(message.payload))
             try:
                 request_id = payload["id"]
                 params = payload["params"]
-                item_id = 'alink_' + request_id
-                item = {'id': item_id, 'request_id': request_id, 'payload': payload, 'identifier': identifier,
-                        'topic': message.topic}
+                item_id = "alink_" + request_id
+                item = {
+                    "id": item_id,
+                    "request_id": request_id,
+                    "payload": payload,
+                    "identifier": identifier,
+                    "topic": message.topic,
+                }
                 self.__push_rrpc_service(item)
                 if self.__on_thing_call_service is not None:
                     triggered = 1
@@ -2446,20 +2461,17 @@ UxeCp6
         if not self.__on_topic_rrpc_message:
             return
         try:
-            rrpc_id = message.topic.split('/', 4)[3]
-            item_id = 'rrpc_' + rrpc_id
-            item = {'id': item_id, 'payload': message.payload, 'topic': message.topic}
+            rrpc_id = message.topic.split("/", 4)[3]
+            item_id = "rrpc_" + rrpc_id
+            item = {"id": item_id, "payload": message.payload, "topic": message.topic}
             self.__push_rrpc_service(item)
-            self.__on_topic_rrpc_message(rrpc_id, message.topic,
-                                         message.payload,
-                                         message.qos,
-                                         self.__user_data)
+            self.__on_topic_rrpc_message(rrpc_id, message.topic, message.payload, message.qos, self.__user_data)
             # self.__mqtt_client.publish(message.topic, response, 0)
             # self.__link_log.debug('reply topic:%s' % message.topic)
         except Exception as e:
             self.__link_log.error("on_topic_rrpc_message process raise exception:%r" % e)
 
-    def __try_parse_try_shadow(self, payload):
+    def __try_parse_try_shadow(self, payload) -> None:
         try:
             self.__latest_shadow.set_latest_recevied_time(self.__timestamp())
             self.__latest_shadow.set_latest_recevied_payload(payload)
@@ -2467,36 +2479,32 @@ UxeCp6
             # parse the pay load
             msg = self.__load_json(payload)
             # set version
-            if 'version' in msg:
-                self.__latest_shadow.set_version(msg['version'])
-            elif 'payload' in msg and 'version' in msg['payload']:
-                self.__latest_shadow.set_version(msg['payload']['version'])
+            if "version" in msg:
+                self.__latest_shadow.set_version(msg["version"])
+            elif "payload" in msg and "version" in msg["payload"]:
+                self.__latest_shadow.set_version(msg["payload"]["version"])
 
             # set timestamp
-            if 'timestamp' in msg:
-                self.__latest_shadow.set_timestamp(msg['timestamp'])
-            elif 'payload' in msg and 'timestamp' in msg['payload']:
-                self.__latest_shadow.set_timestamp(msg['payload']['timestamp'])
+            if "timestamp" in msg:
+                self.__latest_shadow.set_timestamp(msg["timestamp"])
+            elif "payload" in msg and "timestamp" in msg["payload"]:
+                self.__latest_shadow.set_timestamp(msg["payload"]["timestamp"])
 
             # set state and metadata
-            if 'payload' in msg and msg['payload']['status'] == 'success':
-                if 'state' in msg['payload']:
-                    self.__latest_shadow.set_state(msg['payload']['state'])
-                if 'metadata' in msg['payload']:
-                    self.__latest_shadow.set_metadata(msg['payload']['metadata'])
-        except Exception as e:
+            if "payload" in msg and msg["payload"]["status"] == "success":
+                if "state" in msg["payload"]:
+                    self.__latest_shadow.set_state(msg["payload"]["state"])
+                if "metadata" in msg["payload"]:
+                    self.__latest_shadow.set_metadata(msg["payload"]["metadata"])
+        except Exception:
             pass
 
     def thing_update_shadow(self, reported, version):
-        request = {
-            'state': {'reported': reported},
-            'method': 'update',
-            'version': version
-        }
+        request = {"state": {"reported": reported}, "method": "update", "version": version}
         return self.__thing_update_shadow(request)
 
     def thing_get_shadow(self):
-        request = {'method': 'get'}
+        request = {"method": "get"}
         return self.__thing_update_shadow(request)
 
     def local_get_latest_shadow(self):
@@ -2509,57 +2517,54 @@ UxeCp6
         if not self.__thing_setup_state or not self.__thing_enable_state:
             return 1, None
         with self.__thing_shadow_mid_lock:
-            rc, mid = self.__mqtt_client.publish(self.__thing_topic_shadow_update,
-                                                 json.dumps(request), 1)
+            rc, mid = self.__mqtt_client.publish(self.__thing_topic_shadow_update, json.dumps(request), 1)
             if rc == mqtt.MQTT_ERR_SUCCESS:
                 self.__thing_shadow_mid[mid] = self.__timestamp()
                 return 0, mid
             else:
                 return 1, None
 
-    def __on_internal_message(self, client, user_data, message):
+    def __on_internal_message(self, client, user_data, message) -> None:
         self.__link_log.info("__on_internal_message")
         self.__handler_task.post_message(self.__handler_task_cmd_on_message, (client, user_data, message))
         # self.__worker_thread.async_post_message(message)
-        pass
 
-    def __handler_task_on_message_callback(self, value):
+    def __handler_task_on_message_callback(self, value) -> None:
         client, user_data, message = value
         self.__on_internal_async_message(message)
 
-    def __on_internal_connect(self, client, user_data, session_flag, rc):
+    def __on_internal_connect(self, client, user_data, session_flag, rc) -> None:
         self.__link_log.info("__on_internal_connect")
         if rc == 0:
             self.__reset_reconnect_wait()
             # self.__upload_device_interface_info()
             self.__handler_task.post_message(self.__handler_task_cmd_on_connect, (client, user_data, session_flag, rc))
 
-    def __handler_task_on_connect_callback(self, value):
+    def __handler_task_on_connect_callback(self, value) -> None:
         client, user_data, session_flag, rc = value
         self.__link_log.info("__on_internal_connect enter")
-        self.__link_log.debug("session:%d, return code:%d" % (session_flag['session present'], rc))
+        self.__link_log.debug("session:%d, return code:%d" % (session_flag["session present"], rc))
         if rc == 0:
             self.__linkkit_state = LinkKit.LinkKitState.CONNECTED
             # self.__worker_thread.start()
         if self.__on_connect is not None:
             try:
-                self.__on_connect(session_flag['session present'], rc, self.__user_data)
+                self.__on_connect(session_flag["session present"], rc, self.__user_data)
             except Exception as e:
                 self.__link_log.error("on_connect process raise exception:%r" % e)
-        pass
         if self.__thing_setup_state:
             self.__thing_enable_state = True
             if self.__on_thing_enable:
                 self.__on_thing_enable(self.__user_data)
-        return
 
-    def __on_internal_disconnect(self, client, user_data, rc):
+    def __on_internal_disconnect(self, client, user_data, rc) -> None:
         self.__link_log.info("__on_internal_disconnect enter")
         if self.__linkkit_state == LinkKit.LinkKitState.DESTRUCTING:
             self.__linkkit_state = LinkKit.LinkKitState.DESTRUCTED
-        elif self.__linkkit_state == LinkKit.LinkKitState.DISCONNECTING:
-            self.__linkkit_state = LinkKit.LinkKitState.DISCONNECTED
-        elif self.__linkkit_state == LinkKit.LinkKitState.CONNECTED:
+        elif (
+            self.__linkkit_state == LinkKit.LinkKitState.DISCONNECTING
+            or self.__linkkit_state == LinkKit.LinkKitState.CONNECTED
+        ):
             self.__linkkit_state = LinkKit.LinkKitState.DISCONNECTED
         elif self.__linkkit_state == LinkKit.LinkKitState.DISCONNECTED:
             self.__link_log.error("__on_internal_disconnect enter from wrong state:%r" % self.__linkkit_state)
@@ -2589,7 +2594,7 @@ UxeCp6
         if self.__linkkit_state == LinkKit.LinkKitState.DESTRUCTED:
             self.__handler_task.stop()
 
-    def __handler_task_on_disconnect_callback(self, value):
+    def __handler_task_on_disconnect_callback(self, value) -> None:
         self.__link_log.info("__handler_task_on_disconnect_callback enter")
         client, user_data, rc = value
         if self.__thing_setup_state:
@@ -2606,9 +2611,7 @@ UxeCp6
             except Exception as e:
                 self.__link_log.error("on_disconnect process raise exception:%r" % e)
 
-        pass
-
-    def __on_internal_publish(self, client, user_data, mid):
+    def __on_internal_publish(self, client, user_data, mid) -> None:
         self.__handler_task.post_message(self.__handler_task_cmd_on_publish, (client, user_data, mid))
 
     def __gateway_add_subdev_topo(self, subdev_array):
@@ -2632,7 +2635,7 @@ UxeCp6
                 "clientId": client_id,
                 "timestamp": millis,
                 "signmethod": "hmacSha256",
-                "sign": sign
+                "sign": sign,
             }
             request_params.append(params)
         request_id = self.__get_thing_request_id()
@@ -2650,7 +2653,6 @@ UxeCp6
                 return 0, request_id
             else:
                 return 1, None
-        pass
 
     def gateway_add_subdev_topo(self, subdev_array):
         return self.__gateway_add_subdev_topo(subdev_array)
@@ -2696,7 +2698,6 @@ UxeCp6
                 return 0, request_id
             else:
                 return 1, None
-        pass
 
     def gateway_delete_subdev_topo(self, subdev_array):
         return self.__gateway_delete_subdev_topo(subdev_array)
@@ -2722,7 +2723,7 @@ UxeCp6
                 "clientId": client_id,
                 "timestamp": millis,
                 "cleanSession": "false",
-                "sign": sign
+                "sign": sign,
             }
             device_list.append(dev_params)
         request_params = {
@@ -2777,7 +2778,6 @@ UxeCp6
             return 0, request_id
         else:
             return 1, None
-        pass
 
     def __gateway_register_subdev(self, subdev_array):
         request_params = []
@@ -2833,7 +2833,7 @@ UxeCp6
                 "deviceName": dn,
                 "random": random_str,
                 "signMethod": "hmacSha256",
-                "sign": sign
+                "sign": sign,
             }
             device_list.append(dev_params)
         request_params = {
@@ -2854,7 +2854,7 @@ UxeCp6
         else:
             return 1, None
 
-    def __handler_task_on_publish_callback(self, value):
+    def __handler_task_on_publish_callback(self, value) -> None:
         client, user_data, mid = value
         self.__link_log.debug("__on_internal_publish message:%d" % mid)
         with self.__thing_event_post_mid_lock:
@@ -2919,15 +2919,15 @@ UxeCp6
                 return
         if self.__on_publish_topic is not None:
             self.__on_publish_topic(mid, self.__user_data)
-        pass
 
-    def __on_internal_subscribe(self, client, user_data, mid, granted_qos):
+    def __on_internal_subscribe(self, client, user_data, mid, granted_qos) -> None:
         self.__handler_task.post_message(self.__handler_task_cmd_on_subscribe, (client, user_data, mid, granted_qos))
 
-    def __handler_task_on_subscribe_callback(self, value):
+    def __handler_task_on_subscribe_callback(self, value) -> None:
         client, user_data, mid, granted_qos = value
-        self.__link_log.debug("__on_internal_subscribe mid:%d  granted_qos:%s" %
-                              (mid, str(','.join('%s' % it for it in granted_qos))))
+        self.__link_log.debug(
+            "__on_internal_subscribe mid:%d  granted_qos:%s" % (mid, str(",".join("%s" % it for it in granted_qos)))
+        )
         # try to read rrpc
         with self.__user_rrpc_topics_subscribe_request_lock:
             if mid in self.__user_rrpc_topics_subscribe_request:
@@ -2936,7 +2936,7 @@ UxeCp6
                     try:
                         self.__on_subscribe_rrpc_topic(mid, granted_qos, self.__user_data)
                     except Exception as err:
-                        self.__link_log.error('Caught exception in on_subscribe_topic: %s', err)
+                        self.__link_log.error("Caught exception in on_subscribe_topic: %s", err)
                 return
 
         # try to read other topic
@@ -2949,8 +2949,7 @@ UxeCp6
             return_topics = []
             for index in range(len(topics_requests)):
                 if granted_qos[index] < 0 or granted_qos[index] > 1:
-                    self.__link_log.error("topics:%s, granted wrong:%d" %
-                                          (topics_requests[index], granted_qos[index]))
+                    self.__link_log.error("topics:%s, granted wrong:%d" % (topics_requests[index], granted_qos[index]))
                 else:
                     self.__user_topics[topics_requests[index][0]] = granted_qos[index]
                 return_topics.append((topics_requests[index], granted_qos[index]))
@@ -2958,13 +2957,12 @@ UxeCp6
             try:
                 self.__on_subscribe_topic(mid, granted_qos, self.__user_data)
             except Exception as err:
-                self.__link_log.error('Caught exception in on_subscribe_topic: %s', err)
-        pass
+                self.__link_log.error("Caught exception in on_subscribe_topic: %s", err)
 
-    def __on_internal_unsubscribe(self, client, user_data, mid):
+    def __on_internal_unsubscribe(self, client, user_data, mid) -> None:
         self.__handler_task.post_message(self.__handler_task_cmd_on_unsubscribe, (client, user_data, mid))
 
-    def __handler_task_on_unsubscribe_callback(self, value):
+    def __handler_task_on_unsubscribe_callback(self, value) -> None:
         client, user_data, mid = value
         self.__link_log.debug("__on_internal_unsubscribe mid:%d" % mid)
         unsubscribe_request = None
@@ -2976,13 +2974,12 @@ UxeCp6
                     try:
                         self.__on_unsubscribe_rrpc_topic(mid, self.__user_data)
                     except Exception as err:
-                        self.__link_log.error('Caught exception in on_unsubscribe_rrpc_topic: %s', err)
+                        self.__link_log.error("Caught exception in on_unsubscribe_rrpc_topic: %s", err)
                 return
 
         with self.__user_topics_unsubscribe_request_lock:
             if mid in self.__user_topics_unsubscribe_request:
                 unsubscribe_request = self.__user_topics_unsubscribe_request.pop(mid)
-                pass
         if unsubscribe_request is not None:
             for t in unsubscribe_request:
                 self.__link_log.debug("__user_topics:%s" % str(self.__user_topics))
@@ -2995,25 +2992,25 @@ UxeCp6
             try:
                 self.__on_unsubscribe_topic(mid, self.__user_data)
             except Exception as err:
-                self.__link_log.error('Caught exception in on_unsubscribe_topic: %s', err)
+                self.__link_log.error("Caught exception in on_unsubscribe_topic: %s", err)
 
     def dump_user_topics(self):
         return self.__user_topics
 
-    def force_reconnect(self):
+    def force_reconnect(self) -> None:
         self.__link_log.error("force reconnecting")
         self.__force_reconnect = True
 
     @staticmethod
     def to_user_topic(topic):
-        topic_section = topic.split('/', 3)
+        topic_section = topic.split("/", 3)
         user_topic = topic_section[3]
         return user_topic
 
     def to_full_topic(self, topic):
         return self.__USER_TOPIC_PREFIX % (self.__product_key, self.__device_name, topic)
 
-    def __is_valid_str(self, user_str):
+    def __is_valid_str(self, user_str) -> bool:
         if user_str is None or user_str == "":
             return False
         return True