astreum 0.1.2__tar.gz → 0.1.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: astreum
-Version: 0.1.2
+Version: 0.1.4
 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

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

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

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

@@ -0,0 +1,121 @@
+import threading
+from typing import Callable, Dict, List, Optional, Tuple
+import uuid
+
+from astreum.machine.environment import Environment
+from astreum.machine.expression import Expr
+from astreum.machine.tokenizer import tokenize
+from 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.2 → astreum-0.1.4}/src/astreum/machine/environment.py

@@ -1,6 +1,5 @@
-# Define the Environment class
-from typing import Callable, Dict, List, Optional
-from src.astreum.machine.expression import Expr
+from typing import Dict, Optional
+from astreum.machine.expression import Expr
 
 
 class Environment:
@@ -9,11 +8,9 @@ class Environment:
         self.parent = parent
 
     def set(self, name: str, value: Expr):
-        """Set a variable in the current environment."""
         self.data[name] = value
 
     def get(self, name: str) -> Optional[Expr]:
-        """Retrieve a variable's value, searching parent environments if necessary."""
         if name in self.data:
             return self.data[name]
         elif self.parent:

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

@@ -1,7 +1,6 @@
-# Parser function
 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.machine.expression import Expr
 
 
 def parse(tokens: List[str]) -> Tuple[Expr, List[str]]:
@@ -19,7 +18,6 @@ def parse(tokens: List[str]) -> Tuple[Expr, List[str]]:
 
         while inner_tokens:
             if inner_tokens[0] == ')':
-                # End of list
                 return Expr.ListExpr(list_items), inner_tokens[1:]
 
             expr, inner_tokens = parse(inner_tokens)
@@ -35,10 +33,8 @@ def parse(tokens: List[str]) -> Tuple[Expr, List[str]]:
         return Expr.String(string_content), rest
 
     else:
-        # Try to parse as integer
         try:
             number = int(first_token)
             return Expr.Integer(number), rest
         except ValueError:
-            # Treat as symbol
             return Expr.Symbol(first_token), rest

{astreum-0.1.2 → astreum-0.1.4}/src/astreum/machine/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.2 → astreum-0.1.4}/src/astreum.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: astreum
-Version: 0.1.2
+Version: 0.1.4
 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

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

@@ -1,163 +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):
-        # Initialize the global environment
-        self.global_env = Environment()
-        
-        # Dictionary to manage user sessions: session_id -> local Environment
-        self.sessions: Dict[str, Environment] = {}
-        
-        # Lock for thread-safe access to the global environment and sessions
-        self.lock = threading.Lock()
-    
-    def create_session(self) -> str:
-        """
-        Create a new user session with a unique session ID and a fresh local environment.
-        Returns the session ID.
-        """
-        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:
-        """
-        Terminate an existing user session.
-        Returns True if the session was successfully terminated, False otherwise.
-        """
-        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]:
-        """
-        Retrieve the local environment for a given session ID.
-        Returns the Environment if found, None otherwise.
-        """
-        with self.lock:
-            return self.sessions.get(session_id, None)
-    
-    def evaluate_code(self, code: str, session_id: str) -> Tuple[Optional[Expr], Optional[str]]:
-        """
-        Evaluate code within the context of a user's session.
-        Returns a tuple of (Result Expression, Error Message).
-        If evaluation is successful, Error Message is None.
-        If an error occurs, Result Expression is None.
-        """
-        env = self.get_session_env(session_id)
-        if env is None:
-            return None, f"Session ID {session_id} not found."
-        
-        try:
-            tkns = tokenize(input=code)
-            expr, _ = parse(tokens=tkns)
-            result = self.evaluate(expr, env)
-            return result, None
-        except Exception as e:
-            return None, str(e)
-    
-    def evaluate(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:
-                # Return the symbol itself if not found in the environment
-                return expr
-        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):
-                # Check if it's a user-defined function
-                user_def_fn = env.get(first.value)
-                if isinstance(user_def_fn, Expr.Function):
-                    fn_params, fn_body = user_def_fn.params, user_def_fn.body
-                    args = expr.elements[1:]
-                    
-                    if len(fn_params) != len(args):
-                        raise TypeError(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(arg, env)
-                        new_env.set(param, evaluated_arg)
-                    
-                    # Evaluate the function body within the new environment
-                    return self.evaluate(fn_body, new_env)
-                
-                # Check for special functions
-                elif first.value in ["def", "+"]:
-                    args = expr.elements[1:]
-
-                    match first.value:
-                        case "def":
-                            if len(args) != 2:
-                                raise TypeError("def expects exactly two arguments: a symbol and an expression")
-                            if not isinstance(args[0], Expr.Symbol):
-                                raise TypeError("First argument to def must be a symbol")
-                            
-                            var_name = args[0].value
-                            var_value = self.evaluate(args[1], env)
-                            env.set(var_name, var_value)
-                            return args[0]  # Return the symbol name
-                        
-                        case "+":
-                            # Ensure all arguments are integers
-                            evaluated_args = [self.evaluate(arg, env) for arg in args]
-                            if not all(isinstance(arg, Expr.Integer) for arg in evaluated_args):
-                                raise TypeError("All arguments to + must be integers")
-                            
-                            # Sum the integer values and return as an Expr.Integer
-                            result = sum(arg.value for arg in evaluated_args)
-                            return Expr.Integer(result)
-
-                else:
-                    # Attempt to evaluate as a function application
-                    func = self.evaluate(first, env)
-                    if isinstance(func, Expr.Function):
-                        fn_params, fn_body = func.params, func.body
-                        args = expr.elements[1:]
-                        
-                        if len(fn_params) != len(args):
-                            raise TypeError(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=func.env)
-                        
-                        # Evaluate and bind each argument
-                        for param, arg in zip(fn_params, args):
-                            evaluated_arg = self.evaluate(arg, env)
-                            new_env.set(param, evaluated_arg)
-                        
-                        # Evaluate the function body within the new environment
-                        return self.evaluate(fn_body, new_env)
-                    else:
-                        raise TypeError(f"'{first.value}' is not a function")
-            else:
-                evaluated_elements = [self.evaluate(e, env) for e in expr.elements]
-                return Expr.ListExpr(evaluated_elements)
-        elif isinstance(expr, Expr.Function):
-            return expr
-        else:
-            raise TypeError(f"Unknown expression type: {type(expr)}")