Fix exception causes all over the code (#32322)

Author: cool-RR

doc/make.py

@@ -83,8 +83,8 @@ def _process_single_doc(self, single_doc):
                 obj = pandas  # noqa: F821
                 for name in single_doc.split("."):
                     obj = getattr(obj, name)
-            except AttributeError:
-                raise ImportError(f"Could not import {single_doc}")
+            except AttributeError as err:
+                raise ImportError(f"Could not import {single_doc}") from err
             else:
                 return single_doc[len("pandas.") :]
         else:

pandas/__init__.py

@@ -37,7 +37,7 @@
         f"C extension: {module} not built. If you want to import "
         "pandas from the source directory, you may need to run "
         "'python setup.py build_ext --inplace --force' to build the C extensions first."
-    )
+    ) from e
 
 from pandas._config import (
     get_option,
@@ -290,8 +290,8 @@ def __getattr__(self, item):
 
             try:
                 return getattr(self.np, item)
-            except AttributeError:
-                raise AttributeError(f"module numpy has no attribute {item}")
+            except AttributeError as err:
+                raise AttributeError(f"module numpy has no attribute {item}") from err
 
     np = __numpy()
 
@@ -306,8 +306,10 @@ def __getattr__(cls, item):
 
             try:
                 return getattr(cls.datetime, item)
-            except AttributeError:
-                raise AttributeError(f"module datetime has no attribute {item}")
+            except AttributeError as err:
+                raise AttributeError(
+                    f"module datetime has no attribute {item}"
+                ) from err
 
         def __instancecheck__(cls, other):
             return isinstance(other, cls.datetime)

pandas/_config/config.py

@@ -213,8 +213,8 @@ def __getattr__(self, key: str):
         prefix += key
         try:
             v = object.__getattribute__(self, "d")[key]
-        except KeyError:
-            raise OptionError("No such option")
+        except KeyError as err:
+            raise OptionError("No such option") from err
         if isinstance(v, dict):
             return DictWrapper(v, prefix)
         else:

pandas/core/algorithms.py

@@ -686,8 +686,8 @@ def value_counts(
         values = Series(values)
         try:
             ii = cut(values, bins, include_lowest=True)
-        except TypeError:
-            raise TypeError("bins argument only works with numeric data.")
+        except TypeError as err:
+            raise TypeError("bins argument only works with numeric data.") from err
 
         # count, remove nulls (from the index), and but the bins
         result = ii.value_counts(dropna=dropna)

pandas/core/arrays/_ranges.py

@@ -121,8 +121,8 @@ def _generate_range_overflow_safe(
         #  we cannot salvage the operation by recursing, so raise
         try:
             addend = np.uint64(periods) * np.uint64(np.abs(stride))
-        except FloatingPointError:
-            raise OutOfBoundsDatetime(msg)
+        except FloatingPointError as err:
+            raise OutOfBoundsDatetime(msg) from err
 
     if np.abs(addend) <= i64max:
         # relatively easy case without casting concerns

pandas/core/arrays/categorical.py

@@ -350,7 +350,7 @@ def __init__(
         if dtype.categories is None:
             try:
                 codes, categories = factorize(values, sort=True)
-            except TypeError:
+            except TypeError as err:
                 codes, categories = factorize(values, sort=False)
                 if dtype.ordered:
                     # raise, as we don't have a sortable data structure and so
@@ -359,13 +359,13 @@ def __init__(
                         "'values' is not ordered, please "
                         "explicitly specify the categories order "
                         "by passing in a categories argument."
-                    )
-            except ValueError:
+                    ) from err
+            except ValueError as err:
 
                 # FIXME
                 raise NotImplementedError(
                     "> 1 ndim Categorical are not supported at this time"
-                )
+                ) from err
 
             # we're inferring from values
             dtype = CategoricalDtype(categories, dtype.ordered)

pandas/core/arrays/datetimes.py

@@ -2080,11 +2080,11 @@ def _infer_tz_from_endpoints(start, end, tz):
     """
     try:
         inferred_tz = timezones.infer_tzinfo(start, end)
-    except AssertionError:
+    except AssertionError as err:
         # infer_tzinfo raises AssertionError if passed mismatched timezones
         raise TypeError(
             "Start and end cannot both be tz-aware with different timezones"
-        )
+        ) from err
 
     inferred_tz = timezones.maybe_get_tz(inferred_tz)
     tz = timezones.maybe_get_tz(tz)

pandas/core/arrays/integer.py

@@ -154,15 +154,15 @@ def safe_cast(values, dtype, copy: bool):
     """
     try:
         return values.astype(dtype, casting="safe", copy=copy)
-    except TypeError:
+    except TypeError as err:
 
         casted = values.astype(dtype, copy=copy)
         if (casted == values).all():
             return casted
 
         raise TypeError(
             f"cannot safely cast non-equivalent {values.dtype} to {np.dtype(dtype)}"
-        )
+        ) from err
 
 
 def coerce_to_array(
@@ -199,8 +199,8 @@ def coerce_to_array(
         if not issubclass(type(dtype), _IntegerDtype):
             try:
                 dtype = _dtypes[str(np.dtype(dtype))]
-            except KeyError:
-                raise ValueError(f"invalid dtype specified {dtype}")
+            except KeyError as err:
+                raise ValueError(f"invalid dtype specified {dtype}") from err
 
     if isinstance(values, IntegerArray):
         values, mask = values._data, values._mask

pandas/core/arrays/interval.py

@@ -448,12 +448,12 @@ def from_tuples(cls, data, closed="right", copy=False, dtype=None):
                 try:
                     # need list of length 2 tuples, e.g. [(0, 1), (1, 2), ...]
                     lhs, rhs = d
-                except ValueError:
+                except ValueError as err:
                     msg = f"{name}.from_tuples requires tuples of length 2, got {d}"
-                    raise ValueError(msg)
-                except TypeError:
+                    raise ValueError(msg) from err
+                except TypeError as err:
                     msg = f"{name}.from_tuples received an invalid item, {d}"
-                    raise TypeError(msg)
+                    raise TypeError(msg) from err
             left.append(lhs)
             right.append(rhs)
 
@@ -538,10 +538,10 @@ def __setitem__(self, key, value):
             try:
                 array = IntervalArray(value)
                 value_left, value_right = array.left, array.right
-            except TypeError:
+            except TypeError as err:
                 # wrong type: not interval or NA
                 msg = f"'value' should be an interval type, got {type(value)} instead."
-                raise TypeError(msg)
+                raise TypeError(msg) from err
 
         key = check_array_indexer(self, key)
         # Need to ensure that left and right are updated atomically, so we're
@@ -688,20 +688,20 @@ def astype(self, dtype, copy=True):
             try:
                 new_left = self.left.astype(dtype.subtype)
                 new_right = self.right.astype(dtype.subtype)
-            except TypeError:
+            except TypeError as err:
                 msg = (
                     f"Cannot convert {self.dtype} to {dtype}; subtypes are incompatible"
                 )
-                raise TypeError(msg)
+                raise TypeError(msg) from err
             return self._shallow_copy(new_left, new_right)
         elif is_categorical_dtype(dtype):
             return Categorical(np.asarray(self))
         # TODO: This try/except will be repeated.
         try:
             return np.asarray(self).astype(dtype, copy=copy)
-        except (TypeError, ValueError):
+        except (TypeError, ValueError) as err:
             msg = f"Cannot cast {type(self).__name__} to dtype {dtype}"
-            raise TypeError(msg)
+            raise TypeError(msg) from err
 
     @classmethod
     def _concat_same_type(cls, to_concat):
@@ -1020,13 +1020,13 @@ def length(self):
         """
         try:
             return self.right - self.left
-        except TypeError:
+        except TypeError as err:
             # length not defined for some types, e.g. string
             msg = (
                 "IntervalArray contains Intervals without defined length, "
                 "e.g. Intervals with string endpoints"
             )
-            raise TypeError(msg)
+            raise TypeError(msg) from err
 
     @property
     def mid(self):
@@ -1100,11 +1100,11 @@ def __arrow_array__(self, type=None):
 
         try:
             subtype = pyarrow.from_numpy_dtype(self.dtype.subtype)
-        except TypeError:
+        except TypeError as err:
             raise TypeError(
                 f"Conversion to arrow with subtype '{self.dtype.subtype}' "
                 "is not supported"
-            )
+            ) from err
         interval_type = ArrowIntervalType(subtype, self.closed)
         storage_array = pyarrow.StructArray.from_arrays(
             [

pandas/core/arrays/sparse/dtype.py

@@ -217,8 +217,8 @@ def construct_from_string(cls, string: str) -> "SparseDtype":
         if string.startswith("Sparse"):
             try:
                 sub_type, has_fill_value = cls._parse_subtype(string)
-            except ValueError:
-                raise TypeError(msg)
+            except ValueError as err:
+                raise TypeError(msg) from err
             else:
                 result = SparseDtype(sub_type)
                 msg = (