astreum 0.1.19__py3-none-any.whl → 0.2.0__py3-none-any.whl

astreum/__init__.py

@@ -1,2 +1 @@
-from .machine import AstreumMachine
-from .node import Node
+from node import Node

astreum/{node → _node}/__init__.py

@@ -8,7 +8,7 @@ from .relay import Relay, Topic
 from ..machine import AstreumMachine
 from .utils import hash_data
 from .validation.block import Block
-from .storage import Storage
+from .storage.storage import Storage
 
 class Node:
     def __init__(self, config: dict):

astreum/{node → _node}/relay/envelope.py

@@ -34,7 +34,7 @@ import os
 from dataclasses import dataclass
 from typing import Optional, Tuple, List
 from .message import Message, Topic
-from astreum.utils.bytes_format import encode, decode
+from astreum.format import encode, decode
 from ..utils import hash_data
 
 @dataclass

astreum/{node → _node}/relay/message.py

@@ -6,7 +6,7 @@ import struct
 from enum import IntEnum, auto
 from dataclasses import dataclass
 from typing import Optional
-from astreum.utils.bytes_format import encode, decode
+from astreum.format import encode, decode
 
 class Topic(IntEnum):
     """

astreum/{node → _node}/storage/merkle.py

@@ -1,7 +1,71 @@
 import blake3
 from .storage import Storage
-import astreum.utils.bytes_format as bytes_format bytes_format.decode, bytes_format.encode
+from astreum import format
 
+class MerkleNode:
+    def __init__(self, leaf: bool, data: bytes):
+        """
+        Initialize a Merkle node.
+        
+        For a leaf node, `data` is the actual content to be stored.
+        For an internal node, `data` should be the concatenation of the two child hashes.
+        
+        :param leaf: A boolean flag indicating whether this node is a leaf node (True) or an internal node (False).
+        :param data: The node's data. For leaves, the stored data; for internal nodes, concatenated child hashes.
+        """
+        self.leaf = leaf
+        self.data = data
+        self._hash = None  # Cached hash value to avoid recomputation.
+
+    @classmethod
+    def from_bytes(cls, data: bytes) -> 'MerkleNode':
+        """
+        Deserialize a MerkleNode from its byte representation.
+        
+        The input bytes are expected to be in the Astreum format, containing a leaf flag and node data.
+        
+        :param data: The serialized node data.
+        :return: A new MerkleNode instance.
+        """
+        leaf_flag, node_data = format.decode(data)
+        return cls(True if leaf_flag == 1 else False, node_data)
+
+    @classmethod
+    def from_storage(cls, storage: Storage, hash_value: bytes) -> 'MerkleNode' or None:
+        """
+        Retrieve and deserialize a MerkleNode from storage using its hash.
+        
+        :param storage: The Storage instance used to retrieve the node.
+        :param hash_value: The hash key under which the node is stored.
+        :return: A MerkleNode instance if found, otherwise None.
+        """
+        node_bytes = storage.get(hash_value)
+        if node_bytes is None:
+            return None
+        return cls.from_bytes(node_bytes)
+
+    def to_bytes(self) -> bytes:
+        """
+        Serialize the MerkleNode into bytes using the Astreum format.
+        
+        The format encodes a list containing the leaf flag and the node data.
+        
+        :return: The serialized bytes representing the node.
+        """
+        return format.encode([1 if self.leaf else 0, self.data])
+
+    def hash(self) -> bytes:
+        """
+        Compute (or retrieve a cached) hash of the node using the Blake3 algorithm.
+        
+        For leaf nodes, the hash is computed over the actual data.
+        For internal nodes, the hash is computed over the concatenated child hashes.
+        
+        :return: The Blake3 digest of the node's data.
+        """
+        if self._hash is None:
+            self._hash = blake3.blake3(self.data).digest()
+        return self._hash
 
 
 class MerkleTree:
@@ -158,67 +222,3 @@ class MerkleTree:
             return new_node_hash
 
 
-class MerkleNode:
-    def __init__(self, leaf: bool, data: bytes):
-        """
-        Initialize a Merkle node.
-        
-        For a leaf node, `data` is the actual content to be stored.
-        For an internal node, `data` should be the concatenation of the two child hashes.
-        
-        :param leaf: A boolean flag indicating whether this node is a leaf node (True) or an internal node (False).
-        :param data: The node's data. For leaves, the stored data; for internal nodes, concatenated child hashes.
-        """
-        self.leaf = leaf
-        self.data = data
-        self._hash = None  # Cached hash value to avoid recomputation.
-
-    @classmethod
-    def from_bytes(cls, data: bytes) -> 'MerkleNode':
-        """
-        Deserialize a MerkleNode from its byte representation.
-        
-        The input bytes are expected to be in the Astreum format, containing a leaf flag and node data.
-        
-        :param data: The serialized node data.
-        :return: A new MerkleNode instance.
-        """
-        leaf_flag, node_data = bytes_format.decode(data)
-        return cls(True if leaf_flag == 1 else False, node_data)
-
-    @classmethod
-    def from_storage(cls, storage: Storage, hash_value: bytes) -> 'MerkleNode' or None:
-        """
-        Retrieve and deserialize a MerkleNode from storage using its hash.
-        
-        :param storage: The Storage instance used to retrieve the node.
-        :param hash_value: The hash key under which the node is stored.
-        :return: A MerkleNode instance if found, otherwise None.
-        """
-        node_bytes = storage.get(hash_value)
-        if node_bytes is None:
-            return None
-        return cls.from_bytes(node_bytes)
-
-    def to_bytes(self) -> bytes:
-        """
-        Serialize the MerkleNode into bytes using the Astreum format.
-        
-        The format encodes a list containing the leaf flag and the node data.
-        
-        :return: The serialized bytes representing the node.
-        """
-        return bytes_format.encode([1 if self.leaf else 0, self.data])
-
-    def hash(self) -> bytes:
-        """
-        Compute (or retrieve a cached) hash of the node using the Blake3 algorithm.
-        
-        For leaf nodes, the hash is computed over the actual data.
-        For internal nodes, the hash is computed over the concatenated child hashes.
-        
-        :return: The Blake3 digest of the node's data.
-        """
-        if self._hash is None:
-            self._hash = blake3.blake3(self.data).digest()
-        return self._hash

astreum/{node → _node}/storage/patricia.py

@@ -1,7 +1,7 @@
 import blake3
 from typing import Optional, List
 from .storage import Storage
-import astreum.utils.bytes_format as bytes_format bytes_format.decode, bytes_format.encode
+import astreum.format as format format.decode, format.encode
 
 
 def common_prefix_length(a: bytes, b: bytes) -> int:
@@ -35,7 +35,7 @@ class PatriciaNode:
         Expected format: [key, value, children]
         where children is a list of child node hashes (bytes).
         """
-        decoded = bytes_format.decode(data)
+        decoded = format.decode(data)
         key, value, children = decoded
         return cls(key, value, children)
 
@@ -59,7 +59,7 @@ class PatriciaNode:
         
         Structure: [key, value, children]
         """
-        return bytes_format.encode([self.key, self.value, self.children])
+        return format.encode([self.key, self.value, self.children])
 
     def hash(self) -> bytes:
         """

astreum/{node → _node}/storage/storage.py

@@ -39,6 +39,8 @@ class Storage:
         self.pending_requests = {}  # hash -> (start_time, event)
         self.request_lock = threading.Lock()
 
+        
+
     def put(self, data_hash: bytes, data: bytes) -> bool:
         """Store data with its hash. Returns True if successful, False if space limit exceeded."""
         data_size = len(data)

astreum/{node → _node}/utils.py

@@ -4,7 +4,7 @@ Utility functions for the Astreum blockchain.
 
 import blake3
 
-def hash_data(data: bytes) -> bytes:
+def blake3_hash(data: bytes) -> bytes:
     """
     Hash data using BLAKE3.
     

astreum/{node → _node}/validation/account.py

@@ -1,7 +1,7 @@
 from typing import Optional
 from ..storage.patricia import PatriciaTrie
 
-import astreum.utils.bytes_format as bytes_format
+import astreum.format as format
 class Account:
     def __init__(self, public_key: bytes, balance: int, code: bytes, counter: int, data: bytes, secret_key: Optional[bytes] = None):
         """
@@ -30,7 +30,7 @@ class Account:
         
         The public_key (and optional secret_key) must be provided separately.
     """
-        decoded = bytes_format.decode(data)
+        decoded = format.decode(data)
         balance, code, counter, account_data = decoded
         return cls(public_key, balance, code, counter, account_data, secret_key=secret_key)
     
@@ -40,7 +40,7 @@ class Account:
         
         Format: [balance, code, counter, data]
         """
-        return bytes_format.encode([
+        return format.encode([
             self.balance,
             self.code,
             self.counter,

astreum/{node → _node}/validation/transaction.py

@@ -1,7 +1,7 @@
 from typing import Optional
 import time
 from .account import Account, get_account_from_storage
-import astreum.utils.bytes_format as bytes_format
+import astreum.format as format
 
 class Transaction:
     def __init__(
@@ -36,7 +36,7 @@ class Transaction:
         Returns:
             Transaction object
         """
-        decoded = bytes_format.decode(data)
+        decoded = format.decode(data)
         sender_public_key, recipient_public_key, amount, tx_data, counter, timestamp, signature = decoded
         
         sender_account = None
@@ -63,7 +63,7 @@ class Transaction:
         
         Format: [sender_hash, recipient_hash, amount, data, counter, timestamp, signature]
         """
-        return bytes_format.encode([
+        return format.encode([
             self.sender.public_key,
             self.recipient.public_key,
             self.amount,

astreum/lispeum/__init__.py

@@ -0,0 +1,2 @@
+from parser import parse
+from tokenizer import tokenize

astreum/lispeum/parser.py

@@ -1,6 +1,6 @@
 from typing import List, Tuple
 from astreum.machine.error import ParseError
-from astreum.lispeum.expression import Expr
+from astreum.node import Expr
 
 
 def parse(tokens: List[str]) -> Tuple[Expr, List[str]]:

astreum/machine/environment.py

@@ -2,28 +2,3 @@ from typing import Dict, Optional
 from astreum.lispeum.expression import Expr
 
 
-class Environment:
-    def __init__(self, parent: 'Environment' = None, node: 'Node' = None):
-        self.data: Dict[str, Expr] = {}
-        self.parent = parent
-        self.node = node
-
-    def set(self, name: str, value: Expr):
-        if self.node:
-            self.node.post_global_storage(name, value)
-        else:
-            self.data[name] = value
-
-    def get(self, name: str) -> Optional[Expr]:
-        if self.node:
-            return self.node.query_global_storage(name)
-
-        if name in self.data:
-            return self.data[name]
-        elif self.parent:
-            return self.parent.get(name)
-        else:
-            return None
-
-    def __repr__(self):
-        return f"Environment({self.data})"