micrOSDevToolKit 2.8.6__py3-none-any.whl → 2.9.0__py3-none-any.whl

micrOS/source/Tasks.py

@@ -19,7 +19,7 @@ from Network import sta_high_avail
 
 try:
     from gc import collect
-except:
+except ImportError:
     console_write("[SIMULATOR MODE GC IMPORT]")
     from simgc import collect
 
@@ -38,22 +38,34 @@ class TaskBase:
     TASKS = {}                          # TASK OBJ list
 
     def __init__(self):
-        self.task = None             # [TASK] Store created async task object
-        self.done = asyncio.Event()  # [TASK] Store done state
-        self.out = ""                # [TASK] Store output
-        self.tag = None              # [TASK] Task tag (identification)
+        self.task = None             # Store created async task object
+        self.tag = None              # Task tag (identification)
+        self.done = asyncio.Event()  # Store task done state
+        self.out = ""                # Store task output
 
     @staticmethod
-    def is_busy(tag):
+    def is_busy(tag) -> bool:
         """
-        Check task is busy by tag in TASKS
-        - exists + running = busy
+        Check task is busy by tag
+        :param tag: for task selection
         """
         task = TaskBase.TASKS.get(tag, None)
         # return True: busy OR False: not busy (inactive)
         return bool(task is not None and not task.done.is_set())
 
-    def cancel(self):
+    @staticmethod
+    def task_gc():
+        """
+        Automatic passive task deletion over QUEUE_SIZE
+        """
+        keep  = TaskBase.QUEUE_SIZE
+        passive = tuple((task_tag for task_tag in list(TaskBase.TASKS) if not TaskBase.is_busy(task_tag)))
+        if len(passive) >= keep:
+            for i in range(0, len(passive)-keep+1):
+                del TaskBase.TASKS[passive[i]]
+            collect()  # GC collect
+
+    def cancel(self) -> bool:
         """
         Cancel task (+cleanup)
         """
@@ -83,13 +95,13 @@ class TaskBase:
         collect()                           # GC collect
 
     @staticmethod
-    def task_gc():
-        keep  = TaskBase.QUEUE_SIZE
-        passive = tuple((task_tag for task_tag in list(TaskBase.TASKS) if not TaskBase.is_busy(task_tag)))
-        if len(passive) >= keep:
-            for i in range(0, len(passive)-keep+1):
-                del TaskBase.TASKS[passive[i]]
-            collect()  # GC collect
+    async def feed(sleep_ms=1):
+        """
+        Feed event loop
+        :param sleep_ms: in millisecond (min: 1)
+        """
+        # TODO: feed WDT - preemptive cooperative multitasking aka reboot if no feed until X time period
+        return await asyncio.sleep_ms(sleep_ms)
 
     def __del__(self):
         try:
@@ -187,9 +199,12 @@ class MagicTask(TaskBase):
         - self.__inloop: lm call type - one-shot (False) / looped (True)
         - self.__msg_buf: lm msg object redirect to variable - store lm output
         """
+        jsonify = self.__callback[-1] == '>json'
+        if jsonify:
+            self.__callback = self.__callback[:-1]
         while True:
-            await asyncio.sleep_ms(self.__sleep)
-            state, self.out = _exec_lm_core(self.__callback)
+            await self.feed(self.__sleep)
+            state, self.out = _exec_lm_core(self.__callback, jsonify)
             if not state or not self.__inloop:
                 break
         self.task_gc()    # Task pool cleanup
@@ -265,10 +280,10 @@ class Manager:
         try:
             while True:
                 # [0] Just chill
-                await asyncio.sleep_ms(300)
+                await my_task.feed(300)
                 # [1] PROBE SYSTEM LOAD + 300ms
                 t = ticks_ms()
-                await asyncio.sleep_ms(300)
+                await my_task.feed(300)
                 delta_rate = int(((ticks_diff(ticks_ms(), t) / 300) - 1) * 100)
                 Manager.LOAD = int((Manager.LOAD + delta_rate) / 2)  # Average - smooth
                 # [2] NETWORK AUTO REPAIR
@@ -353,7 +368,6 @@ class Manager:
         - by tag: module.function
         - by tag module.*, kill all for selected module
         """
-
         def terminate(_tag):
             to_kill = TaskBase.TASKS.get(_tag, None)
             try:
@@ -399,85 +413,94 @@ class Manager:
 #################################################################
 #                      LM EXEC CORE functions                   #
 #################################################################
-
-def lm_exec(arg_list):
+def exec_builtins(func):
+    """
+    Module execution built-in commands and modifiers
+    - modules         - show active modules list
+    - task kill ...   - task termination
+           show ...   - task output dump
+    -  ... >json      - postfix to "jsonize" the output
+    """
+    def wrapper(arg_list, jsonify=None):
+        # Ensure the parameter is a list of strings
+        if isinstance(arg_list, list) and arg_list:
+            # JSONIFY: [1] >json in arg_list or [2] jsonify True/False
+            json_flag = arg_list[-1] == '>json'
+            if json_flag:
+                arg_list = arg_list[:-1]
+            json_flag = jsonify if isinstance(jsonify, bool) else json_flag
+            # MODULES
+            if arg_list[0] == 'modules':
+                return True, list((m.strip().replace('LM_', '') for m in modules if m.startswith('LM_'))) + ['task']
+            # Handle task manipulation commands: list, kill, show - return True -> Command handled
+            if 'task' == arg_list[0]:
+                arg_len = len(arg_list)
+                # task list
+                if arg_len > 1 and 'list' == arg_list[1]:
+                    on, off = Manager.list_tasks(json=json_flag)
+                    # RETURN:    JSON mode                                                   Human readable mode with cpu & queue info
+                    return (True, {'active': on[3:], 'inactive': off}) if json_flag else (True, '\n'.join(on) + '\n' + '\n'.join(off) + '\n')
+                # task kill <taskID> / task show <taskID>
+                if arg_len > 2:
+                    if 'kill' == arg_list[1]:
+                        state, msg = Manager.kill(tag=arg_list[2])
+                        return True, msg
+                    if 'show' == arg_list[1]:
+                        return True, Manager.show(tag=arg_list[2])
+                return True, "Invalid task cmd! Help: task list / kill <taskID> / show <taskID>"
+            # Call the decorated function with the additional flag
+            return func(arg_list, json_flag)
+    return wrapper
+
+
+@exec_builtins
+def lm_exec(arg_list, jsonify):
     """
     Main LM executor function with
     - async (background)
     - sync
     (single) task execution (_exec_lm_core)
     :param arg_list: command parameters
-    Return Bool(OK/NOK), STR(Command output)
+    :param jsonify: request json output (controlled by the decorator)
+    Return Bool(OK/NOK), "Command output"
     """
 
-    def _exec_task():
-        nonlocal arg_list, arg_len
-        # [1] Handle task manipulation commands: list, kill, show - return True -> Command handled
-        if 'task' == arg_list[0]:
-            # task list
-            if arg_len > 1 and 'list' == arg_list[1]:
-                if arg_len > 2 and arg_list[2].strip() == '>json':
-                    # JSON mode
-                    on, off = Manager.list_tasks(json=True)
-                    return True, {'active': on[3:], 'inactive': off}
-                on, off = Manager.list_tasks(json=False)
-                # Human readable mode with cpu & queue info
-                return True, '\n'.join(on) + '\n' + '\n'.join(off) + '\n'  # Show active tasks and passive tasks
-            # task kill <taskID> / task show <taskID>
-            if arg_len > 2:
-                if 'kill' == arg_list[1]:
-                    state, msg = Manager.kill(tag=arg_list[2])
-                    return True, msg
-                if 'show' == arg_list[1]:
-                    return True, Manager.show(tag=arg_list[2])
-            return True, "Invalid task cmd! Help: task list / kill <taskID> / show <taskID>"
-        # [2] Start async task, postfix: &, &&
-        if arg_len > 2 and '&' in arg_list[-1]:
-            # Evaluate task mode: loop + delay
-            mode = arg_list.pop(-1)
-            loop = mode.count('&') == 2
-            delay = mode.replace('&', '').strip()
-            delay = int(delay) if delay.isdigit() else None
-            # Create and start async lm task
-            try:
-                state = Manager.create_task(arg_list, loop=loop, delay=delay)
-            except Exception as e:
-                # Valid & handled task command
-                return True, str(e)
-            tag = '.'.join(arg_list[0:2])
+    # [1] Async "background" task execution, postfix: &, &&
+    if len(arg_list) > 2 and '&' in arg_list[-1]:
+        # Evaluate task mode: loop + delay
+        mode = arg_list.pop(-1)
+        loop = mode.count('&') == 2
+        delay = mode.replace('&', '').strip()
+        delay = int(delay) if delay.isdigit() else None
+        # Create and start async lm task
+        try:
+            state = Manager.create_task(arg_list, loop=loop, delay=delay)
+        except Exception as e:
             # Valid & handled task command
-            if state:
-                return True, f"Start {tag}"
-            return True, f"{tag} is Busy"
-        # Not valid task command
-        return False, ''
-
-    # ================ main function ================
-    # modules built-in function: show loaded LoadModules
-    arg_len = len(arg_list)
-    if arg_len > 0 and arg_list[0] == 'modules':
-        return True, list((m.strip().replace('LM_', '') for m in modules if m.startswith('LM_'))) + ['task']
-    # [1] Run task command: start (&), list, kill, show
-    is_task, out = _exec_task()
-    if is_task:
-        return True, out
+            return True, str(e)
+        tag = '.'.join(arg_list[0:2])
+        # Valid & handled task command
+        if state:
+            return True, f"Start {tag}"
+        return True, f"{tag} is Busy"
+
     # [2] Sync "realtime" task execution
-    state, out = _exec_lm_core(arg_list)
+    state, out = _exec_lm_core(arg_list, jsonify)
     return state, out
 
 
-def _exec_lm_core(cmd_list):
+def _exec_lm_core(cmd_list, jsonify):
     """
     [CORE] Single command executor: MODULE.FUNCTION...
     :param cmd_list: list of string parameters
         [1] module name (LM)
         [2] function
         [3...] parameters (separator: space)
-        [-1] Built-in json output handler: >json
+    :param jsonify: request json output
     Return Bool(OK/NOK), STR(Command output)
     """
 
-    def __func_params(param):
+    def _func_params(param):
         buf = None
         if "'" in param or '"' in param:
             str_index = [i for i, c in enumerate(param) if c in ('"', "'")]
@@ -489,12 +512,9 @@ def _exec_lm_core(cmd_list):
             param = param.format(*buf)
         return param
 
-    # Check json mode for LM execution
-    json_mode = cmd_list[-1] == '>json'
-    cmd_list = cmd_list[0:-1] if json_mode else cmd_list
     # LoadModule execution
     if len(cmd_list) >= 2:
-        lm_mod, lm_func, lm_params = f"LM_{cmd_list[0]}", cmd_list[1], __func_params(' '.join(cmd_list[2:]))
+        lm_mod, lm_func, lm_params = f"LM_{cmd_list[0]}", cmd_list[1], _func_params(' '.join(cmd_list[2:]))
         try:
             # ------------- LM LOAD & EXECUTE ------------- #
             # [1] LOAD MODULE - OPTIMIZED by sys.modules
@@ -516,11 +536,11 @@ def _exec_lm_core(cmd_list):
             # Handle LM output data
             if isinstance(lm_output, dict):
                 # json True: output->json else Format dict output "human readable"
-                lm_output = dumps(lm_output) if json_mode else '\n'.join(
+                lm_output = dumps(lm_output) if jsonify else '\n'.join(
                     [f" {key}: {value}" for key, value in lm_output.items()])
             if lm_func == 'help':
                 # Special case for help command: json True: output->json else Format dict output "human readable"
-                lm_output = dumps(lm_output) if json_mode else '\n'.join([f" {out}," for out in lm_output])
+                lm_output = dumps(lm_output) if jsonify else '\n'.join([f" {out}," for out in lm_output])
             # Return LM exec result
             return True, str(lm_output)
             # ---------------------------------------------------------------------- #
@@ -540,7 +560,7 @@ def lm_is_loaded(lm_name):
     [Auth mode]
     Check lm_name in enabled modules
     """
-    static_keywords = tuple('task')
+    static_keywords = ('task', 'modules')
     loaded_mods = [lm.replace('LM_', '') for lm in modules if lm.startswith('LM_')]
     return lm_name in static_keywords or lm_name in loaded_mods
 
@@ -573,7 +593,7 @@ def exec_lm_pipe(taskstr):
 
 def exec_lm_pipe_schedule(taskstr):
     """
-    Scheduled Wrapper for exec_lm_pipe for IRQs (extIRQ, timIRQ)
+    Scheduled Wrapper for exec_lm_pipe for IRQs (extIRQ, timIRQ,  cronIRQ)
     """
     try:
         schedule(exec_lm_pipe, taskstr)
@@ -581,15 +601,3 @@ def exec_lm_pipe_schedule(taskstr):
     except Exception as e:
         errlog_add(f"[ERR] exec_lm_pipe_schedule: {e}")
         return False
-
-
-def exec_lm_core_schedule(arg_list):
-    """
-    Scheduled Wrapper for lm_exec for cron IRQ
-    """
-    try:
-        schedule(lm_exec, arg_list)
-        return True
-    except Exception as e:
-        errlog_add(f"[ERR] schedule_lm_exec {arg_list}: {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

@@ -1,3 +1,17 @@
+"""
+Module is responsible for webserver environment
+dedicated to micrOS framework.
+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
+    - "virtual" endpoints                           - to reply from script on a defined endpoint
+        - stream                                    - stream data (jpeg) function
+
+Designed by Marcell Ban aka BxNxM
+"""
+
 from json import dumps, loads
 import uasyncio as asyncio
 from Tasks import lm_exec, NativeTask, lm_is_loaded
@@ -60,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
@@ -76,14 +103,11 @@ class WebEngine:
             # REST sub-parameter handling (rest commands)
             cmd = (cmd.replace('/', ' ').replace('%22', '"').replace('%E2%80%9C', '"')
                    .replace('%E2%80%9D', '"').replace('-', ' ').strip().split())
-            # request json format instead of default string output (+ handle & tasks syntax)
-            cmd.insert(-1, '>json') if cmd[-1].startswith('&') else cmd.append('>json')
             # EXECUTE COMMAND - LoadModule
             if WebEngine.AUTH:
-                state, out = lm_exec(cmd) if lm_is_loaded(cmd[0]) or cmd[0].startswith('modules') else (
-                True, 'Auth:Protected')
+                state, out = lm_exec(cmd, jsonify=True) if lm_is_loaded(cmd[0]) else (True, 'Auth:Protected')
             else:
-                state, out = lm_exec(cmd)
+                state, out = lm_exec(cmd, jsonify=True)
             try:
                 resp_schema['result'] = loads(out)  # Load again ... hack for embedded shell json converter...
             except:

micrOS/source/dashboard.html

@@ -31,10 +31,10 @@
             transition: border-color 0.3s ease; /* Smooth transition for border color */
         }
     </style>
-    <script src="uapi.js" defer></script>
-    <script src="uwidgets.js" defer></script>
-    <script src="uwidgets_pro.js" defer></script>
-    <script src="udashboard.js" defer></script>
+    <script src="uapi.js" ></script>
+    <script src="uwidgets.js" ></script>
+    <script src="uwidgets_pro.js" ></script>
+    <script src="udashboard.js" ></script>
 </head>
 <body>
     <h1> micrOS dashboard </h1>

micrOS/source/micrOS.py

@@ -20,15 +20,6 @@ from Debug import errlog_add
 #            INTERRUPT HANDLER INTERFACES / WRAPPERS            #
 #################################################################
 
-
-def safe_boot():
-    try:
-        bootup()
-    except Exception as e:
-        print(f"[micrOS main] Hooks.boot() error: {e}")
-        errlog_add(f"[ERR] safe_boot: {e}")
-
-
 def irq_handler():
     try:
         enableInterrupt()
@@ -58,7 +49,11 @@ def micrOS():
     aio = Manager()
 
     # BOOT TASKS: Initial LM executions
-    safe_boot()
+    try:
+        bootup()
+    except Exception as e:
+        print(f"[micrOS main] Hooks.boot() error: {e}")
+        errlog_add(f"[ERR] safe_boot: {e}")
 
     # NETWORK setup
     nwmd = auto_nw_config()

micrOS/source/micrOSloader.py

@@ -14,11 +14,12 @@ except:
 try:
     from Debug import errlog_add
 except Exception as e:
-    print(f"Import error: {e}")
+    print(f"[loader] Import error: {e}")
     errlog_add = None
+from machine import reset
 
 
-def __is_micrOS():
+def _is_micrOS():
     """
     Recovery mode for OTA update in case of connection/transfer failure
         .if_mode can have 2 possible values: webrepl or micros (strings)
@@ -34,7 +35,6 @@ def __is_micrOS():
         False -> webrepl
         * EOE (EndOfExecution) -> off
     """
-    mode = 'micros'
     try:
         with open('.if_mode', 'r') as f:
             mode = f.read().strip().lower()
@@ -54,7 +54,6 @@ def __is_micrOS():
         exit(0)
     # start webrepl
     print("[loader][if_mode:False] .if_mode:webrepl -> webrepl interface")
-    print("[loader][recovery mode] - manually selected in .if_mode file")
     return False
 
 
@@ -71,7 +70,14 @@ def __recovery_mode():
         import webrepl
         webrepl.start(password=pwd)
     except Exception as e:
-        print(f"Webrepl import error: {e}")
+        if callable(errlog_add):
+            errlog_add(f"[ERR][micrOSloader] webrepl failed: {e}")
+        print("[loader] Reset .if_mode to micros and reboot")
+        with open('.if_mode', 'w') as f:
+            f.write("micros")
+        # Reboot machine
+        reset()
+
 
 
 def __auto_restart_event():
@@ -82,10 +88,6 @@ def __auto_restart_event():
             - value: micros     [update was successful - reboot is necessary]
     :return:
     """
-    from sys import platform
-    if platform == 'rp2':
-        print("[loader][ota-rebooter] SKIP on platform: rp2 (webrepl block)")
-        return
 
     from utime import sleep
     trigger_is_active = False
@@ -93,7 +95,7 @@ def __auto_restart_event():
     # Wait after webrepl started for possible ota updates (~3s*5= 15sec)
     while wait_update_tout > 0:
         # Wait for micros turns to webrepl until timeout
-        if __is_micrOS():
+        if _is_micrOS():
             # micrOS mode
             print(f"[loader][ota-rebooter][micros][{wait_update_tout}] Wait for OTA update possible start")
             wait_update_tout -= 1
@@ -102,19 +104,18 @@ def __auto_restart_event():
             # Set trigger  - if_mode changed to webrepl - ota update started - trigger wait
             trigger_is_active = True
         # Restart if trigger was activated
-        if trigger_is_active and __is_micrOS():
+        if trigger_is_active and _is_micrOS():
             print("[loader][ota-rebooter][micros][trigger: True] OTA was finished - reboot")
             # Create cleanup indicator file for ConfigHandler
             with open('cleanup.pds', 'w') as f:
                 f.write('')
             # Reboot machine
-            from machine import reset
             reset()
         sleep(3)
 
 
 def main():
-    if __is_micrOS():
+    if _is_micrOS():
         # Main mode
         try:
             print("[loader][main mode] Start micrOS (default)")
@@ -126,11 +127,8 @@ def main():
             # Handle micrOS system crash (never happened...but) -> webrepl mode default pwd: ADmin123
             print(f"[loader][main mode] micrOS start failed: {e}")
             print("[loader][main mode] -> [recovery mode]")
-            if errlog_add is not None:
-                try:
-                    errlog_add(f"[ERR][micrOSloader] start failed: {e}")
-                except:
-                    pass
+            if callable(errlog_add):
+                errlog_add(f"[ERR][micrOSloader] start failed: {e}")
     # Recovery aka webrepl mode
     __recovery_mode()
     __auto_restart_event()

micrOS/source/uapi.js

@@ -1,9 +1,9 @@
-// Get the current hostname and create the REST API URL
-const currentHostname = window.location.hostname;
-const port = window.location.port ? `:${window.location.port}` : "";
+// CORE MICROS BACKEND INTERFACE
+
+const BASE_URL = `http://${window.location.hostname}${window.location.port ? `:${window.location.port}` : ""}`;
 
 function restAPICore(cmd, timeout=5000) {
-    const query = `http://${currentHostname}${port}/rest/${cmd.trim().replace(/\s+/g, '/')}`;
+    const query = `${BASE_URL}/rest/${cmd.trim().replace(/\s+/g, '/')}`;
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), timeout);
     const startTime = performance.now();
@@ -59,5 +59,4 @@ function restInfo() {
     });
 }
 
-// Init basic info from board
-// restInfo();
+// Designed by BxNxM |/|/|/|/