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

micrOS/source/Logger.py

@@ -5,32 +5,49 @@ Module is responsible for System and User logging
 Designed by Marcell Ban aka BxNxM
 """
 from time import localtime
-from os import listdir, remove
+from re import match
+from uos import remove
+from Files import OSPath, path_join, ilist_fs, is_dir
 
 #############################################
 #        LOGGING WITH DATA ROTATION         #
 #############################################
 
+def _init_logger():
+    """ Init /logs folder """
+    if not is_dir(OSPath.LOGS):
+        OSPath.LOGS = OSPath._ROOT
+    return OSPath.LOGS
 
-def logger(data, f_name, limit):
+
+def _dir_select(f_name:str) -> str:
+    """
+    Select log dir based on file extension
+    :param f_name: filename with extension to detect target dir
+    """
+    if f_name.endswith(".log"):
+        return OSPath.LOGS
+    return OSPath.DATA
+
+
+def logger(data, f_name:str, limit:int):
     """
-    Create generic logger function
-    - implements log line rotation
-    - automatic time stump
-    :param data: input string data to log
+    Generic logger function with line rotation and time
+    :param data: data to log
     :param f_name: file name to use
     :param limit: line limit for log rotation
     return write verdict - true / false
     INFO: hardcoded max data number = 30
     """
-    def _logger(_data, _f_name, _limit, f_mode='r+'):
-        _limit = 30 if _limit > 30 else _limit
+    def _logger(f_mode='r+'):
+        nonlocal data, f_path, limit
+        limit = min(limit, 30)  # Hardcoded max data line = 30
         # [1] GET TIME STUMP
         ts_buff = [str(k) for k in localtime()]
         ts = ".".join(ts_buff[0:3]) + "-" + ":".join(ts_buff[3:6])
         # [2] OPEN FILE - WRITE DATA WITH TS
-        with open(_f_name, f_mode) as f:
-            _data = f"{ts} {_data}\n"
+        with open(f_path, f_mode) as f:
+            _data = f"{ts} {data}\n"
             # read file lines and filter by time stump chunks (hack for replace truncate)
             lines = [_l for _l in f.readlines() if '-' in _l and '.' in _l]
             # get file params
@@ -38,42 +55,43 @@ def logger(data, f_name, limit):
             lines.append(_data)
             f.seek(0)
             # line data rotate
-            if lines_len >= _limit:
-                lines = lines[-_limit:]
-                lines_str = ''.join(lines)
-            else:
-                lines_str = ''.join(lines)
+            if lines_len >= limit:
+                lines = lines[-limit:]
             # write file
-            f.write(lines_str)
+            f.write(''.join(lines))
 
+    f_path = path_join(_dir_select(f_name), f_name)
     # Run logger
     try:
         # There is file - append 'r+'
-        _logger(data, f_name, limit)
+        _logger()
     except:
         try:
             # There is no file - create 'a+'
-            _logger(data, f_name, limit, 'a+')
+            _logger('a+')
         except:
             return False
     return True
 
 
-def log_get(f_name, msgobj=None):
+def log_get(f_name:str, msgobj=None):
     """
-    Get and stream (ver osocket/stdout) .log file's content and count "critical" errors
-    - critical error tag in log line: [ERR]
+    Generic file getter for .log files
+    - log content critical [ERR] counter
     """
+    f_path = path_join(_dir_select(f_name), f_name)
     err_cnt = 0
     try:
-        with open(f_name, 'r') as f:
+        if msgobj is not None:
+            msgobj(f_path)
+        with open(f_path, 'r') as f:
             eline = f.readline().strip()
             while eline:
                 # GET error from log line (tag: [ERR])
                 err_cnt += 1 if "[ERR]" in eline else 0
                 # GIVE BACK .log file contents
                 if msgobj is not None:
-                    msgobj(eline)
+                    msgobj(f"\t{eline}")
                 eline = f.readline().strip()
     except:
         pass
@@ -81,14 +99,33 @@ def log_get(f_name, msgobj=None):
 
 
 def syslog(data=None, msgobj=None):
+    """
+    System log setter/getter
+    :param data: None - read logs, str - write logs
+    :param msgobj: function to stream .log files
+    """
     if data is None:
-        return log_get('err.log', msgobj)
-    return logger(data, 'err.log', limit=6)
+        # READ LOGS
+        err_cnt = sum([log_get(f, msgobj) for f in ilist_fs(OSPath.LOGS, type_filter='f') if f.endswith(".sys.log")])
+        return err_cnt
+    # WRITE LOGS - [target].sys.log automatic log level detection
+    _match = match(r"^\[([^\[\]]+)\]", data)
+    log_lvl = _match.group(1).lower() if _match else 'user'
+    f_name = f"{log_lvl}.sys.log" if log_lvl in ("err", "warn", "boot", "info") else 'user.sys.log'
+    return logger(data, f_name, limit=4)
 
 
 def log_clean(msgobj=None):
-    to_del = [file for file in listdir() if file.endswith('.log')]
+    """
+    Clean logs folder
+    """
+    logs_dir = OSPath.LOGS
+    to_del = [file for file in ilist_fs(logs_dir, type_filter='f') if file.endswith('.log')]
     for _del in to_del:
+        _del = path_join(logs_dir, _del)
         if msgobj is not None:
             msgobj(f" Delete: {_del}")
         remove(_del)
+
+# Init log folder at module load
+_init_logger()

micrOS/source/Network.py

@@ -19,7 +19,8 @@ from utime import sleep_ms
 from network import AP_IF, STA_IF, WLAN
 from machine import unique_id
 from Config import cfgget, cfgput
-from Debug import console_write, errlog_add
+from Debug import console_write, syslog
+from microIO import detect_platform
 
 
 class NW:
@@ -48,23 +49,36 @@ def ifconfig():
 
 
 def set_dev_uid():
+    if detect_platform() == "esp32c6":
+        # ESP32-C6: unique_id() not unique (can return same ID on different boards)
+        try:
+            sta = WLAN(STA_IF)
+            was = sta.active()
+            if not was: sta.active(True)
+            uid = hexlify(sta.config('mac')).decode()
+            if not was: sta.active(False)
+            cfgput('hwuid', f"micr{uid}OS")
+            return
+        except Exception as e:
+            syslog(f"[ERR] set_dev_uid (esp32c6): {e}")
+    # Legacy micrOS device UID generation (+fallback)
     try:
         cfgput('hwuid', f'micr{hexlify(unique_id()).decode("utf-8")}OS')
     except Exception as e:
-        errlog_add(f"[ERR] set_dev_uid error: {e}")
+        syslog(f"[ERR] set_dev_uid: {e}")
 
 
 def get_mac():
-    return WLAN().config('mac')
+    """ Get AP/STA mac address as raw binary data"""
+    return NW.NIF.config('mac')
 
 #################################################################
 #                       SET WIFI STA MODE                       #
 #################################################################
 
 
-def __select_available_wifi_nw(sta_if, raw_essid, raw_pwd):
+def _select_available_wifi_nw(raw_essid:str, raw_pwd:str):
     """
-    raw_essid: essid parameter, in case of multiple values separator is ;
     raw_pwd: essid pwd parameter,  in case of multiple values separator is ;
     return detected essid with corresponding password
     """
@@ -72,18 +86,18 @@ def __select_available_wifi_nw(sta_if, raw_essid, raw_pwd):
         essid = essid.strip()
         # Scan wifi network - retry workaround
         for _ in range(0, 2):
-            if essid in (wifispot[0].decode('utf-8') for wifispot in sta_if.scan()):
+            if essid in (wifispot[0].decode('utf-8') for wifispot in NW.NIF.scan()):
                 console_write(f'\t| - [NW: STA] ESSID WAS FOUND: {essid}')
                 try:
                     return essid, str(raw_pwd.split(';')[idx]).strip()
                 except Exception as e:
-                    errlog_add(f'[ERR][SET STA] stapwd config error: {e}')
+                    syslog(f'[ERR][SET STA] stapwd config error: {e}')
             sleep_ms(400)
     return None, ''
 
 
-def set_wifi(essid, pwd, timeout=60):
-    console_write(f'[NW: STA] SET WIFI STA NW {essid}')
+def set_wifi(essid:str, pwd:str, timeout=60):
+    console_write('[NW: STA] Enable')
 
     # Disable AP mode
     ap_if = WLAN(AP_IF)
@@ -94,18 +108,25 @@ def set_wifi(essid, pwd, timeout=60):
     # Set STA and Connect
     sta_if = WLAN(STA_IF)
     sta_if.active(True)
+    NW.NIF = sta_if
     # Handle rsp2-w limitation (try)
     try:
         # Set custom DHCP hostname for dhcp name resolve
         sta_if.config(dhcp_hostname=cfgget('devfid'))
     except Exception as e:
-        console_write(f"dhcp_hostname conf error: {e}")
+        syslog(f"[ERR] STA dhcp_hostname: {e}")
+    if cfgget("espnow"):
+        try:
+            # prevents Wi-Fi PS from dropping ESP-NOW frames while STA is connected.
+            sta_if.config(pm=sta_if.PM_NONE)
+        except Exception as e:
+            syslog(f"[ERR] ESPNow STA PM_NONE: {e}")
     # Check are we already connected
     if sta_if.isconnected():
         console_write(f"\t| [NW: STA] ALREADY CONNECTED TO {essid}")
     else:
         # Multiple essid and pwd handling with retry mechanism
-        essid, pwd = __select_available_wifi_nw(sta_if, essid, pwd)
+        essid, pwd = _select_available_wifi_nw(essid, pwd)
 
         # Connect to the located wifi network
         if essid is not None:
@@ -118,7 +139,7 @@ def set_wifi(essid, pwd, timeout=60):
                 timeout -= 1
                 sleep_ms(500)
             # Set static IP - here because some data comes from connection. (subnet, etc.)
-            if sta_if.isconnected() and __set_wifi_dev_static_ip(sta_if):
+            if sta_if.isconnected() and _set_wifi_dev_static_ip(sta_if):
                 sta_if.disconnect()
                 del sta_if
                 return set_wifi(essid, pwd)
@@ -131,11 +152,10 @@ def set_wifi(essid, pwd, timeout=60):
     # Store STA IP (make it static ip)
     cfgput("devip", str(sta_if.ifconfig()[0]))
     set_dev_uid()
-    NW.NIF = sta_if
     return sta_if.isconnected()
 
 
-def __set_wifi_dev_static_ip(sta_if):
+def _set_wifi_dev_static_ip(sta_if:STA_IF):
     console_write("[NW: STA] Set device static IP.")
     stored_ip = cfgget('devip')
     if 'n/a' not in stored_ip.lower() and '.' in stored_ip:
@@ -149,7 +169,7 @@ def __set_wifi_dev_static_ip(sta_if):
                 sta_if.ifconfig(tuple(conn_ips))
                 return True     # was reconfigured
             except Exception as e:
-                errlog_add(f"[ERR][STA] StaticIP conf failed: {e}")
+                syslog(f"[ERR][STA] StaticIP conf failed: {e}")
         else:
             console_write(f"[NW: STA][SKIP] StaticIP conf.: {stored_ip} ? {conn_ips[0]}")
     else:
@@ -162,7 +182,7 @@ def __set_wifi_dev_static_ip(sta_if):
 #################################################################
 
 
-def set_access_point(_essid, _pwd, _authmode=3):
+def set_access_point(_essid:str, _pwd:str, _authmode:int=3):
     console_write(f"[NW: AP] SET AP MODE: {_essid} - {_pwd} - auth mode: {_authmode} (if possible)")
 
     sta_if = WLAN(STA_IF)
@@ -171,6 +191,7 @@ def set_access_point(_essid, _pwd, _authmode=3):
 
     ap_if = WLAN(AP_IF)
     ap_if.active(True)
+    NW.NIF = ap_if
     # Set WiFi access point name (formally known as ESSID) and WiFi authmode (3): WPA2-PSK
     try:
         # Config #1 (esp)
@@ -184,12 +205,11 @@ def set_access_point(_essid, _pwd, _authmode=3):
             # Config #2 (rp2-w)???
             ap_if.config(essid=_essid, password=_pwd)
         except Exception as e2:
-            errlog_add(f"[ERR][AP] config failed: {e2}")
+            syslog(f"[ERR][AP] config failed: {e2}")
     if not (ap_if.active() and str(ap_if.config('essid')) == str(_essid)):
-        errlog_add("[ERR][AP] error")
+        syslog("[ERR][AP] error")
     console_write(f"\t|\t| [NW: AP] network config: {str(ap_if.ifconfig())}")
     set_dev_uid()
-    NW.NIF = ap_if
     return ap_if.active()
 
 #################################################################
@@ -228,7 +248,7 @@ def sta_high_avail():
         raw_essid = cfgget("staessid")
         wifi_avail = False
         # [CHECK 2] check known network is available
-        for idx, essid in enumerate(raw_essid.split(';')):
+        for essid in raw_essid.split(';'):
             essid = essid.strip()
             # Scan wifi network - retry workaround
             for _ in range(0, 2):
@@ -241,7 +261,7 @@ def sta_high_avail():
         if wifi_avail or not ap_if.active():
             # ACTION: Restart micrOS node (boot phase automatically detects nw mode)
             from machine import reset
-            console_write("[Restart] network repair")
+            syslog("[WARN] Restart, network repair")
             reset()
         return f'{cfgget("nwmd")} mode NOK, wifi avail: {wifi_avail}'
     return f'{cfgget("nwmd")} mode OK'

micrOS/source/Notify.py

@@ -6,12 +6,13 @@ Common:
     - lm_execute
 Supported notification subscribers (add_subscriber)
     - LM_telegram
+    - LM_mqtt_client
 Designed by Marcell Ban aka BxNxM
 """
 
 from Config import cfgget
 from Tasks import lm_exec, lm_is_loaded
-from Debug import errlog_add
+from Debug import syslog
 
 #########################################
 #          micrOS Notifications         #
@@ -33,44 +34,69 @@ class Notify:
         raise Exception("Subscribe error, Notify parent missing")
 
     @staticmethod
-    def message(text, reply_to=None, chat_id=None):
+    def send_msg(text, *args, **kwargs):
         """
-        Send message to all subscribers
+        This method has to be implemented by the child class
         """
-        exit_code = 0
+        raise NotImplementedError("Child class must implement send_msg method")
+
+    @staticmethod
+    def message(text, *args, **kwargs):
+        """
+        Send message to all subscribers - Notify send_msg(text, ...) agents
+        :param text: text message to send
+        :param channels (optional): select communication interface(s) by class name
+               e.g. "Telegram", "MQTT" or an iterable of these.
+               If omitted or empty, sends over all available channels.
+        Telegram params (optional):
+            reply_to: message id to reply to (optional) - default: None
+             chat_id: chat identifier - default: None -> auto resolve in child class
+        MQTT client params (optional):
+            topic: mqtt topic to send the message - default: None -> auto resolve in child class
+        return: verdict and metrics
+        """
+        errors, channels, interfaces = 0, kwargs.get("channels", ()), set()
+        channels = (channels,) if isinstance(channels, str) else tuple(channels)
         for s in Notify._SUBSCRIBERS:
+            name = s.__class__.__name__
             try:
-                s.send_msg(text, reply_to, chat_id)
+                if len(channels) == 0 or name in channels:
+                    s.send_msg(text, *args, **kwargs)
+                    interfaces.add(name)
             except Exception as e:
-                errlog_add(f"[ERR] Notify: {e}")
-                exit_code+=1
-        return f"Sent N{len(Notify._SUBSCRIBERS)} ({exit_code})"
+                syslog(f"[ERR] Notify.{name}: {e}")
+                errors+=1
+        return (f"Sent over {', '.join(interfaces)} ({len(interfaces)}/{len(Notify._SUBSCRIBERS)}) client(s)"
+                f" - errors: ({errors})")
 
     @staticmethod
     def notifications(state=None):
         """
-        Setter for disable/enable notification messages
+        Setter for disable/enable notification messages (over LM_system)
+        :param state: True/False/ None(default) - show current state
         """
         if isinstance(state, bool):
             Notify.GLOBAL_NOTIFY = state
-        return f"Notifications: {'enabled' if Notify.GLOBAL_NOTIFY else 'disabled'}"
+        targets = ", ".join(s.__class__.__name__ for s in Notify._SUBSCRIBERS)
+        return f"Notifications[{targets}]: {'enabled' if Notify.GLOBAL_NOTIFY else 'disabled'}"
 
     @staticmethod
-    def notify(text, reply_to=None, chat_id=None):
+    def notify(text, *args, **kwargs):
         """
-        Notification sender
+        Notification sender for Load Modules
         """
         if Notify.GLOBAL_NOTIFY:
-            return Notify.message(text, reply_to, chat_id)
+            return Notify.message(text, *args, **kwargs)
         return "Notifications disabled"
 
     @staticmethod
-    def lm_execute(cmd_args):
-        """Executor with basic access handling"""
-        if lm_is_loaded(cmd_args[0]):
-            try:
-                _, out = lm_exec(cmd_args)
-            except Exception as e:
-                out = str(e)
-            return True, out
-        return False, cmd_args[0]
+    def lm_execute(cmd_args, jsonify=False, secure=True):
+        """Load Module Executor with basic access handling"""
+        state = False
+        if secure and not lm_is_loaded(cmd_args[0]):
+            return state, f"NotAllowed {cmd_args[0]}"
+        try:
+            state, out = lm_exec(cmd_args, jsonify)
+        except Exception as e:
+            out = str(e)
+        return state, out