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

toolkit/lib/micrOSClientHistory.py

@@ -0,0 +1,156 @@
+import sys
+import os
+import re
+
+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
+
+
+ANSI_ESCAPE_RE = re.compile(r"\x1B\[[0-?]*[ -/]*[@-~]")
+
+
+class CommandInterface:
+    def __init__(self, prompt):
+        self._prompt = ""
+        self._prompt_plain = ""
+        self._last_rendered_length = 0
+        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
+
+    @staticmethod
+    def _strip_ansi(value):
+        if not value:
+            return ""
+        return ANSI_ESCAPE_RE.sub("", value)
+
+    @property
+    def prompt(self):
+        return self._prompt
+
+    @prompt.setter
+    def prompt(self, value):
+        self._prompt = value
+        self._prompt_plain = self._strip_ansi(value)
+
+    def pre_input_hook(self):
+        """Ensures prompt visibility when scrolling through history."""
+        buffer = readline.get_line_buffer()
+        sys.stdout.write("\r")
+        rendered = f"{self.prompt}{buffer}"
+        sys.stdout.write(rendered)
+
+        visible_length = len(self._prompt_plain) + len(buffer)
+        if visible_length < self._last_rendered_length:
+            padding = " " * (self._last_rendered_length - visible_length)
+            sys.stdout.write(padding)
+            sys.stdout.write("\r")
+            sys.stdout.write(rendered)
+
+        sys.stdout.flush()
+        self._last_rendered_length = visible_length
+        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/lib/pip_package_installer.py

@@ -1,10 +1,11 @@
 import sys
-from sys import executable
 import os
 import subprocess
+import getpass
+USER = getpass.getuser()
 MYPATH = os.path.dirname(__file__)
 USER_DATA_OPT_INST_DONE = os.path.join(MYPATH, '../user_data/.opt_dep_install')
-INTERPRETER = executable
+INTERPRETER = sys.executable
 
 sys.path.append(os.path.join(MYPATH, '../'))
 from DevEnvCompile import Compile
@@ -40,13 +41,39 @@ def list_packages():
     return AVAILABLE_PACKAGES
 
 
-def install_package(name):
+def run_subprocess(cmd_list: list):
     try:
-        state = subprocess.check_call([INTERPRETER, '-m', 'pip', 'install', name])
+        result = subprocess.run(
+            cmd_list,
+            capture_output=True,  # Captures stdout and stderr
+            text=True,  # Decodes output into strings
+            check=True  # Raises CalledProcessError for non-zero exit codes
+        )
+        print(f"Subprocess output: {result.stdout}")
+        return True, result.stdout
+    except subprocess.CalledProcessError as e:
+        print(f"{TerminalColors.Colors.ERR}Subprocess error:{TerminalColors.Colors.NC} {e.stderr}")
+        return False, e.stderr
+
+def install_package(name, additional_pip_param=None):
+    print(f"Install optional dependency (pip): {name}")
+    try:
+        if additional_pip_param is None:
+            state, out = run_subprocess([INTERPRETER, '-m', 'pip', 'install', '--user', USER, name])
+        else:
+            state, out = run_subprocess([INTERPRETER, '-m', 'pip', 'install', '--user', USER, name, additional_pip_param])
         if state:
             print(f"{TerminalColors.Colors.OK}[PIP] install {name} OK{TerminalColors.Colors.NC}")
         else:
             print(f"{TerminalColors.Colors.WARN}[PIP] install {name} NOK{TerminalColors.Colors.NC}")
+            if "--break-system-packages" in out:
+                # (Retry) Support system wide package install
+                install_package(name, additional_pip_param="--break-system-packages")
+            elif "This environment is externally managed" in out:
+                # (Retry-Fallback) Support brew installed python
+                if "brew install" in out:
+                    print(f"Install optional dependency (brew): {name}")
+                    state, out = run_subprocess(["brew", "install", name])
     except subprocess.CalledProcessError as e:
         print(f"{TerminalColors.Colors.ERR}[PIP] error: {e}{TerminalColors.Colors.NC}")
         state = False

toolkit/micrOSdashboard.py

@@ -6,17 +6,12 @@ import os
 import threading
 import subprocess
 import time
-from PyQt5.QtWidgets import QPushButton
-import PyQt5.QtCore as QtCore
-from PyQt5.QtCore import pyqtSlot
-from PyQt5.QtWidgets import *
-from PyQt5.QtGui import QIcon
-from PyQt5.QtGui import QTextCursor
-from PyQt5.QtWidgets import QApplication, QPlainTextEdit
-from PyQt5.QtCore import QThread, pyqtSignal
-from PyQt5.QtGui import QFont
-from PyQt5 import QtGui
-from PyQt5.QtGui import QPixmap
+
+from PyQt5.QtWidgets import (QApplication, QPlainTextEdit, QPushButton, QProgressBar, QComboBox, QLabel, QCheckBox,
+                             QLineEdit, QMessageBox, QWidget, QToolTip)
+from PyQt5.QtCore import pyqtSlot, QThread, QSize, pyqtSignal
+from PyQt5.QtGui import QIcon, QTextCursor, QFont, QPixmap
+
 import concurrent.futures
 
 MYPATH = os.path.dirname(__file__)
@@ -29,14 +24,14 @@ try:
     from . import socketClient
     from . import dashboard_apps
     from .lib import LocalMachine
-    from .lib.file_extensions import check_all_extensions
+    from .lib.MicrosFiles import check_all_extensions
 except Exception as e:
     print("Import warning: {}".format(e))
     import MicrOSDevEnv
     import socketClient
     import dashboard_apps
     from lib import LocalMachine
-    from lib.file_extensions import check_all_extensions
+    from lib.MicrosFiles import check_all_extensions
 
 APP_DIR = os.path.join(MYPATH, 'dashboard_apps')
 
@@ -454,7 +449,7 @@ class HeaderInfo:
         logo_path = os.path.join(MYPATH, '../media/logo_mini.png')
         button = QPushButton('', self.parent_obj)
         button.setIcon(QIcon(logo_path))
-        button.setIconSize(QtCore.QSize(50, 50))
+        button.setIconSize(QSize(50, 50))
         button.setGeometry(20, 5, 50, 50)
         button.setToolTip(f"Open micrOS repo documentation\n{self.url}")
         button.setStyleSheet('border: 0px solid black;')
@@ -581,7 +576,7 @@ class ClusterStatus:
                     except:
                         hwuid = hello
             status = '🟢' if status else '🔴'
-            msg = f"{status}{hwuid}|{devip}🏷{fuid} v:️{version}"
+            msg = f"{status}{hwuid} | {devip}🏷{fuid} v:{version}"
             return msg
 
         with concurrent.futures.ThreadPoolExecutor() as executor:
@@ -609,7 +604,7 @@ class QuickOTAUpload(QLabel):
         width = 200
         height = 15
         label = QLabel(self.parent_obj)
-        label.setText("Quick LM OTA Upload")
+        label.setText("Drag-n-Drop OTA file upload")
         label.setGeometry(start_x, start_y, width, height)
         label.setStyleSheet("background-color: white")
 
@@ -638,14 +633,14 @@ class QuickOTAUpload(QLabel):
         pixmap = QPixmap(logo_path)
         pixmap = pixmap.scaled(100, 100)
         self.setPixmap(pixmap)
-        self.setToolTip(f"Direct LM module upload to micrOS board via webrepl\nSimulator path: {os.path.join(MYPATH, 'workspace/simulator')}")
+        self.setToolTip(f"OTA File (py,mpy,js,html,css) upload to micrOS board via webrepl\nSimulator path: {os.path.join(MYPATH, 'workspace/simulator')}")
         self.setAcceptDrops(True)
 
     def get_upload_callback(self):
         if len(self.contents_path) == 0:
             self.parent_obj.console.append_output(f"Empty upload list.")
         else:
-            if not self.parent_obj.start_bg_application_popup(text="QUICK LM OTA UPLOAD?",
+            if not self.parent_obj.start_bg_application_popup(text="OTA UPLOAD?",
                                                               verify_data_dict={i+1: path for i, path in enumerate(self.contents_path)}):
                 return
             self.parent_obj.on_click_lm_quick_update(upload_path_list=self.contents_path)
@@ -954,7 +949,7 @@ class micrOSGUI(QWidget):
         self.devenv_usb_deployment_is_active = True
         # Create a Thread with a function without any arguments
         self.console.append_output('[usb_deploy] |- start usb_deploy job')
-        th = threading.Thread(target=self.devtool_obj.deploy_micros, kwargs={'restore': False, 'purge_conf': True},
+        th = threading.Thread(target=self.devtool_obj.deploy_micros, kwargs={'restore_config': False, "cleanup_workdir": True},
                               daemon=DAEMON)
         th.start()
         self.bgjob_thread_obj_dict['usb_deploy'] = th
@@ -1064,7 +1059,7 @@ class micrOSGUI(QWidget):
                                                                  'forced LM_ prefix': not self.modifiers_obj.unsafe_ota_enabled}):
             return
 
-        self.console.append_output('[quick_ota] Update Load Modules over wifi')
+        self.console.append_output('[quick_ota] Module upload over wifi')
         # Start init_progressbar
         pth = ProgressbarUpdateThread()
         pth.eta_sec = ProgressbarTimers.quick_ota
@@ -1219,7 +1214,7 @@ class micrOSGUI(QWidget):
 
 def main():
     app = QApplication(sys.argv)
-    app.setWindowIcon(QtGui.QIcon(os.path.join(MYPATH, '../media/logo.png')))
+    app.setWindowIcon(QIcon(os.path.join(MYPATH, '../media/logo.png')))
     ex = micrOSGUI()
     ex.draw()
     sys.exit(app.exec_())

toolkit/micrOSlint.py

@@ -18,7 +18,7 @@ MICROS_SOURCE_DIR = os.path.join(MYPATH, '../micrOS/source')
 RELEASE_INFO_PATH = os.path.join(MYPATH, '../micrOS/release_info/micrOS_ReleaseInfo')
 
 # MICROS LINTER CONFIG
-ALLOWED_LM_DEP_WARNS = 7        # ALLOWED NUMBER OF LM CORE DEPENDENCY (less is better)
+ALLOWED_LM_DEP_WARNS = 3        # ALLOWED NUMBER OF LM CORE DEPENDENCY (less is better)
 
 def parse_micros_file_categories(verbose=True):
     """
@@ -27,11 +27,17 @@ def parse_micros_file_categories(verbose=True):
     file_ignore_list = ['.DS_Store']
     # micrOS file categories
     categories = {'core': [], 'load_module': [], 'pin_maps': [], 'other': []}
-    files = [f for f in LocalMachine.FileHandler.list_dir(MICROS_SOURCE_DIR) if f not in file_ignore_list]
+    modules_path = os.path.join(MICROS_SOURCE_DIR, "modules")
+    web_path = os.path.join(MICROS_SOURCE_DIR, "web")
+    check_file = lambda _b, _f: os.path.isfile(os.path.join(_b, _f)) and _f not in file_ignore_list
+    root_files = [f for f in LocalMachine.FileHandler.list_dir(MICROS_SOURCE_DIR) if check_file(MICROS_SOURCE_DIR, f)]
+    module_files = [f"modules/{f}" for f in LocalMachine.FileHandler.list_dir(modules_path) if check_file(modules_path, f)]
+    web_files = [f"web/{f}" for f in LocalMachine.FileHandler.list_dir(web_path) if check_file(web_path, f)]
+    files = root_files + module_files + web_files
     for f in files:
-        if f.startswith('LM_') and f.endswith('.py'):
+        if f.endswith('.py') and "LM_" in f:
             categories['load_module'].append(f)
-        elif f.startswith('IO_') and f.endswith('.py'):
+        elif f.endswith('.py') and "IO_" in f:
             categories['pin_maps'].append(f)
         elif f.endswith('.py'):
             categories['core'].append(f)
@@ -172,14 +178,15 @@ def core_dep_checker(categories, verbose=True):
 def load_module_checker(categories, verbose=True):
 
     def _is_allowed(_relation):
-        _allowed_whitelist = ['Common', 'microIO', 'Types']
+        _allowed_whitelist = ['Common', 'microIO', 'Types', 'urequests', 'Auth']
         _allowed = []
         for _allow in _relation:
             if _allow in _allowed_whitelist:
                 _allowed.append(_allow)
         return _relation, _allowed
 
-    lm_god_mode = ['LM_system.py', 'LM_lmpacman.py', 'LM_intercon.py']
+    lm_god_mode = ['modules/LM_system.py', 'modules/LM_pacman.py',
+                   'modules/LM_espnow.py', 'modules/LM_cluster.py']
     state_lm_dep = True
     verdict = []
     lm_resources = categories['load_module']
@@ -222,7 +229,12 @@ def _run_pylint(file_name):
         '--disable=broad-exception-caught',         # Disable BROAD exception
         '--disable=broad-exception-raised',         # Disable BROAD exception
         '--disable=too-many-return-statements',     # :D I don't think so :D
-        '--disable=too-many-branches'               # :D I don't think so :D
+        '--disable=too-many-branches',              # :D I don't think so :D
+        '--disable=too-many-positional-arguments',  # :D I don't think so :D
+        '--disable=too-many-instance-attributes',   # :D I don't think so :D
+        '--disable=wrong-import-position',          # :D I don't think so :D !!! It is needed due to optimizations
+        '--disable=too-many-arguments',             # :D I know what I am doing...
+        '--disable=multiple-statements',            # :D I line oneliners
     ]
     if file_name in ['Tasks.py', 'microIO.py', 'Types.py']:
         pylint_opts.append('--disable=exec-used')   # Disable micrOS execution core exec/eval warning
@@ -239,7 +251,7 @@ def _run_pylint(file_name):
 
 def run_pylint(categories, verbose=True, dry_run=False):
     # ERROR CONFIG: drop error if this is in pylint output
-    error_msg_core = ['syntax-error', 'undefined-variable', 'no-member']
+    error_msg_core = ['syntax-error', 'undefined-variable', 'bad-indentation']  # 'no-member' ?
     # BYPASS 'no-member' due to duty and sleep_ms micropython functions is drops false alarm, etc.
     error_msg_lm = ['syntax-error', 'undefined-variable']
 
@@ -346,13 +358,18 @@ def _verdict_gen(master_key, categories, verbose=True):
                     ref = ['?', []]
             spacer = "\n" + " " * 98
             ref_verdict = f'{ref[0]}:{spacer.join(ref[1])}' if verbose else ref[0]
+            if isinstance(ref_verdict, int):
+                ref_cnt = f"{Colors.BOLD}{ref_verdict}{Colors.NC}" if ref_verdict > 0 else ref_verdict
+            else:
+                ref_cnt = ref_verdict
 
             mlint = categories[master_key][master_module]['linter']['mlint'][0]
+            mlint = f"{Colors.OK}OK{Colors.NC}" if mlint else f"{Colors.WARN}NOK{Colors.NC}"
             try:
                 pylint = categories[master_key][master_module]['linter']['pylint'][0]
             except Exception as e:
                 pylint = f'{e}'
-            long_verdict.append(f"\t{i+1}\t{lines}\t{master_module}{_spacer(master_module)}(mlint: {mlint})\t(pylint: {pylint})\t(ref.: {ref_verdict})")
+            long_verdict.append(f"\t{i+1}\t{lines}\t{master_module}{_spacer(master_module)}(mlint: {mlint})\t(pylint: {pylint})\t(ref.: {ref_cnt})")
             short_result[master_module] = [pylint, ref_verdict]
     return  short_result, long_verdict
 
@@ -502,8 +519,9 @@ def diff_short_summary(summary, verbose=True):
 
 def save_system_analysis_json(categories):
     file_path = os.path.join(MYPATH, 'user_data/system_analysis.json')
+    sorted_categories = {key: categories[key] for key in sorted(categories)}
     with open(file_path, 'w') as json_file:
-        json.dump(categories, json_file, indent=4)
+        json.dump(sorted_categories, json_file, indent=4)
     return f"system_analysis json saved to {file_path}"
 
 def save_system_summary_json(summary):

micrOS/source/IO_esp32.py → toolkit/simulator_lib/IO_darwin.py

@@ -51,6 +51,9 @@ i2s_sck = const(26)    # Serial clock
 i2s_ws = const(25)     # Word select
 i2s_sd = const(33)     # Serial data
 
+tx = const(50)
+rx = const(51)
+
 
 # EXTERNAL EVENT IRQ
 irq1 = const(4)         # D4  - event irq pin

toolkit/simulator_lib/aioespnow.py

@@ -0,0 +1,28 @@
+
+
+class AIOESPNow:
+
+    def __init__(self):
+        self._active = False
+        self.peers_table = None
+
+    def active(self, state=None):
+        if state is not None:
+            self._active = state
+        return self._active
+
+    def stats(self):
+        pass
+
+    def add_peer(self, mac):
+        pass
+
+    async def asend(self, mac, full_msg):
+        pass
+
+    def send(self, mac, full_msg):
+        pass
+
+    def __iter__(self):
+        return (i for i in range(0, 3))
+

toolkit/simulator_lib/camera.py

@@ -0,0 +1,84 @@
+import os
+import time
+MYPATH = os.path.dirname(__file__)
+
+JPEG = None
+XCLK_20MHz = None
+PSRAM = None
+FRAME_SVGA = None
+FRAME_HD = None
+FRAME_HVGA = None
+
+EFFECT_NEG = None
+EFFECT_BW = None
+EFFECT_RED = None
+EFFECT_GREEN = None
+EFFECT_BLUE = None
+EFFECT_RETRO = None
+EFFECT_NONE = None
+
+WB_SUNNY = None
+WB_CLOUDY = None
+WB_OFFICE = None
+WB_HOME = None
+WB_NONE = None
+
+
+def _dummy_images_gen():
+    images = [os.path.join(MYPATH, 'view01.jpg'), os.path.join(MYPATH, 'view02.jpg')]
+    while True:
+        for img in images:
+            yield img
+
+_DUMMY_IMAGES = _dummy_images_gen()
+
+def init(*args, **kwargs):
+    print("Init dummy camera module")
+    print(args)
+    print(kwargs)
+    return True
+
+def deinit(*args, **kwargs):
+    print("DeInit dummy camera module")
+    print(args)
+    print(kwargs)
+    return True
+
+def framesize(*args, **kwargs):
+    pass
+
+def flip(*args, **kwargs):
+    pass
+
+def mirror(*args, **kwargs):
+    pass
+
+def speffect(*args, **kwargs):
+    pass
+
+def whitebalance(*args, **kwargs):
+    pass
+
+def saturation(*args, **kwargs):
+    pass
+
+def brightness(*args, **kwargs):
+    pass
+
+def contrast(*args, **kwargs):
+    pass
+
+def quality(*args, **kwargs):
+    pass
+
+def capture():
+    print("Load dummy image")
+    image = next(_DUMMY_IMAGES)
+    try:
+        time.sleep(1)
+        with open(image, 'rb') as f:
+            image_bin = f.read()
+            return image_bin
+    except Exception as e:
+        print(f"Cannot load {image}: {e}")
+        return b''

toolkit/simulator_lib/dht.py

@@ -1,4 +1,4 @@
-from sim_console import console
+from sim_common import console
 
 
 class DHT22:

toolkit/simulator_lib/framebuf.py

@@ -1,6 +1,54 @@
 
 MONO_VLSB = None
+MONO_HMSB = None
 
 
 class FrameBuffer:
-    pass
+
+    def __init__(self, *args, **kwargs):
+        pass
+
+    def fill(self, color=0):
+        pass
+
+    def show(self):
+        pass
+
+    def write_cmd(self, cmd):
+        pass
+
+    def reset(self):
+        pass
+
+    def poweron(self):
+        pass
+
+    def poweroff(self):
+        pass
+
+    def flip(self, *args, **kwargs):
+        pass
+
+    def rotate(self, *args, **kwargs):
+        pass
+
+    def text(self, string, x, y, color=0):
+        pass
+
+    def pixel(self, x, y, color=0):
+        pass
+
+    def line(self, x0, y0, x1, y1, color=0):
+        pass
+
+    def rect(self, x0, y0, x1, y1, color=0):
+        pass
+
+    def fill_rect(self, x, y, w, h, color=0):
+        pass
+
+    def blit(self, fbuf, x, y, key, palette):
+        pass
+
+    def scroll(self, dx, dy):
+        pass