BUG: numeric_only with axis=1 in DataFrame.corrwith and DataFrameGroupBy.cummin/max (#47724)

* BUG: DataFrame.corrwith and DataFrameGroupBy.cummin/cummax with numeric_only=True

* test improvements

Author: rhshadrach

pandas/core/frame.py

@@ -10560,7 +10560,8 @@ def corrwith(
             else:
                 return this.apply(lambda x: other.corr(x, method=method), axis=axis)
 
-        other = other._get_numeric_data()
+        if numeric_only_bool:
+            other = other._get_numeric_data()
         left, right = this.align(other, join="inner", copy=False)
 
         if axis == 1:
@@ -10573,11 +10574,15 @@ def corrwith(
             right = right + left * 0
 
             # demeaned data
-            ldem = left - left.mean()
-            rdem = right - right.mean()
+            ldem = left - left.mean(numeric_only=numeric_only_bool)
+            rdem = right - right.mean(numeric_only=numeric_only_bool)
 
             num = (ldem * rdem).sum()
-            dom = (left.count() - 1) * left.std() * right.std()
+            dom = (
+                (left.count() - 1)
+                * left.std(numeric_only=numeric_only_bool)
+                * right.std(numeric_only=numeric_only_bool)
+            )
 
             correl = num / dom
 

pandas/core/groupby/groupby.py

@@ -3630,7 +3630,11 @@ def cummin(self, axis=0, numeric_only=False, **kwargs) -> NDFrameT:
         skipna = kwargs.get("skipna", True)
         if axis != 0:
             f = lambda x: np.minimum.accumulate(x, axis)
-            return self._python_apply_general(f, self._selected_obj, is_transform=True)
+            numeric_only_bool = self._resolve_numeric_only("cummax", numeric_only, axis)
+            obj = self._selected_obj
+            if numeric_only_bool:
+                obj = obj._get_numeric_data()
+            return self._python_apply_general(f, obj, is_transform=True)
 
         return self._cython_transform(
             "cummin", numeric_only=numeric_only, skipna=skipna
@@ -3650,7 +3654,11 @@ def cummax(self, axis=0, numeric_only=False, **kwargs) -> NDFrameT:
         skipna = kwargs.get("skipna", True)
         if axis != 0:
             f = lambda x: np.maximum.accumulate(x, axis)
-            return self._python_apply_general(f, self._selected_obj, is_transform=True)
+            numeric_only_bool = self._resolve_numeric_only("cummax", numeric_only, axis)
+            obj = self._selected_obj
+            if numeric_only_bool:
+                obj = obj._get_numeric_data()
+            return self._python_apply_general(f, obj, is_transform=True)
 
         return self._cython_transform(
             "cummax", numeric_only=numeric_only, skipna=skipna

pandas/tests/groupby/test_function.py

@@ -555,6 +555,81 @@ def test_idxmin_idxmax_axis1():
         gb2.idxmax(axis=1)
 
 
+@pytest.mark.parametrize("numeric_only", [True, False, None])
+def test_axis1_numeric_only(request, groupby_func, numeric_only):
+    if groupby_func in ("idxmax", "idxmin"):
+        pytest.skip("idxmax and idx_min tested in test_idxmin_idxmax_axis1")
+    if groupby_func in ("mad", "tshift"):
+        pytest.skip("mad and tshift are deprecated")
+    if groupby_func in ("corrwith", "skew"):
+        msg = "GH#47723 groupby.corrwith and skew do not correctly implement axis=1"
+        request.node.add_marker(pytest.mark.xfail(reason=msg))
+
+    df = DataFrame(np.random.randn(10, 4), columns=["A", "B", "C", "D"])
+    df["E"] = "x"
+    groups = [1, 2, 3, 1, 2, 3, 1, 2, 3, 4]
+    gb = df.groupby(groups)
+    method = getattr(gb, groupby_func)
+    args = (0,) if groupby_func == "fillna" else ()
+    kwargs = {"axis": 1}
+    if numeric_only is not None:
+        # when numeric_only is None we don't pass any argument
+        kwargs["numeric_only"] = numeric_only
+
+    # Functions without numeric_only and axis args
+    no_args = ("cumprod", "cumsum", "diff", "fillna", "pct_change", "rank", "shift")
+    # Functions with axis args
+    has_axis = (
+        "cumprod",
+        "cumsum",
+        "diff",
+        "pct_change",
+        "rank",
+        "shift",
+        "cummax",
+        "cummin",
+        "idxmin",
+        "idxmax",
+        "fillna",
+    )
+    if numeric_only is not None and groupby_func in no_args:
+        msg = "got an unexpected keyword argument 'numeric_only'"
+        with pytest.raises(TypeError, match=msg):
+            method(*args, **kwargs)
+    elif groupby_func not in has_axis:
+        msg = "got an unexpected keyword argument 'axis'"
+        warn = FutureWarning if groupby_func == "skew" and not numeric_only else None
+        with tm.assert_produces_warning(warn, match="Dropping of nuisance columns"):
+            with pytest.raises(TypeError, match=msg):
+                method(*args, **kwargs)
+    # fillna and shift are successful even on object dtypes
+    elif (numeric_only is None or not numeric_only) and groupby_func not in (
+        "fillna",
+        "shift",
+    ):
+        msgs = (
+            # cummax, cummin, rank
+            "not supported between instances of",
+            # cumprod
+            "can't multiply sequence by non-int of type 'float'",
+            # cumsum, diff, pct_change
+            "unsupported operand type",
+        )
+        with pytest.raises(TypeError, match=f"({'|'.join(msgs)})"):
+            method(*args, **kwargs)
+    else:
+        result = method(*args, **kwargs)
+
+        df_expected = df.drop(columns="E").T if numeric_only else df.T
+        expected = getattr(df_expected, groupby_func)(*args).T
+        if groupby_func == "shift" and not numeric_only:
+            # shift with axis=1 leaves the leftmost column as numeric
+            # but transposing for expected gives us object dtype
+            expected = expected.astype(float)
+
+        tm.assert_equal(result, expected)
+
+
 def test_groupby_cumprod():
     # GH 4095
     df = DataFrame({"key": ["b"] * 10, "value": 2})
@@ -1321,7 +1396,7 @@ def test_deprecate_numeric_only(
         assert "b" not in result.columns
     elif (
         # kernels that work on any dtype and have numeric_only arg
-        kernel in ("first", "last", "corrwith")
+        kernel in ("first", "last")
         or (
             # kernels that work on any dtype and don't have numeric_only arg
             kernel in ("any", "all", "bfill", "ffill", "fillna", "nth", "nunique")
@@ -1339,7 +1414,8 @@ def test_deprecate_numeric_only(
             "(not allowed for this dtype"
             "|must be a string or a number"
             "|cannot be performed against 'object' dtypes"
-            "|must be a string or a real number)"
+            "|must be a string or a real number"
+            "|unsupported operand type)"
         )
         with pytest.raises(TypeError, match=msg):
             method(*args, **kwargs)