astreum 0.2.36__py3-none-any.whl → 0.2.38__py3-none-any.whl

astreum/__init__.py

@@ -1 +1,9 @@
-from ._node import Node, Expr, Env, tokenize, parse
+"""Lightweight package initializer to avoid circular imports during tests.
+
+Exports are intentionally minimal; import submodules directly as needed:
+ - Node, Expr, Env, tokenize, parse -> from astreum._node or astreum.lispeum
+ - Validation types -> from astreum._validation
+ - Storage types -> from astreum._storage
+"""
+
+__all__: list[str] = []

astreum/_communication/__init__.py

@@ -0,0 +1,9 @@
+from .peer import Peer
+from .route import Route
+from .setup import communication_setup
+
+__all__ = [
+    "Peer",
+    "Route",
+    "communication_setup",
+]

astreum/_communication/peer.py

@@ -0,0 +1,11 @@
+from cryptography.hazmat.primitives.asymmetric.x25519 import X25519PrivateKey, X25519PublicKey
+from datetime import datetime, timezone
+
+class Peer:
+    shared_key: bytes
+    timestamp: datetime
+    latest_block: bytes
+
+    def __init__(self, my_sec_key: X25519PrivateKey, peer_pub_key: X25519PublicKey):
+        self.shared_key = my_sec_key.exchange(peer_pub_key)
+        self.timestamp = datetime.now(timezone.utc)

astreum/_communication/route.py

@@ -0,0 +1,25 @@
+from typing import Dict, List
+from cryptography.hazmat.primitives.asymmetric.x25519 import X25519PrivateKey, X25519PublicKey
+
+class Route:
+    def __init__(self, relay_public_key: X25519PublicKey, bucket_size: int = 16):
+        self.relay_public_key_bytes = relay_public_key.public_bytes(encoding=Encoding.Raw, format=PublicFormat.Raw)
+        self.bucket_size = bucket_size
+        self.buckets: Dict[int, List[X25519PublicKey]] = {
+            i: [] for i in range(len(self.relay_public_key_bytes) * 8)
+        }
+        self.peers = {}
+
+    @staticmethod
+    def _matching_leading_bits(a: bytes, b: bytes) -> int:
+        for byte_index, (ba, bb) in enumerate(zip(a, b)):
+            diff = ba ^ bb
+            if diff:
+                return byte_index * 8 + (8 - diff.bit_length())
+        return len(a) * 8
+
+    def add_peer(self, peer_public_key: X25519PublicKey):
+        peer_public_key_bytes = peer_public_key.public_bytes(encoding=Encoding.Raw, format=PublicFormat.Raw)
+        bucket_idx = self._matching_leading_bits(self.relay_public_key_bytes, peer_public_key_bytes)
+        if len(self.buckets[bucket_idx]) < self.bucket_size:
+            self.buckets[bucket_idx].append(peer_public_key)  

astreum/_communication/setup.py

@@ -0,0 +1,113 @@
+import socket, threading
+from queue import Queue
+from typing import Tuple, Optional
+from cryptography.hazmat.primitives.asymmetric import ed25519
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric.x25519 import (
+    X25519PrivateKey,
+    X25519PublicKey,
+)
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from .. import Node
+
+from .import Route
+
+def load_x25519(hex_key: Optional[str]) -> X25519PrivateKey:
+    """DH key for relaying (always X25519)."""
+    return 
+
+def load_ed25519(hex_key: Optional[str]) -> Optional[ed25519.Ed25519PrivateKey]:
+    """Signing key for validation (Ed25519), or None if absent."""
+    return ed25519.Ed25519PrivateKey.from_private_bytes(bytes.fromhex(hex_key)) \
+           if hex_key else None
+
+def make_routes(
+    relay_pk: X25519PublicKey,
+    val_sk: Optional[ed25519.Ed25519PrivateKey]
+) -> Tuple[Route, Optional[Route]]:
+    """Peer route (DH pubkey) + optional validation route (ed pubkey)."""
+    peer_rt = Route(relay_pk)
+    val_rt  = Route(val_sk.public_key()) if val_sk else None
+    return peer_rt, val_rt
+
+def setup_udp(
+    bind_port: int,
+    use_ipv6: bool
+) -> Tuple[socket.socket, int, Queue, threading.Thread, threading.Thread]:
+    fam  = socket.AF_INET6 if use_ipv6 else socket.AF_INET
+    sock = socket.socket(fam, socket.SOCK_DGRAM)
+    if use_ipv6:
+        sock.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 0)
+    sock.bind(("::" if use_ipv6 else "0.0.0.0", bind_port or 0))
+    port = sock.getsockname()[1]
+
+    q    = Queue()
+    pop  = threading.Thread(target=lambda: None, daemon=True)
+    proc = threading.Thread(target=lambda: None, daemon=True)
+    pop.start(); proc.start()
+    return sock, port, q, pop, proc
+
+def setup_outgoing(
+    use_ipv6: bool
+) -> Tuple[socket.socket, Queue, threading.Thread]:
+    fam  = socket.AF_INET6 if use_ipv6 else socket.AF_INET
+    sock = socket.socket(fam, socket.SOCK_DGRAM)
+    q    = Queue()
+    thr  = threading.Thread(target=lambda: None, daemon=True)
+    thr.start()
+    return sock, q, thr
+
+def make_maps():
+    """Empty lookup maps: peers and addresses."""
+    return 
+
+def communication_setup(node: "Node", config: dict):
+    node.use_ipv6              = config.get('use_ipv6', False)
+
+    # key loading
+    node.relay_secret_key      = load_x25519(config.get('relay_secret_key'))
+    node.validation_secret_key = load_ed25519(config.get('validation_secret_key'))
+
+    # derive pubs + routes
+    node.relay_public_key      = node.relay_secret_key.public_key()
+    node.validation_public_key = (
+        node.validation_secret_key.public_key().public_bytes(
+            encoding=serialization.Encoding.Raw,
+            format=serialization.PublicFormat.Raw,
+        )
+        if node.validation_secret_key
+        else None
+    )
+    node.peer_route, node.validation_route = make_routes(
+        node.relay_public_key,
+        node.validation_secret_key
+    )
+
+    # sockets + queues + threads
+    (node.incoming_socket,
+        node.incoming_port,
+        node.incoming_queue,
+        node.incoming_populate_thread,
+        node.incoming_process_thread
+    ) = setup_udp(config.get('incoming_port', 7373), node.use_ipv6)
+
+    (node.outgoing_socket,
+        node.outgoing_queue,
+        node.outgoing_thread
+    ) = setup_outgoing(node.use_ipv6)
+
+    # other workers & maps
+    node.object_request_queue = Queue()
+    node.peer_manager_thread  = threading.Thread(
+        target=node._relay_peer_manager,
+        daemon=True
+    )
+    node.peer_manager_thread.start()
+
+    node.peers, node.addresses = {}, {} # peers: Dict[X25519PublicKey,Peer], addresses: Dict[(str,int),X25519PublicKey]
+
+    # bootstrap pings
+    for addr in config.get('bootstrap', []):
+        node._send_ping(addr)

astreum/_lispeum/__init__.py

@@ -2,7 +2,7 @@ from .expression import Expr
 from .environment import Env
 from .low_evaluation import low_eval
 from .meter import Meter
-from .parser import parse
+from .parser import parse, ParseError
 from .tokenizer import tokenize
 
 __all__ = [
@@ -11,6 +11,6 @@ __all__ = [
     "low_eval",
     "Meter",
     "parse",
-    "tokenize"
+    "tokenize",
+    "ParseError",
 ]
-

astreum/_lispeum/environment.py

@@ -1,10 +1,13 @@
 from ast import Expr
 from typing import Dict, Optional
+import uuid
 
 
 class Env:
     def __init__(
         self,
-        data: Optional[Dict[str, Expr]] = None
+        data: Optional[Dict[str, Expr]] = None,
+        parent_id: Optional[uuid.UUID] = None,
     ):
-        self.data: Dict[bytes, Expr] = {} if data is None else data
+        self.data: Dict[bytes, Expr] = {} if data is None else data
+        self.parent_id = parent_id

astreum/_lispeum/expression.py

@@ -10,21 +10,21 @@ class Expr:
             if not self.elements:
                 return "()"
             inner = " ".join(str(e) for e in self.elements)
-            return f"({inner})"
+            return f"({inner} list)"
         
     class Symbol:
         def __init__(self, value: str):
             self.value = value
 
         def __repr__(self):
-            return self.value
+            return f"({self.value} symbol)"
         
-    class Byte:
-        def __init__(self, value: int):
+    class Bytes:
+        def __init__(self, value: bytes):
             self.value = value
 
         def __repr__(self):
-            return self.value
+            return f"({self.value} bytes)"
         
     class Error:
         def __init__(self, topic: str, origin: Optional['Expr'] = None):
@@ -33,5 +33,5 @@ class Expr:
 
         def __repr__(self):
             if self.origin is None:
-                return f'({self.topic} err)'
-            return f'({self.origin} {self.topic} err)'
+                return f'({self.topic} error)'
+            return f'({self.origin} {self.topic} error)'

astreum/_lispeum/high_evaluation.py

@@ -1,7 +1,9 @@
-from typing import List, Union
-import uuid
-
-from src.astreum._lispeum import Env, Expr, Meter
+from typing import List, Union
+import uuid
+
+from .environment import Env
+from .expression import Expr
+from .meter import Meter
 
 
 def high_eval(self, env_id: uuid.UUID, expr: Expr, meter = None) -> Expr:
@@ -125,9 +127,7 @@ def high_eval(self, env_id: uuid.UUID, expr: Expr, meter = None) -> Expr:
 
                 # Execute low-level code built from sk-body using the caller's meter
                 res = self.low_eval(code, meter=meter)
-                if isinstance(res, Expr.Error):
-                    return res
-                return Expr.ListExpr([Expr.Byte(b) for b in res])
+                return res
 
         # ---------- (... (body params fn))  HIGH-LEVEL CALL ----------
         if isinstance(tail, Expr.ListExpr):
@@ -174,4 +174,4 @@ def high_eval(self, env_id: uuid.UUID, expr: Expr, meter = None) -> Expr:
 
         # ---------- default: resolve each element and return list ----------
         resolved: List[Expr] = [self.high_eval(env_id, e, meter=meter) for e in expr.elements]
-        return Expr.ListExpr(resolved)
+        return Expr.ListExpr(resolved)

astreum/_lispeum/low_evaluation.py

@@ -1,5 +1,6 @@
-from typing import Dict, List, Union
-from src.astreum._lispeum import Expr, Meter
+from typing import Dict, List, Union
+from .expression import Expr
+from .meter import Meter
 
 def tc_to_int(b: bytes) -> int:
     """bytes -> int using two's complement (width = len(b)*8)."""
@@ -34,18 +35,19 @@ def nand_bytes(a: bytes, b: bytes) -> bytes:
     resu = (~(au & bu)) & mask
     return resu.to_bytes(w, "big", signed=False)
 
-def low_eval(self, code: List[bytes], meter: Meter) -> Union[bytes, Expr.Error]:
+def low_eval(self, code: List[bytes], meter: Meter) -> Expr:
         
         heap: Dict[bytes, bytes] = {}
 
         stack: List[bytes] = []
         pc = 0
 
-        while True:
-            if pc >= len(code):
-                if len(stack) != 1:
-                    return Expr.Error("bad stack")
-                return stack.pop()
+        while True:
+            if pc >= len(code):
+                if len(stack) != 1:
+                    return Expr.Error("bad stack")
+                # wrap successful result as an Expr.Bytes
+                return Expr.Bytes(stack.pop())
 
             tok = code[pc]
             pc += 1

astreum/_lispeum/parser.py

@@ -1,5 +1,5 @@
-from typing import List, Tuple
-from src.astreum._lispeum import Expr
+from typing import List, Tuple
+from src.astreum._lispeum import Expr
 
 class ParseError(Exception):
     pass
@@ -27,14 +27,30 @@ def _parse_one(tokens: List[str], pos: int = 0) -> Tuple[Expr, int]:
     if tok == ')':
         raise ParseError("unexpected ')'")
 
-    # try integer → Byte
-    try:
-        n = int(tok)
-        return Expr.Byte(n), pos + 1
-    except ValueError:
-        return Expr.Symbol(tok), pos + 1
+    # try integer → Bytes (variable-length two's complement)
+    try:
+        n = int(tok)
+        # encode as minimal-width signed two's complement, big-endian
+        def int_to_min_tc(v: int) -> bytes:
+            """Return the minimal-width signed two's complement big-endian
+            byte encoding of integer v. Width expands just enough so that
+            decoding with signed=True yields the same value and sign.
+            Example: 0 -> b"\x00", 127 -> b"\x7f", 128 -> b"\x00\x80".
+            """
+            if v == 0:
+                return b"\x00"
+            w = 1
+            while True:
+                try:
+                    return v.to_bytes(w, "big", signed=True)
+                except OverflowError:
+                    w += 1
+
+        return Expr.Bytes(int_to_min_tc(n)), pos + 1
+    except ValueError:
+        return Expr.Symbol(tok), pos + 1
 
 def parse(tokens: List[str]) -> Tuple[Expr, List[str]]:
     """Parse tokens into an Expr and return (expr, remaining_tokens)."""
     expr, next_pos = _parse_one(tokens, 0)
-    return expr, tokens[next_pos:]
+    return expr, tokens[next_pos:]

astreum/_node.py

@@ -1,126 +1,35 @@
 from __future__ import annotations
-from typing import Dict, List, Optional, Tuple, Union
+from typing import Dict, Optional
 import uuid
 import threading
 
-from src.astreum._lispeum import Env, Expr, Meter, low_eval
+from src.astreum._storage.atom import Atom
+from src.astreum._lispeum import Env, Expr, low_eval, parse, tokenize, ParseError
 
 def bytes_touched(*vals: bytes) -> int:
     """For metering: how many bytes were manipulated (max of operands)."""
     return max((len(v) for v in vals), default=1)
 
-from blake3 import blake3
-
-ZERO32 = b"\x00"*32
-
-def u64_le(n: int) -> bytes:
-    return int(n).to_bytes(8, "little", signed=False)
-
-def hash_bytes(b: bytes) -> bytes:
-    return blake3(b).digest()
-
-class Atom:
-    data: bytes
-    next: bytes
-    size: int
-
-    def __init__(self, data: bytes, next: bytes = ZERO32, size: Optional[int] = None):
-        self.data = data
-        self.next = next
-        self.size = len(data) if size is None else size
-
-    @staticmethod
-    def from_data(data: bytes, next_hash: bytes = ZERO32) -> "Atom":
-        return Atom(data=data, next=next_hash, size=len(data))
-
-    @staticmethod
-    def object_id_from_parts(data_hash: bytes, next_hash: bytes, size: int) -> bytes:
-        return blake3(data_hash + next_hash + u64_le(size)).digest()
-
-    def data_hash(self) -> bytes:
-        return hash_bytes(self.data)
-
-    def object_id(self) -> bytes:
-        return self.object_id_from_parts(self.data_hash(), self.next, self.size)
-
-    @staticmethod
-    def verify_metadata(object_id: bytes, size: int, next_hash: bytes, data_hash: bytes) -> bool:
-        return object_id == blake3(data_hash + next_hash + u64_le(size)).digest()
-
-    def to_bytes(self) -> bytes:
-        if len(self.next) != len(ZERO32):
-            raise ValueError("next must be 32 bytes")
-        return self.next + self.data
-
-    @staticmethod
-    def from_bytes(buf: bytes) -> "Atom":
-        if len(buf) < len(ZERO32):
-            raise ValueError("buffer too short for Atom header")
-        next_hash = buf[:len(ZERO32)]
-        data = buf[len(ZERO32):]
-        return Atom(data=data, next=next_hash, size=len(data))
-
-def u32_le(n: int) -> bytes:
-    return int(n).to_bytes(4, "little", signed=False)
-
-def expr_to_atoms(e: Expr) -> Tuple[bytes, List[Atom]]:
-    def sym(v: str) -> Tuple[bytes, List[Atom]]:
-        val = v.encode("utf-8")
-        val_atom = Atom.from_data(u32_le(len(val)) + val)
-        typ_atom = Atom.from_data(b"symbol", val_atom.object_id())
-        return typ_atom.object_id(), [val_atom, typ_atom]
-
-    def byt(v: int) -> Tuple[bytes, List[Atom]]:
-        val_atom = Atom.from_data(bytes([v & 0xFF]))
-        typ_atom = Atom.from_data(b"byte", val_atom.object_id())
-        return typ_atom.object_id(), [val_atom, typ_atom]
-
-    def err(topic: str, origin: Optional[Expr]) -> Tuple[bytes, List[Atom]]:
-        t = topic.encode("utf-8")
-        origin_hash, acc = (ZERO32, [])
-        if origin is not None:
-            origin_hash, acc = expr_to_atoms(origin)
-        val_atom = Atom.from_data(u32_le(len(t)) + t + origin_hash)
-        typ_atom = Atom.from_data(b"error", val_atom.object_id())
-        return typ_atom.object_id(), acc + [val_atom, typ_atom]
-
-    def lst(items: List[Expr]) -> Tuple[bytes, List[Atom]]:
-        acc: List[Atom] = []
-        child_hashes: List[bytes] = []
-        for it in items:
-            h, atoms = expr_to_atoms(it)
-            acc.extend(atoms)
-            child_hashes.append(h)
-        next_hash = ZERO32
-        elem_atoms: List[Atom] = []
-        for h in reversed(child_hashes):
-            a = Atom.from_data(h, next_hash)
-            next_hash = a.object_id()
-            elem_atoms.append(a)
-        elem_atoms.reverse()
-        head = next_hash
-        val_atom = Atom.from_data(u64_le(len(items)), head)
-        typ_atom = Atom.from_data(b"list", val_atom.object_id())
-        return typ_atom.object_id(), acc + elem_atoms + [val_atom, typ_atom]
-
-    if isinstance(e, Expr.Symbol):
-        return sym(e.value)
-    if isinstance(e, Expr.Byte):
-        return byt(e.value)
-    if isinstance(e, Expr.Error):
-        return err(e.topic, e.origin)
-    if isinstance(e, Expr.ListExpr):
-        return lst(e.elements)
-    raise TypeError("unknown Expr variant")
-
 class Node:
-    def __init__(self):
+    def __init__(self, config: dict):
         # Storage Setup
-        self.in_memory_storage: Dict[bytes, bytes] = {}
+        self.in_memory_storage: Dict[bytes, Atom] = {}
+        self.in_memory_storage_lock = threading.RLock()
         # Lispeum Setup
         self.environments: Dict[uuid.UUID, Env] = {}
         self.machine_environments_lock = threading.RLock()
         self.low_eval = low_eval
+        # Communication and Validation Setup (import lazily to avoid heavy deps during parsing tests)
+        try:
+            from astreum._communication import communication_setup  # type: ignore
+            communication_setup(node=self, config=config)
+        except Exception:
+            pass
+        try:
+            from astreum._validation import validation_setup  # type: ignore
+            validation_setup(node=self)
+        except Exception:
+            pass
 
     # ---- Env helpers ----
     def env_get(self, env_id: uuid.UUID, key: bytes) -> Optional[Expr]:
@@ -139,9 +48,11 @@ class Node:
             env.data[key] = value
             return True
 
-    # ---- Storage (persistent) ----
-    def _local_get(self, key: bytes) -> Optional[bytes]:
-        return self.in_memory_storage.get(key)
+    # Storage
+    def _local_get(self, key: bytes) -> Optional[Atom]:
+        with self.in_memory_storage_lock:
+            return self.in_memory_storage.get(key)
 
-    def _local_set(self, key: bytes, value: bytes) -> None:
-        self.in_memory_storage[key] = value
+    def _local_set(self, key: bytes, value: Atom) -> None:
+        with self.in_memory_storage_lock:
+            self.in_memory_storage[key] = value

astreum/_storage/__init__.py

@@ -0,0 +1,5 @@
+from .atom import Atom
+
+__all__ = [
+    "Atom",
+]

astreum/_storage/atom.py

@@ -0,0 +1,100 @@
+
+
+from typing import List, Optional, Tuple
+
+from .._lispeum.expression import Expr
+from blake3 import blake3
+
+ZERO32 = b"\x00"*32
+
+def u64_le(n: int) -> bytes:
+    return int(n).to_bytes(8, "little", signed=False)
+
+def hash_bytes(b: bytes) -> bytes:
+    return blake3(b).digest()
+
+class Atom:
+    data: bytes
+    next: bytes
+    size: int
+
+    def __init__(self, data: bytes, next: bytes = ZERO32, size: Optional[int] = None):
+        self.data = data
+        self.next = next
+        self.size = len(data) if size is None else size
+
+    @staticmethod
+    def from_data(data: bytes, next_hash: bytes = ZERO32) -> "Atom":
+        return Atom(data=data, next=next_hash, size=len(data))
+
+    @staticmethod
+    def object_id_from_parts(data_hash: bytes, next_hash: bytes, size: int) -> bytes:
+        return blake3(data_hash + next_hash + u64_le(size)).digest()
+
+    def data_hash(self) -> bytes:
+        return hash_bytes(self.data)
+
+    def object_id(self) -> bytes:
+        return self.object_id_from_parts(self.data_hash(), self.next, self.size)
+
+    @staticmethod
+    def verify_metadata(object_id: bytes, size: int, next_hash: bytes, data_hash: bytes) -> bool:
+        return object_id == blake3(data_hash + next_hash + u64_le(size)).digest()
+
+    def to_bytes(self) -> bytes:
+        return self.next + self.data
+
+    @staticmethod
+    def from_bytes(buf: bytes) -> "Atom":
+        if len(buf) < len(ZERO32):
+            raise ValueError("buffer too short for Atom header")
+        next_hash = buf[:len(ZERO32)]
+        data = buf[len(ZERO32):]
+        return Atom(data=data, next=next_hash, size=len(data))
+
+def expr_to_atoms(e: Expr) -> Tuple[bytes, List[Atom]]:
+    def symbol(value: str) -> Tuple[bytes, List[Atom]]:
+        val = value.encode("utf-8")
+        val_atom = Atom.from_data(data=val)
+        typ_atom = Atom.from_data(b"symbol", val_atom.object_id())
+        return typ_atom.object_id(), [val_atom, typ_atom]
+
+    def bytes(data: bytes) -> Tuple[bytes, List[Atom]]:
+        val_atom = Atom.from_data(data=data)
+        typ_atom = Atom.from_data(b"byte", val_atom.object_id())
+        return typ_atom.object_id(), [val_atom, typ_atom]
+
+    def err(topic: str, origin: Optional[Expr]) -> Tuple[bytes, List[Atom]]:
+        topic_bytes = topic.encode("utf-8")
+        topic_atom = Atom.from_data(data=topic_bytes)
+        typ_atom = Atom.from_data(data=b"error", next_hash=topic_atom.object_id())
+        return typ_atom.object_id(), [topic_atom, typ_atom]
+
+    def lst(items: List[Expr]) -> Tuple[bytes, List[Atom]]:
+        acc: List[Atom] = []
+        child_hashes: List[bytes] = []
+        for it in items:
+            h, atoms = expr_to_atoms(it)
+            acc.extend(atoms)
+            child_hashes.append(h)
+        next_hash = ZERO32
+        elem_atoms: List[Atom] = []
+        for h in reversed(child_hashes):
+            a = Atom.from_data(h, next_hash)
+            next_hash = a.object_id()
+            elem_atoms.append(a)
+        elem_atoms.reverse()
+        head = next_hash
+        val_atom = Atom.from_data(data=u64_le(len(items)), next_hash=head)
+        typ_atom = Atom.from_data(data=b"list", next_hash=val_atom.object_id())
+        return typ_atom.object_id(), acc + elem_atoms + [val_atom, typ_atom]
+
+    if isinstance(e, Expr.Symbol):
+        return symbol(e.value)
+    if isinstance(e, Expr.Bytes):
+        return bytes(e.value)
+    if isinstance(e, Expr.Error):
+        return err(e.topic, e.origin)
+    if isinstance(e, Expr.ListExpr):
+        return lst(e.elements)
+    raise TypeError("unknown Expr variant")

astreum/_validation/__init__.py

@@ -0,0 +1,12 @@
+from .block import Block
+from .chain import Chain
+from .fork import Fork
+from .setup import validation_setup
+
+
+__all__ = [
+    "Block",
+    "Chain",
+    "Fork",
+    "validation_setup",
+]