SparseArray is an ExtensionArray

pandas/core/sparse/array.py

@@ -763,13 +763,28 @@ def _concat_same_type(cls, to_concat):
  return cls(data, sparse_index=sp_index, fill_value=fill_value)
 
  def astype(self, dtype=None, copy=True):
- # I don't know what to do here...
- # We have a few things to potentially change
- # 1. SparseArray -> another dtype (dense, extension, etc.)
- # 2. self.sp_values.dtype
- # 3. the fill value
- # 2 & 3 can be done by passing a `SparseDtype()`, but changing
- # the fill_value changes the *values*.
+ """
+ Change the dtype of a SparseArray.
+
+ Parameters
+ ----------
+ dtype : np.dtype or ExtensionDtype
+ For SparseDtype, this can change two things
+
+ 1. The dtype of ``self.sp_values`` will be set to
+ ``dtype.subdtype``
+ 2. The ``fill_value`` will be set to ``dtype.fill_value``.
+
+ For other dtypes, this will convert to a dense array
+ with `dtype` type.
+
+ copy : bool, default True
+ Whether to ensure a copy is made, even if not necessary.
+
+ Returns
+ -------
+ array : ExtensionArray or ndarray.
+ """
  dtype = pandas_dtype(dtype)
 
  if isinstance(dtype, SparseDtype):
@@ -780,7 +795,8 @@ def astype(self, dtype=None, copy=True):
  if sp_values is self.sp_values and copy:
  sp_values = sp_values.copy()
 
- return self._simple_new(sp_values.copy(),
+
+ return self._simple_new(sp_values,
  self.sp_index,
  dtype)
  else:

pandas/tests/sparse/test_array.py

@@ -400,30 +400,39 @@ def test_constructor_float32(self):
  tm.assert_numpy_array_equal(dense, data)
 
  def test_astype(self):
- res = self.arr.astype('Sparse[f8]')
- res.sp_values[:3] = 27
- assert not (self.arr.sp_values[:3] == 27).any()
-
- result = self.arr.astype('Sparse[i8]')
- assert result.dtype == SparseDtype("int8", np.nan)
+ # float -> float
+ arr = SparseArray([None, None, 0, 2])
+ result = arr.astype("Sparse[float32]")
+ expected = SparseArray([None, None, 0, 2], dtype=np.dtype('float32'))
+ tm.assert_sp_array_equal(result, expected)
 
- msg = ("unable to coerce current fill_value nan "
- "to Sparse\\[int64\\] dtype")
+ # float -> float, different fill
+ # This is strange, since some "fill_na" values are in the spares values.
+ # That probably complicates everything else.
+ dtype = SparseDtype("float64", fill_value=0)
+ result = arr.astype(dtype)
+ expected = SparseArray._simple_new(np.array([0., 2.], dtype=dtype.subdtype),
+ IntIndex(4, [2, 3]),
+ dtype)
+ tm.assert_sp_array_equal(result, expected)
 
- arr = SparseArray([0, np.nan, 0, 1])
- with tm.assert_raises_regex(ValueError, msg):
- arr.astype('Sparse[i8]')
+ dtype = SparseDtype("int64", 0)
+ result = arr.astype(dtype)
+ expected = SparseArray._simple_new(np.array([0, 2], dtype=np.int64),
+ IntIndex(4, [2, 3]),
+ dtype)
+ tm.assert_sp_array_equal(result, expected)
 
  arr = SparseArray([0, np.nan, 0, 1], fill_value=0)
- msg = 'Cannot convert non-finite values \\(NA or inf\\) to integer'
- with tm.assert_raises_regex(ValueError, msg):
- raise pytest.xfail("https://github.com/pandas-dev/"
- "pandas/issues/22216")
- # arr.astype('i8')
+ with tm.assert_raises_regex(ValueError, 'NA'):
+ arr.astype('Sparse[i8]')
 
+ @pytest.mark.xfail(reason="Different semantics", strict=True)
  def test_astype_all(self, any_real_dtype):
+ # This is why I worry about putting in on the type
  vals = np.array([1, 2, 3])
  arr = SparseArray(vals, fill_value=1)
+ # Expected here is `[nan, 2, 3]` since the fill value changes.
  typ = np.dtype(any_real_dtype).type
 
  res = arr.astype(SparseDtype(typ))