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

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 hexlify(WLAN().config('mac'), ':').decode()
+    """ 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

@@ -1,226 +1,102 @@
-from sys import modules
-import urequests
+"""
+Module is responsible for Notification handling
+Common:
+    - notifications None/True/False
+    - notify 'text'
+    - 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 console_write
+from Debug import syslog
 
 #########################################
 #          micrOS Notifications         #
 #          with Telegram Class          #
 #########################################
-
-
-class Telegram:
-    # Telegram bot token and chat ID
-    # https://core.telegram.org/bots/api
-    _TOKEN = None
-    _CHAT_IDS = set()                                # Telegram bot chat IDs - multi group support - persistent caching
-    _API_PARAMS = "?offset=-1&limit=1&timeout=2"     # Generic API params - optimization
-    _DEVFID = cfgget('devfid')                       # For reply message (pre text)
-    _IN_MSG_ID = None
+class Notify:
+    GLOBAL_NOTIFY = True            # Enable Global notifications
+    _DEVFID = cfgget('devfid')      # For reply message (pre text)
+    _SUBSCRIBERS = set()            # Store set of notification objects: send_msg
 
     @staticmethod
-    def __id_cache(mode):
+    def add_subscriber(instance):
         """
-        pds - persistent data structure
-        modes:
-            r - recover, s - save
+        Add Notification agent like: Telegram
         """
-        if mode == 's':
-            # SAVE CACHE
-            console_write("[NTFY] Save chatIDs cache...")
-            with open('telegram.pds', 'w') as f:
-                f.write(','.join([str(k) for k in Telegram._CHAT_IDS]))
-            return
-        try:
-            # RESTORE CACHE
-            console_write("[NTFY] Restore chatIDs cache...")
-            with open('telegram.pds', 'r') as f:
-                # set() comprehension
-                Telegram._CHAT_IDS = {int(k) for k in f.read().strip().split(',')}
-        except:
-            pass
+        if isinstance(instance, Notify):
+            Notify._SUBSCRIBERS.add(instance)
+            return True
+        raise Exception("Subscribe error, Notify parent missing")
 
     @staticmethod
-    def __bot_token():
-        """Get bot token"""
-        if Telegram._TOKEN is None:
-            token = cfgget('telegram')
-            if token is None or token == 'n/a':
-                return None
-            Telegram._TOKEN = token
-        return Telegram._TOKEN
-
-    @staticmethod
-    def send_msg(text, reply_to=None, chat_id=None):
+    def send_msg(text, *args, **kwargs):
         """
-        Send a message to the Telegram chat by chat_id
-        :param text: text to send
-        :param reply_to: reply to specific message, if None, simple reply
-        :param chat_id: chat_id to reply on, if None, reply to all known
-        RETURN None when telegram bot token is missing
+        This method has to be implemented by the child class
         """
-        def _send(chid):
-            """Send message to chat_id (chid)"""
-            data = {"chat_id": chid, "text": f"{Telegram._DEVFID}⚙️\n{text}"}
-            if isinstance(reply_to, int):
-                data['reply_to_message_id'] = reply_to
-                Telegram._IN_MSG_ID = reply_to
-            _, _resp = urequests.post(url, headers={"Content-Type": "application/json"}, json=data, jsonify=True, sock_size=128)
-            console_write(f"\tSend message:\n{data}\nresponse:\n{_resp}")
-            return _resp
-
-        def _get_chat_ids():
-            """Return chat ID or None (in case of no token or cannot get ID)"""
-            if len(Telegram._CHAT_IDS) == 0:
-                Telegram.get_msg()  # It will update the Telegram.CHAT_IDS
-            console_write(f"\tGet chatIDs: {Telegram._CHAT_IDS}")
-            return Telegram._CHAT_IDS
-        
-        # --------------------- FUNCTION MAIN ------------------------ #
-        console_write("[NTFY] SEND MESSAGE")
-        # Check bot token
-        bot_token = Telegram.__bot_token()
-        if bot_token is None:
-            return None
-        url = f"https://api.telegram.org/bot{bot_token}/sendMessage{Telegram._API_PARAMS}"
-
-        verdict = ""
-        # Reply to ALL (notification) - chat_id was not provided
-        if chat_id is None:
-            console_write("\tREPLY ALL")
-            for _chat_id in _get_chat_ids():
-                resp_json = _send(chid=_chat_id)
-                verdict += f'Sent{_chat_id};' if resp_json['ok'] else str(resp_json)
-        else:
-            console_write(f"\tREPLY TO {chat_id}")
-            # Direct reply to chat_id
-            resp_json = _send(chid=chat_id)
-            verdict = f'Sent{chat_id}' if resp_json['ok'] else str(resp_json)
-        return verdict
+        raise NotImplementedError("Child class must implement send_msg method")
 
     @staticmethod
-    def get_msg():
+    def message(text, *args, **kwargs):
         """
-        Get the last message from the Telegram chat.
-        RETURN None when telegram bot token is missing
+        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
         """
-
-        def _update_chat_ids():
-            """
-            Update known chat_id-s and cache them
-            - return active chat_id frm resp_json
-            """
-            console_write("[NTFY GET] update chatIDs")
-            _cid = None
-            if resp_json.get("ok", None) and len(resp_json["result"]) > 0:
-                _cid = resp_json["result"][-1]["message"]["chat"]["id"]
-                # LIMIT Telegram._CHAT_IDS NOTIFICATION CACHE TO 3 IDs
-                if len(Telegram._CHAT_IDS) < 4:
-                    _ids = len(Telegram._CHAT_IDS)
-                    Telegram._CHAT_IDS.add(_cid)
-                    if len(Telegram._CHAT_IDS) - _ids > 0:  # optimized save (slow storage access)
-                        Telegram.__id_cache('s')
-            else:
-                Telegram.__id_cache('r')
-                if len(Telegram._CHAT_IDS) == 0:
-                    error_message = resp_json.get("description", "Unknown error")
-                    raise Exception(f"Error retrieving chat ID: {error_message}")
-            return _cid
-
-        # --------------------- FUNCTION MAIN ------------------------ #
-        console_write("[NTFY] GET MESSAGE")
-        bot_token = Telegram.__bot_token()
-        if bot_token is None:
-            return None
-        response = {'sender': None, 'text': None, 'm_id': -1, 'c_id': None}
-        url = f"https://api.telegram.org/bot{bot_token}/getUpdates{Telegram._API_PARAMS}"
-        console_write(f"\t1/2[GET] request: {url}")
-        _, resp_json = urequests.get(url, jsonify=True, sock_size=128)
-        if len(resp_json["result"]) > 0:
-            response['c_id'] = _update_chat_ids()
-            resp = resp_json["result"][-1]["message"]
-            response['sender'] = f"{resp['chat']['first_name']}{resp['chat']['last_name']}" if resp['chat'].get('username', None) is None else resp['chat']['username']
-            response['text'], response['m_id'] = resp['text'], resp['message_id']
-        console_write(f"\t2/2[GET] response: {response}")
-        return response
+        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:
+                if len(channels) == 0 or name in channels:
+                    s.send_msg(text, *args, **kwargs)
+                    interfaces.add(name)
+            except Exception as e:
+                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 receive_eval():
+    def notifications(state=None):
         """
-        READ - VALIDATE - EXECUTE - REPLY LOOP
-        - can be used in async loop
-        RETURN None when telegram bot token is missing
+        Setter for disable/enable notification messages (over LM_system)
+        :param state: True/False/ None(default) - show current state
         """
-
-        console_write("[NTFY] REC&EVAL sequence")
-
-        # Return data structure template
-        verdict = None
-
-        def lm_execute(cmd_args):
-            nonlocal verdict
-            if lm_is_loaded(cmd_args[0]):
-                verdict = f'[UP] Exec: {" ".join(cmd_args[0])}'
-                try:
-                    _, out = lm_exec(cmd_args)
-                except Exception as e:
-                    out = str(e)
-                Telegram.send_msg(out, reply_to=m_id)
-            else:
-                verdict = f'[UP] NoAccess: {cmd_args[0]}'
-                Telegram._IN_MSG_ID = m_id
-
-        # -------------------------- FUNCTION MAIN -------------------------- #
-        # Poll telegram chat
-        data = Telegram.get_msg()
-        if data is None:
-            return data
-        # Get msg, msg_id, chat_id as main input data source
-        msg_in, m_id, c_id = data['text'], data['m_id'], data['c_id']
-        if msg_in is not None and m_id != Telegram._IN_MSG_ID:
-            # replace single/double quotation to apostrophe (str syntax for repl interpretation)
-            msg_in = msg_in.replace('‘', "'").replace('’', "'").replace('“', '"').replace('”', '"')
-            # [TELEGRAM CMD] /PING - Get auto reply from node - loaded modules
-            #               Example: /ping
-            if msg_in.startswith('/ping'):
-                # Parse loaded modules
-                _loaded_mods = [lm.replace('LM_', '') for lm in modules if lm.startswith('LM_')] + ['task']
-                Telegram.send_msg(', '.join(_loaded_mods), reply_to=m_id, chat_id=c_id)
-            # [TELEGRAM CMD] /CMD_SELECT - Load Module execution handling - SELECTED DEV. MODE
-            #               Example: /cmd_select device module func param(s)
-            elif msg_in.startswith('/cmd_select'):
-                cmd_lm = msg_in.replace('/cmd_select', '').strip().split()
-                # [Compare] cmd selected device param with DEVFID (device/prompt name)
-                if cmd_lm[0] in Telegram._DEVFID:
-                    lm_execute(cmd_lm[1:])
-                else:
-                    verdict = f'[UP] NoSelected: {cmd_lm[0]}'
-            # [TELEGRAM CMD] /CMD - Load Module execution handling - ALL mode
-            #               Example: /cmd module func param(s)
-            elif msg_in.startswith('/cmd'):
-                cmd_lm = msg_in.replace('/cmd', '').strip().split()
-                lm_execute(cmd_lm)
-        else:
-            verdict = "[UP] NoExec"
-        console_write(f"\tREC&EVAL: {verdict}")
-        return verdict
+        if isinstance(state, bool):
+            Notify.GLOBAL_NOTIFY = state
+        targets = ", ".join(s.__class__.__name__ for s in Notify._SUBSCRIBERS)
+        return f"Notifications[{targets}]: {'enabled' if Notify.GLOBAL_NOTIFY else 'disabled'}"
 
     @staticmethod
-    def set_commands():
+    def notify(text, *args, **kwargs):
         """
-        Set Custom Commands to the Telegram chat.
-        RETURN None when telegram bot token is missing
+        Notification sender for Load Modules
         """
+        if Notify.GLOBAL_NOTIFY:
+            return Notify.message(text, *args, **kwargs)
+        return "Notifications disabled"
 
-        console_write("[NTFY] SET DEFAULT COMMANDS")
-        bot_token = Telegram.__bot_token()
-        if bot_token is None:
-            return None
-        url = f"https://api.telegram.org/bot{bot_token}/setMyCommands{Telegram._API_PARAMS}"
-        data = {"commands": [{"command": "ping", "description": "Ping All endpoints, return active modules."},
-                             {"command": "cmd", "description": "Command to All endpoints (only loaded modules)."},
-                             {"command": "cmd_select", "description": "Command to Selected endpoints: device module func"},
-                             ]}
-        _, resp_json = urequests.post(url, headers={"Content-Type": "application/json"}, json=data, jsonify=True, sock_size=128)
-        return 'Custom commands was set' if resp_json['ok'] else str(resp_json)
+    @staticmethod
+    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