review comments

Author: sreeja97

doc/source/whatsnew/v3.0.0.rst

@@ -156,7 +156,7 @@ All warnings for upcoming changes in pandas will have the base class :class:`pan
 
 Other enhancements
 ^^^^^^^^^^^^^^^^^^
-- :class:`pandas.NamedAgg` now forwards any ``*args`` and ``**kwargs``
+- :class:`pandas.NamedAgg` now supports passing ``*args`` and ``**kwargs``
   to calls of ``aggfunc`` (:issue:`58283`)
 - :func:`pandas.merge` propagates the ``attrs`` attribute to the result if all
   inputs have identical ``attrs``, as has so far already been the case for

pandas/core/apply.py

@@ -49,6 +49,7 @@
 from pandas.core._numba.executor import generate_apply_looper
 import pandas.core.common as com
 from pandas.core.construction import ensure_wrapped_if_datetimelike
+from pandas.core.groupby.generic import NamedAgg
 from pandas.core.util.numba_ import (
     get_jit_arguments,
     prepare_function_arguments,
@@ -1714,7 +1715,12 @@ def reconstruct_func(
     or not and also normalize the keyword to get new order of columns.
 
     If named aggregation is applied, `func` will be None, and kwargs contains the
-    column and aggregation function information to be parsed;
+    column and aggregation function information to be parsed.
+    Each value in kwargs can be either:
+        - a tuple of (column, aggfunc)
+        - or a NamedAgg instance, which may also include additional *args and **kwargs
+          to be passed to the aggregation function.
+
     If named aggregation is not applied, `func` is either string (e.g. 'min') or
     Callable, or list of them (e.g. ['min', np.max]), or the dictionary of column name
     and str/Callable/list of them (e.g. {'A': 'min'}, or {'A': [np.min, lambda x: x]})
@@ -1727,8 +1733,9 @@ def reconstruct_func(
     ----------
     func: agg function (e.g. 'min' or Callable) or list of agg functions
         (e.g. ['min', np.max]) or dictionary (e.g. {'A': ['min', np.max]}).
-    **kwargs: dict, kwargs used in is_multi_agg_with_relabel and
-        normalize_keyword_aggregation function for relabelling
+    **kwargs : dict
+        Keyword arguments used in is_multi_agg_with_relabel and
+        normalize_keyword_aggregation function for relabelling.
 
     Returns
     -------
@@ -1745,7 +1752,6 @@ def reconstruct_func(
     >>> reconstruct_func("min")
     (False, 'min', None, None)
     """
-    from pandas.core.groupby.generic import NamedAgg
 
     relabeling = func is None and (
         is_multi_agg_with_relabel(**kwargs)
@@ -1776,10 +1782,10 @@ def reconstruct_func(
         for key, val in kwargs.items():
             if isinstance(val, NamedAgg):
                 aggfunc = val.aggfunc
-                if getattr(val, "args", ()) or getattr(val, "kwargs", {}):
-                    a = getattr(val, "args", ())
-                    kw = getattr(val, "kwargs", {})
-                    aggfunc = lambda x, func=aggfunc, a=a, kw=kw: func(x, *a, **kw)
+                if val.args or val.kwargs:
+                    aggfunc = lambda x, func=aggfunc, a=val.args, kw=val.kwargs: func(
+                        x, *a, **kw
+                    )
                 converted_kwargs[key] = (val.column, aggfunc)
             else:
                 converted_kwargs[key] = val

pandas/core/groupby/generic.py

@@ -125,7 +125,7 @@ class NamedAgg:
     aggfunc : function or str
         Function to apply to the provided column. If string, the name of a built-in
         pandas function.
-    *args, **kwargs :
+    *args, **kwargs : Any
         Optional positional and keyword arguments passed to ``aggfunc``.
 
     See Also
@@ -163,7 +163,7 @@ class NamedAgg:
 
     column: Hashable
     aggfunc: AggScalar
-    args: tuple[Any, ...] = dataclasses.field(default_factory=tuple)
+    args: tuple[Any, ...] = ()
     kwargs: dict[str, Any] = dataclasses.field(default_factory=dict)
 
     def __init__(

pandas/tests/groupby/aggregate/test_aggregate.py

@@ -870,6 +870,7 @@ def n_between(self, ser, low, high, **kwargs):
         return ser.between(low, high, **kwargs).sum()
 
     def test_namedagg_args(self):
+        # https://github.com/pandas-dev/pandas/issues/58283
         df = DataFrame({"A": [0, 0, 1, 1], "B": [-1, 0, 1, 2]})
 
         result = df.groupby("A").agg(
@@ -879,6 +880,7 @@ def test_namedagg_args(self):
         tm.assert_frame_equal(result, expected)
 
     def test_namedagg_kwargs(self):
+        # https://github.com/pandas-dev/pandas/issues/58283
         df = DataFrame({"A": [0, 0, 1, 1], "B": [-1, 0, 1, 2]})
 
         result = df.groupby("A").agg(
@@ -890,6 +892,7 @@ def test_namedagg_kwargs(self):
         tm.assert_frame_equal(result, expected)
 
     def test_namedagg_args_and_kwargs(self):
+        # https://github.com/pandas-dev/pandas/issues/58283
         df = DataFrame({"A": [0, 0, 1, 1], "B": [-1, 0, 1, 2]})
 
         result = df.groupby("A").agg(
@@ -903,17 +906,21 @@ def test_namedagg_args_and_kwargs(self):
         tm.assert_frame_equal(result, expected)
 
     def test_multiple_named_agg_with_args_and_kwargs(self):
+        # https://github.com/pandas-dev/pandas/issues/58283
         df = DataFrame({"A": [0, 1, 2, 3], "B": [1, 2, 3, 4]})
 
         result = df.groupby("A").agg(
             n_between01=pd.NamedAgg("B", self.n_between, 0, 1),
             n_between13=pd.NamedAgg("B", self.n_between, 1, 3),
             n_between02=pd.NamedAgg("B", self.n_between, 0, 2),
         )
-        expected = df.groupby("A").agg(
-            n_between01=("B", lambda x: x.between(0, 1).sum()),
-            n_between13=("B", lambda x: x.between(0, 3).sum()),
-            n_between02=("B", lambda x: x.between(0, 2).sum()),
+        expected = DataFrame(
+            {
+                "n_between01": [2, 0],
+                "n_between13": [2, 1],
+                "n_between02": [2, 1],
+            },
+            index=Index(["a", "b"], name="A"),
         )
         tm.assert_frame_equal(result, expected)