micrOSDevToolKit 2.9.1__py3-none-any.whl → 2.9.6__py3-none-any.whl

micrOS/source/Shell.py

@@ -11,8 +11,8 @@ Designed by Marcell Ban aka BxNxM
 #################################################################
 #                           IMPORTS                             #
 #################################################################
-from os import listdir
 from sys import modules
+from uos import listdir
 from machine import reset as hard_reset, soft_reset
 from Config import cfgget, cfgput
 from Tasks import lm_exec
@@ -25,7 +25,7 @@ from Debug import errlog_add
 
 class Shell:
     __slots__ = ['__devfid', '__auth_mode', '__hwuid', '__auth_ok', '__conf_mode']
-    MICROS_VERSION = '2.9.1-0'
+    MICROS_VERSION = '2.9.6-0'
 
     def __init__(self):
         """
@@ -45,10 +45,8 @@ class Shell:
         except Exception as e:
             errlog_add(f"[ERR] micrOS version export failed (config): {e}")
 
-    def send(self, msg):
-        """
-        Must be defined by child class...
-        """
+    async def a_send(self, msg):
+        """ Must be defined by parent class... """
         pass
 
     def reset(self):
@@ -56,44 +54,43 @@ class Shell:
         self.__auth_ok = False
         self.__conf_mode = False
 
-    def reboot(self, hard=False):
-        """Reboot micropython VM"""
-        self.send(f"{'[HARD] ' if hard else ''}Reboot micrOS system.")
-        self.send("Bye!")
+    async def reboot(self, hard=False):
+        """ Reboot micropython VM """
+        await self.a_send(f"{'[HARD] ' if hard else ''}Reboot micrOS system.\nBye!")
         if hard:
             hard_reset()
         soft_reset()
 
     def prompt(self):
-        """Generate prompt"""
+        """ Generate prompt """
         auth = "[password] " if self.__auth_mode and not self.__auth_ok else ""
         mode = "[configure] " if self.__conf_mode else ""
         return f"{auth}{mode}{self.__devfid} $ "
 
-    def __auth(self, msg_list):
-        """Authorize user"""
+    async def __auth(self, msg_list):
+        """ Authorize user """
         # Set user auth state
         if self.__auth_mode and not self.__auth_ok:
             # check password
             usrpwd = cfgget('appwd')
             if usrpwd == msg_list[0].strip():
                 self.__auth_ok = True
-                self.send("AuthOk")
+                await self.a_send("AuthOk")
                 return True, []
-            self.send("AuthFailed\nBye!")
+            await self.a_send("AuthFailed\nBye!")
             return False, []
         return True, msg_list
 
-    def shell(self, msg):
+    async def shell(self, msg):
         """
         micrOS Shell main - input string handling
         :param msg: incoming shell command (command or load module call)
         """
-        state = self.__shell(msg)
-        self.send(self.prompt())
+        state = await self.__shell(msg)
+        await self.a_send(self.prompt())
         return state
 
-    def __shell(self, msg):
+    async def __shell(self, msg):
         """
         Socket server - interpreter shell
         :param msg: socket input string
@@ -118,11 +115,11 @@ class Shell:
         # Hello message
         if msg_list[0] == 'hello':
             # For low level device identification - hello msg
-            self.send(f"hello:{self.__devfid}:{self.__hwuid}")
+            await self.a_send(f"hello:{self.__devfid}:{self.__hwuid}")
             return True
 
         # [!] AUTH
-        state, msg_list = self.__auth(msg_list)
+        state, msg_list = await self.__auth(msg_list)
         if not state:
             return False
         if len(msg_list) == 0:
@@ -131,7 +128,7 @@ class Shell:
         # Version handling
         if msg_list[0] == 'version':
             # For micrOS system version info
-            self.send(str(Shell.MICROS_VERSION))
+            await self.a_send(str(Shell.MICROS_VERSION))
             return True
 
         # Reboot micropython VM
@@ -140,12 +137,12 @@ class Shell:
             if len(msg_list) >= 2 and "-h" in msg_list[1]:
                 # reboot / reboot -h
                 hard = True
-            self.reboot(hard)
+            await self.reboot(hard)
 
         if msg_list[0].startswith('webrepl'):
             if len(msg_list) == 2 and '-u' in msg_list[1]:
-                Shell.webrepl(msg_obj=self.send, update=True)
-            Shell.webrepl(msg_obj=self.send)
+                await Shell.webrepl(msg_obj=self.a_send, update=True)
+            return await Shell.webrepl(msg_obj=self.a_send)
 
         # CONFIGURE MODE STATE: ACCESS FOR NODE_CONFIG.JSON
         if msg_list[0].startswith('conf'):
@@ -157,34 +154,34 @@ class Shell:
 
         # HELP MSG
         if msg_list[0] == "help":
-            self.send("[MICROS]   - built-in shell commands")
-            self.send("   hello   - hello msg - for device identification")
-            self.send("   modules - show active Load Modules")
-            self.send("   version - returns micrOS version")
-            self.send("   exit    - exit from shell socket prompt")
-            self.send("   reboot  - system soft reboot (vm), hard reboot (hw): reboot -h")
-            self.send("   webrepl - start webrepl, for file transfers use with --update")
-            self.send("[CONF] Configure mode - built-in shell commands")
-            self.send("  conf       - Enter conf mode")
-            self.send("    dump       - Dump all data")
-            self.send("    key        - Get value")
-            self.send("    key value  - Set value")
-            self.send("  noconf     - Exit conf mode")
-            self.send("[TASK] postfix: &x - one-time,  &&x - periodic, x: wait ms [x min: 20ms]")
-            self.send("  task list         - list tasks with <tag>s")
-            self.send("  task kill <tag>   - stop task")
-            self.send("  task show <tag>   - show task output")
-            self.send("[EXEC] Command mode (LMs):")
-            self.send("   help lm  - list ALL LoadModules")
+            await self.a_send("[MICROS]   - built-in shell commands")
+            await self.a_send("   hello   - hello msg - for device identification")
+            await self.a_send("   modules - show active Load Modules")
+            await self.a_send("   version - returns micrOS version")
+            await self.a_send("   exit    - exit from shell socket prompt")
+            await self.a_send("   reboot  - system soft reboot (vm), hard reboot (hw): reboot -h")
+            await self.a_send("   webrepl - start webrepl, for file transfers use with --update")
+            await self.a_send("[CONF] Configure mode - built-in shell commands")
+            await self.a_send("  conf       - Enter conf mode")
+            await self.a_send("    dump       - Dump all data")
+            await self.a_send("    key        - Get value")
+            await self.a_send("    key value  - Set value")
+            await self.a_send("  noconf     - Exit conf mode")
+            await self.a_send("[TASK] postfix: &x - one-time,  &&x - periodic, x: wait ms [x min: 20ms]")
+            await self.a_send("  task list         - list tasks with <tag>s")
+            await self.a_send("  task kill <tag>   - stop task")
+            await self.a_send("  task show <tag>   - show task output")
+            await self.a_send("[EXEC] Command mode (LMs):")
+            await self.a_send("   help lm  - list ALL LoadModules")
             if "lm" in str(msg_list):
-                return Shell._show_lm_funcs(msg_obj=self.send)
-            return Shell._show_lm_funcs(msg_obj=self.send, active_only=True)
+                return await Shell._show_lm_funcs(msg_obj=self.a_send)
+            return await Shell._show_lm_funcs(msg_obj=self.a_send, active_only=True)
 
         # [2] EXECUTE:
         # @1 Configure mode
         if self.__conf_mode and len(msg_list) > 0:
             # Lock thread under config handling is threads available
-            return Shell._configure(self.send, msg_list)
+            return await Shell._configure(self.a_send, msg_list)
         # @2 Command mode
         """
         INPUT MSG STRUCTURE
@@ -193,43 +190,43 @@ class Shell:
         """
         try:
             # Execute command via InterpreterCore
-            self.send(lm_exec(arg_list=msg_list)[1])
+            await self.a_send(lm_exec(arg_list=msg_list)[1])
             return True
         except Exception as e:
-            self.send(f"[ERROR] shell.lm_exec internal error: {e}")
+            await self.a_send(f"[ERROR] shell.lm_exec internal error: {e}")
             return False
 
     #################################################################
     #                     CONFIGURE MODE HANDLER                    #
     #################################################################
     @staticmethod
-    def _configure(msg_obj, msg_list):
+    async def _configure(msg_obj, msg_list):
         """
         :param msg_obj: shell output stream function reference (write object)
         :param msg_list: socket input param list
         :return: execution status
         """
-        def dump():
+        async def dump():
             nonlocal msg_obj, msg_list
             if msg_list[0] == 'dump':
                 search = msg_list[1] if len(msg_list) == 2 else None
                 # DUMP DATA
                 for _key, value in cfgget().items():
                     if search is None or search in _key:
-                        msg_obj(f"  {_key}{' ' * (10 - len(_key))}:{' ' * 7} {value}")
+                        await msg_obj(f"  {_key}{' ' * (10 - len(_key))}:{' ' * 7} {value}")
                 return True
             return False
 
         # [CONFIG] Get value
         if len(msg_list) == 1:
-            if dump():                      # Simple dump without param filter
+            if await dump():                      # Simple dump without param filter
                 return True
             # GET SINGLE PARAMETER VALUE
-            msg_obj(cfgget(msg_list[0]))
+            await msg_obj(cfgget(msg_list[0]))
             return True
         # [CONFIG] Set value
         if len(msg_list) >= 2:
-            if dump():                      # Dump with search option
+            if await dump():                      # Dump with search option
                 return True
             # Deserialize params
             key = msg_list[0]
@@ -237,28 +234,28 @@ class Shell:
             try:
                 output = cfgput(key, " ".join(msg_list[1:]), type_check=True)
             except Exception as e:
-                msg_obj(f"node_config write error: {e}")
+                await msg_obj(f"node_config write error: {e}")
                 output = False
             # Evaluation and reply
-            msg_obj('Saved' if output else 'Invalid key' if cfgget(key) is None else 'Failed to save')
+            await msg_obj('Saved' if output else 'Invalid key' if cfgget(key) is None else 'Failed to save')
         return True
 
     #################################################################
     #                   COMMAND MODE & LMS HANDLER                  #
     #################################################################
     @staticmethod
-    def _show_lm_funcs(msg_obj, active_only=False):
+    async def _show_lm_funcs(msg_obj, active_only=False):
         """
         Dump LM modules with functions - in case of [py] files
         Dump LM module with help function call - in case of [mpy] files
         """
-        def _help(mod):
+        async def _help(mod):
             for lm_path in (i for i in mod if i.startswith('LM_') and (i.endswith('py'))):
                 lm_name = lm_path.replace('LM_', '').split('.')[0]
                 try:
-                    msg_obj(f"   {lm_name}")
+                    await msg_obj(f"   {lm_name}")
                     if lm_path.endswith('.mpy'):
-                        msg_obj(f"   {' ' * len(lm_path.replace('LM_', '').split('.')[0])}help")
+                        await msg_obj(f"   {' ' * len(lm_path.replace('LM_', '').split('.')[0])}help")
                         continue
                     with open(lm_path, 'r') as f:
                         line = "micrOSisTheBest"
@@ -266,9 +263,9 @@ class Shell:
                             line = f.readline()
                             ldata = line.strip()
                             if ldata.startswith('def ') and not ldata.split()[1].startswith("_") and 'self' not in ldata:
-                                msg_obj(f"   {' ' * len(lm_name)}{ldata.replace('def ', '').split('(')[0]}")
+                                await msg_obj(f"   {' ' * len(lm_name)}{ldata.replace('def ', '').split('(')[0]}")
                 except Exception as e:
-                    msg_obj(f"[{lm_path}] SHOW LM PARSER WARNING: {e}")
+                    await msg_obj(f"[{lm_path}] SHOW LM PARSER WARNING: {e}")
                     return False
             return True
 
@@ -276,29 +273,30 @@ class Shell:
         if active_only:
             mod_keys = modules.keys()
             active_modules = (dir_mod for dir_mod in listdir() if dir_mod.split('.')[0] in mod_keys)
-            return _help(active_modules)
+            return await _help(active_modules)
         # [2] list all LMs on file system (ALL - help lm) - manual
-        return _help(listdir())
+        return await _help(listdir())
 
     @staticmethod
-    def webrepl(msg_obj, update=False):
+    async def webrepl(msg_obj, update=False):
         from Network import ifconfig
 
-        msg_obj(" Start micropython WEBREPL - file transfer and debugging")
-        msg_obj("  [i] restart machine shortcut: import reset")
-        msg_obj(f"  Connect over http://micropython.org/webrepl/#{ifconfig()[1][0]}:8266/")
-        msg_obj(f"  \t[!] webrepl password: {cfgget('appwd')}")
+        await msg_obj(" Start micropython WEBREPL - file transfer and debugging")
+        await msg_obj("  [i] restart machine shortcut: import reset")
+        await msg_obj(f"  Connect over http://micropython.org/webrepl/#{ifconfig()[1][0]}:8266/")
+        await msg_obj(f"  \t[!] webrepl password: {cfgget('appwd')}")
         if update:
-            msg_obj(" Restart node then start webrepl...")
-            msg_obj(" Bye!")
+            await msg_obj(" Restart node then start webrepl...")
+            await msg_obj(" Bye!")
             # Set .if_mode->webrepl (start webrepl after reboot and poll update status...)
             with open('.if_mode', 'w') as f:
                 f.write('webrepl')
             hard_reset()
         try:
             import webrepl
-            msg_obj(webrepl.start(password=cfgget('appwd')))
+            await msg_obj(webrepl.start(password=cfgget('appwd')))
         except Exception as e:
             _err_msg = f"[ERR] while starting webrepl: {e}"
-            msg_obj(_err_msg)
+            await msg_obj(_err_msg)
             errlog_add(_err_msg)
+        return True

micrOS/source/Web.py

@@ -5,7 +5,7 @@ Built-in-function:
 - response
     - landing page: index.html
     - rest/                                         - call load modules, e.x.: system/top
-    - file response (.html, .css, .js, .jped)       - generic file server feature
+    - file response (.html, .css, .js, .jpeg)       - generic file server feature
     - "virtual" endpoints                           - to reply from script on a defined endpoint
         - stream                                    - stream data (jpeg) function
 
@@ -21,7 +21,7 @@ from Config import cfgget
 
 class WebEngine:
     __slots__ = ["client"]
-    REST_ENDPOINTS = {}
+    ENDPOINTS = {}
     AUTH = cfgget('auth')
     VERSION = "n/a"
     REQ200 = "HTTP/1.1 200 OK\r\nContent-Type: {dtype}\r\nContent-Length:{len}\r\n\r\n{data}"
@@ -37,7 +37,8 @@ class WebEngine:
         """File dynamic Content-Type handling"""
         content_types = {".html": "text/html",
                          ".css": "text/css",
-                         ".js": "application/javascript"}
+                         ".js": "application/javascript",
+                         ".jpeg": "image/jpeg"}
         # Extract the file extension
         ext = path.rsplit('.', 1)[-1]
         # Return the content type based on the file extension
@@ -49,7 +50,7 @@ class WebEngine:
         _method, url, _version = request.split('\n')[0].split()
         # Protocol validation
         if _method != "GET" and _version.startswith('HTTP'):
-            _err = "Bad Request: not GET HTTP/1.1"
+            _err = f"Bad Request: not GET HTTP but {_version}"
             await self.client.a_send(self.REQ400.format(len=len(_err), data=_err))
             return
 
@@ -109,46 +110,42 @@ class WebEngine:
             else:
                 state, out = lm_exec(cmd, jsonify=True)
             try:
-                resp_schema['result'] = loads(out)  # Load again ... hack for embedded shell json converter...
+                resp_schema['result'] = loads(out)  # Load again ... hack for embedded json converter...
             except:
                 resp_schema['result'] = out
             resp_schema['state'] = state
         else:
             resp_schema['result'] = {"micrOS": WebEngine.VERSION, 'node': cfgget('devfid'), 'auth': WebEngine.AUTH}
-            if len(tuple(WebEngine.REST_ENDPOINTS.keys())) > 0:
-                resp_schema['result']['usr_endpoints'] = tuple(WebEngine.REST_ENDPOINTS)
+            if len(tuple(WebEngine.ENDPOINTS.keys())) > 0:
+                resp_schema['result']['usr_endpoints'] = tuple(WebEngine.ENDPOINTS)
             resp_schema['state'] = True
         response = dumps(resp_schema)
         return WebEngine.REQ200.format(dtype='text/html', len=len(response), data=response)
 
     async def endpoints(self, url):
         url = url[1:]  # Cut first / char
-        if url in WebEngine.REST_ENDPOINTS:
+        if url in WebEngine.ENDPOINTS:
             console_write(f"[WebCli] endpoint: {url}")
             # Registered endpoint was found - exec callback
             try:
                 # RESOLVE ENDPOINT CALLBACK
                 # dtype:
-                #   one-shot: image/jpeg | text/html | text/plain              - data: raw
-                #       task: multipart/x-mixed-replace | multipart/form-data  - data: dict=callback,content-type
-                #                   content-type: image/jpeg | audio/l16;*
-                dtype, data = WebEngine.REST_ENDPOINTS[url]()
+                #   one-shot (simple MIME types):    image/jpeg | text/html | text/plain              - data: raw
+                #       task (streaming MIME types): multipart/x-mixed-replace | multipart/form-data  - data: dict{callback,content-type}
+                #                                                                                       content-type: image/jpeg | audio/l16;*
+                dtype, data = WebEngine.ENDPOINTS[url]()
                 if dtype == 'image/jpeg':
-                    resp = f"HTTP/1.1 200 OK\r\nContent-Type: {dtype}\r\nContent-Length:{len(data)}\r\n\r\n".encode(
-                        'utf8') + data
+                    resp = f"HTTP/1.1 200 OK\r\nContent-Type: {dtype}\r\nContent-Length:{len(data)}\r\n\r\n".encode('utf8') + data
                     await self.client.a_send(resp, encode=None)
                 elif dtype in ('multipart/x-mixed-replace', 'multipart/form-data'):
-                    headers = (
-                        f"HTTP/1.1 200 OK\r\nContent-Type: {dtype}; boundary=\"micrOS_boundary\"\r\n\r\n").encode(
-                        'utf-8')
-                    await self.client.a_send(headers, encode=None)
+                    headers = f"HTTP/1.1 200 OK\r\nContent-Type: {dtype}; boundary=\"micrOS_boundary\"\r\n\r\n"
+                    await self.client.a_send(headers)
                     # Start Native stream async task
                     task = NativeTask()
-                    task.create(callback=self.stream(data['callback'], task, data['content-type']),
-                                tag=f"web.stream_{self.client.client_id.replace('W', '')}")
+                    tag=f"web.stream_{self.client.client_id.replace('W', '')}"
+                    task.create(callback=self.stream(data['callback'], task, data['content-type']), tag=tag)
                 else:  # dtype: text/html or text/plain
-                    await self.client.a_send(
-                        f"HTTP/1.1 200 OK\r\nContent-Type: {dtype}\r\nContent-Length:{len(data)}\r\n\r\n{data}")
+                    await self.client.a_send(WebEngine.REQ200.format(dtype=dtype, len=len(data), data=data))
             except Exception as e:
                 await self.client.a_send(self.REQ404.format(len=len(str(e)), data=e))
                 errlog_add(f"[ERR] WebCli endpoints {url}: {e}")
@@ -159,6 +156,8 @@ class WebEngine:
         """
         Async stream method
         :param callback: sync or async function callback (auto-detect) WARNING: works for functions only (not methods!)
+        :param task: NativeTask instance (that the stream runs in)
+        :param content_type: image/jpeg | audio/l16;*
         """
         is_coroutine = 'generator' in str(type(callback))  # async function callback auto-detect
         with task:
@@ -175,6 +174,6 @@ class WebEngine:
             # Gracefully terminate the stream
             if self.client.connected:
                 closing_boundary = '\r\n--micrOS_boundary--\r\n'
-                await self.client.a_send(closing_boundary, encode=None)
+                await self.client.a_send(closing_boundary)
                 await self.client.close()
             task.out = 'Finished stream'

micrOS/source/microIO.py

@@ -9,7 +9,7 @@ Designed by Marcell Ban aka BxNxM
 #                           IMPORTS                             #
 #################################################################
 from sys import platform
-from os import listdir
+from uos import listdir, uname
 from Logger import syslog
 
 #################################################################
@@ -29,7 +29,6 @@ def detect_platform():
     Unified platform detection for micrOS
     """
     if 'esp32' in platform:
-        from os import uname
         board = str(uname()[-1]).lower()
         if 'tinypico' in board:
             return 'tinypico'    # esp32 family - tinypico

micrOS/source/reset.py

@@ -1,5 +1,9 @@
-from os import listdir
+"""
+Easy reset for webrepl terminal
+"""
+
 from time import sleep
+from uos import listdir
 from machine import soft_reset, reset
 
 print('Device reboot now, boot micrOSloader...')

micrOS/source/urequests.py

@@ -1,9 +1,16 @@
+"""
+This module implements an optimized version of requests module
+for async and sync http get and post requests.
+
+Designed by Marcell Ban aka BxNxM GitHub
+"""
+
+from json import loads, dumps
 from usocket import socket, getaddrinfo
 try:
-    from ussl import wrap_socket    # Legacy micropython ssl usage
+    from ussl import wrap_socket    # Legacy micropython ssl usage (+simulator mode)
 except ImportError:
     from ssl import wrap_socket     # From micropython 1.23...
-from json import loads, dumps
 from Debug import errlog_add
 import uasyncio as asyncio
 
@@ -39,7 +46,7 @@ def _chunked(_body):
         chunk_size_str = _body[:line_end]
         try:
             chunk_size = int(chunk_size_str, 16)
-        except ValueError as e:
+        except ValueError:
             chunk_size = 0
 
         # Check chunk size
@@ -213,7 +220,8 @@ async def arequest(method, url, data=None, json=None, headers=None, sock_size=25
         status_code, body = _parse_response(response)
     except Exception as e:
         status_code = 500
-        body = f'[ERR] arequest failed: {e}'
+        # https://github.com/micropython/micropython/blob/8785645a952c03315dbf93667b5f7c7eec49762f/cc3200/simplelink/include/device.h
+        body = "[WARN] arequest ASSOC_REJECT" if "-104" == str(e) else f"[ERR] arequest failed: {e}"
         errlog_add(body)
     finally:
         if writer:

{micrOSDevToolKit-2.9.1.data → micrOSDevToolKit-2.9.6.data}/scripts/devToolKit.py

@@ -10,8 +10,9 @@ if len(sys.argv) > 1 and sys.argv[1] in ['light', '--light']:
 else:
     # INSTALL OPTIONAL DEPENDENCIES - PIP HACK
     from toolkit.lib import pip_package_installer as pip_install
-    pip_install.install_optional_dependencies(['PyQt5', 'opencv-python', 'PyAudio', 'mpy-cross==1.20.0', 'matplotlib'])
-
+    pip_install.install_optional_dependencies(['PyQt5', 'opencv-python', 'PyAudio', 'mpy-cross==1.24.1.post2', 'matplotlib'])
+    if sys.platform.startswith("win"):
+        pip_install.install_optional_dependencies(['pyreadline3'])
 
 # NORMAL CODE ...
 MYPATH = os.path.dirname(__file__)

{micrOSDevToolKit-2.9.1.dist-info → micrOSDevToolKit-2.9.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: micrOSDevToolKit
-Version: 2.9.1
+Version: 2.9.6
 Summary: Development and deployment environment for micrOS, the diy micropython automation OS (IoT)
 Home-page: https://github.com/BxNxM/micrOS
 Author: Marcell Ban