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

toolkit/MicrOSDevEnv.py

@@ -35,13 +35,13 @@ class MicrOSDevTool(OTA, USB):
     #####################################################
     #                    DevEnv METHODS                 #
     #####################################################
-    def precompile_micros(self):
-        micros_dev_env = Compile.is_mpycross_available()
+    def precompile_micros(self, cleanup=True):
+        micros_dev_env = Compile().is_mpycross_available()
         if not micros_dev_env:
             self.console("SKIP PRECOMPILE - DEV ENV INACTIVE\n\t-> mpy-cross not available", state='warn')
             return True
         self.console("PRECOMPILE - DEV ENV ACTIVE: mpy-cross available", state='ok')
-        state = super(MicrOSDevTool, self).precompile_micros()
+        state = super(MicrOSDevTool, self).precompile_micros(cleanup)
         # Drops Segmentation fault: 11 error: simulator doc gen... TODO
         self.LM_functions_static_dump_gen()
         return state
@@ -62,8 +62,16 @@ class MicrOSDevTool(OTA, USB):
                 if f.endswith('.json'):
                     continue
                 f_path = os.path.join(self.micrOS_dir_path, f)
-                self.console("[SIM] Copy micrOS resources: {} -> {}".format(f_path, self.micros_sim_workspace))
-                LocalMachine.FileHandler().copy(f_path, self.micros_sim_workspace)
+                if f.startswith("_") or f.startswith("."):
+                    # SKIP files startswith `_` and `.`
+                    continue
+                _, f_type = LocalMachine.FileHandler.path_is_exists(f_path)
+                target_dir = self.micros_sim_workspace
+                if f_type == "d":
+                    target_dir = os.path.join(self.micros_sim_workspace, f)
+                self.console(f"[SIM] Copy micrOS resources: {f_path} -> {target_dir}")
+                if not LocalMachine.FileHandler().copy(f_path, target_dir):
+                    self.console(f"[ERROR] Failed to copy: {f_path}")
 
             if prepare_only:
                 # In case of automatic node_conf creation
@@ -128,26 +136,34 @@ class MicrOSDevTool(OTA, USB):
             self.console("[ERROR] micrOS SIM\n{}".format(e))
         workdir_handler.popd()
 
-    def LM_functions_static_dump_gen(self):
-        """
-        Generate static module-function provider json description: sfuncman.json
-        [!] name dependency with micrOS internal manual provider
-        """
-
-        if not os.path.isdir(self.sfuncman_output_path):
-            self.console('DOC GEN DISABLED', state="WARN")
-            return
-
-        repo_version = self.get_micros_version_from_repo()
-        static_help_json_path = os.path.join(self.sfuncman_output_path, 'sfuncman_{}.json'.format(repo_version))
-        static_help_html_path = os.path.join(self.sfuncman_output_path, 'sfuncman.html')
+    def _build_doc_load_module_structure(self):
+
+        def _is_private_func(_line):
+            nonlocal decorator, line
+            if 'def ' in line and 'def _' not in line:
+                if "async" in line and decorator is not None and "@micro_task" in decorator:
+                    # Enable (adjust) async task method with publish_micro_task decorator
+                    line = line.replace("async", "").strip()
+                    return False
+                if '(self' in line or '(cls' in _line or (decorator is not None and "staticmethod" in decorator):
+                    # Ignore class methods
+                    return True
+                return False
+            # Ignore non functions, and hidden functions (starts with _)
+            return True
 
         # [PARSING] Collect Load Module function structure buffer
-        modules_to_doc = (i.split('.')[0] for i in LocalMachine.FileHandler.list_dir(self.micrOS_dir_path) if
-                          i.startswith('LM_') and (i.endswith('.py')))
+        modules_sim_path = os.path.join(self.micros_sim_workspace, "modules")
+        if LocalMachine.FileHandler.path_is_exists(modules_sim_path):
+            modules_path = modules_sim_path
+        else:
+            modules_path = os.path.join(self.micrOS_dir_path, "modules")
+        self.console(f"[DOC-GEN] INPUT MODULES PATH: {modules_path}")
+        modules_to_doc = [i.split('.')[0] for i in LocalMachine.FileHandler.list_dir(modules_path) if
+                          i.startswith('LM_') and (i.endswith('.py'))]
         module_function_dict = {}
         for LM in modules_to_doc:
-            LMpath = '{}/{}.py'.format(self.micrOS_dir_path, LM)
+            LMpath = '{}/{}.py'.format(modules_path, LM)
             try:
                 module_name = LM.replace('LM_', '')
                 module_function_dict[module_name] = {}
@@ -157,29 +173,66 @@ class MicrOSDevTool(OTA, USB):
                         line = f.readline()
                         if not line:
                             break
-                        if 'def ' in line and 'def _' not in line:
-                            if '(self' in line or '(cls' in line or (decorator is not None and "staticmethod" in decorator):
-                                continue
-                            # Gen proper func name
-                            command = '{}'.format(line.split(')')[0]).replace("def", '').strip()
-                            command = command.replace('(', ' ') \
-                                .replace(',', '') \
-                                .replace('msgobj=None', '') \
-                                .replace('force=True', '')
-                            func = command.strip().split()[0]
-                            param = ' '.join(command.strip().split()[1:])
-                            # Save record
-                            if module_function_dict[module_name].get(func, None) is None:
-                                module_function_dict[module_name][func] = {}
-                            module_function_dict[module_name][func]['param(s)'] = param if len(param) > 0 else ""
-                        elif line.strip().startswith("@"):
-                            decorator = line.strip()
-                        else:
-                            decorator = None
+                        if _is_private_func(line):
+                            if line.strip().startswith("@"):
+                                decorator = line.strip()
+                            else:
+                                decorator = None
+                            continue
+
+                        # Gen proper func name
+                        command = '{}'.format(line.split(')')[0]).replace("def", '').strip()
+                        command = command.replace('(', ' ') \
+                            .replace(',', '') \
+                            .replace('msgobj=None', '') \
+                            .replace('force=True', '')
+                        func = command.strip().split()[0]
+                        param = ' '.join(command.strip().split()[1:])
+                        # Save record
+                        if module_function_dict[module_name].get(func, None) is None:
+                            module_function_dict[module_name][func] = {}
+                        module_function_dict[module_name][func]['param(s)'] = param if len(param) > 0 else ""
+
                 # Create / update module data fields
-                module_function_dict[module_name]['img'] = f"https://github.com/BxNxM/micrOS/blob/master/media/lms/{module_name}.png?raw=true"
+                module_function_dict[module_name][
+                    'img'] = f"https://github.com/BxNxM/micrOS/blob/master/media/lms/{module_name}.png?raw=true"
             except Exception as e:
                 self.console("STATIC micrOS HELP GEN: LM [{}] PARSER ERROR: {}".format(LM, e))
+        self.console(f"[DOC-GEN] Detected modules: {module_function_dict.keys()}")
+        return module_function_dict
+
+    def LM_functions_static_dump_gen(self):
+        """
+        Generate static module-function provider json description: sfuncman.json
+        [!] name dependency with micrOS internal manual provider
+        """
+
+        def _my_json_to_html(mod_func_dict):
+            import json2html
+            table_attributes = 'border="1" cellspacing="1" cellpadding="5" width="80%"'
+
+            sorted_modules_w_data = dict(sorted(mod_func_dict.items(), key=lambda item: item[0].lower()))
+            module_shortcuts = ' | '.join(
+                f'<a href="#{mod_name.replace(" ", "_")}">{mod_name}</a>'
+                for mod_name in sorted_modules_w_data)
+            html_tables = module_shortcuts + "<br><hr><br>"
+            for key, value in sorted_modules_w_data.items():
+                anchor = key.replace(" ", "_")  # Replace spaces with underscores for a valid anchor
+                html_tables += f'\n<br><br>\n<h2 id="{anchor}"><a href="#{anchor}">{key}</a></h2>\n'
+                html_tables += json2html.json2html.convert(json=value,
+                                                           table_attributes=table_attributes,
+                                                           clubbing=True,
+                                                           escape=False,
+                                                           encode=False)
+            return html_tables
+
+        if not os.path.isdir(self.sfuncman_output_path):
+            self.console('DOC GEN DISABLED', state="WARN")
+            return
+
+        repo_version = self.get_micros_version_from_repo()
+        static_help_json_path = os.path.join(self.sfuncman_output_path, 'sfuncman_{}.json'.format(repo_version))
+        static_help_html_path = os.path.join(self.sfuncman_output_path, 'sfuncman.html')
 
         # Prepare (update simulator workspace)
         self.simulator(prepare_only=True)
@@ -188,6 +241,7 @@ class MicrOSDevTool(OTA, USB):
         import simulator
         sim_proc = simulator.micrOSIM(doc_resolve=True)
         # Generate function doc-strings and pinmap info
+        module_function_dict = self._build_doc_load_module_structure()
         _out = sim_proc.gen_lm_doc_json_html(module_function_dict)
         if _out is None:
             self.console("#########################", state='ERR')
@@ -195,10 +249,15 @@ class MicrOSDevTool(OTA, USB):
             self.console("# -[micrOSIM][DOC ERR]- #", state='ERR')
             self.console("#########################", state='ERR')
             module_function_dict_html = module_function_dict
+            module_function_dict_ext = {}
+            module_function_dict_html_ext = {}
         else:
             # Unpack output
-            module_function_dict, module_function_dict_html = _out
+            (module_function_dict, module_function_dict_html,
+             module_function_dict_ext, module_function_dict_html_ext) = _out
 
+        # Merge built-in and external packages at json dco level (unified document) - external modules has annotation by default
+        module_function_dict.update(module_function_dict_ext)
         hardcoded_manual = {"task": {"list": {"doc": "list micrOS tasks by taskID", "param(s)": ""},
                                      "kill": {"doc": "kill / stop micrOS task", "param(s)": "taskID"},
                                      "img": "https://github.com/BxNxM/micrOS/blob/master/media/lms/tasks.png?raw=true"}
@@ -214,12 +273,10 @@ class MicrOSDevTool(OTA, USB):
         _url = hardcoded_manual["task"]["img"]
         hardcoded_manual['task']['img'] = f'<img src="{_url}" alt="tasks" height=150>'
         module_function_dict_html.update(hardcoded_manual)
-        module_function_json = json.dumps(module_function_dict_html, indent=4)
-        import json2html
-        table_attributes = 'border="1" cellspacing="1" cellpadding="5" width="80%"'
-        html_table = json2html.json2html.convert(json=module_function_json,
-                                                 table_attributes=table_attributes,
-                                                 clubbing=True, escape=False, encode=False)
+        html_tables = _my_json_to_html(module_function_dict_html)
+        html_tables_ext = _my_json_to_html(module_function_dict_html_ext)
+        if len(html_tables_ext) > 0:
+            html_tables_ext = '<br><h2 id="external-modules"> External modules (packages).:</h2>' + html_tables_ext
 
         # http://corelangs.com/css/table/tablecolor.html
         # http://corelangs.com/css/table/tablecolor.html
@@ -253,25 +310,38 @@ micrOS Load Modules
 </p>
 
 <h2>
-Logical pin names aka pin map
+microIO Pin-Mapping (names to integers)
 </h2>
     <b> Multi-platform pinmap IO handling feature - resolve pin number by name (tag)<br>
     <b>[i] Use 'module_name pinmap()' function to get pins on a runtime system (micrOS shell) and start DIY</b>
 <ul>
-  <li><a href="https://github.com/BxNxM/micrOS/blob/master/micrOS/source/IO_esp32.py" target="_blank">esp32</a></li>
-  <li><a href="https://github.com/BxNxM/micrOS/blob/master/micrOS/source/IO_esp32s3.py" target="_blank">esp32s3</a></li>
-  <li><a href="https://github.com/BxNxM/micrOS/blob/master/micrOS/source/IO_m5stamp.py" target="_blank">m5stamp</a></li>
-  <li><a href="https://github.com/BxNxM/micrOS/blob/master/micrOS/source/IO_tinypico.py" target="_blank">tinypico</a></li>
-  <li><a href="https://github.com/BxNxM/micrOS/blob/master/micrOS/source/IO_esp32c3.py" target="_blank">esp32c3</a></li>
-  <li><a href="https://github.com/BxNxM/micrOS/blob/master/micrOS/source/IO_esp32s2.py" target="_blank">esp32s2</a></li>
-  <li><a href="https://github.com/BxNxM/micrOS/blob/master/micrOS/source/IO_rp2.py" target="_blank">rp2 (experimental)</a></li>
+  <li><a href="https://github.com/BxNxM/micrOS/blob/master/micrOS/source/modules/IO_m5stamp.py" target="_blank">m5stamp</a></li>
+  <li><a href="https://github.com/BxNxM/micrOS/blob/master/micrOS/source/modules/IO_tinypico.py" target="_blank">tinypico</a></li>
+  <li><a href="https://github.com/BxNxM/micrOS/blob/master/micrOS/source/modules/IO_s3matrix.py" target="_blank">s3matrix</a></li>
+
+  <li><a href="https://github.com/BxNxM/micrOS/blob/master/micrOS/source/modules/IO_esp32.py" target="_blank">esp32</a></li>
+  <li><a href="https://github.com/BxNxM/micrOS/blob/master/micrOS/source/modules/IO_esp32s3.py" target="_blank">esp32s3</a></li>
+  <li><a href="https://github.com/BxNxM/micrOS/blob/master/micrOS/source/modules/IO_esp32c3.py" target="_blank">esp32c3</a></li>
+  <li><a href="https://github.com/BxNxM/micrOS/blob/master/micrOS/source/modules/IO_esp32c6.py" target="_blank">esp32c6</a></li>
+  <li><a href="https://github.com/BxNxM/micrOS/blob/master/micrOS/source/modules/IO_esp32s2.py" target="_blank">esp32s2</a></li>
+  <li><a href="https://github.com/BxNxM/micrOS/blob/master/micrOS/source/modules/IO_rp2.py" target="_blank">rp2 (experimental)</a></li>
 </ul>
 
+<h2>External package support</h2>
+<a href="#external-modules">Go to external packages</a>
+&nbsp;|&nbsp;
+<a href="https://github.com/BxNxM/micrOSPackages" target="_blank">
+  View Packages on GitHub
+</a>
+<br>
+
+<h2> Built-in control modules for various peripheries.: </h2>
+
 """
         html_body_end = """</body>
 </html>"""
 
-        html_page = html_body_start + html_table + html_body_end
+        html_page = html_body_start + html_tables + html_tables_ext + html_body_end
         # Write html to file
         with open(static_help_html_path, 'w') as f:
             f.write(html_page)

toolkit/WebRepl.py

@@ -0,0 +1,73 @@
+import sys
+import os
+
+MYDIR = os.path.dirname(__file__)
+print("Module [WebRepl] path: {} __package__: {} __name__: {} __file__: {}".format(
+    sys.path[0], __package__, __name__, MYDIR))
+try:
+    from .lib.TerminalColors import Colors
+    from .lib.LocalMachine import FileHandler, CommandHandler, SimplePopPushd
+    from .socketClient import ConnectionData
+except Exception as e:
+    print("Import warning __name__:{}: {}".format(__name__, e))
+    from lib.TerminalColors import Colors
+    from lib.LocalMachine import FileHandler, CommandHandler, SimplePopPushd
+    from socketClient import ConnectionData
+
+WEBREPL_DIR = os.path.join(MYDIR, "workspace/webrepl")
+MAKE_HTML_WEBPAGE_PATH = os.path.join(WEBREPL_DIR, "make_html_js.py")
+WEBREPL_WEBPAGE_PATH = os.path.join(WEBREPL_DIR, "webrepl.html")
+
+def init_webrepl_frontend():
+    webrepldir_handler = SimplePopPushd()
+    webrepldir_handler.pushd(WEBREPL_DIR)
+
+    is_exists, ftype = FileHandler.path_is_exists(MAKE_HTML_WEBPAGE_PATH)
+    if is_exists and ftype == 'f':
+        print("RUN webrepl/make_html_js.py")
+        exitcode, _, stderr = CommandHandler.run_command(f"{sys.executable} {MAKE_HTML_WEBPAGE_PATH}", shell=True)
+        webrepldir_handler.popd()
+        if exitcode == 0:
+            return True
+        print(f"Cannot init {MAKE_HTML_WEBPAGE_PATH}: {stderr}")
+        return False
+    print(f"WEBREPL MAKE MISSING: {MAKE_HTML_WEBPAGE_PATH}")
+    return False
+
+def open_webrepl_webpage(address=None, port=8266):
+    # file:///Users/usrname/micrOS/micrOS/toolkit/workspace/webrepl/webrepl.html#10.0.1.76:8266
+    fuid = ''
+    if address is None:
+        try:
+            address, _, fuid, _ = ConnectionData.select_device()
+        except KeyboardInterrupt:
+            address = None
+
+    device = "" if address is None else f"#{address}:{port}"
+    webrepl_html = f"file://{WEBREPL_WEBPAGE_PATH}{device}"
+    is_exists, ftype = FileHandler.path_is_exists(WEBREPL_WEBPAGE_PATH)
+    if is_exists and ftype == "f":
+        print(f"OPEN {fuid} webrepl {webrepl_html}")
+        if sys.platform == "darwin":
+            CommandHandler.run_command(f"open '{webrepl_html}'", shell=True)
+        elif sys.platform == "win32":
+            CommandHandler.run_command(f"start {webrepl_html}", shell=True)
+        elif sys.platform == "linux":
+            CommandHandler.run_command(f"xdg-open {webrepl_html}", shell=True)
+        else:
+            print("Unsupported OS")
+            return False
+        return True
+    print(f"{WEBREPL_WEBPAGE_PATH} not exists.")
+    return False
+
+
+def open_webrepl():
+    state = init_webrepl_frontend()
+    if state:
+        open_webrepl_webpage()
+
+
+
+if __name__ == "__main__":
+    open_webrepl()

toolkit/dashboard_apps/BackupRestore.py

@@ -5,27 +5,17 @@ import sys
 import json
 MYPATH = os.path.dirname(os.path.abspath(__file__))
 BACKUP_DIR = os.path.join(MYPATH, "../user_data/node_config_archive/")
-sys.path.append(os.path.dirname(MYPATH))
-import socketClient
 sys.path.append(os.path.join(MYPATH, '../lib/'))
 from TerminalColors import Colors
 
-# FILL OUT
-DEVICE = 'node01'
-PASSWD = None
+try:
+    from ._app_base import AppBase
+except:
+    from _app_base import AppBase
 
-def base_cmd():
-    if PASSWD is None:
-        return ['--dev', DEVICE]
-    return ['--dev', DEVICE, '--password', PASSWD]
+CLIENT = None
 
 
-def run_command(cmd):
-    # EDIT YOUR COMMAND
-    args = base_cmd() + cmd
-    status, answer = socketClient.run(args)
-    return status, answer
-
 ###########################################################
 def _value_type(value):
     value = value.strip()
@@ -42,15 +32,16 @@ def _value_type(value):
 
 
 def backup():
-    print(f"\tBackup name format: {DEVICE}-<tag>-node_config.json")
-    print(f"\t\t tag is optional (press simply enter): {DEVICE}-node_config.json")
-    backup_tag = input(f"\tFill backup tag for {DEVICE}: ").strip()
+    device = CLIENT.get_device()
+    print(f"\tBackup name format: {device}-<tag>-node_config.json")
+    print(f"\t\t tag is optional (press simply enter): {device}-node_config.json")
+    backup_tag = input(f"\tFill backup tag for {device}: ").strip()
     backup_tag = "" if len(backup_tag) == 0 else f"-{backup_tag}"
-    backup_name = f"{DEVICE}{backup_tag}-node_config.json"
+    backup_name = f"{device}{backup_tag}-node_config.json"
     backup_path = os.path.join(BACKUP_DIR, backup_name)
     print(f"\tBackup path: {backup_path}")
 
-    status, answer = run_command(["conf", "dump"])
+    status, answer = CLIENT.run(["conf", "dump"])
     if status:
         configuration = {line.split(":")[0].strip(): _value_type(':'.join(line.split(":")[1:])) for line in answer.strip().split("\n") if ":" in line}
         with open(backup_path, 'w') as f:
@@ -61,7 +52,8 @@ def backup():
 
 
 def restore():
-    print(f"\tRestore backup for: {DEVICE}")
+    device = CLIENT.get_device()
+    print(f"\tRestore backup for: {device}")
     diff_config = {}
 
     # SELECT AND LOAD CONFIG BACKUP
@@ -81,7 +73,7 @@ def restore():
     print(f"BACKUP CONFIG DICT:\n{backup_dict}")
 
     # LOAD LIVE DEVICE CONFIG - create config diff
-    status, answer = run_command(["conf", "dump"])
+    status, answer = CLIENT.run(["conf", "dump"])
     if not status:
         return f"Cannot load live device config"
     live_configuration = {line.split(":")[0].strip(): _value_type(':'.join(line.split(":")[1:])) for line in answer.strip().split("\n") if ":" in line}
@@ -103,20 +95,16 @@ def restore():
         print(f"{Colors.WARN}SKIP restore...{Colors.NC}")
         return
 
-    print(f"PACKAGE CONFIG DIFFS...{DEVICE}")
+    print(f"PACKAGE CONFIG DIFFS...{device}")
     conf_cmd_list = ["conf"]
     for key, value in diff_config.items():
         print(f"\tADD {key} : {value}")
         conf_cmd_list.append(f"{key} {value}")
     conf_cmd_list.append("reboot")
 
-    verify = input(f"{Colors.WARN}This is BETA feature, are you sure?{Colors.NC} [YY/n]: ")
-    if verify != "YY":
-        print(f"{Colors.WARN}SKIP restore...{Colors.NC}")
-        return
     # Restore
-    print(f"APPLY CONFIG DIFFS...{DEVICE}")
-    status, answer = run_command(conf_cmd_list)
+    print(f"APPLY CONFIG DIFFS...{device}")
+    status, answer = CLIENT.run(conf_cmd_list)
     if status:
         print(f"{Colors.OKGREEN}Backup was successfully restored:{Colors.NC} {backup_path}\nRebooting...")
     else:
@@ -148,15 +136,12 @@ def app(devfid=None, pwd=None):
         send command(s) over socket connection [socketClient.run(args)]
         list load module commands and send in single connection
     """
-    global DEVICE, PASSWD
-    if devfid is not None:
-        DEVICE = devfid
-    if pwd is not None:
-        PASSWD = pwd
+    global CLIENT
+    CLIENT = AppBase(device=devfid, password=pwd)
 
     print(f"{Colors.WARN}Backup & Restore management{Colors.NC}\n")
     while True:
-        print(f"{Colors.UNDERLINE}Operations on {DEVICE}{Colors.NC}")
+        print(f"{Colors.UNDERLINE}Operations on {CLIENT.get_device()}{Colors.NC}")
         print("\t[1]  Backup")
         print("\t[2]  Restore")
         print("\t[3]  Delete backups")

toolkit/dashboard_apps/CCTDemo.py

@@ -2,38 +2,33 @@
 
 import os
 import sys
-import time
 MYPATH = os.path.dirname(os.path.abspath(__file__))
-sys.path.append(os.path.dirname(MYPATH))
-import socketClient
 sys.path.append(os.path.join(MYPATH, '../lib/'))
-from TerminalColors import Colors
 
-# FILL OUT
-DEVICE = 'node01'
+try:
+    from ._app_base import AppBase
+except:
+    from _app_base import AppBase
 
+CLIENT = None
 
-def base_cmd():
-    return ['--dev', DEVICE]
 
-
-def app(devfid=None):
+def app(devfid=None, pwd=None):
     """
     devfid: selected device input
         send command(s) over socket connection [socketClient.run(args)]
         list load module commands and send in single connection
     """
-    global DEVICE
-    if devfid is not None:
-        DEVICE = devfid
+    global CLIENT
+    CLIENT = AppBase(device=devfid, password=pwd)
 
-    status, answer = socketClient.run(base_cmd() + ['cct white 50 400',
+    status, answer = CLIENT.run(['cct white 50 400',
                                                     'cct brightness 50'])
-    status, answer = socketClient.run(base_cmd() + ['cct brightness 100', 'cct brightness 20',
+    status, answer = CLIENT.run(['cct brightness 100', 'cct brightness 20',
                                                     'cct brightness 60'])
-    status, answer = socketClient.run(base_cmd() + ['cct white 400 50',
+    status, answer = CLIENT.run(['cct white 400 50',
                                                     'cct brightness 100', 'cct brightness 20'])
-    status, answer = socketClient.run(base_cmd() + ['cct white 600 700',
+    status, answer = CLIENT.run(['cct white 600 700',
                                                     'cct white 50 300'])
 
 

toolkit/dashboard_apps/CCTTest.py

@@ -5,18 +5,15 @@ import sys
 import time
 import random
 MYPATH = os.path.dirname(os.path.abspath(__file__))
-sys.path.append(os.path.dirname(MYPATH))
-import socketClient
-import time
 sys.path.append(os.path.join(MYPATH, '../lib/'))
 from TerminalColors import Colors
 
-# FILL OUT
-DEVICE = 'node01'
-
+try:
+    from ._app_base import AppBase
+except:
+    from _app_base import AppBase
 
-def base_cmd():
-    return ['--dev', DEVICE]
+CLIENT = None
 
 
 def test_random_colors(test_len=8, smooth=False):
@@ -30,12 +27,12 @@ def test_random_colors(test_len=8, smooth=False):
 
     # Generate command
     cmd_list_str = " <a> ".join(["{} {} {} {} >json".format(main_function, k[0], k[1], smooth) for k in cct_list])
-    args = base_cmd() + [cmd_list_str]
+    args = [cmd_list_str]
     print("{} Generated command {} - multi message single connection single connection: {} cold warm {}\n{}".format(Colors.HEADER, Colors.NC, main_function, smooth, args))
 
     start_t = time.time()
     # SEND MESSSAGE OVER micrOS client
-    status, answer = socketClient.run(args)
+    status, answer = CLIENT.run(args)
     delta_t = round((time.time() - start_t)/test_len, 1)
 
     #Evaluate last message
@@ -51,14 +48,14 @@ def test_random_colors(test_len=8, smooth=False):
 
 def test_toogle():
     main_function = 'cct toggle'
-    args_on = base_cmd() + [f'{main_function} True >json']
-    args_toggle = base_cmd() + [f'{main_function} >json']
+    args_on = [f'{main_function} True >json']
+    args_toggle = [f'{main_function} >json']
 
     # SEND MESSSAGE OVER micrOS client
-    status, answer = socketClient.run(args_on)
+    status, answer = CLIENT.run(args_on)
     if status and '"S": 1' in answer:
         # SEND MESSSAGE OVER micrOS client
-        status, answer = socketClient.run(args_toggle)
+        status, answer = CLIENT.run(args_toggle)
         if status and '"S": 0' in answer:
             return True, '{} works {}OK{}'.format(main_function, Colors.OK, Colors.NC)
     return False, '{} not works {}NOK{}: {}'.format(main_function, Colors.ERR, Colors.NC, answer)
@@ -66,24 +63,23 @@ def test_toogle():
 
 def test_brightness():
     main_function = 'cct brightness'
-    args_10 = base_cmd() + [f'{main_function} 10 >json']
-    args_50 = base_cmd() + [f'{main_function} 50 >json']
-    args_actual_br = base_cmd() + [f'{main_function} >json']
+    args_10 = [f'{main_function} 10 >json']
+    args_50 = [f'{main_function} 50 >json']
+    args_actual_br = [f'{main_function} >json']
 
-    status, answer = socketClient.run(args_10)
+    status, answer = CLIENT.run(args_10)
     if status:
-        status, answer = socketClient.run(args_50)
+        status, answer = CLIENT.run(args_50)
         if status:
-            status, answer = socketClient.run(args_actual_br)
+            status, answer = CLIENT.run(args_actual_br)
             if status and "50.0 %" in answer:
                 return True, "{} function {}OK{} (50.0 % == {})".format(main_function, Colors.OK, Colors.NC, answer)
     return False, "{} function {}NOK{} (50.0 % == {})".format(main_function, Colors.ERR, Colors.NC, answer)
 
 
-def app(devfid=None):
-    global DEVICE
-    if devfid is not None:
-        DEVICE = devfid
+def app(devfid=None, pwd=None):
+    global CLIENT
+    CLIENT = AppBase(device=devfid, password=pwd)
 
     test_pool = { 'Color change test': test_random_colors(test_len=8, smooth=False),
                   'Color smooth test': test_random_colors(test_len=4, smooth=True),

toolkit/dashboard_apps/CamStream.py

@@ -2,14 +2,10 @@ import sys, os
 import subprocess
 MYPATH = os.path.dirname(os.path.abspath(__file__))
 
-DEVICE = "node01"
 
-def app(devfid=None):
+def app(devfid=None, pwd=None):
     """
     Wrapper function to start subprocess plotting... (threading limitation)
     """
-    global DEVICE
-    if devfid is not None:
-        DEVICE = devfid
-    result = subprocess.run([f'{sys.executable}', os.path.join(MYPATH, '_capture.py'), DEVICE])
+    result = subprocess.run([f'{sys.executable}', os.path.join(MYPATH, '_capture.py'), devfid])
     print(result)