An easy way of copying one PyTables file to another.

This function allows you to copy an existing PyTables file named srcfilename to another file called dstfilename. The source file must exist and be readable. The destination file can be overwritten in place if existing by asserting the overwrite argument.

This function is a shorthand for the File.copyFile() method, which acts on an already opened file. kwargs takes keyword arguments used to customize the copying process. See the documentation of File.copyFile() (see description) for a description of those arguments.

Determine whether a file is in the HDF5 format.

When successful, it returns a true value if the file is an HDF5 file, false otherwise. If there were problems identifying the file, an HDF5ExtError is raised.

Determine whether a file is in the PyTables format.

When successful, it returns a true value if the file is a PyTables file, false otherwise. The true value is the format version string of the file. If there were problems identifying the file, an HDF5ExtError is raised.

Iterate over long ranges.

This is similar to xrange(), but it allows 64-bit arguments on all platforms. The results of the iteration are sequentially yielded in the form of numpy.int64 values, but getting random individual items is not supported.

Because of the Python 32-bit limitation on object lengths, the length attribute (which is also a numpy.int64 value) should be used instead of the len() syntax.

Default start and step arguments are supported in the same way as in xrange(). When the standard [x]range() Python objects support 64-bit arguments, this iterator will be deprecated.

Open a PyTables (or generic HDF5) file and return a File object.

Arguments:

Print all the versions of software that PyTables relies on.

Disable all flavors except those in keep.

Providing an empty keep sequence implies disabling all flavors (but the internal one). If the sequence is not specified, only optional flavors are disabled.

	Important
	Once you disable a flavor, it can not be enabled again.

Split a PyTables type into a PyTables kind and an item size.

Returns a tuple of (kind, itemsize). If no item size is present in the type (in the form of a precision), the returned item size is None.

>>> split_type('int32')
('int', 4)
>>> split_type('string')
('string', None)
>>> split_type('int20')
Traceback (most recent call last):
  ...
ValueError: precision must be a multiple of 8: 20
>>> split_type('foo bar')
Traceback (most recent call last):
  ...
ValueError: malformed type: 'foo bar'

Run all the tests in the test suite.

If verbose is set, the test suite will emit messages with full verbosity (not recommended unless you are looking into a certain problem).

If heavy is set, the test suite will be run in heavy mode (you should be careful with this because it can take a lot of time and resources from your computer).

Get version information about a C library.

If the library indicated by name is available, this function returns a 3-tuple containing the major library version as an integer, its full version as a string, and the version date as a string. If the library is not available, None is returned.

The currently supported library names are hdf5, zlib, lzo and bzip2. If another name is given, a ValueError is raised.

Flush all the alive leaves in object tree and close the file.

Copy the contents of this file to dstfilename.

dstfilename must be a path string indicating the name of the destination file. If it already exists, the copy will fail with an IOError, unless the overwrite argument is true, in which case the destination file will be overwritten in place. In this last case, the destination file should be closed or ugly errors will happen.

Additional keyword arguments may be passed to customize the copying process. For instance, title and filters may be changed, user attributes may be or may not be copied, data may be sub-sampled, stats may be collected, etc. Arguments unknown to nodes are simply ignored. Check the documentation for copying operations of nodes to see which options they support.

Copying a file usually has the beneficial side effect of creating a more compact and cleaner version of the original file.

Flush all the alive leaves in the object tree.

Enter a context and return the same file.

Exit a context and close the file.

Return a short string representation of the object tree.

Example of use:

>>> f = tables.openFile('data/test.h5')
>>> print f
data/test.h5 (File) 'Table Benchmark'
Last modif.: 'Mon Sep 20 12:40:47 2004'
Object Tree:
/ (Group) 'Table Benchmark'
/tuple0 (Table(100L,)) 'This is the table title'
/group0 (Group) ''
/group0/tuple1 (Table(100L,)) 'This is the table title'
/group0/group1 (Group) ''
/group0/group1/tuple2 (Table(100L,)) 'This is the table title'
/group0/group1/group2 (Group) ''

Return a detailed string representation of the object tree.

Copy the children of a group into another group.

This method copies the nodes hanging from the source group srcgroup into the destination group dstgroup. Existing destination nodes can be replaced by asserting the overwrite argument. If the recursive argument is true, all descendant nodes of srcnode are recursively copied. If createparents is true, the needed groups for the given destination parent group path to exist will be created.

kwargs takes keyword arguments used to customize the copying process. See the documentation of Group._f_copyChildren() (see description) for a description of those arguments.

Copy the node specified by where and name to newparent/newname.

Additional keyword arguments may be passed to customize the copying process. The supported arguments depend on the kind of node being copied. See Group._f_copy() (description) and Leaf.copy() (description) for more information on their allowed keyword arguments.

This method returns the newly created copy of the source node (i.e. the destination node). See Node._f_copy() (description) for further details on the semantics of copying nodes.

Create a new array with the given name in where location. See the Array class (in Section 4.7) for more information on arrays.

See File.createTable() (description) for more information on the rest of parameters.

Create a new chunked array with the given name in where location. See the CArray class (in Section 4.8) for more information on chunked arrays.

See File.createTable() (description) for more information on the rest of parameters.

Create a new enlargeable array with the given name in where location. See the EArray (in Section 4.9) class for more information on enlargeable arrays.

See File.createTable() (description) for more information on the rest of parameters.

Create a new group with the given name in where location. See the Group class (in Section 4.4) for more information on groups.

See File.createTable() (description) for more information on the rest of parameters.

Create a new table with the given name in where location. See the Table (in Section 4.6) class for more information on tables.

Create a new variable-length array with the given name in where location. See the VLArray (in Section 4.10) class for more information on variable-length arrays.

See File.createTable() (description) for more information on the rest of parameters.

Move the node specified by where and name to newparent/newname.

The other arguments work as in Node._f_move() (see description).

Remove the object node name under where location.

Change the name of the node specified by where and name to newname.

Get the node under where with the given name.

where can be a Node instance (see Section 4.3) or a path string leading to a node. If no name is specified, that node is returned.

If a name is specified, this must be a string with the name of a node under where. In this case the where argument can only lead to a Group (see Section 4.4) instance (else a TypeError is raised). The node called name under the group where is returned.

In both cases, if the node to be returned does not exist, a NoSuchNodeError is raised. Please note that hidden nodes are also considered.

If the classname argument is specified, it must be the name of a class derived from Node. If the node is found but it is not an instance of that class, a NoSuchNodeError is also raised.

Is the node under path visible?

If the node does not exist, a NoSuchNodeError is raised.

Iterate over children nodes hanging from where.

The returned nodes are alphanumerically sorted by their name. This is an iterator version of File.listNodes() (see description).

Return a list with children nodes hanging from where.

This is a list-returning version of File.iterNodes() (see description).

Recursively iterate over groups (not leaves) hanging from where.

The where group itself is listed first (preorder), then each of its child groups (following an alphanumerical order) is also traversed, following the same procedure. If where is not supplied, the root group is used.

The where argument can be a path string or a Group instance (see Section 4.4).

Recursively iterate over nodes hanging from where.

Example of use:

# Recursively print all the nodes hanging from '/detector'.
print "Nodes hanging from group '/detector':"
for node in h5file.walkNodes('/detector', classname='EArray'):
    print node

Is there a node with that path?

Returns True if the file has a node with the given path (a string), False otherwise.

Recursively iterate over the nodes in the tree.

This is equivalent to calling File.walkNodes() (see description) with no arguments.

Example of use:

# Recursively list all the nodes in the object tree.
h5file = tables.openFile('vlarray1.h5')
print "All nodes in the object tree:"
for node in h5file:
    print node

Disable the Undo/Redo mechanism.

Disabling the Undo/Redo mechanism leaves the database in the current state and forgets past and future database states. This makes File.mark() (see description), File.undo() (see description), File.redo() (see description) and other methods fail with an UndoRedoError.

Calling this method when the Undo/Redo mechanism is already disabled raises an UndoRedoError.

Enable the Undo/Redo mechanism.

This operation prepares the database for undoing and redoing modifications in the node hierarchy. This allows File.mark() (see description), File.undo() (see description), File.redo() (see description) and other methods to be called.

The filters argument, when specified, must be an instance of class Filters (see Section 4.14.1) and is meant for setting the compression values for the action log. The default is having compression enabled, as the gains in terms of space can be considerable. You may want to disable compression if you want maximum speed for Undo/Redo operations.

Calling this method when the Undo/Redo mechanism is already enabled raises an UndoRedoError.

Get the identifier of the current mark.

Returns the identifier of the current mark. This can be used to know the state of a database after an application crash, or to get the identifier of the initial implicit mark after a call to File.enableUndo() (see description).

This method can only be called when the Undo/Redo mechanism has been enabled. Otherwise, an UndoRedoError is raised.

Go to a specific mark of the database.

Returns the database to the state associated with the specified mark. Both the identifier of a mark and its name can be used.

This method can only be called when the Undo/Redo mechanism has been enabled. Otherwise, an UndoRedoError is raised.

Is the Undo/Redo mechanism enabled?

Returns True if the Undo/Redo mechanism has been enabled for this file, False otherwise. Please note that this mechanism is persistent, so a newly opened PyTables file may already have Undo/Redo support enabled.

Mark the state of the database.

Creates a mark for the current state of the database. A unique (and immutable) identifier for the mark is returned. An optional name (a string) can be assigned to the mark. Both the identifier of a mark and its name can be used in File.undo() (see description) and File.redo() (see description) operations. When the name has already been used for another mark, an UndoRedoError is raised.

This method can only be called when the Undo/Redo mechanism has been enabled. Otherwise, an UndoRedoError is raised.

Go to a future state of the database.

Returns the database to the state associated with the specified mark. Both the identifier of a mark and its name can be used. If the mark is omitted, the next created mark is used. If there are no future marks, or the specified mark is not newer than the current one, an UndoRedoError is raised.

This method can only be called when the Undo/Redo mechanism has been enabled. Otherwise, an UndoRedoError is raised.

Go to a past state of the database.

Returns the database to the state associated with the specified mark. Both the identifier of a mark and its name can be used. If the mark is omitted, the last created mark is used. If there are no past marks, or the specified mark is not older than the current one, an UndoRedoError is raised.

This method can only be called when the Undo/Redo mechanism has been enabled. Otherwise, an UndoRedoError is raised.

Copy PyTables attributes from one node to another.

Delete a PyTables attribute from the given node.

Get a PyTables attribute from the given node.

Set a PyTables attribute for the given node.

If the node already has a large number of attributes, a PerformanceWarning is issued.

Close this node in the tree.

This releases all resources held by the node, so it should not be used again. On nodes with data, it may be flushed to disk.

The closing operation is not recursive, i.e. closing a group does not close its children.

Copy this node and return the new node.

Creates and returns a copy of the node, maybe in a different place in the hierarchy. newparent can be a Group object (see Section 4.4) or a pathname in string form. If it is not specified or None, the current parent group is chosen as the new parent. newname must be a string with a new name. If it is not specified or None, the current name is chosen as the new name. If recursive copy is stated, all descendants are copied as well. If createparents is true, the needed groups for the given new parent group path to exist will be created.

Copying a node across databases is supported but can not be undone. Copying a node over itself is not allowed, nor it is recursively copying a node into itself. These result in a NodeError. Copying over another existing node is similarly not allowed, unless the optional overwrite argument is true, in which case that node is recursively removed before copying.

Additional keyword arguments may be passed to customize the copying process. For instance, title and filters may be changed, user attributes may be or may not be copied, data may be sub-sampled, stats may be collected, etc. See the documentation for the particular node type.

Using only the first argument is equivalent to copying the node to a new location without changing its name. Using only the second argument is equivalent to making a copy of the node in the same group.

Is this node visible?

Move or rename this node.

Moves a node into a new parent group, or changes the name of the node. newparent can be a Group object (see Section 4.4) or a pathname in string form. If it is not specified or None, the current parent group is chosen as the new parent. newname must be a string with a new name. If it is not specified or None, the current name is chosen as the new name. If createparents is true, the needed groups for the given new parent group path to exist will be created.

Moving a node across databases is not allowed, nor it is moving a node into itself. These result in a NodeError. However, moving a node over itself is allowed and simply does nothing. Moving over another existing node is similarly not allowed, unless the optional overwrite argument is true, in which case that node is recursively removed before moving.

Usually, only the first argument will be used, effectively moving the node to a new location without changing its name. Using only the second argument is equivalent to renaming the node in place.

Remove this node from the hierarchy.

If the node has children, recursive removal must be stated by giving recursive a true value; otherwise, a NodeError will be raised.

Rename this node in place.

Changes the name of a node to newname (a string). If a node with the same newname already exists and overwrite is true, recursively remove it before renaming.

Delete a PyTables attribute from this node.

If the named attribute does not exist, an AttributeError is raised.

Get a PyTables attribute from this node.

If the named attribute does not exist, an AttributeError is raised.

Set a PyTables attribute for this node.

If the node already has a large number of attributes, a PerformanceWarning is issued.

Close this node in the tree.

This method has the behavior described in Node._f_close() (see description). It should be noted that this operation disables access to nodes descending from this group. Therefore, if you want to explicitly close them, you will need to walk the nodes hanging from this group before closing it.

Copy this node and return the new one.

This method has the behavior described in Node._f_copy() (see description). In addition, it recognizes the following keyword arguments:

Copy the children of this group into another group.

Children hanging directly from this group are copied into dstgroup, which can be a Group (see Section 4.4) object or its pathname in string form. If createparents is true, the needed groups for the given destination group path to exist will be created.

The operation will fail with a NodeError if there is a child node in the destination group with the same name as one of the copied children from this one, unless overwrite is true; in this case, the former child node is recursively removed before copying the later.

By default, nodes descending from children groups of this node are not copied. If the recursive argument is true, all descendant nodes of this node are recursively copied.

Additional keyword arguments may be passed to customize the copying process. For instance, title and filters may be changed, user attributes may be or may not be copied, data may be sub-sampled, stats may be collected, etc. Arguments unknown to nodes are simply ignored. Check the documentation for copying operations of nodes to see which options they support.

Get the child called childname of this group.

If the child exists (be it visible or not), it is returned. Else, a NoSuchNodeError is raised.

Using this method is recommended over getattr() when doing programmatic accesses to children if the childname is unknown beforehand or when its name is not a valid Python identifier.

Iterate over children nodes.

Child nodes are yielded alphanumerically sorted by node name. If the name of a class derived from Node (see Section 4.3) is supplied in the classname parameter, only instances of that class (or subclasses of it) will be returned.

This is an iterator version of Group._f_listNodes() (see description).

Return a list with children nodes.

This is a list-returning version of Group._f_iterNodes() (see description).

Recursively iterate over descendent groups (not leaves).

This method starts by yielding self, and then it goes on to recursively iterate over all child groups in alphanumerical order, top to bottom (preorder), following the same procedure.

Iterate over descendent nodes.

This method recursively walks self top to bottom (preorder), iterating over child groups in alphanumerical order, and yielding nodes. If classname is supplied, only instances of the named class are yielded.

If classname is Group, it behaves like Group._f_walkGroups() (see the section called “_f_walkGroups()”), yielding only groups. If you don't want a recursive behavior, use Group._f_iterNodes() (see description) instead.

Example of use:

# Recursively print all the arrays hanging from '/'
print "Arrays in the object tree '/':"
for array in h5file.root._f_walkNodes('Array', recursive=True):
    print array

Is there a child with that name?

Returns a true value if the group has a child node (visible or hidden) with the given name (a string), false otherwise.

Delete a Python attribute called name.

This method deletes an ordinary Python attribute from the object. It does not remove children nodes from this group; for that, use File.removeNode() (see description) or Node._f_remove() (see description). It does neither delete a PyTables node attribute; for that, use File.delNodeAttr() (see description), Node._f_delAttr() (see description) or Node._v_attrs (see Section 4.3.2).

If there is an attribute and a child node with the same name, the child node will be made accessible again via natural naming.

Get a Python attribute or child node called name.

If the object has a Python attribute called name, its value is returned. Else, if the node has a child node called name, it is returned. Else, an AttributeError is raised.

Iterate over the child nodes hanging directly from the group.

This iterator is not recursive. Example of use:

# Non-recursively list all the nodes hanging from '/detector'
print "Nodes in '/detector' group:"
for node in h5file.root.detector:
    print node

Return a detailed string representation of the group.

Example of use:

>>> f = tables.openFile('data/test.h5')
>>> f.root.group0
/group0 (Group) 'First Group'
  children := ['tuple1' (Table), 'group1' (Group)]

Set a Python attribute called name with the given value.

This method stores an ordinary Python attribute in the object. It does not store new children nodes under this group; for that, use the File.create*() methods (see the File class in Section 4.2). It does neither store a PyTables node attribute; for that, use File.setNodeAttr() (see description), Node._f_setAttr() (see description) or Node._v_attrs (see Section 4.3.2).

If there is already a child node with the same name, a NaturalNameWarning will be issued and the child node will not be accessible via natural naming nor getattr(). It will still be available via File.getNode() (see description), Group._f_getChild() (see description) and children dictionaries in the group (if visible).

Return a short string representation of the group.

Example of use:

>>> f=tables.openFile('data/test.h5')
>>> print f.root.group0
/group0 (Group) 'First Group'

Close this node in the tree.

This method is completely equivalent to Leaf._f_close() (see description).

Copy this node and return the new one.

This method has the behavior described in Node._f_copy() (see description). Please note that there is no recursive flag since leaves do not have child nodes. In addition, this method recognizes the following keyword arguments:

Delete a PyTables attribute from this node.

This method has the behavior described in Node._f_delAttr() (see description).

Flush pending data to disk.

Saves whatever remaining buffered data to disk. It also releases I/O buffers, so if you are filling many datasets in the same PyTables session, please call flush() extensively so as to help PyTables to keep memory requirements low.

Get a PyTables attribute from this node.

This method has the behavior described in Node._f_getAttr() (see description).

Is this node visible?

This method has the behavior described in Node._f_isVisible() (see description).

Move or rename this node.

This method has the behavior described in Node._f_move() (see description).

Rename this node in place.

This method has the behavior described in Node._f_rename() (see description).

Remove this node from the hierarchy.

This method has the behavior described in Node._f_remove() (see description). Please note that there is no recursive flag since leaves do not have child nodes.

Set a PyTables attribute for this node.

This method has the behavior described in Node._f_setAttr() (see description).

Return the length of the main dimension of the leaf data.

Close this node in the tree.

This method has the behavior described in Node._f_close() (see description). Besides that, the optional argument flush tells whether to flush pending data to disk or not before closing.