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

micrOS/source/LM_telegram.py

@@ -1,7 +1,229 @@
+from sys import modules
 import uasyncio as asyncio
-from Notify import Telegram
-from Common import micro_task, syslog
-from Network import ifconfig
+import urequests
+from Notify import Notify
+from Config import cfgget
+from Common import micro_task, syslog, console_write
+from LM_system import ifconfig
+
+
+class Telegram(Notify):
+    # Telegram bot token and chat ID
+    # https://core.telegram.org/bots/api
+    _TOKEN = None  # Telegram token
+    _CHAT_IDS = set()  # Telegram bot chat IDs - multi group support - persistent caching
+    _API_PARAMS = "?offset=-1&limit=1&timeout=2"  # Generic API params - optimization
+    _IN_MSG_ID = None
+
+    @staticmethod
+    def __id_cache(mode):
+        """
+        pds - persistent data structure
+        modes:
+            r - recover, s - save
+        """
+        if mode == 's':
+            # SAVE CACHE
+            console_write("[NTFY] Save chatIDs cache...")
+            with open('telegram.pds', 'w') as f:
+                f.write(','.join([str(k) for k in Telegram._CHAT_IDS]))
+            return
+        try:
+            # RESTORE CACHE
+            console_write("[NTFY] Restore chatIDs cache...")
+            with open('telegram.pds', 'r') as f:
+                # set() comprehension
+                Telegram._CHAT_IDS = {int(k) for k in f.read().strip().split(',')}
+        except:
+            pass
+
+    @staticmethod
+    def __bot_token():
+        """Get bot token"""
+        if Telegram._TOKEN is None:
+            token = cfgget('telegram')
+            if token is None or token == 'n/a':
+                return None
+            Telegram._TOKEN = token
+        return Telegram._TOKEN
+
+    @staticmethod
+    def send_msg(text, reply_to=None, chat_id=None):
+        """
+        Send a message to the Telegram chat by chat_id
+        :param text: text to send
+        :param reply_to: reply to specific message, if None, simple reply
+        :param chat_id: chat_id to reply on, if None, reply to all known
+        RETURN None when telegram bot token is missing
+        """
+
+        def _send(chid):
+            """Send message to chat_id (chid)"""
+            data = {"chat_id": chid, "text": f"{Telegram._DEVFID}⚙️\n{text}"}
+            if isinstance(reply_to, int):
+                data['reply_to_message_id'] = reply_to
+                Telegram._IN_MSG_ID = reply_to
+            _, _resp = urequests.post(url, headers={"Content-Type": "application/json"}, json=data, jsonify=True,
+                                      sock_size=128)
+            console_write(f"\tSend message:\n{data}\nresponse:\n{_resp}")
+            return _resp
+
+        def _get_chat_ids():
+            """Return chat ID or None (in case of no token or cannot get ID)"""
+            if len(Telegram._CHAT_IDS) == 0:
+                Telegram.get_msg()  # It will update the Telegram.CHAT_IDS
+            console_write(f"\tGet chatIDs: {Telegram._CHAT_IDS}")
+            return Telegram._CHAT_IDS
+
+        # --------------------- FUNCTION MAIN ------------------------ #
+        console_write("[NTFY] SEND MESSAGE")
+        # Check bot token
+        bot_token = Telegram.__bot_token()
+        if bot_token is None:
+            return None
+        url = f"https://api.telegram.org/bot{bot_token}/sendMessage{Telegram._API_PARAMS}"
+
+        verdict = ""
+        # Reply to ALL (notification) - chat_id was not provided
+        if chat_id is None:
+            console_write("\tREPLY ALL")
+            for _chat_id in _get_chat_ids():
+                resp_json = _send(chid=_chat_id)
+                verdict += f'Sent{_chat_id};' if resp_json['ok'] else str(resp_json)
+        else:
+            console_write(f"\tREPLY TO {chat_id}")
+            # Direct reply to chat_id
+            resp_json = _send(chid=chat_id)
+            verdict = f'Sent{chat_id}' if resp_json['ok'] else str(resp_json)
+        return verdict
+
+    @staticmethod
+    def get_msg():
+        """
+        Get the last message from the Telegram chat.
+        RETURN None when telegram bot token is missing
+        """
+
+        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
+
+        # --------------------- FUNCTION MAIN ------------------------ #
+        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}")
+        _, resp_json = urequests.get(url, jsonify=True, sock_size=128)
+        if len(resp_json["result"]) > 0:
+            response['c_id'] = _update_chat_ids()
+            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
+    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
+        verdict = None
+
+        def lm_execute(cmd_args):
+            nonlocal verdict, m_id
+            access, output = Telegram.lm_execute(cmd_args)
+            if access:
+                verdict = f'[UP] Exec: {" ".join(cmd_args[0])}'
+                Telegram.send_msg(output, reply_to=m_id)
+            else:
+                verdict = f'[UP] NoAccess: {cmd_args[0]}'
+                Telegram._IN_MSG_ID = m_id
+
+        # -------------------------- FUNCTION MAIN -------------------------- #
+        # Poll telegram chat
+        data = Telegram.get_msg()
+        if data is None:
+            return data
+        # Get msg, msg_id, chat_id as main input data source
+        msg_in, m_id, c_id = data['text'], data['m_id'], data['c_id']
+        if msg_in is not None and m_id != Telegram._IN_MSG_ID:
+            # replace single/double quotation to apostrophe (str syntax for repl interpretation)
+            msg_in = msg_in.replace('‘', "'").replace('’', "'").replace('“', '"').replace('”', '"')
+            if msg_in.startswith('/ping'):
+                # Parse loaded modules
+                _loaded_mods = [lm.replace('LM_', '') for lm in modules if lm.startswith('LM_')] + ['task']
+                Telegram.send_msg(', '.join(_loaded_mods), reply_to=m_id, chat_id=c_id)
+            elif msg_in.startswith('/cmd_select'):
+                cmd_lm = msg_in.strip().split()[1:]
+                # [Compare] cmd selected device param with DEVFID (device/prompt name)
+                if cmd_lm[0] in Telegram._DEVFID:
+                    lm_execute(cmd_lm[1:])
+                else:
+                    verdict = f'[UP] NoSelected: {cmd_lm[0]}'
+            elif msg_in.startswith('/cmd'):
+                cmd_lm = msg_in.strip().split()[1:]
+                lm_execute(cmd_lm)
+            elif msg_in.startswith('/notify'):
+                param = msg_in.strip().split()[1:]
+                if len(param) > 0:
+                    verdict = Telegram.notifications(not param[0].strip().lower() in ("disable", "off", 'false'))
+                else:
+                    verdict = Telegram.notifications()
+                Telegram.send_msg(verdict, reply_to=m_id)
+        else:
+            verdict = "[UP] NoExec"
+        console_write(f"\tREC&EVAL: {verdict}")
+        return verdict
+
+    @staticmethod
+    def set_commands():
+        """
+        Set Custom Commands to the Telegram chat.
+        RETURN None when telegram bot token is missing
+        """
+
+        console_write("[NTFY] SET DEFAULT COMMANDS")
+        bot_token = Telegram.__bot_token()
+        if bot_token is None:
+            return None
+        url = f"https://api.telegram.org/bot{bot_token}/setMyCommands{Telegram._API_PARAMS}"
+        data = {"commands": [{"command": "ping", "description": "Ping All endpoints: list of active modules."},
+                             {"command": "notify", "description": "Enable/Disable notifications: on or off"},
+                             {"command": "cmd", "description": "Run active module function on all devices."},
+                             {"command": "cmd_select",
+                              "description": "Same as cmd, only first param must be device name."},
+                             ]}
+        _, resp_json = urequests.post(url, headers={"Content-Type": "application/json"}, json=data, jsonify=True,
+                                      sock_size=128)
+        return 'Custom commands was set' if resp_json['ok'] else str(resp_json)
 
 #########################################
 #          micrOS Notifications         #
@@ -15,6 +237,7 @@ 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")
 
@@ -103,17 +326,6 @@ def receiver_loop():
     return "Starting" if state else "Already running"
 
 
-def notifications(enable=None):
-    """
-    Global notifications control for micrOS
-    :param enable: True: Enable notifications / False: Disable notifications
-    return: state verdict
-    """
-    if enable is None:
-        enable = not Telegram.GLOBAL_NOTIFY
-    return Telegram.notifications(state=enable)
-
-
 def help(widgets=False):
     """
     [i] micrOS LM naming convention - built-in help message
@@ -125,5 +337,4 @@ def help(widgets=False):
             'receive',
             'receiver_loop',
             'notify "message"',
-            'notifications enable=False',
             'load', 'INFO: Send & Receive messages with Telegram bot')

micrOS/source/Logger.py

@@ -1,3 +1,9 @@
+"""
+Module is responsible for System and User logging
+- built-in log rotation
+
+Designed by Marcell Ban aka BxNxM
+"""
 from time import localtime
 from os import listdir, remove
 

micrOS/source/Notify.py

@@ -1,247 +1,76 @@
-from sys import modules
-import urequests
+"""
+Module is responsible for Notification handling
+Common:
+    - notifications None/True/False
+    - notify 'text'
+    - lm_execute
+Supported notification subscribers (add_subscriber)
+    - LM_telegram
+Designed by Marcell Ban aka BxNxM
+"""
+
 from Config import cfgget
 from Tasks import lm_exec, lm_is_loaded
-from Debug import console_write
+from Debug import errlog_add
 
 #########################################
 #          micrOS Notifications         #
 #          with Telegram Class          #
 #########################################
-
-class Telegram:
-    # Telegram bot token and chat ID
-    # https://core.telegram.org/bots/api
-    GLOBAL_NOTIFY = True                             # Enable Global notifications
-    _TOKEN = None                                    # Telegram token
-    _CHAT_IDS = set()                                # Telegram bot chat IDs - multi group support - persistent caching
-    _API_PARAMS = "?offset=-1&limit=1&timeout=2"     # Generic API params - optimization
-    _DEVFID = cfgget('devfid')                       # For reply message (pre text)
-    _IN_MSG_ID = None
+class Notify:
+    GLOBAL_NOTIFY = True            # Enable Global notifications
+    _DEVFID = cfgget('devfid')      # For reply message (pre text)
+    _SUBSCRIBERS = set()            # Store set of notification objects: send_msg
 
     @staticmethod
-    def __id_cache(mode):
+    def add_subscriber(instance):
         """
-        pds - persistent data structure
-        modes:
-            r - recover, s - save
+        Add Notification agent like: Telegram
         """
-        if mode == 's':
-            # SAVE CACHE
-            console_write("[NTFY] Save chatIDs cache...")
-            with open('telegram.pds', 'w') as f:
-                f.write(','.join([str(k) for k in Telegram._CHAT_IDS]))
-            return
-        try:
-            # RESTORE CACHE
-            console_write("[NTFY] Restore chatIDs cache...")
-            with open('telegram.pds', 'r') as f:
-                # set() comprehension
-                Telegram._CHAT_IDS = {int(k) for k in f.read().strip().split(',')}
-        except:
-            pass
-
-    @staticmethod
-    def __bot_token():
-        """Get bot token"""
-        if Telegram._TOKEN is None:
-            token = cfgget('telegram')
-            if token is None or token == 'n/a':
-                return None
-            Telegram._TOKEN = token
-        return Telegram._TOKEN
+        if isinstance(instance, Notify):
+            Notify._SUBSCRIBERS.add(instance)
+            return True
+        raise Exception("Subscribe error, Notify parent missing")
 
     @staticmethod
-    def send_msg(text, reply_to=None, chat_id=None):
+    def message(text, reply_to=None, chat_id=None):
         """
-        Send a message to the Telegram chat by chat_id
-        :param text: text to send
-        :param reply_to: reply to specific message, if None, simple reply
-        :param chat_id: chat_id to reply on, if None, reply to all known
-        RETURN None when telegram bot token is missing
+        Send message to all subscribers
         """
-        def _send(chid):
-            """Send message to chat_id (chid)"""
-            data = {"chat_id": chid, "text": f"{Telegram._DEVFID}⚙️\n{text}"}
-            if isinstance(reply_to, int):
-                data['reply_to_message_id'] = reply_to
-                Telegram._IN_MSG_ID = reply_to
-            _, _resp = urequests.post(url, headers={"Content-Type": "application/json"}, json=data, jsonify=True, sock_size=128)
-            console_write(f"\tSend message:\n{data}\nresponse:\n{_resp}")
-            return _resp
-
-        def _get_chat_ids():
-            """Return chat ID or None (in case of no token or cannot get ID)"""
-            if len(Telegram._CHAT_IDS) == 0:
-                Telegram.get_msg()  # It will update the Telegram.CHAT_IDS
-            console_write(f"\tGet chatIDs: {Telegram._CHAT_IDS}")
-            return Telegram._CHAT_IDS
-        
-        # --------------------- FUNCTION MAIN ------------------------ #
-        console_write("[NTFY] SEND MESSAGE")
-        # Check bot token
-        bot_token = Telegram.__bot_token()
-        if bot_token is None:
-            return None
-        url = f"https://api.telegram.org/bot{bot_token}/sendMessage{Telegram._API_PARAMS}"
-
-        verdict = ""
-        # Reply to ALL (notification) - chat_id was not provided
-        if chat_id is None:
-            console_write("\tREPLY ALL")
-            for _chat_id in _get_chat_ids():
-                resp_json = _send(chid=_chat_id)
-                verdict += f'Sent{_chat_id};' if resp_json['ok'] else str(resp_json)
-        else:
-            console_write(f"\tREPLY TO {chat_id}")
-            # Direct reply to chat_id
-            resp_json = _send(chid=chat_id)
-            verdict = f'Sent{chat_id}' if resp_json['ok'] else str(resp_json)
-        return verdict
+        exit_code = 0
+        for s in Notify._SUBSCRIBERS:
+            try:
+                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})"
 
     @staticmethod
     def notifications(state=None):
         """
         Setter for disable/enable notification messages
         """
-        if state is not None:
-            Telegram.GLOBAL_NOTIFY = state
-        return f"Notifications: {'enabled' if Telegram.GLOBAL_NOTIFY else 'disabled'}"
-
+        if isinstance(state, bool):
+            Notify.GLOBAL_NOTIFY = state
+        return f"Notifications: {'enabled' if Notify.GLOBAL_NOTIFY else 'disabled'}"
 
     @staticmethod
     def notify(text, reply_to=None, chat_id=None):
         """
         Notification sender
         """
-        if Telegram.GLOBAL_NOTIFY:
-            return Telegram.send_msg(text, reply_to, chat_id)
+        if Notify.GLOBAL_NOTIFY:
+            return Notify.message(text, reply_to, chat_id)
         return "Notifications disabled"
 
     @staticmethod
-    def get_msg():
-        """
-        Get the last message from the Telegram chat.
-        RETURN None when telegram bot token is missing
-        """
-
-        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
-
-        # --------------------- FUNCTION MAIN ------------------------ #
-        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}")
-        _, resp_json = urequests.get(url, jsonify=True, sock_size=128)
-        if len(resp_json["result"]) > 0:
-            response['c_id'] = _update_chat_ids()
-            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
-    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
-        verdict = None
-
-        def lm_execute(cmd_args):
-            nonlocal verdict
-            if lm_is_loaded(cmd_args[0]):
-                verdict = f'[UP] Exec: {" ".join(cmd_args[0])}'
-                try:
-                    _, out = lm_exec(cmd_args)
-                except Exception as e:
-                    out = str(e)
-                Telegram.send_msg(out, reply_to=m_id)
-            else:
-                verdict = f'[UP] NoAccess: {cmd_args[0]}'
-                Telegram._IN_MSG_ID = m_id
-
-        # -------------------------- FUNCTION MAIN -------------------------- #
-        # Poll telegram chat
-        data = Telegram.get_msg()
-        if data is None:
-            return data
-        # Get msg, msg_id, chat_id as main input data source
-        msg_in, m_id, c_id = data['text'], data['m_id'], data['c_id']
-        if msg_in is not None and m_id != Telegram._IN_MSG_ID:
-            # replace single/double quotation to apostrophe (str syntax for repl interpretation)
-            msg_in = msg_in.replace('‘', "'").replace('’', "'").replace('“', '"').replace('”', '"')
-            if msg_in.startswith('/ping'):
-                # Parse loaded modules
-                _loaded_mods = [lm.replace('LM_', '') for lm in modules if lm.startswith('LM_')] + ['task']
-                Telegram.send_msg(', '.join(_loaded_mods), reply_to=m_id, chat_id=c_id)
-            elif msg_in.startswith('/cmd_select'):
-                cmd_lm = msg_in.strip().split()[1:]
-                # [Compare] cmd selected device param with DEVFID (device/prompt name)
-                if cmd_lm[0] in Telegram._DEVFID:
-                    lm_execute(cmd_lm[1:])
-                else:
-                    verdict = f'[UP] NoSelected: {cmd_lm[0]}'
-            elif msg_in.startswith('/cmd'):
-                cmd_lm = msg_in.strip().split()[1:]
-                lm_execute(cmd_lm)
-            elif msg_in.startswith('/notify'):
-                param = msg_in.strip().split()[1:]
-                if len(param) > 0:
-                    verdict = Telegram.notifications(not param[0].strip().lower() in ("disable", "off", 'false'))
-                else:
-                    verdict = Telegram.notifications()
-                Telegram.send_msg(verdict, reply_to=m_id)
-        else:
-            verdict = "[UP] NoExec"
-        console_write(f"\tREC&EVAL: {verdict}")
-        return verdict
-
-    @staticmethod
-    def set_commands():
-        """
-        Set Custom Commands to the Telegram chat.
-        RETURN None when telegram bot token is missing
-        """
-
-        console_write("[NTFY] SET DEFAULT COMMANDS")
-        bot_token = Telegram.__bot_token()
-        if bot_token is None:
-            return None
-        url = f"https://api.telegram.org/bot{bot_token}/setMyCommands{Telegram._API_PARAMS}"
-        data = {"commands": [{"command": "ping", "description": "Ping All endpoints: list of active modules."},
-                             {"command": "notify", "description": "Enable/Disable notifications: on or off"},
-                             {"command": "cmd", "description": "Run active module function on all devices."},
-                             {"command": "cmd_select", "description": "Same as cmd, only first param must be device name."},
-                             ]}
-        _, resp_json = urequests.post(url, headers={"Content-Type": "application/json"}, json=data, jsonify=True, sock_size=128)
-        return 'Custom commands was set' if resp_json['ok'] else str(resp_json)
+    def lm_execute(cmd_args):
+        """Executor with basic access handling"""
+        if lm_is_loaded(cmd_args[0]):
+            try:
+                _, out = lm_exec(cmd_args)
+            except Exception as e:
+                out = str(e)
+            return True, out
+        return False, cmd_args[0]

micrOS/source/Shell.py

@@ -25,7 +25,7 @@ from Debug import errlog_add
 
 class Shell:
     __slots__ = ['__devfid', '__auth_mode', '__hwuid', '__auth_ok', '__conf_mode']
-    MICROS_VERSION = '2.8.4-0'
+    MICROS_VERSION = '2.9.1-0'
 
     def __init__(self):
         """
@@ -264,8 +264,9 @@ class Shell:
                         line = "micrOSisTheBest"
                         while line:
                             line = f.readline()
-                            if line.strip().startswith('def') and '_' not in line and 'self' not in line:
-                                msg_obj(f"   {' ' * len(lm_name)}{line.replace('def ', '').split('(')[0]}")
+                            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]}")
                 except Exception as e:
                     msg_obj(f"[{lm_path}] SHOW LM PARSER WARNING: {e}")
                     return False

micrOS/source/Types.py

@@ -70,8 +70,12 @@ def _generate(type_dict, help_msg):
                 overwrite[value_type] = values
             valid_params.append(param_str)
         else:
-            param_str = f'{p}=:{"range" if "range" in type_dict else "options"}:'
-            valid_params.append(param_str)
+            if p.startswith("&"):
+                # Handle special use case - task postfix
+                valid_params.append(p)
+            else:
+                param_str = f'{p}=:{"range" if "range" in type_dict else "options"}:'
+                valid_params.append(param_str)
     type_dict['lm_call'] = f"{func} {' '.join(valid_params)}"
     return dumps(type_dict | overwrite)
 

micrOS/source/Web.py

@@ -74,9 +74,22 @@ class WebEngine:
             try:
                 # SEND RESOURCE CONTENT: HTML, JS, CSS
                 with open(resource, 'r') as file:
-                    html = file.read()
-                await self.client.a_send(self.REQ200.format(dtype=WebEngine.file_type(resource), len=len(html), data=html))
-            except OSError:
+                    data = file.read()
+                response = self.REQ200.format(dtype=WebEngine.file_type(resource), len=len(data), data=data)
+                # Send entire response data
+                await self.client.a_send(response)
+
+                # Send chunks of response data (experimental)
+                #response_len, chunk_size, position = len(response), 300, 0
+                #while position < response_len:
+                #    # Calculate the size of the next chunk
+                #    next_chunk_size = min(chunk_size, response_len - position)
+                #    chunk = response[position:position + next_chunk_size]
+                #    await self.client.a_send(chunk)
+                #    position += next_chunk_size
+            except Exception as e:
+                if 'memory allocation failed' in str(e):
+                    errlog_add(f"[ERR] WebCli {resource}: {e}")
                 await self.client.a_send(self.REQ404.format(len=13, data='404 Not Found'))
             return
         # INVALID/BAD REQUEST