naeural-client 3.2.0__tar.gz → 3.2.3__tar.gz

{naeural_client-3.2.0 → naeural_client-3.2.3}/PKG-INFO

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

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

{naeural_client-3.2.0 → naeural_client-3.2.3}/naeural_client/base/generic_session.py

@@ -19,7 +19,7 @@ from time import sleep
 from time import time as tm
 
 from ..base_decentra_object import BaseDecentrAIObject
-from ..bc import DefaultBlockEngine, _DotDict
+from ..bc import DefaultBlockEngine, _DotDict, EE_VPN_IMPL
 from ..const import (
   COMMANDS, ENVIRONMENT, HB, PAYLOAD_DATA, STATUS_TYPE, 
   PLUGIN_SIGNATURES, DEFAULT_PIPELINES,
@@ -45,7 +45,7 @@ from ..utils.config import (
 
 DEBUG_MQTT_SERVER = "r9092118.ala.eu-central-1.emqxsl.com"
 SDK_NETCONFIG_REQUEST_DELAY = 300
-
+SHOW_PENDING_THRESHOLD = 3600
 
 
 
@@ -229,14 +229,10 @@ class GenericSession(BaseDecentrAIObject):
     
     # TODO: maybe read config from file?
     self._config = {**self.default_config, **config}
-
-    if root_topic is not None:
-      for key in self._config.keys():
-        if isinstance(self._config[key], dict) and 'TOPIC' in self._config[key]:
-          if isinstance(self._config[key]["TOPIC"], str) and self._config[key]["TOPIC"].startswith("{}"):
-            nr_empty = self._config[key]["TOPIC"].count("{}")
-            self._config[key]["TOPIC"] = self._config[key]["TOPIC"].format(root_topic, *(["{}"] * (nr_empty - 1)))
-    # end if root_topic
+    
+    
+    
+    self.comms_root_topic = root_topic
     
     self.__auto_configuration = auto_configuration
 
@@ -245,8 +241,8 @@ class GenericSession(BaseDecentrAIObject):
     
     self.name = name
     self.silent = silent
-    
-    self.__eth_enabled = eth_enabled
+
+    self._eth_enabled = eth_enabled
 
     self.encrypt_comms = encrypt_comms
 
@@ -354,6 +350,22 @@ class GenericSession(BaseDecentrAIObject):
     # end bc_engine
     # END TODO
     
+    
+    str_topic = os.environ.get(ENVIRONMENT.EE_ROOT_TOPIC_ENV_KEY, self.comms_root_topic)    
+    
+    if str_topic != self.comms_root_topic:
+      self.P(f"Changing root topic from '{self.comms_root_topic}' to '{str_topic}'", color='y')
+      self.comms_root_topic = str_topic
+
+    if self.comms_root_topic is not None:
+      for key in self._config.keys():
+        if isinstance(self._config[key], dict) and 'TOPIC' in self._config[key]:
+          if isinstance(self._config[key]["TOPIC"], str) and self._config[key]["TOPIC"].startswith("{}"):
+            nr_empty = self._config[key]["TOPIC"].count("{}")
+            self._config[key]["TOPIC"] = self._config[key]["TOPIC"].format(self.comms_root_topic, *(["{}"] * (nr_empty - 1)))
+    # end if root_topic
+
+    
     ## last config step
     self.__fill_config(
       host=self.__host, 
@@ -830,8 +842,12 @@ class GenericSession(BaseDecentrAIObject):
         # this is for legacy and custom implementation where heartbeats still contain
         # the pipeline configuration.
         pipeline_names = [x.get(PAYLOAD_DATA.NAME, None) for x in msg_active_configs]
+        received_plugins = dict_msg.get(HB.ACTIVE_PLUGINS, [])
         self.D(f'<HB> Processing pipelines from <{short_addr}>:{pipeline_names}', color='y')
-        self.__process_node_pipelines(msg_node_addr, msg_active_configs)
+        new_pipeliens = self.__process_node_pipelines(
+          node_addr=msg_node_addr, pipelines=msg_active_configs,
+          plugins_statuses=received_plugins,
+        )
 
       # TODO: move this call in `__on_message_default_callback`
       if self.__maybe_ignore_message(msg_node_addr):
@@ -1113,19 +1129,23 @@ class GenericSession(BaseDecentrAIObject):
         return
 
       try:
+        if EE_VPN_IMPL and self._eth_enabled:
+          self.P("Disabling ETH for VPN implementation", color='r')
+          self._eth_enabled = False
+        
         self.bc_engine = DefaultBlockEngine(
           log=self.log,
           name=self.name,
           config=blockchain_config,
           verbosity=self._verbosity,
           user_config=user_config,
-          eth_enabled=self.__eth_enabled, 
+          eth_enabled=self._eth_enabled, 
         )
       except:
         raise ValueError("Failure in private blockchain setup:\n{}".format(traceback.format_exc()))
       
       # extra setup flag for re-connections with same multiton instance
-      self.bc_engine.set_eth_flag(self.__eth_enabled)
+      self.bc_engine.set_eth_flag(self._eth_enabled)
       return
 
     def __start_main_loop_thread(self):
@@ -2868,8 +2888,8 @@ class GenericSession(BaseDecentrAIObject):
       telegram_bot_token=None,
       telegram_bot_token_env_key=ENVIRONMENT.TELEGRAM_BOT_TOKEN_ENV_KEY,
       telegram_bot_name=None,
-      telegram_bot_name_env_key=ENVIRONMENT.TELEGRAM_BOT_NAME_ENV_KEY,
-      
+      telegram_bot_name_env_key=ENVIRONMENT.TELEGRAM_BOT_NAME_ENV_KEY,      
+      processor_handler=None,            
       system_prompt=None,
       agent_type="API",
       api_token_env_key=ENVIRONMENT.TELEGRAM_API_AGENT_TOKEN_ENV_KEY,
@@ -2943,6 +2963,7 @@ class GenericSession(BaseDecentrAIObject):
         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."
           raise ValueError(message)
+
       
 
       pipeline: Pipeline = self.create_pipeline(
@@ -2950,6 +2971,10 @@ class GenericSession(BaseDecentrAIObject):
         name=name,
         # default TYPE is "Void"
       )
+
+      proc_func_args, proc_func_base64_code =[], None
+      if processor_handler is not None:
+        _, proc_func_args, proc_func_base64_code = pipeline._get_method_data(processor_handler)
       
       
       obfuscated_token = telegram_bot_token[:4] + "*" * (len(telegram_bot_token) - 4)      
@@ -2957,8 +2982,13 @@ class GenericSession(BaseDecentrAIObject):
       instance = pipeline.create_plugin_instance(
         signature=signature,
         instance_id=self.log.get_unique_id(),
+
         telegram_bot_token=telegram_bot_token,
         telegram_bot_name=telegram_bot_name,
+
+        processor_handler=proc_func_base64_code, # not mandatory
+        processor_handler_args=proc_func_args, # not mandatory
+
         system_prompt=system_prompt,
         agent_type=agent_type,
         api_token=api_token,
@@ -3289,6 +3319,50 @@ class GenericSession(BaseDecentrAIObject):
       return dct_result
 
 
+  def date_to_readable(self, date, check_none=False, start_time=None, pending_threshold=SHOW_PENDING_THRESHOLD):
+    """
+    Convert a date to a human-readable format.
+
+    Parameters
+    ----------
+
+    date : str
+        The date to convert.
+    check_none : bool, optional
+        If True, and the date is None it will check if too much time passed from the start time.
+        If too much time passed, it will return 'Error!', otherwise, it will return 'Pending'.
+        If False, it will return 'Never' if the date is None.
+        Defaults to False.
+    start_time : str, optional
+        The start time to compare with the date in case it is None. Defaults to None.
+    pending_threshold : int, optional
+        The threshold in seconds to consider a date as pending. Defaults to SHOW_PENDING_THRESHOLD.
+        If the time passed since start_time is greater than pending_threshold and
+        check_none is set to True, it will return 'Error!'.
+
+    Returns
+    -------
+
+    str
+        The human-readable date.
+    """
+    if date is None:
+      if not check_none or start_time is None:
+        return 'Never'
+      # endif not check_none
+      start_dt = self.log.str_to_date(start_time, fmt='%Y-%m-%d %H:%M:%S.%f')
+      since_start = (dt.now() - start_dt).total_seconds()
+      if since_start > pending_threshold:
+        return 'Error!'
+      return 'Pending'
+    # endif date is None
+    if date.startswith('1970'):
+      return 'Never'
+    if '.' in date:
+      date = date.split('.')[0]
+    return date
+
+
   def get_nodes_apps(
     self, 
     node=None, 
@@ -3379,16 +3453,18 @@ class GenericSession(BaseDecentrAIObject):
             if len(instance_status) == 0:
               # this instance is only present in config but is NOT loaded so ignore it
               continue
-            start_time = instance_status.get('INIT_TIMESTAMP')
-            last_probe = instance_status.get('EXEC_TIMESTAMP')
-            last_data = instance_status.get('LAST_PAYLOAD_TIME')
-            dates = [start_time, last_probe, last_data]
-            for i in range(len(dates)):
-              if isinstance(dates[i], str):
-                if dates[i].startswith('1970'):
-                  dates[i] = 'Never'
-                elif '.' in dates[i]:
-                  dates[i] = dates[i].split('.')[0]
+            start_time = instance_status.get(HB.ACTIVE_PLUGINS_INFO.INIT_TIMESTAMP)
+            last_probe = instance_status.get(HB.ACTIVE_PLUGINS_INFO.EXEC_TIMESTAMP)
+            last_data = instance_status.get(HB.ACTIVE_PLUGINS_INFO.LAST_PAYLOAD_TIME)
+            dates = [start_time, last_data]
+            error_dates = [
+              instance_status.get(HB.ACTIVE_PLUGINS_INFO.FIRST_ERROR_TIME),
+              instance_status.get(HB.ACTIVE_PLUGINS_INFO.LAST_ERROR_TIME),
+            ]
+            dates = [self.date_to_readable(x, check_none=False) for x in dates]
+            error_dates = [self.date_to_readable(x, check_none=False) for x in error_dates]
+            last_probe = self.date_to_readable(last_probe, check_none=True, start_time=start_time)
+
             lst_plugin_instance_data.append({
               'Node'  : node,
               'Owner' : pipeline_owner,
@@ -3397,8 +3473,9 @@ class GenericSession(BaseDecentrAIObject):
               'Plugin': instance.signature,
               'Id': instance.instance_id,
               'Start' : dates[0],
-              'Probe' : dates[1],
-              'Data' : dates[2],
+              'Probe' : last_probe,
+              'Data' : dates[1],
+              'LastError': error_dates[1],
             })
           # endfor instances in app
         # endfor apps
@@ -3408,7 +3485,8 @@ class GenericSession(BaseDecentrAIObject):
       log_with_color(f'Node(s) {nodes} not found. Please check the configuration.', color='r')
       return 
     if as_df:
-      df = pd.DataFrame(lst_plugin_instance_data)
+      color_condition = lambda x: (x['LastError'] != 'Never' or x['Probe'] == 'Error!')
+      df = self.log.colored_dataframe(lst_plugin_instance_data, color_condition=color_condition)
       if not (df.empty or df.shape[0] == 0):
         df['Node'] = df['Node'].apply(lambda x: self._shorten_addr(x))
         df['Owner'] = df['Owner'].apply(lambda x: self._shorten_addr(x))

{naeural_client-3.2.0 → naeural_client-3.2.3}/naeural_client/bc/__init__.py

@@ -1,3 +1,3 @@
 from .ec import BaseBCEllipticCurveEngine
-from .base import BCct, _DotDict, _ComplexJsonEncoder, VerifyMessage
+from .base import BCct, _DotDict, _ComplexJsonEncoder, VerifyMessage, EE_VPN_IMPL
 DefaultBlockEngine = BaseBCEllipticCurveEngine

{naeural_client-3.2.0 → naeural_client-3.2.3}/naeural_client/bc/base.py

@@ -319,7 +319,7 @@ class BaseBlockEngine(_EVMMixin):
     self.__config = config
     self.__ensure_ascii_payloads = ensure_ascii_payloads
     
-    self.__eth_enabled = eth_enabled
+    self._eth_enabled = eth_enabled
     
     if user_config:
       user_folder = get_user_folder()
@@ -350,12 +350,12 @@ class BaseBlockEngine(_EVMMixin):
   
   @property
   def eth_enabled(self):
-    return self.__eth_enabled
+    return self._eth_enabled
 
 
   def set_eth_flag(self, value):    
-    if value != self.__eth_enabled:
-      self.__eth_enabled = value
+    if value != self._eth_enabled:
+      self._eth_enabled = value
       self.log.P("Changed eth_enabled to {}".format(value), color='d')
     return
 
@@ -377,7 +377,7 @@ class BaseBlockEngine(_EVMMixin):
 
   def _init(self):
     self.P(
-      f"Initializing BC-engine (ETH_ENABLED={self.__eth_enabled})...", verbosity=1
+      f"Initializing BC-engine (ETH_ENABLED={self._eth_enabled})...", verbosity=1
     )
 
     if True:
@@ -414,7 +414,7 @@ class BaseBlockEngine(_EVMMixin):
     self.__eth_address = self._get_eth_address()
     self.__eth_account = self._get_eth_account()
     ### end Ethereum
-    if self.__eth_enabled:
+    if self._eth_enabled:
       self.P(
         "{} / ETH: {} ({})".format(self.address, self.eth_address, self.evm_network), boxed=True, verbosity=1,
         color='g'
@@ -1212,7 +1212,7 @@ class BaseBlockEngine(_EVMMixin):
       dct_data[BCct.SIGN] = result
       dct_data[BCct.SENDER] = self.address
       
-      if self.__eth_enabled:
+      if self._eth_enabled:
         dct_data[BCct.ETH_SENDER] = self.eth_address
         ### add eth signature
         dct_data[BCct.ETH_SIGN] = "0xBEEF"

{naeural_client-3.2.0 → naeural_client-3.2.3}/naeural_client/const/environment.py

@@ -28,8 +28,11 @@ class ENVIRONMENT:
 
   EE_SECURED = 'EE_SECURED'
   AIXP_SECURED = 'AIXP_SECURED'
+  EE_MQTT_SECURED = 'EE_MQTT_SECURED'
   
   TELEGRAM_BOT_TOKEN_ENV_KEY = 'EE_TELEGRAM_BOT_TOKEN'
   TELEGRAM_BOT_NAME_ENV_KEY = 'EE_TELEGRAM_BOT_NAME'
   
   TELEGRAM_API_AGENT_TOKEN_ENV_KEY = 'EE_TELEGRAM_API_AGENT_TOKEN'
+  
+  EE_ROOT_TOPIC_ENV_KEY = 'EE_ROOT_TOPIC'

{naeural_client-3.2.0 → naeural_client-3.2.3}/naeural_client/logging/logger_mixins/utils_mixin.py

@@ -7,12 +7,82 @@ import hashlib
 import numpy as np
 import traceback
 import random
+import pandas as pd
 from queue import Queue
 
 from collections import OrderedDict, deque, defaultdict
 
 from io import BytesIO, TextIOWrapper
 
+class ColorDataFrame(pd.DataFrame):
+  """
+  A DataFrame subclass that colors specific rows red when printed in a console.
+
+  Parameters
+  ----------
+  *args : tuple
+    Positional arguments passed to the pd.DataFrame constructor.
+  color_condition : callable, optional
+    A function that takes a row (pd.Series) and returns True if the row should be
+    highlighted in red, or False otherwise.
+  **kwargs : dict
+    Keyword arguments passed to the pd.DataFrame constructor.
+
+  Returns
+  -------
+  ColorDataFrame
+    A subclass of DataFrame that overrides the to_string method for coloring.
+
+  Examples
+  --------
+  
+  df = ColorDataFrame(
+    df,
+    color_condition=lambda row: row['value'] > 9
+  )
+  print(df)
+  """
+
+  _metadata = ['_color_condition']
+
+  def __init__(self, *args, color_condition=lambda row: False, **kwargs):
+    super().__init__(*args, **kwargs)
+    # Store the condition function as an attribute
+    self._color_condition = color_condition
+    return
+
+  def to_string(self, *args, **kwargs):
+    """
+    Overridden version of to_string that applies ANSI colors to rows
+    matching the condition.
+    """
+    original_string = super().to_string(*args, **kwargs)
+    # Split the original string into lines
+    lines = original_string.split('\n')
+
+    header_lines = lines[:1]
+    data_lines = lines[1:]
+
+    colored_data_lines = []
+    for row_index, row_line in enumerate(data_lines):
+      # Attempt to parse the index from the leftmost part of each row line
+      try:
+        # The row's index in the actual DataFrame
+        df_index = self.index[row_index]
+      except IndexError:
+        colored_data_lines.append(row_line)
+        continue
+
+      # Check if row meets the color condition
+      if self._color_condition(self.loc[df_index]):
+        # Red color ANSI: \033[91m ... \033[0m
+        row_line = f"\033[91m{row_line}\033[0m"
+
+      colored_data_lines.append(row_line)
+
+    return "\n".join(header_lines + colored_data_lines)
+
+
 
 adjectives = [
   'able', 'arco', 'arty', 'awed', 'awny', 'bald', 'base', 'bass', 'bent', 'best', 'boxy', 
@@ -64,6 +134,14 @@ class _UtilsMixin(object):
 
   def __init__(self):
     super(_UtilsMixin, self).__init__()
+    
+    
+  @staticmethod
+  def colored_dataframe(df, color_condition=lambda row: False):
+    """
+    A DataFrame subclass that colors specific rows red when printed in a console.
+    """
+    return ColorDataFrame(df, color_condition=color_condition)
 
   @staticmethod
   def get_function_parameters(function):

{naeural_client-3.2.0 → naeural_client-3.2.3}/pyproject.toml

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

naeural_client-3.2.3/template.env

@@ -0,0 +1,23 @@
+EE_MQTT_HOST=192.168.1.1
+EE_MQTT_PORT=1883
+EE_MQTT_USER=local-user
+EE_MQTT=some-p@55word
+EE_DAUTH_URL=N/A
+EE_ETH_ENABLED=false
+EE_VPN_IMPL=1
+EE_SECURED=false
+EE_ROOT_TOPIC=some-vpn-root-topic
+
+
+
+# EE_MQTT_HOST=
+# EE_MQTT_PORT=
+# EE_MQTT_USER=
+# EE_MQTT=
+# EE_SECURED=true
+
+TARGET_NODE=0xai_A9GWvmq3m-cyEMUyOaTTeyMSTkAwk-mfY2ftn1fsOQXE
+TELEGRAM_BOT_TOKEN=7741954463:AAEmAvTtbFkWe3AAgtGiN-jJcgf986v-eV0
+TELEGRAM_BOT_NAME=Aimethica_bot
+
+TELEGRAM_API_AGENT_TOKEN=

{naeural_client-3.2.0 → naeural_client-3.2.3}/xperimental/_checks/session_check.py

@@ -6,6 +6,5 @@ if __name__ == '__main__':
     silent=False,
     verbosity=3,
   )
-  sess.P(sess.get_client_address(), color='g')
   
   sess.wait(seconds=15, close_session=True)

{naeural_client-3.2.0 → naeural_client-3.2.3}/xperimental/_checks/workload_check.py

@@ -4,13 +4,13 @@ from naeural_client import Session
 
 if __name__ == '__main__':
   sess = Session(
-    silent=False,
+    silent=True,
     verbosity=3,
   )
   sess.P(sess.get_client_address(), color='g')
   
   node = '0xai_AxLOEgr3I1SCi3wp1c3tYxgVEpZrfV_qpDoG3_J8Sc4e'
-  df = sess.get_node_apps(node=node, show_full=True, as_json=False, as_df=True)
-  sess.P(f"Results:\n{df}", color='b')
+  df = sess.get_nodes_apps(node=node, show_full=True, as_json=False, as_df=True)
+  sess.P(f"Results:\n{df}", color='b', show=True)
     
   sess.wait(seconds=15, close_session=True)

naeural_client-3.2.3/xperimental/test.py

@@ -0,0 +1,74 @@
+import pandas as pd
+
+class ColorDataFrame(pd.DataFrame):
+  """
+  A DataFrame subclass that colors specific rows red when printed in a console.
+
+  Parameters
+  ----------
+  *args : tuple
+    Positional arguments passed to the pd.DataFrame constructor.
+  color_condition : callable, optional
+    A function that takes a row (pd.Series) and returns True if the row should be
+    highlighted in red, or False otherwise.
+  **kwargs : dict
+    Keyword arguments passed to the pd.DataFrame constructor.
+
+  Returns
+  -------
+  ColorDataFrame
+    A subclass of DataFrame that overrides the to_string method for coloring.
+
+  Examples
+  --------
+  
+  >>> df = ColorDataFrame(
+        df,
+  ...   color_condition=lambda row: row['value'] > 9
+      )  
+  >>> print(df)
+  """
+
+  _metadata = ['_color_condition']
+
+  def __init__(self, *args, color_condition=lambda row: False, **kwargs):
+    super().__init__(*args, **kwargs)
+    # Store the condition function as an attribute
+    self._color_condition = color_condition
+    return
+
+  def to_string(self, *args, **kwargs):
+    """
+    Overridden version of to_string that applies ANSI colors to rows
+    matching the condition.
+    """
+    original_string = super().to_string(*args, **kwargs)
+    # Split the original string into lines
+    lines = original_string.split('\n')
+
+    header_lines = lines[:1]
+    data_lines = lines[1:]
+
+    colored_data_lines = []
+    for row_index, row_line in enumerate(data_lines):
+      # Attempt to parse the index from the leftmost part of each row line
+      try:
+        # The row's index in the actual DataFrame
+        df_index = self.index[row_index]
+      except IndexError:
+        colored_data_lines.append(row_line)
+        continue
+
+      # Check if row meets the color condition
+      if self._color_condition(self.loc[df_index]):
+        # Red color ANSI: \033[91m ... \033[0m
+        row_line = f"\033[91m{row_line}\033[0m"
+
+      colored_data_lines.append(row_line)
+
+    return "\n".join(header_lines + colored_data_lines)
+
+
+if __name__ == "__main__":
+  df = ColorDataFrame({'value': [10, -5, 3]}, color_condition=lambda row: row['value'] > 9)
+  print(df)