astreum 0.1.4__tar.gz → 0.1.6__tar.gz

{astreum-0.1.4 → astreum-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: astreum
-Version: 0.1.4
+Version: 0.1.6
 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
@@ -20,5 +20,5 @@ Python library to interact with the Astreum blockchain and its Lispeum virtual m
 
 ## Testing
 
-python -m unittest discover -s tests
+python3 -m unittest discover -s tests
 

{astreum-0.1.4 → astreum-0.1.6}/README.md

@@ -6,5 +6,5 @@ Python library to interact with the Astreum blockchain and its Lispeum virtual m
 
 ## Testing
 
-python -m unittest discover -s tests
+python3 -m unittest discover -s tests
 

{astreum-0.1.4 → astreum-0.1.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "astreum"
-version = "0.1.4"
+version = "0.1.6"
 authors = [
   { name="Roy R. O. Okello", email="roy@stelar.xyz" },
 ]

{astreum-0.1.4 → astreum-0.1.6}/src/astreum/__init__.py

@@ -1 +1,2 @@
 from .machine import AstreumMachine
+from .node import Node

astreum-0.1.6/src/astreum/lispeum/expression.py

@@ -0,0 +1,95 @@
+from typing import List, Union
+
+class Expr:
+    class ListExpr:
+        def __init__(self, elements: List['Expr']):
+            self.elements = elements
+
+        def __eq__(self, other):
+            if not isinstance(other, Expr.ListExpr):
+                return NotImplemented
+            return self.elements == other.elements
+
+        def __ne__(self, other):
+            return not self.__eq__(other)
+
+        @property
+        def value(self):
+            inner = " ".join(str(e) for e in self.elements)
+            return f"({inner})"
+
+
+        def __repr__(self):
+            if not self.elements:
+                return "()"
+            
+            inner = " ".join(str(e) for e in self.elements)
+            return f"({inner})"
+        
+        def __iter__(self):
+            return iter(self.elements)
+        
+        def __getitem__(self, index: Union[int, slice]):
+            return self.elements[index]
+
+        def __len__(self):
+            return len(self.elements)
+
+    class Symbol:
+        def __init__(self, value: str):
+            self.value = value
+
+        def __repr__(self):
+            return self.value
+
+    class Integer:
+        def __init__(self, value: int):
+            self.value = value
+
+        def __repr__(self):
+            return str(self.value)
+
+    class String:
+        def __init__(self, value: str):
+            self.value = value
+
+        def __repr__(self):
+            return f'"{self.value}"'
+        
+    class Boolean:
+        def __init__(self, value: bool):
+            self.value = value
+
+        def __repr__(self):
+            return "true" if self.value else "false"
+
+    class Function:
+        def __init__(self, params: List[str], body: 'Expr'):
+            self.params = params
+            self.body = body
+
+        def __repr__(self):
+            params_str = " ".join(self.params)
+            body_str = str(self.body)
+            return f"(fn ({params_str}) {body_str})"
+        
+    class Error:
+        """
+        Represents an error with a freeform category and message.
+        - `category`: A string identifying the type of error (e.g., 'SyntaxError').
+        - `message`: A human-readable description of the error.
+        - `details`: Optional, additional information about the error.
+        """
+        def __init__(self, category: str, message: str, details: str = None):
+            if not category:
+                raise ValueError("Error category must be provided.")
+            if not message:
+                raise ValueError("Error message must be provided.")
+            self.category = category
+            self.message = message
+            self.details = details
+
+        def __repr__(self):
+            if self.details:
+                return f'({self.category} "{self.message}" {self.details})'
+            return f'({self.category} "{self.message}")'

{astreum-0.1.4/src/astreum/machine → astreum-0.1.6/src/astreum/lispeum}/parser.py

@@ -1,6 +1,6 @@
 from typing import List, Tuple
 from astreum.machine.error import ParseError
-from astreum.machine.expression import Expr
+from astreum.lispeum.expression import Expr
 
 
 def parse(tokens: List[str]) -> Tuple[Expr, List[str]]:

astreum-0.1.6/src/astreum/lispeum/special/definition.py

@@ -0,0 +1,27 @@
+from astreum.lispeum.expression import Expr
+from astreum.machine.environment import Environment
+
+
+def handle_definition(machine, args: Expr.ListExpr, env: Environment) -> Expr:
+        if len(args) != 2:
+            return Expr.Error(
+                category="SyntaxError",
+                message="def expects exactly two arguments: a symbol and an expression"
+            )
+        
+        if not isinstance(args[0], Expr.Symbol):
+            return Expr.Error(
+                category="TypeError",
+                message="First argument to def must be a symbol"
+            )
+    
+        var_name = args[0].value
+
+        result = machine.evaluate_expression(args[1], env)
+
+        if isinstance(result, Expr.Error):
+            return result
+
+        env.set(var_name, result)
+    
+        return result

astreum-0.1.6/src/astreum/lispeum/special/list/all.py

@@ -0,0 +1,32 @@
+from astreum.lispeum.expression import Expr
+from astreum.machine.environment import Environment
+
+def handle_list_all(machine, list: Expr.ListExpr, predicate: Expr.Function, env: Environment) -> Expr:
+    if not isinstance(list, Expr.ListExpr):
+        return Expr.ListExpr([
+            Expr.ListExpr([]),
+            Expr.String("First argument must be a list")
+        ])
+    
+    if not isinstance(predicate, Expr.Function):
+        return Expr.ListExpr([
+            Expr.ListExpr([]),
+            Expr.String("Second argument must be a function")
+        ])
+    
+    for elem in list.elements:
+        new_env = Environment(parent=env)
+        new_env.set(predicate.params[0], elem)
+        
+        result, _ = machine.evaluate_expression(predicate, new_env)
+
+        if result == Expr.Boolean(False):
+            return Expr.ListExpr([
+                Expr.Boolean(False),
+                Expr.ListExpr([])
+            ])
+    
+    return Expr.ListExpr([
+        Expr.Boolean(True),
+        Expr.ListExpr([])
+    ])

astreum-0.1.6/src/astreum/lispeum/special/list/any.py

@@ -0,0 +1,32 @@
+from astreum.lispeum.expression import Expr
+from astreum.machine.environment import Environment
+
+def handle_list_any(machine, list: Expr.ListExpr, predicate: Expr.Function, env: Environment) -> Expr:
+    if not isinstance(list, Expr.ListExpr):
+        return Expr.ListExpr([
+            Expr.ListExpr([]),
+            Expr.String("First argument must be a list")
+        ])
+    
+    if not isinstance(predicate, Expr.Function):
+        return Expr.ListExpr([
+            Expr.ListExpr([]),
+            Expr.String("Second argument must be a function")
+        ])
+    
+    for elem in list.elements:
+        new_env = Environment(parent=env)
+        new_env.set(predicate.params[0], elem)
+        
+        result, _ = machine.evaluate_expression(predicate, new_env)
+
+        if result == Expr.Boolean(True):
+            return Expr.ListExpr([
+                Expr.Boolean(True),
+                Expr.ListExpr([])
+            ])
+    
+    return Expr.ListExpr([
+        Expr.Boolean(False),
+        Expr.ListExpr([])
+    ])

astreum-0.1.6/src/astreum/lispeum/special/list/fold.py

@@ -0,0 +1,29 @@
+from astreum.lispeum.expression import Expr
+from astreum.machine.environment import Environment
+
+
+def handle_list_fold(machine, list: Expr.ListExpr, initial: Expr, func: Expr.Function, env: Environment) -> Expr:
+    if not isinstance(list, Expr.ListExpr):
+        return Expr.ListExpr([
+            Expr.ListExpr([]),
+            Expr.String("First argument must be a list")
+        ])
+    
+    if not isinstance(func, Expr.Function):
+        return Expr.ListExpr([
+            Expr.ListExpr([]),
+            Expr.String("Third argument must be a function")
+        ])
+    
+    result = initial
+    for elem in list.elements:
+        new_env = Environment(parent=env)
+        new_env.set(func.params[0], result)
+        new_env.set(func.params[1], elem)
+        
+        result = machine.evaluate_expression(func, new_env)
+    
+    return Expr.ListExpr([
+        result,
+        Expr.ListExpr([])
+    ])

astreum-0.1.6/src/astreum/lispeum/special/list/get.py

@@ -0,0 +1,20 @@
+
+
+from astreum.lispeum.expression import Expr
+from astreum.machine.environment import Environment
+
+
+def handle_list_get(machine, list: Expr.ListExpr, index: Expr.Integer, env: Environment) -> Expr:
+    if not isinstance(list, Expr.ListExpr):
+        return Expr.ListExpr([
+            Expr.ListExpr([]),
+            Expr.String("First argument must be a list")
+        ])
+    
+    if index.value < 0 or index.value >= len(list.elements):
+        return Expr.ListExpr([
+            Expr.ListExpr([]),
+            Expr.String("Index out of bounds")
+        ])
+    
+    return machine.evaluate_expression(list.elements[index])

astreum-0.1.6/src/astreum/lispeum/special/list/insert.py

@@ -0,0 +1,23 @@
+from astreum.lispeum.expression import Expr
+
+
+def handle_list_insert(list: Expr.ListExpr, index: Expr.Integer, value: Expr) -> Expr:
+    if not isinstance(list, Expr.ListExpr):
+        return Expr.ListExpr([
+            Expr.ListExpr([]),
+            Expr.String("First argument must be a list")
+        ])
+    
+    if index.value < 0 or index.value > len(list.elements):
+        return Expr.ListExpr([
+            Expr.ListExpr([]),
+            Expr.String("Index out of bounds")
+        ])
+    
+    new_elements = list.elements[:index.value] + [value] + list.elements[index.value:]
+    
+    return Expr.ListExpr([
+        Expr.ListExpr(new_elements),
+        Expr.ListExpr([])
+    ])
+    

astreum-0.1.6/src/astreum/lispeum/special/list/map.py

@@ -0,0 +1,30 @@
+from astreum.lispeum.expression import Expr
+from astreum.machine.environment import Environment
+
+
+def handle_list_map(machine, list: Expr.ListExpr, func: Expr.Function, env: Environment) -> Expr:
+    if not isinstance(list, Expr.ListExpr):
+        return Expr.ListExpr([
+            Expr.ListExpr([]),
+            Expr.String("First argument must be a list")
+        ])
+    
+    if not isinstance(func, Expr.Function):
+        return Expr.ListExpr([
+            Expr.ListExpr([]),
+            Expr.String("Second argument must be a function")
+        ])
+    
+    mapped_elements = []
+    for elem in list.elements:
+        new_env = Environment(parent=env)
+        new_env.set(func.params[0], elem)
+        
+        mapped_elem = machine.evaluate_expression(func.body, new_env)
+        
+        mapped_elements.append(mapped_elem)
+    
+    return Expr.ListExpr([
+        Expr.ListExpr(mapped_elements),
+        Expr.ListExpr([])
+    ])

astreum-0.1.6/src/astreum/lispeum/special/list/position.py

@@ -0,0 +1,33 @@
+from astreum.lispeum.expression import Expr
+from astreum.machine.environment import Environment
+
+
+def handle_list_position(machine, list: Expr.ListExpr, predicate: Expr.Function, env: Environment) -> Expr:
+    if not isinstance(list, Expr.ListExpr):
+        return Expr.ListExpr([
+            Expr.ListExpr([]),
+            Expr.String("First argument must be a list")
+        ])
+    
+    if not isinstance(predicate, Expr.Function):
+        return Expr.ListExpr([
+            Expr.ListExpr([]),
+            Expr.String("Second argument must be a function")
+        ])
+    
+    for idx, elem in enumerate(list.elements):
+        new_env = Environment(parent=env)
+        new_env.set(predicate.params[0], elem)
+        
+        result, _ = machine.evaluate_expression(predicate, new_env)
+
+        if result == Expr.Boolean(True):
+            return Expr.ListExpr([
+                Expr.Integer(idx),
+                Expr.ListExpr([])
+            ])
+    
+    return Expr.ListExpr([
+        Expr.ListExpr([]),
+        Expr.ListExpr([])
+    ])

astreum-0.1.6/src/astreum/lispeum/special/list/remove.py

@@ -0,0 +1,22 @@
+from astreum.lispeum.expression import Expr
+
+
+def handle_list_remove(list: Expr.ListExpr, index: Expr.Integer) -> Expr:
+    if not isinstance(list, Expr.ListExpr):
+        return Expr.ListExpr([
+            Expr.ListExpr([]),
+            Expr.String("First argument must be a list")
+        ])
+    
+    if index.value < 0 or index.value >= len(list.elements):
+        return Expr.ListExpr([
+            Expr.ListExpr([]),
+            Expr.String("Index out of bounds")
+        ])
+    
+    new_elements = list.elements[:index.value] + list.elements[index.value + 1:]
+    
+    return Expr.ListExpr([
+        Expr.ListExpr(new_elements),
+        Expr.ListExpr([])
+    ])

astreum-0.1.6/src/astreum/machine/__init__.py

@@ -0,0 +1,254 @@
+import threading
+from typing import Dict, Optional
+import uuid
+
+from astreum.lispeum.special.definition import handle_definition
+from astreum.lispeum.special.list.all import handle_list_all
+from astreum.lispeum.special.list.any import handle_list_any
+from astreum.lispeum.special.list.fold import handle_list_fold
+from astreum.lispeum.special.list.get import handle_list_get
+from astreum.lispeum.special.list.insert import handle_list_insert
+from astreum.lispeum.special.list.map import handle_list_map
+from astreum.lispeum.special.list.position import handle_list_position
+from astreum.lispeum.special.list.remove import handle_list_remove
+from astreum.machine.environment import Environment
+from astreum.lispeum.expression import Expr
+from astreum.lispeum.tokenizer import tokenize
+from astreum.lispeum.parser import parse
+
+class AstreumMachine:
+    def __init__(self, node: 'Node' = None):
+        self.global_env = Environment(node=node)
+        self.sessions: Dict[str, Environment] = {}
+        self.lock = threading.Lock()
+         
+    
+    def create_session(self) -> str:
+        session_id = str(uuid.uuid4())
+        with self.lock:
+            self.sessions[session_id] = Environment(parent=self.global_env)
+        return session_id
+    
+    def terminate_session(self, session_id: str) -> bool:
+        with self.lock:
+            if session_id in self.sessions:
+                del self.sessions[session_id]
+                return True
+            else:
+                return False
+    
+    def get_session_env(self, session_id: str) -> Optional[Environment]:
+        with self.lock:
+            return self.sessions.get(session_id, None)
+    
+    def evaluate_code(self, code: str, session_id: str) -> Expr:
+        session_env = self.get_session_env(session_id)
+        if session_env is None:
+            raise ValueError(f"Session ID {session_id} not found.")
+        
+        try:
+            tkns = tokenize(input=code)
+            expr, _ = parse(tokens=tkns)
+            result = self.evaluate_expression(expr, session_env)
+            return result
+        
+        except Exception as e:
+            raise ValueError(e)
+    
+    def evaluate_expression(self, expr: Expr, env: Environment) -> Expr:
+        if isinstance(expr, Expr.Boolean) or isinstance(expr, Expr.Integer) or isinstance(expr, Expr.String) or isinstance(expr, Expr.Error):
+            return expr
+        
+        elif isinstance(expr, Expr.Symbol):
+            value = env.get(expr.value)
+            
+            if value:
+                return value
+            else:
+                return Expr.Error(
+                    category="NameError",
+                    message=f"Variable '{expr.value}' not found in environments."
+                )
+        
+        elif isinstance(expr, Expr.ListExpr):
+            
+            if len(expr.elements) == 0:
+                return expr 
+            
+            if len(expr.elements) == 1:
+                return self.evaluate_expression(expr=expr.elements[0], env=env)
+            
+            first = expr.elements[0]
+
+            if isinstance(first, Expr.Symbol):
+                
+                first_symbol_value = env.get(first.value)
+
+                if first_symbol_value and not isinstance(first_symbol_value, Expr.Function):
+                    evaluated_elements = [self.evaluate_expression(e, env) for e in expr.elements]
+                    return Expr.ListExpr(evaluated_elements)
+                
+                elif first.value == "def":
+                    return handle_definition(
+                        machine=self,
+                        args=expr.elements[1:],
+                        env=env
+                    )
+
+                # List
+                elif first.value == "list.new":
+                    return Expr.ListExpr([self.evaluate_expression(arg, env) for arg in expr.elements[1:]])
+
+                elif first.value == "list.get":
+                    args = expr.elements[1:]
+                    if len(args) != 2:
+                        return Expr.Error(
+                            category="SyntaxError",
+                            message="list.get expects exactly two arguments: a list and an index"
+                        )
+                    list_obj = self.evaluate_expression(args[0], env)
+                    index = self.evaluate_expression(args[1], env)
+                    return handle_list_get(self, list_obj, index, env)
+
+                elif first.value == "list.insert":
+                    args = expr.elements[1:]
+                    if len(args) != 3:
+                        return Expr.ListExpr([
+                            Expr.ListExpr([]),
+                            Expr.String("list.insert expects exactly three arguments: a list, an index, and a value")
+                        ])
+                    
+                    return handle_list_insert(
+                        list=self.evaluate_expression(args[0], env),
+                        index=self.evaluate_expression(args[1], env),
+                        value=self.evaluate_expression(args[2], env),
+                    )
+
+                elif first.value == "list.remove":
+                    args = expr.elements[1:]
+                    if len(args) != 2:
+                        return Expr.ListExpr([
+                            Expr.ListExpr([]),
+                            Expr.String("list.remove expects exactly two arguments: a list and an index")
+                        ])
+                    
+                    return handle_list_remove(
+                        list=self.evaluate_expression(args[0], env),
+                        index=self.evaluate_expression(args[1], env),
+                    )
+
+                elif first.value == "list.length":
+                    args = expr.elements[1:]
+                    if len(args) != 1:
+                        return Expr.ListExpr([
+                            Expr.ListExpr([]),
+                            Expr.String("list.length expects exactly one argument: a list")
+                        ])
+                    
+                    list_obj = self.evaluate_expression(args[0], env)
+                    if not isinstance(list_obj, Expr.ListExpr):
+                        return Expr.ListExpr([
+                            Expr.ListExpr([]),
+                            Expr.String("Argument must be a list")
+                        ])
+                    
+                    return Expr.ListExpr([
+                        Expr.Integer(len(list_obj.elements)),
+                        Expr.ListExpr([]) 
+                    ])
+
+                elif first.value == "list.fold":
+                    if len(args) != 3:
+                        return Expr.ListExpr([
+                            Expr.ListExpr([]),
+                            Expr.String("list.fold expects exactly three arguments: a list, an initial value, and a function")
+                        ])
+                    
+                    return handle_list_fold(
+                        machine=self,
+                        list=self.evaluate_expression(args[0], env),
+                        initial=self.evaluate_expression(args[1], env),
+                        func=self.evaluate_expression(args[2], env),
+                        env=env,
+                    )
+
+                elif first.value == "list.map":
+                    if len(args) != 2:
+                        return Expr.ListExpr([
+                            Expr.ListExpr([]),
+                            Expr.String("list.map expects exactly two arguments: a list and a function")
+                        ])
+                    
+                    return handle_list_map(
+                        machine=self,
+                        list=self.evaluate_expression(args[0], env),
+                        func=self.evaluate_expression(args[1], env),
+                        env=env,
+                    )
+
+                elif first.value == "list.position":
+                    if len(args) != 2:
+                        return Expr.ListExpr([
+                            Expr.ListExpr([]),
+                            Expr.String("list.position expects exactly two arguments: a list and a function")
+                        ])
+                    
+                    return handle_list_position(
+                        machine=self,
+                        list=self.evaluate_expression(args[0], env),
+                        predicate=self.evaluate_expression(args[1], env),
+                        env=env,
+                    )
+
+                elif first.value == "list.any":
+                    if len(args) != 2:
+                        return Expr.ListExpr([
+                            Expr.ListExpr([]),
+                            Expr.String("list.any expects exactly two arguments: a list and a function")
+                        ])
+                    
+                    return handle_list_any(
+                        machine=self,
+                        list=self.evaluate_expression(args[0], env),
+                        predicate=self.evaluate_expression(args[1], env),
+                        env=env,
+                    )
+
+                elif first.value == "list.all":
+                    if len(args) != 2:
+                        return Expr.ListExpr([
+                            Expr.ListExpr([]),
+                            Expr.String("list.all expects exactly two arguments: a list and a function")
+                        ])
+                    
+                    return handle_list_all(
+                        machine=self,
+                        list=self.evaluate_expression(args[0], env),
+                        predicate=self.evaluate_expression(args[1], env),
+                        env=env,
+                    )
+
+                # Number
+                elif first.value == "+":
+                    evaluated_args = [self.evaluate_expression(arg, env) for arg in expr.elements[1:]]
+
+                    # Check for non-integer arguments
+                    if not all(isinstance(arg, Expr.Integer) for arg in evaluated_args):
+                        return Expr.Error(
+                            category="TypeError",
+                            message="All arguments to + must be integers"
+                        )
+                    
+                    # Sum up the integer values
+                    result = sum(arg.value for arg in evaluated_args)
+                    return Expr.Integer(result)
+
+            else:
+                evaluated_elements = [self.evaluate_expression(e, env) for e in expr.elements]
+                return Expr.ListExpr(evaluated_elements)
+            
+        elif isinstance(expr, Expr.Function):
+            return expr
+        
+        else:
+            raise ValueError(f"Unknown expression type: {type(expr)}")