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

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'

micrOS/source/LM_mqtt_pro.py

@@ -0,0 +1,211 @@
+# async_message.py Test of asynchronous mqtt client with async Broker class
+# (C) Copyright Peter Hinch 2024.
+# Released under the MIT licence.
+# Public brokers https://github.com/mqtt/mqtt.github.io/wiki/public_brokers
+# mip command: ???
+
+from Config import cfgget
+from mqtt_as import MQTTClient, config
+from Common import micro_task, console, syslog, exec_cmd
+
+
+# Set up MQTT
+class MQTT:
+    CLIENT:MQTTClient = None        # MQTT Client (broker) instance
+    TOPIC = "micros"                # Default topic
+    TOPIC_COMMAND_LUT = {}          # Lookup table for command/topic pairs
+    # Example:
+    #       {"topic1": ["mod func", "mod2 func"], "topic2": []}
+
+
+async def _receiver(task):
+    """
+    MQTT AS receiver loop
+    """
+    async for topic, msg, retained in MQTT.CLIENT.queue:
+        topic, msg = topic.decode(), msg.decode()
+        console(f'Topic: "{topic}" Message: "{msg}" Retained: {retained}')
+
+        # Command execution... use MQTT.TOPIC_COMMAND_LUT
+        topic_commands:list = MQTT.TOPIC_COMMAND_LUT.get(topic, None)
+        output_struct:list = []
+        if topic_commands is None:
+            syslog(f"[WARN] mqtt Unknown topic: {topic}")
+        elif len(topic_commands) == 0:
+            syslog(f"[WARN] mqtt No commands for {topic}")
+        else:
+            task.out = f"Handle topic: {topic}"
+            for cmd in topic_commands:
+                single_command = cmd.split()
+                if len(single_command) > 0:
+                    state, output = exec_cmd(single_command, jsonify=True, skip_check=True)
+                    output_struct.append({"state": state, "result": output, "cmd": cmd})
+            if len(output_struct) > 0:
+                console(f'\tMQTT Publish: {output_struct}')
+                task.out = f"Publish {topic}"
+                MQTT.CLIENT.publish(topic, str(output_struct))
+            else:
+                task.out = f"Nothing to publish {topic}"
+        task.feed()
+
+
+async def _subscribe():
+    """
+    MQTT AS Topic subscribe towards server
+    """
+    with micro_task(tag="mqtt.subscribe") as my_task:
+        my_task.out = "Started"
+        try:
+            for t in MQTT.TOPIC_COMMAND_LUT:
+                console(f"Subscribe topic: {t}")
+                await MQTT.CLIENT.subscribe(t, 1)
+            my_task.out = "Done"
+        except Exception as e:
+            my_task.out = f"Error: {e}"
+
+
+async def _publish(message, topic):
+    """
+    Send message to topic with mqtt
+    """
+    tag = f"mqtt.publish.{topic}"
+    with micro_task(tag=tag) as my_task:
+        console(f"mqtt send: [{topic}] {message}")
+        await MQTT.CLIENT.publish(topic, message, qos=1)
+        my_task.out = "Sent"
+
+
+async def _up():
+    """
+    UP Listener - resubscribe
+    """
+    with micro_task(tag="mqtt.up") as my_task:
+        while True:
+            # Wait for UP Event - (re)subscribe
+            my_task.out = "Wait"
+            await MQTT.CLIENT.up.wait()
+            MQTT.CLIENT.up.clear()
+            micro_task(tag="mqtt.subscribe", task=_subscribe())
+            my_task.out = "Re-Subscription"
+            my_task.feed()
+
+
+async def _init_client(topic:str=None, commands:str=None, raw_dict:dict|None=None):
+    """
+    Initialize main mqtt receiver and topics
+    :param topic: topic string, ex.: 'lights'
+    :param commands: semicolon separated commands. ex.: 'rgb toggle; cct toggle'
+    OR
+    :param raw_dict: python dict string for multi topic subscription, ex.: {"lights": ["rgb toggle", "cct toggle"], ...}
+    """
+    with micro_task(tag="mqtt.client") as my_task:
+        try:
+            await MQTT.CLIENT.connect()
+            my_task.out = "Connection successful."
+        except OSError:
+            my_task.out = "Connection failed."
+            return
+        # Wait for mqtt client connected successfully
+        await MQTT.CLIENT.up.wait()
+        MQTT.CLIENT.up.clear()
+        # Initialize mqtt topics, ha
+        subscribe(topic, commands, raw_dict)
+        micro_task(tag="mqtt.up", task=_up())
+        # Async listener loop
+        await _receiver(my_task)
+        my_task.out = "Receiver closed"
+    # Close when listener exits
+    MQTT.CLIENT.close()
+
+#########################################
+#           PUBLIC FUNCTIONS            #
+#########################################
+
+def publish(message:str, topic:str=MQTT.TOPIC):
+    """
+    Publish message
+    :param message: string to be sent
+    :param topic: topic for message
+    """
+    state = micro_task(tag=f"mqtt.publish.{topic}", task=_publish(message, topic))
+    state = "starting" if state else "already running"
+    return f"Message send, {state}"
+
+
+def subscribe(topic:str=None, commands:str=None, raw_dict:dict|None=None):
+    """
+    Subscribe for single topics and set callback function(s) aka command(s)
+    :param topic: topic string, ex.: 'lights'
+    :param commands: semicolon separated commands. ex.: 'rgb toggle; cct toggle'
+    OR
+    :param raw_dict: python dict string for multi topic subscription, ex.: {"lights": ["rgb toggle", "cct toggle"], ...}
+
+    return: all or selected topics command
+    """
+    updated = False
+    topic = topic.strip()
+    # Register single topic
+    if topic and commands:
+        # raw commands structure: 'rgb toggle; cct toggle'
+        commands = [ c.strip() for c in commands.split(";") ]
+        # commands: Topic LUT structure: {'topic': ['mod func'], ..., 'lights': ['rgb toggle', 'cct toggle']}
+        updated = True if MQTT.TOPIC_COMMAND_LUT.get(topic, None) is None else False
+        MQTT.TOPIC_COMMAND_LUT[topic] = commands
+    # Register multiple topics at once
+    elif isinstance(raw_dict, dict):
+        updated = True
+        MQTT.TOPIC_COMMAND_LUT.update(raw_dict)
+    # Start subscribe task
+    if updated:
+        state = micro_task(tag="mqtt.subscribe", task=_subscribe())
+        state = "starting" if state else "already running"
+        return f"Subscribe, {state}"
+
+    # Return handling
+    if topic is not None:
+        # Return selected topic commands
+        return MQTT.TOPIC_COMMAND_LUT.get(topic, None)
+    # Return registered topics
+    return MQTT.TOPIC_COMMAND_LUT
+
+
+def _configure(server_ip:str, username:str, password:str):
+    # Define configuration
+    config["keepalive"] = 120
+    config["queue_len"] = 1  # Use event interface with default queue
+    # Define configuration
+    config['client_id'] = cfgget("devfid")
+    config['ssid'] = cfgget("staessid")
+    config['wifi_pw'] = cfgget("stapwd")
+    config['port'] = 1883                       # expose????
+    config['server'] = server_ip                # '172.20.10.2'
+    config['user'] = username                   # test
+    config['password'] = password               # '12345'
+    return config
+
+
+def load(server_ip:str, username:str, password:str, topic:str=None, commands:str=None, raw_dict:dict|None=None):
+    """
+    Load MQTT_AS receiver...
+    :param server_ip: server IP address
+    :param username: server user
+    :param password: server user password
+
+    :param topic: topic string, ex.: 'lights'
+    :param commands: semicolon separated commands. ex.: 'rgb toggle; cct toggle'
+    OR
+    :param raw_dict: python dict string for multi topic subscription, ex.: {"lights": ["rgb toggle", "cct toggle"], ...}
+    """
+    MQTTClient.DEBUG = True
+    MQTT.CLIENT = MQTTClient(_configure(server_ip, username, password))
+
+    state = micro_task(tag="mqtt.client", task=_init_client(topic, commands, raw_dict))
+    return "Starting" if state else "Already running"
+
+
+def help():
+    return ("load <server_ip> <username> <password> topic='micros', commands='rgb toggle; cct toggle'",
+            "subscribe topic='micros', commands='rgb toggle; cct toggle'",
+            "subscribe #without params dumps the topic-command data structure",
+            "publish message='hello' topic='micros'",
+            "HINT: task show mqtt.*")

micrOS/source/LM_pacman.py

@@ -1,73 +1,56 @@
-from uos import listdir, remove, stat
 from sys import modules
 from Common import socket_stream
-
-WEB_EXT = ('html', 'js', 'css')
-DATA_TYPES = ('log', 'pds', 'dat')
-
-def _is_app_resource(path='/'):
-    if stat(path)[0] & 0x4000:      # Dir check
-        return True, 'd'
-    file_name = path.split("/")[-1]
-    if file_name.startswith('LM_') or file_name.split('.')[-1] in WEB_EXT + DATA_TYPES:
-        return True, 'f'
-    return False, '?'
+from Files import _is_module, list_fs, ilist_fs, remove_fs
 
 
 #############################################
 #     Safe file system handler functions    #
 #############################################
 
-def ls(path="/", content='*', raw=False):
+def ls(path="/", content='*', raw=False, select='*'):
     """
     Linux like ls command - list app resources and app folders
     :param path: path to list, default: /
     :param content: content type, default all, f-file, d-dir can be selected
     :param raw: keep raw output [(is_app, type), ...]
+    :param select: select specific app resource: LM or IO, default: all
     """
-    path = path if path.endswith('/') else f"{path}/"
-    items = []
-    for item in listdir(path):
-        is_app, item_type = _is_app_resource(path + item)
-        if is_app and (content == "*" or item_type == content):
-            items.append((item_type, item))
+    items = list_fs(path, content, select=select)
     if raw:
         return items
-    formatted_output = ""
-    i = 0
-    for f in items:
-        i += 1
-        spacer = " " * (4 - len(str(i)))
-        formatted_output += f"{i}{spacer}{f[0]}   {f[1]}\n"
-    return formatted_output
+
+    # Build a formatted output (just like `ls -l` style index)
+    lines = ""
+    for i, f in enumerate(items):
+        spacer = " " * (4 - len(str(i+1)))
+        if content == "*":
+            lines += f"{i+1}{spacer}{f[0]}   {f[1]}\n"
+        else:
+            lines += f"{i + 1}{spacer}{f}\n"
+    return lines
 
 
-def rm(path):
+def rm(path, allow_dir=False):
     """
     Linux like rm command - delete app resources and folders
     :param path: app resource name/path, ex.: LM_robustness.py
+    :param allow_dir: enable directory deletion, default: False
     """
-    if 'pacman.' in path or 'system.' in path or "/" == path.strip():
-        return f'Load module {path} is protected, skip delete.'
-    is_app, item_type = _is_app_resource(path)
-    if is_app:
-        remove(path)
-        return f"Remove: {path} {'dir' if item_type == 'd' else 'file'}"
-    return f"Invalid path {path}"
+    return remove_fs(path, allow_dir)
 
 
 def dirtree(path="/", raw=False):
     """Return only directories from a given path."""
     path = path if path.endswith('/') else f"{path}/"
-    folders = [f"{path}/{item}" for item in listdir(path) if _is_app_resource(f"{path}{item}")[1] == 'd']
-    folder_contents = {folder:listdir(folder) for folder in folders}
+    folders = [f"{path}/{item}" for item in ilist_fs(path, type_filter='d')]
+    folder_contents = {folder:list_fs(folder) for folder in folders}
     if raw:
         return folder_contents
     formatted_output = ""
     for k, v in folder_contents.items():
         formatted_output += f"{k}\n"
         for val in v:
-            formatted_output += f"\t{val}\n"
+            formatted_output += f"\t{val[0]}   {val[1]}\n"
     return formatted_output
 
 
@@ -108,18 +91,20 @@ def del_duplicates():
     - delete duplicated .mpy and .py resources, keep .mpy resource!
     """
     msg_buf = []
-    py = list((res.split('.')[0] for res in listdir() if res.endswith('.py')))       # Normally smaller list
-    mpy = (res.split('.')[0] for res in listdir() if res.endswith('.mpy'))
+    files =  list_fs(type_filter='f', select='LM')
+    py = list((res.split('.')[0] for res in files if res.endswith('.py')))       # Normally smaller list
+    mpy = (res.split('.')[0] for res in files if res.endswith('.mpy'))
     for m in mpy:
         # Iterate over mpy resources
         state = True
         if m in py and m != 'main':
             to_delete = f'{m}.py'
             try:
-                remove(to_delete)
+                verdict = remove_fs(to_delete)
             except:
+                verdict = "n/a"
                 state = False
-            msg_buf.append(f'   Delete {to_delete} {state}')
+            msg_buf.append(f'   Delete {to_delete} {state} - {verdict}')
     return '\n'.join(msg_buf) if len(msg_buf) > 0 else 'Nothing to delete.'
 
 
@@ -147,7 +132,7 @@ def cachedump(delpds=None, msgobj=None):
     if delpds is None:
         # List pds files aka application cache
         msg_buf = []
-        for pds in (_pds for _pds in listdir() if _pds.endswith('.pds')):
+        for pds in (_pds for _pds in ilist_fs(type_filter='f') if _pds.endswith('.pds')):
             with open(pds, 'r') as f:
                 if msgobj is None:
                     msg_buf.append(f'{pds}: {f.read()}')
@@ -156,8 +141,8 @@ def cachedump(delpds=None, msgobj=None):
         return msg_buf if len(msg_buf) > 0 else ''
     # Remove given pds file
     try:
-        remove(f'{delpds}.pds')
-        return f'{delpds}.pds delete done.'
+        verdict = remove_fs(f'{delpds}.pds')
+        return f'{delpds}.pds delete done.: {verdict}'
     except:
         return f'{delpds}.pds not exists'
 
@@ -168,7 +153,7 @@ def dat_dump():
     - logged data from LMs, sensor datat, etc...
     """
     logs_dir = "/logs/"
-    dats = (f for f in listdir(logs_dir) if f.endswith('.dat'))
+    dats = (f for f in ilist_fs(type_filter='f') if f.endswith('.dat'))
     out = {}
     for dat in dats:
         with open(f"{logs_dir}{dat}", 'r') as f:
@@ -188,8 +173,7 @@ def listmods(msgobj=None):
     """
     # Dump available LMs
     msg_buf = []
-    for k in (res.replace('LM_', '') for res in listdir("/")
-              if res.startswith('LM_') or res.split('.')[-1] in WEB_EXT):
+    for k in (res.replace('LM_', '') for res in ilist_fs(type_filter='f', select='LM')):
         if msgobj is None:
             msg_buf.append(f'   {k}')
         else:
@@ -197,21 +181,17 @@ def listmods(msgobj=None):
     return msg_buf if len(msg_buf) > 0 else ''
 
 
-def delmod(mod=None):
+def delmod(mod):
     """
     Module package manager
     :param mod:
         Delete Load Module with full name: module.py or module.mpy
         OR delete any web resource: *.js, *.css, *.html
     """
-    if mod is not None and (mod.endswith('py') or mod.split('.')[-1] in WEB_EXT):
-        # LM exception list - system and pacman cannot be deleted
-        if 'pacman.' in mod or 'system.' in mod:
-            return f'Load module {mod} is in use, skip delete.'
+    if mod.endswith('py') or _is_module(mod):
         try:
-            to_remove = mod if mod.split('.')[-1] in WEB_EXT else f'LM_{mod}'
-            remove(to_remove)
-            return f'Delete module: {mod}'
+            to_remove = f'LM_{mod}' if mod.endswith('py') else mod
+            return remove_fs(to_remove)
         except Exception as e:
             return f'Cannot delete: {mod}: {e}'
     return f'Invalid value: {mod}'
@@ -223,7 +203,7 @@ def micros_checksum(msgobj=None):
     from binascii import hexlify
     from Config import cfgget
 
-    for f_name in (_pds for _pds in listdir() if _pds.endswith('py')):
+    for f_name in ilist_fs(type_filter='f', select='LM'):
         with open(f_name, 'rb') as f:
             cs = hexlify(sha1(f.read()).digest()).decode('utf-8')
         msgobj(f"{cs} {f_name}")
@@ -244,5 +224,5 @@ def help(widgets=False):
             'dat_dump',
             'download url="BxNxM/micrOS/master/toolkit/workspace/precompiled/LM_robustness.py"',
             'micros_checksum',
-            'ls path="/" content="*/f/d"',
+            'ls path="/" content="*/f/d" select="*/LM/IO"',
             'rm <path>', 'dirtree path="/"')

micrOS/source/LM_system.py

@@ -1,4 +1,4 @@
-from uos import statvfs, getcwd, listdir, uname
+from uos import statvfs, getcwd, uname
 from utime import localtime
 from network import WLAN, STA_IF, AP_IF
 from binascii import hexlify

micrOS/source/Logger.py

@@ -6,7 +6,8 @@ Designed by Marcell Ban aka BxNxM
 """
 from time import localtime
 from re import match
-from uos import listdir, remove, stat, mkdir, getcwd
+from uos import remove, mkdir, getcwd
+from Files import ilist_fs, is_dir
 
 #############################################
 #        LOGGING WITH DATA ROTATION         #
@@ -18,14 +19,7 @@ def _init_logger():
     global LOG_FOLDER
     if LOG_FOLDER is None:
         LOG_FOLDER = f"{getcwd()}logs"
-        do_create = True
-        try:
-            if stat(LOG_FOLDER)[0] & 0x4000:
-                # Dir exists - skip create
-                do_create = False
-        except:
-            pass
-        if do_create:
+        if not is_dir(LOG_FOLDER):
             try:
                 mkdir(LOG_FOLDER)
                 syslog(f"[BOOT] log dir {LOG_FOLDER} init")
@@ -107,7 +101,7 @@ def log_get(f_name, msgobj=None):
 
 def syslog(data=None, msgobj=None):
     if data is None:
-        err_cnt = sum([log_get(f, msgobj) for f in listdir(LOG_FOLDER) if f.endswith(".sys.log")])
+        err_cnt = sum([log_get(f, msgobj) for f in ilist_fs(LOG_FOLDER, type_filter='f') if f.endswith(".sys.log")])
         return err_cnt
 
     _match = match(r"^\[([^\[\]]+)\]", data)
@@ -117,7 +111,7 @@ def syslog(data=None, msgobj=None):
 
 
 def log_clean(msgobj=None):
-    to_del = [file for file in listdir(LOG_FOLDER) if file.endswith('.log')]
+    to_del = [file for file in ilist_fs(LOG_FOLDER, type_filter='f') if file.endswith('.log')]
     for _del in to_del:
         _del = f"{LOG_FOLDER}/{_del}"
         if msgobj is not None:

micrOS/source/Shell.py

@@ -12,9 +12,9 @@ Designed by Marcell Ban aka BxNxM
 #                           IMPORTS                             #
 #################################################################
 from sys import modules
-from uos import listdir
 from machine import reset as hard_reset, soft_reset
 from Config import cfgget, cfgput
+from Files import ilist_fs
 from Tasks import lm_exec
 from Debug import errlog_add
 
@@ -25,7 +25,7 @@ from Debug import errlog_add
 
 class Shell:
     __slots__ = ['__devfid', '__auth_mode', '__hwuid', '__auth_ok', '__conf_mode']
-    MICROS_VERSION = '2.10.2-0'
+    MICROS_VERSION = '2.10.5-0'
 
     def __init__(self):
         """
@@ -155,27 +155,30 @@ class Shell:
 
         # HELP MSG
         if local_cmd and msg_list[0] == "help":
-            await self.a_send("[MICROS]     - built-in shell commands")
+            await self.a_send("[MICROS]")
             await self.a_send("   hello     - hello msg - for device identification")
             await self.a_send("   modules   - show active Load Modules")
             await self.a_send("   version   - returns micrOS version")
-            await self.a_send("   exit      - exit from shell socket prompt")
+            await self.a_send("   exit      - exit shell session")
             await self.a_send("   reboot    - system soft reboot (vm), hard reboot (hw): reboot -h")
             await self.a_send("   webrepl   - start webrepl, for file transfers use with --update")
-            await self.a_send("[CONF] Configure mode - built-in shell commands")
+            await self.a_send("[CONF] Configuration mode")
             await self.a_send("  conf       - Enter conf mode")
-            await self.a_send("    dump       - Dump all data")
+            await self.a_send("    dump       - Dump all data, filter: dump <str>")
             await self.a_send("    key        - Get value")
             await self.a_send("    key value  - Set value")
             await self.a_send("  noconf     - Exit conf mode")
-            await self.a_send("[TASK] postfix: ...&x - one-time, ...&&x - periodic, x: wait ms [x min: 20ms]")
-            await self.a_send("  task list         - list tasks by <tag>s")
+            await self.a_send("[TASK] Task operations")
+            await self.a_send("  task list         - list tasks by tags")
             await self.a_send("  task kill <tag>   - stop task")
             await self.a_send("  task show <tag>   - show task output")
-            await self.a_send("[EXEC] Command mode (LMs):")
-            await self.a_send("  >>node01.local    - INTERCON postfix, execute command on remote device")
-            await self.a_send("  >json             - JSON postfix, request json formatted output")
-            await self.a_send("  help lm           - list ALL LoadModules")
+            await self.a_send("[EXEC] Command mode, syntax(...): <module> <function> <params> <postfix>")
+            await self.a_send("  Postfix hints:")
+            await self.a_send("    ... &<x>            - start one-shot task")
+            await self.a_send("    ... &&<x>           - start periodic task, where <x>: delay ms [x min: 20ms]")
+            await self.a_send("    ... >>hostname      - remote command execution (intercon)")
+            await self.a_send("    ... >json           - request json formatted output")
+            await self.a_send("  help lm           - list ALL available LoadModules")
             if "lm" in str(msg_list):
                 return await Shell._show_lm_funcs(msg_obj=self.a_send)
             return await Shell._show_lm_funcs(msg_obj=self.a_send, active_only=True)
@@ -252,13 +255,13 @@ class Shell:
         Dump LM modules with functions - in case of [py] files
         Dump LM module with help function call - in case of [mpy] files
         """
-        async def _help(mod):
-            for lm_path in (i for i in mod if i.startswith('LM_') and (i.endswith('py'))):
+        async def _help(mods):
+            for lm_path in mods:
                 lm_name = lm_path.replace('LM_', '').split('.')[0]
                 try:
-                    await msg_obj(f"   {lm_name}")
+                    await msg_obj(f"  {lm_name}")
                     if lm_path.endswith('.mpy'):
-                        await msg_obj(f"   {' ' * len(lm_path.replace('LM_', '').split('.')[0])}help")
+                        await msg_obj(f"  {' ' * len(lm_path.replace('LM_', '').split('.')[0])}help")
                         continue
                     with open(lm_path, 'r') as f:
                         line = "micrOSisTheBest"
@@ -266,19 +269,20 @@ class Shell:
                             line = f.readline()
                             ldata = line.strip()
                             if ldata.startswith('def ') and not ldata.split()[1].startswith("_") and 'self' not in ldata:
-                                await msg_obj(f"   {' ' * len(lm_name)}{ldata.replace('def ', '').split('(')[0]}")
+                                await msg_obj(f"  {' ' * len(lm_name)}{ldata.replace('def ', '').split('(')[0]}")
                 except Exception as e:
                     await msg_obj(f"[{lm_path}] SHOW LM PARSER WARNING: {e}")
                     return False
             return True
 
+        await msg_obj("")
         # [1] list active modules (default in shell)
         if active_only:
             mod_keys = modules.keys()
-            active_modules = (dir_mod for dir_mod in listdir() if dir_mod.split('.')[0] in mod_keys)
+            active_modules = (dir_mod for dir_mod in ilist_fs(type_filter='f', select="LM") if dir_mod.split('.')[0] in mod_keys)
             return await _help(active_modules)
         # [2] list all LMs on file system (ALL - help lm) - manual
-        return await _help(listdir())
+        return await _help(ilist_fs(type_filter='f', select="LM"))
 
     @staticmethod
     async def webrepl(msg_obj, update=False):

micrOS/source/Tasks.py

@@ -44,7 +44,7 @@ class TaskBase:
         self.out = ""                # Store task output
 
     @staticmethod
-    def is_busy(tag) -> bool:
+    def is_busy(tag:str) -> bool:
         """
         Check task is busy by tag
         :param tag: for task selection
@@ -335,7 +335,7 @@ class Manager:
             _tasks = []
             tag_parts = tag.split('.')
             for t in TaskBase.TASKS:
-                if t.startswith(tag_parts[0]) and len(tag_parts) > 1 and tag_parts[1] == '*':
+                if len(tag_parts) > 1 and t.startswith('.'.join(tag_parts[0:-1])) and tag_parts[-1] == '*':
                     _tasks.append(t)
             if len(_tasks) == 0:
                 return []

micrOS/source/microIO.py

@@ -10,7 +10,8 @@ Designed by Marcell Ban aka BxNxM
 #                           IMPORTS                             #
 #################################################################
 from sys import platform
-from uos import listdir, uname
+from uos import uname
+from Files import ilist_fs
 from Logger import syslog
 
 #################################################################
@@ -65,7 +66,7 @@ def set_pinmap(map_data=None):
 
     # SELECT LOOKUP TABLE BASED ON PLATFORM / User input
     if isinstance(io_file, str) and io_file != 'n/a':
-        if f"IO_{io_file}" in [io.split('.')[0] for io in listdir() if io.startswith('IO_')]:
+        if f"IO_{io_file}" in [io.split('.')[0] for io in ilist_fs(type_filter='f', select="IO")]:
             PinMap.MAPPING_LUT = io_file
             return PinMap.MAPPING_LUT
     PinMap.MAPPING_LUT = detect_platform()