micropython code extracted into separate library blynklib_mp.py

Author: amorozenko

README.md

@@ -60,7 +60,7 @@ pip install --user -e .
 ``` 
 
 #### Testing
-You can run unit tests for cPython version of library (blynklib_cp.py) using the command:
+You can run unit tests for cPython version of library (blynklib.py) using the command:
 
     python setup.py test
 
@@ -73,14 +73,14 @@ and related installation docs can be found [here][micropython-pkg].
 
 
 ## Features
-This library supports Python2, Python3, and Micropython.
+This library supports Python2, Python3 (blynklib.py) , and Micropython (blynklib_mp.py).
 
 - Communication with public or local [Blynk Server][blynk-server].
 - Exchange any data between your hardware and app
 - Tested to work with: Raspberry Pi (any), ESP32, ESP8266
 
 ##### List of available operations:
- - Subscribe to connect/disconnect events (ssl connection available only for cPython lib)
+ - Subscribe to connect/disconnect events (ssl connection supported only by cPython lib)
  - Subscribe to read/write events of [virtual pins][blynk-vpins]
  - [Virtual Pin][blynk-vpins] write
  - [Virtual Pin][blynk-vpins] sync
@@ -108,6 +108,7 @@ BLYNK_AUTH = '<YourAuthToken>' #insert your Auth Token here
 #### Usage example
 ```python
 import blynklib
+# import blynklib_mp as blynklib # micropython import
 
 BLYNK_AUTH = '<YourAuthToken>' #insert your Auth Token here
 # base lib init
@@ -122,6 +123,7 @@ blynk = blynklib.Blynk(BLYNK_AUTH)
 # blynk = blynklib.Blynk(BLYNK_AUTH, port=443, ssl_cert='<path to local blynk server certificate>')
 # current blynk-cloud.com certificate stored in project as 
 # https://github.com/blynkkk/lib-python/blob/master/certificate/blynk-cloud.com.crt
+# Note! ssl feature supported only by cPython
 
 # register handler for Virtual Pin V22 reading by Blynk App.
 # when a widget in Blynk App asks Virtual Pin data from server within given configurable interval (1,2,5,10 sec etc) 
@@ -168,7 +170,7 @@ Examples can be found **[here][blynk-py-examples]** Check them all to get famili
 - [08_blynk_timer.py](https://github.com/blynkkk/lib-python/blob/master/examples/08_blynk_timer.py): How send data periodically from hardware by using **[Blynk Timer][blynktimer-doc]**
 - [09_sync_virtual_pin.py](https://github.com/blynkkk/lib-python/blob/master/examples/09_sync_virtual_pin.py): How to sync virtual pin states and properties
 - [10_rtc_sync.py](https://github.com/blynkkk/lib-python/blob/master/examples/10_rtc_sync.py): How to perform RTC sync with blynk server 
-- [11_ssl_socket.py](https://github.com/blynkkk/lib-python/blob/master/examples/11_ssl_socket.py): SSL server connection. Feature available only fo cPython. 
+- [11_ssl_socket.py](https://github.com/blynkkk/lib-python/blob/master/examples/11_ssl_socket.py): SSL server connection. Feature supported only by cPython library. 
 
 ##### Raspberry Pi (any):
 Read [Raspberry Pi guide](https://github.com/blynkkk/lib-python/tree/master/examples/raspberry) first.

blynklib.py

@@ -2,28 +2,12 @@
 # Copyright (c) 2015-2019 Volodymyr Shymanskyy.
 # See the file LICENSE for copying permission.
 
-__version__ = '0.2.5'
+__version__ = '0.2.6'
 
-try:
-    import usocket as socket
-    import utime as time
-    import ustruct as struct
-    import uselect as select
-    from micropython import const
-
-    ticks_ms = time.ticks_ms
-    sleep_ms = time.sleep_ms
-
-    IOError = OSError
-except ImportError:
-    import socket
-    import time
-    import struct
-    import select
-
-    const = lambda x: x
-    ticks_ms = lambda: int(time.time() * 1000)
-    sleep_ms = lambda x: time.sleep(x // 1000)
+import socket
+import ssl
+import struct
+import time
 
 LOGO = """
         ___  __          __
@@ -37,6 +21,14 @@ def stub_log(*args):
     pass
 
 
+def ticks_ms():
+    return int(time.time() * 1000)
+
+
+def sleep_ms(ms):
+    time.sleep(ms // 1000)
+
+
 class BlynkError(Exception):
     pass
 
@@ -48,32 +40,32 @@ def __init__(self, server, port):
 
 
 class Protocol(object):
-    MSG_RSP = const(0)
-    MSG_LOGIN = const(2)
-    MSG_PING = const(6)
-    MSG_TWEET = const(12)
-    MSG_EMAIL = const(13)
-    MSG_NOTIFY = const(14)
-    MSG_BRIDGE = const(15)
-    MSG_HW_SYNC = const(16)
-    MSG_INTERNAL = const(17)
-    MSG_PROPERTY = const(19)
-    MSG_HW = const(20)
-    MSG_REDIRECT = const(41)
-    MSG_HEAD_LEN = const(5)
-
-    STATUS_INVALID_TOKEN = const(9)
-    STATUS_NO_DATA = const(17)
-    STATUS_OK = const(200)
-    VPIN_MAX_NUM = const(32)
-
-    _msg_id = 1
+    MSG_RSP = 0
+    MSG_LOGIN = 2
+    MSG_PING = 6
+    MSG_TWEET = 12
+    MSG_EMAIL = 13
+    MSG_NOTIFY = 14
+    MSG_BRIDGE = 15
+    MSG_HW_SYNC = 16
+    MSG_INTERNAL = 17
+    MSG_PROPERTY = 19
+    MSG_HW = 20
+    MSG_REDIRECT = 41
+    MSG_HEAD_LEN = 5
+
+    STATUS_INVALID_TOKEN = 9
+    STATUS_NO_DATA = 17
+    STATUS_OK = 200
+    VPIN_MAX_NUM = 32
+
+    _msg_id = 0
 
     def _get_msg_id(self, **kwargs):
         if 'msg_id' in kwargs:
             return kwargs['msg_id']
         self._msg_id += 1
-        return self._msg_id if self._msg_id <= 0xFFFF else 1
+        return self._msg_id if self._msg_id <= 0xFFFF else 0
 
     def _pack_msg(self, msg_type, *args, **kwargs):
         data = ('\0'.join([str(curr_arg) for curr_arg in args])).encode('utf-8')
@@ -134,40 +126,35 @@ def internal_msg(self, *args):
 
 
 class Connection(Protocol):
-    SOCK_MAX_TIMEOUT = const(5)
+    SOCK_MAX_TIMEOUT = 5
     SOCK_TIMEOUT = 0.05
-    EAGAIN = const(11)
-    ETIMEDOUT = const(60)
-    RETRIES_TX_DELAY = const(2)
-    RETRIES_TX_MAX_NUM = const(3)
-    RECONNECT_SLEEP = const(1)
-    TASK_PERIOD_RES = const(50)
-    DISCONNECTED = const(0)
-    CONNECTING = const(1)
-    AUTHENTICATING = const(2)
-    AUTHENTICATED = const(3)
+    SOCK_SSL_TIMEOUT = 1
+    EAGAIN = 11
+    ETIMEDOUT = 60
+    RETRIES_TX_DELAY = 2
+    RETRIES_TX_MAX_NUM = 3
+    RECONNECT_SLEEP = 1
+    TASK_PERIOD_RES = 50
+    DISCONNECTED = 0
+    CONNECTING = 1
+    AUTHENTICATING = 2
+    AUTHENTICATED = 3
 
     _state = None
     _socket = None
     _last_rcv_time = 0
     _last_ping_time = 0
     _last_send_time = 0
 
-    def __init__(self, token, server='blynk-cloud.com', port=80, heartbeat=10, rcv_buffer=1024, log=stub_log):
+    def __init__(self, token, server='blynk-cloud.com', port=80, ssl_cert=None, heartbeat=10, rcv_buffer=1024,
+                 log=stub_log):
         self.token = token
         self.server = server
         self.port = port
         self.heartbeat = heartbeat
         self.rcv_buffer = rcv_buffer
         self.log = log
-
-    def _set_socket_timeout(self, timeout):
-        if getattr(self._socket, 'settimeout', None):
-            self._socket.settimeout(timeout)
-        else:
-            p = select.poll()
-            p.register(self._socket)
-            p.poll(int(timeout * 1000))
+        self.ssl_cert = ssl_cert
 
     def send(self, data):
         retries = self.RETRIES_TX_MAX_NUM
@@ -182,13 +169,13 @@ def send(self, data):
     def receive(self, length, timeout):
         d_buff = b''
         try:
-            self._set_socket_timeout(timeout)
+            self._socket.settimeout(timeout)
             d_buff += self._socket.recv(length)
             if len(d_buff) >= length:
                 d_buff = d_buff[:length]
             return d_buff
         except (IOError, OSError) as err:
-            if str(err) == 'timed out':
+            if 'timed out' in str(err):
                 return b''
             if str(self.EAGAIN) in str(err) or str(self.ETIMEDOUT) in str(err):
                 return b''
@@ -213,7 +200,16 @@ def _get_socket(self):
             self._state = self.CONNECTING
             self._socket = socket.socket()
             self._socket.connect(socket.getaddrinfo(self.server, self.port)[0][4])
-            self._set_socket_timeout(self.SOCK_TIMEOUT)
+            self._socket.settimeout(self.SOCK_TIMEOUT)
+            if self.ssl_cert:
+                # system’s default CA certificates case
+                if self.ssl_cert == "default":
+                    self.ssl_cert = None
+                self.log('Using SSL socket...')
+                ssl_context = ssl.create_default_context(cafile=self.ssl_cert)
+                ssl_context.verify_mode = ssl.CERT_REQUIRED
+                self._socket.settimeout(self.SOCK_SSL_TIMEOUT)
+                self._socket = ssl_context.wrap_socket(sock=self._socket, server_hostname=self.server)
             self.log('Connected to blynk server')
         except Exception as g_exc:
             raise BlynkError('Connection with the Blynk server failed: {}'.format(g_exc))
@@ -250,7 +246,7 @@ def connected(self):
 
 
 class Blynk(Connection):
-    _CONNECT_TIMEOUT = const(30)  # 30sec
+    _CONNECT_TIMEOUT = 30  # 30sec
     _VPIN_WILDCARD = '*'
     _VPIN_READ = 'read v'
     _VPIN_WRITE = 'write v'
@@ -300,6 +296,7 @@ def disconnect(self, err_msg=None):
         self._state = self.DISCONNECTED
         if err_msg:
             self.log('[ERROR]: {}\nConnection closed'.format(err_msg))
+        self._msg_id = 0
         time.sleep(self.RECONNECT_SLEEP)
 
     def virtual_write(self, v_pin, *val):
@@ -351,11 +348,11 @@ def process(self, msg_type, msg_id, msg_len, msg_args):
         elif msg_type == self.MSG_PING:
             self.send(self.response_msg(self.STATUS_OK, msg_id=msg_id))
         elif msg_type in (self.MSG_HW, self.MSG_BRIDGE, self.MSG_INTERNAL):
-            if msg_type == self.MSG_INTERNAL and len(msg_args) >= const(2):
+            if msg_type == self.MSG_INTERNAL and len(msg_args) >= 2:
                 self.call_handler("{}{}".format(self._INTERNAL, msg_args[0]), msg_args[1:])
-            elif len(msg_args) >= const(3) and msg_args[0] == 'vw':
+            elif len(msg_args) >= 3 and msg_args[0] == 'vw':
                 self.call_handler("{}{}".format(self._VPIN_WRITE, msg_args[1]), int(msg_args[1]), msg_args[2:])
-            elif len(msg_args) == const(2) and msg_args[0] == 'vr':
+            elif len(msg_args) == 2 and msg_args[0] == 'vr':
                 self.call_handler("{}{}".format(self._VPIN_READ, msg_args[1]), int(msg_args[1]))
 
     def read_response(self, timeout=0.5):