micrOSDevToolKit 2.9.11__py3-none-any.whl → 2.10.5__py3-none-any.whl

micrOS/source/Files.py

@@ -0,0 +1,101 @@
+from uos import ilistdir, remove, stat
+
+################################   Helper functions   #####################################
+
+def _is_module(path:str='/', pyprefix:str='*') -> bool:
+    """
+    Filter application modules, LM_.* (pyprefix) or app data or web resource
+    :param path: file to check
+    :param pyprefix: python resource filter prefix, default: * (all: LM and IO)
+    """
+    # micrOS file types
+    allowed_exts = ('html', 'js', 'css', 'log', 'pds', 'dat')
+    mod_prefixes = ('LM', "IO")
+    fname = path.split("/")[-1]
+    if fname.split("_")[0] in mod_prefixes or fname.split('.')[-1] in allowed_exts:
+        if pyprefix == '*':
+            # MODE: ALL app resources
+            return True
+        if fname.startswith(f"{pyprefix.upper()}_"):
+            # MODE: SELECTED app resources
+            return True
+    return False
+
+
+def _type_mask_to_str(item_type:int=None) -> str:
+    # Map the raw bit-mask to a single character
+    if item_type & 0x4000:              # Dir bit-mask
+        item_type = 'd'
+    elif item_type & 0x8000:            # File bit-mask
+        item_type = 'f'
+    else:
+        item_type = 'o'
+    return item_type
+
+###########################   Public functions   #############################
+
+def ilist_fs(path:str="/", type_filter:str='*', select:str='*', core:bool=False):
+    """
+    Linux like ls command - list app resources and app folders
+    :param path: path to list, default: /
+    :param type_filter: content type, default all (*), f-file, d-dir can be selected
+    :param select: select specific application resource type by prefix: LM or IO
+    :param core: list core files resources as well, default: False
+    return iterator:
+        when content is all (*) output: [(item_type, item), ...]
+        OR
+        content type was selected (not *) output: [item, ...]
+    """
+    path = path if path.endswith('/') else f"{path}/"
+    # Info: uos.ilistdir: (name, type, inode[, size])
+    for item, item_type, *_ in ilistdir(path):
+        item_type = _type_mask_to_str(item_type)
+        if type_filter in ("*", item_type):
+            # Mods only
+            if not core and item_type == 'f' and not _is_module(path+item, pyprefix=select):
+                continue
+            if select != '*' and item_type == 'd':
+                continue
+            # Create result
+            if type_filter == "*":
+                yield item_type, item
+            else:
+                yield item
+
+
+def list_fs(path:str="/", type_filter:str='*', select:str='*', core:bool=False) -> list[str,] | list[tuple[str, str],]:
+    """
+    Wrapper of ilist_fs
+    Return list
+    """
+    return list(ilist_fs(path, type_filter, select, core))
+
+
+def remove_fs(path, allow_dir=False):
+    """
+    Linux like rm command - delete app resources and folders
+    :param path: app resource path
+    :param allow_dir: enable directory deletion, default: False
+    """
+    # protect some resources
+    if 'pacman.mpy' in path or 'system.mpy' in path or "/" == path.strip():
+        return f'Load module {path} is protected, skip deletion'
+    _is_dir = is_dir(path)
+    if _is_module(path) or (_is_dir and allow_dir):
+        remove(path)
+        return f"Removed: {path} {'dir' if _is_dir else 'file'}"
+    return f"Protected path: {path}"
+
+
+def is_dir(path):
+    try:
+        return stat(path)[0] & 0x4000
+    except OSError:
+        return False
+
+
+def is_file(path):
+    try:
+        return stat(path)[0] & 0x8000
+    except OSError:
+        return False

micrOS/source/InterConnect.py

@@ -1,6 +1,6 @@
 from socket import getaddrinfo, SOCK_STREAM
 from re import compile
-import uasyncio as asyncio
+from uasyncio import open_connection
 from Debug import errlog_add
 from Config import cfgget
 from Server import Server
@@ -22,7 +22,7 @@ class InterCon:
         pattern = compile(r'^(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])$')
         return bool(pattern.match(str_in))
 
-    async def send_cmd(self, host, cmd):
+    async def send_cmd(self, host:str, cmd:list):
         """
         Async Main method to implement device-device communication with
         - dhcp host resolve and IP caching
@@ -50,7 +50,7 @@ class InterCon:
         if InterCon.validate_ipv4(host):
             try:
                 # Create socket object
-                self.reader, self.writer = await asyncio.open_connection(host, InterCon.PORT)
+                self.reader, self.writer = await open_connection(host, InterCon.PORT)
                 # Send command over TCP/IP
                 output = await self.__run_command(cmd, hostname)
             except OSError as e:
@@ -72,14 +72,13 @@ class InterCon:
             errlog_add(f"[ERR][intercon] Invalid host: {host}")
         return ''
 
-    async def __run_command(self, cmd, hostname):
+    async def __run_command(self, cmd:list, hostname:str):
         """
         Implements receive data on open connection, command query and result collection
         :param cmd: command string to server socket shell
         :param hostname: hostname for prompt checking
         Return None here will trigger retry mechanism... + deletes cached IP
         """
-        cmd = str.encode(cmd)
         data, prompt = await self.__receive_data()
         if "Connection is busy. Bye!" in prompt:
             return None
@@ -87,7 +86,7 @@ class InterCon:
         if hostname is None or prompt is None or str(prompt).replace('$', '').strip() == str(hostname).split('.')[0]:
             # Run command on validated device
             # TODO: Handle multiple cmd as input, separated by ; (????)
-            self.writer.write(cmd)
+            self.writer.write(str.encode(' '.join(cmd)))
             await self.writer.drain()
             data, _ = await self.__receive_data(prompt=prompt)
             if data == '\0':
@@ -141,7 +140,7 @@ class InterCon:
         return data, prompt
 
 
-async def _send_cmd(host, cmd, com_obj):
+async def _send_cmd(host:str, cmd:list, com_obj):
     """
     Async send command wrapper for further async task integration and sync send_cmd usage (main)
     :param host: hostname / IP address
@@ -154,12 +153,12 @@ async def _send_cmd(host, cmd, com_obj):
             out = await com_obj.send_cmd(host, cmd)     # Send CMD
             if out is not None:                         # Retry mechanism
                 break
-            await asyncio.sleep_ms(100)                 # Retry mechanism
+            await com_obj.task.feed(sleep_ms=100)       # Retry mechanism
         com_obj.task.out = '' if out is None else out
     return com_obj.task.out
 
 
-def send_cmd(host, cmd):
+def send_cmd(host:str, cmd:list|str) -> dict:
     """
     Sync wrapper of async _send_cmd (InterCon.send_cmd consumer with retry)
     :param host: hostname / IP address
@@ -167,11 +166,15 @@ def send_cmd(host, cmd):
     """
     def _tagify():
         nonlocal host, cmd
-        _mod = cmd.split(' ')[0].strip()
+        _mod = cmd[0]
         if InterCon.validate_ipv4(host):
             return f"{'.'.join(host.split('.')[-2:])}.{_mod}"
         return f"{host.replace('.local', '')}.{_mod}"
 
+    # Handle legacy string input
+    if isinstance(cmd, str):
+        cmd = cmd.split()
+
     com_obj = InterCon()
     tag = f"con.{_tagify()}"
     started = com_obj.task.create(callback=_send_cmd(host, cmd, com_obj), tag=tag)
@@ -182,7 +185,7 @@ def send_cmd(host, cmd):
     return result
 
 
-def host_cache():
+def host_cache() -> dict:
     """
     Dump InterCon connection cache
     """

micrOS/source/LM_espnow.py

@@ -6,13 +6,14 @@ def load():
     """
     return Espnow.initialize()
 
-def send(peer, msg='modules'):
+def send(peer:bytes|str, msg:str='modules'):
     """
     Send message to peer (by mac address)
     :param peer: mac address of espnow device
     :param msg: message string/load module call
     """
-    return Espnow.espnow_send(peer, msg)
+    now = Espnow.initialize()
+    return now.send(peer, msg)
 
 def start_server():
     """
@@ -20,21 +21,23 @@ def start_server():
     - this can receive espnow messages
     - it includes Load Module execution logic (beta)
     """
-    return Espnow.espnow_server()
+    now = Espnow.initialize()
+    return now.start_server()
 
 def stats():
     """
     Get ESPNOW stats
     """
-    return Espnow.stats()
+    now = Espnow.initialize()
+    return now.stats()
 
-def add_peer(peer):
+def add_peer(peer:bytes, dev_name:str=None):
     """
     Add ESPNOW peer to known hosts
     - It is needed before first send(...)
     """
     now = Espnow.initialize()
-    return Espnow.add_peer(now, peer)
+    return now.add_peer(peer, dev_name)
 
 def mac_address():
     """
@@ -46,4 +49,4 @@ def help():
     """
     [beta] ESPNOW sender/receiver with LM execution
     """
-    return 'load', 'send <peer> "ping"', 'start_server', 'add_peer <peer>', 'stats', 'mac_address'
+    return 'load', 'send <peer> "ping"', 'start_server', 'add_peer <peer> dev_name=None', 'stats', 'mac_address'

micrOS/source/LM_intercon.py

@@ -4,6 +4,7 @@ from Common import syslog
 
 def sendcmd(*args, **kwargs):
     """
+    [!!!] OBSOLETE - NEW SYNTAX: system top >>node01.local
     Implements send command function towards micrOS devices
         example: sendcmd "hello" host="IP/hostname.local") OR sendcmd host="IP/hostname.local" cmd="system rssi")
     :param host[0]: host IP or Hostname
@@ -34,6 +35,7 @@ def sendcmd(*args, **kwargs):
 
 def addr_cache():
     """
+    [!!!] OBSOLETE -> new command: system hosts
     Dump intercon connection cache
     :return dict: device-ip pairs
     """
@@ -46,6 +48,7 @@ def addr_cache():
 
 def help(widgets=False):
     """
+    [!!!] OBSOLETE
     [i] micrOS LM naming convention - built-in help message
     :return tuple:
         (widgets=False) list of functions implemented by this application

micrOS/source/LM_light_sensor.py

@@ -5,12 +5,8 @@ ADC.ATTN_2_5DB — the full range voltage: 1.5V
 ADC.ATTN_6DB — the full range voltage: 2.0V
 ADC.ATTN_11DB — the full range voltage: 3.3V
 """
-from Common import SmartADC, micro_task
+from Common import SmartADC, micro_task, exec_cmd
 from Types import resolve
-try:
-    import LM_intercon as InterCon
-except:
-    InterCon = None
 from microIO import bind_pin, pinmap_search
 
 
@@ -76,19 +72,15 @@ async def _task(on, off, threshold, tolerance=2, check_ms=5000):
             # TURN ON
             if percent <= threshold:
                 if on != last_ev:
-                    if InterCon is not None:
-                        host = on[0]
-                        cmd = ' '.join(on[1:])
-                        InterCon.send_cmd(host, cmd)
-                    my_task.out = f"{percent}% <= threshold: {threshold}% - ON"
+                    host = on[0]
+                    state, _ = exec_cmd(on[1:] + [f">>{host}"], jsonify=True, skip_check=True)
+                    my_task.out = f"{percent}% <= threshold: {threshold}% - ON [{'OK' if state else 'NOK'}]"
                     last_ev = on
             elif percent > threshold+tolerance:     # +tolerance to avoid "on/off/on/off" on threshold limit
                 if off != last_ev:
-                    if InterCon is not None:
-                        host = off[0]
-                        cmd = ' '.join(off[1:])
-                        InterCon.send_cmd(host, cmd)
-                    my_task.out = f"{percent}% > threshold: {threshold+tolerance}% - OFF"
+                    host = off[0]
+                    state, _ = exec_cmd(off[1:] + [f">>{host}"], jsonify=True, skip_check=True)
+                    my_task.out = f"{percent}% > threshold: {threshold+tolerance}% - OFF [{'OK' if state else 'NOK'}]"
                     last_ev = off
             await my_task.feed(sleep_ms=check_ms)   # Sample every <check_ms> sec
 

micrOS/source/LM_mqtt_pro.py

@@ -0,0 +1,211 @@
+# async_message.py Test of asynchronous mqtt client with async Broker class
+# (C) Copyright Peter Hinch 2024.
+# Released under the MIT licence.
+# Public brokers https://github.com/mqtt/mqtt.github.io/wiki/public_brokers
+# mip command: ???
+
+from Config import cfgget
+from mqtt_as import MQTTClient, config
+from Common import micro_task, console, syslog, exec_cmd
+
+
+# Set up MQTT
+class MQTT:
+    CLIENT:MQTTClient = None        # MQTT Client (broker) instance
+    TOPIC = "micros"                # Default topic
+    TOPIC_COMMAND_LUT = {}          # Lookup table for command/topic pairs
+    # Example:
+    #       {"topic1": ["mod func", "mod2 func"], "topic2": []}
+
+
+async def _receiver(task):
+    """
+    MQTT AS receiver loop
+    """
+    async for topic, msg, retained in MQTT.CLIENT.queue:
+        topic, msg = topic.decode(), msg.decode()
+        console(f'Topic: "{topic}" Message: "{msg}" Retained: {retained}')
+
+        # Command execution... use MQTT.TOPIC_COMMAND_LUT
+        topic_commands:list = MQTT.TOPIC_COMMAND_LUT.get(topic, None)
+        output_struct:list = []
+        if topic_commands is None:
+            syslog(f"[WARN] mqtt Unknown topic: {topic}")
+        elif len(topic_commands) == 0:
+            syslog(f"[WARN] mqtt No commands for {topic}")
+        else:
+            task.out = f"Handle topic: {topic}"
+            for cmd in topic_commands:
+                single_command = cmd.split()
+                if len(single_command) > 0:
+                    state, output = exec_cmd(single_command, jsonify=True, skip_check=True)
+                    output_struct.append({"state": state, "result": output, "cmd": cmd})
+            if len(output_struct) > 0:
+                console(f'\tMQTT Publish: {output_struct}')
+                task.out = f"Publish {topic}"
+                MQTT.CLIENT.publish(topic, str(output_struct))
+            else:
+                task.out = f"Nothing to publish {topic}"
+        task.feed()
+
+
+async def _subscribe():
+    """
+    MQTT AS Topic subscribe towards server
+    """
+    with micro_task(tag="mqtt.subscribe") as my_task:
+        my_task.out = "Started"
+        try:
+            for t in MQTT.TOPIC_COMMAND_LUT:
+                console(f"Subscribe topic: {t}")
+                await MQTT.CLIENT.subscribe(t, 1)
+            my_task.out = "Done"
+        except Exception as e:
+            my_task.out = f"Error: {e}"
+
+
+async def _publish(message, topic):
+    """
+    Send message to topic with mqtt
+    """
+    tag = f"mqtt.publish.{topic}"
+    with micro_task(tag=tag) as my_task:
+        console(f"mqtt send: [{topic}] {message}")
+        await MQTT.CLIENT.publish(topic, message, qos=1)
+        my_task.out = "Sent"
+
+
+async def _up():
+    """
+    UP Listener - resubscribe
+    """
+    with micro_task(tag="mqtt.up") as my_task:
+        while True:
+            # Wait for UP Event - (re)subscribe
+            my_task.out = "Wait"
+            await MQTT.CLIENT.up.wait()
+            MQTT.CLIENT.up.clear()
+            micro_task(tag="mqtt.subscribe", task=_subscribe())
+            my_task.out = "Re-Subscription"
+            my_task.feed()
+
+
+async def _init_client(topic:str=None, commands:str=None, raw_dict:dict|None=None):
+    """
+    Initialize main mqtt receiver and topics
+    :param topic: topic string, ex.: 'lights'
+    :param commands: semicolon separated commands. ex.: 'rgb toggle; cct toggle'
+    OR
+    :param raw_dict: python dict string for multi topic subscription, ex.: {"lights": ["rgb toggle", "cct toggle"], ...}
+    """
+    with micro_task(tag="mqtt.client") as my_task:
+        try:
+            await MQTT.CLIENT.connect()
+            my_task.out = "Connection successful."
+        except OSError:
+            my_task.out = "Connection failed."
+            return
+        # Wait for mqtt client connected successfully
+        await MQTT.CLIENT.up.wait()
+        MQTT.CLIENT.up.clear()
+        # Initialize mqtt topics, ha
+        subscribe(topic, commands, raw_dict)
+        micro_task(tag="mqtt.up", task=_up())
+        # Async listener loop
+        await _receiver(my_task)
+        my_task.out = "Receiver closed"
+    # Close when listener exits
+    MQTT.CLIENT.close()
+
+#########################################
+#           PUBLIC FUNCTIONS            #
+#########################################
+
+def publish(message:str, topic:str=MQTT.TOPIC):
+    """
+    Publish message
+    :param message: string to be sent
+    :param topic: topic for message
+    """
+    state = micro_task(tag=f"mqtt.publish.{topic}", task=_publish(message, topic))
+    state = "starting" if state else "already running"
+    return f"Message send, {state}"
+
+
+def subscribe(topic:str=None, commands:str=None, raw_dict:dict|None=None):
+    """
+    Subscribe for single topics and set callback function(s) aka command(s)
+    :param topic: topic string, ex.: 'lights'
+    :param commands: semicolon separated commands. ex.: 'rgb toggle; cct toggle'
+    OR
+    :param raw_dict: python dict string for multi topic subscription, ex.: {"lights": ["rgb toggle", "cct toggle"], ...}
+
+    return: all or selected topics command
+    """
+    updated = False
+    topic = topic.strip()
+    # Register single topic
+    if topic and commands:
+        # raw commands structure: 'rgb toggle; cct toggle'
+        commands = [ c.strip() for c in commands.split(";") ]
+        # commands: Topic LUT structure: {'topic': ['mod func'], ..., 'lights': ['rgb toggle', 'cct toggle']}
+        updated = True if MQTT.TOPIC_COMMAND_LUT.get(topic, None) is None else False
+        MQTT.TOPIC_COMMAND_LUT[topic] = commands
+    # Register multiple topics at once
+    elif isinstance(raw_dict, dict):
+        updated = True
+        MQTT.TOPIC_COMMAND_LUT.update(raw_dict)
+    # Start subscribe task
+    if updated:
+        state = micro_task(tag="mqtt.subscribe", task=_subscribe())
+        state = "starting" if state else "already running"
+        return f"Subscribe, {state}"
+
+    # Return handling
+    if topic is not None:
+        # Return selected topic commands
+        return MQTT.TOPIC_COMMAND_LUT.get(topic, None)
+    # Return registered topics
+    return MQTT.TOPIC_COMMAND_LUT
+
+
+def _configure(server_ip:str, username:str, password:str):
+    # Define configuration
+    config["keepalive"] = 120
+    config["queue_len"] = 1  # Use event interface with default queue
+    # Define configuration
+    config['client_id'] = cfgget("devfid")
+    config['ssid'] = cfgget("staessid")
+    config['wifi_pw'] = cfgget("stapwd")
+    config['port'] = 1883                       # expose????
+    config['server'] = server_ip                # '172.20.10.2'
+    config['user'] = username                   # test
+    config['password'] = password               # '12345'
+    return config
+
+
+def load(server_ip:str, username:str, password:str, topic:str=None, commands:str=None, raw_dict:dict|None=None):
+    """
+    Load MQTT_AS receiver...
+    :param server_ip: server IP address
+    :param username: server user
+    :param password: server user password
+
+    :param topic: topic string, ex.: 'lights'
+    :param commands: semicolon separated commands. ex.: 'rgb toggle; cct toggle'
+    OR
+    :param raw_dict: python dict string for multi topic subscription, ex.: {"lights": ["rgb toggle", "cct toggle"], ...}
+    """
+    MQTTClient.DEBUG = True
+    MQTT.CLIENT = MQTTClient(_configure(server_ip, username, password))
+
+    state = micro_task(tag="mqtt.client", task=_init_client(topic, commands, raw_dict))
+    return "Starting" if state else "Already running"
+
+
+def help():
+    return ("load <server_ip> <username> <password> topic='micros', commands='rgb toggle; cct toggle'",
+            "subscribe topic='micros', commands='rgb toggle; cct toggle'",
+            "subscribe #without params dumps the topic-command data structure",
+            "publish message='hello' topic='micros'",
+            "HINT: task show mqtt.*")

micrOS/source/LM_oled_ui.py

@@ -7,13 +7,9 @@ from Common import syslog, exec_cmd, manage_task
 from machine import Pin
 from Types import resolve
 try:
-    from LM_system import memory_usage
+    from LM_system import memory_usage, hosts
 except:
     memory_usage = None         # Optional function handling
-try:
-    import LM_intercon as InterCon
-except:
-    InterCon = None             # Optional function handling
 try:
     from LM_gameOfLife import next_gen as gol_nextgen, reset as gol_reset
 except:
@@ -228,6 +224,7 @@ class PageUI:
                         self.page_callback_list[self.active_page]()             # <== Execute page functions
                 except Exception as e:
                     PageUI.PAGE_UI_OBJ.show_msg = f"Err: {e}"                   # Show page error in msgbox
+                    syslog(f"oled_ui render error: {e}")
             PageUI.DISPLAY.show()
             self.__power_save()
         else:
@@ -322,7 +319,7 @@ class PageUI:
     #####################################
     #           PAGE GENERATORS         #
     #####################################
-    def intercon_page(self, host, cmd, run=False):
+    def intercon_page(self, host:str, cmd:list, run=False):
         """Generic interconnect page core - create multiple page with it"""
         posx, posy = 5, 12
 
@@ -331,10 +328,13 @@ class PageUI:
             self.open_intercons.append(host)
             try:
                 # Send CMD to other device & show result
-                data_meta = InterCon.send_cmd(host, cmd)
-                self.cmd_task_tag = data_meta['tag']
-                if "Task is Busy" in data_meta['verdict'] and not run:
-                    self.cmd_out = data_meta['verdict']     # Otherwise the task start output not relevant on UI
+                state, data_meta = exec_cmd(cmd + [f">>{host}"], jsonify=True, skip_check=True)
+                if state:
+                    self.cmd_task_tag = data_meta['tag']
+                    if "Task is Busy" in data_meta['verdict'] and not run:
+                        self.cmd_out = data_meta['verdict']     # Otherwise the task start output not relevant on UI
+                else:
+                    self.cmd_out = f"Error: {data_meta}"
             except Exception as e:
                 self.cmd_out = str(e)
             self.open_intercons.remove(host)
@@ -344,7 +344,7 @@ class PageUI:
             return
         # Draw host + cmd details
         PageUI.DISPLAY.text(host, 0, posy)
-        PageUI.DISPLAY.text(cmd, posx, posy+10)
+        PageUI.DISPLAY.text(' '.join(cmd), posx, posy+10)
         # Update display output with retrieved task result (by TaskID)
         if self.cmd_task_tag is not None:
             task_buffer = manage_task(self.cmd_task_tag, 'show').replace(' ', '')
@@ -373,7 +373,7 @@ class PageUI:
             try:
                 cmd_list = cmd.strip().split()
                 # Send CMD to other device & show result
-                state, out = exec_cmd(cmd_list)
+                state, out = exec_cmd(cmd_list, skip_check=True)
                 try:
                     self.cmd_out = ''.join(out.strip().split()).replace(' ', '')
                 except Exception:
@@ -409,13 +409,12 @@ def _sys_page():
 
 
 def _intercon_cache(line_limit=3):
-    if InterCon is None:
-        return False
     line_start = 15
     line_cnt = 1
     PageUI.DISPLAY.text("InterCon cache", 0, line_start)
-    if sum([1 for _ in InterCon.host_cache()]) > 0:
-        for key, val in InterCon.host_cache().items():
+    cache = hosts()["intercon"]
+    if sum([1 for _ in cache]) > 0:
+        for key, val in cache.items():
             key = key.split('.')[0]
             val = '.'.join(val.split('.')[-2:])
             PageUI.DISPLAY.text(f" {val} {key}", 0, line_start+(line_cnt*10))
@@ -502,7 +501,7 @@ def msgbox(msg='micrOS msg'):
     return 'Show msg'
 
 
-def intercon_genpage(cmd=None, run=False):
+def intercon_genpage(cmd:str=None, run=False):
     """
     Create intercon pages dynamically :)
     - based on cmd value.
@@ -512,7 +511,7 @@ def intercon_genpage(cmd=None, run=False):
     """
     raw = cmd.split()
     host = raw[0]
-    cmd = ' '.join(raw[1:])
+    cmd = raw[1:]
     try:
         # Create page for intercon command
         PageUI.PAGE_UI_OBJ.add_page(lambda: PageUI.PAGE_UI_OBJ.intercon_page(host, cmd, run=run))
@@ -522,7 +521,7 @@ def intercon_genpage(cmd=None, run=False):
     return True
 
 
-def cmd_genpage(cmd=None, run=False):
+def cmd_genpage(cmd:str=None, run=False):
     """
     Create load module execution pages dynamically :)
     - based on cmd value: load_module function (args)
@@ -530,9 +529,6 @@ def cmd_genpage(cmd=None, run=False):
     :param run: run button event at page init: True/False
     :return: page creation verdict
     """
-    if not isinstance(cmd, str):
-        return False
-
     try:
         # Create page for intercon command
         PageUI.PAGE_UI_OBJ.add_page(lambda: PageUI.PAGE_UI_OBJ.cmd_call_page(cmd, run=run))