updates

Author: TomAugspurger

doc/source/user_guide/sparse.rst

@@ -263,15 +263,11 @@ have no replacement.
 Interaction with scipy.sparse
 -----------------------------
 
-SparseDataFrame
-~~~~~~~~~~~~~~~
+Use :meth:`DataFrame.sparse.from_coo` to create a ``DataFrame`` with sparse values from a sparse matrix.
 
-.. versionadded:: 0.20.0
-
-Pandas supports creating sparse dataframes directly from ``scipy.sparse`` matrices.
+.. versionadded:: 0.25.0
 
 .. ipython:: python
-   :okwarning:
 
    from scipy.sparse import csr_matrix
 
@@ -281,25 +277,22 @@ Pandas supports creating sparse dataframes directly from ``scipy.sparse`` matric
    sp_arr = csr_matrix(arr)
    sp_arr
 
-   sdf = pd.SparseDataFrame(sp_arr)
-   sdf
+   sdf = pd.DataFrame.sparse.from_spmatrix(sp_arr)
+   sdf.head()
+   sdf.dtypes
 
 All sparse formats are supported, but matrices that are not in :mod:`COOrdinate <scipy.sparse>` format will be converted, copying data as needed.
-To convert a ``SparseDataFrame`` back to sparse SciPy matrix in COO format, you can use the :meth:`SparseDataFrame.to_coo` method:
+To convert back to sparse SciPy matrix in COO format, you can use the :meth:`DataFrame.sparse.to_coo` method:
 
 .. ipython:: python
 
-   sdf.to_coo()
+   sdf.sparse.to_coo()
 
-SparseSeries
-~~~~~~~~~~~~
-
-A :meth:`SparseSeries.to_coo` method is implemented for transforming a ``SparseSeries`` indexed by a ``MultiIndex`` to a ``scipy.sparse.coo_matrix``.
+:meth:`Series.sparse.to_coo` is implemented for transforming a ``Series`` with sparse values indexed by a ``MultiIndex`` to a ``scipy.sparse.coo_matrix``.
 
 The method requires a ``MultiIndex`` with two or more levels.
 
 .. ipython:: python
-   :okwarning:
 
    s = pd.Series([3.0, np.nan, 1.0, 3.0, np.nan, np.nan])
    s.index = pd.MultiIndex.from_tuples([(1, 2, 'a', 0),
@@ -309,19 +302,17 @@ The method requires a ``MultiIndex`` with two or more levels.
                                         (2, 1, 'b', 0),
                                         (2, 1, 'b', 1)],
                                        names=['A', 'B', 'C', 'D'])
-
    s
-   # SparseSeries
-   ss = s.to_sparse()
+   ss = s.astype('Sparse')
    ss
 
-In the example below, we transform the ``SparseSeries`` to a sparse representation of a 2-d array by specifying that the first and second ``MultiIndex`` levels define labels for the rows and the third and fourth levels define labels for the columns. We also specify that the column and row labels should be sorted in the final sparse representation.
+In the example below, we transform the ``Series`` to a sparse representation of a 2-d array by specifying that the first and second ``MultiIndex`` levels define labels for the rows and the third and fourth levels define labels for the columns. We also specify that the column and row labels should be sorted in the final sparse representation.
 
 .. ipython:: python
 
-   A, rows, columns = ss.to_coo(row_levels=['A', 'B'],
-                                column_levels=['C', 'D'],
-                                sort_labels=True)
+   A, rows, columns = ss.sparse.to_coo(row_levels=['A', 'B'],
+                                       column_levels=['C', 'D'],
+                                       sort_labels=True)
 
    A
    A.todense()
@@ -332,16 +323,16 @@ Specifying different row and column labels (and not sorting them) yields a diffe
 
 .. ipython:: python
 
-   A, rows, columns = ss.to_coo(row_levels=['A', 'B', 'C'],
-                                column_levels=['D'],
-                                sort_labels=False)
+   A, rows, columns = ss.sparse.to_coo(row_levels=['A', 'B', 'C'],
+                                       column_levels=['D'],
+                                       sort_labels=False)
 
    A
    A.todense()
    rows
    columns
 
-A convenience method :meth:`SparseSeries.from_coo` is implemented for creating a ``SparseSeries`` from a ``scipy.sparse.coo_matrix``.
+A convenience method :meth:`Series.sparse.from_coo` is implemented for creating a ``Series`` with sparse values from a ``scipy.sparse.coo_matrix``.
 
 .. ipython:: python
 
@@ -351,23 +342,28 @@ A convenience method :meth:`SparseSeries.from_coo` is implemented for creating a
    A
    A.todense()
 
-The default behaviour (with ``dense_index=False``) simply returns a ``SparseSeries`` containing
+The default behaviour (with ``dense_index=False``) simply returns a ``Series`` containing
 only the non-null entries.
 
 .. ipython:: python
-   :okwarning:
 
-   ss = pd.SparseSeries.from_coo(A)
+   ss = pd.Series.sparse.from_coo(A)
    ss
 
 Specifying ``dense_index=True`` will result in an index that is the Cartesian product of the
 row and columns coordinates of the matrix. Note that this will consume a significant amount of memory
 (relative to ``dense_index=False``) if the sparse matrix is large (and sparse) enough.
 
 .. ipython:: python
-   :okwarning:
 
-   ss_dense = pd.SparseSeries.from_coo(A, dense_index=True)
+   ss_dense = pd.Series.sparse.from_coo(A, dense_index=True)
    ss_dense
 
 
+.. _sparse.subclasses:
+
+Sparse Subclasses
+-----------------
+
+The :class:`SparseSeries` and :class:`SparseDataFrame` classes are deprecated. Visit their
+API pages for usage.

pandas/core/arrays/sparse.py

@@ -2033,7 +2033,8 @@ def from_coo(cls, A, dense_index=False):
         from pandas.core.sparse.scipy_sparse import _coo_to_sparse_series
         from pandas import Series
 
-        result = _coo_to_sparse_series(A, dense_index=dense_index)
+        result = _coo_to_sparse_series(A, dense_index=dense_index,
+                                       sparse_series=False)
         # SparseSeries -> Series[sparse]
         result = Series(result.values, index=result.index, copy=False)
 

pandas/core/series.py

@@ -1589,7 +1589,6 @@ def to_sparse(self, kind='block', fill_value=None):
         SparseSeries
             Sparse representation of the Series.
         """
-        # TODO: deprecate
         from pandas.core.sparse.series import SparseSeries
 
         values = SparseArray(self, kind=kind, fill_value=fill_value)

pandas/core/sparse/scipy_sparse.py

@@ -116,14 +116,19 @@ def _sparse_series_to_coo(ss, row_levels=(0, ), column_levels=(1, ),
     return sparse_matrix, rows, columns
 
 
-def _coo_to_sparse_series(A, dense_index=False):
+def _coo_to_sparse_series(A, dense_index=False, sparse_series=True):
     """
     Convert a scipy.sparse.coo_matrix to a SparseSeries.
     Use the defaults given in the SparseSeries constructor.
     """
+    from pandas import SparseDtype
+
     s = Series(A.data, MultiIndex.from_arrays((A.row, A.col)))
     s = s.sort_index()
-    s = s.to_sparse()  # TODO: specify kind?
+    if sparse_series:
+        s = s.to_sparse()  # TODO: specify kind?
+    else:
+        s = s.astype(SparseDtype(s.dtype))
     if dense_index:
         # is there a better constructor method to use here?
         i = range(A.shape[0])

pandas/tests/arrays/sparse/test_accessor.py

@@ -101,3 +101,21 @@ def test_density(self):
         res = df.sparse.density
         expected = 0.75
         assert res == expected
+
+    @pytest.mark.parametrize("dtype", ['int64', 'float64'])
+    @pytest.mark.parametrize("dense_index", [True, False])
+    @td.skip_if_no_scipy
+    def test_series_from_coo(self, dtype, dense_index):
+        import scipy.sparse
+
+        A = scipy.sparse.eye(3, format='coo', dtype=dtype)
+        result = pd.Series.sparse.from_coo(A, dense_index=dense_index)
+        index = pd.MultiIndex.from_tuples([(0, 0), (1, 1), (2, 2)])
+        expected = pd.Series(pd.SparseArray(np.array([1, 1, 1], dtype=dtype)),
+                             index=index)
+        if dense_index:
+            expected = expected.reindex(
+                pd.MultiIndex.from_product(index.levels)
+            )
+
+        tm.assert_series_equal(result, expected)