Added _dict_compat to deal with datetime64-keyed dict

Author: kawochen

pandas/core/common.py

@@ -19,7 +19,7 @@
 import pandas.lib as lib
 import pandas.tslib as tslib
 from pandas import compat
-from pandas.compat import StringIO, BytesIO, range, long, u, zip, map, string_types
+from pandas.compat import StringIO, BytesIO, range, long, u, zip, map, string_types, iteritems
 
 from pandas.core.config import get_option
 
@@ -3361,3 +3361,17 @@ def _random_state(state=None):
         return np.random.RandomState()
     else:
         raise ValueError("random_state must be an integer, a numpy RandomState, or None")
+
+def _dict_compat(d):
+    """
+    Helper function to convert datetimelike-keyed dicts to Timestamp-keyed dict
+
+    Parameters
+    ----------
+    d: dict like object
+
+    Returns
+    __________
+    dict
+    """
+    return dict((_maybe_box_datetimelike(key), value) for key, value in iteritems(d))

pandas/core/frame.py

@@ -28,7 +28,7 @@
                                 _infer_dtype_from_scalar, _values_from_object,
                                 is_list_like, _maybe_box_datetimelike,
                                 is_categorical_dtype, is_object_dtype,
-                                _possibly_infer_to_datetimelike)
+                                _possibly_infer_to_datetimelike, _dict_compat)
 from pandas.core.generic import NDFrame, _shared_docs
 from pandas.core.index import Index, MultiIndex, _ensure_index
 from pandas.core.indexing import (maybe_droplevels,
@@ -5095,15 +5095,9 @@ def _homogenize(data, index, dtype=None):
                 v = v.reindex(index, copy=False)
         else:
             if isinstance(v, dict):
-                if lib.infer_dtype(v) in ['datetime64']:
-                    v = {lib.Timestamp(key): v[key] for key in v}
+                v = _dict_compat(v)
                 oindex = index.astype('O')
-                if type(v) == dict:
-                    # fast cython method
-                    v = lib.fast_multiget(v, oindex.values, default=NA)
-                else:
-                    v = lib.map_infer(oindex.values, v.get)
-
+                v = lib.fast_multiget(v, oindex.values, default=NA)
             v = _sanitize_array(v, index, dtype=dtype, copy=False,
                                 raise_cast_failure=False)
 

pandas/tests/test_common.py

@@ -5,7 +5,7 @@
 import sys
 
 import nose
-from nose.tools import assert_equal
+from nose.tools import assert_equal, assert_dict_equal
 import numpy as np
 from pandas.tslib import iNaT, NaT
 from pandas import Series, DataFrame, date_range, DatetimeIndex, Timestamp, Float64Index
@@ -1018,6 +1018,16 @@ def test_maybe_convert_string_to_array(self):
         self.assertTrue(result.dtype == object)
 
 
+def test_dict_compat():
+    data_datetime64 = {np.datetime64('1990-03-15'): 1,
+                       np.datetime64('2015-03-15'): 2}
+    data_unchanged = {1: 2, 3: 4, 5: 6}
+    expected = {Timestamp('1990-3-15'): 1, Timestamp('2015-03-15'): 2}
+    assert_dict_equal(com._dict_compat(data_datetime64), expected)
+    assert_dict_equal(com._dict_compat(expected), expected)
+    assert_dict_equal(com._dict_compat(data_unchanged), data_unchanged)
+
+
 if __name__ == '__main__':
     nose.runmodule(argv=[__file__, '-vvs', '-x', '--pdb', '--pdb-failure'],
                    exit=False)

pandas/tests/test_frame.py

@@ -2955,20 +2955,28 @@ def test_constructor_dict_multiindex(self):
         check(df, expected)
 
     def test_constructor_dict_datetime64_index(self):
-
-        data = {1: {np.datetime64('1990-03-15'): 1},
-                2: {np.datetime64('1989-12-03'): 3},
-                3: {np.datetime64('1988-11-06'): 5},
-                4: {np.datetime64('1984-02-19'): 7}}
-
-        data_expected = {1: {Timestamp('1990-03-15'): 1},
-                         2: {Timestamp('1989-12-03'): 3},
-                         3: {Timestamp('1988-11-06'): 5},
-                         4: {Timestamp('1984-02-19'): 7}}
-
-        result = DataFrame(data)
-        expected = DataFrame(data_expected)
-        assert_frame_equal(result, expected)
+        # GH 10160
+        dates_as_str = ['1984-02-19', '1988-11-06', '1989-12-03', '1990-03-15']
+
+        def create_data(constructor):
+            return dict((i, {constructor(s): 2*i}) for i, s in enumerate(dates_as_str))
+
+        data_datetime64 = create_data(np.datetime64)
+        data_datetime = create_data(lambda x: datetime.strptime(x, '%Y-%m-%d'))
+        data_Timestamp = create_data(Timestamp)
+
+        expected = DataFrame([{0: 0, 1: None, 2: None, 3: None},
+                              {0: None, 1: 2, 2: None, 3: None},
+                              {0: None, 1: None, 2: 4, 3: None},
+                              {0: None, 1: None, 2: None, 3: 6}],
+                             index=[Timestamp(dt) for dt in dates_as_str])
+
+        result_datetime64 = DataFrame(data_datetime64)
+        result_datetime = DataFrame(data_datetime)
+        result_Timestamp = DataFrame(data_Timestamp)
+        assert_frame_equal(result_datetime64, expected)
+        assert_frame_equal(result_datetime, expected)
+        assert_frame_equal(result_Timestamp, expected)
 
 
     def _check_basic_constructor(self, empty):