BUG: Support dictionaries in SeriesGroupBy.agg

doc/source/whatsnew/v2.0.0.rst

@@ -1022,6 +1022,7 @@ Groupby/resample/rolling
 - Bug in :meth:`.DataFrameGroupBy.transform` and :meth:`.SeriesGroupBy.transform` would raise incorrectly when grouper had ``axis=1`` for ``"idxmin"`` and ``"idxmax"`` arguments (:issue:`45986`)
 - Bug in :class:`.DataFrameGroupBy` would raise when used with an empty DataFrame, categorical grouper, and ``dropna=False`` (:issue:`50634`)
 - Bug in :meth:`.SeriesGroupBy.value_counts` did not respect ``sort=False`` (:issue:`50482`)
+- Bug in :meth:`.SeriesGroupBy.agg` would incorrectly raise on any dictionary; nested renamers (a dictionary containing dictionary values) is still not supported (:issue:`50684`)
 -
 
 Reshaping

pandas/core/groupby/generic.py

@@ -292,18 +292,15 @@ def aggregate(self, func=None, *args, engine=None, engine_kwargs=None, **kwargs)
     agg = aggregate
 
     def _aggregate_multiple_funcs(self, arg) -> DataFrame:
-        if isinstance(arg, dict):
-
-            # show the deprecation, but only if we
-            # have not shown a higher level one
-            # GH 15931
-            raise SpecificationError("nested renamer is not supported")
-
-        if any(isinstance(x, (tuple, list)) for x in arg):
+        if is_dict_like(arg):
+            # GH#50684
+            # Series is dict-like but doesn't have a `.values()`; use `.items()`
+            if any(is_dict_like(value) for _, value in arg.items()):
+                raise SpecificationError("nested renamer is not supported")
+            arg = list(arg.items())
+
+        elif any(isinstance(x, (tuple, list)) for x in arg):
             arg = [(x, x) if not isinstance(x, (tuple, list)) else x for x in arg]
-
-            # indicated column order
-            columns = next(zip(*arg))
         else:
             # list of functions / function names
             columns = []

pandas/tests/groupby/aggregate/test_aggregate.py

@@ -434,9 +434,12 @@ def numpystd(x):
 
     # this uses column selection & renaming
     msg = r"nested renamer is not supported"
+    d = {"C": np.mean, "D": {"foo": np.mean, "bar": np.std}}
     with pytest.raises(SpecificationError, match=msg):
-        d = {"C": np.mean, "D": {"foo": np.mean, "bar": np.std}}
         grouped.aggregate(d)
+    with pytest.raises(SpecificationError, match=msg):
+        # GH#50684
+        grouped["B"].aggregate(d)
 
     # But without renaming, these functions are OK
     d = {"C": [np.mean], "D": [numpymean, numpystd]}

pandas/tests/groupby/aggregate/test_other.py

@@ -228,9 +228,10 @@ def test_agg_dict_renaming_deprecation():
     with pytest.raises(KeyError, match=msg):
         df.groupby("A")[["B", "C"]].agg({"ma": "max"})
 
-    msg = r"nested renamer is not supported"
-    with pytest.raises(SpecificationError, match=msg):
-        df.groupby("A").B.agg({"foo": "count"})
+    # GH#50684
+    result = df.groupby("A").B.agg({"foo": "count"})
+    expected = DataFrame({"foo": df.groupby("A").B.count()})
+    tm.assert_frame_equal(result, expected)
 
 
 def test_agg_compat():
@@ -246,12 +247,17 @@ def test_agg_compat():
 
     g = df.groupby(["A", "B"])
 
-    msg = r"nested renamer is not supported"
-    with pytest.raises(SpecificationError, match=msg):
-        g["D"].agg({"C": ["sum", "std"]})
+    result = g["D"].agg({"C": ["sum", "std"]})
+    expected = g["D"].agg(["sum", "std"])
+    expected.columns = MultiIndex(
+        levels=[["C"], ["sum", "std"]],
+        codes=[[0, 0], [0, 1]],
+    )
+    tm.assert_frame_equal(result, expected)
 
-    with pytest.raises(SpecificationError, match=msg):
-        g["D"].agg({"C": "sum", "D": "std"})
+    result = g["D"].agg({"C": "sum", "D": "std"})
+    expected = g["D"].agg(["sum", "std"]).rename(columns={"sum": "C", "std": "D"})
+    tm.assert_frame_equal(result, expected)
 
 
 def test_agg_nested_dicts():
@@ -276,11 +282,15 @@ def test_agg_nested_dicts():
 
     # same name as the original column
     # GH9052
-    with pytest.raises(SpecificationError, match=msg):
-        g["D"].agg({"result1": np.sum, "result2": np.mean})
+    result = g["D"].agg({"result1": np.sum, "result2": np.mean})
+    expected = g["D"].agg(["sum", "mean"])
+    expected.columns = ["result1", "result2"]
+    tm.assert_frame_equal(result, expected)
 
-    with pytest.raises(SpecificationError, match=msg):
-        g["D"].agg({"D": np.sum, "result2": np.mean})
+    result = g["D"].agg({"D": np.sum, "result2": np.mean})
+    expected = g["D"].agg(["sum", "mean"])
+    expected.columns = ["D", "result2"]
+    tm.assert_frame_equal(result, expected)
 
 
 def test_agg_item_by_item_raise_typeerror():

pandas/tests/groupby/test_groupby.py

@@ -5,10 +5,7 @@
 import pytest
 
 from pandas.compat import IS64
-from pandas.errors import (
-    PerformanceWarning,
-    SpecificationError,
-)
+from pandas.errors import PerformanceWarning
 
 import pandas as pd
 from pandas import (
@@ -71,9 +68,10 @@ def test_basic(dtype):
     # complex agg
     agged = grouped.aggregate([np.mean, np.std])
 
-    msg = r"nested renamer is not supported"
-    with pytest.raises(SpecificationError, match=msg):
-        grouped.aggregate({"one": np.mean, "two": np.std})
+    # GH#50684
+    result = grouped.aggregate({"one": np.mean, "two": np.std})
+    expected = agged.rename(columns={"mean": "one", "std": "two"})
+    tm.assert_frame_equal(result, expected)
 
     group_constants = {0: 10, 1: 20, 2: 30}
     agged = grouped.agg(lambda x: group_constants[x.name] + x.mean())
@@ -452,9 +450,15 @@ def test_frame_set_name_single(df):
     result = grouped["C"].agg([np.mean, np.std])
     assert result.index.name == "A"
 
-    msg = r"nested renamer is not supported"
-    with pytest.raises(SpecificationError, match=msg):
-        grouped["C"].agg({"foo": np.mean, "bar": np.std})
+    # GH#50684
+    result = grouped["C"].agg({"foo": np.mean, "bar": np.std})
+    expected = DataFrame(
+        {
+            "foo": grouped["C"].mean(),
+            "bar": grouped["C"].std(),
+        }
+    )
+    tm.assert_frame_equal(result, expected)
 
 
 def test_multi_func(df):
@@ -677,9 +681,10 @@ def test_groupby_as_index_agg(df):
 
     grouped = df.groupby("A", as_index=True)
 
-    msg = r"nested renamer is not supported"
-    with pytest.raises(SpecificationError, match=msg):
-        grouped["C"].agg({"Q": np.sum})
+    # GH#50684
+    result = grouped["C"].agg({"Q": np.sum})
+    expected = DataFrame({"Q": grouped["C"].sum()})
+    tm.assert_frame_equal(result, expected)
 
     # multi-key
 

pandas/tests/resample/test_resample_api.py

@@ -550,15 +550,23 @@ def test_agg_misc():
         result = t[["A", "B"]].agg({"A": ["sum", "std"], "B": ["mean", "std"]})
         tm.assert_frame_equal(result, expected, check_like=True)
 
-    msg = "nested renamer is not supported"
-
-    # series like aggs
+    # series like aggs - GH#50684
     for t in cases:
-        with pytest.raises(pd.errors.SpecificationError, match=msg):
-            t["A"].agg({"A": ["sum", "std"]})
+        result = t["A"].agg({"A": ["sum", "std"]})
+        expected = t["A"].agg(["sum", "std"])
+        expected.columns = pd.MultiIndex(
+            levels=[["A"], ["sum", "std"]],
+            codes=[[0, 0], [0, 1]],
+        )
+        tm.assert_frame_equal(result, expected)
 
-        with pytest.raises(pd.errors.SpecificationError, match=msg):
-            t["A"].agg({"A": ["sum", "std"], "B": ["mean", "std"]})
+        result = t["A"].agg({"A": ["sum", "std"], "B": ["mean", "std"]})
+        expected = t["A"].agg(["sum", "std", "mean", "std"])
+        expected.columns = pd.MultiIndex(
+            levels=[["A", "B"], ["sum", "std", "mean"]],
+            codes=[[0, 0, 1, 1], [0, 1, 2, 1]],
+        )
+        tm.assert_frame_equal(result, expected)
 
     # errors
     # invalid names in the agg specification