ratio1 3.4.36__tar.gz → 3.4.37__tar.gz

{ratio1-3.4.36 → ratio1-3.4.37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ratio1
-Version: 3.4.36
+Version: 3.4.37
 Summary: `ratio1` or Ration1 SDK is the Python SDK required for client app development for the Ratio1 ecosystem
 Project-URL: Homepage, https://github.com/Ratio1/ratio1_sdk
 Project-URL: Bug Tracker, https://github.com/Ratio1/ratio1_sdk/issues

{ratio1-3.4.36 → ratio1-3.4.37}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "ratio1"
-version = "3.4.36"
+version = "3.4.37"
 authors = [
   { name="Andrei Ionut Damian", email="andrei.damian@ratio1.ai" },
   { name="Cristan Bleotiu", email="cristian.bleotiu@ratio1.ai" },

{ratio1-3.4.36 → ratio1-3.4.37}/ratio1/_ver.py

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

{ratio1-3.4.36 → ratio1-3.4.37}/ratio1/base/generic_session.py

@@ -27,7 +27,6 @@ from ..const import (
   BLOCKCHAIN_CONFIG, SESSION_CT, NET_CONFIG
 )
 from ..const import comms as comm_ct
-from ..const.evm_net import EVM_NET_DATA, EvmNetData
 from ..const import DEEPLOY_CT
 from ..io_formatter import IOFormatterWrapper
 from ..logging import Logger
@@ -1548,7 +1547,7 @@ class GenericSession(BaseDecentrAIObject):
           If no oracles are found for the wallet on the current network
       """
       current_network = block_engine.current_evm_network
-      api_base_url = EVM_NET_DATA[current_network][EvmNetData.EE_DEEPLOY_API_URL_KEY]
+      api_base_url = block_engine.get_deeploy_url()
 
       wallet_nodes = block_engine.web3_get_wallet_nodes(block_engine.eth_address)
       oracles_on_the_network = block_engine.web3_get_oracles(current_network)
@@ -1750,6 +1749,13 @@ class GenericSession(BaseDecentrAIObject):
       dct_aliases = {v: k for k, v in self.__dct_node_address_to_alias.items()}
       return dct_aliases
 
+    def get_node_address(self, node):
+      """
+      A public wrapper for __get_node_address.
+      """
+      return self.__get_node_address(node)
+
+
     def __get_node_address(self, node):
       """
       Get the address of a node. If node is an address, return it. Else, return the address of the node.
@@ -2317,6 +2323,19 @@ class GenericSession(BaseDecentrAIObject):
 
       return active_supervisors
 
+    def get_last_hb(self):
+      """
+      Get the last heartbeat of all nodes.
+
+      Returns
+      -------
+      dict
+          A dictionary with the last heartbeat of all nodes.
+          Where the key is the node address and the value is the last heartbeat.
+      """
+      return self._dct_online_nodes_last_heartbeat
+
+
     def attach_to_pipeline(self, *,
                            node,
                            name,
@@ -3307,21 +3326,6 @@ class GenericSession(BaseDecentrAIObject):
       if target_nodes_count == 0 and len(target_nodes) == 0:
         raise ValueError("You must specify at least one target node to deploy the container app.")
 
-      # Check if PK exists
-      if not os.path.isfile(signer_private_key_path):
-        raise ValueError("Private key path is not valid.")
-
-      # Create a block engine instance with the private key
-      block_engine = DefaultBlockEngine(
-        log=logger,
-        name="deeploy_launch_container_app",
-        config={
-          BCct.K_PEM_FILE: signer_private_key_path,
-          BCct.K_PASSWORD: signer_private_key_password,
-        }
-      )
-
-      current_network, api_base_url = self.__validate_deeploy_network_and_get_api_url(block_engine)
       #####################################################
 
       assert callable(message_handler), "The `message_handler` method parameter must be provided."
@@ -3354,43 +3358,126 @@ class GenericSession(BaseDecentrAIObject):
 
 
       #####################################################
-      request_data = {DEEPLOY_CT.DEEPLOY_KEYS.REQUEST: {
-        DEEPLOY_CT.DEEPLOY_KEYS.APP_ALIAS: name,
-        DEEPLOY_CT.DEEPLOY_KEYS.PLUGIN_SIGNATURE: signature,
-        DEEPLOY_CT.DEEPLOY_KEYS.TARGET_NODES: target_nodes,
-        DEEPLOY_CT.DEEPLOY_KEYS.TARGET_NODES_COUNT: target_nodes_count,
-      }}
-
-      request_data[DEEPLOY_CT.DEEPLOY_KEYS.REQUEST][DEEPLOY_CT.DEEPLOY_KEYS.APP_PARAMS] = {
-        'TELEGRAM_BOT_TOKEN': telegram_bot_token,
-        'TELEGRAM_BOT_NAME': telegram_bot_name,
-        'MESSAGE_HANDLER': func_base64_code,
-        'MESSAGE_HANDLER_ARGS': func_args,  # mandatory message and user
-        'MESSAGE_HANDLER_NAME': func_name,  # not mandatory
-        'PROCESSING_HANDLER': proc_func_base64_code,  # not mandatory
-        'PROCESSING_HANDLER_ARGS': proc_func_args,  # not mandatory
+      app_params = {
+        DEEPLOY_CT.DEEPLOY_KEYS.APP_PARAMS_TELEGRAM_BOT_TOKEN: telegram_bot_token,
+        DEEPLOY_CT.DEEPLOY_KEYS.APP_PARAMS_TELEGRAM_BOT_NAME: telegram_bot_name,
+        DEEPLOY_CT.DEEPLOY_KEYS.APP_PARAMS_MESSAGE_HANDLER: func_base64_code,
+        DEEPLOY_CT.DEEPLOY_KEYS.APP_PARAMS_MESSAGE_HANDLER_ARGS: func_args,  # mandatory message and user
+        DEEPLOY_CT.DEEPLOY_KEYS.APP_PARAMS_MESSAGE_HANDLER_NAME: func_name,  # not mandatory
+        DEEPLOY_CT.DEEPLOY_KEYS.APP_PARAMS_PROCESSING_HANDLER: proc_func_base64_code,  # not mandatory
+        DEEPLOY_CT.DEEPLOY_KEYS.APP_PARAMS_PROCESSING_HANDLER_ARGS: proc_func_args,  # not mandatory
       }
 
+      api_base_url, request_body = self.__generate_deeploy_request(
+        logger=logger,
+        signer_private_key_path=signer_private_key_path,
+        signer_private_key_password=signer_private_key_password,
+        app_alias=name,
+        signature=signature,
+        target_nodes=target_nodes,
+        target_nodes_count=target_nodes_count,
+        app_params=app_params
+      )
+
+
       try:
-        # Set the nonce for the request
-        nonce = f"0x{int(time.time() * 1000):x}"
-        request_data[DEEPLOY_CT.DEEPLOY_KEYS.REQUEST][DEEPLOY_CT.DEEPLOY_KEYS.NONCE] = nonce
+        # Send request
+        response = requests.post(f"{api_base_url}/{DEEPLOY_CT.DEEPLOY_REQUEST_PATHS.CREATE_PIPELINE}", json=request_body)
+        return response.json()
+      except Exception as e:
+        logger.P(f"Error during deeploy_simple_telegram_bot: {e}", color='r', show=True)
+        raise e
 
-        # Sign the payload using eth_sign_payload
-        signature = block_engine.eth_sign_payload(
-          payload=request_data[DEEPLOY_CT.DEEPLOY_KEYS.REQUEST],
-          indent=1,
-          no_hash=True,
-          message_prefix="Please sign this message for Deeploy: "
-        )
+    def deeploy_custom_code(self,
+                            signer_private_key_path: str,
+                            logger,
+                            custom_code=None,
+                            target_nodes=[],
+                            target_nodes_count=0,
+                            signer_private_key_password='',
+                            name="deeploy_custom_code",
+                            signature=PLUGIN_SIGNATURES.CUSTOM_EXEC_01,
+                            config={},
+                            ):
+      """
+      Deploy custom Python code on the Ratio1 Edge Protocol network using the Deeploy API.
+      Parameters
+      ----------
+      signer_private_key_path : str
+          Path to the PEM file containing the private key used for signing the deployment request
+          
+      logger : Logger
+          Logger instance for recording deployment activities and errors
+          
+      custom_code : callable
+          Python function to deploy. Must be a callable function that will be serialized and deployed to edge nodes.
+          The function will be validated for syntax errors before deployment.
+          
+      target_nodes : list, optional
+          List of specific node addresses to deploy the custom code to.
+          If empty, uses target_nodes_count instead. Defaults to []
+          
+      target_nodes_count : int, optional
+          Number of nodes to deploy to when target_nodes is not specified. Defaults to 0
+          
+      signer_private_key_password : str, optional
+          Password for the private key file if it's encrypted. Defaults to ''
+          
+      name : str, optional
+          Application alias/name for identification. Defaults to "deeploy_custom_code"
+          
+      signature : str, optional
+          The signature of the plugin that will be used. Defaults to PLUGIN_SIGNATURES.CUSTOM_EXEC_01
+          
+      config : dict, optional
+          Additional configuration parameters to pass to the deployed custom code.
+          These parameters will be available to the custom code at runtime. Defaults to {}
+
+      Returns
+      -------
+      dict
+          JSON response from the Deeploy API containing deployment status and details
 
+      """
+      if target_nodes_count == 0 and len(target_nodes) == 0:
+        raise ValueError("You must specify at least one target node to deploy the container app.")
+
+      #####################################################
+
+      assert callable(custom_code), "The `custom_code` method parameter must be provided."
+
+      base_code_checker_inst = BaseCodeChecker()
+
+      plain_code = base_code_checker_inst.get_function_source_code(custom_code)
+      custom_code_base64, error_messages = base_code_checker_inst.code_to_base64(plain_code, return_errors=True)
+      if error_messages:
+        raise ValueError(f"Custom code has errors: {error_messages}")
+      #####################################################
+      app_params = {
+        DEEPLOY_CT.DEEPLOY_KEYS.APP_PARAMS_CODE: custom_code_base64,
+        **config
+      }
+
+      api_base_url, request_body = self.__generate_deeploy_request(
+        logger=logger,
+        signer_private_key_path=signer_private_key_path,
+        signer_private_key_password=signer_private_key_password,
+        app_alias=name,
+        signature=signature,
+        target_nodes=target_nodes,
+        target_nodes_count=target_nodes_count,
+        app_params=app_params
+      )
+
+      try:
         # Send request
-        response = requests.post(f"{api_base_url}/{DEEPLOY_CT.DEEPLOY_REQUEST_PATHS.CREATE_PIPELINE}", json=request_data)
+        response = requests.post(f"{api_base_url}/{DEEPLOY_CT.DEEPLOY_REQUEST_PATHS.CREATE_PIPELINE}", json=request_body)
         return response.json()
       except Exception as e:
-        logger.P(f"Error during deeploy_launch_container_app: {e}", color='r', show=True)
+        logger.P(f"Error during deeploy_custom_code: {e}", color='r', show=True)
         raise e
 
+
     def deeploy_close(self, logger,
                       signer_private_key_path: str,
                       app_id: str,
@@ -3471,37 +3558,157 @@ class GenericSession(BaseDecentrAIObject):
       --------
       deeploy_launch_container_app : Deploy a new containerized application
       """
+
+
+      api_base_url, request_body = self.__generate_deeploy_request(
+        logger=logger,
+        signer_private_key_path=signer_private_key_path,
+        signer_private_key_password=signer_private_key_password,
+        request_params={
+          DEEPLOY_CT.DEEPLOY_KEYS.APP_ID: app_id,
+          DEEPLOY_CT.DEEPLOY_KEYS.TARGET_NODES: target_nodes,
+        }
+      )
+
+      endpoint = DEEPLOY_CT.DEEPLOY_REQUEST_PATHS.DELETE_PIPELINE
+      response = requests.post(f"{api_base_url}/{endpoint}", json=request_body)
+      return response.json()
+
+    def __generate_deeploy_request(self,
+                                   logger,
+                                   signer_private_key_path,
+                                   signer_private_key_password,
+                                   app_alias=None,
+                                   signature=None,
+                                   target_nodes=None,
+                                   target_nodes_count=0,
+                                   app_params={},
+                                   request_params={}):
+      """
+      Generate a signed Deeploy API request for deploying applications to edge nodes.
+      
+      This method creates a properly formatted and cryptographically signed request
+      that can be sent to the Deeploy API for deploying various types of applications
+      (containers, custom code, Telegram bots, etc.) to the Ratio1 Edge Protocol network.
+
+      Parameters
+      ----------
+      logger : Logger
+          Logger instance for recording request generation activities and errors
+          
+      signer_private_key_path : str
+          Path to the PEM file containing the private key used for signing the request
+          
+      signer_private_key_password : str
+          Password for the private key file if it's encrypted
+          
+      app_alias : str, optional
+          Application alias/name for identification in the Deeploy system.
+          Required for creation requests, not needed for deletion or query operations.
+          Defaults to None
+          
+      signature : str, optional
+          The plugin signature that identifies the type of application to deploy
+          (e.g., CONTAINER_APP_RUNNER, TELEGRAM_BASIC_BOT_01, CUSTOM_EXEC_01).
+          Required for creation requests, not needed for deletion or query operations.
+          Defaults to None
+          
+      target_nodes : list, optional
+          List of specific node addresses to deploy the application to.
+          If empty, uses target_nodes_count instead.
+          Required for creation requests, optional for other operations.
+          Defaults to None
+          
+      target_nodes_count : int, optional
+          Number of nodes to deploy to when target_nodes is not specified.
+          Used when you want Deeploy to automatically select nodes.
+          Defaults to 0
+          
+      app_params : dict, optional
+          Application-specific parameters that will be passed to the deployed application.
+          These parameters vary depending on the application type and signature.
+          Defaults to {}
+          
+      request_params : dict, optional
+          Additional parameters to include in the request payload.
+          These are typically metadata or configuration options for the deployment process.
+          Defaults to {}
+
+      Returns
+      -------
+      tuple
+          A tuple containing (api_base_url, request_body) where:
+          - api_base_url (str): The base URL for the Deeploy API endpoint
+          - request_body (dict): The complete signed request payload ready for HTTP transmission
+
+      Examples
+      --------
+      Generate a request for deploying a container application:
+      
+      >>> api_url, request = session.__generate_deeploy_request(
+      ...     logger=my_logger,
+      ...     signer_private_key_path="/path/to/private_key.pem",
+      ...     signer_private_key_password="",
+      ...     app_alias="my_web_app",
+      ...     signature="CONTAINER_APP_RUNNER",
+      ...     target_nodes=["node1_address", "node2_address"],
+      ...     target_nodes_count=0,
+      ...     app_params={"image": "nginx:latest", "port": 80}
+      ... )
+      
+      Generate a request for deleting an application (no signature/app_alias needed):
+      
+      >>> api_url, request = session.__generate_deeploy_request(
+      ...     logger=my_logger,
+      ...     signer_private_key_path="/path/to/private_key.pem",
+      ...     signer_private_key_password="",
+      ...     request_params={"app_id": "my_app_12345", "target_nodes": ["node1_address"]}
+      ... )
+      """
+
+      request_body = {DEEPLOY_CT.DEEPLOY_KEYS.REQUEST: {
+        DEEPLOY_CT.DEEPLOY_KEYS.TARGET_NODES_COUNT: target_nodes_count,
+        **request_params
+      }}
+
+      # Add creation-specific fields only if provided
+      if app_alias is not None:
+        request_body[DEEPLOY_CT.DEEPLOY_KEYS.REQUEST][DEEPLOY_CT.DEEPLOY_KEYS.APP_ALIAS] = app_alias
+      if signature is not None:
+        request_body[DEEPLOY_CT.DEEPLOY_KEYS.REQUEST][DEEPLOY_CT.DEEPLOY_KEYS.PLUGIN_SIGNATURE] = signature
+      if target_nodes is not None:
+        request_body[DEEPLOY_CT.DEEPLOY_KEYS.REQUEST][DEEPLOY_CT.DEEPLOY_KEYS.TARGET_NODES] = target_nodes
+      if app_params:
+        request_body[DEEPLOY_CT.DEEPLOY_KEYS.REQUEST][DEEPLOY_CT.DEEPLOY_KEYS.APP_PARAMS] = app_params
+
+      # Check if PK exists
+      if not os.path.isfile(signer_private_key_path):
+        raise ValueError("Private key path is not valid.")
+
       # Create a block engine instance with the private key
       block_engine = DefaultBlockEngine(
         log=logger,
-        name="deeploy_close",
+        name="deeploy_request_block_engine",
         config={
           BCct.K_PEM_FILE: signer_private_key_path,
           BCct.K_PASSWORD: signer_private_key_password,
         }
       )
 
-      current_network, api_base_url = self.__validate_deeploy_network_and_get_api_url(block_engine)
-
-      endpoint = DEEPLOY_CT.DEEPLOY_REQUEST_PATHS.DELETE_PIPELINE
-      request_data = {DEEPLOY_CT.DEEPLOY_KEYS.REQUEST: {}}
-      request_data[DEEPLOY_CT.DEEPLOY_KEYS.REQUEST][DEEPLOY_CT.DEEPLOY_KEYS.APP_ID] = app_id
-      request_data[DEEPLOY_CT.DEEPLOY_KEYS.REQUEST][DEEPLOY_CT.DEEPLOY_KEYS.TARGET_NODES] = target_nodes
-
+      # Set the nonce for the request
       nonce = f"0x{int(time.time() * 1000):x}"
-      request_data[DEEPLOY_CT.DEEPLOY_KEYS.REQUEST][DEEPLOY_CT.DEEPLOY_KEYS.NONCE] = nonce
+      request_body[DEEPLOY_CT.DEEPLOY_KEYS.REQUEST][DEEPLOY_CT.DEEPLOY_KEYS.NONCE] = nonce
 
       # Sign the payload using eth_sign_payload
       block_engine.eth_sign_payload(
-        payload=request_data[DEEPLOY_CT.DEEPLOY_KEYS.REQUEST],
+        payload=request_body[DEEPLOY_CT.DEEPLOY_KEYS.REQUEST],
         indent=1,
         no_hash=True,
         message_prefix="Please sign this message for Deeploy: "
       )
 
-      response = requests.post(f"{api_base_url}/{endpoint}", json=request_data)
-      return response.json()
-
+      _, api_base_url = self.__validate_deeploy_network_and_get_api_url(block_engine)
+      return api_base_url, request_body
 
     def __is_assets_valid(self, assets, mandatory=True, raise_exception=True, default_field_values=None):
       if assets is None:

{ratio1-3.4.36 → ratio1-3.4.37}/ratio1/bc/evm.py

@@ -11,6 +11,7 @@ from eth_utils import keccak, to_checksum_address
 from eth_account.messages import encode_defunct
 
 from ..const.base import EE_VPN_IMPL_ENV_KEY, dAuth, BCctbase, ETHVarTypes, EVM_ABI_DATA
+from ..const.evm_net import EVM_NET_DATA, EvmNetData
 
 EE_VPN_IMPL = str(os.environ.get(EE_VPN_IMPL_ENV_KEY, False)).lower() in [
   'true', '1', 'yes', 'y', 't', 'on'
@@ -1291,4 +1292,19 @@ class _EVMMixin:
           "r1Balance": float(r1_balance),
         }
 
-      return balances
+      return balances
+
+
+  def get_deeploy_url(self):
+    """
+    Returns the deeploy URL from the environment or the network data
+
+    Returns
+    -------
+    str
+      the deeploy URL.
+
+    """
+    current_network = self.current_evm_network
+    deeploy_api_base_url = EVM_NET_DATA[current_network][EvmNetData.EE_DEEPLOY_API_URL_KEY]
+    return deeploy_api_base_url

{ratio1-3.4.36 → ratio1-3.4.37}/ratio1/cli/cli_commands.py

@@ -10,9 +10,9 @@ and it is used by cli.py
 """
 
 from ratio1.cli.nodes import (
-  get_nodes, get_supervisors, 
+  get_nodes, get_supervisors,
   restart_node, shutdown_node,
-  get_apps
+  get_apps, inspect_node
 )
 from ratio1.cli.oracles import get_availability, oracle_rollout
 from ratio1.utils.config import (
@@ -122,14 +122,16 @@ CLI_COMMANDS = {
         "func": restart_node,
         "description": "Restart a node",
         "params": {
-            "node": "The node to restart"
+            "node": "The node to restart",
+            "--ignore-peering": "Ignore peering when running the command (flag)",
         }
     },
     "shutdown": {
         "func": shutdown_node,
         "description": "Shutdown a node",
         "params": {
-            "node": "The node to shutdown"
+            "node": "The node to shutdown",
+            "--ignore-peering": "Ignore peering when running the command (flag)",
         }
     },
     "update": {
@@ -141,6 +143,14 @@ CLI_COMMANDS = {
     },
     "oracle-rollout": {
         "func": oracle_rollout,
-        "description": "Rollout update on all nodes in the network. The rollout order is seed nodes -> oracle nodes -> all other edge nodes. This command is needed when defining new environment variables in seed nodes, in order to make it available to all nodes in the network.",
-    }
+        "description": "Rollout update on all nodes in the network. The rollout order is seed nodes -> oracle nodes -> all other edge nodes. This command is needed when defining new environment variables in seed nodes, in order to make it available to all nodes in the network."
+    },
+    "inspect": {
+        "func": inspect_node,
+        "description": "Inspect a node by address or alias.",
+        "params": {
+            "node": "The node address or alias to inspect",
+            "--wide": "Display all available information (flag)"
+        }
+    },
 }

{ratio1-3.4.36 → ratio1-3.4.37}/ratio1/cli/nodes.py

@@ -211,8 +211,8 @@ def get_apps(args):
 def _send_command_to_node(args, command, ignore_not_found=False):
   node = args.node
   silent = not args.verbose   
+  ignore_peering = args.ignore_peering
 
-  
   t1 = time()
   df, _, _, _, _, sess = _get_netstats(
     silent=silent, online_only=True, return_session=True, all_info=True,
@@ -233,17 +233,21 @@ def _send_command_to_node(args, command, ignore_not_found=False):
     node_addr = df_found.Address.values[0]   
     log_with_color(f"{df_found}")
   else:
-    log_with_color("Node '{}' <{}> not found in network (toal {} nodes, {} peered).".format(
+    log_with_color("Node '{}' <{}> not found in network (total {} nodes, {} peered).".format(
       node, node_addr, df.shape[0], df.Peered.sum()), color='r'
     )
     node_addr = node
-    
+
+  if not peered and not ignore_peering:
+    log_with_color(f"Node '{node}' <{node_addr}> not peered, exiting...", color='r')
+    return
+
   if not peered:
     if found:
       log_with_color(f"Node '{node}' <{node_addr}> is not peered.", color='r')
     else:
       log_with_color(f"Node '{node}' <{node_addr}> may not accept this command.", color='r')
-    
+
   # TODO: currently this is based on node alias, but we should be based on node address
   #       and maybe even node alias
   if (found and peered) or ignore_not_found:
@@ -271,6 +275,7 @@ def restart_node(args):
       Arguments passed to the function.
   """
   node = args.node
+
   log_with_color(f"Attempting to restart node <{node}>", color='b')
   _send_command_to_node(args, COMMANDS.RESTART, ignore_not_found=True)
   return
@@ -286,7 +291,138 @@ def shutdown_node(args):
       Arguments passed to the function.
   """
   node = args.node
+
   log_with_color(f"Attempting to shutdown node <{node}>", color='b')
   _send_command_to_node(args, COMMANDS.STOP, ignore_not_found=True)
   return
 
+
+def inspect_node(args):
+  """
+  This function is used to inspect the node info.
+
+  Parameters
+  ----------
+  args : argparse.Namespace
+      Arguments passed to the function.
+  """
+  node = args.node
+  wide = args.wide
+  silent = not args.verbose
+
+  if not silent:
+    log_with_color(f"Inspecting node <{node}>", color='b')
+
+  from ratio1 import Session
+  session = Session(
+    silent=silent
+  )
+  try:
+    node_address = session.get_node_address(node)
+    last_hb = session.get_last_hb()
+    node_last_hb = last_hb.get(node_address)
+
+    if not node_last_hb:
+      # No last HB was found for specified Address, ETH Address or alias.
+      raise ValueError("Could not find a node by provided address/alias.")
+
+    # Display node stats from HB:
+    _display_node_stats_for_hb(node_last_hb, wide)
+
+  except Exception as e:
+    log_with_color(f"An error occurred while trying to get node info: {e}", color='r')
+  finally:
+    session.close()
+  return
+
+
+def _display_node_stats_for_hb(node_hb, wide=False):
+  """
+  Display main system information from node heartbeat data.
+  
+  Parameters
+  ----------
+  node_hb : dict
+      Node heartbeat data containing system information
+  wide: bool
+      If True, display all plugins.
+  """
+  from ratio1 import HEARTBEAT_DATA
+  from ratio1.utils.config import log_with_color
+  from ratio1.const.base import BCctbase
+  from ratio1 import PAYLOAD_DATA
+
+  # Extract basic node info
+  ee_id = node_hb.get(HEARTBEAT_DATA.EE_ID, 'Unknown')
+  node_addr = node_hb.get(HEARTBEAT_DATA.EE_ADDR, 'Unknown')
+  eth_addr = node_hb.get(BCctbase.ETH_SENDER, 'Unknown')
+  ee_version = node_hb.get(PAYLOAD_DATA.EE_VERSION, 'Unknown')
+  uptime = node_hb.get(HEARTBEAT_DATA.UPTIME, 0)
+  
+  # Display node header
+  log_with_color(f"\n=== Node Information ===", color='b')
+  log_with_color(f"Node alias: {ee_id}", color='g')
+  log_with_color(f"Address: {node_addr}", color='g')
+  log_with_color(f"ETH Address: {eth_addr}", color='g')
+  log_with_color(f"Edge Node Version: {ee_version}", color='g')
+  log_with_color(f"Uptime: {uptime:.1f} seconds ({uptime/3600:.1f} hours)", color='g')
+  
+  # CPU Information
+  cpu_info = node_hb.get(HEARTBEAT_DATA.CPU, 'Unknown')
+  cpu_cores = node_hb.get(HEARTBEAT_DATA.CPU_NR_CORES, 0)
+  cpu_used = node_hb.get(HEARTBEAT_DATA.CPU_USED, 0)
+  
+  log_with_color(f"\n=== CPU Information ===", color='b')
+  log_with_color(f"Processor: {cpu_info}", color='y')
+  log_with_color(f"Cores: {cpu_cores}", color='y')
+  log_with_color(f"Usage: {cpu_used:.1f}%", color='y')
+  
+  # Memory Information
+  total_memory = node_hb.get(HEARTBEAT_DATA.MACHINE_MEMORY, 0)
+  available_memory = node_hb.get(HEARTBEAT_DATA.AVAILABLE_MEMORY, 0)
+  process_memory = node_hb.get(HEARTBEAT_DATA.PROCESS_MEMORY, 0)
+  is_alert_ram = node_hb.get(HEARTBEAT_DATA.IS_ALERT_RAM, False)
+  
+  used_memory = total_memory - available_memory if total_memory and available_memory else 0
+  memory_usage_pct = (used_memory / total_memory * 100) if total_memory > 0 else 0
+  
+  log_with_color(f"\n=== Memory Information ===", color='b')
+  log_with_color(f"Total Memory: {total_memory:.2f} GB", color='y')
+  log_with_color(f"Available Memory: {available_memory:.2f} GB", color='y')
+  log_with_color(f"Used Memory: {used_memory:.2f} GB ({memory_usage_pct:.1f}%)", color='y')
+  log_with_color(f"Process Memory: {process_memory:.2f} GB", color='y')
+  if is_alert_ram:
+    log_with_color(f"RAM Alert: True", color='r')
+  
+  # Disk Information
+  total_disk = node_hb.get(HEARTBEAT_DATA.TOTAL_DISK, 0)
+  available_disk = node_hb.get(HEARTBEAT_DATA.AVAILABLE_DISK, 0)
+  
+  used_disk = total_disk - available_disk if total_disk and available_disk else 0
+  disk_usage_pct = (used_disk / total_disk * 100) if total_disk > 0 else 0
+  
+  log_with_color(f"\n=== Disk Information ===", color='b')
+  log_with_color(f"Total Disk: {total_disk:.2f} GB", color='y')
+  log_with_color(f"Available Disk: {available_disk:.2f} GB", color='y')
+  log_with_color(f"Used Disk: {used_disk:.2f} GB ({disk_usage_pct:.1f}%)", color='y')
+  
+  # Active Plugins
+  active_plugins = node_hb.get(HEARTBEAT_DATA.ACTIVE_PLUGINS, [])
+  log_with_color(f"\n=== Active Plugins ===", color='b')
+  log_with_color(f"Number of Active Plugins: {len(active_plugins)}", color='y')
+  
+  if active_plugins:
+    plugins_to_display = 99999 if wide else 5
+    for i, plugin in enumerate(active_plugins[:plugins_to_display]):  # Show first 5 plugins
+      stream_id = plugin.get(HEARTBEAT_DATA.ACTIVE_PLUGINS_INFO.STREAM_ID, 'Unknown')
+      signature = plugin.get(HEARTBEAT_DATA.ACTIVE_PLUGINS_INFO.SIGNATURE, 'Unknown')
+      instance_id = plugin.get(HEARTBEAT_DATA.ACTIVE_PLUGINS_INFO.INSTANCE_ID, 'Unknown')
+      total_payload = plugin.get(HEARTBEAT_DATA.ACTIVE_PLUGINS_INFO.TOTAL_PAYLOAD_COUNT, 0)
+      log_with_color(f"  {i+1}. {stream_id} {signature} ({instance_id}) - {total_payload} payloads", color='w')
+    
+    if len(active_plugins) > plugins_to_display:
+      log_with_color(f"  ... and {len(active_plugins) - plugins_to_display} more plugins", color='w')
+  
+  log_with_color(f"\n", color='w')  # Add final newline for spacing
+
+  return