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

micrOS/source/Time.py

@@ -14,27 +14,29 @@ from network import WLAN, STA_IF
 from utime import sleep_ms, time, mktime, localtime
 
 from Config import cfgput, cfgget
-from Debug import errlog_add, console_write
+from Debug import syslog, console_write
 from urequests import get as http_get
+from Files import OSPath, path_join
 
 
 class Sun:
     TIME = {}
     UTC = cfgget('utc')  # STORED IN MINUTE
     BOOTIME = None       # Initialize BOOTIME: Not SUN, but for system uptime
+    FILE_CACHE = path_join(OSPath.DATA, 'sun.cache')
 
 
-def set_time(year, month, mday, hour, min, sec):
+def set_time(year, month, mday, hour, minute, sec):
     """
     Set Localtime + RTC Clock manually + update BOOTIME/uptime
         https://docs.micropython.org/en/latest/library/machine.RTC.html
     """
     # Make time from tuple to sec
-    time_sec = mktime((year, month, mday, hour, min, sec, 0, 0))
+    time_sec = mktime((year, month, mday, hour, minute, sec, 0, 0))
     # Set localtime
     localtime(time_sec)
     # Set RTC
-    RTC().datetime((year, month, mday, 0, hour, min, sec, 0))
+    RTC().datetime((year, month, mday, 0, hour, minute, sec, 0))
     # (re)set uptime when settime - normally at boot time
     if Sun.BOOTIME is None:
         Sun.BOOTIME = time()
@@ -47,7 +49,7 @@ def ntp_time():
     :return: ntp date struct
     """
     if not WLAN(STA_IF).isconnected():
-        errlog_add("STA not connected: ntptime")
+        syslog("[WARN] STA not connected: ntptime")
         return False
 
     def get_ntp():
@@ -83,31 +85,30 @@ def ntp_time():
             console_write(f"ntptime error.:{e}")
             err = e
         sleep_ms(100)
-    errlog_add(f"[ERR] ntptime: {err}")
+    syslog(f"[ERR] ntptime: {err}")
     return False
 
 
 def __sun_cache(mode):
     """
-    pds - persistent data structure
+    File cache
     modes:
         r - recover, s - save
     """
     if mode == 's':
         # SAVE CACHE
-        temp = {}
         try:
-            with open('sun.pds', 'w') as f:
-                for k, v in Sun.TIME.items():
-                    temp[k] = tuple([str(t) for t in v])
-                f.write(';'.join([f'{k}:{"-".join(v)}' for k, v in temp.items()]))
+            with open(Sun.FILE_CACHE, 'w') as f:
+                cache = {k:tuple([str(t) for t in v]) for k, v in Sun.TIME.items()}
+                f.write(';'.join([f'{k}:{"-".join(v)}' for k, v in cache.items()]))
         except:
-            errlog_add("[ERR] Cannot write sun cache")
+            syslog("[ERR] Cannot write sun cache")
         return
     try:
         # RESTORE CACHE
-        with open('sun.pds', 'r') as f:
-            buff = {data.split(':')[0]: data.split(':')[1].split('-') for data in f.read().strip().split(';')}
+        with open(Sun.FILE_CACHE, 'r') as f:
+            buff = {data.split(':')[0]: data.split(':')[1].split('-')
+                    for data in f.read().strip().split(';')}
             for k, v in buff.items():
                 Sun.TIME[k] = tuple([int(e) for e in v])
     except:
@@ -140,7 +141,7 @@ def suntime():
         Sun.UTC = int(response.get('offset') / 60)      # IN MINUTE
         cfgput('utc', Sun.UTC, True)
     except Exception as e:
-        errlog_add(f'[ERR] ip-api: {e} data: {response}')
+        syslog(f'[ERR] ip-api: {e} data: {response}')
         return Sun.TIME
 
     # SUNSET-SUNRISE API REQUEST HANDLING
@@ -152,12 +153,10 @@ def suntime():
             _, response = http_get(url, sock_size=512, jsonify=True)
             results = response.get('results')
             time_regex = re_comp(r'T([0-9:]+)')
-            sun = {
-                'sunrise': time_regex.search(results.get('sunrise')).group(1).split(':'),
-                'sunset': time_regex.search(results.get('sunset')).group(1).split(':')
-                }
+            sun = {'sunrise': time_regex.search(results.get('sunrise')).group(1).split(':'),
+                   'sunset': time_regex.search(results.get('sunset')).group(1).split(':')}
         except Exception as e:
-            errlog_add(f'[ERR] sunrise-api: {e} data: {response}')
+            syslog(f'[ERR] sunrise-api: {e} data: {response}')
     # Try to parse response by expected sun_keys
     try:
         for key in sun:
@@ -165,7 +164,7 @@ def suntime():
             sun[key][0] += int(Sun.UTC / 60)
             sun[key] = tuple(sun[key])
     except Exception as e:
-        errlog_add(f'sunrise-api parse error: {e} sun: {sun}')
+        syslog(f'[WARN] sunrise-api parse error: {e} sun: {sun}')
         # Retrieve cached data and return
         __sun_cache('r')  # Using Sun.TIME
         console_write('[suntime] loaded from cache')

micrOS/source/Types.py

@@ -11,25 +11,25 @@ USAGE:
     SLIDER brightness br=<0-100>
     SLIDER brightness br=<0-100-5>
 """
-from json import dumps
-from Debug import errlog_add
+from json import dumps, loads
+from Debug import syslog
 
 ########################################################
 #                 HELP TUPLE RESOLVER                  #
 ########################################################
+
 __TEMPLATE = {'type': 'n/a', 'lm_call': ''}
 __RANGE_100 = {'range': (0, 100, 2)}
 __RANGE_255 = {'range': (0, 255, 2)}
-__RANGE_OPTS = {'range': ("True", "False")}
-
+__OPTIONS = {'options': ("None",)}
 
-# WIDGET TYPES - STRUCTURE (DYNAMIC)
-BUTTON = __TEMPLATE | {'type': 'button'}                                    # Mandatory func params: n/a
-TOGGLE = __TEMPLATE | {'type': 'toggle'} | __RANGE_OPTS                     # Mandatory func params: state
-SLIDER = __TEMPLATE | {'type': 'slider'} | __RANGE_100                      # Mandatory func params: br
-TEXTBOX = __TEMPLATE | {'type': 'textbox', 'refresh': 5000}                 # Mandatory func params: n/a
-COLOR = __TEMPLATE | {'type': 'color'} | __RANGE_255                        # Mandatory func params: r, g, b
-WHITE = __TEMPLATE | {'type': 'white'} | __RANGE_255                        # Mandatory func params: wc, ww
+# Widget Types
+BUTTON = lambda: __TEMPLATE | {'type': 'button'} | __OPTIONS
+SLIDER = lambda: __TEMPLATE | {'type': 'slider'} | __RANGE_100
+TEXTBOX = lambda: __TEMPLATE | {'type': 'textbox', 'refresh': 10000}
+COLOR = lambda: __TEMPLATE | {'type': 'color'} | __RANGE_255
+WHITE = lambda: __TEMPLATE | {'type': 'white'} | __RANGE_255
+JOYSTICK = lambda: __TEMPLATE | {'type': 'joystick'} | __RANGE_100
 
 
 ########################################################
@@ -41,67 +41,102 @@ def _placeholder(var, value, type_dict):
         try:
             int(data)
             return True
-        except:
+        except ValueError:
             return False
 
-    new_range = None
     if value.startswith('<') and value.endswith('>'):
         if '-' in value:
             _range = value[1:-1].split('-')
-            # Range param int check
-            if len([r for r in _range if not _is_int(r)]) == 0:
-                # Get custom range values
-                _min, _max, _step = (_range[0], _range[1], _range[2]) if len(_range) > 2 else (_range[0], _range[1], None)
-                if _step is None:
-                    _step = type_dict['range'][2]
-                new_range = (int(_min), int(_max), int(_step))
-                #print(f"[i] Range overwrite[{var}]: {_range}")
-                return f"{var}=:range:", new_range
-            # Ignore param
-            return "", new_range
-    # Keep param value
-    return f"{var}={value}", new_range
+            if all(_is_int(r) for r in _range):
+                _min, _max = int(_range[0]), int(_range[1])
+                _step = int(_range[2]) if len(_range) > 2 else type_dict['range'][2]
+                return f"{var}=:range:", (_min, _max, _step), 'range'
+            return "", None, None
+        if ',' in value:
+            _opts = tuple(value[1:-1].split(','))
+            return f"{var}=:options:", _opts, 'options'
+    return f"{var}={value}", None, None
 
 
 def _generate(type_dict, help_msg):
-    func = help_msg.split()[1]
-    params = help_msg.split()[2:] if len(help_msg.split()) > 2 else []
-    valid_params = []
+    parts = help_msg.split()
+    func, params = parts[1], parts[2:] if len(parts) > 2 else []
+    valid_params, overwrite = [], {}
     for p in params:
         if '=' in p:
             var, value = p.split("=")
+            param_str, values, value_type = _placeholder(var, value, type_dict)
+            if value_type:
+                overwrite[value_type] = values
+            valid_params.append(param_str)
+        else:
+            if p.startswith("&"):
+                # Handle special use case - task postfix
+                valid_params.append(p)
+            else:
+                param_str = f'{p}=:{"range" if "range" in type_dict else "options"}:'
+                valid_params.append(param_str)
+    type_dict['lm_call'] = f"{func} {' '.join(valid_params)}"
+    return dumps(type_dict | overwrite)
+
+
+def _extract_tag_and_overrides(msg):
+    """
+    Example:
+      "TEXTBOX{'refresh': 5000} measure ntfy=False"
+    OR with default refresh value:
+      "TEXTBOX measure ntfy=False"
+    return:
+      tag                   -> "TEXTBOX"
+      overrides(optional)   -> {'refresh': 5000}
+      cmd                   -> "measure ntfy=False"
+    """
+    msg = msg.strip()
+    if not msg:
+        return "", {}, ""
+    tag_end = len(msg)
+    for i, c in enumerate(msg):
+        if c in " {":
+            tag_end = i
+            break
+    tag = msg[:tag_end]
+    cmd = msg[tag_end:].lstrip()
+    overrides = {}
+    if tag.isupper() and cmd.startswith('{'):
+        i = cmd.find('}')
+        if i >= 0:
             try:
-                p, new_range = _placeholder(var, value, type_dict)
-                if new_range is not None:
-                    type_dict['range'] = new_range
+                overrides = loads('{' + cmd[1:i].replace("'", '"') + '}')
             except Exception as e:
-                errlog_add(f"[ERR] Type.resolve._placeholder: {e}")
-        else:
-            # Empty param fallback
-            p = f'{p}=:range:'
-        valid_params.append(p)
-    type_dict['lm_call'] = f"{func} " + " ".join(valid_params)
-    return dumps(type_dict)
+                syslog(f"[ERR] Types tag overrides: {e}")
+            cmd = cmd[i + 1:].lstrip()
+    return tag, overrides, cmd
+
 
 def resolve(help_data, widgets=False):
     help_msg = []
     for msg in help_data:
-        tag = msg.split()[0].strip()
-        # TYPE DECORATION detect in help strings
-        if tag.isupper():
-            try:
-                resolved_tag = eval(tag)
-            except NameError:
-                resolved_tag = tag
+        tag, overrides, cmd = _extract_tag_and_overrides(msg)
+        if tag and tag.isupper():
+            # TAG exists in help message
             if widgets:
-                if isinstance(resolved_tag, dict):
-                    # Create json string type + extract widgets from help message
-                    help_msg.append(_generate(resolved_tag, msg))
+                # Format output as widget - machine-readable
+                factory = globals().get(tag, None)
+                resolved_tag = factory() if callable(factory) else factory
+                if isinstance(resolved_tag, dict) and overrides:
+                    # Apply inline widget-only overrides, e.g. TEXTBOX{'refresh': 5000}
+                    resolved_tag.update(overrides)
+                try:
+                    # Build a clean message for _generate, without inline {...}
+                    cleaned_msg = (tag + ' ' + cmd).strip()
+                    # Generate JSON output with TAG
+                    help_msg.append(_generate(resolved_tag, cleaned_msg))
+                except Exception as e:
+                    syslog(f"[ERR] resolve {tag} help msg: {e}")
                 continue
-            # Human readable mode (decorated functions)
-            help_msg.append(msg.replace(tag, '').strip())
+            # Widgets OFF - TAG exists - remove TAG from output
+            help_msg.append(cmd.strip())
         elif not widgets:
-            # Human readable mode (non decorated functions)
-            help_msg.append(f"{msg}")
+            # No TAG - Widgets OFF output
+            help_msg.append(msg)
     return tuple(help_msg)
-