micrOSDevToolKit 2.17.1__py3-none-any.whl → 2.19.0__py3-none-any.whl

micrOS/release_info/micrOS_ReleaseInfo/system_analysis_sum.json

@@ -25,7 +25,7 @@
             1
         ],
         "Tasks.py": [
-            9.43,
+            9.46,
             12
         ],
         "Config.py": [
@@ -46,7 +46,7 @@
         ],
         "Types.py": [
             8.91,
-            28
+            29
         ],
         "Logger.py": [
             8.84,
@@ -57,7 +57,7 @@
             35
         ],
         "InterConnect.py": [
-            9.41,
+            9.62,
             2
         ],
         "Debug.py": [
@@ -69,8 +69,8 @@
             8
         ],
         "Espnow.py": [
-            9.5,
-            3
+            9.48,
+            4
         ],
         "Scheduler.py": [
             9.62,
@@ -117,7 +117,7 @@
             0
         ],
         "modules/LM_oled_ui.py": [
-            8.78,
+            9.2,
             0
         ],
         "modules/LM_system.py": [
@@ -141,7 +141,7 @@
             0
         ],
         "modules/LM_tcs3472.py": [
-            9.0,
+            9.48,
             0
         ],
         "modules/LM_oled.py": [
@@ -245,15 +245,15 @@
             0
         ],
         "modules/LM_oledui.py": [
-            8.7,
+            8.94,
             0
         ],
         "modules/LM_espnow.py": [
-            6.0,
+            7.14,
             0
         ],
         "modules/LM_telegram.py": [
-            9.58,
+            9.63,
             0
         ],
         "modules/LM_OV2640.py": [
@@ -323,11 +323,11 @@
     },
     "summary": {
         "core": [
-            3925,
+            4004,
             24
         ],
         "load": [
-            9880,
+            9988,
             56
         ],
         "core_dep": [
@@ -338,8 +338,8 @@
             true,
             4
         ],
-        "core_score": 9.24,
-        "load_score": 8.36,
-        "version": "2.17.1-0"
+        "core_score": 9.25,
+        "load_score": 8.4,
+        "version": "2.19.0-0"
     }
 }

micrOS/source/Config.py

@@ -102,12 +102,12 @@ class Data:
         liveconf = Data.read_cfg_file(nosafe=True)
         # Remove obsolete keys from conf
         try:
-            remove('cleanup.pds')       # Try to remove cleanup.pds (cleanup indicator by micrOSloader)
+            remove('.cleanup')       # Try to remove .cleanup (cleanup indicator by micrOSloader)
             console_write("[CONF] Purge obsolete keys")
             for key in (key for key in liveconf if key not in Data.CONFIG_CACHE):
                 liveconf.pop(key, None)
         except Exception:
-            console_write("[CONF] SKIP obsolete keys check (no cleanup.pds)")
+            console_write("[CONF] SKIP obsolete keys check (no .cleanup)")
         # Merge template to live conf (store active conf in Data.CONFIG_CACHE)
         Data.CONFIG_CACHE.update(liveconf)
         console_write("[CONF] User config injection done")

micrOS/source/Espnow.py

@@ -99,14 +99,14 @@ class ESPNowSS:
             self.devfid = cfgget('devfid')
             self.devices: dict[bytes, str] = {}         # mapping for { "mac address": "devfid" } pairs
             self.server_ready = False
-            self.peer_cache = path_join(OSPath.DATA, "espnow_peers.app_json")
+            self.peer_cache_path = path_join(OSPath.DATA, "espnow_peers.app_json")
             self._load_peers()
 
     def _load_peers(self):
-        if not is_file(self.peer_cache):
+        if not is_file(self.peer_cache_path):
             return
         try:
-            with open(self.peer_cache, 'r') as f:
+            with open(self.peer_cache_path, 'r') as f:
                 devices_map = load(f)
                 self.devices = {bytes(k): v for k, v in devices_map}
             for mac in self.devices:
@@ -179,6 +179,7 @@ class ESPNowSS:
             self.server_ready = True
             my_task.out = "ESPNow receiver running"
             async for mac, msg in self.espnow:
+                reply, response = False, ""
                 try:
                     reply, response = self._request_handler(msg, my_task, mac)
                     if reply:
@@ -188,7 +189,6 @@ class ESPNowSS:
                     if len(err.args) > 1 and err.args[1] == 'ESP_ERR_ESPNOW_NOT_FOUND':
                         # AUTOMATIC PEER REGISTRATION
                         self.espnow.add_peer(mac)
-                        reply, response = self._request_handler(msg, my_task, mac)
                         if reply:
                             await self.__asend_raw(mac, response)
                     else:
@@ -262,6 +262,14 @@ class ESPNowSS:
         return _tasks
 
     # ----------- OTHER METHODS --------------
+    def save_peers(self):
+        try:
+            with open(self.peer_cache_path, "w") 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):
         """
@@ -285,16 +293,10 @@ class ESPNowSS:
             expected_response =  f"hello {self.devfid}"
             is_ok = False
             if result == expected_response:
-                try:
-                    with open(self.peer_cache, "w") as f:
-                        dump([[list(k), v] for k, v in self.devices.items()], f)
-                    is_ok = True
-                except Exception as e:
-                    syslog(f"[ERR][ESPNOW] Saving peers: {e}")
+                is_ok = self.save_peers()
             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"
         # Create an asynchronous sending task.
@@ -321,4 +323,19 @@ class ESPNowSS:
             _peers = self.espnow.peers_table
         except Exception as e:
             _peers = str(e)
-        return {"stats": _stats, "peers": _peers, "map": self.devices, "ready": self.server_ready}
+        return {"stats": _stats, "peers": _peers, "ready": self.server_ready}
+    
+    def members(self):
+        return self.devices
+
+    def remove_peer(self, peer:bytes) -> bool:
+        """
+        Remove peer from ESPNow devices
+        :param peer: MAC address as bytes to remove
+        """
+        if isinstance(peer, bytes):
+            if self.devices.pop(peer, None) is not None:
+                self.save_peers()
+                self.espnow.del_peer(peer)
+                return True
+        return False

micrOS/source/InterConnect.py

@@ -1,14 +1,34 @@
+"""
+Module is responsible for device-device communication
+dedicated to micrOS framework.
+Built-in-function:
+- Socket InterConnect interface
+- ESPNow redirection
+
+Designed by 
+    Marcell Ban aka BxNxM
+    Kristof Kasza aka KKristof452
+"""
+
 from socket import getaddrinfo, SOCK_STREAM
-from re import compile
+from re import compile as re_compile
+from json import loads
 from uasyncio import open_connection
+
 from Debug import syslog
 from Config import cfgget
 from Server import Server
 from Tasks import NativeTask
 
+if cfgget('espnow'):
+    from Espnow import ESPNowSS
+else:
+    ESPNowSS = None
+
 
 class InterCon:
-    CONN_MAP = {}
+    CONN_MAP: dict[str, str] = {}   # hostname: IP address pairs
+    NO_ESPNOW: list[str] = []       # disabled ESPNow hostname list (cache for fallback speed-up)
     PORT = cfgget('socport')
 
     def __init__(self):
@@ -19,7 +39,7 @@ class InterCon:
 
     @staticmethod
     def validate_ipv4(str_in):
-        pattern = compile(r'^(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])$')
+        pattern = re_compile(r'^(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])$')
         return bool(pattern.match(str_in))
 
     async def send_cmd(self, host:str, cmd:list):
@@ -34,7 +54,12 @@ class InterCon:
         # Check if host is a hostname (example.local) and resolve its IP address
         if not InterCon.validate_ipv4(host):
             hostname = host
-            # Retrieve IP address by hostname dynamically
+            # Lookup hostname without .domain (sub-hostname matching)
+            if '.' not in hostname:
+                _hosts = list([d for d in InterCon.CONN_MAP if hostname in d])
+                if len(_hosts) > 0:
+                    hostname = _hosts[0]
+            # Retrieve IP address by hostname.domain dynamically
             if InterCon.CONN_MAP.get(hostname, None) is None:
                 try:
                     addr_info = getaddrinfo(host, InterCon.PORT, 0, SOCK_STREAM)
@@ -68,8 +93,7 @@ class InterCon:
                 InterCon.CONN_MAP[hostname] = None if output is None else host
             # None: ServerBusy(or \0) or Prompt mismatch (auto delete cached IP), STR: valid comm. output
             return output
-        else:
-            syslog(f"[ERR][intercon] Invalid host: {host}")
+        syslog(f"[ERR][intercon] Invalid host: {host}")
         return ''
 
     async def __run_command(self, cmd:list, hostname:str):
@@ -85,7 +109,6 @@ class InterCon:
         # Compare prompt |node01 $| with hostname 'node01.local'
         if hostname is None or prompt is None or str(prompt).replace('$', '').strip() == str(hostname).split('.')[0]:
             # Run command on validated device
-            # TODO: Handle multiple cmd as input, separated by ; (????)
             self.writer.write(str.encode(' '.join(cmd)))
             await self.writer.drain()
             data, _ = await self.__receive_data(prompt=prompt)
@@ -109,7 +132,7 @@ class InterCon:
             return True             # AuthOk
         return False                # AuthFailed
 
-    async def __receive_data(self, prompt=None):
+    async def __receive_data(self, prompt=None) -> tuple[str, str]:
         """
         Implements data receive loop until prompt / [configure] / Bye!
         :param prompt: socket shell prompt
@@ -139,8 +162,34 @@ class InterCon:
         data = data.replace(prompt, '').replace('\n', ' ')
         return data, prompt
 
+    async def auto_espnow_handshake(self, host:str) -> dict:
+        """
+        [1] Check espnow.server running on host
+        [2] Get MAC address for host (from system info)
+        [3] Execute ESPNowSS.handshake
+        """
+        response = await self.send_cmd(host, ["task", "list", ">json"])
+        if not response:
+            return {None: f"[ERR] ESPNow auto handshake: task list, {response}"}
+
+        active_tasks = loads(response).get("active")
+        if "espnow.server" in active_tasks:
+            response = await self.send_cmd(host, ["system", "info", ">json"])
+            if not response:
+                return {None: "[ERR] ESPNow auto handshake: system info"}
+            try:
+                host_mac = loads(response).get("mac")
+            except Exception as ex:
+                return {None: f"[ERR] ESPNow auto handshake: {ex}"}
+
+            return ESPNowSS().handshake(host_mac)
+
+        if not InterCon.validate_ipv4(host):
+            InterCon.NO_ESPNOW.append(str(host).split(".")[0])   # host.local -> host
+        return {None: f"ESPNow auto handshake: espnow disabled on host {host}"}
+
 
-async def _send_cmd(host:str, cmd:list, com_obj):
+async def _socket_send_cmd(host:str, cmd:list, com_obj:InterCon) -> None:
     """
     Async send command wrapper for further async task integration and sync send_cmd usage (main)
     :param host: hostname / IP address
@@ -148,21 +197,57 @@ async def _send_cmd(host:str, cmd:list, com_obj):
     :param com_obj: InterCon object to utilize send_cmd method and task status updates
     """
     # Send command
+    for _ in range(0, 2):                           # Retry mechanism
+        out = await com_obj.send_cmd(host, cmd)     # Send CMD
+        if out is not None:                         # Retry mechanism
+            break
+        await com_obj.task.feed(sleep_ms=100)       # Retry mechanism
+    com_obj.task.out = '' if out is None else out
+
+
+async def _send_cmd(host:str, cmd:list|str, com_obj:InterCon):
+    """
+    Top level InterConnect callback function
+        [1] node01.domain -> ESPNow, Socket
+                (domain: .local, .net, etc.)
+        [2] node01 -> ESPNow, Socket fallback in case found in InterConnect cache
+        [3] IP address -> Socket
+    """
     with com_obj.task:
-        for _ in range(0, 4):                           # Retry mechanism
-            out = await com_obj.send_cmd(host, cmd)     # Send CMD
-            if out is not None:                         # Retry mechanism
-                break
-            await com_obj.task.feed(sleep_ms=100)       # Retry mechanism
-        com_obj.task.out = '' if out is None else out
-    return com_obj.task.out
+        if ESPNowSS:
+            # [1] ESPNow Active
+            name = str(host).split(".")[0]   # host.local -> host
+            if name not in InterCon.NO_ESPNOW and name in list(ESPNowSS().devices.values()):
+                com_obj.task.out = "Redirected to ESPNow"
+                if isinstance(cmd, list):
+                    cmd = ' '.join(cmd)
+                # Send command and retrieve result
+                sender = ESPNowSS().send(peer=name, msg=cmd)
+                sender_task = NativeTask.TASKS.get(list(sender.keys())[0])
+                result = await sender_task.await_result(timeout=10)
+                if result != "Timeout has beed exceeded":
+                    # Successful command execution
+                    com_obj.task.out = result                       # Output mirroring: Child -> Parent
+                    sender_task.out = "Redirected to ParentTask"    # Remove redundant data in embedded mode
+                    return
+
+        # Handle legacy string input
+        if isinstance(cmd, str):
+            cmd = cmd.split()
+        # [1][2] Socket send (default and fallback)
+        await _socket_send_cmd(host, cmd, com_obj)
+
+        if ESPNowSS and name not in InterCon.NO_ESPNOW:
+            # [3] Automatic ESPNow handshake
+            verdict = await com_obj.auto_espnow_handshake(host)
+            if list(verdict.keys())[0] is None:
+                syslog(str(list(verdict.values())[0]))
 
 
 def send_cmd(host:str, cmd:list|str) -> dict:
     """
-    Sync wrapper of async _send_cmd (InterCon.send_cmd consumer with retry)
-    :param host: hostname / IP address
-    :param cmd: command string to server socket shell
+    Top level InterConnect send task creation
+        Handles ESPNow and socket communication
     """
     def _tagify():
         nonlocal host, cmd
@@ -171,18 +256,10 @@ def send_cmd(host:str, cmd:list|str) -> dict:
             return f"{'.'.join(host.split('.')[-2:])}.{_mod}"
         return f"{host.replace('.local', '')}.{_mod}"
 
-    # Handle legacy string input
-    if isinstance(cmd, str):
-        cmd = cmd.split()
-
     com_obj = InterCon()
-    tag = f"con.{_tagify()}"
-    started = com_obj.task.create(callback=_send_cmd(host, cmd, com_obj), tag=tag)
-    if started:
-        result = {"verdict": f"Task started: task show {tag}", "tag": tag}
-    else:
-        result = {"verdict": "Task is Busy", "tag": tag}
-    return result
+    task_id = f"con.{_tagify()}"            # CHECK TASK ID CONFLICT
+    state = com_obj.task.create(callback=_send_cmd(host, cmd, com_obj), tag=task_id)
+    return {task_id: "Starting"} if state else {task_id: "Already running"}
 
 
 def host_cache() -> dict:
@@ -190,4 +267,3 @@ def host_cache() -> dict:
     Dump InterCon connection cache
     """
     return InterCon.CONN_MAP
-

micrOS/source/Server.py

@@ -183,12 +183,11 @@ class WebCli(Client, WebEngine):
         :param method: HTTP method name
         :param auto_enable: enable webui when register (endpoint)
         """
-        if method not in WebEngine.METHODS:
-            raise ValueError(f"method must be one of {WebEngine.METHODS}")
-
         if cfgget('webui'):
             if not endpoint in WebEngine.ENDPOINTS:
                 WebEngine.ENDPOINTS[endpoint] = {}
+            if method not in WebEngine.METHODS:
+                raise ValueError(f"method must be one of {WebEngine.METHODS}")
             WebEngine.ENDPOINTS[endpoint][method] = callback
             return
         # AUTO ENABLE webui when register (endpoint) called and webui is False

micrOS/source/Shell.py

@@ -25,7 +25,7 @@ from Debug import syslog
 
 class Shell:
     __slots__ = ['__devfid', '__auth_mode', '__hwuid', '__auth_ok', '__conf_mode']
-    MICROS_VERSION = '2.17.1-0'
+    MICROS_VERSION = '2.19.0-0'
 
     def __init__(self):
         """

micrOS/source/Tasks.py

@@ -43,6 +43,20 @@ class TaskBase:
         self.done = asyncio.Event()  # Store task done state
         self.out = ""                # Store task output
 
+    def _create(self, callback:callable) -> bool:
+        """
+        Create async task and register it to TASKS dict by tag
+        :param callback: coroutine function
+        """
+        if TaskBase.is_busy(self.tag):
+            # Skip task if already running
+            return False
+        # Create async task from coroutine function
+        self.task = asyncio.get_event_loop().create_task(callback)
+        # Store Task object by key - for task control
+        TaskBase.TASKS[self.tag] = self
+        return True
+
     @staticmethod
     def is_busy(tag:str) -> bool:
         """
@@ -50,7 +64,7 @@ class TaskBase:
         :param tag: for task selection
         """
         task = TaskBase.TASKS.get(tag, None)
-        # return True: busy OR False: not busy (inactive)
+        # return True: busy OR False: not busy (inactive) OR None: not exists
         return bool(task is not None and not task.done.is_set())
 
     @staticmethod
@@ -138,15 +152,8 @@ class NativeTask(TaskBase):
         """
         # Create task tag
         self.tag = f"aio.{ticks_ms()}" if tag is None else tag
-        if TaskBase.is_busy(self.tag):
-            # Skip task if already running
-            return False
-
-        # Start task with coroutine callback
-        self.task = asyncio.get_event_loop().create_task(callback)
-        # Store Task object by key - for task control
-        TaskBase.TASKS[self.tag] = self
-        return True
+        # Create task with coroutine callback
+        return super()._create(callback)
 
     def __enter__(self):
         """
@@ -189,9 +196,6 @@ class MagicTask(TaskBase):
         """
         # Create task tag
         self.tag = '.'.join(callback[0:2])
-        if TaskBase.is_busy(self.tag):
-            # Skip task if already running
-            return False
 
         # Set parameters for async wrapper
         self.__callback = callback
@@ -199,10 +203,8 @@ class MagicTask(TaskBase):
         # Set sleep value for async loop - optional parameter with min sleep limit check (20ms)
         self.__sleep = self.__sleep if sleep is None else sleep if sleep > 19 else self.__sleep
 
-        self.task = asyncio.get_event_loop().create_task(self.__task_wrapper())
-        # Store Task object by key - for task control
-        TaskBase.TASKS[self.tag] = self
-        return True
+        # Create task with coroutine callback
+        return super()._create(self.__task_wrapper())
 
     async def __task_wrapper(self):
         """
@@ -373,7 +375,7 @@ class Manager:
         return '\n'.join(output)
 
     @staticmethod
-    def kill(tag):
+    def kill(tag:str) -> (bool, str):
         """
         Primary interface
         Kill/terminate async task
@@ -474,11 +476,11 @@ def exec_builtins(func):
                 if arg_len > 1 and 'list' == arg_list[1]:
                     on, off = Manager.list_tasks(json=json_flag)
                     # RETURN:    JSON mode                                                   Human readable mode with cpu & queue info
-                    return (True, {'active': on[3:], 'inactive': off}) if json_flag else (True, '\n'.join(on) + '\n' + '\n'.join(off) + '\n')
+                    return (True, dumps({'active': on[3:], 'inactive': off})) if json_flag else (True, '\n'.join(on) + '\n' + '\n'.join(off) + '\n')
                 # task kill <taskID> / task show <taskID>
                 if arg_len > 2:
                     if 'kill' == arg_list[1]:
-                        state, msg = Manager.kill(tag=arg_list[2])
+                        _, msg = Manager.kill(tag=arg_list[2])
                         return True, msg
                     if 'show' == arg_list[1]:
                         return True, Manager.show(tag=arg_list[2])

micrOS/source/micrOSloader.py

@@ -102,7 +102,7 @@ def __auto_restart_event():
         if trigger_is_active and _is_micrOS():
             print("[loader][ota-rebooter][micros][trigger: True] OTA was finished - reboot")
             # Create cleanup indicator file for ConfigHandler
-            with open('cleanup.pds', 'w') as f:
+            with open('.cleanup', 'w') as f:
                 f.write('')
             # Reboot machine
             reset()

micrOS/source/modules/LM_espnow.py

@@ -17,6 +17,13 @@ def stats():
     return ESPNOW.stats()
 
 
+def members():
+    """
+    Get ESPNow devices
+    """
+    return ESPNOW.members()
+
+
 def handshake(peer:bytes|str):
     """
     Handshake with ESPNow Peer
@@ -27,10 +34,20 @@ def handshake(peer:bytes|str):
     return ESPNOW.handshake(peer)
 
 
+def remove(peer:bytes):
+    """
+    Remove peer by binary mac address
+    :param peer: binary mac address of espnow device
+    """
+    return ESPNOW.remove_peer(peer)
+
+
 def help():
     """
     ESPNOW sender/receiver with LM execution
     """
     return ('handshake peer=<mac-address>',
             'send peer=<peer-name> cmd="hello"',
-            'stats')
+            'remove peer=<binary-mac-address>',
+            'stats',
+            'members')

micrOS/source/modules/LM_neoeffects.py

@@ -277,7 +277,7 @@ def help(widgets=False):
                              'BUTTON fire speed_ms=150',
                              'BUTTON stop',
                              'shader offset=0 size=6',
-                             'control speed_ms=None batch=None',
+                             'SLIDER control speed_ms=<1-200> batch=None',
                              'random max_val=255',
                              'pinmap',
                              'COLOR color r=<0-255-10> g b'

micrOS/source/modules/LM_neomatrix.py

@@ -430,7 +430,7 @@ def help(widgets=False):
                              'BUTTON rainbow',
                              'BUTTON spiral speed_ms=40',
                              'BUTTON noise speed_ms=85',
-                             'SLIDER control speed_ms=<1-200-2> bt_draw=None',
+                             'SLIDER control speed_ms=<1-200> bt_draw=None',
                              'draw_colormap bitmap=[(0,0,(10,2,0)),(x,y,color),...]',
                              'get_colormap',
                              'status'

micrOS/source/modules/LM_oled_ui.py

@@ -343,9 +343,10 @@ class PageUI:
                 # Send CMD to other device & show result
                 state, data_meta = exec_cmd(cmd + [f">>{host}"], jsonify=True)
                 if state:
-                    self.cmd_task_tag = data_meta['tag']
-                    if "Task is Busy" in data_meta['verdict'] and not run:
-                        self.cmd_out = data_meta['verdict']     # Otherwise the task start output not relevant on UI
+                    self.cmd_task_tag = list(data_meta.keys())[0]
+                    verdict = list(data_meta.values())[0]
+                    if "Already running" in verdict and not run:
+                        self.cmd_out = verdict     # Otherwise the task start output not relevant on UI
                 else:
                     self.cmd_out = f"Error: {data_meta}"
             except Exception as e:

micrOS/source/modules/LM_oledui.py

@@ -782,9 +782,10 @@ class PageUI:
                 # Send CMD to other device & show result
                 state, data_meta = exec_cmd(cmd + [f">>{host}"], jsonify=True)
                 if state:
-                    self._cmd_task_tag = data_meta['tag']
-                    if "Task is Busy" in data_meta['verdict'] and not run:
-                        self.app_frame.press_output = data_meta['verdict']     # Otherwise the task start output not relevant on UI
+                    self._cmd_task_tag = list(data_meta.keys())[0]
+                    verdict = list(data_meta.values())[0]
+                    if "Already running" in verdict and not run:
+                        self.app_frame.press_output = verdict     # Otherwise the task start output not relevant on UI
                 else:
                     self.app_frame.press_output = f"Error: {data_meta}"
             except Exception as e: