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

micrOS/source/Config.py

@@ -12,20 +12,28 @@ Designed by Marcell Ban aka BxNxM
 #################################################################
 #                           IMPORTS                             #
 #################################################################
-from os import remove
+from re import search
 from json import load, dump
+from uos import remove
 from utime import sleep
-from Debug import DebugCfg, console_write, errlog_add
+from Debug import DebugCfg, console_write, syslog
+from Files import OSPath, path_join, is_file
+from uos import rename as move_file
 try:
     from microIO import set_pinmap
 except:
-    errlog_add("[ERR] LogicalPins import: set_pinmap")
+    syslog("[ERR] microIO import: set_pinmap")
     set_pinmap = None
 
 
 class Data:
-    # micrOS config path
-    CONFIG_PATH = "node_config.json"
+    """
+    Data class for managing configuration data.
+    """
+    __slots__ = []
+
+    CONFIG_NAME = "node_config.json"
+    CONFIG_PATH = path_join(OSPath.CONFIG, CONFIG_NAME)
     CONFIG_CACHE = {"version": "n/a",
                     "auth": False,
                     "staessid": "your_wifi_name",
@@ -58,21 +66,28 @@ class Data:
                     "irq4_trig": "n/a",
                     "irq_prell_ms": 300,
                     "boothook": "n/a",
-                    "aioqueue": 4,
+                    "aioqueue": 5,
                     "utc": +60,
                     "boostmd": True,
-                    "guimeta": "...",     # special "offloaded" key indicator
+                    "guimeta": "...",       # special "offloaded" key indicator
                     "cstmpmap": "n/a",
-                    "telegram": "n/a"}    # telegram bot token
+                    "espnow": False}
 
     @staticmethod
     def init():
+        # Migrate config from / to /config
+        if is_file(Data.CONFIG_NAME):
+            console_write(f"[CONF] Migrate {Data.CONFIG_NAME} to {Data.CONFIG_PATH}")
+            move_file(Data.CONFIG_NAME, Data.CONFIG_PATH)
         # Inject user config into template
         Data.__inject_default_conf()
         # [!!!] Init selected pinmap - default pinmap calculated by platform
-        if set_pinmap is not None:
-            pinmap = set_pinmap(Data.CONFIG_CACHE['cstmpmap'])
-            console_write(f"[PIN MAP] {pinmap}")
+        if callable(set_pinmap):
+            try:
+                pinmap = set_pinmap(Data.CONFIG_CACHE['cstmpmap'])
+                console_write(f"[PIN MAP] {pinmap}")
+            except Exception as e:
+                console_write(f"\n[PIN MAP] !!! SETUP ERROR !!!: {e}\n")
         # SET dbg based on config settings (inject user conf)
         DebugCfg.DEBUG = Data.CONFIG_CACHE['dbg']
         if DebugCfg.DEBUG:
@@ -89,12 +104,12 @@ class Data:
         liveconf = Data.read_cfg_file(nosafe=True)
         # Remove obsolete keys from conf
         try:
-            remove('cleanup.pds')       # Try to remove cleanup.pds (cleanup indicator by micrOSloader)
+            remove('.cleanup')       # Try to remove .cleanup (cleanup indicator by micrOSloader)
             console_write("[CONF] Purge obsolete keys")
             for key in (key for key in liveconf if key not in Data.CONFIG_CACHE):
                 liveconf.pop(key, None)
         except Exception:
-            console_write("[CONF] SKIP obsolete keys check (no cleanup.pds)")
+            console_write("[CONF] SKIP obsolete keys check (no .cleanup)")
         # Merge template to live conf (store active conf in Data.CONFIG_CACHE)
         Data.CONFIG_CACHE.update(liveconf)
         console_write("[CONF] User config injection done")
@@ -103,7 +118,7 @@ class Data:
             Data.write_cfg_file()
             console_write("[CONF] Save conf successful")
         except Exception as e:
-            errlog_add(f"[ERR] Save (__inject) conf failed: {e}")
+            syslog(f"[ERR] Save (__inject) conf failed: {e}")
         finally:
             del liveconf
 
@@ -121,7 +136,7 @@ class Data:
                 if nosafe:
                     break
                 sleep(0.2)
-                errlog_add(f'[ERR] read_cfg_file error: {e}')
+                syslog(f'[ERR] read_cfg_file error: {e}')
         # Return config cache
         return conf
 
@@ -134,7 +149,7 @@ class Data:
                     dump(Data.CONFIG_CACHE, f)
                 break
             except Exception as e:
-                errlog_add(f'[ERR] write_cfg_file {Data.CONFIG_PATH} (json): {e}')
+                syslog(f'[ERR] write_cfg_file {Data.CONFIG_PATH} (json): {e}')
             sleep(0.2)
         return True
 
@@ -143,20 +158,16 @@ class Data:
         value_in_cfg = Data.CONFIG_CACHE[key]
         try:
             if isinstance(value_in_cfg, bool):
-                del value_in_cfg
                 if str(value).lower() == 'true':
                     return True
                 if str(value).lower() == 'false':
                     return False
                 raise Exception("type_handler type handling error")
             if isinstance(value_in_cfg, str):
-                del value_in_cfg
                 return str(value)
             if isinstance(value_in_cfg, int):
-                del value_in_cfg
                 return int(value)
             if isinstance(value_in_cfg, float):
-                del value_in_cfg
                 return float(value)
         except Exception as e:
             console_write(f"Input value type error! {e}")
@@ -169,21 +180,37 @@ class Data:
         These kind of parameters are not cached in memory
         """
         # Write str value to file
+        offloaded_key = path_join(OSPath.CONFIG, f'.{key}.key')
         if isinstance(value, str) and key in Data.CONFIG_CACHE:
             try:
-                with open(f'.{key}.key', 'w') as f:
+                with open(offloaded_key, 'w') as f:
                     f.write(value)
                 return True
             except Exception:
                 return False
         # Read str value from file
         try:
-            with open(f'.{key}.key', 'r') as f:
+            with open(offloaded_key, 'r') as f:
                 return f.read().strip()
         except Exception:
             # Return default value if key not exists
             return 'n/a'
 
+    @staticmethod
+    def validate_pwd(password):
+        """
+        Validate appwd parameter
+        - webrepl password
+        - micrOS auth password (Shell/WebCli)
+        - wifi access point password
+        """
+        # Check password rules
+        if 4 <= len(password) <= 9:
+            if search(r"[A-Z]", password) and search(r"[a-z]", password):
+                if search(r"\d", password):
+                    return True, ''
+        return False, 'Password must include [0-9] both [a-z][A-Z] and length between 4-9 char.'
+
 
 #################################################################
 #                  CONFIGHANDLER  FUNCTIONS                     #
@@ -200,11 +227,14 @@ def cfgget(key=None):
             return Data.disk_keys(key)
         return val
     except Exception as e:
-        errlog_add(f'[ERR] cfgget {key} error: {e}')
+        syslog(f'[ERR] cfgget {key} error: {e}')
     return None
 
-
 def cfgput(key, value, type_check=False):
+    if key == 'appwd':
+        is_valid, verdict = Data.validate_pwd(value)
+        if not is_valid:
+            raise Exception(verdict)
     # Handle special "offloaded" keys
     if str(Data.CONFIG_CACHE.get(key, None)) == '...':
         return Data.disk_keys(key, value)
@@ -222,7 +252,7 @@ def cfgput(key, value, type_check=False):
         del value
         return True
     except Exception as e:
-        errlog_add(f'[ERR] cfgput {key} error: {e}')
+        syslog(f'[ERR] cfgput {key} error: {e}')
         return False
 
 #################################################################

micrOS/source/Debug.py

@@ -1,11 +1,18 @@
-import os
-from time import localtime
-from machine import Pin
+"""
+micrOS Console and Log write interface implementations.
+- with progress led feature, simple and custom
+    Designed by Marcell Ban aka BxNxM
+"""
 
+from machine import Pin
+try:
+    from Logger import syslog as logger_syslog
+except:
+    logger_syslog = None
 try:
-    from microIO import physical_pin, pinmap_dump, detect_platform
+    from microIO import resolve_pin, pinmap_search, register_pin
 except:
-    detect_platform = None
+    pinmap_search = None
 
 
 #############################################
@@ -16,109 +23,60 @@ except:
 class DebugCfg:
     DEBUG = True        # DEBUG PRINT ON/OFF - SET FROM ConfigHandler
     PLED_STEP = None    # PROGRESS LED OBJECT - init in init_pled
-    NEO_WHEEL = None    # NEOPIXEL (ws2812/esp32s3) color wheel object
-    COLOR_INDEX = 0     # APA102 TinyPico color wheel counter
 
     @staticmethod
     def init_pled():
         # CALL FROM ConfigHandler
-        if detect_platform is None:
+        if pinmap_search is None:
             # Check LogicalPins module loadable (robustness...)
             return
-        micro_platform = detect_platform()
-        pled = pinmap_dump('builtin')['builtin']
-        if micro_platform == "tinypico":
-            # Progress led for TinyPico
-            DebugCfg._init_apa102()
-        elif pled is not None:
-            if isinstance(pled, int):
-                # SET PROGRESS LED WITH BUILT-IN step FUNCTION
-                if micro_platform == "esp32s3":
-                    # Progress led for esp32s3
-                    DebugCfg._init_ws2812()
-                else:
-                    # Progress led for esp32/etc
-                    DebugCfg._init_simple()
-            else:
-                # OVERRIDE PROGRESS LED WITH CUSTOM step FUNCTION
-                DebugCfg.PLED_STEP = pled
-
-    @staticmethod
-    def step():
-        """
-        DEBUG LED FEEDBACK
-        - handle 3 types of builtin LEDs: analog, neopixel(ws2812), apa102
-        - automatic selection based on board type + builtin logical pin number
-        """
-        try:
-            if callable(DebugCfg.PLED_STEP):
-                return DebugCfg.PLED_STEP()         # Run step function (return None: double-blink OR True: no d-b)
-        except Exception as e:
-            errlog_add(f"[PLED] step error: {e}")
-        return True
+        pled = pinmap_search('builtin')['builtin']
+        if pled is None:
+            # No available builtin pin, skip pled init...
+            return
+        # CONFIGURE PROGRESS LED
+        if isinstance(pled, int):
+            # [MODE] Simple flashing progress LED
+            try:
+                # Progress led for esp32/etc
+                led_obj = Pin(abs(resolve_pin('builtin')), Pin.OUT)
+                if resolve_pin('builtin') < 0:
+                    # Pin number start with (-), like -8 (means inverted output)
+                    led_obj.value(1)            # Turn OFF built-in LED state invert (1:OFF)
+                # Set function callback for step function (simple led - blink)
+                DebugCfg.PLED_STEP = lambda: led_obj.value(not led_obj.value())  # # double-blink: return None
+            except Exception as e:
+                syslog(f"[PLED] led error: {e}")
+        elif callable(pled):
+            # [MODE] OVERRIDE PROGRESS LED WITH CUSTOM step FUNCTION
+            DebugCfg.PLED_STEP = pled
+            DebugCfg._auto_register_pin()
+        else:
+            syslog(f"[WARN] pled type not supported: {pled}")
 
-    @staticmethod
-    def _init_simple():
-        try:
-            # Progress led for esp32/etc
-            led_obj = Pin(abs(physical_pin('builtin')), Pin.OUT)
-            if physical_pin('builtin') < 0:     # Pin number start with (-), like -8 (means inverted output)
-                led_obj.value(1)                # Turn OFF built-in LED state invert (1:OFF)
-            # Set function callback for step function (simple led - blink)
-            DebugCfg.PLED_STEP = lambda: led_obj.value(not led_obj.value())     # # double-blink: return None
-        except Exception as e:
-            errlog_add(f"[PLED] led error: {e}")
 
     @staticmethod
-    def _init_apa102():
+    def _auto_register_pin():
         try:
-            from machine import SoftSPI
-            from dotstar import DotStar
-            from tinypico import DOTSTAR_CLK, DOTSTAR_DATA, SPI_MISO, set_dotstar_power, dotstar_color_wheel
-            spi = SoftSPI(sck=Pin(DOTSTAR_CLK), mosi=Pin(DOTSTAR_DATA), miso=Pin(SPI_MISO))
-            # Create a DotStar instance
-            dotstar = DotStar(spi, 1, brightness=0.4)  # Just one DotStar, half brightness
-            # Turn on the power to the DotStar
-            set_dotstar_power(True)
-            DebugCfg.PLED_STEP = lambda: DebugCfg._step_apa102(led_obj=dotstar, color_wheel=dotstar_color_wheel)
+            pin = DebugCfg.PLED_STEP(pin=True)
+            if isinstance(pin, int):
+                register_pin('builtin', pin)
         except Exception as e:
-            errlog_add(f"[PLED] apa102 error: {e}")
+            syslog(f"[ERR] pled pin registration: {e}", console=False)
 
-    @staticmethod
-    def _step_apa102(led_obj, color_wheel):
-        # Get the R,G,B values of the next colour
-        r, g, b = color_wheel(DebugCfg.COLOR_INDEX*2)
-        # Set the colour on the DOTSTAR
-        led_obj[0] = (int(r * 0.6), g, b, 0.4)
-        # Increase the wheel index
-        DebugCfg.COLOR_INDEX = 0 if DebugCfg.COLOR_INDEX > 1000 else DebugCfg.COLOR_INDEX + 2
-        return True                  # No double-blink
 
     @staticmethod
-    def _init_ws2812():
+    def step():
+        """
+        DEBUG LED FLASHING FEEDBACK
+        - handle step callback function execution
+        """
         try:
-            from neopixel import NeoPixel
-            neo_pin = Pin(physical_pin('builtin'))
-            led_obj = NeoPixel(neo_pin, 1)
-            DebugCfg.PLED_STEP = lambda: DebugCfg._step_ws2812(led_obj)
+            if callable(DebugCfg.PLED_STEP):
+                return DebugCfg.PLED_STEP()         # Run step function (return None: double-blink OR True: no d-b)
         except Exception as e:
-            errlog_add(f"[PLED] ws2812 error: {e}")
-
-    @staticmethod
-    def _step_ws2812(led_obj):
-        def _color_wheel():
-            while True:
-                yield 10, 0, 0
-                yield 5, 5, 0
-                yield 0, 10, 0
-                yield 0, 5, 5
-                yield 0, 0, 10
-                yield 5, 0, 5
-        if DebugCfg.NEO_WHEEL is None:
-            DebugCfg.NEO_WHEEL = _color_wheel()
-        led_obj[0] = next(DebugCfg.NEO_WHEEL)
-        led_obj.write()
-        return True                     # No double-blink
+            syslog(f"[PLED] step error: {e}")
+        return True
 
 
 def console_write(msg):
@@ -129,112 +87,15 @@ def console_write(msg):
             if analog is None:
                 DebugCfg.step()             # Double-blink
         except Exception as e:
-            errlog_add(f"[ERR] console_write: {e}", console=False)
-
-#############################################
-#        LOGGING WITH DATA ROTATION         #
-#############################################
+            syslog(f"[ERR] console_write: {e}", console=False)
 
 
-def logger(data, f_name, limit):
-    """
-    Create generic logger function
-    - implements log line rotation
-    - automatic time stump
-    :param data: input string data to log
-    :param f_name: file name to use
-    :param limit: line limit for log rotation
-    return write verdict - true / false
-    INFO: hardcoded max data number = 30
-    """
-    def _logger(_data, _f_name, _limit, f_mode='r+'):
-        _limit = 30 if _limit > 30 else _limit
-        # [1] GET TIME STUMP
-        ts_buff = [str(k) for k in localtime()]
-        ts = ".".join(ts_buff[0:3]) + "-" + ":".join(ts_buff[3:6])
-        # [2] OPEN FILE - WRITE DATA WITH TS
-        with open(_f_name, f_mode) as f:
-            _data = f"{ts} {_data}\n"
-            # read file lines and filter by time stump chunks (hack for replace truncate)
-            lines = [_l for _l in f.readlines() if '-' in _l and '.' in _l]
-            # get file params
-            lines_len = len(lines)
-            lines.append(_data)
-            f.seek(0)
-            # line data rotate
-            if lines_len >= _limit:
-                lines = lines[-_limit:]
-                lines_str = ''.join(lines)
-            else:
-                lines_str = ''.join(lines)
-            # write file
-            f.write(lines_str)
-
-    # Run logger
-    try:
-        # There is file - append 'r+'
-        _logger(data, f_name, limit)
-    except:
-        try:
-            # There is no file - create 'a+'
-            _logger(data, f_name, limit, 'a+')
-        except:
-            return False
-    return True
-
-
-def log_get(f_name, msgobj=None):
-    """
-    Get and stream (ver osocket/stdout) .log file's content and count "critical" errors
-    - critical error tag in log line: [ERR]
-    """
-    err_cnt = 0
-    try:
-        with open(f_name, 'r') as f:
-            eline = f.readline().strip()
-            while eline:
-                # GET error from log line (tag: [ERR])
-                err_cnt += 1 if "[ERR]" in eline else 0
-                # GIVE BACK .log file contents
-                if msgobj is None:
-                    console_write(eline)
-                else:
-                    msgobj(eline)
-                eline = f.readline().strip()
-    except:
-        pass
-    return err_cnt
-
-
-#############################################
-#               ERROR LOGGING               #
-#############################################
-
-
-def errlog_add(data, console=True):
+def syslog(data, console=True):
     """
     :param data: msg string / data
     :param console: activate console_write (default: True)
     :return: is ok
     """
     if console:
-        console_write(msg=data)
-    return logger(data, 'err.log', limit=6)
-
-
-def errlog_get(msgobj=None):
-    f_name = 'err.log'
-    errcnt = log_get(f_name, msgobj)
-    # Return error number
-    return errcnt
-
-
-def errlog_clean(msgobj=None):
-    to_del = [file for file in os.listdir() if file.endswith('.log')]
-    for _del in to_del:
-        del_msg = f" Delete: {_del}"
-        if msgobj is None:
-            console_write(del_msg)
-        else:
-            msgobj(del_msg)
-        os.remove(_del)
+        console_write(data)
+    return False if logger_syslog is None else logger_syslog(data)