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

toolkit/simulator_lib/aioespnow.py

@@ -0,0 +1,28 @@
+
+
+class AIOESPNow:
+
+    def __init__(self):
+        self._active = False
+        self.peers_table = None
+
+    def active(self, state=None):
+        if state is not None:
+            self._active = state
+        return self._active
+
+    def stats(self):
+        pass
+
+    def add_peer(self, mac):
+        pass
+
+    async def asend(self, mac, full_msg):
+        pass
+
+    def send(self, mac, full_msg):
+        pass
+
+    def __iter__(self):
+        return (i for i in range(0, 3))
+

toolkit/simulator_lib/dht.py

@@ -1,4 +1,4 @@
-from sim_console import console
+from sim_common import console
 
 
 class DHT22:

toolkit/simulator_lib/framebuf.py

@@ -1,6 +1,54 @@
 
 MONO_VLSB = None
+MONO_HMSB = None
 
 
 class FrameBuffer:
-    pass
+
+    def __init__(self, *args, **kwargs):
+        pass
+
+    def fill(self, color=0):
+        pass
+
+    def show(self):
+        pass
+
+    def write_cmd(self, cmd):
+        pass
+
+    def reset(self):
+        pass
+
+    def poweron(self):
+        pass
+
+    def poweroff(self):
+        pass
+
+    def flip(self, *args, **kwargs):
+        pass
+
+    def rotate(self, *args, **kwargs):
+        pass
+
+    def text(self, string, x, y, color=0):
+        pass
+
+    def pixel(self, x, y, color=0):
+        pass
+
+    def line(self, x0, y0, x1, y1, color=0):
+        pass
+
+    def rect(self, x0, y0, x1, y1, color=0):
+        pass
+
+    def fill_rect(self, x, y, w, h, color=0):
+        pass
+
+    def blit(self, fbuf, x, y, key, palette):
+        pass
+
+    def scroll(self, dx, dy):
+        pass

toolkit/simulator_lib/machine.py

@@ -1,8 +1,7 @@
 from threading import Thread
 import time
 import micropython
-from sim_console import console
-import sys
+from sim_common import console
 
 
 def machine(*args, **kwargs):
@@ -173,6 +172,9 @@ class SoftI2C(I2C):
     def __init__(self, scl, sda, freq=None):
         super().__init__(scl, sda, freq)
 
+    def writevto(self, *args, **kwargs):
+       pass
+
 
 class SoftSPI:
     def __init__(self, sck, mosi, miso):
@@ -184,12 +186,21 @@ class UART:
     def __init__(self, pin, baudrate, tx, rx, timeout=1):
         pass
 
+    def init(self, *args, **kwargs):
+        pass
+
+    def deinit(self):
+        pass
+
     def write(self, frame):
         pass
 
     def read(self, *args, **kwargs):
         pass
 
+    def any(self):
+        return False
+
 def freq(*args, **kwargs):
     return 1
 
@@ -214,3 +225,7 @@ def unique_id():
 
 def time_pulse_us():
     return time.time_ns()*1000
+
+
+def SDCard():
+    pass

toolkit/simulator_lib/micropython.py

@@ -1,4 +1,4 @@
-from sim_console import console
+from sim_common import console
 try:
     import resource
 except Exception as e:
@@ -25,8 +25,8 @@ def mem_info(*args, **kwargs):
     return total_heap, used_heap, free_heap
 
 
-def const(*args):
-    return args
+def const(arg):
+    return arg
 
 
 def schedule(callback, arg):

toolkit/simulator_lib/mip.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+
+try:
+    from sim_common import console
+except:
+    console = print
+from pathlib import Path
+from urllib.parse import urlparse
+from urllib.request import urlopen, Request
+import json
+
+
+def _guess_url_is_file(url):
+
+    # 1. URL path contains a filename-like pattern
+    url_content = Path(urlparse(url).path).name
+    if "." in url_content:
+        return True
+
+    # 2. HEAD request content-type
+    try:
+        with urlopen(Request(url, method="HEAD")) as resp:
+            ctype = resp.headers.get("Content-Type", "")
+            if not ctype.startswith("text/html"):
+                return True
+    except Exception as e:
+        if "404" in str(e) or "400" in str(e):
+            return False
+
+    # 4. GET small chunk and detect HTML
+    try:
+        with urlopen(url) as resp:
+            chunk = resp.read(256).lower()
+            if b"<html" in chunk:
+                return False
+    except:
+        pass
+
+    # last fallback: treat as file if unsure
+    return True
+
+
+def _url_file_content(url):
+    data = ""
+    try:
+        with urlopen(url) as resp:
+            data = resp.read()
+    except Exception as e:
+        print()
+        console(f"❌ Failed to read {url}: {e}")
+    return data
+
+
+def _save_file(path, data):
+    try:
+        # Write as binary
+        with open(path, "wb") as f:
+            f.write(data)
+        print(f"✅ Saved {path.parent.name}/{path.name}")
+        return True
+    except Exception as e:
+        console(f"Failed to save {path}: {e}")
+    return False
+
+
+def _github_to_url(ref, branch="master"):
+    if ref.startswith("github"):
+        """
+        Convert: github:peterhinch/micropython-mqtt
+                https://raw.githubusercontent.com/peterhinch/micropython-mqtt/refs/heads/master/mqtt_as/clean.py
+            To: https://raw.githubusercontent.com/peterhinch/micropython-mqtt/refs/heads/master/XXX
+        """
+        base_github_url = "https://raw.githubusercontent.com"
+        _parts = ref.split("/")
+        user = _parts[0].split(":")[-1]
+        repo = _parts[1]
+        file_path = "/".join(_parts[2:])
+        branch = f"refs/heads/{branch}"
+        if "." in file_path:
+            # File mode - Build raw URL
+            ref = f"{base_github_url}/{user}/{repo}/{branch}/{file_path}"
+        else:
+            # Folder mode - Build raw URL
+            ref = f"{base_github_url}/{user}/{repo}/{branch}/{file_path}"
+        return ref
+    return None
+
+
+def _mip_emu(ref, target:Path=Path("lib"), version:str="master"):
+    """
+    Tiny simulation of MicroPython's mip.install for normal Python.
+    """
+    installed = []
+
+    if isinstance(ref, str) and (ref.startswith("http") or ref.startswith("github")):
+
+        if ref.startswith("github"):
+            url = _github_to_url(ref, branch=version)
+            if url is None:
+                console(f"Invalid GitHub URL: {ref}")
+                return []
+        else:
+            url = ref
+        dest = target / Path(urlparse(url).path).name
+
+        if not _guess_url_is_file(url):
+            # Folder mode, redirect to package.json
+            url = f"{url.rstrip('/')}/package.json"
+            dest = target / Path(urlparse(url).path).name
+            console(f"Patch url (dir) to point to package.json: {url}")
+        try:
+            # File mode
+            print(f"🔻 Downloading {url} to {dest}", end="")
+            data = _url_file_content(url)
+            print(f" ({len(data)} bytes)")
+        except Exception as e:
+            console(f"❌ Failed to read {url}: {e}")
+            return []
+
+        if url.endswith("package.json"):
+            # Install based on package.json content
+            package_json_data = json.loads(data)
+            package_urls = package_json_data.get("urls", [])
+            for file_url in package_urls:
+                pack_source_file = file_url[1]
+                if pack_source_file.startswith("github"):
+                    pack_source_file = _github_to_url(pack_source_file, branch=version)
+                pack_dest_file = Path(file_url[0])
+                pack_dest_dir = target / pack_dest_file.parent
+                pack_dest_dir.mkdir(parents=True, exist_ok=True)
+                pack_dest_file = pack_dest_dir / pack_dest_file.name
+                print(f"File download: {pack_source_file} -> {pack_dest_file}")
+                data = _url_file_content(pack_source_file)
+                if data:
+                    if _save_file(pack_dest_file, data):
+                        installed.append(pack_dest_dir.name)
+        else:
+            if data:
+                # Install based on file content - save url body to file
+                if _save_file(dest, data):
+                    installed.append(dest.name)
+    return installed
+
+
+def _dump_dir_content(target):
+    # Dump content
+    base_path = str(target.parent)
+    for item in target.iterdir():
+        print(f" 🗂️ {str(item).replace(base_path, '')}")
+        if item.is_dir():
+            for subitem in item.iterdir():
+                print(f"   {str(subitem).replace(base_path, '')}")
+        print("")
+
+
+def install(ref, **kwargs):
+    target = kwargs.get("target", Path.cwd() / "lib")
+    version = kwargs.get("version", "master")
+    console(f">>> mip install: {ref} {kwargs}")
+    if isinstance(target, str):
+        target = Path(target)
+    # Run mip emulation
+    _mip_emu(ref, target=target, version=version)
+    # Dump content
+    _dump_dir_content(target)

toolkit/simulator_lib/neopixel.py

@@ -1,4 +1,4 @@
-
+from sim_common import console
 
 class NeoPixel:
     __instance = None
@@ -17,9 +17,10 @@ class NeoPixel:
         return cls.__pix_list[key]
 
     def __setitem__(cls, key, value):
+        console(f"Update NeoPixel at index {key} to {value}")
         cls.__pix_list[key] = value
 
     def write(cls):
-        pass
+        console(f"Neopixel write: {cls.__pix_list}")
 
 

toolkit/simulator_lib/network.py

@@ -1,4 +1,4 @@
-from sim_console import console
+from sim_common import console
 import socket
 
 AP_IF = "DUMMY_AP_IF"
@@ -45,6 +45,7 @@ class WLAN:
             self.__config_dict[key] = value
         for key in args:
             return self.__config_dict.get(key, None)
+        return None
 
     def ifconfig(self, addr_tuple=None):
         console("Local server IP: {}".format(self.__get_machine_ip()))

toolkit/simulator_lib/node_config.json

@@ -2,6 +2,5 @@
   "devfid": "simulator",
   "appwd": "ADmin123",
   "webui": true,
-  "boothook": "dashboard_be load; neopixel load; #system top",
-  "aioqueue": 4,
-  "telegram": "6185435843:AAH71wEyoOil8bRKecQHp4zazTQ_MmE7bvE"}
+  "boothook": "web load dashboard=True fileserver=True fs_explore=True; fileserver mounts_write_access modules=True logs=True pwd=$pwd; neopixel load; #telegram load '6185435843:AAH71wEyoOil8bRKecQHp4zazTQ_MmE7bvE' &; #telegram receiver_loop &2000",
+  "aioqueue": 4}

toolkit/simulator_lib/ntptime.py

@@ -1,4 +1,4 @@
-from sim_console import console
+from sim_common import console
 
 
 def settime(*args, **kwargs):

toolkit/simulator_lib/{sim_console.py → sim_common.py}

@@ -1,8 +1,6 @@
 import sys
 import os
-#MYPATH = os.path.dirname(os.path.abspath(__file__))
-#DEV_ENV_DIR = os.path.dirname(MYPATH)
-#sys.path.append(DEV_ENV_DIR)
+import time
 
 print("Module [sim_console] path: {} __package__: {} __name__: {}".format(sys.path[0], __package__, __name__))
 
@@ -16,6 +14,7 @@ except Exception as e:
     print("TerminalColors import error: {}".format(e))
     Colors = None
 
+
 def console(msg, end='\n', skip_tmp_msgs=True):
     if end == '\r' and skip_tmp_msgs:
         return

toolkit/simulator_lib/simgc.py

@@ -6,6 +6,10 @@ except Exception as e:
 
 MEM_BASELOAD = None
 
+class MockMemory:
+    USED = 200_000      # 200 kb default memory usage
+    FREE = 1000_000     # 1 Mb default free memory
+
 def _get_memory_usage():
     global  MEM_BASELOAD
     if psutil:
@@ -16,7 +20,7 @@ def _get_memory_usage():
         if MEM_BASELOAD is None:
             MEM_BASELOAD = 0
         return memory_usage_bytes - MEM_BASELOAD
-    return -1000
+    return MockMemory.USED
 
 
 MEM_BASELOAD = _get_memory_usage()      # HACK: GET MEM BASELOAD - CLOSEST TO REALITY - GET REAL MICROS MEM USAGE
@@ -28,7 +32,7 @@ def _get_free_memory():
         # Free memory in bytes
         free_memory_bytes = virtual_memory.available
         return free_memory_bytes
-    return -1000
+    return MockMemory.FREE
 
 
 def mem_free(*args, **kwargs):

toolkit/simulator_lib/simulator.py

@@ -4,24 +4,58 @@ import multiprocessing
 import time
 import copy
 import json
+from pathlib import Path
 
 MYPATH = os.path.dirname(__file__)
 SIM_PATH = os.path.join(MYPATH, '../workspace/simulator')
-sys.path.insert(0, SIM_PATH)
-sys.path.insert(0, os.path.join(MYPATH, '../lib'))
-from sim_console import console
+PACKAGES_PATH = os.path.join(MYPATH, '../../micrOS/packages/')
+sys.path.insert(0, SIM_PATH)                         # Add Sim to path
+sys.path.append(os.path.join(MYPATH, '../lib'))             # Add devtoolkit/lib to path
+from sim_common import console
 import micrOSloader
 import LocalMachine
+if os.path.exists(PACKAGES_PATH):
+    sys.path.append(PACKAGES_PATH)
+    try:
+        import _tools.unpack as package_unpack
+    except ImportError:
+        print(f"[WARNING] Import error Packages._tools: {PACKAGES_PATH}")
+        package_unpack = None
+else:
+    print(f"[WARNING] No Packages._tools available: {PACKAGES_PATH}")
+    package_unpack = None
 
+# Enable/Disable Simulator Config and Packages import
 ENABLE_SIM_CONFIG = True
+ENABLE_SIM_PACKAGES = True
+EXTERNAL_LOAD_MODULES_FROM_PACKAGES = []
 
 
-def apply_sim_node_config():
+def apply_sim_patch():
+    """
+    Apply Config and more
+    """
+    global EXTERNAL_LOAD_MODULES_FROM_PACKAGES
+
+    # APPLY SIM CONFIG - for testing: enable webui, etc...
     if ENABLE_SIM_CONFIG:
         print("Copy SIM config - for testing: enable webui, etc.")
         sim_config = os.path.join(MYPATH, 'node_config.json')
         LocalMachine.FileHandler().copy(sim_config, os.path.join(SIM_PATH))
 
+    if ENABLE_SIM_PACKAGES and package_unpack is not None:
+        overwritten_files, ext_load_module = package_unpack.unpack_all(Path(SIM_PATH))
+        for mod in overwritten_files:
+            print(f"\t⚠️ [SIM][UNPACK] Overwritten file from packages submodule: {mod}")
+        EXTERNAL_LOAD_MODULES_FROM_PACKAGES = [elm.lstrip("LM_").split(".")[0] for elm in ext_load_module if elm.startswith("LM_")]
+        # Time module patch - extend with basic micropython utime features for micrOS Simulator
+        import utime
+        time.ticks_ms = utime.ticks_ms
+        time.ticks_diff = utime.ticks_diff
+        #sys.modules['time'] = time
+    else:
+        print("⚠️ [SIM][UNPACK] Package unpacking disabled or package_unpack module not available.")
+
 
 class micrOSIM():
     SIM_PROCESS_LIST = []
@@ -29,6 +63,7 @@ class micrOSIM():
     def __init__(self, doc_resolve=False):
         if doc_resolve:
             console("[micrOSIM] Create micrOS LM doc (env proc)")
+            self._init_sim_doc_resolve()
             # json_structure, html_structure
             self.doc_output = (None, None)
         else:
@@ -38,7 +73,20 @@ class micrOSIM():
             self.pid = None
             micrOSIM.SIM_PROCESS_LIST.append(self.process)
 
+    def _init_sim_doc_resolve(self):
+        """
+        Init micrOS in simulator - folder structure creation
+        """
+        apply_sim_patch()
+        sim_path = LocalMachine.SimplePopPushd()
+        sim_path.pushd(SIM_PATH)
+        import micrOS               # Init micrOS - DO NOT REMOVE
+        sim_path.popd()
+
     def micrOS_sim_worker(self, trace=False):
+        """
+        Start micrOS in python simulator
+        """
         sim_path = LocalMachine.SimplePopPushd()
         sim_path.pushd(SIM_PATH)
         console("[micrOSIM] Start micrOS loader in: {}".format(SIM_PATH))
@@ -58,7 +106,7 @@ class micrOSIM():
             # Trace handling - DEBUG
             sys.settrace(trace_func)
 
-        apply_sim_node_config()
+        apply_sim_patch()
         micrOSloader.main()
 
         console("[micrOSIM] Stop micrOS ({})".format(SIM_PATH))
@@ -102,14 +150,77 @@ class micrOSIM():
             console("[micrOSIM] Proc was finished: {}/{}".format(i+1, proc_len))
         micrOSIM.SIM_PROCESS_LIST = []
 
+    @staticmethod
+    def _lm_doc_builder(mod, func_dict, structure, structure_to_html):
+        # Embed img url to table - module level
+        img_url = structure[mod]['img']
+        structure_to_html[mod]['img'] = f'<img src="{img_url}" alt="{mod}" height=150>'
+        # Parse function doc strings
+        for func in func_dict:
+            # -- Skip functions --
+            if not isinstance(structure[mod][func], dict):
+                continue
+            # -- Skip functions --
+
+            console(f"[micrOSIM][Extract doc-str] LM_{mod}.{func}.__doc__")
+            try:
+                # Get function doc string
+                exec(f"from modules import LM_{mod}")
+                doc_str = eval(f"LM_{mod}.{func}.__doc__")
+                # Get function pin map
+                if func == 'pinmap':
+                    # Get module pin map - module level
+                    console(f"[micrOSIM][Extract pin map tokens] LM_{mod}.pinmap()")
+                    try:
+                        mod_pinmap = eval(f"LM_{mod}.pinmap()")
+                        if mod_pinmap is not None:
+                            mod_pinmap = ', '.join(dict(mod_pinmap).keys())
+                            mod_pinmap = f"\npin map: {mod_pinmap}"
+                    except:
+                        mod_pinmap = ''
+                    # Add pinmap to doc string of pinmap() function
+                    doc_str = "" if doc_str is None else doc_str
+                    doc_str += mod_pinmap
+                if func == 'help':
+                    console(f"[micrOSIM][Render widgets from help] LM_{mod}.help(True)")
+                    if f"{mod}" in EXTERNAL_LOAD_MODULES_FROM_PACKAGES:
+                        mod_help = f"\n\tEXTERNAL PACKAGE: https://github.com/BxNxM/micrOSPackages"
+                    else:
+                        mod_help = ""
+                    mod_help += f"\n[i] micrOS Widget Types:"
+                    try:
+                        widgets_help = eval(f"LM_{mod}.help(True)")
+                        if widgets_help is not None and isinstance(widgets_help, tuple):
+                            for widget in widgets_help:
+                                widget = json.loads(widget)
+                                mod_help += f"\n\t{widget}"
+                    except:
+                        mod_help += '\n\tN/A'
+                    # Add help renderes widgets to doc string
+                    doc_str = "" if doc_str is None else doc_str
+                    doc_str += mod_help
+            except Exception as e:
+                doc_str = str(e)
+            # Update structure with doc-str
+            structure[mod][func]['doc'] = doc_str
+            structure_to_html[mod][func]['doc'] = 'No doc string available' if doc_str is None else doc_str.strip() \
+                .replace('\n', '<br>\n').replace(' ', '&nbsp;')
+            # Remove empty param(s) cells
+            param_cell = structure_to_html[mod][func].get('param(s)', None)
+            if param_cell is not None and len(param_cell.strip()) == 0:
+                structure_to_html[mod][func].pop('param(s)')
+
+
     def _lm_doc_strings(self, structure):
         """
         Collect function doc strings and module logical pins (pin map)
-        Create 2 dict structures adding docstring
-        - html hack structure
-        - json raw structure
+        Create 4 dict structures adding docstring
+        - html json + raw json for built-in modules
+        - html json + raw json for external (installable packages) modules
         """
         structure_to_html = copy.deepcopy(structure)
+        structure_ext_to_html = copy.deepcopy(structure)
+        structure_external = copy.deepcopy(structure)
 
         # Step into workspace path
         popd = LocalMachine.SimplePopPushd()
@@ -118,60 +229,27 @@ class micrOSIM():
         # Based on created module-function structure collect doc strings
         for mod, func_dict in structure.items():
             # Embed img url to table - module level
-            img_url = structure[mod]['img']
-            structure_to_html[mod]['img'] = f'<img src="{img_url}" alt="{mod}" height=150>'
-            # Parse function doc strings
-            for func in func_dict:
-                # -- Skip functions --
-                if not isinstance(structure[mod][func], dict):
-                    continue
-                # -- Skip functions --
-
-                console(f"[micrOSIM][Extract doc-str] LM_{mod}.{func}.__doc__")
-                try:
-                    # Get function doc string
-                    exec(f"import LM_{mod}")
-                    doc_str = eval(f"LM_{mod}.{func}.__doc__")
-                    # Get function pin map
-                    if func == 'pinmap':
-                        # Get module pin map - module level
-                        console(f"[micrOSIM][Extract pin map tokens] LM_{mod}.pinmap()")
-                        try:
-                            mod_pinmap = eval(f"LM_{mod}.pinmap()")
-                            if mod_pinmap is not None:
-                                mod_pinmap = ', '.join(dict(mod_pinmap).keys())
-                                mod_pinmap = f"\npin map: {mod_pinmap}"
-                        except:
-                            mod_pinmap = ''
-                        # Add pinmap to doc string of pinmap() function
-                        doc_str += mod_pinmap
-                    if func == 'help':
-                        console(f"[micrOSIM][Render widgets from help] LM_{mod}.help(True)")
-                        mod_help = f"\n[i] micrOS Widget Types:"
-                        try:
-                            widgets_help = eval(f"LM_{mod}.help(True)")
-                            if widgets_help is not None and isinstance(widgets_help, tuple):
-                                for widget in widgets_help:
-                                    widget = json.loads(widget)
-                                    mod_help += f"\n\t{widget}"
-                        except:
-                            mod_help += '\n\tN/A'
-                        # Add help renderes widgets to doc string
-                        doc_str += mod_help
-                except Exception as e:
-                    doc_str = str(e)
-                # Update structure with doc-str
-                structure[mod][func]['doc'] = doc_str
-                structure_to_html[mod][func]['doc'] = 'No doc string available' if doc_str is None else doc_str.strip()\
-                    .replace('\n', '<br>\n').replace(' ', '&nbsp;')
-                # Remove empty param(s) cells
-                param_cell = structure_to_html[mod][func].get('param(s)', None)
-                if param_cell is not None and len(param_cell.strip()) == 0:
-                    structure_to_html[mod][func].pop('param(s)')
+            if mod in EXTERNAL_LOAD_MODULES_FROM_PACKAGES:
+                # EXTERNAL MODULE STRUCTURE
+                self._lm_doc_builder(mod, func_dict, structure_external, structure_ext_to_html)
+            else:
+                # BUILT-IN MODULE STRUCTURE
+                self._lm_doc_builder(mod, func_dict, structure, structure_to_html)
+        # CLEANUP DUPLICATES:
+        for mod, func_dict in structure_external.items():
+            if mod in EXTERNAL_LOAD_MODULES_FROM_PACKAGES:
+                # Remove mod from built-ins
+                del structure[mod]
+                del structure_to_html[mod]
+        for mod, func_dict in structure.items():
+            if mod not in EXTERNAL_LOAD_MODULES_FROM_PACKAGES:
+                # Remove mod from external packages
+                del structure_external[mod]
+                del structure_ext_to_html[mod]
 
         # restore path
         popd.popd()
-        self.doc_output = (structure, structure_to_html)
+        self.doc_output = (structure, structure_to_html, structure_external, structure_ext_to_html)
 
     def gen_lm_doc_json_html(self, structure):
         try: