FIX-#5238: Make rmul really rmul instead of mul.

modin/core/storage_formats/base/query_compiler.py

@@ -529,6 +529,14 @@ def mod(self, other, **kwargs):  # noqa: PR02
     def mul(self, other, **kwargs):  # noqa: PR02
         return BinaryDefault.register(pandas.DataFrame.mul)(self, other=other, **kwargs)
 
+    @doc_utils.doc_binary_method(
+        operation="multiplication", sign="*", self_on_right=True
+    )
+    def rmul(self, other, **kwargs):  # noqa: PR02
+        return BinaryDefault.register(pandas.DataFrame.rmul)(
+            self, other=other, **kwargs
+        )
+
     @doc_utils.add_refer_to("DataFrame.corr")
     def corr(self, **kwargs):  # noqa: PR02
         """

modin/core/storage_formats/pandas/query_compiler.py

@@ -404,6 +404,7 @@ def to_numpy(self, **kwargs):
     lt = Binary.register(pandas.DataFrame.lt)
     mod = Binary.register(pandas.DataFrame.mod)
     mul = Binary.register(pandas.DataFrame.mul)
+    rmul = Binary.register(pandas.DataFrame.rmul)
     ne = Binary.register(pandas.DataFrame.ne)
     pow = Binary.register(pandas.DataFrame.pow)
     radd = Binary.register(pandas.DataFrame.radd)

modin/pandas/base.py

@@ -2322,7 +2322,15 @@ def rmod(
             "rmod", other, axis=axis, level=level, fill_value=fill_value
         )
 
-    rmul = mul
+    def rmul(
+        self, other, axis="columns", level=None, fill_value=None
+    ):  # noqa: PR01, RT01, D200
+        """
+        Get Multiplication of dataframe and other, element-wise (binary operator `rmul`).
+        """
+        return self._binary_op(
+            "rmul", other, axis=axis, level=level, fill_value=fill_value
+        )
 
     def _rolling(
         self, window, min_periods, center, win_type, *args, **kwargs

modin/pandas/dataframe.py

@@ -1525,7 +1525,22 @@ def mul(
             broadcast=isinstance(other, Series),
         )
 
-    rmul = multiply = mul
+    multiply = mul
+
+    def rmul(
+        self, other, axis="columns", level=None, fill_value=None
+    ):  # noqa: PR01, RT01, D200
+        """
+        Get multiplication of ``DataFrame`` and `other`, element-wise (binary operator `mul`).
+        """
+        return self._binary_op(
+            "rmul",
+            other,
+            axis=axis,
+            level=level,
+            fill_value=fill_value,
+            broadcast=isinstance(other, Series),
+        )
 
     def ne(self, other, axis="columns", level=None):  # noqa: PR01, RT01, D200
         """

modin/pandas/series.py

@@ -1301,7 +1301,18 @@ def mul(self, other, level=None, fill_value=None, axis=0):  # noqa: PR01, RT01,
             new_other, level=level, fill_value=None, axis=axis
         )
 
-    multiply = rmul = mul
+    multiply = mul
+
+    def rmul(
+        self, other, level=None, fill_value=None, axis=0
+    ):  # noqa: PR01, RT01, D200
+        """
+        Return multiplication of series and `other`, element-wise (binary operator `mul`).
+        """
+        new_self, new_other = self._prepare_inter_op(other)
+        return super(Series, new_self).rmul(
+            new_other, level=level, fill_value=None, axis=axis
+        )
 
     def ne(self, other, level=None, fill_value=None, axis=0):  # noqa: PR01, RT01, D200
         """

modin/pandas/test/dataframe/test_binary.py

@@ -29,6 +29,7 @@
     create_test_dfs,
     default_to_pandas_ignore_string,
     CustomIntegerForAddition,
+    NonCommutativeMultiplyInteger,
 )
 from modin.config import Engine, NPartitions
 from modin.test.test_utils import warns_that_defaulting_to_pandas
@@ -353,3 +354,22 @@ def test_add_custom_class():
         *create_test_dfs(test_data["int_data"]),
         lambda df: df + CustomIntegerForAddition(4),
     )
+
+
+def test_non_commutative_multiply_pandas():
+    # The non commutative integer class implementation is tricky. Check that
+    # multiplying such an integer with a pandas dataframe is really not
+    # commutative.
+    pandas_df = pd.DataFrame([[1]], dtype=int)
+    integer = NonCommutativeMultiplyInteger(2)
+    assert not (integer * pandas_df).equals(pandas_df * integer)
+
+
+def test_non_commutative_multiply():
+    # This test checks that mul and rmul do different things when
+    # multiplication is not commutative, e.g. for adding a string to a string.
+    # For context see https://github.com/modin-project/modin/issues/5238
+    modin_df, pandas_df = create_test_dfs([1], dtype=int)
+    integer = NonCommutativeMultiplyInteger(2)
+    eval_general(modin_df, pandas_df, lambda s: integer * s)
+    eval_general(modin_df, pandas_df, lambda s: s * integer)

modin/pandas/test/test_series.py

@@ -75,6 +75,7 @@
     test_data_large_categorical_series_values,
     default_to_pandas_ignore_string,
     CustomIntegerForAddition,
+    NonCommutativeMultiplyInteger,
 )
 from modin.config import NPartitions
 
@@ -4258,11 +4259,33 @@ def test_encode(data, encoding_type):
 
 
 @pytest.mark.parametrize("data", test_string_data_values, ids=test_string_data_keys)
-def test_add_string_to_series(data):
+def test_non_commutative_add_string_to_series(data):
+    # This test checks that add and radd do different things when addition is
+    # not commutative, e.g. for adding a string to a string. For context see
+    # https://github.com/modin-project/modin/issues/4908
     eval_general(*create_test_series(data), lambda s: "string" + s)
     eval_general(*create_test_series(data), lambda s: s + "string")
 
 
+def test_non_commutative_multiply_pandas():
+    # The non commutative integer class implementation is tricky. Check that
+    # multiplying such an integer with a pandas series is really not
+    # commutative.
+    pandas_series = pd.DataFrame([[1]], dtype=int)
+    integer = NonCommutativeMultiplyInteger(2)
+    assert not (integer * pandas_series).equals(pandas_series * integer)
+
+
+def test_non_commutative_multiply():
+    # This test checks that mul and rmul do different things when
+    # multiplication is not commutative, e.g. for adding a string to a string.
+    # For context see https://github.com/modin-project/modin/issues/5238
+    modin_series, pandas_series = create_test_series(1, dtype=int)
+    integer = NonCommutativeMultiplyInteger(2)
+    eval_general(modin_series, pandas_series, lambda s: integer * s)
+    eval_general(modin_series, pandas_series, lambda s: s * integer)
+
+
 @pytest.mark.parametrize(
     "is_sparse_data", [True, False], ids=["is_sparse", "is_not_sparse"]
 )

modin/pandas/test/utils.py

@@ -490,6 +490,38 @@ def __radd__(self, other):
         return other + self.value
 
 
+class NonCommutativeMultiplyInteger:
+    """int-like class with non-commutative multiply operation.
+
+    We need to test that rmul and mul do different things even when
+    multiplication is not commutative, but almost all multiplication is
+    commutative. This class' fake multiplication overloads are not commutative
+    when you multiply an instance of this class with pandas.series, which
+    does not know how to __mul__ with this class. e.g.
+
+    NonCommutativeMultiplyInteger(2) * pd.Series(1, dtype=int) == pd.Series(2, dtype=int)
+    pd.Series(1, dtype=int) * NonCommutativeMultiplyInteger(2) == pd.Series(3, dtype=int)
+    """
+
+    def __init__(self, value: int):
+        if not isinstance(value, int):
+            raise TypeError(
+                f"must initialize with integer, but got {value} of type {type(value)}"
+            )
+        self.value = value
+
+    def __mul__(self, other):
+        # Note that we need to check other is an int, otherwise when we (left) mul
+        # this with a series, we'll just multiply self.value by the series, whereas
+        # we want to make the series do an rmul instead.
+        if not isinstance(other, int):
+            return NotImplemented
+        return self.value * other
+
+    def __rmul__(self, other):
+        return self.value * other + 1
+
+
 def categories_equals(left, right):
     assert (left.ordered and right.ordered) or (not left.ordered and not right.ordered)
     assert_extension_array_equal(left, right)