micrOSDevToolKit 2.9.4__py3-none-any.whl → 2.9.7__py3-none-any.whl

micrOS/source/LM_telegram.py

@@ -1,5 +1,4 @@
 from sys import modules
-import uasyncio as asyncio
 import urequests
 from Notify import Notify
 from Config import cfgget
@@ -15,6 +14,10 @@ class Telegram(Notify):
     _API_PARAMS = "?offset=-1&limit=1&timeout=2"  # Generic API params - optimization
     _IN_MSG_ID = None
 
+    def __init__(self):
+        # Subscribe to the notification system - provide send_msg method (over self)
+        super().add_subscriber(self)
+
     @staticmethod
     def __id_cache(mode):
         """
@@ -97,36 +100,60 @@ class Telegram(Notify):
             verdict = f'Sent{chat_id}' if resp_json['ok'] else str(resp_json)
         return verdict
 
+    @staticmethod
+    def __update_chat_ids(resp_json):
+        """
+        Update known chat_id-s and cache them
+        - return active chat_id frm resp_json
+        """
+        console_write("[NTFY GET] update chatIDs")
+        _cid = None
+        if resp_json.get("ok", None) and len(resp_json["result"]) > 0:
+            _cid = resp_json["result"][-1]["message"]["chat"]["id"]
+            # LIMIT Telegram._CHAT_IDS NOTIFICATION CACHE TO 3 IDs
+            if len(Telegram._CHAT_IDS) < 4:
+                _ids = len(Telegram._CHAT_IDS)
+                Telegram._CHAT_IDS.add(_cid)
+                if len(Telegram._CHAT_IDS) - _ids > 0:  # optimized save (slow storage access)
+                    Telegram.__id_cache('s')
+        else:
+            Telegram.__id_cache('r')
+            if len(Telegram._CHAT_IDS) == 0:
+                error_message = resp_json.get("description", "Unknown error")
+                raise Exception(f"Error retrieving chat ID: {error_message}")
+        return _cid
+
     @staticmethod
     def get_msg():
         """
         Get the last message from the Telegram chat.
         RETURN None when telegram bot token is missing
         """
+        console_write("[NTFY] GET MESSAGE")
+        bot_token = Telegram.__bot_token()
+        if bot_token is None:
+            return None
+        response = {'sender': None, 'text': None, 'm_id': -1, 'c_id': None}
+        url = f"https://api.telegram.org/bot{bot_token}/getUpdates{Telegram._API_PARAMS}"
+        console_write(f"\t1/2[GET] request: {url}")
 
-        def _update_chat_ids():
-            """
-            Update known chat_id-s and cache them
-            - return active chat_id frm resp_json
-            """
-            console_write("[NTFY GET] update chatIDs")
-            _cid = None
-            if resp_json.get("ok", None) and len(resp_json["result"]) > 0:
-                _cid = resp_json["result"][-1]["message"]["chat"]["id"]
-                # LIMIT Telegram._CHAT_IDS NOTIFICATION CACHE TO 3 IDs
-                if len(Telegram._CHAT_IDS) < 4:
-                    _ids = len(Telegram._CHAT_IDS)
-                    Telegram._CHAT_IDS.add(_cid)
-                    if len(Telegram._CHAT_IDS) - _ids > 0:  # optimized save (slow storage access)
-                        Telegram.__id_cache('s')
-            else:
-                Telegram.__id_cache('r')
-                if len(Telegram._CHAT_IDS) == 0:
-                    error_message = resp_json.get("description", "Unknown error")
-                    raise Exception(f"Error retrieving chat ID: {error_message}")
-            return _cid
+        _, resp_json = urequests.get(url, jsonify=True, sock_size=128)
 
-        # --------------------- FUNCTION MAIN ------------------------ #
+        if len(resp_json["result"]) > 0:
+            response['c_id'] = Telegram.__update_chat_ids(resp_json)
+            resp = resp_json["result"][-1]["message"]
+            response['sender'] = f"{resp['chat']['first_name']}{resp['chat']['last_name']}" if resp['chat'].get(
+                'username', None) is None else resp['chat']['username']
+            response['text'], response['m_id'] = resp['text'], resp['message_id']
+        console_write(f"\t2/2[GET] response: {response}")
+        return response
+
+    @staticmethod
+    async def aget_msg():
+        """
+        Async: Get the last message from the Telegram chat.
+        RETURN None when telegram bot token is missing
+        """
         console_write("[NTFY] GET MESSAGE")
         bot_token = Telegram.__bot_token()
         if bot_token is None:
@@ -134,9 +161,11 @@ class Telegram(Notify):
         response = {'sender': None, 'text': None, 'm_id': -1, 'c_id': None}
         url = f"https://api.telegram.org/bot{bot_token}/getUpdates{Telegram._API_PARAMS}"
         console_write(f"\t1/2[GET] request: {url}")
-        _, resp_json = urequests.get(url, jsonify=True, sock_size=128)
+
+        _, resp_json = await urequests.aget(url, jsonify=True, sock_size=128)
+
         if len(resp_json["result"]) > 0:
-            response['c_id'] = _update_chat_ids()
+            response['c_id'] = Telegram.__update_chat_ids(resp_json)
             resp = resp_json["result"][-1]["message"]
             response['sender'] = f"{resp['chat']['first_name']}{resp['chat']['last_name']}" if resp['chat'].get(
                 'username', None) is None else resp['chat']['username']
@@ -145,16 +174,13 @@ class Telegram(Notify):
         return response
 
     @staticmethod
-    def receive_eval():
+    async def receive_eval():
         """
         READ - VALIDATE - EXECUTE - REPLY LOOP
         - can be used in async loop
         RETURN None when telegram bot token is missing
         """
-
-        console_write("[NTFY] REC&EVAL sequence")
-
-        # Return data structure template
+        console_write("[NTFY] EVAL sequence")
         verdict = None
 
         def lm_execute(cmd_args):
@@ -168,8 +194,8 @@ class Telegram(Notify):
                 Telegram._IN_MSG_ID = m_id
 
         # -------------------------- FUNCTION MAIN -------------------------- #
-        # Poll telegram chat
-        data = Telegram.get_msg()
+        # Async Poll telegram chat
+        data = await Telegram.aget_msg()
         if data is None:
             return data
         # Get msg, msg_id, chat_id as main input data source
@@ -197,12 +223,42 @@ class Telegram(Notify):
                     verdict = Telegram.notifications(not param[0].strip().lower() in ("disable", "off", 'false'))
                 else:
                     verdict = Telegram.notifications()
+                # Send is still synchronous (OK)
                 Telegram.send_msg(verdict, reply_to=m_id)
         else:
             verdict = "[UP] NoExec"
-        console_write(f"\tREC&EVAL: {verdict}")
+        console_write(f"\tBOT: {verdict}")
         return verdict
 
+    @staticmethod
+    async def bot_repl(tag, period=3):
+        """
+        BOT - ReceiveEvalPrintLoop
+        :param tag: task tag (access)
+        :param period: polling period in sec, default: 3
+        """
+        cancel_cnt = 0
+        period = period if period > 0 else 1
+        period_ms = period * 1000
+        with micro_task(tag=tag) as my_task:
+            my_task.out = "[UP] Running"
+            while True:
+                # Normal task period
+                await my_task.feed(sleep_ms=period_ms)
+                try:
+                    v = await Telegram.receive_eval()
+                    my_task.out = "Missing bot token" if v is None else f"{v} ({period}s)"
+                    cancel_cnt = 0
+                except Exception as e:
+                    my_task.out = str(e)
+                    # Auto scale - blocking nature - in case of serial failures (5) - hibernate task (increase async sleep)
+                    cancel_cnt += 1
+                    if cancel_cnt > 5:
+                        my_task.out = f"[DOWN] {e} (wait 1min)"
+                        cancel_cnt = 5
+                        # SLOW DOWN - hibernate task
+                        await my_task.feed(sleep_ms=60_000)
+
     @staticmethod
     def set_commands():
         """
@@ -237,7 +293,6 @@ def __init():
         _sta_available = True if ifconfig()[0] == "STA" else False
         if _sta_available:
             TELEGRAM_OBJ = Telegram()
-            Notify.add_subscriber(TELEGRAM_OBJ)
         else:
             syslog("No STA: cannot init telegram")
 
@@ -292,37 +347,16 @@ def receive():
     return "Missing telegram bot token" if verdict is None else verdict
 
 
-async def __task():
-    cancel_cnt = 0
-    with micro_task(tag='telegram._loop') as my_task:
-        my_task.out = "[UP] Running"
-        while True:
-            # Normal task period
-            await asyncio.sleep(5)
-            try:
-                v = TELEGRAM_OBJ.receive_eval()
-                my_task.out = "Missing bot token" if v is None else v
-                cancel_cnt = 0
-            except Exception as e:
-                my_task.out = str(e)
-                # Auto scale - blocking nature - in case of serial failures (5) - hibernate task (increase async sleep)
-                cancel_cnt += 1
-                if cancel_cnt > 5:
-                    my_task.out = f"[DOWN] {e}"
-                    cancel_cnt = 5
-                    # SLOW DOWN - hibernate task
-                    asyncio.sleep(115)
-
-
-def receiver_loop():
+def receiver_loop(period=3):
     """
-    Telegram msg receiver loop - automatic LM execution
+    Telegram BOT (repl) - ReadEvalPrintLoop for Load Modules
     - Only executes module (function) if the module is already loaded
-    on the endpoint / micrOS node
+    :param period: polling period in sec, default: 3
     """
     if TELEGRAM_OBJ is None:
         return "Network unavailable."
-    state = micro_task(tag='telegram._loop', task=__task())
+    tag = 'telegram.bot_repl'
+    state = micro_task(tag=tag, task=TELEGRAM_OBJ.bot_repl(tag=tag, period=period))
     return "Starting" if state else "Already running"
 
 
@@ -335,6 +369,6 @@ def help(widgets=False):
     """
     return ('send "text"',
             'receive',
-            'receiver_loop',
+            'receiver_loop period=3',
             'notify "message"',
             'load', 'INFO: Send & Receive messages with Telegram bot')

micrOS/source/Logger.py

@@ -5,12 +5,34 @@ Module is responsible for System and User logging
 Designed by Marcell Ban aka BxNxM
 """
 from time import localtime
-from os import listdir, remove
 from re import match
+from uos import listdir, remove, stat, mkdir, getcwd
 
 #############################################
 #        LOGGING WITH DATA ROTATION         #
 #############################################
+LOG_FOLDER = None
+
+def _init_logger():
+    """ Init /logs folder """
+    global LOG_FOLDER
+    if LOG_FOLDER is None:
+        LOG_FOLDER = f"{getcwd()}logs"
+        do_create = True
+        try:
+            if stat(LOG_FOLDER)[0] & 0x4000:
+                # Dir exists - skip create
+                do_create = False
+        except:
+            pass
+        if do_create:
+            try:
+                mkdir(LOG_FOLDER)
+                syslog(f"[BOOT] log dir {LOG_FOLDER} init")
+            except Exception as e:
+                LOG_FOLDER = getcwd()
+                syslog(f"[BOOT] log dir {LOG_FOLDER} fallback: {e}")
+    return LOG_FOLDER
 
 
 def logger(data, f_name, limit):
@@ -24,14 +46,15 @@ def logger(data, f_name, limit):
     return write verdict - true / false
     INFO: hardcoded max data number = 30
     """
-    def _logger(_data, _f_name, _limit, f_mode='r+'):
-        _limit = 30 if _limit > 30 else _limit
+    def _logger(f_mode='r+'):
+        nonlocal data, f_name, limit
+        limit = min(limit, 30)  # Hardcoded max data line = 30
         # [1] GET TIME STUMP
         ts_buff = [str(k) for k in localtime()]
         ts = ".".join(ts_buff[0:3]) + "-" + ":".join(ts_buff[3:6])
         # [2] OPEN FILE - WRITE DATA WITH TS
-        with open(_f_name, f_mode) as f:
-            _data = f"{ts} {_data}\n"
+        with open(f_name, f_mode) as f:
+            _data = f"{ts} {data}\n"
             # read file lines and filter by time stump chunks (hack for replace truncate)
             lines = [_l for _l in f.readlines() if '-' in _l and '.' in _l]
             # get file params
@@ -39,22 +62,20 @@ def logger(data, f_name, limit):
             lines.append(_data)
             f.seek(0)
             # line data rotate
-            if lines_len >= _limit:
-                lines = lines[-_limit:]
-                lines_str = ''.join(lines)
-            else:
-                lines_str = ''.join(lines)
+            if lines_len >= limit:
+                lines = lines[-limit:]
             # write file
-            f.write(lines_str)
+            f.write(''.join(lines))
 
+    f_name = f"{LOG_FOLDER}/{f_name}"
     # Run logger
     try:
         # There is file - append 'r+'
-        _logger(data, f_name, limit)
+        _logger()
     except:
         try:
             # There is no file - create 'a+'
-            _logger(data, f_name, limit, 'a+')
+            _logger('a+')
         except:
             return False
     return True
@@ -65,6 +86,7 @@ def log_get(f_name, msgobj=None):
     Get and stream (ver osocket/stdout) .log file's content and count "critical" errors
     - critical error tag in log line: [ERR]
     """
+    f_name = f"{LOG_FOLDER}/{f_name}"
     err_cnt = 0
     try:
         if msgobj is not None:
@@ -85,7 +107,7 @@ def log_get(f_name, msgobj=None):
 
 def syslog(data=None, msgobj=None):
     if data is None:
-        err_cnt = sum([log_get(f, msgobj) for f in listdir() if f.endswith(".sys.log")])
+        err_cnt = sum([log_get(f, msgobj) for f in listdir(LOG_FOLDER) if f.endswith(".sys.log")])
         return err_cnt
 
     _match = match(r"^\[([^\[\]]+)\]", data)
@@ -95,8 +117,12 @@ def syslog(data=None, msgobj=None):
 
 
 def log_clean(msgobj=None):
-    to_del = [file for file in listdir() if file.endswith('.log')]
+    to_del = [file for file in listdir(LOG_FOLDER) if file.endswith('.log')]
     for _del in to_del:
+        _del = f"{LOG_FOLDER}/{_del}"
         if msgobj is not None:
             msgobj(f" Delete: {_del}")
         remove(_del)
+
+# Init log folder at module load
+_init_logger()

micrOS/source/Notify.py

@@ -35,16 +35,17 @@ class Notify:
     @staticmethod
     def message(text, reply_to=None, chat_id=None):
         """
-        Send message to all subscribers
+        Send message to all subscribers - Notify agents
         """
         exit_code = 0
         for s in Notify._SUBSCRIBERS:
             try:
+                # !!! SUBSCRIBER HAS TO DEFINE send_msg(text, reply_to, chat_id) method !!!
                 s.send_msg(text, reply_to, chat_id)
             except Exception as e:
                 errlog_add(f"[ERR] Notify: {e}")
                 exit_code+=1
-        return f"Sent N{len(Notify._SUBSCRIBERS)} ({exit_code})"
+        return f"Sent for {len(Notify._SUBSCRIBERS)} client(s), errors: ({exit_code})"
 
     @staticmethod
     def notifications(state=None):
@@ -66,7 +67,7 @@ class Notify:
 
     @staticmethod
     def lm_execute(cmd_args):
-        """Executor with basic access handling"""
+        """Load Module Executor with basic access handling"""
         if lm_is_loaded(cmd_args[0]):
             try:
                 _, out = lm_exec(cmd_args)

micrOS/source/Server.py

@@ -182,7 +182,7 @@ class WebCli(Client, WebEngine):
             if cfgput('webui', True):  # SET webui to True
                 from machine import reset
                 reset()  # HARD RESET (REBOOT)
-        WebEngine.REST_ENDPOINTS[endpoint] = callback
+        WebEngine.ENDPOINTS[endpoint] = callback
 
 
 class ShellCli(Client, Shell):
@@ -413,4 +413,7 @@ class Server:
 
     def __del__(self):
         Client.console("[ socket server ] <<destructor>>")
-        self.server.close()
+        if self.server:
+            self.server.close()
+        if self.web:
+            self.web.close()

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.4-0'
+    MICROS_VERSION = '2.9.7-0'
 
     def __init__(self):
         """

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.4.data → micrOSDevToolKit-2.9.7.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.4.dist-info → micrOSDevToolKit-2.9.7.dist-info}/METADATA

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