naeural-client 2.7.5__tar.gz → 2.7.7__tar.gz

{naeural_client-2.7.5 → naeural_client-2.7.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: naeural_client
-Version: 2.7.5
+Version: 2.7.7
 Summary: `naeural_client` is the Python SDK required for client app development for the Naeural Edge Protocol Edge Protocol framework
 Project-URL: Homepage, https://github.com/NaeuralEdgeProtocol/naeural_client
 Project-URL: Bug Tracker, https://github.com/NaeuralEdgeProtocol/naeural_client/issues

{naeural_client-2.7.5 → naeural_client-2.7.7}/naeural_client/_ver.py

@@ -1,4 +1,4 @@
-__VER__ = "2.7.5"
+__VER__ = "2.7.7"
 
 if __name__ == "__main__":
   with open("pyproject.toml", "rt") as fd:

{naeural_client-2.7.5 → naeural_client-2.7.7}/naeural_client/base/generic_session.py

@@ -42,6 +42,7 @@ from ..utils.config import (
 
 
 DEBUG_MQTT_SERVER = "r9092118.ala.eu-central-1.emqxsl.com"
+SDK_NETCONFIG_REQUEST_DELAY = 300
 
 
 class GenericSession(BaseDecentrAIObject):
@@ -88,6 +89,7 @@ class GenericSession(BaseDecentrAIObject):
               on_notification=None,
               on_heartbeat=None,
               debug_silent=True,
+              debug=False,
               silent=False,
               verbosity=1,
               dotenv_path=None,
@@ -156,8 +158,13 @@ class GenericSession(BaseDecentrAIObject):
         As arguments, it has a reference to this Session object, the node name and the heartbeat payload.
         Defaults to None.
         
-    debug_silent : bool, optional
+    debug_silent : bool, optional 
         This flag will disable debug logs, set to 'False` for a more verbose log, by default True
+        Observation: Obsolete, will be removed
+        
+    debug : bool, optional
+        This flag will enable debug logs, set to 'False` for a more verbose log, by default False
+        
         
     silent : bool, optional
         This flag will disable all logs, set to 'False` for a more verbose log, by default False
@@ -174,9 +181,11 @@ class GenericSession(BaseDecentrAIObject):
         Defaults to True.
     """
     
+    debug = debug or not debug_silent
+    
     self.__at_least_one_node_peered = False
     self.__at_least_a_netmon_received = False
-
+    
     # TODO: maybe read config from file?
     self._config = {**self.default_config, **config}
 
@@ -204,6 +213,9 @@ class GenericSession(BaseDecentrAIObject):
     self._dct_can_send_to_node: dict[str, bool] = {}
     self._dct_node_last_seen_time = {} # key is node address
     self._dct_node_addr_name = {}
+
+    self._dct_netconfig_pipelines_requests = {}
+    
     self.online_timeout = 60
     self.filter_workers = filter_workers
     self.__show_commands = show_commands
@@ -260,7 +272,7 @@ class GenericSession(BaseDecentrAIObject):
       
     super(GenericSession, self).__init__(
       log=log, 
-      DEBUG=not debug_silent, 
+      DEBUG=debug, 
       create_logger=True,
       silent=self.silent,
       local_cache_base_folder=local_cache_base_folder,
@@ -528,8 +540,7 @@ class GenericSession(BaseDecentrAIObject):
         **kwargs
       )
       self.bc_engine.sign(msg_to_send)
-      if not self.silent:
-        self.P(f'Sending encrypted payload to <{node_addr}>', color='y')
+      self.P(f'Sending encrypted payload to <{node_addr}>', color='d')
       self._send_payload(msg_to_send)
       return
 
@@ -551,10 +562,12 @@ class GenericSession(BaseDecentrAIObject):
       additional_data = {
         PAYLOAD_DATA.EE_PAYLOAD_PATH: [self.bc_engine.address, DEFAULT_PIPELINES.ADMIN_PIPELINE, PLUGIN_SIGNATURES.NET_CONFIG_MONITOR, None]
       }
+      self.D("Sending net-config request to <{}>".format(node_addr), color='y')
       self.send_encrypted_payload(
         node_addr=node_addr, payload=payload,
         additional_data=additional_data
       )
+      self._dct_netconfig_pipelines_requests[node_addr] = tm()      
       return
 
     def __track_allowed_node_by_netmon(self, node_addr, dict_msg):
@@ -578,9 +591,17 @@ class GenericSession(BaseDecentrAIObject):
         self.__track_online_node(node_addr, node_alias)
       
       client_is_allowed = self.bc_engine.contains_current_address(node_whitelist)
-      can_send = not node_secured or client_is_allowed or self.bc_engine.address == node_addr
+      can_send = not node_secured or client_is_allowed or self.bc_engine.address == node_addr      
       if node_addr not in self._dct_can_send_to_node and can_send:
-        self.__request_pipelines_from_net_config_monitor(node_addr)
+        if node_online:
+          # only attempt to request pipelines if the node is online and if not recently requested
+          last_requested_by_netmon = self._dct_netconfig_pipelines_requests.get(node_addr, 0)
+          if tm() - last_requested_by_netmon > SDK_NETCONFIG_REQUEST_DELAY:
+            self.__request_pipelines_from_net_config_monitor(node_addr)
+          else:
+            self.D(f"Node <{node_addr}> is online but pipelines were recently requested", color='y')
+        else:
+          self.D(f"Node <{node_addr}> is offline thus NOT sending net-config request", color='y')
       # endif node seen for the first time
 
       self._dct_can_send_to_node[node_addr] = can_send
@@ -623,6 +644,7 @@ class GenericSession(BaseDecentrAIObject):
           The name of the instance that sent the message.
       """
       # extract relevant data from the message
+      self.D("<HB> Received hb from: {}".format(msg_node_addr), verbosity=2)
 
       if dict_msg.get(HB.HEARTBEAT_VERSION) == HB.V2:
         str_data = self.log.decompress_text(dict_msg[HB.ENCODED_DATA])
@@ -647,7 +669,7 @@ class GenericSession(BaseDecentrAIObject):
         # this is for legacy and custom implementation where heartbeats still contain
         # the pipeline configuration.
         pipeline_names = [x.get(PAYLOAD_DATA.NAME, None) for x in msg_active_configs]
-        self.D(f'<HB>Received pipelines from <{msg_node_addr}>:{pipeline_names}', color='y')
+        self.D(f'<HB> Processing pipelines from <{msg_node_addr}>:{pipeline_names}', color='y')
         self.__process_node_pipelines(msg_node_addr, msg_active_configs)
 
       # TODO: move this call in `__on_message_default_callback`
@@ -661,7 +683,7 @@ class GenericSession(BaseDecentrAIObject):
       for transaction in open_transactions_copy:
         transaction.handle_heartbeat(dict_msg)
 
-      self.D("Received hb from: {}".format(msg_node_addr), verbosity=2)
+      self.D("<HB> Received hb from: {}".format(msg_node_addr), verbosity=2)
 
       self.__track_allowed_node_by_hb(msg_node_addr, dict_msg)
 
@@ -746,27 +768,31 @@ class GenericSession(BaseDecentrAIObject):
         current_network = dict_msg.get(PAYLOAD_DATA.NETMON_CURRENT_NETWORK, {})        
         if current_network:
           self.__at_least_a_netmon_received = True
-          all_addresses = [
-            x[PAYLOAD_DATA.NETMON_ADDRESS] for x in current_network.values()
-          ]
-          online_addresses = [
-            x[PAYLOAD_DATA.NETMON_ADDRESS] for x in current_network.values() 
-            if x[PAYLOAD_DATA.NETMON_STATUS_KEY] == PAYLOAD_DATA.NETMON_STATUS_ONLINE
-          ] 
-          self.P(f"Net config from <{sender_addr}> `{ee_id}`:  {len(online_addresses)}/{len(all_addresses)}", color='y')
           self.__current_network_statuses[sender_addr] = current_network
-
+          online_addresses = []
+          all_addresses = []
           for _ , node_data in current_network.items():
-            node_addr = node_data.get("address", None)    
+            node_addr = node_data.get(PAYLOAD_DATA.NETMON_ADDRESS, None)
+            all_addresses.append(node_addr)
+            is_online = node_data.get(PAYLOAD_DATA.NETMON_STATUS_KEY) == PAYLOAD_DATA.NETMON_STATUS_ONLINE
+            node_alias = node_data.get(PAYLOAD_DATA.NETMON_EEID, None)
+            if is_online:
+              # no need to call here __track_online_node as it is already called 
+              # in below in __track_allowed_node_by_netmon
+              online_addresses.append(node_addr)
+            # end if is_online
             if node_addr is not None:
               self.__track_allowed_node_by_netmon(node_addr, node_data)
-              nr_peers = sum([v for k, v in self._dct_can_send_to_node.items()])
-              if nr_peers > 0 and not self.__at_least_one_node_peered:                
-                self.__at_least_one_node_peered = True
-                self.P(
-                  f"Received {PLUGIN_SIGNATURES.NET_MON_01} from {sender_addr}, so far {nr_peers} peers that allow me: {json.dumps(self._dct_can_send_to_node, indent=2)}", 
-                  color='g'
-                )
+            # end if node_addr
+          # end for each node in network map
+          nr_peers = sum(self._dct_can_send_to_node.values())
+          self.P(f"Net config from <{sender_addr}> `{ee_id}`:  {len(online_addresses)}/{len(all_addresses)}", color='y')
+          if nr_peers > 0 and not self.__at_least_one_node_peered:                
+            self.__at_least_one_node_peered = True
+            self.P(
+              f"Received {PLUGIN_SIGNATURES.NET_MON_01} from {sender_addr}, so far {nr_peers} peers that allow me: {json.dumps(self._dct_can_send_to_node, indent=2)}", 
+              color='g'
+            )
           # end for each node in network map
         # end if current_network is valid
       # end if NET_MON_01
@@ -786,31 +812,37 @@ class GenericSession(BaseDecentrAIObject):
       if msg_pipeline.lower() == REQUIRED_PIPELINE.lower() and msg_signature.upper() == REQUIRED_SIGNATURE.upper():
         # extract data
         sender_addr = dict_msg.get(PAYLOAD_DATA.EE_SENDER, None)
+        short_sender_addr = sender_addr[:8] + '...' + sender_addr[-4:]
+        if self.client_address == sender_addr:
+          self.D("<NETCFG> Ignoring message from self", color='d')
         receiver = dict_msg.get(PAYLOAD_DATA.EE_DESTINATION, None)
         if not isinstance(receiver, list):
           receiver = [receiver]
         path = dict_msg.get(PAYLOAD_DATA.EE_PAYLOAD_PATH, [None, None, None, None])
         ee_id = dict_msg.get(PAYLOAD_DATA.EE_ID, None)
+        op = dict_msg.get(NET_CONFIG.NET_CONFIG_DATA, {}).get(NET_CONFIG.OPERATION, "UNKNOWN")
+        # drop any incoming request as we are not a net-config provider just a consumer
+        if op == NET_CONFIG.REQUEST_COMMAND:
+          self.P(f"<NETCFG> Dropping request from <{short_sender_addr}> `{ee_id}`", color='d')
+          return
         
         # check if I am allowed to see this payload
         if not self.bc_engine.contains_current_address(receiver):
-          self.P(f"Received net-config from <{sender_addr}> `{ee_id}` but I am not in the receiver list: {receiver}", color='d')
+          self.P(f"<NETCFG> Received `{op}` from <{short_sender_addr}> `{ee_id}` but I am not in the receiver list: {receiver}", color='d')
           return                
 
-        # decrypt payload
+        # encryption check. By now all should be decrypted
         is_encrypted = dict_msg.get(PAYLOAD_DATA.EE_IS_ENCRYPTED, False)
         if not is_encrypted:
-          self.P(f"Received net-config from <{sender_addr}> `{ee_id}` but it is not encrypted", color='r')
+          self.P(f"<NETCFG> Received from <{short_sender_addr}> `{ee_id}` but it is not encrypted", color='r')
           return
         net_config_data = dict_msg.get(NET_CONFIG.NET_CONFIG_DATA, {})
         received_pipelines = net_config_data.get('PIPELINES', [])
-        self.D(f"Received {len(received_pipelines)} pipelines from <{sender_addr}>")
+        self.D(f"<NETCFG> Received {len(received_pipelines)} pipelines from <{sender_addr}>")
         new_pipelines = self.__process_node_pipelines(sender_addr, received_pipelines)
         pipeline_names = [x.name for x in new_pipelines]
-        self.P(f'<NETCFG>Received pipelines from <{sender_addr}>:{pipeline_names}', color='y')
-        self.D(f'[DEBUG][NETCFG]Received pipelines from <{sender_addr}>:\n{new_pipelines}', color='y')
-
-        # load with same method as a hb
+        if len(new_pipelines) > 0:
+          self.P(f'<NETCFG>   Received NEW pipelines from <{sender_addr}>:{pipeline_names}', color='y')
       return True
       
 
@@ -1163,7 +1195,8 @@ class GenericSession(BaseDecentrAIObject):
       self, 
       seconds=10, 
       close_session_on_timeout=True, 
-      close_pipeline_on_timeout=False
+      close_pipeline_on_timeout=False,
+      **kwargs,
     ):
       """
       Wait for a given amount of time.
@@ -1178,11 +1211,21 @@ class GenericSession(BaseDecentrAIObject):
           
       close_pipeline_on_timeout : bool, optional
           If `True`, will close the pipelines when the time is up, by default False
+          
+      **kwargs : dict
+          Additional or replacement parameters to be passed to the `run` method:
+            `close_session` : bool - If `True` will close the session when the loop is exited.
+            `close_pipelines` : bool - If `True` will close all pipelines initiated by this session when the loop is exited.
+          
       """
+      if "close_pipelines" in kwargs:
+        close_pipeline_on_timeout = kwargs.get("close_pipelines")
+      if "close_session" in kwargs:
+        close_session_on_timeout = kwargs.get("close_session")
       self.run(
         wait=seconds, 
         close_session=close_session_on_timeout, 
-        close_pipelines=close_pipeline_on_timeout
+        close_pipelines=close_pipeline_on_timeout,
       )
       return    
 
@@ -2388,13 +2431,13 @@ class GenericSession(BaseDecentrAIObject):
       if telegram_bot_token is None:
         telegram_bot_token = os.getenv(telegram_bot_token_env_key)
         if telegram_bot_token is None:
-          message = f"Warning! No Telegram bot token provided as via env {ENVIRONMENT.TELEGRAM_BOT_TOKEN_ENV_KEY} or explicitly as `telegram_bot_token` param."
+          message = f"Warning! No Telegram bot token provided as via env '{telegram_bot_token_env_key}' or explicitly as `telegram_bot_token` param."
           raise ValueError(message)
         
       if telegram_bot_name is None:
-        telegram_bot_name = os.getenv(telegram_bot_name_env_key)
+        telegram_bot_name = os.getenv(telegram_bot_name_env_key, name)
         if telegram_bot_name is None:
-          message = f"Warning! No Telegram bot name provided as via env {ENVIRONMENT.TELEGRAM_BOT_NAME_ENV_KEY} or explicitly as `telegram_bot_name` param."
+          message = f"Warning! No Telegram bot name provided as via env '{telegram_bot_name_env_key}' or explicitly as `telegram_bot_name` param."
           raise ValueError(message)
       
 

{naeural_client-2.7.5 → naeural_client-2.7.7}/naeural_client/bc/base.py

@@ -1514,6 +1514,7 @@ class BaseBlockEngine:
     debug=False, 
     max_tries=5,
     network=None,
+    return_full_data=False,
     **kwargs
   ):
     """
@@ -1662,4 +1663,6 @@ class BaseBlockEngine:
       # Invalid URL, thus dct_env will remain None
       self.P(f"dAuth URL is not invalid: {url}", color='r')
     #end if url is valid
+    if return_full_data:
+      return dct_response
     return dct_env

{naeural_client-2.7.5 → naeural_client-2.7.7}/naeural_client/const/environment.py

@@ -29,7 +29,7 @@ class ENVIRONMENT:
   EE_SECURED = 'EE_SECURED'
   AIXP_SECURED = 'AIXP_SECURED'
   
-  TELEGRAM_BOT_TOKEN_ENV_KEY = 'TELEGRAM_BOT_TOKEN'
-  TELEGRAM_BOT_NAME_ENV_KEY = 'TELEGRAM_BOT_NAME'
+  TELEGRAM_BOT_TOKEN_ENV_KEY = 'EE_TELEGRAM_BOT_TOKEN'
+  TELEGRAM_BOT_NAME_ENV_KEY = 'EE_TELEGRAM_BOT_NAME'
   
-  TELEGRAM_API_AGENT_TOKEN_ENV_KEY = 'TELEGRAM_API_AGENT_TOKEN'
+  TELEGRAM_API_AGENT_TOKEN_ENV_KEY = 'EE_TELEGRAM_API_AGENT_TOKEN'

{naeural_client-2.7.5 → naeural_client-2.7.7}/nepctl.MD

@@ -21,7 +21,7 @@ EE_MQTT=
 
 EE_SECURED=true
 
-TARGET_NODE=
+EE_TARGET_NODE=
 ```
 
 

{naeural_client-2.7.5 → naeural_client-2.7.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "naeural_client"
-version = "2.7.5"
+version = "2.7.7"
 authors = [
   { name="Andrei Ionut Damian", email="andrei.damian@me.com" },
   { name="Cristan Bleotiu", email="cristibleotiu@gmail.com" },

{naeural_client-2.7.5 → naeural_client-2.7.7}/tutorials/.example_env

@@ -5,4 +5,4 @@ EE_HOSTNAME=r9092118.ala.eu-central-1.emqxsl.com
 EE_PORT=8883
 EE_SECURED=true
 
-TARGET_NODE=0xai....
+EE_TARGET_NODE=0xai....

{naeural_client-2.7.5 → naeural_client-2.7.7}/tutorials/ex01_part1_connect.py

@@ -46,9 +46,22 @@ class MessageHandler:
     node_alias = heartbeat[PAYLOAD_DATA.EE_ID]
     short_addr = self.shorten_address(node_addr)
     cpu = heartbeat[HEARTBEAT_DATA.CPU]
-    if node_alias.startswith("mnoderunner"):
-      self.hb = heartbeat
-    session.P(f"{node_alias} <{short_addr}> has a {cpu}", color='magenta')
+    cpu_load = heartbeat[HEARTBEAT_DATA.CPU_USED]
+    mem = heartbeat[HEARTBEAT_DATA.MACHINE_MEMORY]
+    mem_avail = heartbeat[HEARTBEAT_DATA.AVAILABLE_MEMORY]
+    disk_avail = heartbeat[HEARTBEAT_DATA.AVAILABLE_DISK]
+    disk_total = heartbeat[HEARTBEAT_DATA.TOTAL_DISK]
+    disk_load = (disk_total - disk_avail) / disk_total * 100
+    mem_load = (mem - mem_avail) / mem * 100
+    self.hb = heartbeat # simple storage of the last heartbeat
+    plugins = heartbeat[HEARTBEAT_DATA.ACTIVE_PLUGINS] or []
+    pipelines = heartbeat[HEARTBEAT_DATA.CONFIG_STREAMS] or []
+    session.P(
+      "<{}> {} {} Load: {:.1f}% CPU, {:.1f}% RAM, {:.1f}% Disk, {} plugins, {} pipelines".format(
+        short_addr, node_alias, cpu, cpu_load, mem_load, disk_load, len(plugins), len(pipelines)
+      ),
+      color='magenta'
+    )
     return
 
 

{naeural_client-2.7.5 → naeural_client-2.7.7}/tutorials/ex01_part2_filter.py

@@ -134,9 +134,13 @@ if __name__ == '__main__':
 
   # Observation:
   #   next code is not mandatory - it is used to keep the session open and cleanup the resources
-  #   in production, you would not need this code as the script can close after the pipeline will be sent
-  session.run(
-    wait=15, # wait for the user to stop the execution or a given time
-    close_pipelines=True # when the user stops the execution, the remote edge-node pipelines will be closed
+  #   due to the fact that this is a example/tutorial and maybe we dont want to keep the pipeline
+  #   active after the session is closed we use close_pipelines=True
+  #   in production, you would not need this code as the script can close 
+  #   after the pipeline will be sent 
+  session.wait(
+    seconds=120,            # we wait the session for 60 seconds
+    close_pipelines=True,   # we close the pipelines after the session
+    close_session=True,     # we close the session after the session
   )
   session.P("Main thread exiting...")

{naeural_client-2.7.5 → naeural_client-2.7.7}/tutorials/ex01_part3_adv_filter.py

@@ -142,7 +142,17 @@ if __name__ == '__main__':
       # silent=True,
   )
 
-  session.wait(seconds=20) # wait for the user to stop the execution or a given time
+  # Observation:
+  #   next code is not mandatory - it is used to keep the session open and cleanup the resources
+  #   due to the fact that this is a example/tutorial and maybe we dont want to keep the pipeline
+  #   active after the session is closed we use close_pipelines=True
+  #   in production, you would not need this code as the script can close 
+  #   after the pipeline will be sent 
+  session.wait(
+    seconds=120,            # we wait the session for 60 seconds
+    close_pipelines=True,   # we close the pipelines after the session
+    close_session=True,     # we close the session after the session
+  )
   session.P("Main thread exiting...")
   
   netinfo = session.get_network_known_nodes()  

{naeural_client-2.7.5 → naeural_client-2.7.7}/tutorials/ex02_part1_deploy_webapi.py

@@ -24,7 +24,13 @@ def run_predict(plugin: CustomPluginTemplate, inputs: list[int], nr_steps: int)
 if __name__ == '__main__':
   
   session = Session(silent=True)
+
   my_node = "0xai_ApM1AbzLq1VtsLIidmvzt1Nv4Cyl5Wed0fHNMoZv9u4X"
+
+  # NOTE: When working with SDK please use the nodes internal addresses. While the EVM address of the node
+  #       is basically based on the same sk/pk it is in a different format and not directly usable with the SDK
+  #       the internal node address is easily spoted as starting with 0xai_ and can be found 
+  #       via `docker exec r1node get_node_info` or via the launcher UI
   
   app, _ = session.create_web_app(
     node=my_node,
@@ -42,8 +48,14 @@ if __name__ == '__main__':
   except Exception as e:
     print("Error deploying webapp: ", e)
   
+  # Observation:
+  #   next code is not mandatory - it is used to keep the session open and cleanup the resources
+  #   due to the fact that this is a example/tutorial and maybe we dont want to keep the pipeline
+  #   active after the session is closed we use close_pipelines=True
+  #   in production, you would not need this code as the script can close 
+  #   after the pipeline will be sent 
   session.wait(
-    close_pipeline_on_timeout=True,
-    close_session_on_timeout=True,
-    seconds=300
+    seconds=120,            # we wait the session for 60 seconds
+    close_pipelines=True,   # we close the pipelines after the session
+    close_session=True,     # we close the session after the session
   )

{naeural_client-2.7.5 → naeural_client-2.7.7}/tutorials/ex02_part2_deploy_plugin.py

@@ -20,6 +20,12 @@ def instance_on_data(pipeline: Pipeline, data: Payload):
 if __name__ == '__main__':
   # create a session
   # the network credentials are read from the .env file automatically
+
+  # NOTE: When working with SDK please use the nodes internal addresses. While the EVM address of the node
+  #       is basically based on the same sk/pk it is in a different format and not directly usable with the SDK
+  #       the internal node address is easily spoted as starting with 0xai_ and can be found 
+  #       via `docker exec r1node get_node_info` or via the launcher UI
+
   session: Session = Session(encrypt_comms=True)
 
   session.wait_for_any_node()
@@ -57,9 +63,13 @@ if __name__ == '__main__':
 
   # Observation:
   #   next code is not mandatory - it is used to keep the session open and cleanup the resources
-  #   in production, you would not need this code as the script can close after the pipeline will be sent
-  session.run(
-    wait=60, # wait for the user to stop the execution or a given time
-    close_pipelines=True # when the user stops the execution, the remote edge-node pipelines will be closed
+  #   due to the fact that this is a example/tutorial and maybe we dont want to keep the pipeline
+  #   active after the session is closed we use close_pipelines=True
+  #   in production, you would not need this code as the script can close 
+  #   after the pipeline will be sent 
+  session.wait(
+    seconds=120,            # we wait the session for 60 seconds
+    close_pipelines=True,   # we close the pipelines after the session
+    close_session=True,     # we close the session after the session
   )
   session.P("Main thread exiting...")

{naeural_client-2.7.5 → naeural_client-2.7.7}/tutorials/ex08_custom_webapi.py

@@ -44,7 +44,7 @@ def predict(plugin: CustomPluginTemplate, series: list[int], steps: int) -> list
 if __name__ == "__main__":
   session = Session(silent=True)
 
-  node = os.environ.get("TARGET_NODE", "INSERT_YOUR_NODE_ADDRESS_HERE")
+  node = os.environ.get("EE_TARGET_NODE", "INSERT_YOUR_NODE_ADDRESS_HERE")
   session.P(f"Waiting for node {node} to be available for deployment...")
   session.wait_for_node(node)
 

naeural_client-2.7.7/tutorials/ex10_telegram_echo_bot.py

@@ -0,0 +1,57 @@
+import os
+import time
+
+from naeural_client import Session, CustomPluginTemplate, PLUGIN_TYPES
+
+def reply(plugin: CustomPluginTemplate, message: str, user: str):
+  """
+  This function is used to reply to a message. The given parameters are mandatory
+  """
+  # for each user message we increase a counter
+  plugin.int_cache[user] += 1 # int_cache is a default dict that allows persistence in the plugin
+  plugin.P(f"Replying to the {plugin.int_cache[user]} msg of '{user}' on message '{message}'")
+  result = f"The answer to your {plugin.int_cache[user]} question is in the question itself: {message}"
+  return result
+
+
+if __name__ == "__main__":   
+  session = Session() 
+
+  # NOTE: When working with SDK please use the nodes internal addresses. While the EVM address of the node
+  #       is basically based on the same sk/pk it is in a different format and not directly usable with the SDK
+  #       the internal node address is easily spoted as starting with 0xai_ and can be found 
+  #       via `docker exec r1node get_node_info` or via the launcher UI
+
+  # this tutorial assumes you have started your own local node for dev-testing purposes
+  # you can either supply the node address via env or directly here
+  # Note: in order to get the environment variable first you have to create the Session
+  #       object that will load the environment variables
+  my_node = os.getenv("EE_TARGET_NODE", "0xai_my_own_node_address") 
+
+  session.wait_for_node(my_node) 
+    
+      
+  # now we create a telegram bot pipeline & plugin instance and for that we only need the Telegram token
+  # we can chose to use the token directly via `telegram_bot_token` parameter
+  # or use the environment key EE_TELEGRAM_BOT_TOKEN 
+  # in this case for this simple example we are going to use the token directly
+  pipeline, _ = session.create_telegram_simple_bot(
+    node=my_node,
+    name="telegram_bot_echo",
+    telegram_bot_token="your_token_goes_here",  # we use the token directly
+    message_handler=reply,
+  )
+  
+  pipeline.deploy() # we deploy the pipeline
+
+  # Observation:
+  #   next code is not mandatory - it is used to keep the session open and cleanup the resources
+  #   due to the fact that this is a example/tutorial and maybe we dont want to keep the pipeline
+  #   active after the session is closed we use close_pipelines=True
+  #   in production, you would not need this code as the script can close 
+  #   after the pipeline will be sent 
+  session.wait(
+    seconds=120,            # we wait the session for 120 seconds
+    close_pipelines=True,   # we close the pipelines after the session
+    close_session=True,     # we close the session after the session
+  )

{naeural_client-2.7.5 → naeural_client-2.7.7}/tutorials/ex11_telegram_blackjack_bot.py

@@ -186,12 +186,20 @@ def reply(plugin, message: str, user: str):
 
 
 if __name__ == "__main__":
-  my_node = os.getenv("TARGET_NODE") # we can specify a node here, if we want to connect to a specific
     
-  session = Session() # assume .env is available and will be used for the connection and tokens
+  session = Session() 
+  
+  # assume .env is available and will be used for the connection and tokens
+  # NOTE: When working with SDK please use the nodes internal addresses. While the EVM address of the node
+  #       is basically based on the same sk/pk it is in a different format and not directly usable with the SDK
+  #       the internal node address is easily spoted as starting with 0xai_ and can be found 
+  #       via `docker exec r1node get_node_info` or via the launcher UI
+  my_node = os.getenv("EE_TARGET_NODE", "0xai_your_node_address") # we can specify a node here, if we want to connect to a specific
+
   session.wait_for_node(my_node) # wait for the node to be active
     
-      
+  # unlike the previous example, we are going to use the token from the environment
+  # and deploy the app on the target node and leave it there
   pipeline, _ = session.create_telegram_simple_bot(
     node=my_node,
     name="telegram_bot_blackjack",
@@ -200,4 +208,16 @@ if __name__ == "__main__":
   
   pipeline.deploy() # we deploy the pipeline
 
+
+  # Observation:
+  #   next code is not mandatory - it is used to keep the session open and cleanup the resources
+  #   due to the fact that this is a example/tutorial and maybe we dont want to keep the pipeline
+  #   active after the session is closed we use close_pipelines=True
+  #   in production, you would not need this code as the script can close 
+  #   after the pipeline will be sent 
+  session.wait(
+    seconds=600,            # we wait the session for 10 minutes
+    close_pipelines=True,   # we close the pipelines after the session
+    close_session=True,     # we close the session after the session
+  )
  

{naeural_client-2.7.5 → naeural_client-2.7.7}/tutorials/ex12_telegram_smart_bot.py

@@ -2,21 +2,25 @@ import os
 from naeural_client import Session
 
 if __name__ == "__main__":
-  my_node = os.getenv("TARGET_NODE")  # we specify a node here
-  # The node can also be specified directly, without using the environment variable.
-  # my_node = "<target_edge_node_identifier>"
   
-  if my_node is None:
-    # In case the node is not specified, we exit the script.
-    print("Please specify the node to connect to.")
-    exit(1)
-
   # We define the system prompt
   SYSTEM_PROMPT = """
   Hi! I am a simple echo bot. I will repeat everything you say to me.
   """
 
   session = Session()  # assume .env is available and will be used for the connection and tokens
+
+  # NOTE: When working with SDK please use the nodes internal addresses. While the EVM address of the node
+  #       is basically based on the same sk/pk it is in a different format and not directly usable with the SDK
+  #       the internal node address is easily spoted as starting with 0xai_ and can be found 
+  #       via `docker exec r1node get_node_info` or via the launcher UI
+
+  my_node = os.getenv("EE_TARGET_NODE")  # we specify a node here
+  # The node can also be specified directly, without using the environment variable.
+  # my_node = "<target_edge_node_identifier>"
+  
+  assert my_node is not None, "Please provide the target edge node identifier"
+
   session.wait_for_node(my_node)  # wait for the node to be active
 
   # Now we create a telegram bot pipeline & plugin instance.

{naeural_client-2.7.5 → naeural_client-2.7.7}/tutorials/ex13_launch_repo_based_webapp.py

@@ -12,8 +12,8 @@ if __name__ == "__main__":
   session = Session()
 
   nodes = [
-    environ.get("TARGET_NODE_1", "INSERT_YOUR_NODE_ADDRESS_HERE"),
-    environ.get("TARGET_NODE_2", "INSERT_YOUR_NODE_ADDRESS_HERE")
+    environ.get("EE_TARGET_NODE_1", "INSERT_YOUR_NODE_ADDRESS_HERE"),
+    environ.get("EE_TARGET_NODE_2", "INSERT_YOUR_NODE_ADDRESS_HERE")
   ]
 
   if isinstance(nodes, str):