naeural-client 2.2.6__tar.gz → 2.3.1__tar.gz

{naeural_client-2.2.6 → naeural_client-2.3.1}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.3
 Name: naeural_client
-Version: 2.2.6
+Version: 2.3.1
 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/Naeural Edge ProtocolEdgeProtocol/naeural_client
-Project-URL: Bug Tracker, https://github.com/Naeural Edge ProtocolEdgeProtocol/naeural_client/issues
-Author-email: Stefan Saraev <saraevstefan@gmail.com>, Andrei Ionut Damian <andrei.damian@me.com>, Cristan Bleotiu <cristibleotiu@gmail.com>
+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>
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
@@ -16,6 +16,7 @@ Requires-Dist: pika
 Requires-Dist: pyaml
 Requires-Dist: pyopenssl>=23.0.0
 Requires-Dist: python-dateutil
+Requires-Dist: web3
 Description-Content-Type: text/markdown
 
 # naeural_client SDK

{naeural_client-2.2.6 → naeural_client-2.3.1}/naeural_client/_ver.py

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

{naeural_client-2.2.6 → naeural_client-2.3.1}/naeural_client/base/generic_session.py

@@ -17,9 +17,12 @@ from ..utils import load_dotenv
 from .payload import Payload
 from .pipeline import Pipeline
 from .transaction import Transaction
+from ..utils.config import load_user_defined_config, get_user_config_file
 
 # TODO: add support for remaining commands from EE
 
+DEBUG_MQTT_SERVER = "r9092118.ala.eu-central-1.emqxsl.com"
+
 
 class GenericSession(BaseDecentrAIObject):
   """
@@ -59,7 +62,8 @@ class GenericSession(BaseDecentrAIObject):
                on_payload=None,
                on_notification=None,
                on_heartbeat=None,
-               silent=True,
+               debug_silent=True,
+               silent=False,
                verbosity=1,
                dotenv_path=None,
                show_commands=False,
@@ -120,8 +124,14 @@ class GenericSession(BaseDecentrAIObject):
         Callback that handles heartbeats received from this network.
         As arguments, it has a reference to this Session object, the node name and the heartbeat payload.
         Defaults to None.
-    silent : bool, optional
+        
+    debug_silent : bool, optional
         This flag will disable debug logs, set to 'False` for a more verbose log, by default True
+        
+    silent : bool, optional
+        This flag will disable all logs, set to 'False` for a more verbose log, by default False
+        The logs will still be recored in the log file even if this flag is set to True.
+        
     dotenv_path : str, optional
         Path to the .env file, by default None. If None, the path will be searched in the current working directory and in the directories of the files from the call stack.
     root_topic : str, optional
@@ -142,6 +152,7 @@ class GenericSession(BaseDecentrAIObject):
 
     self.log = log
     self.name = name
+    self.silent = silent
 
     self._verbosity = verbosity
     self.encrypt_comms = encrypt_comms
@@ -158,7 +169,10 @@ class GenericSession(BaseDecentrAIObject):
     pwd = pwd or kwargs.get('password', kwargs.get('pass', None))
     user = user or kwargs.get('username', None)
     host = host or kwargs.get('hostname', None)
+    
+    ## now we prepare config via ~/.naeural/config or .env
     self.__fill_config(host, port, user, pwd, secured, dotenv_path)
+    ## end config
 
     self.custom_on_payload = on_payload
     self.custom_on_heartbeat = on_heartbeat
@@ -180,15 +194,30 @@ class GenericSession(BaseDecentrAIObject):
     self.__open_transactions_lock = Lock()
 
     self.__create_user_callback_threads()
-    super(GenericSession, self).__init__(log=log, DEBUG=not silent, create_logger=True)
+    super(GenericSession, self).__init__(
+      log=log, 
+      DEBUG=not debug_silent, 
+      create_logger=True,
+      silent=self.silent,
+    )
     return
 
   def startup(self):
-    self.__start_blockchain(self.__bc_engine, self.__blockchain_config)
+    # start the blockchain engine assuming config is already set
+    self.__start_blockchain(
+      self.__bc_engine, self.__blockchain_config, 
+      user_config=self.__user_config_loaded,
+    )
+    # end bc_engine
     self.formatter_wrapper = IOFormatterWrapper(self.log, plugin_search_locations=self.__formatter_plugins_locations)
 
     self._connect()
 
+    self.P("Created {} comms session '{}' from <{}> SDKv{}.".format(
+      "decrypted" if not self.encrypt_comms else "encrypted", 
+      self.name, self.bc_engine.address, self.log.version
+    ))
+    
     if not self.encrypt_comms:
       self.P(
         "Warning: Emitted messages will not be encrypted.\n"
@@ -546,7 +575,7 @@ class GenericSession(BaseDecentrAIObject):
 
   # Main loop
   if True:
-    def __start_blockchain(self, bc_engine, blockchain_config):
+    def __start_blockchain(self, bc_engine, blockchain_config, user_config=False):
       if bc_engine is not None:
         self.bc_engine = bc_engine
         return
@@ -557,6 +586,7 @@ class GenericSession(BaseDecentrAIObject):
           name=self.name,
           config=blockchain_config,
           verbosity=self._verbosity,
+          user_config=user_config,
         )
       except:
         raise ValueError("Failure in private blockchain setup:\n{}".format(traceback.format_exc()))
@@ -780,15 +810,19 @@ class GenericSession(BaseDecentrAIObject):
       host : str
           The hostname of the server.
           Can be retrieved from the environment variables AIXP_HOSTNAME, AIXP_HOST
+          
       port : int
           The port.
           Can be retrieved from the environment variable AIXP_PORT
+          
       user : str
           The user name.
           Can be retrieved from the environment variables AIXP_USERNAME, AIXP_USER
+          
       pwd : str
           The password.
           Can be retrieved from the environment variables AIXP_PASSWORD, AIXP_PASS, AIXP_PWD
+          
       dotenv_path : str, optional
           Path to the .env file, by default None. If None, the path will be searched in the current working directory and in the directories of the files from the call stack.
 
@@ -798,11 +832,21 @@ class GenericSession(BaseDecentrAIObject):
           Missing credentials
       """
 
-      # this method will search for the credentials in the environment variables
-      # the path to env file, if not specified, will be search in the following order:
-      #  1. current working directory
-      #  2-N. directories of the files from the call stack
-      load_dotenv(dotenv_path=dotenv_path, verbose=False)
+      # if the ~/.naeural/config file exists, load the credentials from there else try to load them from .env
+      if not load_user_defined_config():        
+        # this method will search for the credentials in the environment variables
+        # the path to env file, if not specified, will be search in the following order:
+        #  1. current working directory
+        #  2-N. directories of the files from the call stack
+        load_dotenv(dotenv_path=dotenv_path, verbose=False)
+        if not self.silent:
+          print("Loaded credentials from environment variables.", flush=True)
+        self.__user_config_loaded = False
+      else:
+        if not self.silent:
+          print(f"Loaded credentials from `{get_user_config_file()}`.", flush=True)
+        self.__user_config_loaded = True
+      # endif config loading from ~ or ./.env
 
       possible_user_values = [
         user,
@@ -849,7 +893,7 @@ class GenericSession(BaseDecentrAIObject):
         os.getenv(ENVIRONMENT.EE_HOST),
         os.getenv(ENVIRONMENT.EE_MQTT_HOST),
         self._config.get(comm_ct.HOST),
-        "r9092118.ala.eu-central-1.emqxsl.com",
+        DEBUG_MQTT_SERVER,
       ]
 
       host = next((x for x in possible_host_values if x is not None), None)

{naeural_client-2.2.6 → naeural_client-2.3.1}/naeural_client/base_decentra_object.py

@@ -24,6 +24,7 @@ class BaseDecentrAIObject(object):
                show_prefixes=False,
                prefix_log=None,
                log_at_startup=False,
+               silent=False,
                **kwargs):
 
     super(BaseDecentrAIObject, self).__init__()
@@ -32,7 +33,13 @@ class BaseDecentrAIObject(object):
       if not create_logger:
         raise ValueError("Logger object is invalid: {}".format(log))
       else:
-        log = Logger("DEF", DEBUG=DEBUG, base_folder='.', app_folder='_local_cache')
+        log = Logger(
+          "DEF", 
+          DEBUG=DEBUG, 
+          base_folder='.', 
+          app_folder='_local_cache',
+          silent=silent,
+        )
     # endif
 
     self.log = log
@@ -79,7 +86,6 @@ class BaseDecentrAIObject(object):
         msg = "{} {}".format(self.prefix_log, s)
       # endif
     # endif
-
     _r = self.log.P(msg, show_time=t, color=color, **kwargs)
     return _r
 

{naeural_client-2.2.6 → naeural_client-2.3.1}/naeural_client/bc/base.py

@@ -12,6 +12,8 @@ from copy import deepcopy
 
 from cryptography.hazmat.primitives import serialization
 
+from ..utils.config import get_user_folder
+
 
 class BCct:
   SIGN      = 'EE_SIGN'
@@ -21,6 +23,7 @@ class BCct:
   ADDR_PREFIX_OLD = "aixp_"
   ADDR_PREFIX   = "0xai_"
   
+  K_USER_CONFIG_PEM_FILE = 'NAEURAL_PEM_FILE'
   K_PEM_FILE = 'PEM_FILE'
   K_PASSWORD = 'PASSWORD'
   K_PEM_LOCATION = 'PEM_LOCATION'
@@ -270,7 +273,7 @@ class BaseBlockEngine:
   _lock: Lock = Lock()
   __instances = {}
   
-  def __new__(cls, name, log, config, ensure_ascii_payloads=False, verbosity=1):
+  def __new__(cls, name, log, config, ensure_ascii_payloads=False, verbosity=1, user_config=False):
     with cls._lock:
       if name not in cls.__instances:
         instance = super(BaseBlockEngine, cls).__new__(cls)
@@ -278,6 +281,7 @@ class BaseBlockEngine:
           name=name, log=log, config=config, 
           ensure_ascii_payloads=ensure_ascii_payloads,
           verbosity=verbosity,
+          user_config=user_config,
         )
         cls.__instances[name] = instance
       else:
@@ -291,6 +295,7 @@ class BaseBlockEngine:
       log=None, 
       ensure_ascii_payloads=False,
       verbosity=1,
+      user_config=False,
     ):
 
     self.__name = name
@@ -304,11 +309,15 @@ class BaseBlockEngine:
     self.__config = config
     self.__ensure_ascii_payloads = ensure_ascii_payloads
     
-    pem_name = config.get(BCct.K_PEM_FILE, '_pk.pem')
-    pem_folder = config.get(BCct.K_PEM_LOCATION, 'data')
-    pem_fn = os.path.join(log.get_target_folder(pem_folder), pem_name)
+    if user_config:
+      user_folder = get_user_folder()
+      pem_fn = str(user_folder / '_naeural.pem')
+    else:
+      pem_name = config.get(BCct.K_PEM_FILE, '_pk.pem')
+      pem_folder = config.get(BCct.K_PEM_LOCATION, 'data')
+      pem_fn = os.path.join(log.get_target_folder(pem_folder), pem_name)
+    #endif pem is defined in ~/.naeural/config
     self.__pem_file = pem_fn
-    
     self._init()
     return
   
@@ -353,9 +362,13 @@ class BaseBlockEngine:
         password=self.__password,
         fn=self.__pem_file,
       )
-    self.__public_key = self._get_pk(private_key=self.__private_key)
+    self.__public_key = self._get_pk(private_key=self.__private_key)    
     self.__address = self._pk_to_address(self.__public_key)
-    self.P("Current address: {}".format(self.address), boxed=True, verbosity=1)
+    ### Ethereum
+    self.__eth_address = self._get_eth_address()
+    self.__eth_account = self._get_eth_account()
+    ### end Ethereum
+    self.P("Address: {} / ETH: {}".format(self.address, self.eth_address), boxed=True, verbosity=1)
     self.P("Allowed list of senders: {}".format(self.allowed_list), verbosity=1)
     return
   
@@ -363,6 +376,11 @@ class BaseBlockEngine:
   def private_key(self):
     return self.__private_key
   
+  
+  @property
+  def public_key(self):
+    return self.private_key.public_key()
+  
  
   @staticmethod
   def _compute_hash(data : bytes, method='SHA256'):
@@ -717,6 +735,32 @@ class BaseBlockEngine:
 
     """
     raise NotImplementedError()  
+  
+  
+  def _get_eth_address(self):
+    """
+    Returns the Ethereum address for the current pk
+
+    Returns
+    -------
+    eth_address : str
+      the Ethereum address.
+
+    """
+    raise NotImplementedError()
+  
+  
+  def _get_eth_acccount(self):
+    """
+    Returns the Ethereum account for the current sk
+
+    Returns
+    -------
+    eth_account : str
+      the Ethereum account.
+
+    """
+    raise NotImplementedError()
     
       
   
@@ -1045,3 +1089,15 @@ class BaseBlockEngine:
     """
     raise NotImplementedError()
   
+  
+  ### Ethereum
+  
+  @property
+  def eth_address(self):
+    return self.__eth_address
+  
+  @property
+  def eth_account(self):
+    return self.__eth_account
+  
+  ### end Ethereum

{naeural_client-2.2.6 → naeural_client-2.3.1}/naeural_client/bc/ec.py

@@ -11,6 +11,11 @@ from cryptography.hazmat.backends import default_backend
 from cryptography.hazmat.primitives.ciphers.aead import AESGCM
 from cryptography.hazmat.primitives.kdf.hkdf import HKDF
 
+from web3 import Web3
+from eth_account import Account
+from eth_utils import keccak, to_checksum_address
+from eth_account.messages import encode_defunct
+
 from .base import BaseBlockEngine, VerifyMessage, BCct
 
 
@@ -18,6 +23,7 @@ from .base import BaseBlockEngine, VerifyMessage, BCct
 class BaseBCEllipticCurveEngine(BaseBlockEngine):
   MAX_ADDRESS_VALUE = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
   
+  
   def _get_pk(self, private_key : ec.EllipticCurvePrivateKey) -> ec.EllipticCurvePublicKey:
     """
     Simple wrapper to generate pk from sk
@@ -233,6 +239,7 @@ class BaseBCEllipticCurveEngine(BaseBlockEngine):
       data=bpublic_key
     )
     return public_key
+  
 
   def __derive_shared_key(self, peer_public_key : str, info : str = BCct.DEFAULT_INFO, debug : bool = False):
     """
@@ -266,6 +273,7 @@ class BaseBCEllipticCurveEngine(BaseBlockEngine):
     if debug:
       print('derived-shared_key: ', base64.b64encode(derived_key))
     return derived_key
+  
 
   def encrypt(
     self, 
@@ -380,5 +388,140 @@ class BaseBCEllipticCurveEngine(BaseBlockEngine):
       
       result = plaintext.decode()
     except Exception as exc:
+      if debug:
+        self.P("Error decrypting from <{}> (compressed_flag `{}`): {}".format(
+          sender_address, compressed_flag, exc), color='r'
+        )
       result = None
-    return result
+    return result
+  
+  
+  
+  ### ETH
+
+  def _get_eth_address(self, pk=None):
+    if pk is None:
+      pk = self.public_key
+    raw_public_key = pk.public_numbers()
+
+    # Compute Ethereum-compatible address
+    x = raw_public_key.x.to_bytes(32, 'big')
+    y = raw_public_key.y.to_bytes(32, 'big')
+    uncompressed_key = b'\x04' + x + y
+    keccak_hash = keccak(uncompressed_key[1:])  # Remove 0x04 prefix
+    eth_address = "0x" + keccak_hash[-20:].hex()
+    eth_address = to_checksum_address(eth_address)
+    return eth_address    
+  
+  def _get_eth_account(self):
+    private_key_bytes = self.private_key.private_numbers().private_value.to_bytes(32, 'big')
+    return Account.from_key(private_key_bytes)
+  
+  
+  def node_address_to_eth_address(self, address):
+    """
+    Converts a node address to an Ethereum address.
+
+    Parameters
+    ----------
+    address : str
+        The node address convert.
+
+    Returns
+    -------
+    str
+        The Ethereum address.
+    """
+    public_key = self._address_to_pk(address)
+    return self._get_eth_address(pk=public_key)
+    
+
+  
+  def eth_hash_message(self, types, values, as_hex=False):
+    """
+    Hashes a message using the keccak256 algorithm.
+
+    Parameters
+    ----------
+    types : list
+        The types of the values.
+        
+    values : list of any
+        The values to hash.
+
+    Returns
+    -------
+    bytes
+        The hash of the message in hexadecimal format.
+    """
+    message = Web3.solidity_keccak(types, values)
+    if as_hex:
+      return message.hex()
+    return message
+  
+  
+  def eth_sign_message(self, types, values):
+    """
+    Signs a message using the private key.
+
+    Parameters
+    ----------
+    types : list
+        The types of the values.
+        
+    values : list of any
+        The values to sign.
+
+    Returns
+    -------
+    str
+        The signature of the message.
+    """
+    message_hash = self.eth_hash_message(types, values, as_hex=False)
+    signable_message = encode_defunct(primitive=message_hash)
+    signed_message = Account.sign_message(signable_message, private_key=self.eth_account.key)
+    if hasattr(signed_message, "message_hash"): # backward compatibility
+      signed_message_hash = signed_message.message_hash
+    else:
+      signed_message_hash = signed_message.messageHash
+    return {
+        "message_hash": message_hash.hex(),
+        "r": hex(signed_message.r),
+        "s": hex(signed_message.s),
+        "v": signed_message.v,
+        "signature": signed_message.signature.hex(),
+        "signed_message": signed_message_hash.hex(),
+        "sender" : self.eth_address,
+    }
+    
+  def eth_sign_node_epochs(self, node, epochs, epochs_vals, signature_only=True):
+    """
+    Signs the node availability
+
+    Parameters
+    ----------
+    node : str
+        The node address.
+        
+    epochs : list of int
+        The epochs to sign.
+        
+    epochs_vals : list of int
+        The values for each epoch.
+        
+    signature_only : bool, optional
+        Whether to return only the signature. The default is True.
+
+    Returns
+    -------
+    str
+        The signature of the message.
+    """
+    types = ["string", "uint256[]", "uint256[]"]
+    values = [node, epochs, epochs_vals]
+    result = self.eth_sign_message(types, values)
+    if signature_only:
+      return result["signature"]
+    return result
+  
+  

naeural_client-2.3.1/naeural_client/cli/README.md

@@ -0,0 +1,7 @@
+# The Naeural Edge Protocol CLI 
+
+## Develop
+
+```bash
+pip install -e .
+```

naeural_client-2.3.1/naeural_client/cli/cli.py

@@ -0,0 +1,48 @@
+import argparse
+
+from naeural_client.utils.config import maybe_init_config, log_with_color
+from naeural_client.cli.cli_commands import CLI_COMMANDS
+
+from naeural_client import version
+
+def build_parser():
+  """
+  Dynamically builds the argument parser based on CLI_COMMANDS.
+
+  Returns
+  -------
+  argparse.ArgumentParser
+      Configured argument parser.
+  """
+  descr = f"nepctl v{version} - CLI for Naeural Edge Protocol SDK package"
+  
+ 
+  parser = argparse.ArgumentParser(description=descr)
+  subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+  # Iterate over top-level commands
+  for command, subcommands in CLI_COMMANDS.items():
+    command_parser = subparsers.add_parser(command, help=f"{command} commands")
+    if isinstance(subcommands, dict):  # Nested subcommands
+      command_subparsers = command_parser.add_subparsers(dest="subcommand")
+      for subcommand, func in subcommands.items():
+        subcommand_parser = command_subparsers.add_parser(
+            subcommand, help=f"{subcommand} command"
+        )
+        subcommand_parser.set_defaults(func=func)
+    else:
+      command_parser.set_defaults(func=subcommands)
+
+  return parser
+
+def main():
+  maybe_init_config()
+  parser = build_parser()
+  args = parser.parse_args()
+  if hasattr(args, "func"):
+    args.func()  # Call the dynamically loaded function
+  else:
+    parser.print_help()
+
+if __name__ == "__main__":
+  main()

naeural_client-2.3.1/naeural_client/cli/cli_commands.py

@@ -0,0 +1,15 @@
+from naeural_client.cli.nodes import get_nodes, get_supervisors
+from naeural_client.utils.config import show_config, reset_config
+
+
+# Define the available commands
+CLI_COMMANDS = {
+    "get": {
+        "nodes": get_nodes,
+        "supervisors": get_supervisors,
+    },
+    "config": {
+        "show": show_config,
+        "reset": reset_config,
+    },
+}

naeural_client-2.3.1/naeural_client/cli/nodes.py

@@ -0,0 +1,22 @@
+from naeural_client.utils.config import log_with_color
+
+
+def get_nodes():
+  """
+  This function is used to get the information about the nodes and it will perform the following:
+  
+  1. Create a Session object.
+  2. Wait for the first net mon message via Session and show progress. 
+  3. Wait for the second net mon message via Session and show progress.  
+  4. Get the active nodes union via Session and display the nodes marking those peered vs non-peered.
+  """
+  log_with_color("Getting nodes information", color="b")
+  return
+  
+  
+def get_supervisors():
+  """
+  This function is used to get the information about the supervisors.
+  """
+  log_with_color("Getting supervisors information", color='b')
+  return