API: disallow renamed nested-dicts

Author: jreback

pandas/core/base.py

@@ -302,6 +302,10 @@ def _selected_obj(self):
         else:
             return self.obj[self._selection]
 
+    @cache_readonly
+    def ndim(self):
+        return self._selected_obj.ndim
+
     @cache_readonly
     def _obj_with_exclusions(self):
         if self._selection is not None and isinstance(self.obj,
@@ -438,14 +442,18 @@ def _aggregate(self, arg, *args, **kwargs):
             if self._selection is not None:
                 subset = obj
 
+                ndim = 1 if len(self._selection_list) == 1 else 2
                 for fname, agg_how in compat.iteritems(arg):
-                    colg = self._gotitem(self._selection, ndim=1,
+                    colg = self._gotitem(self._selection, ndim=ndim,
                                          subset=subset)
                     result[fname] = colg.aggregate(agg_how, _level=None)
                     keys.append(fname)
             else:
                 for col, agg_how in compat.iteritems(arg):
                     colg = self._gotitem(col, ndim=1)
+                    if colg.ndim != 1:
+                        raise ValueError("nested dictionary is ambiguous"
+                                         "in aggregation")
                     result[col] = colg.aggregate(agg_how, _level=_level)
                     keys.append(col)
 

pandas/core/window.py

@@ -76,7 +76,7 @@ def _convert_freq(self, how=None):
                               "to passing to a window function", FutureWarning,
                               stacklevel=6)
 
-            obj = obj.resample(self.freq).aggregate(how or 'upsample')
+            obj = obj.resample(self.freq).aggregate(how or 'asfreq')
         return obj
 
     def _create_blocks(self, how):

pandas/tests/test_groupby.py

@@ -34,11 +34,6 @@
 from numpy.testing import assert_equal
 
 
-def compare_frame_like(result, expected):
-    # if we are using dicts, the orderings is not guaranteed
-    assert_frame_equal(result.reindex_like(expected), expected)
-
-
 class TestGroupBy(tm.TestCase):
 
     _multiprocess_can_split_ = True
@@ -1484,7 +1479,7 @@ def test_aggregate_api_consistency(self):
         expected = pd.concat([d_sum, d_mean],
                              axis=1)
         expected.columns = ['sum', 'mean']
-        compare_frame_like(result, expected)
+        assert_frame_equal(result, expected, check_like=True)
 
         result = grouped.agg([np.sum, np.mean])
         expected = pd.concat([c_sum,
@@ -1494,7 +1489,7 @@ def test_aggregate_api_consistency(self):
                              axis=1)
         expected.columns = MultiIndex.from_product([['C', 'D'],
                                                     ['sum', 'mean']])
-        compare_frame_like(result, expected)
+        assert_frame_equal(result, expected, check_like=True)
 
         result = grouped[['D', 'C']].agg([np.sum, np.mean])
         expected = pd.concat([d_sum,
@@ -1504,18 +1499,18 @@ def test_aggregate_api_consistency(self):
                              axis=1)
         expected.columns = MultiIndex.from_product([['D', 'C'],
                                                     ['sum', 'mean']])
-        compare_frame_like(result, expected)
+        assert_frame_equal(result, expected, check_like=True)
 
-        import pdb; pdb.set_trace()
-        result = grouped[['D', 'C']].agg({'r': np.sum, 'r2': np.mean})
+        result = grouped[['D', 'C']].agg(OrderedDict([('r', np.sum),
+                                                      ('r2', np.mean)]))
         expected = pd.concat([d_sum,
-                              d_mean,
                               c_sum,
+                              d_mean,
                               c_mean],
                              axis=1)
         expected.columns = MultiIndex.from_product([['r', 'r2'],
-                                                    ['sum', 'mean']])
-        compare_frame_like(result, expected)
+                                                    ['D', 'C']])
+        assert_frame_equal(result, expected, check_like=True)
 
     def test_multi_iter(self):
         s = Series(np.arange(6))
@@ -5489,7 +5484,7 @@ def test_tab_completion(self):
              'cumprod', 'tail', 'resample', 'cummin', 'fillna', 'cumsum',
              'cumcount', 'all', 'shift', 'skew', 'bfill', 'ffill', 'take',
              'tshift', 'pct_change', 'any', 'mad', 'corr', 'corrwith', 'cov',
-             'dtypes', 'diff', 'idxmax', 'idxmin'])
+             'dtypes', 'ndim', 'diff', 'idxmax', 'idxmin'])
         self.assertEqual(results, expected)
 
     def test_lexsort_indexer(self):

pandas/tests/test_window.py

@@ -121,10 +121,6 @@ def test_agg(self):
         b_std = r['B'].std()
         b_sum = r['B'].sum()
 
-        def compare(result, expected):
-            # if we are using dicts, the orderings is not guaranteed
-            assert_frame_equal(result.reindex_like(expected), expected)
-
         result = r.aggregate([np.mean, np.std])
         expected = pd.concat([a_mean, a_std, b_mean, b_std], axis=1)
         expected.columns = pd.MultiIndex.from_product([['A', 'B'], ['mean',
@@ -134,7 +130,7 @@ def compare(result, expected):
         result = r.aggregate({'A': np.mean, 'B': np.std})
 
         expected = pd.concat([a_mean, b_std], axis=1)
-        compare(result, expected)
+        assert_frame_equal(result, expected, check_like=True)
 
         result = r.aggregate({'A': ['mean', 'std']})
         expected = pd.concat([a_mean, a_std], axis=1)
@@ -151,7 +147,7 @@ def compare(result, expected):
         expected = pd.concat([a_mean, a_sum], axis=1)
         expected.columns = pd.MultiIndex.from_tuples([('A', 'mean'), ('A',
                                                                       'sum')])
-        compare(result, expected)
+        assert_frame_equal(result, expected, check_like=True)
 
         result = r.aggregate({'A': {'mean': 'mean',
                                     'sum': 'sum'},
@@ -160,19 +156,19 @@ def compare(result, expected):
         expected = pd.concat([a_mean, a_sum, b_mean, b_sum], axis=1)
         expected.columns = pd.MultiIndex.from_tuples([('A', 'mean'), (
             'A', 'sum'), ('B', 'mean2'), ('B', 'sum2')])
-        compare(result, expected)
+        assert_frame_equal(result, expected, check_like=True)
 
         result = r.aggregate({'A': ['mean', 'std'], 'B': ['mean', 'std']})
         expected = pd.concat([a_mean, a_std, b_mean, b_std], axis=1)
         expected.columns = pd.MultiIndex.from_tuples([('A', 'mean'), (
             'A', 'std'), ('B', 'mean'), ('B', 'std')])
-        compare(result, expected)
+        assert_frame_equal(result, expected, check_like=True)
 
         # passed lambda
         result = r.agg({'A': np.sum, 'B': lambda x: np.std(x, ddof=1)})
         rcustom = r['B'].apply(lambda x: np.std(x, ddof=1))
         expected = pd.concat([a_sum, rcustom], axis=1)
-        compare(result, expected)
+        assert_frame_equal(result, expected, check_like=True)
 
     def test_agg_consistency(self):
 
@@ -191,6 +187,26 @@ def test_agg_consistency(self):
         expected = pd.MultiIndex.from_tuples([('A', 'sum'), ('A', 'mean')])
         tm.assert_index_equal(result, expected)
 
+    def test_agg_nested_dicts(self):
+
+        # API change for disallowing these types of nested dicts
+        df = DataFrame({'A': range(5), 'B': range(0, 10, 2)})
+        r = df.rolling(window=3)
+
+        def f():
+            r.aggregate({'r1': {'A': ['mean', 'sum']},
+                         'r2': {'B': ['mean', 'sum']}})
+
+        self.assertRaises(ValueError, f)
+
+        result = r.agg({'A': {'ra': ['mean', 'std']},
+                        'B': {'rb': ['mean', 'std']}})
+        expected = pd.concat([r['A'].mean(), r['A'].std(), r['B'].mean(),
+                              r['B'].std()], axis=1)
+        expected.columns = pd.MultiIndex.from_tuples([('A', 'ra', 'mean'), (
+            'A', 'ra', 'std'), ('B', 'rb', 'mean'), ('B', 'rb', 'std')])
+        assert_frame_equal(result, expected, check_like=True)
+
     def test_window_with_args(self):
         tm._skip_if_no_scipy()
 

pandas/tseries/tests/test_resample.py

@@ -3,7 +3,7 @@
 from datetime import datetime, timedelta
 from functools import partial
 
-from pandas.compat import range, lrange, zip, product
+from pandas.compat import range, lrange, zip, product, OrderedDict
 import numpy as np
 
 from pandas import (Series, DataFrame, Panel, Index, isnull,
@@ -31,11 +31,6 @@
 bday = BDay()
 
 
-def compare_frame_like(result, expected):
-    # if we are using dicts, the orderings is not guaranteed
-    assert_frame_equal(result.reindex_like(expected), expected)
-
-
 class TestResampleAPI(tm.TestCase):
     _multiprocess_can_split_ = True
 
@@ -211,7 +206,7 @@ def test_downsample_but_actually_upsampling(self):
 
         # this is reindex / asfreq
         rng = pd.date_range('1/1/2012', periods=100, freq='S')
-        ts = pd.Series(np.arange(len(rng)), index=rng)
+        ts = pd.Series(np.arange(len(rng), dtype='int64'), index=rng)
         result = ts.resample('20s').asfreq()
         expected = Series([0, 20, 40, 60, 80],
                           index=pd.date_range('2012-01-01 00:00:00',
@@ -271,7 +266,7 @@ def test_agg(self):
         for t in [r, g]:
             result = t.aggregate({'A': np.mean,
                                   'B': np.std})
-            compare_frame_like(result, expected)
+            assert_frame_equal(result, expected, check_like=True)
 
         expected = pd.concat([a_mean, a_std], axis=1)
         expected.columns = pd.MultiIndex.from_tuples([('A', 'mean'),
@@ -291,7 +286,7 @@ def test_agg(self):
                                                       ('A', 'sum')])
         for t in [r, g]:
             result = t.aggregate({'A': {'mean': 'mean', 'sum': 'sum'}})
-            compare_frame_like(result, expected)
+            assert_frame_equal(result, expected, check_like=True)
 
         expected = pd.concat([a_mean, a_sum, b_mean, b_sum], axis=1)
         expected.columns = pd.MultiIndex.from_tuples([('A', 'mean'),
@@ -301,7 +296,7 @@ def test_agg(self):
         for t in [r, g]:
             result = t.aggregate({'A': {'mean': 'mean', 'sum': 'sum'},
                                   'B': {'mean2': 'mean', 'sum2': 'sum'}})
-            compare_frame_like(result, expected)
+            assert_frame_equal(result, expected, check_like=True)
 
         expected = pd.concat([a_mean, a_std, b_mean, b_std], axis=1)
         expected.columns = pd.MultiIndex.from_tuples([('A', 'mean'),
@@ -311,7 +306,7 @@ def test_agg(self):
         for t in [r, g]:
             result = t.aggregate({'A': ['mean', 'std'],
                                   'B': ['mean', 'std']})
-            compare_frame_like(result, expected)
+            assert_frame_equal(result, expected, check_like=True)
 
         expected = pd.concat([a_mean, a_sum, b_mean, b_sum], axis=1)
         expected.columns = pd.MultiIndex.from_tuples([('r1', 'A', 'mean'),
@@ -338,19 +333,39 @@ def test_agg_misc(self):
                             'B': lambda x: np.std(x, ddof=1)})
             rcustom = t['B'].apply(lambda x: np.std(x, ddof=1))
             expected = pd.concat([r['A'].sum(), rcustom], axis=1)
-            compare_frame_like(result, expected)
+            assert_frame_equal(result, expected, check_like=True)
 
         # misc
+        expected = pd.concat([t['A'].sum(),
+                              t['B'].sum(),
+                              t['A'].mean(),
+                              t['B'].mean()],
+                             axis=1)
+        expected.columns = pd.MultiIndex.from_tuples([('result1', 'A'),
+                                                      ('result1', 'B'),
+                                                      ('result2', 'A'),
+                                                      ('result2', 'B')])
         for t in [r, g]:
-            t[['A', 'B']].agg({'result1': np.sum, 'result2': np.mean})
+            result = t[['A', 'B']].agg(OrderedDict([('result1', np.sum),
+                                                    ('result2', np.mean)]))
+            assert_frame_equal(result, expected, check_like=True)
 
         for t in [r, g]:
             t.agg({'A': ['sum', 'std'], 'B': ['mean', 'std']})
 
+        # what should this produce??????
+        import pdb; pdb.set_trace()
         for t in [r, g]:
             t[['A', 'B']].agg({'A': ['sum', 'std'],
                                'B': ['mean', 'std']})
 
+        # errors
+        for t in [r, g]:
+            r[['A']].agg({'A': ['sum', 'std'], 'B': ['mean', 'std']})
+
+        for t in [r, g]:
+            r['A'].agg({'A': ['sum', 'std'], 'B': ['mean', 'std']})
+
 
 class TestResample(tm.TestCase):
     _multiprocess_can_split_ = True
@@ -515,7 +530,7 @@ def test_resample_with_timedeltas(self):
 
     def test_resample_single_period_timedelta(self):
 
-        s = Series(range(5), index=pd.timedelta_range(
+        s = Series(list(range(5)), index=pd.timedelta_range(
             '1 day', freq='s', periods=5))
         result = s.resample('2s').sum()
         expected = Series([1, 5, 4], index=pd.timedelta_range(

pandas/util/testing.py

@@ -984,6 +984,7 @@ def assert_frame_equal(left, right, check_dtype=True,
                        by_blocks=False,
                        check_exact=False,
                        check_datetimelike_compat=False,
+                       check_like=False,
                        obj='DataFrame'):
 
     """Check that left and right DataFrame are equal.
@@ -1014,6 +1015,8 @@ def assert_frame_equal(left, right, check_dtype=True,
         Whether to compare number exactly.
     check_dateteimelike_compat : bool, default False
         Compare datetime-like which is comparable ignoring dtype.
+    check_like : bool, default False
+        If true, then reindex_like operands
     obj : str, default 'DataFrame'
         Specify object name being compared, internally used to show appropriate
         assertion message
@@ -1026,16 +1029,24 @@ def assert_frame_equal(left, right, check_dtype=True,
     if check_frame_type:
         assertIsInstance(left, type(right))
 
+    if check_like:
+        left, right = left.reindex_like(right), right
+
     # shape comparison (row)
     if left.shape[0] != right.shape[0]:
-        raise_assert_detail(obj, 'DataFrame shape (number of rows) are different',
+        raise_assert_detail(obj,
+                            'DataFrame shape (number of rows) are different',
                             '{0}, {1}'.format(left.shape[0], left.index),
                             '{0}, {1}'.format(right.shape[0], right.index))
     # shape comparison (columns)
     if left.shape[1] != right.shape[1]:
-        raise_assert_detail(obj, 'DataFrame shape (number of columns) are different',
-                            '{0}, {1}'.format(left.shape[1], left.columns),
-                            '{0}, {1}'.format(right.shape[1], right.columns))
+        raise_assert_detail(obj,
+                            'DataFrame shape (number of columns) '
+                            'are different',
+                            '{0}, {1}'.format(left.shape[1],
+                                              left.columns),
+                            '{0}, {1}'.format(right.shape[1],
+                                              right.columns))
 
     # index comparison
     assert_index_equal(left.index, right.index, exact=check_index_type,