micrOSDevToolKit 2.1.5__py3-none-any.whl → 2.26.1__py3-none-any.whl

micrOS/source/Tasks.py

@@ -10,18 +10,19 @@ Designed by Marcell Ban aka BxNxM
 #################################################################
 from sys import modules
 from json import dumps
+from re import match
 import uasyncio as asyncio
 from micropython import schedule
 from utime import ticks_ms, ticks_diff
-from Debug import console_write, errlog_add
+from Debug import console_write, syslog
 from Config import cfgget
 from Network import sta_high_avail
 
 try:
-    from gc import collect
-except:
+    from gc import collect as gcollect
+except ImportError:
     console_write("[SIMULATOR MODE GC IMPORT]")
-    from simgc import collect
+    from simgc import collect as gcollect
 
 #################################################################
 #                Implement custom task class                    #
@@ -33,26 +34,52 @@ class TaskBase:
     """
     Async task base definition for common features
     """
+    __slots__ = ['task', 'done', 'out', 'tag', '__callback', '__inloop', '__sleep']
     QUEUE_SIZE = cfgget('aioqueue')     # QUEUE size from config
     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
 
+    ######  BASE METHODS FOR CHILD CLASSES  ####
+    def _create(self, callback:callable) -> dict:
+        """
+        Create async task and register it to TASKS dict by tag
+        :param callback: coroutine function
+        """
+        # Create async task from coroutine function
+        self.task = asyncio.get_event_loop().create_task(callback)
+        # Store Task object by key - for task control
+        TaskBase.TASKS[self.tag] = self
+        return {self.tag: "Starting"}
+
+    @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]]
+            gcollect()
+
+    ######  PUBLIC TASK METHODS  #####
     @staticmethod
-    def is_busy(tag):
+    def is_busy(tag:str) -> 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 True: busy OR False: not busy (inactive) OR None: not exists
         return bool(task is not None and not task.done.is_set())
 
-    def cancel(self):
+    def cancel(self) -> bool:
         """
         Cancel task (+cleanup)
         """
@@ -62,15 +89,38 @@ class TaskBase:
                     self.task.cancel()  # Try to cancel task by asyncio
                 except Exception as e:
                     if "can't cancel self" != str(e):
-                        errlog_add(f"[WARN] IRQ Task cancel: {e}")
+                        syslog(f"[WARN] IRQ Task cancel: {e}")
                 self.__task_del()
             else:
                 return False
         except Exception as e:
-            errlog_add(f"[ERR] Task kill: {e}")
+            syslog(f"[ERR] Task kill: {e}")
             return False
         return True
 
+    @staticmethod
+    async def feed(sleep_ms=1):
+        """
+        Feed event loop
+        :param sleep_ms: in millisecond
+        """
+        # TODO?: feed WDT - auto restart when system is frozen
+        if sleep_ms <= 0:
+            return await asyncio.sleep(0.000_000_1)     # 0 means: 100ns (Absolute minimum)
+        return await asyncio.sleep_ms(sleep_ms)
+
+    async def await_result(self, timeout:int=5):
+        """
+        Wait for task completion with timeout
+        :param timeout: in seconds
+        """
+        try:
+            await asyncio.wait_for(self.done.wait(), timeout)
+        except asyncio.TimeoutError:
+            return "Timeout has beed exceeded"
+        return self.out
+
+    ######  PRIVATE LCM METHODS  #####
     def __task_del(self, keep_cache=False):
         """
         Delete task from TASKS
@@ -79,22 +129,13 @@ class TaskBase:
         if self.tag in TaskBase.TASKS:
             if not keep_cache:              # True - In case of destructor
                 del TaskBase.TASKS[self.tag]
-        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
+        gcollect()
 
     def __del__(self):
         try:
             self.__task_del(keep_cache=True)
         except Exception as e:
-            errlog_add(f"[ERR] TaskBase.__del__: {e}")
+            syslog(f"[ERR] TaskBase.__del__: {e}")
 
 
 class NativeTask(TaskBase):
@@ -103,7 +144,7 @@ class NativeTask(TaskBase):
     - could be built in function or custom code from load modules
     """
 
-    def create(self, callback=None, tag=None):
+    def create(self, callback:callable=None, tag:str=None) -> dict:
         """
         Create async task with coroutine callback (no queue limit check!)
         + async socket server task
@@ -112,15 +153,11 @@ class NativeTask(TaskBase):
         """
         # Create task tag
         self.tag = f"aio.{ticks_ms()}" if tag is None else tag
-        if TaskBase.is_busy(self.tag):
+        if self.is_busy(self.tag):
             # Skip task if already running
-            return False
-
-        # Start task with coroutine callback
-        self.task = asyncio.get_event_loop().create_task(callback)
-        # Store Task object by key - for task control
-        TaskBase.TASKS[self.tag] = self
-        return True
+            return {self.tag: "Already running"}
+        # Create task with coroutine callback
+        return super()._create(callback)
 
     def __enter__(self):
         """
@@ -137,7 +174,7 @@ class NativeTask(TaskBase):
         Helper function for Task creation in Load Modules
         [HINT] Use python with feature to utilize this feature
         """
-        self.task_gc()    # Task pool cleanup
+        self._task_gc()    # Task pool cleanup
         self.done.set()
 
 
@@ -153,7 +190,7 @@ class MagicTask(TaskBase):
         self.__inloop = False        # [LM] Task while loop for LM callback
         self.__sleep = 20            # [LM] Task while loop - async wait (proc feed) [ms]
 
-    def create(self, callback=None, loop=None, sleep=None):
+    def create(self, callback:list=None, loop:bool=None, sleep:int=None) -> dict:
         """
         Create async task with function callback (with queue limit check)
         - wrap (sync) function into async task (task_wrapper)
@@ -163,20 +200,16 @@ class MagicTask(TaskBase):
         """
         # Create task tag
         self.tag = '.'.join(callback[0:2])
-        if TaskBase.is_busy(self.tag):
+        if self.is_busy(self.tag):
             # Skip task if already running
-            return False
-
+            return {self.tag: "Already running"}
         # Set parameters for async wrapper
         self.__callback = callback
         self.__inloop = self.__inloop if loop is None else loop
         # Set sleep value for async loop - optional parameter with min sleep limit check (20ms)
         self.__sleep = self.__sleep if sleep is None else sleep if sleep > 19 else self.__sleep
-
-        self.task = asyncio.get_event_loop().create_task(self.__task_wrapper())
-        # Store Task object by key - for task control
-        TaskBase.TASKS[self.tag] = self
-        return True
+        # Create task with coroutine callback
+        return super()._create(self.__task_wrapper())
 
     async def __task_wrapper(self):
         """
@@ -187,11 +220,11 @@ class MagicTask(TaskBase):
         - self.__msg_buf: lm msg object redirect to variable - store lm output
         """
         while True:
-            await asyncio.sleep_ms(self.__sleep)
+            await self.feed(self.__sleep)
             state, self.out = _exec_lm_core(self.__callback)
             if not state or not self.__inloop:
                 break
-        self.task_gc()    # Task pool cleanup
+        self._task_gc()    # Task pool cleanup
         self.done.set()
 
     def cancel(self):
@@ -208,8 +241,10 @@ class Manager:
     """
     micrOS async task handler
     """
+    __slots__ = ['_initialized', 'idle_counter']
     INSTANCE = None                      # Manager object
     LOAD = 0                             # CPU overload measure
+    INTERCON = None                      # Dynamic ref. for interconnect calls
 
     def __new__(cls):
         """
@@ -223,7 +258,7 @@ class Manager:
             cls.INSTANCE._initialized = False
             # Set async event loop exception handler
             asyncio.get_event_loop().set_exception_handler(lambda loop=None, context=None:
-                                                           errlog_add(f"[aio] exception: {loop}:{context}"))
+                                                           syslog(f"[aio] exception: {loop}:{context}"))
         return cls.INSTANCE
 
     def __init__(self):
@@ -248,7 +283,7 @@ class Manager:
         """
         if Manager._queue_len() >= TaskBase.QUEUE_SIZE:
             msg = f"[aio] Task queue full: {TaskBase.QUEUE_SIZE}"
-            errlog_add(msg)
+            syslog(msg)
             raise Exception(msg)
 
     async def idle_task(self):
@@ -263,28 +298,33 @@ 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
-                if self.idle_counter > 200:  # ~120 sec
+                if self.idle_counter > 300:  # ~ 3 min
                     self.idle_counter = 0    # Reset counter
-                    # Check and fix STA network (example: after power outage - micrOS boards boots faster then router)
+                    # Check and fix STA network (reboot if target ssid is available not yet connected)
                     sta_high_avail()
                 self.idle_counter += 1  # Increase counter
         except Exception as e:
-            errlog_add(f"[ERR] Idle task exists: {e}")
+            syslog(f"[ERR] Idle task exists: {e}")
         my_task.done.set()
 
     @staticmethod
-    def create_task(callback, tag=None, loop=False, delay=None):
+    def create_task(callback, tag:str=None, loop:bool=False, delay:int=None) -> dict:
         """
-        Primary interface
-        Generic task creator method
-            Create async Task with coroutine/list(lm call) callback
+        Primary interface of micrOS Generic task creator method
+        :param tag: task unique identifier
+        NativeTask:
+            :param callback: callable, coroutine to start a task
+        MagicTask with queue limiter:
+            :param callback: list of staring (command)
+            :param loop: MagicTask looping parameter
+            :param delay: MagicTask delay parameter
         """
         if isinstance(callback, list):
             # Check queue if task is Load Module
@@ -320,7 +360,7 @@ class Manager:
             _tasks = []
             tag_parts = tag.split('.')
             for t in TaskBase.TASKS:
-                if t.startswith(tag_parts[0]) and len(tag_parts) > 1 and tag_parts[1] == '*':
+                if len(tag_parts) > 1 and t.startswith('.'.join(tag_parts[0:-1])) and tag_parts[-1] == '*':
                     _tasks.append(t)
             if len(_tasks) == 0:
                 return []
@@ -344,20 +384,19 @@ class Manager:
         return '\n'.join(output)
 
     @staticmethod
-    def kill(tag):
+    def kill(tag:str) -> (bool, str):
         """
         Primary interface
         Kill/terminate async task
         - by tag: module.function
         - by tag module.*, kill all for selected module
         """
-
         def terminate(_tag):
             to_kill = TaskBase.TASKS.get(_tag, None)
             try:
                 return False if to_kill is None else to_kill.cancel()
             except Exception as e:
-                errlog_add(f"[ERR] Task kill: {e}")
+                syslog(f"[ERR] Task kill: {e}")
                 return False
 
         # Handle task group kill (module.*)
@@ -383,126 +422,130 @@ class Manager:
         try:
             asyncio.get_event_loop().run_forever()
         except Exception as e:
-            errlog_add(f"[aio] loop stopped: {e}")
+            syslog(f"[aio] loop stopped: {e}")
             asyncio.get_event_loop().close()
 
     @staticmethod
-    def server_task_msg(msg):
-        server_task = TaskBase.TASKS.get('server', None)
-        if server_task is None:
-            return
-        server_task.out = msg
+    def task_msg(tag:str, msg:str=None) -> bool|str:
+        """
+        Set/Get task message (for server virtual task, etc.)
+        """
+        _task = TaskBase.TASKS.get(tag, None)
+        if _task is None:
+            return False
+        # Get task output
+        if tag is None:
+            return _task.out
+        # Set task output
+        _task.out = msg
+        return True
 
 
 #################################################################
 #                      LM EXEC CORE functions                   #
 #################################################################
-
-def exec_lm_pipe(taskstr):
+def exec_builtins(func):
     """
-    Input: taskstr contains LM calls separated by ;
-    Used for execute config callback parameters (BootHook, ...)
+    [Decorator] Module execution built-in commands and modifiers
+    - modules         - show active modules list
+    - task kill ...   - task termination
+           show ...   - task output dump
+    -  ... >json      - postfix to jsonify the output
     """
-    try:
-        # Handle config default empty value (do nothing)
-        if taskstr.startswith('n/a'):
-            return True
-        # Execute individual commands - msgobj->"/dev/null"
-        for cmd in (cmd.strip().split() for cmd in taskstr.split(';') if len(cmd) > 0):
-            if not lm_exec(cmd)[0]:
-                console_write(f"|-[LM-PIPE] task error: {cmd}")
-    except Exception as e:
-        errlog_add(f"[ERR] exec_lm_pipe {taskstr}: {e}")
-        return False
-    return True
-
-
-def exec_lm_pipe_schedule(taskstr):
+    def wrapper(arg_list:list, jsonify=None):
+        # Ensure the parameter is a list of strings
+        if isinstance(arg_list, list) and arg_list:
+            # Postfix operator handling
+            # ... >json               - command output format option
+            # ... >>node01.local      - intercon: command execution on remote device by hostname/IP address
+            arg_list, json_flag = (arg_list[:-1], True) if arg_list[-1] == '>json' else (arg_list, False)
+            json_flag = jsonify if isinstance(jsonify, bool) else json_flag
+            arg_list, intercon_target = ((arg_list[:-1], arg_list[-1].replace(">>", ""))
+                                          if match(r'^>>[A-Za-z0-9._-]+$', arg_list[-1])
+                                          else (arg_list, None))
+
+            # INTERCONNECT
+            if intercon_target:
+                if Manager.INTERCON is None:
+                    from InterConnect import send_cmd
+                    Manager.INTERCON = send_cmd
+                try:
+                    out = Manager.INTERCON(host=intercon_target, cmd=arg_list)
+                except Exception as e:
+                    out = {}
+                    syslog(f"[ERR] Intercon: {e}")
+                return True, out
+
+            # 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, dumps({'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]:
+                        _, 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 False, None
+
+    return wrapper
+
+
+def lm_exec(arg_list:list, jsonify:bool=None):
     """
-    Wrapper for exec_lm_pipe
-    - Schedule LM executions from IRQs (extIRQ, timIRQ)
+    Main LM executor function with
+    - async (background)
+    - sync
+    (single) task execution (_exec_lm_core)
+    :param arg_list: command parameters
+    :param jsonify: request json output (controlled by the decorator)
+    Return Bool(OK/NOK), "Command output"
     """
-    try:
-        schedule(exec_lm_pipe, taskstr)
-        return True
-    except Exception as e:
-        errlog_add(f"[ERR] exec_lm_pipe_schedule: {e}")
-        return False
 
+    # [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:
+            return True, Manager.create_task(arg_list, loop=loop, delay=delay)
+        except Exception as e:
+            return False, {".".join(arg_list[0:2]): str(e)}
 
-def lm_exec(arg_list):
-    """
-    Main LM executor function wrapper
-    - handle async (background) task execution
-    - handle sync task execution (_exec_lm_core)
-    """
-
-    def task_manager(msg_list):
-        msg_len = len(msg_list)
-        # [1] Handle task manipulation commands: list, kill, show - return True -> Command handled
-        if 'task' == msg_list[0]:
-            # task list
-            if msg_len > 1 and 'list' == msg_list[1]:
-                if msg_len > 2 and msg_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 msg_len > 2:
-                if 'kill' == msg_list[1]:
-                    state, msg = Manager.kill(tag=msg_list[2])
-                    return True, msg
-                if 'show' == msg_list[1]:
-                    return True, Manager.show(tag=msg_list[2])
-            return True, "Invalid task cmd! Help: task list / kill <taskID> / show <taskID>"
-        # [2] Start async task, postfix: &, &&
-        if msg_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])
-            # 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
-    if len(arg_list) > 0 and arg_list[0] == 'modules':
-        return True, list([m.strip().replace('LM_', '') for m in modules if m.startswith('LM_')])
-    # [1] Run task command: start (&), list, kill, show
-    is_task, out = task_manager(arg_list)
-    if is_task:
-        return True, out
     # [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):
+@exec_builtins
+def _exec_lm_core(cmd_list, jsonify):
     """
-    CORE STRING REFERENCE EXECUTOR: MODULE.FUNCTION...
+    [CORE] Single command executor: MODULE.FUNCTION...
     :param cmd_list: list of string parameters
         [1] module name (LM)
         [2] function
         [3...] parameters (separator: space)
-    Built-in json output handler: >json
+    :param jsonify: request json output
+    Return Bool(OK/NOK), Str(Command output)
     """
 
-    def __conv_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 ('"', "'")]
@@ -514,12 +557,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], __conv_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
@@ -540,12 +580,13 @@ def _exec_lm_core(cmd_list):
             # ------------ LM output format: dict(jsonify) / str(raw) ------------- #
             # 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(
+                # jsonify (True) json output, (False) default, "human readable" output)
+                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])
+                # Special case:
+                #   jsonify (True) json output, (False) default, "human readable" formatted 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)
             # ---------------------------------------------------------------------- #
@@ -554,30 +595,55 @@ def _exec_lm_core(cmd_list):
                 # UNLOAD MODULE IF MEMORY ERROR HAPPENED + gc.collect
                 if lm_mod in modules:
                     del modules[lm_mod]
-                collect()
+                gcollect()
             # LM EXECUTION ERROR
             return False, f"Core error: {lm_mod}->{lm_func}: {e}"
     return False, "Shell: for hints type help.\nShell: for LM exec: [1](LM)module [2]function [3...]optional params"
 
+
 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
 
 
-def exec_lm_core_schedule(arg_list):
+#####################  LM EXEC CORE WRAPPERS  #####################
+
+def exec_lm_pipe(taskstr):
     """
-    Wrapper for lm_exec for Scheduler
-    - micropython scheduling
-        - exec protection for cron IRQ
+    Real-time multi command executor
+    - with #comment annotation feature
+    :param taskstr: contains LM calls separated by ;
+    Used for execute config callback parameters (BootHook, IRQs, ...)
     """
     try:
-        schedule(lm_exec, arg_list)
+        # Handle config default empty value (do nothing)
+        if taskstr.startswith('n/a'):
+            return True
+        # Execute individual commands - msgobj->"/dev/null"
+        for cmd in (cmd.strip().split() for cmd in taskstr.split(';') if len(cmd) > 0):
+            if cmd[0].startswith("#"):
+                console_write(f"[SKIP] exec_lm_pipe: {' '.join(cmd)}")
+                continue
+            if not lm_exec(cmd)[0]:
+                syslog(f"[WARN] exec_lm_pipe: {' '.join(cmd)}")
+    except Exception as e:
+        syslog(f"[ERR] exec_lm_pipe {taskstr}: {e}")
+        return False
+    return True
+
+
+def exec_lm_pipe_schedule(taskstr):
+    """
+    Scheduled Wrapper for exec_lm_pipe for IRQs (extIRQ, timIRQ,  cronIRQ)
+    """
+    try:
+        schedule(exec_lm_pipe, taskstr)
         return True
     except Exception as e:
-        errlog_add(f"[ERR] schedule_lm_exec {arg_list}: {e}")
+        syslog(f"[ERR] exec_lm_pipe_schedule: {e}")
         return False