micrOSDevToolKit 2.10.2__py3-none-any.whl → 2.10.5__py3-none-any.whl

micrOS/release_info/micrOS_ReleaseInfo/system_analysis_sum.json

@@ -4,6 +4,10 @@
             9.16,
             7
         ],
+        "Files.py": [
+            9.6,
+            4
+        ],
         "micrOSloader.py": [
             7.33,
             1
@@ -26,14 +30,14 @@
         ],
         "Config.py": [
             9.48,
-            17
+            18
         ],
         "reset.py": [
             10.0,
             0
         ],
         "Shell.py": [
-            9.34,
+            9.36,
             1
         ],
         "Notify.py": [
@@ -45,12 +49,12 @@
             29
         ],
         "Logger.py": [
-            8.85,
+            8.9,
             4
         ],
         "Common.py": [
             9.78,
-            34
+            35
         ],
         "InterConnect.py": [
             9.41,
@@ -65,7 +69,7 @@
             8
         ],
         "Espnow.py": [
-            9.43,
+            9.49,
             1
         ],
         "Scheduler.py": [
@@ -73,7 +77,7 @@
             1
         ],
         "microIO.py": [
-            9.42,
+            9.43,
             42
         ],
         "micrOS.py": [
@@ -89,7 +93,7 @@
             0
         ],
         "urequests.py": [
-            8.99,
+            8.96,
             5
         ],
         "LM_roboarm.py": [
@@ -101,7 +105,7 @@
             1
         ],
         "LM_pacman.py": [
-            8.94,
+            8.92,
             0
         ],
         "LM_genIO.py": [
@@ -113,7 +117,7 @@
             0
         ],
         "LM_system.py": [
-            8.19,
+            8.28,
             5
         ],
         "LM_robustness.py": [
@@ -237,7 +241,7 @@
             0
         ],
         "LM_espnow.py": [
-            7.5,
+            7.89,
             0
         ],
         "LM_telegram.py": [
@@ -272,6 +276,10 @@
             8.9,
             4
         ],
+        "LM_mqtt_pro.py": [
+            9.35,
+            0
+        ],
         "LM_trackball.py": [
             8.31,
             1
@@ -315,12 +323,12 @@
     },
     "summary": {
         "core": [
-            3380,
-            23
+            3550,
+            24
         ],
         "load": [
-            9077,
-            55
+            9217,
+            56
         ],
         "core_dep": [
             true,
@@ -328,10 +336,10 @@
         ],
         "load_dep": [
             true,
-            5
+            6
         ],
-        "core_score": 9.22,
-        "load_score": 8.2,
-        "version": "2.10.2-0"
+        "core_score": 9.24,
+        "load_score": 8.23,
+        "version": "2.10.5-0"
     }
 }

micrOS/source/Common.py

@@ -125,10 +125,10 @@ def manage_task(tag, operation):
     raise Exception(f"Invalid operation: {operation}")
 
 
-def exec_cmd(cmd, jsonify:bool=None, skip_check=False):
+def exec_cmd(cmd:list, jsonify:bool=None, skip_check=False):
     """
     [LM] Single (sync) LM execution
-    :param cmd: command string list
+    :param cmd: command string list, ex.: ['system', 'clock']
     :param jsonify: request json output
     :param skip_check: skip cmd type check, micropython bug
     return state, output

micrOS/source/Espnow.py

@@ -1,157 +1,279 @@
 from aioespnow import AIOESPNow
 from binascii import hexlify
 from Tasks import NativeTask, TaskBase, lm_exec, lm_is_loaded
+import uasyncio as asyncio
 from Network import get_mac
 from Config import cfgget
 from Debug import errlog_add
 
-# Configuration values and globals
-_INSTANCE = None
-_DEVFID = cfgget('devfid')  # for example, "node01"
 
-async def asend(now, mac, msg):
+# ----------- PARSE AND RENDER MSG PROTOCOL  --------------
+
+def render_response(tid, oper, data, prompt) -> str:
     """
-    Send a message over ESPNow. The sent message will be extended with the server prompt.
-    The prompt indicates the end-of-message with a '$' marker.
+    Render ESPNow custom message (protocol)
     """
-    prompt = f"{_DEVFID}$"  # '$' symbol is the ACK (end of message)!
-    # Append a newline and the server prompt to the message.
-    full_msg = f"{msg}\n{prompt}".encode("utf-8")
-    return await now.asend(mac, full_msg)
+    if oper not in ("REQ", "RSP"):
+        errlog_add(f"[ERR] espnow render_response, unknown oper: {oper}")
+    tmp = "{tid}|{oper}|{data}|{prompt}$"
+    tmp = tmp.replace("{tid}", str(tid))
+    tmp = tmp.replace("{oper}", str(oper))
+    tmp = tmp.replace("{data}", str(data))
+    tmp = tmp.replace("{prompt}", str(prompt))
+    return tmp
 
-def _serv_execute(msg, my_task):
+def parse_request(msg:bytes) -> (bool, dict|str):
     """
-    Process an incoming command and return a tuple (ready, response).
-
-    The function decodes the message, strips any trailing '$' (which marks the prompt),
-    and then interprets the message as a command. The command is split into tokens where
-    the first token is considered the module/command. If the module is allowed (lm_is_loaded),
-    the command is executed with lm_exec; otherwise, "NotAllowed" is returned.
+    Parse ESPNow custom message protocol
     """
     try:
-        command_line = msg.decode('utf-8').strip()
+        msg = msg.decode('utf-8').strip()
     except UnicodeError:
-        my_task.out = "[NOW SERVE] Invalid encoding"
         return False, "Invalid encoding"
+    # strip the trailing '$' then split on '|'
+    parts = msg.rstrip("$").split("|")
+    if len(parts) == 4:
+        return True, {"tid": parts[0],
+                      "oper": parts[1],
+                      "data": parts[2],
+                      "prompt": parts[3]}
+    return False, f"Missing 4 args: {msg}"
+
+
+# ----------- ESPNOW SESSION SERVER - LISTENER AND SENDER  --------------
+class ResponseRouter:
+    """
+    Response Router (by mac address)
+    to connect sender task with receiver loop (aka server)
+    """
+    _routes: dict[bytes, "ResponseRouter"] = {}
+
+    def __init__(self, mac: bytes):
+        self.mac = mac
+        self.response = None
+        self._event = asyncio.Event()
+        ResponseRouter._routes[mac] = self
 
-    # Split the command into tokens.
-    tokens = command_line.split()
-    if not tokens:
-        return False, "[NOW SERVE] Empty command"
-    # Remove trailing prompt marker if present.
-    client_token = "?$"
-    if tokens[-1].endswith("$"):
-        client_token = tokens[-1]
-        tokens = tokens[:-1]
-    my_task.out = f"[NOW SERVE] {' '.join(tokens)} (from {client_token})"
-    # Check if the module/command is allowed.
-    module = tokens[0]
-    if lm_is_loaded(module):
+    async def get_response(self, timeout:int=10) -> str|dict:
+        """Wait for one response, then clear the event for reuse."""
         try:
-            state, out = lm_exec(tokens)
-        except Exception as e:
-            # Optionally log the exception here.
-            state, out = False, f"[ERR][NOW SERVE] {tokens}: {e}"
-    else:
-        state, out = False, f"[WARN][NOW SERVE] NotAllowed {tokens[0]}"
-    return state, out
+            await asyncio.wait_for(self._event.wait(), timeout)
+        except asyncio.TimeoutError:
+            return "Timeout has beed exceeded"
+        self._event.clear()
+        return self.response
+
+    @staticmethod
+    def update_response(mac: bytes, response: str) -> None:
+        # USE <tid> for proper session response mapping
+        router = ResponseRouter._routes.get(mac)
+        if router is None:
+            errlog_add(f"[WARN][ESPNOW] No response route for {mac}")
+            return
+        router.response = response
+        router._event.set()
+
+    def close(self) -> None:
+        """Remove routing entry when done."""
+        ResponseRouter._routes.pop(self.mac, None)
 
-async def _server(now):
+
+class ESPNowSS:
     """
-    ESPNow server task that continuously waits for incoming messages and processes commands.
+    ESPNow Session Server
     """
-    with TaskBase.TASKS.get('espnow.server', None) as my_task:
-        async for mac, msg in now:
-            try:
-                state, response = _serv_execute(msg, my_task)
-                if state:
-                    await asend(now, mac, response)
-                else:
-                    errlog_add(response)
-            except OSError as err:
-                # If the peer is not yet added, add it and retry.
-                if len(err.args) > 1 and err.args[1] == 'ESP_ERR_ESPNOW_NOT_FOUND':
-                    now.add_peer(mac)
-                    state, response = _serv_execute(msg, my_task)
+    _instance = None
+
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            # first time: actually create it
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self):
+        # __init__ still runs each time, so guard if needed
+        if not hasattr(self, '_initialized'):
+            self.espnow = AIOESPNow()                   # Instance with async support
+            self.espnow.active(True)
+            self.devfid = cfgget('devfid')
+            self.devices: dict[bytes, str] = {}         # mapping for { "mac address": "devfid" } pairs
+            self._initialized = True
+            self.server_ready = False
+
+    # ----------- SERVER METHODS --------------
+    def _request_handler(self, msg:bytes, my_task:NativeTask, mac:bytes):
+        """
+        Handle server input message (request), with REQ/RSP types (oper)
+            oper==REQ   - command execution
+            oper==RSP   - command response
+        :param msg: valid message format> "{tid}|{oper}|{data}|{prompt}$", {data} is the user input
+        :param my_task: Server task instance, for my_task.out update
+        :param mac: sender binary mac address
+        """
+
+        state, request = parse_request(msg)
+        if not state:
+            my_task.out = f"[_ESPNOW] {request}"
+            return state, request
+
+        # parsed request: {"tid": "n/a", "oper": "n/a", "data": "n/a", "prompt": "n/a"}
+        operation, prompt, tid = request["oper"], request["prompt"], request["tid"]
+        my_task.out = f"[{tid}] {operation} from {prompt}"
+        # Update known devices
+        self.devices[mac] = request["prompt"]
+
+        # Check if the module/command is allowed., check oper==REQ/RSP
+        if operation == "REQ":
+            command = request["data"].split()
+            module = command[0]
+            if lm_is_loaded(module):
+                try:
+                    state, out = lm_exec(command)
+                    # rendered_output: "{tid}|{oper}|{data}|{prompt}$"
+                    rendered_out = render_response(tid="?", oper="RSP", data=out, prompt=self.devfid)
+                    return state, rendered_out
+                except Exception as e:
+                    # Optionally log the exception here.
+                    state, out = False, f"[ERR][_ESPNOW] {command}: {e}"
+            else:
+                state, out = False, f"[WARN][_ESPNOW] NotAllowed {module}"
+            return state, out
+        if operation == "RSP":
+            resp_data = request["data"]
+            ResponseRouter.update_response(mac, resp_data)          # USE <tid> for proper session response mapping
+        return False, f"[_ESPNOW] No action, {request}"
+
+    async def _server(self, tag:str):
+        """
+        ESPnow async listener task
+        :param tag: micro_task tag for task access
+        """
+        with TaskBase.TASKS.get(tag, None) as my_task:
+            self.server_ready = True
+            my_task.out = "ESPNow receiver running"
+            async for mac, msg in self.espnow:
+                try:
+                    state, response = self._request_handler(msg, my_task, mac)
                     if state:
-                        await asend(now, mac, response)
+                        await self.__asend_raw(mac, response)
                     else:
                         errlog_add(response)
-                else:
-                    # Optionally handle or log other OSErrors here.
-                    errlog_add(f"[ERR][NOW SERVER] {err}")
+                except OSError as err:
+                    # If the peer is not yet added, add it and retry.
+                    if len(err.args) > 1 and err.args[1] == 'ESP_ERR_ESPNOW_NOT_FOUND':
+                        self.add_peer(mac)
+                        state, response = self._request_handler(msg, my_task, mac)
+                        if state:
+                            await self.__asend_raw(mac, response)
+                        else:
+                            errlog_add(response)
+                    else:
+                        # Optionally handle or log other OSErrors here.
+                        errlog_add(f"[ERR][NOW SERVER] {err}")
+
+    def start_server(self):
+        """
+        Start the async ESPNow receiver server.
+        """
+        # Create an asynchronous task with tag 'espnow.server'
+        tag = 'espnow.server'
+        state = NativeTask().create(callback=self._server(tag), tag=tag)
+        return "Starting" if state else "Already running"
+
+    #----------- SEND METHODS --------------
+    async def __asend_raw(self, mac:bytes, msg:str):
+        """
+        ESPnow send message to mac address
+        """
+        return await self.espnow.asend(mac, msg.encode("utf-8"))
+
+    async def _asend_task(self, peer:bytes, tag:str, msg:str):
+        """
+        ESPNow client task: send a command to a peer and update task status.
+        """
+        with TaskBase.TASKS.get(tag, None) as my_task:
+            router = ResponseRouter(peer)
+            # rendered_output: "{tid}|{oper}|{data}|{prompt}$"
+            rendered_out = render_response(tid="?", oper="REQ", data=msg, prompt=self.devfid)
+            if await self.__asend_raw(peer, rendered_out):
+                my_task.out = f"[ESPNOW SEND] {rendered_out}"
+                my_task.out = await router.get_response()
+            else:
+                my_task.out = "[ESPNOW SEND] Peer not responding"
+            router.close()
+
+    def mac_by_peer_name(self, peer_name:str) -> bytes|None:
+        matches = [k for k, v in self.devices.items() if v == peer_name]
+        peer = matches[0] if matches else None
+        return peer
+
+    def send(self, peer:bytes|str, msg:str) -> str:
+        """
+        Send a command over ESPNow.
+        :param peer: Binary MAC address of another device.
+        :param msg: String command message to send.
+        """
+        peer_name = None
+        if isinstance(peer, str):
+            # Peer as device name (prompt)
+            _peer = self.mac_by_peer_name(peer)
+            if _peer is None:
+                return f"Unknown device: {peer}"
+            peer_name = peer
+            peer = _peer
+
+        peer_name = hexlify(peer, ':').decode() if peer_name is None else peer_name
+        task_id = f"con.espnow.{peer_name}"
+        # Create an asynchronous sending task.
+        state = NativeTask().create(callback=INSTANCE._asend_task(peer, task_id, msg), tag=task_id)
+        return "Starting" if state else "Already running"
+
+    # ----------- OTHER METHODS --------------
+
+    def add_peer(self, peer:bytes, devfid:str=None):
+        """
+        Add a peer given its MAC address.
+        :param peer: Binary MAC address of a peer (e.g. b'\xbb\xbb\xbb\xbb\xbb\xbb').
+        :param devfid: optional parameter to register dev uid for mac address
+        """
+        try:
+            self.espnow.add_peer(peer)
+            if devfid is not None:
+                # Update known devices
+                self.devices[peer] = devfid
+        except Exception as e:
+            return f"Peer error: {e}"
+        return "Peer register done"
+
+    def stats(self):
+        """
+        Return stats for ESPNow peers.
+        stats: tx_pkts, tx_responses, tx_failures, rx_packets, rx_dropped_packets.
+        peers: peer, rssi, time_ms.
+        """
+        try:
+            _stats = self.espnow.stats()
+        except Exception as e:
+            _stats = str(e)
+        try:
+            _peers = self.espnow.peers_table
+        except Exception as e:
+            _peers = str(e)
+        return {"stats": _stats, "peers": _peers, "map": self.devices, "ready": self.server_ready}
 
-async def _send(now, peer, tag, msg):
-    """
-    ESPNow client task: send a command to a peer and update task status.
-    """
-    with TaskBase.TASKS.get(tag, None) as my_task:
-        if not await asend(now, peer, msg):
-            my_task.out = "[NOW SEND] Peer not responding"
-        else:
-            my_task.out = f"[NOW SEND] {msg}"
 
 ###################################################
 #                   Control functions             #
 ###################################################
-def initialize():
-    """
-    Initialize the ESPNow protocol. (WLAN must be active.)
-    """
-    global _INSTANCE
-    if _INSTANCE is None:
-        now = AIOESPNow()  # Instance with async support
-        now.active(True)
-        _INSTANCE = now
-    return _INSTANCE
-
-def add_peer(now, peer):
-    """
-    Add a peer given its MAC address.
-    :param now: ESPNow instance.
-    :param peer: Binary MAC address of a peer (e.g. b'\xbb\xbb\xbb\xbb\xbb\xbb').
-    """
-    now.add_peer(peer)
-    return "Peer register done"
+INSTANCE = ESPNowSS()
 
-def espnow_server():
-    """
-    Start the async ESPNow receiver server.
-    """
-    now = initialize()
-    # Create an asynchronous task with tag 'espnow.server'
-    state = NativeTask().create(callback=_server(now), tag='espnow.server')
-    return "Starting" if state else "Already running"
+def initialize():
+    # TODO: remove, use ESPNowSS() class instead
+    global INSTANCE
+    if INSTANCE is None:
+        INSTANCE = ESPNowSS()
+    return INSTANCE
 
-def espnow_send(peer, msg):
-    """
-    Send a command over ESPNow.
-    :param peer: Binary MAC address of another device.
-    :param msg: String command message to send.
-    """
-    now = initialize()
-    mac_str = hexlify(peer, ':').decode()
-    task_id = f"espnow.cli.{mac_str}"
-    # Create an asynchronous sending task.
-    state = NativeTask().create(callback=_send(now, peer, task_id, msg), tag=task_id)
-    return "Starting" if state else "Already running"
-
-def stats():
-    """
-    Return stats for ESPNow peers.
-    stats: tx_pkts, tx_responses, tx_failures, rx_packets, rx_dropped_packets.
-    peers: peer, rssi, time_ms.
-    """
-    now = initialize()
-    try:
-        _stats = now.stats()
-    except Exception as e:
-        _stats = str(e)
-    try:
-        _peers = now.peers_table
-    except Exception as e:
-        _peers = str(e)
-    return {"stats": _stats, "peers": _peers}
 
 def mac_address():
     """

micrOS/source/Files.py

@@ -0,0 +1,101 @@
+from uos import ilistdir, remove, stat
+
+################################   Helper functions   #####################################
+
+def _is_module(path:str='/', pyprefix:str='*') -> bool:
+    """
+    Filter application modules, LM_.* (pyprefix) or app data or web resource
+    :param path: file to check
+    :param pyprefix: python resource filter prefix, default: * (all: LM and IO)
+    """
+    # micrOS file types
+    allowed_exts = ('html', 'js', 'css', 'log', 'pds', 'dat')
+    mod_prefixes = ('LM', "IO")
+    fname = path.split("/")[-1]
+    if fname.split("_")[0] in mod_prefixes or fname.split('.')[-1] in allowed_exts:
+        if pyprefix == '*':
+            # MODE: ALL app resources
+            return True
+        if fname.startswith(f"{pyprefix.upper()}_"):
+            # MODE: SELECTED app resources
+            return True
+    return False
+
+
+def _type_mask_to_str(item_type:int=None) -> str:
+    # Map the raw bit-mask to a single character
+    if item_type & 0x4000:              # Dir bit-mask
+        item_type = 'd'
+    elif item_type & 0x8000:            # File bit-mask
+        item_type = 'f'
+    else:
+        item_type = 'o'
+    return item_type
+
+###########################   Public functions   #############################
+
+def ilist_fs(path:str="/", type_filter:str='*', select:str='*', core:bool=False):
+    """
+    Linux like ls command - list app resources and app folders
+    :param path: path to list, default: /
+    :param type_filter: content type, default all (*), f-file, d-dir can be selected
+    :param select: select specific application resource type by prefix: LM or IO
+    :param core: list core files resources as well, default: False
+    return iterator:
+        when content is all (*) output: [(item_type, item), ...]
+        OR
+        content type was selected (not *) output: [item, ...]
+    """
+    path = path if path.endswith('/') else f"{path}/"
+    # Info: uos.ilistdir: (name, type, inode[, size])
+    for item, item_type, *_ in ilistdir(path):
+        item_type = _type_mask_to_str(item_type)
+        if type_filter in ("*", item_type):
+            # Mods only
+            if not core and item_type == 'f' and not _is_module(path+item, pyprefix=select):
+                continue
+            if select != '*' and item_type == 'd':
+                continue
+            # Create result
+            if type_filter == "*":
+                yield item_type, item
+            else:
+                yield item
+
+
+def list_fs(path:str="/", type_filter:str='*', select:str='*', core:bool=False) -> list[str,] | list[tuple[str, str],]:
+    """
+    Wrapper of ilist_fs
+    Return list
+    """
+    return list(ilist_fs(path, type_filter, select, core))
+
+
+def remove_fs(path, allow_dir=False):
+    """
+    Linux like rm command - delete app resources and folders
+    :param path: app resource path
+    :param allow_dir: enable directory deletion, default: False
+    """
+    # protect some resources
+    if 'pacman.mpy' in path or 'system.mpy' in path or "/" == path.strip():
+        return f'Load module {path} is protected, skip deletion'
+    _is_dir = is_dir(path)
+    if _is_module(path) or (_is_dir and allow_dir):
+        remove(path)
+        return f"Removed: {path} {'dir' if _is_dir else 'file'}"
+    return f"Protected path: {path}"
+
+
+def is_dir(path):
+    try:
+        return stat(path)[0] & 0x4000
+    except OSError:
+        return False
+
+
+def is_file(path):
+    try:
+        return stat(path)[0] & 0x8000
+    except OSError:
+        return False