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

quantalogic/python_interpreter/misc_visitors.py

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

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

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

@@ -1,110 +0,0 @@
-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",
-]