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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: naeural_client
-Version: 2.7.5
+Version: 2.7.6
 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.6}/naeural_client/_ver.py

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

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

@@ -2388,13 +2388,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.6}/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.6}/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.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "naeural_client"
-version = "2.7.5"
+version = "2.7.6"
 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.6}/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.6}/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.6}/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.6}/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.6}/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.6}/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.6}/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.6/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.6}/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.6}/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.6}/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):

naeural_client-2.7.5/tutorials/ex10_telegram_echo_bot.py

@@ -1,45 +0,0 @@
-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__":
-  # TELEGRAM_BOT_TOKEN_ENV_KEY = "TELEGRAM_BOT_TOKEN"  # this is the default - we can specify a env key here
-  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.wait_for_node(my_node) # wait for the node to be active
-    
-      
-  # now we create a telegram bot pipeline & plugin instance
-  # we can chose to use the token directly or use the environment key
-  # instance: PLUGIN_TYPES.TELEGRAM_BASIC_BOT_01  
-  pipeline, _ = session.create_telegram_simple_bot(
-    node=my_node,
-    name="telegram_bot_echo",
-    # telegram_bot_token=os.getenv("TELEGRAM_BOT_TOKEN"),  # we use the token directly
-    # telegram_bot_token_env_key=TELEGRAM_BOT_TOKEN_ENV_KEY, # not mandatory - we can use the default
-    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
-  #   in production, you would not need this code as the script can close after the pipeline will be sent  
-  session.run(
-    wait=120,  # we run 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
-  )