fix according to comments

Author: jreback

doc/source/api.rst

@@ -1773,6 +1773,7 @@ Computations / Descriptive Stats
    :toctree: generated/
 
    Resampler.count
+   Resampler.nunique
    Resampler.first
    Resampler.last
    Resampler.max

doc/source/timeseries.rst

@@ -1295,7 +1295,7 @@ For upsampling, you can specify a way to upsample and the ``limit`` parameter to
 
    # from secondly to every 250 milliseconds
 
-   ts[:2].resample('250L').reindex()
+   ts[:2].resample('250L').asfreq()
 
    ts[:2].resample('250L').ffill()
 
@@ -1398,7 +1398,7 @@ must be implemented on the Resampled object
 
    r.agg({'A' : 'sum', 'B' : 'std'})
 
-Furthermore you can pass a nested dict to indicate different aggregations on different columns.
+Furthermore, you can also specify multiple aggregation functions for each column separately.
 
 .. ipython:: python
 

pandas/core/base.py

@@ -423,7 +423,6 @@ def _aggregate(self, arg, *args, **kwargs):
         if isinstance(arg, compat.string_types):
             return getattr(self, arg)(*args, **kwargs), None
 
-        result = compat.OrderedDict()
         if isinstance(arg, dict):
 
             # aggregate based on the passed dict
@@ -483,22 +482,33 @@ def _agg_2dim(name, how):
                                      subset=obj)
                 return colg.aggregate(how, _level=None)
 
+            def _agg(arg, func):
+                """
+                run the aggregations over the arg with func
+                return an OrderedDict
+                """
+                result = compat.OrderedDict()
+                for fname, agg_how in compat.iteritems(arg):
+                    result[fname] = func(fname, agg_how)
+                return result
+
             # set the final keys
             keys = list(compat.iterkeys(arg))
+            result = compat.OrderedDict()
 
             # nested renamer
             if is_nested_renamer:
-                results = [_agg_1dim(k, v) for k, v in compat.iteritems(arg)]
+                result = list(_agg(arg, _agg_1dim).values())
 
-                if all(isinstance(r, dict) for r in results):
+                if all(isinstance(r, dict) for r in result):
 
+                    result, results = compat.OrderedDict(), result
                     for r in results:
                         result.update(r)
                     keys = list(compat.iterkeys(result))
 
                 else:
 
-                    result = results
                     if self._selection is not None:
                         keys = None
 
@@ -511,27 +521,29 @@ def _agg_2dim(name, how):
                 # but may have multiple aggregations
                 if len(sl) == 1:
 
-                    for fname, agg_how in compat.iteritems(arg):
-                        result[fname] = _agg_1dim(self._selection,
-                                                  agg_how)
+                    result = _agg(arg, lambda fname,
+                                  agg_how: _agg_1dim(self._selection, agg_how))
 
                 # we are selecting the same set as we are aggregating
                 elif not len(sl - set(compat.iterkeys(arg))):
 
-                    for fname, agg_how in compat.iteritems(arg):
-                        result[fname] = _agg_1dim(fname, agg_how)
+                    result = _agg(arg, _agg_1dim)
 
                 # we are a DataFrame, with possibly multiple aggregations
                 else:
 
-                    for fname, agg_how in compat.iteritems(arg):
-                        result[fname] = _agg_2dim(fname, agg_how)
+                    result = _agg(arg, _agg_2dim)
 
             # no selection
             else:
 
-                for col, agg_how in compat.iteritems(arg):
-                    result[col] = _agg_1dim(col, agg_how)
+                try:
+                    result = _agg(arg, _agg_1dim)
+                except SpecificationError:
+
+                    # we are aggregating expecting all 1d-returns
+                    # but we have 2d
+                    result = _agg(arg, _agg_2dim)
 
             # combine results
             if isinstance(result, list):

pandas/core/generic.py

@@ -3627,7 +3627,7 @@ def resample(self, rule, how=None, axis=0, fill_method=None, closed=None,
 
         Upsample the series into 30 second bins.
 
-        >>> series.resample('30S').upsample()[0:5] #select first 5 rows
+        >>> series.resample('30S').asfreq()[0:5] #select first 5 rows
         2000-01-01 00:00:00     0
         2000-01-01 00:00:30   NaN
         2000-01-01 00:01:00     1
@@ -3677,20 +3677,9 @@ def resample(self, rule, how=None, axis=0, fill_method=None, closed=None,
                      fill_method=fill_method, convention=convention,
                      limit=limit, base=base)
 
-        # deprecation warning
-        # but call the method anyhow
-        if fill_method is not None:
-            args = "limit={0}".format(limit) if limit is not None else ""
-            warnings.warn("fill_method is deprecated to .resample()\n"
-                          "the new syntax is .resample(...)."
-                          "{fill_method}({args})".format(
-                              fill_method=fill_method,
-                              args=args),
-                          FutureWarning, stacklevel=2)
-            return r.aggregate(fill_method, limit=limit)
+        # deprecation warnings
+        # but call methods anyhow
 
-        # deprecation warning
-        # but call the method anyhow
         if how is not None:
 
             # .resample(..., how='sum')
@@ -3701,11 +3690,34 @@ def resample(self, rule, how=None, axis=0, fill_method=None, closed=None,
             else:
                 method = ".apply(<func>)"
 
-            warnings.warn("how in .resample() is deprecated\n"
-                          "the new syntax is .resample(...).{method}".format(
-                              method=method),
+            # if we have both a how and fill_method, then show
+            # the following warning
+            if fill_method is None:
+                warnings.warn("how in .resample() is deprecated\n"
+                              "the new syntax is "
+                              ".resample(...).{method}".format(
+                                  method=method),
+                              FutureWarning, stacklevel=2)
+            r = r.aggregate(how)
+
+        if fill_method is not None:
+
+            # show the prior function call
+            method = '.' + method if how is not None else ''
+
+            args = "limit={0}".format(limit) if limit is not None else ""
+            warnings.warn("fill_method is deprecated to .resample()\n"
+                          "the new syntax is .resample(...){method}"
+                          ".{fill_method}({args})".format(
+                              method=method,
+                              fill_method=fill_method,
+                              args=args),
                           FutureWarning, stacklevel=2)
-            return r.aggregate(how)
+
+            if how is not None:
+                r = getattr(r, fill_method)(limit=limit)
+            else:
+                r = r.aggregate(fill_method, limit=limit)
 
         return r
 

pandas/core/groupby.py

@@ -355,18 +355,28 @@ def __unicode__(self):
         # TODO: Better unicode/repr for GroupBy object
         return object.__repr__(self)
 
+    def _assure_grouper(self):
+        """
+        we create the grouper on instantiation
+        sub-classes may have a different policy
+        """
+        pass
+
     @property
     def groups(self):
         """ dict {group name -> group labels} """
+        self._assure_grouper()
         return self.grouper.groups
 
     @property
     def ngroups(self):
+        self._assure_grouper()
         return self.grouper.ngroups
 
     @property
     def indices(self):
         """ dict {group name -> group indices} """
+        self._assure_grouper()
         return self.grouper.indices
 
     def _get_indices(self, names):

pandas/tests/test_groupby.py

@@ -1501,8 +1501,24 @@ def test_aggregate_api_consistency(self):
                                                     ['sum', 'mean']])
         assert_frame_equal(result, expected, check_like=True)
 
-        result = grouped[['D', 'C']].agg(OrderedDict([('r', np.sum),
-                                                      ('r2', np.mean)]))
+        result = grouped.agg({'C': 'mean', 'D': 'sum'})
+        expected = pd.concat([d_sum,
+                              c_mean],
+                             axis=1)
+        assert_frame_equal(result, expected, check_like=True)
+
+        result = grouped.agg({'C': ['mean', 'sum'],
+                              'D': ['mean', 'sum']})
+        expected = pd.concat([c_mean,
+                              c_sum,
+                              d_mean,
+                              d_sum],
+                             axis=1)
+        expected.columns = MultiIndex.from_product([['C', 'D'],
+                                                    ['mean', 'sum']])
+
+        result = grouped[['D', 'C']].agg({'r': np.sum,
+                                          'r2': np.mean})
         expected = pd.concat([d_sum,
                               c_sum,
                               d_mean,