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

astreum/__init__.py

@@ -1 +1 @@
-from .node import Node, Expr
+from ._node import Node, Expr, Env, tokenize, parse

astreum/_lispeum/__init__.py

@@ -0,0 +1,16 @@
+from .expression import Expr
+from .environment import Env
+from .low_evaluation import low_eval
+from .meter import Meter
+from .parser import parse
+from .tokenizer import tokenize
+
+__all__ = [
+    "Env",
+    "Expr",
+    "low_eval",
+    "Meter",
+    "parse",
+    "tokenize"
+]
+

astreum/_lispeum/environment.py

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

astreum/_lispeum/expression.py

@@ -0,0 +1,37 @@
+from typing import List, Optional
+
+
+class Expr:
+    class ListExpr:
+        def __init__(self, elements: List['Expr']):
+            self.elements = elements
+        
+        def __repr__(self):
+            if not self.elements:
+                return "()"
+            inner = " ".join(str(e) for e in self.elements)
+            return f"({inner})"
+        
+    class Symbol:
+        def __init__(self, value: str):
+            self.value = value
+
+        def __repr__(self):
+            return self.value
+        
+    class Byte:
+        def __init__(self, value: int):
+            self.value = value
+
+        def __repr__(self):
+            return self.value
+        
+    class Error:
+        def __init__(self, topic: str, origin: Optional['Expr'] = None):
+            self.topic = topic
+            self.origin  = origin
+
+        def __repr__(self):
+            if self.origin is None:
+                return f'({self.topic} err)'
+            return f'({self.origin} {self.topic} err)'

astreum/_lispeum/high_evaluation.py

@@ -0,0 +1,177 @@
+from typing import List, Union
+import uuid
+
+from src.astreum._lispeum import Env, Expr, 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)
+                if isinstance(res, Expr.Error):
+                    return res
+                return Expr.ListExpr([Expr.Byte(b) for b in 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

@@ -0,0 +1,121 @@
+from typing import Dict, List, Union
+from src.astreum._lispeum import Expr, 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) -> Union[bytes, Expr.Error]:
+        
+        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()
+
+            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/meter.py

@@ -0,0 +1,18 @@
+from typing import Optional
+
+
+class Meter:
+    def __init__(self, enabled: bool = True, limit: Optional[int] = None):
+        self.enabled = enabled
+        self.limit: Optional[int] = limit
+        self.used: int = 0
+
+    def charge_bytes(self, n: int) -> bool:
+        if not self.enabled:
+            return True
+        if n < 0:
+            n = 0
+        if self.limit is not None and (self.used + n) >= self.limit:
+            return False
+        self.used += n
+        return True

astreum/_lispeum/parser.py

@@ -0,0 +1,40 @@
+from typing import List, Tuple
+from src.astreum._lispeum import Expr
+
+class ParseError(Exception):
+    pass
+
+def _parse_one(tokens: List[str], pos: int = 0) -> Tuple[Expr, int]:
+    if pos >= len(tokens):
+        raise ParseError("unexpected end")
+    tok = tokens[pos]
+
+    if tok == '(':  # list
+        items: List[Expr] = []
+        i = pos + 1
+        while i < len(tokens):
+            if tokens[i] == ')':
+                # special-case error form at close: (origin topic err) or (topic err)
+                if len(items) >= 3 and isinstance(items[-1], Expr.Symbol) and items[-1].value == 'err' and isinstance(items[-2], Expr.Symbol):
+                    return Expr.Error(items[-2].value, origin=items[-3]), i + 1
+                if len(items) == 2 and isinstance(items[-1], Expr.Symbol) and items[-1].value == 'err' and isinstance(items[-2], Expr.Symbol):
+                    return Expr.Error(items[-2].value), i + 1
+                return Expr.ListExpr(items), i + 1
+            expr, i = _parse_one(tokens, i)
+            items.append(expr)
+        raise ParseError("expected ')'")
+
+    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
+
+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:]

astreum/_lispeum/tokenizer.py

@@ -0,0 +1,22 @@
+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

@@ -3,116 +3,124 @@ from typing import Dict, List, Optional, Tuple, Union
 import uuid
 import threading
 
-# ===============================
-# 1. Helpers (no decoding, two's complement)
-# ===============================
-
-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)
+from src.astreum._lispeum import Env, Expr, Meter, low_eval
 
 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)
 
-# ===============================
-# 2. Structures
-# ===============================
-
-class Expr:
-    class ListExpr:
-        def __init__(self, elements: List['Expr']):
-            self.elements = elements
-        
-        def __repr__(self):
-            if not self.elements:
-                return "()"
-            inner = " ".join(str(e) for e in self.elements)
-            return f"({inner})"
-        
-    class Symbol:
-        def __init__(self, value: str):
-            self.value = value
-
-        def __repr__(self):
-            return self.value
-        
-    class Byte:
-        def __init__(self, value: int):
-            self.value = value
-
-        def __repr__(self):
-            return self.value
-        
-    class Error:
-        def __init__(self, topic: str, origin: Optional['Expr'] = None):
-            self.topic = topic
-            self.origin  = origin
-
-        def __repr__(self):
-            if self.origin is None:
-                return f'({self.topic} err)'
-            return f'({self.origin} {self.topic} err)'
-
-class Env:
-    def __init__(
-        self,
-        data: Optional[Dict[str, Expr]] = None,
-        parent_id: Optional[uuid.UUID] = None,
-    ):
-        self.data: Dict[bytes, Expr] = {} if data is None else data
-        self.parent_id = parent_id
-
-class Meter:
-    def __init__(self, enabled: bool = True, limit: Optional[int] = None):
-        self.enabled = enabled
-        self.limit: Optional[int] = limit
-        self.used: int = 0
-
-    def charge_bytes(self, n: int) -> bool:
-        if not self.enabled:
-            return True
-        if n < 0:
-            n = 0
-        if self.limit is not None and (self.used + n) >= self.limit:
-            return False
-        self.used += n
-        return True
+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):
-        self.environments: Dict[uuid.UUID, Env] = {}
+        # Storage Setup
         self.in_memory_storage: Dict[bytes, bytes] = {}
+        # Lispeum Setup
+        self.environments: Dict[uuid.UUID, Env] = {}
         self.machine_environments_lock = threading.RLock()
+        self.low_eval = low_eval
 
     # ---- Env helpers ----
     def env_get(self, env_id: uuid.UUID, key: bytes) -> Optional[Expr]:
@@ -137,356 +145,3 @@ class Node:
 
     def _local_set(self, key: bytes, value: bytes) -> None:
         self.in_memory_storage[key] = value
-
-    # ---- Eval ----
-    def low_eval(self, code: List[bytes], meter: Meter) -> Union[bytes, Expr.Error]:
-        
-        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()
-
-            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
-
-            # ---------- STORAGE GET ----------
-            if tok == b"storage_get":
-                if len(stack) < 1:
-                    return Expr.Error("underflow")
-                key = stack.pop()
-                val = self._local_get(key) or b""
-                if not meter.charge_bytes(1):
-                    return Expr.Error("meter limit")
-                stack.append(val)
-                continue
-
-            # ---------- STORAGE SET ----------
-            if tok == b"storage_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")
-                self._local_set(key, val)
-                continue
-
-            # if no opcode matched above, treat token as literal
-
-            # not an opcode → literal blob
-            stack.append(tok)
-
-    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)
-                if isinstance(res, Expr.Error):
-                    return res
-                return Expr.ListExpr([Expr.Byte(b) for b in 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)
-
-# ===============================
-# 3. Lightweight Parser for Expr (postfix, limited forms)
-# ===============================
-
-class ParseError(Exception):
-    pass
-
-def tokenize(source: str) -> List[str]:
-    """Tokenize a minimal Lispeum subset for this module.
-
-    Supports:
-    - Integers (e.g., -1, 0, 255) → Byte
-    - Symbols (e.g., add, nand, def, fn, sk, int.sub, $0)
-    - Lists using parentheses
-    """
-    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
-
-def _parse_one(tokens: List[str], pos: int = 0) -> Tuple[Expr, int]:
-    if pos >= len(tokens):
-        raise ParseError("unexpected end")
-    tok = tokens[pos]
-
-    if tok == '(':  # list
-        items: List[Expr] = []
-        i = pos + 1
-        while i < len(tokens):
-            if tokens[i] == ')':
-                # special-case error form at close: (origin topic err) or (topic err)
-                if len(items) >= 3 and isinstance(items[-1], Expr.Symbol) and items[-1].value == 'err' and isinstance(items[-2], Expr.Symbol):
-                    return Expr.Error(items[-2].value, origin=items[-3]), i + 1
-                if len(items) == 2 and isinstance(items[-1], Expr.Symbol) and items[-1].value == 'err' and isinstance(items[-2], Expr.Symbol):
-                    return Expr.Error(items[-2].value), i + 1
-                return Expr.ListExpr(items), i + 1
-            expr, i = _parse_one(tokens, i)
-            items.append(expr)
-        raise ParseError("expected ')'")
-
-    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
-
-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:]

astreum/lispeum/__init__.py

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

{astreum-0.2.34.dist-info → astreum-0.2.36.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astreum
-Version: 0.2.34
+Version: 0.2.36
 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

{astreum-0.2.34.dist-info → astreum-0.2.36.dist-info}/RECORD

@@ -1,13 +1,21 @@
-astreum/__init__.py,sha256=y2Ok3EY_FstcmlVASr80lGR_0w-dH-SXDCCQFmL6uwA,28
-astreum/_node.py,sha256=cJSzj7N4unkOH5T_nDa7bKy_jBD-p0oJTDlAXjuFFYw,18773
+astreum/__init__.py,sha256=oIrOJ0DZZByGtiIaupDBLhIOLL2nm0FOI7uWhDcaIsk,51
+astreum/_node.py,sha256=YWz7RASGM9qCHJEQoldehzcnWBhS3jLbRfT6_VlWZcM,5391
 astreum/format.py,sha256=X4tG5GGPweNCE54bHYkLFiuLTbmpy5upO_s1Cef-MGA,2711
 astreum/node.py,sha256=SuVm1b0QWl1FpDUaLRH1fiFYnXCrPs6qYeUQlPDae8w,38358
+astreum/_lispeum/__init__.py,sha256=HzJp03YmP0b8IS2NtM893katuUooro_C701H08uf4i4,274
+astreum/_lispeum/environment.py,sha256=5SAEUgEzRlDGqtrmr-g6Za-fuuhX55GXGnZKVKxfkCQ,230
+astreum/_lispeum/expression.py,sha256=PS8RAahwduhnJy7-6jYaILAc0uFu1XLhbnHUJhvVwo8,1024
+astreum/_lispeum/high_evaluation.py,sha256=s6DJSEWLc_-05Tpk8TOaSJm0TKrC3H_YEym5pnXfPWw,8041
+astreum/_lispeum/low_evaluation.py,sha256=mbeA0KMeWQruAPctYJAP-L6QmU1btU0l5ScJWFF_nxA,4322
+astreum/_lispeum/meter.py,sha256=5q2PFW7_jmgKVM1-vwE4RRjMfPEthUA4iu1CwR-Axws,505
+astreum/_lispeum/parser.py,sha256=_J-KeIZlK-PP0Wc9mAl82hyQsPG2wsgshqAc3fCNVk8,1562
+astreum/_lispeum/tokenizer.py,sha256=P68uIj4aPKzjuCJ85jfzRi67QztpuXIOC1vvLQueBI4,552
 astreum/crypto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 astreum/crypto/ed25519.py,sha256=FRnvlN0kZlxn4j-sJKl-C9tqiz_0z4LZyXLj3KIj1TQ,1760
 astreum/crypto/quadratic_form.py,sha256=pJgbORey2NTWbQNhdyvrjy_6yjORudQ67jBz2ScHptg,4037
 astreum/crypto/wesolowski.py,sha256=SUgGXW3Id07dJtWzDcs4dluIhjqbRWQ8YWjn_mK78AQ,4092
 astreum/crypto/x25519.py,sha256=i29v4BmwKRcbz9E7NKqFDQyxzFtJUqN0St9jd7GS1uA,1137
-astreum/lispeum/__init__.py,sha256=K-NDzIjtIsXzC9X7lnYvlvIaVxjFcY7WNsgLIE3DH3U,58
+astreum/lispeum/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 astreum/lispeum/environment.py,sha256=wolwt9psDl62scgjaVG0G59xlBs1AM4NPgryUbxzG_4,1220
 astreum/lispeum/expression.py,sha256=K8gFifDaHu394bs9qnpvP8tjeiymFGQpnDC_iW9nU4E,2379
 astreum/lispeum/parser.py,sha256=jQRzZYvBuSg8t_bxsbt1-WcHaR_LPveHNX7Qlxhaw-M,1165
@@ -27,8 +35,8 @@ astreum/relay/setup.py,sha256=ynvGaJdlDtw_f5LLiow2Wo7IRzUjvgk8eSr1Sv4_zTg,2090
 astreum/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 astreum/storage/object.py,sha256=knFlvw_tpcC4twSu1DGNpHX31wlANN8E5dgEqIfU--Q,2041
 astreum/storage/setup.py,sha256=1-9ztEFI_BvRDvAA0lAn4mFya8iq65THTArlj--M3Hg,626
-astreum-0.2.34.dist-info/licenses/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
-astreum-0.2.34.dist-info/METADATA,sha256=5EXXn-HyFQ6cCd34YuK0A0g1xDZA0VOZaudtxHdqimA,6149
-astreum-0.2.34.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-astreum-0.2.34.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
-astreum-0.2.34.dist-info/RECORD,,
+astreum-0.2.36.dist-info/licenses/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
+astreum-0.2.36.dist-info/METADATA,sha256=P3P6HjaFqg6F1e9EVnr9OtMapOJMvtaVB0hqw486D6I,6149
+astreum-0.2.36.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+astreum-0.2.36.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
+astreum-0.2.36.dist-info/RECORD,,