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

astreum/machine/__init__.py

@@ -0,0 +1,163 @@
+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)}")

astreum/machine/environment.py

@@ -0,0 +1,25 @@
+# Define the Environment class
+from typing import Callable, Dict, List, Optional
+from src.astreum.machine.expression import Expr
+
+
+class Environment:
+    def __init__(self, parent: 'Environment' = None):
+        self.data: Dict[str, Expr] = {}
+        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:
+            return self.parent.get(name)
+        else:
+            return None
+
+    def __repr__(self):
+        return f"Environment({self.data})"

astreum/machine/error.py

@@ -0,0 +1,2 @@
+class ParseError(Exception):
+    pass

astreum/machine/expression.py

@@ -0,0 +1,50 @@
+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/machine/parser.py

@@ -0,0 +1,44 @@
+# Parser function
+from typing import List, Tuple
+from src.astreum.machine.error import ParseError
+from src.astreum.machine.expression import Expr
+
+
+def parse(tokens: List[str]) -> Tuple[Expr, List[str]]:
+    if not tokens:
+        raise ParseError("Unexpected end of input")
+
+    first_token, *rest = tokens
+
+    if first_token == '(':
+        if not rest:
+            raise ParseError("Expected token after '('")
+
+        list_items = []
+        inner_tokens = rest
+
+        while inner_tokens:
+            if inner_tokens[0] == ')':
+                # End of list
+                return Expr.ListExpr(list_items), inner_tokens[1:]
+
+            expr, inner_tokens = parse(inner_tokens)
+            list_items.append(expr)
+
+        raise ParseError("Expected closing ')'")
+
+    elif first_token == ')':
+        raise ParseError("Unexpected closing parenthesis")
+
+    elif first_token.startswith('"') and first_token.endswith('"'):
+        string_content = first_token[1:-1]
+        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/machine/tokenizer.py

@@ -0,0 +1,52 @@
+
+
+# Tokenizer function
+from typing import List
+
+from src.astreum.machine.error import ParseError
+
+
+def tokenize(input: str) -> List[str]:
+    tokens = []
+    current_token = ""
+    in_string = False
+    escape = False
+
+    for char in input:
+        if in_string:
+            if escape:
+                current_token += char
+                escape = False
+            elif char == '\\':
+                escape = True
+            elif char == '"':
+                in_string = False
+                tokens.append(f'"{current_token}"')
+                current_token = ""
+            else:
+                current_token += char
+        else:
+            if char.isspace():
+                if current_token:
+                    tokens.append(current_token)
+                    current_token = ""
+            elif char == '(' or char == ')':
+                if current_token:
+                    tokens.append(current_token)
+                    current_token = ""
+                tokens.append(char)
+            elif char == '"':
+                if current_token:
+                    tokens.append(current_token)
+                    current_token = ""
+                in_string = True
+            else:
+                current_token += char
+
+    if in_string:
+        raise ParseError("Unterminated string literal")
+
+    if current_token:
+        tokens.append(current_token)
+
+    return tokens

{astreum-0.1.0.dist-info → astreum-0.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: astreum
-Version: 0.1.0
+Version: 0.1.2
 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
@@ -13,4 +13,12 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 
 # lib
+
 Python library to interact with the Astreum blockchain and its Lispeum virtual machine.
+
+[View on PyPI](https://pypi.org/project/astreum/)
+
+## Testing
+
+python -m unittest discover -s tests
+

astreum-0.1.2.dist-info/RECORD

@@ -0,0 +1,12 @@
+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,,

astreum/machine.py

@@ -1,7 +0,0 @@
-class AstreumMachine:
-    def __init__(self):
-        pass
-
-    def execute(self, code: str) -> str:
-        """Returns the input value."""
-        return code

astreum-0.1.0.dist-info/RECORD

@@ -1,7 +0,0 @@
-astreum/__init__.py,sha256=-hmy95qFWlCbmHEcj5sGniM-UtpIn-iwwhVWFrFkd_w,37
-astreum/machine.py,sha256=o39_-R5tiLwVrkwscWMzYazn-_Qe6Ns1mTvkHupUKjU,167
-astreum-0.1.0.dist-info/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
-astreum-0.1.0.dist-info/METADATA,sha256=lJ6_9gugRp2AfQk32OATbdEMw-ME-lzkZtzNeo9jRuE,637
-astreum-0.1.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-astreum-0.1.0.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
-astreum-0.1.0.dist-info/RECORD,,