astreum 0.2.61__py3-none-any.whl → 0.3.9__py3-none-any.whl

astreum/machine/evaluations/low_evaluation.py

@@ -0,0 +1,281 @@
+from typing import Dict, List, Union
+
+from astreum.storage.models.atom import ZERO32, Atom, AtomKind
+from ..models.expression import Expr, error_expr
+from ..models.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 (NOT-AND) on two byte strings, zero-extending to max width.
+
+    The NAND gate yields 0 only when all inputs are 1; otherwise it outputs 1.
+    Truth table:
+        A | B | NAND
+        0 | 0 |  1
+        0 | 1 |  1
+        1 | 0 |  1
+        1 | 1 |  0
+    """
+    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:
+        """Execute low-level bytecode with stack/heap semantics under metering."""
+        heap: Dict[bytes, bytes] = {}
+
+        stack: List[bytes] = []
+        pc = 0
+
+        while True:
+            if pc >= len(code):
+                if len(stack) != 1:
+                    return error_expr("low_eval", "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 error_expr("low_eval", "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 error_expr("low_eval", "meter limit")
+            #     stack.append(res_b)
+            #     continue
+
+            # ---------- NAND ----------
+            
+            if tok == b"nand":
+                if len(stack) < 2:
+                    return error_expr("low_eval", "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 error_expr("low_eval", "meter limit")
+                stack.append(res_b)
+                continue
+
+            # ---------- JUMP ----------
+            if tok == b"jump":
+                if len(stack) < 1:
+                    return error_expr("low_eval", "underflow")
+                tgt_b = stack.pop()
+                if not meter.charge_bytes(1):
+                    return error_expr("low_eval", "meter limit")
+                tgt_i = tc_to_int(tgt_b)
+                if tgt_i < 0 or tgt_i >= len(code):
+                    return error_expr("low_eval", "bad jump")
+                pc = tgt_i
+                continue
+
+            # ---------- HEAP GET ----------
+            if tok == b"heap_get":
+                if len(stack) < 1:
+                    return error_expr("low_eval", "underflow")
+                key = stack.pop()
+                val = heap.get(key) or b""
+                # get cost: 1
+                if not meter.charge_bytes(1):
+                    return error_expr("low_eval", "meter limit")
+                stack.append(val)
+                continue
+
+            # ---------- HEAP SET ----------
+            if tok == b"heap_set":
+                if len(stack) < 2:
+                    return error_expr("low_eval", "underflow")
+                val = stack.pop()
+                key = stack.pop()
+                if not meter.charge_bytes(len(val)):
+                    return error_expr("low_eval", "meter limit")
+                heap[key] = val
+                continue
+
+            # ---------- ATOM SLICE ----------
+            if tok == b"atom_slice":
+                if len(stack) < 3:
+                    return error_expr("low_eval", "underflow")
+                len_b = stack.pop()
+                idx_b = stack.pop()
+                id_b = stack.pop()
+
+                idx = tc_to_int(idx_b)
+                length = tc_to_int(len_b)
+                if idx < 0 or length < 0:
+                    return error_expr("low_eval", "bad slice")
+
+                atom = self.storage_get(key=id_b)
+                if atom is None:
+                    return error_expr("low_eval", "unknown atom")
+
+                data = atom.data
+                slice_bytes = data[idx : idx + length]
+
+                if not meter.charge_bytes(len(slice_bytes)):
+                    return error_expr("low_eval", "meter limit")
+
+                new_atom = Atom(data=slice_bytes, kind=atom.kind)
+                new_id = new_atom.object_id()
+                try:
+                    self._hot_storage_set(key=new_id, value=new_atom)
+                except RuntimeError:
+                    return error_expr("low_eval", "storage error")
+
+                stack.append(new_id)
+                continue
+
+            # ---------- ATOM LINK ----------
+            if tok == b"atom_link":
+                if len(stack) < 2:
+                    return error_expr("low_eval", "underflow")
+                id2_b = stack.pop()
+                id1_b = stack.pop()
+
+                if not meter.charge_bytes(len(id1_b) + len(id2_b)):
+                    return error_expr("low_eval", "meter limit")
+                
+                atom = self.storage_get(key=id_b)
+                if atom is None:
+                    return error_expr("low_eval", "unknown atom")
+
+                new_atom = Atom(data=id1_b, next_id=id2_b, kind=atom.kind)
+                new_id = new_atom.object_id()
+
+                try:
+                    self._hot_storage_set(key=new_id, value=new_atom)
+                except RuntimeError:
+                    return error_expr("low_eval", "storage error")
+
+                stack.append(new_id)
+                continue
+
+            # ---------- ATOM CONCAT ----------
+            if tok == b"atom_concat":
+                if len(stack) < 2:
+                    return error_expr("low_eval", "underflow")
+                id2_b = stack.pop()
+                id1_b = stack.pop()
+
+                atom1 = self.storage_get(key=id1_b)
+                atom2 = self.storage_get(key=id2_b)
+                if atom1 is None or atom2 is None:
+                    return error_expr("low_eval", "unknown atom")
+
+                joined = atom1.data + atom2.data
+
+                if not meter.charge_bytes(len(joined)):
+                    return error_expr("low_eval", "meter limit")
+
+                new_atom = Atom(data=joined, kind=AtomKind.BYTES)
+                new_id = new_atom.object_id()
+
+                try:
+                    self._hot_storage_set(key=new_id, value=new_atom)
+                except RuntimeError:
+                    return error_expr("low_eval", "storage error")
+
+                stack.append(new_id)
+                continue
+
+                        # ---------- ATOM NEW ----------
+            
+            if tok == b"atom_new":
+                if len(stack) < 2:
+                    return error_expr("low_eval", "underflow")
+                data_b = stack.pop()
+                kind_b = stack.pop()
+
+                if len(kind_b) != 1:
+                    return error_expr("low_eval", "bad atom kind")
+
+                kind_value = kind_b[0]
+                try:
+                    kind = AtomKind(kind_value)
+                except ValueError:
+                    return error_expr("low_eval", "unknown atom kind")
+
+                if not meter.charge_bytes(len(data_b)):
+                    return error_expr("low_eval", "meter limit")
+
+                new_atom = Atom(data=data_b, kind=kind)
+                new_id = new_atom.object_id()
+
+                try:
+                    self._hot_storage_set(key=new_id, value=new_atom)
+                except RuntimeError:
+                    return error_expr("low_eval", "storage error")
+
+                stack.append(new_id)
+                continue
+
+                        # ---------- ATOM LOAD ----------
+            
+            if tok == b"atom_load":
+                if len(stack) < 3:
+                    return error_expr("low_eval", "underflow")
+                len_b = stack.pop()
+                idx_b = stack.pop()
+                id_b = stack.pop()
+
+                idx = tc_to_int(idx_b)
+                length = tc_to_int(len_b)
+                if idx < 0 or length < 0:
+                    return error_expr("low_eval", "bad load")
+                if length > 32:
+                    return error_expr("low_eval", "load too wide")
+
+                atom = self.storage_get(key=id_b)
+                if atom is None:
+                    return error_expr("low_eval", "unknown atom")
+
+                data = atom.data
+                chunk = data[idx : idx + length]
+
+                if not meter.charge_bytes(len(chunk)):
+                    return error_expr("low_eval", "meter limit")
+
+                stack.append(chunk)
+                continue
+
+            # if no opcode matched above, treat token as literal
+            # not an opcode → literal blob
+            stack.append(tok)

astreum/machine/evaluations/script_evaluation.py

@@ -0,0 +1,27 @@
+"""High level eval helper that reuses the existing tokenizer, parser and evaluator."""
+
+from __future__ import annotations
+
+import uuid
+from typing import Optional
+
+from ..models.expression import Expr, error_expr
+from ..parser import ParseError, parse
+from ..tokenizer import tokenize
+
+
+def script_eval(self, source: str, env_id: Optional[uuid.UUID] = None, meter=None) -> Expr:
+    """Evaluate textual expressions by tokenizing, parsing and forwarding to high_eval."""
+    tokens = tokenize(source)
+    if not tokens:
+        return error_expr("eval", "no expression provided")
+
+    try:
+        expr, rest = parse(tokens)
+    except ParseError as exc:
+        return error_expr("eval", f"parse error: {exc}")
+
+    if rest:
+        return error_expr("eval", "unexpected tokens after expression")
+
+    return self.high_eval(expr=expr, env_id=env_id, meter=meter)

astreum/machine/models/environment.py

@@ -0,0 +1,31 @@
+from ast import Expr
+from typing import Dict, Optional
+import uuid
+
+
+class Env:
+    def __init__(
+        self,
+        data: Optional[Dict[str, Expr]] = None,
+        parent_id: Optional[uuid.UUID] = None,
+    ):
+        self.data: Dict[str, Expr] = {} if data is None else data
+        self.parent_id = parent_id
+
+def env_get(self, env_id: uuid.UUID, key: str) -> Optional[Expr]:
+    """Resolve a value by walking the environment chain starting at env_id."""
+    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: str, value: Expr) -> bool:
+    """Bind a value to key within the specified environment if it exists."""
+    with self.machine_environments_lock:
+        env = self.environments.get(env_id)
+        if env is None:
+            return False
+        env.data[key] = value
+        return True

astreum/{_lispeum → machine/models}/expression.py

@@ -1,6 +1,6 @@
 from typing import Any, List, Optional, Tuple
 
-from .._storage.atom import Atom, AtomKind
+from ...storage.models.atom import Atom, AtomKind
 
 ZERO32 = b"\x00" * 32
 ERROR_SYMBOL = "error"
@@ -88,7 +88,7 @@ class Expr:
 
         if kind_enum is AtomKind.LIST:
             # Empty list sentinel: zero-length payload and no next pointer.
-            if len(type_atom.data) == 0 and type_atom.next == ZERO32:
+            if len(type_atom.data) == 0 and type_atom.next_id == ZERO32:
                 return cls.ListExpr([])
 
             elements: List[Expr] = []
@@ -102,8 +102,8 @@ class Expr:
                     raise ValueError("list element hash has unexpected length")
                 child_expr = cls.from_atoms(node, child_hash)
                 elements.append(child_expr)
-                next_id = current_atom.next
-                if not next_id or next_id == ZERO32:
+                next_id = current_atom.next_id
+                if next_id == ZERO32:
                     break
                 next_atom = _require(next_id, f"list element {idx}")
                 next_kind = _atom_kind(next_atom)
@@ -118,11 +118,17 @@ class Expr:
     @staticmethod
     def to_atoms(e: "Expr") -> Tuple[bytes, List[Atom]]:
         def symbol(value: str) -> Tuple[bytes, List[Atom]]:
-            atom = Atom.from_data(data=value.encode("utf-8"), kind=AtomKind.SYMBOL)
+            atom = Atom(
+                data=value.encode("utf-8"),
+                kind=AtomKind.SYMBOL,
+            )
             return atom.object_id(), [atom]
 
         def bytes_value(data: bytes) -> Tuple[bytes, List[Atom]]:
-            atom = Atom.from_data(data=data, kind=AtomKind.BYTES)
+            atom = Atom(
+                data=data,
+                kind=AtomKind.BYTES,
+            )
             return atom.object_id(), [atom]
 
         def lst(items: List["Expr"]) -> Tuple[bytes, List[Atom]]:
@@ -135,14 +141,14 @@ class Expr:
             next_hash = ZERO32
             elem_atoms: List[Atom] = []
             for h in reversed(child_hashes):
-                a = Atom.from_data(h, next_hash, kind=AtomKind.LIST)
+                a = Atom(data=h, next_id=next_hash, kind=AtomKind.LIST)
                 next_hash = a.object_id()
                 elem_atoms.append(a)
             elem_atoms.reverse()
             if elem_atoms:
                 head = elem_atoms[0].object_id()
             else:
-                empty_atom = Atom.from_data(data=b"", next_hash=ZERO32, kind=AtomKind.LIST)
+                empty_atom = Atom(data=b"", kind=AtomKind.LIST)
                 elem_atoms = [empty_atom]
                 head = empty_atom.object_id()
             return head, acc + elem_atoms
@@ -188,3 +194,25 @@ def error_expr(topic: str, message: str) -> Expr.ListExpr:
         Expr.Bytes(topic_bytes),
         Expr.Bytes(message_bytes),
     ])
+
+def get_expr_list_from_storage(self, key: bytes) -> Optional["ListExpr"]:
+        """Load a list expression from storage using the given atom list root hash."""
+        atoms = self.get_atom_list_from_storage(root_hash=key)
+        if atoms is None:
+            return None
+        
+        expr_list = []
+        for atom in atoms:
+            match atom.kind:
+                case AtomKind.SYMBOL:
+                    expr_list.append(Expr.Symbol(atom.data))
+                case AtomKind.BYTES:
+                    expr_list.append(Expr.Bytes(atom.data))
+                case AtomKind.LIST:
+                    expr_list.append(Expr.ListExpr([
+                        Expr.Bytes(atom.data),
+                        Expr.Symbol("ref")
+                    ]))
+
+        expr_list.reverse()
+        return Expr.ListExpr(expr_list)

astreum/machine/tokenizer.py

@@ -0,0 +1,90 @@
+from typing import List
+
+
+def tokenize(source: str) -> List[str]:
+    tokens: List[str] = []
+    cur: List[str] = []
+    n = len(source)
+    i = 0
+
+    def flush_cur() -> None:
+        if cur:
+            tokens.append("".join(cur))
+            cur.clear()
+
+    def skip_line_comment(idx: int) -> int:
+        while idx < n and source[idx] != "\n":
+            idx += 1
+        return idx
+
+    def skip_ws_and_comments(idx: int) -> int:
+        while idx < n:
+            ch = source[idx]
+            if ch.isspace():
+                flush_cur()
+                idx += 1
+                continue
+            if ch == ";":
+                flush_cur()
+                idx = skip_line_comment(idx + 1)
+                continue
+            break
+        return idx
+
+    def skip_expression(idx: int) -> int:
+        idx = skip_ws_and_comments(idx)
+        if idx >= n:
+            return n
+        ch = source[idx]
+        if ch == "(":
+            depth = 0
+            while idx < n:
+                ch = source[idx]
+                if ch == "(":
+                    depth += 1
+                    idx += 1
+                    continue
+                if ch == ")":
+                    depth -= 1
+                    idx += 1
+                    if depth == 0:
+                        break
+                    continue
+                if ch == ";":
+                    idx = skip_line_comment(idx + 1)
+                    continue
+                if ch == "#" and idx + 1 < n and source[idx + 1] == ";":
+                    idx = skip_expression(idx + 2)
+                    continue
+                idx += 1
+            return idx
+        if ch == ")":
+            return idx + 1
+        while idx < n:
+            ch = source[idx]
+            if ch.isspace() or ch in ("(", ")", ";"):
+                break
+            if ch == "#" and idx + 1 < n and source[idx + 1] == ";":
+                break
+            idx += 1
+        return idx
+
+    while i < n:
+        i = skip_ws_and_comments(i)
+        if i >= n:
+            break
+        ch = source[i]
+        if ch == "#" and i + 1 < n and source[i + 1] == ";":
+            flush_cur()
+            i = skip_expression(i + 2)
+            continue
+        if ch in ("(", ")"):
+            flush_cur()
+            tokens.append(ch)
+            i += 1
+            continue
+        cur.append(ch)
+        i += 1
+
+    flush_cur()
+    return tokens