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

micrOS/source/modules/LM_mqtt_client.py

@@ -123,8 +123,8 @@ def publish(topic: str, message: str, retain: bool = False):
     :return: Status message string.
     """
     unique_tag = f'mqtt.publish.{topic}.{time.ticks_ms()}'
-    state = micro_task(tag=unique_tag, task=_publish(unique_tag, message, topic, retain))
-    return f"Message was sent {state}"
+    state:dict = micro_task(tag=unique_tag, task=_publish(unique_tag, message, topic, retain))
+    return f"Message was sent ({list(state.values())[0]})"
 
 
 ####################
@@ -142,8 +142,8 @@ async def _up():
             my_task.out = "Wait"
             await MQTT.CLIENT.up.wait()
             MQTT.CLIENT.up.clear()
-            state = micro_task(tag=MQTT.SUB_TASK, task=_subscribe(MQTT.DEFAULT_TOPIC))
-            my_task.out = f"Re-Subscription {state}"
+            state:dict = micro_task(tag=MQTT.SUB_TASK, task=_subscribe(MQTT.DEFAULT_TOPIC))
+            my_task.out = f"Re-Subscription ({list(state.values())[0]})"
             my_task.feed()
 
 
@@ -165,10 +165,14 @@ async def _init_client():
         MQTT.CLIENT.up.clear()
         
         # Initialize mqtt topics
-        if not micro_task(tag=MQTT.SUB_TASK, task=_subscribe(MQTT.DEFAULT_TOPIC)):
-            syslog(f"Failed start mqtt subscribe")
-        if not micro_task(tag=MQTT.UP_TASK, task=_up()):
-            syslog(f"Failed start mqtt up")
+        try:
+            micro_task(tag=MQTT.SUB_TASK, task=_subscribe(MQTT.DEFAULT_TOPIC))
+        except Exception as err:
+            syslog(f"Failed start mqtt subscribe: {err}")
+        try:
+            micro_task(tag=MQTT.UP_TASK, task=_up())
+        except Exception as err:
+            syslog(f"Failed start mqtt up: {err}")
         # Async listener loop
         await _receiver()
         my_task.out = "Receiver closed"
@@ -230,8 +234,7 @@ def load(username: str, password: str, server_ip: str, server_port: str='1883',
     MQTT.CLIENT = MQTTClient(_configure(username, password, server_ip, server_port))
     MQTT.QOS = qos
 
-    state = micro_task(tag=MQTT.CLIENT_TASK, task=_init_client())
-    return {MQTT.CLIENT_TASK: "Starting"} if state else {MQTT.CLIENT_TASK: "Already running"}
+    return micro_task(tag=MQTT.CLIENT_TASK, task=_init_client())
 
 
 def help(widgets=False):

micrOS/source/modules/LM_neopixel.py

@@ -278,8 +278,7 @@ def transition(r=None, g=None, b=None, sec=1.0, wake=False):
     # Create transition generator and calculate step_ms
     rgb_gen, step_ms = transition_gen(r_from, r_to, g_from, g_to, b_from, b_to, interval_sec=sec)
     # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
-    state = micro_task(tag=Data.RGB_TASK_TAG, task=_task(ms_period=step_ms, iterable=rgb_gen))
-    return "Starting transition" if state else "Transition already running"
+    return micro_task(tag=Data.RGB_TASK_TAG, task=_task(ms_period=step_ms, iterable=rgb_gen))
 
 
 def random(smooth=True, max_val=255):

micrOS/source/modules/LM_oled_ui.py

@@ -1,3 +1,9 @@
+"""
+micrOS simple OLED UI (irq or single task based refresh)
+    - with page generation
+Designed by Marcell Ban aka BxNxM
+"""
+
 from Config import cfgget
 from utime import localtime
 from network import WLAN, STA_IF
@@ -236,8 +242,8 @@ class PageUI:
                     else:
                         self.page_callback_list[self.active_page]()             # <== Execute page functions
                 except Exception as e:
-                    PageUI.PAGE_UI_OBJ.show_msg = f"Err: {e}"                   # Show page error in msgbox
                     syslog(f"oled_ui render error: {e}")
+                    PageUI.PAGE_UI_OBJ.show_msg = f"Err: {e}"                   # Show page error in msgbox
             PageUI.DISPLAY.show()
             self.__power_save()
         else:
@@ -332,16 +338,17 @@ class PageUI:
     #####################################
     #           PAGE GENERATORS         #
     #####################################
-    def intercon_page(self, host:str, cmd:list, run=False):
+    def intercon_page(self, cmd:str, run=False):
         """Generic interconnect page core - create multiple page with it"""
         posx, posy = 5, 12
 
         def _button():
+            nonlocal host, _cmd
             # BUTTON CALLBACK - INTERCONNECT execution
             self.open_intercons.append(host)
             try:
                 # Send CMD to other device & show result
-                state, data_meta = exec_cmd(cmd + [f">>{host}"], jsonify=True)
+                state, data_meta = exec_cmd(_cmd, jsonify=True)
                 if state:
                     self.cmd_task_tag = list(data_meta.keys())[0]
                     verdict = list(data_meta.values())[0]
@@ -354,21 +361,24 @@ class PageUI:
             self.open_intercons.remove(host)
 
         # Check open host connection
-        if host in self.open_intercons:
-            return
+        _cmd = cmd.strip().split()
+        host = _cmd[-1].replace(">", "").replace("&", "")
         # Draw host + cmd details
-        PageUI.DISPLAY.text(host, 0, posy)
-        PageUI.DISPLAY.text(' '.join(cmd), posx, posy+10)
+        PageUI.DISPLAY.text(' '.join(_cmd[0:-1]), 0, posy)
+        PageUI.DISPLAY.text(_cmd[-1], posx, posy+10)
+        self._cmd_text(posx, posy + 10)
+
         # Update display output with retrieved task result (by TaskID)
         if self.cmd_task_tag is not None:
             task_buffer = manage_task(self.cmd_task_tag, 'show').replace(' ', '')
             if task_buffer is not None and len(task_buffer) > 0:
                 # Set display out to task buffered data
                 self.cmd_out = task_buffer
-                # Kill task - clean
-                manage_task(self.cmd_task_tag, 'kill')
-                # data gathered - remove tag - skip re-read
-                self.cmd_task_tag = None
+                if not manage_task(self.cmd_task_tag, 'isbusy'):
+                    # Kill task - clean
+                    manage_task(self.cmd_task_tag, 'kill')
+                    # data gathered - remove tag - skip re-read
+                    self.cmd_task_tag = None
         # Show self.cmd_out value on display
         self._cmd_text(posx, posy+10)
         # Run button event at page init
@@ -378,7 +388,7 @@ class PageUI:
             # Set button press callback (+draw button)
             self.set_press_callback(_button)
 
-    def cmd_call_page(self, cmd, run=False):
+    def cmd_call_page(self, cmd:str, run=False):
         """Generic LoadModule execution page core - create multiple page with it"""
         posx, posy = 5, 12
 
@@ -429,8 +439,14 @@ def _intercon_cache(line_limit=3):
     cache = hosts()["intercon"]
     if sum([1 for _ in cache]) > 0:
         for key, val in cache.items():
-            key = key.split('.')[0]
-            val = '.'.join(val.split('.')[-2:])
+            if '.' in key:
+                # IP splitting
+                key = key.split('.')[0]
+                val = '.'.join(val.split('.')[-2:])
+            else:
+                # MAC splitting
+                key = key.split(':')[0]
+                val = ':'.join(val.split(':')[-2:])
             PageUI.DISPLAY.text(f" {val} {key}", 0, line_start+(line_cnt*10))
             line_cnt += 1
             if line_cnt > line_limit:
@@ -514,8 +530,7 @@ def msgbox(msg='micrOS msg'):
     PageUI.PAGE_UI_OBJ.render_page()
     return 'Show msg'
 
-
-def intercon_genpage(cmd:str=None, run=False):
+def genpage(cmd:str=None, run=False):
     """
     Create intercon pages dynamically :)
     - based on cmd value.
@@ -523,31 +538,15 @@ def intercon_genpage(cmd:str=None, run=False):
     :param run: run button event at page init: True/False
     :return: page creation verdict
     """
-    raw = cmd.split()
-    host = raw[0]
-    cmd = raw[1:]
-    try:
-        # Create page for intercon command
-        PageUI.PAGE_UI_OBJ.add_page(lambda: PageUI.PAGE_UI_OBJ.intercon_page(host, cmd, run=run))
-    except Exception as e:
-        syslog(f'[ERR] intercon_genpage: {e}')
-        return str(e)
-    return True
-
-
-def cmd_genpage(cmd:str=None, run=False):
-    """
-    Create load module execution pages dynamically :)
-    - based on cmd value: load_module function (args)
-    :param cmd: 'load_module function (args)' string
-    :param run: run button event at page init: True/False
-    :return: page creation verdict
-    """
     try:
-        # Create page for intercon command
-        PageUI.PAGE_UI_OBJ.add_page(lambda: PageUI.PAGE_UI_OBJ.cmd_call_page(cmd, run=run))
+        if ">>" in cmd or "&" in cmd:
+            # Create page for intercon/task background command
+            PageUI.PAGE_UI_OBJ.add_page(lambda: PageUI.PAGE_UI_OBJ.intercon_page(cmd, run=run))
+        else:
+            # Create page for realtime command
+            PageUI.PAGE_UI_OBJ.add_page(lambda: PageUI.PAGE_UI_OBJ.cmd_call_page(cmd, run=run))
     except Exception as e:
-        syslog(f'[ERR] cmd_genpage: {e}')
+        syslog(f'[ERR] genpage: {e}')
         return str(e)
     return True
 
@@ -598,6 +597,5 @@ def help(widgets=False):
                              'draw',
                              'BUTTON control cmd=<prev,press,next,on,off>',
                              'msgbox "msg"',
-                             'intercon_genpage "host cmd" run=False',
-                             'cmd_genpage "cmd" run=False',
+                             'genpage "cmd" run=False',
                              'pinmap'), widgets=widgets)

micrOS/source/modules/LM_oledui.py

@@ -1,3 +1,8 @@
+"""
+micrOS multitask OLED UI
+    - with page generation
+Designed by Marcell Ban aka BxNxM
+"""
 from utime import localtime, ticks_ms, ticks_diff, sleep_ms
 from Common import syslog, micro_task, manage_task, exec_cmd
 from Types import resolve
@@ -121,8 +126,7 @@ class Frame(BaseFrame):
         """
         # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
         self._taskid = f"oledui.{tid}"
-        state = micro_task(tag=self._taskid, task=self._task(period_ms=period_ms))
-        return "Starting" if state else "Already running"
+        return micro_task(tag=self._taskid, task=self._task(period_ms=period_ms))
 
     def hover(self):
         """
@@ -486,8 +490,7 @@ class ScreenSaver(BaseFrame):
     def run(self, fps=10):
         # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
         period_ms = int(1000/fps)
-        state = micro_task(tag="oledui.anim", task=self._task(period_ms))
-        return "Starting" if state else "Already running"
+        return micro_task(tag="oledui.anim", task=self._task(period_ms))
 
     def cancel(self):
         if self.running:
@@ -740,79 +743,59 @@ class PageUI:
         :param y: frame y
         """
         x, y = x+2, y+4
-        def _execute(display, w, h, x, y):
-            nonlocal cmd
-            try:
-                cmd_list = cmd.strip().split()
-                # Send CMD to other device & show result
-                state, out = exec_cmd(cmd_list)
-                cmd_out = out.strip()
-            except Exception as e:
-                cmd_out = str(e)
-            self.app_frame.press_output = cmd_out
-            PageUI.write_lines(cmd_out, display, x, y + 15)
-
-        display.text(cmd, x, y)
-        if run:
-            _execute(display, w, h, x, y)
-        else:
-            self._press_indicator(display, w, h, x, y)
-            PageUI.write_lines(self.app_frame.press_output, display, x, y + 15)
-            # Return "press" callback, mandatory input parameters: display, w, h, x, y
-            return {"press": _execute}
-        return
 
+        def _display_output():
+            nonlocal x, y, display
+            if self._cmd_task_tag is None:
+                # Display cached data
+                PageUI.write_lines(self.app_frame.press_output, display, x, y + 20)
+                return
+            task_buffer = manage_task(self._cmd_task_tag, 'show').replace(' ', '')
+            if task_buffer is not None and len(task_buffer) > 0:
+                # Update display out to task buffered data
+                self.app_frame.press_output = task_buffer
+                if not manage_task(self._cmd_task_tag, 'isbusy'):
+                    # data gathered - remove tag - skip re-read
+                    self._cmd_task_tag = None
+            # Display task cached data
+            PageUI.write_lines(self.app_frame.press_output, display, x, y + 20)
 
-    def intercon_exec_page(self, host, cmd, run, display, w, h, x, y):
-        """
-        :param host: hostname or IP address of a device
-        :param cmd: load module string command
-        :param run: auto-run command (every page refresh)
-        :param display: display instance
-        :param h: frame h
-        :param w: frame w
-        :param x: frame x
-        :param y: frame y
-        """
-        x, y = x+2, y+4
         def _execute(display, w, h, x, y):
-            nonlocal host, cmd, run
-            # Check open host connection
+            nonlocal cmd, run
             try:
-                # Send CMD to other device & show result
-                state, data_meta = exec_cmd(cmd + [f">>{host}"], jsonify=True)
-                if state:
-                    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
+                cmd_list = cmd.strip().split()
+                # TASK mode: background execution, intercon: >> OR task: &
+                if '>>' in cmd_list[-1] or '&' in cmd_list[-1]:
+                    # BACKGROUND: EXECUTE COMMAND
+                    state, out = exec_cmd(cmd_list, jsonify=True) if self._cmd_task_tag is None else (False, "skip...")
+                    if state:
+                        self._cmd_task_tag = list(out.keys())[0]
+                        buffer = manage_task(self._cmd_task_tag, 'show').replace(' ', '')
+                        if buffer is not None and len(buffer) > 0:
+                            self.app_frame.press_output = buffer
                 else:
-                    self.app_frame.press_output = f"Error: {data_meta}"
+                    # REALTIME mode: get command execution result
+                    state, out = exec_cmd(cmd_list, jsonify=True)
+                    self.app_frame.press_output = str(out)
             except Exception as e:
                 self.app_frame.press_output = str(e)
+            # Print and cache output to display
+            PageUI.write_lines(self.app_frame.press_output, display, x, y+20)
 
-        def _read_buffer():
-            # Read command output from async buffer
-            if self._cmd_task_tag is not None:
-                task_buffer = manage_task(self._cmd_task_tag, 'show').replace(' ', '')
-                if task_buffer is not None and len(task_buffer) > 0:
-                    # Set display out to task buffered data
-                    self.app_frame.press_output = task_buffer
-                    # data gathered - remove tag - skip re-read
-                    self._cmd_task_tag = None
-            PageUI.write_lines(self.app_frame.press_output, display, x, y + 20, line_limit=2)
-
-        PageUI.write_lines(f"{host.split(".")[0]}:{' '.join(cmd)}", display, x, y, line_limit=2)
+        # Write command header line and buffered output
+        PageUI.write_lines(cmd, display, x, y, line_limit=2)
+        _display_output()
+        # RUN command
         if run:
-            if self._cmd_task_tag is None:
-                _execute(display, w, h, x, y)
-            _read_buffer()
-            return
-        _read_buffer()
+            # Automatic Execution Mode (in page refresh time)
+            _execute(display, w, h, x, y)
+            return None
+        # Button Press Execution Mode (callback)
         self._press_indicator(display, w, h, x, y)
         # Return "press" callback, mandatory input parameters: display, w, h, x, y
         return {"press": _execute}
 
+
 #################################################################################
 #                                     Page function                             #
 #################################################################################
@@ -835,8 +818,14 @@ def _intercon_nodes_page(display, w, h, x, y):
     cache = hosts()["intercon"]
     if sum([1 for _ in cache]) > 0:
         for key, val in cache.items():
-            key = key.split('.')[0]
-            val = '.'.join(val.split('.')[-2:])
+            if '.' in key:
+                # IP splitting
+                key = key.split('.')[0]
+                val = '.'.join(val.split('.')[-2:])
+            else:
+                # MAC splitting
+                key = key.split(':')[0]
+                val = ':'.join(val.split(':')[-2:])
             display.text(f" {val} {key}", x, line_start + (line_cnt * 10))
             line_cnt += 1
             if line_cnt > line_limit:
@@ -902,7 +891,7 @@ def cursor(x, y):
     return "Set cursor position"
 
 
-def cmd_genpage(cmd=None, run=False):
+def genpage(cmd=None, run=False):
     """
     Create load module execution pages dynamically :)
     - based on cmd value: load_module function (args)
@@ -917,30 +906,11 @@ def cmd_genpage(cmd=None, run=False):
         # Create page for intercon command
         PageUI.INSTANCE.add_page(lambda display, w, h, x, y: PageUI.INSTANCE.lm_exec_page(cmd, run, display, w, h, x, y))
     except Exception as e:
-        syslog(f'[ERR] cmd_genpage: {e}')
+        syslog(f'[ERR] genpage: {e}')
         return str(e)
     return True
 
 
-def intercon_genpage(cmd=None, run=False):
-    """
-    Create intercon pages dynamically :)
-    - based on cmd value.
-    :param cmd: 'host hello' or 'host system clock'
-    :param run: run button event at page init: True/False
-    :return: page creation verdict
-    """
-    raw = cmd.split()
-    host = raw[0]
-    cmd = raw[1:]
-    try:
-        # Create page for intercon command
-        PageUI.INSTANCE.add_page(lambda display, w, h, x, y: PageUI.INSTANCE.intercon_exec_page(host, cmd, run, display, w, h, x, y))
-    except Exception as e:
-        syslog(f'[ERR] intercon_genpage: {e}')
-        return str(e)
-    return True
-
 def add_page(page_callback):
     """
     [LM] Create page from load module with callback function
@@ -965,6 +935,5 @@ def help(widgets=False):
                   "BUTTON control cmd=<prev,press,next,on,off>",
                   "BUTTON debug", "cursor x y",
                   "popup msg='text'", "cancel_popup",
-                  "cmd_genpage cmd='system clock'",
-                  "intercon_genpage 'host cmd' run=False"),
+                  "genpage cmd='system clock'"),
         widgets=widgets)

micrOS/source/modules/LM_pacman.py

@@ -1,6 +1,6 @@
 from sys import modules
 from Common import socket_stream
-from Files import is_protected, list_fs, ilist_fs, remove_fs, OSPath, path_join
+from Files import is_protected, list_fs, ilist_fs, remove_file, remove_dir, OSPath, path_join
 
 
 #############################################
@@ -31,13 +31,22 @@ def ls(path="/", content='*', raw=False, select='*', core=False):
     return lines
 
 
-def rm(path, allow_dir=False):
+def rm(path, force=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
+    :param force: bypasses protection check - sudo mode
     """
-    return remove_fs(path, allow_dir)
+    return remove_file(path, force)
+
+
+def rmdir(path, force=False):
+    """
+    Linux like rmdir command for directory deletion
+    :param path: app resource folder path, ex.: /lib/myapp
+    :param force: bypasses protection check - sudo mode
+    """
+    return remove_dir(path, force)
 
 
 def dirtree(path="/", raw=False, core=False):
@@ -64,44 +73,26 @@ def cat(path):
     return content
 
 
-def download(url=None, package=None):
+def download(ref=None):
     """
-    [BETA] Load Module downloader with mip
-    :param url: github url path, ex. BxNxM/micrOS/master/toolkit/workspace/precompiled/LM_robustness.py
-    :param package: mip package name or raw url (hack)
+    Unified mip-based downloader for micrOS.
+    Automatically detects:
+      1. Official MicroPython packages (from https://micropython.org/pi/v2)
+            Example: pacman download "umqtt.simple"
+      2. Single-file load modules (LM_/IO_ names or URLs)
+            Example: pacman download "https://github.com/BxNxM/micrOS/blob/master/toolkit/workspace/precompiled/modules/LM_rgb.mpy"
+                     pacman download "github.com/BxNxM/micrOS/blob/master/toolkit/workspace/precompiled/modules/LM_rgb.mpy"
+      3. GitHub packages (folders via tree/blob URLs or github: form)
+            Example: pacman download "github:peterhinch/micropython-mqtt"
+                     pacman download "https://github.com/peterhinch/micropython-mqtt/tree/master"
+                     pacman download "https://github.com/peterhinch/micropython-mqtt/blob/master/package.json"
+                     pacman download "https://github.com/peterhinch/micropython-mqtt"
+                     [NOK] pacman download "https://github.com/basanovase/sim7600/tree/main/sim7600" -> Package not found: github:basanovase/sim7600/package.json
+      4. Install from local /config/requirements.txt file
+            Example: pacman download "requirements.txt"
     """
-    def _install(target=None):
-        nonlocal url, verdict
-        try:
-            verdict += f"Install {url}\n"
-            if target is None:
-                install(url)                    # Default download: /lib
-            else:
-                install(url, target=target)     # Custom target
-            verdict += "\n|- Done"
-        except Exception as e:
-            verdict += f"|- Cannot install: {url}\n{e}"
-        return verdict
-
-    from mip import install
-    verdict = ""
-    if url is None and package is None:
-        return "Nothing to download, url=None package=None"
-    if package is None:
-        verdict += "Install from GitHub URL"
-        base_url = "https://raw.githubusercontent.com/"
-        file_name = url.split("/")[-1]
-        if not(file_name.endswith("py") and file_name.startswith("LM_")):
-            return "Invalid file name in url ending, hint: /LM_*.mpy or /LM_*.py"
-        # Convert GitHub URL to raw content URL
-        if "github.com" in url and "blob" in url:
-            url = url.replace("https://github.com/", base_url).replace("/blob", "")
-        else:
-            url = f"{base_url}{url}"
-        return _install(target=OSPath.MODULES)          # Install module from Github URL
-    url = package
-    return _install()                                   # Install official package
-
+    from Pacman import download as pm_download
+    return pm_download(ref)
 
 def del_duplicates(migrate=True):
     """
@@ -119,7 +110,7 @@ def del_duplicates(migrate=True):
         if m in py and m != 'main':
             to_delete = f'{m}.py'
             try:
-                verdict = remove_fs(path_join(modules_path, to_delete))
+                verdict = remove_file(path_join(modules_path, to_delete))
             except:
                 verdict = "n/a"
                 state = False
@@ -130,7 +121,7 @@ def del_duplicates(migrate=True):
     def _migrate_from_root(_rf):
         nonlocal _deleted, files
         if _rf in files:
-            remove_fs(path_join(OSPath._ROOT, _rf))
+            remove_file(path_join(OSPath._ROOT, _rf))
             if _rf in ("LM_pacman.mpy", "LM_system.mpy"):
                 # Delete protected LMs from root
                 remove(path_join(OSPath._ROOT, _rf))
@@ -188,7 +179,7 @@ def cachedump(delete=None, msgobj=None):
     # Remove given cache file
     try:
         delete_cache = path_join(data_dir, f"{delete}.cache")
-        verdict = remove_fs(delete_cache)
+        verdict = remove_file(delete_cache)
         return f'{delete_cache} delete done.: {verdict}'
     except:
         return f'{delete}.cache not exists'
@@ -252,7 +243,7 @@ def delmod(mod):
     else:
         return f'Invalid {mod}, must ends with .py or .mpy'
     try:
-        return remove_fs(path_join(OSPath.MODULES, to_remove))
+        return remove_file(path_join(OSPath.MODULES, to_remove))
     except Exception as e:
         return f'Cannot delete: {mod}: {e}'
 
@@ -286,5 +277,6 @@ def help(widgets=False):
             'micros_checksum',
             'ls path="/" content="*/f/d" select="*/LM/IO"',
             'rm <path>',
+            'rmdir <path>',
             'dirtree path="/"',
             'makedir <path>')

micrOS/source/modules/LM_presence.py

@@ -213,8 +213,7 @@ def motion_trig(sample_ms=15, buff_size=10):
 
     # [3] Start mic sampling in async task
     # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
-    state = micro_task(tag=Data.TASK_TAG, task=__task(ms_period=sample_ms, buff_size=buff_size))
-    return "Starting" if state else "Already running"
+    return micro_task(tag=Data.TASK_TAG, task=__task(ms_period=sample_ms, buff_size=buff_size))
 
 
 def subscribe_intercon(on, off):

micrOS/source/modules/LM_rest.py

@@ -66,8 +66,7 @@ def aurl(subdomain):
     tag = "rest." + subdomain.replace("http://", '').replace("https://", '')
     if len(tag) > 50:
         tag = tag[0:50]
-    state = micro_task(tag=tag, task=__task(subdomain, tag))
-    return f"Starting" if state else f"Already running"
+    return micro_task(tag=tag, task=__task(subdomain, tag))
 
 
 def help(widgets=False):

micrOS/source/modules/LM_rgb.py

@@ -246,8 +246,7 @@ def transition(r=None, g=None, b=None, sec=1.0, wake=False):
     # Create transition generator and calculate step_ms
     rgb_gen, step_ms = transition_gen(r_from, r, g_from, g, b_from, b, interval_sec=sec)
     # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
-    state = micro_task(tag=Data.RGB_TASK_TAG, task=_task(ms_period=step_ms, iterable=rgb_gen))
-    return "Starting transition" if state else "Transition already running"
+    return micro_task(tag=Data.RGB_TASK_TAG, task=_task(ms_period=step_ms, iterable=rgb_gen))
 
 
 def random(smooth=True, max_val=1000):

micrOS/source/modules/LM_roboarm.py

@@ -204,11 +204,10 @@ def play(*args, s=None, delay=None, deinit=True):
 
     # Start play - servo XY in async task
     # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
-    state = micro_task(tag=RoboArm.PLAY_TAG, task=_play(args, deinit, delay))
-    if state:
-        return 'Play: {} steps'.format(int(len(args)/2))
-    return 'Play - already running'
 
+    state:dict = micro_task(tag=RoboArm.PLAY_TAG, task=_play(args, deinit, delay))
+    state.update({"Play steps": int(len(args)/2)})
+    return state
 
 def record(clean=False, rec_limit=8):
     """

micrOS/source/modules/LM_robustness.py

@@ -83,8 +83,7 @@ def create_task():
     """
     # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
     task_tag = "microtask.run"
-    state = micro_task(tag=task_tag, task=__task(tag=task_tag, period_ms=5))
-    return "Starting" if state else "Already running"
+    return micro_task(tag=task_tag, task=__task(tag=task_tag, period_ms=5))
 
 
 @micro_task("microtask", _wrap=True)

micrOS/source/modules/LM_telegram.py

@@ -362,8 +362,7 @@ def receiver_loop(period=3):
     if Telegram.INSTANCE is None:
         return "Network unavailable."
     tag = 'telegram.server_bot'
-    state = micro_task(tag=tag, task=Telegram.server_bot(tag=tag, period=period))
-    return {tag: "Starting"} if state else {tag: "Already running"}
+    return micro_task(tag=tag, task=Telegram.server_bot(tag=tag, period=period))
 
 
 def help(widgets=False):

micrOS/source/urequests.py

@@ -282,7 +282,7 @@ async def apost(url, data=None, json=None, headers:dict=None, sock_size=256, jso
     return await arequest('POST', url, data=data, json=json, headers=headers, sock_size=sock_size, jsonify=jsonify)
 
 
-def host_cache():
+def host_cache() -> dict:
     """
     Return address cache
     """