naeural-client 2.1.3__tar.gz → 2.1.5__tar.gz

{naeural_client-2.1.3 → naeural_client-2.1.5}/.github/workflows/python-publish.yml

@@ -8,7 +8,10 @@
 
 name: Publish Python 🐍 distributions 📦 to PyPI
 
-on: push
+on:
+  push:
+    branches:
+      - main
 
 jobs:
   build-n-publish:

{naeural_client-2.1.3 → naeural_client-2.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: naeural_client
-Version: 2.1.3
+Version: 2.1.5
 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

{naeural_client-2.1.3 → naeural_client-2.1.5}/naeural_client/_ver.py

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

{naeural_client-2.1.3 → naeural_client-2.1.5}/naeural_client/base/generic_session.py

@@ -9,7 +9,7 @@ from time import time as tm
 
 from ..base_decentra_object import BaseDecentrAIObject
 from ..bc import DefaultBlockEngine
-from ..const import COMMANDS, ENVIRONMENT, HB, PAYLOAD_DATA, STATUS_TYPE, PLUGIN_SIGNATURES
+from ..const import COMMANDS, ENVIRONMENT, HB, PAYLOAD_DATA, STATUS_TYPE, PLUGIN_SIGNATURES, BLOCKCHAIN_CONFIG
 from ..const import comms as comm_ct
 from ..io_formatter import IOFormatterWrapper
 from ..logging import Logger
@@ -44,11 +44,6 @@ class GenericSession(BaseDecentrAIObject):
       "CERT_PATH": None,
   }
 
-  BLOCKCHAIN_CONFIG = {
-      "PEM_FILE": "_pk_sdk.pem",
-      "PASSWORD": None,
-      "PEM_LOCATION": "data"
-  }
 
   def __init__(self, *,
                host=None,

{naeural_client-2.1.3 → naeural_client-2.1.5}/naeural_client/bc/base.py

@@ -39,6 +39,7 @@ class BCct:
   DEFAULT_INFO = '0xai handshake data'
   
   
+  
 class _DotDict(dict):
   __getattr__ = dict.__getitem__
   __setattr__ = dict.__setitem__
@@ -269,7 +270,7 @@ class BaseBlockEngine:
   _lock: Lock = Lock()
   __instances = {}
   
-  def __new__(cls, name, config, log, ensure_ascii_payloads=False, verbosity=1):
+  def __new__(cls, name, log, config, ensure_ascii_payloads=False, verbosity=1):
     with cls._lock:
       if name not in cls.__instances:
         instance = super(BaseBlockEngine, cls).__new__(cls)

{naeural_client-2.1.3 → naeural_client-2.1.5}/naeural_client/bc/ec.py

@@ -2,6 +2,7 @@ import base64
 import hashlib
 import os
 import binascii
+import zlib
 
 from cryptography.hazmat.primitives import hashes
 from cryptography.hazmat.primitives.asymmetric import ec
@@ -266,7 +267,15 @@ class BaseBCEllipticCurveEngine(BaseBlockEngine):
       print('derived-shared_key: ', base64.b64encode(derived_key))
     return derived_key
 
-  def encrypt(self, plaintext: str, receiver_address: str, info: str = BCct.DEFAULT_INFO, debug: bool = False):
+  def encrypt(
+    self, 
+    plaintext: str, 
+    receiver_address: str, 
+    compressed: bool = False,
+    embed_compressed: bool = False,
+    info: str = BCct.DEFAULT_INFO, 
+    debug: bool = False
+  ):
     """
     Encrypts plaintext using the sender's private key and receiver's public key, 
     then base64 encodes the output.
@@ -278,21 +287,43 @@ class BaseBCEllipticCurveEngine(BaseBlockEngine):
         
     plaintext : str
         The plaintext to encrypt.
+        
+    compressed : bool, optional
+        Whether to compress the plaintext before encryption. The default is False.
 
     Returns
     -------
     str
         The base64 encoded nonce and ciphertext.
     """
+    if compressed:
+      to_encrypt_data = zlib.compress(plaintext.encode())
+      compressed_flag = (1).to_bytes(1)
+    else:
+      to_encrypt_data = plaintext.encode()
+      compressed_flag = (0).to_bytes(1)
+      
     receiver_pk = self._address_to_pk(receiver_address)
     shared_key = self.__derive_shared_key(receiver_pk, info=info, debug=debug)
     aesgcm = AESGCM(shared_key)
     nonce = os.urandom(12)  # Generate a unique nonce for each encryption
-    ciphertext = aesgcm.encrypt(nonce, plaintext.encode(), None)
-    encrypted_data = nonce + ciphertext  # Prepend the nonce to the ciphertext
+    ciphertext = aesgcm.encrypt(nonce, to_encrypt_data, None)
+    if embed_compressed:
+      encrypted_data = nonce + compressed_flag + ciphertext
+    else:
+      encrypted_data = nonce + ciphertext  # Prepend the nonce to the ciphertext
+    #end if      
     return base64.b64encode(encrypted_data).decode()  # Encode to base64
 
-  def decrypt(self, encrypted_data_b64 : str, sender_address : str, info: str = BCct.DEFAULT_INFO, debug: bool = False):
+  def decrypt(
+    self, 
+    encrypted_data_b64 : str, 
+    sender_address : str, 
+    decompress: bool = False,
+    embed_compressed: bool = False,
+    info: str = BCct.DEFAULT_INFO, 
+    debug: bool = False
+  ):
     """
     Decrypts base64 encoded encrypted data using the receiver's private key.
 
@@ -303,7 +334,7 @@ class BaseBCEllipticCurveEngine(BaseBlockEngine):
         
     sender_address : str
         The sender's address.
-
+        
     Returns
     -------
     str
@@ -311,13 +342,27 @@ class BaseBCEllipticCurveEngine(BaseBlockEngine):
 
     """
     try:
+        
       sender_pk = self._address_to_pk(sender_address)
       encrypted_data = base64.b64decode(encrypted_data_b64)  # Decode from base64
-      nonce = encrypted_data[:12]  # Extract the nonce
-      ciphertext = encrypted_data[12:]  # The rest is the ciphertext
+      nonce = encrypted_data[:12]  # Extract the nonce      
+
+      if embed_compressed:
+        start_data = 13
+        compressed_flag_byte = encrypted_data[12:13]
+        compressed_flag = int.from_bytes(compressed_flag_byte, byteorder='big')
+      else:
+        start_data = 12
+        compressed_flag = None      
+
+      ciphertext = encrypted_data[start_data:]  # The rest is the ciphertext
       shared_key = self.__derive_shared_key(sender_pk, info=info, debug=debug)
       aesgcm = AESGCM(shared_key)
       plaintext = aesgcm.decrypt(nonce, ciphertext, None)
+            
+      if (embed_compressed and compressed_flag) or (not embed_compressed and decompress):
+        plaintext = zlib.decompress(plaintext)          
+      
       result = plaintext.decode()
     except Exception as exc:
       result = None

{naeural_client-2.1.3 → naeural_client-2.1.5}/naeural_client/const/__init__.py

@@ -4,7 +4,7 @@ from . import base as BASE_CT
 from . import payload as PAYLOAD_CT
 from .formatter import FORMATTER_DATA
 from .payload import STATUS_TYPE, PAYLOAD_DATA, COMMANDS, NOTIFICATION_CODES
-from .base import CONFIG_STREAM, BIZ_PLUGIN_DATA, PLUGIN_INFO
+from .base import CONFIG_STREAM, BIZ_PLUGIN_DATA, PLUGIN_INFO, BLOCKCHAIN_CONFIG
 from . import heartbeat as HB
 from .environment import ENVIRONMENT
 from .apps import PLUGIN_SIGNATURES

{naeural_client-2.1.3 → naeural_client-2.1.5}/naeural_client/const/base.py

@@ -1,6 +1,22 @@
 EE_ID = 'EE_ID'
 SB_ID = 'SB_ID'  # change to SB_ID = EE_ID post mod from sb to ee
 
+BLOCKCHAIN_CONFIG = {
+    "PEM_FILE": "_pk_sdk.pem",
+    "PASSWORD": None,
+    "PEM_LOCATION": "data"
+}
+
+class DCT_TYPES:
+  VOID_PIPELINE = 'Void'
+  NETWORK_LISTENER = 'NetworkListener'
+  METASTREAM_PIPELINE = 'MetaStream'
+  
+  
+class DCT_OPTIONS:
+  NETWORK_LISTENER_PATH_FILTER = "PATH_FILTER"
+  NETWORK_LISTENER_MESSAGE_FILTER = "MESSAGE_FILTER"
+  ADMIN_PIPELINE_VER = 'ADMIN_PIPELINE_VER'
 
 class CONFIG_STREAM:
   K_URL = 'URL'
@@ -22,7 +38,7 @@ class CONFIG_STREAM:
   K_PIPELINE_COMMAND = 'PIPELINE_COMMAND'
   K_USE_LOCAL_COMMS_ONLY = 'USE_LOCAL_COMMS_ONLY'
 
-  METASTREAM = 'MetaStream'
+  METASTREAM = DCT_TYPES.METASTREAM_PIPELINE
 
   INITIATOR_ID = K_INITIATOR_ID
   SESSION_ID = K_SESSION_ID
@@ -53,10 +69,14 @@ class CONFIG_STREAM:
 
   MANDATORY = [K_NAME, K_TYPE]
 
-  VOID_STREAM = 'VOID'
+  VOID_STREAM = DCT_TYPES.VOID_PIPELINE
+  
+  DEFAULT_ADMIN_PIPELINE_TYPE = DCT_TYPES.NETWORK_LISTENER
 
   NO_DATA_STREAMS = [VOID_STREAM]
-
+  
+  PIPELINE_OPTIONS = DCT_OPTIONS
+  PIPELINE_TYPES = DCT_TYPES
 
 class BIZ_PLUGIN_DATA:
   INSTANCE_ID = 'INSTANCE_ID'

{naeural_client-2.1.3 → naeural_client-2.1.5}/naeural_client/const/payload.py

@@ -181,6 +181,8 @@ class PAYLOAD_DATA:
   EE_SENDER = BC_CT.SENDER
   EE_HASH = BC_CT.HASH
   EE_SIGN = BC_CT.SIGN
+  
+  EE_DESTINATION = "EE_DEST"
 
   NOTIFICATION = 'NOTIFICATION'
   INFO = 'INFO'
@@ -188,3 +190,5 @@ class PAYLOAD_DATA:
   TAGS = 'TAGS'
 
   ID_TAGS = 'ID_TAGS'
+  
+  

{naeural_client-2.1.3 → naeural_client-2.1.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "naeural_client"
-version = "2.1.3"
+version = "2.1.5"
 authors = [
   { name="Stefan Saraev", email="saraevstefan@gmail.com" },
   { name="Andrei Ionut Damian", email="andrei.damian@me.com" },

{naeural_client-2.1.3 → naeural_client-2.1.5}/tutorials/.example_env

@@ -4,3 +4,5 @@ EE_PASSWORD=TODO: fill this variable
 EE_HOSTNAME=r9092118.ala.eu-central-1.emqxsl.com
 EE_PORT=8883
 EE_SECURED=true
+
+TARGET_NODE=0xai....

naeural_client-2.1.5/tutorials/ex11_telegram_blackjack_bot.py

@@ -0,0 +1,203 @@
+import os
+import time
+
+from naeural_client import Session, CustomPluginTemplate
+
+def reply(plugin, message: str, user: str):
+  # Define the deck of cards and their values
+  cards = ['2', '3', '4', '5', '6', '7', '8', '9', '10',
+           'Jack', 'Queen', 'King', 'Ace']
+  card_values = {
+    '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7,
+    '8': 8, '9': 9, '10': 10,
+    'Jack': 10, 'Queen': 10, 'King': 10,
+    'Ace': 11  # Ace is treated as 11 initially; we'll adjust as needed
+  }
+
+  # Initialize user state if not already present
+  if user not in plugin.obj_cache or plugin.obj_cache[user] is None:
+    plugin.obj_cache[user] = {
+      'state': 'NOT_STARTED',
+      'wins': 0,
+      'losses': 0
+    }
+
+  # Retrieve the user's game state
+  user_cache = plugin.obj_cache[user]
+  message = message.strip().lower()  # Normalize the input message
+
+  if user_cache.get('state') == 'NOT_STARTED':
+    if message == 'card' or message == 'start':
+      # Start a new game
+      user_cache['hand'] = []  # Initialize player's hand
+      user_cache['state'] = 'PLAYING'
+
+      # Deal the first card
+      card = plugin.np.random.choice(cards)
+      user_cache['hand'].append(card)
+
+      # Calculate hand value
+      total = 0
+      aces = 0  # Count of aces in hand
+      for c in user_cache['hand']:
+        if c == 'Ace':
+          aces += 1
+        else:
+          total += card_values[c]
+      # Adjust for aces
+      for _ in range(aces):
+        if total + 11 <= 21:
+          total += 11  # Count ace as 11 if it doesn't cause bust
+        else:
+          total += 1   # Otherwise, count ace as 1
+
+      # Return the initial game message
+      return (f"Welcome to a new game of Black Jack, you have a {card}. "
+              f"Your total is {total}. Type 'card' to get another card, or 'stop' to hold.")
+    else:
+      # Prompt user to start a new game
+      return "Welcome to Black Jack. Type 'card' to start a new game."
+
+  elif user_cache.get('state') == 'PLAYING':
+    if message == 'card':
+      # Player chooses to draw another card
+      card = plugin.np.random.choice(cards)
+      user_cache['hand'].append(card)
+
+      # Recalculate hand value
+      total = 0
+      aces = 0
+      for c in user_cache['hand']:
+        if c == 'Ace':
+          aces += 1
+        else:
+          total += card_values[c]
+      for _ in range(aces):
+        if total + 11 <= 21:
+          total += 11
+        else:
+          total += 1
+
+      hand_str = ', '.join(user_cache['hand'])  # Format hand as a string
+
+      if total > 21:
+        # Player busts
+        user_cache['state'] = 'BUST'
+        user_cache['losses'] += 1  # Increment losses
+        return (f"You are given a {card}. Your hand: {hand_str}. "
+                f"Your total is {total}. Bust! You lose.\n"
+                f"Total Wins: {user_cache['wins']}, Total Losses: {user_cache['losses']}")
+      elif total == 21:
+        # Player hits Black Jack
+        user_cache['state'] = 'BLACKJACK'
+        user_cache['wins'] += 1  # Increment wins
+        return (f"You are given a {card}. Black Jack! Congratulations, you win! "
+                f"Your hand: {hand_str}.\n"
+                f"Total Wins: {user_cache['wins']}, Total Losses: {user_cache['losses']}")
+      else:
+        # Continue playing
+        return (f"You are given a {card}. Your hand: {hand_str}. "
+                f"Your total is {total}. Type 'card' to get another card, or 'stop' to hold.")
+    elif message == 'stop':
+      # Player chooses to hold; dealer's turn
+      dealer_hand = []
+      dealer_total = 0
+      dealer_aces = 0
+
+      # Dealer draws cards until total >= 17
+      while True:
+        dealer_card = plugin.np.random.choice(cards)
+        dealer_hand.append(dealer_card)
+
+        # Update dealer's total
+        if dealer_card == 'Ace':
+          dealer_aces += 1
+        else:
+          dealer_total += card_values[dealer_card]
+
+        # Calculate dealer's total considering aces
+        temp_total = dealer_total
+        aces = dealer_aces
+        for _ in range(aces):
+          if temp_total + 11 <= 21:
+            temp_total += 11
+          else:
+            temp_total += 1
+
+        dealer_total_with_aces = temp_total
+
+        # Dealer stops hitting when total >= 17
+        if dealer_total_with_aces >= 17:
+          dealer_total = dealer_total_with_aces
+          break
+        else:
+          dealer_total = dealer_total_with_aces
+
+      # Calculate player's total
+      player_total = 0
+      player_aces = 0
+      for c in user_cache['hand']:
+        if c == 'Ace':
+          player_aces += 1
+        else:
+          player_total += card_values[c]
+      for _ in range(player_aces):
+        if player_total + 11 <= 21:
+          player_total += 11
+        else:
+          player_total += 1
+
+      user_cache['state'] = 'GAME_OVER'  # Update game state
+
+      # Determine the outcome
+      if dealer_total > 21:
+        result = "Dealer busts! You win!"
+        user_cache['wins'] += 1
+      elif player_total > dealer_total:
+        result = "You win!"
+        user_cache['wins'] += 1
+      elif player_total == dealer_total:
+        result = "It's a tie!"
+        # Ties are not counted as wins or losses
+      else:
+        result = "You lose!"
+        user_cache['losses'] += 1
+
+      player_hand_str = ', '.join(user_cache['hand'])
+      dealer_hand_str = ', '.join(dealer_hand)
+
+      # Return the game result with total wins and losses
+      return (f"You stopped with {player_total}. Your hand: {player_hand_str}.\n"
+              f"Dealer's hand: {dealer_hand_str} (Total: {dealer_total}).\n"
+              f"{result}\nTotal Wins: {user_cache['wins']}, Total Losses: {user_cache['losses']}")
+    else:
+      # Invalid input during playing
+      return "Invalid input. Please type 'card' to get another card, or 'stop' to hold."
+
+  elif user_cache.get('state') in ['BUST', 'BLACKJACK', 'GAME_OVER']:
+    # Game is over; reset state for a new game
+    user_cache['state'] = 'NOT_STARTED'
+    return "Game over. Type 'card' to start a new game."
+
+  else:
+    # Catch-all for unexpected state
+    return "An error occurred. Please start a new game."
+
+
+
+if __name__ == "__main__":
+  my_node = os.getenv("TARGET_NODE") # we can specify a node here, if we want to connect to a specific
+    
+  session = Session() # assume .env is available and will be used for the connection and tokens
+  session.wait_for_node(my_node) # wait for the node to be active
+    
+      
+  pipeline, _ = session.create_telegram_simple_bot(
+    node=my_node,
+    name="telegram_bot_blackjack",
+    message_handler=reply,
+  )
+  
+  pipeline.deploy() # we deploy the pipeline
+
+ 

naeural_client-2.1.5/xperimental/enc_dec_test.py

@@ -0,0 +1,66 @@
+import json
+
+from naeural_client import Logger, const
+from naeural_client.bc import DefaultBlockEngine
+
+
+
+if __name__ == '__main__' :
+  l = Logger("ENC", base_folder=".", app_folder="_local_cache")
+  eng1 = DefaultBlockEngine(
+    log=l, name="test1", 
+    config={
+        "PEM_FILE"     : "test1.pem",
+        "PASSWORD"     : None,      
+        "PEM_LOCATION" : "data"
+      }
+  )
+  eng2 = DefaultBlockEngine(
+    log=l, name="test2", 
+    config={
+        "PEM_FILE"     : "test2.pem",
+        "PASSWORD"     : None,      
+        "PEM_LOCATION" : "data"
+      }
+  )
+  
+  data = {
+    "test": "data1 data2 data3 data4 data5 data6 data7 data8 data9 data10",
+    "test2": "data21 data22 data23 data24 data25 data26 data27 data28 data29 data210",
+    "test3": "data31 data32 data33 data34 data35 data36 data37 data38 data39 data310",
+    "test4" : {
+      "test5": "data5 data6 data7 data8 data9 data10 data11 data12 data13 data14",
+      "test6": "data6 data7 data8 data9 data10 data11 data12 data13 data14 data15",
+      "test7": [
+        "data7",
+        {
+          "test9": "data91 data92 data93 data94 data95 data96 data97 data98 data99 data910",
+          "test10": "data10 data11 data12 data13 data14 data15 data16 data17 data18 data19 data110",
+        }
+      ]
+    }
+  }
+  
+  l.P("Non compressed test", color='g')  
+  str_data = json.dumps(data)
+  l.P(f"Data size: {len(str_data)}")  
+  encdata = eng1.encrypt(plaintext=str_data, receiver_address=eng2.address)
+  l.P(f"Encrypted data (size: {len(encdata)}): {encdata}")  
+  decdata = eng2.decrypt(encrypted_data_b64=encdata, sender_address=eng1.address)
+  l.P(f"Decrypted data:\n {json.dumps(json.loads(decdata), indent=2)}")
+  
+  l.P("Compressed test", color='g')  
+  str_data = json.dumps(data)
+  l.P(f"Data size: {len(str_data)}")  
+  encdata = eng1.encrypt(plaintext=str_data, receiver_address=eng2.address, compressed=True, embed_compressed=False)
+  l.P(f"Encrypted data (size: {len(encdata)}): {encdata}")  
+  decdata = eng2.decrypt(encrypted_data_b64=encdata, sender_address=eng1.address, decompress=True, embed_compressed=False)
+  l.P(f"Decrypted data:\n {json.dumps(json.loads(decdata), indent=2)}")  
+  
+  l.P("Compressed test with embed", color='g')  
+  str_data = json.dumps(data)
+  l.P(f"Data size: {len(str_data)}")  
+  encdata = eng1.encrypt(plaintext=str_data, receiver_address=eng2.address, compressed=True, embed_compressed=True)
+  l.P(f"Encrypted data (size: {len(encdata)}): {encdata}")  
+  decdata = eng2.decrypt(encrypted_data_b64=encdata, sender_address=eng1.address, embed_compressed=True) # decompress does not matter
+  l.P(f"Decrypted data:\n {json.dumps(json.loads(decdata), indent=2)}")