COMPAT: pytables 3.0.0 function name compat

Author: jreback

ci/requirements-2.7_NUMPY_DEV_master.txt

@@ -1,3 +1,5 @@
 python-dateutil
 pytz
 cython==0.19.1
+numexpr==2.4
+tables==3.1.0

pandas/io/pytables.py

@@ -497,7 +497,7 @@ def open(self, mode='a', **kwargs):
         Parameters
         ----------
         mode : {'a', 'w', 'r', 'r+'}, default 'a'
-            See HDFStore docstring or tables.openFile for info about modes
+            See HDFStore docstring or tables.open_file for info about modes
         """
         tables = _tables()
 
@@ -530,11 +530,11 @@ def open(self, mode='a', **kwargs):
                                               fletcher32=self._fletcher32)
 
         try:
-            self._handle = tables.openFile(self._path, self._mode, **kwargs)
+            self._handle = tables.open_file(self._path, self._mode, **kwargs)
         except (IOError) as e:  # pragma: no cover
             if 'can not be written' in str(e):
                 print('Opening %s in read-only mode' % self._path)
-                self._handle = tables.openFile(self._path, 'r', **kwargs)
+                self._handle = tables.open_file(self._path, 'r', **kwargs)
             else:
                 raise
 
@@ -549,7 +549,7 @@ def open(self, mode='a', **kwargs):
                                "and not open the same file multiple times at once,\n"
                                "upgrade the HDF5 version, or downgrade to PyTables 3.0.0 which allows\n"
                                "files to be opened multiple times at once\n".format(version=tables.__version__,
-                                                                                    hdf_version=tables.getHDF5Version()))
+                                                                                    hdf_version=tables.get_hdf5_version()))
 
             raise e
 
@@ -1023,7 +1023,7 @@ def groups(self):
         _tables()
         self._check_if_open()
         return [
-            g for g in self._handle.walkNodes()
+            g for g in self._handle.walk_nodes()
             if (getattr(g._v_attrs, 'pandas_type', None) or
                 getattr(g, 'table', None) or
                 (isinstance(g, _table_mod.table.Table) and
@@ -1036,7 +1036,7 @@ def get_node(self, key):
         try:
             if not key.startswith('/'):
                 key = '/' + key
-            return self._handle.getNode(self.root, key)
+            return self._handle.get_node(self.root, key)
         except:
             return None
 
@@ -1221,7 +1221,7 @@ def _write_to_group(self, key, value, format, index=True, append=False,
 
         # remove the node if we are not appending
         if group is not None and not append:
-            self._handle.removeNode(group, recursive=True)
+            self._handle.remove_node(group, recursive=True)
             group = None
 
         # we don't want to store a table node at all if are object is 0-len
@@ -1243,7 +1243,7 @@ def _write_to_group(self, key, value, format, index=True, append=False,
                 new_path += p
                 group = self.get_node(new_path)
                 if group is None:
-                    group = self._handle.createGroup(path, p)
+                    group = self._handle.create_group(path, p)
                 path = new_path
 
         s = self._create_storer(group, format, value, append=append,
@@ -2137,7 +2137,7 @@ def write(self, **kwargs):
     def delete(self, where=None, start=None, stop=None, **kwargs):
         """ support fully deleting the node in its entirety (only) - where specification must be None """
         if where is None and start is None and stop is None:
-            self._handle.removeNode(self.group, recursive=True)
+            self._handle.remove_node(self.group, recursive=True)
             return None
 
         raise TypeError("cannot delete on an abstract storer")
@@ -2379,7 +2379,7 @@ def write_array_empty(self, key, value):
 
         # ugly hack for length 0 axes
         arr = np.empty((1,) * value.ndim)
-        self._handle.createArray(self.group, key, arr)
+        self._handle.create_array(self.group, key, arr)
         getattr(self.group, key)._v_attrs.value_type = str(value.dtype)
         getattr(self.group, key)._v_attrs.shape = value.shape
 
@@ -2389,7 +2389,7 @@ def _is_empty_array(self, shape):
 
     def write_array(self, key, value, items=None):
         if key in self.group:
-            self._handle.removeNode(self.group, key)
+            self._handle.remove_node(self.group, key)
 
         # Transform needed to interface with pytables row/col notation
         empty_array = self._is_empty_array(value.shape)
@@ -2410,7 +2410,7 @@ def write_array(self, key, value, items=None):
             if atom is not None:
                 # create an empty chunked array and fill it from value
                 if not empty_array:
-                    ca = self._handle.createCArray(self.group, key, atom,
+                    ca = self._handle.create_carray(self.group, key, atom,
                                                    value.shape,
                                                    filters=self._filters)
                     ca[:] = value
@@ -2438,23 +2438,23 @@ def write_array(self, key, value, items=None):
                 ws = performance_doc % (inferred_type, key, items)
                 warnings.warn(ws, PerformanceWarning)
 
-            vlarr = self._handle.createVLArray(self.group, key,
+            vlarr = self._handle.create_vlarray(self.group, key,
                                                _tables().ObjectAtom())
             vlarr.append(value)
         else:
             if empty_array:
                 self.write_array_empty(key, value)
             else:
                 if value.dtype.type == np.datetime64:
-                    self._handle.createArray(self.group, key, value.view('i8'))
+                    self._handle.create_array(self.group, key, value.view('i8'))
                     getattr(
                         self.group, key)._v_attrs.value_type = 'datetime64'
                 elif value.dtype.type == np.timedelta64:
-                    self._handle.createArray(self.group, key, value.view('i8'))
+                    self._handle.create_array(self.group, key, value.view('i8'))
                     getattr(
                         self.group, key)._v_attrs.value_type = 'timedelta64'
                 else:
-                    self._handle.createArray(self.group, key, value)
+                    self._handle.create_array(self.group, key, value)
 
         getattr(self.group, key)._v_attrs.transposed = transposed
 
@@ -2558,7 +2558,7 @@ def write(self, obj, **kwargs):
         for name, ss in compat.iteritems(obj):
             key = 'sparse_series_%s' % name
             if key not in self.group._v_children:
-                node = self._handle.createGroup(self.group, key)
+                node = self._handle.create_group(self.group, key)
             else:
                 node = getattr(self.group, key)
             s = SparseSeriesFixed(self.parent, node)
@@ -2594,7 +2594,7 @@ def write(self, obj, **kwargs):
         for name, sdf in compat.iteritems(obj):
             key = 'sparse_frame_%s' % name
             if key not in self.group._v_children:
-                node = self._handle.createGroup(self.group, key)
+                node = self._handle.create_group(self.group, key)
             else:
                 node = getattr(self.group, key)
             s = SparseFrameFixed(self.parent, node)
@@ -3012,18 +3012,18 @@ def create_index(self, columns=None, optlevel=None, kind=None):
                     cur_kind = index.kind
 
                     if kind is not None and cur_kind != kind:
-                        v.removeIndex()
+                        v.remove_index()
                     else:
                         kw['kind'] = cur_kind
 
                     if optlevel is not None and cur_optlevel != optlevel:
-                        v.removeIndex()
+                        v.remove_index()
                     else:
                         kw['optlevel'] = cur_optlevel
 
                 # create the index
                 if not v.is_indexed:
-                    v.createIndex(**kw)
+                    v.create_index(**kw)
 
     def read_axes(self, where, **kwargs):
         """create and return the axes sniffed from the table: return boolean
@@ -3583,7 +3583,7 @@ def write(self, obj, axes=None, append=False, complib=None,
               chunksize=None, expectedrows=None, dropna=True, **kwargs):
 
         if not append and self.is_exists:
-            self._handle.removeNode(self.group, 'table')
+            self._handle.remove_node(self.group, 'table')
 
         # create the axes
         self.create_axes(axes=axes, obj=obj, validate=append,
@@ -3602,7 +3602,7 @@ def write(self, obj, axes=None, append=False, complib=None,
             self.set_attrs()
 
             # create the table
-            table = self._handle.createTable(self.group, **options)
+            table = self._handle.create_table(self.group, **options)
 
         else:
             table = self.table
@@ -3731,12 +3731,12 @@ def delete(self, where=None, start=None, stop=None, **kwargs):
         if where is None or not len(where):
             if start is None and stop is None:
                 nrows = self.nrows
-                self._handle.removeNode(self.group, recursive=True)
+                self._handle.remove_node(self.group, recursive=True)
             else:
                 # pytables<3.0 would remove a single row with stop=None
                 if stop is None:
                     stop = self.nrows
-                nrows = self.table.removeRows(start=start, stop=stop)
+                nrows = self.table.remove_rows(start=start, stop=stop)
                 self.table.flush()
             return nrows
 
@@ -3775,7 +3775,7 @@ def delete(self, where=None, start=None, stop=None, **kwargs):
             pg = groups.pop()
             for g in reversed(groups):
                 rows = l.take(lrange(g, pg))
-                table.removeRows(start=rows[rows.index[0]
+                table.remove_rows(start=rows[rows.index[0]
                                             ], stop=rows[rows.index[-1]] + 1)
                 pg = g
 
@@ -4318,10 +4318,10 @@ def select(self):
         generate the selection
         """
         if self.condition is not None:
-            return self.table.table.readWhere(self.condition.format(),
+            return self.table.table.read_where(self.condition.format(),
                                               start=self.start, stop=self.stop)
         elif self.coordinates is not None:
-            return self.table.table.readCoordinates(self.coordinates)
+            return self.table.table.read_coordinates(self.coordinates)
         return self.table.table.read(start=self.start, stop=self.stop)
 
     def select_coords(self):
@@ -4340,7 +4340,7 @@ def select_coords(self):
             stop += nrows
 
         if self.condition is not None:
-            return self.table.table.getWhereList(self.condition.format(),
+            return self.table.table.get_where_list(self.condition.format(),
                                                  start=start, stop=stop,
                                                  sort=True)
         elif self.coordinates is not None: