You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@arrow.apache.org by we...@apache.org on 2017/07/17 13:06:16 UTC
[03/15] arrow-site git commit: Update pyarrow Python documentation

http://git-wip-us.apache.org/repos/asf/arrow-site/blob/796ce23f/docs/python/memory.html
----------------------------------------------------------------------
diff --git a/docs/python/memory.html b/docs/python/memory.html
index f6e7847..7bbbd1a 100644
--- a/docs/python/memory.html
+++ b/docs/python/memory.html
@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 
+
 <html xmlns="http://www.w3.org/1999/xhtml">
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
@@ -37,7 +38,7 @@
 <meta name="apple-mobile-web-app-capable" content="yes">
 
   </head>
-  <body>
+  <body role="document">
 
   <div id="navbar" class="navbar navbar-default navbar-fixed-top">
     <div class="container">
@@ -148,7 +149,7 @@
       
   <div class="section" id="memory-and-io-interfaces">
 <span id="io"></span><h1>Memory and IO Interfaces<a class="headerlink" href="#memory-and-io-interfaces" title="Permalink to this headline">¶</a></h1>
-<p>This section will introduce you to the major concepts in PyArrow’s memory
+<p>This section will introduce you to the major concepts in PyArrow&#8217;s memory
 management and IO systems:</p>
 <ul class="simple">
 <li>Buffers</li>
@@ -164,34 +165,34 @@ not own. <code class="docutils literal"><span class="pre">arrow::Buffer</span></
 reference other Buffers, while preserving memory lifetime and clean
 parent-child relationships.</p>
 <p>There are many implementations of <code class="docutils literal"><span class="pre">arrow::Buffer</span></code>, but they all provide a
-standard interface: a data pointer and length. This is similar to Python’s
+standard interface: a data pointer and length. This is similar to Python&#8217;s
 built-in <cite>buffer protocol</cite> and <code class="docutils literal"><span class="pre">memoryview</span></code> objects.</p>
 <p>A <a class="reference internal" href="generated/pyarrow.Buffer.html#pyarrow.Buffer" title="pyarrow.Buffer"><code class="xref py py-class docutils literal"><span class="pre">Buffer</span></code></a> can be created from any Python object which
-implements the buffer protocol. Let’s consider a bytes object:</p>
+implements the buffer protocol. Let&#8217;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="sa">b</span><span class="s1">&#39;abcdefghijklmnopqrstuvwxyz&#39;</span>
+<span class="gp">In [2]: </span><span class="n">data</span> <span class="o">=</span> <span class="n">b</span><span class="s1">&#39;abcdefghijklmnopqrstuvwxyz&#39;</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">&lt;pyarrow.lib.Buffer at 0x7efc46c9a6c0&gt;</span>
+<span class="gh">Out[4]: </span><span class="go">&lt;pyarrow.lib.Buffer at 0x2b9642a1ea40&gt;</span>
 
 <span class="gp">In [5]: </span><span class="n">buf</span><span class="o">.</span><span class="n">size</span>
-<span class="gh">Out[5]: </span><span class="go">26</span>
+<span class="go">Out[5]: 26</span>
 </pre></div>
 </div>
 <p>Creating a Buffer in this way does not allocate any memory; it is a zero-copy
 view on the memory exported from the <code class="docutils literal"><span class="pre">data</span></code> bytes object.</p>
-<p>The Buffer’s <code class="docutils literal"><span class="pre">to_pybytes</span></code> method can convert to a Python byte string:</p>
+<p>The Buffer&#8217;s <code class="docutils literal"><span class="pre">to_pybytes</span></code> method can convert to a Python byte string:</p>
 <div class="highlight-ipython"><div class="highlight"><pre><span></span><span class="gp">In [6]: </span><span class="n">buf</span><span class="o">.</span><span class="n">to_pybytes</span><span class="p">()</span>
-<span class="gh">Out[6]: </span><span class="go">&#39;abcdefghijklmnopqrstuvwxyz&#39;</span>
+<span class="gh">Out[6]: </span><span class="go">b&#39;abcdefghijklmnopqrstuvwxyz&#39;</span>
 </pre></div>
 </div>
 <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">&lt;memory at 0x7efc46c9b050&gt;</span>
+<span class="gh">Out[7]: </span><span class="go">&lt;memory at 0x2b96417c6dc8&gt;</span>
 </pre></div>
 </div>
 </div>
@@ -206,7 +207,7 @@ IO objects:</p>
 <li>Write-only files supporting random access</li>
 <li>File supporting reads, writes, and random access</li>
 </ul>
-<p>In the the interest of making these objects behave more like Python’s built-in
+<p>In the the interest of making these objects behave more like Python&#8217;s built-in
 <code class="docutils literal"><span class="pre">file</span></code> objects, we have defined a <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> base class
 which is intended to mimic Python files and able to be used in functions where
 a Python file (such as <code class="docutils literal"><span class="pre">file</span></code> or <code class="docutils literal"><span class="pre">BytesIO</span></code>) is expected.</p>
@@ -219,7 +220,7 @@ not need to acquire the Python GIL</li>
 </ul>
 <p>There are several kinds 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> options available:</p>
 <ul class="simple">
-<li><code class="xref py py-class docutils literal"><span class="pre">OSFile</span></code>, a native file that uses your operating system’s
+<li><code class="xref py py-class docutils literal"><span class="pre">OSFile</span></code>, a native file that uses your operating system&#8217;s
 file descriptors</li>
 <li><a class="reference internal" href="generated/pyarrow.MemoryMappedFile.html#pyarrow.MemoryMappedFile" title="pyarrow.MemoryMappedFile"><code class="xref py py-class docutils literal"><span class="pre">MemoryMappedFile</span></code></a>, for reading (zero-copy) and writing with
 memory maps</li>
@@ -238,23 +239,23 @@ 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">13184</span>
+<span class="gh">Out[8]: </span><span class="go">13376</span>
 </pre></div>
 </div>
 <p>PyArrow uses a default built-in memory pool, but in the future there may be
-additional memory pools (and subpools) to choose from. Let’s consider an
+additional memory pools (and subpools) to choose from. Let&#8217;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="sa">b</span><span class="s1">&#39;foo&#39;</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">&#39;foo&#39;</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">13440</span>
+<span class="gh">Out[11]: </span><span class="go">13632</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">&#39;foo&#39;</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="n">b</span><span class="s1">&#39;foo&#39;</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">17280</span>
+<span class="gh">Out[13]: </span><span class="go">17472</span>
 </pre></div>
 </div>
 <p>The default allocator requests memory in a minimum increment of 64 bytes. If
@@ -262,7 +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">13184</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
@@ -273,47 +274,47 @@ pass in a custom memory pool:</p>
 <span class="nn">&lt;ipython-input-16-e9c01b97bee0&gt;</span> in <span class="ni">&lt;module&gt;</span><span class="nt">()</span>
 <span class="ne">----&gt; </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>: &#39;module&#39; object has no attribute &#39;jemalloc_memory_pool&#39;
+<span class="ne">AttributeError</span>: module &#39;pyarrow&#39; has no attribute &#39;jemalloc_memory_pool&#39;
 
 <span class="gp">In [17]: </span><span class="n">my_pool</span>
-<span class="gt">---------------------------------------------------------------------------</span>
-<span class="ne">NameError</span><span class="g g-Whitespace">                                 </span>Traceback (most recent call last)
-<span class="nn">&lt;ipython-input-17-310377b8dff5&gt;</span> in <span class="ni">&lt;module&gt;</span><span class="nt">()</span>
-<span class="ne">----&gt; </span><span class="mi">1</span> <span class="n">my_pool</span>
+<span class="go">-------------------
 --------------------------------------------------------</span>
+<span class="go">NameError                                 Traceback (most recent call last)</span>
+<span class="go">&lt;ipython-input-17-310377b8dff5&gt; in &lt;module&gt;()</span>
+<span class="go">----&gt; 1 my_pool</span>
 
-<span class="ne">NameError</span>: name &#39;my_pool&#39; is not defined
+<span class="go">NameError: name &#39;my_pool&#39; 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="gt">---------------------------------------------------------------------------</span>
-<span class="ne">NameError</span><span class="g g-Whitespace">                                 </span>Traceback (most recent call last)
-<span class="nn">&lt;ipython-input-18-ba01057c1aa4&gt;</span> in <span class="ni">&lt;module&gt;</span><span class="nt">()</span>
-<span class="ne">----&gt; </span><span class="mi">1</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">&lt;ipython-input-18-ba01057c1aa4&gt; in &lt;module&gt;()</span>
+<span class="go">----&gt; 1 my_pool.bytes_allocated()</span>
 
-<span class="ne">NameError</span>: name &#39;my_pool&#39; is not defined
+<span class="go">NameError: name &#39;my_pool&#39; 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="gt">---------------------------------------------------------------------------</span>
-<span class="ne">NameError</span><span class="g g-Whitespace">                                 </span>Traceback (most recent call last)
-<span class="nn">&lt;ipython-input-19-89bc1e2a2ea7&gt;</span> in <span class="ni">&lt;module&gt;</span><span class="nt">()</span>
-<span class="ne">----&gt; </span><span class="mi">1</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">&lt;ipython-input-19-89bc1e2a2ea7&gt; in &lt;module&gt;()</span>
+<span class="go">----&gt; 1 stream = pa.BufferOutputStream(my_pool)</span>
 
-<span class="ne">NameError</span>: name &#39;my_pool&#39; is not defined
+<span class="go">NameError: name &#39;my_pool&#39; 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="sa">b</span><span class="s1">&#39;foo&#39;</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">&lt;ipython-input-20-ae0e879b2a89&gt;</span> in <span class="ni">&lt;module&gt;</span><span class="nt">()</span>
-<span class="ne">----&gt; </span><span class="mi">1</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">&#39;foo&#39;</span><span class="p">)</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">&#39;foo&#39;</span><span class="p">)</span>
+<span class="go">
 
 
 
 
 
 
 
 
 
 
 
 
 ---------------------------------------------------------------------------</span>
+<span class="go">AttributeError                            Traceback (most recent call last)</span>
+<span class="go">&lt;ipython-input-20-ae0e879b2a89&gt; in &lt;module&gt;()</span>
+<span class="go">----&gt; 1 stream.write(b&#39;foo&#39;)</span>
 
-<span class="ne">AttributeError</span>: &#39;NoneType&#39; object has no attribute &#39;write&#39;
+<span class="go">AttributeError: &#39;NoneType&#39; object has no attribute &#39;write&#39;</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="gt">---------------------------------------------------------------------------</span>
-<span class="ne">NameError</span><span class="g g-Whitespace">                                 </span>Traceback (most recent call last)
-<span class="nn">&lt;ipython-input-21-ba01057c1aa4&gt;</span> in <span class="ni">&lt;module&gt;</span><span class="nt">()</span>
-<span class="ne">----&gt; </span><span class="mi">1</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">&lt;ipython-input-21-ba01057c1aa4&gt; in &lt;module&gt;()</span>
+<span class="go">----&gt; 1 my_pool.bytes_allocated()</span>
 
-<span class="ne">NameError</span>: name &#39;my_pool&#39; is not defined
+<span class="go">NameError: name &#39;my_pool&#39; is not defined</span>
 </pre></div>
 </div>
 </div>
@@ -323,13 +324,13 @@ pass in a custom memory pool:</p>
 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">&#39;example.dat&#39;</span><span class="p">,</span> <span class="s1">&#39;wb&#39;</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">&#39;some example data&#39;</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">&#39;some example data&#39;</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>
+<p>Using pyarrow&#8217;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">&#39;example2.dat&#39;</span><span class="p">,</span> <span class="s1">&#39;wb&#39;</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">&#39;some example data&#39;</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">&#39;some example data&#39;</span><span class="p">)</span>
 <span class="gp">   ....: </span>
 </pre></div>
 </div>
@@ -343,10 +344,10 @@ the mapped memory without any memory allocation or copying:</p>
 <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">&#39;example.dat&#39;</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">&#39;some&#39;</span>
+<span class="gh">Out[26]: </span><span class="go">b&#39;some&#39;</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="gh">Out[27]: </span><span class="go">&#39;some&#39;</span>
+<span class="go">Out[27]: b&#39;some&#39;</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
@@ -356,10 +357,10 @@ into Arrow Buffer objects, use <code class="docutils literal"><span class="pre">
 <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 [30]: </span><span class="k">print</span><span class="p">(</span><span class="n">buf</span><span class="p">)</span>
-<span class="go">&lt;pyarrow.lib.Buffer object at 0x7efc44162730&gt;</span>
+<span class="go">&lt;pyarrow.lib.Buffer object at 0x2b96432dcab0&gt;</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="gh">Out[31]: </span><span class="go">&#39;some&#39;</span>
+<span class="go">Out[31]: b&#39;some&#39;</span>
 </pre></div>
 </div>
 <p>Many tools in PyArrow, particular the Apache Parquet interface and the file and
@@ -372,25 +373,25 @@ types than with normal Python file objects.</p>
 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>
 
-<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="sa">b</span><span class="s1">&#39;hello, friends&#39;</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">&#39;hello, friends&#39;</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 [35]: </span><span class="n">buf</span>
-<span class="gh">Out[35]: </span><span class="go">&lt;pyarrow.lib.Buffer at 0x7efc44162bc8&gt;</span>
+<span class="gh">Out[35]: </span><span class="go">&lt;pyarrow.lib.Buffer at 0x2b96432c94c8&gt;</span>
 
 <span class="gp">In [36]: </span><span class="n">buf</span><span class="o">.</span><span class="n">size</span>
-<span class="gh">Out[36]: </span><span class="go">14</span>
+<span class="go">Out[36]: 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 [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 [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">&#39;friends&#39;</span>
+<span class="gh">Out[39]: </span><span class="go">b&#39;friends&#39;</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>
+<p>These have similar semantics to Python&#8217;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>
@@ -413,7 +414,7 @@ that can read and write to the Hadoop filesytem. Read more in the
     </p>
     <p>
         &copy; Copyright 2016-2017 Apache Software Foundation.<br/>
-      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.6.2.<br/>
+      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.5.5.<br/>
     </p>
   </div>
 </footer>

http://git-wip-us.apache.org/repos/asf/arrow-site/blob/796ce23f/docs/python/objects.inv
----------------------------------------------------------------------
diff --git a/docs/python/objects.inv b/docs/python/objects.inv
index 3c154c1..afd0b36 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/796ce23f/docs/python/pandas.html
----------------------------------------------------------------------
diff --git a/docs/python/pandas.html b/docs/python/pandas.html
index 8a8b25f..bd45d97 100644
--- a/docs/python/pandas.html
+++ b/docs/python/pandas.html
@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 
+
 <html xmlns="http://www.w3.org/1999/xhtml">
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
@@ -37,7 +38,7 @@
 <meta name="apple-mobile-web-app-capable" content="yes">
 
   </head>
-  <body>
+  <body role="document">
 
   <div id="navbar" class="navbar navbar-default navbar-fixed-top">
     <div class="container">
@@ -148,7 +149,7 @@
     <div class="col-md-12 content">
       
   <div class="section" id="using-pyarrow-with-pandas">
-<h1>Using PyArrow with pandas<a class="headerlink" href="#using-pyarrow-with-pandas" title="Permalink to this headline">¶</a></h1>
+<span id="pandas"></span><h1>Using PyArrow with pandas<a class="headerlink" href="#using-pyarrow-with-pandas" title="Permalink to this headline">¶</a></h1>
 <p>To interface with pandas, PyArrow provides various conversion routines to
 consume pandas structures and convert back to them.</p>
 <div class="section" id="dataframes">
@@ -159,7 +160,7 @@ supports flat columns, the Table also provides nested columns, thus it can
 represent more data than a DataFrame, so a full conversion is not always possible.</p>
 <p>Conversion from a Table to a DataFrame is done by calling
 <code class="xref py py-meth docutils literal"><span class="pre">pyarrow.table.Table.to_pandas()</span></code>. The inverse is then achieved by using
-<code class="xref py py-meth docutils literal"><span class="pre">pyarrow.Table.from_pandas()</span></code>. This conversion routine provides the
+<a class="reference internal" href="generated/pyarrow.Table.html#pyarrow.Table.from_pandas" title="pyarrow.Table.from_pandas"><code class="xref py py-meth docutils literal"><span class="pre">pyarrow.Table.from_pandas()</span></code></a>. This conversion routine provides the
 convience parameter <code class="docutils literal"><span class="pre">timestamps_to_ms</span></code>. Although Arrow supports timestamps of
 different resolutions, pandas only supports nanosecond timestamps and most
 other systems (e.g. Parquet) only work on millisecond timestamps. This parameter
@@ -180,7 +181,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 <code class="xref py py-meth docutils literal"><span class="pre">pyarrow.array.from_pandas_series()</span></code>.
+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>.
 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>
@@ -293,7 +294,7 @@ support for some types.</p>
     </p>
     <p>
         &copy; Copyright 2016-2017 Apache Software Foundation.<br/>
-      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.6.2.<br/>
+      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.5.5.<br/>
     </p>
   </div>
 </footer>