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

astreum/machine/__init__.py

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

@@ -0,0 +1,22 @@
+from typing import Dict, 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):
+        self.data[name] = value
+
+    def get(self, name: str) -> Optional[Expr]:
+        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,40 @@
+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] == ')':
+                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:
+            number = int(first_token)
+            return Expr.Integer(number), rest
+        except ValueError:
+            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.1.dist-info → astreum-0.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: astreum
-Version: 0.1.1
+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
@@ -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.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/machine.py

@@ -1,10 +0,0 @@
-class AstreumMachine:
-    def __init__(self):
-        pass
-
-    def evaluate(self, code: str) -> list[str]:
-        return self.tokenize(code)
-
-    def tokenize(self, input: str) -> list[str]:
-        tokens = input.replace("(", " ( ").replace(")", " ) ").split()
-        return tokens

astreum-0.1.1.dist-info/RECORD

@@ -1,7 +0,0 @@
-astreum/__init__.py,sha256=-hmy95qFWlCbmHEcj5sGniM-UtpIn-iwwhVWFrFkd_w,37
-astreum/machine.py,sha256=pstgeN47YOr6vG3-vx4TMOjmzZD2Xpd66CgSKWB-UNc,296
-astreum-0.1.1.dist-info/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
-astreum-0.1.1.dist-info/METADATA,sha256=W3dD-otz_e9ox6dbsLGrVMxdge0W4VF8WxH_-hbg_ww,637
-astreum-0.1.1.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-astreum-0.1.1.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
-astreum-0.1.1.dist-info/RECORD,,