micrOSDevToolKit 2.8.6__py3-none-any.whl → 2.9.0__py3-none-any.whl

micrOS/source/Notify.py

@@ -1,248 +1,76 @@
-from sys import modules
-import urequests
+"""
+Module is responsible for Notification handling
+Common:
+    - notifications None/True/False
+    - notify 'text'
+    - lm_execute
+Supported notification subscribers (add_subscriber)
+    - LM_telegram
+Designed by Marcell Ban aka BxNxM
+"""
+
 from Config import cfgget
 from Tasks import lm_exec, lm_is_loaded
-from Debug import console_write
+from Debug import errlog_add
 
 #########################################
 #          micrOS Notifications         #
 #          with Telegram Class          #
 #########################################
-
-
-class Telegram:
-    # Telegram bot token and chat ID
-    # https://core.telegram.org/bots/api
-    GLOBAL_NOTIFY = True                             # Enable Global notifications
-    _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
-    _DEVFID = cfgget('devfid')                       # For reply message (pre text)
-    _IN_MSG_ID = None
+class Notify:
+    GLOBAL_NOTIFY = True            # Enable Global notifications
+    _DEVFID = cfgget('devfid')      # For reply message (pre text)
+    _SUBSCRIBERS = set()            # Store set of notification objects: send_msg
 
     @staticmethod
-    def __id_cache(mode):
+    def add_subscriber(instance):
         """
-        pds - persistent data structure
-        modes:
-            r - recover, s - save
+        Add Notification agent like: Telegram
         """
-        if mode == 's':
-            # SAVE CACHE
-            console_write("[NTFY] Save chatIDs cache...")
-            with open('telegram.pds', '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:
-                # set() comprehension
-                Telegram._CHAT_IDS = {int(k) for k in f.read().strip().split(',')}
-        except:
-            pass
+        if isinstance(instance, Notify):
+            Notify._SUBSCRIBERS.add(instance)
+            return True
+        raise Exception("Subscribe error, Notify parent missing")
 
     @staticmethod
-    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 Telegram._TOKEN
-
-    @staticmethod
-    def send_msg(text, reply_to=None, chat_id=None):
+    def message(text, reply_to=None, chat_id=None):
         """
-        Send a message to the Telegram chat by chat_id
-        :param text: text to send
-        :param reply_to: reply to specific message, if None, simple reply
-        :param chat_id: chat_id to reply on, if None, reply to all known
-        RETURN None when telegram bot token is missing
+        Send message to all subscribers
         """
-        def _send(chid):
-            """Send message to chat_id (chid)"""
-            data = {"chat_id": chid, "text": f"{Telegram._DEVFID}⚙️\n{text}"}
-            if isinstance(reply_to, int):
-                data['reply_to_message_id'] = reply_to
-                Telegram._IN_MSG_ID = reply_to
-            _, _resp = urequests.post(url, headers={"Content-Type": "application/json"}, json=data, jsonify=True, sock_size=128)
-            console_write(f"\tSend message:\n{data}\nresponse:\n{_resp}")
-            return _resp
-
-        def _get_chat_ids():
-            """Return chat ID or None (in case of no token or cannot get ID)"""
-            if len(Telegram._CHAT_IDS) == 0:
-                Telegram.get_msg()  # It will update the Telegram.CHAT_IDS
-            console_write(f"\tGet chatIDs: {Telegram._CHAT_IDS}")
-            return Telegram._CHAT_IDS
-        
-        # --------------------- FUNCTION MAIN ------------------------ #
-        console_write("[NTFY] SEND MESSAGE")
-        # Check bot token
-        bot_token = Telegram.__bot_token()
-        if bot_token is None:
-            return None
-        url = f"https://api.telegram.org/bot{bot_token}/sendMessage{Telegram._API_PARAMS}"
-
-        verdict = ""
-        # Reply to ALL (notification) - chat_id was not provided
-        if chat_id is None:
-            console_write("\tREPLY ALL")
-            for _chat_id in _get_chat_ids():
-                resp_json = _send(chid=_chat_id)
-                verdict += f'Sent{_chat_id};' if resp_json['ok'] else str(resp_json)
-        else:
-            console_write(f"\tREPLY TO {chat_id}")
-            # Direct reply to chat_id
-            resp_json = _send(chid=chat_id)
-            verdict = f'Sent{chat_id}' if resp_json['ok'] else str(resp_json)
-        return verdict
+        exit_code = 0
+        for s in Notify._SUBSCRIBERS:
+            try:
+                s.send_msg(text, reply_to, chat_id)
+            except Exception as e:
+                errlog_add(f"[ERR] Notify: {e}")
+                exit_code+=1
+        return f"Sent N{len(Notify._SUBSCRIBERS)} ({exit_code})"
 
     @staticmethod
     def notifications(state=None):
         """
         Setter for disable/enable notification messages
         """
-        if state is not None:
-            Telegram.GLOBAL_NOTIFY = state
-        return f"Notifications: {'enabled' if Telegram.GLOBAL_NOTIFY else 'disabled'}"
-
+        if isinstance(state, bool):
+            Notify.GLOBAL_NOTIFY = state
+        return f"Notifications: {'enabled' if Notify.GLOBAL_NOTIFY else 'disabled'}"
 
     @staticmethod
     def notify(text, reply_to=None, chat_id=None):
         """
         Notification sender
         """
-        if Telegram.GLOBAL_NOTIFY:
-            return Telegram.send_msg(text, reply_to, chat_id)
+        if Notify.GLOBAL_NOTIFY:
+            return Notify.message(text, reply_to, chat_id)
         return "Notifications disabled"
 
     @staticmethod
-    def get_msg():
-        """
-        Get the last message from the Telegram chat.
-        RETURN None when telegram bot token is missing
-        """
-
-        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
-
-        # --------------------- FUNCTION MAIN ------------------------ #
-        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)
-        if len(resp_json["result"]) > 0:
-            response['c_id'] = _update_chat_ids()
-            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}")
-        return response
-
-    @staticmethod
-    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
-        verdict = None
-
-        def lm_execute(cmd_args):
-            nonlocal verdict
-            if lm_is_loaded(cmd_args[0]):
-                verdict = f'[UP] Exec: {" ".join(cmd_args[0])}'
-                try:
-                    _, out = lm_exec(cmd_args)
-                except Exception as e:
-                    out = str(e)
-                Telegram.send_msg(out, reply_to=m_id)
-            else:
-                verdict = f'[UP] NoAccess: {cmd_args[0]}'
-                Telegram._IN_MSG_ID = m_id
-
-        # -------------------------- FUNCTION MAIN -------------------------- #
-        # Poll telegram chat
-        data = Telegram.get_msg()
-        if data is None:
-            return data
-        # Get msg, msg_id, chat_id as main input data source
-        msg_in, m_id, c_id = data['text'], data['m_id'], data['c_id']
-        if msg_in is not None and m_id != Telegram._IN_MSG_ID:
-            # replace single/double quotation to apostrophe (str syntax for repl interpretation)
-            msg_in = msg_in.replace('‘', "'").replace('’', "'").replace('“', '"').replace('”', '"')
-            if msg_in.startswith('/ping'):
-                # Parse loaded modules
-                _loaded_mods = [lm.replace('LM_', '') for lm in modules if lm.startswith('LM_')] + ['task']
-                Telegram.send_msg(', '.join(_loaded_mods), reply_to=m_id, chat_id=c_id)
-            elif msg_in.startswith('/cmd_select'):
-                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:])
-                else:
-                    verdict = f'[UP] NoSelected: {cmd_lm[0]}'
-            elif msg_in.startswith('/cmd'):
-                cmd_lm = msg_in.strip().split()[1:]
-                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()
-                Telegram.send_msg(verdict, reply_to=m_id)
-        else:
-            verdict = "[UP] NoExec"
-        console_write(f"\tREC&EVAL: {verdict}")
-        return verdict
-
-    @staticmethod
-    def set_commands():
-        """
-        Set Custom Commands to the Telegram chat.
-        RETURN None when telegram bot token is missing
-        """
-
-        console_write("[NTFY] SET DEFAULT COMMANDS")
-        bot_token = Telegram.__bot_token()
-        if bot_token is None:
-            return None
-        url = f"https://api.telegram.org/bot{bot_token}/setMyCommands{Telegram._API_PARAMS}"
-        data = {"commands": [{"command": "ping", "description": "Ping All endpoints: list of active modules."},
-                             {"command": "notify", "description": "Enable/Disable notifications: on or off"},
-                             {"command": "cmd", "description": "Run active module function on all devices."},
-                             {"command": "cmd_select", "description": "Same as cmd, only first param must be device name."},
-                             ]}
-        _, resp_json = urequests.post(url, headers={"Content-Type": "application/json"}, json=data, jsonify=True, sock_size=128)
-        return 'Custom commands was set' if resp_json['ok'] else str(resp_json)
+    def lm_execute(cmd_args):
+        """Executor with basic access handling"""
+        if lm_is_loaded(cmd_args[0]):
+            try:
+                _, out = lm_exec(cmd_args)
+            except Exception as e:
+                out = str(e)
+            return True, out
+        return False, cmd_args[0]

micrOS/source/Scheduler.py

@@ -1,6 +1,6 @@
 from time import localtime
 from re import compile
-from Tasks import exec_lm_core_schedule
+from Tasks import exec_lm_pipe_schedule
 from Debug import console_write, errlog_add
 from Time import Sun, suntime, ntp_time
 
@@ -179,7 +179,7 @@ def __scheduler_trigger(cron_time_now, crontask, deltasec=2):
                 lm_state = False
                 if isinstance(crontask[1], str):
                     # [1] Execute Load Module as a string (user LMs)
-                    lm_state = exec_lm_core_schedule(crontask[1].split())
+                    lm_state = exec_lm_pipe_schedule(crontask[1])
                 else:
                     try:
                         # [2] Execute function reference (built-in functions)
@@ -207,6 +207,7 @@ def deserialize_raw_input(cron_data):
     Scheduler/Cron input string format
     :param cron_data: raw cron tasks, time based task execution input (bytearray)
         example: WD:H:M:S!LM func;WD:H:M:S!LM func; ...
+        multi command example: WD:H:M:S!LM func;LM func2;; WD:H:M:S!LM func;; ...
 
         time_tag: timestamp / time-tag aka suntime
                 timestamp: WD:H:M:S
@@ -218,8 +219,10 @@ def deserialize_raw_input(cron_data):
     Returns tuple: (("WD:H:M:S", 'LM FUNC'), ("WD:H:M:S", 'LM FUNC'), ...)
     """
     try:
-        # Parse and create return - convert cron_data (bytearray) to string
-        return (tuple(cron.split('!')) for cron in str(cron_data, 'utf-8').split(';'))
+        # Parse and create return
+        cd = str(cron_data, 'utf-8')            # convert cron_data (bytearray) to string
+        sep = ';;' if ';;' in cd else ';'       # support multi command with ;;
+        return (tuple(cron.split('!')) for cron in cd.split(sep))
     except Exception as e:
         errlog_add(f"[ERR] cron deserialize - syntax error: {e}")
     return ()

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
 
@@ -25,7 +25,7 @@ from Debug import errlog_add
 
 class Shell:
     __slots__ = ['__devfid', '__auth_mode', '__hwuid', '__auth_ok', '__conf_mode']
-    MICROS_VERSION = '2.8.1-0'
+    MICROS_VERSION = '2.9.0-0'
 
     def __init__(self):
         """