naeural-client 2.6.5__tar.gz → 2.6.7__tar.gz

{naeural_client-2.6.5 → naeural_client-2.6.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: naeural_client
-Version: 2.6.5
+Version: 2.6.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.6.5 → naeural_client-2.6.7}/naeural_client/_ver.py

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

{naeural_client-2.6.5 → naeural_client-2.6.7}/naeural_client/base/generic_session.py

@@ -50,6 +50,10 @@ class GenericSession(BaseDecentrAIObject):
   A Session manages `Pipelines` and handles all messages received from the communication server.
   The Session handles all callbacks that are user-defined and passed as arguments in the API calls.
   """
+  
+  START_TIMEOUT = 30
+  
+  
   default_config = {
       "CONFIG_CHANNEL": {
           "TOPIC": "{}/{}/config"
@@ -164,7 +168,14 @@ class GenericSession(BaseDecentrAIObject):
     root_topic : str, optional
         This is the root of the topics used by the SDK. It is used to create the topics for the communication channels.
         Defaults to "naeural"
+        
+    auto_configuration : bool, optional
+        If True, the SDK will attempt to complete the dauth process automatically.
+        Defaults to True.
     """
+    
+    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}
@@ -274,6 +285,7 @@ class GenericSession(BaseDecentrAIObject):
       dauth_endp=None, # get from consts or env
       add_env=self.__auto_configuration,
       debug=False,
+      sender_alias='ratio1-SDK'
     )
     # end bc_engine
     # END TODO
@@ -466,21 +478,59 @@ class GenericSession(BaseDecentrAIObject):
       self._dct_node_addr_name[node_addr] = node_id
       return
 
-    def __track_allowed_node(self, node_addr, dict_msg):
+    def __track_allowed_node_by_hb(self, node_addr, dict_msg):
       """
-      Track if this session is allowed to send messages to node.
+      Track if this session is allowed to send messages to node using hb data
 
       Parameters
       ----------
       node_addr : str
           The address of the Naeural Edge Protocol edge node that sent the message.
+
       dict_msg : dict
-          The message received from the communication server.
+          The message received from the communication server as a heartbeat of the object from netconfig
       """
       node_whitelist = dict_msg.get(HB.EE_WHITELIST, [])
       node_secured = dict_msg.get(HB.SECURED, False)
+      
+      client_is_allowed = self.bc_engine.contains_current_address(node_whitelist)
+
+      self._dct_can_send_to_node[node_addr] = not node_secured or client_is_allowed or self.bc_engine.address == node_addr
+      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
+
+      Parameters
+      ----------
+      node_addr : str
+          The address of the Naeural Edge Protocol edge node that sent the message.
+
+      dict_msg : dict
+          The message received from the communication server as a heartbeat of the object from netconfig
+      """
+      node_whitelist = dict_msg.get(PAYLOAD_DATA.NETMON_WHITELIST, [])
+      node_secured = dict_msg.get(PAYLOAD_DATA.NETMON_NODE_SECURED, False)
+      
+      client_is_allowed = self.bc_engine.contains_current_address(node_whitelist)
 
-      self._dct_can_send_to_node[node_addr] = not node_secured or self.bc_engine.address_no_prefix in node_whitelist or self.bc_engine.address == node_addr
+      self._dct_can_send_to_node[node_addr] = not node_secured or client_is_allowed or self.bc_engine.address == node_addr
+      return
+    
+    
+    def __process_node_pipelines(self, node_addr, pipelines):
+      """
+      Given a list of pipeline configurations, create or update the pipelines for a node.      
+      """
+      for config in pipelines:
+        pipeline_name = config[PAYLOAD_DATA.NAME]
+        pipeline: Pipeline = self._dct_online_nodes_pipelines[node_addr].get(pipeline_name, None)
+        if pipeline is not None:
+          pipeline._sync_configuration_with_remote({k.upper(): v for k, v in config.items()})
+        else:
+          self._dct_online_nodes_pipelines[node_addr][pipeline_name] = self.__create_pipeline_from_config(
+            node_addr, config)
       return
 
     def __on_heartbeat(self, dict_msg: dict, msg_node_addr, msg_pipeline, msg_signature, msg_instance):
@@ -516,19 +566,20 @@ class GenericSession(BaseDecentrAIObject):
 
       msg_active_configs = dict_msg.get(HB.CONFIG_STREAMS)
       if msg_active_configs is None:
-        return
+        msg_active_configs = []      
+      # at this point we dont return if no active configs are present
+      # 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] = {}
-      for config in msg_active_configs:
-        pipeline_name = config[PAYLOAD_DATA.NAME]
-        pipeline: Pipeline = self._dct_online_nodes_pipelines[msg_node_addr].get(pipeline_name, None)
-        if pipeline is not None:
-          pipeline._sync_configuration_with_remote({k.upper(): v for k, v in config.items()})
-        else:
-          self._dct_online_nodes_pipelines[msg_node_addr][pipeline_name] = self.__create_pipeline_from_config(
-            msg_node_addr, config)
+        
+      if len(msg_active_configs) > 0:
+        # this is for legacy and custom implementation where heartbeats still contain
+        # the pipeline configuration.
+        self.__process_node_pipelines(msg_node_addr, msg_active_configs)
 
       # TODO: move this call in `__on_message_default_callback`
       if self.__maybe_ignore_message(msg_node_addr):
@@ -543,7 +594,7 @@ class GenericSession(BaseDecentrAIObject):
 
       self.D("Received hb from: {}".format(msg_node_addr), verbosity=2)
 
-      self.__track_allowed_node(msg_node_addr, dict_msg)
+      self.__track_allowed_node_by_hb(msg_node_addr, dict_msg)
 
       # call the custom callback, if defined
       if self.custom_on_heartbeat is not None:
@@ -613,7 +664,8 @@ class GenericSession(BaseDecentrAIObject):
       self, 
       dict_msg: dict,  
       msg_pipeline : str, 
-      msg_signature : str
+      msg_signature : str,
+      sender_addr: str,
     ):
       REQUIRED_PIPELINE = DEFAULT_PIPELINES.ADMIN_PIPELINE
       REQUIRED_SIGNATURE = PLUGIN_SIGNATURES.NET_MON_01
@@ -624,6 +676,7 @@ class GenericSession(BaseDecentrAIObject):
         ee_id = dict_msg.get(PAYLOAD_DATA.EE_ID, None)
         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()
           ]
@@ -633,10 +686,30 @@ class GenericSession(BaseDecentrAIObject):
           ] 
           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
+
+          for _ , node_data in current_network.items():
+            node_addr = node_data.get("address", None)    
+            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 for each node in network map
         # end if current_network is valid
       # end if NET_MON_01
       return
       
+      
+    def __maybe_process_net_config(
+      self, 
+      dict_msg: dict,  
+      msg_pipeline : str, 
+      msg_signature : str,
+      sender_addr: str,
+    ):
+      return
+      
 
     # TODO: maybe convert dict_msg to Payload object
     #       also maybe strip the dict from useless info for the user of the sdk
@@ -656,12 +729,16 @@ class GenericSession(BaseDecentrAIObject):
       ----------
       dict_msg : dict
           The message received from the communication server
+          
       msg_node_addr : str
           The address of the Naeural Edge Protocol edge node that sent the message.
+          
       msg_pipeline : str
           The name of the pipeline that sent the message.
+          
       msg_signature : str
           The signature of the plugin that sent the message.
+          
       msg_instance : str
           The name of the instance that sent the message.
       """
@@ -671,7 +748,19 @@ class GenericSession(BaseDecentrAIObject):
       if self.__maybe_ignore_message(msg_node_addr):
         return
       
-      self.__maybe_process_net_mon(dict_msg, msg_pipeline, msg_signature)
+      self.__maybe_process_net_mon(
+        dict_msg=dict_msg, 
+        msg_pipeline=msg_pipeline, 
+        msg_signature=msg_signature, 
+        sender_addr=msg_node_addr
+      )
+      
+      self.__maybe_process_net_config(
+        dict_msg=dict_msg, 
+        msg_pipeline=msg_pipeline, 
+        msg_signature=msg_signature, 
+        sender_addr=msg_node_addr
+      )
 
       # call the pipeline and instance defined callbacks
       for pipeline in self.own_pipelines:
@@ -727,6 +816,8 @@ class GenericSession(BaseDecentrAIObject):
 
       self.__running_main_loop_thread = True
       self._main_loop_thread.start()
+      
+      # we could wait here for `self.__at_least_one_node_peered` but is not a good idea
       return
 
     def __handle_open_transactions(self):
@@ -847,10 +938,16 @@ class GenericSession(BaseDecentrAIObject):
       This method runs on a separate thread from the main thread, and it is responsible for handling all messages received from the communication server.
       We use it like this to avoid blocking the main thread, which is used by the user.
       """
+      self.__start_main_loop_time = tm()
       while self.__running_main_loop_thread:
         self.__maybe_reconnect()
         self.__handle_open_transactions()
         sleep(0.1)
+        if not self.__at_least_a_netmon_received:
+          if (tm() - self.__start_main_loop_time) > self.START_TIMEOUT:
+            msg = "Timeout waiting for NET_MON_01 message. Exiting..."
+            self.P(msg, color='r', show=True)
+            break        
       # end while self.running
 
       self.P("Main loop thread exiting...", verbosity=2)
@@ -900,7 +997,7 @@ class GenericSession(BaseDecentrAIObject):
 
       return
 
-    def sleep(self, wait=True):
+    def sleep(self, wait=True, close_session=True, close_pipelines=False):
       """
       Sleep for a given amount of time.
 
@@ -926,7 +1023,37 @@ class GenericSession(BaseDecentrAIObject):
           callable_loop_condition = callable(wait) and wait()
       except KeyboardInterrupt:
         self.P("CTRL+C detected. Stopping loop.", color='r', verbosity=1)
+        
+      if close_session:
+        self.close(close_pipelines, wait_close=True)        
       return
+    
+    def wait(
+      self, 
+      seconds=10, 
+      close_session_on_timeout=True, 
+      close_pipeline_on_timeout=False
+    ):
+      """
+      Wait for a given amount of time.
+
+      Parameters
+      ----------
+      seconds : int, float, optional
+          The amount of time to wait, by default 10
+          
+      close_session_on_timeout : bool, optional
+          If `True`, will close the session when the time is up, by default True
+          
+      close_pipeline_on_timeout : bool, optional
+          If `True`, will close the pipelines when the time is up, by default False
+      """
+      self.run(
+        wait=seconds, 
+        close_session=close_session_on_timeout, 
+        close_pipelines=close_pipeline_on_timeout
+      )
+      return    
 
   # Utils
   if True:
@@ -2352,6 +2479,7 @@ class GenericSession(BaseDecentrAIObject):
       allowed_only=False,
       supervisor=None,
       df_only=False,
+      debug=False,
     ):
       """
       This function will return a Pandas dataframe  known nodes in the network based on
@@ -2400,10 +2528,11 @@ class GenericSession(BaseDecentrAIObject):
         'Address': PAYLOAD_DATA.NETMON_ADDRESS,
         'Alias'  : PAYLOAD_DATA.NETMON_EEID,
         'Seen ago' : PAYLOAD_DATA.NETMON_LAST_SEEN,
-        'Last state': PAYLOAD_DATA.NETMON_STATUS_KEY,
+        'Version' : PAYLOAD_DATA.NETMON_NODE_VERSION,
+        'State': PAYLOAD_DATA.NETMON_STATUS_KEY,
         'Last probe' : PAYLOAD_DATA.NETMON_LAST_REMOTE_TIME,
         'Zone' : PAYLOAD_DATA.NETMON_NODE_UTC,
-        'Supervisor' : PAYLOAD_DATA.NETMON_IS_SUPERVISOR,
+        'Oracle' : PAYLOAD_DATA.NETMON_IS_SUPERVISOR,
         'Peered' : PAYLOAD_DATA.NETMON_WHITELIST,
       })
       reverse_mapping = {v: k for k, v in mapping.items()}
@@ -2441,6 +2570,7 @@ class GenericSession(BaseDecentrAIObject):
           # the following will get the whitelist for the current inspected  node
           # without calling self.get_allowed_nodes but instead using the netmon data
           whitelist = node_info.get(PAYLOAD_DATA.NETMON_WHITELIST, [])
+          version = node_info.get(PAYLOAD_DATA.NETMON_NODE_VERSION, '0.0.0')
           client_is_allowed = self.bc_engine.contains_current_address(whitelist)          
           if allowed_only and not client_is_allowed:
             continue
@@ -2464,6 +2594,8 @@ class GenericSession(BaseDecentrAIObject):
               val = self.bc_engine._add_prefix(val)
             elif key == PAYLOAD_DATA.NETMON_WHITELIST:
               val = client_is_allowed
+            elif key in [PAYLOAD_DATA.NETMON_STATUS_KEY, PAYLOAD_DATA.NETMON_NODE_VERSION]:
+              val = val.split(' ')[0]
             res[column].append(val)          
         # end for
       # end if
@@ -2475,6 +2607,9 @@ class GenericSession(BaseDecentrAIObject):
         SESSION_CT.NETSTATS_NR_SUPERVISORS : len(self.__current_network_statuses),
         SESSION_CT.NETSTATS_ELAPSED : elapsed,
       })
+      if debug:
+        self.P(f"Peering:\n{json.dumps(self._dct_can_send_to_node, indent=2)}", color='y')
+        self.P(f"Used netmon data from {best_super} ({best_super_alias}):\n{json.dumps(best_info, indent=2)}", color='y')
       if df_only:
         return dct_result[SESSION_CT.NETSTATS_REPORT]
       return dct_result

{naeural_client-2.6.5 → naeural_client-2.6.7}/naeural_client/bc/base.py

@@ -16,7 +16,11 @@ from cryptography.hazmat.primitives import serialization
 
 from ..utils.config import get_user_folder
 
-from ..const.base import BCctbase, BCct, DAUTH_SUBKEY, DAUTH_URL
+from ..const.base import (
+  BCctbase, BCct, 
+  DAUTH_SUBKEY, DAUTH_URL, DAUTH_ENV_KEY,
+  DAUTH_NONCE, DAUTH_VARS,
+)
     
   
   
@@ -1216,7 +1220,8 @@ class BaseBlockEngine:
   ### end Ethereum
 
 
-  def dauth_autocomplete(self, dauth_endp=None, add_env=True, debug=False, max_tries=5):
+  def dauth_autocomplete(self, dauth_endp=None, add_env=True, debug=False, max_tries=5, **kwargs):
+    MIN_LEN = 10
     dct_env = {}
     dct_result = {}
     done = False
@@ -1224,25 +1229,34 @@ class BaseBlockEngine:
     in_env = False
     url = dauth_endp
     
-    if url is None:
+    if not isinstance(url, str) or len(url) < MIN_LEN:
       if isinstance(DAUTH_URL, str) and len(DAUTH_URL) > 0:
         url = DAUTH_URL
-      else:
-        url = os.environ.get('DAUTH_URL')
+
+      if DAUTH_ENV_KEY in os.environ:
         in_env = True
+        url = os.environ[DAUTH_ENV_KEY]
     
     if isinstance(url, str) and len(url) > 0:
       if dauth_endp is None:
-        self.P("Found dAuth URL in environment: '{}'".format(url), color='g')
+        if in_env:
+          self.P("Found dAuth URL in environment: '{}'".format(url), color='g')
+        else:
+          self.P("Using default dAuth URL: '{}'".format(url), color='g')
       
       while not done:
         self.P(f"Trying dAuth `{url}` information... (try {tries})")
         try:
-          nonce_data = {
-            'nonce' : str(uuid.uuid4())[:8]
+          to_send = {
+            **kwargs,
+            DAUTH_NONCE : str(uuid.uuid4())[:8],
           }
-          self.sign(nonce_data)
-          response = requests.post(url, json={'body' : nonce_data})
+          ######
+          if len(kwargs) == 0:
+            to_send['sender_alias'] = 'direct-call'
+          ######
+          self.sign(to_send)          
+          response = requests.post(url, json={'body' : to_send})
           if response.status_code == 200:
             dct_response = response.json()
             if debug:
@@ -1275,4 +1289,7 @@ class BaseBlockEngine:
         if tries >= max_tries:
           done = True    
       #end while
+    else:
+      self.P(f"dAuth URL is not invalid: {url}", color='r')
+    #end if url is valid
     return dct_env

{naeural_client-2.6.5 → naeural_client-2.6.7}/naeural_client/cli/nodes.py

@@ -49,6 +49,9 @@ def get_nodes(args):
     supervisor=supervisor_addr,
   )
   df, supervisor, super_alias, nr_supers, elapsed = res
+  if args.online:
+    FILTERED = ['State']
+    df = df[[c for c in df.columns if c not in FILTERED]]
 
   prefix = "Online n" if (args.online or args.peered) else "N"
   if supervisor == "ERROR":
@@ -72,6 +75,8 @@ def get_supervisors(args):
     supervisors_only=True,
   )
   df, supervisor, super_alias, nr_supers, elapsed = res
+  FILTERED = ['Oracle', 'State']
+  df = df[[c for c in df.columns if c not in FILTERED]]
   
   if supervisor == "ERROR":
     log_with_color(f"No supervisors or no comms available in {elapsed:.1f}s. Please check your settings.", color='r')

{naeural_client-2.6.5 → naeural_client-2.6.7}/naeural_client/const/base.py

@@ -1,24 +1,27 @@
 EE_ID = 'EE_ID'
 SB_ID = 'SB_ID'  # change to SB_ID = EE_ID post mod from sb to ee
 
+class BCctbase: 
+  SIGN      = 'EE_SIGN'
+  SENDER    = 'EE_SENDER'
+  HASH      = 'EE_HASH'
+  
+  ETH_SIGN  = 'EE_ETH_SIGN'
+  ETH_SENDER= 'EE_ETH_SENDER'
+
 
 DAUTH_URL = 'https://dauth.ratio1.ai/get_auth_data'
 DAUTH_SUBKEY = 'auth'
+DAUTH_ENV_KEY = 'DAUTH_URL'
+DAUTH_NONCE = 'nonce'
+DAUTH_VARS = [DAUTH_NONCE, BCctbase.SIGN, BCctbase.SENDER, BCctbase.HASH]
+
 
 class LocalInfo:
   LOCAL_INFO_FILE = 'local_info.json'
   K_ADDRESS = 'address'
   K_ALIAS = 'alias'
   K_ETH_ADDRESS = 'eth_address'
-
-
-class BCctbase: 
-  SIGN      = 'EE_SIGN'
-  SENDER    = 'EE_SENDER'
-  HASH      = 'EE_HASH'
-  
-  ETH_SIGN  = 'EE_ETH_SIGN'
-  ETH_SENDER= 'EE_ETH_SENDER'
     
 
 class BCct:

{naeural_client-2.6.5 → naeural_client-2.6.7}/naeural_client/const/heartbeat.py

@@ -23,6 +23,7 @@ EE_ADDR = 'EE_ADDR'
 EE_WHITELIST = 'EE_WHITELIST'
 EE_IS_SUPER = 'EE_IS_SUPER'
 EE_FORMATTER = 'EE_FORMATTER'
+EE_ID = 'EE_ID'
 
 SECURED = 'SECURED'
 

{naeural_client-2.6.5 → naeural_client-2.6.7}/naeural_client/const/payload.py

@@ -205,6 +205,8 @@ class PAYLOAD_DATA:
   NETMON_LAST_SEEN = 'last_seen_sec'
   NETMON_IS_SUPERVISOR = 'is_supervisor'
   NETMON_WHITELIST = 'whitelist'
+  NETMON_NODE_SECURED = 'secured'
+  NETMON_NODE_VERSION = 'version'
   
   
 class NET_CONFIG:
@@ -212,4 +214,5 @@ class NET_CONFIG:
   REQUEST_COMMAND = "GET_CONFIG"
   NET_CONFIG_DATA = 'NET_CONFIG_DATA'
   OPERATION = 'OP'
-  DESTINATION = 'DEST'
+  DESTINATION = 'DEST'
+  DATA = 'DATA'

{naeural_client-2.6.5 → naeural_client-2.6.7}/naeural_client/logging/base_logger.py

@@ -91,6 +91,7 @@ class BaseLogger(object):
     if os.name == 'nt':
       os.system('color')
     self.__lib__ = lib_name
+    self.__folder_setup_done = False
     self.append_spaces = append_spaces
     self.show_time = show_time
     self.no_folders_no_save = no_folders_no_save
@@ -1112,35 +1113,41 @@ class BaseLogger(object):
         BaseLogger.print_color("  Config modified with following env vars: {}".format(matches))
       else:
         BaseLogger.print_color("  No secrets/template found in config")
+        
+    if not self.__folder_setup_done:
+      # if not already done lets setup de folders
+      self._base_folder = self.expand_tilda(self._base_folder)
+      self._base_folder = self._get_cloud_base_folder(self._base_folder)
+      self._root_folder = os.path.abspath(self._base_folder)
+      self._base_folder = os.path.join(self._base_folder, self._app_folder)
+    
+      if not self.silent:
+        BaseLogger.print_color("BASE: {}".format(self._base_folder))
 
-    self._base_folder = self.expand_tilda(self._base_folder)
-    self._base_folder = self._get_cloud_base_folder(self._base_folder)
-    self._root_folder = os.path.abspath(self._base_folder)
-    self._base_folder = os.path.join(self._base_folder, self._app_folder)
-    if not self.silent:
-      BaseLogger.print_color("BASE: {}".format(self._base_folder))
-
-    self._normalize_path_sep()
-
-    if not os.path.isdir(self._base_folder):
-      BaseLogger.print_color(
-        f"WARNING! Invalid app base folder '{self._base_folder}'! We create it automatically!",
-        color='r'
-      )
-    #endif
-
-    self._logs_dir = os.path.join(self._base_folder, self.get_logs_dir_name())
-    self._outp_dir = os.path.join(self._base_folder, self.get_output_dir_name())
-    self._data_dir = os.path.join(self._base_folder, self.get_data_dir_name())
-    self._modl_dir = os.path.join(self._base_folder, self.get_models_dir_name())
+      self._normalize_path_sep()
 
-    self._setup_folders([
-      self._outp_dir,
-      self._logs_dir,
-      self._data_dir,
-      self._modl_dir
-    ])
+      if not os.path.isdir(self._base_folder):
+        BaseLogger.print_color(
+          f"WARNING! Invalid app base folder '{self._base_folder}'! We create it automatically!",
+          color='r'
+        )
+      #endif
 
+      self._logs_dir = os.path.join(self._base_folder, self.get_logs_dir_name())
+      self._outp_dir = os.path.join(self._base_folder, self.get_output_dir_name())
+      self._data_dir = os.path.join(self._base_folder, self.get_data_dir_name())
+      self._modl_dir = os.path.join(self._base_folder, self.get_models_dir_name())
+
+      self._setup_folders([
+        self._outp_dir,
+        self._logs_dir,
+        self._data_dir,
+        self._modl_dir
+      ])
+      self.__folder_setup_done = True
+    else:
+      BaseLogger.print_color("Folders already configured.", color='y')
+    #endif apply only first time
     return
 
   @staticmethod

{naeural_client-2.6.5 → naeural_client-2.6.7}/pyproject.toml

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

{naeural_client-2.6.5 → naeural_client-2.6.7}/tutorials/ex01_part1_connect.py

@@ -18,7 +18,7 @@ IMPORTANT: Session will WAIT until network map is clarified.
 """
 import json
 
-from naeural_client import Session, Payload, PAYLOAD_DATA
+from naeural_client import Session, Payload, PAYLOAD_DATA, HEARTBEAT_DATA
 
 
 class MessageHandler:  
@@ -43,11 +43,10 @@ class MessageHandler:
     heartbeat : dict
         The heartbeat received from the edge node.        
     """
-    session.P("{} ({}) has a {}".format(
-      heartbeat[PAYLOAD_DATA.EE_ID], 
-      self.shorten_address(node_addr), 
-      heartbeat["CPU"])
-    )
+    node_alias = heartbeat[PAYLOAD_DATA.EE_ID]
+    short_addr = self.shorten_address(node_addr)
+    cpu = heartbeat[HEARTBEAT_DATA.CPU]
+    session.P(f"{node_alias} <{short_addr}> has a {cpu}", color='magenta')
     return
 
 
@@ -62,17 +61,13 @@ if __name__ == '__main__':
       on_heartbeat=filterer.on_heartbeat,
   )
 
-  session.P("Client address is: {}".format(session.get_client_address()), color='g')
+  session.P("Client address is: {}".format(session.get_client_address()), color='m')
   
   # lets see top 5 online nodes
   netinfo = session.get_network_known_nodes(online_only=True)
   session.P(f"Online nodes reported by {netinfo.reporter}:\n{netinfo.report}")
 
-  # 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=30, # 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
-  )
-  session.P("Main thread exiting...")
+  session.sleep(10) # wait for 10 seconds
+  session.P("Closing session...", color='m')
+  session.close()
+  session.P("Main thread exiting...", color='m')

{naeural_client-2.6.5 → naeural_client-2.6.7}/tutorials/ex01_part2_filter.py

@@ -128,7 +128,7 @@ if __name__ == '__main__':
   )
   
   # lets see top 5 online nodes
-  netinfo = session.get_network_known_nodes(online_only=True)
+  netinfo = session.get_network_known_nodes(online_only=True, debug=True)
   session.P(f"Online nodes reported by {netinfo.reporter}:\n{netinfo.report}")
   
 
@@ -136,7 +136,7 @@ if __name__ == '__main__':
   #   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=30, # wait for the user to stop the execution or a given time
+    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
   )
   session.P("Main thread exiting...")