STY: Enable B904 (pandas-dev#56941)

Author: tqa236

asv_bench/benchmarks/algos/isin.py

@@ -61,8 +61,8 @@ def setup(self, dtype):
                 self.series = Series(
                     Index([f"i-{i}" for i in range(N)], dtype=object), dtype=dtype
                 )
-            except ImportError:
-                raise NotImplementedError
+            except ImportError as err:
+                raise NotImplementedError from err
             self.values = list(self.series[:2])
 
         else:

asv_bench/benchmarks/array.py

@@ -76,8 +76,8 @@ class ArrowStringArray:
     def setup(self, multiple_chunks):
         try:
             import pyarrow as pa
-        except ImportError:
-            raise NotImplementedError
+        except ImportError as err:
+            raise NotImplementedError from err
         strings = np.array([str(i) for i in range(10_000)], dtype=object)
         if multiple_chunks:
             chunks = [strings[i : i + 100] for i in range(0, len(strings), 100)]

asv_bench/benchmarks/strings.py

@@ -21,8 +21,8 @@ def setup(self, dtype):
             self.s = Series(
                 Index([f"i-{i}" for i in range(10000)], dtype=object), dtype=dtype
             )
-        except ImportError:
-            raise NotImplementedError
+        except ImportError as err:
+            raise NotImplementedError from err
 
 
 class Construction:

pandas/compat/_optional.py

@@ -160,9 +160,9 @@ def import_optional_dependency(
     )
     try:
         module = importlib.import_module(name)
-    except ImportError:
+    except ImportError as err:
         if errors == "raise":
-            raise ImportError(msg)
+            raise ImportError(msg) from err
         return None
 
     # Handle submodules: if we have submodule, grab parent module from sys.modules

pandas/core/array_algos/datetimelike_accumulations.py

@@ -37,8 +37,10 @@ def _cum_func(
             np.cumsum: 0,
             np.minimum.accumulate: np.iinfo(np.int64).max,
         }[func]
-    except KeyError:
-        raise ValueError(f"No accumulation for {func} implemented on BaseMaskedArray")
+    except KeyError as err:
+        raise ValueError(
+            f"No accumulation for {func} implemented on BaseMaskedArray"
+        ) from err
 
     mask = isna(values)
     y = values.view("i8")

pandas/core/array_algos/masked_accumulations.py

@@ -60,10 +60,10 @@ def _cum_func(
             np.cumsum: 0,
             np.minimum.accumulate: dtype_info.max,
         }[func]
-    except KeyError:
+    except KeyError as err:
         raise NotImplementedError(
             f"No accumulation for {func} implemented on BaseMaskedArray"
-        )
+        ) from err
 
     values[mask] = fill_value
 

pandas/core/arrays/categorical.py

@@ -597,9 +597,9 @@ def astype(self, dtype: AstypeArg, copy: bool = True) -> ArrayLike:
             except (
                 TypeError,  # downstream error msg for CategoricalIndex is misleading
                 ValueError,
-            ):
+            ) as err:
                 msg = f"Cannot cast {self.categories.dtype} dtype to {dtype}"
-                raise ValueError(msg)
+                raise ValueError(msg) from err
 
             result = take_nd(
                 new_cats, ensure_platform_int(self._codes), fill_value=fill_value

pandas/core/arrays/datetimelike.py

@@ -524,9 +524,9 @@ def _validate_comparison_value(self, other):
             try:
                 # GH#18435 strings get a pass from tzawareness compat
                 other = self._scalar_from_string(other)
-            except (ValueError, IncompatibleFrequency):
+            except (ValueError, IncompatibleFrequency) as err:
                 # failed to parse as Timestamp/Timedelta/Period
-                raise InvalidComparison(other)
+                raise InvalidComparison(other) from err
 
         if isinstance(other, self._recognized_scalars) or other is NaT:
             other = self._scalar_type(other)
@@ -664,11 +664,11 @@ def _validate_listlike(self, value, allow_object: bool = False):
             if lib.infer_dtype(value) in self._infer_matches:
                 try:
                     value = type(self)._from_sequence(value)
-                except (ValueError, TypeError):
+                except (ValueError, TypeError) as err:
                     if allow_object:
                         return value
                     msg = self._validation_error_message(value, True)
-                    raise TypeError(msg)
+                    raise TypeError(msg) from err
 
         # Do type inference if necessary up front (after unpacking
         # NumpyExtensionArray)

pandas/core/arrays/period.py

@@ -1188,10 +1188,10 @@ def dt64arr_to_periodarr(
     freq = Period._maybe_convert_freq(freq)
     try:
         base = freq._period_dtype_code
-    except (AttributeError, TypeError):
+    except (AttributeError, TypeError) as err:
         # AttributeError: _period_dtype_code might not exist
         # TypeError: _period_dtype_code might intentionally raise
-        raise TypeError(f"{freq.name} is not supported as period frequency")
+        raise TypeError(f"{freq.name} is not supported as period frequency") from err
     return c_dt64arr_to_periodarr(data.view("i8"), base, tz, reso=reso), freq
 
 

pandas/core/dtypes/cast.py

@@ -1817,8 +1817,8 @@ def np_can_hold_element(dtype: np.dtype, element: Any) -> Any:
                     # TODO: general-case for EAs?
                     try:
                         casted = element.astype(dtype)
-                    except (ValueError, TypeError):
-                        raise LossySetitemError
+                    except (ValueError, TypeError) as err:
+                        raise LossySetitemError from err
                     # Check for cases of either
                     #  a) lossy overflow/rounding or
                     #  b) semantic changes like dt64->int64