ENH: initial commit for adding Expr based terms for pytables support

Author: jreback

pandas/computation/engines.py

@@ -75,5 +75,4 @@ def evaluate(self):
     def _evaluate(self, env):
         pass
 
-
-_engines = {'numexpr': NumExprEngine, 'python': PythonEngine}
+_engines = {'numexpr': NumExprEngine, 'python': PythonEngine }

pandas/computation/expr.py

@@ -8,7 +8,6 @@
 from pandas.computation.ops import _arith_ops_syms, _unary_ops_syms
 from pandas.computation.ops import Term, Constant
 
-
 class Scope(object):
     __slots__ = 'globals', 'locals'
 
@@ -21,7 +20,6 @@ def __init__(self, gbls=None, lcls=None, frame_level=1):
         finally:
             del frame
 
-
 class ExprParserError(Exception):
     pass
 
@@ -49,53 +47,66 @@ def __init__(self, env):
                     lambda node, unary_op=unary_op: partial(UnaryOp, unary_op))
         self.env = env
 
-    def visit(self, node):
+    def generic_visit(self, node, **kwargs):
+        """Called if no explicit visitor function exists for a node."""
+        for field, value in iter_fields(node):
+            if isinstance(value, list):
+                for item in value:
+                    if isinstance(item, AST):
+                        self.visit(item, **kwargs)
+            elif isinstance(value, AST):
+                self.visit(value, **kwargs)
+
+    def visit(self, node, **kwargs):
         if not (isinstance(node, ast.AST) or isinstance(node, basestring)):
             raise TypeError('"node" must be an AST node or a string, you'
                             ' passed a(n) {0}'.format(node.__class__))
         if isinstance(node, basestring):
             node = ast.fix_missing_locations(ast.parse(node))
-        return super(ExprVisitor, self).visit(node)
 
-    def visit_Module(self, node):
+        method = 'visit_' + node.__class__.__name__
+        visitor = getattr(self, method, self.generic_visit)
+        return visitor(node, **kwargs)
+
+    def visit_Module(self, node, **kwargs):
         if len(node.body) != 1:
             raise ExprParserError('only a single expression is allowed')
 
         expr = node.body[0]
         if not isinstance(expr, ast.Expr):
             raise SyntaxError('only expressions are allowed')
 
-        return self.visit(expr)
+        return self.visit(expr, **kwargs)
 
-    def visit_Expr(self, node):
-        return self.visit(node.value)
+    def visit_Expr(self, node, **kwargs):
+        return self.visit(node.value, **kwargs)
 
-    def visit_BinOp(self, node):
+    def visit_BinOp(self, node, **kwargs):
         op = self.visit(node.op)
-        left = self.visit(node.left)
-        right = self.visit(node.right)
+        left = self.visit(node.left,side='left')
+        right = self.visit(node.right,side='right')
         return op(left, right)
 
-    def visit_UnaryOp(self, node):
+    def visit_UnaryOp(self, node, **kwargs):
         if isinstance(node.op, ast.Not):
             raise NotImplementedError("not operator not yet supported")
         op = self.visit(node.op)
         return op(self.visit(node.operand))
 
-    def visit_Name(self, node):
+    def visit_Name(self, node, **kwargs):
         return Term(node.id, self.env)
 
-    def visit_Num(self, node):
+    def visit_Num(self, node, **kwargs):
         return Constant(node.n, self.env)
 
-    def visit_Compare(self, node):
+    def visit_Compare(self, node, **kwargs):
         ops = node.ops
         comps = node.comparators
         if len(ops) != 1:
             raise ExprParserError('chained comparisons not supported')
-        return self.visit(ops[0])(self.visit(node.left), self.visit(comps[0]))
+        return self.visit(ops[0])(self.visit(node.left,side='left'), self.visit(comps[0],side='right'))
 
-    def visit_Call(self, node):
+    def visit_Call(self, node, **kwargs):
         if not isinstance(node.func, ast.Name):
             raise TypeError("Only named functions are supported")
 
@@ -106,10 +117,10 @@ def visit_Call(self, node):
 
         raise NotImplementedError("function calls not yet supported")
 
-    def visit_Attribute(self, node):
+    def visit_Attribute(self, node, **kwargs):
         raise NotImplementedError("attribute access is not yet supported")
 
-    def visit_BoolOp(self, node):
+    def visit_BoolOp(self, node, **kwargs):
         raise NotImplementedError("boolean operators are not yet supported")
 
 

pandas/computation/ops.py

@@ -24,43 +24,43 @@ class BinaryOperatorError(OperatorError):
     pass
 
 
-def _resolve_name(env, key):
-    res = env.locals.get(key, env.globals.get(key))
-
-    if res is None:
-        if not isinstance(key, basestring):
-            return key
-
-        raise NameError('name {0!r} is not defined'.format(key))
-
-    return res
-
-
-def _update_name(env, key, value):
-    if isinstance(key, basestring):
-        try:
-            del env.locals[key]
-            env.locals[key] = value
-        except KeyError:
-            try:
-                del env.globals[key]
-                env.globals[key] = value
-            except KeyError:
-                raise NameError('{0!r} is undefined'.format(key))
-
-
 class Term(StringMixin):
-    def __init__(self, name, env):
+    def __init__(self, name, env, side=None):
         self.name = name
-        self.value = _resolve_name(env, name)
         self.env = env
+        self.side = side
+        self.value = self._resolve_name()
         self.type = type(self.value)
 
     def __unicode__(self):
         return com.pprint_thing(self.name)
 
+    def _resolve_name(self):
+        env = self.env
+        key = self.name
+        res = env.locals.get(key, env.globals.get(key))
+
+        if res is None:
+            if not isinstance(key, basestring):
+                return key
+
+            raise NameError('name {0!r} is not defined'.format(key))
+        return res
+
     def update(self, value):
-        _update_name(self.env, self.name, value)
+        env = self.env
+        key = self.name
+        if isinstance(key, basestring):
+            try:
+                del env.locals[key]
+                env.locals[key] = value
+            except KeyError:
+                try:
+                    del env.globals[key]
+                    env.globals[key] = value
+                except KeyError:
+                    raise NameError('{0!r} is undefined'.format(key))
+
         self.value = value
 
     @property