Revert & more tests

Author: rhshadrach

pandas/core/groupby/generic.py

@@ -21,7 +21,6 @@
     Union,
     cast,
 )
-import warnings
 
 import numpy as np
 
@@ -33,7 +32,6 @@
     Substitution,
     doc,
 )
-from pandas.util._exceptions import find_stack_level
 
 from pandas.core.dtypes.common import (
     ensure_int64,
@@ -64,10 +62,6 @@
 import pandas.core.common as com
 from pandas.core.frame import DataFrame
 from pandas.core.groupby import base
-from pandas.core.groupby.base import (
-    reduction_kernels,
-    transformation_kernels,
-)
 from pandas.core.groupby.groupby import (
     GroupBy,
     GroupByPlot,
@@ -332,14 +326,6 @@ def aggregate(self, func=None, *args, engine=None, engine_kwargs=None, **kwargs)
             kwargs = {}
 
         if isinstance(func, str):
-            if func not in reduction_kernels and not self._grouper._is_resample:
-                meth = "transform" if func in transformation_kernels else "apply"
-                warnings.warn(
-                    f"In the future, using the non-aggregation {func=} will raise a "
-                    f"ValueError, use this function with {type(self).__name__}.{meth}",
-                    category=DeprecationWarning,
-                    stacklevel=find_stack_level(),
-                )
             if maybe_use_numba(engine) and engine is not None:
                 # Not all agg functions support numba, only propagate numba kwargs
                 # if user asks for numba, and engine is not None
@@ -1576,19 +1562,6 @@ def aggregate(self, func=None, *args, engine=None, engine_kwargs=None, **kwargs)
             kwargs["engine"] = engine
             kwargs["engine_kwargs"] = engine_kwargs
 
-        if (
-            isinstance(func, str)
-            and func not in reduction_kernels
-            and not self._grouper._is_resample
-        ):
-            meth = "transform" if func in transformation_kernels else "apply"
-            warnings.warn(
-                f"In the future, using the non-aggregation {func=} will raise a "
-                f"ValueError, use this function with {type(self).__name__}.{meth}",
-                category=DeprecationWarning,
-                stacklevel=find_stack_level(),
-            )
-
         op = GroupByApply(self, func, args=args, kwargs=kwargs)
         result = op.agg()
         if not is_dict_like(func) and result is not None:

pandas/tests/groupby/aggregate/test_aggregate.py

@@ -486,9 +486,6 @@ def test_groupby_agg_dict_dup_columns():
     tm.assert_frame_equal(result, expected)
 
 
-@pytest.mark.filterwarnings(
-    "ignore:In the future, using the non-aggregation func:DeprecationWarning"
-)
 @pytest.mark.parametrize(
     "op",
     [
@@ -568,9 +565,7 @@ def test_order_aggregate_multiple_funcs():
     # GH 25692
     df = DataFrame({"A": [1, 1, 2, 2], "B": [1, 2, 3, 4]})
 
-    msg = "using the non-aggregation func='ohlc' will raise"
-    with tm.assert_produces_warning(DeprecationWarning, match=msg):
-        res = df.groupby("A").agg(["sum", "max", "mean", "ohlc", "min"])
+    res = df.groupby("A").agg(["sum", "max", "mean", "ohlc", "min"])
     result = res.columns.levels[1]
 
     expected = Index(["sum", "max", "mean", "ohlc", "min"])
@@ -1176,6 +1171,22 @@ def test_with_kwargs(self):
         expected = DataFrame({"<lambda_0>": [13], "<lambda_1>": [30]})
         tm.assert_frame_equal(result, expected)
 
+    def test_unused_kwargs(self):
+        # GH#39169 - Passing kwargs used to have agg pass the entire frame rather
+        # than column-by-column
+
+        # UDF that works on both the entire frame and column-by-column
+        func = lambda data, **kwargs: np.sum(np.sum(data))
+
+        df = DataFrame([[1, 2], [3, 4]])
+        expected = DataFrame({0: [1, 3], 1: [2, 4]})
+
+        result = df.groupby(level=0).agg(func)
+        tm.assert_frame_equal(result, expected)
+
+        result = df.groupby(level=0).agg(func, foo=42)
+        tm.assert_frame_equal(result, expected)
+
     def test_agg_with_one_lambda(self):
         # GH 25719, write tests for DataFrameGroupby.agg with only one lambda
         df = DataFrame(
@@ -1262,6 +1273,40 @@ def test_agg_multiple_lambda(self):
         )
         tm.assert_frame_equal(result2, expected)
 
+    def test_multiple_udf_same_name(self):
+        # GH#28570
+        quant50 = partial(np.percentile, q=50)
+        quant70 = partial(np.percentile, q=70)
+
+        df = DataFrame({"col1": ["a", "a", "b", "b", "b"], "col2": [1, 2, 3, 4, 5]})
+        expected = DataFrame(
+            [[1.5, 1.7], [4.0, 4.4]],
+            index=Index(["a", "b"], name="col1"),
+            columns=MultiIndex(
+                levels=[["col2"], ["percentile"]],
+                codes=[[0, 0], [0, 0]],
+            ),
+        )
+        gb = df.groupby("col1")
+        result = gb.agg({"col2": [quant50, quant70]})
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("use_kwargs", [True, False])
+    def test_multiple_udf_with_args(self, use_kwargs):
+        # GH#26611
+        def func(x, y):
+            return x.sum() + y
+
+        df = DataFrame({"A": [1, 2]})
+        expected = DataFrame({"A": [13]})
+        gb = df.groupby([0, 0])
+        if use_kwargs:
+            args, kwargs = (), {"y": 10}
+        else:
+            args, kwargs = (10,), {}
+        result = gb.agg(func, *args, **kwargs)
+        tm.assert_frame_equal(result, expected)
+
 
 def test_pass_args_kwargs_duplicate_columns(tsframe, as_index):
     # go through _aggregate_frame with self.axis == 0 and duplicate columns
@@ -1383,14 +1428,9 @@ def test_nonagg_agg():
     df = DataFrame({"a": [1, 1, 2, 2], "b": [1, 2, 2, 1]})
     g = df.groupby("a")
 
-    msg = "using the non-aggregation func='cumsum' will raise"
-    with tm.assert_produces_warning(DeprecationWarning, match=msg):
-        result = g.agg(["cumsum"])
+    result = g.agg(["cumsum"])
     result.columns = result.columns.droplevel(-1)
-
-    msg = "using the non-aggregation func='cumsum' will raise"
-    with tm.assert_produces_warning(DeprecationWarning, match=msg):
-        expected = g.agg("cumsum")
+    expected = g.agg("cumsum")
 
     tm.assert_frame_equal(result, expected)
 
@@ -1467,7 +1507,6 @@ def test_groupby_agg_precision(any_real_numeric_dtype):
             levels=[["a"], ["b"]], codes=[[0], [0]], names=["key1", "key2"]
         ),
     )
-
     result = df.groupby(["key1", "key2"]).agg(lambda x: x)
     tm.assert_frame_equal(result, expected)
 
@@ -1672,9 +1711,7 @@ def test_groupby_agg_extension_timedelta_cumsum_with_named_aggregation():
         }
     )
     gb = df.groupby("grps")
-    msg = "using the non-aggregation func='cumsum' will raise"
-    with tm.assert_produces_warning(DeprecationWarning, match=msg):
-        result = gb.agg(td=("td", "cumsum"))
+    result = gb.agg(td=("td", "cumsum"))
     tm.assert_frame_equal(result, expected)
 
 

pandas/tests/groupby/aggregate/test_cython.py

@@ -21,7 +21,6 @@
     bdate_range,
 )
 import pandas._testing as tm
-from pandas.core.groupby.base import reduction_kernels
 
 
 @pytest.mark.parametrize(
@@ -288,16 +287,8 @@ def test_read_only_buffer_source_agg(agg):
     )
     df._mgr.arrays[0].flags.writeable = False
 
-    if agg in reduction_kernels:
-        warn = None
-        msg = ""
-    else:
-        warn = DeprecationWarning
-        msg = f"using the non-aggregation func='{agg}' will raise"
-    with tm.assert_produces_warning(warn, match=msg):
-        result = df.groupby(["species"]).agg({"sepal_length": agg})
-    with tm.assert_produces_warning(warn, match=msg):
-        expected = df.copy().groupby(["species"]).agg({"sepal_length": agg})
+    result = df.groupby(["species"]).agg({"sepal_length": agg})
+    expected = df.copy().groupby(["species"]).agg({"sepal_length": agg})
 
     tm.assert_equal(result, expected)
 

pandas/tests/groupby/test_groupby.py

@@ -2936,11 +2936,9 @@ def test_groupby_dropna_with_nunique_unique():
     df = [[1, 1, 1, "A"], [1, None, 1, "A"], [1, None, 2, "A"], [1, None, 3, "A"]]
     df_dropna = DataFrame(df, columns=["a", "b", "c", "partner"])
 
-    msg = "using the non-aggregation func='unique' will raise"
-    with tm.assert_produces_warning(DeprecationWarning, match=msg):
-        result = df_dropna.groupby(["a", "b", "c"], dropna=False).agg(
-            {"partner": ["nunique", "unique"]}
-        )
+    result = df_dropna.groupby(["a", "b", "c"], dropna=False).agg(
+        {"partner": ["nunique", "unique"]}
+    )
 
     index = MultiIndex.from_tuples(
         [(1, 1.0, 1), (1, np.nan, 1), (1, np.nan, 2), (1, np.nan, 3)],

pandas/tests/groupby/test_raises.py

@@ -15,7 +15,6 @@
     Series,
 )
 import pandas._testing as tm
-from pandas.core.groupby.base import reduction_kernels
 from pandas.tests.groupby import get_groupby_method_args
 
 
@@ -85,10 +84,8 @@ def df_with_cat_col():
     return df
 
 
-def _call_and_check(
-    klass, msg, how, gb, groupby_func, args, warn_msg="", warn_category=FutureWarning
-):
-    warn_klass = None if warn_msg == "" else warn_category
+def _call_and_check(klass, msg, how, gb, groupby_func, args, warn_msg=""):
+    warn_klass = None if warn_msg == "" else FutureWarning
     with tm.assert_produces_warning(warn_klass, match=warn_msg, check_stacklevel=False):
         if klass is None:
             if how == "method":
@@ -186,23 +183,9 @@ def test_groupby_raises_string(
     if groupby_func == "fillna":
         kind = "Series" if groupby_series else "DataFrame"
         warn_msg = f"{kind}GroupBy.fillna is deprecated"
-    elif groupby_func not in reduction_kernels and how == "agg":
-        warn_msg = (
-            f"In the future, using the non-aggregation func='{groupby_func}' will "
-            "raise a ValueError"
-        )
     else:
         warn_msg = ""
-    _call_and_check(
-        klass,
-        msg,
-        how,
-        gb,
-        groupby_func,
-        args,
-        warn_msg,
-        warn_category=DeprecationWarning,
-    )
+    _call_and_check(klass, msg, how, gb, groupby_func, args, warn_msg)
 
 
 @pytest.mark.parametrize("how", ["agg", "transform"])
@@ -304,30 +287,12 @@ def test_groupby_raises_datetime(
 
     if groupby_func in ["any", "all"]:
         warn_msg = f"'{groupby_func}' with datetime64 dtypes is deprecated"
-        warn_category = FutureWarning
     elif groupby_func == "fillna":
         kind = "Series" if groupby_series else "DataFrame"
         warn_msg = f"{kind}GroupBy.fillna is deprecated"
-        warn_category = FutureWarning
-    elif groupby_func not in reduction_kernels and how == "agg":
-        warn_msg = (
-            f"In the future, using the non-aggregation func='{groupby_func}' will "
-            "raise a ValueError"
-        )
-        warn_category = DeprecationWarning
     else:
         warn_msg = ""
-        warn_category = FutureWarning
-    _call_and_check(
-        klass,
-        msg,
-        how,
-        gb,
-        groupby_func,
-        args,
-        warn_msg=warn_msg,
-        warn_category=warn_category,
-    )
+    _call_and_check(klass, msg, how, gb, groupby_func, args, warn_msg=warn_msg)
 
 
 @pytest.mark.parametrize("how", ["agg", "transform"])
@@ -522,19 +487,9 @@ def test_groupby_raises_category(
     if groupby_func == "fillna":
         kind = "Series" if groupby_series else "DataFrame"
         warn_msg = f"{kind}GroupBy.fillna is deprecated"
-        warn_category = FutureWarning
-    elif groupby_func not in reduction_kernels and how == "agg":
-        warn_msg = (
-            f"In the future, using the non-aggregation func='{groupby_func}' "
-            "will raise a ValueError"
-        )
-        warn_category = DeprecationWarning
     else:
         warn_msg = ""
-        warn_category = FutureWarning
-    _call_and_check(
-        klass, msg, how, gb, groupby_func, args, warn_msg, warn_category=warn_category
-    )
+    _call_and_check(klass, msg, how, gb, groupby_func, args, warn_msg)
 
 
 @pytest.mark.parametrize("how", ["agg", "transform"])
@@ -705,13 +660,6 @@ def test_groupby_raises_category_on_category(
     if groupby_func == "fillna":
         kind = "Series" if groupby_series else "DataFrame"
         warn_msg = f"{kind}GroupBy.fillna is deprecated"
-        warn_category = FutureWarning
-    elif groupby_func not in reduction_kernels and how == "agg":
-        warn_msg = f"using the non-aggregation func='{groupby_func}' will raise"
-        warn_category = DeprecationWarning
     else:
         warn_msg = ""
-        warn_category = FutureWarning
-    _call_and_check(
-        klass, msg, how, gb, groupby_func, args, warn_msg, warn_category=warn_category
-    )
+    _call_and_check(klass, msg, how, gb, groupby_func, args, warn_msg)