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

quantalogic/codeact/utils.py

@@ -0,0 +1,135 @@
+import ast
+import inspect
+from functools import wraps
+from typing import Any, Callable, Tuple
+
+from loguru import logger
+from lxml import etree
+
+
+def log_async_tool(verb: str):
+    """Decorator factory for consistent async tool logging."""
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            logger.info(f"Starting tool: {func.__name__}")
+            sig = inspect.signature(func)
+            bound_args = sig.bind(*args, **kwargs)
+            bound_args.apply_defaults()
+            logger.info(f"{verb} {', '.join(f'{k}={v}' for k, v in bound_args.arguments.items())}")
+            result = await func(*args, **kwargs)
+            logger.info(f"Finished tool: {func.__name__}")
+            return result
+        return wrapper
+    return decorator
+
+
+def log_tool_method(func: Callable) -> Callable:
+    """Decorator for logging Tool class methods."""
+    @wraps(func)
+    async def wrapper(self, **kwargs):
+        logger.info(f"Starting tool: {self.name}")
+        try:
+            result = await func(self, **kwargs)
+            logger.info(f"Finished tool: {self.name}")
+            return result
+        except Exception as e:
+            logger.error(f"Tool {self.name} failed: {e}")
+            raise
+    return wrapper
+
+
+def validate_xml(xml_string: str) -> bool:
+    """Validate XML string."""
+    try:
+        etree.fromstring(xml_string)
+        return True
+    except etree.XMLSyntaxError as e:
+        logger.error(f"XML validation failed: {e}")
+        return False
+
+
+def validate_code(code: str) -> bool:
+    """Check if code has an async main() function."""
+    try:
+        tree = ast.parse(code)
+        return any(isinstance(node, ast.AsyncFunctionDef) and node.name == "main" 
+                  for node in ast.walk(tree))
+    except SyntaxError:
+        return False
+
+
+def format_xml_element(tag: str, value: Any, **attribs) -> etree.Element:
+    """Create an XML element with optional CDATA and attributes."""
+    elem = etree.Element(tag, **attribs)
+    elem.text = etree.CDATA(str(value)) if value is not None else None
+    return elem
+
+
+class XMLResultHandler:
+    """Utility class for handling XML formatting and parsing."""
+    @staticmethod
+    def format_execution_result(result) -> str:
+        """Format execution result as XML."""
+        root = etree.Element("ExecutionResult")
+        root.append(format_xml_element("Status", "Success" if not result.error else "Error"))
+        root.append(format_xml_element("Value", result.result or result.error))
+        root.append(format_xml_element("ExecutionTime", f"{result.execution_time:.2f} seconds"))
+
+        completed = result.result and result.result.startswith("Task completed:")
+        root.append(format_xml_element("Completed", str(completed).lower()))
+        
+        if completed:
+            final_answer = result.result[len("Task completed:"):].strip()
+            root.append(format_xml_element("FinalAnswer", final_answer))
+
+        if result.local_variables:
+            vars_elem = etree.SubElement(root, "Variables")
+            for k, v in result.local_variables.items():
+                if not callable(v) and not k.startswith("__"):
+                    vars_elem.append(format_xml_element("Variable", str(v)[:5000] + 
+                                                      ("... (truncated)" if len(str(v)) > 5000 else ""), 
+                                                      name=k))
+        return etree.tostring(root, pretty_print=True, encoding="unicode")
+
+    @staticmethod
+    def format_result_summary(result_xml: str) -> str:
+        """Format XML result into a readable summary."""
+        try:
+            root = etree.fromstring(result_xml)
+            lines = [
+                f"- Status: {root.findtext('Status', 'N/A')}",
+                f"- Value: {root.findtext('Value', 'N/A')}",
+                f"- Execution Time: {root.findtext('ExecutionTime', 'N/A')}",
+                f"- Completed: {root.findtext('Completed', 'N/A').capitalize()}"
+            ]
+            if final_answer := root.findtext("FinalAnswer"):
+                lines.append(f"- Final Answer: {final_answer}")
+
+            if (vars_elem := root.find("Variables")) is not None:
+                lines.append("- Variables:")
+                lines.extend(f"  - {var.get('name', 'unknown')}: {var.text.strip() or 'N/A'}" 
+                            for var in vars_elem.findall("Variable"))
+            return "\n".join(lines)
+        except etree.XMLSyntaxError:
+            logger.error(f"Failed to parse XML: {result_xml}")
+            return result_xml
+
+    @staticmethod
+    def parse_response(response: str) -> Tuple[str, str]:
+        """Parse XML response to extract thought and code."""
+        try:
+            root = etree.fromstring(response)
+            thought = root.findtext("Thought") or ""
+            code = root.findtext("Code") or ""
+            return thought, code
+        except etree.XMLSyntaxError as e:
+            raise ValueError(f"Failed to parse XML: {e}")
+
+    @staticmethod
+    def extract_result_value(result: str) -> str:
+        """Extract the value from the result XML."""
+        try:
+            return etree.fromstring(result).findtext("Value") or ""
+        except etree.XMLSyntaxError:
+            return ""

quantalogic/coding_agent.py

@@ -15,7 +15,7 @@ from quantalogic.tools import (
     ReadHTMLTool,
     ReplaceInFileTool,
     RipgrepTool,
-    SearchDefinitionNames,
+    SearchDefinitionNamesTool,
     TaskCompleteTool,
     WriteFileTool,
 )
@@ -71,7 +71,7 @@ def create_coding_agent(
         # Code navigation and search tools
         ListDirectoryTool(),  # Lists directory contents
         RipgrepTool(),  # Searches code with regex
-        SearchDefinitionNames(),  # Finds code definitions
+        SearchDefinitionNamesTool(),  # Finds code definitions
         # Specialized language model tools
         ReadFileTool(),
         ExecuteBashCommandTool(),

quantalogic/python_interpreter/__init__.py

@@ -0,0 +1,23 @@
+# quantalogic/utils/__init__.py
+from .exceptions import BreakException, ContinueException, ReturnException, WrappedException, has_await
+from .execution import AsyncExecutionResult, execute_async, interpret_ast, interpret_code
+from .function_utils import AsyncFunction, Function, LambdaFunction
+from .interpreter_core import ASTInterpreter
+from .scope import Scope
+
+__all__ = [
+    'ASTInterpreter',
+    'execute_async',
+    'interpret_ast',
+    'interpret_code',
+    'AsyncExecutionResult',
+    'ReturnException',
+    'BreakException',
+    'ContinueException',
+    'WrappedException',
+    'has_await',
+    'Function',
+    'AsyncFunction',
+    'LambdaFunction',
+    'Scope',
+]

quantalogic/python_interpreter/assignment_visitors.py

@@ -0,0 +1,63 @@
+import ast
+from typing import Any
+
+from .interpreter_core import ASTInterpreter
+
+async def visit_Assign(self: ASTInterpreter, node: ast.Assign, wrap_exceptions: bool = True) -> None:
+    value: Any = await self.visit(node.value, wrap_exceptions=wrap_exceptions)
+    for target in node.targets:
+        if isinstance(target, ast.Subscript):
+            obj = await self.visit(target.value, wrap_exceptions=wrap_exceptions)
+            key = await self.visit(target.slice, wrap_exceptions=wrap_exceptions)
+            obj[key] = value
+        else:
+            await self.assign(target, value)
+
+async def visit_AugAssign(self: ASTInterpreter, node: ast.AugAssign, wrap_exceptions: bool = True) -> Any:
+    if isinstance(node.target, ast.Name):
+        current_val: Any = self.get_variable(node.target.id)
+    else:
+        current_val: Any = await self.visit(node.target, wrap_exceptions=wrap_exceptions)
+    right_val: Any = await self.visit(node.value, wrap_exceptions=wrap_exceptions)
+    op = node.op
+    if isinstance(op, ast.Add):
+        result: Any = current_val + right_val
+    elif isinstance(op, ast.Sub):
+        result = current_val - right_val
+    elif isinstance(op, ast.Mult):
+        result = current_val * right_val
+    elif isinstance(op, ast.Div):
+        result = current_val / right_val
+    elif isinstance(op, ast.FloorDiv):
+        result = current_val // right_val
+    elif isinstance(op, ast.Mod):
+        result = current_val % right_val
+    elif isinstance(op, ast.Pow):
+        result = current_val**right_val
+    elif isinstance(op, ast.BitAnd):
+        result = current_val & right_val
+    elif isinstance(op, ast.BitOr):
+        result = current_val | right_val
+    elif isinstance(op, ast.BitXor):
+        result = current_val ^ right_val
+    elif isinstance(op, ast.LShift):
+        result = current_val << right_val
+    elif isinstance(op, ast.RShift):
+        result = current_val >> right_val
+    else:
+        raise Exception("Unsupported augmented operator: " + str(op))
+    await self.assign(node.target, result)
+    return result
+
+async def visit_AnnAssign(self: ASTInterpreter, node: ast.AnnAssign, wrap_exceptions: bool = True) -> None:
+    value = await self.visit(node.value, wrap_exceptions=wrap_exceptions) if node.value else None
+    annotation = await self.visit(node.annotation, wrap_exceptions=True)
+    if isinstance(node.target, ast.Name):
+        self.type_hints[node.target.id] = annotation
+    if value is not None or node.simple:
+        await self.assign(node.target, value)
+
+async def visit_NamedExpr(self: ASTInterpreter, node: ast.NamedExpr, wrap_exceptions: bool = True) -> Any:
+    value = await self.visit(node.value, wrap_exceptions=wrap_exceptions)
+    await self.assign(node.target, value)
+    return value

quantalogic/python_interpreter/base_visitors.py

@@ -0,0 +1,20 @@
+import ast
+from typing import Any
+
+from .exceptions import WrappedException
+from .interpreter_core import ASTInterpreter
+
+async def visit_Module(self: ASTInterpreter, node: ast.Module, wrap_exceptions: bool = True) -> Any:
+    last_value = None
+    for stmt in node.body:
+        last_value = await self.visit(stmt, wrap_exceptions=True)
+    return last_value
+
+async def visit_Expr(self: ASTInterpreter, node: ast.Expr, wrap_exceptions: bool = True) -> Any:
+    return await self.visit(node.value, wrap_exceptions=wrap_exceptions)
+
+async def visit_Pass(self: ASTInterpreter, node: ast.Pass, wrap_exceptions: bool = True) -> None:
+    return None
+
+async def visit_TypeIgnore(self: ASTInterpreter, node: ast.TypeIgnore, wrap_exceptions: bool = True) -> None:
+    pass

quantalogic/python_interpreter/class_visitors.py

@@ -0,0 +1,22 @@
+import ast
+from typing import Any, Dict, List
+
+from .function_utils import Function
+from .interpreter_core import ASTInterpreter
+
+async def visit_ClassDef(self: ASTInterpreter, node: ast.ClassDef, wrap_exceptions: bool = True) -> Any:
+    base_frame = {}
+    self.env_stack.append(base_frame)
+    bases = [await self.visit(base, wrap_exceptions=True) for base in node.bases]
+    try:
+        for stmt in node.body:
+            await self.visit(stmt, wrap_exceptions=True)
+        class_dict = {k: v for k, v in self.env_stack[-1].items() if k not in ["__builtins__"]}
+        cls = type(node.name, tuple(bases), class_dict)
+        for name, value in class_dict.items():
+            if isinstance(value, Function):
+                value.defining_class = cls
+        self.env_stack[-2][node.name] = cls
+        return cls
+    finally:
+        self.env_stack.pop()

quantalogic/python_interpreter/comprehension_visitors.py

@@ -0,0 +1,172 @@
+import ast
+from typing import Any, Dict, List
+
+from .interpreter_core import ASTInterpreter
+from .exceptions import WrappedException
+
+async def visit_ListComp(self: ASTInterpreter, node: ast.ListComp, wrap_exceptions: bool = True) -> List[Any]:
+    result = []
+    base_frame = self.env_stack[-1].copy()
+    self.env_stack.append(base_frame)
+
+    async def rec(gen_idx: int):
+        if gen_idx == len(node.generators):
+            element = await self.visit(node.elt, wrap_exceptions=wrap_exceptions)
+            result.append(element)
+        else:
+            comp = node.generators[gen_idx]
+            iterable = await self.visit(comp.iter, wrap_exceptions=wrap_exceptions)
+            if hasattr(iterable, '__aiter__'):
+                async for item in iterable:
+                    new_frame = self.env_stack[-1].copy()
+                    self.env_stack.append(new_frame)
+                    await self.assign(comp.target, item)
+                    conditions = [await self.visit(if_clause, wrap_exceptions=True) for if_clause in comp.ifs]
+                    if all(conditions):
+                        await rec(gen_idx + 1)
+                    self.env_stack.pop()
+            else:
+                try:
+                    for item in iterable:
+                        new_frame = self.env_stack[-1].copy()
+                        self.env_stack.append(new_frame)
+                        await self.assign(comp.target, item)
+                        conditions = [await self.visit(if_clause, wrap_exceptions=True) for if_clause in comp.ifs]
+                        if all(conditions):
+                            await rec(gen_idx + 1)
+                        self.env_stack.pop()
+                except TypeError as e:
+                    lineno = getattr(node, "lineno", 1)
+                    col = getattr(node, "col_offset", 0)
+                    context_line = self.source_lines[lineno - 1] if self.source_lines and lineno <= len(self.source_lines) else ""
+                    raise WrappedException(f"Object {iterable} is not iterable", e, lineno, col, context_line) from e
+
+    await rec(0)
+    self.env_stack.pop()
+    return result
+
+async def visit_DictComp(self: ASTInterpreter, node: ast.DictComp, wrap_exceptions: bool = True) -> Dict[Any, Any]:
+    result = {}
+    base_frame = self.env_stack[-1].copy()
+    self.env_stack.append(base_frame)
+
+    async def rec(gen_idx: int):
+        if gen_idx == len(node.generators):
+            key = await self.visit(node.key, wrap_exceptions=True)
+            val = await self.visit(node.value, wrap_exceptions=True)
+            result[key] = val
+        else:
+            comp = node.generators[gen_idx]
+            iterable = await self.visit(comp.iter, wrap_exceptions=wrap_exceptions)
+            if hasattr(iterable, '__aiter__'):
+                async for item in iterable:
+                    new_frame = self.env_stack[-1].copy()
+                    self.env_stack.append(new_frame)
+                    await self.assign(comp.target, item)
+                    conditions = [await self.visit(if_clause, wrap_exceptions=True) for if_clause in comp.ifs]
+                    if all(conditions):
+                        await rec(gen_idx + 1)
+                    self.env_stack.pop()
+            else:
+                try:
+                    for item in iterable:
+                        new_frame = self.env_stack[-1].copy()
+                        self.env_stack.append(new_frame)
+                        await self.assign(comp.target, item)
+                        conditions = [await self.visit(if_clause, wrap_exceptions=True) for if_clause in comp.ifs]
+                        if all(conditions):
+                            await rec(gen_idx + 1)
+                        self.env_stack.pop()
+                except TypeError as e:
+                    lineno = getattr(node, "lineno", 1)
+                    col = getattr(node, "col_offset", 0)
+                    context_line = self.source_lines[lineno - 1] if self.source_lines and lineno <= len(self.source_lines) else ""
+                    raise WrappedException(f"Object {iterable} is not iterable", e, lineno, col, context_line) from e
+
+    await rec(0)
+    self.env_stack.pop()
+    return result
+
+async def visit_SetComp(self: ASTInterpreter, node: ast.SetComp, wrap_exceptions: bool = True) -> set:
+    result = set()
+    base_frame = self.env_stack[-1].copy()
+    self.env_stack.append(base_frame)
+
+    async def rec(gen_idx: int):
+        if gen_idx == len(node.generators):
+            result.add(await self.visit(node.elt, wrap_exceptions=True))
+        else:
+            comp = node.generators[gen_idx]
+            iterable = await self.visit(comp.iter, wrap_exceptions=wrap_exceptions)
+            if hasattr(iterable, '__aiter__'):
+                async for item in iterable:
+                    new_frame = self.env_stack[-1].copy()
+                    self.env_stack.append(new_frame)
+                    await self.assign(comp.target, item)
+                    conditions = [await self.visit(if_clause, wrap_exceptions=True) for if_clause in comp.ifs]
+                    if all(conditions):
+                        await rec(gen_idx + 1)
+                    self.env_stack.pop()
+            else:
+                try:
+                    for item in iterable:
+                        new_frame = self.env_stack[-1].copy()
+                        self.env_stack.append(new_frame)
+                        await self.assign(comp.target, item)
+                        conditions = [await self.visit(if_clause, wrap_exceptions=True) for if_clause in comp.ifs]
+                        if all(conditions):
+                            await rec(gen_idx + 1)
+                        self.env_stack.pop()
+                except TypeError as e:
+                    lineno = getattr(node, "lineno", 1)
+                    col = getattr(node, "col_offset", 0)
+                    context_line = self.source_lines[lineno - 1] if self.source_lines and lineno <= len(self.source_lines) else ""
+                    raise WrappedException(f"Object {iterable} is not iterable", e, lineno, col, context_line) from e
+
+    await rec(0)
+    self.env_stack.pop()
+    return result
+
+async def visit_GeneratorExp(self: ASTInterpreter, node: ast.GeneratorExp, wrap_exceptions: bool = True) -> Any:
+    base_frame: Dict[str, Any] = self.env_stack[-1].copy()
+    self.env_stack.append(base_frame)
+
+    async def gen():
+        async def rec(gen_idx: int):
+            if gen_idx == len(node.generators):
+                yield await self.visit(node.elt, wrap_exceptions=True)
+            else:
+                comp = node.generators[gen_idx]
+                iterable = await self.visit(comp.iter, wrap_exceptions=wrap_exceptions)
+                if hasattr(iterable, '__aiter__'):
+                    async for item in iterable:
+                        new_frame = self.env_stack[-1].copy()
+                        self.env_stack.append(new_frame)
+                        await self.assign(comp.target, item)
+                        conditions = [await self.visit(if_clause, wrap_exceptions=True) for if_clause in comp.ifs]
+                        if all(conditions):
+                            async for val in rec(gen_idx + 1):
+                                yield val
+                        self.env_stack.pop()
+                else:
+                    try:
+                        for item in iterable:
+                            new_frame = self.env_stack[-1].copy()
+                            self.env_stack.append(new_frame)
+                            await self.assign(comp.target, item)
+                            conditions = [await self.visit(if_clause, wrap_exceptions=True) for if_clause in comp.ifs]
+                            if all(conditions):
+                                async for val in rec(gen_idx + 1):
+                                    yield val
+                            self.env_stack.pop()
+                    except TypeError as e:
+                        lineno = getattr(node, "lineno", 1)
+                        col = getattr(node, "col_offset", 0)
+                        context_line = self.source_lines[lineno - 1] if self.source_lines and lineno <= len(self.source_lines) else ""
+                        raise WrappedException(f"Object {iterable} is not iterable", e, lineno, col, context_line) from e
+
+        async for val in rec(0):
+            yield val
+
+    self.env_stack.pop()
+    return gen()

quantalogic/python_interpreter/context_visitors.py

@@ -0,0 +1,59 @@
+import ast
+from typing import Any
+
+from .exceptions import ReturnException
+from .interpreter_core import ASTInterpreter
+
+async def visit_With(self: ASTInterpreter, node: ast.With, wrap_exceptions: bool = True) -> Any:
+    result = None
+    contexts = []
+    for item in node.items:
+        ctx = await self.visit(item.context_expr, wrap_exceptions=wrap_exceptions)
+        val = ctx.__enter__()
+        contexts.append((ctx, val))
+        if item.optional_vars:
+            await self.assign(item.optional_vars, val)
+    try:
+        for stmt in node.body:
+            result = await self.visit(stmt, wrap_exceptions=wrap_exceptions)
+    except ReturnException as ret:
+        for ctx, _ in reversed(contexts):
+            ctx.__exit__(None, None, None)
+        raise ret
+    except Exception as e:
+        exc_type, exc_value, tb = type(e), e, e.__traceback__
+        for ctx, _ in reversed(contexts):
+            if not ctx.__exit__(exc_type, exc_value, tb):
+                raise
+        raise
+    else:
+        for ctx, _ in reversed(contexts):
+            ctx.__exit__(None, None, None)
+    return result
+
+async def visit_AsyncWith(self: ASTInterpreter, node: ast.AsyncWith, wrap_exceptions: bool = True) -> Any:
+    result = None
+    contexts = []
+    for item in node.items:
+        ctx = await self.visit(item.context_expr, wrap_exceptions=wrap_exceptions)
+        val = await ctx.__aenter__()
+        contexts.append((ctx, val))
+        if item.optional_vars:
+            await self.assign(item.optional_vars, val)
+    try:
+        for stmt in node.body:
+            result = await self.visit(stmt, wrap_exceptions=wrap_exceptions)
+    except ReturnException as ret:
+        for ctx, _ in reversed(contexts):
+            await ctx.__aexit__(None, None, None)
+        raise ret
+    except Exception as e:
+        exc_type, exc_value, tb = type(e), e, e.__traceback__
+        for ctx, _ in reversed(contexts):
+            if not await ctx.__aexit__(exc_type, exc_value, tb):
+                raise
+        raise
+    else:
+        for ctx, _ in reversed(contexts):
+            await ctx.__aexit__(None, None, None)
+    return result

quantalogic/python_interpreter/control_flow_visitors.py

@@ -0,0 +1,88 @@
+import ast
+from typing import Any
+
+from .exceptions import BreakException, ContinueException, ReturnException
+from .interpreter_core import ASTInterpreter
+
+async def visit_If(self: ASTInterpreter, node: ast.If, wrap_exceptions: bool = True) -> Any:
+    if await self.visit(node.test, wrap_exceptions=wrap_exceptions):
+        branch = node.body
+    else:
+        branch = node.orelse
+    result = None
+    if branch:
+        for stmt in branch[:-1]:
+            await self.visit(stmt, wrap_exceptions=wrap_exceptions)
+        result = await self.visit(branch[-1], wrap_exceptions=wrap_exceptions)
+    return result
+
+async def visit_While(self: ASTInterpreter, node: ast.While, wrap_exceptions: bool = True) -> None:
+    while await self.visit(node.test, wrap_exceptions=wrap_exceptions):
+        try:
+            for stmt in node.body:
+                await self.visit(stmt, wrap_exceptions=wrap_exceptions)
+        except BreakException:
+            break
+        except ContinueException:
+            continue
+    for stmt in node.orelse:
+        await self.visit(stmt, wrap_exceptions=wrap_exceptions)
+
+async def visit_For(self: ASTInterpreter, node: ast.For, wrap_exceptions: bool = True) -> None:
+    iter_obj: Any = await self.visit(node.iter, wrap_exceptions=wrap_exceptions)
+    broke = False
+    if hasattr(iter_obj, '__aiter__'):
+        async for item in iter_obj:
+            await self.assign(node.target, item)
+            try:
+                for stmt in node.body:
+                    await self.visit(stmt, wrap_exceptions=wrap_exceptions)
+            except BreakException:
+                broke = True
+                break
+            except ContinueException:
+                continue
+    else:
+        for item in iter_obj:
+            await self.assign(node.target, item)
+            try:
+                for stmt in node.body:
+                    await self.visit(stmt, wrap_exceptions=wrap_exceptions)
+            except BreakException:
+                broke = True
+                break
+            except ContinueException:
+                continue
+    if not broke:
+        for stmt in node.orelse:
+            await self.visit(stmt, wrap_exceptions=wrap_exceptions)
+
+async def visit_AsyncFor(self: ASTInterpreter, node: ast.AsyncFor, wrap_exceptions: bool = True) -> None:
+    iterable = await self.visit(node.iter, wrap_exceptions=wrap_exceptions)
+    broke = False
+    async for value in iterable:
+        await self.assign(node.target, value)
+        try:
+            for stmt in node.body:
+                await self.visit(stmt, wrap_exceptions=wrap_exceptions)
+        except BreakException:
+            broke = True
+            break
+        except ContinueException:
+            continue
+    if not broke:
+        for stmt in node.orelse:
+            await self.visit(stmt, wrap_exceptions=wrap_exceptions)
+
+async def visit_Break(self: ASTInterpreter, node: ast.Break, wrap_exceptions: bool = True) -> None:
+    raise BreakException()
+
+async def visit_Continue(self: ASTInterpreter, node: ast.Continue, wrap_exceptions: bool = True) -> None:
+    raise ContinueException()
+
+async def visit_Return(self: ASTInterpreter, node: ast.Return, wrap_exceptions: bool = True) -> None:
+    value: Any = await self.visit(node.value, wrap_exceptions=wrap_exceptions) if node.value is not None else None
+    raise ReturnException(value)
+
+async def visit_IfExp(self: ASTInterpreter, node: ast.IfExp, wrap_exceptions: bool = True) -> Any:
+    return await self.visit(node.body, wrap_exceptions=wrap_exceptions) if await self.visit(node.test, wrap_exceptions=wrap_exceptions) else await self.visit(node.orelse, wrap_exceptions=wrap_exceptions)