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

micrOS/source/{LM_telegram.py → modules/LM_telegram.py}

@@ -1,37 +1,52 @@
 from sys import modules
-import uasyncio as asyncio
 import urequests
 from Notify import Notify
-from Config import cfgget
-from Common import micro_task, syslog, console_write
+from Common import micro_task, syslog, console_write, data_dir, conf_dir
 from LM_system import ifconfig
+from utime import localtime
+
+
+def _timestamp():
+    _time = [str(k) for k in localtime()[3:6]]
+    return ':'.join(_time)
 
 
 class Telegram(Notify):
+    INSTANCE = None
     # Telegram bot token and chat ID
     # https://core.telegram.org/bots/api
     _TOKEN = None  # Telegram token
     _CHAT_IDS = set()  # Telegram bot chat IDs - multi group support - persistent caching
     _API_PARAMS = "?offset=-1&limit=1&timeout=2"  # Generic API params - optimization
     _IN_MSG_ID = None
+    _FILE_CACHE = data_dir('telegram.cache')
+
+    def __init__(self, token:str):
+        """
+        :param token: bot token
+        """
+        # Subscribe to the notification system - provide send_msg method (over self)
+        super().add_subscriber(self)
+        Telegram._TOKEN = token
+        Telegram.INSTANCE = self
 
     @staticmethod
-    def __id_cache(mode):
+    def __id_cache(mode:str):
         """
-        pds - persistent data structure
+        File cache
         modes:
             r - recover, s - save
         """
         if mode == 's':
             # SAVE CACHE
             console_write("[NTFY] Save chatIDs cache...")
-            with open('telegram.pds', 'w') as f:
+            with open(Telegram._FILE_CACHE, 'w') as f:
                 f.write(','.join([str(k) for k in Telegram._CHAT_IDS]))
             return
         try:
             # RESTORE CACHE
             console_write("[NTFY] Restore chatIDs cache...")
-            with open('telegram.pds', 'r') as f:
+            with open(Telegram._FILE_CACHE, 'r') as f:
                 # set() comprehension
                 Telegram._CHAT_IDS = {int(k) for k in f.read().strip().split(',')}
         except:
@@ -41,14 +56,11 @@ class Telegram(Notify):
     def __bot_token():
         """Get bot token"""
         if Telegram._TOKEN is None:
-            token = cfgget('telegram')
-            if token is None or token == 'n/a':
-                return None
-            Telegram._TOKEN = token
+            return None
         return Telegram._TOKEN
 
     @staticmethod
-    def send_msg(text, reply_to=None, chat_id=None):
+    def send_msg(text:str, *args, **kwargs):
         """
         Send a message to the Telegram chat by chat_id
         :param text: text to send
@@ -56,6 +68,8 @@ class Telegram(Notify):
         :param chat_id: chat_id to reply on, if None, reply to all known
         RETURN None when telegram bot token is missing
         """
+        reply_to = kwargs.get("reply_to", args[0] if len(args) > 0 else None)
+        chat_id = kwargs.get("chat_id", args[1] if len(args) > 1 else None)
 
         def _send(chid):
             """Send message to chat_id (chid)"""
@@ -97,79 +111,104 @@ class Telegram(Notify):
             verdict = f'Sent{chat_id}' if resp_json['ok'] else str(resp_json)
         return verdict
 
+    @staticmethod
+    def __update_chat_ids(resp_json:dict):
+        """
+        Update known chat_id-s and cache them
+        - return active chat_id frm resp_json
+        """
+        _cid = None
+        if resp_json.get("ok", None) and len(resp_json["result"]) > 0:
+            _cid = resp_json["result"][-1]["message"]["chat"]["id"]
+            # LIMIT Telegram._CHAT_IDS NOTIFICATION CACHE TO 3 IDs
+            if len(Telegram._CHAT_IDS) < 4 and _cid not in Telegram._CHAT_IDS:
+                console_write("[NTFY GET] update chatIDs")
+                _ids = len(Telegram._CHAT_IDS)
+                Telegram._CHAT_IDS.add(_cid)
+                if len(Telegram._CHAT_IDS) - _ids > 0:  # optimized save (slow storage access)
+                    Telegram.__id_cache('s')
+        else:
+            Telegram.__id_cache('r')
+            if len(Telegram._CHAT_IDS) == 0:
+                error_message = resp_json.get("description", "Unknown error")
+                raise Exception(f"Error retrieving chat ID: {error_message}")
+        return _cid
+
     @staticmethod
     def get_msg():
         """
         Get the last message from the Telegram chat.
         RETURN None when telegram bot token is missing
         """
+        console_write("[NTFY] GET MESSAGE")
+        bot_token = Telegram.__bot_token()
+        if bot_token is None:
+            return None
+        response = {'sender': None, 'text': None, 'm_id': -1, 'c_id': None}
+        url = f"https://api.telegram.org/bot{bot_token}/getUpdates{Telegram._API_PARAMS}"
+        console_write(f"\t[GET] request: {url}")
 
-        def _update_chat_ids():
-            """
-            Update known chat_id-s and cache them
-            - return active chat_id frm resp_json
-            """
-            console_write("[NTFY GET] update chatIDs")
-            _cid = None
-            if resp_json.get("ok", None) and len(resp_json["result"]) > 0:
-                _cid = resp_json["result"][-1]["message"]["chat"]["id"]
-                # LIMIT Telegram._CHAT_IDS NOTIFICATION CACHE TO 3 IDs
-                if len(Telegram._CHAT_IDS) < 4:
-                    _ids = len(Telegram._CHAT_IDS)
-                    Telegram._CHAT_IDS.add(_cid)
-                    if len(Telegram._CHAT_IDS) - _ids > 0:  # optimized save (slow storage access)
-                        Telegram.__id_cache('s')
-            else:
-                Telegram.__id_cache('r')
-                if len(Telegram._CHAT_IDS) == 0:
-                    error_message = resp_json.get("description", "Unknown error")
-                    raise Exception(f"Error retrieving chat ID: {error_message}")
-            return _cid
+        _, resp_json = urequests.get(url, jsonify=True, sock_size=128)
 
-        # --------------------- FUNCTION MAIN ------------------------ #
+        if len(resp_json["result"]) > 0:
+            response['c_id'] = Telegram.__update_chat_ids(resp_json)
+            resp = resp_json["result"][-1]["message"]
+            response['sender'] = f"{resp['chat']['first_name']}{resp['chat']['last_name']}" if resp['chat'].get(
+                'username', None) is None else resp['chat']['username']
+            response['text'], response['m_id'] = resp['text'], resp['message_id']
+        console_write(f"\t\t[GET] response: {response}")
+        return response
+
+    @staticmethod
+    async def aget_msg():
+        """
+        Async: Get the last message from the Telegram chat.
+        RETURN None when telegram bot token is missing
+        """
         console_write("[NTFY] GET MESSAGE")
         bot_token = Telegram.__bot_token()
         if bot_token is None:
             return None
         response = {'sender': None, 'text': None, 'm_id': -1, 'c_id': None}
         url = f"https://api.telegram.org/bot{bot_token}/getUpdates{Telegram._API_PARAMS}"
-        console_write(f"\t1/2[GET] request: {url}")
-        _, resp_json = urequests.get(url, jsonify=True, sock_size=128)
+        console_write(f"\t[aGET] request: {url}")
+
+        _, resp_json = await urequests.aget(url, jsonify=True, sock_size=128)
+
         if len(resp_json["result"]) > 0:
-            response['c_id'] = _update_chat_ids()
+            response['c_id'] = Telegram.__update_chat_ids(resp_json)
             resp = resp_json["result"][-1]["message"]
             response['sender'] = f"{resp['chat']['first_name']}{resp['chat']['last_name']}" if resp['chat'].get(
                 'username', None) is None else resp['chat']['username']
             response['text'], response['m_id'] = resp['text'], resp['message_id']
-        console_write(f"\t2/2[GET] response: {response}")
+        console_write(f"\t\t[aGET] response: {response}")
         return response
 
     @staticmethod
-    def receive_eval():
+    async def receive_eval():
         """
         READ - VALIDATE - EXECUTE - REPLY LOOP
         - can be used in async loop
         RETURN None when telegram bot token is missing
         """
-
-        console_write("[NTFY] REC&EVAL sequence")
-
-        # Return data structure template
+        console_write("[NTFY] EVAL sequence")
         verdict = None
 
-        def lm_execute(cmd_args):
+        def _lm_execute(cmd_args):
             nonlocal verdict, m_id
-            access, output = Telegram.lm_execute(cmd_args)
+            status, output = Telegram.lm_execute(cmd_args)
+            access = "NotAllowed" not in str(output)
+            status = "OK" if status else "NOK"
             if access:
-                verdict = f'[UP] Exec: {" ".join(cmd_args[0])}'
+                verdict = f'{_timestamp()} [UP][{status}] Exec: {" ".join(cmd_args[0])}'
                 Telegram.send_msg(output, reply_to=m_id)
             else:
-                verdict = f'[UP] NoAccess: {cmd_args[0]}'
+                verdict = f'{_timestamp()} [UP][{status}] NoAccess: {cmd_args[0]}'
                 Telegram._IN_MSG_ID = m_id
 
         # -------------------------- FUNCTION MAIN -------------------------- #
-        # Poll telegram chat
-        data = Telegram.get_msg()
+        # Async Poll telegram chat
+        data = await Telegram.aget_msg()
         if data is None:
             return data
         # Get msg, msg_id, chat_id as main input data source
@@ -185,24 +224,54 @@ class Telegram(Notify):
                 cmd_lm = msg_in.strip().split()[1:]
                 # [Compare] cmd selected device param with DEVFID (device/prompt name)
                 if cmd_lm[0] in Telegram._DEVFID:
-                    lm_execute(cmd_lm[1:])
+                    _lm_execute(cmd_lm[1:])
                 else:
-                    verdict = f'[UP] NoSelected: {cmd_lm[0]}'
+                    verdict = f'{_timestamp()} [UP] NoSelected: {cmd_lm[0]}'
             elif msg_in.startswith('/cmd'):
                 cmd_lm = msg_in.strip().split()[1:]
-                lm_execute(cmd_lm)
+                _lm_execute(cmd_lm)
             elif msg_in.startswith('/notify'):
                 param = msg_in.strip().split()[1:]
                 if len(param) > 0:
                     verdict = Telegram.notifications(not param[0].strip().lower() in ("disable", "off", 'false'))
                 else:
                     verdict = Telegram.notifications()
+                # Send is still synchronous (OK)
                 Telegram.send_msg(verdict, reply_to=m_id)
         else:
-            verdict = "[UP] NoExec"
-        console_write(f"\tREC&EVAL: {verdict}")
+            verdict = f"{_timestamp()} [UP] NoExec"
         return verdict
 
+    @staticmethod
+    async def server_bot(tag:str, period:int=3):
+        """
+        BOT - ReceiveEvalPrintLoop
+        :param tag: task tag (access)
+        :param period: polling period in sec, default: 3
+        """
+        cancel_cnt = 0
+        period = period if period > 0 else 1
+        period_ms = period * 1000
+        with micro_task(tag=tag) as my_task:
+            my_task.out = f"{_timestamp()} [UP] Running"
+            while True:
+                # Normal task period
+                await my_task.feed(sleep_ms=period_ms)
+                try:
+                    # await asyncio.wait_for(Telegram.receive_eval(), 5)    # 5 sec timeout???
+                    v = await Telegram.receive_eval()
+                    my_task.out = "Missing bot token" if v is None else f"{v} ({period}s)"
+                    cancel_cnt = 0
+                except Exception as e:
+                    my_task.out = str(e)
+                    # Auto scale - blocking nature - in case of serial failures (5) - hibernate task (increase async sleep)
+                    cancel_cnt += 1
+                    if cancel_cnt > 5:
+                        my_task.out = f"{_timestamp()} [DOWN] {e} (wait 1min)"
+                        cancel_cnt = 5
+                        # SLOW DOWN - hibernate task
+                        await my_task.feed(sleep_ms=60_000)
+
     @staticmethod
     def set_commands():
         """
@@ -228,57 +297,58 @@ class Telegram(Notify):
 #########################################
 #          micrOS Notifications         #
 #########################################
-TELEGRAM_OBJ = None
 
-def __init():
-    global TELEGRAM_OBJ
-    if TELEGRAM_OBJ is None:
+def __init(token:str=None):
+    token_cache = conf_dir("telegram.token")
+    token_refresh = True
+    if Telegram.INSTANCE is None:
         # ENABLE TELEGRAM IF NW IS STA - CONNECTED TO THE WEB
-        _sta_available = True if ifconfig()[0] == "STA" else False
-        if _sta_available:
-            TELEGRAM_OBJ = Telegram()
-            Notify.add_subscriber(TELEGRAM_OBJ)
+        if ifconfig()[0] == "STA":
+            if token is None:
+                token_refresh = False
+                # Attempt to load token from config folder
+                try:
+                    with open(token_cache, "r") as f:
+                        token = f.read()
+                except Exception as e:
+                    err = f"Telegram: cannot load {token_cache}: {e}"
+                    syslog(err)
+                    raise Exception(err)
+            # Initialize telegram with token
+            Telegram(token)
+            if token_refresh:
+                # Save token
+                with open(token_cache, "w") as f:
+                    f.write(token)
         else:
             syslog("No STA: cannot init telegram")
+    return Telegram.INSTANCE
 
-# Auto INIT Telegram at load time (legacy)
-__init()
 
-def load():
+def load(token:str=None):
     """
     Set custom chat commands for Telegram
     - /ping
     - /cmd module function (params)
+    :param token: telegram bot token
     """
-    __init()
-    if TELEGRAM_OBJ is None:
+    if __init(token) is None:
         return "Network unavailable."
-    verdict = TELEGRAM_OBJ.set_commands()
+    verdict = Telegram.set_commands()
     return "Missing telegram bot token" if verdict is None else verdict
 
 
-def send(text):
+def send(text:str):
     """
     Send Telegram message - micrOS notification
     :param text: text to send
     return verdict
     """
-    if TELEGRAM_OBJ is None:
+    if Telegram.INSTANCE is None:
         return "Network unavailable."
-    verdict = TELEGRAM_OBJ.send_msg(text)
+    verdict = Telegram.send_msg(text)
     return "Missing telegram bot token" if verdict is None else verdict
 
-def notify(text):
-    """
-    Notify function with system global enable/disable function
-    Control with:
-        telegram notification enable=True
-        telegram notification enable=False
-    """
-    if TELEGRAM_OBJ is None:
-        return "Network unavailable."
-    return TELEGRAM_OBJ.notify(text)
-
 
 def receive():
     """
@@ -286,44 +356,22 @@ def receive():
     - if all value None, then no incoming messages
     One successful msg receive is necessary to get chat_id for msg send as well!
     """
-    if TELEGRAM_OBJ is None:
+    if Telegram.INSTANCE is None:
         return "Network unavailable."
-    verdict = TELEGRAM_OBJ.get_msg()
+    verdict = Telegram.get_msg()
     return "Missing telegram bot token" if verdict is None else verdict
 
 
-async def __task():
-    cancel_cnt = 0
-    with micro_task(tag='telegram._loop') as my_task:
-        my_task.out = "[UP] Running"
-        while True:
-            # Normal task period
-            await asyncio.sleep(5)
-            try:
-                v = TELEGRAM_OBJ.receive_eval()
-                my_task.out = "Missing bot token" if v is None else v
-                cancel_cnt = 0
-            except Exception as e:
-                my_task.out = str(e)
-                # Auto scale - blocking nature - in case of serial failures (5) - hibernate task (increase async sleep)
-                cancel_cnt += 1
-                if cancel_cnt > 5:
-                    my_task.out = f"[DOWN] {e}"
-                    cancel_cnt = 5
-                    # SLOW DOWN - hibernate task
-                    asyncio.sleep(115)
-
-
-def receiver_loop():
+def receiver_loop(period=3):
     """
-    Telegram msg receiver loop - automatic LM execution
+    Telegram BOT (repl) - ReadEvalPrintLoop for Load Modules
     - Only executes module (function) if the module is already loaded
-    on the endpoint / micrOS node
+    :param period: polling period in sec, default: 3
     """
-    if TELEGRAM_OBJ is None:
-        return "Network unavailable."
-    state = micro_task(tag='telegram._loop', task=__task())
-    return "Starting" if state else "Already running"
+    if Telegram.INSTANCE is None:
+        return "Network unavailable or Telegram uninitialized"
+    tag = 'telegram.server_bot'
+    return micro_task(tag=tag, task=Telegram.server_bot(tag=tag, period=period))
 
 
 def help(widgets=False):
@@ -335,6 +383,6 @@ def help(widgets=False):
     """
     return ('send "text"',
             'receive',
-            'receiver_loop',
-            'notify "message"',
-            'load', 'INFO: Send & Receive messages with Telegram bot')
+            'receiver_loop period=3',
+            'load token=<your-bot-token>',
+            'INFO: Send & Receive messages with Telegram bot')

micrOS/source/{LM_trackball.py → modules/LM_trackball.py}

@@ -8,7 +8,7 @@ https://github.com/mchobby/esp8266-upy/blob/master/trackball/examples/test_color
 from utime import sleep, ticks_ms, ticks_diff
 from struct import unpack
 from machine import SoftI2C, Pin
-from microIO import resolve_pin, pinmap_search
+from microIO import bind_pin, pinmap_search
 from Common import syslog
 from micropython import schedule
 
@@ -179,7 +179,7 @@ def load(width=100, height=100, irq_sampling=50, sensitivity=5, reload=False):
     """
     global TRACKBALL
     if TRACKBALL is None or reload:
-        i2c = SoftI2C(scl=Pin(resolve_pin('i2c_scl')), sda=Pin(resolve_pin('i2c_sda')))
+        i2c = SoftI2C(scl=Pin(bind_pin('i2c_scl')), sda=Pin(bind_pin('i2c_sda')))
         TRACKBALL = Trackball(i2c, max_x=width, max_y=height, irq_sampling=irq_sampling, sensitivity=sensitivity)
         _craft_event_interrupt()
         ready_color()
@@ -253,7 +253,7 @@ def _craft_event_interrupt():
             syslog(f"[ERR] Trackball user callback: {e}")
 
     try:
-        pin = resolve_pin("trackball_int")
+        pin = bind_pin("trackball_int")
     except Exception as e:
         pin = None
         syslog(f'[ERR] trackball_int IRQ: {e}')

micrOS/source/{LM_veml7700.py → modules/LM_veml7700.py}

@@ -5,7 +5,7 @@
 from machine import SoftI2C, Pin
 from time import sleep
 from micropython import const
-from microIO import resolve_pin, pinmap_search
+from microIO import bind_pin, pinmap_search
 from Types import resolve
 
 # start const
@@ -134,7 +134,7 @@ def load():
     VEML7700 Digital light intensity sensor
     """
     if VEML7700.INSTANCE is None:
-        i2c = SoftI2C(Pin(resolve_pin('i2c_scl')), Pin(resolve_pin('i2c_sda')))
+        i2c = SoftI2C(Pin(bind_pin('i2c_scl')), Pin(bind_pin('i2c_sda')))
         VEML7700.INSTANCE = VEML7700(address=0x10, i2c=i2c, it=100, gain=1/8)
     return VEML7700.INSTANCE
 

micrOS/source/modules/LM_web.py

@@ -0,0 +1,38 @@
+"""
+Web backend loader
+    - Dynamic application dashboard
+    - Fileserver
+"""
+
+from Common import web_endpoint, web_mounts
+
+
+def load(dashboard=True, fileserver:bool=False, fs_explore:bool=False):
+    """
+    Centralized Web Backend Services Loader
+    - Dynamic application dashboard
+    - Fileserver
+    :param dashboard:  bool - enable*/disable application dashboard
+    :param fileserver: bool - enable/disable* fileserver
+    :param fs_explore: bool - enable all shared web mounts: modules, data
+    """
+    endpoints = []
+    if dashboard:
+        web_endpoint('dashboard', 'dashboard.html')
+        endpoints.append("Dashboard initialized, endpoint: /dashboard")
+    if fileserver:
+        import LM_fileserver
+        endpoints.append(LM_fileserver.load())
+        endpoints.append(web_mounts(fs_explore, fs_explore, fs_explore))
+    return endpoints
+
+
+def help(widgets=False):
+    """
+    [i] micrOS LM naming convention - built-in help message
+    :return tuple:
+        (widgets=False) list of functions implemented by this application
+        (widgets=True) list of widget json for UI generation
+    """
+    return ('load dashboard=True fileserver=False fsdir=None fs_explore=False',
+            'help')

micrOS/source/urequests.py

@@ -1,10 +1,17 @@
+"""
+This module implements an optimized version of requests module
+for async and sync http get and post requests.
+
+Designed by Marcell Ban aka BxNxM GitHub
+"""
+
+from json import loads, dumps
 from usocket import socket, getaddrinfo
 try:
-    from ussl import wrap_socket    # Legacy micropython ssl usage
+    from ussl import wrap_socket    # Legacy micropython ssl usage (+simulator mode)
 except ImportError:
     from ssl import wrap_socket     # From micropython 1.23...
-from json import loads, dumps
-from Debug import errlog_add
+from Debug import syslog
 import uasyncio as asyncio
 
 
@@ -39,7 +46,7 @@ def _chunked(_body):
         chunk_size_str = _body[:line_end]
         try:
             chunk_size = int(chunk_size_str, 16)
-        except ValueError as e:
+        except ValueError:
             chunk_size = 0
 
         # Check chunk size
@@ -109,7 +116,7 @@ def _parse_response(response):
 #          micropython HTTP request         #
 #############################################
 
-def request(method, url, data=None, json=None, headers=None, sock_size=256, jsonify=False):
+def request(method:str, url:str, data:str=None, json=None, headers:dict=None, sock_size=256, jsonify=False):
     """
     Micropython syncronous HTTP request function for REST API handling
     :param method: GET/POST
@@ -140,7 +147,7 @@ def request(method, url, data=None, json=None, headers=None, sock_size=256, json
     try:
         sock = wrap_socket(sock) if proto == 'https:' else sock
     except Exception as e:
-        errlog_add(f'[ERR] https soc-wrap: {e}')
+        syslog(f'[ERR] https soc-wrap: {e}')
 
     # [1] BUILD REQUEST
     http_request = _build_request(host, method, path, headers, data, json)
@@ -174,7 +181,7 @@ def request(method, url, data=None, json=None, headers=None, sock_size=256, json
 #       async micropython HTTP request      #
 #############################################
 
-async def arequest(method, url, data=None, json=None, headers=None, sock_size=256, jsonify=False):
+async def arequest(method:str, url:str, data:str=None, json=None, headers:dict=None, sock_size=256, jsonify=False):
     """
     Micropython asynchronous HTTP request function for REST API handling
     :param method: GET/POST
@@ -190,10 +197,19 @@ async def arequest(method, url, data=None, json=None, headers=None, sock_size=25
     addr = _host_to_addr(host, port)
     reader, writer = None, None
 
+    # Open a connection
     try:
-        # Open a connection
         reader, writer = await asyncio.open_connection(addr[0], port, ssl=(proto == 'https:'))
+    except Exception as e:
+        # Refresh host address & reconnect
+        if "EHOSTUNREACH" in str(e):
+            addr = _host_to_addr(host, port, force=True)
+            reader, writer = await asyncio.open_connection(addr[0], port, ssl=(proto == 'https:'))
+        else:
+            syslog(f"[ERR] arequest connection: {e}")
 
+    # Send request + Wait for the response
+    try:
         # Build the HTTP request
         http_request = _build_request(host, method, path, headers, data, json)
 
@@ -213,8 +229,14 @@ async def arequest(method, url, data=None, json=None, headers=None, sock_size=25
         status_code, body = _parse_response(response)
     except Exception as e:
         status_code = 500
-        body = f'[ERR] arequest failed: {e}'
-        errlog_add(body)
+        # https://github.com/micropython/micropython/blob/8785645a952c03315dbf93667b5f7c7eec49762f/cc3200/simplelink/include/device.h
+        if "-104" == str(e):
+            body = "[WARN] arequest: ASSOC_REJECT"
+        elif "ECONNABORTED" in str(e):
+            body = f"[WARN] arequest: {e}"
+        else:
+            body = f"[ERR] arequest: {e}"
+        syslog(body)
     finally:
         if writer:
             writer.close()
@@ -226,14 +248,16 @@ async def arequest(method, url, data=None, json=None, headers=None, sock_size=25
 #      Implement http get/post functions    #
 #############################################
 
-def get(url, headers={}, sock_size=256, jsonify=False):
+def get(url:str, headers:dict=None, sock_size=256, jsonify=False):
     """
     GENERIC HTTP GET FUNCTION
     """
+    if headers is None:
+        headers = {}
     return request('GET', url, headers=headers, sock_size=sock_size, jsonify=jsonify)
 
 
-def post(url, data=None, json=None, headers={}, sock_size=256, jsonify=False):
+def post(url:str, data=None, json=None, headers:dict=None, sock_size=256, jsonify=False):
     """
     GENERIC HTTP POST FUNCTION
     :param data: string body (handle bare string as data for POST method)
@@ -242,14 +266,14 @@ def post(url, data=None, json=None, headers={}, sock_size=256, jsonify=False):
     return request('POST', url, data=data, json=json, headers=headers, sock_size=sock_size, jsonify=jsonify)
 
 
-async def aget(url, headers={}, sock_size=256, jsonify=False):
+async def aget(url:str, headers:dict=None, sock_size=256, jsonify=False):
     """
     GENERIC ASYNC HTTP GET FUNCTION
     """
     return await arequest('GET', url, headers=headers, sock_size=sock_size, jsonify=jsonify)
 
 
-async def apost(url, data=None, json=None, headers={}, sock_size=256, jsonify=False):
+async def apost(url, data=None, json=None, headers:dict=None, sock_size=256, jsonify=False):
     """
     GENERIC ASYNC HTTP POST FUNCTION
     :param data: string body (handle bare string as data for POST method)
@@ -258,7 +282,7 @@ async def apost(url, data=None, json=None, headers={}, sock_size=256, jsonify=Fa
     return await arequest('POST', url, data=data, json=json, headers=headers, sock_size=sock_size, jsonify=jsonify)
 
 
-def host_cache():
+def host_cache() -> dict:
     """
     Return address cache
     """

{toolkit/workspace/precompiled → micrOS/source/web}/dashboard.html

@@ -38,6 +38,9 @@
 </head>
 <body>
     <h1> micrOS dashboard </h1>
+    <div id="restInfo">
+      <div id="restInfoHeader"></div>
+    </div>
     <!-- Container for the dynamically generated list -->
     <section id="widgets-section"></section>
     <br><br><br>
@@ -54,6 +57,7 @@
     <script>
         document.addEventListener("DOMContentLoaded", function() {
             // Init basic info from board after DOM is fully loaded
+            restInfo(showPages=false);
 
             // INIT DASHBOARD (load active modules -> build page)
             DynamicWidgetLoad();