astreum 0.1.8__py3-none-any.whl → 0.1.9__py3-none-any.whl

astreum/lispeum/storage.py

@@ -56,191 +56,139 @@ def _serialize_expr(expr: Any, objects: Dict[bytes, bytes]) -> bytes:
     """
     if expr is None:
         # None type
+        is_leaf = True
         type_bytes = b'N'  # N for None
-        type_hash = hashlib.sha256(type_bytes).digest()
-        objects[type_hash] = type_bytes
         
-        # None values don't need a value leaf, just return the type hash
-        return type_hash
+        # Create the object with leaf flag and body
+        object_bytes = struct.pack("?", is_leaf) + type_bytes
+        object_hash = hashlib.sha256(object_bytes).digest()
+        objects[object_hash] = object_bytes
+        
+        return object_hash
         
     elif isinstance(expr, Expr.ListExpr):
-        # Create type leaf
+        # Create type object
+        is_leaf = False
         type_bytes = b'L'  # L for List
-        type_hash = hashlib.sha256(type_bytes).digest()
-        objects[type_hash] = type_bytes
         
         # Serialize each element and collect their hashes
         element_hashes = []
         for elem in expr.elements:
             elem_hash = _serialize_expr(elem, objects)
             element_hashes.append(elem_hash)
-            
+        
         # Create value leaf with all element hashes
         value_bytes = b''.join(element_hashes)
-        value_hash = hashlib.sha256(value_bytes).digest()
-        objects[value_hash] = value_bytes
         
-        # Create the tree node with type and value
-        tree_bytes = type_hash + value_hash
-        tree_hash = hashlib.sha256(tree_bytes).digest()
-        objects[tree_hash] = tree_bytes
+        # Create the object with leaf flag and body
+        object_bytes = struct.pack("?", is_leaf) + type_bytes + value_bytes
+        object_hash = hashlib.sha256(object_bytes).digest()
+        objects[object_hash] = object_bytes
         
-        return tree_hash
+        return object_hash
         
     elif isinstance(expr, Expr.Symbol):
-        # Create type leaf
+        # Create the object - symbols are leaf nodes
+        is_leaf = True
         type_bytes = b'S'  # S for Symbol
-        type_hash = hashlib.sha256(type_bytes).digest()
-        objects[type_hash] = type_bytes
-        
-        # Create value leaf
         value_bytes = expr.value.encode('utf-8')
-        value_hash = hashlib.sha256(value_bytes).digest()
-        objects[value_hash] = value_bytes
         
-        # Create the tree node with type and value
-        tree_bytes = type_hash + value_hash
-        tree_hash = hashlib.sha256(tree_bytes).digest()
-        objects[tree_hash] = tree_bytes
+        # Create the object with leaf flag and body
+        object_bytes = struct.pack("?", is_leaf) + type_bytes + value_bytes
+        object_hash = hashlib.sha256(object_bytes).digest()
+        objects[object_hash] = object_bytes
         
-        return tree_hash
+        return object_hash
         
     elif isinstance(expr, Expr.Integer):
-        # Create type leaf
+        # Create the object - integers are leaf nodes
+        is_leaf = True
         type_bytes = b'I'  # I for Integer
-        type_hash = hashlib.sha256(type_bytes).digest()
-        objects[type_hash] = type_bytes
-        
-        # Create value leaf - use 2's complement little endian for integers
         value_bytes = struct.pack("<q", expr.value)  # 8-byte little endian
-        value_hash = hashlib.sha256(value_bytes).digest()
-        objects[value_hash] = value_bytes
         
-        # Create the tree node with type and value
-        tree_bytes = type_hash + value_hash
-        tree_hash = hashlib.sha256(tree_bytes).digest()
-        objects[tree_hash] = tree_bytes
+        # Create the object with leaf flag and body
+        object_bytes = struct.pack("?", is_leaf) + type_bytes + value_bytes
+        object_hash = hashlib.sha256(object_bytes).digest()
+        objects[object_hash] = object_bytes
         
-        return tree_hash
+        return object_hash
         
     elif isinstance(expr, Expr.String):
-        # Create type leaf
+        # Create the object - strings are leaf nodes
+        is_leaf = True
         type_bytes = b'T'  # T for Text/String
-        type_hash = hashlib.sha256(type_bytes).digest()
-        objects[type_hash] = type_bytes
-        
-        # Create value leaf
         value_bytes = expr.value.encode('utf-8')
-        value_hash = hashlib.sha256(value_bytes).digest()
-        objects[value_hash] = value_bytes
         
-        # Create the tree node with type and value
-        tree_bytes = type_hash + value_hash
-        tree_hash = hashlib.sha256(tree_bytes).digest()
-        objects[tree_hash] = tree_bytes
+        # Create the object with leaf flag and body
+        object_bytes = struct.pack("?", is_leaf) + type_bytes + value_bytes
+        object_hash = hashlib.sha256(object_bytes).digest()
+        objects[object_hash] = object_bytes
         
-        return tree_hash
+        return object_hash
         
     elif isinstance(expr, Expr.Boolean):
-        # Create type leaf
+        # Create the object - booleans are leaf nodes
+        is_leaf = True
         type_bytes = b'B'  # B for Boolean
-        type_hash = hashlib.sha256(type_bytes).digest()
-        objects[type_hash] = type_bytes
-        
-        # Create value leaf
         value_bytes = b'1' if expr.value else b'0'
-        value_hash = hashlib.sha256(value_bytes).digest()
-        objects[value_hash] = value_bytes
         
-        # Create the tree node with type and value
-        tree_bytes = type_hash + value_hash
-        tree_hash = hashlib.sha256(tree_bytes).digest()
-        objects[tree_hash] = tree_bytes
+        # Create the object with leaf flag and body
+        object_bytes = struct.pack("?", is_leaf) + type_bytes + value_bytes
+        object_hash = hashlib.sha256(object_bytes).digest()
+        objects[object_hash] = object_bytes
         
-        return tree_hash
+        return object_hash
         
     elif isinstance(expr, Expr.Function):
-        # Create type leaf
+        # Create the object - functions are not leaf nodes
+        is_leaf = False
         type_bytes = b'F'  # F for Function
-        type_hash = hashlib.sha256(type_bytes).digest()
-        objects[type_hash] = type_bytes
         
         # Serialize params
         params_list = []
         for param in expr.params:
             params_list.append(param.encode('utf-8'))
         params_bytes = b','.join(params_list)
-        params_hash = hashlib.sha256(params_bytes).digest()
-        objects[params_hash] = params_bytes
         
         # Serialize body recursively
         body_hash = _serialize_expr(expr.body, objects)
         
-        # Combine params and body hashes for the value
-        value_bytes = params_hash + body_hash
-        value_hash = hashlib.sha256(value_bytes).digest()
-        objects[value_hash] = value_bytes
-        
-        # Create the tree node with type and value
-        tree_bytes = type_hash + value_hash
-        tree_hash = hashlib.sha256(tree_bytes).digest()
-        objects[tree_hash] = tree_bytes
+        # Create the object with leaf flag and body
+        object_bytes = struct.pack("?", is_leaf) + type_bytes + params_bytes + body_hash
+        object_hash = hashlib.sha256(object_bytes).digest()
+        objects[object_hash] = object_bytes
         
-        return tree_hash
+        return object_hash
         
     elif isinstance(expr, Expr.Error):
-        # Create type leaf
+        # Create the object - errors are not leaf nodes
+        is_leaf = False
         type_bytes = b'E'  # E for Error
-        type_hash = hashlib.sha256(type_bytes).digest()
-        objects[type_hash] = type_bytes
         
         # Serialize error components
         category_bytes = expr.category.encode('utf-8')
-        category_hash = hashlib.sha256(category_bytes).digest()
-        objects[category_hash] = category_bytes
-        
         message_bytes = expr.message.encode('utf-8')
-        message_hash = hashlib.sha256(message_bytes).digest()
-        objects[message_hash] = message_bytes
-        
-        if expr.details:
-            details_bytes = expr.details.encode('utf-8')
-            details_hash = hashlib.sha256(details_bytes).digest()
-            objects[details_hash] = details_bytes
-            
-            # Combine all three components
-            value_bytes = category_hash + message_hash + details_hash
-        else:
-            # Just combine category and message
-            value_bytes = category_hash + message_hash
-            
-        value_hash = hashlib.sha256(value_bytes).digest()
-        objects[value_hash] = value_bytes
+        details_bytes = b'' if expr.details is None else expr.details.encode('utf-8')
         
-        # Create the tree node with type and value
-        tree_bytes = type_hash + value_hash
-        tree_hash = hashlib.sha256(tree_bytes).digest()
-        objects[tree_hash] = tree_bytes
-        
-        return tree_hash
+        # Create the object with leaf flag and body
+        object_bytes = struct.pack("?", is_leaf) + type_bytes + category_bytes + b'\0' + message_bytes + b'\0' + details_bytes
+        object_hash = hashlib.sha256(object_bytes).digest()
+        objects[object_hash] = object_bytes
         
+        return object_hash
+    
     else:
-        # Unknown type - serialize as string
+        # Default fallback for unknown types
+        is_leaf = True
         type_bytes = b'U'  # U for Unknown
-        type_hash = hashlib.sha256(type_bytes).digest()
-        objects[type_hash] = type_bytes
-        
-        # Create value leaf with string representation
         value_bytes = str(expr).encode('utf-8')
-        value_hash = hashlib.sha256(value_bytes).digest()
-        objects[value_hash] = value_bytes
         
-        # Create the tree node with type and value
-        tree_bytes = type_hash + value_hash
-        tree_hash = hashlib.sha256(tree_bytes).digest()
-        objects[tree_hash] = tree_bytes
+        # Create the object with leaf flag and body
+        object_bytes = struct.pack("?", is_leaf) + type_bytes + value_bytes
+        object_hash = hashlib.sha256(object_bytes).digest()
+        objects[object_hash] = object_bytes
         
-        return tree_hash
+        return object_hash
 
 
 def _deserialize_expr(obj_hash: bytes, objects: Dict[bytes, bytes]) -> Any:
@@ -257,93 +205,92 @@ def _deserialize_expr(obj_hash: bytes, objects: Dict[bytes, bytes]) -> Any:
     if obj_hash not in objects:
         return None
         
-    obj_data = objects[obj_hash]
+    obj_bytes = objects[obj_hash]
+    
+    # Extract leaf flag
+    is_leaf = struct.unpack("?", obj_bytes[0:1])[0]
     
-    # Check if this is a type-only node (for None)
-    if len(obj_data) == 1:
-        if obj_data == b'N':
-            return None
-        return None  # Unrecognized single-byte type
+    # Get type indicator
+    type_indicator = obj_bytes[1:2]
     
-    # For regular nodes, expect 64 bytes (two 32-byte hashes)
-    if len(obj_data) == 64:
-        type_hash = obj_data[:32]
-        value_hash = obj_data[32:]
+    # Deserialize based on type
+    if type_indicator == b'N':  # None
+        return None
         
-        if type_hash not in objects or value_hash not in objects:
-            return None
-            
-        type_data = objects[type_hash]
-        value_data = objects[value_hash]
-        
-        # Switch based on the type marker
-        if type_data == b'L':  # List
-            elements = []
-            # Each hash is 32 bytes
-            hash_size = 32
-            for i in range(0, len(value_data), hash_size):
-                elem_hash = value_data[i:i+hash_size]
-                if elem_hash:
-                    elem = _deserialize_expr(elem_hash, objects)
-                    elements.append(elem)
-            return Expr.ListExpr(elements)
-            
-        elif type_data == b'S':  # Symbol
-            return Expr.Symbol(value_data.decode('utf-8'))
-            
-        elif type_data == b'I':  # Integer
-            int_value = struct.unpack("<q", value_data)[0]
-            return Expr.Integer(int_value)
-            
-        elif type_data == b'T':  # String (Text)
-            return Expr.String(value_data.decode('utf-8'))
-            
-        elif type_data == b'B':  # Boolean
-            return Expr.Boolean(value_data == b'1')
-            
-        elif type_data == b'F':  # Function
-            # Value contains params_hash and body_hash
-            params_hash = value_data[:32]
-            body_hash = value_data[32:]
-            
-            if params_hash not in objects:
-                return None
-                
-            params_data = objects[params_hash]
-            params = [p.decode('utf-8') for p in params_data.split(b',') if p]
-            
-            body = _deserialize_expr(body_hash, objects)
-            return Expr.Function(params, body)
-            
-        elif type_data == b'E':  # Error
-            # Check if we have details or just category and message
-            if len(value_data) == 64:  # No details
-                category_hash = value_data[:32]
-                message_hash = value_data[32:]
-                details_hash = None
-            elif len(value_data) == 96:  # With details
-                category_hash = value_data[:32]
-                message_hash = value_data[32:64]
-                details_hash = value_data[64:]
-            else:
-                return None
-                
-            if category_hash not in objects or message_hash not in objects:
-                return None
-                
-            category = objects[category_hash].decode('utf-8')
-            message = objects[message_hash].decode('utf-8')
-            
-            details = None
-            if details_hash and details_hash in objects:
-                details = objects[details_hash].decode('utf-8')
-                
-            return Expr.Error(category, message, details)
+    elif type_indicator == b'L':  # List
+        if is_leaf:
+            # Empty list
+            return Expr.ListExpr([])
+        
+        # Non-leaf list has child element hashes
+        elements_bytes = obj_bytes[2:]
+        element_hashes = [elements_bytes[i:i+32] for i in range(0, len(elements_bytes), 32)]
+        
+        # Deserialize each element
+        elements = []
+        for elem_hash in element_hashes:
+            elem = _deserialize_expr(elem_hash, objects)
+            elements.append(elem)
             
-        elif type_data == b'U':  # Unknown
-            return Expr.String(value_data.decode('utf-8'))
+        return Expr.ListExpr(elements)
+        
+    elif type_indicator == b'S':  # Symbol
+        value_bytes = obj_bytes[2:]
+        return Expr.Symbol(value_bytes.decode('utf-8'))
+        
+    elif type_indicator == b'I':  # Integer
+        value_bytes = obj_bytes[2:10]  # 8 bytes for int64
+        value = struct.unpack("<q", value_bytes)[0]
+        return Expr.Integer(value)
+        
+    elif type_indicator == b'T':  # Text/String
+        value_bytes = obj_bytes[2:]
+        return Expr.String(value_bytes.decode('utf-8'))
+        
+    elif type_indicator == b'B':  # Boolean
+        value_bytes = obj_bytes[2:3]
+        return Expr.Boolean(value_bytes == b'1')
+        
+    elif type_indicator == b'F':  # Function
+        # Non-leaf function
+        remaining_bytes = obj_bytes[2:]
+        
+        # Find the separator between params and body hash
+        params_end = remaining_bytes.find(b',', remaining_bytes.rfind(b','))
+        if params_end == -1:
+            params_end = 0  # No params
             
-    return None  # Unrecognized format
+        params_bytes = remaining_bytes[:params_end+1]
+        body_hash = remaining_bytes[params_end+1:]
+        
+        # Parse params
+        params = []
+        if params_bytes:
+            for param_bytes in params_bytes.split(b','):
+                if param_bytes:  # Skip empty strings
+                    params.append(param_bytes.decode('utf-8'))
+        
+        # Deserialize body
+        body = _deserialize_expr(body_hash, objects)
+        
+        return Expr.Function(params, body)
+        
+    elif type_indicator == b'E':  # Error
+        remaining_bytes = obj_bytes[2:]
+        
+        # Split by null bytes to get category, message, and details
+        parts = remaining_bytes.split(b'\0', 2)
+        
+        category = parts[0].decode('utf-8')
+        message = parts[1].decode('utf-8') if len(parts) > 1 else ""
+        details = parts[2].decode('utf-8') if len(parts) > 2 else None
+        
+        return Expr.Error(category, message, details)
+        
+    else:  # Unknown
+        value_bytes = obj_bytes[2:]
+        # Return as a string
+        return value_bytes.decode('utf-8')
 
 
 def store_expr(expr: Any, storage) -> bytes:
@@ -357,101 +304,107 @@ def store_expr(expr: Any, storage) -> bytes:
     Returns:
         The hash of the root object
     """
+    # Convert expression to objects
     root_hash, objects = expr_to_objects(expr)
     
-    # Store all objects in the storage
+    # Store each object in the storage
     for obj_hash, obj_data in objects.items():
         storage.put(obj_hash, obj_data)
-        
+    
     return root_hash
 
 
-def get_expr_from_storage(root_hash: bytes, storage) -> Any:
+def get_expr_from_storage(root_hash: bytes, storage, max_depth: int = 50) -> Any:
     """
-    Load a Lispeum expression from storage.
+    Load a Lispeum expression from storage. Will recursively resolve
+    objects from the storage until a leaf node is reached.
     
     Args:
         root_hash: The hash of the root object
-        storage: Storage interface with get(key) method
+        storage: Storage interface with get method and get_recursive method
+        max_depth: Maximum recursion depth for resolution
         
     Returns:
         The loaded Lispeum expression, or None if not found
     """
-    if not root_hash:
+    # Check if storage has the get_recursive method (newer storage interface)
+    if hasattr(storage, 'get_recursive'):
+        # Use the storage's built-in recursive retrieval
+        objects = storage.get_recursive(root_hash, max_depth)
+    else:
+        # Fallback to manual recursive retrieval for older storage interfaces
+        objects = {}
+        _load_objects_recursive(root_hash, storage, objects, max_depth)
+    
+    # If no objects were retrieved, return None
+    if not objects:
         return None
         
-    # Build the objects dictionary from storage
-    objects = {}
-    queue = [root_hash]
-    visited = set()
+    # Deserialize the expression
+    return objects_to_expr(root_hash, objects)
+
+
+def _load_objects_recursive(obj_hash: bytes, storage, objects: Dict[bytes, bytes], max_depth: int, current_depth: int = 0) -> bool:
+    """
+    Recursively load objects from storage.
     
-    while queue:
-        current_hash = queue.pop(0)
-        if current_hash in visited:
-            continue
-            
-        visited.add(current_hash)
-        obj_data = storage.get(current_hash)
-        
-        if not obj_data:
-            # Can't find an object, return None
-            return None
-            
-        objects[current_hash] = obj_data
+    Args:
+        obj_hash: The hash of the object to load
+        storage: Storage interface with get(key) method
+        objects: Dictionary to store loaded objects
+        max_depth: Maximum recursion depth
+        current_depth: Current recursion depth
         
-        # For single-byte nodes (e.g., None), no further processing needed
-        if len(obj_data) == 1:
-            continue
+    Returns:
+        True if object was loaded, False otherwise
+    """
+    # Check if we've reached max recursion depth
+    if current_depth >= max_depth:
+        print(f"Warning: Max recursion depth {max_depth} reached while loading objects")
+        return False
+        
+    # Check if we already have this object
+    if obj_hash in objects:
+        return True
+        
+    # Load the object from storage
+    obj_data = storage.get(obj_hash)
+    if obj_data is None:
+        return False
+        
+    # Store the object
+    objects[obj_hash] = obj_data
+    
+    # Check if this is a leaf node
+    is_leaf = struct.unpack("?", obj_data[0:1])[0]
+    if is_leaf:
+        # Leaf node, no need to recurse
+        return True
+        
+    # For non-leaf nodes, recursively load child objects
+    type_indicator = obj_data[1:2]
+    
+    if type_indicator == b'L':  # List
+        # Non-leaf list has child element hashes
+        elements_bytes = obj_data[2:]
+        element_hashes = [elements_bytes[i:i+32] for i in range(0, len(elements_bytes), 32)]
+        
+        # Load each element
+        for elem_hash in element_hashes:
+            _load_objects_recursive(elem_hash, storage, objects, max_depth, current_depth + 1)
             
-        # For regular tree nodes (type + value)
-        if len(obj_data) == 64:
-            # Add both hashes to the queue
-            type_hash = obj_data[:32]
-            value_hash = obj_data[32:]
+    elif type_indicator == b'F':  # Function
+        # Non-leaf function has body hash
+        remaining_bytes = obj_data[2:]
+        
+        # Find the separator between params and body hash
+        params_end = remaining_bytes.find(b',', remaining_bytes.rfind(b','))
+        if params_end == -1:
+            params_end = 0  # No params
             
-            if type_hash not in visited:
-                queue.append(type_hash)
-                
-            if value_hash not in visited:
-                queue.append(value_hash)
-                
-            # For function and error types, we need to check the value fields
-            # which might contain additional hashes
-            if type_hash in objects:
-                type_data = objects[type_hash]
-                
-                # For Function type, the value contains params_hash + body_hash
-                if type_data == b'F' and value_hash in objects:
-                    value_data = objects[value_hash]
-                    if len(value_data) == 64:
-                        params_hash = value_data[:32]
-                        body_hash = value_data[32:]
-                        
-                        if params_hash not in visited:
-                            queue.append(params_hash)
-                            
-                        if body_hash not in visited:
-                            queue.append(body_hash)
-                
-                # For Error type, the value contains category_hash + message_hash + [details_hash]
-                elif type_data == b'E' and value_hash in objects:
-                    value_data = objects[value_hash]
-                    hash_size = 32
-                    
-                    for i in range(0, len(value_data), hash_size):
-                        component_hash = value_data[i:i+hash_size]
-                        if component_hash and component_hash not in visited:
-                            queue.append(component_hash)
-                
-                # For List type, the value contains all element hashes
-                elif type_data == b'L' and value_hash in objects:
-                    value_data = objects[value_hash]
-                    hash_size = 32
-                    
-                    for i in range(0, len(value_data), hash_size):
-                        elem_hash = value_data[i:i+hash_size]
-                        if elem_hash and elem_hash not in visited:
-                            queue.append(elem_hash)
+        body_hash = remaining_bytes[params_end+1:]
+        
+        # Load body
+        _load_objects_recursive(body_hash, storage, objects, max_depth, current_depth + 1)
     
-    # Reconstruct the expression from objects
-    return objects_to_expr(root_hash, objects)
+    return True