Move _groupby_function inside GroupBy

Add support for __qualname__

Author: jreback

pandas/core/groupby.py

@@ -12,8 +12,8 @@
 )
 
 from pandas import compat
-from pandas.compat.numpy import function as nv
-from pandas.compat.numpy import _np_version_under1p8
+from pandas.compat.numpy import function as nv, _np_version_under1p8
+from pandas.compat import set_function_name
 
 from pandas.types.common import (is_numeric_dtype,
                                  is_timedelta64_dtype, is_datetime64_dtype,
@@ -172,64 +172,6 @@
                                 'cummin', 'cummax'])
 
 
-def _groupby_function(name, alias, npfunc, numeric_only=True,
-                      _convert=False):
-
-    _local_template = "Compute %(f)s of group values"
-
-    @Substitution(name='groupby', f=name)
-    @Appender(_doc_template)
-    @Appender(_local_template)
-    def f(self, **kwargs):
-        if 'numeric_only' not in kwargs:
-            kwargs['numeric_only'] = numeric_only
-        self._set_group_selection()
-        try:
-            return self._cython_agg_general(alias, alt=npfunc, **kwargs)
-        except AssertionError as e:
-            raise SpecificationError(str(e))
-        except Exception:
-            result = self.aggregate(lambda x: npfunc(x, axis=self.axis))
-            if _convert:
-                result = result._convert(datetime=True)
-            return result
-
-    f.__name__ = name
-
-    return f
-
-
-def _first_compat(x, axis=0):
-
-    def _first(x):
-
-        x = np.asarray(x)
-        x = x[notnull(x)]
-        if len(x) == 0:
-            return np.nan
-        return x[0]
-
-    if isinstance(x, DataFrame):
-        return x.apply(_first, axis=axis)
-    else:
-        return _first(x)
-
-
-def _last_compat(x, axis=0):
-    def _last(x):
-
-        x = np.asarray(x)
-        x = x[notnull(x)]
-        if len(x) == 0:
-            return np.nan
-        return x[-1]
-
-    if isinstance(x, DataFrame):
-        return x.apply(_last, axis=axis)
-    else:
-        return _last(x)
-
-
 class Grouper(object):
     """
     A Grouper allows the user to specify a groupby instruction for a target
@@ -1184,14 +1126,74 @@ def size(self):
             result.name = getattr(self, 'name', None)
         return result
 
-    sum = _groupby_function('sum', 'add', np.sum)
-    prod = _groupby_function('prod', 'prod', np.prod)
-    min = _groupby_function('min', 'min', np.min, numeric_only=False)
-    max = _groupby_function('max', 'max', np.max, numeric_only=False)
-    first = _groupby_function('first', 'first', _first_compat,
-                              numeric_only=False, _convert=True)
-    last = _groupby_function('last', 'last', _last_compat, numeric_only=False,
-                             _convert=True)
+    @classmethod
+    def _add_numeric_operations(cls):
+        """ add numeric operations to the GroupBy generically """
+
+        def _groupby_function(name, alias, npfunc,
+                              numeric_only=True, _convert=False):
+
+            _local_template = "Compute %(f)s of group values"
+
+            @Substitution(name='groupby', f=name)
+            @Appender(_doc_template)
+            @Appender(_local_template)
+            def f(self, **kwargs):
+                if 'numeric_only' not in kwargs:
+                    kwargs['numeric_only'] = numeric_only
+                self._set_group_selection()
+                try:
+                    return self._cython_agg_general(alias, alt=npfunc, **kwargs)
+                except AssertionError as e:
+                    raise SpecificationError(str(e))
+                except Exception:
+                    result = self.aggregate(lambda x: npfunc(x, axis=self.axis))
+                    if _convert:
+                        result = result._convert(datetime=True)
+                    return result
+
+            set_function_name(f, name, cls)
+
+            return f
+
+        def _first_compat(x, axis=0):
+
+            def _first(x):
+
+                x = np.asarray(x)
+                x = x[notnull(x)]
+                if len(x) == 0:
+                    return np.nan
+                return x[0]
+
+            if isinstance(x, DataFrame):
+                return x.apply(_first, axis=axis)
+            else:
+                return _first(x)
+
+
+        def _last_compat(x, axis=0):
+            def _last(x):
+
+                x = np.asarray(x)
+                x = x[notnull(x)]
+                if len(x) == 0:
+                    return np.nan
+                return x[-1]
+
+            if isinstance(x, DataFrame):
+                return x.apply(_last, axis=axis)
+            else:
+                return _last(x)
+
+        cls.sum = _groupby_function('sum', 'add', np.sum)
+        cls.prod = _groupby_function('prod', 'prod', np.prod)
+        cls.min = _groupby_function('min', 'min', np.min, numeric_only=False)
+        cls.max = _groupby_function('max', 'max', np.max, numeric_only=False)
+        cls.first = _groupby_function('first', 'first', _first_compat,
+                                      numeric_only=False, _convert=True)
+        cls.last = _groupby_function('last', 'last', _last_compat, numeric_only=False,
+                                     _convert=True)
 
     @Substitution(name='groupby')
     @Appender(_doc_template)
@@ -1603,6 +1605,8 @@ def tail(self, n=5):
         mask = self._cumcount_array(ascending=False) < n
         return self._selected_obj[mask]
 
+GroupBy._add_numeric_operations()
+
 
 @Appender(GroupBy.__doc__)
 def groupby(obj, by, **kwds):

pandas/tests/groupby/test_groupby.py

@@ -3849,19 +3849,36 @@ def test_groupby_whitelist(self):
             'nsmallest',
         ])
 
-        names_dont_match_pair = (self.DF_METHOD_NAMES_THAT_DONT_MATCH_ATTRIBUTE,
-                                 self.S_METHOD_NAMES_THAT_DONT_MATCH_ATTRIBUTE)
-        for obj, whitelist, names_dont_match in zip((df, s), (df_whitelist, s_whitelist), names_dont_match_pair):
+        names_dont_match_pair = (
+            self.DF_METHOD_NAMES_THAT_DONT_MATCH_ATTRIBUTE,
+            self.S_METHOD_NAMES_THAT_DONT_MATCH_ATTRIBUTE)
+        for obj, whitelist, names_dont_match in (
+                zip((df, s),
+                    (df_whitelist, s_whitelist),
+                    names_dont_match_pair)):
+
             gb = obj.groupby(df.letters)
-            self.assertEqual(whitelist, gb._apply_whitelist)
+
+            assert whitelist == gb._apply_whitelist
             for m in whitelist:
                 f = getattr(type(gb), m)
+
+                # name
                 try:
                     n = f.__name__
                 except AttributeError:
                     continue
                 if m not in names_dont_match:
-                    self.assertEqual(n, m)
+                    assert n == m
+
+                # qualname
+                if compat.PY3:
+                    try:
+                        n = f.__qualname__
+                    except AttributeError:
+                        continue
+                    if m not in names_dont_match:
+                        assert n.endswith(m)
 
     def test_groupby_method_names_that_dont_match_attribute(self):
         from string import ascii_lowercase
@@ -3873,9 +3890,10 @@ def test_groupby_method_names_that_dont_match_attribute(self):
         gb = df.groupby(df.letters)
         s = df.floats
 
-        names_dont_match_pair = (self.DF_METHOD_NAMES_THAT_DONT_MATCH_ATTRIBUTE,
-                                 self.S_METHOD_NAMES_THAT_DONT_MATCH_ATTRIBUTE)
-        for obj, names_dont_match in zip((df, s),  names_dont_match_pair):
+        names_dont_match_pair = (
+            self.DF_METHOD_NAMES_THAT_DONT_MATCH_ATTRIBUTE,
+            self.S_METHOD_NAMES_THAT_DONT_MATCH_ATTRIBUTE)
+        for obj, names_dont_match in zip((df, s), names_dont_match_pair):
             gb = obj.groupby(df.letters)
             for m in names_dont_match:
                 f = getattr(gb, m)