<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>filenode - simulating a filesystem with PyTables — PyTables 3.0.0 documentation</title>
<link rel="stylesheet" href="../_static/cloud.css" type="text/css" />
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
<link rel="stylesheet" href="../" type="text/css" />
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: '../',
VERSION: '3.0.0',
COLLAPSE_INDEX: false,
FILE_SUFFIX: '.html',
HAS_SOURCE: true
};
</script>
<script type="text/javascript" src="../_static/jquery.js"></script>
<script type="text/javascript" src="../_static/underscore.js"></script>
<script type="text/javascript" src="../_static/doctools.js"></script>
<script type="text/javascript" src="../_static/jquery.cookie.js"></script>
<script type="text/javascript" src="../_static/toggle_sections.js"></script>
<script type="text/javascript" src="../_static/toggle_sidebar.js"></script>
<link rel="shortcut icon" href="../_static/favicon.ico"/>
<link rel="top" title="PyTables 3.0.0 documentation" href="../index.html" />
<link rel="up" title="PyTables User’s Guide" href="index.html" />
<link rel="next" title="Supported data types in PyTables" href="datatypes.html" />
<link rel="prev" title="Optimization tips" href="optimization.html" />
</head>
<body>
<div class="relbar-top">
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
accesskey="I">index</a></li>
<li class="right" >
<a href="../py-modindex.html" title="Python Module Index"
>modules</a> </li>
<li class="right" >
<a href="../np-modindex.html" title="Python Module Index"
>modules</a> </li>
<li class="right" >
<a href="datatypes.html" title="Supported data types in PyTables"
accesskey="N">next</a> </li>
<li class="right" >
<a href="optimization.html" title="Optimization tips"
accesskey="P">previous</a> </li>
<li><a href="../index.html">PyTables 3.0.0 documentation</a> »</li>
<li><a href="index.html" accesskey="U">PyTables User’s Guide</a> »</li>
</ul>
</div>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body">
<div class="section" id="filenode-simulating-a-filesystem-with-pytables">
<span id="filenode-usersguide"></span><h1>filenode - simulating a filesystem with PyTables<a class="headerlink" href="#filenode-simulating-a-filesystem-with-pytables" title="Permalink to this headline">¶</a></h1>
<div class="section" id="what-is-filenode">
<h2>What is filenode?<a class="headerlink" href="#what-is-filenode" title="Permalink to this headline">¶</a></h2>
<p>filenode is a module which enables you to create a PyTables database of nodes
which can be used like regular opened files in Python. In other words, you
can store a file in a PyTables database, and read and write it as you would
do with any other file in Python. Used in conjunction with PyTables
hierarchical database organization, you can have your database turned into an
open, extensible, efficient, high capacity, portable and metadata-rich
filesystem for data exchange with other systems (including backup purposes).</p>
<p>Between the main features of filenode, one can list:</p>
<ul class="simple">
<li><em>Open:</em> Since it relies on PyTables, which in turn, sits over HDF5 (see
<a class="reference internal" href="bibliography.html#hdfg1"><em>[HDGG1]</em></a>), a standard hierarchical data format from NCSA.</li>
<li><em>Extensible:</em> You can define new types of nodes, and their instances will
be safely preserved (as are normal groups, leafs and attributes) by
PyTables applications having no knowledge of their types. Moreover, the set
of possible attributes for a node is not fixed, so you can define your own
node attributes.</li>
<li><em>Efficient:</em> Thanks to PyTables’ proven extreme efficiency on handling huge
amounts of data. filenode can make use of PyTables’ on-the-fly compression
and decompression of data.</li>
<li><em>High capacity:</em> Since PyTables and HDF5 are designed for massive data
storage (they use 64-bit addressing even where the platform does not
support it natively).</li>
<li><em>Portable:</em> Since the HDF5 format has an architecture-neutral design, and
the HDF5 libraries and PyTables are known to run under a variety of
platforms. Besides that, a PyTables database fits into a single file, which
poses no trouble for transportation.</li>
<li><em>Metadata-rich:</em> Since PyTables can store arbitrary key-value pairs (even
Python objects!) for every database node. Metadata may include authorship,
keywords, MIME types and encodings, ownership information, access control
lists (ACL), decoding functions and anything you can imagine!</li>
</ul>
</div>
<div class="section" id="finding-a-filenode-node">
<h2>Finding a filenode node<a class="headerlink" href="#finding-a-filenode-node" title="Permalink to this headline">¶</a></h2>
<p>filenode nodes can be recognized because they have a NODE_TYPE system
attribute with a ‘file’ value. It is recommended that you use the
<tt class="xref py py-meth docutils literal"><span class="pre">File.get_node_attr()</span></tt> method of tables.File class to get the NODE_TYPE
attribute independently of the nature (group or leaf) of the node, so you do
not need to care about.</p>
</div>
<div class="section" id="filenode-simulating-files-inside-pytables">
<h2>filenode - simulating files inside PyTables<a class="headerlink" href="#filenode-simulating-files-inside-pytables" title="Permalink to this headline">¶</a></h2>
<p>The filenode module is part of the nodes sub-package of PyTables. The
recommended way to import the module is:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="kn">from</span> <span class="nn">tables.nodes</span> <span class="kn">import</span> <span class="n">filenode</span>
</pre></div>
</div>
<p>However, filenode exports very few symbols, so you can import * for
interactive usage. In fact, you will most probably only use the NodeType
constant and the new_node() and open_node() calls.</p>
<p>The NodeType constant contains the value that the NODE_TYPE system attribute
of a node file is expected to contain (‘file’, as we have seen).
Although this is not expected to change, you should use filenode.NodeType
instead of the literal ‘file’ when possible.</p>
<p>new_node() and open_node() are the equivalent to the Python file() call (alias
open()) for ordinary files. Their arguments differ from that of file(), but
this is the only point where you will note the difference between working
with a node file and working with an ordinary file.</p>
<p>For this little tutorial, we will assume that we have a PyTables database
opened for writing. Also, if you are somewhat lazy at typing sentences, the
code that we are going to explain is included in the examples/filenodes1.py
file.</p>
<p>You can create a brand new file with these sentences:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="kn">import</span> <span class="nn">tables</span>
<span class="gp">>>> </span><span class="n">h5file</span> <span class="o">=</span> <span class="n">tables</span><span class="o">.</span><span class="n">open_file</span><span class="p">(</span><span class="s">'fnode.h5'</span><span class="p">,</span> <span class="s">'w'</span><span class="p">)</span>
</pre></div>
</div>
<div class="section" id="creating-a-new-file-node">
<h3>Creating a new file node<a class="headerlink" href="#creating-a-new-file-node" title="Permalink to this headline">¶</a></h3>
<p>Creation of a new file node is achieved with the new_node() call. You must
tell it in which PyTables file you want to create it, where in the PyTables
hierarchy you want to create the node and which will be its name. The
PyTables file is the first argument to new_node(); it will be also called the
‘host PyTables file’. The other two arguments must be given as keyword
arguments where and name, respectively.
As a result of the call, a brand new appendable and readable file node object
is returned.</p>
<p>So let us create a new node file in the previously opened h5file PyTables
file, named ‘fnode_test’ and placed right under the root of the database
hierarchy. This is that command:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">fnode</span> <span class="o">=</span> <span class="n">filenode</span><span class="o">.</span><span class="n">new_node</span><span class="p">(</span><span class="n">h5file</span><span class="p">,</span> <span class="n">where</span><span class="o">=</span><span class="s">'/'</span><span class="p">,</span> <span class="n">name</span><span class="o">=</span><span class="s">'fnode_test'</span><span class="p">)</span>
</pre></div>
</div>
<p>That is basically all you need to create a file node. Simple, isn’t it? From
that point on, you can use fnode as any opened Python file (i.e. you can
write data, read data, lines of text and so on).</p>
<p>new_node() accepts some more keyword arguments. You can give a title to your
file with the title argument. You can use PyTables’ compression features with
the filters argument. If you know beforehand the size that your file will
have, you can give its final file size in bytes to the expectedsize argument
so that the PyTables library would be able to optimize the data access.</p>
<p>new_node() creates a PyTables node where it is told to. To prove it, we will
try to get the NODE_TYPE attribute from the newly created node:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="k">print</span> <span class="n">h5file</span><span class="o">.</span><span class="n">get_node_attr</span><span class="p">(</span><span class="s">'/fnode_test'</span><span class="p">,</span> <span class="s">'NODE_TYPE'</span><span class="p">)</span>
<span class="go">file</span>
</pre></div>
</div>
</div>
<div class="section" id="using-a-file-node">
<h3>Using a file node<a class="headerlink" href="#using-a-file-node" title="Permalink to this headline">¶</a></h3>
<p>As stated above, you can use the new node file as any other opened file. Let
us try to write some text in and read it:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="k">print</span> <span class="o">>></span> <span class="n">fnode</span><span class="p">,</span> <span class="s">"This is a test text line."</span>
<span class="gp">>>> </span><span class="k">print</span> <span class="o">>></span> <span class="n">fnode</span><span class="p">,</span> <span class="s">"And this is another one."</span>
<span class="gp">>>> </span><span class="k">print</span> <span class="o">>></span> <span class="n">fnode</span>
<span class="gp">>>> </span><span class="n">fnode</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="s">"Of course, file methods can also be used."</span><span class="p">)</span>
<span class="go">>>></span>
<span class="gp">>>> </span><span class="n">fnode</span><span class="o">.</span><span class="n">seek</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span> <span class="c"># Go back to the beginning of file.</span>
<span class="go">>>></span>
<span class="gp">>>> </span><span class="k">for</span> <span class="n">line</span> <span class="ow">in</span> <span class="n">fnode</span><span class="p">:</span>
<span class="gp">... </span> <span class="k">print</span> <span class="nb">repr</span><span class="p">(</span><span class="n">line</span><span class="p">)</span>
<span class="go">'This is a test text line.\\n'</span>
<span class="go">'And this is another one.\\n'</span>
<span class="go">'\\n'</span>
<span class="go">'Of course, file methods can also be used.'</span>
</pre></div>
</div>
<p>This was run on a Unix system, so newlines are expressed as ‘n’. In fact,
you can override the line separator for a file by setting its line_separator
property to any string you want.</p>
<p>While using a file node, you should take care of closing it <em>before</em> you
close the PyTables host file.
Because of the way PyTables works, your data it will not be at a risk, but
every operation you execute after closing the host file will fail with a
ValueError. To close a file node, simply delete it or call its close()
method:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">fnode</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
<span class="gp">>>> </span><span class="k">print</span> <span class="n">fnode</span><span class="o">.</span><span class="n">closed</span>
<span class="go">True</span>
</pre></div>
</div>
</div>
<div class="section" id="opening-an-existing-file-node">
<h3>Opening an existing file node<a class="headerlink" href="#opening-an-existing-file-node" title="Permalink to this headline">¶</a></h3>
<p>If you have a file node that you created using new_node(), you can open it
later by calling open_node(). Its arguments are similar to that of file() or
open(): the first argument is the PyTables node that you want to open (i.e. a
node with a NODE_TYPE attribute having a ‘file’ value), and the second
argument is a mode string indicating how to open the file. Contrary to
file(), open_node() can not be used to create a new file node.</p>
<p>File nodes can be opened in read-only mode (‘r’) or in read-and-append mode
(‘a+’). Reading from a file node is allowed in both modes, but appending is
only allowed in the second one. Just like Python files do, writing data to an
appendable file places it after the file pointer if it is on or beyond the
end of the file, or otherwise after the existing data. Let us see an
example:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">node</span> <span class="o">=</span> <span class="n">h5file</span><span class="o">.</span><span class="n">root</span><span class="o">.</span><span class="n">fnode_test</span>
<span class="gp">>>> </span><span class="n">fnode</span> <span class="o">=</span> <span class="n">filenode</span><span class="o">.</span><span class="n">open_node</span><span class="p">(</span><span class="n">node</span><span class="p">,</span> <span class="s">'a+'</span><span class="p">)</span>
<span class="gp">>>> </span><span class="k">print</span> <span class="nb">repr</span><span class="p">(</span><span class="n">fnode</span><span class="o">.</span><span class="n">readline</span><span class="p">())</span>
<span class="go">'This is a test text line.\\n'</span>
<span class="gp">>>> </span><span class="k">print</span> <span class="n">fnode</span><span class="o">.</span><span class="n">tell</span><span class="p">()</span>
<span class="go">26</span>
<span class="gp">>>> </span><span class="k">print</span> <span class="o">>></span> <span class="n">fnode</span><span class="p">,</span> <span class="s">"This is a new line."</span>
<span class="gp">>>> </span><span class="k">print</span> <span class="nb">repr</span><span class="p">(</span><span class="n">fnode</span><span class="o">.</span><span class="n">readline</span><span class="p">())</span>
<span class="go">''</span>
</pre></div>
</div>
<p>Of course, the data append process places the pointer at the end of the file,
so the last readline() call hit EOF. Let us seek to the beginning of the file
to see the whole contents of our file:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">fnode</span><span class="o">.</span><span class="n">seek</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
<span class="gp">>>> </span><span class="k">for</span> <span class="n">line</span> <span class="ow">in</span> <span class="n">fnode</span><span class="p">:</span>
<span class="gp">... </span> <span class="k">print</span> <span class="nb">repr</span><span class="p">(</span><span class="n">line</span><span class="p">)</span>
<span class="go">'This is a test text line.\\n'</span>
<span class="go">'And this is another one.\\n'</span>
<span class="go">'\\n'</span>
<span class="go">'Of course, file methods can also be used.This is a new line.\\n'</span>
</pre></div>
</div>
<p>As you can check, the last string we wrote was correctly appended at the end
of the file, instead of overwriting the second line, where the file pointer
was positioned by the time of the appending.</p>
</div>
<div class="section" id="adding-metadata-to-a-file-node">
<h3>Adding metadata to a file node<a class="headerlink" href="#adding-metadata-to-a-file-node" title="Permalink to this headline">¶</a></h3>
<p>You can associate arbitrary metadata to any open node file, regardless of its
mode, as long as the host PyTables file is writable. Of course, you could use
the set_node_attr() method of tables.File to do it directly on the proper node,
but filenode offers a much more comfortable way to do it. filenode objects
have an attrs property which gives you direct access to their corresponding
AttributeSet object.</p>
<p>For instance, let us see how to associate MIME type metadata to our file
node:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">fnode</span><span class="o">.</span><span class="n">attrs</span><span class="o">.</span><span class="n">content_type</span> <span class="o">=</span> <span class="s">'text/plain; charset=us-ascii'</span>
</pre></div>
</div>
<p>As simple as A-B-C. You can put nearly anything in an attribute, which opens
the way to authorship, keywords, permissions and more. Moreover, there is not
a fixed list of attributes.
However, you should avoid names in all caps or starting with ‘_’, since
PyTables and filenode may use them internally. Some valid examples:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">fnode</span><span class="o">.</span><span class="n">attrs</span><span class="o">.</span><span class="n">author</span> <span class="o">=</span> <span class="s">"Ivan Vilata i Balaguer"</span>
<span class="gp">>>> </span><span class="n">fnode</span><span class="o">.</span><span class="n">attrs</span><span class="o">.</span><span class="n">creation_date</span> <span class="o">=</span> <span class="s">'2004-10-20T13:25:25+0200'</span>
<span class="gp">>>> </span><span class="n">fnode</span><span class="o">.</span><span class="n">attrs</span><span class="o">.</span><span class="n">keywords_en</span> <span class="o">=</span> <span class="p">[</span><span class="s">"FileNode"</span><span class="p">,</span> <span class="s">"test"</span><span class="p">,</span> <span class="s">"metadata"</span><span class="p">]</span>
<span class="gp">>>> </span><span class="n">fnode</span><span class="o">.</span><span class="n">attrs</span><span class="o">.</span><span class="n">keywords_ca</span> <span class="o">=</span> <span class="p">[</span><span class="s">"FileNode"</span><span class="p">,</span> <span class="s">"prova"</span><span class="p">,</span> <span class="s">"metadades"</span><span class="p">]</span>
<span class="gp">>>> </span><span class="n">fnode</span><span class="o">.</span><span class="n">attrs</span><span class="o">.</span><span class="n">owner</span> <span class="o">=</span> <span class="s">'ivan'</span>
<span class="gp">>>> </span><span class="n">fnode</span><span class="o">.</span><span class="n">attrs</span><span class="o">.</span><span class="n">acl</span> <span class="o">=</span> <span class="p">{</span><span class="s">'ivan'</span><span class="p">:</span> <span class="s">'rw'</span><span class="p">,</span> <span class="s">'@users'</span><span class="p">:</span> <span class="s">'r'</span><span class="p">}</span>
</pre></div>
</div>
<p>You can check that these attributes get stored by running the ptdump command
on the host PyTables file.</p>
<div class="highlight-bash"><div class="highlight"><pre><span class="nv">$ </span>ptdump -a fnode.h5:/fnode_test
/fnode_test <span class="o">(</span>EArray<span class="o">(</span>113,<span class="o">))</span> <span class="s1">''</span>
/fnode_test.attrs <span class="o">(</span>AttributeSet<span class="o">)</span>, 14 attributes:
<span class="o">[</span>CLASS :<span class="o">=</span> <span class="s1">'EARRAY'</span>,
EXTDIM :<span class="o">=</span> 0,
FLAVOR :<span class="o">=</span> <span class="s1">'numpy'</span>,
NODE_TYPE :<span class="o">=</span> <span class="s1">'file'</span>,
NODE_TYPE_VERSION :<span class="o">=</span> 2,
TITLE :<span class="o">=</span> <span class="s1">''</span>,
VERSION :<span class="o">=</span> <span class="s1">'1.2'</span>,
acl :<span class="o">=</span> <span class="o">{</span><span class="s1">'ivan'</span>: <span class="s1">'rw'</span>, <span class="s1">'@users'</span>: <span class="s1">'r'</span><span class="o">}</span>,
author :<span class="o">=</span> <span class="s1">'Ivan Vilata i Balaguer'</span>,
content_type :<span class="o">=</span> <span class="s1">'text/plain; charset=us-ascii'</span>,
creation_date :<span class="o">=</span> <span class="s1">'2004-10-20T13:25:25+0200'</span>,
keywords_ca :<span class="o">=</span> <span class="o">[</span><span class="s1">'FileNode'</span>, <span class="s1">'prova'</span>, <span class="s1">'metadades'</span><span class="o">]</span>,
keywords_en :<span class="o">=</span> <span class="o">[</span><span class="s1">'FileNode'</span>, <span class="s1">'test'</span>, <span class="s1">'metadata'</span><span class="o">]</span>,
owner :<span class="o">=</span> <span class="s1">'ivan'</span><span class="o">]</span>
</pre></div>
</div>
<p>Note that filenode makes no assumptions about the meaning of your metadata,
so its handling is entirely left to your needs and imagination.</p>
</div>
</div>
<div class="section" id="complementary-notes">
<h2>Complementary notes<a class="headerlink" href="#complementary-notes" title="Permalink to this headline">¶</a></h2>
<p>You can use file nodes and PyTables groups to mimic a filesystem with files
and directories. Since you can store nearly anything you want as file
metadata, this enables you to use a PyTables file as a portable compressed
backup, even between radically different platforms. Take this with a grain of
salt, since node files are restricted in their naming (only valid Python
identifiers are valid); however, remember that you can use node titles and
metadata to overcome this limitation. Also, you may need to devise some
strategy to represent special files such as devices, sockets and such (not
necessarily using filenode).</p>
<p>We are eager to hear your opinion about filenode and its potential uses.
Suggestions to improve filenode and create other node types are also welcome.
Do not hesitate to contact us!</p>
</div>
<div class="section" id="current-limitations">
<h2>Current limitations<a class="headerlink" href="#current-limitations" title="Permalink to this headline">¶</a></h2>
<p>filenode is still a young piece of software, so it lacks some functionality.
This is a list of known current limitations:</p>
<ol class="arabic simple">
<li>Node files can only be opened for read-only or read and append mode. This
should be enhanced in the future.</li>
<li>Near future?</li>
<li>Only binary I/O is supported currently (read/write strings of bytes)</li>
<li>There is no universal newline support yet. The only new-line character
used at the moment is <tt class="docutils literal"><span class="pre">\n</span></tt>. This is likely to be improved in a near
future.</li>
<li>Sparse files (files with lots of zeros) are not treated specially; if you
want them to take less space, you should be better off using compression.</li>
</ol>
<p>These limitations still make filenode entirely adequate to work with most
binary and text files. Of course, suggestions and patches are welcome.</p>
<p>See <a class="reference internal" href="libref/filenode_classes.html#filenode-classes"><em>Filenode Module</em></a> for detailed documentation on the filenode
interface.</p>
</div>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar">
<div class="sphinxsidebarwrapper">
<p class="logo"><a href="../index.html">
<img class="logo" src="../_static/logo-pytables-small.png" alt="Logo"/>
</a></p>
<h3><a href="../index.html">Table Of Contents</a></h3>
<ul>
<li><a class="reference internal" href="#">filenode - simulating a filesystem with PyTables</a><ul>
<li><a class="reference internal" href="#what-is-filenode">What is filenode?</a></li>
<li><a class="reference internal" href="#finding-a-filenode-node">Finding a filenode node</a></li>
<li><a class="reference internal" href="#filenode-simulating-files-inside-pytables">filenode - simulating files inside PyTables</a><ul>
<li><a class="reference internal" href="#creating-a-new-file-node">Creating a new file node</a></li>
<li><a class="reference internal" href="#using-a-file-node">Using a file node</a></li>
<li><a class="reference internal" href="#opening-an-existing-file-node">Opening an existing file node</a></li>
<li><a class="reference internal" href="#adding-metadata-to-a-file-node">Adding metadata to a file node</a></li>
</ul>
</li>
<li><a class="reference internal" href="#complementary-notes">Complementary notes</a></li>
<li><a class="reference internal" href="#current-limitations">Current limitations</a></li>
</ul>
</li>
</ul>
<h4>Previous topic</h4>
<p class="topless"><a href="optimization.html"
title="previous chapter">Optimization tips</a></p>
<h4>Next topic</h4>
<p class="topless"><a href="datatypes.html"
title="next chapter">Supported data types in PyTables</a></p>
<h3>This Page</h3>
<ul class="this-page-menu">
<li><a href="../_sources/usersguide/filenode.txt"
rel="nofollow">Show Source</a></li>
</ul>
<div id="searchbox" style="display: none">
<h3>Quick search</h3>
<form class="search" action="../search.html" method="get">
<input type="text" name="q" />
<input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
<p class="searchtip" style="font-size: 90%">
Enter search terms or a module, class or function name.
</p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="relbar-bottom">
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
>index</a></li>
<li class="right" >
<a href="../py-modindex.html" title="Python Module Index"
>modules</a> </li>
<li class="right" >
<a href="../np-modindex.html" title="Python Module Index"
>modules</a> </li>
<li class="right" >
<a href="datatypes.html" title="Supported data types in PyTables"
>next</a> </li>
<li class="right" >
<a href="optimization.html" title="Optimization tips"
>previous</a> </li>
<li><a href="../index.html">PyTables 3.0.0 documentation</a> »</li>
<li><a href="index.html" >PyTables User’s Guide</a> »</li>
</ul>
</div>
</div>
<div class="footer">
© Copyright 2011-2013, PyTables maintainers.
Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.1.3.
</div>
<!-- cloud_sptheme 1.3 -->
</body>
</html>
