astreum 0.2.41__py3-none-any.whl → 0.3.1__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/machine/models/expression.py

@@ -0,0 +1,218 @@
+from typing import Any, List, Optional, Tuple
+
+from ...storage.models.atom import Atom, AtomKind
+
+ZERO32 = b"\x00" * 32
+ERROR_SYMBOL = "error"
+
+
+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})"
+
+        def to_atoms(self):
+            return Expr.to_atoms(self)
+        
+    class Symbol:
+        def __init__(self, value: str):
+            self.value = value
+
+        def __repr__(self):
+            return f"{self.value}"
+
+        def to_atoms(self):
+            return Expr.to_atoms(self)
+        
+    class Bytes:
+        def __init__(self, value: bytes):
+            self.value = value
+
+        def __repr__(self):
+            int_value = int.from_bytes(self.value, "big") if self.value else 0
+            return f"{int_value}"
+
+        def to_atoms(self):
+            return Expr.to_atoms(self)
+    @classmethod
+    def from_atoms(cls, node: Any, root_hash: bytes) -> "Expr":
+        """Rebuild an expression tree from stored atoms."""
+        if not isinstance(root_hash, (bytes, bytearray)):
+            raise TypeError("root hash must be bytes-like")
+
+        storage_get = getattr(node, "storage_get", None)
+        if not callable(storage_get):
+            raise TypeError("node must provide a callable 'storage_get'")
+
+        expr_id = bytes(root_hash)
+
+        def _require(atom_id: Optional[bytes], context: str):
+            if not atom_id:
+                raise ValueError(f"missing atom id while decoding {context}")
+            atom = storage_get(atom_id)
+            if atom is None:
+                raise ValueError(f"missing atom data while decoding {context}")
+            return atom
+
+        def _atom_kind(atom: Any) -> Optional[AtomKind]:
+            kind_value = getattr(atom, "kind", None)
+            if isinstance(kind_value, AtomKind):
+                return kind_value
+            if isinstance(kind_value, int):
+                try:
+                    return AtomKind(kind_value)
+                except ValueError:
+                    return None
+            return None
+
+        type_atom = _require(expr_id, "expression atom")
+
+        kind_enum = _atom_kind(type_atom)
+        if kind_enum is None:
+            raise ValueError("expression atom missing kind")
+
+        if kind_enum is AtomKind.SYMBOL:
+            try:
+                return cls.Symbol(type_atom.data.decode("utf-8"))
+            except UnicodeDecodeError as exc:
+                raise ValueError("symbol atom is not valid utf-8") from exc
+
+        if kind_enum is AtomKind.BYTES:
+            return cls.Bytes(type_atom.data)
+
+        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_id == ZERO32:
+                return cls.ListExpr([])
+
+            elements: List[Expr] = []
+            current_atom = type_atom
+            idx = 0
+            while True:
+                child_hash = current_atom.data
+                if not child_hash:
+                    raise ValueError("list element missing child hash")
+                if len(child_hash) != len(ZERO32):
+                    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_id
+                if next_id == ZERO32:
+                    break
+                next_atom = _require(next_id, f"list element {idx}")
+                next_kind = _atom_kind(next_atom)
+                if next_kind is not AtomKind.LIST:
+                    raise ValueError("list chain contains non-list atom")
+                current_atom = next_atom
+                idx += 1
+            return cls.ListExpr(elements)
+
+        raise ValueError(f"unknown expression kind: {kind_enum}")
+
+    @staticmethod
+    def to_atoms(e: "Expr") -> Tuple[bytes, List[Atom]]:
+        def symbol(value: str) -> Tuple[bytes, List[Atom]]:
+            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(
+                data=data,
+                kind=AtomKind.BYTES,
+            )
+            return atom.object_id(), [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(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(data=b"", kind=AtomKind.LIST)
+                elem_atoms = [empty_atom]
+                head = empty_atom.object_id()
+            return head, acc + elem_atoms
+
+        if isinstance(e, Expr.Symbol):
+            return symbol(e.value)
+        if isinstance(e, Expr.Bytes):
+            return bytes_value(e.value)
+        if isinstance(e, Expr.ListExpr):
+            return lst(e.elements)
+        raise TypeError("unknown Expr variant")
+
+def _expr_generate_id(expr) -> bytes:
+    expr_id, _ = Expr.to_atoms(expr)
+    return expr_id
+
+
+def _expr_cached_id(expr) -> bytes:
+    cached = getattr(expr, "_cached_id", None)
+    if cached is None:
+        cached = _expr_generate_id(expr)
+        setattr(expr, "_cached_id", cached)
+    return cached
+
+
+for _expr_cls in (Expr.ListExpr, Expr.Symbol, Expr.Bytes):
+    _expr_cls.generate_id = _expr_generate_id  # type: ignore[attr-defined]
+    _expr_cls.id = property(_expr_cached_id)  # type: ignore[attr-defined]
+
+
+def error_expr(topic: str, message: str) -> Expr.ListExpr:
+    """Encode an error as (error <topic-bytes> <message-bytes>)."""
+    try:
+        topic_bytes = topic.encode("utf-8")
+    except UnicodeEncodeError as exc:
+        raise ValueError("error topic must be valid utf-8") from exc
+    try:
+        message_bytes = message.encode("utf-8")
+    except UnicodeEncodeError as exc:
+        raise ValueError("error message must be valid utf-8") from exc
+    return Expr.ListExpr([
+        Expr.Symbol(ERROR_SYMBOL),
+        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/{_lispeum → machine}/parser.py

@@ -1,5 +1,5 @@
-from typing import List, Tuple
-from src.astreum._lispeum import Expr
+from typing import List, Tuple
+from . import Expr
 
 class ParseError(Exception):
     pass
@@ -14,12 +14,7 @@ def _parse_one(tokens: List[str], pos: int = 0) -> Tuple[Expr, int]:
         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
+                return Expr.ListExpr(items), i + 1
             expr, i = _parse_one(tokens, i)
             items.append(expr)
         raise ParseError("expected ')'")
@@ -27,30 +22,30 @@ def _parse_one(tokens: List[str], pos: int = 0) -> Tuple[Expr, int]:
     if tok == ')':
         raise ParseError("unexpected ')'")
 
-    # 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
+    # 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:]