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

micrOS/source/Shell.py

@@ -2,7 +2,7 @@
 Module is responsible for shell like environment
 dedicated to micrOS framework.
 Built-in-function:
-- Shell wrapper for safe InterpreterCore interface
+- Shell wrapper for lm_exec interface
 - Configuration handling interface - state machine handling
 - Help (runtime) message generation
 
@@ -11,12 +11,12 @@ Designed by Marcell Ban aka BxNxM
 #################################################################
 #                           IMPORTS                             #
 #################################################################
-from os import listdir
 from sys import modules
 from machine import reset as hard_reset, soft_reset
 from Config import cfgget, cfgput
+from Files import OSPath, ilist_fs, path_join
 from Tasks import lm_exec
-from Debug import errlog_add
+from Debug import syslog
 
 
 #################################################################
@@ -24,7 +24,8 @@ from Debug import errlog_add
 #################################################################
 
 class Shell:
-    MICROS_VERSION = '2.1.5-0'
+    __slots__ = ['__devfid', '__auth_mode', '__hwuid', '__auth_ok', '__conf_mode']
+    MICROS_VERSION = '2.26.1-0'
 
     def __init__(self):
         """
@@ -42,57 +43,53 @@ class Shell:
         try:
             cfgput('version', Shell.MICROS_VERSION)
         except Exception as e:
-            errlog_add(f"[ERR] micrOS version export failed (config): {e}")
+            syslog(f"[ERR] micrOS version export failed (config): {e}")
 
-    def send(self, msg):
-        """
-        Must be defined by child class...
-        """
-        pass
+    async def a_send(self, msg):
+        """ Must be defined by child class... """
+        raise NotImplementedError("Child class must implement a_send method")
 
     def reset(self):
         """Reset shell state"""
         self.__auth_ok = False
         self.__conf_mode = False
 
-    def reboot(self, hard=False):
-        """Reboot micropython VM"""
-        self.send(f"{'[HARD] ' if hard else ''}Reboot micrOS system.")
-        self.send("Bye!")
+    async def reboot(self, hard=False):
+        """ Reboot micropython VM """
+        await self.a_send(f"{'[HARD] ' if hard else ''}Reboot micrOS system.\nBye!")
         if hard:
             hard_reset()
         soft_reset()
 
     def prompt(self):
-        """Generate prompt"""
+        """ Generate prompt """
         auth = "[password] " if self.__auth_mode and not self.__auth_ok else ""
         mode = "[configure] " if self.__conf_mode else ""
         return f"{auth}{mode}{self.__devfid} $ "
 
-    def __auth(self, msg_list):
-        """Authorize user"""
+    async def __auth(self, msg_list):
+        """ Authorize user """
         # Set user auth state
         if self.__auth_mode and not self.__auth_ok:
             # check password
-            usrpwd = cfgget('appwd')
-            if usrpwd == msg_list[0].strip():
+            if cfgget('appwd') == msg_list[0].strip():
                 self.__auth_ok = True
-                self.send("AuthOk")
+                await self.a_send("AuthOk")
                 return True, []
-            self.send("AuthFailed\nBye!")
+            await self.a_send("AuthFailed\nBye!")
             return False, []
         return True, msg_list
 
-    def shell(self, msg):
+    async def shell(self, msg):
         """
         micrOS Shell main - input string handling
         :param msg: incoming shell command (command or load module call)
         """
-        state = self.__shell(msg)
-        self.send(self.prompt())
+        state = await self.__shell(msg)
+        await self.a_send(self.prompt())
         return state
 
-    def __shell(self, msg):
+    async def __shell(self, msg):
         """
         Socket server - interpreter shell
         :param msg: socket input string
@@ -108,6 +105,8 @@ class Shell:
             # No msg to work with
             return True
         msg_list = msg.strip().split()
+        # INTERCON embedding: conf mode and remote call request check
+        is_local_cmd = self.__conf_mode or not msg_list[-1].startswith(">>")
 
         ##########################################
         #   [1] Handle built-in shell commands   #
@@ -115,75 +114,80 @@ class Shell:
         ##########################################
 
         # Hello message
-        if msg_list[0] == 'hello':
+        if is_local_cmd and msg_list[0] == 'hello':
             # For low level device identification - hello msg
-            self.send(f"hello:{self.__devfid}:{self.__hwuid}")
+            await self.a_send(f"hello:{self.__devfid}:{self.__hwuid}")
             return True
 
         # [!] AUTH
-        state, msg_list = self.__auth(msg_list)
+        state, msg_list = await self.__auth(msg_list)
         if not state:
             return False
         if len(msg_list) == 0:
             return True
 
         # Version handling
-        if msg_list[0] == 'version':
+        if is_local_cmd and msg_list[0] == 'version':
             # For micrOS system version info
-            self.send(str(Shell.MICROS_VERSION))
+            await self.a_send(str(Shell.MICROS_VERSION))
             return True
 
         # Reboot micropython VM
-        if msg_list[0] == 'reboot':
+        if is_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
-            self.reboot(hard)
+            await self.reboot(hard)
 
-        if msg_list[0].startswith('webrepl'):
+        if is_local_cmd and msg_list[0].startswith('webrepl'):
             if len(msg_list) == 2 and '-u' in msg_list[1]:
-                Shell.webrepl(msg_obj=self.send, update=True)
-            Shell.webrepl(msg_obj=self.send)
+                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 is_local_cmd and msg_list[0].startswith('conf'):
             self.__conf_mode = True
             return True
-        if msg_list[0].startswith('noconf'):
+        if is_local_cmd and msg_list[0].startswith('noconf'):
             self.__conf_mode = False
             return True
 
         # HELP MSG
-        if msg_list[0] == "help":
-            self.send("[MICROS]   - built-in shell commands")
-            self.send("   hello   - hello msg - for device identification")
-            self.send("   modules - show active Load Modules")
-            self.send("   version - returns micrOS version")
-            self.send("   exit    - exit from shell socket prompt")
-            self.send("   reboot  - system soft reboot (vm), hard reboot (hw): reboot -h")
-            self.send("   webrepl - start webrepl, for file transfers use with --update")
-            self.send("[CONF] Configure mode - built-in shell commands")
-            self.send("  conf       - Enter conf mode")
-            self.send("    dump       - Dump all data")
-            self.send("    key        - Get value")
-            self.send("    key value  - Set value")
-            self.send("  noconf     - Exit conf mode")
-            self.send("[TASK] postfix: &x - one-time,  &&x - periodic, x: wait ms [x min: 20ms]")
-            self.send("  task list         - list tasks with <tag>s")
-            self.send("  task kill <tag>   - stop task")
-            self.send("  task show <tag>   - show task output")
-            self.send("[EXEC] Command mode (LMs):")
-            self.send("   help lm  - list ALL LoadModules")
+        if is_local_cmd and msg_list[0] == "help":
+            await self.a_send("[MICROS]")
+            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 shell session")
+            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] Configuration mode")
+            await self.a_send("  conf       - Enter conf mode")
+            await self.a_send("    dump       - Dump all data, filter: dump <str>")
+            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] Task operations")
+            await self.a_send("  task list         - list tasks by tags")
+            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, syntax(...): <module> <function> <params> <postfix>")
+            await self.a_send("  Postfix hints:")
+            await self.a_send("    ... &<x>            - start one-shot task")
+            await self.a_send("    ... &&<x>           - start periodic task, where <x>: delay ms [x min: 20ms]")
+            await self.a_send("    ... >json           - request json formatted output")
+            await self.a_send("    ... >>hostname      - remote command execution (intercon)")
+            await self.a_send("  help lm           - list ALL available LoadModules")
             if "lm" in str(msg_list):
-                return Shell._show_lm_funcs(msg_obj=self.send)
-            return Shell._show_lm_funcs(msg_obj=self.send, active_only=True)
+                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 is_local_cmd and self.__conf_mode and len(msg_list) > 0:
             # Lock thread under config handling is threads available
-            return Shell._configure(self.send, msg_list)
+            return await Shell._configure(self.a_send, msg_list)
         # @2 Command mode
         """
         INPUT MSG STRUCTURE
@@ -192,43 +196,43 @@ class Shell:
         """
         try:
             # Execute command via InterpreterCore
-            self.send(lm_exec(arg_list=msg_list)[1])
+            await self.a_send(lm_exec(arg_list=msg_list)[1])
             return True
         except Exception as e:
-            self.send(f"[ERROR] shell.lm_exec internal error: {e}")
+            await self.a_send(f"[ERROR] shell.lm_exec internal error: {e}")
             return False
 
     #################################################################
     #                     CONFIGURE MODE HANDLER                    #
     #################################################################
     @staticmethod
-    def _configure(msg_obj, msg_list):
+    async def _configure(msg_obj, msg_list):
         """
         :param msg_obj: shell output stream function reference (write object)
         :param msg_list: socket input param list
         :return: execution status
         """
-        def dump():
+        async def dump():
             nonlocal msg_obj, msg_list
             if msg_list[0] == 'dump':
                 search = msg_list[1] if len(msg_list) == 2 else None
                 # DUMP DATA
                 for _key, value in cfgget().items():
                     if search is None or search in _key:
-                        msg_obj(f"  {_key}{' ' * (10 - len(_key))}:{' ' * 7} {value}")
+                        await msg_obj(f"  {_key}{' ' * (10 - len(_key))}:{' ' * 7} {value}")
                 return True
             return False
 
         # [CONFIG] Get value
         if len(msg_list) == 1:
-            if dump():                      # Simple dump without param filter
+            if await dump():                      # Simple dump without param filter
                 return True
             # GET SINGLE PARAMETER VALUE
-            msg_obj(cfgget(msg_list[0]))
+            await msg_obj(cfgget(msg_list[0]))
             return True
         # [CONFIG] Set value
         if len(msg_list) >= 2:
-            if dump():                      # Dump with search option
+            if await dump():                      # Dump with search option
                 return True
             # Deserialize params
             key = msg_list[0]
@@ -236,67 +240,73 @@ class Shell:
             try:
                 output = cfgput(key, " ".join(msg_list[1:]), type_check=True)
             except Exception as e:
-                msg_obj(f"node_config write error: {e}")
+                await msg_obj(f"node_config write error: {e}")
                 output = False
             # Evaluation and reply
-            msg_obj('Saved' if output else 'Invalid key' if cfgget(key) is None else 'Failed to save')
+            await msg_obj('Saved' if output else 'Invalid key' if cfgget(key) is None else 'Failed to save')
         return True
 
     #################################################################
     #                   COMMAND MODE & LMS HANDLER                  #
     #################################################################
     @staticmethod
-    def _show_lm_funcs(msg_obj, active_only=False):
+    async def _show_lm_funcs(msg_obj, active_only=False):
         """
         Dump LM modules with functions - in case of [py] files
         Dump LM module with help function call - in case of [mpy] files
         """
-        def _help(mod):
-            for lm_path in (i for i in mod if i.startswith('LM_') and (i.endswith('py'))):
+        async def _help(mods):
+            nonlocal mpath
+            for lm_path in mods:
                 lm_name = lm_path.replace('LM_', '').split('.')[0]
                 try:
-                    msg_obj(f"   {lm_name}")
+                    await msg_obj(f"  {lm_name}")
                     if lm_path.endswith('.mpy'):
-                        msg_obj(f"   {' ' * len(lm_path.replace('LM_', '').split('.')[0])}help")
+                        await msg_obj(f"  {' ' * len(lm_path.replace('LM_', '').split('.')[0])}help")
                         continue
-                    with open(lm_path, 'r') as f:
+                    with open(path_join(mpath, lm_path), 'r') as f:
                         line = "micrOSisTheBest"
                         while line:
                             line = f.readline()
-                            if line.strip().startswith('def') and '_' not in line and 'self' not in line:
-                                msg_obj(f"   {' ' * len(lm_name)}{line.replace('def ', '').split('(')[0]}")
+                            ldata = line.strip()
+                            if ldata.startswith('def ') and not ldata.split()[1].startswith("_") and 'self' not in ldata:
+                                await msg_obj(f"  {' ' * len(lm_name)}{ldata.replace('def ', '').split('(')[0]}")
                 except Exception as e:
-                    msg_obj(f"[{lm_path}] SHOW LM PARSER WARNING: {e}")
+                    await msg_obj(f"[{lm_path}] SHOW LM PARSER WARNING: {e}")
                     return False
             return True
 
+        await msg_obj("")
         # [1] list active modules (default in shell)
+        mpath = OSPath.MODULES
         if active_only:
             mod_keys = modules.keys()
-            active_modules = (dir_mod for dir_mod in listdir() if dir_mod.split('.')[0] in mod_keys)
-            return _help(active_modules)
+            active_modules = (dir_mod for dir_mod in ilist_fs(path=mpath, type_filter='f', select="LM")
+                              if dir_mod.split('.')[0] in mod_keys)
+            return await _help(active_modules)
         # [2] list all LMs on file system (ALL - help lm) - manual
-        return _help(listdir())
+        return await _help(ilist_fs(path=mpath, type_filter='f', select="LM"))
 
     @staticmethod
-    def webrepl(msg_obj, update=False):
+    async def webrepl(msg_obj, update=False):
         from Network import ifconfig
 
-        msg_obj(" Start micropython WEBREPL - file transfer and debugging")
-        msg_obj("  [i] restart machine shortcut: import reset")
-        msg_obj(f"  Connect over http://micropython.org/webrepl/#{ifconfig()[1][0]}:8266/")
-        msg_obj(f"  \t[!] webrepl password: {cfgget('appwd')}")
+        await msg_obj(" Start micropython WEBREPL - file transfer and debugging")
+        await msg_obj("  [i] restart machine shortcut: import reset")
+        await msg_obj(f"  Connect over http://micropython.org/webrepl/#{ifconfig()[1][0]}:8266/")
+        await msg_obj(f"  \t[!] webrepl password: {cfgget('appwd')}")
         if update:
-            msg_obj(" Restart node then start webrepl...")
-            msg_obj(" Bye!")
+            await msg_obj(" Restart node then start webrepl...")
+            await msg_obj(" Bye!")
             # Set .if_mode->webrepl (start webrepl after reboot and poll update status...)
             with open('.if_mode', 'w') as f:
                 f.write('webrepl')
             hard_reset()
         try:
             import webrepl
-            msg_obj(webrepl.start(password=cfgget('appwd')))
+            await msg_obj(webrepl.start(password=cfgget('appwd')))
         except Exception as e:
             _err_msg = f"[ERR] while starting webrepl: {e}"
-            msg_obj(_err_msg)
-            errlog_add(_err_msg)
+            await msg_obj(_err_msg)
+            syslog(_err_msg)
+        return True