quantalogic 0.61.2__py3-none-any.whl → 0.80__py3-none-any.whl

quantalogic/python_interpreter/function_utils.py

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

quantalogic/python_interpreter/function_visitors.py

@@ -1,209 +0,0 @@
-import ast
-import asyncio
-import inspect
-from typing import Any, Dict, List
-
-from .exceptions import WrappedException
-from .function_utils import AsyncFunction, Function, LambdaFunction, AsyncGeneratorFunction
-from .interpreter_core import ASTInterpreter
-
-async def visit_FunctionDef(self: ASTInterpreter, node: ast.FunctionDef, wrap_exceptions: bool = True) -> None:
-    closure: List[Dict[str, Any]] = self.env_stack[:]
-    pos_kw_params = [arg.arg for arg in node.args.args]
-    vararg_name = node.args.vararg.arg if node.args.vararg else None
-    kwonly_params = [arg.arg for arg in node.args.kwonlyargs]
-    kwarg_name = node.args.kwarg.arg if node.args.kwarg else None
-    pos_defaults_values = [await self.visit(default, wrap_exceptions=True) for default in node.args.defaults]
-    num_pos_defaults = len(pos_defaults_values)
-    pos_defaults = dict(zip(pos_kw_params[-num_pos_defaults:], pos_defaults_values)) if num_pos_defaults else {}
-    kw_defaults_values = [await self.visit(default, wrap_exceptions=True) if default else None for default in node.args.kw_defaults]
-    kw_defaults = dict(zip(kwonly_params, kw_defaults_values))
-    kw_defaults = {k: v for k, v in kw_defaults.items() if v is not None}
-
-    func = Function(node, closure, self, pos_kw_params, vararg_name, kwonly_params, kwarg_name, pos_defaults, kw_defaults)
-    decorated_func = func
-    for decorator in reversed(node.decorator_list):
-        dec = await self.visit(decorator, wrap_exceptions=True)
-        if asyncio.iscoroutine(dec):
-            dec = await dec
-        if dec in (staticmethod, classmethod, property):
-            decorated_func = dec(func)
-        else:
-            decorated_func = await self._execute_function(dec, [decorated_func], {})
-    self.set_variable(node.name, decorated_func)
-
-async def visit_AsyncFunctionDef(self: ASTInterpreter, node: ast.AsyncFunctionDef, wrap_exceptions: bool = True) -> None:
-    closure: List[Dict[str, Any]] = self.env_stack[:]
-    pos_kw_params = [arg.arg for arg in node.args.args]
-    vararg_name = node.args.vararg.arg if node.args.vararg else None
-    kwonly_params = [arg.arg for arg in node.args.kwonlyargs]
-    kwarg_name = node.args.kwarg.arg if node.args.kwarg else None
-    pos_defaults_values = [await self.visit(default, wrap_exceptions=True) for default in node.args.defaults]
-    num_pos_defaults = len(pos_defaults_values)
-    pos_defaults = dict(zip(pos_kw_params[-num_pos_defaults:], pos_defaults_values)) if num_pos_defaults else {}
-    kw_defaults_values = [await self.visit(default, wrap_exceptions=True) if default else None for default in node.args.kw_defaults]
-    kw_defaults = dict(zip(kwonly_params, kw_defaults_values))
-    kw_defaults = {k: v for k, v in kw_defaults.items() if v is not None}
-
-    func = AsyncFunction(node, closure, self, pos_kw_params, vararg_name, kwonly_params, kwarg_name, pos_defaults, kw_defaults)
-    for decorator in reversed(node.decorator_list):
-        dec = await self.visit(decorator, wrap_exceptions=True)
-        if asyncio.iscoroutine(dec):
-            dec = await dec
-        func = await self._execute_function(dec, [func], {})
-    self.set_variable(node.name, func)
-
-async def visit_AsyncGeneratorDef(self: ASTInterpreter, node: ast.AsyncFunctionDef, wrap_exceptions: bool = True) -> None:
-    closure: List[Dict[str, Any]] = self.env_stack[:]
-    pos_kw_params = [arg.arg for arg in node.args.args]
-    vararg_name = node.args.vararg.arg if node.args.vararg else None
-    kwonly_params = [arg.arg for arg in node.args.kwonlyargs]
-    kwarg_name = node.args.kwarg.arg if node.args.kwarg else None
-    pos_defaults_values = [await self.visit(default, wrap_exceptions=True) for default in node.args.defaults]
-    num_pos_defaults = len(pos_defaults_values)
-    pos_defaults = dict(zip(pos_kw_params[-num_pos_defaults:], pos_defaults_values)) if num_pos_defaults else {}
-    kw_defaults_values = [await self.visit(default, wrap_exceptions=True) if default else None for default in node.args.kw_defaults]
-    kw_defaults = dict(zip(kwonly_params, kw_defaults_values))
-    kw_defaults = {k: v for k, v in kw_defaults.items() if v is not None}
-
-    func = AsyncGeneratorFunction(node, closure, self, pos_kw_params, vararg_name, kwonly_params, kwarg_name, pos_defaults, kw_defaults)
-    for decorator in reversed(node.decorator_list):
-        dec = await self.visit(decorator, wrap_exceptions=True)
-        if asyncio.iscoroutine(dec):
-            dec = await dec
-        func = await self._execute_function(dec, [func], {})
-    self.set_variable(node.name, func)
-
-async def visit_Call(self: ASTInterpreter, node: ast.Call, is_await_context: bool = False, wrap_exceptions: bool = True) -> Any:
-    func = await self.visit(node.func, wrap_exceptions=wrap_exceptions)
-
-    evaluated_args: List[Any] = []
-    for arg in node.args:
-        arg_value = await self.visit(arg, wrap_exceptions=wrap_exceptions)
-        if isinstance(arg, ast.Starred):
-            evaluated_args.extend(arg_value)
-        else:
-            evaluated_args.append(arg_value)
-
-    kwargs: Dict[str, Any] = {}
-    for kw in node.keywords:
-        if kw.arg is None:
-            unpacked_kwargs = await self.visit(kw.value, wrap_exceptions=wrap_exceptions)
-            if not isinstance(unpacked_kwargs, dict):
-                raise TypeError(f"** argument must be a mapping, not {type(unpacked_kwargs).__name__}")
-            kwargs.update(unpacked_kwargs)
-        else:
-            kwargs[kw.arg] = await self.visit(kw.value, wrap_exceptions=wrap_exceptions)
-
-    # Handle str() explicitly to avoid __new__ restriction
-    if func is str:
-        if len(evaluated_args) != 1:
-            raise TypeError(f"str() takes exactly one argument ({len(evaluated_args)} given)")
-        arg = evaluated_args[0]
-        return f"{arg}"  # Use f-string to safely convert to string
-
-    # Handle exceptions passed to str() (original behavior preserved)
-    if func is str and len(evaluated_args) == 1 and isinstance(evaluated_args[0], BaseException):
-        exc = evaluated_args[0]
-        if isinstance(exc, WrappedException) and hasattr(exc, 'original_exception'):
-            inner_exc = exc.original_exception
-            return inner_exc.args[0] if inner_exc.args else str(inner_exc)
-        return exc.args[0] if exc.args else str(exc)
-
-    if func is super:
-        if len(evaluated_args) == 0:
-            if not (self.current_class and self.current_instance):
-                # Infer from call stack if possible
-                for frame in reversed(self.env_stack):
-                    if 'self' in frame and '__current_method__' in frame:
-                        self.current_instance = frame['self']
-                        self.current_class = frame['self'].__class__
-                        break
-                if not (self.current_class and self.current_instance):
-                    raise TypeError("super() without arguments requires a class instantiation context")
-            result = super(self.current_class, self.current_instance)
-        elif len(evaluated_args) >= 2:
-            cls, obj = evaluated_args[0], evaluated_args[1]
-            result = super(cls, obj)
-        else:
-            raise TypeError("super() requires class and instance arguments")
-        return result
-
-    if isinstance(node.func, ast.Attribute) and isinstance(node.func.value, ast.Call) and isinstance(node.func.value.func, ast.Name) and node.func.value.func.id == 'super':
-        super_call = await self.visit(node.func.value, wrap_exceptions=wrap_exceptions)
-        method = getattr(super_call, node.func.attr)
-        return await self._execute_function(method, evaluated_args, kwargs)
-
-    if func is list and len(evaluated_args) == 1 and hasattr(evaluated_args[0], '__aiter__'):
-        return [val async for val in evaluated_args[0]]
-
-    if func in (range, list, dict, set, tuple, frozenset):
-        return func(*evaluated_args, **kwargs)
-
-    if inspect.isclass(func):
-        instance = await self._create_class_instance(func, *evaluated_args, **kwargs)
-        return instance
-
-    if isinstance(func, (staticmethod, classmethod, property)):
-        if isinstance(func, property):
-            result = func.fget(*evaluated_args, **kwargs)
-        else:
-            result = func(*evaluated_args, **kwargs)
-    elif asyncio.iscoroutinefunction(func) or isinstance(func, AsyncFunction):
-        result = func(*evaluated_args, **kwargs)
-        if not is_await_context:
-            result = await result
-    elif isinstance(func, Function):
-        if func.node.name == "__init__":
-            await func(*evaluated_args, **kwargs)
-            return None
-        result = await func(*evaluated_args, **kwargs)
-    elif isinstance(func, AsyncGeneratorFunction):
-        return func(*evaluated_args, **kwargs)
-    else:
-        result = func(*evaluated_args, **kwargs)
-        if asyncio.iscoroutine(result) and not is_await_context:
-            result = await result
-    return result
-
-async def visit_Await(self: ASTInterpreter, node: ast.Await, wrap_exceptions: bool = True) -> Any:
-    coro = await self.visit(node.value, is_await_context=True, wrap_exceptions=wrap_exceptions)
-    if not asyncio.iscoroutine(coro):
-        raise TypeError(f"Cannot await non-coroutine object: {type(coro)}")
-    
-    try:
-        return await asyncio.wait_for(coro, timeout=60)
-    except asyncio.TimeoutError as e:
-        line_info = f"line {node.lineno}" if hasattr(node, "lineno") else "unknown line"
-        context_line = self.source_lines[node.lineno - 1] if self.source_lines and hasattr(node, "lineno") else "<unknown>"
-        error_msg = f"Operation timed out after 60 seconds at {line_info}: {context_line.strip()}"
-        logger_msg = f"Coroutine execution timed out: {error_msg}"
-        self.env_stack[0]["logger"].error(logger_msg)
-        
-        if wrap_exceptions:
-            col = getattr(node, "col_offset", 0)
-            raise WrappedException(error_msg, e, node.lineno if hasattr(node, "lineno") else 0, col, context_line)
-        else:
-            raise asyncio.TimeoutError(error_msg) from e
-
-async def visit_Lambda(self: ASTInterpreter, node: ast.Lambda, wrap_exceptions: bool = True) -> Any:
-    closure: List[Dict[str, Any]] = self.env_stack[:]
-    pos_kw_params = [arg.arg for arg in node.args.args]
-    vararg_name = node.args.vararg.arg if node.args.vararg else None
-    kwonly_params = [arg.arg for arg in node.args.kwonlyargs]
-    kwarg_name = node.args.kwarg.arg if node.args.kwarg else None
-    pos_defaults_values = [await self.visit(default, wrap_exceptions=True) for default in node.args.defaults]
-    num_pos_defaults = len(pos_defaults_values)
-    pos_defaults = dict(zip(pos_kw_params[-num_pos_defaults:], pos_defaults_values)) if num_pos_defaults else {}
-    kw_defaults_values = [await self.visit(default, wrap_exceptions=True) if default else None for default in node.args.kw_defaults]
-    kw_defaults = dict(zip(kwonly_params, kw_defaults_values))
-    kw_defaults = {k: v for k, v in kw_defaults.items() if v is not None}
-
-    lambda_func = LambdaFunction(
-        node, closure, self, pos_kw_params, vararg_name, kwonly_params, kwarg_name, pos_defaults, kw_defaults
-    )
-    
-    async def lambda_wrapper(*args, **kwargs):
-        return await lambda_func(*args, **kwargs)
-    
-    return lambda_wrapper

quantalogic/python_interpreter/import_visitors.py

@@ -1,28 +0,0 @@
-import ast
-from typing import Any
-
-from .interpreter_core import ASTInterpreter
-
-async def visit_Import(self: ASTInterpreter, node: ast.Import, wrap_exceptions: bool = True) -> None:
-    for alias in node.names:
-        module_name: str = alias.name
-        asname: str = alias.asname if alias.asname is not None else module_name
-        if module_name not in self.allowed_modules:
-            raise Exception(
-                f"Import Error: Module '{module_name}' is not allowed. Only {self.allowed_modules} are permitted."
-            )
-        self.set_variable(asname, self.modules[module_name])
-
-async def visit_ImportFrom(self: ASTInterpreter, node: ast.ImportFrom, wrap_exceptions: bool = True) -> None:
-    if not node.module:
-        raise Exception("Import Error: Missing module name in 'from ... import ...' statement")
-    if node.module not in self.allowed_modules:
-        raise Exception(
-            f"Import Error: Module '{node.module}' is not allowed. Only {self.allowed_modules} are permitted."
-        )
-    for alias in node.names:
-        if alias.name == "*":
-            raise Exception("Import Error: 'from ... import *' is not supported.")
-        asname = alias.asname if alias.asname else alias.name
-        attr = getattr(self.modules[node.module], alias.name)
-        self.set_variable(asname, attr)