naeural-client 2.6.14__py3-none-any.whl → 2.6.16__py3-none-any.whl

naeural_client/_ver.py

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

naeural_client/base/generic_session.py

@@ -23,7 +23,7 @@ from ..bc import DefaultBlockEngine, _DotDict
 from ..const import (
   COMMANDS, ENVIRONMENT, HB, PAYLOAD_DATA, STATUS_TYPE, 
   PLUGIN_SIGNATURES, DEFAULT_PIPELINES,
-  BLOCKCHAIN_CONFIG, SESSION_CT
+  BLOCKCHAIN_CONFIG, SESSION_CT, NET_CONFIG
 )
 from ..const import comms as comm_ct
 from ..io_formatter import IOFormatterWrapper
@@ -366,24 +366,33 @@ class GenericSession(BaseDecentrAIObject):
       """
       # check if payload is encrypted
       if dict_msg.get(PAYLOAD_DATA.EE_IS_ENCRYPTED, False):
-        encrypted_data = dict_msg.get(PAYLOAD_DATA.EE_ENCRYPTED_DATA, None)
-        sender_addr = dict_msg.get(comm_ct.COMM_SEND_MESSAGE.K_SENDER_ADDR, None)
+        destination = dict_msg.get(PAYLOAD_DATA.EE_DESTINATION, [])
+        if not isinstance(destination, list):
+          destination = [destination]
+        if self.bc_engine.contains_current_address(destination):
 
-        str_data = self.bc_engine.decrypt(encrypted_data, sender_addr)
+          encrypted_data = dict_msg.get(PAYLOAD_DATA.EE_ENCRYPTED_DATA, None)
+          sender_addr = dict_msg.get(comm_ct.COMM_SEND_MESSAGE.K_SENDER_ADDR, None)
 
-        if str_data is None:
-          self.D("Cannot decrypt message, dropping..\n{}".format(str_data), verbosity=2)
-          return None
+          str_data = self.bc_engine.decrypt(encrypted_data, sender_addr)
 
-        try:
-          dict_data = json.loads(str_data)
-        except Exception as e:
-          self.P("Error while decrypting message: {}".format(e), color='r', verbosity=1)
-          self.D("Message: {}".format(str_data), verbosity=2)
-          return None
+          if str_data is None:
+            self.D("Cannot decrypt message, dropping..\n{}".format(str_data), verbosity=2)
+            return None
 
-        dict_msg = {**dict_data, **dict_msg}
-        dict_msg.pop(PAYLOAD_DATA.EE_ENCRYPTED_DATA, None)
+          try:
+            dict_data = json.loads(str_data)
+          except Exception as e:
+            self.P("Error while decrypting message: {}".format(e), color='r', verbosity=1)
+            self.D("Message: {}".format(str_data), verbosity=2)
+            return None
+
+          dict_msg = {**dict_data, **dict_msg}
+          dict_msg.pop(PAYLOAD_DATA.EE_ENCRYPTED_DATA, None)
+        else:
+          payload_path = dict_msg.get(PAYLOAD_DATA.EE_PAYLOAD_PATH, None)
+          self.D(f"Message {payload_path} is encrypted but not for this address.", verbosity=2)
+        # endif message for us
       # end if encrypted
 
       formatter = self.formatter_wrapper \
@@ -498,6 +507,56 @@ class GenericSession(BaseDecentrAIObject):
       self._dct_can_send_to_node[node_addr] = not node_secured or client_is_allowed or self.bc_engine.address == node_addr
       return
 
+    def send_encrypted_payload(self, node_addr, payload, **kwargs):
+      """
+      TODO: move in BlockChainEngine
+      Send an encrypted payload to a node.
+
+      Parameters
+      ----------
+      node_addr : str
+          The address of the edge node that will receive the message.
+      payload : dict
+          The payload dict to be sent.
+      **kwargs : dict
+          Additional data to be sent to __prepare_message.
+      """
+      msg_to_send = self.__prepare_message(
+        msg_data=payload,
+        encrypt_message=True,
+        destination=node_addr,
+        **kwargs
+      )
+      self.bc_engine.sign(msg_to_send)
+      if not self.silent:
+        self.P(f'Sending encrypted payload to <{node_addr}>', color='y')
+      self._send_payload(msg_to_send)
+      return
+
+    def __request_pipelines_from_net_config_monitor(self, node_addr):
+      """
+      Request the pipelines for a node from the net-config monitor plugin instance.
+      Parameters
+      ----------
+      node_addr : str
+          The address of the edge node that sent the message.
+
+      """
+      payload = {
+        NET_CONFIG.NET_CONFIG_DATA: {
+          NET_CONFIG.OPERATION: NET_CONFIG.REQUEST_COMMAND,
+          NET_CONFIG.DESTINATION: node_addr,
+        }
+      }
+      additional_data = {
+        PAYLOAD_DATA.EE_PAYLOAD_PATH: [self.bc_engine.address, DEFAULT_PIPELINES.ADMIN_PIPELINE, PLUGIN_SIGNATURES.NET_CONFIG_MONITOR, None]
+      }
+      self.send_encrypted_payload(
+        node_addr=node_addr, payload=payload,
+        additional_data=additional_data
+      )
+      return
+
     def __track_allowed_node_by_netmon(self, node_addr, dict_msg):
       """
       Track if this session is allowed to send messages to node using net-mon data
@@ -505,7 +564,7 @@ class GenericSession(BaseDecentrAIObject):
       Parameters
       ----------
       node_addr : str
-          The address of the Naeural Edge Protocol edge node that sent the message.
+          The address of the edge node that sent the message.
 
       dict_msg : dict
           The message received from the communication server as a heartbeat of the object from netconfig
@@ -514,8 +573,12 @@ class GenericSession(BaseDecentrAIObject):
       node_secured = dict_msg.get(PAYLOAD_DATA.NETMON_NODE_SECURED, False)
       
       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
+      if node_addr not in self._dct_can_send_to_node and can_send:
+        self.__request_pipelines_from_net_config_monitor(node_addr)
+      # endif node seen for the first time
 
-      self._dct_can_send_to_node[node_addr] = not node_secured or client_is_allowed or self.bc_engine.address == node_addr
+      self._dct_can_send_to_node[node_addr] = can_send
       return
     
     
@@ -523,6 +586,9 @@ class GenericSession(BaseDecentrAIObject):
       """
       Given a list of pipeline configurations, create or update the pipelines for a node.      
       """
+      new_pipelines = []
+      if node_addr not in self._dct_online_nodes_pipelines:
+        self._dct_online_nodes_pipelines[node_addr] = {}
       for config in pipelines:
         pipeline_name = config[PAYLOAD_DATA.NAME]
         pipeline: Pipeline = self._dct_online_nodes_pipelines[node_addr].get(pipeline_name, None)
@@ -531,7 +597,8 @@ class GenericSession(BaseDecentrAIObject):
         else:
           self._dct_online_nodes_pipelines[node_addr][pipeline_name] = self.__create_pipeline_from_config(
             node_addr, config)
-      return
+          new_pipelines.append(self._dct_online_nodes_pipelines[node_addr][pipeline_name])
+      return new_pipelines
 
     def __on_heartbeat(self, dict_msg: dict, msg_node_addr, msg_pipeline, msg_signature, msg_instance):
       """
@@ -571,14 +638,11 @@ class GenericSession(BaseDecentrAIObject):
       # as the protocol should NOT send a heartbeat with active configs to
       # the entire network, only to the interested parties via net-config
 
-      # default action
-      if msg_node_addr not in self._dct_online_nodes_pipelines:
-        # this is ok here although we dont get the pipelines from the heartbeat
-        self._dct_online_nodes_pipelines[msg_node_addr] = {}
-        
       if len(msg_active_configs) > 0:
         # 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.__process_node_pipelines(msg_node_addr, msg_active_configs)
 
       # TODO: move this call in `__on_message_default_callback`
@@ -699,8 +763,7 @@ class GenericSession(BaseDecentrAIObject):
         # end if current_network is valid
       # end if NET_MON_01
       return
-      
-      
+
     def __maybe_process_net_config(
       self, 
       dict_msg: dict,  
@@ -708,7 +771,39 @@ class GenericSession(BaseDecentrAIObject):
       msg_signature : str,
       sender_addr: str,
     ):
-      return
+      # TODO: bleo if session is in debug mode then for each net-config show what pipelines have
+      # been received
+      REQUIRED_PIPELINE = DEFAULT_PIPELINES.ADMIN_PIPELINE
+      REQUIRED_SIGNATURE = PLUGIN_SIGNATURES.NET_CONFIG_MONITOR
+      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)
+        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)
+        
+        # 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')
+          return                
+
+        # decrypt payload
+        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')
+          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}>")
+        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
+      return True
       
 
     # TODO: maybe convert dict_msg to Payload object
@@ -908,15 +1003,38 @@ class GenericSession(BaseDecentrAIObject):
       """
       raise NotImplementedError
 
-    def _send_payload(self, to, payload):
+    def _send_raw_message(self, to, msg, communicator='default'):
       """
-      Send a payload to a node.
+      Send a message to a node.
 
       Parameters
       ----------
       to : str
-          The name of the Naeural Edge Protocol edge node that will receive the payload.
-      payload : dict
+          The name of the Naeural Edge Protocol edge node that will receive the message.
+      msg : dict or str
+          The message to send.
+      """
+      raise NotImplementedError
+
+    def _send_command(self, to, command):
+      """
+      Send a command to a node.
+
+      Parametersc
+      ----------
+      to : str
+          The name of the Naeural Edge Protocol edge node that will receive the command.
+      command : str or dict
+          The command to send.
+      """
+      raise NotImplementedError
+
+    def _send_payload(self, payload):
+      """
+      Send a payload to a node.
+      Parameters
+      ----------
+      payload : dict or str
           The payload to send.
       """
       raise NotImplementedError
@@ -1241,6 +1359,68 @@ class GenericSession(BaseDecentrAIObject):
         result = aliases.get(node, None)
       return result
 
+    def __prepare_message(
+        self, msg_data, encrypt_message: bool = True,
+        destination: str = None, destination_id: str = None,
+        session_id: str = None, additional_data: dict = None
+    ):
+      """
+      Prepare and maybe encrypt a message for sending.
+      Parameters
+      ----------
+      msg_data : dict
+          The message to send.
+      encrypt_message : bool
+          If True, will encrypt the message.
+      destination : str, optional
+          The destination address, by default None
+      destination_id : str, optional
+          The destination id, by default None
+      additional_data : dict, optional
+          Additional data to send, by default None
+          This has to be dict!
+
+      Returns
+      -------
+      msg_to_send : dict
+          The message to send.
+      """
+      if destination is None and destination_id is not None:
+        # Initial code `str_enc_data = self.bc_engine.encrypt(str_data, destination_id)` could not work under any
+        # circumstances due to the fact that encrypt requires the public key of the receiver not the alias
+        # of the receiver. The code below is a workaround to encrypt the message
+        # TODO: furthermore the code will be migrated to the use of the address of the worker
+        destination = self.get_addr_by_name(destination_id)
+        assert destination is not None, f"Unknown address for id: {destination_id}"
+      # endif only destination_id provided
+
+      # This part is duplicated with the creation of payloads
+      if encrypt_message and destination is not None:
+        str_data = json.dumps(msg_data)
+        str_enc_data = self.bc_engine.encrypt(str_data, destination)
+        msg_data = {
+          comm_ct.COMM_SEND_MESSAGE.K_EE_IS_ENCRYPTED: True,
+          comm_ct.COMM_SEND_MESSAGE.K_EE_ENCRYPTED_DATA: str_enc_data,
+        }
+      else:
+        msg_data[comm_ct.COMM_SEND_MESSAGE.K_EE_IS_ENCRYPTED] = False
+        if encrypt_message:
+          msg_data[comm_ct.COMM_SEND_MESSAGE.K_EE_ENCRYPTED_DATA] = "Error! No receiver address found!"
+      # endif encrypt_message and destination available
+      msg_to_send = {
+        **msg_data,
+        PAYLOAD_DATA.EE_DESTINATION: destination,
+        comm_ct.COMM_SEND_MESSAGE.K_EE_ID: destination_id,
+        comm_ct.COMM_SEND_MESSAGE.K_SESSION_ID: session_id or self.name,
+        comm_ct.COMM_SEND_MESSAGE.K_INITIATOR_ID: self.name,
+        comm_ct.COMM_SEND_MESSAGE.K_SENDER_ADDR: self.bc_engine.address,
+        comm_ct.COMM_SEND_MESSAGE.K_TIME: dt.now().strftime("%Y-%m-%d %H:%M:%S.%f"),
+      }
+      if additional_data is not None and isinstance(additional_data, dict):
+        msg_to_send.update(additional_data)
+      # endif additional_data provided
+      return msg_to_send
+
     def _send_command_to_box(self, command, worker, payload, show_command=True, session_id=None, **kwargs):
       """
       Send a command to a node.
@@ -1273,37 +1453,12 @@ class GenericSession(BaseDecentrAIObject):
         comm_ct.COMM_SEND_MESSAGE.K_PAYLOAD: payload,
       }
 
-      # This part is duplicated with the creation of payloads
-      encrypt_payload = self.encrypt_comms
-      if encrypt_payload and worker is not None:        
-        str_data = json.dumps(critical_data)
-        
-        # Initial code `str_enc_data = self.bc_engine.encrypt(str_data, worker)` could not work under any
-        # circumstances due to the fact that encrypt requires the public key of the receiver not the alias
-        # of the receiver. The code below is a workaround to encrypt the message
-        # TODO: furthermore the code will be migrated to the use of the address of the worker
-        worker_addr = self.get_addr_by_name(worker)
-        assert worker_addr is not None, f"Unknown worker address: {worker} - {worker_addr}"
-        
-        str_enc_data = self.bc_engine.encrypt(str_data, worker_addr)
-        critical_data = {
-          comm_ct.COMM_SEND_MESSAGE.K_EE_IS_ENCRYPTED: True,
-          comm_ct.COMM_SEND_MESSAGE.K_EE_ENCRYPTED_DATA: str_enc_data,
-        }
-      else:
-        critical_data[comm_ct.COMM_SEND_MESSAGE.K_EE_IS_ENCRYPTED] = False
-        if encrypt_payload:
-          critical_data[comm_ct.COMM_SEND_MESSAGE.K_EE_ENCRYPTED_DATA] = "Error! No receiver address found!"
-
-      # endif
-      msg_to_send = {
-          **critical_data,
-          comm_ct.COMM_SEND_MESSAGE.K_EE_ID: worker,
-          comm_ct.COMM_SEND_MESSAGE.K_SESSION_ID: session_id or self.name,
-          comm_ct.COMM_SEND_MESSAGE.K_INITIATOR_ID: self.name,
-          comm_ct.COMM_SEND_MESSAGE.K_SENDER_ADDR: self.bc_engine.address,
-          comm_ct.COMM_SEND_MESSAGE.K_TIME: dt.now().strftime("%Y-%m-%d %H:%M:%S.%f"),
-      }
+      msg_to_send = self.__prepare_message(
+        msg_data=critical_data,
+        encrypt_message=self.encrypt_comms,
+        destination_id=worker,
+        session_id=session_id,
+      )
       self.bc_engine.sign(msg_to_send, use_digest=True)
       if show_command:
         self.P(
@@ -1311,7 +1466,7 @@ class GenericSession(BaseDecentrAIObject):
           color='y',
           verbosity=1
         )
-      self._send_payload(worker, msg_to_send)
+      self._send_command(worker, msg_to_send)
       return
 
     def _send_command_create_pipeline(self, worker, pipeline_config, **kwargs):
@@ -2470,6 +2625,35 @@ class GenericSession(BaseDecentrAIObject):
     def client_address(self):
       return self.get_client_address()
     
+    def __wait_for_supervisors_net_mon_data(
+      self, 
+      supervisor=None, 
+      timeout=10, 
+      min_supervisors=2
+    ):
+      # the following loop will wait for the desired number of supervisors to appear online
+      # for the current session
+      start = tm()      
+      result = False
+      while (tm() - start) < timeout:
+        if supervisor is not None:
+          if supervisor in self.__current_network_statuses:
+            result = True
+            break
+        elif len(self.__current_network_statuses) >= min_supervisors:
+          result = True
+          break
+        sleep(0.1)
+      elapsed = tm() - start      
+      # end while
+      # done waiting for supervisors
+      return result, elapsed
+      
+      
+    def get_all_nodes_pipelines(self):
+      # TODO: Bleo inject this function in __on_hb and maybe_process_net_config and dump result
+      return self._dct_online_nodes_pipelines
+    
     def get_network_known_nodes(
       self, 
       timeout=10, 
@@ -2540,19 +2724,11 @@ class GenericSession(BaseDecentrAIObject):
       for k in mapping:
         res[k] = []
 
-      # the following loop will wait for the desired number of supervisors to appear online
-      # for the current session
-      start = tm()      
-      while (tm() - start) < timeout:
-        if supervisor is not None:
-          if supervisor in self.__current_network_statuses:
-            break
-        elif len(self.__current_network_statuses) >= min_supervisors:
-          break
-        sleep(0.1)
-      elapsed = tm() - start
-      # end while
-      # done waiting for supervisors
+      result, elapsed = self.__wait_for_supervisors_net_mon_data(
+        supervisor=supervisor,
+        timeout=timeout,
+        min_supervisors=min_supervisors,
+      )
       best_super = 'ERROR'
       best_super_alias = 'ERROR'
       

naeural_client/bc/base.py

@@ -1314,4 +1314,4 @@ class BaseBlockEngine:
     else:
       self.P(f"dAuth URL is not invalid: {url}", color='r')
     #end if url is valid
-    return dct_env
+    return dct_env

naeural_client/const/apps.py

@@ -10,6 +10,7 @@ class PLUGIN_SIGNATURES:
   CHAIN_DIST_CUSTOM_JOB_01 = 'PROCESS_REAL_TIME_COLLECTED_DATA_CUSTOM_EXEC_CHAIN_DIST'
   TELEGRAM_BASIC_BOT_01 = 'TELEGRAM_BASIC_BOT_01'  
   TELEGRAM_CONVERSATIONAL_BOT_01 = 'TELEGRAM_CONVERSATIONAL_BOT_01'
+  NET_CONFIG_MONITOR = 'NET_CONFIG_MONITOR'
   # INSERT_NEW_PLUGIN_HERE
   
   

naeural_client/const/base.py

@@ -18,6 +18,9 @@ DAUTH_VARS = [DAUTH_NONCE, BCctbase.SIGN, BCctbase.SENDER, BCctbase.HASH]
 
 ETH_ENABLED_ENV_KEY = 'EE_ETH_ENABLED'
 
+EE_EPOCH_INTERVALS_KEY = 'EE_EPOCH_INTERVALS'
+EE_EPOCH_INTERVAL_SECONDS_KEY = 'EE_EPOCH_INTERVAL_SECONDS'
+
 
 class LocalInfo:
   LOCAL_INFO_FILE = 'local_info.json'

naeural_client/default/session/mqtt_session.py

@@ -10,7 +10,7 @@ class MqttSession(GenericSession):
     self._default_communicator = MQTTWrapper(
         log=self.log,
         config=self._config,
-        send_channel_name=comm_ct.COMMUNICATION_CONFIG_CHANNEL,
+        send_channel_name=comm_ct.COMMUNICATION_PAYLOADS_CHANNEL,
         recv_channel_name=comm_ct.COMMUNICATION_PAYLOADS_CHANNEL,
         comm_type=comm_ct.COMMUNICATION_DEFAULT,
         recv_buff=self._payload_messages,
@@ -21,6 +21,7 @@ class MqttSession(GenericSession):
     self._heartbeats_communicator = MQTTWrapper(
         log=self.log,
         config=self._config,
+        send_channel_name=comm_ct.COMMUNICATION_CONFIG_CHANNEL,
         recv_channel_name=comm_ct.COMMUNICATION_CTRL_CHANNEL,
         comm_type=comm_ct.COMMUNICATION_HEARTBEATS,
         recv_buff=self._hb_messages,
@@ -37,6 +38,11 @@ class MqttSession(GenericSession):
         connection_name=self.name,
         verbosity=self._verbosity,
     )
+    self.__communicators = {
+      'default': self._default_communicator,
+      'heartbeats': self._heartbeats_communicator,
+      'notifications': self._notifications_communicator,
+    }
     return super(MqttSession, self).startup()
 
   @property
@@ -64,9 +70,18 @@ class MqttSession(GenericSession):
     self._notifications_communicator.release()
     return
 
-  def _send_payload(self, to, msg):
+  def _send_raw_message(self, to, msg, communicator='default'):
     payload = json.dumps(msg)
+    communicator_obj = self.__communicators.get(communicator, self._default_communicator)
+    communicator_obj._send_to = to
+    communicator_obj.send(payload)
+    return
 
-    self._default_communicator._send_to = to
-    self._default_communicator.send(payload)
+  def _send_payload(self, payload):
+    # `to` parameter will be added after migrating to segregated payloads.
+    self._send_raw_message(to=None, msg=payload, communicator='default')
     return
+
+  def _send_command(self, to, command):
+    self._send_raw_message(to, command, communicator='heartbeats')
+    return

naeural_client-2.6.16.dist-info/METADATA

@@ -0,0 +1,279 @@
+Metadata-Version: 2.4
+Name: naeural_client
+Version: 2.6.16
+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
+Author-email: Andrei Ionut Damian <andrei.damian@me.com>, Cristan Bleotiu <cristibleotiu@gmail.com>, Stefan Saraev <saraevstefan@gmail.com>
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Requires-Dist: cryptography>=39.0.0
+Requires-Dist: numpy
+Requires-Dist: paho-mqtt
+Requires-Dist: pandas
+Requires-Dist: pika
+Requires-Dist: pyaml
+Requires-Dist: pyopenssl>=23.0.0
+Requires-Dist: python-dateutil
+Requires-Dist: web3
+Description-Content-Type: text/markdown
+
+# Ratio1 SDK
+
+Welcome to the **Ratio1 SDK** repository, formerly known as the **naeural_client SDK**. The Ratio1 SDK is a crucial component of the Ratio1 ecosystem, designed to facilitate interactions, development, and deployment of jobs within the Ratio1 network. By enabling low-code development, the SDK allows developers to build and deploy end-to-end AI (and beyond) cooperative application pipelines seamlessly within the Ratio1 Edge Nodes ecosystem.
+
+## Overview
+
+The **Ratio1 SDK** is engineered to enhance the Ratio1 protocol and ecosystem, aiming to improve the functionality and performance of the Ratio1 Edge Node through dedicated research and community contributions. This SDK serves as an essential tool for developers looking to integrate their applications with the Ratio1 network, enabling them to leverage the decentralized, secure, and privacy-preserving capabilities of Ratio1 Edge Nodes.
+
+Key functionalities of the Ratio1 SDK include:
+
+- **Job Interactions**: Facilitate the development and management of computation tasks within the Ratio1 network.
+- **Development Tools**: Provide low-code solutions for creating and deploying AI-driven application pipelines.
+- **Ecosystem Integration**: Seamlessly integrate with Ratio1 Edge Nodes to utilize their computational resources effectively.
+- **Collaboration and Deployment**: Enable cooperative application development and deployment across multiple edge nodes within the Ratio1 ecosystem.
+
+Unlike the Ratio1 Core Packages, which are intended solely for protocol and ecosystem enhancements and are not meant for standalone installation, the Ratio1 SDK is designed for both client-side development and sending workloads to Ratio1 Edge Nodes, making it an indispensable tool for developers within the ecosystem.
+
+## Dependencies
+
+The Ratio1 SDK relies on several key packages to function effectively. These dependencies are automatically managed when installing the SDK via pip:
+
+- `pika`
+- `paho-mqtt`
+- `numpy`
+- `pyopenssl>=23.0.0`
+- `cryptography>=39.0.0`
+- `python-dateutil`
+- `pyaml`
+
+## Installation
+
+Installing the Ratio1 SDK is straightforward and is intended for development and integration into your projects. Use the following pip commands to install the SDK:
+
+### Standard Installation
+
+To install the Ratio1 SDK, run:
+
+```shell
+pip install ratio1_sdk --upgrade
+```
+
+### Development Installation
+
+For development purposes, you can clone the repository and set up the SDK in an editable mode:
+
+```shell
+git clone https://github.com/Ratio1/ratio1_sdk
+cd ratio1_sdk
+pip install -e .
+```
+
+This allows you to make modifications to the SDK and have them reflected immediately without reinstalling.
+
+## Documentation
+
+Comprehensive documentation for the Ratio1 SDK is currently a work in progress. Minimal documentation is available here, with detailed code examples located in the `tutorials` folder within the project's repository. We encourage developers to explore these examples to understand the SDK's capabilities and integration methods.
+
+## Quick Start Guides
+
+Starting with version 2.6+, the Ratio1 SDK automatically performs self-configuration using **dAuth**—the Ratio1 decentralized self-authentication system. To begin integrating with the Ratio1 network, follow these steps:
+
+### 1. Start a Local Edge Node
+
+Launch a local Ratio1 Edge Node using Docker:
+
+```bash
+docker run -d --name=local_node ratio1/edge_node:develop
+```
+
+After a few seconds, the node will be online. Retrieve the node's address by running:
+
+```bash
+docker exec local_node get_node_info
+```
+
+The output will resemble:
+
+```json
+{
+  "address": "0xai_AtMvIwaEPi5M8cnkdbaZ3tbUhCzKbGKEYuZ1xFtCjT_6",
+  "alias": "6dd74472642e",
+  "eth_address": "0x98FE7c0d8CeC2E97B932D2bDC1bb73B395C9Dfd7"
+}
+```
+
+### 2. Develop and Deploy Jobs
+
+Use the SDK to develop and send workloads to the Edge Nodes. Below are examples of both local and remote execution.
+
+## Examples
+
+### Local Execution
+
+This example demonstrates how to find all 168 prime numbers in the interval 1 - 1000 using local execution. The code leverages multiple threads to perform prime number generation efficiently.
+
+```python
+import numpy as np
+from concurrent.futures import ThreadPoolExecutor
+
+def local_brute_force_prime_number_generator():
+    def is_prime(n):
+        if n <= 1:
+            return False
+        for i in range(2, int(np.sqrt(n)) + 1):
+            if n % i == 0:
+                return False
+        return True
+
+    random_numbers = np.random.randint(1, 1000, 20)
+
+    thread_pool = ThreadPoolExecutor(max_workers=4)
+    are_primes = list(thread_pool.map(is_prime, random_numbers))
+
+    prime_numbers = []
+    for i in range(len(random_numbers)):
+        if are_primes[i]:
+            prime_numbers.append(random_numbers[i])
+
+    return prime_numbers
+
+if __name__ == "__main__":
+    found_so_far = []
+    print_step = 0
+
+    while len(found_so_far) < 168:
+        # Compute a batch of prime numbers
+        prime_numbers = local_brute_force_prime_number_generator()
+
+        # Keep only the new prime numbers
+        for prime_number in prime_numbers:
+            if prime_number not in found_so_far:
+                found_so_far.append(prime_number)
+
+        # Show progress
+        if print_step % 50 == 0:
+            print("Found so far: {}:  {}\n".format(len(found_so_far), sorted(found_so_far)))
+
+        print_step += 1
+
+    # Show final result
+    print("Found so far: {}:  {}\n".format(len(found_so_far), sorted(found_so_far)))
+```
+
+### Remote Execution
+
+To accelerate prime number discovery, this example demonstrates deploying the task across multiple edge nodes within the Ratio1 network. Minimal code changes are required to transition from local to remote execution.
+
+#### 1. Modify the Prime Number Generator
+
+```python
+from ratio1_sdk import CustomPluginTemplate
+
+def remote_brute_force_prime_number_generator(plugin: CustomPluginTemplate):
+    def is_prime(n):
+        if n <= 1:
+            return False
+        for i in range(2, int(plugin.np.sqrt(n)) + 1):
+            if n % i == 0:
+                return False
+        return True
+
+    random_numbers = plugin.np.random.randint(1, 1000, 20)
+    are_primes = plugin.threadapi_map(is_prime, random_numbers, n_threads=4)
+
+    prime_numbers = []
+    for i in range(len(random_numbers)):
+        if are_primes[i]:
+            prime_numbers.append(random_numbers[i])
+
+    return prime_numbers
+```
+
+#### 2. Connect to the Network and Select a Node
+
+```python
+from ratio1_sdk import Session
+from time import sleep
+
+def on_heartbeat(session: Session, node: str, heartbeat: dict):
+    session.P("{} is online".format(node))
+    return
+
+if __name__ == '__main__':
+    session = Session(
+        on_heartbeat=on_heartbeat
+    )
+
+    # Run the program for 15 seconds to detect online nodes
+    sleep(15)
+
+    # Retrieve and select an online node
+    node = "0xai_A8SY7lEqBtf5XaGyB6ipdk5C30vSf3HK4xELp3iplwLe"  # naeural-1
+```
+
+#### 3. Deploy the Distributed Job
+
+```python
+from ratio1_sdk import DistributedCustomCodePresets as Presets
+
+_, _ = session.create_chain_dist_custom_job(
+    node=node,
+    main_node_process_real_time_collected_data=Presets.PROCESS_REAL_TIME_COLLECTED_DATA__KEEP_UNIQUES_IN_AGGREGATED_COLLECTED_DATA,
+    main_node_finish_condition=Presets.FINISH_CONDITION___AGGREGATED_DATA_MORE_THAN_X,
+    main_node_finish_condition_kwargs={"X": 167},
+    main_node_aggregate_collected_data=Presets.AGGREGATE_COLLECTED_DATA___AGGREGATE_COLLECTED_DATA,
+    nr_remote_worker_nodes=2,
+    worker_node_code=remote_brute_force_prime_number_generator,
+    on_data=locally_process_partial_results,
+    deploy=True
+)
+```
+
+#### 4. Close the Session Upon Completion
+
+```python
+# Wait until the finished flag is set to True
+session.run(wait=lambda: not finished, close_pipelines=True)
+```
+
+## Project Financing Disclaimer
+
+This project incorporates open-source components developed with the support of financing grants **SMIS 143488** and **SMIS 156084**, provided by the Romanian Competitiveness Operational Programme. We extend our sincere gratitude for this support, which has been instrumental in advancing our work and enabling us to share these resources with the community.
+
+The content and information within this repository are solely the responsibility of the authors and do not necessarily reflect the views of the funding agencies. The grants have specifically supported certain aspects of this open-source project, facilitating broader dissemination and collaborative development.
+
+For any inquiries regarding the funding and its impact on this project, please contact the authors directly.
+
+## License
+
+This project is licensed under the **Apache 2.0 License**. For more details, please refer to the [LICENSE](LICENSE) file.
+
+## Contact
+
+For more information, visit our website at [https://ratio1.ai](https://ratio1.ai) or reach out to us via email at [support@ratio1.ai](mailto:support@ratio1.ai).
+
+## Citation
+
+If you use the Ratio1 SDK in your research or projects, please cite it as follows:
+
+```bibtex
+@misc{Ratio1SDK,
+  author       = {Ratio1.AI},
+  title        = {Ratio1 SDK},
+  year         = {2024-2025},
+  howpublished = {\url{https://github.com/NaeuralEdgeProtocol/naeural_client}},
+}
+```
+
+```bibtex
+@misc{Ratio1EdgeNode,
+  author = {Ratio1.AI},
+  title = {Ratio1: Edge Node},
+  year = {2024-2025},
+  howpublished = {\url{https://github.com/NaeuralEdgeProtocol/edge_node}},
+}
+```

{naeural_client-2.6.14.dist-info → naeural_client-2.6.16.dist-info}/RECORD

@@ -1,10 +1,10 @@
 naeural_client/__init__.py,sha256=YimqgDbjLuywsf8zCWE0EaUXH4MBUrqLxt0TDV558hQ,632
-naeural_client/_ver.py,sha256=suKXv38GGYBJ0RcB_6qcC-hc1VP14y80oKWh1Ov0_Xg,331
+naeural_client/_ver.py,sha256=eM7t0xRbVJaaGjrh0O9tmQF7K_usWv_3wk3hVZ27_Qs,331
 naeural_client/base_decentra_object.py,sha256=C4iwZTkhKNBS4VHlJs5DfElRYLo4Q9l1V1DNVSk1fyQ,4412
 naeural_client/plugins_manager_mixin.py,sha256=X1JdGLDz0gN1rPnTN_5mJXR8JmqoBFQISJXmPR9yvCo,11106
 naeural_client/base/__init__.py,sha256=hACh83_cIv7-PwYMM3bQm2IBmNqiHw-3PAfDfAEKz9A,259
 naeural_client/base/distributed_custom_code_presets.py,sha256=cvz5R88P6Z5V61Ce1vHVVh8bOkgXd6gve_vdESDNAsg,2544
-naeural_client/base/generic_session.py,sha256=p7NZoMZJEW-2Zb0CrJyXIgtlpqZcRW9If6p3R_EfzzE,97509
+naeural_client/base/generic_session.py,sha256=Vw08ywfW03aN0_5kmXOF5-VkRthl7FwAXqJu3M3NDMs,104275
 naeural_client/base/instance.py,sha256=kcZJmjLBtx8Bjj_ysIOx1JmLA-qSpG7E28j5rq6IYus,20444
 naeural_client/base/pipeline.py,sha256=b4uNHrEIOlAtw4PGUx20dxwBhDck5__SrVXaHcSi8ZA,58251
 naeural_client/base/plugin_template.py,sha256=qGaXByd_JZFpjvH9GXNbT7KaitRxIJB6-1IhbKrZjq4,138123
@@ -14,7 +14,7 @@ naeural_client/base/webapp_pipeline.py,sha256=QmPLVmhP0CPdi0YuvbZEH4APYz2Amtw3gy
 naeural_client/base/payload/__init__.py,sha256=y8fBI8tG2ObNfaXFWjyWZXwu878FRYj_I8GIbHT4GKE,29
 naeural_client/base/payload/payload.py,sha256=x-au7l67Z_vfn_4R2C_pjZCaFuUVXHngJiGOfIAYVdE,2690
 naeural_client/bc/__init__.py,sha256=FQj23D1PrY06NUOARiKQi4cdj0-VxnoYgYDEht8lpr8,158
-naeural_client/bc/base.py,sha256=hVdk_Vxi94jMy6OJfbYVrbQgMCNNi3BgVOj_NCw5cKc,36159
+naeural_client/bc/base.py,sha256=KC-wtymP9tEvXGG6wfiRirgshjW7_y58ylWjbe_lUWo,36160
 naeural_client/bc/chain.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 naeural_client/bc/ec.py,sha256=qI8l7YqiS4MNftlx-tF7IZUswrSeQc7KMn5OZ0fEaJs,23370
 naeural_client/certs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -31,8 +31,8 @@ naeural_client/comm/amqp_wrapper.py,sha256=hzj6ih07DnLQy2VSfA88giDIFHaCp9uSdGLTA
 naeural_client/comm/mqtt_wrapper.py,sha256=Ig3bFZkCbWd4y_Whn2PPa91Z3aLgNbNPau6Tn5yLPZ8,16167
 naeural_client/const/README.md,sha256=6OHesr-f5NBuuJGryEoi_TCu2XdlhfQYlDKx_IJoXeg,177
 naeural_client/const/__init__.py,sha256=MM6Zib6i7M2qWcMkLtLx14zqU-lE-u2uPHjNvbh2jAM,478
-naeural_client/const/apps.py,sha256=gIONTZUkqPveu3DwelyJWpbFMeIR9l6DlaNg-xEfK1A,611
-naeural_client/const/base.py,sha256=Ld6WuQeqm5FbARL_-xs3gXxpa46ypksHimAk1g4qanw,4467
+naeural_client/const/apps.py,sha256=ePBiJXLuPfFOKuw-LJrT9OWbaodU7QApfDurIPNDoB4,655
+naeural_client/const/base.py,sha256=1ScfnfNd5xeWo7tkkDgQR95vliTpcax025Naj0Lqw38,4574
 naeural_client/const/comms.py,sha256=La6JXWHexH8CfcBCKyT4fCIoeaoZlcm7KtZ57ab4ZgU,2201
 naeural_client/const/environment.py,sha256=iytmTDgbOjvORPwHQmc0K0r-xJx7dnnzNnqAJJiFCDA,870
 naeural_client/const/formatter.py,sha256=AW3bWlqf39uaqV4BBUuW95qKYfF2OkkU4f9hy3kSVhM,200
@@ -47,7 +47,7 @@ naeural_client/default/instance/net_mon_01_plugin.py,sha256=u85i2AiYHkLJnam0wOx-
 naeural_client/default/instance/telegram_basic_bot_01_plugin.py,sha256=P_W2K_ng7svbhoIoYGvkGxa4v9UUoxuOAAgtoM36wDo,161
 naeural_client/default/instance/telegram_conversational_bot_01_plugin.py,sha256=XkyE-uNbtFnTSGA1nOf-XNmUipAUjhg0xXV1glRb7gc,179
 naeural_client/default/instance/view_scene_01_plugin.py,sha256=5kMhd23kL5AYCdOJzrdCqi2ohoQNvmpv8oE6hWQtUWk,720
-naeural_client/default/session/mqtt_session.py,sha256=dpQcBhhVZDo458v0IqJMZb1CsTn-TxXhYjNlyJp9Rp8,2414
+naeural_client/default/session/mqtt_session.py,sha256=QdL0LPCqV3Fw0VSNgnsXWKJoxnkl17BtSYvEmhNU_zM,3079
 naeural_client/io_formatter/__init__.py,sha256=_wy7c-Z9kgb26jN7uNTDq88G7xZ3wI_ObuQd3QWNPkQ,85
 naeural_client/io_formatter/io_formatter_manager.py,sha256=MiZ70cGVD6hR99QiEk9wvJ_vADxpI-y2bTb0ITlMNI0,3451
 naeural_client/io_formatter/base/__init__.py,sha256=VmLHY35NCRR46lgjhcrwtFxmJIVOjX2ADV9wOXt9CKA,41
@@ -81,8 +81,8 @@ naeural_client/utils/__init__.py,sha256=mAnke3-MeRzz3nhQvhuHqLnpaaCSmDxicd7Ck9uw
 naeural_client/utils/comm_utils.py,sha256=4cS9llRr_pK_3rNgDcRMCQwYPO0kcNU7AdWy_LtMyCY,1072
 naeural_client/utils/config.py,sha256=v7xHikr6Z5Sbvf3opYeMhYzGWD2pe0HlRwa-aGJzUh8,6323
 naeural_client/utils/dotenv.py,sha256=_AgSo35n7EnQv5yDyu7C7i0kHragLJoCGydHjvOkrYY,2008
-naeural_client-2.6.14.dist-info/METADATA,sha256=tI-zL6Ld5JvnTFP9JDWK8sfx788VwVGABqbmCfubxUQ,13176
-naeural_client-2.6.14.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-naeural_client-2.6.14.dist-info/entry_points.txt,sha256=PNdyotDaQBAslZREx5luVyj0kqpQnwNACwkFNTPIHU4,55
-naeural_client-2.6.14.dist-info/licenses/LICENSE,sha256=cvOsJVslde4oIaTCadabXnPqZmzcBO2f2zwXZRmJEbE,11311
-naeural_client-2.6.14.dist-info/RECORD,,
+naeural_client-2.6.16.dist-info/METADATA,sha256=PaCUsM0cAtvH9ZUTzfwNxZTumPu4np7e3inODMj9WLA,10362
+naeural_client-2.6.16.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+naeural_client-2.6.16.dist-info/entry_points.txt,sha256=PNdyotDaQBAslZREx5luVyj0kqpQnwNACwkFNTPIHU4,55
+naeural_client-2.6.16.dist-info/licenses/LICENSE,sha256=cvOsJVslde4oIaTCadabXnPqZmzcBO2f2zwXZRmJEbE,11311
+naeural_client-2.6.16.dist-info/RECORD,,

naeural_client-2.6.14.dist-info/METADATA

@@ -1,358 +0,0 @@
-Metadata-Version: 2.4
-Name: naeural_client
-Version: 2.6.14
-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
-Author-email: Andrei Ionut Damian <andrei.damian@me.com>, Cristan Bleotiu <cristibleotiu@gmail.com>, Stefan Saraev <saraevstefan@gmail.com>
-License-File: LICENSE
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.8
-Requires-Dist: cryptography>=39.0.0
-Requires-Dist: numpy
-Requires-Dist: paho-mqtt
-Requires-Dist: pandas
-Requires-Dist: pika
-Requires-Dist: pyaml
-Requires-Dist: pyopenssl>=23.0.0
-Requires-Dist: python-dateutil
-Requires-Dist: web3
-Description-Content-Type: text/markdown
-
-# Ratio1 SDK (naeural_client SDK)
-
-This is the Python SDK package that allows interactions, development and deployment of jobs in Ratio1 ecosystem formely known as Naeural Edge Protocol network. The SDK enables low-code development and deployment of end-to-end AI (and not only) cooperative application pipelines within the Ratio1 Edge Nodes ecosystem. 
-
-## Dependencies
-
-This packet depends and will automatically install the following packets: `pika`, `paho-mqtt`, `numpy`, `pyopenssl>=23.0.0`, `cryptography>=39.0.0`, `python-dateutil`, `pyaml`.
-
-## Installation
-
-```shell
-pip install naeural_client --upgrade
-```
-
-### Development installation
-
-```shell
-git clone https://github.com/NaeuralEdgeProtocol/naeural_client
-pip install -e .
-```
-
-## Documentation
-
-Minimal documentation will be presented here. The complete documentation is
-Work in Progress.
-
-Code examples are located in the `tutorials` folder in the project's repository.
-
-## Quick start guides
-
-Starting with version 2.6+ the SDK will automatically perform self-configuration using the dAuth - the Ratio1 decentralized self-authentication system.
-
-In order to start a local edge node you just need to run:
-
-```bash
-docker run -d --name=local_node naeural/edge_node:develop
-```
-after a few seconds the node will be online and you can get the node's address by running:
-
-```bash
-docker exec local_node get_node_info
-```
-
-The output will be similar to:
-
-```json
-{
-  "address": "0xai_AtMvIwaEPi5M8cnkdbaZ3tbUhCzKbGKEYuZ1xFtCjT_6",
-  "alias": "6dd74472642e",
-  "eth_address": "0x98FE7c0d8CeC2E97B932D2bDC1bb73B395C9Dfd7"
-}
-```
-
-
-## Some Examples
-
-### Local Execution
-
-We want to find all $168$ prime numbers in the interval $1$ - $1000$. For this we can run the following code on our local machine.
-
-This code has segments running on multiple threads using a ThreadPool.
-
-```python
-import numpy as np
-from concurrent.futures import ThreadPoolExecutor
-
-
-def local_brute_force_prime_number_generator():
-  def is_prime(n):
-    if n <= 1:
-      return False
-    for i in range(2, int(np.sqrt(n)) + 1):
-      if n % i == 0:
-        return False
-    return True
-
-  random_numbers = np.random.randint(1, 1000, 20)
-
-  thread_pool = ThreadPoolExecutor(max_workers=4)
-  are_primes = list(thread_pool.map(is_prime, random_numbers))
-
-  prime_numbers = []
-  for i in range(len(random_numbers)):
-    if are_primes[i]:
-      prime_numbers.append(random_numbers[i])
-
-  return prime_numbers
-
-
-if __name__ == "__main__":
-  found_so_far = []
-
-  print_step = 0
-
-  while len(found_so_far) < 168:
-    # compute a batch of prime numbers
-    prime_numbers = local_brute_force_prime_number_generator()
-
-    # keep only the new prime numbers
-    for prime_number in prime_numbers:
-      if prime_number not in found_so_far:
-        found_so_far.append(prime_number)
-    # end for
-
-    # show progress
-    if print_step % 50 == 0:
-      print("Found so far: {}:  {}\n".format(len(found_so_far), sorted(found_so_far)))
-
-    print_step += 1
-  # end while
-
-  # show final result
-  print("Found so far: {}:  {}\n".format(len(found_so_far), sorted(found_so_far)))
-```
-
-We can see that we have a `local_brute_force_prime_number_generator` method which will generate a random sample of $20$ numbers that will be checked if they are prime or not.
-
-The rest of the code handles how the numbers generated with this method are kept.
-Because we want to find $168$ unique numbers, we append to the list of found primes only the numbers that are not present yet.
-
-At the end, we want to show a list of all the numbers found.
-
-### Remote Execution
-
-For this example we would like to use multiple edge nodes to find the prime numbers faster.
-
-To execute this code on our network, a series of changes must be made to the `local_brute_force_prime_number_generator` method.
-These changes are the only ones a developer has to do to deploy his own custom code on the network.
-
-For this, we will create a new method, `remote_brute_force_prime_number_generator`, which will use the exposed edge node API methods.
-
-```python
-from naeural_client import CustomPluginTemplate
-
-# through the `plugin` object we get access to the edge node API
-# the CustomPluginTemplate class acts as a documentation for all the available methods and attributes
-# since we do not allow imports in the custom code due to security reasons, the `plugin` object
-#   exposes common modules to the user
-def remote_brute_force_prime_number_generator(plugin: CustomPluginTemplate):
-  def is_prime(n):
-    if n <= 1:
-      return False
-    # we use the `plugin.np` instead of the `np` module
-    for i in range(2, int(plugin.np.sqrt(n)) + 1):
-      if n % i == 0:
-        return False
-    return True
-
-  # we use the `plugin.np` instead of the `np` module
-  random_numbers = plugin.np.random.randint(1, 1000, 20)
-
-  # we use the `plugin.threadapi_map` instead of the `ThreadPoolExecutor.map`
-  are_primes = plugin.threadapi_map(is_prime, random_numbers, n_threads=4)
-
-  prime_numbers = []
-  for i in range(len(random_numbers)):
-    if are_primes[i]:
-      prime_numbers.append(random_numbers[i])
-
-  return prime_numbers
-```
-
-This are all the changes we have to do to deploy this code in the network.
-
-Now lets connect to the network and see what nodes are online.
-We will use the `on_heartbeat` callback to print the nodes.
-
-```python
-from naeural_client import Session
-from time import sleep
-
-def on_heartbeat(session: Session, node: str, heartbeat: dict):
-  # the `.P` method is used to print messages in the console and store them in the log file
-  session.P("{} is online".format(node))
-  return
-
-
-if __name__ == '__main__':
-  # create a session
-  # the network credentials are read from the .env file automatically
-  session = Session(
-      on_heartbeat=on_heartbeat
-  )
-
-  # run the program for 15 seconds to show all the nodes that are online
-  sleep(15)
-
-```
-
-Next we will select an online node. This node will be our entrypoint in the network.
-
-The available nodes in our test net are:
-
-```
-0xai_A8SY7lEqBtf5XaGyB6ipdk5C30vSf3HK4xELp3iplwLe naeural-1
-0xai_Amfnbt3N-qg2-qGtywZIPQBTVlAnoADVRmSAsdDhlQ-6 naeural-2
-0xai_ApltAljEgWk3g8x2QcSa0sS3hT1P4dyCchd04zFSMy5e naeural-3
-```
-
-We will send a task to this node. Since we want to distribute the task of finding prime numbers to multiple nodes, this selected node will handle distribution of tasks and collection of the results.
-
-```python
-node = "0xai_A8SY7lEqBtf5XaGyB6ipdk5C30vSf3HK4xELp3iplwLe" # naeural-1
-
-# we usually wait for the node to be online before sending the task
-# but in this case we are sure that the node is online because we
-# have received heartbeats from it during the sleep period
-
-# session.wait_for_node(node)
-```
-
-Our selected node will periodically output partial results with the prime numbers found so far by the worker nodes. We want to consume these results.
-
-Thus, we need to implement a callback method that will handle this.
-
-```python
-from naeural_client import Pipeline
-
-# a flag used to close the session when the task is finished
-finished = False
-
-def locally_process_partial_results(pipeline: Pipeline, full_payload):
-  global finished
-  found_so_far = full_payload.get("DATA")
-
-  if found_so_far:
-    pipeline.P("Found so far: {}:  {}\n\n".format(len(found_so_far), sorted(found_so_far)))
-
-  progress = full_payload.get("PROGRESS")
-  if progress == 100:
-    pipeline.P("FINISHED\n\n")
-    finished = True
-
-  return
-```
-
-Now we are ready to deploy our job to the network.
-
-```python
-from naeural_client import DistributedCustomCodePresets as Presets
-
-_, _ = session.create_chain_dist_custom_job(
-    # this is the main node, our entrypoint
-    node=node,
-
-    # this function is executed on the main node
-    # this handles what we want to do with primes found by a worker node after an iteration
-    # we want to store only the unique prime numbers
-    # we cam either write a custom code to pass here or we can use a preset
-    main_node_process_real_time_collected_data=Presets.PROCESS_REAL_TIME_COLLECTED_DATA__KEEP_UNIQUES_IN_AGGREGATED_COLLECTED_DATA,
-
-    # this function is executed on the main node
-    # this handles the finish condition of our distributed job
-    # we want to finish when we have found 168 prime numbers
-    # so more than 167 prime numbers
-    # we cam either write a custom code to pass here or we can use a preset
-    main_node_finish_condition=Presets.FINISH_CONDITION___AGGREGATED_DATA_MORE_THAN_X,
-    main_node_finish_condition_kwargs={
-        "X": 167
-    },
-
-    # this function is executed on the main node
-    # this handles the final processing of the results
-    # this function prepares data for the final result of the distributed job
-    # we want to aggregate all the prime numbers found by the worker nodes in a single list
-    # we cam either write a custom code to pass here or we can use a preset
-    main_node_aggregate_collected_data=Presets.AGGREGATE_COLLECTED_DATA___AGGREGATE_COLLECTED_DATA,
-
-    # how many worker nodes we want to use for this task
-    nr_remote_worker_nodes=2,
-
-    # this is the function that will be executed on the worker nodes
-    # this function generates prime numbers using brute force
-    # we simply pass the function reference
-    worker_node_code=remote_brute_force_prime_number_generator,
-
-    # this is the function that will be executed on the client
-    # this is the callback function that processes the partial results
-    # in our case we want to print the partial results
-    on_data=locally_process_partial_results,
-
-    # we want to deploy the job immediately
-    deploy=True
-)
-```
-
-Last but not least, we want to close the session when the distributed job finished.
-
-```python
-# we wait until the finished flag is set to True
-# we want to release the resources allocated on the selected node when the job is finished
-session.run(wait=lambda: not finished, close_pipelines=True)
-```
-
-
-# Project Financing Disclaimer
-
-This project includes open-source components that have been developed with the support of financing grants SMIS 143488 and SMIS 156084, provided by the Romanian Competitiveness Operational Programme. We are grateful for this support, which has enabled us to advance our work and share these resources with the community.
-
-The content and information provided within this repository are solely the responsibility of the authors and do not necessarily reflect the views of the funding agencies. The funding received under these grants has been instrumental in supporting specific parts of this open source project, allowing for broader dissemination and collaborative development.
-
-For any inquiries related to the funding and its impact on this project, please contact the authors directly.
-
-
-# Citation
-
-```bibtex
-@misc{naeural_client,
-  author = {Stefan Saraev, Andrei Damian},
-  title = {naeural_client: Python SDK for Naeural Edge Protocol Edge Protocol},
-  year = {2024},
-  howpublished = {\url{https://github.com/Naeural Edge ProtocolEdgeProtocol/naeural_client}},
-}
-```
-
-```bibtex
-@misc{project_funding_acknowledgment1,
-  author       = {Damian, Bleotiu, Saraev, Constantinescu},
-  title        = {SOLIS – Sistem Omogen multi-Locație cu funcționalități Inteligente și Sustenabile”
-SMIS 143488},
-  howpublished = {\url{https://github.com/Naeural Edge ProtocolEdgeProtocol/}},
-  note         = {This project includes open-source components developed with support from the Romanian Competitiveness Operational Programme under grants SMIS 143488. The content is solely the responsibility of the authors and does not necessarily reflect the views of the funding agencies.},
-  year         = {2021-2022}
-}
-```
-
-```bibtex
-@misc{project_funding_acknowledgment2,
-  author       = {Damian, Bleotiu, Saraev, Constantinescu, Milik, Lupaescu},
-  title        = {ReDeN – Rețea Descentralizată Neurală SMIS 156084},
-  howpublished = {\url{https://github.com/Naeural Edge ProtocolEdgeProtocol/}},
-  note         = {This project includes open-source components developed with support from the Romanian Competitiveness Operational Programme under grants SMIS 143488. The content is solely the responsibility of the authors and does not necessarily reflect the views of the funding agencies.},
-  year         = {2023-2024}
-}
-```