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

quantalogic/python_interpreter/function_visitors.py

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

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

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

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