CLN: remove engine detection and manip for datetimes

pandas/computation/eval.py

@@ -2,40 +2,13 @@
 
 import sys
 import numbers
-import collections
-import itertools
 
 import numpy as np
 
-Scope = collections.namedtuple('Scope', 'globals locals')
-
-import pandas.core.common as com
-from pandas.computation.expr import Expr
+from pandas.computation.expr import Expr, Scope
 from pandas.computation.engines import _engines
 
 
-def _scope_has_series_and_frame_datetime_index(env):
-    from pandas import DatetimeIndex
-    series_index = frame_index = 0
-
-    for v in itertools.chain(env.locals.itervalues(),
-                             env.globals.itervalues()):
-        series_index += com.is_series(v) and isinstance(v.index, DatetimeIndex)
-        frame_index += com.is_frame(v) and isinstance(v.index, DatetimeIndex)
-    return series_index, frame_index
-
-
-def _maybe_convert_engine(env, engine):
-    assert isinstance(env, Scope), 'environment must be an instance of Scope'
-    assert isinstance(engine, basestring), 'engine name must be a string'
-
-    ret = engine
-
-    if all(_scope_has_series_and_frame_datetime_index(env)):
-        ret = 'python'
-    return ret
-
-
 def eval(expr, engine='numexpr', truediv=True, local_dict=None,
          global_dict=None):
     # make sure we're passed a valid engine
@@ -44,7 +17,8 @@ def eval(expr, engine='numexpr', truediv=True, local_dict=None,
                        ' {1}'.format(_engines.keys()))
 
     # 1 up in the call stack for locals/globals; see the documentation for the
-    # inspect module for why you must decrease the refcount of frame
+    # inspect module for why you must decrease the refcount of frame at all
+    # costs
     frame = sys._getframe(1)
 
     try:
@@ -54,8 +28,6 @@ def eval(expr, engine='numexpr', truediv=True, local_dict=None,
         # shallow copy the scope so we don't overwrite everything
         env = Scope(gbl.copy(), lcl.copy())
 
-        engine = _maybe_convert_engine(env, engine)
-
         # parse the expression
         parsed_expr = Expr(expr, engine, env, truediv)
 

pandas/computation/expressions.py

@@ -7,6 +7,7 @@
 """
 
 import numpy as np
+import pandas.core.common as com
 
 try:
     import numexpr as ne
@@ -46,13 +47,10 @@ def set_use_numexpr(v=True):
 def set_numexpr_threads(n=None):
     # if we are using numexpr, set the threads to n
     # otherwise reset
-    try:
-        if _NUMEXPR_INSTALLED and _USE_NUMEXPR:
-            if n is None:
-                n = ne.detect_number_of_cores()
-            ne.set_num_threads(n)
-    except:
-        pass
+    if _NUMEXPR_INSTALLED and _USE_NUMEXPR:
+        if n is None:
+            n = ne.detect_number_of_cores()
+        ne.set_num_threads(n)
 
 
 def _evaluate_standard(op, op_str, a, b, raise_on_error=True, **eval_kwargs):
@@ -84,7 +82,8 @@ def _can_use_numexpr(op, op_str, a, b, dtype_check):
 
     return False
 
-def _evaluate_numexpr(op, op_str, a, b, raise_on_error = False, **eval_kwargs):
+
+def _evaluate_numexpr(op, op_str, a, b, raise_on_error=False, **eval_kwargs):
     result = None
 
     if _can_use_numexpr(op, op_str, a, b, 'evaluate'):
@@ -94,15 +93,13 @@ def _evaluate_numexpr(op, op_str, a, b, raise_on_error = False, **eval_kwargs):
                 a_value = a_value.values
             if hasattr(b_value, 'values'):
                 b_value = b_value.values
-            result = ne.evaluate('a_value %s b_value' % op_str, 
-                                 local_dict={ 'a_value' : a_value, 
-                                              'b_value' : b_value }, 
+            result = ne.evaluate('a_value %s b_value' % op_str,
+                                 local_dict={'a_value': a_value,
+                                             'b_value': b_value},
                                  casting='safe', **eval_kwargs)
-        except (ValueError), detail:
-            if 'unknown type object' in str(detail):
-                pass
-        except (Exception), detail:
-            if raise_on_error:
+        except Exception as detail:
+            if ('unknown type object' not in com.pprint_thing(detail) and
+                raise_on_error):
                 raise
 
     if result is None:
@@ -128,17 +125,15 @@ def _where_numexpr(cond, a, b, raise_on_error=False):
                 a_value = a_value.values
             if hasattr(b_value, 'values'):
                 b_value = b_value.values
-            result = ne.evaluate('where(cond_value,a_value,b_value)',
+            result = ne.evaluate('where(cond_value, a_value, b_value)',
                                  local_dict={'cond_value': cond_value,
                                              'a_value': a_value,
                                              'b_value': b_value},
                                  casting='safe')
-        except (ValueError), detail:
-            if 'unknown type object' in str(detail):
-                pass
-        except (Exception), detail:
-            if raise_on_error:
-                raise TypeError(str(detail))
+        except Exception as detail:
+            if ('unknown type object' not in com.pprint_thing(detail) and
+                raise_on_error):
+                raise
 
     if result is None:
         result = _where_standard(cond, a, b, raise_on_error)
@@ -149,7 +144,9 @@ def _where_numexpr(cond, a, b, raise_on_error=False):
 # turn myself on
 set_use_numexpr(True)
 
-def evaluate(op, op_str, a, b, raise_on_error=False, use_numexpr=True, **eval_kwargs):
+
+def evaluate(op, op_str, a, b, raise_on_error=False, use_numexpr=True,
+             **eval_kwargs):
     """ evaluate and return the expression of the op on a and b
 
         Parameters
@@ -166,7 +163,8 @@ def evaluate(op, op_str, a, b, raise_on_error=False, use_numexpr=True, **eval_kw
         """
 
     if use_numexpr:
-        return _evaluate(op, op_str, a, b, raise_on_error=raise_on_error, **eval_kwargs)
+        return _evaluate(op, op_str, a, b, raise_on_error=raise_on_error,
+                         **eval_kwargs)
     return _evaluate_standard(op, op_str, a, b, raise_on_error=raise_on_error)
 
 

pandas/computation/ops.py

@@ -52,6 +52,32 @@ def _update_names(env, mapping):
         updater(key, value)
 
 
+class Term(object):
+    def __init__(self, value, name, env):
+        self.value = value
+        self.name = name
+        self.env = env
+        self.type = type(value)
+
+    def __iter__(self):
+        yield self.value
+        raise StopIteration
+
+    def __str__(self):
+        return '{0}({1!r})'.format(self.__class__.__name__, self.name)
+
+    __repr__ = __str__
+
+    def update(self, env, value):
+        _update_name(self.env, self.name, value)
+        self.value = value
+
+
+class Constant(Term):
+    def __init__(self, value, env):
+        super(Constant, self).__init__(value, value, env)
+
+
 class Op(object):
     """Hold an operator of unknown arity
     """
@@ -89,13 +115,14 @@ def name(self):
 def _cast(terms, env, dtype):
     resolver = partial(_resolve_name, env)
     updater = partial(_update_name, env)
+    dt = np.dtype(dtype)
     for term in terms:
         t = resolver(term)
         try:
-            new_value = t.astype(dtype)
+            new_value = t.astype(dt)
         except AttributeError:
-            new_value = dtype.type(t)
-        updater(term, t)
+            new_value = dt.type(t)
+        updater(term, new_value)
 
 class BinOp(Op):
     """Hold a binary operator and its operands
@@ -160,7 +187,7 @@ def __call__(self, env):
 class Mod(BinOp):
     def __init__(self, lhs, rhs, env=None):
         super(Mod, self).__init__('%', lhs, rhs)
-        _cast(env, (lhs, rhs), np.float_)
+        _cast((lhs, rhs), env, np.float_)
 
 
 _unary_ops_syms = '+', '-', '~'

pandas/computation/tests/test_eval.py

@@ -5,8 +5,8 @@
 from itertools import product
 
 import nose
-from nose.tools import assert_raises, assert_tuple_equal, assert_equal
-from nose.tools import assert_true
+from nose.tools import assert_raises, assert_tuple_equal
+from nose.tools import assert_true, assert_false
 
 from numpy.random import randn, rand
 import numpy as np
@@ -23,8 +23,6 @@
 import pandas.computation.expr as expr
 from pandas.computation.expressions import _USE_NUMEXPR
 from pandas.computation.eval import Scope
-from pandas.computation.eval import _scope_has_series_and_frame_datetime_index
-from pandas.computation.eval import _maybe_convert_engine
 from pandas.util.testing import assert_frame_equal, randbool
 
 
@@ -551,8 +549,6 @@ def check_datetime_index_rows_punts_to_python(engine):
     index = getattr(df, 'index')
     s = Series(np.random.randn(5), index[:5])
     env = Scope(globals(), locals())
-    assert_true(_scope_has_series_and_frame_datetime_index(env))
-    assert_equal(_maybe_convert_engine(env, engine), 'python')
 
 
 def test_datetime_index_rows_punts_to_python():
@@ -582,6 +578,21 @@ def test_global_scope():
         yield check_global_scope, engine
 
 
+def check_is_expr(engine):
+    s = 1
+    valid = 's + 1'
+    invalid = 's +'
+    assert_true(expr.isexpr(valid, check_names=True))
+    assert_false(expr.isexpr(valid, check_names=False))
+    assert_false(expr.isexpr(invalid, check_names=False))
+    assert_false(expr.isexpr(invalid, check_names=True))
+
+
+def test_is_expr():
+    for engine in _engines:
+        check_is_expr(engine)
+
+
 if __name__ == '__main__':
     nose.runmodule(argv=[__file__, '-vvs', '-x', '--pdb', '--pdb-failure'],
                    exit=False)