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

quantalogic/prompts/system_prompt.j2

@@ -7,6 +7,10 @@ Expert ReAct AI Agent implementing OODA (Observe-Orient-Decide-Act) loop with co
 ### Input Protocol
 Task Format: <task>task_description</task>
 
+### FORBIDDEN
+- Never install / execute commands apt-get, or install packages using npm, pnpm, pip yarn, or any other package manager
+- Just provide the command to run if wanted in their environment.
+
 ### Cognitive Framework
 1. 🔍 **OBSERVE**: Gather essential data  
 2. 🧭 **ORIENT**: Analyze context briefly  
@@ -75,8 +79,8 @@ Task Format: <task>task_description</task>
 - 🛠️ **Tools**: {{ tools }}  
 - 🌐 **Environment**: {{ environment }}  
 
-### Execution Guidelines
-. 🎯 Focus on task objectives  
+### Execution Guidelines    
+1. 🎯 Focus on task objectives  
 2. 📊 Use data-driven decisions  
 3. 🔄 Optimize with feedback loops  
 4. ⚡ Maximize efficiency via interpolation  

quantalogic/prompts/tools_prompt.j2

@@ -7,7 +7,5 @@ Instructions:
 1. Select ONE tool per message
 2. You will receive the tool's output in the next user response
 3. Choose the most appropriate tool for each step
-4. If it's not asked to write on files, don't use write_file tool
-5. If files are written, then use tool to display the prepared download link
-6. Give the final full answer using all the variables
-7. Use task_complete tool to confirm task completion with the full content of the final answer
+4. Give the final full answer using all the variables
+5. Use task_complete tool to confirm task completion with the full content of the final answer

quantalogic/prompts.py

@@ -1,20 +1,34 @@
 import os
 from pathlib import Path
+from typing import Dict
 
 from jinja2 import Environment, FileSystemLoader
+from loguru import logger
 
 from quantalogic.version import get_version
 
+# Map agent modes to their system prompt templates
+SYSTEM_PROMPTS: Dict[str, str] = {
+    "react": "system_prompt.j2",
+    "chat": "chat_prompt.j2",
+    "code": "code_system_prompt.j2",
+    "code_enhanced": "code_2_system_prompt.j2",
+    "legal": "legal_system_prompt.j2",
+    "legal_enhanced": "legal_2_system_prompt.j2",
+    "doc": "doc_system_prompt.j2",
+    "default": "system_prompt.j2"  # Fallback template
+}
 
-def system_prompt(tools: str, environment: str, expertise: str = ""):
+def system_prompt(tools: str, environment: str, expertise: str = "", agent_mode: str = "react"):
     """System prompt for the ReAct chatbot with enhanced cognitive architecture.
     
-    Uses a Jinja2 template from the prompts directory.
+    Uses a Jinja2 template from the prompts directory based on agent_mode.
     
     Args:
         tools: Available tools for the agent
         environment: Environment information
         expertise: Domain expertise information
+        agent_mode: Mode to determine which system prompt to use
         
     Returns:
         str: The rendered system prompt
@@ -26,8 +40,13 @@ def system_prompt(tools: str, environment: str, expertise: str = ""):
     template_dir = current_dir / 'prompts'
     env = Environment(loader=FileSystemLoader(template_dir))
     
-    # Load the template
-    template = env.get_template('system_prompt.j2')
+    # Get template name based on agent mode, fallback to default if not found
+    template_name = SYSTEM_PROMPTS.get(agent_mode, "system_prompt.j2")
+    try:
+        template = env.get_template(template_name)
+    except Exception as e:
+        logger.warning(f"Template {template_name} not found, using default")
+        template = env.get_template("system_prompt.j2")
     
     # Render the template with the provided variables
     return template.render(

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)

quantalogic/python_interpreter/exception_visitors.py

@@ -0,0 +1,109 @@
+import ast
+from typing import Any, Optional, Tuple
+
+from .exceptions import BaseExceptionGroup, ReturnException, WrappedException
+from .interpreter_core import ASTInterpreter
+
+async def visit_Try(self: ASTInterpreter, node: ast.Try, wrap_exceptions: bool = True) -> Any:
+    result: Any = None
+    try:
+        for stmt in node.body:
+            result = await self.visit(stmt, wrap_exceptions=False)
+    except ReturnException as ret:
+        raise ret
+    except Exception as e:
+        original_e = e.original_exception if isinstance(e, WrappedException) else e
+        for handler in node.handlers:
+            exc_type = await self._resolve_exception_type(handler.type)
+            if exc_type and isinstance(original_e, exc_type):
+                if handler.name:
+                    self.set_variable(handler.name, original_e)
+                handler_result = None
+                try:
+                    for stmt in handler.body:
+                        handler_result = await self.visit(stmt, wrap_exceptions=True)
+                except ReturnException as ret:
+                    raise ret
+                if handler_result is not None:
+                    result = handler_result
+                break
+        else:
+            raise
+    else:
+        for stmt in node.orelse:
+            result = await self.visit(stmt, wrap_exceptions=True)
+    finally:
+        for stmt in node.finalbody:
+            await self.visit(stmt, wrap_exceptions=True)
+    return result
+
+async def visit_TryStar(self: ASTInterpreter, node: ast.TryStar, wrap_exceptions: bool = True) -> Any:
+    result: Any = None
+    exc_info: Optional[Tuple] = None
+
+    try:
+        for stmt in node.body:
+            result = await self.visit(stmt, wrap_exceptions=False)
+    except BaseException as e:
+        exc_info = (type(e), e, e.__traceback__)
+        handled = False
+        if isinstance(e, BaseExceptionGroup):
+            remaining_exceptions = []
+            for handler in node.handlers:
+                if handler.type is None:
+                    exc_type = BaseException
+                elif isinstance(handler.type, ast.Name):
+                    exc_type = self.get_variable(handler.type.id)
+                else:
+                    exc_type = await self.visit(handler.type, wrap_exceptions=True)
+                matching_exceptions = [ex for ex in e.exceptions if isinstance(ex, exc_type)]
+                if matching_exceptions:
+                    if handler.name:
+                        self.set_variable(handler.name, BaseExceptionGroup("", matching_exceptions))
+                    for stmt in handler.body:
+                        result = await self.visit(stmt, wrap_exceptions=True)
+                    handled = True
+                remaining_exceptions.extend([ex for ex in e.exceptions if not isinstance(ex, exc_type)])
+            if remaining_exceptions and not handled:
+                raise BaseExceptionGroup("Uncaught exceptions", remaining_exceptions)
+            if handled:
+                exc_info = None
+        else:
+            for handler in node.handlers:
+                if handler.type is None:
+                    exc_type = BaseException
+                elif isinstance(handler.type, ast.Name):
+                    exc_type = self.get_variable(handler.type.id)
+                else:
+                    exc_type = await self.visit(handler.type, wrap_exceptions=True)
+                if exc_info and issubclass(exc_info[0], exc_type):
+                    if handler.name:
+                        self.set_variable(handler.name, exc_info[1])
+                    for stmt in handler.body:
+                        result = await self.visit(stmt, wrap_exceptions=True)
+                    exc_info = None
+                    handled = True
+                    break
+        if exc_info and not handled:
+            raise exc_info[1]
+    else:
+        for stmt in node.orelse:
+            result = await self.visit(stmt, wrap_exceptions=True)
+    finally:
+        for stmt in node.finalbody:
+            try:
+                await self.visit(stmt, wrap_exceptions=True)
+            except ReturnException:
+                raise
+            except Exception:
+                if exc_info:
+                    raise exc_info[1]
+                raise
+
+    return result
+
+async def visit_Raise(self: ASTInterpreter, node: ast.Raise, wrap_exceptions: bool = True) -> None:
+    exc = await self.visit(node.exc, wrap_exceptions=wrap_exceptions) if node.exc else None
+    if exc:
+        raise exc
+    raise Exception("Raise with no exception specified")