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

micrOS/source/LM_sound_event.py

@@ -37,7 +37,6 @@ Terminal ready
 """
 
 import LM_i2s_mic
-import uasyncio as asyncio
 import json
 
 from microIO import pinmap_search
@@ -647,7 +646,7 @@ async def __control_task(capture_duration_ms,
     :param pause_duration_ms: int - duration of pause frames to distinguish events
     :param event_buffer_length: int - number of events to store at once
     """
-    with micro_task(tag=Data.CONTROL_TASK_TAG):
+    with micro_task(tag=Data.CONTROL_TASK_TAG) as my_task:
         samples = []
         frame_size = int((frame_size_ms/1000)*LM_i2s_mic.Data.SAMPLING_RATE)
         pause_duration = int(pause_duration_ms/frame_size_ms)
@@ -674,7 +673,7 @@ async def __control_task(capture_duration_ms,
                 
                 # Wait for new samples to be taken
                 ms_period = int(len(new_samples)/LM_i2s_mic.Data.SAMPLING_RATE)
-                await asyncio.sleep_ms(ms_period)
+                await my_task.feed(sleep_ms=ms_period)
                 Data.EVENTS = Data.EVENTS[-event_buffer_length:]
             except Exception as e:
                 console(f'[ERR] sound_event: {e}')

micrOS/source/Notify.py

@@ -9,7 +9,6 @@ from Debug import console_write
 #          with Telegram Class          #
 #########################################
 
-
 class Telegram:
     # Telegram bot token and chat ID
     # https://core.telegram.org/bots/api

micrOS/source/Scheduler.py

@@ -1,6 +1,6 @@
 from time import localtime
 from re import compile
-from Tasks import exec_lm_core_schedule
+from Tasks import exec_lm_pipe_schedule
 from Debug import console_write, errlog_add
 from Time import Sun, suntime, ntp_time
 
@@ -179,7 +179,7 @@ def __scheduler_trigger(cron_time_now, crontask, deltasec=2):
                 lm_state = False
                 if isinstance(crontask[1], str):
                     # [1] Execute Load Module as a string (user LMs)
-                    lm_state = exec_lm_core_schedule(crontask[1].split())
+                    lm_state = exec_lm_pipe_schedule(crontask[1])
                 else:
                     try:
                         # [2] Execute function reference (built-in functions)
@@ -207,6 +207,7 @@ def deserialize_raw_input(cron_data):
     Scheduler/Cron input string format
     :param cron_data: raw cron tasks, time based task execution input (bytearray)
         example: WD:H:M:S!LM func;WD:H:M:S!LM func; ...
+        multi command example: WD:H:M:S!LM func;LM func2;; WD:H:M:S!LM func;; ...
 
         time_tag: timestamp / time-tag aka suntime
                 timestamp: WD:H:M:S
@@ -218,8 +219,10 @@ def deserialize_raw_input(cron_data):
     Returns tuple: (("WD:H:M:S", 'LM FUNC'), ("WD:H:M:S", 'LM FUNC'), ...)
     """
     try:
-        # Parse and create return - convert cron_data (bytearray) to string
-        return (tuple(cron.split('!')) for cron in str(cron_data, 'utf-8').split(';'))
+        # Parse and create return
+        cd = str(cron_data, 'utf-8')            # convert cron_data (bytearray) to string
+        sep = ';;' if ';;' in cd else ';'       # support multi command with ;;
+        return (tuple(cron.split('!')) for cron in cd.split(sep))
     except Exception as e:
         errlog_add(f"[ERR] cron deserialize - syntax error: {e}")
     return ()

micrOS/source/Shell.py

@@ -2,7 +2,7 @@
 Module is responsible for shell like environment
 dedicated to micrOS framework.
 Built-in-function:
-- Shell wrapper for safe InterpreterCore interface
+- Shell wrapper for lm_exec interface
 - Configuration handling interface - state machine handling
 - Help (runtime) message generation
 
@@ -25,7 +25,7 @@ from Debug import errlog_add
 
 class Shell:
     __slots__ = ['__devfid', '__auth_mode', '__hwuid', '__auth_ok', '__conf_mode']
-    MICROS_VERSION = '2.8.1-0'
+    MICROS_VERSION = '2.8.4-0'
 
     def __init__(self):
         """

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/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
@@ -76,14 +90,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

@@ -34,7 +34,6 @@ def __is_micrOS():
         False -> webrepl
         * EOE (EndOfExecution) -> off
     """
-    mode = 'micros'
     try:
         with open('.if_mode', 'r') as f:
             mode = f.read().strip().lower()
@@ -82,10 +81,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

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 |/|/|/|/