micrOSDevToolKit 2.10.2__tar.gz → 2.10.5__tar.gz

{microsdevtoolkit-2.10.2/micrOSDevToolKit.egg-info → microsdevtoolkit-2.10.5}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: micrOSDevToolKit
-Version: 2.10.2
+Version: 2.10.5
 Summary: Development and deployment environment for micrOS, the diy micropython automation OS (IoT)
 Home-page: https://github.com/BxNxM/micrOS
 Author: Marcell Ban
@@ -31,6 +31,7 @@ Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: license
+Dynamic: license-file
 Dynamic: project-url
 Dynamic: requires-dist
 Dynamic: summary

{microsdevtoolkit-2.10.2 → microsdevtoolkit-2.10.5}/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"
     }
 }

{microsdevtoolkit-2.10.2 → microsdevtoolkit-2.10.5}/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

microsdevtoolkit-2.10.5/micrOS/source/Espnow.py

@@ -0,0 +1,282 @@
+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
+
+
+# ----------- PARSE AND RENDER MSG PROTOCOL  --------------
+
+def render_response(tid, oper, data, prompt) -> str:
+    """
+    Render ESPNow custom message (protocol)
+    """
+    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 parse_request(msg:bytes) -> (bool, dict|str):
+    """
+    Parse ESPNow custom message protocol
+    """
+    try:
+        msg = msg.decode('utf-8').strip()
+    except UnicodeError:
+        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
+
+    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)
+        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)
+
+
+class ESPNowSS:
+    """
+    ESPNow Session Server
+    """
+    _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 self.__asend_raw(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':
+                        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}
+
+
+###################################################
+#                   Control functions             #
+###################################################
+INSTANCE = ESPNowSS()
+
+def initialize():
+    # TODO: remove, use ESPNowSS() class instead
+    global INSTANCE
+    if INSTANCE is None:
+        INSTANCE = ESPNowSS()
+    return INSTANCE
+
+
+def mac_address():
+    """
+    Get the binary MAC address.
+    """
+    return get_mac()

microsdevtoolkit-2.10.5/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

{microsdevtoolkit-2.10.2/toolkit/workspace/precompiled → microsdevtoolkit-2.10.5/micrOS/source}/LM_espnow.py

@@ -6,13 +6,14 @@ def load():
     """
     return Espnow.initialize()
 
-def send(peer, msg='modules'):
+def send(peer:bytes|str, msg:str='modules'):
     """
     Send message to peer (by mac address)
     :param peer: mac address of espnow device
     :param msg: message string/load module call
     """
-    return Espnow.espnow_send(peer, msg)
+    now = Espnow.initialize()
+    return now.send(peer, msg)
 
 def start_server():
     """
@@ -20,21 +21,23 @@ def start_server():
     - this can receive espnow messages
     - it includes Load Module execution logic (beta)
     """
-    return Espnow.espnow_server()
+    now = Espnow.initialize()
+    return now.start_server()
 
 def stats():
     """
     Get ESPNOW stats
     """
-    return Espnow.stats()
+    now = Espnow.initialize()
+    return now.stats()
 
-def add_peer(peer):
+def add_peer(peer:bytes, dev_name:str=None):
     """
     Add ESPNOW peer to known hosts
     - It is needed before first send(...)
     """
     now = Espnow.initialize()
-    return Espnow.add_peer(now, peer)
+    return now.add_peer(peer, dev_name)
 
 def mac_address():
     """
@@ -46,4 +49,4 @@ def help():
     """
     [beta] ESPNOW sender/receiver with LM execution
     """
-    return 'load', 'send <peer> "ping"', 'start_server', 'add_peer <peer>', 'stats', 'mac_address'
+    return 'load', 'send <peer> "ping"', 'start_server', 'add_peer <peer> dev_name=None', 'stats', 'mac_address'