ENH: convert all datetime-like objects to Timestamp

Author: cpcloud

pandas/computation/expr.py

@@ -379,8 +379,6 @@ def f(cls):
     return f
 
 
-_date_kinds = frozenset(['datetime64', 'timestamp', 'datetime'])
-
 @disallow(_unsupported_nodes)
 @add_ops(_op_classes)
 class BaseExprVisitor(ast.NodeVisitor):
@@ -496,7 +494,7 @@ def _possibly_evaluate_binop(self, op, op_class, lhs, rhs,
         res = op(lhs, rhs)
 
         if (res.op in _cmp_ops_syms and
-            lhs.kind in _date_kinds or rhs.kind in _date_kinds and
+            lhs.is_datetime or rhs.is_datetime and
             self.engine != 'pytables'):
             # all date ops must be done in python bc numexpr doesn't work well
             # with NaT

pandas/computation/ops.py

@@ -5,6 +5,7 @@
 import operator as op
 from functools import partial
 from itertools import product, islice, chain
+from datetime import datetime
 
 import numpy as np
 
@@ -161,21 +162,16 @@ def raw(self):
                                           self.type))
 
     @property
-    def kind(self):
-        t = self.type
+    def is_datetime(self):
         try:
-            res = t.__name__
+            t = self.type.type
         except AttributeError:
-            res = t.type.__name__
-        return res.lower()
+            t = self.type
+
+        return issubclass(t, (datetime, np.datetime64))
 
     @property
     def value(self):
-        kind = self.kind
-        if kind == 'timestamp':
-            return self._value.asm8
-        elif kind == 'datetime':
-            return np.datetime64(self._value)
         return self._value
 
     @value.setter
@@ -246,14 +242,13 @@ def isscalar(self):
         return all(operand.isscalar for operand in self.operands)
 
     @property
-    def kind(self):
-        t = self.return_type
-
+    def is_datetime(self):
         try:
-            res = t.__name__
+            t = self.return_type.type
         except AttributeError:
-            res = t.type.__name__
-        return res.lower()
+            t = self.return_type
+
+        return issubclass(t, (datetime, np.datetime64))
 
 
 def _in(x, y):
@@ -431,24 +426,20 @@ def stringify(value):
 
         lhs, rhs = self.lhs, self.rhs
 
-        if (is_term(lhs) and lhs.kind.startswith('datetime') and is_term(rhs)
-                and rhs.isscalar):
+        if is_term(lhs) and lhs.is_datetime and is_term(rhs) and rhs.isscalar:
             v = rhs.value
             if isinstance(v, (int, float)):
                 v = stringify(v)
-            v = _ensure_decoded(v)
-            v = pd.Timestamp(v)
+            v = pd.Timestamp(_ensure_decoded(v))
             if v.tz is not None:
                 v = v.tz_convert('UTC')
             self.rhs.update(v)
 
-        if (is_term(rhs) and rhs.kind.startswith('datetime') and
-                is_term(lhs) and lhs.isscalar):
+        if is_term(rhs) and rhs.is_datetime and is_term(lhs) and lhs.isscalar:
             v = lhs.value
             if isinstance(v, (int, float)):
                 v = stringify(v)
-            v = _ensure_decoded(v)
-            v = pd.Timestamp(v)
+            v = pd.Timestamp(_ensure_decoded(v))
             if v.tz is not None:
                 v = v.tz_convert('UTC')
             self.lhs.update(v)

pandas/core/frame.py

@@ -1910,8 +1910,10 @@ def _get_index_resolvers(self, axis):
                 key = '{prefix}level_{i}'.format(prefix=prefix, i=i)
                 level = i
 
-            d[key] = Series(axis_index.get_level_values(level).values,
-                            index=axis_index, name=level)
+            level_values = axis_index.get_level_values(level)
+            s = level_values.to_series()
+            s.index = axis_index
+            d[key] = s
 
         # put the index/columns itself in the dict
         if isinstance(axis_index, MultiIndex):

pandas/tests/test_frame.py

@@ -11432,23 +11432,28 @@ def check_query_multiindex_get_index_resolvers(self, parser, engine):
         resolvers = df._get_index_resolvers('index')
         resolvers.update(df._get_index_resolvers('columns'))
 
+        def to_series(mi, level):
+            level_values = mi.get_level_values(level)
+            s = level_values.to_series()
+            s.index = mi
+            return s
+
+        col_series = df.columns.to_series()
         expected = {'index': df.index,
-                    'columns': Series(df.columns, index=df.columns,
-                                      name=df.columns.name),
-                    'spam': Series(df.index.get_level_values('spam'),
-                                   name='spam', index=df.index),
-                    'eggs': Series(df.index.get_level_values('eggs'),
-                                   name='eggs', index=df.index),
-                    'C0': Series(df.columns, index=df.columns,
-                                 name=df.columns.name)}
+                    'columns': col_series,
+                    'spam': to_series(df.index, 'spam'),
+                    'eggs': to_series(df.index, 'eggs'),
+                    'C0': col_series}
         for k, v in resolvers.items():
             if isinstance(v, Index):
                 assert v.is_(expected[k])
             elif isinstance(v, Series):
+                print(k)
                 tm.assert_series_equal(v, expected[k])
             else:
                 raise AssertionError("object must be a Series or Index")
 
+
 class TestDataFrameQueryNumExprPandas(unittest.TestCase):
     @classmethod
     def setUpClass(cls):