wip

Author: TomAugspurger

pandas/io/pytables.py

@@ -183,7 +183,7 @@ class DuplicateWarning(Warning):
     "series": "SeriesFixed",
     "sparse_series": "SeriesFixed",
     "frame": "FrameFixed",
-    "sparse_frame": "FrameFixed",
+    "sparse_frame": "SparseFrameFixed",
 }
 
 # table class map
@@ -2722,6 +2722,18 @@ def write(self, obj, **kwargs):
 
     def read_array(self, key, start=None, stop=None):
         """ read an array for the specified node (off of group """
+        if (
+            self.pandas_type == "sparse_series" or "sp_index_length" in self.attrs
+        ) and key not in self.group:
+            # Compatibility for files written with pandas 0.25.1 and earlier.
+            if "sp_values" in self.group:
+                key = "sp_values"
+            dtype = "Sparse"
+            sp_index = self.read_index("sp_index".format(key))
+        else:
+            dtype = None
+            sp_index = None
+
         import tables
 
         node = getattr(self.group, key)
@@ -2732,7 +2744,7 @@ def read_array(self, key, start=None, stop=None):
         if isinstance(node, tables.VLArray):
             ret = node[0][start:stop]
         else:
-            dtype = getattr(attrs, "value_type", None)
+            dtype = getattr(attrs, "value_type", dtype)
             shape = getattr(attrs, "shape", None)
 
             if shape is not None:
@@ -2754,7 +2766,8 @@ def read_array(self, key, start=None, stop=None):
                     raise NotImplementedError(
                         "start and/or stop are not supported in fixed Sparse reading"
                     )
-                sp_index = self.read_index("{}_sp_index".format(key))
+                if sp_index is None:
+                    sp_index = self.read_index("{}_sp_index".format(key))
                 ret = SparseArray(
                     ret, sparse_index=sp_index, fill_value=self.attrs.fill_value
                 )
@@ -3079,10 +3092,10 @@ def shape(self):
         except (TypeError, AttributeError):
             return None
 
-    def read(self, **kwargs):
+    def read(self, key="values", **kwargs):
         kwargs = self.validate_read(kwargs)
         index = self.read_index("index", **kwargs)
-        values = self.read_array("values", **kwargs)
+        values = self.read_array(key, **kwargs)
         return Series(values, index=index, name=self.name)
 
     def write(self, obj, **kwargs):
@@ -3184,6 +3197,22 @@ class FrameFixed(BlockManagerFixed):
     obj_type = DataFrame
 
 
+class SparseFrameFixed(GenericFixed):
+    pandas_kind = "sparse_frame"
+    attributes = ["default_kind", "default_fill_value"]
+
+    def read(self, **kwargs):
+        kwargs = self.validate_read(kwargs)
+        columns = self.read_index("columns")
+        sdict = {}
+        for c in columns:
+            key = "sparse_series_{columns}".format(columns=c)
+            s = SeriesFixed(self.parent, getattr(self.group, key))
+            s.infer_axes()
+            sdict[c] = s.read(key=key)
+        return DataFrame(sdict)
+
+
 class Table(Fixed):
     """ represent a table:
           facilitate read/write of various types of tables

pandas/tests/io/pytables/test_pytables.py

@@ -4883,6 +4883,29 @@ def test_read_py2_hdf_file_in_py3(self, datapath):
             result = store["p"]
             assert_frame_equal(result, expected)
 
+    def test_read_legacy_sparse(self, datapath):
+        """
+        Generated with pandas 0.25.1 and
+
+        >>> s = pd.Series([1, None, 2, 3]).to_sparse()
+        >>> df = pd.DataFrame({"A": [1, None, 2, 3], "B": [1, 0, 0, 0]}).to_sparse()
+        >>> s.to_hdf("pandas/tests/io/data/legacy_hdf/legacy_sparse.h5", "series")
+        >>> df.to_hdf("pandas/tests/io/data/legacy_hdf/legacy_sparse.h5", "frame")
+        """
+        result = pd.read_hdf(
+            datapath("io", "data", "legacy_hdf", "legacy_sparse.h5"), "series"
+        )
+        expected = pd.Series(pd.SparseArray([1, None, 2, 3]))
+        tm.assert_series_equal(result, expected)
+
+        result = pd.read_hdf(
+            datapath("io", "data", "legacy_hdf", "legacy_sparse.h5"), "frame"
+        )
+        expected = pd.DataFrame(
+            {"A": pd.SparseArray([1, None, 2, 3]), "B": pd.SparseArray([1, 0, 0, 0])}
+        )
+        tm.assert_frame_equal(result, expected)
+
     @pytest.mark.parametrize("where", ["", (), (None,), [], [None]])
     def test_select_empty_where(self, where):
         # GH26610