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

quantalogic/python_interpreter/misc_visitors.py

@@ -0,0 +1,148 @@
+import ast
+from typing import Any
+
+from .interpreter_core import ASTInterpreter
+
+async def visit_Global(self: ASTInterpreter, node: ast.Global, wrap_exceptions: bool = True) -> None:
+    self.env_stack[-1].setdefault("__global_names__", set()).update(node.names)
+
+async def visit_Nonlocal(self: ASTInterpreter, node: ast.Nonlocal, wrap_exceptions: bool = True) -> None:
+    self.env_stack[-1].setdefault("__nonlocal_names__", set()).update(node.names)
+
+async def visit_Delete(self: ASTInterpreter, node: ast.Delete, wrap_exceptions: bool = True):
+    for target in node.targets:
+        if isinstance(target, ast.Name):
+            del self.env_stack[-1][target.id]
+        elif isinstance(target, ast.Subscript):
+            obj = await self.visit(target.value, wrap_exceptions=wrap_exceptions)
+            key = await self.visit(target.slice, wrap_exceptions=wrap_exceptions)
+            del obj[key]
+        else:
+            raise Exception(f"Unsupported del target: {type(target).__name__}")
+
+async def visit_Assert(self: ASTInterpreter, node: ast.Assert, wrap_exceptions: bool = True) -> None:
+    test = await self.visit(node.test, wrap_exceptions=wrap_exceptions)
+    if not test:
+        msg = await self.visit(node.msg, wrap_exceptions=wrap_exceptions) if node.msg else "Assertion failed"
+        raise AssertionError(msg)
+
+async def visit_Yield(self: ASTInterpreter, node: ast.Yield, wrap_exceptions: bool = True) -> Any:
+    value = await self.visit(node.value, wrap_exceptions=wrap_exceptions) if node.value else None
+    self.recursion_depth += 1  # Treat yields as recursion for loop detection
+    if self.recursion_depth > self.max_recursion_depth:
+        raise RecursionError(f"Maximum recursion depth exceeded in yield ({self.max_recursion_depth})")
+    self.recursion_depth -= 1
+    return value
+
+async def visit_YieldFrom(self: ASTInterpreter, node: ast.YieldFrom, wrap_exceptions: bool = True) -> Any:
+    iterable = await self.visit(node.value, wrap_exceptions=wrap_exceptions)
+    if hasattr(iterable, '__aiter__'):
+        async def async_gen():
+            async for value in iterable:
+                yield value
+        return async_gen()
+    else:
+        def sync_gen():
+            for value in iterable:
+                yield value
+        return sync_gen()
+
+async def visit_Match(self: ASTInterpreter, node: ast.Match, wrap_exceptions: bool = True) -> Any:
+    subject = await self.visit(node.subject, wrap_exceptions=wrap_exceptions)
+    result = None
+    base_frame = self.env_stack[-1].copy()
+    for case in node.cases:
+        self.env_stack.append(base_frame.copy())
+        try:
+            if await self._match_pattern(subject, case.pattern):
+                if case.guard and not await self.visit(case.guard, wrap_exceptions=True):
+                    continue
+                for stmt in case.body[:-1]:
+                    await self.visit(stmt, wrap_exceptions=wrap_exceptions)
+                result = await self.visit(case.body[-1], wrap_exceptions=wrap_exceptions)
+                break
+        finally:
+            self.env_stack.pop()
+    return result
+
+async def _match_pattern(self: ASTInterpreter, subject: Any, pattern: ast.AST) -> bool:
+    if isinstance(pattern, ast.MatchValue):
+        value = await self.visit(pattern.value, wrap_exceptions=True)
+        return subject == value
+    elif isinstance(pattern, ast.MatchSingleton):
+        return subject is pattern.value
+    elif isinstance(pattern, ast.MatchSequence):
+        if not isinstance(subject, (list, tuple)):
+            return False
+        if len(pattern.patterns) != len(subject) and not any(isinstance(p, ast.MatchStar) for p in pattern.patterns):
+            return False
+        star_idx = None
+        for i, pat in enumerate(pattern.patterns):
+            if isinstance(pat, ast.MatchStar):
+                if star_idx is not None:
+                    return False
+                star_idx = i
+        if star_idx is None:
+            for sub, pat in zip(subject, pattern.patterns):
+                if not await self._match_pattern(sub, pat):
+                    return False
+            return True
+        else:
+            before = pattern.patterns[:star_idx]
+            after = pattern.patterns[star_idx + 1:]
+            if len(before) + len(after) > len(subject):
+                return False
+            for sub, pat in zip(subject[:len(before)], before):
+                if not await self._match_pattern(sub, pat):
+                    return False
+            for sub, pat in zip(subject[len(subject) - len(after):], after):
+                if not await self._match_pattern(sub, pat):
+                    return False
+            star_pat = pattern.patterns[star_idx]
+            star_count = len(subject) - len(before) - len(after)
+            star_sub = subject[len(before):len(before) + star_count]
+            if star_pat.name:
+                self.set_variable(star_pat.name, star_sub)
+            return True
+    elif isinstance(pattern, ast.MatchMapping):
+        if not isinstance(subject, dict):
+            return False
+        keys = [await self.visit(k, wrap_exceptions=True) for k in pattern.keys]
+        if len(keys) != len(subject) and pattern.rest is None:
+            return False
+        for k, p in zip(keys, pattern.patterns):
+            if k not in subject or not await self._match_pattern(subject[k], p):
+                return False
+        if pattern.rest:
+            remaining = {k: v for k, v in subject.items() if k not in keys}
+            self.set_variable(pattern.rest, remaining)
+        return True
+    elif isinstance(pattern, ast.MatchClass):
+        cls = await self.visit(pattern.cls, wrap_exceptions=True)
+        if not isinstance(subject, cls):
+            return False
+        attrs = [getattr(subject, attr) for attr in pattern.attribute_names]
+        if len(attrs) != len(pattern.patterns):
+            return False
+        for attr_val, pat in zip(attrs, pattern.patterns):
+            if not await self._match_pattern(attr_val, pat):
+                return False
+        return True
+    elif isinstance(pattern, ast.MatchStar):
+        if pattern.name:
+            self.set_variable(pattern.name, subject)
+        return True
+    elif isinstance(pattern, ast.MatchAs):
+        if pattern.pattern:
+            if not await self._match_pattern(subject, pattern.pattern):
+                return False
+        if pattern.name:
+            self.set_variable(pattern.name, subject)
+        return True
+    elif isinstance(pattern, ast.MatchOr):
+        for pat in pattern.patterns:
+            if await self._match_pattern(subject, pat):
+                return True
+        return False
+    else:
+        raise Exception(f"Unsupported match pattern: {pattern.__class__.__name__}")

quantalogic/python_interpreter/operator_visitors.py

@@ -0,0 +1,108 @@
+import ast
+from typing import Any
+
+from .interpreter_core import ASTInterpreter
+
+async def visit_BinOp(self: ASTInterpreter, node: ast.BinOp, wrap_exceptions: bool = True) -> Any:
+    left: Any = await self.visit(node.left, wrap_exceptions=wrap_exceptions)
+    right: Any = await self.visit(node.right, wrap_exceptions=wrap_exceptions)
+    op = node.op
+    if isinstance(op, ast.Add):
+        return left + right
+    elif isinstance(op, ast.Sub):
+        if isinstance(left, set) and isinstance(right, set):
+            return left - right
+        return left - right
+    elif isinstance(op, ast.Mult):
+        return left * right
+    elif isinstance(op, ast.Div):
+        return left / right
+    elif isinstance(op, ast.FloorDiv):
+        return left // right
+    elif isinstance(op, ast.Mod):
+        return left % right
+    elif isinstance(op, ast.Pow):
+        return left**right
+    elif isinstance(op, ast.LShift):
+        return left << right
+    elif isinstance(op, ast.RShift):
+        return left >> right
+    elif isinstance(op, ast.BitOr):
+        if isinstance(left, set) and isinstance(right, set):
+            return left | right
+        return left | right
+    elif isinstance(op, ast.BitXor):
+        return left ^ right
+    elif isinstance(op, ast.BitAnd):
+        if isinstance(left, set) and isinstance(right, set):
+            return left & right
+        return left & right
+    else:
+        raise Exception("Unsupported binary operator: " + str(op))
+
+async def visit_UnaryOp(self: ASTInterpreter, node: ast.UnaryOp, wrap_exceptions: bool = True) -> Any:
+    operand: Any = await self.visit(node.operand, wrap_exceptions=wrap_exceptions)
+    op = node.op
+    if isinstance(op, ast.UAdd):
+        return +operand
+    elif isinstance(op, ast.USub):
+        return -operand
+    elif isinstance(op, ast.Not):
+        return not operand
+    elif isinstance(op, ast.Invert):
+        return ~operand
+    else:
+        raise Exception("Unsupported unary operator: " + str(op))
+
+async def visit_Compare(self: ASTInterpreter, node: ast.Compare, wrap_exceptions: bool = True) -> bool:
+    left: Any = await self.visit(node.left, wrap_exceptions=wrap_exceptions)
+    for op, comparator in zip(node.ops, node.comparators):
+        right: Any = await self.visit(comparator, wrap_exceptions=wrap_exceptions)
+        if isinstance(op, ast.Eq):
+            if not (left == right):
+                return False
+        elif isinstance(op, ast.NotEq):
+            if not (left != right):
+                return False
+        elif isinstance(op, ast.Lt):
+            if not (left < right):
+                return False
+        elif isinstance(op, ast.LtE):
+            if not (left <= right):
+                return False
+        elif isinstance(op, ast.Gt):
+            if not (left > right):
+                return False
+        elif isinstance(op, ast.GtE):
+            if not (left >= right):
+                return False
+        elif isinstance(op, ast.Is):
+            if left is not right:
+                return False
+        elif isinstance(op, ast.IsNot):
+            if not (left is not right):
+                return False
+        elif isinstance(op, ast.In):
+            if left not in right:
+                return False
+        elif isinstance(op, ast.NotIn):
+            if not (left not in right):
+                return False
+        else:
+            raise Exception("Unsupported comparison operator: " + str(op))
+        left = right
+    return True
+
+async def visit_BoolOp(self: ASTInterpreter, node: ast.BoolOp, wrap_exceptions: bool = True) -> bool:
+    if isinstance(node.op, ast.And):
+        for value in node.values:
+            if not await self.visit(value, wrap_exceptions=wrap_exceptions):
+                return False
+        return True
+    elif isinstance(node.op, ast.Or):
+        for value in node.values:
+            if await self.visit(value, wrap_exceptions=wrap_exceptions):
+                return True
+        return False
+    else:
+        raise Exception("Unsupported boolean operator: " + str(node.op))

quantalogic/python_interpreter/scope.py

@@ -0,0 +1,10 @@
+# quantalogic/utils/scope.py
+class Scope:
+    def __init__(self, env_stack):
+        self.env_stack = env_stack
+
+    def __enter__(self):
+        self.env_stack.append({})
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.env_stack.pop()

quantalogic/python_interpreter/visit_handlers.py

@@ -0,0 +1,110 @@
+from .base_visitors import (
+    visit_Module,
+    visit_Expr,
+    visit_Pass,
+    visit_TypeIgnore,
+)
+
+from .import_visitors import (
+    visit_Import,
+    visit_ImportFrom,
+)
+
+from .literal_visitors import (
+    visit_Constant,
+    visit_Name,
+    visit_List,
+    visit_Tuple,
+    visit_Dict,
+    visit_Set,
+    visit_Attribute,
+    visit_Subscript,
+    visit_Slice,
+    visit_Index,
+    visit_Starred,
+    visit_JoinedStr,
+    visit_FormattedValue,
+)
+
+from .operator_visitors import (
+    visit_BinOp,
+    visit_UnaryOp,
+    visit_Compare,
+    visit_BoolOp,
+)
+
+from .assignment_visitors import (
+    visit_Assign,
+    visit_AugAssign,
+    visit_AnnAssign,
+    visit_NamedExpr,
+)
+
+from .control_flow_visitors import (
+    visit_If,
+    visit_While,
+    visit_For,
+    visit_AsyncFor,
+    visit_Break,
+    visit_Continue,
+    visit_Return,
+    visit_IfExp,
+)
+
+from .function_visitors import (
+    visit_FunctionDef,
+    visit_AsyncFunctionDef,
+    visit_AsyncGeneratorDef,
+    visit_Call,
+    visit_Await,
+    visit_Lambda,
+)
+
+from .comprehension_visitors import (
+    visit_ListComp,
+    visit_DictComp,
+    visit_SetComp,
+    visit_GeneratorExp,
+)
+
+from .exception_visitors import (
+    visit_Try,
+    visit_TryStar,
+    visit_Raise,
+)
+
+from .class_visitors import (
+    visit_ClassDef,
+)
+
+from .context_visitors import (
+    visit_With,
+    visit_AsyncWith,
+)
+
+from .misc_visitors import (
+    visit_Global,
+    visit_Nonlocal,
+    visit_Delete,
+    visit_Assert,
+    visit_Yield,
+    visit_YieldFrom,
+    visit_Match,
+    _match_pattern,
+)
+
+__all__ = [
+    "visit_Import", "visit_ImportFrom", "visit_ListComp", "visit_Module", "visit_Expr",
+    "visit_Constant", "visit_Name", "visit_BinOp", "visit_UnaryOp", "visit_Assign",
+    "visit_AugAssign", "visit_AnnAssign", "visit_Compare", "visit_BoolOp", "visit_If",
+    "visit_While", "visit_For", "visit_Break", "visit_Continue", "visit_FunctionDef",
+    "visit_AsyncFunctionDef", "visit_AsyncGeneratorDef", "visit_Call", "visit_Await",
+    "visit_Return", "visit_Lambda", "visit_List", "visit_Tuple", "visit_Dict",
+    "visit_Set", "visit_Attribute", "visit_Subscript", "visit_Slice", "visit_Index",
+    "visit_Starred", "visit_Pass", "visit_TypeIgnore", "visit_Try", "visit_TryStar",
+    "visit_Nonlocal", "visit_JoinedStr", "visit_FormattedValue", "visit_GeneratorExp",
+    "visit_ClassDef", "visit_With", "visit_AsyncWith", "visit_Raise", "visit_Global",
+    "visit_IfExp", "visit_DictComp", "visit_SetComp", "visit_Yield", "visit_YieldFrom",
+    "visit_Match", "visit_Delete", "visit_AsyncFor", "visit_Assert", "visit_NamedExpr",
+    "_match_pattern",
+]

quantalogic/server/agent_server.py

@@ -563,7 +563,7 @@ async def event_stream(request: Request, task_id: Optional[str] = None) -> Strea
                 except Empty:
                     # Send keepalive to maintain connection
                     yield ": keepalive\n\n"
-                    await asyncio.sleep(0.1)
+                    # await asyncio.sleep(0)
 
                 if server_state.is_shutting_down:
                     yield 'event: shutdown\ndata: {"message": "Server shutting down"}\n\n'

quantalogic/tools/__init__.py

@@ -8,6 +8,7 @@ from .duckduckgo_search_tool import DuckDuckGoSearchTool
 from .edit_whole_content_tool import EditWholeContentTool
 from .elixir_tool import ElixirTool
 from .execute_bash_command_tool import ExecuteBashCommandTool
+from .file_tracker_tool import FileTrackerTool
 from .grep_app_tool import GrepAppTool
 from .input_question_tool import InputQuestionTool
 from .jinja_tool import JinjaTool
@@ -22,14 +23,14 @@ from .read_file_tool import ReadFileTool
 from .read_html_tool import ReadHTMLTool
 from .replace_in_file_tool import ReplaceInFileTool
 from .ripgrep_tool import RipgrepTool
-from .safe_python_interpreter_tool import SafePythonInterpreterTool
-from .search_definition_names import SearchDefinitionNames
+from .search_definition_names_tool import SearchDefinitionNamesTool
 from .sequence_tool import SequenceTool
 from .serpapi_search_tool import SerpApiSearchTool
 from .sql_query_tool import SQLQueryTool
 from .task_complete_tool import TaskCompleteTool
 from .tool import Tool, ToolArgument, create_tool
 from .unified_diff_tool import UnifiedDiffTool
+from .utils.generate_database_report import generate_database_report
 from .wikipedia_search_tool import WikipediaSearchTool
 from .write_file_tool import WriteFileTool
 
@@ -41,6 +42,7 @@ __all__ = [
     'EditWholeContentTool',
     'ElixirTool',
     'ExecuteBashCommandTool',
+    'generate_database_report',
     'GrepAppTool',
     'InputQuestionTool',
     'JinjaTool',
@@ -56,7 +58,7 @@ __all__ = [
     'ReplaceInFileTool',
     'RipgrepTool',
     'SafePythonInterpreterTool',
-    'SearchDefinitionNames',
+    'SearchDefinitionNamesTool',
     'SequenceTool',
     'SerpApiSearchTool',
     'SQLQueryTool',
@@ -66,5 +68,6 @@ __all__ = [
     'UnifiedDiffTool',
     'WikipediaSearchTool',
     'WriteFileTool',
+    'FileTrackerTool',
     "create_tool"
 ]