BUG: Don't raise for NDFrame.mask with nullable boolean

doc/source/whatsnew/v1.1.2.rst

@@ -23,6 +23,7 @@ Fixed regressions
 - Regression in :meth:`DataFrame.replace` where a ``TypeError`` would be raised when attempting to replace elements of type :class:`Interval` (:issue:`35931`)
 - Fix regression in pickle roundtrip of the ``closed`` attribute of :class:`IntervalIndex` (:issue:`35658`)
 - Fixed regression in :meth:`DataFrameGroupBy.agg` where a ``ValueError: buffer source array is read-only`` would be raised when the underlying array is read-only (:issue:`36014`)
+- Fixed regression in :meth:`DataFrame.mask` and :meth:`DataFrame.where` raising an ``AseertionError`` when using a nullable boolean mask (:issue:`35429`)
 - Fixed regression in :meth:`Series.groupby.rolling` number of levels of :class:`MultiIndex` in input was compressed to one (:issue:`36018`)
 -
 

pandas/core/frame.py

@@ -3122,6 +3122,8 @@ def _setitem_frame(self, key, value):
 
         self._check_inplace_setting(value)
         self._check_setitem_copy()
+        if not self._indexed_same(key):
+            key = key.reindex_like(self).fillna(False)
         self._where(-key, value, inplace=True)
 
     def _iset_item(self, loc: int, value):

pandas/core/generic.py

@@ -8816,8 +8816,7 @@ def _where(
             cond = self._constructor(cond, **self._construct_axes_dict())
 
         # make sure we are boolean
-        fill_value = bool(inplace)
-        cond = cond.fillna(fill_value)
+        cond = cond.fillna(False)
 
         msg = "Boolean array expected for the condition, not {dtype}"
 
@@ -8834,7 +8833,7 @@ def _where(
             # GH#21947 we have an empty DataFrame/Series, could be object-dtype
             cond = cond.astype(bool)
 
-        cond = -cond if inplace else cond
+        cond = ~cond if inplace else cond
 
         # try to align with other
         try_quick = True
@@ -9094,9 +9093,12 @@ def mask(
         cond = com.apply_if_callable(cond, self)
 
         # see gh-21891
-        if not hasattr(cond, "__invert__"):
+        if not hasattr(cond, "__array__"):
             cond = np.array(cond)
 
+        cond[isna(cond)] = False
+        cond = cond.astype(bool, copy=False)
+
         return self.where(
             ~cond,
             other=other,

pandas/core/internals/blocks.py

@@ -2933,7 +2933,8 @@ def _extract_bool_array(mask: ArrayLike) -> np.ndarray:
         #  Except for BooleanArray, this is equivalent to just
         #  np.asarray(mask, dtype=bool)
         mask = mask.to_numpy(dtype=bool, na_value=False)
+    else:
+        assert isinstance(mask, np.ndarray), type(mask)
+        mask = mask.astype(bool, copy=False)
 
-    assert isinstance(mask, np.ndarray), type(mask)
-    assert mask.dtype == bool, mask.dtype
     return mask

pandas/tests/frame/indexing/test_mask.py

@@ -3,8 +3,9 @@
 """
 
 import numpy as np
+import pytest
 
-from pandas import DataFrame, isna
+from pandas import DataFrame, Series, isna
 import pandas._testing as tm
 
 
@@ -83,3 +84,18 @@ def test_mask_dtype_conversion(self):
         expected = bools.astype(float).mask(mask)
         result = bools.mask(mask)
         tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("inplace", [True, False])
+    def test_mask_nullable_boolean(self, inplace):
+        # https://github.com/pandas-dev/pandas/issues/35429
+        df = DataFrame([1, 2, 3])
+        mask = Series([True, False, None], dtype="boolean")
+        expected = DataFrame([999, 2, 3])
+
+        if inplace:
+            result = df.copy()
+            result.mask(mask, 999, inplace=True)
+        else:
+            result = df.mask(mask, 999, inplace=False)
+
+        tm.assert_frame_equal(result, expected)

pandas/tests/frame/indexing/test_where.py

@@ -159,7 +159,7 @@ def test_where_set(self, where_frame, float_string_frame):
 
         def _check_set(df, cond, check_dtypes=True):
             dfi = df.copy()
-            econd = cond.reindex_like(df).fillna(True)
+            econd = cond.reindex_like(df).fillna(False)
             expected = dfi.mask(~econd)
 
             return_value = dfi.where(cond, np.nan, inplace=True)
@@ -169,7 +169,7 @@ def _check_set(df, cond, check_dtypes=True):
             # dtypes (and confirm upcasts)x
             if check_dtypes:
                 for k, v in df.dtypes.items():
-                    if issubclass(v.type, np.integer) and not cond[k].all():
+                    if issubclass(v.type, np.integer) and not econd[k].all():
                         v = np.dtype("float64")
                     assert dfi[k].dtype == v
 
@@ -642,3 +642,18 @@ def test_df_where_with_category(self, kwargs):
         expected = Series(A, name="A")
 
         tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("inplace", [True, False])
+    def test_where_nullable_boolean_mask(self, inplace):
+        # https://github.com/pandas-dev/pandas/issues/35429
+        df = DataFrame([1, 2, 3])
+        mask = Series([True, False, None], dtype="boolean")
+        expected = DataFrame([1, 999, 999])
+
+        if inplace:
+            result = df.copy()
+            result.where(mask, 999, inplace=True)
+        else:
+            result = df.where(mask, 999, inplace=False)
+
+        tm.assert_frame_equal(result, expected)

pandas/tests/series/indexing/test_mask.py

@@ -63,3 +63,19 @@ def test_mask_inplace():
     rs = s.copy()
     rs.mask(cond, -s, inplace=True)
     tm.assert_series_equal(rs, s.mask(cond, -s))
+
+
+@pytest.mark.parametrize("inplace", [True, False])
+def test_mask_nullable_boolean(inplace):
+    # https://github.com/pandas-dev/pandas/issues/35429
+    ser = Series([1, 2, 3])
+    mask = Series([True, False, None], dtype="boolean")
+    expected = Series([999, 2, 3])
+
+    if inplace:
+        result = ser.copy()
+        result.mask(mask, 999, inplace=True)
+    else:
+        result = ser.mask(mask, 999, inplace=False)
+
+    tm.assert_series_equal(result, expected)

pandas/tests/series/indexing/test_where.py

@@ -452,3 +452,19 @@ def test_where_empty_series_and_empty_cond_having_non_bool_dtypes():
     ser = Series([], dtype=float)
     result = ser.where([])
     tm.assert_series_equal(result, ser)
+
+
+@pytest.mark.parametrize("inplace", [True, False])
+def test_where_nullable_boolean_mask(inplace):
+    # https://github.com/pandas-dev/pandas/issues/35429
+    ser = Series([1, 2, 3])
+    mask = Series([True, False, None], dtype="boolean")
+    expected = Series([1, 999, 999])
+
+    if inplace:
+        result = ser.copy()
+        result.where(mask, 999, inplace=True)
+    else:
+        result = ser.where(mask, 999, inplace=False)
+
+    tm.assert_series_equal(result, expected)