astreum 0.2.41__py3-none-any.whl → 0.3.1__py3-none-any.whl

astreum/_lispeum/high_evaluation.py

@@ -1,177 +0,0 @@
-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:
-
-        if meter is None:
-            meter = Meter()
-
-        # ---------- atoms ----------
-        if isinstance(expr, Expr.Error):
-            return expr
-
-        if isinstance(expr, Expr.Symbol):
-            bound = self.env_get(env_id, expr.value.encode())
-            if bound is None:
-                return Expr.Error(f"unbound symbol '{expr.value}'", origin=expr)
-            return bound
-
-        if not isinstance(expr, Expr.ListExpr):
-            return expr  # Expr.Byte or other literals passthrough
-
-        # ---------- empty / single ----------
-        if len(expr.elements) == 0:
-            return expr
-        if len(expr.elements) == 1:
-            return self.high_eval(env_id=env_id, expr=expr.elements[0], meter=meter)
-
-        tail = expr.elements[-1]
-
-        # ---------- (value name def) ----------
-        if isinstance(tail, Expr.Symbol) and tail.value == "def":
-            if len(expr.elements) < 3:
-                return Expr.Error("def expects (value name def)", origin=expr)
-            name_e = expr.elements[-2]
-            if not isinstance(name_e, Expr.Symbol):
-                return Expr.Error("def name must be symbol", origin=name_e)
-            value_e = expr.elements[-3]
-            value_res = self.high_eval(env_id=env_id, expr=value_e, meter=meter)
-            if isinstance(value_res, Expr.Error):
-                return value_res
-            self.env_set(env_id, name_e.value.encode(), value_res)
-            return value_res
-
-        # ---- LOW-LEVEL call: ( arg1 arg2 ... ( (body) sk ) ) ----
-        if isinstance(tail, Expr.ListExpr):
-            inner = tail.elements
-            if len(inner) >= 2 and isinstance(inner[-1], Expr.Symbol) and inner[-1].value == "sk":
-                body_expr = inner[-2]
-                if not isinstance(body_expr, Expr.ListExpr):
-                    return Expr.Error("sk body must be list", origin=body_expr)
-
-                # helper: turn an Expr into a contiguous bytes buffer
-                def to_bytes(v: Expr) -> Union[bytes, Expr.Error]:
-                    if isinstance(v, Expr.Byte):
-                        return bytes([v.value & 0xFF])
-                    if isinstance(v, Expr.ListExpr):
-                        # expect a list of Expr.Byte
-                        out: bytearray = bytearray()
-                        for el in v.elements:
-                            if isinstance(el, Expr.Byte):
-                                out.append(el.value & 0xFF)
-                            else:
-                                return Expr.Error("byte list must contain only Byte", origin=el)
-                        return bytes(out)
-                    if isinstance(v, Expr.Error):
-                        return v
-                    return Expr.Error("argument must resolve to Byte or (Byte ...)", origin=v)
-
-                # resolve ALL preceding args into bytes (can be Byte or List[Byte])
-                args_exprs = expr.elements[:-1]
-                arg_bytes: List[bytes] = []
-                for a in args_exprs:
-                    v = self.high_eval(env_id=env_id, expr=a, meter=meter)
-                    if isinstance(v, Expr.Error):
-                        return v
-                    vb = to_bytes(v)
-                    if isinstance(vb, Expr.Error):
-                        return vb
-                    arg_bytes.append(vb)
-
-                # build low-level code with $0-based placeholders ($0 = first arg)
-                code: List[bytes] = []
-
-                def emit(tok: Expr) -> Union[None, Expr.Error]:
-                    if isinstance(tok, Expr.Symbol):
-                        name = tok.value
-                        if name.startswith("$"):
-                            idx_s = name[1:]
-                            if not idx_s.isdigit():
-                                return Expr.Error("invalid sk placeholder", origin=tok)
-                            idx = int(idx_s)  # $0 is first
-                            if idx < 0 or idx >= len(arg_bytes):
-                                return Expr.Error("arity mismatch in sk placeholder", origin=tok)
-                            code.append(arg_bytes[idx])
-                            return None
-                        code.append(name.encode())
-                        return None
-
-                    if isinstance(tok, Expr.Byte):
-                        code.append(bytes([tok.value & 0xFF]))
-                        return None
-
-                    if isinstance(tok, Expr.ListExpr):
-                        rv = self.high_eval(env_id, tok, meter=meter)
-                        if isinstance(rv, Expr.Error):
-                            return rv
-                        rb = to_bytes(rv)
-                        if isinstance(rb, Expr.Error):
-                            return rb
-                        code.append(rb)
-                        return None
-
-                    if isinstance(tok, Expr.Error):
-                        return tok
-
-                    return Expr.Error("invalid token in sk body", origin=tok)
-
-                for t in body_expr.elements:
-                    err = emit(t)
-                    if isinstance(err, Expr.Error):
-                        return err
-
-                # Execute low-level code built from sk-body using the caller's meter
-                res = self.low_eval(code, meter=meter)
-                return res
-
-        # ---------- (... (body params fn))  HIGH-LEVEL CALL ----------
-        if isinstance(tail, Expr.ListExpr):
-            fn_form = tail
-            if (len(fn_form.elements) >= 3
-                and isinstance(fn_form.elements[-1], Expr.Symbol)
-                and fn_form.elements[-1].value == "fn"):
-
-                body_expr   = fn_form.elements[-3]
-                params_expr = fn_form.elements[-2]
-
-                if not isinstance(body_expr, Expr.ListExpr):
-                    return Expr.Error("fn body must be list", origin=body_expr)
-                if not isinstance(params_expr, Expr.ListExpr):
-                    return Expr.Error("fn params must be list", origin=params_expr)
-
-                params: List[bytes] = []
-                for p in params_expr.elements:
-                    if not isinstance(p, Expr.Symbol):
-                        return Expr.Error("fn param must be symbol", origin=p)
-                    params.append(p.value.encode())
-
-                args_exprs = expr.elements[:-1]
-                if len(args_exprs) != len(params):
-                    return Expr.Error("arity mismatch", origin=expr)
-
-                arg_bytes: List[bytes] = []
-                for a in args_exprs:
-                    v = self.high_eval(env_id, a, meter=meter)
-                    if isinstance(v, Expr.Error):
-                        return v
-                    if not isinstance(v, Expr.Byte):
-                        return Expr.Error("argument must resolve to Byte", origin=a)
-                    arg_bytes.append(bytes([v.value & 0xFF]))
-
-                # child env, bind params -> Expr.Byte
-                child_env = uuid.uuid4()
-                self.environments[child_env] = Env(parent_id=env_id)
-                for name_b, val_b in zip(params, arg_bytes):
-                    self.env_set(child_env, name_b, Expr.Byte(val_b[0]))
-
-                # evaluate HL body, metered from the top
-                return self.high_eval(child_env, body_expr, meter=meter)
-
-        # ---------- 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)

astreum/_lispeum/low_evaluation.py

@@ -1,123 +0,0 @@
-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)."""
-    if not b:
-        return 0
-    return int.from_bytes(b, "big", signed=True)
-
-def int_to_tc(n: int, width_bytes: int) -> bytes:
-    """int -> bytes (two's complement, fixed width)."""
-    if width_bytes <= 0:
-        return b"\x00"
-    return n.to_bytes(width_bytes, "big", signed=True)
-
-def min_tc_width(n: int) -> int:
-    """minimum bytes to store n in two's complement."""
-    if n == 0:
-        return 1
-    w = 1
-    while True:
-        try:
-            n.to_bytes(w, "big", signed=True)
-            return w
-        except OverflowError:
-            w += 1
-
-def nand_bytes(a: bytes, b: bytes) -> bytes:
-    """Bitwise NAND on two byte strings, zero-extending to max width."""
-    w = max(len(a), len(b), 1)
-    au = int.from_bytes(a.rjust(w, b"\x00"), "big", signed=False)
-    bu = int.from_bytes(b.rjust(w, b"\x00"), "big", signed=False)
-    mask = (1 << (w * 8)) - 1
-    resu = (~(au & bu)) & mask
-    return resu.to_bytes(w, "big", signed=False)
-
-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")
-                # wrap successful result as an Expr.Bytes
-                return Expr.Bytes(stack.pop())
-
-            tok = code[pc]
-            pc += 1
-
-            # ---------- ADD ----------
-            if tok == b"add":
-                if len(stack) < 2:
-                    return Expr.Error("underflow")
-                b_b = stack.pop()
-                a_b = stack.pop()
-                a_i = tc_to_int(a_b)
-                b_i = tc_to_int(b_b)
-                res_i = a_i + b_i
-                width = max(len(a_b), len(b_b), min_tc_width(res_i))
-                res_b = int_to_tc(res_i, width)
-                # charge for both operands' byte widths
-                if not meter.charge_bytes(len(a_b) + len(b_b)):
-                    return Expr.Error("meter limit")
-                stack.append(res_b)
-                continue
-
-            # ---------- NAND ----------
-            if tok == b"nand":
-                if len(stack) < 2:
-                    return Expr.Error("underflow")
-                b_b = stack.pop()
-                a_b = stack.pop()
-                res_b = nand_bytes(a_b, b_b)
-                # bitwise cost: 2 * max(len(a), len(b))
-                if not meter.charge_bytes(2 * max(len(a_b), len(b_b), 1)):
-                    return Expr.Error("meter limit")
-                stack.append(res_b)
-                continue
-
-            # ---------- JUMP ----------
-            if tok == b"jump":
-                if len(stack) < 1:
-                    return Expr.Error("underflow")
-                tgt_b = stack.pop()
-                if not meter.charge_bytes(1):
-                    return Expr.Error("meter limit")
-                tgt_i = tc_to_int(tgt_b)
-                if tgt_i < 0 or tgt_i >= len(code):
-                    return Expr.Error("bad jump")
-                pc = tgt_i
-                continue
-
-            # ---------- HEAP GET ----------
-            if tok == b"heap_get":
-                if len(stack) < 1:
-                    return Expr.Error("underflow")
-                key = stack.pop()
-                val = heap.get(key) or b""
-                # get cost: 1
-                if not meter.charge_bytes(1):
-                    return Expr.Error("meter limit")
-                stack.append(val)
-                continue
-
-            # ---------- HEAP SET ----------
-            if tok == b"heap_set":
-                if len(stack) < 2:
-                    return Expr.Error("underflow")
-                val = stack.pop()
-                key = stack.pop()
-                if not meter.charge_bytes(len(val)):
-                    return Expr.Error("meter limit")
-                heap[key] = val
-                continue
-
-            # if no opcode matched above, treat token as literal
-            # not an opcode → literal blob
-            stack.append(tok)

astreum/_lispeum/tokenizer.py

@@ -1,22 +0,0 @@
-from typing import List
-
-
-def tokenize(source: str) -> List[str]:
-    tokens: List[str] = []
-    cur: List[str] = []
-    for ch in source:
-        if ch.isspace():
-            if cur:
-                tokens.append("".join(cur))
-                cur = []
-            continue
-        if ch in ("(", ")"):
-            if cur:
-                tokens.append("".join(cur))
-                cur = []
-            tokens.append(ch)
-            continue
-        cur.append(ch)
-    if cur:
-        tokens.append("".join(cur))
-    return tokens

astreum/_node.py

@@ -1,58 +0,0 @@
-from __future__ import annotations
-from typing import Dict, Optional
-import uuid
-import threading
-
-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)
-
-class Node:
-    def __init__(self, config: dict):
-        # Storage Setup
-        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._consensus import consensus_setup  # type: ignore
-            consensus_setup(node=self)
-        except Exception:
-            pass
-
-    # ---- Env helpers ----
-    def env_get(self, env_id: uuid.UUID, key: bytes) -> Optional[Expr]:
-        cur = self.environments.get(env_id)
-        while cur is not None:
-            if key in cur.data:
-                return cur.data[key]
-            cur = self.environments.get(cur.parent_id) if cur.parent_id else None
-        return None
-
-    def env_set(self, env_id: uuid.UUID, key: bytes, value: Expr) -> bool:
-        with self.machine_environments_lock:
-            env = self.environments.get(env_id)
-            if env is None:
-                return False
-            env.data[key] = value
-            return True
-
-    # 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: Atom) -> None:
-        with self.in_memory_storage_lock:
-            self.in_memory_storage[key] = value

astreum/_storage/__init__.py

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

astreum/_storage/atom.py

@@ -1,117 +0,0 @@
-
-
-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")
-
-
-def bytes_list_to_atoms(values: List[bytes]) -> Tuple[bytes, List[Atom]]:
-    """Build a forward-ordered linked list of atoms from byte payloads.
-
-    Returns the head object's hash (ZERO32 if no values) and the atoms created.
-    """
-    next_hash = ZERO32
-    atoms: List[Atom] = []
-
-    for value in reversed(values):
-        atom = Atom.from_data(data=bytes(value), next_hash=next_hash)
-        atoms.append(atom)
-        next_hash = atom.object_id()
-
-    atoms.reverse()
-    return (next_hash if values else ZERO32), atoms

astreum/format.py

@@ -1,75 +0,0 @@
-def encode(iterable, encoder=lambda x: x):
-    """
-    Encode an iterable of items into a single bytes object, applying the
-    provided encoder function to each item to convert it into bytes.
-    
-    For each item (after applying encoder), we:
-      - Determine its length (n)
-      - Write a single byte to indicate how many bytes were used for the length:
-          0: n == 0
-          1: n <= 255
-          2: 256 <= n <= 65535
-          4: 65536 <= n <= 4294967295
-          8: n > 4294967295
-      - Write the little-endian encoding of n in the specified number of bytes (if n > 0)
-      - Append the item’s data
-    """
-    result = bytearray()
-    for item in iterable:
-        item_bytes = encoder(item)
-        n = len(item_bytes)
-        if n > 4294967295:
-            result.append(8)
-            result.extend(n.to_bytes(8, byteorder='little'))
-        elif n > 65535:
-            result.append(4)
-            result.extend(n.to_bytes(4, byteorder='little'))
-        elif n > 255:
-            result.append(2)
-            result.extend(n.to_bytes(2, byteorder='little'))
-        elif n > 0:
-            result.append(1)
-            result.extend(n.to_bytes(1, byteorder='little'))
-        else:
-            result.append(0)
-        result.extend(item_bytes)
-    return bytes(result)
-
-
-def decode(buffer, decoder=lambda x: x):
-    """
-    Decode a bytes buffer into a list of items, applying the provided decoder
-    function to convert the bytes into the desired type.
-    
-    The buffer is read sequentially:
-      - Read one byte that indicates how many bytes were used for the length.
-      - If this value is 0, then the item is empty.
-      - Otherwise, read that many bytes to get the item's length (as a little-endian integer).
-      - Then, slice the next 'length' bytes from the buffer to get the item data.
-      - Apply the decoder function to the item data before appending it.
-    
-    By default, the decoder is the identity function, so items are returned as bytes.
-    """
-    decoded_data = []
-    offset = 0
-    buf_len = len(buffer)
-    
-    while offset < buf_len:
-        length_type = buffer[offset]
-        offset += 1
-
-        if length_type == 0:
-            n = 0
-        else:
-            if offset + length_type > buf_len:
-                raise ValueError("Buffer too short for length field")
-            n = int.from_bytes(buffer[offset: offset+length_type], byteorder='little')
-            offset += length_type
-        
-        if offset + n > buf_len:
-            raise ValueError("Buffer is too short for item data")
-        item_data = buffer[offset:offset+n]
-        offset += n
-        decoded_data.append(decoder(item_data))
-        
-    return decoded_data