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

toolkit/lib/micrOSClientHistory.py

@@ -0,0 +1,122 @@
+import sys
+import os
+
+try:
+    import readline  # Linux/macOS
+except ImportError:
+    import pyreadline3 as readline  # Windows (PowerShell, CMD)
+
+try:
+    from .TerminalColors import Colors as color
+except:
+    from TerminalColors import Colors as color
+
+
+class CommandInterface:
+    def __init__(self, prompt):
+        self.prompt = prompt
+        self.command_history = ["help"]
+        self.history_file = os.path.expanduser("~/.micrOS_cmd_history")  # History file (Linux/macOS)
+
+        # Configure readline
+        self.load_history()
+        readline.set_completer_delims("")  # Ensure entire command is considered
+        readline.set_completer(self.autocomplete)
+        # Check if we're running on macOS using libedit
+        if "libedit" in readline.__doc__:
+            readline.parse_and_bind("bind ^I rl_complete")  # macOS alternative
+        else:
+            readline.parse_and_bind("tab: complete")  # Linux/GNU readline
+        readline.set_pre_input_hook(self.pre_input_hook)
+        readline.set_completion_display_matches_hook(self.completion_display)
+
+    def __auto_clear_history(self):
+        cmd_history = []
+        # Load file history in order - skip duplicates
+        if os.path.exists(self.history_file):
+            with open(self.history_file, "r") as f:
+                for line in reversed(f.readlines()):
+                    if line in cmd_history:
+                        continue
+                    cmd_history.append(line)
+            # Save cleaned history to file
+            with open(self.history_file, "w") as f:
+                f.writelines(f"{item}\n" for item in reversed(cmd_history))
+
+    def load_history(self):
+        """Loads command history from a file if available."""
+        print(f"Command history: {self.history_file}")
+        try:
+            self.__auto_clear_history()
+        except Exception as e:
+            print(f"Auto clean history error: {e}")
+        if os.path.exists(self.history_file):
+            with open(self.history_file, "r") as f:
+                for line in f:
+                    clean_line = line.strip()
+                    if clean_line:  # Avoid empty lines
+                        self.command_history.append(clean_line)
+                        readline.add_history(clean_line)
+
+    def save_history(self):
+        """Saves command history to a file."""
+        with open(self.history_file, "w") as f:
+            for cmd in self.command_history:
+                f.write(cmd + "\n")
+
+    def add_history(self, cmd):
+        """Updates readline history and command_history."""
+        cmd = cmd.strip()
+        if cmd and cmd != self.command_history[-1]:  # Avoid duplicate last command
+            self.command_history.append(cmd)
+            readline.add_history(cmd)
+
+    def autocomplete(self, text, state):
+        """Autocomplete function: suggests previous commands."""
+        matches = list(dict.fromkeys(cmd for cmd in self.command_history if cmd.startswith(text)))
+        return matches[state] if state < len(matches) else None
+
+    def pre_input_hook(self):
+        """Ensures prompt visibility when scrolling through history."""
+        sys.stdout.write(f"\r{self.prompt}{readline.get_line_buffer()}")
+        sys.stdout.flush()
+        readline.redisplay()  # Ensures history navigation does not erase prompt
+
+    def completion_display(self, substitutions, matches, longest_match_length):
+        print("\nSuggestions:", ", ".join(matches))
+
+    #####################################
+    #       STANDALONE TEST METHODS     #
+    #####################################
+
+    def dummy_send_cmd(self, cmd, stream):
+        """TEST FUNCTION - OUTPUT STRUCTURE SIMULATION (Must remain unchanged)."""
+        dummy_reply = "Bye!" if cmd.strip() in ["exit", "reboot"] else f"Dummy reply for {cmd}"
+        if stream:
+            print(dummy_reply)  # micrOS protocol: return response data
+            print(self.prompt, end="")  # micrOS protocol: return prompt -> indicating ready state
+        else:
+            dummy_reply = f"{dummy_reply}\n{self.prompt}"
+        return dummy_reply
+
+    def dummy_run(self):
+        """TEST FUNCTION - Simulated interactive terminal."""
+        print(f"{self.prompt}", end="", flush=True)
+        while True:
+            try:
+                cmd = input()
+                output = self.dummy_send_cmd(cmd, stream=True)
+                self.add_history(cmd)
+                if 'Bye!' in str(output):
+                    break
+            except KeyboardInterrupt:
+                print("\nExiting...")
+                break
+
+        self.save_history()
+        print("Session closed.")
+
+
+if __name__ == "__main__":
+    shell = CommandInterface(prompt="<prompt_placeholder>$ ")
+    shell.dummy_run()

toolkit/micrOSlint.py

@@ -179,7 +179,7 @@ def load_module_checker(categories, verbose=True):
                 _allowed.append(_allow)
         return _relation, _allowed
 
-    lm_god_mode = ['LM_system.py', 'LM_lmpacman.py', 'LM_intercon.py']
+    lm_god_mode = ['LM_system.py', 'LM_pacman.py', 'LM_intercon.py']
     state_lm_dep = True
     verdict = []
     lm_resources = categories['load_module']

toolkit/simulator_lib/machine.py

@@ -214,3 +214,7 @@ def unique_id():
 
 def time_pulse_us():
     return time.time_ns()*1000
+
+
+def SDCard():
+    pass

toolkit/simulator_lib/node_config.json

@@ -2,6 +2,6 @@
   "devfid": "simulator",
   "appwd": "ADmin123",
   "webui": true,
-  "boothook": "dashboard_be load; neopixel load; #system top",
+  "boothook": "dashboard_be load; neopixel load; #telegram receiver_loop &2000",
   "aioqueue": 4,
   "telegram": "6185435843:AAH71wEyoOil8bRKecQHp4zazTQ_MmE7bvE"}

toolkit/simulator_lib/uasyncio.py

@@ -1,8 +1,14 @@
 import asyncio
+import ssl
+
+ssl_context = ssl.create_default_context()
+ssl_context.check_hostname = False  # Disable hostname check
+ssl_context.verify_mode = ssl.CERT_NONE  # Disable certificate verification
 
 
 def open_connection(host, port, ssl=False):
-    return asyncio.open_connection(host, port, ssl=ssl)
+    #return asyncio.open_connection(host, port, ssl=ssl)
+    return asyncio.open_connection(host, port, ssl=ssl_context if ssl else None)
 
 
 class Lock(asyncio.Lock):

toolkit/simulator_lib/uos.py

@@ -0,0 +1,138 @@
+import os
+import stat as py_fs_stat
+
+# https://docs.micropython.org/en/v1.9.2/pyboard/library/uos.html
+# https://docs.micropython.org/en/v1.18/library/os.html
+
+MOCK_SIM = False
+
+def listdir(path=None):
+    if path is None:
+        return os.listdir()
+    path = __mock_sim_dir(path)
+    print(f"[uos.SIM] listdir: {path}")
+    return os.listdir(path)
+
+
+def getcwd():
+    _cwd = os.getcwd()
+    if MOCK_SIM:
+        cwd = f"{_cwd}/../workspace/simulator/"
+        print(f"MOCK PATH: {cwd}")
+    elif "workspace/simulator" not in _cwd:
+        cwd = f"{_cwd}/toolkit/workspace/simulator/"
+        print(f"[uos.SIM] MOCK PATH: {_cwd} -> {cwd}")
+    else:
+        cwd = _cwd
+    return cwd
+
+
+def __mock_sim_dir(path):
+    """
+    micropython sim hack
+    """
+    if MOCK_SIM:
+        cwd = getcwd()
+        path = f"{cwd}{path}"
+        print(f"[!!!] [uos.SIM] CWD PATH HACK: {path}")
+    elif "workspace/simulator" not in path:
+        path = f"{getcwd()}{path}"
+    return path
+
+
+def ilistdir(path):
+    buffer = []
+    for filename in listdir(path):
+        _name, _type, _inode = filename, stat(f"{path}/{filename}")[0], 0
+        print(f"[uos.SIM] ilistdir {path}: ({_name}, {_type:#x}, {_inode}")
+        buffer.append((_name, _type, _inode))
+    return tuple(buffer)
+
+
+def mkdir(path):
+    print(f"[uos.SIM] mkdir: {path}")
+    return os.mkdir(path)
+
+
+def remove(path):
+    path = __mock_sim_dir(path)
+    print(f"[uos.SIM] remove: {path}")
+    if "simulator" in path and path.replace('/', '').endswith('simulator'):
+        print(f"\t[uos.SIM] rmdir: Invalid path! {path}")
+        return False
+    return os.remove(path)
+
+
+def rename(old_path, new_path):
+    old_path, new_path = __mock_sim_dir(old_path),  __mock_sim_dir(new_path)
+    print(f"[uos.SIM] rename: {old_path} -> {new_path}")
+    os.rename(old_path, new_path)
+
+def _stat_eval(stat_result):
+    """
+    micropython converter
+    """
+    micropython_file_identifier = {'dir': 0x4000, 'file': 0x8000}
+    # Check if it's a file
+    if py_fs_stat.S_ISREG(stat_result.st_mode):
+        # FILE
+        return (micropython_file_identifier['file'],)
+    if py_fs_stat.S_ISDIR(stat_result.st_mode):
+        # DIRECTORY
+        return (micropython_file_identifier['dir'],)
+    return (0x0,)
+
+def stat(path):
+    path = __mock_sim_dir(path)
+    stat_result = os.stat(path)
+    micropython_stat_result = _stat_eval(stat_result)
+    path_type = 'dir' if micropython_stat_result[0] & 0x4000 else 'file'
+    print(f"[uos.SIM] stat: {path} {path_type}({micropython_stat_result[0]:#x})")
+    return micropython_stat_result
+
+
+def rmdir(path):
+    print(f"[uos.SIM] rmdir: {path}")
+    if "simulator" in path and path.replace('/', '').endswith('simulator'):
+        print(f"\t[uos.SIM] rmdir: Invalid path! {path}")
+        return False
+    return os.rmdir(path)
+
+
+def statvfs(path=None):
+    if path is None:
+        return os.statvfs(__mock_sim_dir(path))
+    return os.statvfs(path)
+
+
+def uname():
+    return os.uname()
+
+
+def sync():
+    print("[uos.SIM] sync - dummy")
+
+
+def urandom(n):
+    print(f"[uos.SIM] sync {n}")
+    return os.urandom(n)
+
+
+def dupterm(stream_object):
+    print("[uos.SIM] dupterm - dummy")
+
+
+def mount(*args, **kwargs):
+    print("[uos.SIM] mount - dummy")
+
+
+def umount(*args, **kwargs):
+    print("[uos.SIM] unmount - dummy")
+
+
+if __name__  == "__main__":
+    MOCK_SIM = True
+    print(f"SIM root (mock: {MOCK_SIM}): {__mock_sim_dir('/')}\ngetcwd: {getcwd()}")
+    print(listdir("/"))
+    print(stat('/'))
+    print(ilistdir('/'))

toolkit/socketClient.py

@@ -210,8 +210,8 @@ class ConnectionData:
                         start_comm = time.time()
                         version_data = SocketDictClient(host=ip, port=port, silent_mode=True, tout=3).non_interactive(['version'])
                         elapsed_time = "{:.3f}".format(time.time() - start_comm)
-                    except:
-                        pass
+                    except Exception as e:
+                        print(f"Getting device version {fuid}:{uid} error: {e}")
 
                 # Generate line printout
                 base_info = "{uid}{spr1}{fuid}".format(uid=uid, spr1=spacer1, fuid=fuid)
@@ -341,7 +341,7 @@ class SocketDictClient:
 #########################################################
 
 
-def main(args, host='127.0.0.1', port=9008, timeout=3, pwd=None, verbose=False):
+def main(args, host='127.0.0.1', port=9008, timeout=5, pwd=None, verbose=False):
     """ main connection wrapper function """
     answer_msg = None
 
@@ -426,7 +426,7 @@ def socket_commandline_args(arg_list):
     return ' <a> '.join(command_buffer), return_action_dict
 
 
-def run(arg_list=[], timeout=5):
+def run(arg_list=[], timeout=10):
     """ Run from code
         - Handles extra command line arguments
     """

toolkit/workspace/precompiled/LM_pacman.py

@@ -0,0 +1,248 @@
+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, '?'
+
+
+#############################################
+#     Safe file system handler functions    #
+#############################################
+
+def ls(path="/", content='*', raw=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), ...]
+    """
+    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))
+    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
+
+
+def rm(path):
+    """
+    Linux like rm command - delete app resources and folders
+    :param path: app resource name/path, ex.: LM_robustness.py
+    """
+    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}"
+
+
+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}
+    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"
+    return formatted_output
+
+
+def download(url=None, package=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)
+    """
+    if url is None and package is None:
+        return "Nothing to download, url=None package=None"
+    if package is None:
+        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}"
+    else:
+        url = package
+    from mip import install
+    verdict = ""
+    try:
+        verdict += f"Install {url}\n"
+        install(url)
+        verdict += "\n|- Done"
+    except Exception as e:
+        verdict += f"|- Cannot install: {url}\n{e}"
+    return verdict
+
+
+def del_duplicates():
+    """
+    Load module package manager (Not just load modules)
+    - 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'))
+    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)
+            except:
+                state = False
+            msg_buf.append(f'   Delete {to_delete} {state}')
+    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(delpds=None, msgobj=None):
+    """
+    Cache system persistent data storage files (.pds)
+    :param delpds: cache name to delete
+    """
+    if delpds is None:
+        # List pds files aka application cache
+        msg_buf = []
+        for pds in (_pds for _pds in listdir() if _pds.endswith('.pds')):
+            with open(pds, 'r') as f:
+                if msgobj is None:
+                    msg_buf.append(f'{pds}: {f.read()}')
+                else:
+                    msgobj(f'{pds}: {f.read()}')
+        return msg_buf if len(msg_buf) > 0 else ''
+    # Remove given pds file
+    try:
+        remove(f'{delpds}.pds')
+        return f'{delpds}.pds delete done.'
+    except:
+        return f'{delpds}.pds not exists'
+
+
+def dat_dump():
+    """
+    Generic .dat file dump
+    - logged data from LMs, sensor datat, etc...
+    """
+    logs_dir = "/logs/"
+    dats = (f for f in listdir(logs_dir) if f.endswith('.dat'))
+    out = {}
+    for dat in dats:
+        with open(f"{logs_dir}{dat}", 'r') as f:
+            out[dat] = f.read()
+    return out
+
+#############################################
+#              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 listdir("/")
+              if res.startswith('LM_') or res.split('.')[-1] in WEB_EXT):
+        if msgobj is None:
+            msg_buf.append(f'   {k}')
+        else:
+            msgobj(f'   {k}')
+    return msg_buf if len(msg_buf) > 0 else ''
+
+
+def delmod(mod=None):
+    """
+    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.'
+        try:
+            to_remove = mod if mod.split('.')[-1] in WEB_EXT else f'LM_{mod}'
+            remove(to_remove)
+            return f'Delete module: {mod}'
+        except Exception as e:
+            return f'Cannot delete: {mod}: {e}'
+    return f'Invalid value: {mod}'
+
+
+@socket_stream
+def micros_checksum(msgobj=None):
+    from hashlib import sha1
+    from binascii import hexlify
+    from Config import cfgget
+
+    for f_name in (_pds for _pds in listdir() if _pds.endswith('py')):
+        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 or .js/.html/.css', 'del_duplicates',
+            'moduls unload="LM_rgb/None"',
+            'cachedump delpds="rgb/None"',
+            'dat_dump',
+            'download url="BxNxM/micrOS/master/toolkit/workspace/precompiled/LM_robustness.py"',
+            'micros_checksum',
+            'ls path="/" content="*/f/d"',
+            'rm <path>', 'dirtree path="/"')

toolkit/workspace/precompiled/LM_robustness.py

@@ -9,8 +9,8 @@ def raise_error(msgobj=None):
     """
     if msgobj is not None:
         msgobj("Raise test exception")
-    syslog('Robustness TeSt ErRoR')
-    raise Exception("Test exception")
+    state = syslog('Robustness TeSt ErRoR')
+    raise Exception(f"Test exception: {'OK' if state else 'NOK'}")
 
 
 @socket_stream

toolkit/workspace/precompiled/_mpy.version

@@ -1 +1 @@
-1.20.0
+1.24.1

toolkit/workspace/precompiled/node_config.json

@@ -1 +1 @@
-{"stapwd": "BNM3,1415", "cron": false, "crontasks": "n/a", "timirq": false, "timirqcbf": "n/a", "irq1": false, "irq1_cbf": "n/a", "irq2": true, "appwd": "ADmin123", "auth": false, "webui": true, "irq2_cbf": "basic_led toggle", "irq2_trig": "n/a", "irq3": false, "irq3_cbf": "n/a", "irq3_trig": "n/a", "irq_prell_ms": 300, "boothook": "types_demo load", "aioqueue": 5, "utc": 60, "boostmd": true, "espnow": false, "irq1_trig": "n/a", "irq4_cbf": "n/a", "guimeta": "...", "devip": "10.0.1.179", "timirqseq": 1000, "cstmpmap": "n/a", "telegram": "n/a", "dbg": true, "hwuid": "micr7c9ebd6147c4OS", "devfid": "TestBird", "staessid": "elektroncsakpozitivan_2G", "soctout": 30, "irq4_trig": "n/a", "irq4": false, "version": "2.8.1-0", "nwmd": "STA", "socport": 9008}
+{"irq2": false, "irq2_cbf": "n/a", "irq3_cbf": "n/a", "timirq": true, "irq4": false, "auth": false, "irq4_cbf": "n/a", "devip": "10.0.1.129", "soctout": 100, "appwd": "ADmin123", "timirqcbf": "rgb run_transition", "timirqseq": 800, "hwuid": "micr8caab594e9d4OS", "staessid": "T-3588F3;elektroncsakpozitivan_2G", "irq1_cbf": "rgb toggle", "cron": true, "irq4_trig": "n/a", "nwmd": "STA", "boothook": "rgb load_n_init", "version": "1.41.0-0", "irq_prell_ms": 300, "crontasks": "sunrise!rgb set_transition 400 0 0 3600;sunset!rgb run_transition 143 330 0 300;*:9:0:0!rgb set_transition 0 300 300 1800;*:12:0:0!rgb toggle False;*:20:0:0!rgb set_transition 600 211 2 3600;*:21:2:0!rgb rgb 100 30 0;*:23:0:0!rgb toggle False", "aioqueue": 3, "utc": 60, "boostmd": true, "irq1_trig": "n/a", "guimeta": "...", "socport": 9008, "webui": true, "cstmpmap": "n/a", "telegram": "n/a", "irq3_trig": "n/a", "dbg": true, "irq2_trig": "n/a", "irq3": false, "devfid": "ujelet", "stapwd": "jBRU7SJmreae8n5p;BNM3,1415", "irq1": false}