(arrow-nanoarrow) branch asf-site updated: update documentation for tag main

github-bot Fri, 21 Aug 2026 20:25:19 -0700

This is an automated email from the ASF dual-hosted git repository.

github-actions[bot] pushed a commit to branch asf-site
in repository https://gitbox.apache.org/repos/asf/arrow-nanoarrow.git



The following commit(s) were added to refs/heads/asf-site by this push:
     new 81563f76 update documentation for tag main
81563f76 is described below

commit 81563f76aecfa68b1e769cd662251ec7a8280e18
Author: GitHub Actions <[email protected]>
AuthorDate: Sat Aug 22 03:24:52 2026 +0000

    update documentation for tag main
---
 main/.doctrees/environment.pickle       | Bin 1172121 -> 1172121 bytes
 main/getting-started/cpp.html           |  34 +++++++++---------
 main/getting-started/python.html        |  30 ++++++++--------
 main/getting-started/r.html             |  30 ++++++++--------
 main/index.html                         |  10 +++---
 main/r/pkgdown.yml                      |   2 +-
 main/reference/python/advanced.html     |  28 +++++++--------
 main/reference/python/array-stream.html |  36 +++++++++----------
 main/reference/python/array.html        |  40 ++++++++++-----------
 main/reference/python/schema.html       |  60 ++++++++++++++++----------------
 10 files changed, 135 insertions(+), 135 deletions(-)

diff --git a/main/.doctrees/environment.pickle 
b/main/.doctrees/environment.pickle
index 56210acf..7d31f1cf 100644
Binary files a/main/.doctrees/environment.pickle and 
b/main/.doctrees/environment.pickle differ
diff --git a/main/getting-started/cpp.html b/main/getting-started/cpp.html
index 6620c7b6..fb9a73e5 100644
--- a/main/getting-started/cpp.html
+++ b/main/getting-started/cpp.html
@@ -539,7 +539,7 @@ in another file include something from another project.</p>
 <div class="highlight-c notranslate"><div 
class="highlight"><pre><span></span><span class="c1">// Builds an ArrowArray of 
type string that will contain one element for each line</span>
 <span class="c1">// in src and places it into out.</span>
 <span class="c1">//</span>
-<span class="c1">// On success, returns {0, &quot;&quot;}; on error, returns 
{&lt;errno code&gt;, &lt;error message&gt;}</span>
+<span class="c1">// On success, returns {0, ""}; on error, returns {&lt;errno 
code&gt;, &lt;error message&gt;}</span>
 <span class="n">std</span><span class="o">::</span><span 
class="n">pair</span><span class="o">&lt;</span><span 
class="kt">int</span><span class="p">,</span><span class="w"> </span><span 
class="n">std</span><span class="o">::</span><span class="n">string</span><span 
class="o">&gt;</span><span class="w"> </span><span 
class="n">linesplitter_read</span><span class="p">(</span><span 
class="k">const</span><span class="w"> </span><span class="n">std</span><span 
class="o">::</span><span class="n [...]
 <span class="w">                                              </span><span 
class="k">struct</span><span class="w"> </span><span 
class="nc">ArrowArray</span><span class="o">*</span><span class="w"> 
</span><span class="n">out</span><span class="p">);</span>
 
@@ -651,17 +651,17 @@ that we can build it using VSCode’s C/C++/CMake 
integration:</p>
 <span class="cp">#include</span><span class="w"> </span><span 
class="cpf">&lt;string&gt;</span>
 <span class="cp">#include</span><span class="w"> </span><span 
class="cpf">&lt;utility&gt;</span>
 
-<span class="cp">#include</span><span class="w"> </span><span 
class="cpf">&quot;nanoarrow/nanoarrow.hpp&quot;</span>
+<span class="cp">#include</span><span class="w"> </span><span 
class="cpf">"nanoarrow/nanoarrow.hpp"</span>
 
-<span class="cp">#include</span><span class="w"> </span><span 
class="cpf">&quot;linesplitter.h&quot;</span>
+<span class="cp">#include</span><span class="w"> </span><span 
class="cpf">"linesplitter.h"</span>
 
 <span class="n">std</span><span class="o">::</span><span 
class="n">pair</span><span class="o">&lt;</span><span 
class="kt">int</span><span class="p">,</span><span class="w"> </span><span 
class="n">std</span><span class="o">::</span><span class="n">string</span><span 
class="o">&gt;</span><span class="w"> </span><span 
class="n">linesplitter_read</span><span class="p">(</span><span 
class="k">const</span><span class="w"> </span><span class="n">std</span><span 
class="o">::</span><span class="n [...]
 <span class="w">                                              </span><span 
class="k">struct</span><span class="w"> </span><span 
class="nc">ArrowArray</span><span class="o">*</span><span class="w"> 
</span><span class="n">out</span><span class="p">)</span><span class="w"> 
</span><span class="p">{</span>
-<span class="w">  </span><span class="k">return</span><span class="w"> 
</span><span class="p">{</span><span class="n">ENOTSUP</span><span 
class="p">,</span><span class="w"> </span><span 
class="s">&quot;&quot;</span><span class="p">};</span>
+<span class="w">  </span><span class="k">return</span><span class="w"> 
</span><span class="p">{</span><span class="n">ENOTSUP</span><span 
class="p">,</span><span class="w"> </span><span class="s">""</span><span 
class="p">};</span>
 <span class="p">}</span>
 
 <span class="n">std</span><span class="o">::</span><span 
class="n">pair</span><span class="o">&lt;</span><span 
class="kt">int</span><span class="p">,</span><span class="w"> </span><span 
class="n">std</span><span class="o">::</span><span class="n">string</span><span 
class="o">&gt;</span><span class="w"> </span><span 
class="n">linesplitter_write</span><span class="p">(</span><span 
class="k">struct</span><span class="w"> </span><span 
class="nc">ArrowArray</span><span class="o">*</span><span [...]
-<span class="w">  </span><span class="k">return</span><span class="w"> 
</span><span class="p">{</span><span class="n">ENOTSUP</span><span 
class="p">,</span><span class="w"> </span><span 
class="s">&quot;&quot;</span><span class="p">};</span>
+<span class="w">  </span><span class="k">return</span><span class="w"> 
</span><span class="p">{</span><span class="n">ENOTSUP</span><span 
class="p">,</span><span class="w"> </span><span class="s">""</span><span 
class="p">};</span>
 <span class="p">}</span>
 </pre></div>
 </div>
@@ -710,7 +710,7 @@ detecting the number of characters until the next <code 
class="docutils literal
 end-of-string.</p>
 <div class="highlight-cpp notranslate"><div 
class="highlight"><pre><span></span><span class="k">static</span><span 
class="w"> </span><span class="kt">int64_t</span><span class="w"> </span><span 
class="nf">find_newline</span><span class="p">(</span><span 
class="k">const</span><span class="w"> </span><span 
class="n">ArrowStringView</span><span class="o">&amp;</span><span class="w"> 
</span><span class="n">src</span><span class="p">)</span><span class="w"> 
</span><span class="p">{</span>
 <span class="w">  </span><span class="k">for</span><span class="w"> 
</span><span class="p">(</span><span class="kt">int64_t</span><span class="w"> 
</span><span class="n">i</span><span class="w"> </span><span 
class="o">=</span><span class="w"> </span><span class="mi">0</span><span 
class="p">;</span><span class="w"> </span><span class="n">i</span><span 
class="w"> </span><span class="o">&lt;</span><span class="w"> </span><span 
class="n">src</span><span class="p">.</span><span class="n">size [...]
-<span class="w">    </span><span class="k">if</span><span class="w"> 
</span><span class="p">(</span><span class="n">src</span><span 
class="p">.</span><span class="n">data</span><span class="p">[</span><span 
class="n">i</span><span class="p">]</span><span class="w"> </span><span 
class="o">==</span><span class="w"> </span><span 
class="sc">&#39;\n&#39;</span><span class="p">)</span><span class="w"> 
</span><span class="p">{</span>
+<span class="w">    </span><span class="k">if</span><span class="w"> 
</span><span class="p">(</span><span class="n">src</span><span 
class="p">.</span><span class="n">data</span><span class="p">[</span><span 
class="n">i</span><span class="p">]</span><span class="w"> </span><span 
class="o">==</span><span class="w"> </span><span class="sc">'\n'</span><span 
class="p">)</span><span class="w"> </span><span class="p">{</span>
 <span class="w">      </span><span class="k">return</span><span class="w"> 
</span><span class="n">i</span><span class="p">;</span>
 <span class="w">    </span><span class="p">}</span>
 <span class="w">  </span><span class="p">}</span>
@@ -753,7 +753,7 @@ definition.</p>
 <span class="w">  </span><span class="k">if</span><span class="w"> 
</span><span class="p">(</span><span class="n">code</span><span class="w"> 
</span><span class="o">!=</span><span class="w"> </span><span 
class="n">NANOARROW_OK</span><span class="p">)</span><span class="w"> 
</span><span class="p">{</span>
 <span class="w">    </span><span class="k">return</span><span class="w"> 
</span><span class="p">{</span><span class="n">code</span><span 
class="p">,</span><span class="w"> </span><span class="n">std</span><span 
class="o">::</span><span class="n">string</span><span class="p">(</span><span 
class="n">ArrowErrorMessage</span><span class="p">(</span><span 
class="o">&amp;</span><span class="n">error</span><span class="p">))};</span>
 <span class="w">  </span><span class="p">}</span><span class="w"> </span><span 
class="k">else</span><span class="w"> </span><span class="p">{</span>
-<span class="w">    </span><span class="k">return</span><span class="w"> 
</span><span class="p">{</span><span class="n">NANOARROW_OK</span><span 
class="p">,</span><span class="w"> </span><span 
class="s">&quot;&quot;</span><span class="p">};</span>
+<span class="w">    </span><span class="k">return</span><span class="w"> 
</span><span class="p">{</span><span class="n">NANOARROW_OK</span><span 
class="p">,</span><span class="w"> </span><span class="s">""</span><span 
class="p">};</span>
 <span class="w">  </span><span class="p">}</span>
 <span class="p">}</span>
 </pre></div>
@@ -776,10 +776,10 @@ handling:</p>
 <span class="w">  </span><span class="n">ArrowStringView</span><span 
class="w"> </span><span class="n">item</span><span class="p">;</span>
 <span class="w">  </span><span class="k">for</span><span class="w"> 
</span><span class="p">(</span><span class="kt">int64_t</span><span class="w"> 
</span><span class="n">i</span><span class="w"> </span><span 
class="o">=</span><span class="w"> </span><span class="mi">0</span><span 
class="p">;</span><span class="w"> </span><span class="n">i</span><span 
class="w"> </span><span class="o">&lt;</span><span class="w"> </span><span 
class="n">input</span><span class="o">-&gt;</span><span class="n [...]
 <span class="w">    </span><span class="k">if</span><span class="w"> 
</span><span class="p">(</span><span class="n">ArrowArrayViewIsNull</span><span 
class="p">(</span><span class="n">input_view</span><span 
class="p">.</span><span class="n">get</span><span class="p">(),</span><span 
class="w"> </span><span class="n">i</span><span class="p">))</span><span 
class="w"> </span><span class="p">{</span>
-<span class="w">      </span><span class="n">out</span><span class="w"> 
</span><span class="o">&lt;&lt;</span><span class="w"> </span><span 
class="s">&quot;</span><span class="se">\n</span><span 
class="s">&quot;</span><span class="p">;</span>
+<span class="w">      </span><span class="n">out</span><span class="w"> 
</span><span class="o">&lt;&lt;</span><span class="w"> </span><span 
class="s">"</span><span class="se">\n</span><span class="s">"</span><span 
class="p">;</span>
 <span class="w">    </span><span class="p">}</span><span class="w"> 
</span><span class="k">else</span><span class="w"> </span><span 
class="p">{</span>
 <span class="w">      </span><span class="n">item</span><span class="w"> 
</span><span class="o">=</span><span class="w"> </span><span 
class="n">ArrowArrayViewGetStringUnsafe</span><span class="p">(</span><span 
class="n">input_view</span><span class="p">.</span><span 
class="n">get</span><span class="p">(),</span><span class="w"> </span><span 
class="n">i</span><span class="p">);</span>
-<span class="w">      </span><span class="n">out</span><span class="w"> 
</span><span class="o">&lt;&lt;</span><span class="w"> </span><span 
class="n">std</span><span class="o">::</span><span class="n">string</span><span 
class="p">(</span><span class="n">item</span><span class="p">.</span><span 
class="n">data</span><span class="p">,</span><span class="w"> </span><span 
class="n">item</span><span class="p">.</span><span 
class="n">size_bytes</span><span class="p">)</span><span class="w"> </s [...]
+<span class="w">      </span><span class="n">out</span><span class="w"> 
</span><span class="o">&lt;&lt;</span><span class="w"> </span><span 
class="n">std</span><span class="o">::</span><span class="n">string</span><span 
class="p">(</span><span class="n">item</span><span class="p">.</span><span 
class="n">data</span><span class="p">,</span><span class="w"> </span><span 
class="n">item</span><span class="p">.</span><span 
class="n">size_bytes</span><span class="p">)</span><span class="w"> </s [...]
 <span class="w">    </span><span class="p">}</span>
 <span class="w">  </span><span class="p">}</span>
 
@@ -814,9 +814,9 @@ the complexity of your project grows.</p>
 <code class="docutils literal notranslate"><span 
class="pre">linesplitter_test.cc</span></code>, add the following:</p>
 <div class="highlight-cpp notranslate"><div 
class="highlight"><pre><span></span><span class="cp">#include</span><span 
class="w"> </span><span class="cpf">&lt;gtest/gtest.h&gt;</span>
 
-<span class="cp">#include</span><span class="w"> </span><span 
class="cpf">&quot;nanoarrow/nanoarrow.hpp&quot;</span>
+<span class="cp">#include</span><span class="w"> </span><span 
class="cpf">"nanoarrow/nanoarrow.hpp"</span>
 
-<span class="cp">#include</span><span class="w"> </span><span 
class="cpf">&quot;linesplitter.h&quot;</span>
+<span class="cp">#include</span><span class="w"> </span><span 
class="cpf">"linesplitter.h"</span>
 
 <span class="n">TEST</span><span class="p">(</span><span 
class="n">Linesplitter</span><span class="p">,</span><span class="w"> 
</span><span class="n">LinesplitterRoundtrip</span><span 
class="p">)</span><span class="w"> </span><span class="p">{</span>
 <span class="w">  </span><span class="n">EXPECT_EQ</span><span 
class="p">(</span><span class="mi">4</span><span class="p">,</span><span 
class="w"> </span><span class="mi">4</span><span class="p">);</span>
@@ -854,9 +854,9 @@ with <code class="docutils literal notranslate"><span 
class="pre">cd</span> <spa
 trip, so a useful first test might be to check.</p>
 <div class="highlight-cpp notranslate"><div 
class="highlight"><pre><span></span><span class="n">TEST</span><span 
class="p">(</span><span class="n">Linesplitter</span><span 
class="p">,</span><span class="w"> </span><span 
class="n">LinesplitterRoundtrip</span><span class="p">)</span><span class="w"> 
</span><span class="p">{</span>
 <span class="w">  </span><span class="n">nanoarrow</span><span 
class="o">::</span><span class="n">UniqueArray</span><span class="w"> 
</span><span class="n">out</span><span class="p">;</span>
-<span class="w">  </span><span class="k">auto</span><span class="w"> 
</span><span class="n">result</span><span class="w"> </span><span 
class="o">=</span><span class="w"> </span><span 
class="n">linesplitter_read</span><span class="p">(</span><span 
class="s">&quot;line1</span><span class="se">\n</span><span 
class="s">line2</span><span class="se">\n</span><span 
class="s">line3&quot;</span><span class="p">,</span><span class="w"> 
</span><span class="n">out</span><span class="p">.</span><span [...]
+<span class="w">  </span><span class="k">auto</span><span class="w"> 
</span><span class="n">result</span><span class="w"> </span><span 
class="o">=</span><span class="w"> </span><span 
class="n">linesplitter_read</span><span class="p">(</span><span 
class="s">"line1</span><span class="se">\n</span><span 
class="s">line2</span><span class="se">\n</span><span 
class="s">line3"</span><span class="p">,</span><span class="w"> </span><span 
class="n">out</span><span class="p">.</span><span class="n" [...]
 <span class="w">  </span><span class="n">ASSERT_EQ</span><span 
class="p">(</span><span class="n">result</span><span class="p">.</span><span 
class="n">first</span><span class="p">,</span><span class="w"> </span><span 
class="mi">0</span><span class="p">);</span>
-<span class="w">  </span><span class="n">ASSERT_EQ</span><span 
class="p">(</span><span class="n">result</span><span class="p">.</span><span 
class="n">second</span><span class="p">,</span><span class="w"> </span><span 
class="s">&quot;&quot;</span><span class="p">);</span>
+<span class="w">  </span><span class="n">ASSERT_EQ</span><span 
class="p">(</span><span class="n">result</span><span class="p">.</span><span 
class="n">second</span><span class="p">,</span><span class="w"> </span><span 
class="s">""</span><span class="p">);</span>
 
 <span class="w">  </span><span class="n">ASSERT_EQ</span><span 
class="p">(</span><span class="n">out</span><span class="o">-&gt;</span><span 
class="n">length</span><span class="p">,</span><span class="w"> </span><span 
class="mi">3</span><span class="p">);</span>
 
@@ -866,18 +866,18 @@ trip, so a useful first test might be to check.</p>
 <span class="w">  </span><span class="n">ArrowStringView</span><span 
class="w"> </span><span class="n">item</span><span class="p">;</span>
 
 <span class="w">  </span><span class="n">item</span><span class="w"> 
</span><span class="o">=</span><span class="w"> </span><span 
class="n">ArrowArrayViewGetStringUnsafe</span><span class="p">(</span><span 
class="n">out_view</span><span class="p">.</span><span 
class="n">get</span><span class="p">(),</span><span class="w"> </span><span 
class="mi">0</span><span class="p">);</span>
-<span class="w">  </span><span class="n">ASSERT_EQ</span><span 
class="p">(</span><span class="n">std</span><span class="o">::</span><span 
class="n">string</span><span class="p">(</span><span class="n">item</span><span 
class="p">.</span><span class="n">data</span><span class="p">,</span><span 
class="w"> </span><span class="n">item</span><span class="p">.</span><span 
class="n">size_bytes</span><span class="p">),</span><span class="w"> 
</span><span class="s">&quot;line1&quot;</span><span cl [...]
+<span class="w">  </span><span class="n">ASSERT_EQ</span><span 
class="p">(</span><span class="n">std</span><span class="o">::</span><span 
class="n">string</span><span class="p">(</span><span class="n">item</span><span 
class="p">.</span><span class="n">data</span><span class="p">,</span><span 
class="w"> </span><span class="n">item</span><span class="p">.</span><span 
class="n">size_bytes</span><span class="p">),</span><span class="w"> 
</span><span class="s">"line1"</span><span class="p">);</span>
 
 <span class="w">  </span><span class="n">item</span><span class="w"> 
</span><span class="o">=</span><span class="w"> </span><span 
class="n">ArrowArrayViewGetStringUnsafe</span><span class="p">(</span><span 
class="n">out_view</span><span class="p">.</span><span 
class="n">get</span><span class="p">(),</span><span class="w"> </span><span 
class="mi">1</span><span class="p">);</span>
-<span class="w">  </span><span class="n">ASSERT_EQ</span><span 
class="p">(</span><span class="n">std</span><span class="o">::</span><span 
class="n">string</span><span class="p">(</span><span class="n">item</span><span 
class="p">.</span><span class="n">data</span><span class="p">,</span><span 
class="w"> </span><span class="n">item</span><span class="p">.</span><span 
class="n">size_bytes</span><span class="p">),</span><span class="w"> 
</span><span class="s">&quot;line2&quot;</span><span cl [...]
+<span class="w">  </span><span class="n">ASSERT_EQ</span><span 
class="p">(</span><span class="n">std</span><span class="o">::</span><span 
class="n">string</span><span class="p">(</span><span class="n">item</span><span 
class="p">.</span><span class="n">data</span><span class="p">,</span><span 
class="w"> </span><span class="n">item</span><span class="p">.</span><span 
class="n">size_bytes</span><span class="p">),</span><span class="w"> 
</span><span class="s">"line2"</span><span class="p">);</span>
 
 <span class="w">  </span><span class="n">item</span><span class="w"> 
</span><span class="o">=</span><span class="w"> </span><span 
class="n">ArrowArrayViewGetStringUnsafe</span><span class="p">(</span><span 
class="n">out_view</span><span class="p">.</span><span 
class="n">get</span><span class="p">(),</span><span class="w"> </span><span 
class="mi">2</span><span class="p">);</span>
-<span class="w">  </span><span class="n">ASSERT_EQ</span><span 
class="p">(</span><span class="n">std</span><span class="o">::</span><span 
class="n">string</span><span class="p">(</span><span class="n">item</span><span 
class="p">.</span><span class="n">data</span><span class="p">,</span><span 
class="w"> </span><span class="n">item</span><span class="p">.</span><span 
class="n">size_bytes</span><span class="p">),</span><span class="w"> 
</span><span class="s">&quot;line3&quot;</span><span cl [...]
+<span class="w">  </span><span class="n">ASSERT_EQ</span><span 
class="p">(</span><span class="n">std</span><span class="o">::</span><span 
class="n">string</span><span class="p">(</span><span class="n">item</span><span 
class="p">.</span><span class="n">data</span><span class="p">,</span><span 
class="w"> </span><span class="n">item</span><span class="p">.</span><span 
class="n">size_bytes</span><span class="p">),</span><span class="w"> 
</span><span class="s">"line3"</span><span class="p">);</span>
 
 
 <span class="w">  </span><span class="k">auto</span><span class="w"> 
</span><span class="n">result2</span><span class="w"> </span><span 
class="o">=</span><span class="w"> </span><span 
class="n">linesplitter_write</span><span class="p">(</span><span 
class="n">out</span><span class="p">.</span><span class="n">get</span><span 
class="p">());</span>
 <span class="w">  </span><span class="n">ASSERT_EQ</span><span 
class="p">(</span><span class="n">result2</span><span class="p">.</span><span 
class="n">first</span><span class="p">,</span><span class="w"> </span><span 
class="mi">0</span><span class="p">);</span>
-<span class="w">  </span><span class="n">ASSERT_EQ</span><span 
class="p">(</span><span class="n">result2</span><span class="p">.</span><span 
class="n">second</span><span class="p">,</span><span class="w"> </span><span 
class="s">&quot;line1</span><span class="se">\n</span><span 
class="s">line2</span><span class="se">\n</span><span 
class="s">line3</span><span class="se">\n</span><span 
class="s">&quot;</span><span class="p">);</span>
+<span class="w">  </span><span class="n">ASSERT_EQ</span><span 
class="p">(</span><span class="n">result2</span><span class="p">.</span><span 
class="n">second</span><span class="p">,</span><span class="w"> </span><span 
class="s">"line1</span><span class="se">\n</span><span 
class="s">line2</span><span class="se">\n</span><span 
class="s">line3</span><span class="se">\n</span><span class="s">"</span><span 
class="p">);</span>
 <span class="p">}</span>
 </pre></div>
 </div>
diff --git a/main/getting-started/python.html b/main/getting-started/python.html
index 5a9ef809..30b9fdde 100644
--- a/main/getting-started/python.html
+++ b/main/getting-started/python.html
@@ -507,11 +507,11 @@ necessarily been resolved yet.</p>
 <a class="reference external" 
href="https://arrow.apache.org/docs/format/Columnar.html#serialization-and-interprocess-communication-ipc";>Arrow
 IPC</a>
 reader:</p>
-<div class="highlight-python notranslate"><div 
class="highlight"><pre><span></span><span class="n">url</span> <span 
class="o">=</span> <span 
class="s2">&quot;https://github.com/apache/arrow-experiments/raw/main/data/arrow-commits/arrow-commits.arrows&quot;</span>
+<div class="highlight-python notranslate"><div 
class="highlight"><pre><span></span><span class="n">url</span> <span 
class="o">=</span> <span 
class="s2">"https://github.com/apache/arrow-experiments/raw/main/data/arrow-commits/arrow-commits.arrows";</span>
 <span class="n">na</span><span class="o">.</span><span 
class="n">ArrayStream</span><span class="o">.</span><span 
class="n">from_url</span><span class="p">(</span><span 
class="n">url</span><span class="p">)</span>
 </pre></div>
 </div>
-<div class="highlight-default notranslate"><div 
class="highlight"><pre><span></span><span class="n">nanoarrow</span><span 
class="o">.</span><span class="n">ArrayStream</span><span 
class="o">&lt;</span><span class="n">non</span><span class="o">-</span><span 
class="n">nullable</span> <span class="n">struct</span><span 
class="o">&lt;</span><span class="n">commit</span><span class="p">:</span> 
<span class="n">string</span><span class="p">,</span> <span 
class="n">time</span><span class="p">:< [...]
+<div class="highlight-default notranslate"><div 
class="highlight"><pre><span></span><span class="n">nanoarrow</span><span 
class="o">.</span><span class="n">ArrayStream</span><span 
class="o">&lt;</span><span class="n">non</span><span class="o">-</span><span 
class="n">nullable</span> <span class="n">struct</span><span 
class="o">&lt;</span><span class="n">commit</span><span class="p">:</span> 
<span class="n">string</span><span class="p">,</span> <span 
class="n">time</span><span class="p">:< [...]
 </pre></div>
 </div>
 <p>These objects implement the <a class="reference external" 
href="https://arrow.apache.org/docs/format/CDataInterface/PyCapsuleInterface.html";>Arrow
 PyCapsule
@@ -588,8 +588,8 @@ Interface</a>
 </pre></div>
 </div>
 <div class="highlight-default notranslate"><div 
class="highlight"><pre><span></span><span class="o">&lt;</span><span 
class="n">nanoarrow</span><span class="o">.</span><span 
class="n">c_schema</span><span class="o">.</span><span class="n">CSchema</span> 
<span class="n">decimal128</span><span class="p">(</span><span 
class="mi">10</span><span class="p">,</span> <span class="mi">3</span><span 
class="p">)</span><span class="o">&gt;</span>
-<span class="o">-</span> <span class="nb">format</span><span 
class="p">:</span> <span class="s1">&#39;d:10,3&#39;</span>
-<span class="o">-</span> <span class="n">name</span><span class="p">:</span> 
<span class="s1">&#39;&#39;</span>
+<span class="o">-</span> <span class="nb">format</span><span 
class="p">:</span> <span class="s1">'d:10,3'</span>
+<span class="o">-</span> <span class="n">name</span><span class="p">:</span> 
<span class="s1">''</span>
 <span class="o">-</span> <span class="n">flags</span><span class="p">:</span> 
<span class="mi">2</span>
 <span class="o">-</span> <span class="n">metadata</span><span 
class="p">:</span> <span class="n">NULL</span>
 <span class="o">-</span> <span class="n">dictionary</span><span 
class="p">:</span> <span class="n">NULL</span>
@@ -617,7 +617,7 @@ can be used to interpret its contents. This works for any 
object
 implementing the <a class="reference external" 
href="https://arrow.apache.org/docs/format/CDataInterface.html";>Arrow PyCapsule
 Interface</a>
 (e.g., <code class="docutils literal notranslate"><span 
class="pre">pyarrow.Array</span></code>, <code class="docutils literal 
notranslate"><span class="pre">pyarrow.RecordBatch</span></code>).</p>
-<div class="highlight-python notranslate"><div 
class="highlight"><pre><span></span><span class="n">na</span><span 
class="o">.</span><span class="n">c_array</span><span class="p">([</span><span 
class="s2">&quot;one&quot;</span><span class="p">,</span> <span 
class="s2">&quot;two&quot;</span><span class="p">,</span> <span 
class="s2">&quot;three&quot;</span><span class="p">,</span> <span 
class="kc">None</span><span class="p">],</span> <span class="n">na</span><span 
class="o">.</span><span cl [...]
+<div class="highlight-python notranslate"><div 
class="highlight"><pre><span></span><span class="n">na</span><span 
class="o">.</span><span class="n">c_array</span><span class="p">([</span><span 
class="s2">"one"</span><span class="p">,</span> <span 
class="s2">"two"</span><span class="p">,</span> <span 
class="s2">"three"</span><span class="p">,</span> <span 
class="kc">None</span><span class="p">],</span> <span class="n">na</span><span 
class="o">.</span><span class="n">string</span><span cla [...]
 </pre></div>
 </div>
 <div class="highlight-default notranslate"><div 
class="highlight"><pre><span></span><span class="o">&lt;</span><span 
class="n">nanoarrow</span><span class="o">.</span><span 
class="n">c_array</span><span class="o">.</span><span class="n">CArray</span> 
<span class="n">string</span><span class="o">&gt;</span>
@@ -632,11 +632,11 @@ Interface</a>
 <p>Using <code class="docutils literal notranslate"><span 
class="pre">c_array()</span></code> is a good fit for testing and for ephemeral 
array
 objects that are being passed from one library to another. For a higher
 level interface, use <code class="docutils literal notranslate"><span 
class="pre">Array()</span></code>:</p>
-<div class="highlight-python notranslate"><div 
class="highlight"><pre><span></span><span class="n">array</span> <span 
class="o">=</span> <span class="n">na</span><span class="o">.</span><span 
class="n">Array</span><span class="p">([</span><span 
class="s2">&quot;one&quot;</span><span class="p">,</span> <span 
class="s2">&quot;two&quot;</span><span class="p">,</span> <span 
class="s2">&quot;three&quot;</span><span class="p">,</span> <span 
class="kc">None</span><span class="p">],</span> <span [...]
+<div class="highlight-python notranslate"><div 
class="highlight"><pre><span></span><span class="n">array</span> <span 
class="o">=</span> <span class="n">na</span><span class="o">.</span><span 
class="n">Array</span><span class="p">([</span><span 
class="s2">"one"</span><span class="p">,</span> <span 
class="s2">"two"</span><span class="p">,</span> <span 
class="s2">"three"</span><span class="p">,</span> <span 
class="kc">None</span><span class="p">],</span> <span class="n">na</span><span 
clas [...]
 <span class="n">array</span><span class="o">.</span><span 
class="n">to_pylist</span><span class="p">()</span>
 </pre></div>
 </div>
-<div class="highlight-default notranslate"><div 
class="highlight"><pre><span></span><span class="p">[</span><span 
class="s1">&#39;one&#39;</span><span class="p">,</span> <span 
class="s1">&#39;two&#39;</span><span class="p">,</span> <span 
class="s1">&#39;three&#39;</span><span class="p">,</span> <span 
class="kc">None</span><span class="p">]</span>
+<div class="highlight-default notranslate"><div 
class="highlight"><pre><span></span><span class="p">[</span><span 
class="s1">'one'</span><span class="p">,</span> <span 
class="s1">'two'</span><span class="p">,</span> <span 
class="s1">'three'</span><span class="p">,</span> <span 
class="kc">None</span><span class="p">]</span>
 </pre></div>
 </div>
 <div class="highlight-python notranslate"><div 
class="highlight"><pre><span></span><span class="n">array</span><span 
class="o">.</span><span class="n">buffers</span>
@@ -644,7 +644,7 @@ level interface, use <code class="docutils literal 
notranslate"><span class="pre
 </div>
 <div class="highlight-default notranslate"><div 
class="highlight"><pre><span></span><span class="p">(</span><span 
class="n">nanoarrow</span><span class="o">.</span><span 
class="n">c_lib</span><span class="o">.</span><span 
class="n">CBufferView</span><span class="p">(</span><span 
class="nb">bool</span><span class="p">[</span><span class="mi">1</span> <span 
class="n">b</span><span class="p">]</span> <span 
class="mi">11100000</span><span class="p">),</span>
  <span class="n">nanoarrow</span><span class="o">.</span><span 
class="n">c_lib</span><span class="o">.</span><span 
class="n">CBufferView</span><span class="p">(</span><span 
class="n">int32</span><span class="p">[</span><span class="mi">20</span> <span 
class="n">b</span><span class="p">]</span> <span class="mi">0</span> <span 
class="mi">3</span> <span class="mi">6</span> <span class="mi">11</span> <span 
class="mi">11</span><span class="p">),</span>
- <span class="n">nanoarrow</span><span class="o">.</span><span 
class="n">c_lib</span><span class="o">.</span><span 
class="n">CBufferView</span><span class="p">(</span><span 
class="n">string</span><span class="p">[</span><span class="mi">11</span> <span 
class="n">b</span><span class="p">]</span> <span class="sa">b</span><span 
class="s1">&#39;onetwothree&#39;</span><span class="p">))</span>
+ <span class="n">nanoarrow</span><span class="o">.</span><span 
class="n">c_lib</span><span class="o">.</span><span 
class="n">CBufferView</span><span class="p">(</span><span 
class="n">string</span><span class="p">[</span><span class="mi">11</span> <span 
class="n">b</span><span class="p">]</span> <span class="sa">b</span><span 
class="s1">'onetwothree'</span><span class="p">))</span>
 </pre></div>
 </div>
 <p>Advanced users can create arrays directly from buffers using
@@ -652,7 +652,7 @@ level interface, use <code class="docutils literal 
notranslate"><span class="pre
 <div class="highlight-python notranslate"><div 
class="highlight"><pre><span></span><span class="n">na</span><span 
class="o">.</span><span class="n">c_array_from_buffers</span><span 
class="p">(</span>
     <span class="n">na</span><span class="o">.</span><span 
class="n">string</span><span class="p">(),</span>
     <span class="mi">2</span><span class="p">,</span>
-    <span class="p">[</span><span class="kc">None</span><span 
class="p">,</span> <span class="n">na</span><span class="o">.</span><span 
class="n">c_buffer</span><span class="p">([</span><span 
class="mi">0</span><span class="p">,</span> <span class="mi">3</span><span 
class="p">,</span> <span class="mi">6</span><span class="p">],</span> <span 
class="n">na</span><span class="o">.</span><span class="n">int32</span><span 
class="p">()),</span> <span class="sa">b</span><span class="s2">&quot;ab [...]
+    <span class="p">[</span><span class="kc">None</span><span 
class="p">,</span> <span class="n">na</span><span class="o">.</span><span 
class="n">c_buffer</span><span class="p">([</span><span 
class="mi">0</span><span class="p">,</span> <span class="mi">3</span><span 
class="p">,</span> <span class="mi">6</span><span class="p">],</span> <span 
class="n">na</span><span class="o">.</span><span class="n">int32</span><span 
class="p">()),</span> <span class="sa">b</span><span class="s2">"abcdef" [...]
 <span class="p">)</span>
 </pre></div>
 </div>
@@ -674,7 +674,7 @@ representing a sequence of <code class="docutils literal 
notranslate"><span clas
 object implementing the <a class="reference external" 
href="https://arrow.apache.org/docs/format/CDataInterface.html";>Arrow PyCapsule
 Interface</a>
 (e.g., <code class="docutils literal notranslate"><span 
class="pre">pyarrow.RecordBatchReader</span></code>, <code class="docutils 
literal notranslate"><span class="pre">pyarrow.ChunkedArray</span></code>).</p>
-<div class="highlight-python notranslate"><div 
class="highlight"><pre><span></span><span class="n">pa_batch</span> <span 
class="o">=</span> <span class="n">pa</span><span class="o">.</span><span 
class="n">record_batch</span><span class="p">({</span><span 
class="s2">&quot;col1&quot;</span><span class="p">:</span> <span 
class="p">[</span><span class="mi">1</span><span class="p">,</span> <span 
class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span 
class="p">]})</span>
+<div class="highlight-python notranslate"><div 
class="highlight"><pre><span></span><span class="n">pa_batch</span> <span 
class="o">=</span> <span class="n">pa</span><span class="o">.</span><span 
class="n">record_batch</span><span class="p">({</span><span 
class="s2">"col1"</span><span class="p">:</span> <span class="p">[</span><span 
class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span 
class="p">,</span> <span class="mi">3</span><span class="p">]})</span>
 <span class="n">reader</span> <span class="o">=</span> <span 
class="n">pa</span><span class="o">.</span><span 
class="n">RecordBatchReader</span><span class="o">.</span><span 
class="n">from_batches</span><span class="p">(</span><span 
class="n">pa_batch</span><span class="o">.</span><span 
class="n">schema</span><span class="p">,</span> <span class="p">[</span><span 
class="n">pa_batch</span><span class="p">])</span>
 <span class="n">array_stream</span> <span class="o">=</span> <span 
class="n">na</span><span class="o">.</span><span 
class="n">c_array_stream</span><span class="p">(</span><span 
class="n">reader</span><span class="p">)</span>
 <span class="n">array_stream</span>
@@ -698,7 +698,7 @@ it like an iterator. The <code class="docutils literal 
notranslate"><span class=
 <span class="o">-</span> <span class="n">buffers</span><span 
class="p">:</span> <span class="p">(</span><span class="mi">0</span><span 
class="p">,)</span>
 <span class="o">-</span> <span class="n">dictionary</span><span 
class="p">:</span> <span class="n">NULL</span>
 <span class="o">-</span> <span class="n">children</span><span 
class="p">[</span><span class="mi">1</span><span class="p">]:</span>
-  <span class="s1">&#39;col1&#39;</span><span class="p">:</span> <span 
class="o">&lt;</span><span class="n">nanoarrow</span><span 
class="o">.</span><span class="n">c_array</span><span class="o">.</span><span 
class="n">CArray</span> <span class="n">int64</span><span class="o">&gt;</span>
+  <span class="s1">'col1'</span><span class="p">:</span> <span 
class="o">&lt;</span><span class="n">nanoarrow</span><span 
class="o">.</span><span class="n">c_array</span><span class="o">.</span><span 
class="n">CArray</span> <span class="n">int64</span><span class="o">&gt;</span>
     <span class="o">-</span> <span class="n">length</span><span 
class="p">:</span> <span class="mi">3</span>
     <span class="o">-</span> <span class="n">offset</span><span 
class="p">:</span> <span class="mi">0</span>
     <span class="o">-</span> <span class="n">null_count</span><span 
class="p">:</span> <span class="mi">0</span>
@@ -713,9 +713,9 @@ it like an iterator. The <code class="docutils literal 
notranslate"><span class=
 </pre></div>
 </div>
 <div class="highlight-default notranslate"><div 
class="highlight"><pre><span></span><span class="n">nanoarrow</span><span 
class="o">.</span><span class="n">Array</span><span class="o">&lt;</span><span 
class="n">non</span><span class="o">-</span><span class="n">nullable</span> 
<span class="n">struct</span><span class="o">&lt;</span><span 
class="n">col1</span><span class="p">:</span> <span class="n">int64</span><span 
class="o">&gt;&gt;</span><span class="p">[</span><span class="mi">3</span [...]
-<span class="p">{</span><span class="s1">&#39;col1&#39;</span><span 
class="p">:</span> <span class="mi">1</span><span class="p">}</span>
-<span class="p">{</span><span class="s1">&#39;col1&#39;</span><span 
class="p">:</span> <span class="mi">2</span><span class="p">}</span>
-<span class="p">{</span><span class="s1">&#39;col1&#39;</span><span 
class="p">:</span> <span class="mi">3</span><span class="p">}</span>
+<span class="p">{</span><span class="s1">'col1'</span><span class="p">:</span> 
<span class="mi">1</span><span class="p">}</span>
+<span class="p">{</span><span class="s1">'col1'</span><span class="p">:</span> 
<span class="mi">2</span><span class="p">}</span>
+<span class="p">{</span><span class="s1">'col1'</span><span class="p">:</span> 
<span class="mi">3</span><span class="p">}</span>
 </pre></div>
 </div>
 </section>
@@ -734,7 +734,7 @@ pip<span class="w"> </span>install<span class="w"> 
</span>-e<span class="w"> </s
 </div>
 <p>Tests use <a class="reference external" 
href="https://docs.pytest.org/";>pytest</a>:</p>
 <div class="highlight-shell notranslate"><div 
class="highlight"><pre><span></span><span class="c1"># Install 
dependencies</span>
-pip<span class="w"> </span>install<span class="w"> </span>-e<span class="w"> 
</span><span class="s2">&quot;.[test]&quot;</span>
+pip<span class="w"> </span>install<span class="w"> </span>-e<span class="w"> 
</span><span class="s2">".[test]"</span>
 
 <span class="c1"># Run tests</span>
 pytest<span class="w"> </span>-vvx
diff --git a/main/getting-started/r.html b/main/getting-started/r.html
index e92e4a0c..5f9f3f6d 100644
--- a/main/getting-started/r.html
+++ b/main/getting-started/r.html
@@ -423,13 +423,13 @@ library</a>.</p>
 <h2>Installation<a class="headerlink" href="#installation" title="Link to this 
heading">#</a></h2>
 <p>You can install the released version of nanoarrow from
 <a class="reference external" href="https://cran.r-project.org/";>CRAN</a> 
with:</p>
-<div class="highlight-r notranslate"><div 
class="highlight"><pre><span></span><span 
class="nf">install.packages</span><span class="p">(</span><span 
class="s">&quot;nanoarrow&quot;</span><span class="p">)</span>
+<div class="highlight-r notranslate"><div 
class="highlight"><pre><span></span><span 
class="nf">install.packages</span><span class="p">(</span><span 
class="s">"nanoarrow"</span><span class="p">)</span>
 </pre></div>
 </div>
 <p>You can install the development version of nanoarrow from
 <a class="reference external" href="https://github.com/";>GitHub</a> with:</p>
-<div class="highlight-r notranslate"><div 
class="highlight"><pre><span></span><span class="c1"># 
install.packages(&quot;remotes&quot;)</span>
-<span class="n">remotes</span><span class="o">::</span><span 
class="nf">install_github</span><span class="p">(</span><span 
class="s">&quot;apache/arrow-nanoarrow/r&quot;</span><span class="p">)</span>
+<div class="highlight-r notranslate"><div 
class="highlight"><pre><span></span><span class="c1"># 
install.packages("remotes")</span>
+<span class="n">remotes</span><span class="o">::</span><span 
class="nf">install_github</span><span class="p">(</span><span 
class="s">"apache/arrow-nanoarrow/r"</span><span class="p">)</span>
 </pre></div>
 </div>
 <p>If you can load the package, you’re good to go!</p>
@@ -454,22 +454,22 @@ arrow R package <code class="docutils literal 
notranslate"><span class="pre">Dat
 <code class="docutils literal notranslate"><span 
class="pre">na_XXX()</span></code> functions to construct them.</p>
 <div class="highlight-r notranslate"><div 
class="highlight"><pre><span></span><span 
class="nf">infer_nanoarrow_schema</span><span class="p">(</span><span 
class="m">1</span><span class="o">:</span><span class="m">5</span><span 
class="p">)</span>
 <span class="c1">#&gt; &lt;nanoarrow_schema int32&gt;</span>
-<span class="c1">#&gt;  $ format    : chr &quot;i&quot;</span>
-<span class="c1">#&gt;  $ name      : chr &quot;&quot;</span>
+<span class="c1">#&gt;  $ format    : chr "i"</span>
+<span class="c1">#&gt;  $ name      : chr ""</span>
 <span class="c1">#&gt;  $ metadata  : list()</span>
 <span class="c1">#&gt;  $ flags     : int 2</span>
 <span class="c1">#&gt;  $ children  : list()</span>
 <span class="c1">#&gt;  $ dictionary: NULL</span>
 <span class="nf">as_nanoarrow_schema</span><span class="p">(</span><span 
class="n">arrow</span><span class="o">::</span><span 
class="nf">schema</span><span class="p">(</span><span 
class="n">col1</span><span class="w"> </span><span class="o">=</span><span 
class="w"> </span><span class="n">arrow</span><span class="o">::</span><span 
class="nf">float64</span><span class="p">()))</span>
 <span class="c1">#&gt; &lt;nanoarrow_schema struct&gt;</span>
-<span class="c1">#&gt;  $ format    : chr &quot;+s&quot;</span>
-<span class="c1">#&gt;  $ name      : chr &quot;&quot;</span>
+<span class="c1">#&gt;  $ format    : chr "+s"</span>
+<span class="c1">#&gt;  $ name      : chr ""</span>
 <span class="c1">#&gt;  $ metadata  : list()</span>
 <span class="c1">#&gt;  $ flags     : int 0</span>
 <span class="c1">#&gt;  $ children  :List of 1</span>
 <span class="c1">#&gt;   ..$ col1:&lt;nanoarrow_schema double&gt;</span>
-<span class="c1">#&gt;   .. ..$ format    : chr &quot;g&quot;</span>
-<span class="c1">#&gt;   .. ..$ name      : chr &quot;col1&quot;</span>
+<span class="c1">#&gt;   .. ..$ format    : chr "g"</span>
+<span class="c1">#&gt;   .. ..$ name      : chr "col1"</span>
 <span class="c1">#&gt;   .. ..$ metadata  : list()</span>
 <span class="c1">#&gt;   .. ..$ flags     : int 2</span>
 <span class="c1">#&gt;   .. ..$ children  : list()</span>
@@ -477,8 +477,8 @@ arrow R package <code class="docutils literal 
notranslate"><span class="pre">Dat
 <span class="c1">#&gt;  $ dictionary: NULL</span>
 <span class="nf">na_int64</span><span class="p">()</span>
 <span class="c1">#&gt; &lt;nanoarrow_schema int64&gt;</span>
-<span class="c1">#&gt;  $ format    : chr &quot;l&quot;</span>
-<span class="c1">#&gt;  $ name      : chr &quot;&quot;</span>
+<span class="c1">#&gt;  $ format    : chr "l"</span>
+<span class="c1">#&gt;  $ name      : chr ""</span>
 <span class="c1">#&gt;  $ metadata  : list()</span>
 <span class="c1">#&gt;  $ flags     : int 2</span>
 <span class="c1">#&gt;  $ children  : list()</span>
@@ -534,14 +534,14 @@ ArrowSchema, at the R level we attach a schema wherever 
possible. You
 can access the attached schema using <code class="docutils literal 
notranslate"><span class="pre">infer_nanoarrow_schema()</span></code>:</p>
 <div class="highlight-r notranslate"><div 
class="highlight"><pre><span></span><span 
class="nf">infer_nanoarrow_schema</span><span class="p">(</span><span 
class="n">array</span><span class="p">)</span>
 <span class="c1">#&gt; &lt;nanoarrow_schema struct&gt;</span>
-<span class="c1">#&gt;  $ format    : chr &quot;+s&quot;</span>
-<span class="c1">#&gt;  $ name      : chr &quot;&quot;</span>
+<span class="c1">#&gt;  $ format    : chr "+s"</span>
+<span class="c1">#&gt;  $ name      : chr ""</span>
 <span class="c1">#&gt;  $ metadata  : list()</span>
 <span class="c1">#&gt;  $ flags     : int 0</span>
 <span class="c1">#&gt;  $ children  :List of 1</span>
 <span class="c1">#&gt;   ..$ col1:&lt;nanoarrow_schema double&gt;</span>
-<span class="c1">#&gt;   .. ..$ format    : chr &quot;g&quot;</span>
-<span class="c1">#&gt;   .. ..$ name      : chr &quot;col1&quot;</span>
+<span class="c1">#&gt;   .. ..$ format    : chr "g"</span>
+<span class="c1">#&gt;   .. ..$ name      : chr "col1"</span>
 <span class="c1">#&gt;   .. ..$ metadata  : list()</span>
 <span class="c1">#&gt;   .. ..$ flags     : int 2</span>
 <span class="c1">#&gt;   .. ..$ children  : list()</span>
diff --git a/main/index.html b/main/index.html
index 530216a2..b5ac6b04 100644
--- a/main/index.html
+++ b/main/index.html
@@ -413,7 +413,7 @@ conda<span class="w"> </span>install<span class="w"> 
</span>nanoarrow<span class
 </div>
 <p>The nanoarrow R package is available from
 <a class="reference external" href="https://cran.r-project.org";>CRAN</a>:</p>
-<div class="highlight-r notranslate"><div 
class="highlight"><pre><span></span><span 
class="nf">install.packages</span><span class="p">(</span><span 
class="s">&quot;nanoarrow&quot;</span><span class="p">)</span>
+<div class="highlight-r notranslate"><div 
class="highlight"><pre><span></span><span 
class="nf">install.packages</span><span class="p">(</span><span 
class="s">"nanoarrow"</span><span class="p">)</span>
 </pre></div>
 </div>
 <p>The C library can be used by generating bundled versions of the core
@@ -432,7 +432,7 @@ and Python bindings.</p>
 <p>CMake is also supported via a build/install with <code class="docutils 
literal notranslate"><span class="pre">find_package()</span></code> or
 using <code class="docutils literal notranslate"><span 
class="pre">FetchContent</span></code>:</p>
 <div class="highlight-default notranslate"><div 
class="highlight"><pre><span></span><span 
class="n">fetchcontent_declare</span><span class="p">(</span><span 
class="n">nanoarrow</span>
-                     <span class="n">URL</span> <span 
class="s2">&quot;https://www.apache.org/dyn/closer.lua?action=download&amp;filename=arrow/apache-arrow-nanoarrow-0.6.0/apache-arrow-nanoarrow-0.6.0.tar.gz&quot;</span><span
 class="p">)</span>
+                     <span class="n">URL</span> <span 
class="s2">"https://www.apache.org/dyn/closer.lua?action=download&amp;filename=arrow/apache-arrow-nanoarrow-0.6.0/apache-arrow-nanoarrow-0.6.0.tar.gz";</span><span
 class="p">)</span>
 
 <span class="n">fetchcontent_makeavailable</span><span class="p">(</span><span 
class="n">nanoarrow</span><span class="p">)</span>
 </pre></div>
@@ -443,9 +443,9 @@ meson<span class="w"> </span>wrap<span class="w"> 
</span>install<span class="w">
 </pre></div>
 </div>
 <p>…and declared as a dependency with:</p>
-<div class="highlight-default notranslate"><div 
class="highlight"><pre><span></span><span class="n">nanoarrow_dep</span> <span 
class="o">=</span> <span class="n">dependency</span><span 
class="p">(</span><span class="s1">&#39;nanoarrow&#39;</span><span 
class="p">)</span>
-<span class="n">example_exec</span> <span class="o">=</span> <span 
class="n">executable</span><span class="p">(</span><span 
class="s1">&#39;example_meson_minimal_app&#39;</span><span class="p">,</span>
-                          <span class="s1">&#39;src/app.cc&#39;</span><span 
class="p">,</span>
+<div class="highlight-default notranslate"><div 
class="highlight"><pre><span></span><span class="n">nanoarrow_dep</span> <span 
class="o">=</span> <span class="n">dependency</span><span 
class="p">(</span><span class="s1">'nanoarrow'</span><span class="p">)</span>
+<span class="n">example_exec</span> <span class="o">=</span> <span 
class="n">executable</span><span class="p">(</span><span 
class="s1">'example_meson_minimal_app'</span><span class="p">,</span>
+                          <span class="s1">'src/app.cc'</span><span 
class="p">,</span>
                           <span class="n">dependencies</span><span 
class="p">:</span> <span class="p">[</span><span 
class="n">nanoarrow_dep</span><span class="p">])</span>
 </pre></div>
 </div>
diff --git a/main/r/pkgdown.yml b/main/r/pkgdown.yml
index a47f63b3..0d2b03dd 100644
--- a/main/r/pkgdown.yml
+++ b/main/r/pkgdown.yml
@@ -2,4 +2,4 @@ pandoc: 3.7.0.2
 pkgdown: 2.2.1
 pkgdown_sha: ~
 articles: {}
-last_built: 2026-08-07T14:16Z
+last_built: 2026-08-22T03:24Z
diff --git a/main/reference/python/advanced.html 
b/main/reference/python/advanced.html
index 477b7a95..0644b26d 100644
--- a/main/reference/python/advanced.html
+++ b/main/reference/python/advanced.html
@@ -454,9 +454,9 @@ imported structure.</p>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">schema</span><span 
class="o">.</span><span class="n">is_valid</span><span class="p">()</span>
 <span class="go">True</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">schema</span><span 
class="o">.</span><span class="n">format</span>
-<span class="go">&#39;i&#39;</span>
+<span class="go">'i'</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">schema</span><span 
class="o">.</span><span class="n">name</span>
-<span class="go">&#39;&#39;</span>
+<span class="go">''</span>
 </pre></div>
 </div>
 </section>
@@ -477,7 +477,7 @@ parameterized types). This wrapper extends that facility to 
Python.</p>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">schema</span> <span 
class="o">=</span> <span class="n">na</span><span class="o">.</span><span 
class="n">c_schema</span><span class="p">(</span><span class="n">pa</span><span 
class="o">.</span><span class="n">decimal128</span><span 
class="p">(</span><span class="mi">10</span><span class="p">,</span> <span 
class="mi">3</span><span class="p">))</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">schema_view</span> <span 
class="o">=</span> <span class="n">c_schema_view</span><span 
class="p">(</span><span class="n">schema</span><span class="p">)</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">schema_view</span><span 
class="o">.</span><span class="n">type</span>
-<span class="go">&#39;decimal128&#39;</span>
+<span class="go">'decimal128'</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">schema_view</span><span 
class="o">.</span><span class="n">decimal_bitwidth</span>
 <span class="go">128</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">schema_view</span><span 
class="o">.</span><span class="n">decimal_precision</span>
@@ -683,7 +683,7 @@ this function will construct a <code class="xref py 
py-class docutils literal no
 <section id="id6">
 <h3>Examples<a class="headerlink" href="#id6" title="Link to this 
heading">#</a></h3>
 <div class="doctest highlight-default notranslate"><div 
class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span 
class="kn">import</span><span class="w"> </span><span 
class="nn">nanoarrow</span><span class="w"> </span><span 
class="k">as</span><span class="w"> </span><span class="nn">na</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">c_array</span> <span 
class="o">=</span> <span class="n">na</span><span class="o">.</span><span 
class="n">c_array_from_buffers</span><span class="p">(</span><span 
class="n">na</span><span class="o">.</span><span class="n">uint8</span><span 
class="p">(),</span> <span class="mi">5</span><span class="p">,</span> <span 
class="p">[</span><span class="kc">None</span><span class="p">,</span> <span 
class="sa">b</span><span class="s2">&quot;1234 [...]
+<span class="gp">&gt;&gt;&gt; </span><span class="n">c_array</span> <span 
class="o">=</span> <span class="n">na</span><span class="o">.</span><span 
class="n">c_array_from_buffers</span><span class="p">(</span><span 
class="n">na</span><span class="o">.</span><span class="n">uint8</span><span 
class="p">(),</span> <span class="mi">5</span><span class="p">,</span> <span 
class="p">[</span><span class="kc">None</span><span class="p">,</span> <span 
class="sa">b</span><span class="s2">"12345"</s [...]
 <span class="gp">&gt;&gt;&gt; </span><span class="n">na</span><span 
class="o">.</span><span class="n">Array</span><span class="p">(</span><span 
class="n">c_array</span><span class="p">)</span><span class="o">.</span><span 
class="n">inspect</span><span class="p">()</span>
 <span class="go">&lt;ArrowArray uint8&gt;</span>
 <span class="go">- length: 5</span>
@@ -716,13 +716,13 @@ IPC). The offset and length of this view are independent 
of its parent
 <span class="gp">&gt;&gt;&gt; </span><span class="kn">import</span><span 
class="w"> </span><span class="nn">nanoarrow</span><span class="w"> 
</span><span class="k">as</span><span class="w"> </span><span 
class="nn">na</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span><span 
class="w"> </span><span class="nn">nanoarrow.c_array</span><span class="w"> 
</span><span class="kn">import</span> <span class="n">c_array_view</span>
 <span class="gp">&gt;&gt;&gt;</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">array</span> <span 
class="o">=</span> <span class="n">na</span><span class="o">.</span><span 
class="n">c_array</span><span class="p">(</span><span class="n">pa</span><span 
class="o">.</span><span class="n">array</span><span class="p">([</span><span 
class="s2">&quot;one&quot;</span><span class="p">,</span> <span 
class="s2">&quot;two&quot;</span><span class="p">,</span> <span 
class="s2">&quot;three&quot;</span><span class="p">,</span> <s [...]
+<span class="gp">&gt;&gt;&gt; </span><span class="n">array</span> <span 
class="o">=</span> <span class="n">na</span><span class="o">.</span><span 
class="n">c_array</span><span class="p">(</span><span class="n">pa</span><span 
class="o">.</span><span class="n">array</span><span class="p">([</span><span 
class="s2">"one"</span><span class="p">,</span> <span 
class="s2">"two"</span><span class="p">,</span> <span 
class="s2">"three"</span><span class="p">,</span> <span 
class="kc">None</span><spa [...]
 <span class="gp">&gt;&gt;&gt; </span><span class="n">array_view</span> <span 
class="o">=</span> <span class="n">c_array_view</span><span 
class="p">(</span><span class="n">array</span><span class="p">)</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span 
class="o">.</span><span class="n">array</span><span class="p">(</span><span 
class="n">array_view</span><span class="o">.</span><span 
class="n">buffer</span><span class="p">(</span><span class="mi">1</span><span 
class="p">))</span>
 <span class="go">array([ 0,  3,  6, 11, 11], dtype=int32)</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">np</span><span 
class="o">.</span><span class="n">array</span><span class="p">(</span><span 
class="n">array_view</span><span class="o">.</span><span 
class="n">buffer</span><span class="p">(</span><span class="mi">2</span><span 
class="p">))</span>
-<span class="go">array([b&#39;o&#39;, b&#39;n&#39;, b&#39;e&#39;, 
b&#39;t&#39;, b&#39;w&#39;, b&#39;o&#39;, b&#39;t&#39;, b&#39;h&#39;, 
b&#39;r&#39;, b&#39;e&#39;, b&#39;e&#39;],</span>
-<span class="go">      dtype=&#39;|S1&#39;)</span>
+<span class="go">array([b'o', b'n', b'e', b't', b'w', b'o', b't', b'h', b'r', 
b'e', b'e'],</span>
+<span class="go">      dtype='|S1')</span>
 </pre></div>
 </div>
 </section>
@@ -740,7 +740,7 @@ IPC). The offset and length of this view are independent of 
its parent
 <div class="doctest highlight-default notranslate"><div 
class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span 
class="kn">import</span><span class="w"> </span><span 
class="nn">pyarrow</span><span class="w"> </span><span class="k">as</span><span 
class="w"> </span><span class="nn">pa</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span><span 
class="w"> </span><span class="nn">nanoarrow.c_array_stream</span><span 
class="w"> </span><span class="kn">import</span> <span 
class="n">allocate_c_array_stream</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">pa_column</span> <span 
class="o">=</span> <span class="n">pa</span><span class="o">.</span><span 
class="n">array</span><span class="p">([</span><span class="mi">1</span><span 
class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span 
class="mi">3</span><span class="p">],</span> <span class="n">pa</span><span 
class="o">.</span><span class="n">int32</span><span class="p">())</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">pa_batch</span> <span 
class="o">=</span> <span class="n">pa</span><span class="o">.</span><span 
class="n">record_batch</span><span class="p">([</span><span 
class="n">pa_column</span><span class="p">],</span> <span 
class="n">names</span><span class="o">=</span><span class="p">[</span><span 
class="s2">&quot;col1&quot;</span><span class="p">])</span>
+<span class="gp">&gt;&gt;&gt; </span><span class="n">pa_batch</span> <span 
class="o">=</span> <span class="n">pa</span><span class="o">.</span><span 
class="n">record_batch</span><span class="p">([</span><span 
class="n">pa_column</span><span class="p">],</span> <span 
class="n">names</span><span class="o">=</span><span class="p">[</span><span 
class="s2">"col1"</span><span class="p">])</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">pa_reader</span> <span 
class="o">=</span> <span class="n">pa</span><span class="o">.</span><span 
class="n">RecordBatchReader</span><span class="o">.</span><span 
class="n">from_batches</span><span class="p">(</span><span 
class="n">pa_batch</span><span class="o">.</span><span 
class="n">schema</span><span class="p">,</span> <span class="p">[</span><span 
class="n">pa_batch</span><span class="p">])</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">array_stream</span> <span 
class="o">=</span> <span class="n">allocate_c_array_stream</span><span 
class="p">()</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">pa_reader</span><span 
class="o">.</span><span class="n">_export_to_c</span><span 
class="p">(</span><span class="n">array_stream</span><span 
class="o">.</span><span class="n">_addr</span><span class="p">())</span>
@@ -761,20 +761,20 @@ These objects are usually created using 
<cite>nanoarrow.c_array_stream()</cite>.
 <div class="doctest highlight-default notranslate"><div 
class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span 
class="kn">import</span><span class="w"> </span><span 
class="nn">pyarrow</span><span class="w"> </span><span class="k">as</span><span 
class="w"> </span><span class="nn">pa</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="kn">import</span><span 
class="w"> </span><span class="nn">nanoarrow</span><span class="w"> 
</span><span class="k">as</span><span class="w"> </span><span 
class="nn">na</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">pa_column</span> <span 
class="o">=</span> <span class="n">pa</span><span class="o">.</span><span 
class="n">array</span><span class="p">([</span><span class="mi">1</span><span 
class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span 
class="mi">3</span><span class="p">],</span> <span class="n">pa</span><span 
class="o">.</span><span class="n">int32</span><span class="p">())</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">pa_batch</span> <span 
class="o">=</span> <span class="n">pa</span><span class="o">.</span><span 
class="n">record_batch</span><span class="p">([</span><span 
class="n">pa_column</span><span class="p">],</span> <span 
class="n">names</span><span class="o">=</span><span class="p">[</span><span 
class="s2">&quot;col1&quot;</span><span class="p">])</span>
+<span class="gp">&gt;&gt;&gt; </span><span class="n">pa_batch</span> <span 
class="o">=</span> <span class="n">pa</span><span class="o">.</span><span 
class="n">record_batch</span><span class="p">([</span><span 
class="n">pa_column</span><span class="p">],</span> <span 
class="n">names</span><span class="o">=</span><span class="p">[</span><span 
class="s2">"col1"</span><span class="p">])</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">pa_reader</span> <span 
class="o">=</span> <span class="n">pa</span><span class="o">.</span><span 
class="n">RecordBatchReader</span><span class="o">.</span><span 
class="n">from_batches</span><span class="p">(</span><span 
class="n">pa_batch</span><span class="o">.</span><span 
class="n">schema</span><span class="p">,</span> <span class="p">[</span><span 
class="n">pa_batch</span><span class="p">])</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">array_stream</span> <span 
class="o">=</span> <span class="n">na</span><span class="o">.</span><span 
class="n">c_array_stream</span><span class="p">(</span><span 
class="n">pa_reader</span><span class="p">)</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">array_stream</span><span 
class="o">.</span><span class="n">get_schema</span><span class="p">()</span>
 <span class="go">&lt;nanoarrow.c_schema.CSchema struct&gt;</span>
-<span class="go">- format: &#39;+s&#39;</span>
-<span class="go">- name: &#39;&#39;</span>
+<span class="go">- format: '+s'</span>
+<span class="go">- name: ''</span>
 <span class="go">- flags: 0</span>
 <span class="go">- metadata: NULL</span>
 <span class="go">- dictionary: NULL</span>
 <span class="go">- children[1]:</span>
-<span class="go">  &#39;col1&#39;: &lt;nanoarrow.c_schema.CSchema 
int32&gt;</span>
-<span class="go">    - format: &#39;i&#39;</span>
-<span class="go">    - name: &#39;col1&#39;</span>
+<span class="go">  'col1': &lt;nanoarrow.c_schema.CSchema int32&gt;</span>
+<span class="go">    - format: 'i'</span>
+<span class="go">    - name: 'col1'</span>
 <span class="go">    - flags: 2</span>
 <span class="go">    - metadata: NULL</span>
 <span class="go">    - dictionary: NULL</span>
diff --git a/main/reference/python/array-stream.html 
b/main/reference/python/array-stream.html
index 95af9e90..b04ed87a 100644
--- a/main/reference/python/array-stream.html
+++ b/main/reference/python/array-stream.html
@@ -478,16 +478,16 @@ this stream.</p>
 <span class="gp">&gt;&gt;&gt; </span><span class="kn">import</span><span 
class="w"> </span><span class="nn">nanoarrow</span><span class="w"> 
</span><span class="k">as</span><span class="w"> </span><span 
class="nn">na</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span><span 
class="w"> </span><span class="nn">nanoarrow.ipc</span><span class="w"> 
</span><span class="kn">import</span> <span class="n">InputStream</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="k">with</span> <span 
class="n">tempfile</span><span class="o">.</span><span 
class="n">TemporaryDirectory</span><span class="p">()</span> <span 
class="k">as</span> <span class="n">td</span><span class="p">:</span>
-<span class="gp">... </span>    <span class="n">path</span> <span 
class="o">=</span> <span class="n">os</span><span class="o">.</span><span 
class="n">path</span><span class="o">.</span><span class="n">join</span><span 
class="p">(</span><span class="n">td</span><span class="p">,</span> <span 
class="s2">&quot;test.arrows&quot;</span><span class="p">)</span>
-<span class="gp">... </span>    <span class="k">with</span> <span 
class="nb">open</span><span class="p">(</span><span class="n">path</span><span 
class="p">,</span> <span class="s2">&quot;wb&quot;</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">path</span> <span 
class="o">=</span> <span class="n">os</span><span class="o">.</span><span 
class="n">path</span><span class="o">.</span><span class="n">join</span><span 
class="p">(</span><span class="n">td</span><span class="p">,</span> <span 
class="s2">"test.arrows"</span><span class="p">)</span>
+<span class="gp">... </span>    <span class="k">with</span> <span 
class="nb">open</span><span class="p">(</span><span class="n">path</span><span 
class="p">,</span> <span class="s2">"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">nbytes</span> <span 
class="o">=</span> <span class="n">f</span><span class="o">.</span><span 
class="n">write</span><span class="p">(</span><span 
class="n">InputStream</span><span class="o">.</span><span 
class="n">example_bytes</span><span class="p">())</span>
 <span class="gp">...</span>
 <span class="gp">... </span>    <span class="k">with</span> <span 
class="n">na</span><span class="o">.</span><span 
class="n">ArrayStream</span><span class="o">.</span><span 
class="n">from_path</span><span class="p">(</span><span 
class="n">path</span><span class="p">)</span> <span class="k">as</span> <span 
class="n">stream</span><span class="p">:</span>
 <span class="gp">... </span>        <span class="n">stream</span><span 
class="o">.</span><span class="n">read_all</span><span class="p">()</span>
 <span class="go">nanoarrow.Array&lt;non-nullable struct&lt;some_col: 
int32&gt;&gt;[3]</span>
-<span class="go">{&#39;some_col&#39;: 1}</span>
-<span class="go">{&#39;some_col&#39;: 2}</span>
-<span class="go">{&#39;some_col&#39;: 3}</span>
+<span class="go">{'some_col': 1}</span>
+<span class="go">{'some_col': 2}</span>
+<span class="go">{'some_col': 3}</span>
 </pre></div>
 </div>
 </section>
@@ -504,9 +504,9 @@ this stream.</p>
 <span class="gp">&gt;&gt;&gt; </span><span class="k">with</span> <span 
class="n">na</span><span class="o">.</span><span 
class="n">ArrayStream</span><span class="o">.</span><span 
class="n">from_readable</span><span class="p">(</span><span 
class="n">InputStream</span><span class="o">.</span><span 
class="n">example_bytes</span><span class="p">())</span> <span 
class="k">as</span> <span class="n">stream</span><span class="p">:</span>
 <span class="gp">... </span>    <span class="n">stream</span><span 
class="o">.</span><span class="n">read_all</span><span class="p">()</span>
 <span class="go">nanoarrow.Array&lt;non-nullable struct&lt;some_col: 
int32&gt;&gt;[3]</span>
-<span class="go">{&#39;some_col&#39;: 1}</span>
-<span class="go">{&#39;some_col&#39;: 2}</span>
-<span class="go">{&#39;some_col&#39;: 3}</span>
+<span class="go">{'some_col': 1}</span>
+<span class="go">{'some_col': 2}</span>
+<span class="go">{'some_col': 3}</span>
 </pre></div>
 </div>
 </section>
@@ -524,17 +524,17 @@ this stream.</p>
 <span class="gp">&gt;&gt;&gt; </span><span class="kn">import</span><span 
class="w"> </span><span class="nn">nanoarrow</span><span class="w"> 
</span><span class="k">as</span><span class="w"> </span><span 
class="nn">na</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span><span 
class="w"> </span><span class="nn">nanoarrow.ipc</span><span class="w"> 
</span><span class="kn">import</span> <span class="n">InputStream</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="k">with</span> <span 
class="n">tempfile</span><span class="o">.</span><span 
class="n">TemporaryDirectory</span><span class="p">()</span> <span 
class="k">as</span> <span class="n">td</span><span class="p">:</span>
-<span class="gp">... </span>    <span class="n">path</span> <span 
class="o">=</span> <span class="n">os</span><span class="o">.</span><span 
class="n">path</span><span class="o">.</span><span class="n">join</span><span 
class="p">(</span><span class="n">td</span><span class="p">,</span> <span 
class="s2">&quot;test.arrows&quot;</span><span class="p">)</span>
-<span class="gp">... </span>    <span class="k">with</span> <span 
class="nb">open</span><span class="p">(</span><span class="n">path</span><span 
class="p">,</span> <span class="s2">&quot;wb&quot;</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">path</span> <span 
class="o">=</span> <span class="n">os</span><span class="o">.</span><span 
class="n">path</span><span class="o">.</span><span class="n">join</span><span 
class="p">(</span><span class="n">td</span><span class="p">,</span> <span 
class="s2">"test.arrows"</span><span class="p">)</span>
+<span class="gp">... </span>    <span class="k">with</span> <span 
class="nb">open</span><span class="p">(</span><span class="n">path</span><span 
class="p">,</span> <span class="s2">"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">nbytes</span> <span 
class="o">=</span> <span class="n">f</span><span class="o">.</span><span 
class="n">write</span><span class="p">(</span><span 
class="n">InputStream</span><span class="o">.</span><span 
class="n">example_bytes</span><span class="p">())</span>
 <span class="gp">...</span>
 <span class="gp">... </span>    <span class="n">uri</span> <span 
class="o">=</span> <span class="n">pathlib</span><span class="o">.</span><span 
class="n">Path</span><span class="p">(</span><span class="n">path</span><span 
class="p">)</span><span class="o">.</span><span class="n">as_uri</span><span 
class="p">()</span>
 <span class="gp">... </span>    <span class="k">with</span> <span 
class="n">na</span><span class="o">.</span><span 
class="n">ArrayStream</span><span class="o">.</span><span 
class="n">from_url</span><span class="p">(</span><span 
class="n">uri</span><span class="p">)</span> <span class="k">as</span> <span 
class="n">stream</span><span class="p">:</span>
 <span class="gp">... </span>        <span class="n">stream</span><span 
class="o">.</span><span class="n">read_all</span><span class="p">()</span>
 <span class="go">nanoarrow.Array&lt;non-nullable struct&lt;some_col: 
int32&gt;&gt;[3]</span>
-<span class="go">{&#39;some_col&#39;: 1}</span>
-<span class="go">{&#39;some_col&#39;: 2}</span>
-<span class="go">{&#39;some_col&#39;: 3}</span>
+<span class="go">{'some_col': 1}</span>
+<span class="go">{'some_col': 2}</span>
+<span class="go">{'some_col': 3}</span>
 </pre></div>
 </div>
 </section>
@@ -588,15 +588,15 @@ the stream itself.</p>
 <div class="doctest highlight-default notranslate"><div 
class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span 
class="kn">import</span><span class="w"> </span><span 
class="nn">nanoarrow</span><span class="w"> </span><span 
class="k">as</span><span class="w"> </span><span class="nn">na</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="kn">import</span><span 
class="w"> </span><span class="nn">pyarrow</span><span class="w"> </span><span 
class="k">as</span><span class="w"> </span><span class="nn">pa</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">batch</span> <span 
class="o">=</span> <span class="n">pa</span><span class="o">.</span><span 
class="n">record_batch</span><span class="p">(</span>
-<span class="gp">... </span>    <span class="p">[</span><span 
class="n">pa</span><span class="o">.</span><span class="n">array</span><span 
class="p">([</span><span class="mi">1</span><span class="p">,</span> <span 
class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span 
class="p">]),</span> <span class="n">pa</span><span class="o">.</span><span 
class="n">array</span><span class="p">([</span><span 
class="s2">&quot;a&quot;</span><span class="p">,</span> <span class="s2">& [...]
-<span class="gp">... </span>    <span class="n">names</span><span 
class="o">=</span><span class="p">[</span><span 
class="s2">&quot;col1&quot;</span><span class="p">,</span> <span 
class="s2">&quot;col2&quot;</span><span class="p">]</span>
+<span class="gp">... </span>    <span class="p">[</span><span 
class="n">pa</span><span class="o">.</span><span class="n">array</span><span 
class="p">([</span><span class="mi">1</span><span class="p">,</span> <span 
class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span 
class="p">]),</span> <span class="n">pa</span><span class="o">.</span><span 
class="n">array</span><span class="p">([</span><span class="s2">"a"</span><span 
class="p">,</span> <span class="s2">"b"</span>< [...]
+<span class="gp">... </span>    <span class="n">names</span><span 
class="o">=</span><span class="p">[</span><span class="s2">"col1"</span><span 
class="p">,</span> <span class="s2">"col2"</span><span class="p">]</span>
 <span class="gp">... </span><span class="p">)</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">stream</span> <span 
class="o">=</span> <span class="n">na</span><span class="o">.</span><span 
class="n">ArrayStream</span><span class="p">(</span><span 
class="n">batch</span><span class="p">)</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="k">for</span> <span 
class="n">item</span> <span class="ow">in</span> <span 
class="n">stream</span><span class="o">.</span><span 
class="n">iter_tuples</span><span class="p">():</span>
 <span class="gp">... </span>    <span class="nb">print</span><span 
class="p">(</span><span class="n">item</span><span class="p">)</span>
-<span class="go">(1, &#39;a&#39;)</span>
-<span class="go">(2, &#39;b&#39;)</span>
-<span class="go">(3, &#39;c&#39;)</span>
+<span class="go">(1, 'a')</span>
+<span class="go">(2, 'b')</span>
+<span class="go">(3, 'c')</span>
 </pre></div>
 </div>
 </section>
diff --git a/main/reference/python/array.html b/main/reference/python/array.html
index 92789413..3661b6a6 100644
--- a/main/reference/python/array.html
+++ b/main/reference/python/array.html
@@ -493,15 +493,15 @@ Defaults to the CPU device.</p>
 <div class="doctest highlight-default notranslate"><div 
class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span 
class="kn">import</span><span class="w"> </span><span 
class="nn">nanoarrow</span><span class="w"> </span><span 
class="k">as</span><span class="w"> </span><span class="nn">na</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="kn">import</span><span 
class="w"> </span><span class="nn">pyarrow</span><span class="w"> </span><span 
class="k">as</span><span class="w"> </span><span class="nn">pa</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">batch</span> <span 
class="o">=</span> <span class="n">pa</span><span class="o">.</span><span 
class="n">record_batch</span><span class="p">(</span>
-<span class="gp">... </span>    <span class="p">[</span><span 
class="n">pa</span><span class="o">.</span><span class="n">array</span><span 
class="p">([</span><span class="mi">1</span><span class="p">,</span> <span 
class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span 
class="p">]),</span> <span class="n">pa</span><span class="o">.</span><span 
class="n">array</span><span class="p">([</span><span 
class="s2">&quot;a&quot;</span><span class="p">,</span> <span class="s2">& [...]
-<span class="gp">... </span>    <span class="n">names</span><span 
class="o">=</span><span class="p">[</span><span 
class="s2">&quot;col1&quot;</span><span class="p">,</span> <span 
class="s2">&quot;col2&quot;</span><span class="p">]</span>
+<span class="gp">... </span>    <span class="p">[</span><span 
class="n">pa</span><span class="o">.</span><span class="n">array</span><span 
class="p">([</span><span class="mi">1</span><span class="p">,</span> <span 
class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span 
class="p">]),</span> <span class="n">pa</span><span class="o">.</span><span 
class="n">array</span><span class="p">([</span><span class="s2">"a"</span><span 
class="p">,</span> <span class="s2">"b"</span>< [...]
+<span class="gp">... </span>    <span class="n">names</span><span 
class="o">=</span><span class="p">[</span><span class="s2">"col1"</span><span 
class="p">,</span> <span class="s2">"col2"</span><span class="p">]</span>
 <span class="gp">... </span><span class="p">)</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">array</span> <span 
class="o">=</span> <span class="n">na</span><span class="o">.</span><span 
class="n">Array</span><span class="p">(</span><span class="n">batch</span><span 
class="p">)</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">array</span><span 
class="o">.</span><span class="n">child</span><span class="p">(</span><span 
class="mi">1</span><span class="p">)</span>
-<span class="go">nanoarrow.Array&lt;&#39;col2&#39;: string&gt;[3]</span>
-<span class="go">&#39;a&#39;</span>
-<span class="go">&#39;b&#39;</span>
-<span class="go">&#39;c&#39;</span>
+<span class="go">nanoarrow.Array&lt;'col2': string&gt;[3]</span>
+<span class="go">'a'</span>
+<span class="go">'b'</span>
+<span class="go">'c'</span>
 </pre></div>
 </div>
 </section>
@@ -601,20 +601,20 @@ and children arrays).</p>
 <div class="doctest highlight-default notranslate"><div 
class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span 
class="kn">import</span><span class="w"> </span><span 
class="nn">nanoarrow</span><span class="w"> </span><span 
class="k">as</span><span class="w"> </span><span class="nn">na</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="kn">import</span><span 
class="w"> </span><span class="nn">pyarrow</span><span class="w"> </span><span 
class="k">as</span><span class="w"> </span><span class="nn">pa</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">batch</span> <span 
class="o">=</span> <span class="n">pa</span><span class="o">.</span><span 
class="n">record_batch</span><span class="p">(</span>
-<span class="gp">... </span>    <span class="p">[</span><span 
class="n">pa</span><span class="o">.</span><span class="n">array</span><span 
class="p">([</span><span class="mi">1</span><span class="p">,</span> <span 
class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span 
class="p">]),</span> <span class="n">pa</span><span class="o">.</span><span 
class="n">array</span><span class="p">([</span><span 
class="s2">&quot;a&quot;</span><span class="p">,</span> <span class="s2">& [...]
-<span class="gp">... </span>    <span class="n">names</span><span 
class="o">=</span><span class="p">[</span><span 
class="s2">&quot;col1&quot;</span><span class="p">,</span> <span 
class="s2">&quot;col2&quot;</span><span class="p">]</span>
+<span class="gp">... </span>    <span class="p">[</span><span 
class="n">pa</span><span class="o">.</span><span class="n">array</span><span 
class="p">([</span><span class="mi">1</span><span class="p">,</span> <span 
class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span 
class="p">]),</span> <span class="n">pa</span><span class="o">.</span><span 
class="n">array</span><span class="p">([</span><span class="s2">"a"</span><span 
class="p">,</span> <span class="s2">"b"</span>< [...]
+<span class="gp">... </span>    <span class="n">names</span><span 
class="o">=</span><span class="p">[</span><span class="s2">"col1"</span><span 
class="p">,</span> <span class="s2">"col2"</span><span class="p">]</span>
 <span class="gp">... </span><span class="p">)</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">array</span> <span 
class="o">=</span> <span class="n">na</span><span class="o">.</span><span 
class="n">Array</span><span class="p">(</span><span class="n">batch</span><span 
class="p">)</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="k">for</span> <span 
class="n">child</span> <span class="ow">in</span> <span 
class="n">array</span><span class="o">.</span><span 
class="n">iter_children</span><span class="p">():</span>
 <span class="gp">... </span>    <span class="nb">print</span><span 
class="p">(</span><span class="n">child</span><span class="p">)</span>
-<span class="go">nanoarrow.Array&lt;&#39;col1&#39;: int64&gt;[3]</span>
+<span class="go">nanoarrow.Array&lt;'col1': int64&gt;[3]</span>
 <span class="go">1</span>
 <span class="go">2</span>
 <span class="go">3</span>
-<span class="go">nanoarrow.Array&lt;&#39;col2&#39;: string&gt;[3]</span>
-<span class="go">&#39;a&#39;</span>
-<span class="go">&#39;b&#39;</span>
-<span class="go">&#39;c&#39;</span>
+<span class="go">nanoarrow.Array&lt;'col2': string&gt;[3]</span>
+<span class="go">'a'</span>
+<span class="go">'b'</span>
+<span class="go">'c'</span>
 </pre></div>
 </div>
 </section>
@@ -707,15 +707,15 @@ contiguous in memory.</p>
 <div class="doctest highlight-default notranslate"><div 
class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span 
class="kn">import</span><span class="w"> </span><span 
class="nn">nanoarrow</span><span class="w"> </span><span 
class="k">as</span><span class="w"> </span><span class="nn">na</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="kn">import</span><span 
class="w"> </span><span class="nn">pyarrow</span><span class="w"> </span><span 
class="k">as</span><span class="w"> </span><span class="nn">pa</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">batch</span> <span 
class="o">=</span> <span class="n">pa</span><span class="o">.</span><span 
class="n">record_batch</span><span class="p">(</span>
-<span class="gp">... </span>    <span class="p">[</span><span 
class="n">pa</span><span class="o">.</span><span class="n">array</span><span 
class="p">([</span><span class="mi">1</span><span class="p">,</span> <span 
class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span 
class="p">]),</span> <span class="n">pa</span><span class="o">.</span><span 
class="n">array</span><span class="p">([</span><span 
class="s2">&quot;a&quot;</span><span class="p">,</span> <span class="s2">& [...]
-<span class="gp">... </span>    <span class="n">names</span><span 
class="o">=</span><span class="p">[</span><span 
class="s2">&quot;col1&quot;</span><span class="p">,</span> <span 
class="s2">&quot;col2&quot;</span><span class="p">]</span>
+<span class="gp">... </span>    <span class="p">[</span><span 
class="n">pa</span><span class="o">.</span><span class="n">array</span><span 
class="p">([</span><span class="mi">1</span><span class="p">,</span> <span 
class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span 
class="p">]),</span> <span class="n">pa</span><span class="o">.</span><span 
class="n">array</span><span class="p">([</span><span class="s2">"a"</span><span 
class="p">,</span> <span class="s2">"b"</span>< [...]
+<span class="gp">... </span>    <span class="n">names</span><span 
class="o">=</span><span class="p">[</span><span class="s2">"col1"</span><span 
class="p">,</span> <span class="s2">"col2"</span><span class="p">]</span>
 <span class="gp">... </span><span class="p">)</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">array</span> <span 
class="o">=</span> <span class="n">na</span><span class="o">.</span><span 
class="n">Array</span><span class="p">(</span><span class="n">batch</span><span 
class="p">)</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="k">for</span> <span 
class="n">item</span> <span class="ow">in</span> <span 
class="n">array</span><span class="o">.</span><span 
class="n">iter_tuples</span><span class="p">():</span>
 <span class="gp">... </span>    <span class="nb">print</span><span 
class="p">(</span><span class="n">item</span><span class="p">)</span>
-<span class="go">(1, &#39;a&#39;)</span>
-<span class="go">(2, &#39;b&#39;)</span>
-<span class="go">(3, &#39;c&#39;)</span>
+<span class="go">(1, 'a')</span>
+<span class="go">(2, 'b')</span>
+<span class="go">(3, 'c')</span>
 </pre></div>
 </div>
 </section>
@@ -745,8 +745,8 @@ contiguous in memory.</p>
 <div class="doctest highlight-default notranslate"><div 
class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span 
class="kn">import</span><span class="w"> </span><span 
class="nn">nanoarrow</span><span class="w"> </span><span 
class="k">as</span><span class="w"> </span><span class="nn">na</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="kn">import</span><span 
class="w"> </span><span class="nn">pyarrow</span><span class="w"> </span><span 
class="k">as</span><span class="w"> </span><span class="nn">pa</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">batch</span> <span 
class="o">=</span> <span class="n">pa</span><span class="o">.</span><span 
class="n">record_batch</span><span class="p">(</span>
-<span class="gp">... </span>    <span class="p">[</span><span 
class="n">pa</span><span class="o">.</span><span class="n">array</span><span 
class="p">([</span><span class="mi">1</span><span class="p">,</span> <span 
class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span 
class="p">]),</span> <span class="n">pa</span><span class="o">.</span><span 
class="n">array</span><span class="p">([</span><span 
class="s2">&quot;a&quot;</span><span class="p">,</span> <span class="s2">& [...]
-<span class="gp">... </span>    <span class="n">names</span><span 
class="o">=</span><span class="p">[</span><span 
class="s2">&quot;col1&quot;</span><span class="p">,</span> <span 
class="s2">&quot;col2&quot;</span><span class="p">]</span>
+<span class="gp">... </span>    <span class="p">[</span><span 
class="n">pa</span><span class="o">.</span><span class="n">array</span><span 
class="p">([</span><span class="mi">1</span><span class="p">,</span> <span 
class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span 
class="p">]),</span> <span class="n">pa</span><span class="o">.</span><span 
class="n">array</span><span class="p">([</span><span class="s2">"a"</span><span 
class="p">,</span> <span class="s2">"b"</span>< [...]
+<span class="gp">... </span>    <span class="n">names</span><span 
class="o">=</span><span class="p">[</span><span class="s2">"col1"</span><span 
class="p">,</span> <span class="s2">"col2"</span><span class="p">]</span>
 <span class="gp">... </span><span class="p">)</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">array</span> <span 
class="o">=</span> <span class="n">na</span><span class="o">.</span><span 
class="n">Array</span><span class="p">(</span><span class="n">batch</span><span 
class="p">)</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">array</span><span 
class="o">.</span><span class="n">n_children</span>
diff --git a/main/reference/python/schema.html 
b/main/reference/python/schema.html
index a93e4633..3896f12e 100644
--- a/main/reference/python/schema.html
+++ b/main/reference/python/schema.html
@@ -465,7 +465,7 @@ includes:
 <span class="gp">&gt;&gt;&gt; </span><span class="n">na</span><span 
class="o">.</span><span class="n">Schema</span><span class="p">(</span><span 
class="n">na</span><span class="o">.</span><span class="n">Type</span><span 
class="o">.</span><span class="n">INT32</span><span class="p">)</span>
 <span class="go">&lt;Schema&gt; int32</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">na</span><span 
class="o">.</span><span class="n">Schema</span><span class="p">(</span><span 
class="n">na</span><span class="o">.</span><span class="n">Type</span><span 
class="o">.</span><span class="n">DURATION</span><span class="p">,</span> <span 
class="n">unit</span><span class="o">=</span><span class="n">na</span><span 
class="o">.</span><span class="n">TimeUnit</span><span class="o">.</span><span 
class="n">SECOND</span><span class=" [...]
-<span class="go">&lt;Schema&gt; duration(&#39;s&#39;)</span>
+<span class="go">&lt;Schema&gt; duration('s')</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">na</span><span 
class="o">.</span><span class="n">Schema</span><span class="p">(</span><span 
class="n">pa</span><span class="o">.</span><span class="n">int32</span><span 
class="p">())</span>
 <span class="go">&lt;Schema&gt; int32</span>
 </pre></div>
@@ -500,11 +500,11 @@ are meaningful.</p>
 <span class="property"><span class="k"><span 
class="pre">property</span></span><span class="w"> </span></span><span 
class="sig-name descname"><span class="pre">extension</span></span><span 
class="property"><span class="p"><span class="pre">:</span></span><span 
class="w"> </span><a class="reference internal" 
href="#nanoarrow.schema.ExtensionAccessor" 
title="nanoarrow.schema.ExtensionAccessor"><span 
class="pre">ExtensionAccessor</span></a><span class="w"> </span><span 
class="p"><span class [...]
 <dd><p>Access extension type attributes</p>
 <div class="doctest highlight-default notranslate"><div 
class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span 
class="kn">import</span><span class="w"> </span><span 
class="nn">nanoarrow</span><span class="w"> </span><span 
class="k">as</span><span class="w"> </span><span class="nn">na</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">schema</span> <span 
class="o">=</span> <span class="n">na</span><span class="o">.</span><span 
class="n">extension_type</span><span class="p">(</span><span 
class="n">na</span><span class="o">.</span><span class="n">int32</span><span 
class="p">(),</span> <span class="s2">&quot;arrow.example&quot;</span><span 
class="p">,</span> <span class="sa">b</span><span class="s2">&quot;</span><span 
class="si">{}</span><span class="s2">&quot;</span>< [...]
+<span class="gp">&gt;&gt;&gt; </span><span class="n">schema</span> <span 
class="o">=</span> <span class="n">na</span><span class="o">.</span><span 
class="n">extension_type</span><span class="p">(</span><span 
class="n">na</span><span class="o">.</span><span class="n">int32</span><span 
class="p">(),</span> <span class="s2">"arrow.example"</span><span 
class="p">,</span> <span class="sa">b</span><span class="s2">"</span><span 
class="si">{}</span><span class="s2">"</span><span class="p">)</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">schema</span><span 
class="o">.</span><span class="n">extension</span><span class="o">.</span><span 
class="n">name</span>
-<span class="go">&#39;arrow.example&#39;</span>
+<span class="go">'arrow.example'</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">schema</span><span 
class="o">.</span><span class="n">extension</span><span class="o">.</span><span 
class="n">metadata</span>
-<span class="go">b&#39;{}&#39;</span>
+<span class="go">b'{}'</span>
 </pre></div>
 </div>
 </dd></dl>
@@ -514,9 +514,9 @@ are meaningful.</p>
 <span class="sig-name descname"><span class="pre">field</span></span><span 
class="sig-paren">(</span><em class="sig-param"><span class="n"><span 
class="pre">i</span></span></em><span class="sig-paren">)</span> <span 
class="sig-return"><span class="sig-return-icon">&#x2192;</span> <span 
class="sig-return-typehint"><a class="reference internal" 
href="#nanoarrow.schema.Schema" title="nanoarrow.schema.Schema"><span 
class="pre">Schema</span></a></span></span><a class="headerlink" href="#nanoa 
[...]
 <dd><p>Extract a child Schema</p>
 <div class="doctest highlight-default notranslate"><div 
class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span 
class="kn">import</span><span class="w"> </span><span 
class="nn">nanoarrow</span><span class="w"> </span><span 
class="k">as</span><span class="w"> </span><span class="nn">na</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">schema</span> <span 
class="o">=</span> <span class="n">na</span><span class="o">.</span><span 
class="n">struct</span><span class="p">({</span><span 
class="s2">&quot;col1&quot;</span><span class="p">:</span> <span 
class="n">na</span><span class="o">.</span><span class="n">int32</span><span 
class="p">()})</span>
+<span class="gp">&gt;&gt;&gt; </span><span class="n">schema</span> <span 
class="o">=</span> <span class="n">na</span><span class="o">.</span><span 
class="n">struct</span><span class="p">({</span><span 
class="s2">"col1"</span><span class="p">:</span> <span class="n">na</span><span 
class="o">.</span><span class="n">int32</span><span class="p">()})</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">schema</span><span 
class="o">.</span><span class="n">field</span><span class="p">(</span><span 
class="mi">0</span><span class="p">)</span>
-<span class="go">&lt;Schema&gt; &#39;col1&#39;: int32</span>
+<span class="go">&lt;Schema&gt; 'col1': int32</span>
 </pre></div>
 </div>
 </dd></dl>
@@ -526,7 +526,7 @@ are meaningful.</p>
 <span class="property"><span class="k"><span 
class="pre">property</span></span><span class="w"> </span></span><span 
class="sig-name descname"><span class="pre">fields</span></span><span 
class="property"><span class="p"><span class="pre">:</span></span><span 
class="w"> </span><span class="pre">List</span><span class="p"><span 
class="pre">[</span></span><a class="reference internal" 
href="#nanoarrow.schema.Schema" title="nanoarrow.schema.Schema"><span 
class="pre">Schema</span></a><span cla [...]
 <dd><p>Iterate over child Schemas</p>
 <div class="doctest highlight-default notranslate"><div 
class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span 
class="kn">import</span><span class="w"> </span><span 
class="nn">nanoarrow</span><span class="w"> </span><span 
class="k">as</span><span class="w"> </span><span class="nn">na</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">schema</span> <span 
class="o">=</span> <span class="n">na</span><span class="o">.</span><span 
class="n">struct</span><span class="p">({</span><span 
class="s2">&quot;col1&quot;</span><span class="p">:</span> <span 
class="n">na</span><span class="o">.</span><span class="n">int32</span><span 
class="p">()})</span>
+<span class="gp">&gt;&gt;&gt; </span><span class="n">schema</span> <span 
class="o">=</span> <span class="n">na</span><span class="o">.</span><span 
class="n">struct</span><span class="p">({</span><span 
class="s2">"col1"</span><span class="p">:</span> <span class="n">na</span><span 
class="o">.</span><span class="n">int32</span><span class="p">()})</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="k">for</span> <span 
class="n">field</span> <span class="ow">in</span> <span 
class="n">schema</span><span class="o">.</span><span 
class="n">fields</span><span class="p">:</span>
 <span class="gp">... </span>    <span class="nb">print</span><span 
class="p">(</span><span class="n">field</span><span class="o">.</span><span 
class="n">name</span><span class="p">)</span>
 <span class="gp">...</span>
@@ -554,7 +554,7 @@ See also <a class="reference internal" 
href="#nanoarrow.schema.Schema.value_type
 <dd><p>Map key type</p>
 <div class="doctest highlight-default notranslate"><div 
class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span 
class="kn">import</span><span class="w"> </span><span 
class="nn">nanoarrow</span><span class="w"> </span><span 
class="k">as</span><span class="w"> </span><span class="nn">na</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">na</span><span 
class="o">.</span><span class="n">map_</span><span class="p">(</span><span 
class="n">na</span><span class="o">.</span><span class="n">int32</span><span 
class="p">(),</span> <span class="n">na</span><span class="o">.</span><span 
class="n">string</span><span class="p">())</span><span class="o">.</span><span 
class="n">key_type</span>
-<span class="go">&lt;Schema&gt; &#39;key&#39;: non-nullable int32</span>
+<span class="go">&lt;Schema&gt; 'key': non-nullable int32</span>
 </pre></div>
 </div>
 </dd></dl>
@@ -575,9 +575,9 @@ See also <a class="reference internal" 
href="#nanoarrow.schema.Schema.value_type
 <span class="property"><span class="k"><span 
class="pre">property</span></span><span class="w"> </span></span><span 
class="sig-name descname"><span class="pre">metadata</span></span><span 
class="property"><span class="p"><span class="pre">:</span></span><span 
class="w"> </span><span class="pre">Mapping</span><span class="p"><span 
class="pre">[</span></span><span class="pre">bytes</span><span class="p"><span 
class="pre">,</span></span><span class="w"> </span><span 
class="pre">bytes</span> [...]
 <dd><p>Access field metadata of this field</p>
 <div class="doctest highlight-default notranslate"><div 
class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span 
class="kn">import</span><span class="w"> </span><span 
class="nn">nanoarrow</span><span class="w"> </span><span 
class="k">as</span><span class="w"> </span><span class="nn">na</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">schema</span> <span 
class="o">=</span> <span class="n">na</span><span class="o">.</span><span 
class="n">Schema</span><span class="p">(</span><span class="n">na</span><span 
class="o">.</span><span class="n">int32</span><span class="p">(),</span> <span 
class="n">metadata</span><span class="o">=</span><span class="p">{</span><span 
class="s2">&quot;key&quot;</span><span class="p">:</span> <span 
class="s2">&quot;value&quot;</span><span clas [...]
+<span class="gp">&gt;&gt;&gt; </span><span class="n">schema</span> <span 
class="o">=</span> <span class="n">na</span><span class="o">.</span><span 
class="n">Schema</span><span class="p">(</span><span class="n">na</span><span 
class="o">.</span><span class="n">int32</span><span class="p">(),</span> <span 
class="n">metadata</span><span class="o">=</span><span class="p">{</span><span 
class="s2">"key"</span><span class="p">:</span> <span 
class="s2">"value"</span><span class="p">})</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="nb">dict</span><span 
class="p">(</span><span class="n">schema</span><span class="o">.</span><span 
class="n">metadata</span><span class="o">.</span><span 
class="n">items</span><span class="p">())</span>
-<span class="go">{b&#39;key&#39;: b&#39;value&#39;}</span>
+<span class="go">{b'key': b'value'}</span>
 </pre></div>
 </div>
 </dd></dl>
@@ -587,7 +587,7 @@ See also <a class="reference internal" 
href="#nanoarrow.schema.Schema.value_type
 <span class="property"><span class="k"><span 
class="pre">property</span></span><span class="w"> </span></span><span 
class="sig-name descname"><span class="pre">n_fields</span></span><span 
class="property"><span class="p"><span class="pre">:</span></span><span 
class="w"> </span><span class="pre">int</span></span><a class="headerlink" 
href="#nanoarrow.schema.Schema.n_fields" title="Link to this 
definition">#</a></dt>
 <dd><p>Number of child Schemas</p>
 <div class="doctest highlight-default notranslate"><div 
class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span 
class="kn">import</span><span class="w"> </span><span 
class="nn">nanoarrow</span><span class="w"> </span><span 
class="k">as</span><span class="w"> </span><span class="nn">na</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">schema</span> <span 
class="o">=</span> <span class="n">na</span><span class="o">.</span><span 
class="n">struct</span><span class="p">({</span><span 
class="s2">&quot;col1&quot;</span><span class="p">:</span> <span 
class="n">na</span><span class="o">.</span><span class="n">int32</span><span 
class="p">()})</span>
+<span class="gp">&gt;&gt;&gt; </span><span class="n">schema</span> <span 
class="o">=</span> <span class="n">na</span><span class="o">.</span><span 
class="n">struct</span><span class="p">({</span><span 
class="s2">"col1"</span><span class="p">:</span> <span class="n">na</span><span 
class="o">.</span><span class="n">int32</span><span class="p">()})</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">schema</span><span 
class="o">.</span><span class="n">n_fields</span>
 <span class="go">1</span>
 </pre></div>
@@ -599,9 +599,9 @@ See also <a class="reference internal" 
href="#nanoarrow.schema.Schema.value_type
 <span class="property"><span class="k"><span 
class="pre">property</span></span><span class="w"> </span></span><span 
class="sig-name descname"><span class="pre">name</span></span><span 
class="property"><span class="p"><span class="pre">:</span></span><span 
class="w"> </span><span class="pre">str</span><span class="w"> </span><span 
class="p"><span class="pre">|</span></span><span class="w"> </span><span 
class="pre">None</span></span><a class="headerlink" 
href="#nanoarrow.schema.Schema.name [...]
 <dd><p>Field name of this Schema</p>
 <div class="doctest highlight-default notranslate"><div 
class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span 
class="kn">import</span><span class="w"> </span><span 
class="nn">nanoarrow</span><span class="w"> </span><span 
class="k">as</span><span class="w"> </span><span class="nn">na</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">schema</span> <span 
class="o">=</span> <span class="n">na</span><span class="o">.</span><span 
class="n">struct</span><span class="p">({</span><span 
class="s2">&quot;col1&quot;</span><span class="p">:</span> <span 
class="n">na</span><span class="o">.</span><span class="n">int32</span><span 
class="p">()})</span>
+<span class="gp">&gt;&gt;&gt; </span><span class="n">schema</span> <span 
class="o">=</span> <span class="n">na</span><span class="o">.</span><span 
class="n">struct</span><span class="p">({</span><span 
class="s2">"col1"</span><span class="p">:</span> <span class="n">na</span><span 
class="o">.</span><span class="n">int32</span><span class="p">()})</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">schema</span><span 
class="o">.</span><span class="n">field</span><span class="p">(</span><span 
class="mi">0</span><span class="p">)</span><span class="o">.</span><span 
class="n">name</span>
-<span class="go">&#39;col1&#39;</span>
+<span class="go">'col1'</span>
 </pre></div>
 </div>
 </dd></dl>
@@ -627,7 +627,7 @@ See also <a class="reference internal" 
href="#nanoarrow.schema.Schema.value_type
 this type together with its type identifier.</p>
 <div class="doctest highlight-default notranslate"><div 
class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span 
class="kn">import</span><span class="w"> </span><span 
class="nn">nanoarrow</span><span class="w"> </span><span 
class="k">as</span><span class="w"> </span><span class="nn">na</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">na</span><span 
class="o">.</span><span class="n">fixed_size_binary</span><span 
class="p">(</span><span class="mi">123</span><span class="p">)</span><span 
class="o">.</span><span class="n">params</span>
-<span class="go">{&#39;byte_width&#39;: 123}</span>
+<span class="go">{'byte_width': 123}</span>
 </pre></div>
 </div>
 </dd></dl>
@@ -676,8 +676,8 @@ return the serialized result.</p>
 <p>Returns <code class="docutils literal notranslate"><span 
class="pre">None</span></code> for types for which this property is not 
relevant or
 for timezone types for which the timezone is not set.</p>
 <div class="doctest highlight-default notranslate"><div 
class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span 
class="kn">import</span><span class="w"> </span><span 
class="nn">nanoarrow</span><span class="w"> </span><span 
class="k">as</span><span class="w"> </span><span class="nn">na</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">na</span><span 
class="o">.</span><span class="n">timestamp</span><span class="p">(</span><span 
class="n">na</span><span class="o">.</span><span class="n">TimeUnit</span><span 
class="o">.</span><span class="n">SECOND</span><span class="p">,</span> <span 
class="n">timezone</span><span class="o">=</span><span 
class="s2">&quot;America/Halifax&quot;</span><span class="p">)</span><span 
class="o">.</span><span class="n">timezone</span>
-<span class="go">&#39;America/Halifax&#39;</span>
+<span class="gp">&gt;&gt;&gt; </span><span class="n">na</span><span 
class="o">.</span><span class="n">timestamp</span><span class="p">(</span><span 
class="n">na</span><span class="o">.</span><span class="n">TimeUnit</span><span 
class="o">.</span><span class="n">SECOND</span><span class="p">,</span> <span 
class="n">timezone</span><span class="o">=</span><span 
class="s2">"America/Halifax"</span><span class="p">)</span><span 
class="o">.</span><span class="n">timezone</span>
+<span class="go">'America/Halifax'</span>
 </pre></div>
 </div>
 </dd></dl>
@@ -722,9 +722,9 @@ for timezone types for which the timezone is not set.</p>
 <dd><p>Dictionary, map, or list value type</p>
 <div class="doctest highlight-default notranslate"><div 
class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span 
class="kn">import</span><span class="w"> </span><span 
class="nn">nanoarrow</span><span class="w"> </span><span 
class="k">as</span><span class="w"> </span><span class="nn">na</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">na</span><span 
class="o">.</span><span class="n">list_</span><span class="p">(</span><span 
class="n">na</span><span class="o">.</span><span class="n">int32</span><span 
class="p">())</span><span class="o">.</span><span class="n">value_type</span>
-<span class="go">&lt;Schema&gt; &#39;item&#39;: int32</span>
+<span class="go">&lt;Schema&gt; 'item': int32</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">na</span><span 
class="o">.</span><span class="n">map_</span><span class="p">(</span><span 
class="n">na</span><span class="o">.</span><span class="n">int32</span><span 
class="p">(),</span> <span class="n">na</span><span class="o">.</span><span 
class="n">string</span><span class="p">())</span><span class="o">.</span><span 
class="n">value_type</span>
-<span class="go">&lt;Schema&gt; &#39;value&#39;: string</span>
+<span class="go">&lt;Schema&gt; 'value': string</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">na</span><span 
class="o">.</span><span class="n">dictionary</span><span 
class="p">(</span><span class="n">na</span><span class="o">.</span><span 
class="n">int32</span><span class="p">(),</span> <span class="n">na</span><span 
class="o">.</span><span class="n">string</span><span class="p">())</span><span 
class="o">.</span><span class="n">value_type</span>
 <span class="go">&lt;Schema&gt; string</span>
 </pre></div>
@@ -745,7 +745,7 @@ for timezone types for which the timezone is not set.</p>
 <p>This constructor will accept the abbreviations “s”, “ms”, “us”, and “ns”
 and return the appropriate enumerator value.</p>
 <div class="doctest highlight-default notranslate"><div 
class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span 
class="kn">import</span><span class="w"> </span><span 
class="nn">nanoarrow</span><span class="w"> </span><span 
class="k">as</span><span class="w"> </span><span class="nn">na</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">na</span><span 
class="o">.</span><span class="n">TimeUnit</span><span class="o">.</span><span 
class="n">create</span><span class="p">(</span><span 
class="s2">&quot;s&quot;</span><span class="p">)</span>
+<span class="gp">&gt;&gt;&gt; </span><span class="n">na</span><span 
class="o">.</span><span class="n">TimeUnit</span><span class="o">.</span><span 
class="n">create</span><span class="p">(</span><span class="s2">"s"</span><span 
class="p">)</span>
 <span class="go">&lt;TimeUnit.SECOND: 0&gt;</span>
 </pre></div>
 </div>
@@ -994,8 +994,8 @@ meaningful.</p>
 <section id="id21">
 <h2>Examples<a class="headerlink" href="#id21" title="Link to this 
heading">#</a></h2>
 <div class="doctest highlight-default notranslate"><div 
class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span 
class="kn">import</span><span class="w"> </span><span 
class="nn">nanoarrow</span><span class="w"> </span><span 
class="k">as</span><span class="w"> </span><span class="nn">na</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">na</span><span 
class="o">.</span><span class="n">duration</span><span class="p">(</span><span 
class="s2">&quot;s&quot;</span><span class="p">)</span>
-<span class="go">&lt;Schema&gt; duration(&#39;s&#39;)</span>
+<span class="gp">&gt;&gt;&gt; </span><span class="n">na</span><span 
class="o">.</span><span class="n">duration</span><span class="p">(</span><span 
class="s2">"s"</span><span class="p">)</span>
+<span class="go">&lt;Schema&gt; duration('s')</span>
 </pre></div>
 </div>
 </section>
@@ -1521,7 +1521,7 @@ inherited from the schema-like object.</p></li>
 <div class="doctest highlight-default notranslate"><div 
class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span 
class="kn">import</span><span class="w"> </span><span 
class="nn">nanoarrow</span><span class="w"> </span><span 
class="k">as</span><span class="w"> </span><span class="nn">na</span>
 <span class="gp">&gt;&gt;&gt; </span><span class="n">na</span><span 
class="o">.</span><span class="n">struct</span><span class="p">([</span><span 
class="n">na</span><span class="o">.</span><span class="n">int32</span><span 
class="p">()])</span>
 <span class="go">&lt;Schema&gt; struct&lt;: int32&gt;</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">na</span><span 
class="o">.</span><span class="n">struct</span><span class="p">({</span><span 
class="s2">&quot;col1&quot;</span><span class="p">:</span> <span 
class="n">na</span><span class="o">.</span><span class="n">int32</span><span 
class="p">()})</span>
+<span class="gp">&gt;&gt;&gt; </span><span class="n">na</span><span 
class="o">.</span><span class="n">struct</span><span class="p">({</span><span 
class="s2">"col1"</span><span class="p">:</span> <span class="n">na</span><span 
class="o">.</span><span class="n">int32</span><span class="p">()})</span>
 <span class="go">&lt;Schema&gt; struct&lt;col1: int32&gt;</span>
 </pre></div>
 </div>
@@ -1544,8 +1544,8 @@ inherited from the schema-like object.</p></li>
 <section id="id68">
 <h2>Examples<a class="headerlink" href="#id68" title="Link to this 
heading">#</a></h2>
 <div class="doctest highlight-default notranslate"><div 
class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span 
class="kn">import</span><span class="w"> </span><span 
class="nn">nanoarrow</span><span class="w"> </span><span 
class="k">as</span><span class="w"> </span><span class="nn">na</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">na</span><span 
class="o">.</span><span class="n">time32</span><span class="p">(</span><span 
class="s2">&quot;s&quot;</span><span class="p">)</span>
-<span class="go">&lt;Schema&gt; time32(&#39;s&#39;)</span>
+<span class="gp">&gt;&gt;&gt; </span><span class="n">na</span><span 
class="o">.</span><span class="n">time32</span><span class="p">(</span><span 
class="s2">"s"</span><span class="p">)</span>
+<span class="go">&lt;Schema&gt; time32('s')</span>
 </pre></div>
 </div>
 </section>
@@ -1567,8 +1567,8 @@ inherited from the schema-like object.</p></li>
 <section id="id70">
 <h2>Examples<a class="headerlink" href="#id70" title="Link to this 
heading">#</a></h2>
 <div class="doctest highlight-default notranslate"><div 
class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span 
class="kn">import</span><span class="w"> </span><span 
class="nn">nanoarrow</span><span class="w"> </span><span 
class="k">as</span><span class="w"> </span><span class="nn">na</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">na</span><span 
class="o">.</span><span class="n">time64</span><span class="p">(</span><span 
class="s2">&quot;us&quot;</span><span class="p">)</span>
-<span class="go">&lt;Schema&gt; time64(&#39;us&#39;)</span>
+<span class="gp">&gt;&gt;&gt; </span><span class="n">na</span><span 
class="o">.</span><span class="n">time64</span><span class="p">(</span><span 
class="s2">"us"</span><span class="p">)</span>
+<span class="go">&lt;Schema&gt; time64('us')</span>
 </pre></div>
 </div>
 </section>
@@ -1590,10 +1590,10 @@ inherited from the schema-like object.</p></li>
 <section id="id72">
 <h2>Examples<a class="headerlink" href="#id72" title="Link to this 
heading">#</a></h2>
 <div class="doctest highlight-default notranslate"><div 
class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span 
class="kn">import</span><span class="w"> </span><span 
class="nn">nanoarrow</span><span class="w"> </span><span 
class="k">as</span><span class="w"> </span><span class="nn">na</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">na</span><span 
class="o">.</span><span class="n">timestamp</span><span class="p">(</span><span 
class="s2">&quot;s&quot;</span><span class="p">)</span>
-<span class="go">&lt;Schema&gt; timestamp(&#39;s&#39;, &#39;&#39;)</span>
-<span class="gp">&gt;&gt;&gt; </span><span class="n">na</span><span 
class="o">.</span><span class="n">timestamp</span><span class="p">(</span><span 
class="s2">&quot;s&quot;</span><span class="p">,</span> <span 
class="n">timezone</span><span class="o">=</span><span 
class="s2">&quot;America/Halifax&quot;</span><span class="p">)</span>
-<span class="go">&lt;Schema&gt; timestamp(&#39;s&#39;, 
&#39;America/Halifax&#39;)</span>
+<span class="gp">&gt;&gt;&gt; </span><span class="n">na</span><span 
class="o">.</span><span class="n">timestamp</span><span class="p">(</span><span 
class="s2">"s"</span><span class="p">)</span>
+<span class="go">&lt;Schema&gt; timestamp('s', '')</span>
+<span class="gp">&gt;&gt;&gt; </span><span class="n">na</span><span 
class="o">.</span><span class="n">timestamp</span><span class="p">(</span><span 
class="s2">"s"</span><span class="p">,</span> <span 
class="n">timezone</span><span class="o">=</span><span 
class="s2">"America/Halifax"</span><span class="p">)</span>
+<span class="go">&lt;Schema&gt; timestamp('s', 'America/Halifax')</span>
 </pre></div>
 </div>
 </section>

(arrow-nanoarrow) branch asf-site updated: update documentation for tag main

Reply via email to