quantalogic 0.59.3__py3-none-any.whl → 0.61.0__py3-none-any.whl

quantalogic/python_interpreter/exceptions.py

@@ -0,0 +1,39 @@
+import ast
+from typing import Any, List
+
+class ReturnException(Exception):
+    def __init__(self, value: Any) -> None:
+        self.value: Any = value
+
+class BreakException(Exception):
+    pass
+
+class ContinueException(Exception):
+    pass
+
+class BaseExceptionGroup(Exception):
+    def __init__(self, message: str, exceptions: List[Exception]):
+        super().__init__(message)
+        self.exceptions = exceptions
+        self.message = message
+
+    def __str__(self):
+        return f"{self.message}: {', '.join(str(e) for e in self.exceptions)}"
+
+class WrappedException(Exception):
+    def __init__(self, message: str, original_exception: Exception, lineno: int, col: int, context_line: str):
+        super().__init__(message)
+        self.original_exception: Exception = original_exception
+        self.lineno: int = lineno
+        self.col: int = col
+        self.context_line: str = context_line
+        self.message = original_exception.args[0] if original_exception.args else str(original_exception)
+
+    def __str__(self):
+        return f"Error line {self.lineno}, col {self.col}:\n{self.context_line}\nDescription: {self.message}"
+
+def has_await(node: ast.AST) -> bool:
+    for child in ast.walk(node):
+        if isinstance(child, ast.Await):
+            return True
+    return False

quantalogic/python_interpreter/execution.py

@@ -0,0 +1,202 @@
+import ast
+import asyncio
+import textwrap
+import time
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Tuple
+
+from .interpreter_core import ASTInterpreter
+from .function_utils import Function, AsyncFunction
+from .exceptions import WrappedException
+
+@dataclass
+class AsyncExecutionResult:
+    result: Any
+    error: Optional[str]
+    execution_time: float
+    local_variables: Optional[Dict[str, Any]] = None  # Added to store local variables
+
+def optimize_ast(tree: ast.AST) -> ast.AST:
+    """Perform constant folding and basic optimizations on the AST."""
+    class ConstantFolder(ast.NodeTransformer):
+        def visit_BinOp(self, node):
+            self.generic_visit(node)
+            if isinstance(node.left, ast.Constant) and isinstance(node.right, ast.Constant):
+                left, right = node.left.value, node.right.value
+                if isinstance(left, (int, float)) and isinstance(right, (int, float)):
+                    if isinstance(node.op, ast.Add):
+                        return ast.Constant(value=left + right)
+                    elif isinstance(node.op, ast.Sub):
+                        return ast.Constant(value=left - right)
+                    elif isinstance(node.op, ast.Mult):
+                        return ast.Constant(value=left * right)
+                    elif isinstance(node.op, ast.Div) and right != 0:
+                        return ast.Constant(value=left / right)
+            return node
+
+        def visit_If(self, node):
+            self.generic_visit(node)
+            if isinstance(node.test, ast.Constant):
+                if node.test.value:
+                    return ast.Module(body=node.body, type_ignores=[])
+                else:
+                    return ast.Module(body=node.orelse, type_ignores=[])
+            return node
+
+    return ConstantFolder().visit(tree)
+
+class ControlledEventLoop:
+    """Encapsulated event loop management to prevent unauthorized access"""
+    def __init__(self):
+        self._loop = None
+        self._created = False
+        self._lock = asyncio.Lock()
+
+    async def get_loop(self) -> asyncio.AbstractEventLoop:
+        async with self._lock:
+            if self._loop is None:
+                self._loop = asyncio.new_event_loop()
+                self._created = True
+            return self._loop
+
+    async def cleanup(self):
+        async with self._lock:
+            if self._created and self._loop and not self._loop.is_closed():
+                for task in asyncio.all_tasks(self._loop):
+                    task.cancel()
+                await asyncio.gather(*asyncio.all_tasks(self._loop), return_exceptions=True)
+                self._loop.close()
+                self._loop = None
+                self._created = False
+
+    async def run_task(self, coro, timeout: float) -> Any:
+        return await asyncio.wait_for(coro, timeout=timeout)
+
+async def execute_async(
+    code: str,
+    entry_point: Optional[str] = None,
+    args: Optional[Tuple] = None,
+    kwargs: Optional[Dict[str, Any]] = None,
+    timeout: float = 30,
+    allowed_modules: List[str] = ['asyncio'],
+    namespace: Optional[Dict[str, Any]] = None,
+    max_memory_mb: int = 1024
+) -> AsyncExecutionResult:
+    start_time = time.time()
+    event_loop_manager = ControlledEventLoop()
+    
+    try:
+        ast_tree = optimize_ast(ast.parse(textwrap.dedent(code)))
+        loop = await event_loop_manager.get_loop()
+        
+        # Remove direct asyncio access from builtins
+        safe_namespace = namespace.copy() if namespace else {}
+        safe_namespace.pop('asyncio', None)  # Prevent direct asyncio access
+        
+        interpreter = ASTInterpreter(
+            allowed_modules=allowed_modules,
+            restrict_os=True,
+            namespace=safe_namespace,
+            max_memory_mb=max_memory_mb,
+            source=code  # Pass source code for better error context
+        )
+        interpreter.loop = loop
+        
+        async def run_execution():
+            return await interpreter.execute_async(ast_tree)
+        
+        await event_loop_manager.run_task(run_execution(), timeout=timeout)
+        
+        if entry_point:
+            func = interpreter.env_stack[0].get(entry_point)
+            if not func:
+                raise NameError(f"Function '{entry_point}' not found in the code")
+            args = args or ()
+            kwargs = kwargs or {}
+            if isinstance(func, AsyncFunction) or asyncio.iscoroutinefunction(func):
+                # Expect a tuple (result, local_vars) from AsyncFunction
+                execution_result = await event_loop_manager.run_task(func(*args, **kwargs), timeout=timeout)
+                if isinstance(execution_result, tuple) and len(execution_result) == 2:
+                    result, local_vars = execution_result
+                else:
+                    result, local_vars = execution_result, {}
+            elif isinstance(func, Function):
+                result = await func(*args, **kwargs)
+                local_vars = {}  # Non-async functions don't yet support local var return
+            else:
+                result = func(*args, **kwargs)
+                if asyncio.iscoroutine(result):
+                    result = await event_loop_manager.run_task(result, timeout=timeout)
+                local_vars = {}
+            if asyncio.iscoroutine(result):
+                result = await event_loop_manager.run_task(result, timeout=timeout)
+        else:
+            result = await interpreter.execute_async(ast_tree)
+            local_vars = {k: v for k, v in interpreter.env_stack[-1].items() if not k.startswith('__')}
+        
+        # Filter out internal variables if not already filtered
+        filtered_local_vars = local_vars if local_vars else {}
+        if not entry_point:  # Apply filtering only for module-level execution
+            filtered_local_vars = {k: v for k, v in local_vars.items() if not k.startswith('__')}
+        
+        return AsyncExecutionResult(
+            result=result,
+            error=None,
+            execution_time=time.time() - start_time,
+            local_variables=filtered_local_vars
+        )
+    except asyncio.TimeoutError as e:
+        return AsyncExecutionResult(
+            result=None,
+            error=f'TimeoutError: Execution exceeded {timeout} seconds',
+            execution_time=time.time() - start_time
+        )
+    except WrappedException as e:
+        return AsyncExecutionResult(
+            result=None,
+            error=str(e),
+            execution_time=time.time() - start_time
+        )
+    except Exception as e:
+        error_type = type(getattr(e, 'original_exception', e)).__name__
+        error_msg = f'{error_type}: {str(e)}'
+        if hasattr(e, 'lineno') and hasattr(e, 'col_offset'):
+            error_msg += f' at line {e.lineno}, col {e.col_offset}'
+        return AsyncExecutionResult(
+            result=None,
+            error=error_msg,
+            execution_time=time.time() - start_time
+        )
+    finally:
+        await event_loop_manager.cleanup()
+
+def interpret_ast(ast_tree: ast.AST, allowed_modules: List[str], source: str = "", restrict_os: bool = False, namespace: Optional[Dict[str, Any]] = None) -> Any:
+    ast_tree = optimize_ast(ast_tree)
+    event_loop_manager = ControlledEventLoop()
+    
+    # Remove asyncio from namespace
+    safe_namespace = namespace.copy() if namespace else {}
+    safe_namespace.pop('asyncio', None)
+    
+    interpreter = ASTInterpreter(allowed_modules=allowed_modules, source=source, restrict_os=restrict_os, namespace=safe_namespace)
+    
+    async def run_interpreter():
+        loop = await event_loop_manager.get_loop()
+        interpreter.loop = loop
+        result = await interpreter.visit(ast_tree, wrap_exceptions=True)
+        return result
+
+    try:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        interpreter.loop = loop
+        result = loop.run_until_complete(run_interpreter())
+        return result
+    finally:
+        if not loop.is_closed():
+            loop.close()
+
+def interpret_code(source_code: str, allowed_modules: List[str], restrict_os: bool = False, namespace: Optional[Dict[str, Any]] = None) -> Any:
+    dedented_source = textwrap.dedent(source_code).strip()
+    tree: ast.AST = ast.parse(dedented_source)
+    return interpret_ast(tree, allowed_modules, source=dedented_source, restrict_os=restrict_os, namespace=namespace)

quantalogic/python_interpreter/function_utils.py

@@ -0,0 +1,386 @@
+import ast
+import asyncio
+from typing import Any, Dict, List, Optional
+
+from .interpreter_core import ASTInterpreter
+from .exceptions import ReturnException, BreakException, ContinueException
+
+class GeneratorWrapper:
+    def __init__(self, gen):
+        self.gen = gen
+        self.closed = False
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        if self.closed:
+            raise StopIteration
+        try:
+            return next(self.gen)
+        except StopIteration:
+            self.closed = True
+            raise
+
+    def send(self, value):
+        if self.closed:
+            raise StopIteration
+        try:
+            return self.gen.send(value)
+        except StopIteration:
+            self.closed = True
+            raise
+
+    def throw(self, exc):
+        if self.closed:
+            raise StopIteration
+        try:
+            return self.gen.throw(exc)
+        except StopIteration:
+            self.closed = True
+            raise
+
+    def close(self):
+        self.closed = True
+        self.gen.close()
+
+class Function:
+    def __init__(self, node: ast.FunctionDef, closure: List[Dict[str, Any]], interpreter: ASTInterpreter,
+                 pos_kw_params: List[str], vararg_name: Optional[str], kwonly_params: List[str],
+                 kwarg_name: Optional[str], pos_defaults: Dict[str, Any], kw_defaults: Dict[str, Any]) -> None:
+        self.node: ast.FunctionDef = node
+        self.closure: List[Dict[str, Any]] = closure[:]
+        self.interpreter: ASTInterpreter = interpreter
+        self.pos_kw_params = pos_kw_params
+        self.vararg_name = vararg_name
+        self.kwonly_params = kwonly_params
+        self.kwarg_name = kwarg_name
+        self.pos_defaults = pos_defaults
+        self.kw_defaults = kw_defaults
+        self.defining_class = None
+        self.is_generator = any(isinstance(n, (ast.Yield, ast.YieldFrom)) for n in ast.walk(node))
+        self.generator_state = None  # Added for generator protocol
+
+    async def __call__(self, *args: Any, **kwargs: Any) -> Any:
+        new_env_stack: List[Dict[str, Any]] = self.closure[:]
+        local_frame: Dict[str, Any] = {}
+        local_frame[self.node.name] = self
+
+        num_pos = len(self.pos_kw_params)
+        for i, arg in enumerate(args):
+            if i < num_pos:
+                local_frame[self.pos_kw_params[i]] = arg
+            elif self.vararg_name:
+                if self.vararg_name not in local_frame:
+                    local_frame[self.vararg_name] = []
+                local_frame[self.vararg_name].append(arg)
+            else:
+                raise TypeError(f"Function '{self.node.name}' takes {num_pos} positional arguments but {len(args)} were given")
+        if self.vararg_name and self.vararg_name not in local_frame:
+            local_frame[self.vararg_name] = tuple()
+
+        for kwarg_name, kwarg_value in kwargs.items():
+            if kwarg_name in self.pos_kw_params or kwarg_name in self.kwonly_params:
+                if kwarg_name in local_frame:
+                    raise TypeError(f"Function '{self.node.name}' got multiple values for argument '{kwarg_name}'")
+                local_frame[kwarg_name] = kwarg_value
+            elif self.kwarg_name:
+                if self.kwarg_name not in local_frame:
+                    local_frame[self.kwarg_name] = {}
+                local_frame[self.kwarg_name][kwarg_name] = kwarg_value
+            else:
+                raise TypeError(f"Function '{self.node.name}' got an unexpected keyword argument '{kwarg_name}'")
+
+        for param in self.pos_kw_params:
+            if param not in local_frame and param in self.pos_defaults:
+                local_frame[param] = self.pos_defaults[param]
+        for param in self.kwonly_params:
+            if param not in local_frame and param in self.kw_defaults:
+                local_frame[param] = self.kw_defaults[param]
+
+        if self.kwarg_name and self.kwarg_name in local_frame:
+            local_frame[self.kwarg_name] = dict(local_frame[self.kwarg_name])
+
+        missing_args = [param for param in self.pos_kw_params if param not in local_frame and param not in self.pos_defaults]
+        missing_args += [param for param in self.kwonly_params if param not in local_frame and param not in self.kw_defaults]
+        if missing_args:
+            raise TypeError(f"Function '{self.node.name}' missing required arguments: {', '.join(missing_args)}")
+
+        if self.pos_kw_params and self.pos_kw_params[0] == 'self' and args:
+            local_frame['self'] = args[0]
+            local_frame['__current_method__'] = self
+
+        new_env_stack.append(local_frame)
+        new_interp: ASTInterpreter = self.interpreter.spawn_from_env(new_env_stack)
+        
+        if self.defining_class and args:
+            new_interp.current_class = self.defining_class
+            new_interp.current_instance = args[0]
+
+        if self.is_generator:
+            async def generator():
+                for body_stmt in self.node.body:
+                    if isinstance(body_stmt, ast.Expr) and isinstance(body_stmt.value, ast.Yield):
+                        value = await new_interp.visit(body_stmt.value, wrap_exceptions=True)
+                        yield value
+                    elif isinstance(body_stmt, ast.Expr) and isinstance(body_stmt.value, ast.YieldFrom):
+                        sub_iterable = await new_interp.visit(body_stmt.value, wrap_exceptions=True)
+                        for v in sub_iterable:
+                            yield v
+                    else:
+                        await new_interp.visit(body_stmt, wrap_exceptions=True)
+            gen = generator()
+            return GeneratorWrapper(gen)
+        else:
+            last_value = None
+            try:
+                for stmt in self.node.body:
+                    last_value = await new_interp.visit(stmt, wrap_exceptions=True)
+                return last_value
+            except ReturnException as ret:
+                return ret.value
+            return last_value
+
+    def _send_sync(self, gen, value):
+        try:
+            return next(gen) if value is None else gen.send(value)
+        except StopIteration:
+            raise
+
+    def _throw_sync(self, gen, exc):
+        try:
+            return gen.throw(exc)
+        except StopIteration:
+            raise
+
+    def __get__(self, instance: Any, owner: Any):
+        if instance is None:
+            return self
+        async def method(*args: Any, **kwargs: Any) -> Any:
+            return await self(instance, *args, **kwargs)
+        method.__self__ = instance
+        return method
+
+class AsyncFunction:
+    def __init__(self, node: ast.AsyncFunctionDef, closure: List[Dict[str, Any]], interpreter: ASTInterpreter,
+                 pos_kw_params: List[str], vararg_name: Optional[str], kwonly_params: List[str],
+                 kwarg_name: Optional[str], pos_defaults: Dict[str, Any], kw_defaults: Dict[str, Any]) -> None:
+        self.node: ast.AsyncFunctionDef = node
+        self.closure: List[Dict[str, Any]] = closure[:]
+        self.interpreter: ASTInterpreter = interpreter
+        self.pos_kw_params = pos_kw_params
+        self.vararg_name = vararg_name
+        self.kwonly_params = kwonly_params
+        self.kwarg_name = kwarg_name
+        self.pos_defaults = pos_defaults
+        self.kw_defaults = kw_defaults
+
+    async def __call__(self, *args: Any, **kwargs: Any) -> tuple[Any, Dict[str, Any]]:
+        new_env_stack: List[Dict[str, Any]] = self.closure[:]
+        local_frame: Dict[str, Any] = {}
+        local_frame[self.node.name] = self
+
+        num_pos = len(self.pos_kw_params)
+        for i, arg in enumerate(args):
+            if i < num_pos:
+                local_frame[self.pos_kw_params[i]] = arg
+            elif self.vararg_name:
+                if self.vararg_name not in local_frame:
+                    local_frame[self.vararg_name] = []
+                local_frame[self.vararg_name].append(arg)
+            else:
+                raise TypeError(f"Async function '{self.node.name}' takes {num_pos} positional arguments but {len(args)} were given")
+        if self.vararg_name and self.vararg_name not in local_frame:
+            local_frame[self.vararg_name] = tuple()
+
+        for kwarg_name, kwarg_value in kwargs.items():
+            if kwarg_name in self.pos_kw_params or kwarg_name in self.kwonly_params:
+                if kwarg_name in local_frame:
+                    raise TypeError(f"Async function '{self.node.name}' got multiple values for argument '{kwarg_name}'")
+                local_frame[kwarg_name] = kwarg_value
+            elif self.kwarg_name:
+                if self.kwarg_name not in local_frame:
+                    local_frame[self.kwarg_name] = {}
+                local_frame[self.kwarg_name][kwarg_name] = kwarg_value
+            else:
+                raise TypeError(f"Async function '{self.node.name}' got an unexpected keyword argument '{kwarg_name}'")
+
+        for param in self.pos_kw_params:
+            if param not in local_frame and param in self.pos_defaults:
+                local_frame[param] = self.pos_defaults[param]
+        for param in self.kwonly_params:
+            if param not in local_frame and param in self.kw_defaults:
+                local_frame[param] = self.kw_defaults[param]
+
+        missing_args = [param for param in self.pos_kw_params if param not in local_frame and param not in self.pos_defaults]
+        missing_args += [param for param in self.kwonly_params if param not in local_frame and param not in self.kw_defaults]
+        if missing_args:
+            raise TypeError(f"Async function '{self.node.name}' missing required arguments: {', '.join(missing_args)}")
+
+        new_env_stack.append(local_frame)
+        new_interp: ASTInterpreter = self.interpreter.spawn_from_env(new_env_stack)
+        last_value = None
+        try:
+            for stmt in self.node.body:
+                last_value = await new_interp.visit(stmt, wrap_exceptions=True)
+            return last_value, {k: v for k, v in local_frame.items() if not k.startswith('__')}
+        except ReturnException as ret:
+            return ret.value, {k: v for k, v in local_frame.items() if not k.startswith('__')}
+        finally:
+            new_env_stack.pop()
+
+class AsyncGeneratorFunction:
+    def __init__(self, node: ast.AsyncFunctionDef, closure: List[Dict[str, Any]], interpreter: ASTInterpreter,
+                 pos_kw_params: List[str], vararg_name: Optional[str], kwonly_params: List[str],
+                 kwarg_name: Optional[str], pos_defaults: Dict[str, Any], kw_defaults: Dict[str, Any]) -> None:
+        self.node: ast.AsyncFunctionDef = node
+        self.closure: List[Dict[str, Any]] = closure[:]
+        self.interpreter: ASTInterpreter = interpreter
+        self.pos_kw_params = pos_kw_params
+        self.vararg_name = vararg_name
+        self.kwonly_params = kwonly_params
+        self.kwarg_name = kwarg_name
+        self.pos_defaults = pos_defaults
+        self.kw_defaults = kw_defaults
+        self.generator_state = None
+
+    async def __call__(self, *args: Any, **kwargs: Any) -> Any:
+        new_env_stack: List[Dict[str, Any]] = self.closure[:]
+        local_frame: Dict[str, Any] = {}
+        local_frame[self.node.name] = self
+
+        num_pos = len(self.pos_kw_params)
+        for i, arg in enumerate(args):
+            if i < num_pos:
+                local_frame[self.pos_kw_params[i]] = arg
+            elif self.vararg_name:
+                if self.vararg_name not in local_frame:
+                    local_frame[self.vararg_name] = []
+                local_frame[self.vararg_name].append(arg)
+            else:
+                raise TypeError(f"Async generator '{self.node.name}' takes {num_pos} positional arguments but {len(args)} were given")
+        if self.vararg_name and self.vararg_name not in local_frame:
+            local_frame[self.vararg_name] = tuple()
+
+        for kwarg_name, kwarg_value in kwargs.items():
+            if kwarg_name in self.pos_kw_params or kwarg_name in self.kwonly_params:
+                if kwarg_name in local_frame:
+                    raise TypeError(f"Async generator '{self.node.name}' got multiple values for argument '{kwarg_name}'")
+                local_frame[kwarg_name] = kwarg_value
+            elif self.kwarg_name:
+                if self.kwarg_name not in local_frame:
+                    local_frame[self.kwarg_name] = {}
+                local_frame[self.kwarg_name][kwarg_name] = kwarg_value
+            else:
+                raise TypeError(f"Async generator '{self.node.name}' got an unexpected keyword argument '{kwarg_name}'")
+
+        for param in self.pos_kw_params:
+            if param not in local_frame and param in self.pos_defaults:
+                local_frame[param] = self.pos_defaults[param]
+        for param in self.kwonly_params:
+            if param not in local_frame and param in self.kw_defaults:
+                local_frame[param] = self.kw_defaults[param]
+
+        missing_args = [param for param in self.pos_kw_params if param not in local_frame and param not in self.pos_defaults]
+        missing_args += [param for param in self.kwonly_params if param not in local_frame and param not in self.kw_defaults]
+        if missing_args:
+            raise TypeError(f"Async generator '{self.node.name}' missing required arguments: {', '.join(missing_args)}")
+
+        new_env_stack.append(local_frame)
+        new_interp: ASTInterpreter = self.interpreter.spawn_from_env(new_env_stack)
+
+        async def generator():
+            nonlocal self
+            if self.generator_state is None:
+                self.generator_state = {"closed": False, "pending_value": None}
+                
+            for stmt in self.node.body:
+                if self.generator_state["closed"]:
+                    raise StopAsyncIteration
+                
+                if isinstance(stmt, ast.Expr) and isinstance(stmt.value, ast.Yield):
+                    value = await new_interp.visit(stmt.value, wrap_exceptions=True)
+                    yield value
+                elif isinstance(stmt, ast.Expr) and isinstance(stmt.value, ast.YieldFrom):
+                    sub_iterable = await new_interp.visit(stmt.value, wrap_exceptions=True)
+                    async for v in sub_iterable:
+                        yield v
+                else:
+                    await new_interp.visit(stmt, wrap_exceptions=True)
+
+        gen = generator()
+        gen.send = lambda value: asyncio.run_coroutine_threadsafe(self._send(gen, value), self.interpreter.loop).result()
+        gen.throw = lambda exc: asyncio.run_coroutine_threadsafe(self._throw(gen, exc), self.interpreter.loop).result()
+        gen.close = lambda: setattr(self.generator_state, "closed", True)
+        return gen
+
+    async def _send(self, gen, value):
+        try:
+            return await gen.asend(value)
+        except StopAsyncIteration:
+            raise
+
+    async def _throw(self, gen, exc):
+        try:
+            return await gen.athrow(exc)
+        except StopAsyncIteration:
+            raise
+
+class LambdaFunction:
+    def __init__(self, node: ast.Lambda, closure: List[Dict[str, Any]], interpreter: ASTInterpreter,
+                 pos_kw_params: List[str], vararg_name: Optional[str], kwonly_params: List[str],
+                 kwarg_name: Optional[str], pos_defaults: Dict[str, Any], kw_defaults: Dict[str, Any]) -> None:
+        self.node: ast.Lambda = node
+        self.closure: List[Dict[str, Any]] = closure[:]
+        self.interpreter: ASTInterpreter = interpreter
+        self.pos_kw_params = pos_kw_params
+        self.vararg_name = vararg_name
+        self.kwonly_params = kwonly_params
+        self.kwarg_name = kwarg_name
+        self.pos_defaults = pos_defaults
+        self.kw_defaults = kw_defaults
+
+    async def __call__(self, *args: Any, **kwargs: Any) -> Any:
+        new_env_stack: List[Dict[str, Any]] = self.closure[:]
+        local_frame: Dict[str, Any] = {}
+
+        num_pos = len(self.pos_kw_params)
+        for i, arg in enumerate(args):
+            if i < num_pos:
+                local_frame[self.pos_kw_params[i]] = arg
+            elif self.vararg_name:
+                if self.vararg_name not in local_frame:
+                    local_frame[self.vararg_name] = []
+                local_frame[self.vararg_name].append(arg)
+            else:
+                raise TypeError(f"Lambda takes {num_pos} positional arguments but {len(args)} were given")
+        if self.vararg_name and self.vararg_name not in local_frame:
+            local_frame[self.vararg_name] = tuple()
+
+        for kwarg_name, kwarg_value in kwargs.items():
+            if kwarg_name in self.pos_kw_params or kwarg_name in self.kwonly_params:
+                if kwarg_name in local_frame:
+                    raise TypeError(f"Lambda got multiple values for argument '{kwarg_name}'")
+                local_frame[kwarg_name] = kwarg_value
+            elif self.kwarg_name:
+                if self.kwarg_name not in local_frame:
+                    local_frame[self.kwarg_name] = {}
+                local_frame[self.kwarg_name][kwarg_name] = kwarg_value
+            else:
+                raise TypeError(f"Lambda got an unexpected keyword argument '{kwarg_name}'")
+
+        for param in self.pos_kw_params:
+            if param not in local_frame and param in self.pos_defaults:
+                local_frame[param] = self.pos_defaults[param]
+        for param in self.kwonly_params:
+            if param not in local_frame and param in self.kw_defaults:
+                local_frame[param] = self.kw_defaults[param]
+
+        missing_args = [param for param in self.pos_kw_params if param not in local_frame and param not in self.pos_defaults]
+        missing_args += [param for param in self.kwonly_params if param not in local_frame and param not in self.kw_defaults]
+        if missing_args:
+            raise TypeError(f"Lambda missing required arguments: {', '.join(missing_args)}")
+
+        new_env_stack.append(local_frame)
+        new_interp: ASTInterpreter = self.interpreter.spawn_from_env(new_env_stack)
+        return await new_interp.visit(self.node.body, wrap_exceptions=True)