micrOSDevToolKit 2.20.0__py3-none-any.whl → 2.21.0__py3-none-any.whl

micrOS/release_info/micrOS_ReleaseInfo/system_analysis_sum.json

@@ -4,9 +4,13 @@
             9.34,
             6
         ],
+        "Pacman.py": [
+            9.75,
+            1
+        ],
         "Files.py": [
-            9.64,
-            10
+            9.68,
+            11
         ],
         "micrOSloader.py": [
             7.06,
@@ -29,7 +33,7 @@
             12
         ],
         "Config.py": [
-            9.43,
+            9.44,
             19
         ],
         "reset.py": [
@@ -57,19 +61,19 @@
             34
         ],
         "InterConnect.py": [
-            9.62,
+            9.63,
             2
         ],
         "Debug.py": [
             7.37,
-            17
+            18
         ],
         "Network.py": [
             9.81,
             8
         ],
         "Espnow.py": [
-            9.47,
+            9.87,
             4
         ],
         "Scheduler.py": [
@@ -109,7 +113,7 @@
             0
         ],
         "modules/LM_pacman.py": [
-            7.95,
+            7.61,
             0
         ],
         "modules/LM_genIO.py": [
@@ -117,7 +121,7 @@
             0
         ],
         "modules/LM_oled_ui.py": [
-            9.2,
+            9.22,
             0
         ],
         "modules/LM_system.py": [
@@ -241,7 +245,7 @@
             0
         ],
         "modules/LM_oledui.py": [
-            8.94,
+            9.05,
             0
         ],
         "modules/LM_espnow.py": [
@@ -319,11 +323,11 @@
     },
     "summary": {
         "core": [
-            3994,
-            24
+            4171,
+            25
         ],
         "load": [
-            9912,
+            9869,
             55
         ],
         "core_dep": [
@@ -334,8 +338,8 @@
             true,
             4
         ],
-        "core_score": 9.25,
-        "load_score": 8.42,
-        "version": "2.20.0-0"
+        "core_score": 9.29,
+        "load_score": 8.41,
+        "version": "2.21.0-0"
     }
 }

micrOS/source/Config.py

@@ -84,8 +84,11 @@ class Data:
         Data.__inject_default_conf()
         # [!!!] Init selected pinmap - default pinmap calculated by platform
         if callable(set_pinmap):
-            pinmap = set_pinmap(Data.CONFIG_CACHE['cstmpmap'])
-            console_write(f"[PIN MAP] {pinmap}")
+            try:
+                pinmap = set_pinmap(Data.CONFIG_CACHE['cstmpmap'])
+                console_write(f"[PIN MAP] {pinmap}")
+            except Exception as e:
+                console_write(f"\n[PIN MAP] !!! SETUP ERROR !!!: {e}\n")
         # SET dbg based on config settings (inject user conf)
         DebugCfg.DEBUG = Data.CONFIG_CACHE['dbg']
         if DebugCfg.DEBUG:

micrOS/source/Espnow.py

@@ -1,7 +1,23 @@
-from aioespnow import AIOESPNow
+"""
+ESPNow Session Server and Protocol Utilities
+
+This module implements:
+- Custom ESPNow message protocol with transaction IDs (tid) for secure, session-aware communication.
+- Asynchronous server and client logic for sending and receiving ESPNow messages.
+- Response routing using both MAC address and transaction ID to ensure correct delivery to tasks.
+- Peer management, handshake routines, and statistics reporting for ESPNow devices.
+
+Designed for MicroPython environments with async support.
+"""
+
+
 from binascii import hexlify
 from json import load, dump
 import uasyncio as asyncio
+import urandom
+
+from aioespnow import AIOESPNow
+
 from Tasks import NativeTask, lm_exec, lm_is_loaded
 from Config import cfgget
 from Debug import syslog
@@ -10,7 +26,7 @@ from Files import OSPath, path_join, is_file
 
 # ----------- PARSE AND RENDER MSG PROTOCOL  --------------
 
-def render_response(tid:str, oper:str, data:str, prompt:str) -> str:
+def render_packet(tid: str, oper: str, data: str, prompt: str) -> str:
     """
     Render ESPNow custom message (protocol)
     """
@@ -21,7 +37,7 @@ def render_response(tid:str, oper:str, data:str, prompt:str) -> str:
            .replace("{data}", str(data)).replace("{prompt}", prompt))
     return tmp
 
-def parse_request(msg:bytes) -> (bool, dict|str):
+def parse_packet(msg: bytes) -> tuple[bool, dict | str]:
     """
     Parse ESPNow custom message protocol
     """
@@ -39,21 +55,43 @@ def parse_request(msg:bytes) -> (bool, dict|str):
     return False, f"Missing 4 args: {msg}"
 
 
+def get_command_module(request):
+    if isinstance(request, dict):
+        command = request["data"].split()
+        module = command[0]
+    elif isinstance(request, str):
+        command = request.split()
+        module = command[0]
+    else:
+        command = []
+        module = ""
+    return command, module
+
+
+def generate_tid() -> str:
+    """
+    Generate a secure, random transaction ID (tid).
+    Returns an 8-byte hex string.
+    """
+    return hexlify(bytes([urandom.getrandbits(8) for _ in range(8)])).decode()
+
+
 # ----------- 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"] = {}
+    _routes: dict[tuple[bytes, str], "ResponseRouter"] = {}
 
-    def __init__(self, mac: bytes):
+    def __init__(self, mac: bytes, tid: str):
         self.mac = mac
+        self.tid = tid
         self.response = None
         self._event = asyncio.Event()
-        ResponseRouter._routes[mac] = self
+        ResponseRouter._routes[(mac, tid)] = self
 
-    async def get_response(self, timeout:int=10) -> str|dict:
+    async def get_response(self, timeout: int=10) -> str|dict:
         """Wait for one response, then clear the event for reuse."""
         try:
             await asyncio.wait_for(self._event.wait(), timeout)
@@ -63,18 +101,17 @@ class ResponseRouter:
         return self.response
 
     @staticmethod
-    def update_response(mac: bytes, response: str) -> None:
-        # USE <tid> for proper session response mapping
-        router = ResponseRouter._routes.get(mac)
+    def update_response(mac: bytes, tid: str, response: str) -> None:
+        router = ResponseRouter._routes.get((mac, tid), None)
         if router is None:
-            syslog(f"[WARN][ESPNOW] No response route for {mac}")
+            syslog(f"[WARN][ESPNOW] No response route for {(mac, tid)}")
             return
         router.response = response
         router._event.set()
 
     def close(self) -> None:
         """Remove routing entry when done."""
-        ResponseRouter._routes.pop(self.mac, None)
+        ResponseRouter._routes.pop((self.mac, self.tid), None)
 
 
 class ESPNowSS:
@@ -106,7 +143,7 @@ class ESPNowSS:
         if not is_file(self.peer_cache_path):
             return
         try:
-            with open(self.peer_cache_path, 'r') as f:
+            with open(self.peer_cache_path, 'r', encoding='utf-8') as f:
                 devices_map = load(f)
                 self.devices = {bytes(k): v for k, v in devices_map}
             for mac in self.devices:
@@ -116,7 +153,7 @@ class ESPNowSS:
             syslog(f"[ERR][ESPNOW] Loading peers: {e}")
 
     # ----------- SERVER METHODS --------------
-    def _request_handler(self, msg:bytes, my_task:NativeTask, mac:bytes):
+    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
@@ -126,7 +163,7 @@ class ESPNowSS:
         :param mac: sender binary mac address
         """
 
-        state, request = parse_request(msg)
+        state, request = parse_packet(msg)
         if not state:
             my_task.out = f"[_ESPNOW] {request}"
             return state, request
@@ -139,18 +176,17 @@ class ESPNowSS:
 
         # Check if the module/command is allowed., check oper==REQ/RSP
         if operation == "REQ":
-            command = request["data"].split()
-            module = command[0]
+            command, module = get_command_module(request)
             # Handle default hello - handshake message
             if len(command) == 1 and module == "hello":
-                rendered_out = render_response(tid="?", oper="RSP", data=f"hello {prompt}", prompt=self.devfid)
+                rendered_out = render_packet(tid=tid, oper="RSP", data=f"hello {prompt}", prompt=self.devfid)
                 return True, rendered_out
             # COMMAND EXECUTION
             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)
+                    rendered_out = render_packet(tid=tid, oper="RSP", data=out, prompt=self.devfid)
                     return state, rendered_out
                 except Exception as e:
                     # Optionally log the exception here.
@@ -159,17 +195,17 @@ class ESPNowSS:
             else:
                 warning_msg = f"[WARN][_ESPNOW] NotAllowed {module}"
                 syslog(warning_msg)
-                rendered_out = render_response(tid="?", oper="RSP", data=warning_msg,
+                rendered_out = render_packet(tid=tid, oper="RSP", data=warning_msg,
                                                prompt=self.devfid)
                 state, out = True, rendered_out
             return state, out
         if operation == "RSP":
             resp_data = request["data"]
-            ResponseRouter.update_response(mac, resp_data)          # USE <tid> for proper session response mapping
+            ResponseRouter.update_response(mac, tid, resp_data)          # USE <tid> for proper session response mapping
         #syslog(f"[_ESPNOW] No action, {request}")
         return False, ""
 
-    async def _server(self, tag:str):
+    async def _server(self, tag: str):
         """
         ESPnow async listener task
         :param tag: micro_task tag for task access
@@ -204,20 +240,20 @@ class ESPNowSS:
         return NativeTask().create(callback=self._server(tag), tag=tag)
 
     #----------- SEND METHODS --------------
-    async def __asend_raw(self, mac:bytes, msg:str):
+    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):
+    async def _asend_task(self, tid: str, peer: bytes, tag: str, msg: str):
         """
         ESPNow client task: send a command to a peer and update task status.
         """
         with NativeTask.TASKS.get(tag, None) as my_task:
-            router = ResponseRouter(peer)
+            router = ResponseRouter(peer, tid)
             # rendered_output: "{tid}|{oper}|{data}|{prompt}$"
-            rendered_out = render_response(tid="?", oper="REQ", data=msg, prompt=self.devfid)
+            rendered_out = render_packet(tid=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()
@@ -225,12 +261,12 @@ class ESPNowSS:
                 my_task.out = "[ESPNOW SEND] Peer not responding"
             router.close()
 
-    def mac_by_peer_name(self, peer_name:str) -> bytes|None:
+    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) -> dict:
+    def send(self, peer: bytes | str, msg: str) -> dict:
         """
         Send a command over ESPNow.
         :param peer: Binary MAC address of another device.
@@ -246,9 +282,11 @@ class ESPNowSS:
             peer = _peer
 
         peer_name = hexlify(peer, ':').decode() if peer_name is None else peer_name
-        task_id = f"con.espnow.{peer_name}"
+        _, module_name = get_command_module(msg)
+        task_id = f"con.espnow.{peer_name}.{module_name}"
+        tid = generate_tid()
         # Create an asynchronous sending task.
-        return NativeTask().create(callback=self._asend_task(peer, task_id, msg), tag=task_id)
+        return NativeTask().create(callback=self._asend_task(tid, peer, task_id, msg), tag=task_id)
 
     def cluster_send(self, msg):
         """
@@ -262,14 +300,14 @@ class ESPNowSS:
     # ----------- OTHER METHODS --------------
     def save_peers(self):
         try:
-            with open(self.peer_cache_path, "w") as f:
+            with open(self.peer_cache_path, "w", encoding="utf-8") as f:
                 dump([[list(k), v] for k, v in self.devices.items()], f)
             return True
         except Exception as e:
             syslog(f"[ERR][ESPNOW] Saving peers: {e}")
         return False
 
-    async def _handshake(self, peer:bytes, tag:str):
+    async def _handshake(self, peer: bytes, tag: str):
         """
         Handshake with peer
         - with device caching
@@ -295,16 +333,34 @@ class ESPNowSS:
             my_task.out = f"Handshake: {result} from {self.devices.get(peer)} [{'OK' if is_ok else 'NOK'}]"
             sender_task.cancel()    # Delete sender task (cleanup)
 
-    def handshake(self, peer:bytes|str):
-        task_id = f"con.espnow.handshake"
+    def _mac_str_to_bytes(self, mac_str: str) -> bytes|None:
+        """
+        Convert MAC address string (e.g., '50:02:91:86:34:28') to bytes.
+        """
+        try:
+            mac_bytes = bytes(int(x, 16) for x in mac_str.split(":"))
+            if len(mac_bytes) != 6:
+                return None
+            return mac_bytes
+        except Exception:
+            return None
+
+    def handshake(self, peer: bytes | str):
+        """
+        Initiate a handshake with a peer device over ESPNow.
+
+        :param peer: The peer device's MAC address as bytes or a string in the format '50:02:91:86:34:28'.
+        :return: A dictionary with error information or a NativeTask instance for the handshake operation.
+        """
+        task_id = "con.espnow.handshake"
         # Create an asynchronous sending task.
         if isinstance(peer, str) and ":" in peer:
-            # Convert 50:02:91:86:34:28 format to b'P\x02\x91\x864(' bytes
-            peer = bytes(int(x, 16) for x in peer.split(":"))
+            peer_bytes = self._mac_str_to_bytes(peer)
+            if peer_bytes is not None:
+                peer = peer_bytes
         if isinstance(peer, bytes):
             return NativeTask().create(callback=self._handshake(peer, task_id), tag=task_id)
-        else:
-            return {None: "Invalid MAC address format. Use 50:02:91:86:34:28 or b'P\\x02\\x91\\x864('"}
+        return {None: "Invalid MAC address format. Use 50:02:91:86:34:28 or b'P\\x02\\x91\\x864('"}
 
     def stats(self):
         """
@@ -321,11 +377,14 @@ class ESPNowSS:
         except Exception as e:
             _peers = str(e)
         return {"stats": _stats, "peers": _peers, "ready": self.server_ready}
-    
+
     def members(self):
+        """
+        Returns the list of devices that are members of the current group.
+        """
         return self.devices
 
-    def remove_peer(self, peer:bytes) -> bool:
+    def remove_peer(self, peer: bytes) -> bool:
         """
         Remove peer from ESPNow devices
         :param peer: MAC address as bytes to remove

micrOS/source/Files.py

@@ -3,41 +3,49 @@ Module is responsible high level micropython file system opeartions
 [IMPORTANT] This module must never use any micrOS specific functions or classes.
 """
 
-from uos import ilistdir, remove, stat, getcwd, mkdir
+from uos import ilistdir, remove, stat, getcwd, mkdir, rmdir
 from sys import path as upath
 
 ################################   Helper functions   #####################################
 
 def _filter(path:str='/', ext:tuple=None, prefix:tuple=None, hide_core:bool=True) -> bool:
     """
-    Filter files
-    :param path: file to check
+    Filter files in the micrOS filesystem.
+
+    :param path: file path to check
     :param ext: tuple of extensions to filter by, default: None (all)
-    :param hide_core: hide core files (mpy, py), default: True
+    :param prefix: tuple of prefixes to match (e.g. ('LM', 'IO')), default: None
+    :param hide_core: if True, hides core .py/.mpy files in the root (current) directory
+    :return: bool, whether the file passes the filter
     """
+    parent = "/".join(path.split("/")[:-1]) or "/"
     fname = path.split("/")[-1]
     _ext = fname.split(".")[-1]
-    if hide_core and _ext in ("mpy", "py") and not (fname.startswith("LM_") or fname.startswith("IO_")):
+
+    # --- Hide core logic ---
+    # Core = any .py/.mpy in the current (root) working directory
+    if hide_core and _ext in ("mpy", "py") and parent in ('/', ""):
         return False
+
+    # --- General matching rules ---
     if ext is None and prefix is None:
         return True
     if isinstance(prefix, tuple) and fname.split("_")[0] in prefix:
         return True
-    if isinstance(ext, tuple) and fname.split(".")[-1] in ext:
+    if isinstance(ext, tuple) and _ext in ext:
         return True
     return False
 
 def is_protected(path:str='/') -> bool:
     """
-    Check is file protected
-        - deny deletion
+    Check is file/dir protected
+        - every file and folder is protected in root dir: /
+        - with protected file list
     """
-    protected_entities = ("", "node_config.json", "modules", "config", "logs", "web", "data",
-                          "LM_pacman.mpy", "LM_system.mpy")
-    entity = path.split("/")[-1].replace("/", "")
-    if entity in protected_entities:
-        return True
-    return False
+    protected_files = ("node_config.json", "LM_system.mpy", "LM_pacman.mpy")
+    parent = "/".join(path.split("/")[:-1]) or "/"
+    fname = path.split("/")[-1]
+    return parent in ("/", "") or fname in protected_files
 
 def _type_mask_to_str(item_type:int=None) -> str:
     # Map the raw bit-mask to a single character
@@ -83,7 +91,7 @@ def ilist_fs(path:str="/", type_filter:str='*', select:str='*', core:bool=False)
         if type_filter in ("*", item_type):
             # Mods only
             _select = None if select == "*" else (select,)
-            if item_type == 'f' and not _filter(item, prefix=_select, hide_core=not core):
+            if item_type == 'f' and not _filter(path_join(path, item), prefix=_select, hide_core=not core):
                 continue
             if select != '*' and item_type == 'd':
                 continue
@@ -102,20 +110,38 @@ def list_fs(path:str="/", type_filter:str='*', select:str='*', core:bool=False)
     return list(ilist_fs(path, type_filter, select, core))
 
 
-def remove_fs(path, allow_dir=False):
+def remove_file(path, force=False):
     """
     Linux like rm command - delete app resources and folders
-    :param path: app resource path
-    :param allow_dir: enable directory deletion, default: False
+    :param path: file to delete
+    :param force: pypass file protection check - sudo mode
     """
     # protect some resources
-    if is_protected(path):
-        return f'{path} is protected, skip deletion'
-    _is_file = is_file(path)
-    if _is_file or allow_dir:
+    if not force and is_protected(path):
+        return f'Protected resource, skip deletion: {path}'
+    if is_file(path):
         remove(path)
         return f"{path} deleted"
-    return f"Cannot delete {'file' if _is_file else 'dir'}: {path}"
+    return f"Cannot delete dir type: {path}"
+
+
+def remove_dir(path, force=False):
+    """
+    Recursively delete a folder and all its contents.
+    :param path: folder to delete
+    :param force: pypass dir protection check - sudo mode
+    """
+    # protect some resources
+    if not force and is_protected(path):
+        return f'Protected resource, skip deletion: {path}'
+    for entry in ilistdir(path):
+        content_path = path_join(path, entry[0])
+        if is_dir(content_path):            # directory flag
+            remove_dir(content_path)
+        else:
+            remove(content_path)
+    rmdir(path)
+    return f"{path} deleted"
 
 
 def path_join(*parts):
@@ -133,6 +159,7 @@ class OSPath:
     WEB = path_join(_ROOT,'/web')           # Web resources (.html, .css, .js, .json, etc.)
     MODULES = path_join(_ROOT, '/modules')  # Application modules (.mpy, .py)
     CONFIG = path_join(_ROOT, '/config')    # System configuration files (node_config.json, etc.)
+    LIB = path_join(_ROOT, '/lib')          # Official and Custom package installation target path
 
 
 def init_micros_dirs():

micrOS/source/InterConnect.py

@@ -13,6 +13,7 @@ Designed by
 from socket import getaddrinfo, SOCK_STREAM
 from re import compile as re_compile
 from json import loads
+from binascii import hexlify
 from uasyncio import open_connection
 
 from Debug import syslog
@@ -170,7 +171,7 @@ class InterCon:
         """
         response = await self.send_cmd(host, ["task", "list", ">json"])
         if not response:
-            return {None: f"[ERR] ESPNow auto handshake: task list, {response}"}
+            return {None: f"[ERR] ESPNow auto handshake: task list >>{host}: {response}"}
 
         active_tasks = loads(response).get("active")
         if "espnow.server" in active_tasks:
@@ -254,7 +255,8 @@ def send_cmd(host:str, cmd:list|str) -> dict:
         _mod = cmd[0]
         if InterCon.validate_ipv4(host):
             return f"{'.'.join(host.split('.')[-2:])}.{_mod}"
-        return f"{host.replace('.local', '')}.{_mod}"
+        target = ".".join(host.split(".")[0:-1]) if "." in host else host
+        return f"{target}.{_mod}"
 
     com_obj = InterCon()
     task_id = f"con.{_tagify()}"            # CHECK TASK ID CONFLICT
@@ -265,4 +267,8 @@ def host_cache() -> dict:
     """
     Dump InterCon connection cache
     """
-    return InterCon.CONN_MAP
+    if ESPNowSS is None:
+        return InterCon.CONN_MAP
+    all_devs = dict({name:hexlify(mac, ':').decode() for mac, name in ESPNowSS().devices.items()})
+    all_devs.update(InterCon.CONN_MAP)
+    return all_devs