CI: troubleshoot segfault

Author: jbrockmendel

pandas/core/arrays/datetimelike.py

@@ -1005,9 +1005,19 @@ def fillna(self, value=None, method=None, limit=None):
                 else:
                     func = missing.backfill_1d
 
-                values = self.copy()
+                values = self._ndarray
+                if not is_period_dtype(self.dtype):
+                    # For PeriodArray self._ndarray is i8, which gets copied
+                    #  by `func`.  Otherwise we need to make a copy manually
+                    # to avoid modifying `self` in-place.
+                    values = values.copy()
+
                 new_values = func(values, limit=limit, mask=mask)
-                new_values = self._from_backing_data(new_values)
+                if is_datetime64tz_dtype(self.dtype):
+                    # we need to pass int64 values to the constructor to avoid
+                    #  re-localizing incorrectly
+                    new_values = new_values.view("i8")
+                new_values = type(self)(new_values, dtype=self.dtype)
             else:
                 # fill with value
                 new_values = self.copy()

pandas/core/arrays/interval.py

@@ -20,6 +20,7 @@
     is_datetime64_any_dtype,
     is_float_dtype,
     is_integer_dtype,
+    is_interval,
     is_interval_dtype,
     is_list_like,
     is_object_dtype,
@@ -812,9 +813,7 @@ def take(self, indices, allow_fill=False, fill_value=None, axis=None, **kwargs):
 
         fill_left = fill_right = fill_value
         if allow_fill:
-            if (np.asarray(indices) == -1).any():
-                # We have excel tests that pass fill_value=True, xref GH#36466
-                fill_left, fill_right = self._validate_fill_value(fill_value)
+            fill_left, fill_right = self._validate_fill_value(fill_value)
 
         left_take = take(
             self.left, indices, allow_fill=allow_fill, fill_value=fill_left
@@ -825,33 +824,20 @@ def take(self, indices, allow_fill=False, fill_value=None, axis=None, **kwargs):
 
         return self._shallow_copy(left_take, right_take)
 
-    def _validate_listlike(self, value):
-        # list-like of intervals
-        try:
-            array = IntervalArray(value)
-            # TODO: self._check_closed_matches(array, name="value")
-            value_left, value_right = array.left, array.right
-        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) from err
-        return value_left, value_right
-
-    def _validate_scalar(self, value):
-        if isinstance(value, Interval):
-            self._check_closed_matches(value, name="value")
-            left, right = value.left, value.right
-        elif is_valid_nat_for_dtype(value, self.left.dtype):
-            # GH#18295
-            left = right = value
-        else:
-            raise ValueError(
-                "can only insert Interval objects and NA into an IntervalArray"
-            )
-        return left, right
-
     def _validate_fill_value(self, value):
-        return self._validate_scalar(value)
+        if is_interval(value):
+            self._check_closed_matches(value, name="fill_value")
+            fill_left, fill_right = value.left, value.right
+        elif not is_scalar(value) and notna(value):
+            msg = (
+                "'IntervalArray.fillna' only supports filling with a "
+                "'scalar pandas.Interval or NA'. "
+                f"Got a '{type(value).__name__}' instead."
+            )
+            raise ValueError(msg)
+        else:
+            fill_left = fill_right = self.left._na_value
+        return fill_left, fill_right
 
     def _validate_fillna_value(self, value):
         if not isinstance(value, Interval):
@@ -865,12 +851,26 @@ def _validate_fillna_value(self, value):
         return value.left, value.right
 
     def _validate_insert_value(self, value):
-        return self._validate_scalar(value)
+        if isinstance(value, Interval):
+            if value.closed != self.closed:
+                raise ValueError(
+                    "inserted item must be closed on the same side as the index"
+                )
+            left_insert = value.left
+            right_insert = value.right
+        elif is_valid_nat_for_dtype(value, self.left.dtype):
+            # GH#18295
+            left_insert = right_insert = value
+        else:
+            raise ValueError(
+                "can only insert Interval objects and NA into an IntervalIndex"
+            )
+        return left_insert, right_insert
 
     def _validate_setitem_value(self, value):
         needs_float_conversion = False
 
-        if is_valid_nat_for_dtype(value, self.left.dtype):
+        if is_scalar(value) and isna(value):
             # na value: need special casing to set directly on numpy arrays
             if is_integer_dtype(self.dtype.subtype):
                 # can't set NaN on a numpy integer array

pandas/core/dtypes/common.py

@@ -1215,10 +1215,6 @@ def needs_i8_conversion(arr_or_dtype) -> bool:
     """
     if arr_or_dtype is None:
         return False
-    if isinstance(arr_or_dtype, (np.dtype, ExtensionDtype)):
-        # fastpath
-        dtype = arr_or_dtype
-        return dtype.kind in ["m", "M"] or dtype.type is Period
     return (
         is_datetime_or_timedelta_dtype(arr_or_dtype)
         or is_datetime64tz_dtype(arr_or_dtype)

pandas/core/missing.py

@@ -7,15 +7,17 @@
 import numpy as np
 
 from pandas._libs import algos, lib
-from pandas._typing import DtypeObj
 from pandas.compat._optional import import_optional_dependency
 
 from pandas.core.dtypes.cast import infer_dtype_from_array
 from pandas.core.dtypes.common import (
     ensure_float64,
+    is_datetime64_dtype,
+    is_datetime64tz_dtype,
     is_integer_dtype,
     is_numeric_v_string_like,
     is_scalar,
+    is_timedelta64_dtype,
     needs_i8_conversion,
 )
 from pandas.core.dtypes.missing import isna
@@ -70,7 +72,7 @@ def mask_missing(arr, values_to_mask):
     return mask
 
 
-def clean_fill_method(method, allow_nearest: bool = False):
+def clean_fill_method(method, allow_nearest=False):
     # asfreq is compat for resampling
     if method in [None, "asfreq"]:
         return None
@@ -541,12 +543,7 @@ def _cubicspline_interpolate(xi, yi, x, axis=0, bc_type="not-a-knot", extrapolat
 
 
 def interpolate_2d(
-    values,
-    method="pad",
-    axis=0,
-    limit=None,
-    fill_value=None,
-    dtype: Optional[DtypeObj] = None,
+    values, method="pad", axis=0, limit=None, fill_value=None, dtype=None
 ):
     """
     Perform an actual interpolation of values, values will be make 2-d if
@@ -587,14 +584,18 @@ def interpolate_2d(
     return values
 
 
-def _cast_values_for_fillna(values, dtype: DtypeObj):
+def _cast_values_for_fillna(values, dtype):
     """
     Cast values to a dtype that algos.pad and algos.backfill can handle.
     """
     # TODO: for int-dtypes we make a copy, but for everything else this
     #  alters the values in-place.  Is this intentional?
 
-    if needs_i8_conversion(dtype):
+    if (
+        is_datetime64_dtype(dtype)
+        or is_datetime64tz_dtype(dtype)
+        or is_timedelta64_dtype(dtype)
+    ):
         values = values.view(np.int64)
 
     elif is_integer_dtype(values):
@@ -604,7 +605,7 @@ def _cast_values_for_fillna(values, dtype: DtypeObj):
     return values
 
 
-def _fillna_prep(values, mask=None, dtype: Optional[DtypeObj] = None):
+def _fillna_prep(values, mask=None, dtype=None):
     # boilerplate for pad_1d, backfill_1d, pad_2d, backfill_2d
     if dtype is None:
         dtype = values.dtype
@@ -619,19 +620,19 @@ def _fillna_prep(values, mask=None, dtype: Optional[DtypeObj] = None):
     return values, mask
 
 
-def pad_1d(values, limit=None, mask=None, dtype: Optional[DtypeObj] = None):
+def pad_1d(values, limit=None, mask=None, dtype=None):
     values, mask = _fillna_prep(values, mask, dtype)
     algos.pad_inplace(values, mask, limit=limit)
     return values
 
 
-def backfill_1d(values, limit=None, mask=None, dtype: Optional[DtypeObj] = None):
+def backfill_1d(values, limit=None, mask=None, dtype=None):
     values, mask = _fillna_prep(values, mask, dtype)
     algos.backfill_inplace(values, mask, limit=limit)
     return values
 
 
-def pad_2d(values, limit=None, mask=None, dtype: Optional[DtypeObj] = None):
+def pad_2d(values, limit=None, mask=None, dtype=None):
     values, mask = _fillna_prep(values, mask, dtype)
 
     if np.all(values.shape):
@@ -642,7 +643,7 @@ def pad_2d(values, limit=None, mask=None, dtype: Optional[DtypeObj] = None):
     return values
 
 
-def backfill_2d(values, limit=None, mask=None, dtype: Optional[DtypeObj] = None):
+def backfill_2d(values, limit=None, mask=None, dtype=None):
     values, mask = _fillna_prep(values, mask, dtype)
 
     if np.all(values.shape):