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

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",
-]