micrOSDevToolKit 2.9.1__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
+    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                    #
@@ -43,18 +44,20 @@ class TaskBase:
         self.done = asyncio.Event()  # Store task done state
         self.out = ""                # Store task output
 
-    @staticmethod
-    def is_busy(tag) -> bool:
+    ######  BASE METHODS FOR CHILD CLASSES  ####
+    def _create(self, callback:callable) -> dict:
         """
-        Check task is busy by tag
-        :param tag: for task selection
+        Create async task and register it to TASKS dict by tag
+        :param callback: coroutine function
         """
-        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())
+        # 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():
+    def _task_gc():
         """
         Automatic passive task deletion over QUEUE_SIZE
         """
@@ -63,7 +66,18 @@ class TaskBase:
         if len(passive) >= keep:
             for i in range(0, len(passive)-keep+1):
                 del TaskBase.TASKS[passive[i]]
-            collect()  # GC collect
+            gcollect()
+
+    ######  PUBLIC TASK METHODS  #####
+    @staticmethod
+    def is_busy(tag:str) -> bool:
+        """
+        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) OR None: not exists
+        return bool(task is not None and not task.done.is_set())
 
     def cancel(self) -> bool:
         """
@@ -75,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
@@ -92,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
-    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)
+        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):
@@ -116,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
@@ -125,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):
         """
@@ -150,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()
 
 
@@ -166,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)
@@ -176,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):
         """
@@ -199,15 +219,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 self.feed(self.__sleep)
-            state, self.out = _exec_lm_core(self.__callback, jsonify)
+            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):
@@ -227,6 +244,7 @@ class Manager:
     __slots__ = ['_initialized', 'idle_counter']
     INSTANCE = None                      # Manager object
     LOAD = 0                             # CPU overload measure
+    INTERCON = None                      # Dynamic ref. for interconnect calls
 
     def __new__(cls):
         """
@@ -240,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):
@@ -265,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):
@@ -287,21 +305,26 @@ class Manager:
                 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
@@ -337,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 []
@@ -361,7 +384,7 @@ class Manager:
         return '\n'.join(output)
 
     @staticmethod
-    def kill(tag):
+    def kill(tag:str) -> (bool, str):
         """
         Primary interface
         Kill/terminate async task
@@ -373,7 +396,7 @@ class Manager:
             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.*)
@@ -399,15 +422,23 @@ 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
 
 
 #################################################################
@@ -415,23 +446,40 @@ class Manager:
 #################################################################
 def exec_builtins(func):
     """
-    Module execution built-in commands and modifiers
+    [Decorator] 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
+    -  ... >json      - postfix to jsonify the output
     """
-    def wrapper(arg_list, jsonify=None):
+    def wrapper(arg_list: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]
+            # 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)
@@ -439,22 +487,24 @@ def exec_builtins(func):
                 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')
+                    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]:
-                        state, msg = Manager.kill(tag=arg_list[2])
+                        _, 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
 
 
-@exec_builtins
-def lm_exec(arg_list, jsonify):
+def lm_exec(arg_list:list, jsonify:bool=None):
     """
     Main LM executor function with
     - async (background)
@@ -474,21 +524,16 @@ def lm_exec(arg_list, jsonify):
         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)
+            return True, 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"
+            return False, {".".join(arg_list[0:2]): str(e)}
 
     # [2] Sync "realtime" task execution
     state, out = _exec_lm_core(arg_list, jsonify)
     return state, out
 
 
+@exec_builtins
 def _exec_lm_core(cmd_list, jsonify):
     """
     [CORE] Single command executor: MODULE.FUNCTION...
@@ -497,7 +542,7 @@ def _exec_lm_core(cmd_list, jsonify):
         [2] function
         [3...] parameters (separator: space)
     :param jsonify: request json output
-    Return Bool(OK/NOK), STR(Command output)
+    Return Bool(OK/NOK), Str(Command output)
     """
 
     def _func_params(param):
@@ -535,11 +580,12 @@ def _exec_lm_core(cmd_list, jsonify):
             # ------------ 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"
+                # 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"
+                # 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)
@@ -549,7 +595,7 @@ def _exec_lm_core(cmd_list, jsonify):
                 # 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"
@@ -580,13 +626,13 @@ def exec_lm_pipe(taskstr):
             return True
         # Execute individual commands - msgobj->"/dev/null"
         for cmd in (cmd.strip().split() for cmd in taskstr.split(';') if len(cmd) > 0):
-            if len(cmd) > 0 and cmd[0].startswith("#"):
+            if cmd[0].startswith("#"):
                 console_write(f"[SKIP] exec_lm_pipe: {' '.join(cmd)}")
-                return True
+                continue
             if not lm_exec(cmd)[0]:
-                errlog_add(f"[WARN] exec_lm_pipe: {cmd}")
+                syslog(f"[WARN] exec_lm_pipe: {' '.join(cmd)}")
     except Exception as e:
-        errlog_add(f"[ERR] exec_lm_pipe {taskstr}: {e}")
+        syslog(f"[ERR] exec_lm_pipe {taskstr}: {e}")
         return False
     return True
 
@@ -599,5 +645,5 @@ def exec_lm_pipe_schedule(taskstr):
         schedule(exec_lm_pipe, taskstr)
         return True
     except Exception as e:
-        errlog_add(f"[ERR] exec_lm_pipe_schedule: {e}")
+        syslog(f"[ERR] exec_lm_pipe_schedule: {e}")
         return False

micrOS/source/Time.py

@@ -14,27 +14,29 @@ from network import WLAN, STA_IF
 from utime import sleep_ms, time, mktime, localtime
 
 from Config import cfgput, cfgget
-from Debug import errlog_add, console_write
+from Debug import syslog, console_write
 from urequests import get as http_get
+from Files import OSPath, path_join
 
 
 class Sun:
     TIME = {}
     UTC = cfgget('utc')  # STORED IN MINUTE
     BOOTIME = None       # Initialize BOOTIME: Not SUN, but for system uptime
+    FILE_CACHE = path_join(OSPath.DATA, 'sun.cache')
 
 
-def set_time(year, month, mday, hour, min, sec):
+def set_time(year, month, mday, hour, minute, sec):
     """
     Set Localtime + RTC Clock manually + update BOOTIME/uptime
         https://docs.micropython.org/en/latest/library/machine.RTC.html
     """
     # Make time from tuple to sec
-    time_sec = mktime((year, month, mday, hour, min, sec, 0, 0))
+    time_sec = mktime((year, month, mday, hour, minute, sec, 0, 0))
     # Set localtime
     localtime(time_sec)
     # Set RTC
-    RTC().datetime((year, month, mday, 0, hour, min, sec, 0))
+    RTC().datetime((year, month, mday, 0, hour, minute, sec, 0))
     # (re)set uptime when settime - normally at boot time
     if Sun.BOOTIME is None:
         Sun.BOOTIME = time()
@@ -47,7 +49,7 @@ def ntp_time():
     :return: ntp date struct
     """
     if not WLAN(STA_IF).isconnected():
-        errlog_add("STA not connected: ntptime")
+        syslog("[WARN] STA not connected: ntptime")
         return False
 
     def get_ntp():
@@ -83,31 +85,30 @@ def ntp_time():
             console_write(f"ntptime error.:{e}")
             err = e
         sleep_ms(100)
-    errlog_add(f"[ERR] ntptime: {err}")
+    syslog(f"[ERR] ntptime: {err}")
     return False
 
 
 def __sun_cache(mode):
     """
-    pds - persistent data structure
+    File cache
     modes:
         r - recover, s - save
     """
     if mode == 's':
         # SAVE CACHE
-        temp = {}
         try:
-            with open('sun.pds', 'w') as f:
-                for k, v in Sun.TIME.items():
-                    temp[k] = tuple([str(t) for t in v])
-                f.write(';'.join([f'{k}:{"-".join(v)}' for k, v in temp.items()]))
+            with open(Sun.FILE_CACHE, 'w') as f:
+                cache = {k:tuple([str(t) for t in v]) for k, v in Sun.TIME.items()}
+                f.write(';'.join([f'{k}:{"-".join(v)}' for k, v in cache.items()]))
         except:
-            errlog_add("[ERR] Cannot write sun cache")
+            syslog("[ERR] Cannot write sun cache")
         return
     try:
         # RESTORE CACHE
-        with open('sun.pds', 'r') as f:
-            buff = {data.split(':')[0]: data.split(':')[1].split('-') for data in f.read().strip().split(';')}
+        with open(Sun.FILE_CACHE, 'r') as f:
+            buff = {data.split(':')[0]: data.split(':')[1].split('-')
+                    for data in f.read().strip().split(';')}
             for k, v in buff.items():
                 Sun.TIME[k] = tuple([int(e) for e in v])
     except:
@@ -140,7 +141,7 @@ def suntime():
         Sun.UTC = int(response.get('offset') / 60)      # IN MINUTE
         cfgput('utc', Sun.UTC, True)
     except Exception as e:
-        errlog_add(f'[ERR] ip-api: {e} data: {response}')
+        syslog(f'[ERR] ip-api: {e} data: {response}')
         return Sun.TIME
 
     # SUNSET-SUNRISE API REQUEST HANDLING
@@ -155,7 +156,7 @@ def suntime():
             sun = {'sunrise': time_regex.search(results.get('sunrise')).group(1).split(':'),
                    'sunset': time_regex.search(results.get('sunset')).group(1).split(':')}
         except Exception as e:
-            errlog_add(f'[ERR] sunrise-api: {e} data: {response}')
+            syslog(f'[ERR] sunrise-api: {e} data: {response}')
     # Try to parse response by expected sun_keys
     try:
         for key in sun:
@@ -163,7 +164,7 @@ def suntime():
             sun[key][0] += int(Sun.UTC / 60)
             sun[key] = tuple(sun[key])
     except Exception as e:
-        errlog_add(f'sunrise-api parse error: {e} sun: {sun}')
+        syslog(f'[WARN] sunrise-api parse error: {e} sun: {sun}')
         # Retrieve cached data and return
         __sun_cache('r')  # Using Sun.TIME
         console_write('[suntime] loaded from cache')