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

toolkit/lib/micrOSClient.py

@@ -1,6 +1,4 @@
 import socket
-import sys
-
 import select
 import re
 import time
@@ -10,6 +8,25 @@ except:
     from TerminalColors import Colors as color
 
 
+ANSI_ESCAPE_RE = re.compile(r"\x1B\[[0-?]*[ -/]*[@-~]")
+
+def load_command_history(prompt_getter):
+    """Optional command history feature"""
+    try:
+        try:
+            from .micrOSClientHistory import CommandInterface
+        except:
+            from micrOSClientHistory import CommandInterface
+    except Exception as e:
+        print(f"Command history - disabled (readline module error): {e}")
+        return None
+    try:
+        return CommandInterface(prompt=prompt_getter)
+    except Exception as e:
+        print(f"Command history error: {e}")
+    return None
+
+
 class micrOSClient:
     CONN_MAP = {}
 
@@ -35,6 +52,10 @@ class micrOSClient:
         # Validate and resolve host (IP/Hostname)
         self.__address_manager()
 
+    @property
+    def telnet_prompt(self):
+        return f"{color.BOLD}{self.preprompt}{self.prompt}{color.NC} "
+
     def __address_manager(self):
         self.dbg_print("[INIT] micrOSClient")
         # Host is valid IP address - self.host is ip address OK
@@ -67,10 +88,22 @@ class micrOSClient:
 
     @staticmethod
     def validate_ipv4(str_in):
-        pattern = "^([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])$"
-        if bool(re.match(pattern, str_in)):
-            return True
-        return False
+        parts = str_in.split(".")
+        # An IPv4 address must have exactly 4 parts
+        if len(parts) != 4:
+            return False
+        for part in parts:
+            # Each part must be a number and not empty
+            if not part.isdigit():
+                return False
+            num = int(part)
+            # Each number must be in the valid range (0-255)
+            if num < 0 or num > 255:
+                return False
+            # Prevents leading zeros (e.g., "01" is invalid)
+            if part != str(num):
+                return False
+        return True
 
     def __connect(self, timeout):
         # Server connection - create socket
@@ -143,24 +176,35 @@ class micrOSClient:
 
     def __filter_preprompt(self, _data):
         if len(_data) == 0:
-            return
-        last_line = _data.strip().split('\n')[-1]
-        # get pre-prompt: >[configure]< prompt $
+            return _data
+
+        has_trailing_newline = _data.endswith('\n')
+        working = _data.rstrip('\n')
+        lines = working.split('\n') if working else ['']
+        last_line = lines[-1]
+
         if self.prompt is not None:
-            # Check prompt is in last line
-            if self.prompt in last_line:
-                # Check pre-prompt - remove prompt
-                x = last_line.replace(self.prompt, '')
-                # SET preprompt if preprompt exists
-                self.preprompt = x if len(x) > 0 else self.preprompt
-            # Pre-prompt remove and cancel preprompt modes
-            if self.preprompt in last_line:
-                _data = _data.replace(self.preprompt, "")
-            else:
-                self.preprompt = ""
-        return _data
+            prompt_index = last_line.find(self.prompt)
+            if prompt_index != -1:
+                raw_prefix = last_line[:prompt_index]
+                plain_prefix = ANSI_ESCAPE_RE.sub('', raw_prefix)
+
+                plain_prefix = plain_prefix.rstrip()
+                if plain_prefix:
+                    if not plain_prefix.endswith(' '):
+                        plain_prefix += ' '
+                    self.preprompt = plain_prefix
+                else:
+                    self.preprompt = ""
+
+                lines[-1] = last_line[prompt_index:]
 
-    def __receive_data(self, read_timeout=20):
+        rebuilt = '\n'.join(lines)
+        if has_trailing_newline:
+            rebuilt += '\n'
+        return rebuilt
+
+    def __receive_data(self, read_timeout=20, stream=False):
         """
         Client Receiver Loop
         - read_timeout - wait for server to reply (should be <15, avoid msg queue-ing)
@@ -173,7 +217,11 @@ class micrOSClient:
         # Collect answer data
         if select.select([self.conn], [], [], read_timeout)[0]:
             while True:
-                data_buffer += self.conn.recv(4096).decode('utf-8')
+                incoming_data = self.conn.recv(4096).decode('utf-8')
+                if stream:
+                    incoming_data = incoming_data.replace(self.prompt, f"{color.NC}{color.BOLD}{self.prompt}{color.NC}")
+                    print(f"\r{color.LIGHT_GRAY}{incoming_data}{color.NC}", end="")
+                data_buffer += incoming_data
                 # Last line from data_buffer (handle fragmented messages - prompt detection)
                 last_line = data_buffer.strip().split("\n")[-1]
                 # Wait for prompt or special cases (exit/prompt)
@@ -200,7 +248,7 @@ class micrOSClient:
         self.isconn = False
         self.spacer = 0
 
-    def __run_command(self, cmd):
+    def __run_command(self, cmd, stream=False):
         """
         Run command on server tcp/ip connection
         - prompt check - validate device ("hostname $" = "prompt")
@@ -218,14 +266,14 @@ class micrOSClient:
             # Workaround for reboot command - micrOS async server cannot send Bye! msg before reboot.
             if reboot_request:
                 return 'Bye!'
-            data = self.__receive_data()
+            data = self.__receive_data(stream=stream)
             return data
         # Skip command run: prompt and host not the same!
         print(f"[micrOSClient] {color.ERR}prompt mismatch{color.NC}, hostname: {check_hostname} prompt: {check_prompt} ")
         # Check UID?
         return None
 
-    def send_cmd(self, cmd, timeout=3, retry=5):
+    def send_cmd(self, cmd, timeout=3, retry=5, stream=False):
         """
         Send command function - main usage for non interactive mode
         """
@@ -244,7 +292,7 @@ class micrOSClient:
 
         # @ Run command
         try:
-            out = self.__run_command(cmd)
+            out = self.__run_command(cmd, stream=stream)
         except Exception as e:
             self.dbg_print("{}[ERR]{} send_cmd error: {}".format(color.ERR, color.NC, e))
             self.dbg_print("Auto deinit connection")
@@ -258,14 +306,14 @@ class micrOSClient:
         f_delta_t = "{}[{:.2f}]{}".format(color.OKGREEN, delta_time, color.NC)
         self.dbg_print("{}[⏰] {} {}reply: {}{}".format(f_delta_t, cmd, color.BOLD, out, color.NC))
 
-        # return output list
+        # return output list or None
         return out
 
-    def send_cmd_retry(self, cmd, timeout=6, retry=5):
+    def send_cmd_retry(self, cmd, timeout=6, retry=5, stream=False):
         out = None
         for cnt in range(0, retry):
             try:
-                out = self.send_cmd(cmd, timeout)
+                out = self.send_cmd(cmd, timeout, stream=stream)
                 if out is None or isinstance(out, list):
                     break
             except OSError as e:
@@ -277,7 +325,7 @@ class micrOSClient:
             time.sleep(0.2)
         return out
 
-    def telnet(self, timeout=4):
+    def telnet(self, timeout=5):
         """
         Implements interactive mode for socket communication.
         """
@@ -287,18 +335,41 @@ class micrOSClient:
             print("Telnet connect: {}".format(e))
             if "busy" in str(e) or "timed out" in str(e) or "No route to host" in str(e) or "Host is down" in str(e):
                 return
+
+        history = load_command_history(self.telnet_prompt)              # History: Beta feature
+        if history is not None:
+            history.prompt = self.telnet_prompt
+        print(self.telnet_prompt, end="")
+        is_empty = False                                                # Empty input support
         while True:
-            cmd = input("{}{} ".format(self.preprompt, self.prompt))
-            # send command
-            output = self.send_cmd(cmd)
-            # Format output to human readable
-            output = '\n'.join(output) if isinstance(output, list) else output
-            # output to STDOUT
-            if not (cmd.strip() == '' and output is None):
-                print(output)
-            # Close session
-            if 'Bye!' in str(output):
+            try:
+                # INPUT HANDLING
+                if history is not None:
+                    history.prompt = self.telnet_prompt
+                cmd = input(self.telnet_prompt if is_empty else '')     # CANNOT contain prompt - it is coming back from response data
+                if len(cmd.strip()) == 0:
+                    is_empty = True
+                    if history is not None:
+                        history.prompt = self.telnet_prompt
+                    continue
+                is_empty = False
+                # SEND COMMAND
+                output = self.send_cmd(cmd, timeout=timeout, stream=True)
+                if history is not None:
+                    history.prompt = self.telnet_prompt
+                if not (history is None or output is None) and "Shell: for hints type help." not in output:   # History: Beta feature
+                    history.add_history(cmd)
+                # OUTPUT HANDLING
+                if 'Bye!' in str(output):
+                    break
+                if output is None:
+                    print("Exiting... client disconnected")
+                    break
+            except KeyboardInterrupt:
+                print("Exiting...")
                 break
+        if history is not None:                                         # History: Beta feature
+            history.save_history()
         self.close()
 
     def dbg_print(self, msg, end='\n'):
@@ -325,8 +396,9 @@ class micrOSClient:
             verdict.append(console_msg)
             print(f"===>\t\t{console_msg}")
         self.close()
-        verdict.append(f"SINGLE CONNECTION LOAD TEST X{cnt}, AVERAGE REPLY TIME: {round(delta_t_all/cnt, 3)} sec\n")
-        return verdict
+        delta_t_result = round(delta_t_all / cnt, 3)
+        verdict.append(f"SINGLE CONNECTION LOAD TEST X{cnt}, AVERAGE REPLY TIME: {delta_t_result} sec\n")
+        return verdict, delta_t_result
 
     def __del__(self):
         if self.dbg and self.avg_reply[1] > 0:
@@ -355,9 +427,10 @@ def micros_connection_metrics(address):
             print(f"\t\t{_console_msg}")
             all_reply.append(_console_msg)
         success_rate = int(round(_success / cnt, 2) * 100)
-        all_reply.append(f"MULTI CONNECTION LOAD TEST X{cnt}, AVERAGE REPLY TIME: {round(_all_delta_t/cnt, 3)}s, "
-                         f"SERVER AVAILABILITY: {success_rate}% ({round(_all_delta_t/_success, 3)}s)")
-        return all_reply
+        delta_t_result = round(_all_delta_t/cnt, 3)
+        all_reply.append(f"MULTI CONNECTION LOAD TEST X{cnt}, AVERAGE REPLY TIME: {delta_t_result}s, "
+                         f"SERVER AVAILABILITY: {success_rate}% ({int((_all_delta_t/_success)*1000)} ms)")
+        return all_reply, delta_t_result
 
     # ---------------------------------------------------- #
     high_level_verdict = []
@@ -365,12 +438,12 @@ def micros_connection_metrics(address):
     # [1] Create micrOSClient object + Run LOAD tests
     com_obj = micrOSClient(host=address, port=9008, pwd="ADmin123", dbg=True)
     # [1.1] Run load test in one connection
-    verdict_list = com_obj.load_test()
+    verdict_list, delta_t_single_session = com_obj.load_test()
     com_obj.close()
     high_level_verdict.append(verdict_list[-1])
 
     # [2] Run multi connection load test - reconnect - raw connection (without retry)
-    verdict_multi = multi_conn_load(address)
+    verdict_multi, delta_t_multi_session = multi_conn_load(address)
     high_level_verdict.append((verdict_multi[-1]))
 
     ############################################################################
@@ -382,7 +455,7 @@ def micros_connection_metrics(address):
     for k in verdict_multi:
         print(f"\t{k}")
 
-    return high_level_verdict
+    return high_level_verdict, delta_t_single_session, delta_t_multi_session
 
 
 if __name__ == "__main__":
@@ -416,7 +489,7 @@ if __name__ == "__main__":
     print(f"noconf out: {noconf_mode}")
     if force_close: com_obj.close()
 
-    verdict = micros_connection_metrics(address=address)
+    verdict, delta_t_single, delta_t_multi = micros_connection_metrics(address=address)
     for k in verdict:
         print(f"+\t\t{k}")
 

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

@@ -66,8 +66,11 @@ def install_package(name, additional_pip_param=None):
             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}")
-            # Support brew installed python
-            if "This environment is externally managed" in out:
+            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])

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:
@@ -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
@@ -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 = 6        # 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']