ENH/CLN: track scope instead of hard coding minimal stack level

Author: cpcloud

pandas/computation/engines.py

@@ -4,10 +4,34 @@
 import abc
 
 from pandas import compat
-from pandas.compat import DeepChainMap
+from pandas.compat import DeepChainMap, map
 from pandas.core import common as com
 from pandas.computation.align import _align, _reconstruct_object
-from pandas.computation.ops import UndefinedVariableError
+from pandas.computation.ops import UndefinedVariableError, _mathops, _reductions
+
+
+_ne_builtins = frozenset(_mathops + _reductions)
+
+
+class NumExprClobberingError(NameError):
+    pass
+
+
+def _check_ne_builtin_clash(expr):
+    """Attempt to prevent foot-shooting in a helpful way.
+
+    Parameters
+    ----------
+    terms : Term
+        Terms can contain
+    """
+    names = expr.names
+    overlap = names & _ne_builtins
+
+    if overlap:
+        s = ', '.join(map(repr, overlap))
+        raise NumExprClobberingError('Variables in expression "%s" overlap with '
+                                     'numexpr builtins: (%s)' % (expr, s))
 
 
 class AbstractEngine(object):
@@ -89,9 +113,10 @@ def _evaluate(self):
 
         try:
             env = self.expr.env
-            full_scope = DeepChainMap(*(env.resolvers.maps + env.scope.maps))
-            return ne.evaluate(s, local_dict=full_scope,
-                               truediv=env.scope['truediv'])
+            scope = env.full_scope
+            truediv = scope['truediv']
+            _check_ne_builtin_clash(self.expr)
+            return ne.evaluate(s, local_dict=scope, truediv=truediv)
         except KeyError as e:
             # python 3 compat kludge
             try:
@@ -101,6 +126,7 @@ def _evaluate(self):
             raise UndefinedVariableError(msg)
 
 
+
 class PythonEngine(AbstractEngine):
 
     """Evaluate an expression in Python space.

pandas/computation/pytables.py

@@ -7,25 +7,24 @@
 from datetime import datetime, timedelta
 import numpy as np
 import pandas as pd
-from pandas.compat import u, string_types, PY3
+from pandas.compat import u, string_types, PY3, DeepChainMap
 from pandas.core.base import StringMixin
 import pandas.core.common as com
 from pandas.computation import expr, ops
 from pandas.computation.ops import is_term
+from pandas.computation.scope import _ensure_scope
 from pandas.computation.expr import BaseExprVisitor
 from pandas.computation.common import _ensure_decoded
 from pandas.tseries.timedeltas import _coerce_scalar_to_timedelta_type
 
 
 class Scope(expr.Scope):
-    __slots__ = 'globals', 'locals', 'queryables'
-
-    def __init__(self, gbls=None, lcls=None, queryables=None, level=1):
-        super(
-            Scope,
-            self).__init__(gbls=gbls,
-                           lcls=lcls,
-                           level=level)
+    __slots__ = 'queryables',
+
+    def __init__(self, level, global_dict=None, local_dict=None,
+                 queryables=None):
+        super(Scope, self).__init__(level + 1, global_dict=global_dict,
+                                    local_dict=local_dict)
         self.queryables = queryables or dict()
 
 
@@ -48,9 +47,8 @@ def _resolve_name(self):
                 raise NameError('name {0!r} is not defined'.format(self.name))
             return self.name
 
-        # resolve the rhs (and allow to be None)
-        return self.env.locals.get(self.name,
-                                   self.env.globals.get(self.name, self.name))
+        # resolve the rhs (and allow it to be None)
+        return self.env.resolve(self.name, is_local=False)
 
     @property
     def value(self):
@@ -478,7 +476,7 @@ class Expr(expr.Expr):
     """
 
     def __init__(self, where, op=None, value=None, queryables=None,
-                 encoding=None, scope_level=None):
+                 encoding=None, scope_level=0):
 
         # try to be back compat
         where = self.parse_back_compat(where, op, value)
@@ -488,25 +486,25 @@ def __init__(self, where, op=None, value=None, queryables=None,
         self.filter = None
         self.terms = None
         self._visitor = None
-        # capture the environement if needed
-        lcls = dict()
-        if isinstance(where, Expr):
 
-            lcls.update(where.env.locals)
+        # capture the environment if needed
+        local_dict = dict()
+
+        if isinstance(where, Expr):
+            local_dict.update(where.env.scope)
             where = where.expr
 
         elif isinstance(where, (list, tuple)):
             for idx, w in enumerate(where):
                 if isinstance(w, Expr):
-                    lcls.update(w.env.locals)
+                    local_dict.update(w.env.scope)
                 else:
                     w = self.parse_back_compat(w)
                     where[idx] = w
             where = ' & ' .join(["(%s)" % w for w in where])
 
         self.expr = where
-        self.env = Scope(lcls=lcls)
-        self.env.update(scope_level)
+        self.env = Scope(scope_level + 1, local_dict=local_dict)
 
         if queryables is not None and isinstance(self.expr, string_types):
             self.env.queryables.update(queryables)
@@ -535,7 +533,7 @@ def parse_back_compat(self, w, op=None, value=None):
             warnings.warn("passing a tuple into Expr is deprecated, "
                           "pass the where as a single string",
                           DeprecationWarning)
-                
+
         if op is not None:
             if not isinstance(w, string_types):
                 raise TypeError(