Used jreback's solution to pandas-dev#10098 and rewrote the test to be more comprehensive

Author: jameshiebert

pandas/io/pytables.py

@@ -258,29 +258,6 @@ def to_hdf(path_or_buf, key, value, mode=None, complevel=None, complib=None,
            append=None, **kwargs):
     """ store this object, close it if we opened it """
 
-    # PyTables has some limitations that we need to check for
-    if kwargs.get('format', None) == 'table':
-        if value.columns.dtype.kind == 'S':
-            pass
-        elif value.columns.dtype.kind == 'O':
-            # PyTables doesn't support Unicode columns, but types 'O' can still
-            # contain unicode values so check for that
-            for col in value.columns:
-                try:
-                    col.encode('ascii').decode('ascii')
-                except UnicodeEncodeError:
-                    raise ValueError(
-                        "PyTables does not support UTF-8 column headers\n"
-                        "but header {} is at least not encodable to ASCII"
-                        .format(col)
-                    )
-        else:
-            raise ValueError(
-                "Storing data in HDF with PyTables requires that the column\n"
-                "types be of some string type or an object.\n"
-                "    Instead, your columns: {}\n"
-                "    are of type {}".format(value.columns, value.columns.dtype))
-
     if append:
         f = lambda store: store.append(key, value, **kwargs)
     else:
@@ -1559,6 +1536,12 @@ def maybe_set_size(self, min_itemsize=None, **kwargs):
                 self.typ = _tables(
                 ).StringCol(itemsize=min_itemsize, pos=self.pos)
 
+    def validate(self, handler, append, **kwargs):
+        self.validate_names()
+
+    def validate_names(self):
+        pass
+
     def validate_and_set(self, handler, append, **kwargs):
         self.set_table(handler.table)
         self.validate_col()
@@ -2104,6 +2087,10 @@ class DataIndexableCol(DataCol):
     """ represent a data column that can be indexed """
     is_data_indexable = True
 
+    def validate_names(self):
+        if not Index(self.values).is_object():
+            raise ValueError("cannot have non-object label DataIndexableCol")
+
     def get_atom_string(self, block, itemsize):
         return _tables().StringCol(itemsize=itemsize)
 
@@ -3776,6 +3763,9 @@ def write(self, obj, axes=None, append=False, complib=None,
                          min_itemsize=min_itemsize,
                          **kwargs)
 
+        for a in self.axes:
+            a.validate(self, append)
+
         if not self.is_exists:
 
             # create the table

pandas/io/tests/test_pytables.py

@@ -4617,19 +4617,35 @@ def test_preserve_timedeltaindex_type(self):
             store['df'] = df
             assert_frame_equal(store['df'], df)
 
-    def test_to_hdf_with_integer_column_names(self):
+    def test_to_hdf_with_object_column_names(self):
         # GH9057
-        df = DataFrame(columns=[5, 10], data=[[1, 0]])
+        # Writing HDF5 table format should only work for string-like
+        # column types
+        def column_index_data_frame(index):
+            return DataFrame(np.random.randn(10,2), columns=index(2))
+
+        types_should_fail = [ tm.makeIntIndex, tm.makeFloatIndex,
+                                tm.makeDateIndex, tm.makeTimedeltaIndex,
+                                tm.makePeriodIndex ]
+        types_should_run = [ tm.makeStringIndex, tm.makeCategoricalIndex ]
+
+        if compat.PY3:
+            types_should_run.append(tm.makeUnicodeIndex)
+        else:
+            types_should_fail.append(tm.makeUnicodeIndex)
 
-        with ensure_clean_path(self.path) as path:
-            self.assertRaises(ValueError, df.to_hdf, path, 'df', format='table', data_columns=True)
+        for index in types_should_fail:
+            df = column_index_data_frame(index)
+            with ensure_clean_path(self.path) as path, \
+                    self.assertRaises(ValueError,
+                    msg="cannot have non-object label DataIndexableCol"):
+                df.to_hdf(path, 'df', format='table', data_columns=True)
 
-    def test_to_hdf_with_unicode_column_names(self):
-        # GH9057
-        df = DataFrame(columns=[u('\u1234'), u('\u2345')], data=[[1, 0]])
+        for index in types_should_run:
+            df = DataFrame(np.random.randn(10, 2), columns=index(2))
+            with ensure_clean_path(self.path) as path:
+                df.to_hdf(path, 'df', format='table', data_columns=True)
 
-        with ensure_clean_path(self.path) as path:
-            self.assertRaises(ValueError, df.to_hdf, path, 'df', format='table', data_columns=True)
 
 def _test_sort(obj):
     if isinstance(obj, DataFrame):