make SExp wrap any tree implementing the CLVMObject protocol. (#94)

simplify CLVMObject a bit, remove its cons() function

Author: arvidn

clvm/CLVMObject.py

@@ -1,47 +1,29 @@
-"""
-This is the minimal `SExp` type that defines how and where its contents are
-stored in the heap. The methods here are the only ones required for `run_program`.
-A native implementation of `run_program` should implement this base class.
-"""
-
 import typing
 
-# Set this to "1" to do a run-time type check
-# This may slow things down a bit
-
-TYPE_CHECK = 0
-
 
 class CLVMObject:
+    """
+    This class implements the CLVM Object protocol in the simplest possible way,
+    by just having an "atom" and a "pair" field
+    """
 
     atom: typing.Optional[bytes]
-    pair: typing.Optional[typing.Tuple["CLVMObject", "CLVMObject"]]
+
+    # this is always a 2-tuple of an object implementing the CLVM object
+    # protocol.
+    pair: typing.Optional[typing.Tuple[typing.Any, typing.Any]]
     __slots__ = ["atom", "pair"]
 
-    def __new__(class_, v: "SExpType"):
+    def __new__(class_, v):
         if isinstance(v, CLVMObject):
             return v
-        if TYPE_CHECK:
-            type_ok = (
-                isinstance(v, tuple)
-                and len(v) == 2
-                and isinstance(v[0], CLVMObject)
-                and isinstance(v[1], CLVMObject)
-            ) or isinstance(v, bytes)
-            # uncomment next line for debugging help
-            # if not type_ok: breakpoint()
-            assert type_ok
         self = super(CLVMObject, class_).__new__(class_)
         if isinstance(v, tuple):
+            if len(v) != 2:
+                raise ValueError("tuples must be of size 2, cannot create CLVMObject from: %s" % str(v))
             self.pair = v
             self.atom = None
         else:
             self.atom = v
             self.pair = None
         return self
-
-    def cons(self, right: "CLVMObject"):
-        return self.__class__((self, right))
-
-
-SExpType = typing.Union[bytes, typing.Tuple[CLVMObject, CLVMObject]]

clvm/SExp.py

@@ -4,7 +4,7 @@
 from blspy import G1Element
 
 from .as_python import as_python
-from .CLVMObject import CLVMObject, SExpType
+from .CLVMObject import CLVMObject
 
 from .EvalError import EvalError
 
@@ -17,113 +17,152 @@
 
 CastableType = typing.Union[
     "SExp",
-    CLVMObject,
+    "CLVMObject",
     bytes,
+    str,
     int,
     None,
-    SExpType,
     G1Element,
+    list,
     typing.Tuple[typing.Any, typing.Any],
 ]
 
+
 NULL = b""
 
 
+def looks_like_clvm_object(o: typing.Any) -> bool:
+    d = dir(o)
+    return "atom" in d and "pair" in d
+
+
+# this function recognizes some common types and turns them into plain bytes,
+def convert_atom_to_bytes(
+    v: typing.Union[bytes, str, int, G1Element, None, list],
+) -> bytes:
+
+    if isinstance(v, bytes):
+        return v
+    if isinstance(v, str):
+        return v.encode()
+    if isinstance(v, int):
+        return int_to_bytes(v)
+    if isinstance(v, G1Element):
+        return bytes(v)
+    if v is None:
+        return b""
+    if v == []:
+        return b""
+
+    raise ValueError("can't cast %s (%s) to bytes" % (type(v), v))
+
+
+# returns a clvm-object like object
 def to_sexp_type(
     v: CastableType,
-) -> SExpType:
+):
     stack = [v]
     ops = [(0, None)]  # convert
 
     while len(ops) > 0:
         op, target = ops.pop()
         # convert value
         if op == 0:
+            if looks_like_clvm_object(stack[-1]):
+                continue
             v = stack.pop()
             if isinstance(v, tuple):
                 if len(v) != 2:
                     raise ValueError("can't cast tuple of size %d" % len(v))
                 left, right = v
                 target = len(stack)
-                stack.append((left, right))
-                if type(right) != CLVMObject:
+                stack.append(CLVMObject((left, right)))
+                if not looks_like_clvm_object(right):
                     stack.append(right)
                     ops.append((2, target))  # set right
                     ops.append((0, None))  # convert
-                if type(left) != CLVMObject:
+                if not looks_like_clvm_object(left):
                     stack.append(left)
                     ops.append((1, target))  # set left
                     ops.append((0, None))  # convert
                 continue
-            if isinstance(v, CLVMObject):
-                stack.append(v.pair or v.atom)
-                continue
-            if isinstance(v, bytes):
-                stack.append(v)
-                continue
-            if isinstance(v, str):
-                stack.append(v.encode())
-                continue
-            if isinstance(v, int):
-                stack.append(int_to_bytes(v))
-                continue
-            if isinstance(v, G1Element):
-                stack.append(bytes(v))
-                continue
-            if v is None:
-                stack.append(NULL)
-                continue
-            if v == []:
-                stack.append(NULL)
-                continue
-
-            if hasattr(v, "__iter__"):
+            if isinstance(v, list):
                 target = len(stack)
-                stack.append(NULL)
+                stack.append(CLVMObject(NULL))
                 for _ in v:
                     stack.append(_)
                     ops.append((3, target))  # prepend list
                     # we only need to convert if it's not already the right
                     # type
-                    if type(_) != CLVMObject:
+                    if not looks_like_clvm_object(_):
                         ops.append((0, None))  # convert
                 continue
+            stack.append(CLVMObject(convert_atom_to_bytes(v)))
+            continue
 
-            raise ValueError("can't cast to CLVMObject: %s" % v)
         if op == 1:  # set left
-            stack[target] = (CLVMObject(stack.pop()), stack[target][1])
+            stack[target].pair = (CLVMObject(stack.pop()), stack[target].pair[1])
             continue
         if op == 2:  # set right
-            stack[target] = (stack[target][0], CLVMObject(stack.pop()))
+            stack[target].pair = (stack[target].pair[0], CLVMObject(stack.pop()))
             continue
         if op == 3:  # prepend list
-            stack[target] = (CLVMObject(stack.pop()), CLVMObject(stack[target]))
+            stack[target] = CLVMObject((stack.pop(), stack[target]))
             continue
     # there's exactly one item left at this point
     if len(stack) != 1:
         raise ValueError("internal error")
+
+    # stack[0] implements the clvm object protocol and can be wrapped by an SExp
     return stack[0]
 
 
-class SExp(CLVMObject):
+class SExp:
+    """
+    SExp provides higher level API on top of any object implementing the CLVM
+    object protocol.
+    The tree of values is not a tree of SExp objects, it's a tree of CLVMObject
+    like objects. SExp simply wraps them to privide a uniform view of any
+    underlying conforming tree structure.
+
+    The CLVM object protocol (concept) exposes two attributes:
+    1. "atom" which is either None or bytes
+    2. "pair" which is either None or a tuple of exactly two elements. Both
+       elements implementing the CLVM object protocol.
+    Exactly one of "atom" and "pair" must be None.
+    """
     true: "SExp"
     false: "SExp"
     __null__: "SExp"
 
-    def as_pair(self):
+    # the underlying object implementing the clvm object protocol
+    atom: typing.Optional[bytes]
+
+    # this is a tuple of the otherlying CLVMObject-like objects. i.e. not
+    # SExp objects with higher level functions, or None
+    pair: typing.Optional[typing.Tuple[typing.Any, typing.Any]]
+
+    def __init__(self, obj):
+        self.atom = obj.atom
+        self.pair = obj.pair
+
+    # this returns a tuple of two SExp objects, or None
+    def as_pair(self) -> typing.Tuple["SExp", "SExp"]:
         pair = self.pair
         if pair is None:
             return pair
-        return (self.to(pair[0]), self.to(pair[1]))
+        return (self.__class__(pair[0]), self.__class__(pair[1]))
 
+    # TODO: deprecate this. Same as .atom property
     def as_atom(self):
         return self.atom
 
     def listp(self):
         return self.pair is not None
 
     def nullp(self):
-        return self.atom == b""
+        v = self.atom
+        return v is not None and len(v) == 0
 
     def as_int(self):
         return int_from_bytes(self.atom)
@@ -134,26 +173,29 @@ def as_bin(self):
         return f.getvalue()
 
     @classmethod
-    def to(class_, v: CastableType):
+    def to(class_, v: CastableType) -> "SExp":
         if isinstance(v, class_):
             return v
-        v1 = to_sexp_type(v)
-        return class_(v1)
 
-    def cons(self, right: "CLVMObject"):
-        s = (self, right)
-        return self.to(s)
+        if looks_like_clvm_object(v):
+            return class_(v)
+
+        # this will lazily convert elements
+        return class_(to_sexp_type(v))
+
+    def cons(self, right):
+        return self.to((self, right))
 
     def first(self):
         pair = self.pair
         if pair:
-            return self.to(pair[0])
+            return self.__class__(pair[0])
         raise EvalError("first of non-cons", self)
 
     def rest(self):
         pair = self.pair
         if pair:
-            return self.to(pair[1])
+            return self.__class__(pair[1])
         raise EvalError("rest of non-cons", self)
 
     @classmethod
@@ -169,22 +211,22 @@ def as_iter(self):
     def __eq__(self, other: CastableType):
         try:
             other = self.to(other)
+            to_compare_stack = [(self, other)]
+            while to_compare_stack:
+                s1, s2 = to_compare_stack.pop()
+                p1 = s1.as_pair()
+                if p1:
+                    p2 = s2.as_pair()
+                    if p2:
+                        to_compare_stack.append((p1[0], p2[0]))
+                        to_compare_stack.append((p1[1], p2[1]))
+                    else:
+                        return False
+                elif s2.as_pair() or s1.as_atom() != s2.as_atom():
+                    return False
+            return True
         except ValueError:
             return False
-        to_compare_stack = [(self, other)]
-        while to_compare_stack:
-            s1, s2 = to_compare_stack.pop()
-            p1 = s1.as_pair()
-            if p1:
-                p2 = s2.as_pair()
-                if p2:
-                    to_compare_stack.append((p1[0], p2[0]))
-                    to_compare_stack.append((p1[1], p2[1]))
-                else:
-                    return False
-            elif s2.as_pair() or s1.as_atom() != s2.as_atom():
-                return False
-        return True
 
     def list_len(self):
         v = self
@@ -204,5 +246,5 @@ def __repr__(self):
         return "%s(%s)" % (self.__class__.__name__, str(self))
 
 
-SExp.false = SExp.__null__ = SExp(b"")
-SExp.true = SExp(b"\1")
+SExp.false = SExp.__null__ = SExp(CLVMObject(b""))
+SExp.true = SExp(CLVMObject(b"\1"))

tests/as_python_test.py

@@ -11,7 +11,7 @@ def __init__(self):
         self.i = 0
 
 
-def gen_tree(depth):
+def gen_tree(depth: int) -> SExp:
     if depth == 0:
         return SExp.to(1337)
     subtree = gen_tree(depth - 1)
@@ -58,6 +58,8 @@ def test_list_of_one(self):
         v = SExp.to([1])
         self.assertEqual(type(v.pair[0]), CLVMObject)
         self.assertEqual(type(v.pair[1]), CLVMObject)
+        self.assertEqual(type(v.as_pair()[0]), SExp)
+        self.assertEqual(type(v.as_pair()[1]), SExp)
         self.assertEqual(v.pair[0].atom, b"\x01")
         self.assertEqual(v.pair[1].atom, b"")
 
@@ -162,13 +164,21 @@ def test_long_list(self):
         self.assertEqual(v.as_atom(), SExp.null())
 
     def test_invalid_type(self):
-        self.assertRaises(ValueError, lambda: SExp.to(dummy_class))
+        with self.assertRaises(ValueError):
+            s = SExp.to(dummy_class)
+            # conversions are deferred, this is where it will fail:
+            b = list(s.as_iter())
+            print(b)
 
     def test_invalid_tuple(self):
-        self.assertRaises(ValueError, lambda: SExp.to((dummy_class, dummy_class)))
-        self.assertRaises(
-            ValueError, lambda: SExp.to((dummy_class, dummy_class, dummy_class))
-        )
+        with self.assertRaises(ValueError):
+            s = SExp.to((dummy_class, dummy_class))
+            # conversions are deferred, this is where it will fail:
+            b = list(s.as_iter())
+            print(b)
+
+        with self.assertRaises(ValueError):
+            s = SExp.to((dummy_class, dummy_class, dummy_class))
 
     def test_clvm_object_tuple(self):
         o1 = CLVMObject(b"foo")