CLN: address xfails (#46287)

Author: jbrockmendel

pandas/core/arrays/_mixins.py

@@ -222,10 +222,8 @@ def _concat_same_type(
             raise ValueError("to_concat must have the same dtype (tz)", dtypes)
 
         new_values = [x._ndarray for x in to_concat]
-        new_values = np.concatenate(new_values, axis=axis)
-        # error: Argument 1 to "_from_backing_data" of "NDArrayBackedExtensionArray" has
-        # incompatible type "List[ndarray]"; expected "ndarray"
-        return to_concat[0]._from_backing_data(new_values)  # type: ignore[arg-type]
+        new_arr = np.concatenate(new_values, axis=axis)
+        return to_concat[0]._from_backing_data(new_arr)
 
     @doc(ExtensionArray.searchsorted)
     def searchsorted(

pandas/core/arrays/datetimelike.py

@@ -1095,7 +1095,7 @@ def _sub_datetimelike_scalar(self, other):
 
     _sub_datetime_arraylike = _sub_datetimelike_scalar
 
-    def _sub_period(self, other):
+    def _sub_period(self, other: Period):
         # Overridden by PeriodArray
         raise TypeError(f"cannot subtract Period from a {type(self).__name__}")
 

pandas/core/arrays/period.py

@@ -707,11 +707,7 @@ def _cast_quantile_result(self, res_values: np.ndarray) -> np.ndarray:
     # ------------------------------------------------------------------
     # Arithmetic Methods
 
-    def _sub_datelike(self, other):
-        assert other is not NaT
-        return NotImplemented
-
-    def _sub_period(self, other):
+    def _sub_period(self, other: Period):
         # If the operation is well-defined, we return an object-Index
         # of DateOffsets.  Null entries are filled with pd.NaT
         self._check_compatible_with(other)

pandas/core/arrays/sparse/array.py

@@ -838,10 +838,10 @@ def _first_fill_value_loc(self):
         return np.searchsorted(diff, 2) + 1
 
     def unique(self: SparseArrayT) -> SparseArrayT:
-        uniques = list(algos.unique(self.sp_values))
+        uniques = algos.unique(self.sp_values)
         fill_loc = self._first_fill_value_loc()
         if fill_loc >= 0:
-            uniques.insert(fill_loc, self.fill_value)
+            uniques = np.insert(uniques, fill_loc, self.fill_value)
         return type(self)._from_sequence(uniques, dtype=self.dtype)
 
     def _values_for_factorize(self):
@@ -1351,8 +1351,6 @@ def to_dense(self) -> np.ndarray:
         """
         return np.asarray(self, dtype=self.sp_values.dtype)
 
-    _internal_get_values = to_dense
-
     def _where(self, mask, value):
         # NB: may not preserve dtype, e.g. result may be Sparse[float64]
         #  while self is Sparse[int64]

pandas/core/arrays/sparse/dtype.py

@@ -354,7 +354,9 @@ def update_dtype(self, dtype) -> SparseDtype:
             if not isinstance(dtype, np.dtype):
                 raise TypeError("sparse arrays of extension dtypes not supported")
 
-            fill_value = astype_nansafe(np.array(self.fill_value), dtype).item()
+            fvarr = astype_nansafe(np.array(self.fill_value), dtype)
+            # NB: not fv_0d.item(), as that casts dt64->int
+            fill_value = fvarr[0]
             dtype = cls(dtype, fill_value=fill_value)
 
         return dtype

pandas/core/dtypes/cast.py

@@ -379,6 +379,13 @@ def trans(x):
         if np.allclose(new_result, result, equal_nan=True, rtol=0.0, atol=atol):
             return new_result
 
+    elif dtype.kind == result.dtype.kind == "c":
+        new_result = result.astype(dtype)
+
+        if array_equivalent(new_result, result):
+            # TODO: use tolerance like we do for float?
+            return new_result
+
     return result
 
 

pandas/tests/arrays/sparse/test_array.py

@@ -127,10 +127,6 @@ def test_dense_repr(self, vals, fill_value):
         res = arr.to_dense()
         tm.assert_numpy_array_equal(res, vals)
 
-        res2 = arr._internal_get_values()
-
-        tm.assert_numpy_array_equal(res2, vals)
-
     @pytest.mark.parametrize("fix", ["arr", "zarr"])
     def test_pickle(self, fix, request):
         obj = request.getfixturevalue(fix)

pandas/tests/arrays/sparse/test_astype.py

@@ -85,7 +85,6 @@ def test_astype_all(self, any_real_numpy_dtype):
                     np.array([0, 1], dtype="datetime64[ns]"),
                     dtype=SparseDtype("datetime64[ns]", Timestamp("1970")),
                 ),
-                marks=[pytest.mark.xfail(reason="NumPy-7619")],
             ),
             (
                 SparseArray([0, 1, 10]),

pandas/tests/extension/base/methods.py

@@ -27,7 +27,7 @@ def test_value_counts_default_dropna(self, data):
     def test_value_counts(self, all_data, dropna):
         all_data = all_data[:10]
         if dropna:
-            other = np.array(all_data[~all_data.isna()])
+            other = all_data[~all_data.isna()]
         else:
             other = all_data
 
@@ -50,6 +50,10 @@ def test_value_counts_with_normalize(self, data):
             expected = pd.Series(0.0, index=result.index)
             expected[result > 0] = 1 / len(values)
 
+        if isinstance(data.dtype, pd.core.dtypes.dtypes.BaseMaskedDtype):
+            # TODO(GH#44692): avoid special-casing
+            expected = expected.astype("Float64")
+
         self.assert_series_equal(result, expected)
 
     def test_count(self, data_missing):

pandas/tests/extension/test_boolean.py

@@ -226,14 +226,6 @@ def test_searchsorted(self, data_for_sorting, as_series):
         sorter = np.array([1, 0])
         assert data_for_sorting.searchsorted(a, sorter=sorter) == 0
 
-    @pytest.mark.xfail(reason="uses nullable integer")
-    def test_value_counts(self, all_data, dropna):
-        return super().test_value_counts(all_data, dropna)
-
-    @pytest.mark.xfail(reason="uses nullable integer")
-    def test_value_counts_with_normalize(self, data):
-        super().test_value_counts_with_normalize(data)
-
     def test_argmin_argmax(self, data_for_sorting, data_missing_for_sorting):
         # override because there are only 2 unique values