add tests for func input to .agg to TestDataFrameAggregate and TestSeriesAggregate

Author: tp

doc/source/whatsnew/v0.23.1.txt

@@ -94,3 +94,4 @@ Numeric
 ^^^^^^^
 
 - :meth:`~DataFrame.agg` now correctly handles numpy NaN-aware methods like :meth:`numpy.nansum` (:issue:`19629`)
+- :meth:`~DataFrame.agg` now correctly handles built-in methods like ``sum`` when axis=1 (:issue:`19629`)

pandas/conftest.py

@@ -149,3 +149,15 @@ def tz_aware_fixture(request):
     Fixture for trying explicit timezones: {0}
     """
     return request.param
+
+
+@pytest.fixture(
+    params= list(pd.core.base.SelectionMixin._cython_table.items()),
+    ids=lambda x: "({}-{!r})".format(x[0].__name__, x[1]),
+)
+def cython_table_items(request):
+    """
+    Fixture for returning the items in
+    pandas.core.base.SelectionMixin._cython_table
+    """
+    return request.param

pandas/core/base.py

@@ -331,13 +331,14 @@ def _try_aggregate_string_function(self, arg, *args, **kwargs):
 
         raise ValueError("{arg} is an unknown string function".format(arg=arg))
 
-    def _aggregate(self, arg, *args, **kwargs):
+    def _aggregate(self, arg, axis=0, *args, **kwargs):
         """
         provide an implementation for the aggregators
 
         Parameters
         ----------
         arg : string, dict, function
+        axis : int
         *args : args to pass on to the function
         **kwargs : kwargs to pass on to the function
 
@@ -350,25 +351,26 @@ def _aggregate(self, arg, *args, **kwargs):
         how can be a string describe the required post-processing, or
         None if not required
         """
+        obj = self if axis == 0 else self.T
         is_aggregator = lambda x: isinstance(x, (list, tuple, dict))
         is_nested_renamer = False
 
         _axis = kwargs.pop('_axis', None)
         if _axis is None:
-            _axis = getattr(self, 'axis', 0)
+            _axis = getattr(obj, 'axis', 0)
         _level = kwargs.pop('_level', None)
 
         if isinstance(arg, compat.string_types):
-            return self._try_aggregate_string_function(arg, *args,
-                                                       **kwargs), None
+            return obj._try_aggregate_string_function(arg, *args,
+                                                      **kwargs), None
 
         if isinstance(arg, dict):
 
             # aggregate based on the passed dict
             if _axis != 0:  # pragma: no cover
                 raise ValueError('Can only pass dict with axis=0')
 
-            obj = self._selected_obj
+            selected_obj = obj._selected_obj
 
             def nested_renaming_depr(level=4):
                 # deprecation of nested renaming
@@ -403,16 +405,16 @@ def nested_renaming_depr(level=4):
                     if isinstance(v, dict):
                         is_nested_renamer = True
 
-                        if k not in obj.columns:
+                        if k not in selected_obj.columns:
                             msg = ('cannot perform renaming for {key} with a '
                                    'nested dictionary').format(key=k)
                             raise SpecificationError(msg)
                         nested_renaming_depr(4 + (_level or 0))
 
-                    elif isinstance(obj, ABCSeries):
+                    elif isinstance(selected_obj, ABCSeries):
                         nested_renaming_depr()
-                    elif isinstance(obj, ABCDataFrame) and \
-                            k not in obj.columns:
+                    elif isinstance(selected_obj, ABCDataFrame) and \
+                            k not in selected_obj.columns:
                         raise KeyError(
                             "Column '{col}' does not exist!".format(col=k))
 
@@ -422,8 +424,9 @@ def nested_renaming_depr(level=4):
                 # deprecation of renaming keys
                 # GH 15931
                 keys = list(compat.iterkeys(arg))
-                if (isinstance(obj, ABCDataFrame) and
-                        len(obj.columns.intersection(keys)) != len(keys)):
+                intersection_keys = selected_obj.columns.intersection(keys)
+                if (isinstance(selected_obj, ABCDataFrame) and
+                        len(intersection_keys) != len(keys)):
                     nested_renaming_depr()
 
             from pandas.core.reshape.concat import concat
@@ -432,7 +435,7 @@ def _agg_1dim(name, how, subset=None):
                 """
                 aggregate a 1-dim with how
                 """
-                colg = self._gotitem(name, ndim=1, subset=subset)
+                colg = obj._gotitem(name, ndim=1, subset=subset)
                 if colg.ndim != 1:
                     raise SpecificationError("nested dictionary is ambiguous "
                                              "in aggregation")
@@ -442,8 +445,8 @@ def _agg_2dim(name, how):
                 """
                 aggregate a 2-dim with how
                 """
-                colg = self._gotitem(self._selection, ndim=2,
-                                     subset=obj)
+                colg = obj._gotitem(obj._selection, ndim=2,
+                                    subset=selected_obj)
                 return colg.aggregate(how, _level=None)
 
             def _agg(arg, func):
@@ -473,20 +476,21 @@ def _agg(arg, func):
 
                 else:
 
-                    if self._selection is not None:
+                    if obj._selection is not None:
                         keys = None
 
             # some selection on the object
-            elif self._selection is not None:
+            elif obj._selection is not None:
 
-                sl = set(self._selection_list)
+                sl = set(obj._selection_list)
 
                 # we are a Series like object,
                 # but may have multiple aggregations
                 if len(sl) == 1:
 
                     result = _agg(arg, lambda fname,
-                                  agg_how: _agg_1dim(self._selection, agg_how))
+                                              agg_how: _agg_1dim(
+                        obj._selection, agg_how))
 
                 # we are selecting the same set as we are aggregating
                 elif not len(sl - set(keys)):
@@ -531,7 +535,7 @@ def is_any_frame():
                 return concat([result[k] for k in keys],
                               keys=keys, axis=1), True
 
-            elif isinstance(self, ABCSeries) and is_any_series():
+            elif isinstance(obj, ABCSeries) and is_any_series():
 
                 # we have a dict of Series
                 # return a MI Series
@@ -556,20 +560,20 @@ def is_any_frame():
 
                 # we have a dict of scalars
                 result = Series(result,
-                                name=getattr(self, 'name', None))
+                                name=getattr(obj, 'name', None))
 
             return result, True
         elif is_list_like(arg) and arg not in compat.string_types:
             # we require a list, but not an 'str'
-            return self._aggregate_multiple_funcs(arg,
-                                                  _level=_level,
-                                                  _axis=_axis), None
+            return obj._aggregate_multiple_funcs(arg,
+                                                 _level=_level,
+                                                 _axis=_axis), None
         else:
             result = None
 
-        f = self._is_cython_func(arg)
+        f = obj._is_cython_func(arg)
         if f is not None:
-            return getattr(self, f)(*args, **kwargs), None
+            return getattr(obj, f)(*args, **kwargs), None
 
         # caller can react
         return result, True

pandas/core/frame.py

@@ -5818,13 +5818,11 @@ def _gotitem(self,
     def aggregate(self, func, axis=0, *args, **kwargs):
         axis = self._get_axis_number(axis)
 
-        # TODO: flipped axis
         result = None
-        if axis == 0:
-            try:
-                result, how = self._aggregate(func, axis=0, *args, **kwargs)
-            except TypeError:
-                pass
+        try:
+            result, how = self._aggregate(func, axis=axis, *args, **kwargs)
+        except TypeError:
+            pass
         if result is None:
             return self.apply(func, axis=axis, args=args, **kwargs)
         return result

pandas/tests/frame/test_apply.py

@@ -1056,3 +1056,26 @@ def test_non_callable_aggregates(self):
         expected = df.size
 
         assert result == expected
+
+    @pytest.mark.parametrize("df", [
+        pd.DataFrame([[1, 2], [3, 4]]),
+        pd.DataFrame([[np.nan, 2], [3, 4]]),
+        pd.DataFrame(),
+    ])
+    def test_agg_function_input(self, df, cython_table_items):
+        # test whether the functions (keys) in
+        # pd.core.base.SelectionMixin._cython_table give the same result
+        # as the related strings (values) when used in df.agg. Examples:
+        # - ``df.agg(np.nansum)`` should give the same result as
+        #   ``df.agg('sum')``
+        # - ``df.agg(sum)`` should give the same result as ``df.agg('sum')``
+        # etc.
+        # GH21123
+        np_func, str_func = cython_table_items
+
+        tm.assert_almost_equal(df.agg(np_func),
+                               df.agg(str_func),
+                               )
+        tm.assert_almost_equal(df.agg(np_func, axis=1),
+                               df.agg(str_func, axis=1),
+                               )

pandas/tests/series/test_apply.py

@@ -587,3 +587,23 @@ def test_map_missing_mixed(self, vals, mapping, exp):
         result = s.map(mapping)
 
         tm.assert_series_equal(result, pd.Series(exp))
+
+    @pytest.mark.parametrize("series", [
+        pd.Series([1, 2, 3, 4]),
+        pd.Series([np.nan, 2, 3, 4]),
+        pd.Series(),
+    ])
+    def test_agg_function_input(self, series, cython_table_items):
+        # test whether the functions (keys) in
+        # pd.core.base.SelectionMixin._cython_table give the same result
+        # as the related strings (values), when used in ser.agg. Examples:
+        # - ``ser.agg(np.nansum)`` should give the same result as
+        #   ``ser.agg('sum')``
+        # - ``ser.agg(sum)`` should give the same result as ``ser.agg('sum')``
+        # etc.
+        # GH21123
+        np_func, str_func = cython_table_items
+
+        tm.assert_almost_equal(series.agg(np_func),
+                               series.agg(str_func),
+                               )

pandas/tests/test_nanops.py

@@ -13,8 +13,7 @@
 import pandas.core.nanops as nanops
 import pandas.util.testing as tm
 import pandas.util._test_decorators as td
-from pandas.compat.numpy import (_np_version_under1p13, _np_version_under1p10,
-                                 _np_version_under1p12)
+from pandas.compat.numpy import _np_version_under1p13
 
 use_bn = nanops._USE_BOTTLENECK
 
@@ -995,52 +994,6 @@ def prng(self):
         return np.random.RandomState(1234)
 
 
-@pytest.fixture(params=[
-    pd.Series([1, 2, 3, 4]),
-    pd.DataFrame([[1, 2], [3, 4]]),
-    pd.Series([np.nan, 2, 3, 4]),
-    pd.DataFrame([[np.nan, 2], [3, 4]]),
-    pd.Series(),
-    pd.DataFrame(),
-    pd.Series([np.nan]),
-    pd.DataFrame([[np.nan]]),
-])
-def series_or_frame(request):
-    return request.param
-
-
-@pytest.mark.parametrize("standard, nan_method", [
-    (np.sum, np.nansum),
-    (np.mean, np.nanmean),
-    (np.std, np.nanstd),
-    (np.var, np.nanvar),
-    (np.median, np.nanmedian),
-    (np.max, np.nanmax),
-    (np.min, np.nanmin),
-], ids=lambda x: x.__name__)
-def test_np_nan_functions(standard, nan_method, series_or_frame):
-    tm.assert_almost_equal(series_or_frame.agg(standard),
-                           series_or_frame.agg(nan_method),
-                           check_exact=True)
-
-
-@pytest.mark.skipif(_np_version_under1p10, reason="requires numpy>=1.10")
-def test_np_nanprod(series_or_frame):
-    tm.assert_almost_equal(series_or_frame.agg(np.prod),
-                           series_or_frame.agg(np.nanprod),
-                           check_exact=True)
-
-
-@pytest.mark.skipif(_np_version_under1p12, reason="requires numpy>=1.12")
-def test_np_nancumprod(series_or_frame):
-    funcs = [(np.cumprod, np.nancumprod),
-             (np.cumsum, np.nancumsum)]
-    for standard, nan_method in funcs:
-        tm.assert_almost_equal(series_or_frame.agg(standard),
-                               series_or_frame.agg(nan_method),
-                               check_exact=True)
-
-
 def test_use_bottleneck():
 
     if nanops._BOTTLENECK_INSTALLED:

test_fast.bat

@@ -1,3 +1,3 @@
 :: test on windows
 set PYTHONHASHSEED=314159265
-pytest --skip-slow --skip-network -m "not single" -n 4 -r sXX --strict pandas
+pytest --skip-slow --skip-network -m "not single" -n 4 -r sXX --strict pandas -x