astreum 0.1.2__py3-none-any.whl → 0.1.3__py3-none-any.whl

astreum/machine/__init__.py

@@ -9,30 +9,19 @@ 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]
@@ -41,123 +30,92 @@ class AstreumMachine:
                 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:
+        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(expr, env)
+            result = self.evaluate_expression(expr, session_env)
             return result, None
         except Exception as e:
             return None, str(e)
     
-    def evaluate(self, expr: Expr, env: Environment) -> Expr:
-
+    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:
-                # Return the symbol itself if not found in the environment
-                return expr
+                raise ValueError("Variable not found in environments.")
+        
         elif isinstance(expr, Expr.ListExpr):
             if not expr.elements:
-                raise ValueError("Empty list cannot be evaluated")
+                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
+                
+                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 TypeError(f"expected {len(fn_params)} arguments, got {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(arg, env)
+                        evaluated_arg = self.evaluate_expression(arg, env)
                         new_env.set(param, evaluated_arg)
                     
                     # Evaluate the function body within the new environment
-                    return self.evaluate(fn_body, new_env)
+                    return self.evaluate_expression(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")
+                                raise ValueError("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")
+                                raise ValueError("First argument to def must be a symbol")
                             
                             var_name = args[0].value
-                            var_value = self.evaluate(args[1], env)
+                            var_value = self.evaluate_expression(args[1], env)
                             env.set(var_name, var_value)
-                            return args[0]  # Return the symbol name
+                            return args[0]
                         
                         case "+":
-                            # Ensure all arguments are integers
-                            evaluated_args = [self.evaluate(arg, env) for arg in args]
+                            evaluated_args = [self.evaluate_expression(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")
+                                raise ValueError("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]
+                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 TypeError(f"Unknown expression type: {type(expr)}")
+            raise ValueError(f"Unknown expression type: {type(expr)}")

astreum/machine/environment.py

@@ -1,5 +1,4 @@
-# Define the Environment class
-from typing import Callable, Dict, List, Optional
+from typing import Dict, Optional
 from src.astreum.machine.expression import Expr
 
 
@@ -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/machine/parser.py

@@ -1,4 +1,3 @@
-# Parser function
 from typing import List, Tuple
 from src.astreum.machine.error import ParseError
 from src.astreum.machine.expression import Expr
@@ -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.dist-info → astreum-0.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: astreum
-Version: 0.1.2
+Version: 0.1.3
 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.3.dist-info/RECORD

@@ -0,0 +1,12 @@
+astreum/__init__.py,sha256=-hmy95qFWlCbmHEcj5sGniM-UtpIn-iwwhVWFrFkd_w,37
+astreum/machine/__init__.py,sha256=xitq5kFvtcBY88w3yEfsV3r75IIwBhoX6x0jx7as2Fw,5240
+astreum/machine/environment.py,sha256=F1zXHTZpfX4GazUbPhgh43j8EdfV5bedS-b4xWBB_NY,611
+astreum/machine/error.py,sha256=MvqBaZZt33rNELNhUJ2lER3TE3aS8WVqsWF2hz2AwoA,38
+astreum/machine/expression.py,sha256=yOovmkiE11IEIjqEuYwuG7-jx6msOpgyzl3C3yD331c,1298
+astreum/machine/parser.py,sha256=5tSAVi5z7laEYZHsoDofEOq4KKTfo5md6epT2Bsgk8o,1199
+astreum/machine/tokenizer.py,sha256=4QzdZ11ocZKxlcjvV54PUxDuZxuL4et_sz3ILwfp3ko,1441
+astreum-0.1.3.dist-info/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
+astreum-0.1.3.dist-info/METADATA,sha256=RoW6ek_WGNmQzA_n5oHrY7YHS6Z2hMJQeF1OoMOL7z4,740
+astreum-0.1.3.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+astreum-0.1.3.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
+astreum-0.1.3.dist-info/RECORD,,

astreum-0.1.2.dist-info/RECORD

@@ -1,12 +0,0 @@
-astreum/__init__.py,sha256=-hmy95qFWlCbmHEcj5sGniM-UtpIn-iwwhVWFrFkd_w,37
-astreum/machine/__init__.py,sha256=H0phu-6FDw3ByJfm8Tm3ewq0MVNHoJhEVeGkqwDZTc8,7481
-astreum/machine/environment.py,sha256=vL6vL4INfWslgK4KfNFvqH__0t25HRJRptrEQM1aofo,805
-astreum/machine/error.py,sha256=MvqBaZZt33rNELNhUJ2lER3TE3aS8WVqsWF2hz2AwoA,38
-astreum/machine/expression.py,sha256=yOovmkiE11IEIjqEuYwuG7-jx6msOpgyzl3C3yD331c,1298
-astreum/machine/parser.py,sha256=k8gPsQppV-61_n-bmOBekIE-6sO1xMYudJBYlwlVw8k,1315
-astreum/machine/tokenizer.py,sha256=4QzdZ11ocZKxlcjvV54PUxDuZxuL4et_sz3ILwfp3ko,1441
-astreum-0.1.2.dist-info/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
-astreum-0.1.2.dist-info/METADATA,sha256=BGnpbctoLafXbPjio-V6i7Bf-3JktwDtokeSeDc1OUA,740
-astreum-0.1.2.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-astreum-0.1.2.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
-astreum-0.1.2.dist-info/RECORD,,