micrOSDevToolKit 2.9.1__py3-none-any.whl → 2.26.1__py3-none-any.whl

micrOS/source/{LM_oled_ui.py → modules/LM_oled_ui.py}

@@ -1,24 +1,27 @@
+"""
+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
-from microIO import resolve_pin, pinmap_search
+from microIO import bind_pin, pinmap_search
 from Network import ifconfig
 from Common import syslog, exec_cmd, manage_task
 from machine import Pin
 from Types import resolve
 try:
-    from LM_system import memory_usage
+    from LM_system import memory_usage, hosts
 except:
     memory_usage = None         # Optional function handling
-try:
-    import LM_intercon as InterCon
-except:
-    InterCon = None             # Optional function handling
 try:
     from LM_gameOfLife import next_gen as gol_nextgen, reset as gol_reset
 except:
     gol_nextgen = None          # Optional function handling
 
+from utime import ticks_ms, ticks_diff     # For IRQ joystick handling
 
 #################################
 # PAGE MANAGER CLASS DEFINITION #
@@ -153,19 +156,31 @@ class PageUI:
         def _set(pin_tag, callback):
             pin = None
             try:
-                pin = resolve_pin(pin_tag)
+                pin = bind_pin(pin_tag)
             except Exception as e:
                 syslog(f'[ERR] {pin_tag} IRQ: {e}')
             if pin:
                 pin_obj = Pin(pin, Pin.IN, Pin.PULL_DOWN)
                 # [IRQ] - event type setup
-                pin_obj.irq(trigger=Pin.IRQ_RISING, handler=callback)
-
-        _set("js_right", lambda pin: self.control('next'))
-        _set("js_left", lambda pin: self.control('prev'))
-        _set("js_up", lambda pin: self.control('on'))
-        _set("js_down", lambda pin: self.control('off'))
-        _set("js_press", lambda pin: self.control('press'))
+                pin_obj.irq(trigger=Pin.IRQ_FALLING, handler=callback)
+
+        def _event_handler(control_command, prell_ms=150):
+            nonlocal  _p_last
+            _last = _p_last.get(control_command)
+            last = 0 if _last is None else _last
+            # Calculate time difference between last trigger action and now tick.
+            diff = ticks_diff(ticks_ms(), last)
+            if abs(diff) > prell_ms:
+                # Save now tick - last trigger action
+                _p_last[control_command] = ticks_ms()
+                self.control(control_command)
+
+        _p_last = {}
+        _set("js_right", lambda pin: _event_handler('next'))
+        _set("js_left", lambda pin: _event_handler('prev'))
+        _set("js_up", lambda pin: _event_handler('on'))
+        _set("js_down", lambda pin: _event_handler('off'))
+        _set("js_press", lambda pin: _event_handler('press'))
         self.irq_ok = True
 
     def __power_save(self):
@@ -227,6 +242,7 @@ class PageUI:
                     else:
                         self.page_callback_list[self.active_page]()             # <== Execute page functions
                 except Exception as e:
+                    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()
@@ -322,39 +338,47 @@ class PageUI:
     #####################################
     #           PAGE GENERATORS         #
     #####################################
-    def intercon_page(self, host, cmd, 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
-                data_meta = InterCon.send_cmd(host, cmd)
-                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
+                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]
+                    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:
                 self.cmd_out = str(e)
             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(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
@@ -364,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
 
@@ -409,15 +433,20 @@ def _sys_page():
 
 
 def _intercon_cache(line_limit=3):
-    if InterCon is None:
-        return False
     line_start = 15
     line_cnt = 1
     PageUI.DISPLAY.text("InterCon cache", 0, line_start)
-    if sum([1 for _ in InterCon.host_cache()]) > 0:
-        for key, val in InterCon.host_cache().items():
-            key = key.split('.')[0]
-            val = '.'.join(val.split('.')[-2:])
+    cache = hosts()["intercon"]
+    if sum([1 for _ in cache]) > 0:
+        for key, val in cache.items():
+            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:
@@ -501,8 +530,7 @@ def msgbox(msg='micrOS msg'):
     PageUI.PAGE_UI_OBJ.render_page()
     return 'Show msg'
 
-
-def intercon_genpage(cmd=None, run=False):
+def genpage(cmd:str=None, run=False):
     """
     Create intercon pages dynamically :)
     - based on cmd value.
@@ -510,34 +538,15 @@ def intercon_genpage(cmd=None, run=False):
     :param run: run button event at page init: True/False
     :return: page creation verdict
     """
-    raw = cmd.split()
-    host = raw[0]
-    cmd = ' '.join(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=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
-    """
-    if not isinstance(cmd, str):
-        return False
-
     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
 
@@ -588,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_pacman.py

@@ -0,0 +1,320 @@
+from sys import modules
+from Common import socket_stream
+from Files import list_fs, ilist_fs, remove_file, remove_dir, OSPath, path_join, is_protected
+from Auth import sudo
+
+
+#############################################
+#     Safe file system handler functions    #
+#############################################
+
+def ls(path="/", content='*', raw=False, select='*', core=False):
+    """
+    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
+    :param core: include core system files
+    """
+    items = list_fs(path, content, select=select, core=core)
+    if raw:
+        return items
+
+    # 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
+
+
+@sudo(_force_only=(True, 1))
+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 force: bypasses protection check - sudo mode
+    """
+    return remove_file(path, force)
+
+
+@sudo(_force_only=(True, 1))
+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):
+    """Return only directories from a given path."""
+    path = path if path.endswith('/') else f"{path}/"
+    folders = [path_join(path, item) for item in ilist_fs(path, type_filter='d', core=core)]
+    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[0]}   {val[1]}\n"
+    return formatted_output
+
+
+def cat(path):
+    """
+    Dump any file content
+    """
+    if is_protected(path):
+        return f'Read not allowed'
+    with open(path, 'r') as f:
+        content = f.read()
+    return content
+
+
+def install(ref=None):
+    """
+    Unified mip-based installer for micrOS.
+    Automatically detects:
+      1. Official MicroPython packages (from https://micropython.org/pi/v2)
+            Example: pacman install "umqtt.simple"
+      2. Single-file load modules (LM_/IO_ names or URLs)
+            Example: pacman install "https://github.com/BxNxM/micrOS/blob/master/toolkit/workspace/precompiled/modules/LM_rgb.mpy"
+                     pacman install "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 install "github:peterhinch/micropython-mqtt"
+                     pacman install "https://github.com/peterhinch/micropython-mqtt/tree/master"
+                     pacman install "https://github.com/peterhinch/micropython-mqtt/blob/master/package.json"
+                     pacman install "https://github.com/peterhinch/micropython-mqtt"
+                     [NOK] pacman install "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 install "requirements.txt"
+    """
+    from Pacman import install as pm_install
+    return pm_install(ref)
+
+
+@sudo
+def uninstall(name=None):
+    """
+    Delete package by name from /lib
+    :param name: None (default) show installed package name
+                 OR package name to delete (str)
+    """
+    if name is None:
+        return list_fs(path=OSPath.LIB, type_filter='d')
+    from Pacman import uninstall as pm_uninstall
+    return pm_uninstall(name)
+
+
+def upgrade(name=None, force=False):
+    """
+    Upgrade package by name from /lib
+    :param name: None (default) show installed package name
+                 OR package name to upgrade (str)
+    :param force: skip version check
+    """
+    if name is None:
+        return list_fs(path=OSPath.LIB, type_filter='d')
+    from Pacman import upgrade as pm_upgrade
+    return pm_upgrade(name, force)
+
+
+def del_duplicates(migrate=True):
+    """
+    Load module package manager (Not just load modules)
+    - delete duplicated .mpy and .py resources, keep .mpy resource!
+    """
+    modules_path = OSPath.MODULES
+    msg_buf = []
+    files =  list_fs(path=modules_path, 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:
+                verdict = remove_file(path_join(modules_path, to_delete))
+            except:
+                verdict = "n/a"
+                state = False
+            msg_buf.append(f'   Delete {to_delete} {state} - {verdict}')
+
+
+    # MIGRATE /ROOT/LMs & IOs -> /modules
+    def _migrate_from_root(_rf):
+        nonlocal _deleted, files
+        if _rf in files:
+            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))
+            _deleted += 1
+        else:
+            rename(path_join(OSPath._ROOT, _rf), path_join(modules_path, _rf))
+            msg_buf.append(f'   Move /{_rf} -> modules/{_rf}')
+    if migrate:
+        from uos import rename, remove
+        _deleted = 0
+        files = files + list_fs(path=OSPath._ROOT, type_filter='f', select='IO')
+        for rf in ilist_fs(path=OSPath._ROOT, type_filter='f', select='LM'):
+            _migrate_from_root(rf)
+        for rf in ilist_fs(path=OSPath._ROOT, type_filter='f', select='IO'):
+            _migrate_from_root(rf)
+        if _deleted > 0:
+            msg_buf.append(f'   Purged (/): {_deleted}')
+
+    return '\n'.join(msg_buf) if len(msg_buf) > 0 else 'Nothing to delete.'
+
+
+def moduls(unload=None):
+    """
+    List / unload loaded upython Load Modules
+    :param unload: module name to unload
+    :param unload: None - list active modules
+    :return str: verdict
+    """
+    if unload is None:
+        return list(modules.keys())
+    if unload in modules.keys():
+        del modules[unload]
+        return f"Module unload {unload} done."
+    return f"Module unload {unload} failed."
+
+
+@socket_stream
+def cachedump(delete=None, ext="cache", msgobj=None):
+    """
+    Cache system persistent data storage files (.cache)
+    :param delete: cache name to delete
+    :param ext: cache file extension (default: cache)
+    """
+    data_dir = OSPath.DATA
+    if delete is None:
+        # List cache files aka application cache
+        msg_buf = []
+        for cache in (c for c in ilist_fs(data_dir, type_filter='f') if c.endswith('.cache')):
+            _path = path_join(data_dir, cache)
+            with open(_path, 'r') as f:
+                if msgobj is None:
+                    msg_buf.append(f'{_path}: {f.read()}')
+                else:
+                    msgobj(f'{_path}: {f.read()}')
+        return msg_buf if len(msg_buf) > 0 else ''
+    # Remove given cache file
+    try:
+        delete_cache = path_join(data_dir, f"{delete}.cache")
+        verdict = remove_file(delete_cache)
+        return f'{delete_cache} delete done.: {verdict}'
+    except:
+        return f'{delete}.{ext} not exists'
+
+
+def datdump():
+    """
+    Generic .dat file dump
+    - logged data from LMs, sensor data, etc...
+    """
+    data_dir = OSPath.DATA
+    dats = (f for f in ilist_fs(data_dir, type_filter='f') if f.endswith('.dat'))
+    out = {}
+    for dat in dats:
+        with open(path_join(data_dir, dat), 'r') as f:
+            out[dat] = f.read()
+    return out
+
+
+def makedir(path):
+    """
+    Create directory command
+    """
+    from uos import mkdir
+    try:
+        mkdir(path)
+        return f"{path} dir created."
+    except Exception as e:
+        return f"{path} failed to create: {e}"
+
+#############################################
+#              Legacy features              #
+#############################################
+
+
+@socket_stream
+def listmods(msgobj=None):
+    """
+    Load module package manager
+    - list all load modules
+    """
+    # Dump available LMs
+    msg_buf = []
+    for k in (res.replace('LM_', '') for res in ilist_fs(path=OSPath.MODULES, type_filter='f', select='LM')):
+        if msgobj is None:
+            msg_buf.append(f'   {k}')
+        else:
+            msgobj(f'   {k}')
+    return msg_buf if len(msg_buf) > 0 else ''
+
+
+@sudo
+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.endswith('py'):
+        to_remove = f'LM_{mod}'
+    else:
+        return f'Invalid {mod}, must ends with .py or .mpy'
+    try:
+        return remove_file(path_join(OSPath.MODULES, to_remove))
+    except Exception as e:
+        return f'Cannot delete: {mod}: {e}'
+
+
+@socket_stream
+def micros_checksum(msgobj=None):
+    from hashlib import sha1
+    from binascii import hexlify
+    from Config import cfgget
+
+    for f_name in ilist_fs(path=OSPath.MODULES, 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}")
+    # GC collect?
+    return f"micrOS version: {cfgget('version')}"
+
+
+def help(widgets=False):
+    """
+    [i] micrOS LM naming convention - built-in help message
+    :return tuple:
+        (widgets=False) list of functions implemented by this application
+        (widgets=True) list of widget json for UI generation
+    """
+    return ('listmods', 'delmod mod=<module>.py/.mpy', 'del_duplicates',
+            'moduls unload="LM_rgb/None"',
+            'cachedump delete=None',
+            'datdump',
+            # Package commands
+            'install url="BxNxM/micrOS/master/toolkit/workspace/precompiled/LM_robustness.py"',
+            'uninstall name=None',
+            'upgrade name=None',
+            # File system commands
+            'micros_checksum',
+            'ls path="/" content="*/f/d" select="*/LM/IO"',
+            'rm <path>',
+            'rmdir <path>',
+            'dirtree path="/"',
+            'makedir <path>')

micrOS/source/{LM_presence.py → modules/LM_presence.py}

@@ -1,10 +1,7 @@
-from microIO import resolve_pin, pinmap_search
-from Common import SmartADC, micro_task, notify, syslog
+from microIO import bind_pin, pinmap_search
+from Common import SmartADC, micro_task, notify, syslog, exec_cmd
 from utime import ticks_ms
-try:
-    import LM_intercon as InterCon
-except:
-    InterCon = None
+
 
 class Data:
     TASK_TAG = 'presence._capture'
@@ -68,9 +65,9 @@ def __run_intercon(state):
         try:
             cmd = Data.ON_INTERCON_CLBK.split()
             host = cmd[0]
-            cmd = ' '.join(cmd[1:])
-            # Send CMD to other device & show result
-            InterCon.send_cmd(host, cmd)
+            cmd = cmd[1:]
+            # Send CMD to other device
+            state, _ = exec_cmd(cmd + [f">>{host}"], jsonify=True)
         except Exception as e:
             syslog(f"__run_intercon error: {e}")
     if state.lower() == "off":
@@ -79,9 +76,9 @@ def __run_intercon(state):
         try:
             cmd = Data.OFF_INTERCON_CLBK.split()
             host = cmd[0]
-            cmd = ' '.join(cmd[1:])
-            # Send CMD to other device & show result
-            InterCon.send_cmd(host, cmd)
+            cmd = cmd[1:]
+            # Send CMD to other device
+            state, _ = exec_cmd(cmd + [f">>{host}"], jsonify=True)
         except Exception as e:
             syslog(f"__run_intercon error: {e}")
 
@@ -96,7 +93,7 @@ async def __task(ms_period, buff_size):
 
     if Data.MIC_TYPE == Data.MIC_TYPES['ADC']:
         # Create ADC object
-        Data.MIC_ADC = SmartADC.get_instance(resolve_pin('mic'))
+        Data.MIC_ADC = SmartADC.get_instance(bind_pin('mic'))
     elif Data.MIC_TYPE == Data.MIC_TYPES['I2S']:
         if Data.I2S_MIC is None:
             import LM_i2s_mic
@@ -216,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):