astreum 0.2.4__py3-none-any.whl → 0.2.6__py3-none-any.whl

astreum/machine/__init__.py

@@ -1,352 +0,0 @@
-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, node: 'Node' = None):
-        self.global_env = Environment(node=node)
-        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)
-                
-                # Subtraction
-                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"
-                        )
-                    
-                    # With only one argument, negate it
-                    if len(evaluated_args) == 1:
-                        return Expr.Integer(-evaluated_args[0].value)
-                    
-                    # With multiple arguments, subtract all from the first
-                    result = evaluated_args[0].value
-                    for arg in evaluated_args[1:]:
-                        result -= arg.value
-                    
-                    return Expr.Integer(result)
-                
-                # Multiplication
-                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"
-                        )
-                    
-                    # Multiply all values
-                    result = 1
-                    for arg in evaluated_args:
-                        result *= arg.value
-                    
-                    return Expr.Integer(result)
-                
-                # Division (integer division)
-                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"
-                        )
-                    
-                    # Need exactly two arguments
-                    if len(evaluated_args) != 2:
-                        return Expr.Error(
-                            category="ArgumentError",
-                            message="The / operation requires exactly two arguments"
-                        )
-                    
-                    dividend = evaluated_args[0].value
-                    divisor = evaluated_args[1].value
-                    
-                    if divisor == 0:
-                        return Expr.Error(
-                            category="DivisionError",
-                            message="Division by zero"
-                        )
-                    
-                    return Expr.Integer(dividend // divisor)  # Integer division
-                
-                # Remainder (modulo)
-                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"
-                        )
-                    
-                    # Need exactly two arguments
-                    if len(evaluated_args) != 2:
-                        return Expr.Error(
-                            category="ArgumentError",
-                            message="The % operation requires exactly two arguments"
-                        )
-                    
-                    dividend = evaluated_args[0].value
-                    divisor = evaluated_args[1].value
-                    
-                    if divisor == 0:
-                        return Expr.Error(
-                            category="DivisionError",
-                            message="Modulo by zero"
-                        )
-                    
-                    return Expr.Integer(dividend % divisor)
-
-            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

@@ -1,4 +0,0 @@
-from typing import Dict, Optional
-from astreum.lispeum.expression import Expr
-
-

astreum-0.2.4.dist-info/RECORD

@@ -1,56 +0,0 @@
-astreum/__init__.py,sha256=y2Ok3EY_FstcmlVASr80lGR_0w-dH-SXDCCQFmL6uwA,28
-astreum/format.py,sha256=X4tG5GGPweNCE54bHYkLFiuLTbmpy5upO_s1Cef-MGA,2711
-astreum/node.py,sha256=tbU8FNbZeI8mWO3SJriwZsIP0vPhwDnn5sCpMfTZsBY,46378
-astreum/_node/__init__.py,sha256=7yz1YHo0DCUgUQvJf75qdUo_ocl5-XZRU-Vc2NhcvJs,18639
-astreum/_node/utils.py,sha256=Zj4NtbmJ9CWFO3oBvYYauwOiLcpd219qCyGvgTw9Lak,704
-astreum/_node/relay/__init__.py,sha256=A6br8QSGLW7qmKYBJNIC4bEf5QMzLBFaa_FH3MaOJrs,15069
-astreum/_node/relay/bucket.py,sha256=pcmollbbM-xeHlmDxLZnzvf0Ut-9v9RoN6SijYiQuu8,2893
-astreum/_node/relay/envelope.py,sha256=PYpYPd03GqdOK7ovU35MHiWFvSTsM3fTW_ycdnB7UIM,10025
-astreum/_node/relay/message.py,sha256=nShIJ1WUFlqLnv_AFJWLBdbuldoy-sWT2aXcXWB3zKg,2875
-astreum/_node/relay/peer.py,sha256=DlvTR9j0BZQ1dW-p_9UGgfLvQqwNdpNLMSCYEW4FhyI,5899
-astreum/_node/relay/route.py,sha256=fyOSsAe1mfsCVeN6LtQ_OEUEb1FiC5dobZBEJKNGU9U,5814
-astreum/_node/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-astreum/_node/storage/merkle.py,sha256=XCQBrHbwI0FuPTCUwHOy-Kva3uWbvCdw_-13hRPf1UI,10219
-astreum/_node/storage/patricia.py,sha256=tynxn_qETCU9X7yJdeh_0GHpC8Pzcoq4CWrSZlMUeRc,11546
-astreum/_node/storage/storage.py,sha256=K9i9_Z1z47uH_f1ZeFmyh3Xh9VyM_zdcPo1Jaj3KqeI,10096
-astreum/_node/storage/utils.py,sha256=CxKH9GbW31aVYs2Hwg1SirCykSnH_3_JisEayDrpOvY,5169
-astreum/_node/validation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-astreum/_node/validation/account.py,sha256=m2hEpJPzGWPL00mfbmeX15xbLqSId0fYoVDF74bNcdw,3620
-astreum/_node/validation/block.py,sha256=KRvlpLZOmgJ3WJaSHsbk7ryh2Z1NsC2z-RWKWh1quBE,444
-astreum/_node/validation/constants.py,sha256=ImIdLZFtMKx1iWg60YssEKl2tdDqZQnIa2JaJE6CX0o,422
-astreum/_node/validation/stake.py,sha256=Z9EPM-X9c92fpsZIYsdVpvgz4DhxQViPM-RDktWUZq8,7141
-astreum/_node/validation/transaction.py,sha256=T8joGoXR6hZp7i5JiYklDpJ8C-HTTT9twWNMku3caMo,4671
-astreum/_node/validation/vdf.py,sha256=HDdnqn9O_LicfE7SNCmncawKoR-ojLyjlpn74OvRNOU,2194
-astreum/_node/validation/_block/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-astreum/_node/validation/_block/create.py,sha256=apD9h92b9Y146zeppSzKNk_NJPgyBy7FhxoEkypQQNk,2515
-astreum/_node/validation/_block/model.py,sha256=d7x3_tX2MPLnGODL_5_vNjQfLdYa405blc-zL9o8HFA,2589
-astreum/_node/validation/_block/validate.py,sha256=niLexCNhEwUJLclyrdNZSvHcVa_J6jlu7J3FiWY7XBU,6232
-astreum/crypto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-astreum/crypto/ed25519.py,sha256=FRnvlN0kZlxn4j-sJKl-C9tqiz_0z4LZyXLj3KIj1TQ,1760
-astreum/crypto/x25519.py,sha256=i29v4BmwKRcbz9E7NKqFDQyxzFtJUqN0St9jd7GS1uA,1137
-astreum/lispeum/__init__.py,sha256=K-NDzIjtIsXzC9X7lnYvlvIaVxjFcY7WNsgLIE3DH3U,58
-astreum/lispeum/expression.py,sha256=3zOEoXFHpzEFUIi1clONY55WYAh5K0YkYhaLmtvQj0I,2939
-astreum/lispeum/parser.py,sha256=jQRzZYvBuSg8t_bxsbt1-WcHaR_LPveHNX7Qlxhaw-M,1165
-astreum/lispeum/storage.py,sha256=ZveAr5J9RIGFf1VkQkSNWsdPuUkIq2KgT4varn0yFSk,13846
-astreum/lispeum/tokenizer.py,sha256=J-I7MEd0r2ZoVqxvRPlu-Afe2ZdM0tKXXhf1R4SxYTo,1429
-astreum/lispeum/special/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-astreum/lispeum/special/definition.py,sha256=ukQJ-Mz57bpqbTPQiwmevdE4uxec3Zt--apT3VhUYqU,840
-astreum/lispeum/special/list/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-astreum/lispeum/special/list/all.py,sha256=deTsq7fO5wLpLrfXcAWl_Vd-DPqk39qOltPI2eY2qkw,1054
-astreum/lispeum/special/list/any.py,sha256=1ZjlWvYHPKOk1uiJqqeDLR2LxF52d4m7-FmBv-zBWN4,1053
-astreum/lispeum/special/list/fold.py,sha256=GyjOS5RqSbC9BLgMPIsJSIRbsBmB90Jucw_rWH8SixA,933
-astreum/lispeum/special/list/get.py,sha256=dHTL0DPkXzKBrKDA2ecnmZxRTsLlCdeDKOwMT1fenaM,644
-astreum/lispeum/special/list/insert.py,sha256=bjTE3QXqk2USL710uu81wCCBcH1LFkuMb0iUVAOEj0g,712
-astreum/lispeum/special/list/map.py,sha256=vFfORKM0p2_AUUY6gsqeQZ3QL3fgc0tHtIyK2-Crp9A,966
-astreum/lispeum/special/list/position.py,sha256=1EcD5fzfjUCUhHCk8iotFoWdeE9Z2RjjNPdg250GD2o,1073
-astreum/lispeum/special/list/remove.py,sha256=EPhkWFwyKG8HyWPheVvtxCvMaEGvODFUbx7h1fli_hg,690
-astreum/lispeum/special/number/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-astreum/lispeum/special/number/addition.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-astreum/machine/__init__.py,sha256=GOdZl1tS9uIJHbq5WVcplifMDPDLQroX7CVew-K2YbA,15262
-astreum/machine/environment.py,sha256=QsRaDtAIwlkH8Cn-F7Zzuvx2eXcwLys2M5vdsP1omrI,84
-astreum/machine/error.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-astreum-0.2.4.dist-info/licenses/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
-astreum-0.2.4.dist-info/METADATA,sha256=Bapxtz6Heu4UUh2SxiplnWu2LMBz1_gWtU6Vq_LY6YQ,5453
-astreum-0.2.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-astreum-0.2.4.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
-astreum-0.2.4.dist-info/RECORD,,