astreum 0.1.9__py3-none-any.whl → 0.1.12__py3-none-any.whl

astreum/machine/__init__.py

@@ -1,254 +1,352 @@
-import threading
-from typing import Dict, Optional
-import uuid
-
-from astreum.lispeum.special.definition import handle_definition
-from astreum.lispeum.special.list.all import handle_list_all
-from astreum.lispeum.special.list.any import handle_list_any
-from astreum.lispeum.special.list.fold import handle_list_fold
-from astreum.lispeum.special.list.get import handle_list_get
-from astreum.lispeum.special.list.insert import handle_list_insert
-from astreum.lispeum.special.list.map import handle_list_map
-from astreum.lispeum.special.list.position import handle_list_position
-from astreum.lispeum.special.list.remove import handle_list_remove
-from astreum.machine.environment import Environment
-from astreum.lispeum.expression import Expr
-from astreum.lispeum.tokenizer import tokenize
-from astreum.lispeum.parser import parse
-
-class AstreumMachine:
-    def __init__(self, node: 'Node' = None):
-        self.global_env = Environment(node=node)
-        self.sessions: Dict[str, Environment] = {}
-        self.lock = threading.Lock()
-         
-    
-    def create_session(self) -> str:
-        session_id = str(uuid.uuid4())
-        with self.lock:
-            self.sessions[session_id] = Environment(parent=self.global_env)
-        return session_id
-    
-    def terminate_session(self, session_id: str) -> bool:
-        with self.lock:
-            if session_id in self.sessions:
-                del self.sessions[session_id]
-                return True
-            else:
-                return False
-    
-    def get_session_env(self, session_id: str) -> Optional[Environment]:
-        with self.lock:
-            return self.sessions.get(session_id, None)
-    
-    def evaluate_code(self, code: str, session_id: str) -> Expr:
-        session_env = self.get_session_env(session_id)
-        if session_env is None:
-            raise ValueError(f"Session ID {session_id} not found.")
-        
-        try:
-            tkns = tokenize(input=code)
-            expr, _ = parse(tokens=tkns)
-            result = self.evaluate_expression(expr, session_env)
-            return result
-        
-        except Exception as e:
-            raise ValueError(e)
-    
-    def evaluate_expression(self, expr: Expr, env: Environment) -> Expr:
-        if isinstance(expr, Expr.Boolean) or isinstance(expr, Expr.Integer) or isinstance(expr, Expr.String) or isinstance(expr, Expr.Error):
-            return expr
-        
-        elif isinstance(expr, Expr.Symbol):
-            value = env.get(expr.value)
-            
-            if value:
-                return value
-            else:
-                return Expr.Error(
-                    category="NameError",
-                    message=f"Variable '{expr.value}' not found in environments."
-                )
-        
-        elif isinstance(expr, Expr.ListExpr):
-            
-            if len(expr.elements) == 0:
-                return expr 
-            
-            if len(expr.elements) == 1:
-                return self.evaluate_expression(expr=expr.elements[0], env=env)
-            
-            first = expr.elements[0]
-
-            if isinstance(first, Expr.Symbol):
-                
-                first_symbol_value = env.get(first.value)
-
-                if first_symbol_value and not isinstance(first_symbol_value, Expr.Function):
-                    evaluated_elements = [self.evaluate_expression(e, env) for e in expr.elements]
-                    return Expr.ListExpr(evaluated_elements)
-                
-                elif first.value == "def":
-                    return handle_definition(
-                        machine=self,
-                        args=expr.elements[1:],
-                        env=env
-                    )
-
-                # List
-                elif first.value == "list.new":
-                    return Expr.ListExpr([self.evaluate_expression(arg, env) for arg in expr.elements[1:]])
-
-                elif first.value == "list.get":
-                    args = expr.elements[1:]
-                    if len(args) != 2:
-                        return Expr.Error(
-                            category="SyntaxError",
-                            message="list.get expects exactly two arguments: a list and an index"
-                        )
-                    list_obj = self.evaluate_expression(args[0], env)
-                    index = self.evaluate_expression(args[1], env)
-                    return handle_list_get(self, list_obj, index, env)
-
-                elif first.value == "list.insert":
-                    args = expr.elements[1:]
-                    if len(args) != 3:
-                        return Expr.ListExpr([
-                            Expr.ListExpr([]),
-                            Expr.String("list.insert expects exactly three arguments: a list, an index, and a value")
-                        ])
-                    
-                    return handle_list_insert(
-                        list=self.evaluate_expression(args[0], env),
-                        index=self.evaluate_expression(args[1], env),
-                        value=self.evaluate_expression(args[2], env),
-                    )
-
-                elif first.value == "list.remove":
-                    args = expr.elements[1:]
-                    if len(args) != 2:
-                        return Expr.ListExpr([
-                            Expr.ListExpr([]),
-                            Expr.String("list.remove expects exactly two arguments: a list and an index")
-                        ])
-                    
-                    return handle_list_remove(
-                        list=self.evaluate_expression(args[0], env),
-                        index=self.evaluate_expression(args[1], env),
-                    )
-
-                elif first.value == "list.length":
-                    args = expr.elements[1:]
-                    if len(args) != 1:
-                        return Expr.ListExpr([
-                            Expr.ListExpr([]),
-                            Expr.String("list.length expects exactly one argument: a list")
-                        ])
-                    
-                    list_obj = self.evaluate_expression(args[0], env)
-                    if not isinstance(list_obj, Expr.ListExpr):
-                        return Expr.ListExpr([
-                            Expr.ListExpr([]),
-                            Expr.String("Argument must be a list")
-                        ])
-                    
-                    return Expr.ListExpr([
-                        Expr.Integer(len(list_obj.elements)),
-                        Expr.ListExpr([]) 
-                    ])
-
-                elif first.value == "list.fold":
-                    if len(args) != 3:
-                        return Expr.ListExpr([
-                            Expr.ListExpr([]),
-                            Expr.String("list.fold expects exactly three arguments: a list, an initial value, and a function")
-                        ])
-                    
-                    return handle_list_fold(
-                        machine=self,
-                        list=self.evaluate_expression(args[0], env),
-                        initial=self.evaluate_expression(args[1], env),
-                        func=self.evaluate_expression(args[2], env),
-                        env=env,
-                    )
-
-                elif first.value == "list.map":
-                    if len(args) != 2:
-                        return Expr.ListExpr([
-                            Expr.ListExpr([]),
-                            Expr.String("list.map expects exactly two arguments: a list and a function")
-                        ])
-                    
-                    return handle_list_map(
-                        machine=self,
-                        list=self.evaluate_expression(args[0], env),
-                        func=self.evaluate_expression(args[1], env),
-                        env=env,
-                    )
-
-                elif first.value == "list.position":
-                    if len(args) != 2:
-                        return Expr.ListExpr([
-                            Expr.ListExpr([]),
-                            Expr.String("list.position expects exactly two arguments: a list and a function")
-                        ])
-                    
-                    return handle_list_position(
-                        machine=self,
-                        list=self.evaluate_expression(args[0], env),
-                        predicate=self.evaluate_expression(args[1], env),
-                        env=env,
-                    )
-
-                elif first.value == "list.any":
-                    if len(args) != 2:
-                        return Expr.ListExpr([
-                            Expr.ListExpr([]),
-                            Expr.String("list.any expects exactly two arguments: a list and a function")
-                        ])
-                    
-                    return handle_list_any(
-                        machine=self,
-                        list=self.evaluate_expression(args[0], env),
-                        predicate=self.evaluate_expression(args[1], env),
-                        env=env,
-                    )
-
-                elif first.value == "list.all":
-                    if len(args) != 2:
-                        return Expr.ListExpr([
-                            Expr.ListExpr([]),
-                            Expr.String("list.all expects exactly two arguments: a list and a function")
-                        ])
-                    
-                    return handle_list_all(
-                        machine=self,
-                        list=self.evaluate_expression(args[0], env),
-                        predicate=self.evaluate_expression(args[1], env),
-                        env=env,
-                    )
-
-                # Number
-                elif first.value == "+":
-                    evaluated_args = [self.evaluate_expression(arg, env) for arg in expr.elements[1:]]
-
-                    # Check for non-integer arguments
-                    if not all(isinstance(arg, Expr.Integer) for arg in evaluated_args):
-                        return Expr.Error(
-                            category="TypeError",
-                            message="All arguments to + must be integers"
-                        )
-                    
-                    # Sum up the integer values
-                    result = sum(arg.value for arg in evaluated_args)
-                    return Expr.Integer(result)
-
-            else:
-                evaluated_elements = [self.evaluate_expression(e, env) for e in expr.elements]
-                return Expr.ListExpr(evaluated_elements)
-            
-        elif isinstance(expr, Expr.Function):
-            return expr
-        
-        else:
-            raise ValueError(f"Unknown expression type: {type(expr)}")
+import threading
+from typing import Dict, Optional
+import uuid
+
+from astreum.lispeum.special.definition import handle_definition
+from astreum.lispeum.special.list.all import handle_list_all
+from astreum.lispeum.special.list.any import handle_list_any
+from astreum.lispeum.special.list.fold import handle_list_fold
+from astreum.lispeum.special.list.get import handle_list_get
+from astreum.lispeum.special.list.insert import handle_list_insert
+from astreum.lispeum.special.list.map import handle_list_map
+from astreum.lispeum.special.list.position import handle_list_position
+from astreum.lispeum.special.list.remove import handle_list_remove
+from astreum.machine.environment import Environment
+from astreum.lispeum.expression import Expr
+from astreum.lispeum.tokenizer import tokenize
+from astreum.lispeum.parser import parse
+
+class AstreumMachine:
+    def __init__(self, node: 'Node' = None):
+        self.global_env = Environment(node=node)
+        self.sessions: Dict[str, Environment] = {}
+        self.lock = threading.Lock()
+         
+    
+    def create_session(self) -> str:
+        session_id = str(uuid.uuid4())
+        with self.lock:
+            self.sessions[session_id] = Environment(parent=self.global_env)
+        return session_id
+    
+    def terminate_session(self, session_id: str) -> bool:
+        with self.lock:
+            if session_id in self.sessions:
+                del self.sessions[session_id]
+                return True
+            else:
+                return False
+    
+    def get_session_env(self, session_id: str) -> Optional[Environment]:
+        with self.lock:
+            return self.sessions.get(session_id, None)
+    
+    def evaluate_code(self, code: str, session_id: str) -> Expr:
+        session_env = self.get_session_env(session_id)
+        if session_env is None:
+            raise ValueError(f"Session ID {session_id} not found.")
+        
+        try:
+            tkns = tokenize(input=code)
+            expr, _ = parse(tokens=tkns)
+            result = self.evaluate_expression(expr, session_env)
+            return result
+        
+        except Exception as e:
+            raise ValueError(e)
+    
+    def evaluate_expression(self, expr: Expr, env: Environment) -> Expr:
+        if isinstance(expr, Expr.Boolean) or isinstance(expr, Expr.Integer) or isinstance(expr, Expr.String) or isinstance(expr, Expr.Error):
+            return expr
+        
+        elif isinstance(expr, Expr.Symbol):
+            value = env.get(expr.value)
+            
+            if value:
+                return value
+            else:
+                return Expr.Error(
+                    category="NameError",
+                    message=f"Variable '{expr.value}' not found in environments."
+                )
+        
+        elif isinstance(expr, Expr.ListExpr):
+            
+            if len(expr.elements) == 0:
+                return expr 
+            
+            if len(expr.elements) == 1:
+                return self.evaluate_expression(expr=expr.elements[0], env=env)
+            
+            first = expr.elements[0]
+
+            if isinstance(first, Expr.Symbol):
+                
+                first_symbol_value = env.get(first.value)
+
+                if first_symbol_value and not isinstance(first_symbol_value, Expr.Function):
+                    evaluated_elements = [self.evaluate_expression(e, env) for e in expr.elements]
+                    return Expr.ListExpr(evaluated_elements)
+                
+                elif first.value == "def":
+                    return handle_definition(
+                        machine=self,
+                        args=expr.elements[1:],
+                        env=env
+                    )
+
+                # List
+                elif first.value == "list.new":
+                    return Expr.ListExpr([self.evaluate_expression(arg, env) for arg in expr.elements[1:]])
+
+                elif first.value == "list.get":
+                    args = expr.elements[1:]
+                    if len(args) != 2:
+                        return Expr.Error(
+                            category="SyntaxError",
+                            message="list.get expects exactly two arguments: a list and an index"
+                        )
+                    list_obj = self.evaluate_expression(args[0], env)
+                    index = self.evaluate_expression(args[1], env)
+                    return handle_list_get(self, list_obj, index, env)
+
+                elif first.value == "list.insert":
+                    args = expr.elements[1:]
+                    if len(args) != 3:
+                        return Expr.ListExpr([
+                            Expr.ListExpr([]),
+                            Expr.String("list.insert expects exactly three arguments: a list, an index, and a value")
+                        ])
+                    
+                    return handle_list_insert(
+                        list=self.evaluate_expression(args[0], env),
+                        index=self.evaluate_expression(args[1], env),
+                        value=self.evaluate_expression(args[2], env),
+                    )
+
+                elif first.value == "list.remove":
+                    args = expr.elements[1:]
+                    if len(args) != 2:
+                        return Expr.ListExpr([
+                            Expr.ListExpr([]),
+                            Expr.String("list.remove expects exactly two arguments: a list and an index")
+                        ])
+                    
+                    return handle_list_remove(
+                        list=self.evaluate_expression(args[0], env),
+                        index=self.evaluate_expression(args[1], env),
+                    )
+
+                elif first.value == "list.length":
+                    args = expr.elements[1:]
+                    if len(args) != 1:
+                        return Expr.ListExpr([
+                            Expr.ListExpr([]),
+                            Expr.String("list.length expects exactly one argument: a list")
+                        ])
+                    
+                    list_obj = self.evaluate_expression(args[0], env)
+                    if not isinstance(list_obj, Expr.ListExpr):
+                        return Expr.ListExpr([
+                            Expr.ListExpr([]),
+                            Expr.String("Argument must be a list")
+                        ])
+                    
+                    return Expr.ListExpr([
+                        Expr.Integer(len(list_obj.elements)),
+                        Expr.ListExpr([]) 
+                    ])
+
+                elif first.value == "list.fold":
+                    if len(args) != 3:
+                        return Expr.ListExpr([
+                            Expr.ListExpr([]),
+                            Expr.String("list.fold expects exactly three arguments: a list, an initial value, and a function")
+                        ])
+                    
+                    return handle_list_fold(
+                        machine=self,
+                        list=self.evaluate_expression(args[0], env),
+                        initial=self.evaluate_expression(args[1], env),
+                        func=self.evaluate_expression(args[2], env),
+                        env=env,
+                    )
+
+                elif first.value == "list.map":
+                    if len(args) != 2:
+                        return Expr.ListExpr([
+                            Expr.ListExpr([]),
+                            Expr.String("list.map expects exactly two arguments: a list and a function")
+                        ])
+                    
+                    return handle_list_map(
+                        machine=self,
+                        list=self.evaluate_expression(args[0], env),
+                        func=self.evaluate_expression(args[1], env),
+                        env=env,
+                    )
+
+                elif first.value == "list.position":
+                    if len(args) != 2:
+                        return Expr.ListExpr([
+                            Expr.ListExpr([]),
+                            Expr.String("list.position expects exactly two arguments: a list and a function")
+                        ])
+                    
+                    return handle_list_position(
+                        machine=self,
+                        list=self.evaluate_expression(args[0], env),
+                        predicate=self.evaluate_expression(args[1], env),
+                        env=env,
+                    )
+
+                elif first.value == "list.any":
+                    if len(args) != 2:
+                        return Expr.ListExpr([
+                            Expr.ListExpr([]),
+                            Expr.String("list.any expects exactly two arguments: a list and a function")
+                        ])
+                    
+                    return handle_list_any(
+                        machine=self,
+                        list=self.evaluate_expression(args[0], env),
+                        predicate=self.evaluate_expression(args[1], env),
+                        env=env,
+                    )
+
+                elif first.value == "list.all":
+                    if len(args) != 2:
+                        return Expr.ListExpr([
+                            Expr.ListExpr([]),
+                            Expr.String("list.all expects exactly two arguments: a list and a function")
+                        ])
+                    
+                    return handle_list_all(
+                        machine=self,
+                        list=self.evaluate_expression(args[0], env),
+                        predicate=self.evaluate_expression(args[1], env),
+                        env=env,
+                    )
+
+                # Number
+                elif first.value == "+":
+                    evaluated_args = [self.evaluate_expression(arg, env) for arg in expr.elements[1:]]
+
+                    # Check for non-integer arguments
+                    if not all(isinstance(arg, Expr.Integer) for arg in evaluated_args):
+                        return Expr.Error(
+                            category="TypeError",
+                            message="All arguments to + must be integers"
+                        )
+                    
+                    # Sum up the integer values
+                    result = sum(arg.value for arg in evaluated_args)
+                    return Expr.Integer(result)
+                
+                # Subtraction
+                elif first.value == "-":
+                    evaluated_args = [self.evaluate_expression(arg, env) for arg in expr.elements[1:]]
+
+                    # Check for non-integer arguments
+                    if not all(isinstance(arg, Expr.Integer) for arg in evaluated_args):
+                        return Expr.Error(
+                            category="TypeError",
+                            message="All arguments to - must be integers"
+                        )
+                    
+                    # With only one argument, negate it
+                    if len(evaluated_args) == 1:
+                        return Expr.Integer(-evaluated_args[0].value)
+                    
+                    # With multiple arguments, subtract all from the first
+                    result = evaluated_args[0].value
+                    for arg in evaluated_args[1:]:
+                        result -= arg.value
+                    
+                    return Expr.Integer(result)
+                
+                # Multiplication
+                elif first.value == "*":
+                    evaluated_args = [self.evaluate_expression(arg, env) for arg in expr.elements[1:]]
+
+                    # Check for non-integer arguments
+                    if not all(isinstance(arg, Expr.Integer) for arg in evaluated_args):
+                        return Expr.Error(
+                            category="TypeError",
+                            message="All arguments to * must be integers"
+                        )
+                    
+                    # Multiply all values
+                    result = 1
+                    for arg in evaluated_args:
+                        result *= arg.value
+                    
+                    return Expr.Integer(result)
+                
+                # Division (integer division)
+                elif first.value == "/":
+                    evaluated_args = [self.evaluate_expression(arg, env) for arg in expr.elements[1:]]
+
+                    # Check for non-integer arguments
+                    if not all(isinstance(arg, Expr.Integer) for arg in evaluated_args):
+                        return Expr.Error(
+                            category="TypeError",
+                            message="All arguments to / must be integers"
+                        )
+                    
+                    # Need exactly two arguments
+                    if len(evaluated_args) != 2:
+                        return Expr.Error(
+                            category="ArgumentError",
+                            message="The / operation requires exactly two arguments"
+                        )
+                    
+                    dividend = evaluated_args[0].value
+                    divisor = evaluated_args[1].value
+                    
+                    if divisor == 0:
+                        return Expr.Error(
+                            category="DivisionError",
+                            message="Division by zero"
+                        )
+                    
+                    return Expr.Integer(dividend // divisor)  # Integer division
+                
+                # Remainder (modulo)
+                elif first.value == "%":
+                    evaluated_args = [self.evaluate_expression(arg, env) for arg in expr.elements[1:]]
+
+                    # Check for non-integer arguments
+                    if not all(isinstance(arg, Expr.Integer) for arg in evaluated_args):
+                        return Expr.Error(
+                            category="TypeError",
+                            message="All arguments to % must be integers"
+                        )
+                    
+                    # Need exactly two arguments
+                    if len(evaluated_args) != 2:
+                        return Expr.Error(
+                            category="ArgumentError",
+                            message="The % operation requires exactly two arguments"
+                        )
+                    
+                    dividend = evaluated_args[0].value
+                    divisor = evaluated_args[1].value
+                    
+                    if divisor == 0:
+                        return Expr.Error(
+                            category="DivisionError",
+                            message="Modulo by zero"
+                        )
+                    
+                    return Expr.Integer(dividend % divisor)
+
+            else:
+                evaluated_elements = [self.evaluate_expression(e, env) for e in expr.elements]
+                return Expr.ListExpr(evaluated_elements)
+            
+        elif isinstance(expr, Expr.Function):
+            return expr
+        
+        else:
+            raise ValueError(f"Unknown expression type: {type(expr)}")

astreum/node/__init__.py

@@ -13,16 +13,17 @@ from astreum.lispeum.storage import store_expr, get_expr_from_storage
 
 class Node:
     def __init__(self, config: dict):
-        self.config = config
-        self.relay = Relay(config)
+        # Ensure config is a dictionary, but allow it to be None
+        self.config = config if config is not None else {}
+        self.relay = Relay(self.config)
         # Get the node_id from relay instead of generating our own
         self.node_id = self.relay.node_id
-        self.storage = Storage(config)
+        self.storage = Storage(self.config)
         self.storage.node = self  # Set the storage node reference to self
         
         # Latest block of the chain this node is following
         self.latest_block = None
-        self.followed_chain_id = config.get('followed_chain_id', None)
+        self.followed_chain_id = self.config.get('followed_chain_id', None)
         
         # Initialize machine
         self.machine = AstreumMachine(node=self)

astreum/node/models.py

@@ -15,8 +15,21 @@ class Storage:
     def __init__(self, config: dict):
         self.max_space = config.get('max_storage_space', 1024 * 1024 * 1024)  # Default 1GB
         self.current_space = 0
-        self.storage_path = Path(config.get('storage_path', 'storage'))
-        self.storage_path.mkdir(parents=True, exist_ok=True)
+        
+        # Check if storage_path is provided in config
+        storage_path = config.get('storage_path')
+        self.use_memory_storage = storage_path is None
+        
+        # Initialize in-memory storage if no path provided
+        self.memory_storage = {} if self.use_memory_storage else None
+        
+        # Only create storage path if not using memory storage
+        if not self.use_memory_storage:
+            self.storage_path = Path(storage_path)
+            self.storage_path.mkdir(parents=True, exist_ok=True)
+            # Calculate current space usage
+            self.current_space = sum(f.stat().st_size for f in self.storage_path.glob('*') if f.is_file())
+        
         self.max_object_recursion = config.get('max_object_recursion', 50)
         self.network_request_timeout = config.get('network_request_timeout', 5.0)  # Default 5 second timeout
         self.node = None  # Will be set by the Node after initialization
@@ -24,9 +37,6 @@ class Storage:
         # In-progress requests tracking
         self.pending_requests = {}  # hash -> (start_time, event)
         self.request_lock = threading.Lock()
-        
-        # Calculate current space usage
-        self.current_space = sum(f.stat().st_size for f in self.storage_path.glob('*') if f.is_file())
 
     def put(self, data_hash: bytes, data: bytes) -> bool:
         """Store data with its hash. Returns True if successful, False if space limit exceeded."""
@@ -34,6 +44,14 @@ class Storage:
         if self.current_space + data_size > self.max_space:
             return False
 
+        # If using memory storage, store in dictionary
+        if self.use_memory_storage:
+            if data_hash not in self.memory_storage:
+                self.memory_storage[data_hash] = data
+                self.current_space += data_size
+            return True
+
+        # Otherwise use file storage
         file_path = self.storage_path / data_hash.hex()
         
         # Don't store if already exists
@@ -54,6 +72,11 @@ class Storage:
 
     def _local_get(self, data_hash: bytes) -> Optional[bytes]:
         """Get data from local storage only, no network requests."""
+        # If using memory storage, get from dictionary
+        if self.use_memory_storage:
+            return self.memory_storage.get(data_hash)
+            
+        # Otherwise use file storage
         file_path = self.storage_path / data_hash.hex()
         if file_path.exists():
             return file_path.read_bytes()
@@ -144,6 +167,8 @@ class Storage:
 
     def contains(self, data_hash: bytes) -> bool:
         """Check if data exists in storage."""
+        if self.use_memory_storage:
+            return data_hash in self.memory_storage
         return (self.storage_path / data_hash.hex()).exists()
         
     def get_recursive(self, root_hash: bytes, max_depth: Optional[int] = None, 

{astreum-0.1.9.dist-info → astreum-0.1.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: astreum
-Version: 0.1.9
+Version: 0.1.12
 Summary: Python library to interact with the Astreum blockchain and its Lispeum virtual machine.
 Author-email: "Roy R. O. Okello" <roy@stelar.xyz>
 Project-URL: Homepage, https://github.com/astreum/lib
@@ -11,8 +11,8 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: pycryptodomex<4.0.0,>=3.14.1
-Requires-Dist: cryptography<40.0.0,>=39.0.0
+Requires-Dist: pycryptodomex==3.21.0
+Requires-Dist: cryptography==44.0.2
 
 # lib
 

{astreum-0.1.9.dist-info → astreum-0.1.12.dist-info}/RECORD

@@ -17,11 +17,11 @@ astreum/lispeum/special/list/position.py,sha256=1EcD5fzfjUCUhHCk8iotFoWdeE9Z2Rjj
 astreum/lispeum/special/list/remove.py,sha256=EPhkWFwyKG8HyWPheVvtxCvMaEGvODFUbx7h1fli_hg,690
 astreum/lispeum/special/number/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 astreum/lispeum/special/number/addition.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-astreum/machine/__init__.py,sha256=5Sx-_MEYFG-089q2G8JtLp9_ELiPYnYIXhagjy6C4w0,11048
+astreum/machine/__init__.py,sha256=GOdZl1tS9uIJHbq5WVcplifMDPDLQroX7CVew-K2YbA,15262
 astreum/machine/environment.py,sha256=K0084U6B7wwjrDZ9b2_7cEcbBzsB7UOy_Zpbrr7B3GY,834
 astreum/machine/error.py,sha256=MvqBaZZt33rNELNhUJ2lER3TE3aS8WVqsWF2hz2AwoA,38
-astreum/node/__init__.py,sha256=wvmMMACicwhJ-ipSLpR1rsEUXWuHaZ8fnsBCkUA_RA8,22387
-astreum/node/models.py,sha256=MScDCNEpR-SfaFsRSU567mVuZRhH1Lqc7gmlqb3j-nI,10980
+astreum/node/__init__.py,sha256=EdGMa9pargAdB7KzjKBkhuFJ3G3wZF2VeIGkYFOCLws,22497
+astreum/node/models.py,sha256=9Uf2_u55uxWG0ujjySvFJUO5Ub-EzlMnnMJWcgJHjHk,11980
 astreum/node/relay/__init__.py,sha256=gQNYDxllkjZqE6bvgPOYkKu3QHkjPFn11RvtP-BxtKI,13994
 astreum/node/relay/bucket.py,sha256=pcmollbbM-xeHlmDxLZnzvf0Ut-9v9RoN6SijYiQuu8,2893
 astreum/node/relay/envelope.py,sha256=TfkynttoPX7smvMV7xEAdtIlfz-Z-EZjuhZ826csZxA,10078
@@ -30,8 +30,8 @@ astreum/node/relay/peer.py,sha256=DlvTR9j0BZQ1dW-p_9UGgfLvQqwNdpNLMSCYEW4FhyI,58
 astreum/node/relay/route.py,sha256=fyOSsAe1mfsCVeN6LtQ_OEUEb1FiC5dobZBEJKNGU9U,5814
 astreum/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 astreum/utils/bytes_format.py,sha256=X4tG5GGPweNCE54bHYkLFiuLTbmpy5upO_s1Cef-MGA,2711
-astreum-0.1.9.dist-info/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
-astreum-0.1.9.dist-info/METADATA,sha256=giKzIaeLdFUp_6AKqh1YxeS3epMjYpzlT8Dya6Gg3uY,2956
-astreum-0.1.9.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-astreum-0.1.9.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
-astreum-0.1.9.dist-info/RECORD,,
+astreum-0.1.12.dist-info/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
+astreum-0.1.12.dist-info/METADATA,sha256=LnGyI9YKLRNRWLolnyuHDgg0MKPSyLSwJho4FCTg1to,2942
+astreum-0.1.12.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+astreum-0.1.12.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
+astreum-0.1.12.dist-info/RECORD,,