REF: remove no-longer-needed ignore_failures (#49659)

Author: jbrockmendel

pandas/core/frame.py

@@ -10463,7 +10463,7 @@ def _get_data() -> DataFrame:
 
             # After possibly _get_data and transposing, we are now in the
             #  simple case where we can use BlockManager.reduce
-            res, _ = df._mgr.reduce(blk_func, ignore_failures=False)
+            res = df._mgr.reduce(blk_func)
             out = df._constructor(res).iloc[0]
             if out_dtype is not None:
                 out = out.astype(out_dtype)

pandas/core/internals/array_manager.py

@@ -196,7 +196,6 @@ def apply(
         self: T,
         f,
         align_keys: list[str] | None = None,
-        ignore_failures: bool = False,
         **kwargs,
     ) -> T:
         """
@@ -207,19 +206,17 @@ def apply(
         f : str or callable
             Name of the Array method to apply.
         align_keys: List[str] or None, default None
-        ignore_failures: bool, default False
         **kwargs
             Keywords to pass to `f`
 
         Returns
         -------
         ArrayManager
         """
-        assert "filter" not in kwargs
+        assert "filter" not in kwargs and "ignore_failures" not in kwargs
 
         align_keys = align_keys or []
         result_arrays: list[np.ndarray] = []
-        result_indices: list[int] = []
         # fillna: Series/DataFrame is responsible for making sure value is aligned
 
         aligned_args = {k: kwargs[k] for k in align_keys}
@@ -243,27 +240,17 @@ def apply(
                         # otherwise we have an array-like
                         kwargs[k] = obj[i]
 
-            try:
-                if callable(f):
-                    applied = f(arr, **kwargs)
-                else:
-                    applied = getattr(arr, f)(**kwargs)
-            except (TypeError, NotImplementedError):
-                if not ignore_failures:
-                    raise
-                continue
+            if callable(f):
+                applied = f(arr, **kwargs)
+            else:
+                applied = getattr(arr, f)(**kwargs)
+
             # if not isinstance(applied, ExtensionArray):
             #     # TODO not all EA operations return new EAs (eg astype)
             #     applied = array(applied)
             result_arrays.append(applied)
-            result_indices.append(i)
 
-        new_axes: list[Index]
-        if ignore_failures:
-            # TODO copy?
-            new_axes = [self._axes[0], self._axes[1][result_indices]]
-        else:
-            new_axes = self._axes
+        new_axes = self._axes
 
         # error: Argument 1 to "ArrayManager" has incompatible type "List[ndarray]";
         # expected "List[Union[ndarray, ExtensionArray]]"
@@ -985,58 +972,41 @@ def grouped_reduce(self: T, func: Callable, ignore_failures: bool = False) -> T:
         # expected "List[Union[ndarray, ExtensionArray]]"
         return type(self)(result_arrays, [index, columns])  # type: ignore[arg-type]
 
-    def reduce(
-        self: T, func: Callable, ignore_failures: bool = False
-    ) -> tuple[T, np.ndarray]:
+    def reduce(self: T, func: Callable) -> T:
         """
         Apply reduction function column-wise, returning a single-row ArrayManager.
 
         Parameters
         ----------
         func : reduction function
-        ignore_failures : bool, default False
-            Whether to drop columns where func raises TypeError.
 
         Returns
         -------
         ArrayManager
-        np.ndarray
-            Indexer of column indices that are retained.
         """
         result_arrays: list[np.ndarray] = []
-        result_indices: list[int] = []
         for i, arr in enumerate(self.arrays):
-            try:
-                res = func(arr, axis=0)
-            except TypeError:
-                if not ignore_failures:
-                    raise
+            res = func(arr, axis=0)
+
+            # TODO NaT doesn't preserve dtype, so we need to ensure to create
+            # a timedelta result array if original was timedelta
+            # what if datetime results in timedelta? (eg std)
+            if res is NaT and is_timedelta64_ns_dtype(arr.dtype):
+                result_arrays.append(np.array(["NaT"], dtype="timedelta64[ns]"))
             else:
-                # TODO NaT doesn't preserve dtype, so we need to ensure to create
-                # a timedelta result array if original was timedelta
-                # what if datetime results in timedelta? (eg std)
-                if res is NaT and is_timedelta64_ns_dtype(arr.dtype):
-                    result_arrays.append(np.array(["NaT"], dtype="timedelta64[ns]"))
-                else:
-                    # error: Argument 1 to "append" of "list" has incompatible type
-                    # "ExtensionArray"; expected "ndarray"
-                    result_arrays.append(
-                        sanitize_array([res], None)  # type: ignore[arg-type]
-                    )
-                result_indices.append(i)
+                # error: Argument 1 to "append" of "list" has incompatible type
+                # "ExtensionArray"; expected "ndarray"
+                result_arrays.append(
+                    sanitize_array([res], None)  # type: ignore[arg-type]
+                )
 
         index = Index._simple_new(np.array([None], dtype=object))  # placeholder
-        if ignore_failures:
-            indexer = np.array(result_indices)
-            columns = self.items[result_indices]
-        else:
-            indexer = np.arange(self.shape[0])
-            columns = self.items
+        columns = self.items
 
         # error: Argument 1 to "ArrayManager" has incompatible type "List[ndarray]";
         # expected "List[Union[ndarray, ExtensionArray]]"
         new_mgr = type(self)(result_arrays, [index, columns])  # type: ignore[arg-type]
-        return new_mgr, indexer
+        return new_mgr
 
     def operate_blockwise(self, other: ArrayManager, array_op) -> ArrayManager:
         """

pandas/core/internals/base.py

@@ -134,7 +134,6 @@ def apply(
         self: T,
         f,
         align_keys: list[str] | None = None,
-        ignore_failures: bool = False,
         **kwargs,
     ) -> T:
         raise AbstractMethodError(self)

pandas/core/internals/blocks.py

@@ -326,17 +326,12 @@ def apply(self, func, **kwargs) -> list[Block]:
 
         return self._split_op_result(result)
 
-    def reduce(self, func, ignore_failures: bool = False) -> list[Block]:
+    def reduce(self, func) -> list[Block]:
         # We will apply the function and reshape the result into a single-row
         #  Block with the same mgr_locs; squeezing will be done at a higher level
         assert self.ndim == 2
 
-        try:
-            result = func(self.values)
-        except (TypeError, NotImplementedError):
-            if ignore_failures:
-                return []
-            raise
+        result = func(self.values)
 
         if self.values.ndim == 1:
             # TODO(EA2D): special case not needed with 2D EAs
@@ -1957,23 +1952,17 @@ class ObjectBlock(NumpyBlock):
     __slots__ = ()
     is_object = True
 
-    @maybe_split
-    def reduce(self, func, ignore_failures: bool = False) -> list[Block]:
+    def reduce(self, func) -> list[Block]:
         """
         For object-dtype, we operate column-wise.
         """
         assert self.ndim == 2
 
-        try:
-            res = func(self.values)
-        except TypeError:
-            if not ignore_failures:
-                raise
-            return []
+        res = func(self.values)
 
         assert isinstance(res, np.ndarray)
         assert res.ndim == 1
-        res = res.reshape(1, -1)
+        res = res.reshape(-1, 1)
         return [self.make_block_same_class(res)]
 
     @maybe_split

pandas/core/internals/managers.py

@@ -303,7 +303,6 @@ def apply(
         self: T,
         f,
         align_keys: list[str] | None = None,
-        ignore_failures: bool = False,
         **kwargs,
     ) -> T:
         """
@@ -314,15 +313,14 @@ def apply(
         f : str or callable
             Name of the Block method to apply.
         align_keys: List[str] or None, default None
-        ignore_failures: bool, default False
         **kwargs
             Keywords to pass to `f`
 
         Returns
         -------
         BlockManager
         """
-        assert "filter" not in kwargs
+        assert "filter" not in kwargs and "ignore_failures" not in kwargs
 
         align_keys = align_keys or []
         result_blocks: list[Block] = []
@@ -346,20 +344,12 @@ def apply(
                         # otherwise we have an ndarray
                         kwargs[k] = obj[b.mgr_locs.indexer]
 
-            try:
-                if callable(f):
-                    applied = b.apply(f, **kwargs)
-                else:
-                    applied = getattr(b, f)(**kwargs)
-            except (TypeError, NotImplementedError):
-                if not ignore_failures:
-                    raise
-                continue
+            if callable(f):
+                applied = b.apply(f, **kwargs)
+            else:
+                applied = getattr(b, f)(**kwargs)
             result_blocks = extend_blocks(applied, result_blocks)
 
-        if ignore_failures:
-            return self._combine(result_blocks)
-
         out = type(self).from_blocks(result_blocks, self.axes)
         return out
 
@@ -1527,44 +1517,29 @@ def grouped_reduce(self: T, func: Callable, ignore_failures: bool = False) -> T:
 
         return type(self).from_blocks(result_blocks, [self.axes[0], index])
 
-    def reduce(
-        self: T, func: Callable, ignore_failures: bool = False
-    ) -> tuple[T, np.ndarray]:
+    def reduce(self: T, func: Callable) -> T:
         """
         Apply reduction function blockwise, returning a single-row BlockManager.
 
         Parameters
         ----------
         func : reduction function
-        ignore_failures : bool, default False
-            Whether to drop blocks where func raises TypeError.
 
         Returns
         -------
         BlockManager
-        np.ndarray
-            Indexer of mgr_locs that are retained.
         """
         # If 2D, we assume that we're operating column-wise
         assert self.ndim == 2
 
         res_blocks: list[Block] = []
         for blk in self.blocks:
-            nbs = blk.reduce(func, ignore_failures)
+            nbs = blk.reduce(func)
             res_blocks.extend(nbs)
 
         index = Index([None])  # placeholder
-        if ignore_failures:
-            if res_blocks:
-                indexer = np.concatenate([blk.mgr_locs.as_array for blk in res_blocks])
-                new_mgr = self._combine(res_blocks, copy=False, index=index)
-            else:
-                indexer = []
-                new_mgr = type(self).from_blocks([], [self.items[:0], index])
-        else:
-            indexer = np.arange(self.shape[0])
-            new_mgr = type(self).from_blocks(res_blocks, [self.items, index])
-        return new_mgr, indexer
+        new_mgr = type(self).from_blocks(res_blocks, [self.items, index])
+        return new_mgr
 
     def operate_blockwise(self, other: BlockManager, array_op) -> BlockManager:
         """