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

micrOS/source/LM_neoeffects.py

@@ -1,5 +1,7 @@
 from LM_neopixel import load, segment, Data, status, pinmap as pm
 from random import randint
+from Types import resolve
+from Common import manage_task
 
 
 #################################
@@ -285,6 +287,13 @@ def fire(r=None, g=None, b=None, ledcnt=24):
     effect.draw(cgen, shift=False)
     return 'fire R{}:G{}:B{} N:{}'.format(r, g, b, effect.pix_cnt)
 
+
+def stop_effects():
+    """
+    Stop all running (neo)effects tasks
+    """
+    return manage_task("neoeffects.*", "kill")
+
 #######################
 # LM helper functions #
 #######################
@@ -307,10 +316,16 @@ def help(widgets=False):
         (widgets=False) list of functions implemented by this application
         (widgets=True) list of widget json for UI generation
     """
-    return 'meteor r=<0-255> g=<0-255> b=<0-255> shift=True ledcnt=24',\
-           'cycle r g b shift=True ledcnt=24',\
-           'rainbow step=1 br=<5-100> ledcnt=24',\
-           'fire r=None g=None b=None ledcnt=24',\
-           'shader size=4 offset=0 shift=True ledcnt=24',\
-           'random max_val=255',\
-           'color r g b', 'pinmap'
+    return resolve(('meteor r=<0-255> g=<0-255> b=<0-255> shift=True ledcnt=24',
+                             'BUTTON meteor &&',
+                             'cycle r g b shift=True ledcnt=24',
+                             'BUTTON cycle &&50',
+                             'rainbow step=1 br=<5-100> ledcnt=24 &&',
+                             'BUTTON rainbow br=50 &&',
+                             'fire r=None g=None b=None ledcnt=24',
+                             'BUTTON fire &&200',
+                             'BUTTON stop_effects',
+                             'shader size=4 offset=0 shift=True ledcnt=24',
+                             'random max_val=255',
+                             'pinmap',
+                             'COLOR color r=<0-255-10> g b'), widgets=widgets)

micrOS/source/LM_neopixel.py

@@ -3,7 +3,6 @@ from machine import Pin
 from sys import platform
 from utime import sleep_ms
 from Common import transition_gen, micro_task
-import uasyncio as asyncio
 from microIO import resolve_pin, pinmap_search
 from random import randint
 from Types import resolve
@@ -269,7 +268,7 @@ def transition(r=None, g=None, b=None, sec=1.0, wake=False):
                 Data.DCACHE[1] = g_val if g_val > 5 else 5   # SAVE VALUE TO CACHE > 5 ! because toggle
                 Data.DCACHE[2] = b_val if b_val > 5 else 5   # SAVE VALUE TO CACHE > 5 ! because toggle
                 my_task.out = f"Dimming: R:{r_val} G:{g_val} B:{b_val}"
-                await asyncio.sleep_ms(ms_period)
+                await my_task.feed(sleep_ms=ms_period)
             if Data.DCACHE[3] == 1 or wake:
                 __state_machine(r=r_val, g=g_val, b=b_val)
             my_task.out = f"Dimming DONE: R:{r_val} G:{g_val} B:{b_val}"
@@ -346,7 +345,7 @@ def help(widgets=False):
                              'BUTTON toggle state=<True,False> smooth=True',
                              'load ledcnt=24',
                              'SLIDER brightness percent=<0-100> smooth=True wake=True',
-                             'COLOR segment r g b s=<0-n>',
+                             'segment r g b s=<0-n>',
                              'transition r g b sec=1.0 wake=False',
                              'BUTTON random smooth=True max_val=254',
                              'status',

micrOS/source/LM_oledui.py

@@ -1,5 +1,4 @@
 from utime import localtime, ticks_ms, ticks_diff, sleep_ms
-import uasyncio as asyncio
 from Common import syslog, micro_task, manage_task, exec_cmd
 from Types import resolve
 # Core modules
@@ -106,7 +105,7 @@ class Frame(BaseFrame):
                     my_task.out = 'paused' if self.paused else f'refresh: {period_ms} ms'
                     s = self.paused
                 if self.paused:
-                    await asyncio.sleep_ms(period_ms)   # extra wait in paused mode
+                    await my_task.feed(sleep_ms=period_ms) # extra wait in paused mode
                 else:
                     # Draw/Refresh frame
                     self.draw()
@@ -115,7 +114,7 @@ class Frame(BaseFrame):
                     if self._fast_refresh:
                         self._fast_refresh = False
                         break
-                    await asyncio.sleep_ms(micro_sleep_ms)
+                    await my_task.feed(sleep_ms=micro_sleep_ms)
 
     def clb_refresh(self):
         """Fast reload app loop callbacks"""
@@ -486,7 +485,7 @@ class ScreenSaver(BaseFrame):
                 # Store data in task cache (task show mytask)
                 my_task.out = f'GameOfLife: {counter}'
                 # Async sleep - feed event loop
-                await asyncio.sleep_ms(period_ms)
+                await my_task.feed(sleep_ms=period_ms)
             my_task.out = f'GameOfLife stopped: {counter}'
 
     def run(self, fps=10):

micrOS/source/LM_pet_feeder.py

@@ -1,4 +1,3 @@
-import uasyncio as asyncio
 from LM_servo import sduty, deinit, pinmap as servo_pinmap
 from LM_stepper import step, pinmap as stepper_pinmap
 from Common import micro_task
@@ -16,13 +15,13 @@ async def __portion_task(portion, posmin, posmax):
             # [1]Run pos fill up
             for pos in range(posmin, posmax):
                 sduty(pos)
-                await asyncio.sleep_ms(15)
+                await my_task.feed(sleep_ms=15)
             # [2]Wait between fill up / food out
-            await asyncio.sleep_ms(500)
+            await my_task.feed(sleep_ms=500)
             # [3]Run pos food out
             for pos in range(posmax, posmin, -1):
                 sduty(pos)
-                await asyncio.sleep_ms(20)
+                await my_task.feed(sleep_ms=20)
             my_task.out = "{}/{} serving".format(p+1, portion)
     deinit()
     my_task.out += ": {} task done".format(Data.TASK_TAG)

micrOS/source/LM_ph_sensor.py

@@ -12,7 +12,7 @@ ADC.ATTN_11DB — the full range voltage: 3.3V
 
 
 def __measure(samples=10):
-    adc_obj = SmartADC.get_singleton(resolve_pin('ph'))
+    adc_obj = SmartADC.get_instance(resolve_pin('ph'))
     mbuf = 0
     for k in range(0, samples):
         mbuf += adc_obj.get()['volt']
@@ -22,7 +22,7 @@ def __measure(samples=10):
 
 
 def measure():
-    data = SmartADC.get_singleton(resolve_pin('ph')).get()
+    data = SmartADC.get_instance(resolve_pin('ph')).get()
     return "ADC data: {}\nAVG V: {}".format(data, __measure())
 
 

micrOS/source/LM_presence.py

@@ -1,6 +1,5 @@
 from microIO import resolve_pin, pinmap_search
 from Common import SmartADC, micro_task, notify, syslog
-import uasyncio as asyncio
 from utime import ticks_ms
 try:
     import LM_intercon as InterCon
@@ -97,7 +96,7 @@ async def __task(ms_period, buff_size):
 
     if Data.MIC_TYPE == Data.MIC_TYPES['ADC']:
         # Create ADC object
-        Data.MIC_ADC = SmartADC.get_singleton(resolve_pin('mic'))
+        Data.MIC_ADC = SmartADC.get_instance(resolve_pin('mic'))
     elif Data.MIC_TYPE == Data.MIC_TYPES['I2S']:
         if Data.I2S_MIC is None:
             import LM_i2s_mic
@@ -115,7 +114,7 @@ async def __task(ms_period, buff_size):
                 my_task.out = f"{int(Data.OFF_EV_TIMER)-1} sec until off event"
             Data.OFF_EV_TIMER -= round(ms_period / 1000, 3)
             # Async sleep - feed event loop
-            await asyncio.sleep_ms(ms_period)
+            await my_task.feed(sleep_ms=ms_period)
 
         # RUN OFF CALLBACK (local + remote)
         __exec_local_callbacks(Data.OFF_CALLBACKS)

micrOS/source/LM_rest.py

@@ -1,4 +1,8 @@
+import uasyncio as asyncio
 from urequests import get as http_get
+from urequests import aget as http_aget
+from Common import micro_task
+
 
 class Rest:
     GATEWAY_HOST = None
@@ -13,23 +17,60 @@ def load(gateway_url=None):
         if Rest.GATEWAY_HOST is None:
             return 'Missing Gateway url'
         return Rest.GATEWAY_HOST
-    Rest.GATEWAY_HOST = gateway_url
-    return f'Set gateway url: {gateway_url}'
+    if gateway_url.startswith("http"):
+        Rest.GATEWAY_HOST = gateway_url
+    else:
+        return f"URL have to starts with http/https"
+    return f'Gateway url: {gateway_url}'
 
 
-def url(subdomain):
-    """
-    Execute rest call with given subdomain
-    :param subdomain: command parameters of url, like: /webhooks/template
-    """
+def _subdomain(subdomain):
     if Rest.GATEWAY_HOST is None:
-        return 'Missing Gateway url'
+        raise Exception('Missing Gateway url')
     if not subdomain.startswith('/'):
         subdomain = '/' + subdomain
     domain = f'{Rest.GATEWAY_HOST}{subdomain}'
+    return domain
+
+
+def url(subdomain):
+    """
+    Execute rest call with given subdomain / url
+    :param subdomain: url parameter,  http(s) full url or gateway subdomain like: /webhooks/template
+    """
+    if subdomain.startswith('http'):
+        domain = subdomain
+    else:
+        domain = _subdomain(subdomain)
     status_code, response = http_get(domain, jsonify=True)
     return {'status': status_code, 'response': response}
 
+
+async def __task(subdomain, tag):
+    with micro_task(tag=tag) as my_task:
+        my_task.out = f"GET {subdomain}"
+        if subdomain.startswith('http'):
+            domain = subdomain
+        else:
+            domain = _subdomain(subdomain)
+        status_code, response = await http_aget(domain, jsonify=True)
+        my_task.out = f'status: {status_code}, response: {response}'
+    return {'status': status_code, 'response': response}
+
+
+def aurl(subdomain):
+    """
+    Execute async rest call with given subdomain / url
+    :param subdomain: url parameter,  http(s) full url or gateway subdomain like: /webhooks/template
+    """
+    # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
+    tag = "rest." + subdomain.replace("http://", '').replace("https://", '')
+    if len(tag) > 50:
+        tag = tag[0:50]
+    state = micro_task(tag=tag, task=__task(subdomain, tag))
+    return f"Starting" if state else f"Already running"
+
+
 def help(widgets=False):
     """
     [i] micrOS LM naming convention - built-in help message
@@ -37,4 +78,6 @@ def help(widgets=False):
         (widgets=False) list of functions implemented by this application
         (widgets=True) list of widget json for UI generation
     """
-    return 'load gateway_url=<http://gateway.local:5000>', 'url subdomain=</webhooks/template>'
+    return ('load gateway_url=<http://gateway.local:5000>',
+            'url subdomain=</webhooks/template>',
+            'aurl subdomain=</webhooks/template>')

micrOS/source/LM_rgb.py

@@ -4,7 +4,6 @@
 from machine import Pin, PWM
 from sys import platform
 from Common import transition_gen, micro_task
-import uasyncio as asyncio
 from utime import sleep_ms
 from microIO import resolve_pin, pinmap_search
 from random import randint
@@ -240,7 +239,7 @@ def transition(r=None, g=None, b=None, sec=1.0, wake=False):
                 Data.RGB_CACHE[1] = _g if _g > 5 else 5   # SAVE VALUE TO CACHE > 5 ! because toggle
                 Data.RGB_CACHE[2] = _b if _b > 5 else 5   # SAVE VALUE TO CACHE > 5 ! because toggle
                 my_task.out = f"Dimming: R:{_r} G:{_g} B:{_b}"
-                await asyncio.sleep_ms(ms_period)
+                await my_task.feed(sleep_ms=ms_period)
             if Data.RGB_CACHE[3] == 1 or wake:
                 __state_machine(_r, _g, _b)
             my_task.out = f"Dimming DONE: R:{_r} G:{_g} B:{_b}"

micrOS/source/LM_roboarm.py

@@ -3,7 +3,6 @@ from random import randint
 import LM_servo as servo
 from LM_switch import set_state, pinmap as switch_pinmap
 from Common import transition, micro_task
-import uasyncio as asyncio
 from Types import resolve
 
 
@@ -179,7 +178,7 @@ async def _play(args, deinit, delay):
             if task is not None:
                 task.out = "Roboarm X:{} Y:{}".format(x, y)
             # Async wait between steps
-            await asyncio.sleep_ms(delay)
+            await task.feed(sleep_ms=delay)
         if deinit:
             servo.deinit()
         # OFF LASER

micrOS/source/LM_sound_event.py

@@ -37,7 +37,6 @@ Terminal ready
 """
 
 import LM_i2s_mic
-import uasyncio as asyncio
 import json
 
 from microIO import pinmap_search
@@ -647,7 +646,7 @@ async def __control_task(capture_duration_ms,
     :param pause_duration_ms: int - duration of pause frames to distinguish events
     :param event_buffer_length: int - number of events to store at once
     """
-    with micro_task(tag=Data.CONTROL_TASK_TAG):
+    with micro_task(tag=Data.CONTROL_TASK_TAG) as my_task:
         samples = []
         frame_size = int((frame_size_ms/1000)*LM_i2s_mic.Data.SAMPLING_RATE)
         pause_duration = int(pause_duration_ms/frame_size_ms)
@@ -674,7 +673,7 @@ async def __control_task(capture_duration_ms,
                 
                 # Wait for new samples to be taken
                 ms_period = int(len(new_samples)/LM_i2s_mic.Data.SAMPLING_RATE)
-                await asyncio.sleep_ms(ms_period)
+                await my_task.feed(sleep_ms=ms_period)
                 Data.EVENTS = Data.EVENTS[-event_buffer_length:]
             except Exception as e:
                 console(f'[ERR] sound_event: {e}')

micrOS/source/LM_system.py

@@ -7,6 +7,7 @@ from Network import get_mac, ifconfig as network_config
 from Time import ntp_time, set_time, uptime
 from Tasks import Manager
 from Types import resolve
+from Notify import Notify
 
 try:
     from gc import mem_free, mem_alloc, collect
@@ -177,15 +178,16 @@ def list_stations():
     return [("NoAP", '')]
 
 
-def pinmap(key='builtin'):
+def pinmap(keys='builtin irq1 irq2 irq3 irq4'):
     """
     Get Logical pin by key runtime
-    :param key str: logical pin name to resolve
+    :param keys str: logical pin name or names to resolve
     :return dict: key map
     """
     from microIO import pinmap_search, pinmap_info
     map = pinmap_info()
-    map[key] = pinmap_search(key)[key]
+    keys = keys.split()
+    map["search"] = pinmap_search(keys)
     return map
 
 @socket_stream
@@ -232,6 +234,14 @@ def urequests_host_cache():
     return host_cache()
 
 
+def notifications(enable=None):
+    """
+    Global notifications control for micrOS
+    :param enable: True: Enable notifications / False: Disable notifications
+    return: state verdict
+    """
+    return Notify.notifications(state=enable)
+
 #######################
 # LM helper functions #
 #######################
@@ -246,5 +256,6 @@ def help(widgets=False):
     return resolve(('info', 'TEXTBOX top', 'gclean', 'heartbeat', 'clock',
                     'setclock year month mday hour min sec',
                     'ntp', 'rssi', 'list_stations', 'pinmap key="dhtpin"/None', 'alarms clean=False',
+                    'notifications enable=<None,True,False>',
                     'sun refresh=False', 'ifconfig', 'memory_usage',
                     'disk_usage', 'dat_dump', 'urequests_host_cache'), widgets=widgets)

micrOS/source/LM_telegram.py

@@ -1,7 +1,229 @@
+from sys import modules
 import uasyncio as asyncio
-from Notify import Telegram
-from Common import micro_task, syslog
-from Network import ifconfig
+import urequests
+from Notify import Notify
+from Config import cfgget
+from Common import micro_task, syslog, console_write
+from LM_system import ifconfig
+
+
+class Telegram(Notify):
+    # Telegram bot token and chat ID
+    # https://core.telegram.org/bots/api
+    _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
+    _IN_MSG_ID = None
+
+    @staticmethod
+    def __id_cache(mode):
+        """
+        pds - persistent data structure
+        modes:
+            r - recover, s - save
+        """
+        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
+
+    @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):
+        """
+        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
+        """
+
+        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
+
+    @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, m_id
+            access, output = Telegram.lm_execute(cmd_args)
+            if access:
+                verdict = f'[UP] Exec: {" ".join(cmd_args[0])}'
+                Telegram.send_msg(output, 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)
 
 #########################################
 #          micrOS Notifications         #
@@ -15,6 +237,7 @@ def __init():
         _sta_available = True if ifconfig()[0] == "STA" else False
         if _sta_available:
             TELEGRAM_OBJ = Telegram()
+            Notify.add_subscriber(TELEGRAM_OBJ)
         else:
             syslog("No STA: cannot init telegram")
 
@@ -103,17 +326,6 @@ def receiver_loop():
     return "Starting" if state else "Already running"
 
 
-def notifications(enable=None):
-    """
-    Global notifications control for micrOS
-    :param enable: True: Enable notifications / False: Disable notifications
-    return: state verdict
-    """
-    if enable is None:
-        enable = not Telegram.GLOBAL_NOTIFY
-    return Telegram.notifications(state=enable)
-
-
 def help(widgets=False):
     """
     [i] micrOS LM naming convention - built-in help message
@@ -125,5 +337,4 @@ def help(widgets=False):
             'receive',
             'receiver_loop',
             'notify "message"',
-            'notifications enable=False',
             'load', 'INFO: Send & Receive messages with Telegram bot')

micrOS/source/Logger.py

@@ -1,3 +1,9 @@
+"""
+Module is responsible for System and User logging
+- built-in log rotation
+
+Designed by Marcell Ban aka BxNxM
+"""
 from time import localtime
 from os import listdir, remove