http://git-wip-us.apache.org/repos/asf/arrow-site/blob/4d4a3202/docs/python/memory.html
----------------------------------------------------------------------
diff --git a/docs/python/memory.html b/docs/python/memory.html
index 7bbbd1a..569d3c8 100644
--- a/docs/python/memory.html
+++ b/docs/python/memory.html
@@ -73,7 +73,8 @@
<li class="toctree-l1 current"><a class="current reference internal" href="#">Memory and IO Interfaces</a></li>
<li class="toctree-l1"><a class="reference internal" href="data.html">In-Memory Data Model</a></li>
<li class="toctree-l1"><a class="reference internal" href="ipc.html">IPC: Fast Streaming and Serialization</a></li>
-<li class="toctree-l1"><a class="reference internal" href="filesystems.html">Filesystem Interfaces</a></li>
+<li class="toctree-l1"><a class="reference internal" href="filesystems.html">File System Interfaces</a></li>
+<li class="toctree-l1"><a class="reference internal" href="plasma.html">The Plasma In-Memory Object Store</a></li>
<li class="toctree-l1"><a class="reference internal" href="pandas.html">Using PyArrow with pandas</a></li>
<li class="toctree-l1"><a class="reference internal" href="parquet.html">Reading and Writing the Apache Parquet Format</a></li>
<li class="toctree-l1"><a class="reference internal" href="api.html">API Reference</a></li>
@@ -97,7 +98,6 @@
<li><a class="reference internal" href="#memory-pools">Memory Pools</a></li>
<li><a class="reference internal" href="#on-disk-and-memory-mapped-files">On-Disk and Memory Mapped Files</a></li>
<li><a class="reference internal" href="#in-memory-reading-and-writing">In-Memory Reading and Writing</a></li>
-<li><a class="reference internal" href="#hadoop-filesystem">Hadoop Filesystem</a></li>
</ul>
</li>
</ul>
@@ -113,7 +113,7 @@
</a>
</li>
<li>
- <a href="data.html" title="Next Chapter: In-Memory Data Model"><span class="glyphicon glyphicon-chevron-right visible-sm"></span><span class="hidden-sm hidden-tablet">In-Memory Data Model »</span>
+ <a href="data.html" title="Next Chapter: In-Memory Data Model"><span class="glyphicon glyphicon-chevron-right visible-sm"></span><span class="hidden-sm hidden-tablet">In-Memory Dat... »</span>
</a>
</li>
@@ -171,12 +171,12 @@ built-in <cite>buffer protocol</cite> and <code class="docutils literal"><span c
implements the buffer protocol. Let’s consider a bytes object:</p>
<div class="highlight-ipython"><div class="highlight"><pre><span></span><span class="gp">In [1]: </span><span class="kn">import</span> <span class="nn">pyarrow</span> <span class="kn">as</span> <span class="nn">pa</span>
-<span class="gp">In [2]: </span><span class="n">data</span> <span class="o">=</span> <span class="n">b</span><span class="s1">'abcdefghijklmnopqrstuvwxyz'</span>
+<span class="gp">In [2]: </span><span class="n">data</span> <span class="o">=</span> <span class="sa">b</span><span class="s1">'abcdefghijklmnopqrstuvwxyz'</span>
<span class="gp">In [3]: </span><span class="n">buf</span> <span class="o">=</span> <span class="n">pa</span><span class="o">.</span><span class="n">frombuffer</span><span class="p">(</span><span class="n">data</span><span class="p">)</span>
<span class="gp">In [4]: </span><span class="n">buf</span>
-<span class="gh">Out[4]: </span><span class="go"><pyarrow.lib.Buffer at 0x2b9642a1ea40></span>
+<span class="gh">Out[4]: </span><span class="go"><pyarrow.lib.Buffer at 0x7f23fd67af10></span>
<span class="gp">In [5]: </span><span class="n">buf</span><span class="o">.</span><span class="n">size</span>
<span class="go"> Out[5]: 26</span>
@@ -192,7 +192,7 @@ view on the memory exported from the <code class="docutils literal"><span class=
<p>Buffers can be used in circumstances where a Python buffer or memoryview is
required, and such conversions are also zero-copy:</p>
<div class="highlight-ipython"><div class="highlight"><pre><span></span><span class="gp">In [7]: </span><span class="n">memoryview</span><span class="p">(</span><span class="n">buf</span><span class="p">)</span>
-<span class="gh">Out[7]: </span><span class="go"><memory at 0x2b96417c6dc8></span>
+<span class="gh">Out[7]: </span><span class="go"><memory at 0x7f23fd6a8108></span>
</pre></div>
</div>
</div>
@@ -228,7 +228,7 @@ memory maps</li>
as a file</li>
<li><a class="reference internal" href="generated/pyarrow.BufferOutputStream.html#pyarrow.BufferOutputStream" title="pyarrow.BufferOutputStream"><code class="xref py py-class docutils literal"><span class="pre">BufferOutputStream</span></code></a>, for writing data in-memory, producing a
Buffer at the end</li>
-<li><code class="xref py py-class docutils literal"><span class="pre">HdfsFile</span></code>, for reading and writing data to the Hadoop Filesystem</li>
+<li><a class="reference internal" href="generated/pyarrow.HdfsFile.html#pyarrow.HdfsFile" title="pyarrow.HdfsFile"><code class="xref py py-class docutils literal"><span class="pre">HdfsFile</span></code></a>, for reading and writing data to the Hadoop Filesystem</li>
<li><a class="reference internal" href="generated/pyarrow.PythonFile.html#pyarrow.PythonFile" title="pyarrow.PythonFile"><code class="xref py py-class docutils literal"><span class="pre">PythonFile</span></code></a>, for interfacing with Python file objects in C++</li>
</ul>
<p>We will discuss these in the following sections after explaining memory pools.</p>
@@ -239,7 +239,7 @@ Buffer at the end</li>
are tracked in an instance of <code class="docutils literal"><span class="pre">arrow::MemoryPool</span></code>. This means that we can
then precisely track amount of memory that has been allocated:</p>
<div class="highlight-ipython"><div class="highlight"><pre><span></span><span class="gp">In [8]: </span><span class="n">pa</span><span class="o">.</span><span class="n">total_allocated_bytes</span><span class="p">()</span>
-<span class="gh">Out[8]: </span><span class="go">13376</span>
+<span class="gh">Out[8]: </span><span class="go">0</span>
</pre></div>
</div>
<p>PyArrow uses a default built-in memory pool, but in the future there may be
@@ -247,15 +247,15 @@ additional memory pools (and subpools) to choose from. Let’s consider an
<code class="docutils literal"><span class="pre">BufferOutputStream</span></code>, which is like a <code class="docutils literal"><span class="pre">BytesIO</span></code>:</p>
<div class="highlight-ipython"><div class="highlight"><pre><span></span><span class="gp">In [9]: </span><span class="n">stream</span> <span class="o">=</span> <span class="n">pa</span><span class="o">.</span><span class="n">BufferOutputStream</span><span class="p">()</span>
-<span class="gp">In [10]: </span><span class="n">stream</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="n">b</span><span class="s1">'foo'</span><span class="p">)</span>
+<span class="gp">In [10]: </span><span class="n">stream</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="sa">b</span><span class="s1">'foo'</span><span class="p">)</span>
<span class="gp">In [11]: </span><span class="n">pa</span><span class="o">.</span><span class="n">total_allocated_bytes</span><span class="p">()</span>
-<span class="gh">Out[11]: </span><span class="go">13632</span>
+<span class="gh">Out[11]: </span><span class="go">256</span>
-<span class="gp">In [12]: </span><span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">1024</span><span class="p">):</span> <span class="n">stream</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="n">b</span><span class="s1">'foo'</span><span class="p">)</span>
+<span class="gp">In [12]: </span><span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">1024</span><span class="p">):</span> <span class="n">stream</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="sa">b</span><span class="s1">'foo'</span><span class="p">)</span>
<span class="gp">In [13]: </span><span class="n">pa</span><span class="o">.</span><span class="n">total_allocated_bytes</span><span class="p">()</span>
-<span class="gh">Out[13]: </span><span class="go">17472</span>
+<span class="gh">Out[13]: </span><span class="go">4096</span>
</pre></div>
</div>
<p>The default allocator requests memory in a minimum increment of 64 bytes. If
@@ -263,58 +263,7 @@ the stream is garbaged-collected, all of the memory is freed:</p>
<div class="highlight-ipython"><div class="highlight"><pre><span></span><span class="gp">In [14]: </span><span class="n">stream</span> <span class="o">=</span> <span class="bp">None</span>
<span class="gp">In [15]: </span><span class="n">pa</span><span class="o">.</span><span class="n">total_allocated_bytes</span><span class="p">()</span>
-<span class="gh">Out[15]: </span><span class="go">13376</span>
-</pre></div>
-</div>
-<p>Classes and functions that may allocate memory will often have an option to
-pass in a custom memory pool:</p>
-<div class="highlight-ipython"><div class="highlight"><pre><span></span><span class="gp">In [16]: </span><span class="n">my_pool</span> <span class="o">=</span> <span class="n">pa</span><span class="o">.</span><span class="n">jemalloc_memory_pool</span><span class="p">()</span>
-<span class="gt">---------------------------------------------------------------------------</span>
-<span class="ne">AttributeError</span><span class="g g-Whitespace"> </span>Traceback (most recent call last)
-<span class="nn"><ipython-input-16-e9c01b97bee0></span> in <span class="ni"><module></span><span class="nt">()</span>
-<span class="ne">----> </span><span class="mi">1</span> <span class="n">my_pool</span> <span class="o">=</span> <span class="n">pa</span><span class="o">.</span><span class="n">jemalloc_memory_pool</span><span class="p">()</span>
-
-<span class="ne">AttributeError</span>: module 'pyarrow' has no attribute 'jemalloc_memory_pool'
-
-<span class="gp">In [17]: </span><span class="n">my_pool</span>
-<span class="go"> -------------------
--------------------------------------------------------</span>
-<span class="go">NameError Traceback (most recent call last)</span>
-<span class="go"><ipython-input-17-310377b8dff5> in <module>()</span>
-<span class="go">----> 1 my_pool</span>
-
-<span class="go">NameError: name 'my_pool' is not defined</span>
-
-<span class="gp">In [18]: </span><span class="n">my_pool</span><span class="o">.</span><span class="n">bytes_allocated</span><span class="p">()</span>
-<span class="go">
---------------------------------------------------------------------------</span>
-<span class="go">NameError Traceback (most recent call last)</span>
-<span class="go"><ipython-input-18-ba01057c1aa4> in <module>()</span>
-<span class="go">----> 1 my_pool.bytes_allocated()</span>
-
-<span class="go">NameError: name 'my_pool' is not defined</span>
-
-<span class="gp">In [19]: </span><span class="n">stream</span> <span class="o">=</span> <span class="n">pa</span><span class="o">.</span><span class="n">BufferOutputStream</span><span class="p">(</span><span class="n">my_pool</span><span class="p">)</span>
-<span class="go">
---------------------------------------------------------------------------</span>
-<span class="go">NameError Traceback (most recent call last)</span>
-<span class="go"><ipython-input-19-89bc1e2a2ea7> in <module>()</span>
-<span class="go">----> 1 stream = pa.BufferOutputStream(my_pool)</span>
-
-<span class="go">NameError: name 'my_pool' is not defined</span>
-
-<span class="gp">In [20]: </span><span class="n">stream</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="n">b</span><span class="s1">'foo'</span><span class="p">)</span>
-<span class="go">
---------------------------------------------------------------------------</span>
-<span class="go">AttributeError Traceback (most recent call last)</span>
-<span class="go"><ipython-input-20-ae0e879b2a89> in <module>()</span>
-<span class="go">----> 1 stream.write(b'foo')</span>
-
-<span class="go">AttributeError: 'NoneType' object has no attribute 'write'</span>
-
-<span class="gp">In [21]: </span><span class="n">my_pool</span><span class="o">.</span><span class="n">bytes_allocated</span><span class="p">()</span>
-<span class="go">
---------------------------------------------------------------------------</span>
-<span class="go">NameError Traceback (most recent call last)</span>
-<span class="go"><ipython-input-21-ba01057c1aa4> in <module>()</span>
-<span class="go">----> 1 my_pool.bytes_allocated()</span>
-
-<span class="go">NameError: name 'my_pool' is not defined</span>
+<span class="gh">Out[15]: </span><span class="go">0</span>
</pre></div>
</div>
</div>
@@ -323,14 +272,14 @@ pass in a custom memory pool:</p>
<p>PyArrow includes two ways to interact with data on disk: standard operating
system-level file APIs, and memory-mapped files. In regular Python we can
write:</p>
-<div class="highlight-ipython"><div class="highlight"><pre><span></span><span class="gp">In [22]: </span><span class="k">with</span> <span class="nb">open</span><span class="p">(</span><span class="s1">'example.dat'</span><span class="p">,</span> <span class="s1">'wb'</span><span class="p">)</span> <span class="k">as</span> <span class="n">f</span><span class="p">:</span>
-<span class="gp"> ....: </span> <span class="n">f</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="n">b</span><span class="s1">'some example data'</span><span class="p">)</span>
+<div class="highlight-ipython"><div class="highlight"><pre><span></span><span class="gp">In [16]: </span><span class="k">with</span> <span class="nb">open</span><span class="p">(</span><span class="s1">'example.dat'</span><span class="p">,</span> <span class="s1">'wb'</span><span class="p">)</span> <span class="k">as</span> <span class="n">f</span><span class="p">:</span>
+<span class="gp"> ....: </span> <span class="n">f</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="sa">b</span><span class="s1">'some example data'</span><span class="p">)</span>
<span class="gp"> ....: </span>
</pre></div>
</div>
<p>Using pyarrow’s <code class="xref py py-class docutils literal"><span class="pre">OSFile</span></code> class, you can write:</p>
-<div class="highlight-ipython"><div class="highlight"><pre><span></span><span class="gp">In [23]: </span><span class="k">with</span> <span class="n">pa</span><span class="o">.</span><span class="n">OSFile</span><span class="p">(</span><span class="s1">'example2.dat'</span><span class="p">,</span> <span class="s1">'wb'</span><span class="p">)</span> <span class="k">as</span> <span class="n">f</span><span class="p">:</span>
-<span class="gp"> ....: </span> <span class="n">f</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="n">b</span><span class="s1">'some example data'</span><span class="p">)</span>
+<div class="highlight-ipython"><div class="highlight"><pre><span></span><span class="gp">In [17]: </span><span class="k">with</span> <span class="n">pa</span><span class="o">.</span><span class="n">OSFile</span><span class="p">(</span><span class="s1">'example2.dat'</span><span class="p">,</span> <span class="s1">'wb'</span><span class="p">)</span> <span class="k">as</span> <span class="n">f</span><span class="p">:</span>
+<span class="gp"> ....: </span> <span class="n">f</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="sa">b</span><span class="s1">'some example data'</span><span class="p">)</span>
<span class="gp"> ....: </span>
</pre></div>
</div>
@@ -339,28 +288,29 @@ write:</p>
<code class="xref py py-class docutils literal"><span class="pre">OSFile</span></code> allocates new memory on each read, like Python file
objects. In reads from memory maps, the library constructs a buffer referencing
the mapped memory without any memory allocation or copying:</p>
-<div class="highlight-ipython"><div class="highlight"><pre><span></span><span class="gp">In [24]: </span><span class="n">file_obj</span> <span class="o">=</span> <span class="n">pa</span><span class="o">.</span><span class="n">OSFile</span><span class="p">(</span><span class="s1">'example.dat'</span><span class="p">)</span>
+<div class="highlight-ipython"><div class="highlight"><pre><span></span><span class="gp">In [18]: </span><span class="n">file_obj</span> <span class="o">=</span> <span class="n">pa</span><span class="o">.</span><span class="n">OSFile</span><span class="p">(</span><span class="s1">'example.dat'</span><span class="p">)</span>
-<span class="gp">In [25]: </span><span class="n">mmap</span> <span class="o">=</span> <span class="n">pa</span><span class="o">.</span><span class="n">memory_map</span><span class="p">(</span><span class="s1">'example.dat'</span><span class="p">)</span>
+<span class="gp">In [19]: </span><span class="n">mmap</span> <span class="o">=</span> <span class="n">pa</span><span class="o">.</span><span class="n">memory_map</span><span class="p">(</span><span class="s1">'example.dat'</span><span class="p">)</span>
-<span class="gp">In [26]: </span><span class="n">file_obj</span><span class="o">.</span><span class="n">read</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
-<span class="gh">Out[26]: </span><span class="go">b'some'</span>
+<span class="gp">In [20]: </span><span class="n">file_obj</span><span class="o">.</span><span class="n">read</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
+<span class="gh">Out[20]: </span><span class="go">b'some'</span>
-<span class="gp">In [27]: </span><span class="n">mmap</span><span class="o">.</span><span class="n">read</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
-<span class="go"> Out[27]: b'some'</span>
+<span class="gp">In [21]: </span><span class="n">mmap</span><span class="o">.</span><span class="n">read</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
+<span class="go"> Out[21]: b'some'</span>
</pre></div>
</div>
<p>The <code class="docutils literal"><span class="pre">read</span></code> method implements the standard Python file <code class="docutils literal"><span class="pre">read</span></code> API. To read
into Arrow Buffer objects, use <code class="docutils literal"><span class="pre">read_buffer</span></code>:</p>
-<div class="highlight-ipython"><div class="highlight"><pre><span></span><span class="gp">In [28]: </span><span class="n">mmap</span><span class="o">.</span><span class="n">seek</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
+<div class="highlight-ipython"><div class="highlight"><pre><span></span><span class="gp">In [22]: </span><span class="n">mmap</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="gh">Out[22]: </span><span class="go">0</span>
-<span class="gp">In [29]: </span><span class="n">buf</span> <span class="o">=</span> <span class="n">mmap</span><span class="o">.</span><span class="n">read_buffer</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
+<span class="gp">In [23]: </span><span class="n">buf</span> <span class="o">=</span> <span class="n">mmap</span><span class="o">.</span><span class="n">read_buffer</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
-<span class="gp">In [30]: </span><span class="k">print</span><span class="p">(</span><span class="n">buf</span><span class="p">)</span>
-<span class="go"><pyarrow.lib.Buffer object at 0x2b96432dcab0></span>
+<span class="gp">In [24]: </span><span class="k">print</span><span class="p">(</span><span class="n">buf</span><span class="p">)</span>
+<span class="go"><pyarrow.lib.Buffer object at 0x7f23fd39f458></span>
-<span class="gp">In [31]: </span><span class="n">buf</span><span class="o">.</span><span class="n">to_pybytes</span><span class="p">()</span>
-<span class="go"> Out[31]: b'some'</span>
+<span class="gp">In [25]: </span><span class="n">buf</span><span class="o">.</span><span class="n">to_pybytes</span><span class="p">()</span>
+<span class="go"> Out[25]: b'some'</span>
</pre></div>
</div>
<p>Many tools in PyArrow, particular the Apache Parquet interface and the file and
@@ -371,34 +321,29 @@ types than with normal Python file objects.</p>
<h2>In-Memory Reading and Writing<a class="headerlink" href="#in-memory-reading-and-writing" title="Permalink to this headline">¶</a></h2>
<p>To assist with serialization and deserialization of in-memory data, we have
file interfaces that can read and write to Arrow Buffers.</p>
-<div class="highlight-ipython"><div class="highlight"><pre><span></span><span class="gp">In [32]: </span><span class="n">writer</span> <span class="o">=</span> <span class="n">pa</span><span class="o">.</span><span class="n">BufferOutputStream</span><span class="p">()</span>
+<div class="highlight-ipython"><div class="highlight"><pre><span></span><span class="gp">In [26]: </span><span class="n">writer</span> <span class="o">=</span> <span class="n">pa</span><span class="o">.</span><span class="n">BufferOutputStream</span><span class="p">()</span>
-<span class="gp">In [33]: </span><span class="n">writer</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="n">b</span><span class="s1">'hello, friends'</span><span class="p">)</span>
+<span class="gp">In [27]: </span><span class="n">writer</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="sa">b</span><span class="s1">'hello, friends'</span><span class="p">)</span>
-<span class="gp">In [34]: </span><span class="n">buf</span> <span class="o">=</span> <span class="n">writer</span><span class="o">.</span><span class="n">get_result</span><span class="p">()</span>
+<span class="gp">In [28]: </span><span class="n">buf</span> <span class="o">=</span> <span class="n">writer</span><span class="o">.</span><span class="n">get_result</span><span class="p">()</span>
-<span class="gp">In [35]: </span><span class="n">buf</span>
-<span class="gh">Out[35]: </span><span class="go"><pyarrow.lib.Buffer at 0x2b96432c94c8></span>
+<span class="gp">In [29]: </span><span class="n">buf</span>
+<span class="gh">Out[29]: </span><span class="go"><pyarrow.lib.Buffer at 0x7f23fd408538></span>
-<span class="gp">In [36]: </span><span class="n">buf</span><span class="o">.</span><span class="n">size</span>
-<span class="go"> Out[36]: 14</span>
+<span class="gp">In [30]: </span><span class="n">buf</span><span class="o">.</span><span class="n">size</span>
+<span class="go"> Out[30]: 14</span>
-<span class="gp">In [37]: </span><span class="n">reader</span> <span class="o">=</span> <span class="n">pa</span><span class="o">.</span><span class="n">BufferReader</span><span class="p">(</span><span class="n">buf</span><span class="p">)</span>
+<span class="gp">In [31]: </span><span class="n">reader</span> <span class="o">=</span> <span class="n">pa</span><span class="o">.</span><span class="n">BufferReader</span><span class="p">(</span><span class="n">buf</span><span class="p">)</span>
-<span class="gp">In [38]: </span><span class="n">reader</span><span class="o">.</span><span class="n">seek</span><span class="p">(</span><span class="mi">7</span><span class="p">)</span>
+<span class="gp">In [32]: </span><span class="n">reader</span><span class="o">.</span><span class="n">seek</span><span class="p">(</span><span class="mi">7</span><span class="p">)</span>
+<span class="gh">Out[32]: </span><span class="go">7</span>
-<span class="gp">In [39]: </span><span class="n">reader</span><span class="o">.</span><span class="n">read</span><span class="p">(</span><span class="mi">7</span><span class="p">)</span>
-<span class="gh">Out[39]: </span><span class="go">b'friends'</span>
+<span class="gp">In [33]: </span><span class="n">reader</span><span class="o">.</span><span class="n">read</span><span class="p">(</span><span class="mi">7</span><span class="p">)</span>
+<span class="go"> Out[33]: b'friends'</span>
</pre></div>
</div>
<p>These have similar semantics to Python’s built-in <code class="docutils literal"><span class="pre">io.BytesIO</span></code>.</p>
</div>
-<div class="section" id="hadoop-filesystem">
-<h2>Hadoop Filesystem<a class="headerlink" href="#hadoop-filesystem" title="Permalink to this headline">¶</a></h2>
-<p><code class="xref py py-class docutils literal"><span class="pre">HdfsFile</span></code> is an implementation of <a class="reference internal" href="generated/pyarrow.NativeFile.html#pyarrow.NativeFile" title="pyarrow.NativeFile"><code class="xref py py-class docutils literal"><span class="pre">NativeFile</span></code></a>
-that can read and write to the Hadoop filesytem. Read more in the
-<a class="reference internal" href="filesystems.html#hdfs"><span class="std std-ref">Filesystems Section</span></a>.</p>
-</div>
</div>
http://git-wip-us.apache.org/repos/asf/arrow-site/blob/4d4a3202/docs/python/objects.inv
----------------------------------------------------------------------
diff --git a/docs/python/objects.inv b/docs/python/objects.inv
index afd0b36..7565107 100644
Binary files a/docs/python/objects.inv and b/docs/python/objects.inv differ
http://git-wip-us.apache.org/repos/asf/arrow-site/blob/4d4a3202/docs/python/pandas.html
----------------------------------------------------------------------
diff --git a/docs/python/pandas.html b/docs/python/pandas.html
index bd45d97..bd2f7a4 100644
--- a/docs/python/pandas.html
+++ b/docs/python/pandas.html
@@ -31,7 +31,7 @@
<link rel="index" title="Index" href="genindex.html" />
<link rel="search" title="Search" href="search.html" />
<link rel="next" title="Reading and Writing the Apache Parquet Format" href="parquet.html" />
- <link rel="prev" title="Filesystem Interfaces" href="filesystems.html" />
+ <link rel="prev" title="The Plasma In-Memory Object Store" href="plasma.html" />
<meta charset='utf-8'>
<meta http-equiv='X-UA-Compatible' content='IE=edge,chrome=1'>
<meta name='viewport' content='width=device-width, initial-scale=1.0, maximum-scale=1'>
@@ -73,7 +73,8 @@
<li class="toctree-l1"><a class="reference internal" href="memory.html">Memory and IO Interfaces</a></li>
<li class="toctree-l1"><a class="reference internal" href="data.html">In-Memory Data Model</a></li>
<li class="toctree-l1"><a class="reference internal" href="ipc.html">IPC: Fast Streaming and Serialization</a></li>
-<li class="toctree-l1"><a class="reference internal" href="filesystems.html">Filesystem Interfaces</a></li>
+<li class="toctree-l1"><a class="reference internal" href="filesystems.html">File System Interfaces</a></li>
+<li class="toctree-l1"><a class="reference internal" href="plasma.html">The Plasma In-Memory Object Store</a></li>
<li class="toctree-l1 current"><a class="current reference internal" href="#">Using PyArrow with pandas</a></li>
<li class="toctree-l1"><a class="reference internal" href="parquet.html">Reading and Writing the Apache Parquet Format</a></li>
<li class="toctree-l1"><a class="reference internal" href="api.html">API Reference</a></li>
@@ -110,7 +111,7 @@
<li>
- <a href="filesystems.html" title="Previous Chapter: Filesystem Interfaces"><span class="glyphicon glyphicon-chevron-left visible-sm"></span><span class="hidden-sm hidden-tablet">« Filesystem Interfaces</span>
+ <a href="plasma.html" title="Previous Chapter: The Plasma In-Memory Object Store"><span class="glyphicon glyphicon-chevron-left visible-sm"></span><span class="hidden-sm hidden-tablet">« The Plasma In...</span>
</a>
</li>
<li>
@@ -181,7 +182,7 @@ conversion.</p>
<h2>Series<a class="headerlink" href="#series" title="Permalink to this headline">¶</a></h2>
<p>In Arrow, the most similar structure to a pandas Series is an Array.
It is a vector that contains data of the same type as linear memory. You can
-convert a pandas Series to an Arrow Array using <a class="reference internal" href="generated/pyarrow.Array.html#pyarrow.Array.from_pandas" title="pyarrow.Array.from_pandas"><code class="xref py py-meth docutils literal"><span class="pre">pyarrow.Array.from_pandas()</span></code></a>.
+convert a pandas Series to an Arrow Array using <code class="xref py py-meth docutils literal"><span class="pre">pyarrow.Array.from_pandas()</span></code>.
As Arrow Arrays are always nullable, you can supply an optional mask using
the <code class="docutils literal"><span class="pre">mask</span></code> parameter to mark all null-entries.</p>
</div>