Merge remote-tracking branch 'upstream/main' into deps/optional/bump

Author: mroeschke

doc/source/whatsnew/v3.0.0.rst

@@ -913,6 +913,7 @@ Timedelta
 - Accuracy improvement in :meth:`Timedelta.to_pytimedelta` to round microseconds consistently for large nanosecond based Timedelta (:issue:`57841`)
 - Bug in :class:`Timedelta` constructor failing to raise when passed an invalid keyword (:issue:`53801`)
 - Bug in :meth:`DataFrame.cumsum` which was raising ``IndexError`` if dtype is ``timedelta64[ns]`` (:issue:`57956`)
+- Bug in multiplication operations with ``timedelta64`` dtype failing to raise ``TypeError`` when multiplying by ``bool`` objects or dtypes (:issue:`58054`)
 
 Timezones
 ^^^^^^^^^
@@ -969,6 +970,7 @@ Missing
 ^^^^^^^
 - Bug in :meth:`DataFrame.fillna` and :meth:`Series.fillna` that would ignore the ``limit`` argument on :class:`.ExtensionArray` dtypes (:issue:`58001`)
 - Bug in :meth:`NA.__and__`, :meth:`NA.__or__` and :meth:`NA.__xor__` when operating with ``np.bool_`` objects (:issue:`58427`)
+- Bug in ``divmod`` between :class:`NA` and ``Int64`` dtype objects (:issue:`62196`)
 -
 
 MultiIndex
@@ -1137,6 +1139,7 @@ Other
 - Bug in ``Series.list`` methods not preserving the original :class:`Index`. (:issue:`58425`)
 - Bug in ``Series.list`` methods not preserving the original name. (:issue:`60522`)
 - Bug in ``Series.replace`` when the Series was created from an :class:`Index` and Copy-On-Write is enabled (:issue:`61622`)
+- Bug in ``divmod`` and ``rdivmod`` with :class:`DataFrame`, :class:`Series`, and :class:`Index` with ``bool`` dtypes failing to raise, which was inconsistent with ``__floordiv__`` behavior (:issue:`46043`)
 - Bug in printing a :class:`DataFrame` with a :class:`DataFrame` stored in :attr:`DataFrame.attrs` raised a ``ValueError`` (:issue:`60455`)
 - Bug in printing a :class:`Series` with a :class:`DataFrame` stored in :attr:`Series.attrs` raised a ``ValueError`` (:issue:`60568`)
 - Fixed bug where the :class:`DataFrame` constructor misclassified array-like objects with a ``.name`` attribute as :class:`Series` or :class:`Index` (:issue:`61443`)

pandas/core/arrays/masked.py

@@ -791,6 +791,10 @@ def _arith_method(self, other, op):
                 #  will be all-True, but since this is division, we want
                 #  to end up with floating dtype.
                 result = result.astype(np.float64)
+            elif op_name in {"divmod", "rdivmod"}:
+                # GH#62196
+                res = self._maybe_mask_result(result, mask)
+                return res, res.copy()
         else:
             # Make sure we do this before the "pow" mask checks
             #  to get an expected exception message on shape mismatch.

pandas/core/arrays/timedeltas.py

@@ -472,6 +472,11 @@ def _add_offset(self, other):
     @unpack_zerodim_and_defer("__mul__")
     def __mul__(self, other) -> Self:
         if is_scalar(other):
+            if lib.is_bool(other):
+                raise TypeError(
+                    f"Cannot multiply '{self.dtype}' by bool, explicitly cast to "
+                    "integers instead"
+                )
             # numpy will accept float and int, raise TypeError for others
             result = self._ndarray * other
             if result.dtype.kind != "m":
@@ -489,6 +494,13 @@ def __mul__(self, other) -> Self:
         if not hasattr(other, "dtype"):
             # list, tuple
             other = np.array(other)
+
+        if other.dtype.kind == "b":
+            # GH#58054
+            raise TypeError(
+                f"Cannot multiply '{self.dtype}' by bool, explicitly cast to "
+                "integers instead"
+            )
         if len(other) != len(self) and not lib.is_np_dtype(other.dtype, "m"):
             # Exclude timedelta64 here so we correctly raise TypeError
             #  for that instead of ValueError

pandas/core/ops/array_ops.py

@@ -585,6 +585,8 @@ def maybe_prepare_scalar_for_op(obj, shape: Shape):
     roperator.rfloordiv,
     operator.pow,
     roperator.rpow,
+    divmod,
+    roperator.rdivmod,
 }
 
 

pandas/tests/arithmetic/test_bool.py

@@ -0,0 +1,28 @@
+import pytest
+
+from pandas import (
+    DataFrame,
+    Series,
+)
+import pandas._testing as tm
+
+
+def test_divmod_bool_raises(box_with_array):
+    # GH#46043 // raises, so divmod should too
+    ser = Series([True, False])
+    obj = tm.box_expected(ser, box_with_array)
+
+    msg = "operator 'floordiv' not implemented for bool dtypes"
+    with pytest.raises(NotImplementedError, match=msg):
+        obj // obj
+
+    if box_with_array is DataFrame:
+        msg = "operator 'floordiv' not implemented for bool dtypes"
+    else:
+        msg = "operator 'divmod' not implemented for bool dtypes"
+    with pytest.raises(NotImplementedError, match=msg):
+        divmod(obj, obj)
+
+    # go through __rdivmod__
+    with pytest.raises(NotImplementedError, match=msg):
+        divmod(True, obj)

pandas/tests/arithmetic/test_timedelta64.py

@@ -11,6 +11,7 @@
 from pandas._libs.tslibs import timezones
 from pandas.compat import WASM
 from pandas.errors import OutOfBoundsDatetime
+import pandas.util._test_decorators as td
 
 import pandas as pd
 from pandas import (
@@ -1556,6 +1557,51 @@ def test_tdi_rmul_arraylike(self, other, box_with_array):
         commute = tdi * other
         tm.assert_equal(commute, expected)
 
+    def test_td64arr_mul_bool_scalar_raises(self, box_with_array):
+        # GH#58054
+        ser = Series(np.arange(5) * timedelta(hours=1))
+        obj = tm.box_expected(ser, box_with_array)
+
+        msg = r"Cannot multiply 'timedelta64\[ns\]' by bool"
+        with pytest.raises(TypeError, match=msg):
+            True * obj
+        with pytest.raises(TypeError, match=msg):
+            obj * True
+        with pytest.raises(TypeError, match=msg):
+            np.True_ * obj
+        with pytest.raises(TypeError, match=msg):
+            obj * np.True_
+
+    @pytest.mark.parametrize(
+        "dtype",
+        [
+            bool,
+            "boolean",
+            pytest.param("bool[pyarrow]", marks=td.skip_if_no("pyarrow")),
+        ],
+    )
+    def test_td64arr_mul_bool_raises(self, dtype, box_with_array):
+        # GH#58054
+        ser = Series(np.arange(5) * timedelta(hours=1))
+        obj = tm.box_expected(ser, box_with_array)
+
+        other = Series(np.arange(5) < 0.5, dtype=dtype)
+        other = tm.box_expected(other, box_with_array)
+
+        msg = r"Cannot multiply 'timedelta64\[ns\]' by bool"
+        with pytest.raises(TypeError, match=msg):
+            obj * other
+
+        msg2 = msg.replace("rmul", "mul")
+        if dtype == "bool[pyarrow]":
+            # We go through ArrowEA.__mul__ which gives a different message
+            msg2 = (
+                r"operation 'mul' not supported for dtype 'bool\[pyarrow\]' "
+                r"with dtype 'timedelta64\[ns\]'"
+            )
+        with pytest.raises(TypeError, match=msg2):
+            other * obj
+
     # ------------------------------------------------------------------
     # __div__, __rdiv__
 

pandas/tests/arrays/masked/test_arithmetic.py

@@ -246,3 +246,26 @@ def test_unary_op_does_not_propagate_mask(data, op):
     expected = result.copy(deep=True)
     ser[0] = None
     tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("dtype", ["Int64", "Int32", "Float32", "Float64"])
+def test_divmod_pdna(dtype):
+    # GH#62196
+    ser = pd.Series([1, 2, 3], dtype=dtype)
+    res = divmod(pd.NA, ser)
+    assert isinstance(res, tuple) and len(res) == 2
+
+    exp = pd.Series([pd.NA, pd.NA, pd.NA], dtype=dtype)
+    tm.assert_series_equal(res[0], exp)
+    tm.assert_series_equal(res[1], exp)
+
+    tm.assert_series_equal(res[0], pd.NA // ser)
+    tm.assert_series_equal(res[1], pd.NA % ser)
+
+    res = divmod(ser, pd.NA)
+    assert isinstance(res, tuple) and len(res) == 2
+    tm.assert_series_equal(res[0], exp)
+    tm.assert_series_equal(res[1], exp)
+
+    tm.assert_series_equal(res[0], ser // pd.NA)
+    tm.assert_series_equal(res[1], ser % pd.NA)