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

pymammotion/mqtt/linkkit/h2client.py

@@ -16,16 +16,19 @@
 #
 #
 
-import hyper
-import time
+import concurrent.futures
+import hashlib
 import hmac
-import ssl
 import logging
 import os
+import ssl
 import threading
+import time
+
 import crcmod
-import concurrent.futures
-import hashlib
+import hyper
+from types import TracebackType
+from typing import Optional, Type
 
 
 def _assert_value(condition, error_msg):
@@ -38,26 +41,26 @@ _H2_OPT_PORT_DEFAULT = 443
 _H2_MAX_FILE_SIZE = 1024 * 1024 * 1024
 
 
-def h2_set_option(opt, value):
-    if ('heart_beat_interval' == opt):
+def h2_set_option(opt, value) -> None:
+    if opt == "heart_beat_interval":
         global _H2_OPT_HEART_BEAT_TIME_DEFAULT
         _H2_OPT_HEART_BEAT_TIME_DEFAULT = value
-    elif ('port' == opt):
+    elif opt == "port":
         global _H2_OPT_PORT_DEFAULT
         _H2_OPT_PORT_DEFAULT = value
-    elif ('max_file_size' == opt):
+    elif opt == "max_file_size":
         global _H2_MAX_FILE_SIZE
         _H2_MAX_FILE_SIZE = value
 
 
-class StreamHandler():
-    def __init__(self):
+class StreamHandler:
+    def __init__(self) -> None:
         pass
 
-    def __enter__(self):
+    def __enter__(self) -> None:
         pass
 
-    def __exit__(self, type, value, trace):
+    def __exit__(self, type: Optional[Type[BaseException]], value: Optional[BaseException], trace: Optional[TracebackType]) -> None:
         pass
 
     def get_content_length(self):
@@ -66,14 +69,14 @@ class StreamHandler():
     def next(self):
         return None
 
-    def has_next(self):
+    def has_next(self) -> bool:
         return False
 
 
 class FileStreamHandler(StreamHandler):
-    def __init__(self, filename, block_size=512 * 1024, opt_crc64=False):
+    def __init__(self, filename, block_size=512 * 1024, opt_crc64=False) -> None:
         self.__filename = filename
-        self.__block_size = block_size;
+        self.__block_size = block_size
         self.__size = os.stat(filename).st_size
         self.__opt_crc64 = opt_crc64
         self.__last_crc = 0
@@ -82,12 +85,12 @@ class FileStreamHandler(StreamHandler):
     def get_content_length(self):
         return self.__size
 
-    def __enter__(self):
-        logging.debug('open the file, filename:%s' % self.__filename)
-        self.__f = open(self.__filename, 'rb')
+    def __enter__(self) -> None:
+        logging.debug("open the file, filename:%s" % self.__filename)
+        self.__f = open(self.__filename, "rb")
         self.__read_size = 0
 
-    def __exit__(self, type, value, trace):
+    def __exit__(self, type: Optional[Type[BaseException]], value: Optional[BaseException], trace: Optional[TracebackType]) -> None:
         if self.__f:
             self.__f.close()
             self.__f = None
@@ -99,8 +102,9 @@ class FileStreamHandler(StreamHandler):
         if data:
             self.__read_size += len(data)
         if self.__opt_crc64:
-            do_crc64 = crcmod.mkCrcFun(0x142F0E1EBA9EA3693, initCrc=self.__last_crc, xorOut=0xffffffffffffffff,
-                                       rev=True)
+            do_crc64 = crcmod.mkCrcFun(
+                0x142F0E1EBA9EA3693, initCrc=self.__last_crc, xorOut=0xFFFFFFFFFFFFFFFF, rev=True
+            )
             self.__last_crc = do_crc64(data)
         return data
 
@@ -115,7 +119,7 @@ class FileStreamHandler(StreamHandler):
 
 
 class H2Exception(Exception):
-    def __init__(self, code, msg):
+    def __init__(self, code, msg) -> None:
         Exception.__init__(self, msg)
         self.__code = code
         self.__msg = msg
@@ -126,13 +130,12 @@ class H2Exception(Exception):
     def get_msg(self):
         return self.__msg
 
-    def __name__(self):
-        return 'H2Exception'
+    def __name__(self) -> str:
+        return "H2Exception"
 
 
 class UploadFileInfo:
-    def __init__(self, local_filename, remote_filename=None,
-                 overwrite=True):
+    def __init__(self, local_filename, remote_filename=None, overwrite=True) -> None:
         self.local_filename = local_filename
         self.opt_overwrite = overwrite
         if not remote_filename:
@@ -140,35 +143,35 @@ class UploadFileInfo:
         else:
             self.remote_filename = remote_filename
 
-    def __name__(self):
-        return 'UploadFileInfo'
+    def __name__(self) -> str:
+        return "UploadFileInfo"
 
 
 class UploadFileResult:
-    def __init__(self, code=None, exception=None, upload_size=None, total_size=None, file_store_id=None):
+    def __init__(self, code=None, exception=None, upload_size=None, total_size=None, file_store_id=None) -> None:
         self.upload_size = upload_size
         self.total_size = total_size
         self.file_store_id = file_store_id
         self.code = code
         self.exception = exception
 
-    def __name__(self):
-        return 'UploadFileResult'
+    def __name__(self) -> str:
+        return "UploadFileResult"
 
 
 class H2FileUploadSink:
-    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:
         pass
 
-    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:
         pass
 
-    def on_file_upload_progress(self, id, upload_file_info, upload_file_result, user_data):
+    def on_file_upload_progress(self, id, upload_file_info, upload_file_result, user_data) -> None:
         pass
 
 
 class H2FileTask:
-    def __init__(self, id, file_info, future_result):
+    def __init__(self, id, file_info, future_result) -> None:
         self.__file_info = file_info
         self.__future_result = future_result
         self.__id = id
@@ -182,18 +185,18 @@ class H2FileTask:
     def result(self, timeout=None):
         return self.__future_result.result(timeout)
 
-    def cancel(self):
+    def cancel(self) -> None:
         self.__future_result.call()
 
     def get_id(self):
         return self.__id
 
-    def __name__(self):
-        return 'H2FileTask'
+    def __name__(self) -> str:
+        return "H2FileTask"
 
 
 class H2Stream:
-    def __init__(self, client, id):
+    def __init__(self, client, id) -> None:
         self.__client = client
         self.__conn = None
         # self.__length = None
@@ -204,8 +207,8 @@ class H2Stream:
         self.__x_request_id = None
         self.__x_data_stream_id = None
 
-    def __name__(self):
-        return 'H2Stream'
+    def __name__(self) -> str:
+        return "H2Stream"
 
     def get_id(self):
         return self.__id
@@ -214,7 +217,7 @@ class H2Stream:
         _assert_value(path, "path is required")
 
         with self.__client._get_auth_lock():
-            url = '/stream/open' + path
+            url = "/stream/open" + path
             self.__conn = self.__client.get_connect()
 
             # self.__length = length
@@ -228,12 +231,12 @@ class H2Stream:
             if header:
                 conn_header.update(header)
 
-            req_id = self.__conn.request('GET', url, None, conn_header)
+            req_id = self.__conn.request("GET", url, None, conn_header)
             response = self.__conn.get_response(req_id)
 
             self.__check_response(response)
-            self.__x_request_id = response.headers['x-request-id'][0]
-            self.__x_data_stream_id = response.headers['x-data-stream-id'][0]
+            self.__x_request_id = response.headers["x-request-id"][0]
+            self.__x_data_stream_id = response.headers["x-data-stream-id"][0]
 
             logging.debug("x_request_id: %s" % self.__x_request_id)
             logging.debug("x_data_stream_id: %s" % self.__x_data_stream_id)
@@ -241,11 +244,10 @@ class H2Stream:
             return response
 
     def close(self, header):
-        logging.debug('close the stream')
-        final_header = {'x-request-id': self.__x_request_id,
-                        'x-data-stream-id': self.__x_data_stream_id}
+        logging.debug("close the stream")
+        final_header = {"x-request-id": self.__x_request_id, "x-data-stream-id": self.__x_data_stream_id}
         final_header.update(header)
-        req_id = self.__conn.request('GET', '/stream/close/' + self.__path, None, final_header)
+        req_id = self.__conn.request("GET", "/stream/close/" + self.__path, None, final_header)
         response = self.__conn.get_response(req_id)
         self.__check_response(response)
         return response
@@ -253,14 +255,14 @@ class H2Stream:
     def send(self, headers, data_handler):
         # prepare for sending
         with self.__client._get_auth_lock():
-            url = '/stream/send' + self.__path
+            url = "/stream/send" + self.__path
             logging.debug("request url: %s" % url)
-            self.__stream_id = self.__conn.putrequest('GET', url)
-            self.__conn.putheader('x-request-id', self.__x_request_id, stream_id=self.__stream_id)
-            self.__conn.putheader('x-data-stream-id', self.__x_data_stream_id, stream_id=self.__stream_id)
+            self.__stream_id = self.__conn.putrequest("GET", url)
+            self.__conn.putheader("x-request-id", self.__x_request_id, stream_id=self.__stream_id)
+            self.__conn.putheader("x-data-stream-id", self.__x_data_stream_id, stream_id=self.__stream_id)
             content_length = data_handler.get_content_length()
             if content_length:
-                self.__conn.putheader('content-length', '%s' % (content_length), self.__stream_id)
+                self.__conn.putheader("content-length", "%s" % (content_length), self.__stream_id)
             for k, v in headers.items():
                 self.__conn.putheader(k, v, self.__stream_id)
             self.__conn.endheaders(stream_id=self.__stream_id)
@@ -280,20 +282,22 @@ class H2Stream:
         return response
 
     def __check_response(self, response, msg=None):
-        if (response.status != 200):
-            raise H2Exception(response.status,
-                              msg if msg else 'fail to request http/2, code:%d' % (response.status))
+        if response.status != 200:
+            raise H2Exception(response.status, msg if msg else "fail to request http/2, code:%d" % (response.status))
 
-    def __str__(self):
-        return 'H2Stream(id=%s,stream_x_id=%s,x_request_id=%s,x_data_stream_id:%s' % (self.__id,
-                                                                                      self.__stream_id,
-                                                                                      self.__x_request_id,
-                                                                                      self.__x_data_stream_id)
+    def __str__(self) -> str:
+        return "H2Stream(id=%s,stream_x_id=%s,x_request_id=%s,x_data_stream_id:%s" % (
+            self.__id,
+            self.__stream_id,
+            self.__x_request_id,
+            self.__x_data_stream_id,
+        )
 
 
 class H2Client:
-    def __init__(self, region, product_key, device_name, device_secret, client_id=None, opt_max_thread_num=4,
-                 endpoint=None):
+    def __init__(
+        self, region, product_key, device_name, device_secret, client_id=None, opt_max_thread_num=4, endpoint=None
+    ) -> None:
         _assert_value(region, "region is not empty")
         _assert_value(product_key, "product_key is not empty")
         _assert_value(device_name, "device_name is not empty")
@@ -334,7 +338,7 @@ class H2Client:
     def open(self):
         with self.__conn_lock:
             if self.__conn:
-                logging.info('the client is opened')
+                logging.info("the client is opened")
                 return -1
             return self.__connect()
 
@@ -343,22 +347,30 @@ class H2Client:
             return self.__close_connect()
         self.__close_all_streams()
 
-    def upload_file_async(self, local_filename, remote_filename=None, over_write=True,
-                          upload_file_sink=None, upload_sink_user_data=None):
-        _assert_value(local_filename, 'local_filename is required')
+    def upload_file_async(
+        self, local_filename, remote_filename=None, over_write=True, upload_file_sink=None, upload_sink_user_data=None
+    ):
+        _assert_value(local_filename, "local_filename is required")
         self.__check_file(local_filename)
 
         file_info = UploadFileInfo(local_filename, remote_filename, over_write)
 
-        future_result = self.__thread_executor.submit(self.__post_file_task, file_info, upload_file_sink,
-                                                      upload_sink_user_data)
+        future_result = self.__thread_executor.submit(
+            self.__post_file_task, file_info, upload_file_sink, upload_sink_user_data
+        )
         return H2FileTask(id, file_info, future_result)
 
-    def upload_file_sync(self, local_filename, remote_filename=None, over_write=True, timeout=None,
-                         upload_file_sink=None, upload_sink_user_data=None):
+    def upload_file_sync(
+        self,
+        local_filename,
+        remote_filename=None,
+        over_write=True,
+        timeout=None,
+        upload_file_sink=None,
+        upload_sink_user_data=None,
+    ):
         self.__check_file(local_filename)
-        f = self.upload_file_async(local_filename, remote_filename, over_write,
-                                   upload_file_sink, upload_sink_user_data)
+        f = self.upload_file_async(local_filename, remote_filename, over_write, upload_file_sink, upload_sink_user_data)
         return f.result(timeout)
 
     def __create_stream_id(self):
@@ -378,12 +390,12 @@ class H2Client:
         return self.__to_unsign(value1) == self.__to_unsign(value2)
 
     def __to_unsign(self, value):
-        return value if value > 0 else (0xffffffffffffffff + 1 + value)
+        return value if value > 0 else (0xFFFFFFFFFFFFFFFF + 1 + value)
 
     def __check_file(self, path):
         stat_info = os.stat(path)
-        if (stat_info.st_size >= _H2_MAX_FILE_SIZE):
-            raise ValueError('maximum file size exceeded')
+        if stat_info.st_size >= _H2_MAX_FILE_SIZE:
+            raise ValueError("maximum file size exceeded")
 
     def __post_file_task(self, file_info, sink=None, user_data=None):
         local_filename = file_info.local_filename
@@ -398,66 +410,83 @@ class H2Client:
         stream = self.new_stream()
         self.__on_new_stream(stream)
         try:
-            logging.info('start to post file, local_filename:%s, remote:%s, over_write:%d' % (
-            local_filename, remote_filename, over_write))
+            logging.info(
+                "start to post file, local_filename:%s, remote:%s, over_write:%d"
+                % (local_filename, remote_filename, over_write)
+            )
 
             # callback
             if sink:
                 sink.on_file_upload_start(stream.get_id(), file_info, user_data)
 
             # open stream
-            header = {'x-file-name': remote_filename, 'x-file-overwrite': '1' if over_write else '0'}
-            response = stream.open('/c/iot/sys/thing/file/upload', header)
-            x_file_upload_id = response.headers['x-file-upload-id'][0]
+            header = {"x-file-name": remote_filename, "x-file-overwrite": "1" if over_write else "0"}
+            response = stream.open("/c/iot/sys/thing/file/upload", header)
+            x_file_upload_id = response.headers["x-file-upload-id"][0]
 
             # send stream
-            header = {'x-file-upload-id': x_file_upload_id}
+            header = {"x-file-upload-id": x_file_upload_id}
             fs = FileStreamHandler(local_filename, opt_crc64=True)
             stream.send(header, fs)
 
             # close stream
             response = stream.close(header)
-            remote_crc64 = int(response.headers['x-file-crc64ecma'][0])
-            logging.info('crc64, local:%ld, remote:%ld' % (fs.get_crc64(), remote_crc64))
+            remote_crc64 = int(response.headers["x-file-crc64ecma"][0])
+            logging.info("crc64, local:%ld, remote:%ld" % (fs.get_crc64(), remote_crc64))
             if not self.__crc_equal(fs.get_crc64(), remote_crc64):
-                raise Exception('fail to check crc64, local:%ld, remote:%ld' % (fs.get_crc64(), remote_crc64))
-            file_store_id = response.headers['x-file-store-id'][0]
-            logging.info('finish uploading file, local_filename:%s, remote:%s, over_write:%d, file_store_id:%s'
-                         % (local_filename, remote_filename, over_write, file_store_id))
-
-            return UploadFileResult(code, exception, fs.get_read_size(), fs.get_content_length,
-                                    file_store_id)
+                raise Exception("fail to check crc64, local:%ld, remote:%ld" % (fs.get_crc64(), remote_crc64))
+            file_store_id = response.headers["x-file-store-id"][0]
+            logging.info(
+                "finish uploading file, local_filename:%s, remote:%s, over_write:%d, file_store_id:%s"
+                % (local_filename, remote_filename, over_write, file_store_id)
+            )
+
+            return UploadFileResult(code, exception, fs.get_read_size(), fs.get_content_length, file_store_id)
         except H2Exception as e:
             logging.error(
                 "fail to upload the file, local_filename:%s, remote:%s, over_write:%d, x_file_upload_id:%s, stream:%s, code:%s, error:%s"
-                % (local_filename, remote_filename, over_write, x_file_upload_id, stream, e.get_code(), e))
-            return UploadFileResult(e.get_code(), exception,
-                                    (fs.get_read_size() if fs else -1),
-                                    (fs.get_content_length() if fs else -1), file_store_id)
+                % (local_filename, remote_filename, over_write, x_file_upload_id, stream, e.get_code(), e)
+            )
+            return UploadFileResult(
+                e.get_code(),
+                exception,
+                (fs.get_read_size() if fs else -1),
+                (fs.get_content_length() if fs else -1),
+                file_store_id,
+            )
         except Exception as e:
             logging.error(
                 "fail to upload the file, local_filename:%s, remote:%s, over_write:%d, x_file_upload_id:%s, stream:%s, error:%s"
-                % (local_filename, remote_filename, over_write, x_file_upload_id, stream, e))
-            return UploadFileResult(-1, exception,
-                                    (fs.get_read_size() if fs else -1),
-                                    (fs.get_content_length() if fs else -1), file_store_id)
+                % (local_filename, remote_filename, over_write, x_file_upload_id, stream, e)
+            )
+            return UploadFileResult(
+                -1,
+                exception,
+                (fs.get_read_size() if fs else -1),
+                (fs.get_content_length() if fs else -1),
+                file_store_id,
+            )
             # raise e
         finally:
             self.__on_free_stream(stream)
             if sink:
-                result = UploadFileResult(code, exception,
-                                          (fs.get_read_size() if fs else -1),
-                                          (fs.get_content_length() if fs else -1), file_store_id)
+                result = UploadFileResult(
+                    code,
+                    exception,
+                    (fs.get_read_size() if fs else -1),
+                    (fs.get_content_length() if fs else -1),
+                    file_store_id,
+                )
                 sink.on_file_upload_end(stream.get_id(), file_info, result, user_data)
 
-    def __connect(self):
+    def __connect(self) -> int:
         with self.__conn_lock:
             ctx = ssl.SSLContext(ssl.PROTOCOL_TLS)
             h2_endpoint = self.__generate_endpoint()
-            logging.debug('http/2 endpoint:%s' % (h2_endpoint))
-            self.__conn = hyper.HTTP20Connection(h2_endpoint, port=self.__port,
-                                                 force_proto=hyper.tls.NPN_PROTOCOL,
-                                                 ssl_context=ctx)
+            logging.debug("http/2 endpoint:%s" % (h2_endpoint))
+            self.__conn = hyper.HTTP20Connection(
+                h2_endpoint, port=self.__port, force_proto=hyper.tls.NPN_PROTOCOL, ssl_context=ctx
+            )
             return 0
 
     def get_connect(self):
@@ -469,22 +498,30 @@ class H2Client:
     def __fill_auth_header(self, header):
         client_id = self.__client_id or self.__device_name
         timestamp = str(int(time.time() * 1000))
-        sign_content = "clientId" + client_id + "deviceName" + self.__device_name + "productKey" + self.__product_key \
-                       + "timestamp" + timestamp
+        sign_content = (
+            "clientId"
+            + client_id
+            + "deviceName"
+            + self.__device_name
+            + "productKey"
+            + self.__product_key
+            + "timestamp"
+            + timestamp
+        )
         sign = hmac.new(self.__device_secret.encode("utf-8"), sign_content.encode("utf-8"), hashlib.sha256).hexdigest()
-        header['x-auth-param-timestamp'] = timestamp
-        header['x-auth-param-signmethod'] = 'hmacsha256'
-        header['x-auth-param-sign'] = sign
-        header['x-auth-param-product-key'] = self.__product_key
-        header['x-auth-param-device-name'] = self.__device_name
-        header['x-auth-param-client-id'] = client_id
-        header['x-auth-name'] = 'devicename'
+        header["x-auth-param-timestamp"] = timestamp
+        header["x-auth-param-signmethod"] = "hmacsha256"
+        header["x-auth-param-sign"] = sign
+        header["x-auth-param-product-key"] = self.__product_key
+        header["x-auth-param-device-name"] = self.__device_name
+        header["x-auth-param-client-id"] = client_id
+        header["x-auth-name"] = "devicename"
         return header
 
     def __fill_sdk_header(self, header):
-        header['x-sdk-version'] = '1.2.0'
-        header['x-sdk-version-name'] = '1.2.0'
-        header['x-sdk-platform'] = 'python'
+        header["x-sdk-version"] = "1.2.0"
+        header["x-sdk-version-name"] = "1.2.0"
+        header["x-sdk-platform"] = "python"
         return header
 
     def get_default_header(self):
@@ -493,54 +530,53 @@ class H2Client:
         self.__fill_sdk_header(header)
         return header
 
-    def __close_connect(self):
+    def __close_connect(self) -> int:
         with self.__conn_lock:
             if self.__conn:
                 self.__conn.close(0)
             return 0
 
-    def __close_all_streams(self):
+    def __close_all_streams(self) -> None:
         with self.__stream_list_lock:
             self.__stream_list.clear()
             self.__stream_list = None
         self.__stop_heart_beat()
 
-    def __on_new_stream(self, stream):
+    def __on_new_stream(self, stream) -> None:
         with self.__stream_list_lock:
             self.__stream_list.append(stream)
 
             if len(self.__stream_list) == 1:
                 self.__start_heart_beat()
 
-    def __on_free_stream(self, stream):
+    def __on_free_stream(self, stream) -> None:
         with self.__stream_list_lock:
             self.__stream_list.remove(stream)
 
             if len(self.__stream_list) == 0:
                 self.__stop_heart_beat()
 
-    def __start_heart_beat(self):
-        logging.debug('start heart_beat')
+    def __start_heart_beat(self) -> None:
+        logging.debug("start heart_beat")
         self.__schedule_heart_beat()
 
-    def __handle_heart_beat(self):
-        logging.debug('heart...')
-        self.__conn.ping(b'PINGPONG')
+    def __handle_heart_beat(self) -> None:
+        logging.debug("heart...")
+        self.__conn.ping(b"PINGPONG")
         self.__schedule_heart_beat()
 
-    def __stop_heart_beat(self):
-        logging.debug('stop heart')
+    def __stop_heart_beat(self) -> None:
+        logging.debug("stop heart")
         self.__cancel_heart_beat()
 
-    def __schedule_heart_beat(self):
+    def __schedule_heart_beat(self) -> None:
         with self.__heart_beat_lock:
             if self.__opt_heart_beat_time and self.__opt_heart_beat_time > 0:
                 self.__timer = threading.Timer(self.__opt_heart_beat_time, self.__handle_heart_beat)
                 self.__timer.start()
 
-    def __cancel_heart_beat(self):
+    def __cancel_heart_beat(self) -> None:
         with self.__heart_beat_lock:
             if self.__timer:
                 self.__timer.cancel()
                 self.__timer = None
-