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

toolkit/Gateway.py

@@ -17,7 +17,7 @@ try:
     from flask_basicauth import BasicAuth
     from datetime import datetime
 except Exception as e:
-    print("Cannot load flask_basicauth->BasicAuth")
+    print("[GW-AUTH] Cannot load flask_basicauth->BasicAuth")
     BasicAuth = None
 
 try:
@@ -103,10 +103,10 @@ if BasicAuth is not None and (__rest_usr_name and __rest_usr_pwd):
             except Exception as e:
                 response = {"ok": False, "Country": str(e)}
             if response["ok"] and response["Country"] in enabled_country_codes:
-                print(f"\t[GW-AUTH] EXTERNAL LOGIN: ALLOW ({enabled_country_codes}) EXTERNAL IP FROM: {response}")
+                print(f"\t[GW-AUTH] EXTERNAL LOGIN: ALLOW ({enabled_country_codes}) EXTERNAL IP ({ip_address}) FROM: {response}")
                 ADDRESS_CACHE[ip_address] = (True, response)
                 return True, response
-            print(f"\t[GW-AUTH] EXTERNAL LOGIN: DENY ({enabled_country_codes}) EXTERNAL IP FROM: {response}")
+            print(f"\t[GW-AUTH] EXTERNAL LOGIN: DENY - EXTERNAL IP ({ip_address}) FROM: {response}")
             ADDRESS_CACHE[ip_address] = (False, response)
             return False, response
         # Return cached value:
@@ -154,7 +154,7 @@ class Hello(Resource):
 
 class SendCmd(Resource):
     """
-    http://127.0.0.1:5000/sendcmd/micr240ac4f679e8OS/rgb+toggle
+    http://127.0.0.1:5005/sendcmd/micr240ac4f679e8OS/rgb+toggle
         {
           "cmd": [
             "rgb",
@@ -211,7 +211,7 @@ class ListDevices(Resource):
 
     def sort_devices(self):
         device_struct = socketClient.ConnectionData.list_devices()
-        online_devices = socketClient.ConnectionData.nodes_status()
+        online_devices = socketClient.ConnectionData.nodes_status(feature_stat=False)
         filtered_devices = {"online": {}, "offline": {}}
         for uid, data in device_struct.items():
             if data[0] in online_devices:
@@ -554,9 +554,9 @@ class ForwardImg(Resource):
         for devid, dev_conn_data in ListDevices.DEVICE_CACHE['online'].items():
             # IP, PORT, FID
             device = dev_conn_data[2]
-            response = SendCmd.runcmd(device, 'lmpacman module')['response']
+            response = SendCmd.runcmd(device, 'modules')['response']
             print(f"\n\n{response}\n\n")
-            if 'LM_OV2640' in response:
+            if 'OV2640' in response:
                 ForwardImg.CAM_DEVICES.add(device)
         return jsonify(list(ForwardImg.CAM_DEVICES))
 
@@ -621,11 +621,11 @@ api.add_resource(WebHook, '/webhooks', '/webhooks/<string:payload>', '/webhooks/
 
 def gateway(debug=True):
     global API_URL_CACHE
-    API_URL_CACHE = f"http://{my_local_ip()}:5000"
+    API_URL_CACHE = f"http://{my_local_ip()}:5005"
     print("\n############### START MICROS GATEWAY ###############")
     print("#             {}            #".format(API_URL_CACHE))
     print("####################################################\n")
-    app.run(debug=debug, use_reloader=debug, host='0.0.0.0', port=5000)     # host='0.0.0.0' automatic, manual: host=my_local_ip()
+    app.run(debug=debug, use_reloader=debug, host='0.0.0.0', port=5005)     # host='0.0.0.0' automatic, manual: host=my_local_ip()
 
 
 # driver function

toolkit/LM_to_compile.dat

@@ -11,8 +11,6 @@ LM_bme280.py
 LM_co2.py
 LM_dht11.py
 LM_light_sensor.py
-LM_L298N_DCmotor.py
-LM_intercon.py
 LM_tinyrgb.py
 LM_repair.py
 LM_buzzer.py
@@ -25,12 +23,22 @@ LM_cct.py
 LM_presence.py
 LM_telegram.py
 LM_oled_sh1106.py
-LM_lmpacman.py
+LM_pacman.py
 LM_aht10.py
 LM_rgbcct.py
 LM_OV2640.py
-LM_keychain.py
 LM_i2s_mic.py
 LM_rest.py
 LM_gameOfLife.py
 LM_ld2410.py
+LM_sound_event.py
+LM_trackball.py
+LM_oledui.py
+LM_haptic.py
+LM_distance.py
+LM_veml7700.py
+LM_neomatrix.py
+LM_L298N.py
+LM_cluster.py
+LM_fileserver.py
+LM_web.py

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,53 +136,103 @@ 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] = {}
                 with open(LMpath, 'r') as f:
+                    decorator = None
                     while True:
                         line = f.readline()
                         if not line:
                             break
-                        if 'def ' in line and 'def _' not in line:
-                            if '(self' in line or '(cls' in line:
-                                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 ""
+                        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)
@@ -183,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')
@@ -190,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"}
@@ -209,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
@@ -248,22 +310,38 @@ micrOS Load Modules
 </p>
 
 <h2>
-Logical pin names aka pin map
+microIO Pin-Mapping (names to integers)
 </h2>
-    <b> Implements hardware independent periphery handling in Load Modules.<br>
+    <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/LP_esp32.py" target="_blank">esp32</a></li>
-  <li><a href="https://github.com/BxNxM/micrOS/blob/master/micrOS/source/LP_esp32s2.py" target="_blank">esp32s2</a></li>
-  <li><a href="https://github.com/BxNxM/micrOS/blob/master/micrOS/source/LP_tinypico.py" target="_blank">tinypico</a></li>
-  <li><a href="https://github.com/BxNxM/micrOS/blob/master/micrOS/source/LP_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

@@ -0,0 +1,171 @@
+#!/usr/bin/env python3
+
+import os
+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.join(MYPATH, '../lib/'))
+from TerminalColors import Colors
+
+try:
+    from ._app_base import AppBase
+except:
+    from _app_base import AppBase
+
+CLIENT = None
+
+
+###########################################################
+def _value_type(value):
+    value = value.strip()
+    if value == "True":     # Bool
+        return True
+    if value == "False":    # Bool
+        return False
+    try:
+        value = int(value)  # integer
+        return value
+    except Exception:
+        pass
+    return value            # string
+
+
+def backup():
+    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_path = os.path.join(BACKUP_DIR, backup_name)
+    print(f"\tBackup path: {backup_path}")
+
+    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:
+            f.write(json.dumps(configuration, indent=4))
+    else:
+        print(f"{Colors.ERR} Cannot get node config:{Colors.NC} {status}: {answer}")
+    print(f"{Colors.OKGREEN}Backup was successfully saved:{Colors.NC} {backup_path}")
+
+
+def restore():
+    device = CLIENT.get_device()
+    print(f"\tRestore backup for: {device}")
+    diff_config = {}
+
+    # SELECT AND LOAD CONFIG BACKUP
+    backup_list = os.listdir(BACKUP_DIR)
+    for i, json_backup in enumerate(backup_list):
+        print(f"[{i}]  {json_backup}")
+    opt = input("Select backup number to restore: ")
+    try:
+        opt = int(opt)
+    except Exception as e:
+        print(f"{Colors.ERR}INVALID INDEX:{Colors.NC} {e}")
+        return
+    backup_path = os.path.join(BACKUP_DIR, backup_list[opt])
+    with open(backup_path, 'r') as f:
+        backup_dict = json.load(f)
+    print(f"SELECTED CONFIG: {backup_path}")
+    print(f"BACKUP CONFIG DICT:\n{backup_dict}")
+
+    # LOAD LIVE DEVICE CONFIG - create config diff
+    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}
+
+    for key, live_value in live_configuration.items():
+        if key in ("version", "devip", "hwuid", "version", "devfid"):   # IGNORE KEYS
+            continue
+        bckp_value = backup_dict.get(key, None)
+        if bckp_value is None or bckp_value == live_value:
+            continue
+        print(f"\tDIFF: {key} : {live_value} -> {bckp_value}")
+        diff_config[key] = bckp_value
+
+    if len(diff_config.keys()) == 0:
+        print(f"{Colors.OKGREEN}No diff in config - skip restore{Colors.NC}")
+        return
+    verify = input(f"{Colors.WARN}APPLY DIFFS?{Colors.NC} [Y/n]: ")
+    if verify != "Y":
+        print(f"{Colors.WARN}SKIP restore...{Colors.NC}")
+        return
+
+    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")
+
+    # Restore
+    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:
+        print(f"{Colors.ERR}Restore error:{Colors.NC} {status}: {answer}")
+
+
+
+def delete_backup():
+    backup_list = os.listdir(BACKUP_DIR)
+    for i, json_backup in enumerate(backup_list):
+        print(f"[{i}]  {json_backup}")
+    opt = input("Select backup number to delete: ")
+    try:
+        opt = int(opt)
+    except Exception as e:
+        print(f"{Colors.ERR}INVALID INDEX:{Colors.NC} {e}")
+        return
+    remove_path = os.path.join(BACKUP_DIR, backup_list[opt])
+    print(f"Remove: {remove_path}")
+    os.remove(remove_path)
+    print(f"{Colors.OKGREEN}Backup was successfully deleted{Colors.NC}")
+
+###########################################################
+
+
+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 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 {CLIENT.get_device()}{Colors.NC}")
+        print("\t[1]  Backup")
+        print("\t[2]  Restore")
+        print("\t[3]  Delete backups")
+        print("\t[4]  Exit")
+        opt = input(f"{Colors.BOLD}Select operation{Colors.NC}: ")
+        try:
+            opt = int(opt)
+        except Exception as e:
+            return f"{Colors.ERR}INVALID OPTION:{Colors.NC} {opt}: {e}"
+        if opt == 1:
+            print(f"{Colors.BOLD}=== BACKUP ==={Colors.NC}")
+            backup()
+        elif opt == 2:
+            print(f"{Colors.BOLD}=== RESTORE ==={Colors.NC}")
+            restore()
+        elif opt == 3:
+            print(f"{Colors.BOLD}=== DELETE ==={Colors.NC}")
+            delete_backup()
+        elif opt == 4:
+            break
+        else:
+            return f"{Colors.ERR}UNKNOWN OPTION:{Colors.NC} {opt}"
+    return f"{Colors.OKGREEN}Bye!{Colors.NC}"
+
+
+if __name__ == "__main__":
+    app()

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'])