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

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,16 +255,20 @@ 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
-    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"}
+    return com_obj.task.create(callback=_send_cmd(host, cmd, com_obj), tag=task_id)
 
 
 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

micrOS/source/Pacman.py

@@ -0,0 +1,141 @@
+from mip import install
+from Files import OSPath, path_join, is_file
+from Debug import syslog
+
+
+# ---------------------------------------------------------------------
+# Utility helpers
+# ---------------------------------------------------------------------
+
+def _normalize_source(ref):
+    """
+    Normalize GitHub URLs or shorthand for mip compatibility.
+    Converts:
+      - https://github.com/user/repo/blob/branch/path/file.py → https://raw.githubusercontent.com/user/repo/branch/path/file.py
+      - https://github.com/user/repo/tree/branch/path → github:user/repo/path
+    Returns (normalized_ref, branch)
+    """
+    try:
+        ref = ref.strip().rstrip("/")
+        # Already in github: shorthand
+        if ref.startswith("github:"):
+            return ref, None
+
+        if ref.startswith("https://"):
+            ref = ref.replace("https://", "")
+        if ref.startswith("github.com"):
+            # Folder (tree) case → github:user/repo/path
+            if "/tree/" in ref:
+                print("[mip-normalize] detected GitHub tree folder link")
+                parts = ref.split("/")
+                user, repo = parts[1], parts[2]
+                branch = parts[4]
+                path = "/".join(parts[5:])
+                github_ref = f"github:{user}/{repo}/{path}".rstrip("/")
+                return github_ref, branch
+
+            # File (blob) case → raw.githubusercontent.com
+            if "/blob/" in ref:
+                print("[mip-normalize] detected GitHub blob file link")
+                url_base = "https://raw.githubusercontent.com/"
+                ref = ref.replace("github.com/", url_base).replace("/blob", "")
+                return ref, None
+
+            # Direct GitHub file (no blob/tree) → github:user/repo/path
+            if ref.count("/") >= 2:
+                print("[mip-normalize] direct GitHub path (no blob/tree)")
+                parts = ref.split("/")
+                user, repo = parts[1], parts[2]
+                path = "/".join(parts[3:])
+                github_ref = f"github:{user}/{repo}/{path}".rstrip("/")
+                return github_ref, None
+
+        print("[mip-normalize] unchanged")
+        return ref, None
+
+    except Exception as e:
+        syslog(f"[ERR][pacman] normalize failed: {ref}: {e}")
+        print(f"[normalize][ERROR] {e}")
+        return str(ref), None
+
+
+# ---------------------------------------------------------------------
+# Core installer
+# ---------------------------------------------------------------------
+
+def _install_any(ref, target=None):
+    """Internal wrapper with consistent error handling and debug output."""
+    verdict = f"[mip] Installing: {ref}\n"
+    try:
+        ref, branch = _normalize_source(ref)
+        kwargs = {}
+        if branch:
+            kwargs["version"] = branch
+        kwargs["target"] = target or OSPath.LIB
+        verdict = f"[mip] Installing: {ref} {kwargs}\n"
+        # MIP Install
+        install(ref, **kwargs)
+        verdict += f"  ✓ Installed successfully under {kwargs["target"]}"
+    except Exception as e:
+        err = f"  ✗ Failed to install '{ref}': {e}"
+        syslog(f"[ERR][pacman] {err}")
+        verdict += err
+    return verdict
+
+
+# ---------------------------------------------------------------------
+# Public install functions
+# ---------------------------------------------------------------------
+
+def install_requirements(source="requirements.txt"):
+    """Install from a requirements.txt file under /config."""
+    verdict = f"[mip] Installing from requirements file: {source}\n"
+    try:
+        source_path = path_join(OSPath.CONFIG, source)
+        verdict = f"[mip] Installing from requirements file: {source_path}\n"
+        if is_file(source_path):
+            install(source_path)
+            verdict += "  ✓ All listed packages processed"
+        else:
+            err = f"  ✗ {source_path} not exists"
+            syslog(f"[ERR][pacman] {err}")
+            verdict += err
+    except Exception as e:
+        err = f"  ✗ Failed to process {source}: {e}"
+        syslog(f"[ERR][pacman] {err}")
+        verdict += err
+    return verdict
+
+
+# ---------------------------------------------------------------------
+# Unified entry point
+# ---------------------------------------------------------------------
+
+def download(ref):
+    """
+    Unified mip-based downloader for micrOS.
+    Automatically detects:
+      - requirements.txt files (local or remote)
+      - Single-file load modules (LM_/IO_ names or URLs)
+      - GitHub or raw URLs (tree/blob/github:)
+      - Official MicroPython packages
+    """
+
+    if not ref:
+        return "[mip] Nothing to download (empty input)"
+
+    # 1. requirements.txt
+    if ref == "requirements.txt":
+        return install_requirements(ref)
+
+    if "github" in ref:
+        # 2. LM_/IO_ load modules → /modules
+        if ref.endswith("py") and ("LM_" in ref or "IO_" in ref):
+            return _install_any(ref, target=OSPath.MODULES)
+
+        # 3. GitHub or raw URLs → /lib
+        if ref.startswith("http") or ref.startswith("github"):
+            return _install_any(ref, target=OSPath.LIB)
+
+    # 4. Fallback: official micropython package → /lib
+    return _install_any(ref, target=OSPath.LIB)

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.19.0-0'
+    MICROS_VERSION = '2.21.0-0'
 
     def __init__(self):
         """

micrOS/source/Tasks.py

@@ -10,6 +10,7 @@ Designed by Marcell Ban aka BxNxM
 #################################################################
 from sys import modules
 from json import dumps
+from re import match
 import uasyncio as asyncio
 from micropython import schedule
 from utime import ticks_ms, ticks_diff
@@ -18,10 +19,10 @@ from Config import cfgget
 from Network import sta_high_avail
 
 try:
-    from gc import collect
+    from gc import collect as gcollect
 except ImportError:
     console_write("[SIMULATOR MODE GC IMPORT]")
-    from simgc import collect
+    from simgc import collect as gcollect
 
 #################################################################
 #                Implement custom task class                    #
@@ -43,32 +44,20 @@ class TaskBase:
         self.done = asyncio.Event()  # Store task done state
         self.out = ""                # Store task output
 
-    def _create(self, callback:callable) -> bool:
+    ######  BASE METHODS FOR CHILD CLASSES  ####
+    def _create(self, callback:callable) -> dict:
         """
         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:
-        """
-        Check task is busy by tag
-        :param tag: for task selection
-        """
-        task = TaskBase.TASKS.get(tag, None)
-        # return True: busy OR False: not busy (inactive) OR None: not exists
-        return bool(task is not None and not task.done.is_set())
+        return {self.tag: "Starting"}
 
     @staticmethod
-    def task_gc():
+    def _task_gc():
         """
         Automatic passive task deletion over QUEUE_SIZE
         """
@@ -77,18 +66,18 @@ class TaskBase:
         if len(passive) >= keep:
             for i in range(0, len(passive)-keep+1):
                 del TaskBase.TASKS[passive[i]]
-            collect()  # GC collect
+            gcollect()
 
+    ######  PUBLIC TASK METHODS  #####
     @staticmethod
-    async def feed(sleep_ms=1):
+    def is_busy(tag:str) -> bool:
         """
-        Feed event loop
-        :param sleep_ms: in millisecond
+        Check task is busy by tag
+        :param tag: for task selection
         """
-        # TODO: feed WDT - preemptive cooperative multitasking aka reboot if no feed until X time period
-        if sleep_ms <= 0:
-            return await asyncio.sleep(0.000_000_1)     # 0 means: 100ns (Absolute minimum)
-        return await asyncio.sleep_ms(sleep_ms)
+        task = TaskBase.TASKS.get(tag, None)
+        # return True: busy OR False: not busy (inactive) OR None: not exists
+        return bool(task is not None and not task.done.is_set())
 
     def cancel(self) -> bool:
         """
@@ -109,15 +98,16 @@ class TaskBase:
             return False
         return True
 
-    def __task_del(self, keep_cache=False):
+    @staticmethod
+    async def feed(sleep_ms=1):
         """
-        Delete task from TASKS
+        Feed event loop
+        :param sleep_ms: in millisecond
         """
-        self.done.set()
-        if self.tag in TaskBase.TASKS:
-            if not keep_cache:              # True - In case of destructor
-                del TaskBase.TASKS[self.tag]
-        collect()                           # GC collect
+        # TODO?: feed WDT - auto restart when system is frozen
+        if sleep_ms <= 0:
+            return await asyncio.sleep(0.000_000_1)     # 0 means: 100ns (Absolute minimum)
+        return await asyncio.sleep_ms(sleep_ms)
 
     async def await_result(self, timeout:int=5):
         """
@@ -130,6 +120,17 @@ class TaskBase:
             return "Timeout has beed exceeded"
         return self.out
 
+    ######  PRIVATE LCM METHODS  #####
+    def __task_del(self, keep_cache=False):
+        """
+        Delete task from TASKS
+        """
+        self.done.set()
+        if self.tag in TaskBase.TASKS:
+            if not keep_cache:              # True - In case of destructor
+                del TaskBase.TASKS[self.tag]
+        gcollect()
+
     def __del__(self):
         try:
             self.__task_del(keep_cache=True)
@@ -143,7 +144,7 @@ class NativeTask(TaskBase):
     - could be built in function or custom code from load modules
     """
 
-    def create(self, callback:callable=None, tag:str=None) -> bool:
+    def create(self, callback:callable=None, tag:str=None) -> dict:
         """
         Create async task with coroutine callback (no queue limit check!)
         + async socket server task
@@ -152,6 +153,9 @@ class NativeTask(TaskBase):
         """
         # Create task tag
         self.tag = f"aio.{ticks_ms()}" if tag is None else tag
+        if self.is_busy(self.tag):
+            # Skip task if already running
+            return {self.tag: "Already running"}
         # Create task with coroutine callback
         return super()._create(callback)
 
@@ -170,7 +174,7 @@ class NativeTask(TaskBase):
         Helper function for Task creation in Load Modules
         [HINT] Use python with feature to utilize this feature
         """
-        self.task_gc()    # Task pool cleanup
+        self._task_gc()    # Task pool cleanup
         self.done.set()
 
 
@@ -186,7 +190,7 @@ class MagicTask(TaskBase):
         self.__inloop = False        # [LM] Task while loop for LM callback
         self.__sleep = 20            # [LM] Task while loop - async wait (proc feed) [ms]
 
-    def create(self, callback:list=None, loop:bool=None, sleep:int=None) -> bool:
+    def create(self, callback:list=None, loop:bool=None, sleep:int=None) -> dict:
         """
         Create async task with function callback (with queue limit check)
         - wrap (sync) function into async task (task_wrapper)
@@ -196,13 +200,14 @@ class MagicTask(TaskBase):
         """
         # Create task tag
         self.tag = '.'.join(callback[0:2])
-
+        if self.is_busy(self.tag):
+            # Skip task if already running
+            return {self.tag: "Already running"}
         # Set parameters for async wrapper
         self.__callback = callback
         self.__inloop = self.__inloop if loop is None else loop
         # 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
-
         # Create task with coroutine callback
         return super()._create(self.__task_wrapper())
 
@@ -219,7 +224,7 @@ class MagicTask(TaskBase):
             state, self.out = _exec_lm_core(self.__callback)
             if not state or not self.__inloop:
                 break
-        self.task_gc()    # Task pool cleanup
+        self._task_gc()    # Task pool cleanup
         self.done.set()
 
     def cancel(self):
@@ -310,12 +315,16 @@ class Manager:
         my_task.done.set()
 
     @staticmethod
-    def create_task(callback, tag:str=None, loop:bool=False, delay:int=None):
+    def create_task(callback, tag:str=None, loop:bool=False, delay:int=None) -> dict:
         """
-        Primary interface
-        Generic task creator method
-            Create async Task with coroutine/list(lm call) callback
-        :param callback: list|callable
+        Primary interface of micrOS Generic task creator method
+        :param tag: task unique identifier
+        NativeTask:
+            :param callback: callable, coroutine to start a task
+        MagicTask with queue limiter:
+            :param callback: list of staring (command)
+            :param loop: MagicTask looping parameter
+            :param delay: MagicTask delay parameter
         """
         if isinstance(callback, list):
             # Check queue if task is Load Module
@@ -450,8 +459,10 @@ def exec_builtins(func):
             # ... >json               - command output format option
             # ... >>node01.local      - intercon: command execution on remote device by hostname/IP address
             arg_list, json_flag = (arg_list[:-1], True) if arg_list[-1] == '>json' else (arg_list, False)
-            arg_list, intercon_target = (arg_list[:-1], arg_list[-1].replace(">>", "")) if arg_list[-1].startswith('>>') else (arg_list, None)
             json_flag = jsonify if isinstance(jsonify, bool) else json_flag
+            arg_list, intercon_target = ((arg_list[:-1], arg_list[-1].replace(">>", ""))
+                                          if match(r'^>>[A-Za-z0-9._-]+$', arg_list[-1])
+                                          else (arg_list, None))
 
             # INTERCONNECT
             if intercon_target:
@@ -513,15 +524,9 @@ def lm_exec(arg_list:list, jsonify:bool=None):
         delay = int(delay) if delay.isdigit() else None
         # Create and start async lm task
         try:
-            state = Manager.create_task(arg_list, loop=loop, delay=delay)
+            return True, Manager.create_task(arg_list, loop=loop, delay=delay)
         except Exception as e:
-            # Valid & handled task command
-            return True, str(e)
-        tag = '.'.join(arg_list[0:2])
-        # Valid & handled task command
-        if state:
-            return True, f"Start {tag}"
-        return True, f"{tag} is Busy"
+            return False, {".".join(arg_list[0:2]): str(e)}
 
     # [2] Sync "realtime" task execution
     state, out = _exec_lm_core(arg_list, jsonify)
@@ -590,7 +595,7 @@ def _exec_lm_core(cmd_list, jsonify):
                 # UNLOAD MODULE IF MEMORY ERROR HAPPENED + gc.collect
                 if lm_mod in modules:
                     del modules[lm_mod]
-                collect()
+                gcollect()
             # LM EXECUTION ERROR
             return False, f"Core error: {lm_mod}->{lm_func}: {e}"
     return False, "Shell: for hints type help.\nShell: for LM exec: [1](LM)module [2]function [3...]optional params"

micrOS/source/modules/LM_buzzer.py

@@ -270,10 +270,7 @@ def play(rtttlstr='Indiana'):
     global CHECK_NOTIFY
     if CHECK_NOTIFY and not notify():
         return "NoBipp - notify off"
-    state = micro_task(tag=__TASK_TAG, task=_play(rtttlstr))
-    if state:
-        return 'Play song'
-    return 'Song already playing'
+    return micro_task(tag=__TASK_TAG, task=_play(rtttlstr))
 
 
 def list_tones():

micrOS/source/modules/LM_cct.py

@@ -238,8 +238,7 @@ def transition(cw=None, ww=None, sec=1.0, wake=False):
     # Create transition generator and calculate step_ms
     cct_gen, step_ms = transition_gen(cw_from, cw_to, ww_from, ww_to, interval_sec=sec)
     # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
-    state = micro_task(tag=Data.CCT_TASK_TAG, task=_task(ms_period=step_ms, iterable=cct_gen))
-    return "Starting transition" if state else "Transition already running"
+    return micro_task(tag=Data.CCT_TASK_TAG, task=_task(ms_period=step_ms, iterable=cct_gen))
 
 
 def hue_transition(percent, sec=1.0, wake=False):
@@ -288,8 +287,7 @@ def hue_transition(percent, sec=1.0, wake=False):
         #print("Actual percent: {}, target percent: {}".format(actual_percent, warm_percent))
         hue_gen, step_ms = transition_gen(hue_curr_percent, percent*10, interval_sec=sec)
         # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
-        state = micro_task(tag=Data.HUE_TASK_TAG, task=_task(ms_period=step_ms, iterable=hue_gen))
-        return "Starting transition" if state else "Transition already running"
+        return micro_task(tag=Data.HUE_TASK_TAG, task=_task(ms_period=step_ms, iterable=hue_gen))
     else:
         return "Invalid range, percent=<0-100>"
 

micrOS/source/modules/LM_dimmer.py

@@ -184,8 +184,7 @@ def transition(value, sec=1.0, wake=False):
     # Create transition generator and calculate step_ms
     fade_gen, fade_step_ms = transition_gen(from_dim, value, interval_sec=sec)
     # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
-    state = micro_task(tag=Data.DIMM_TASK_TAG, task=_task(ms_period=fade_step_ms, iterable=fade_gen))
-    return "Starting transition" if state else "Transition already running"
+    return micro_task(tag=Data.DIMM_TASK_TAG, task=_task(ms_period=fade_step_ms, iterable=fade_gen))
 
 
 def subscribe_presence():

micrOS/source/modules/LM_distance.py

@@ -70,9 +70,7 @@ def start_dimmer_indicator(idle_distance=180):
     """Distance visualization on LED brightness (LM_dimmer)"""
     from LM_dimmer import set_value
     # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
-    state = micro_task(tag="distance.visual", task=__task(period_ms=200, dimmer=set_value, idle_cm=idle_distance))
-    return "Starting" if state else "Already running"
-
+    return micro_task(tag="distance.visual", task=__task(period_ms=200, dimmer=set_value, idle_cm=idle_distance))
 
 
 #########################

micrOS/source/modules/LM_i2s_mic.py

@@ -94,8 +94,7 @@ def background_capture():
     if not Data.MIC_ENABLED:
         return "Microphone is disabled"
 
-    state = micro_task(tag=Data.TASK_TAG, task=__task(ms_period=1))
-    return "Starting" if state else "Already running"
+    return micro_task(tag=Data.TASK_TAG, task=__task(ms_period=1))
 
 
 def get_from_buffer(capture_duration=Data.CAPTURE_DURATION,

micrOS/source/modules/LM_keychain.py

@@ -216,8 +216,7 @@ def display(period=1000, tts=30):
     # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
     period_ms = 500 if period < 500 else period
     tts_ms = 5000 if tts < 5 else tts*1000
-    state = micro_task(tag="keychain.display", task=_ui_task(period_ms, tts_ms))
-    return "Starting" if state else "Already running"
+    return micro_task(tag="keychain.display", task=_ui_task(period_ms, tts_ms))
 
 
 def temperature():

micrOS/source/modules/LM_light_sensor.py

@@ -96,11 +96,8 @@ def subscribe_intercon(on, off, threshold=4, tolerance=2, sample_sec=60):
     """
     # Start play - servo XY in async task
     # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
-    state = micro_task(tag="light_sensor.intercon", task=_task(on, off, threshold, tolerance=tolerance,
+    return micro_task(tag="light_sensor.intercon", task=_task(on, off, threshold, tolerance=tolerance,
                                                                check_ms=sample_sec*1000))
-    if state:
-        return 'Light sensor remote trigger starts'
-    return 'Light sensor remote trigger - already running'
 
 
 #######################