quantalogic 0.61.1__py3-none-any.whl → 0.61.3__py3-none-any.whl

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)

quantalogic/python_interpreter/interpreter_core.py

@@ -1,358 +0,0 @@
-import ast
-import asyncio
-import builtins
-import logging
-import threading
-from typing import Any, Callable, Dict, List, Optional, Tuple
-
-import psutil  # New dependency for resource monitoring
-
-from .exceptions import BreakException, ContinueException, ReturnException, WrappedException
-from .scope import Scope
-
-
-class ASTInterpreter:
-    def __init__(
-        self,
-        allowed_modules: List[str],
-        env_stack: Optional[List[Dict[str, Any]]] = None,
-        source: Optional[str] = None,
-        restrict_os: bool = True,
-        namespace: Optional[Dict[str, Any]] = None,
-        max_recursion_depth: int = 1000,  # Now configurable
-        max_operations: int = 10000000,   # Added operation limit
-        max_memory_mb: int = 1024,        # Added memory limit (1GB default)
-        sync_mode: bool = False,          # Added for sync execution optimization
-        safe_builtins: Optional[Dict[str, Any]] = None  # New customizable safe_builtins
-    ) -> None:
-        self.allowed_modules: List[str] = allowed_modules
-        self.modules: Dict[str, Any] = {mod: __import__(mod) for mod in allowed_modules}
-        self.restrict_os: bool = restrict_os
-        self.sync_mode: bool = sync_mode
-        self.max_operations: int = max_operations
-        self.operations_count: int = 0
-        self.max_memory_mb: int = max_memory_mb
-        self.process = psutil.Process()  # For memory monitoring
-        self.type_hints: Dict[str, Any] = {}  # Added for type aliases
-        self.special_methods: Dict[str, Callable] = {}  # Added for special method dispatch
-
-        # Default safe_builtins if none provided
-        default_safe_builtins: Dict[str, Any] = {
-            'None': None,
-            'False': False,
-            'True': True,
-            'int': int,
-            'float': float,
-            'str': str,
-            'list': list,
-            'dict': dict,
-            'set': set,
-            'tuple': tuple,
-            'bool': bool,
-            'object': object,
-            'range': range,
-            'iter': iter,              # Added for test_iterators
-            'next': next,              # Added to fix test_iterators
-            'sorted': sorted,          # Added for test_dictionary_methods
-            'frozenset': frozenset,    # Added for test_frozenset
-            'super': super,            # Added for test_class_inheritance
-            'len': len,                # Added for test_empty_structures
-            'property': property,      # Added for test_property_decorator
-            'staticmethod': staticmethod,  # Added for test_static_method
-            'classmethod': classmethod,  # Added for test_class_method
-            '__name__': '__main__',    # Simulate script execution context
-        }
-
-        # Use provided safe_builtins or default
-        self.safe_builtins = safe_builtins if safe_builtins is not None else default_safe_builtins
-
-        if env_stack is None:
-            self.env_stack: List[Dict[str, Any]] = [{}]
-            self.env_stack[0].update(self.modules)
-
-            # Define explicitly allowed built-in functions
-            allowed_builtins = {
-                "enumerate": enumerate,
-                "zip": zip,
-                "sum": sum,
-                "min": min,
-                "max": max,
-                "abs": abs,
-                "round": round,
-                "str": str,
-                "repr": repr,
-                "id": id,
-                "Exception": Exception,
-                "ZeroDivisionError": ZeroDivisionError,
-                "ValueError": ValueError,
-                "TypeError": TypeError,
-                "print": print,
-                "getattr": self.safe_getattr,
-                "vars": lambda obj=None: vars(obj) if obj else dict(self.env_stack[-1]),
-            }
-
-            # Update safe_builtins with allowed functions and restricted import
-            self.safe_builtins.update(allowed_builtins)
-            self.safe_builtins["__import__"] = self.safe_import
-
-            # Set the restricted builtins in the environment
-            self.env_stack[0]["__builtins__"] = self.safe_builtins
-            self.env_stack[0].update(self.safe_builtins)
-            self.env_stack[0]["logger"] = logging.getLogger(__name__)
-
-            # Add the provided namespace (e.g., tools) to the environment
-            if namespace is not None:
-                self.env_stack[0].update(namespace)
-        else:
-            self.env_stack = env_stack
-            if "__builtins__" not in self.env_stack[0]:
-                # Define explicitly allowed built-in functions
-                allowed_builtins = {
-                    "enumerate": enumerate,
-                    "zip": zip,
-                    "sum": sum,
-                    "min": min,
-                    "max": max,
-                    "abs": abs,
-                    "round": round,
-                    "str": str,
-                    "repr": repr,
-                    "id": id,
-                    "Exception": Exception,
-                    "ZeroDivisionError": ZeroDivisionError,
-                    "ValueError": ValueError,
-                    "TypeError": TypeError,
-                    "print": print,
-                    "getattr": self.safe_getattr,
-                    "vars": lambda obj=None: vars(obj) if obj else dict(self.env_stack[-1]),
-                }
-
-                # Update safe_builtins with allowed functions and restricted import
-                self.safe_builtins.update(allowed_builtins)
-                self.safe_builtins["__import__"] = self.safe_import
-
-                # Set the restricted builtins in the environment
-                self.env_stack[0]["__builtins__"] = self.safe_builtins
-                self.env_stack[0].update(self.safe_builtins)
-                self.env_stack[0]["logger"] = logging.getLogger(__name__)
-
-            if namespace is not None:
-                self.env_stack[0].update(namespace)
-
-        if self.restrict_os:
-            os_related_modules = {"os", "sys", "subprocess", "shutil", "platform"}
-            for mod in os_related_modules:
-                if mod in self.modules:
-                    del self.modules[mod]
-            for mod in list(self.allowed_modules):
-                if mod in os_related_modules:
-                    self.allowed_modules.remove(mod)
-
-        self.source_lines: Optional[List[str]] = source.splitlines() if source else None
-        self.var_cache: Dict[str, Any] = {}
-        self.recursion_depth: int = 0
-        self.max_recursion_depth: int = max_recursion_depth
-        self.loop = None
-        self.current_class = None
-        self.current_instance = None
-        self.current_exception = None
-        self.last_exception = None
-        self.lock = threading.Lock()  # Added for thread safety
-
-        if "decimal" in self.modules:
-            dec = self.modules["decimal"]
-            self.env_stack[0]["Decimal"] = dec.Decimal
-            self.env_stack[0]["getcontext"] = dec.getcontext
-            self.env_stack[0]["setcontext"] = dec.setcontext
-            self.env_stack[0]["localcontext"] = dec.localcontext
-            self.env_stack[0]["Context"] = dec.Context
-
-        from . import visit_handlers
-        for handler_name in visit_handlers.__all__:
-            handler = getattr(visit_handlers, handler_name)
-            setattr(self, handler_name, handler.__get__(self, ASTInterpreter))
-
-    def safe_import(self, name: str, globals=None, locals=None, fromlist=(), level=0) -> Any:
-        os_related_modules = {"os", "sys", "subprocess", "shutil", "platform"}
-        if self.restrict_os and name in os_related_modules:
-            raise ImportError(f"Import Error: Module '{name}' is blocked due to OS restriction.")
-        if name not in self.allowed_modules:
-            raise ImportError(f"Import Error: Module '{name}' is not allowed. Only {self.allowed_modules} are permitted.")
-        return self.modules[name]
-
-    def safe_getattr(self, obj: Any, name: str, default: Any = None) -> Any:
-        if name.startswith('__') and name.endswith('__') and name not in ['__init__', '__call__']:
-            raise AttributeError(f"Access to dunder attribute '{name}' is restricted.")
-        return getattr(obj, name, default)
-
-    def spawn_from_env(self, env_stack: List[Dict[str, Any]]) -> "ASTInterpreter":
-        new_interp = ASTInterpreter(
-            self.allowed_modules,
-            env_stack,
-            source="\n".join(self.source_lines) if self.source_lines else None,
-            restrict_os=self.restrict_os,
-            max_recursion_depth=self.max_recursion_depth,
-            max_operations=self.max_operations,
-            max_memory_mb=self.max_memory_mb,
-            sync_mode=self.sync_mode,
-            safe_builtins=self.safe_builtins  # Pass along the customized safe_builtins
-        )
-        new_interp.loop = self.loop
-        new_interp.var_cache = self.var_cache.copy()
-        return new_interp
-
-    def get_variable(self, name: str) -> Any:
-        with self.lock:
-            if name in self.var_cache:
-                return self.var_cache[name]
-            for frame in reversed(self.env_stack):
-                if name in frame:
-                    self.var_cache[name] = frame[name]
-                    return frame[name]
-            raise NameError(f"Name '{name}' is not defined.")
-
-    def set_variable(self, name: str, value: Any) -> None:
-        with self.lock:
-            if "__global_names__" in self.env_stack[-1] and name in self.env_stack[-1]["__global_names__"]:
-                self.env_stack[0][name] = value
-                if name in self.var_cache:
-                    del self.var_cache[name]
-            elif "__nonlocal_names__" in self.env_stack[-1] and name in self.env_stack[-1]["__nonlocal_names__"]:
-                for frame in reversed(self.env_stack[:-1]):
-                    if name in frame:
-                        frame[name] = value
-                        if name in self.var_cache:
-                            del self.var_cache[name]
-                        return
-                raise NameError(f"Nonlocal name '{name}' not found in outer scope")
-            else:
-                self.env_stack[-1][name] = value
-                if name in self.var_cache:
-                    del self.var_cache[name]
-
-    async def assign(self, target: ast.AST, value: Any) -> None:
-        if isinstance(target, ast.Name):
-            self.set_variable(target.id, value)
-        elif isinstance(target, (ast.Tuple, ast.List)):
-            star_index = None
-            for i, elt in enumerate(target.elts):
-                if isinstance(elt, ast.Starred):
-                    if star_index is not None:
-                        raise Exception("Multiple starred expressions not supported")
-                    star_index = i
-            if star_index is None:
-                if len(target.elts) != len(value):
-                    raise ValueError("Unpacking mismatch")
-                for t, v in zip(target.elts, value):
-                    await self.assign(t, v)
-            else:
-                total = len(value)
-                before = target.elts[:star_index]
-                after = target.elts[star_index + 1:]
-                if len(before) + len(after) > total:
-                    raise ValueError("Unpacking mismatch")
-                for i, elt2 in enumerate(before):
-                    await self.assign(elt2, value[i])
-                starred_count = total - len(before) - len(after)
-                await self.assign(target.elts[star_index].value, value[len(before):len(before) + starred_count])
-                for j, elt2 in enumerate(after):
-                    await self.assign(elt2, value[len(before) + starred_count + j])
-        elif isinstance(target, ast.Attribute):
-            obj = await self.visit(target.value, wrap_exceptions=True)
-            setattr(obj, target.attr, value)
-        elif isinstance(target, ast.Subscript):
-            obj = await self.visit(target.value, wrap_exceptions=True)
-            key = await self.visit(target.slice, wrap_exceptions=True)
-            obj[key] = value
-        else:
-            raise Exception("Unsupported assignment target type: " + str(type(target)))
-
-    async def visit(self, node: ast.AST, is_await_context: bool = False, wrap_exceptions: bool = True) -> Any:
-        self.operations_count += 1
-        if self.operations_count > self.max_operations:
-            raise RuntimeError(f"Exceeded maximum operations ({self.max_operations})")
-        memory_usage = self.process.memory_info().rss / 1024 / 1024  # MB
-        if memory_usage > self.max_memory_mb:
-            raise MemoryError(f"Memory usage exceeded limit ({self.max_memory_mb} MB)")
-        
-        self.recursion_depth += 1
-        if self.recursion_depth > self.max_recursion_depth:
-            raise RecursionError(f"Maximum recursion depth exceeded ({self.max_recursion_depth})")
-        
-        method_name: str = "visit_" + node.__class__.__name__
-        method = getattr(self, method_name, self.generic_visit)
-        self.env_stack[0]["logger"].debug(f"Visiting {method_name} at line {getattr(node, 'lineno', 'unknown')}")
-        
-        try:
-            if self.sync_mode and not hasattr(node, 'await'):  # Optimize for sync code
-                result = method(node, wrap_exceptions=wrap_exceptions)
-            elif method_name == "visit_Call":
-                result = await method(node, is_await_context, wrap_exceptions)
-            else:
-                result = await method(node, wrap_exceptions=wrap_exceptions)
-            self.recursion_depth -= 1
-            return result
-        except (ReturnException, BreakException, ContinueException):
-            self.recursion_depth -= 1
-            raise
-        except Exception as e:
-            self.recursion_depth -= 1
-            if not wrap_exceptions:
-                raise
-            lineno = getattr(node, "lineno", None) or 1
-            col = getattr(node, "col_offset", None) or 0
-            context_line = self.source_lines[lineno - 1] if self.source_lines and 1 <= lineno <= len(self.source_lines) else ""
-            raise WrappedException(
-                f"Error line {lineno}, col {col}:\n{context_line}\nDescription: {str(e)}", e, lineno, col, context_line
-            ) from e
-
-    async def generic_visit(self, node: ast.AST, wrap_exceptions: bool = True) -> Any:
-        lineno = getattr(node, "lineno", None) or 1
-        context_line = self.source_lines[lineno - 1] if self.source_lines and 1 <= lineno <= len(self.source_lines) else ""
-        raise Exception(
-            f"Unsupported AST node type: {node.__class__.__name__} at line {lineno}.\nContext: {context_line}"
-        )
-
-    async def execute_async(self, node: ast.Module) -> Any:
-        return await self.visit(node)
-
-    def new_scope(self):
-        return Scope(self.env_stack)
-
-    async def _resolve_exception_type(self, node: Optional[ast.AST]) -> Any:
-        if node is None:
-            return Exception
-        if isinstance(node, ast.Name):
-            exc_type = self.get_variable(node.id)
-            if exc_type in (Exception, ZeroDivisionError, ValueError, TypeError):
-                return exc_type
-            return exc_type
-        if isinstance(node, ast.Call):
-            return await self.visit(node, wrap_exceptions=True)
-        return None
-
-    async def _create_class_instance(self, cls: type, *args, **kwargs):
-        if cls in (super, Exception, BaseException) or issubclass(cls, BaseException):
-            instance = cls.__new__(cls, *args, **kwargs)
-            if hasattr(instance, '__init__'):
-                init_method = instance.__init__.__func__ if hasattr(instance.__init__, '__func__') else instance.__init__
-                await self._execute_function(init_method, [instance] + list(args), kwargs)
-            return instance
-        instance = object.__new__(cls)
-        self.current_instance = instance
-        self.current_class = cls
-        init_method = cls.__init__.__func__ if hasattr(cls.__init__, '__func__') else cls.__init__
-        await self._execute_function(init_method, [instance] + list(args), kwargs)
-        self.current_instance = None
-        self.current_class = None
-        return instance
-
-    async def _execute_function(self, func: Any, args: List[Any], kwargs: Dict[str, Any]):
-        if asyncio.iscoroutinefunction(func):
-            return await func(*args, **kwargs)
-        elif callable(func):
-            result = func(*args, **kwargs)
-            if asyncio.iscoroutine(result):
-                return await result
-            return result
-        raise TypeError(f"Object {func} is not callable")

quantalogic/python_interpreter/literal_visitors.py

@@ -1,74 +0,0 @@
-import ast
-from typing import Any, Dict, List, Tuple
-
-from .interpreter_core import ASTInterpreter
-from .function_utils import Function
-
-async def visit_Constant(self: ASTInterpreter, node: ast.Constant, wrap_exceptions: bool = True) -> Any:
-    return node.value
-
-async def visit_Name(self: ASTInterpreter, node: ast.Name, wrap_exceptions: bool = True) -> Any:
-    if isinstance(node.ctx, ast.Load):
-        return self.get_variable(node.id)
-    elif isinstance(node.ctx, ast.Store):
-        return node.id
-    else:
-        raise Exception("Unsupported context for Name")
-
-async def visit_List(self: ASTInterpreter, node: ast.List, wrap_exceptions: bool = True) -> List[Any]:
-    return [await self.visit(elt, wrap_exceptions=wrap_exceptions) for elt in node.elts]
-
-async def visit_Tuple(self: ASTInterpreter, node: ast.Tuple, wrap_exceptions: bool = True) -> Tuple[Any, ...]:
-    elements = [await self.visit(elt, wrap_exceptions=wrap_exceptions) for elt in node.elts]
-    return tuple(elements)
-
-async def visit_Dict(self: ASTInterpreter, node: ast.Dict, wrap_exceptions: bool = True) -> Dict[Any, Any]:
-    return {
-        await self.visit(k, wrap_exceptions=wrap_exceptions): await self.visit(v, wrap_exceptions=wrap_exceptions)
-        for k, v in zip(node.keys, node.values)
-    }
-
-async def visit_Set(self: ASTInterpreter, node: ast.Set, wrap_exceptions: bool = True) -> set:
-    elements = [await self.visit(elt, wrap_exceptions=wrap_exceptions) for elt in node.elts]
-    return set(elements)
-
-async def visit_Attribute(self: ASTInterpreter, node: ast.Attribute, wrap_exceptions: bool = True) -> Any:
-    value = await self.visit(node.value, wrap_exceptions=wrap_exceptions)
-    attr = node.attr
-    prop = getattr(type(value), attr, None)
-    if isinstance(prop, property) and isinstance(prop.fget, Function):
-        return await prop.fget(value)
-    return getattr(value, attr)
-
-async def visit_Subscript(self: ASTInterpreter, node: ast.Subscript, wrap_exceptions: bool = True) -> Any:
-    value: Any = await self.visit(node.value, wrap_exceptions=wrap_exceptions)
-    slice_val: Any = await self.visit(node.slice, wrap_exceptions=wrap_exceptions)
-    return value[slice_val]
-
-async def visit_Slice(self: ASTInterpreter, node: ast.Slice, wrap_exceptions: bool = True) -> slice:
-    lower: Any = await self.visit(node.lower, wrap_exceptions=wrap_exceptions) if node.lower else None
-    upper: Any = await self.visit(node.upper, wrap_exceptions=wrap_exceptions) if node.upper else None
-    step: Any = await self.visit(node.step, wrap_exceptions=wrap_exceptions) if node.step else None
-    return slice(lower, upper, step)
-
-async def visit_Index(self: ASTInterpreter, node: ast.Index, wrap_exceptions: bool = True) -> Any:
-    return await self.visit(node.value, wrap_exceptions=wrap_exceptions)
-
-async def visit_Starred(self: ASTInterpreter, node: ast.Starred, wrap_exceptions: bool = True) -> Any:
-    value = await self.visit(node.value, wrap_exceptions=wrap_exceptions)
-    if not isinstance(value, (list, tuple, set)):
-        raise TypeError(f"Cannot unpack non-iterable object of type {type(value).__name__}")
-    return value
-
-async def visit_JoinedStr(self: ASTInterpreter, node: ast.JoinedStr, wrap_exceptions: bool = True) -> str:
-    parts = []
-    for value in node.values:
-        val = await self.visit(value, wrap_exceptions=wrap_exceptions)
-        if isinstance(value, ast.FormattedValue):
-            parts.append(str(val))
-        else:
-            parts.append(val)
-    return "".join(parts)
-
-async def visit_FormattedValue(self: ASTInterpreter, node: ast.FormattedValue, wrap_exceptions: bool = True) -> Any:
-    return await self.visit(node.value, wrap_exceptions=wrap_exceptions)