astreum 0.1.3__tar.gz → 0.1.5__tar.gz

{astreum-0.1.3 → astreum-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: astreum
-Version: 0.1.3
+Version: 0.1.5
 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.3 → astreum-0.1.5}/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.3 → astreum-0.1.5}/pyproject.toml

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

astreum-0.1.5/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.3/src/astreum/machine → astreum-0.1.5/src/astreum/lispeum}/parser.py

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

astreum-0.1.5/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.5/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.5/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.5/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.5/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.5/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.5/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.5/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.5/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.3/src/astreum/machine → astreum-0.1.5/src/astreum/lispeum}/tokenizer.py

@@ -3,7 +3,7 @@
 # Tokenizer function
 from typing import List
 
-from src.astreum.machine.error import ParseError
+from astreum.machine.error import ParseError
 
 
 def tokenize(input: str) -> List[str]:

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

@@ -0,0 +1,255 @@
+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):
+        self.global_env = Environment()
+        
+        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)}")

{astreum-0.1.3 → astreum-0.1.5}/src/astreum/machine/environment.py

@@ -1,5 +1,5 @@
 from typing import Dict, Optional
-from src.astreum.machine.expression import Expr
+from astreum.lispeum.expression import Expr
 
 
 class Environment:

{astreum-0.1.3 → astreum-0.1.5}/src/astreum.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: astreum
-Version: 0.1.3
+Version: 0.1.5
 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.5/src/astreum.egg-info/SOURCES.txt

@@ -0,0 +1,28 @@
+LICENSE
+README.md
+pyproject.toml
+src/astreum/__init__.py
+src/astreum.egg-info/PKG-INFO
+src/astreum.egg-info/SOURCES.txt
+src/astreum.egg-info/dependency_links.txt
+src/astreum.egg-info/top_level.txt
+src/astreum/lispeum/__init__.py
+src/astreum/lispeum/expression.py
+src/astreum/lispeum/parser.py
+src/astreum/lispeum/tokenizer.py
+src/astreum/lispeum/special/__init__.py
+src/astreum/lispeum/special/definition.py
+src/astreum/lispeum/special/list/__init__.py
+src/astreum/lispeum/special/list/all.py
+src/astreum/lispeum/special/list/any.py
+src/astreum/lispeum/special/list/fold.py
+src/astreum/lispeum/special/list/get.py
+src/astreum/lispeum/special/list/insert.py
+src/astreum/lispeum/special/list/map.py
+src/astreum/lispeum/special/list/position.py
+src/astreum/lispeum/special/list/remove.py
+src/astreum/lispeum/special/number/__init__.py
+src/astreum/lispeum/special/number/addition.py
+src/astreum/machine/__init__.py
+src/astreum/machine/environment.py
+src/astreum/machine/error.py

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

@@ -1,121 +0,0 @@
-import threading
-from typing import Callable, Dict, List, Optional, Tuple
-import uuid
-
-from src.astreum.machine.environment import Environment
-from src.astreum.machine.expression import Expr
-from src.astreum.machine.tokenizer import tokenize
-from src.astreum.machine.parser import parse
-
-class AstreumMachine:
-    def __init__(self):
-        self.global_env = Environment()
-        
-        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) -> Tuple[Optional[Expr], Optional[str]]:
-        session_env = self.get_session_env(session_id)
-        if session_env is None:
-            return None, 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, None
-        except Exception as e:
-            return None, str(e)
-    
-    def evaluate_expression(self, expr: Expr, env: Environment) -> Expr:
-        if isinstance(expr, Expr.Integer):
-            return expr
-        
-        elif isinstance(expr, Expr.String):
-            return expr
-        
-        elif isinstance(expr, Expr.Symbol):
-            value = env.get(expr.value)
-            if value is not None:
-                return value
-            else:
-                raise ValueError("Variable not found in environments.")
-        
-        elif isinstance(expr, Expr.ListExpr):
-            if not expr.elements:
-                raise ValueError("Empty list cannot be evaluated.")
-            
-            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) 
-                    args = expr.elements[1:]
-                    
-                    if len(fn_params) != len(args):
-                        raise ValueError(f"Expected {len(fn_params)} arguments, got {len(args)}.")
-                    
-                    # Create a new environment for the function execution, inheriting from the function's defining environment
-                    new_env = Environment(parent=env)
-                    
-                    # Evaluate and bind each argument
-                    for param, arg in zip(fn_params, args):
-                        evaluated_arg = self.evaluate_expression(arg, env)
-                        new_env.set(param, evaluated_arg)
-                    
-                    # Evaluate the function body within the new environment
-                    return self.evaluate_expression(fn_body, new_env)
-                
-                elif first.value in ["def", "+"]:
-                    args = expr.elements[1:]
-
-                    match first.value:
-                        case "def":
-                            if len(args) != 2:
-                                raise ValueError("def expects exactly two arguments: a symbol and an expression")
-                            if not isinstance(args[0], Expr.Symbol):
-                                raise ValueError("First argument to def must be a symbol")
-                            
-                            var_name = args[0].value
-                            var_value = self.evaluate_expression(args[1], env)
-                            env.set(var_name, var_value)
-                            return args[0]
-                        
-                        case "+":
-                            evaluated_args = [self.evaluate_expression(arg, env) for arg in args]
-                            if not all(isinstance(arg, Expr.Integer) for arg in evaluated_args):
-                                raise ValueError("All arguments to + must be integers")
-                            
-                            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)}")

astreum-0.1.3/src/astreum/machine/expression.py

@@ -1,50 +0,0 @@
-from typing import List
-
-class Expr:
-    class ListExpr:
-        def __init__(self, elements: List['Expr']):
-            self.elements = elements
-
-        @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})"
-
-    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 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})"

astreum-0.1.3/src/astreum.egg-info/SOURCES.txt

@@ -1,14 +0,0 @@
-LICENSE
-README.md
-pyproject.toml
-src/astreum/__init__.py
-src/astreum.egg-info/PKG-INFO
-src/astreum.egg-info/SOURCES.txt
-src/astreum.egg-info/dependency_links.txt
-src/astreum.egg-info/top_level.txt
-src/astreum/machine/__init__.py
-src/astreum/machine/environment.py
-src/astreum/machine/error.py
-src/astreum/machine/expression.py
-src/astreum/machine/parser.py
-src/astreum/machine/tokenizer.py