TST: HDFStore with compression test coverage

Author: wesm

pandas/io/parsers.py

@@ -212,14 +212,7 @@ def _convert_to_ndarrays(dct):
             values = np.array(values, dtype=float)
         except Exception:
             values = np.array(values, dtype=object)
-
-        try:
-            values = _maybe_convert_int(values)
-        except ValueError:
-            pass
-
-        result[c] = values
-
+        result[c] = _maybe_convert_int(values)
     return result
 
 def _try_parse_dates(values, parser=None):

pandas/io/pytables.py

@@ -98,7 +98,7 @@ class HDFStore(object):
     >>> bar = store['foo']   # retrieve
     >>> store.close()
     """
-    def __init__(self, path, mode='a', complevel=0, complib=None,
+    def __init__(self, path, mode='a', complevel=None, complib=None,
                  fletcher32=False):
         try:
             import tables as _
@@ -162,7 +162,9 @@ def open(self, mode='a', warn=True):
         if self.handle is not None and self.handle.isopen:
             self.handle.close()
 
-        if self.complevel > 0 and self.complib is not None:
+        if self.complib is not None:
+            if self.complevel is None:
+                self.complevel = 9
             self.filters = _tables().Filters(self.complevel,
                                              self.complib,
                                              fletcher32=self.fletcher32)
@@ -442,8 +444,8 @@ def _write_array(self, group, key, value):
             if atom is not None:
                 # create an empty chunked array and fill it from value
                 ca = self.handle.createCArray(group, key, atom,
-                                                value.shape,
-                                                filters=self.filters)
+                                              value.shape,
+                                              filters=self.filters)
                 ca[:] = value
                 return
 
@@ -480,9 +482,10 @@ def _write_table(self, group, items=None, index=None, columns=None,
                 complevel = self.complevel
                 if complevel is None:
                     complevel = 9
-                options['filters'] = _tables().Filters(complevel=complevel,
-                                                       complib=compression,
-                                                       fletcher32=self.fletcher32)
+                filters = _tables().Filters(complevel=complevel,
+                                            complib=compression,
+                                            fletcher32=self.fletcher32)
+                options['filters'] = filters
             elif self.filters is not None:
                 options['filters'] = self.filters
 

pandas/io/tests/test_pytables.py

@@ -169,6 +169,12 @@ def test_frame(self):
         self._check_roundtrip(tdf, tm.assert_frame_equal,
                               compression=True)
 
+        # not consolidated
+        df['foo'] = np.random.randn(len(df))
+        self.store['df'] = df
+        recons = self.store['df']
+        self.assert_(recons._data.is_consolidated())
+
     def test_store_mixed(self):
         def _make_one():
             df = tm.makeDataFrame()
@@ -200,6 +206,16 @@ def _make_one():
         self._check_roundtrip(df1['bool1'], tm.assert_series_equal)
         self._check_roundtrip(df1['int1'], tm.assert_series_equal)
 
+        # try with compression
+        self._check_roundtrip(df1['obj1'], tm.assert_series_equal,
+                              compression=True)
+        self._check_roundtrip(df1['bool1'], tm.assert_series_equal,
+                              compression=True)
+        self._check_roundtrip(df1['int1'], tm.assert_series_equal,
+                              compression=True)
+        self._check_roundtrip(df1, tm.assert_frame_equal,
+                              compression=True)
+
     def test_wide(self):
         wp = tm.makeWidePanel()
         self._check_roundtrip(wp, tm.assert_panel_equal)
@@ -293,7 +309,6 @@ def test_select_filter_corner(self):
     def _check_roundtrip(self, obj, comparator, compression=False):
         options = {}
         if compression:
-            options['complevel'] = 9
             options['complib'] = 'blosc'
 
         store = HDFStore(self.scratchpath, 'w', **options)
@@ -308,7 +323,6 @@ def _check_roundtrip(self, obj, comparator, compression=False):
     def _check_roundtrip_table(self, obj, comparator, compression=False):
         options = {}
         if compression:
-            options['complevel'] = 9
             options['complib'] = 'blosc'
 
         store = HDFStore(self.scratchpath, 'w', **options)