micrOSDevToolKit 2.9.10__py3-none-any.whl → 2.10.2__py3-none-any.whl

micrOS/source/LM_telegram.py

@@ -4,6 +4,11 @@ from Notify import Notify
 from Config import cfgget
 from Common import micro_task, syslog, console_write
 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):
@@ -106,12 +111,12 @@ class Telegram(Notify):
         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:
+            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)
@@ -135,7 +140,7 @@ class Telegram(Notify):
             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}")
+        console_write(f"\t[GET] request: {url}")
 
         _, resp_json = urequests.get(url, jsonify=True, sock_size=128)
 
@@ -145,7 +150,7 @@ class Telegram(Notify):
             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[GET] response: {response}")
         return response
 
     @staticmethod
@@ -160,7 +165,7 @@ class Telegram(Notify):
             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}")
+        console_write(f"\t[aGET] request: {url}")
 
         _, resp_json = await urequests.aget(url, jsonify=True, sock_size=128)
 
@@ -170,7 +175,7 @@ class Telegram(Notify):
             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
@@ -183,14 +188,14 @@ class Telegram(Notify):
         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)
             if access:
-                verdict = f'[UP] Exec: {" ".join(cmd_args[0])}'
+                verdict = f'{_timestamp()} [UP] 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] NoAccess: {cmd_args[0]}'
                 Telegram._IN_MSG_ID = m_id
 
         # -------------------------- FUNCTION MAIN -------------------------- #
@@ -211,12 +216,12 @@ 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:
@@ -226,8 +231,7 @@ class Telegram(Notify):
                 # Send is still synchronous (OK)
                 Telegram.send_msg(verdict, reply_to=m_id)
         else:
-            verdict = "[UP] NoExec"
-        console_write(f"\tBOT: {verdict}")
+            verdict = f"{_timestamp()} [UP] NoExec"
         return verdict
 
     @staticmethod
@@ -241,11 +245,12 @@ class Telegram(Notify):
         period = period if period > 0 else 1
         period_ms = period * 1000
         with micro_task(tag=tag) as my_task:
-            my_task.out = "[UP] Running"
+            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
@@ -254,7 +259,7 @@ class Telegram(Notify):
                     # 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} (wait 1min)"
+                        my_task.out = f"{_timestamp()} [DOWN] {e} (wait 1min)"
                         cancel_cnt = 5
                         # SLOW DOWN - hibernate task
                         await my_task.feed(sleep_ms=60_000)

micrOS/source/Shell.py

@@ -25,7 +25,7 @@ from Debug import errlog_add
 
 class Shell:
     __slots__ = ['__devfid', '__auth_mode', '__hwuid', '__auth_ok', '__conf_mode']
-    MICROS_VERSION = '2.9.9-0'
+    MICROS_VERSION = '2.10.2-0'
 
     def __init__(self):
         """
@@ -106,6 +106,7 @@ class Shell:
             # No msg to work with
             return True
         msg_list = msg.strip().split()
+        local_cmd = not msg_list[-1].startswith(">>")   # intercon request check for shell commands
 
         ##########################################
         #   [1] Handle built-in shell commands   #
@@ -113,7 +114,7 @@ class Shell:
         ##########################################
 
         # Hello message
-        if msg_list[0] == 'hello':
+        if local_cmd and msg_list[0] == 'hello':
             # For low level device identification - hello msg
             await self.a_send(f"hello:{self.__devfid}:{self.__hwuid}")
             return True
@@ -126,60 +127,62 @@ class Shell:
             return True
 
         # Version handling
-        if msg_list[0] == 'version':
+        if local_cmd and msg_list[0] == 'version':
             # For micrOS system version info
             await self.a_send(str(Shell.MICROS_VERSION))
             return True
 
         # Reboot micropython VM
-        if msg_list[0] == 'reboot':
+        if local_cmd and msg_list[0] == 'reboot':
             hard = False
             if len(msg_list) >= 2 and "-h" in msg_list[1]:
                 # reboot / reboot -h
                 hard = True
             await self.reboot(hard)
 
-        if msg_list[0].startswith('webrepl'):
+        if local_cmd and msg_list[0].startswith('webrepl'):
             if len(msg_list) == 2 and '-u' in msg_list[1]:
                 await Shell.webrepl(msg_obj=self.a_send, update=True)
             return await Shell.webrepl(msg_obj=self.a_send)
 
         # CONFIGURE MODE STATE: ACCESS FOR NODE_CONFIG.JSON
-        if msg_list[0].startswith('conf'):
+        if local_cmd and msg_list[0].startswith('conf'):
             self.__conf_mode = True
             return True
-        if msg_list[0].startswith('noconf'):
+        if local_cmd and msg_list[0].startswith('noconf'):
             self.__conf_mode = False
             return True
 
         # HELP MSG
-        if msg_list[0] == "help":
-            await self.a_send("[MICROS]   - built-in shell commands")
-            await self.a_send("   hello   - hello msg - for device identification")
-            await self.a_send("   modules - show active Load Modules")
-            await self.a_send("   version - returns micrOS version")
-            await self.a_send("   exit    - exit from shell socket prompt")
-            await self.a_send("   reboot  - system soft reboot (vm), hard reboot (hw): reboot -h")
-            await self.a_send("   webrepl - start webrepl, for file transfers use with --update")
+        if local_cmd and msg_list[0] == "help":
+            await self.a_send("[MICROS]     - built-in shell commands")
+            await self.a_send("   hello     - hello msg - for device identification")
+            await self.a_send("   modules   - show active Load Modules")
+            await self.a_send("   version   - returns micrOS version")
+            await self.a_send("   exit      - exit from shell socket prompt")
+            await self.a_send("   reboot    - system soft reboot (vm), hard reboot (hw): reboot -h")
+            await self.a_send("   webrepl   - start webrepl, for file transfers use with --update")
             await self.a_send("[CONF] Configure mode - built-in shell commands")
             await self.a_send("  conf       - Enter conf mode")
             await self.a_send("    dump       - Dump all data")
             await self.a_send("    key        - Get value")
             await self.a_send("    key value  - Set value")
             await self.a_send("  noconf     - Exit conf mode")
-            await self.a_send("[TASK] postfix: &x - one-time,  &&x - periodic, x: wait ms [x min: 20ms]")
-            await self.a_send("  task list         - list tasks with <tag>s")
+            await self.a_send("[TASK] postfix: ...&x - one-time, ...&&x - periodic, x: wait ms [x min: 20ms]")
+            await self.a_send("  task list         - list tasks by <tag>s")
             await self.a_send("  task kill <tag>   - stop task")
             await self.a_send("  task show <tag>   - show task output")
             await self.a_send("[EXEC] Command mode (LMs):")
-            await self.a_send("   help lm  - list ALL LoadModules")
+            await self.a_send("  >>node01.local    - INTERCON postfix, execute command on remote device")
+            await self.a_send("  >json             - JSON postfix, request json formatted output")
+            await self.a_send("  help lm           - list ALL LoadModules")
             if "lm" in str(msg_list):
                 return await Shell._show_lm_funcs(msg_obj=self.a_send)
             return await Shell._show_lm_funcs(msg_obj=self.a_send, active_only=True)
 
         # [2] EXECUTE:
         # @1 Configure mode
-        if self.__conf_mode and len(msg_list) > 0:
+        if local_cmd and self.__conf_mode and len(msg_list) > 0:
             # Lock thread under config handling is threads available
             return await Shell._configure(self.a_send, msg_list)
         # @2 Command mode

micrOS/source/Tasks.py

@@ -199,12 +199,9 @@ class MagicTask(TaskBase):
         - self.__inloop: lm call type - one-shot (False) / looped (True)
         - self.__msg_buf: lm msg object redirect to variable - store lm output
         """
-        jsonify = self.__callback[-1] == '>json'
-        if jsonify:
-            self.__callback = self.__callback[:-1]
         while True:
             await self.feed(self.__sleep)
-            state, self.out = _exec_lm_core(self.__callback, jsonify)
+            state, self.out = _exec_lm_core(self.__callback)
             if not state or not self.__inloop:
                 break
         self.task_gc()    # Task pool cleanup
@@ -227,6 +224,7 @@ class Manager:
     __slots__ = ['_initialized', 'idle_counter']
     INSTANCE = None                      # Manager object
     LOAD = 0                             # CPU overload measure
+    INTERCON = None                      # Dynamic ref. for interconnect calls
 
     def __new__(cls):
         """
@@ -419,19 +417,34 @@ def exec_builtins(func):
     - modules         - show active modules list
     - task kill ...   - task termination
            show ...   - task output dump
-    -  ... >json      - postfix to "jsonize" the output
+    -  ... >json      - postfix to jsonify the output
     """
-    def wrapper(arg_list, jsonify=None):
+    def wrapper(arg_list:list, jsonify=None):
         # Ensure the parameter is a list of strings
         if isinstance(arg_list, list) and arg_list:
-            # JSONIFY: [1] >json in arg_list or [2] jsonify True/False
-            json_flag = arg_list[-1] == '>json'
-            if json_flag:
-                arg_list = arg_list[:-1]
+            # Postfix operator handling
+            # ... >json               - command output format option
+            # ... >>node01.local      - intercon: command execution on remote device by hostname/IP address
+            arg_list, json_flag = (arg_list[:-1], True) if arg_list[-1] == '>json' else (arg_list, False)
+            arg_list, intercon_target = (arg_list[:-1], arg_list[-1].replace(">>", "")) if arg_list[-1].startswith('>>') else (arg_list, None)
             json_flag = jsonify if isinstance(jsonify, bool) else json_flag
+
+            # INTERCONNECT
+            if intercon_target:
+                if Manager.INTERCON is None:
+                    from InterConnect import send_cmd
+                    Manager.INTERCON = send_cmd
+                try:
+                    out = Manager.INTERCON(host=intercon_target, cmd=arg_list)
+                except Exception as e:
+                    out = {}
+                    errlog_add(f"[ERR] Intercon: {e}")
+                return True, out
+
             # MODULES
             if arg_list[0] == 'modules':
                 return True, list((m.strip().replace('LM_', '') for m in modules if m.startswith('LM_'))) + ['task']
+
             # Handle task manipulation commands: list, kill, show - return True -> Command handled
             if 'task' == arg_list[0]:
                 arg_len = len(arg_list)
@@ -448,13 +461,13 @@ def exec_builtins(func):
                     if 'show' == arg_list[1]:
                         return True, Manager.show(tag=arg_list[2])
                 return True, "Invalid task cmd! Help: task list / kill <taskID> / show <taskID>"
+
             # Call the decorated function with the additional flag
             return func(arg_list, json_flag)
     return wrapper
 
 
-@exec_builtins
-def lm_exec(arg_list, jsonify):
+def lm_exec(arg_list:list, jsonify:bool=None):
     """
     Main LM executor function with
     - async (background)
@@ -489,6 +502,7 @@ def lm_exec(arg_list, jsonify):
     return state, out
 
 
+@exec_builtins
 def _exec_lm_core(cmd_list, jsonify):
     """
     [CORE] Single command executor: MODULE.FUNCTION...
@@ -535,11 +549,12 @@ def _exec_lm_core(cmd_list, jsonify):
             # ------------ LM output format: dict(jsonify) / str(raw) ------------- #
             # Handle LM output data
             if isinstance(lm_output, dict):
-                # json True: output->json else Format dict output "human readable"
+                # jsonify (True) json output, (False) default, "human readable" output)
                 lm_output = dumps(lm_output) if jsonify else '\n'.join(
                     [f" {key}: {value}" for key, value in lm_output.items()])
             if lm_func == 'help':
-                # Special case for help command: json True: output->json else Format dict output "human readable"
+                # Special case:
+                #   jsonify (True) json output, (False) default, "human readable" formatted output)
                 lm_output = dumps(lm_output) if jsonify else '\n'.join([f" {out}," for out in lm_output])
             # Return LM exec result
             return True, str(lm_output)
@@ -582,7 +597,7 @@ def exec_lm_pipe(taskstr):
         for cmd in (cmd.strip().split() for cmd in taskstr.split(';') if len(cmd) > 0):
             if len(cmd) > 0 and cmd[0].startswith("#"):
                 console_write(f"[SKIP] exec_lm_pipe: {' '.join(cmd)}")
-                return True
+                continue
             if not lm_exec(cmd)[0]:
                 errlog_add(f"[WARN] exec_lm_pipe: {cmd}")
     except Exception as e:

micrOS/source/Web.py

@@ -102,8 +102,9 @@ class WebEngine:
         cmd = url.replace('/rest', '')
         if len(cmd) > 1:
             # REST sub-parameter handling (rest commands)
-            cmd = (cmd.replace('/', ' ').replace('%22', '"').replace('%E2%80%9C', '"')
-                   .replace('%E2%80%9D', '"').replace('-', ' ').strip().split())
+            cmd = (cmd.replace('/', ' ').replace('-', ' ').replace("%3E", ">")
+                   .replace('%22', '"').replace('%E2%80%9C', '"').replace('%E2%80%9D', '"')
+                   .strip().split())
             # EXECUTE COMMAND - LoadModule
             if WebEngine.AUTH:
                 state, out = lm_exec(cmd, jsonify=True) if lm_is_loaded(cmd[0]) else (True, 'Auth:Protected')

{micrOSDevToolKit-2.9.10.dist-info → micrOSDevToolKit-2.10.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: micrOSDevToolKit
-Version: 2.9.10
+Version: 2.10.2
 Summary: Development and deployment environment for micrOS, the diy micropython automation OS (IoT)
 Home-page: https://github.com/BxNxM/micrOS
 Author: Marcell Ban
@@ -126,14 +126,6 @@ Link for python 3.9+ [download](https://www.python.org/downloads/release/python-
 > Note: **Allow extend system path** with that python version (installation parameter) </br>
 > On **Windows**: RUN AS ADMINISTARTOR
 
-### 1.2 Install git
-
-Link for git [download](https://git-scm.com/downloads)
-
-> Git is a distributed version control system that helps developers track changes, collaborate on code, and manage project history efficiently.
-
-It is needed to be able to download webrepl client (automatic), that is used for OverTheAir file transfers and other features.
-
 ----------------------------------------
 
 ### 2. Install micrOS devToolKit GUI
@@ -495,29 +487,74 @@ Official [DockerHub](https://hub.docker.com/repository/docker/bxnxm/micros-gatew
 
 ## FUTURE RELEASE PLANS
 
-Version **3.0.0-0**
+Version **3.0.0-0** `micrOS-Autonomous`
 
 ```
     Core:
-    - Async SSL/TLS integration (micropython 1.22+ required)
-        - urequest module async redesign for rest clients
-            - LM_telegram (Notify) + server (listener - chatbot)
-            - Time (ntp location + sunset/sunrise api)
-    - ESP-NOW (peer-to-peer communication) integration into InterCon
-    - ??? New intercon syntax ???:
+    - (1) Async SSL/TLS integration (micropython 1.22+ required)                [DONE]
+        - urequest module async redesign for rest clients                       [OK]
+            - LM_telegram (Notify) + server (listener - chatbot)                [OK]
+    - (2) ESP-NOW (peer-to-peer communication) integration into InterCon        [PoC:OK][TODO]
+    - (3) New intercon syntax - command level integration:                      [DONE]
     	- rgb toggle >>RingLight.local
-    	- similar as: intercon sendcmd host="RingLight.local" cmd="rgb toggle"
+    	- similar as (obsolete): intercon sendcmd host="RingLight.local" cmd="rgb toggle"
+    - (4) Create multi level project structure (curret is flat fs)               [TODO?] FS
+		- New micrOS FS structure:
+			- Note:
+				- On device (boot) micrOS Hooks.py/os_dir_fs_hook (check+correct)  [Phase1-FS:TODO]
+				- DevToolKit USB & OTA feature adaptation                          [Phase2-FS:TODO]
+					- os_dir_fs_handler (usb+webrepl) features
+
+			- root fs (stays untouched (approx.: 24)): /
+				- micrOS.py (core)
+				- Config.py (core)
+				- Tasks.py (core)
+				- Shell.py (core)
+				- Web.py (core)
+				- Server.py (core)
+				- node_config,json (core config)
+				- etc... (core)
+
+			- module folder - mip complient: /lib
+				- LM_* (approx.: 54)
+				- IO_* (approx.: 5)
+				- *.py/.mpy (driver)
+				- Dynamic/Runtime (approx.: 0-8):
+					- *.pds (LM app cache - persistent data storage)
+					- *.dat (Common datalogger output)
+
+			- web folder: /web
+				- *.html
+				- *.js
+				- *.css
+
+			- /logs
+				- still there (created runtime) 
+
+		- (5) Proper mip installer support (/lib)                                [TODO]
+			- Note: Autonomous package management over wifi (github) 
+				- pacman download
+				- pacman ls
+				- pacman dirtree
+				- pacman ...
 ```
 
-Version **3.1.0-0**
+Version **3.1.0-0** `micrOS-SecurePower`
 
 ```
     Core:
     - Async socket servers with SSL/TLS integration (with auth.)
         - WebCli (https?), ShellCli (ssocket/sterminal) and InterCon
+    - Low power mode with ESPNOW + (AP mode?)
+    	- Remote controller / Sensor UseCase
+    	- --- client mode (fyi: normally micrOS operates in server mode) 
+    - Intercon-Wire (?)
+    	- Idea of wired message communication protocol same as Intercon-Shell/Intercon-espnow
+    	- Possible HW protocols: i2c / onewire / uart BUT it should support bidirectional message transfers
+    	- Goal: CoProcessor easy integration feature - Arduino env support 
 ```
 
-Version **4.0.0-0**
+Version **4.0.0-0** `micrOS-???`
 
 ```
     Core:
@@ -525,6 +562,7 @@ Version **4.0.0-0**
         - Network
             - wifi (defualt, current interfaces)
             - Study of BLE (Shell)
+            - Com. (wifi/now/ble...lora?/etc?.) as plugin architecture (?)
     - Low power mode (with BLE) and soft-sleep / deep-sleep
 ```
 
@@ -696,8 +734,6 @@ devToolKit.py -c -p '--dev BedLamp help'
       help
    dht22
         help
-   intercon
-           help
    robustness
              help
    system
@@ -827,8 +863,6 @@ BedLamp $ help
       help
    dht22
         help
-   intercon
-           help
    robustness
              help
    system
@@ -919,10 +953,9 @@ micrOS Load Module resources
 43	105	LM_lmpacman.py           (mlint: True)	(pylint: 8.38)	(ref.: 0)
 44	176	LM_gameOfLife.py         (mlint: True)	(pylint: 9.29)	(ref.: 2)
 45	58	LM_catgame.py            (mlint: True)	(pylint: 8.46)	(ref.: 0)
-46	42	LM_intercon.py           (mlint: True)	(pylint: 8.18)	(ref.: 3)
-47	43	LM_ds18.py               (mlint: True)	(pylint: 5.0)	(ref.: 2)
-48	250	LM_i2s_mic.py            (mlint: False)	(pylint: 8.71)	(ref.: 1)
-49	34	LM_sdcard.py             (mlint: True)	(pylint: 7.88)	(ref.: 0)
+46	43	LM_ds18.py               (mlint: True)	(pylint: 5.0)	(ref.: 2)
+47	250	LM_i2s_mic.py            (mlint: False)	(pylint: 8.71)	(ref.: 1)
+48	34	LM_sdcard.py             (mlint: True)	(pylint: 7.88)	(ref.: 0)
 
 SUM CODE LINES (WITH COMMENTS, WITHOUT EMPTY LINES): 6822
 ```
@@ -1013,7 +1046,6 @@ micrOS/toolkit/workspace/precompiled
     │   ├── LM_esp32.py
     │   ├── LM_genIO.mpy
     │   ├── LM_i2c.py
-    │   ├── LM_intercon.mpy
     │   ├── LM_light_sensor.mpy
     │   ├── LM_neoeffects.mpy
     │   ├── LM_neopixel.mpy