REF/TYP: use OpsMixin for DataFrame

pandas/core/frame.py

@@ -124,6 +124,7 @@
     relabel_result,
     transform,
 )
+from pandas.core.arraylike import OpsMixin
 from pandas.core.arrays import Categorical, ExtensionArray
 from pandas.core.arrays.sparse import SparseFrameAccessor
 from pandas.core.construction import extract_array
@@ -336,7 +337,7 @@
 # DataFrame class
 
 
-class DataFrame(NDFrame):
+class DataFrame(OpsMixin, NDFrame):
     """
     Two-dimensional, size-mutable, potentially heterogeneous tabular data.
 
@@ -420,6 +421,7 @@ def _constructor(self) -> Type[DataFrame]:
     _constructor_sliced: Type[Series] = Series
     _deprecations: FrozenSet[str] = NDFrame._deprecations | frozenset([])
     _accessors: Set[str] = {"sparse"}
+    __hash__ = NDFrame.__hash__
 
     @property
     def _constructor_expanddim(self):
@@ -5838,7 +5840,87 @@ def reorder_levels(self, order, axis=0) -> DataFrame:
         return result
 
     # ----------------------------------------------------------------------
-    # Arithmetic / combination related
+    # Arithmetic Methods
+
+    def _cmp_method(self, other, op):
+        axis = 1  # only relevant for Series other case
+
+        self, other = ops.align_method_FRAME(self, other, axis, flex=False, level=None)
+
+        # See GH#4537 for discussion of scalar op behavior
+        new_data = self._dispatch_frame_op(other, op, axis=axis)
+        return self._construct_result(new_data)
+
+    def _arith_method(self, other, op):
+        if ops._should_reindex_frame_op(self, other, op, 1, 1, None, None):
+            return ops._frame_arith_method_with_reindex(self, other, op)
+
+        axis = 1  # only relevant for Series other case
+
+        self, other = ops.align_method_FRAME(self, other, axis, flex=True, level=None)
+
+        new_data = self._dispatch_frame_op(other, op, axis=axis)
+        return self._construct_result(new_data)
+
+    _logical_method = _arith_method
+
+    def _dispatch_frame_op(self, right, func, axis: Optional[int] = None):
+        """
+        Evaluate the frame operation func(left, right) by evaluating
+        column-by-column, dispatching to the Series implementation.
+
+        Parameters
+        ----------
+        right : scalar, Series, or DataFrame
+        func : arithmetic or comparison operator
+        axis : {None, 0, 1}
+
+        Returns
+        -------
+        DataFrame
+        """
+        # Get the appropriate array-op to apply to each column/block's values.
+        array_op = ops.get_array_op(func)
+
+        right = lib.item_from_zerodim(right)
+        if not is_list_like(right):
+            # i.e. scalar, faster than checking np.ndim(right) == 0
+            bm = self._mgr.apply(array_op, right=right)
+            return type(self)(bm)
+
+        elif isinstance(right, DataFrame):
+            assert self.index.equals(right.index)
+            assert self.columns.equals(right.columns)
+            # TODO: The previous assertion `assert right._indexed_same(self)`
+            #  fails in cases with empty columns reached via
+            #  _frame_arith_method_with_reindex
+
+            bm = self._mgr.operate_blockwise(right._mgr, array_op)
+            return type(self)(bm)
+
+        elif isinstance(right, Series) and axis == 1:
+            # axis=1 means we want to operate row-by-row
+            assert right.index.equals(self.columns)
+
+            right = right._values
+            # maybe_align_as_frame ensures we do not have an ndarray here
+            assert not isinstance(right, np.ndarray)
+
+            arrays = [array_op(l, r) for l, r in zip(self._iter_column_arrays(), right)]
+
+        elif isinstance(right, Series):
+            assert right.index.equals(self.index)  # Handle other cases later
+            right = right._values
+
+            arrays = [array_op(l, right) for l in self._iter_column_arrays()]
+
+        else:
+            # Remaining cases have less-obvious dispatch rules
+            raise NotImplementedError(right)
+
+        return type(self)._from_arrays(
+            arrays, self.columns, self.index, verify_integrity=False
+        )
 
     def _combine_frame(self, other: DataFrame, func, fill_value=None):
         # at this point we have `self._indexed_same(other)`
@@ -5857,7 +5939,7 @@ def _arith_op(left, right):
                 left, right = ops.fill_binop(left, right, fill_value)
                 return func(left, right)
 
-        new_data = ops.dispatch_to_series(self, other, _arith_op)
+        new_data = self._dispatch_frame_op(other, _arith_op)
         return new_data
 
     def _construct_result(self, result) -> DataFrame:
@@ -5879,6 +5961,9 @@ def _construct_result(self, result) -> DataFrame:
         out.index = self.index
         return out
 
+    # ----------------------------------------------------------------------
+    # Combination-Related
+
     @Appender(
         """
 Returns
@@ -7254,7 +7339,7 @@ def diff(self, periods: int = 1, axis: Axis = 0) -> DataFrame:
         bm_axis = self._get_block_manager_axis(axis)
 
         if bm_axis == 0 and periods != 0:
-            return self - self.shift(periods, axis=axis)  # type: ignore[operator]
+            return self - self.shift(periods, axis=axis)
 
         new_data = self._mgr.diff(n=periods, axis=bm_axis)
         return self._constructor(new_data)

pandas/core/ops/__init__.py

@@ -4,12 +4,11 @@
 This is not a public API.
 """
 import operator
-from typing import TYPE_CHECKING, Optional, Set, Type
+from typing import TYPE_CHECKING, Optional, Set
 import warnings
 
 import numpy as np
 
-from pandas._libs import lib
 from pandas._libs.ops_dispatch import maybe_dispatch_ufunc_to_dunder_op  # noqa:F401
 from pandas._typing import Level
 from pandas.util._decorators import Appender
@@ -28,7 +27,6 @@
 )
 from pandas.core.ops.common import unpack_zerodim_and_defer  # noqa:F401
 from pandas.core.ops.docstrings import (
-    _arith_doc_FRAME,
     _flex_comp_doc_FRAME,
     _make_flex_doc,
     _op_descriptions,
@@ -143,29 +141,6 @@ def _maybe_match_name(a, b):
     return None
 
 
-# -----------------------------------------------------------------------------
-
-
-def _get_op_name(op, special: bool) -> str:
-    """
-    Find the name to attach to this method according to conventions
-    for special and non-special methods.
-
-    Parameters
-    ----------
-    op : binary operator
-    special : bool
-
-    Returns
-    -------
-    op_name : str
-    """
-    opname = op.__name__.strip("_")
-    if special:
-        opname = f"__{opname}__"
-    return opname
-
-
 # -----------------------------------------------------------------------------
 # Masking NA values and fallbacks for operations numpy does not support
 
@@ -211,70 +186,6 @@ def fill_binop(left, right, fill_value):
     return left, right
 
 
-# -----------------------------------------------------------------------------
-# Dispatch logic
-
-
-def dispatch_to_series(left, right, func, axis: Optional[int] = None):
-    """
-    Evaluate the frame operation func(left, right) by evaluating
-    column-by-column, dispatching to the Series implementation.
-
-    Parameters
-    ----------
-    left : DataFrame
-    right : scalar, Series, or DataFrame
-    func : arithmetic or comparison operator
-    axis : {None, 0, 1}
-
-    Returns
-    -------
-    DataFrame
-    """
-    # Get the appropriate array-op to apply to each column/block's values.
-    array_op = get_array_op(func)
-
-    right = lib.item_from_zerodim(right)
-    if not is_list_like(right):
-        # i.e. scalar, faster than checking np.ndim(right) == 0
-        bm = left._mgr.apply(array_op, right=right)
-        return type(left)(bm)
-
-    elif isinstance(right, ABCDataFrame):
-        assert left.index.equals(right.index)
-        assert left.columns.equals(right.columns)
-        # TODO: The previous assertion `assert right._indexed_same(left)`
-        #  fails in cases with empty columns reached via
-        #  _frame_arith_method_with_reindex
-
-        bm = left._mgr.operate_blockwise(right._mgr, array_op)
-        return type(left)(bm)
-
-    elif isinstance(right, ABCSeries) and axis == 1:
-        # axis=1 means we want to operate row-by-row
-        assert right.index.equals(left.columns)
-
-        right = right._values
-        # maybe_align_as_frame ensures we do not have an ndarray here
-        assert not isinstance(right, np.ndarray)
-
-        arrays = [array_op(l, r) for l, r in zip(left._iter_column_arrays(), right)]
-
-    elif isinstance(right, ABCSeries):
-        assert right.index.equals(left.index)  # Handle other cases later
-        right = right._values
-
-        arrays = [array_op(l, right) for l in left._iter_column_arrays()]
-
-    else:
-        # Remaining cases have less-obvious dispatch rules
-        raise NotImplementedError(right)
-
-    return type(left)._from_arrays(
-        arrays, left.columns, left.index, verify_integrity=False
-    )
-
-
 # -----------------------------------------------------------------------------
 # Series
 
@@ -299,9 +210,8 @@ def align_method_SERIES(left: "Series", right, align_asobject: bool = False):
     return left, right
 
 
-def flex_method_SERIES(cls, op, special):
-    assert not special  # "special" also means "not flex"
-    name = _get_op_name(op, special)
+def flex_method_SERIES(op):
+    name = op.__name__.strip("_")
     doc = _make_flex_doc(name, "series")
 
     @Appender(doc)
@@ -427,7 +337,7 @@ def to_series(right):
                     "Do `left, right = left.align(right, axis=1, copy=False)` "
                     "before e.g. `left == right`",
                     FutureWarning,
-                    stacklevel=3,
+                    stacklevel=5,
                 )
 
         left, right = left.align(
@@ -533,10 +443,9 @@ def _maybe_align_series_as_frame(frame: "DataFrame", series: "Series", axis: int
     return type(frame)(rvalues, index=frame.index, columns=frame.columns)
 
 
-def flex_arith_method_FRAME(cls: Type["DataFrame"], op, special: bool):
-    assert not special
-    op_name = _get_op_name(op, special)
-    default_axis = None if special else "columns"
+def flex_arith_method_FRAME(op):
+    op_name = op.__name__.strip("_")
+    default_axis = "columns"
 
     na_op = get_array_op(op)
     doc = _make_flex_doc(op_name, "dataframe")
@@ -563,13 +472,13 @@ def f(self, other, axis=default_axis, level=None, fill_value=None):
             new_data = self._combine_frame(other, na_op, fill_value)
 
         elif isinstance(other, ABCSeries):
-            new_data = dispatch_to_series(self, other, op, axis=axis)
+            new_data = self._dispatch_frame_op(other, op, axis=axis)
         else:
             # in this case we always have `np.ndim(other) == 0`
             if fill_value is not None:
                 self = self.fillna(fill_value)
 
-            new_data = dispatch_to_series(self, other, op)
+            new_data = self._dispatch_frame_op(other, op)
 
         return self._construct_result(new_data)
 
@@ -578,32 +487,8 @@ def f(self, other, axis=default_axis, level=None, fill_value=None):
     return f
 
 
-def arith_method_FRAME(cls: Type["DataFrame"], op, special: bool):
-    assert special
-    op_name = _get_op_name(op, special)
-    doc = _arith_doc_FRAME % op_name
-
-    @Appender(doc)
-    def f(self, other):
-
-        if _should_reindex_frame_op(self, other, op, 1, 1, None, None):
-            return _frame_arith_method_with_reindex(self, other, op)
-
-        axis = 1  # only relevant for Series other case
-
-        self, other = align_method_FRAME(self, other, axis, flex=True, level=None)
-
-        new_data = dispatch_to_series(self, other, op, axis=axis)
-        return self._construct_result(new_data)
-
-    f.__name__ = op_name
-
-    return f
-
-
-def flex_comp_method_FRAME(cls: Type["DataFrame"], op, special: bool):
-    assert not special  # "special" also means "not flex"
-    op_name = _get_op_name(op, special)
+def flex_comp_method_FRAME(op):
+    op_name = op.__name__.strip("_")
     default_axis = "columns"  # because we are "flex"
 
     doc = _flex_comp_doc_FRAME.format(
@@ -616,26 +501,7 @@ def f(self, other, axis=default_axis, level=None):
 
         self, other = align_method_FRAME(self, other, axis, flex=True, level=level)
 
-        new_data = dispatch_to_series(self, other, op, axis=axis)
-        return self._construct_result(new_data)
-
-    f.__name__ = op_name
-
-    return f
-
-
-def comp_method_FRAME(cls: Type["DataFrame"], op, special: bool):
-    assert special  # "special" also means "not flex"
-    op_name = _get_op_name(op, special)
-
-    @Appender(f"Wrapper for comparison method {op_name}")
-    def f(self, other):
-        axis = 1  # only relevant for Series other case
-
-        self, other = align_method_FRAME(self, other, axis, flex=False, level=None)
-
-        # See GH#4537 for discussion of scalar op behavior
-        new_data = dispatch_to_series(self, other, op, axis=axis)
+        new_data = self._dispatch_frame_op(other, op, axis=axis)
         return self._construct_result(new_data)
 
     f.__name__ = op_name