This is an automated email from the ASF dual-hosted git repository.
github-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 2f3eb014 update documentation for tag main
2f3eb014 is described below
commit 2f3eb0147e5ea3bd9a5ee6cf015d146133cd1a6c
Author: GitHub Actions <[email protected]>
AuthorDate: Wed Apr 24 00:00:50 2024 +0000
update documentation for tag main
---
main/genindex.html | 13 +-
main/objects.inv | Bin 21271 -> 21279 bytes
main/r/pkgdown.yml | 2 +-
main/reference/python.html | 380 ++++++++++++++++++++++++---------------------
main/searchindex.js | 2 +-
5 files changed, 213 insertions(+), 184 deletions(-)
diff --git a/main/genindex.html b/main/genindex.html
index 5887d53d..ed7474ba 100644
--- a/main/genindex.html
+++ b/main/genindex.html
@@ -358,6 +358,7 @@ document.write(`
| <a href="#L"><strong>L</strong></a>
| <a href="#M"><strong>M</strong></a>
| <a href="#N"><strong>N</strong></a>
+ | <a href="#O"><strong>O</strong></a>
| <a href="#P"><strong>P</strong></a>
| <a href="#R"><strong>R</strong></a>
| <a href="#S"><strong>S</strong></a>
@@ -1329,10 +1330,10 @@ document.write(`
<li><a
href="reference/python.html#nanoarrow.interval_month_day_nano">interval_month_day_nano()
(in module nanoarrow)</a>
</li>
<li><a
href="reference/python.html#nanoarrow.interval_months">interval_months() (in
module nanoarrow)</a>
-</li>
- <li><a
href="reference/python.html#nanoarrow.Array.iter_buffers">iter_buffers() (Array
method)</a>
</li>
<li><a
href="reference/python.html#nanoarrow.Array.iter_children">iter_children()
(Array method)</a>
+</li>
+ <li><a
href="reference/python.html#nanoarrow.Array.iter_chunk_views">iter_chunk_views()
(Array method)</a>
</li>
<li><a
href="reference/python.html#nanoarrow.Array.iter_chunks">iter_chunks() (Array
method)</a>
</li>
@@ -1453,6 +1454,14 @@ document.write(`
</ul></td>
</tr></table>
+<h2 id="O">O</h2>
+<table style="width: 100%" class="indextable genindextable"><tr>
+ <td style="width: 33%; vertical-align: top;"><ul>
+ <li><a href="reference/python.html#nanoarrow.Array.offset">offset (Array
property)</a>
+</li>
+ </ul></td>
+</tr></table>
+
<h2 id="P">P</h2>
<table style="width: 100%" class="indextable genindextable"><tr>
<td style="width: 33%; vertical-align: top;"><ul>
diff --git a/main/objects.inv b/main/objects.inv
index c9290b88..169bafe4 100644
Binary files a/main/objects.inv and b/main/objects.inv differ
diff --git a/main/r/pkgdown.yml b/main/r/pkgdown.yml
index f616cb85..79321ccf 100644
--- a/main/r/pkgdown.yml
+++ b/main/r/pkgdown.yml
@@ -2,5 +2,5 @@ pandoc: 2.9.2.1
pkgdown: 2.0.9
pkgdown_sha: ~
articles: {}
-last_built: 2024-04-23T19:17Z
+last_built: 2024-04-24T00:00Z
diff --git a/main/reference/python.html b/main/reference/python.html
index 6b5dfcbc..ec157fdb 100644
--- a/main/reference/python.html
+++ b/main/reference/python.html
@@ -440,7 +440,7 @@ Defaults to the CPU device.</p>
<dl class="py method">
<dt class="sig sig-object py" id="nanoarrow.Array.buffer">
<span class="sig-name descname"><span class="pre">buffer</span></span><span
class="sig-paren">(</span><em class="sig-param"><span class="n"><span
class="pre">i</span></span><span class="p"><span
class="pre">:</span></span><span class="w"> </span><span class="n"><span
class="pre">int</span></span></em><span class="sig-paren">)</span> <span
class="sig-return"><span class="sig-return-icon">→</span> <span
class="sig-return-typehint"><span class="pre">CBuffer</span></span></span><a
cla [...]
-<dd><p>Access a single buffer of a contiguous array.</p>
+<dd><p>Access a single buffer of a contiguous array</p>
<section id="id3">
<h3>Examples<a class="headerlink" href="#id3" title="Link to this
heading">#</a></h3>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
@@ -454,7 +454,7 @@ Defaults to the CPU device.</p>
<dl class="py property">
<dt class="sig sig-object py" id="nanoarrow.Array.buffers">
-<em class="property"><span class="pre">property</span><span class="w">
</span></em><span class="sig-name descname"><span
class="pre">buffers</span></span><em class="property"><span class="p"><span
class="pre">:</span></span><span class="w"> </span><span
class="pre">Tuple</span><span class="p"><span class="pre">[</span></span><span
class="pre">CBuffer</span><span class="p"><span
class="pre">]</span></span></em><a class="headerlink"
href="#nanoarrow.Array.buffers" title="Link to this defin [...]
+<em class="property"><span class="pre">property</span><span class="w">
</span></em><span class="sig-name descname"><span
class="pre">buffers</span></span><em class="property"><span class="p"><span
class="pre">:</span></span><span class="w"> </span><span
class="pre">Tuple</span><span class="p"><span class="pre">[</span></span><span
class="pre">CBuffer</span><span class="p"><span
class="pre">,</span></span><span class="w"> </span><span class="p"><span
class="pre">...</span></span><span cla [...]
<dd><p>Access buffers of a contiguous array.</p>
<section id="id4">
<h3>Examples<a class="headerlink" href="#id4" title="Link to this
heading">#</a></h3>
@@ -527,7 +527,7 @@ Defaults to the CPU device.</p>
<dl class="py property">
<dt class="sig sig-object py" id="nanoarrow.Array.device">
<em class="property"><span class="pre">property</span><span class="w">
</span></em><span class="sig-name descname"><span
class="pre">device</span></span><em class="property"><span class="p"><span
class="pre">:</span></span><span class="w"> </span><span
class="pre">Device</span></em><a class="headerlink"
href="#nanoarrow.Array.device" title="Link to this definition">#</a></dt>
-<dd><p>Get the device on which the buffers for this array are allocated.</p>
+<dd><p>Get the device on which the buffers for this array are allocated</p>
<section id="id9">
<h3>Examples<a class="headerlink" href="#id9" title="Link to this
heading">#</a></h3>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
@@ -548,30 +548,12 @@ Defaults to the CPU device.</p>
and children arrays).</p>
</dd></dl>
-<dl class="py method">
-<dt class="sig sig-object py" id="nanoarrow.Array.iter_buffers">
-<span class="sig-name descname"><span
class="pre">iter_buffers</span></span><span class="sig-paren">(</span><span
class="sig-paren">)</span> <span class="sig-return"><span
class="sig-return-icon">→</span> <span class="sig-return-typehint"><span
class="pre">Iterable</span><span class="p"><span
class="pre">[</span></span><span class="pre">Tuple</span><span class="p"><span
class="pre">[</span></span><span class="pre">CBuffer</span><span
class="p"><span class="pre">]</span></span><spa [...]
-<dd><p>Iterate over buffers of each chunk in this Array.</p>
-<section id="id10">
-<h3>Examples<a class="headerlink" href="#id10" title="Link to this
heading">#</a></h3>
-<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
-<span class="gp">>>> </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="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">na</span><span
class="o">.</span><span class="n">int32</span><span class="p">())</span>
-<span class="gp">>>> </span><span class="k">for</span> <span
class="n">data</span><span class="p">,</span> <span class="n">validity</span>
<span class="ow">in</span> <span class="n">array</span><span
class="o">.</span><span class="n">iter_buffers</span><span class="p">():</span>
-<span class="gp">... </span> <span class="nb">print</span><span
class="p">(</span><span class="n">data</span><span class="p">)</span>
-<span class="gp">... </span> <span class="nb">print</span><span
class="p">(</span><span class="n">validity</span><span class="p">)</span>
-<span class="go">nanoarrow.c_lib.CBufferView(bool[0 b] )</span>
-<span class="go">nanoarrow.c_lib.CBufferView(int32[12 b] 1 2 3)</span>
-</pre></div>
-</div>
-</section>
-</dd></dl>
-
<dl class="py method">
<dt class="sig sig-object py" id="nanoarrow.Array.iter_children">
<span class="sig-name descname"><span
class="pre">iter_children</span></span><span class="sig-paren">(</span><span
class="sig-paren">)</span> <span class="sig-return"><span
class="sig-return-icon">→</span> <span class="sig-return-typehint"><span
class="pre">Iterable</span></span></span><a class="headerlink"
href="#nanoarrow.Array.iter_children" title="Link to this definition">#</a></dt>
<dd><p>Iterate over children of this Array</p>
-<section id="id11">
-<h3>Examples<a class="headerlink" href="#id11" title="Link to this
heading">#</a></h3>
+<section id="id10">
+<h3>Examples<a class="headerlink" href="#id10" title="Link to this
heading">#</a></h3>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </span><span class="kn">import</span> <span
class="nn">pyarrow</span> <span class="k">as</span> <span class="nn">pa</span>
<span class="gp">>>> </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>
@@ -594,6 +576,28 @@ and children arrays).</p>
</section>
</dd></dl>
+<dl class="py method">
+<dt class="sig sig-object py" id="nanoarrow.Array.iter_chunk_views">
+<span class="sig-name descname"><span
class="pre">iter_chunk_views</span></span><span class="sig-paren">(</span><span
class="sig-paren">)</span> <span class="sig-return"><span
class="sig-return-icon">→</span> <span class="sig-return-typehint"><span
class="pre">Iterable</span><span class="p"><span
class="pre">[</span></span><span class="pre">CArrayView</span><span
class="p"><span class="pre">]</span></span></span></span><a class="headerlink"
href="#nanoarrow.Array.iter_chunk_views" [...]
+<dd><p>Iterate over prepared views of each chunk</p>
+<section id="id11">
+<h3>Examples<a class="headerlink" href="#id11" title="Link to this
heading">#</a></h3>
+<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
+<span class="gp">>>> </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="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">na</span><span
class="o">.</span><span class="n">int32</span><span class="p">())</span>
+<span class="gp">>>> </span><span class="k">for</span> <span
class="n">view</span> <span class="ow">in</span> <span
class="n">array</span><span class="o">.</span><span
class="n">iter_chunk_views</span><span class="p">():</span>
+<span class="gp">... </span> <span class="n">offset</span><span
class="p">,</span> <span class="n">length</span> <span class="o">=</span> <span
class="n">view</span><span class="o">.</span><span class="n">offset</span><span
class="p">,</span> <span class="n">view</span><span class="o">.</span><span
class="n">length</span>
+<span class="gp">... </span> <span class="n">validity</span><span
class="p">,</span> <span class="n">data</span> <span class="o">=</span> <span
class="n">view</span><span class="o">.</span><span class="n">buffers</span>
+<span class="gp">... </span> <span class="nb">print</span><span
class="p">(</span><span class="n">view</span><span class="o">.</span><span
class="n">offset</span><span class="p">,</span> <span
class="n">view</span><span class="o">.</span><span class="n">length</span><span
class="p">)</span>
+<span class="gp">... </span> <span class="nb">print</span><span
class="p">(</span><span class="n">validity</span><span class="p">)</span>
+<span class="gp">... </span> <span class="nb">print</span><span
class="p">(</span><span class="n">data</span><span class="p">)</span>
+<span class="go">0 3</span>
+<span class="go">nanoarrow.c_lib.CBufferView(bool[0 b] )</span>
+<span class="go">nanoarrow.c_lib.CBufferView(int32[12 b] 1 2 3)</span>
+</pre></div>
+</div>
+</section>
+</dd></dl>
+
<dl class="py method">
<dt class="sig sig-object py" id="nanoarrow.Array.iter_chunks">
<span class="sig-name descname"><span
class="pre">iter_chunks</span></span><span class="sig-paren">(</span><span
class="sig-paren">)</span> <span class="sig-return"><span
class="sig-return-icon">→</span> <span class="sig-return-typehint"><span
class="pre">Iterable</span></span></span><a class="headerlink"
href="#nanoarrow.Array.iter_chunks" title="Link to this definition">#</a></dt>
@@ -676,7 +680,7 @@ contiguous in memory.</p>
<dl class="py property">
<dt class="sig sig-object py" id="nanoarrow.Array.n_buffers">
<em class="property"><span class="pre">property</span><span class="w">
</span></em><span class="sig-name descname"><span
class="pre">n_buffers</span></span><em class="property"><span class="p"><span
class="pre">:</span></span><span class="w"> </span><span
class="pre">int</span></em><a class="headerlink"
href="#nanoarrow.Array.n_buffers" title="Link to this definition">#</a></dt>
-<dd><p>Get the number of buffers in each chunk of this Array.</p>
+<dd><p>Get the number of buffers in each chunk of this Array</p>
<section id="id16">
<h3>Examples<a class="headerlink" href="#id16" title="Link to this
heading">#</a></h3>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
@@ -723,6 +727,21 @@ contiguous in memory.</p>
</section>
</dd></dl>
+<dl class="py property">
+<dt class="sig sig-object py" id="nanoarrow.Array.offset">
+<em class="property"><span class="pre">property</span><span class="w">
</span></em><span class="sig-name descname"><span
class="pre">offset</span></span><em class="property"><span class="p"><span
class="pre">:</span></span><span class="w"> </span><span
class="pre">int</span></em><a class="headerlink" href="#nanoarrow.Array.offset"
title="Link to this definition">#</a></dt>
+<dd><p>Access the logical offset of a contiguous array</p>
+<section id="id19">
+<h3>Examples<a class="headerlink" href="#id19" title="Link to this
heading">#</a></h3>
+<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
+<span class="gp">>>> </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</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">na</span><span
class="o">.</span><span class="n">int32</span><span class="p">())</span>
+<span class="gp">>>> </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="mi">1</span><span
class="p">:])</span><span class="o">.</span><span class="n">offset</span>
+<span class="go">1</span>
+</pre></div>
+</div>
+</section>
+</dd></dl>
+
<dl class="py property">
<dt class="sig sig-object py" id="nanoarrow.Array.schema">
<em class="property"><span class="pre">property</span><span class="w">
</span></em><span class="sig-name descname"><span
class="pre">schema</span></span><em class="property"><span class="p"><span
class="pre">:</span></span><span class="w"> </span><a class="reference
internal" href="#nanoarrow.Schema" title="nanoarrow.schema.Schema"><span
class="pre">Schema</span></a></em><a class="headerlink"
href="#nanoarrow.Array.schema" title="Link to this definition">#</a></dt>
@@ -904,8 +923,8 @@ categories can be identified. Type values can be used in
place of
<dt class="sig sig-object py" id="nanoarrow.allocate_c_array">
<span class="sig-name descname"><span
class="pre">allocate_c_array</span></span><span class="sig-paren">(</span><em
class="sig-param"><span class="n"><span class="pre">schema</span></span><span
class="o"><span class="pre">=</span></span><span class="default_value"><span
class="pre">None</span></span></em><span class="sig-paren">)</span> <span
class="sig-return"><span class="sig-return-icon">→</span> <span
class="sig-return-typehint"><span class="pre">CArray</span></span></span><a
[...]
<dd><p>Allocate an uninitialized ArrowArray</p>
-<section id="id19">
-<h2>Examples<a class="headerlink" href="#id19" title="Link to this
heading">#</a></h2>
+<section id="id20">
+<h2>Examples<a class="headerlink" href="#id20" title="Link to this
heading">#</a></h2>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">pyarrow</span> <span
class="k">as</span> <span class="nn">pa</span>
<span class="gp">>>> </span><span class="kn">import</span> <span
class="nn">nanoarrow</span> <span class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </span><span class="n">schema</span> <span
class="o">=</span> <span class="n">na</span><span class="o">.</span><span
class="n">allocate_c_schema</span><span class="p">()</span>
@@ -919,8 +938,8 @@ categories can be identified. Type values can be used in
place of
<dt class="sig sig-object py" id="nanoarrow.allocate_c_array_stream">
<span class="sig-name descname"><span
class="pre">allocate_c_array_stream</span></span><span
class="sig-paren">(</span><span class="sig-paren">)</span> <span
class="sig-return"><span class="sig-return-icon">→</span> <span
class="sig-return-typehint"><span
class="pre">CArrayStream</span></span></span><a class="headerlink"
href="#nanoarrow.allocate_c_array_stream" title="Link to this
definition">#</a></dt>
<dd><p>Allocate an uninitialized ArrowArrayStream wrapper</p>
-<section id="id20">
-<h2>Examples<a class="headerlink" href="#id20" title="Link to this
heading">#</a></h2>
+<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">>>> </span><span
class="kn">import</span> <span class="nn">pyarrow</span> <span
class="k">as</span> <span class="nn">pa</span>
<span class="gp">>>> </span><span class="kn">import</span> <span
class="nn">nanoarrow</span> <span class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </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>
@@ -937,8 +956,8 @@ categories can be identified. Type values can be used in
place of
<dt class="sig sig-object py" id="nanoarrow.allocate_c_schema">
<span class="sig-name descname"><span
class="pre">allocate_c_schema</span></span><span
class="sig-paren">(</span><span class="sig-paren">)</span> <span
class="sig-return"><span class="sig-return-icon">→</span> <span
class="sig-return-typehint"><span class="pre">CSchema</span></span></span><a
class="headerlink" href="#nanoarrow.allocate_c_schema" title="Link to this
definition">#</a></dt>
<dd><p>Allocate an uninitialized ArrowSchema wrapper</p>
-<section id="id21">
-<h2>Examples<a class="headerlink" href="#id21" title="Link to this
heading">#</a></h2>
+<section id="id22">
+<h2>Examples<a class="headerlink" href="#id22" title="Link to this
heading">#</a></h2>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">pyarrow</span> <span
class="k">as</span> <span class="nn">pa</span>
<span class="gp">>>> </span><span class="kn">import</span> <span
class="nn">nanoarrow</span> <span class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </span><span class="n">schema</span> <span
class="o">=</span> <span class="n">na</span><span class="o">.</span><span
class="n">allocate_c_schema</span><span class="p">()</span>
@@ -956,10 +975,10 @@ categories can be identified. Type values can be used in
place of
representation whose scope maps to that of a fully-consumed
ArrowArrayStream in the Arrow C Data interface. Note that an
<a class="reference internal" href="#nanoarrow.Array"
title="nanoarrow.Array"><code class="xref py py-class docutils literal
notranslate"><span class="pre">Array</span></code></a> is not necessarily
contiguous in memory (i.e.,
-it may consist of zero or more <a href="#id22"><span class="problematic"
id="id23">``</span></a>ArrowArray``s).
+it may consist of zero or more <a href="#id23"><span class="problematic"
id="id24">``</span></a>ArrowArray``s).
See <a class="reference internal" href="#nanoarrow.Array"
title="nanoarrow.Array"><code class="xref py py-class docutils literal
notranslate"><span class="pre">Array</span></code></a> for class details.</p>
-<section id="id24">
-<h2>Parameters<a class="headerlink" href="#id24" title="Link to this
heading">#</a></h2>
+<section id="id25">
+<h2>Parameters<a class="headerlink" href="#id25" title="Link to this
heading">#</a></h2>
<dl class="simple">
<dt>obj<span class="classifier">array or array
stream-like</span></dt><dd><p>An array-like or array stream-like object. This
can be any object
supporting the Arrow PyCapsule interface, the Python buffer
@@ -974,8 +993,8 @@ Defaults to the CPU device.</p>
</dd>
</dl>
</section>
-<section id="id25">
-<h2>Examples<a class="headerlink" href="#id25" title="Link to this
heading">#</a></h2>
+<section id="id26">
+<h2>Examples<a class="headerlink" href="#id26" title="Link to this
heading">#</a></h2>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </span><span class="n">na</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">na</span><span class="o">.</span><span class="n">int32</span><span
class="p">())</span>
<span class="go">nanoarrow.Array<int32>[3]</span>
@@ -991,15 +1010,15 @@ Defaults to the CPU device.</p>
<dt class="sig sig-object py" id="nanoarrow.binary">
<span class="sig-name descname"><span class="pre">binary</span></span><span
class="sig-paren">(</span><em class="sig-param"><span class="n"><span
class="pre">nullable</span></span><span class="p"><span
class="pre">:</span></span><span class="w"> </span><span class="n"><span
class="pre">bool</span></span><span class="w"> </span><span class="o"><span
class="pre">=</span></span><span class="w"> </span><span
class="default_value"><span class="pre">True</span></span></em><span
class="sig-pare [...]
<dd><p>Create an instance of a variable or fixed-width binary type.</p>
-<section id="id26">
-<h2>Parameters<a class="headerlink" href="#id26" title="Link to this
heading">#</a></h2>
+<section id="id27">
+<h2>Parameters<a class="headerlink" href="#id27" title="Link to this
heading">#</a></h2>
<dl class="simple">
<dt>nullable<span class="classifier">bool, optional</span></dt><dd><p>Use
<code class="docutils literal notranslate"><span
class="pre">False</span></code> to mark this field as non-nullable.</p>
</dd>
</dl>
</section>
-<section id="id27">
-<h2>Examples<a class="headerlink" href="#id27" title="Link to this
heading">#</a></h2>
+<section id="id28">
+<h2>Examples<a class="headerlink" href="#id28" title="Link to this
heading">#</a></h2>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </span><span class="n">na</span><span
class="o">.</span><span class="n">binary</span><span class="p">()</span>
<span class="go">Schema(BINARY)</span>
@@ -1012,15 +1031,15 @@ Defaults to the CPU device.</p>
<dt class="sig sig-object py" id="nanoarrow.bool">
<span class="sig-name descname"><span class="pre">bool</span></span><span
class="sig-paren">(</span><em class="sig-param"><span class="n"><span
class="pre">nullable</span></span><span class="p"><span
class="pre">:</span></span><span class="w"> </span><span class="n"><span
class="pre">bool</span></span><span class="w"> </span><span class="o"><span
class="pre">=</span></span><span class="w"> </span><span
class="default_value"><span class="pre">True</span></span></em><span
class="sig-paren" [...]
<dd><p>Create an instance of a boolean type.</p>
-<section id="id28">
-<h2>Parameters<a class="headerlink" href="#id28" title="Link to this
heading">#</a></h2>
+<section id="id29">
+<h2>Parameters<a class="headerlink" href="#id29" title="Link to this
heading">#</a></h2>
<dl class="simple">
<dt>nullable<span class="classifier">bool, optional</span></dt><dd><p>Use
<code class="docutils literal notranslate"><span
class="pre">False</span></code> to mark this field as non-nullable.</p>
</dd>
</dl>
</section>
-<section id="id29">
-<h2>Examples<a class="headerlink" href="#id29" title="Link to this
heading">#</a></h2>
+<section id="id30">
+<h2>Examples<a class="headerlink" href="#id30" title="Link to this
heading">#</a></h2>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </span><span class="n">na</span><span
class="o">.</span><span class="n">bool</span><span class="p">()</span>
<span class="go">Schema(BOOL)</span>
@@ -1045,8 +1064,8 @@ the content into a more easily inspectable object.</p>
<p>Note that the <code class="xref py py-class docutils literal
notranslate"><span class="pre">CArray</span></code> objects returned by <code
class="docutils literal notranslate"><span class="pre">.child()</span></code>
hold strong
references to the original <code class="docutils literal notranslate"><span
class="pre">ArrowArray</span></code> to avoid copies while inspecting an
imported structure.</p>
-<section id="id30">
-<h2>Parameters<a class="headerlink" href="#id30" title="Link to this
heading">#</a></h2>
+<section id="id31">
+<h2>Parameters<a class="headerlink" href="#id31" title="Link to this
heading">#</a></h2>
<dl class="simple">
<dt>obj<span class="classifier">array-like</span></dt><dd><p>An object
supporting the Arrow PyCapsule interface, the Python buffer
protocol, or an iterable of Python objects.</p>
@@ -1058,8 +1077,8 @@ different than <code class="docutils literal
notranslate"><span class="pre">sche
</dd>
</dl>
</section>
-<section id="id31">
-<h2>Examples<a class="headerlink" href="#id31" title="Link to this
heading">#</a></h2>
+<section id="id32">
+<h2>Examples<a class="headerlink" href="#id32" title="Link to this
heading">#</a></h2>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </span><span class="c1"># Create from
iterable</span>
<span class="gp">>>> </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="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">na</span><span
class="o">.</span><span class="n">int32</span><span class="p">())</span>
@@ -1088,8 +1107,8 @@ to be assembled; however, requires some knowledge of the
Arrow Columnar
specification. This function will do its best to validate the sizes and
content of buffers according to <code class="docutils literal
notranslate"><span class="pre">validation_level</span></code>; however, not all
types of arrays can currently be validated when constructed in this way.</p>
-<section id="id32">
-<h2>Parameters<a class="headerlink" href="#id32" title="Link to this
heading">#</a></h2>
+<section id="id33">
+<h2>Parameters<a class="headerlink" href="#id33" title="Link to this
heading">#</a></h2>
<dl class="simple">
<dt>schema<span class="classifier">schema-like</span></dt><dd><p>The data type
of the desired array as sanitized by <a class="reference internal"
href="#nanoarrow.c_schema" title="nanoarrow.c_schema"><code class="xref py
py-func docutils literal notranslate"><span
class="pre">c_schema()</span></code></a>.</p>
</dd>
@@ -1122,8 +1141,8 @@ output array.</p>
</dd>
</dl>
</section>
-<section id="id33">
-<h2>Examples<a class="headerlink" href="#id33" title="Link to this
heading">#</a></h2>
+<section id="id34">
+<h2>Examples<a class="headerlink" href="#id34" title="Link to this
heading">#</a></h2>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </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">"1234 [...]
<span class="gp">>>> </span><span class="n">na</span><span
class="o">.</span><span class="n">c_array_view</span><span
class="p">(</span><span class="n">c_array</span><span class="p">)</span>
@@ -1149,8 +1168,8 @@ output array.</p>
<p>This class provides a user-facing interface to access the fields of
an ArrowArrayStream as defined in the Arrow C Stream interface.
These objects are usually created using
<cite>nanoarrow.c_array_stream()</cite>.</p>
-<section id="id34">
-<h2>Examples<a class="headerlink" href="#id34" title="Link to this
heading">#</a></h2>
+<section id="id35">
+<h2>Examples<a class="headerlink" href="#id35" title="Link to this
heading">#</a></h2>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">pyarrow</span> <span
class="k">as</span> <span class="nn">pa</span>
<span class="gp">>>> </span><span class="kn">import</span> <span
class="nn">nanoarrow</span> <span class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </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>
@@ -1193,8 +1212,8 @@ data types. The buffer data is usually propagated from an
ArrowArray
but can also be propagated from other types of objects (e.g., serialized
IPC). The offset and length of this view are independent of its parent
(i.e., this object can also represent a slice of its parent).</p>
-<section id="id35">
-<h2>Examples<a class="headerlink" href="#id35" title="Link to this
heading">#</a></h2>
+<section id="id36">
+<h2>Examples<a class="headerlink" href="#id36" title="Link to this
heading">#</a></h2>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">pyarrow</span> <span
class="k">as</span> <span class="nn">pa</span>
<span class="gp">>>> </span><span class="kn">import</span> <span
class="nn">numpy</span> <span class="k">as</span> <span class="nn">np</span>
<span class="gp">>>> </span><span class="kn">import</span> <span
class="nn">nanoarrow</span> <span class="k">as</span> <span class="nn">na</span>
@@ -1226,8 +1245,8 @@ a Python iterable. The <code class="docutils literal
notranslate"><span class="p
values from obj into binary form.</p>
<p>Unlike with <a class="reference internal" href="#nanoarrow.c_array"
title="nanoarrow.c_array"><code class="xref py py-func docutils literal
notranslate"><span class="pre">c_array()</span></code></a>, <code
class="docutils literal notranslate"><span class="pre">schema</span></code> is
explicitly
honoured (or an error will be raised).</p>
-<section id="id36">
-<h2>Parameters<a class="headerlink" href="#id36" title="Link to this
heading">#</a></h2>
+<section id="id37">
+<h2>Parameters<a class="headerlink" href="#id37" title="Link to this
heading">#</a></h2>
<dl class="simple">
<dt>obj<span class="classifier">buffer-like or iterable</span></dt><dd><p>A
Python object that supports the Python buffer protocol. This includes
bytes, memoryview, bytearray, bulit-in types as well as numpy arrays.</p>
@@ -1239,8 +1258,8 @@ decimal types, binary, string, fixed-size binary).</p>
</dd>
</dl>
</section>
-<section id="id37">
-<h2>Examples<a class="headerlink" href="#id37" title="Link to this
heading">#</a></h2>
+<section id="id38">
+<h2>Examples<a class="headerlink" href="#id38" title="Link to this
heading">#</a></h2>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </span><span class="n">na</span><span
class="o">.</span><span class="n">c_buffer</span><span class="p">(</span><span
class="sa">b</span><span class="s2">"1234"</span><span
class="p">)</span>
<span class="go">nanoarrow.c_lib.CBuffer(uint8[4 b] 49 50 51 52)</span>
@@ -1265,8 +1284,8 @@ and deserialize the content into a more easily
inspectable object.</p>
<p>Note that the <code class="xref py py-class docutils literal
notranslate"><span class="pre">CSchema</span></code> objects returned by <code
class="docutils literal notranslate"><span class="pre">.child()</span></code>
hold strong
references to the original <cite>ArrowSchema</cite> to avoid copies while
inspecting an
imported structure.</p>
-<section id="id38">
-<h2>Examples<a class="headerlink" href="#id38" title="Link to this
heading">#</a></h2>
+<section id="id39">
+<h2>Examples<a class="headerlink" href="#id39" title="Link to this
heading">#</a></h2>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">pyarrow</span> <span
class="k">as</span> <span class="nn">pa</span>
<span class="gp">>>> </span><span class="kn">import</span> <span
class="nn">nanoarrow</span> <span class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </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">int32</span><span class="p">())</span>
@@ -1288,8 +1307,8 @@ imported structure.</p>
<p>The <code class="docutils literal notranslate"><span
class="pre">ArrowSchemaView</span></code> is a nanoarrow C library structure
that facilitates
access to the deserialized content of an <code class="docutils literal
notranslate"><span class="pre">ArrowSchema</span></code> (e.g., parameter
values for
parameterized types). This wrapper extends that facility to Python.</p>
-<section id="id39">
-<h2>Examples<a class="headerlink" href="#id39" title="Link to this
heading">#</a></h2>
+<section id="id40">
+<h2>Examples<a class="headerlink" href="#id40" title="Link to this
heading">#</a></h2>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">pyarrow</span> <span
class="k">as</span> <span class="nn">pa</span>
<span class="gp">>>> </span><span class="kn">import</span> <span
class="nn">nanoarrow</span> <span class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </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>
@@ -1317,15 +1336,15 @@ parameterized types). This wrapper extends that
facility to Python.</p>
<dt class="sig sig-object py" id="nanoarrow.date32">
<span class="sig-name descname"><span class="pre">date32</span></span><span
class="sig-paren">(</span><em class="sig-param"><span class="n"><span
class="pre">nullable</span></span><span class="p"><span
class="pre">:</span></span><span class="w"> </span><span class="n"><span
class="pre">bool</span></span><span class="w"> </span><span class="o"><span
class="pre">=</span></span><span class="w"> </span><span
class="default_value"><span class="pre">True</span></span></em><span
class="sig-pare [...]
<dd><p>Create an instance of a 32-bit date type (days since 1970-01-01).</p>
-<section id="id40">
-<h2>Parameters<a class="headerlink" href="#id40" title="Link to this
heading">#</a></h2>
+<section id="id41">
+<h2>Parameters<a class="headerlink" href="#id41" title="Link to this
heading">#</a></h2>
<dl class="simple">
<dt>nullable<span class="classifier">bool, optional</span></dt><dd><p>Use
<code class="docutils literal notranslate"><span
class="pre">False</span></code> to mark this field as non-nullable.</p>
</dd>
</dl>
</section>
-<section id="id41">
-<h2>Examples<a class="headerlink" href="#id41" title="Link to this
heading">#</a></h2>
+<section id="id42">
+<h2>Examples<a class="headerlink" href="#id42" title="Link to this
heading">#</a></h2>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </span><span class="n">na</span><span
class="o">.</span><span class="n">date32</span><span class="p">()</span>
<span class="go">Schema(DATE32)</span>
@@ -1338,15 +1357,15 @@ parameterized types). This wrapper extends that
facility to Python.</p>
<dt class="sig sig-object py" id="nanoarrow.date64">
<span class="sig-name descname"><span class="pre">date64</span></span><span
class="sig-paren">(</span><em class="sig-param"><span class="n"><span
class="pre">nullable</span></span><span class="p"><span
class="pre">:</span></span><span class="w"> </span><span class="n"><span
class="pre">bool</span></span><span class="w"> </span><span class="o"><span
class="pre">=</span></span><span class="w"> </span><span
class="default_value"><span class="pre">True</span></span></em><span
class="sig-pare [...]
<dd><p>Create an instance of a 64-bit date type (milliseconds since
1970-01-01).</p>
-<section id="id42">
-<h2>Parameters<a class="headerlink" href="#id42" title="Link to this
heading">#</a></h2>
+<section id="id43">
+<h2>Parameters<a class="headerlink" href="#id43" title="Link to this
heading">#</a></h2>
<dl class="simple">
<dt>nullable<span class="classifier">bool, optional</span></dt><dd><p>Use
<code class="docutils literal notranslate"><span
class="pre">False</span></code> to mark this field as non-nullable.</p>
</dd>
</dl>
</section>
-<section id="id43">
-<h2>Examples<a class="headerlink" href="#id43" title="Link to this
heading">#</a></h2>
+<section id="id44">
+<h2>Examples<a class="headerlink" href="#id44" title="Link to this
heading">#</a></h2>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </span><span class="n">na</span><span
class="o">.</span><span class="n">date64</span><span class="p">()</span>
<span class="go">Schema(DATE64)</span>
@@ -1359,8 +1378,8 @@ parameterized types). This wrapper extends that facility
to Python.</p>
<dt class="sig sig-object py" id="nanoarrow.decimal128">
<span class="sig-name descname"><span
class="pre">decimal128</span></span><span class="sig-paren">(</span><em
class="sig-param"><span class="n"><span
class="pre">precision</span></span><span class="p"><span
class="pre">:</span></span><span class="w"> </span><span class="n"><span
class="pre">int</span></span></em>, <em class="sig-param"><span class="n"><span
class="pre">scale</span></span><span class="p"><span
class="pre">:</span></span><span class="w"> </span><span class="n"><span class=
[...]
<dd><p>Create an instance of a 128-bit decimal type.</p>
-<section id="id44">
-<h2>Parameters<a class="headerlink" href="#id44" title="Link to this
heading">#</a></h2>
+<section id="id45">
+<h2>Parameters<a class="headerlink" href="#id45" title="Link to this
heading">#</a></h2>
<dl class="simple">
<dt>precision<span class="classifier">int</span></dt><dd><p>The number of
significant digits representable by this type. Must be
between 1 and 38.</p>
@@ -1371,8 +1390,8 @@ between 1 and 38.</p>
</dd>
</dl>
</section>
-<section id="id45">
-<h2>Examples<a class="headerlink" href="#id45" title="Link to this
heading">#</a></h2>
+<section id="id46">
+<h2>Examples<a class="headerlink" href="#id46" title="Link to this
heading">#</a></h2>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </span><span class="n">na</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="go">Schema(DECIMAL128, precision=10, scale=3)</span>
@@ -1385,8 +1404,8 @@ between 1 and 38.</p>
<dt class="sig sig-object py" id="nanoarrow.decimal256">
<span class="sig-name descname"><span
class="pre">decimal256</span></span><span class="sig-paren">(</span><em
class="sig-param"><span class="n"><span
class="pre">precision</span></span><span class="p"><span
class="pre">:</span></span><span class="w"> </span><span class="n"><span
class="pre">int</span></span></em>, <em class="sig-param"><span class="n"><span
class="pre">scale</span></span><span class="p"><span
class="pre">:</span></span><span class="w"> </span><span class="n"><span class=
[...]
<dd><p>Create an instance of a 256-bit decimal type.</p>
-<section id="id46">
-<h2>Parameters<a class="headerlink" href="#id46" title="Link to this
heading">#</a></h2>
+<section id="id47">
+<h2>Parameters<a class="headerlink" href="#id47" title="Link to this
heading">#</a></h2>
<dl class="simple">
<dt>precision<span class="classifier">int</span></dt><dd><p>The number of
significant digits representable by this type. Must be
between 1 and 76.</p>
@@ -1397,8 +1416,8 @@ between 1 and 76.</p>
</dd>
</dl>
</section>
-<section id="id47">
-<h2>Examples<a class="headerlink" href="#id47" title="Link to this
heading">#</a></h2>
+<section id="id48">
+<h2>Examples<a class="headerlink" href="#id48" title="Link to this
heading">#</a></h2>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </span><span class="n">na</span><span
class="o">.</span><span class="n">decimal256</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="go">Schema(DECIMAL256, precision=10, scale=3)</span>
@@ -1411,8 +1430,8 @@ between 1 and 76.</p>
<dt class="sig sig-object py" id="nanoarrow.duration">
<span class="sig-name descname"><span class="pre">duration</span></span><span
class="sig-paren">(</span><em class="sig-param"><span class="n"><span
class="pre">unit</span></span></em>, <em class="sig-param"><span
class="n"><span class="pre">nullable</span></span><span class="p"><span
class="pre">:</span></span><span class="w"> </span><span class="n"><span
class="pre">bool</span></span><span class="w"> </span><span class="o"><span
class="pre">=</span></span><span class="w"> </span><span c [...]
<dd><p>Create an instance of a duration type.</p>
-<section id="id48">
-<h2>Parameters<a class="headerlink" href="#id48" title="Link to this
heading">#</a></h2>
+<section id="id49">
+<h2>Parameters<a class="headerlink" href="#id49" title="Link to this
heading">#</a></h2>
<dl>
<dt>unit<span class="classifier">str or <a class="reference internal"
href="#nanoarrow.TimeUnit" title="nanoarrow.TimeUnit"><code class="xref py
py-class docutils literal notranslate"><span
class="pre">TimeUnit</span></code></a></span></dt><dd><p>The unit of values
stored by this type.</p>
</dd>
@@ -1420,8 +1439,8 @@ between 1 and 76.</p>
</dd>
</dl>
</section>
-<section id="id49">
-<h2>Examples<a class="headerlink" href="#id49" title="Link to this
heading">#</a></h2>
+<section id="id50">
+<h2>Examples<a class="headerlink" href="#id50" title="Link to this
heading">#</a></h2>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </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">Schema(DURATION, unit=SECOND)</span>
@@ -1434,8 +1453,8 @@ between 1 and 76.</p>
<dt class="sig sig-object py" id="nanoarrow.fixed_size_binary">
<span class="sig-name descname"><span
class="pre">fixed_size_binary</span></span><span class="sig-paren">(</span><em
class="sig-param"><span class="n"><span
class="pre">byte_width</span></span><span class="p"><span
class="pre">:</span></span><span class="w"> </span><span class="n"><span
class="pre">int</span></span></em>, <em class="sig-param"><span class="n"><span
class="pre">nullable</span></span><span class="p"><span
class="pre">:</span></span><span class="w"> </span><span class="n">< [...]
<dd><p>Create an instance of a variable or fixed-width binary type.</p>
-<section id="id50">
-<h2>Parameters<a class="headerlink" href="#id50" title="Link to this
heading">#</a></h2>
+<section id="id51">
+<h2>Parameters<a class="headerlink" href="#id51" title="Link to this
heading">#</a></h2>
<dl class="simple">
<dt>byte_width<span class="classifier">int</span></dt><dd><p>The width of each
element in bytes.</p>
</dd>
@@ -1443,8 +1462,8 @@ between 1 and 76.</p>
</dd>
</dl>
</section>
-<section id="id51">
-<h2>Examples<a class="headerlink" href="#id51" title="Link to this
heading">#</a></h2>
+<section id="id52">
+<h2>Examples<a class="headerlink" href="#id52" title="Link to this
heading">#</a></h2>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </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="go">Schema(FIXED_SIZE_BINARY, byte_width=123)</span>
@@ -1457,15 +1476,15 @@ between 1 and 76.</p>
<dt class="sig sig-object py" id="nanoarrow.float16">
<span class="sig-name descname"><span class="pre">float16</span></span><span
class="sig-paren">(</span><em class="sig-param"><span class="n"><span
class="pre">nullable</span></span><span class="p"><span
class="pre">:</span></span><span class="w"> </span><span class="n"><span
class="pre">bool</span></span><span class="w"> </span><span class="o"><span
class="pre">=</span></span><span class="w"> </span><span
class="default_value"><span class="pre">True</span></span></em><span
class="sig-par [...]
<dd><p>Create an instance of a 16-bit floating-point type.</p>
-<section id="id52">
-<h2>Parameters<a class="headerlink" href="#id52" title="Link to this
heading">#</a></h2>
+<section id="id53">
+<h2>Parameters<a class="headerlink" href="#id53" title="Link to this
heading">#</a></h2>
<dl class="simple">
<dt>nullable<span class="classifier">bool, optional</span></dt><dd><p>Use
<code class="docutils literal notranslate"><span
class="pre">False</span></code> to mark this field as non-nullable.</p>
</dd>
</dl>
</section>
-<section id="id53">
-<h2>Examples<a class="headerlink" href="#id53" title="Link to this
heading">#</a></h2>
+<section id="id54">
+<h2>Examples<a class="headerlink" href="#id54" title="Link to this
heading">#</a></h2>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </span><span class="n">na</span><span
class="o">.</span><span class="n">float16</span><span class="p">()</span>
<span class="go">Schema(HALF_FLOAT)</span>
@@ -1478,15 +1497,15 @@ between 1 and 76.</p>
<dt class="sig sig-object py" id="nanoarrow.float32">
<span class="sig-name descname"><span class="pre">float32</span></span><span
class="sig-paren">(</span><em class="sig-param"><span class="n"><span
class="pre">nullable</span></span><span class="p"><span
class="pre">:</span></span><span class="w"> </span><span class="n"><span
class="pre">bool</span></span><span class="w"> </span><span class="o"><span
class="pre">=</span></span><span class="w"> </span><span
class="default_value"><span class="pre">True</span></span></em><span
class="sig-par [...]
<dd><p>Create an instance of a 32-bit floating-point type.</p>
-<section id="id54">
-<h2>Parameters<a class="headerlink" href="#id54" title="Link to this
heading">#</a></h2>
+<section id="id55">
+<h2>Parameters<a class="headerlink" href="#id55" title="Link to this
heading">#</a></h2>
<dl class="simple">
<dt>nullable<span class="classifier">bool, optional</span></dt><dd><p>Use
<code class="docutils literal notranslate"><span
class="pre">False</span></code> to mark this field as non-nullable.</p>
</dd>
</dl>
</section>
-<section id="id55">
-<h2>Examples<a class="headerlink" href="#id55" title="Link to this
heading">#</a></h2>
+<section id="id56">
+<h2>Examples<a class="headerlink" href="#id56" title="Link to this
heading">#</a></h2>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </span><span class="n">na</span><span
class="o">.</span><span class="n">float32</span><span class="p">()</span>
<span class="go">Schema(FLOAT)</span>
@@ -1499,15 +1518,15 @@ between 1 and 76.</p>
<dt class="sig sig-object py" id="nanoarrow.float64">
<span class="sig-name descname"><span class="pre">float64</span></span><span
class="sig-paren">(</span><em class="sig-param"><span class="n"><span
class="pre">nullable</span></span><span class="p"><span
class="pre">:</span></span><span class="w"> </span><span class="n"><span
class="pre">bool</span></span><span class="w"> </span><span class="o"><span
class="pre">=</span></span><span class="w"> </span><span
class="default_value"><span class="pre">True</span></span></em><span
class="sig-par [...]
<dd><p>Create an instance of a 64-bit floating-point type.</p>
-<section id="id56">
-<h2>Parameters<a class="headerlink" href="#id56" title="Link to this
heading">#</a></h2>
+<section id="id57">
+<h2>Parameters<a class="headerlink" href="#id57" title="Link to this
heading">#</a></h2>
<dl class="simple">
<dt>nullable<span class="classifier">bool, optional</span></dt><dd><p>Use
<code class="docutils literal notranslate"><span
class="pre">False</span></code> to mark this field as non-nullable.</p>
</dd>
</dl>
</section>
-<section id="id57">
-<h2>Examples<a class="headerlink" href="#id57" title="Link to this
heading">#</a></h2>
+<section id="id58">
+<h2>Examples<a class="headerlink" href="#id58" title="Link to this
heading">#</a></h2>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </span><span class="n">na</span><span
class="o">.</span><span class="n">float64</span><span class="p">()</span>
<span class="go">Schema(DOUBLE)</span>
@@ -1520,15 +1539,15 @@ between 1 and 76.</p>
<dt class="sig sig-object py" id="nanoarrow.int16">
<span class="sig-name descname"><span class="pre">int16</span></span><span
class="sig-paren">(</span><em class="sig-param"><span class="n"><span
class="pre">nullable</span></span><span class="p"><span
class="pre">:</span></span><span class="w"> </span><span class="n"><span
class="pre">bool</span></span><span class="w"> </span><span class="o"><span
class="pre">=</span></span><span class="w"> </span><span
class="default_value"><span class="pre">True</span></span></em><span
class="sig-paren [...]
<dd><p>Create an instance of a signed 16-bit integer type.</p>
-<section id="id58">
-<h2>Parameters<a class="headerlink" href="#id58" title="Link to this
heading">#</a></h2>
+<section id="id59">
+<h2>Parameters<a class="headerlink" href="#id59" title="Link to this
heading">#</a></h2>
<dl class="simple">
<dt>nullable<span class="classifier">bool, optional</span></dt><dd><p>Use
<code class="docutils literal notranslate"><span
class="pre">False</span></code> to mark this field as non-nullable.</p>
</dd>
</dl>
</section>
-<section id="id59">
-<h2>Examples<a class="headerlink" href="#id59" title="Link to this
heading">#</a></h2>
+<section id="id60">
+<h2>Examples<a class="headerlink" href="#id60" title="Link to this
heading">#</a></h2>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </span><span class="n">na</span><span
class="o">.</span><span class="n">int16</span><span class="p">()</span>
<span class="go">Schema(INT16)</span>
@@ -1541,15 +1560,15 @@ between 1 and 76.</p>
<dt class="sig sig-object py" id="nanoarrow.int32">
<span class="sig-name descname"><span class="pre">int32</span></span><span
class="sig-paren">(</span><em class="sig-param"><span class="n"><span
class="pre">nullable</span></span><span class="p"><span
class="pre">:</span></span><span class="w"> </span><span class="n"><span
class="pre">bool</span></span><span class="w"> </span><span class="o"><span
class="pre">=</span></span><span class="w"> </span><span
class="default_value"><span class="pre">True</span></span></em><span
class="sig-paren [...]
<dd><p>Create an instance of a signed 32-bit integer type.</p>
-<section id="id60">
-<h2>Parameters<a class="headerlink" href="#id60" title="Link to this
heading">#</a></h2>
+<section id="id61">
+<h2>Parameters<a class="headerlink" href="#id61" title="Link to this
heading">#</a></h2>
<dl class="simple">
<dt>nullable<span class="classifier">bool, optional</span></dt><dd><p>Use
<code class="docutils literal notranslate"><span
class="pre">False</span></code> to mark this field as non-nullable.</p>
</dd>
</dl>
</section>
-<section id="id61">
-<h2>Examples<a class="headerlink" href="#id61" title="Link to this
heading">#</a></h2>
+<section id="id62">
+<h2>Examples<a class="headerlink" href="#id62" title="Link to this
heading">#</a></h2>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </span><span class="n">na</span><span
class="o">.</span><span class="n">int32</span><span class="p">()</span>
<span class="go">Schema(INT32)</span>
@@ -1562,15 +1581,15 @@ between 1 and 76.</p>
<dt class="sig sig-object py" id="nanoarrow.int64">
<span class="sig-name descname"><span class="pre">int64</span></span><span
class="sig-paren">(</span><em class="sig-param"><span class="n"><span
class="pre">nullable</span></span><span class="p"><span
class="pre">:</span></span><span class="w"> </span><span class="n"><span
class="pre">bool</span></span><span class="w"> </span><span class="o"><span
class="pre">=</span></span><span class="w"> </span><span
class="default_value"><span class="pre">True</span></span></em><span
class="sig-paren [...]
<dd><p>Create an instance of a signed 32-bit integer type.</p>
-<section id="id62">
-<h2>Parameters<a class="headerlink" href="#id62" title="Link to this
heading">#</a></h2>
+<section id="id63">
+<h2>Parameters<a class="headerlink" href="#id63" title="Link to this
heading">#</a></h2>
<dl class="simple">
<dt>nullable<span class="classifier">bool, optional</span></dt><dd><p>Use
<code class="docutils literal notranslate"><span
class="pre">False</span></code> to mark this field as non-nullable.</p>
</dd>
</dl>
</section>
-<section id="id63">
-<h2>Examples<a class="headerlink" href="#id63" title="Link to this
heading">#</a></h2>
+<section id="id64">
+<h2>Examples<a class="headerlink" href="#id64" title="Link to this
heading">#</a></h2>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </span><span class="n">na</span><span
class="o">.</span><span class="n">int64</span><span class="p">()</span>
<span class="go">Schema(INT64)</span>
@@ -1583,15 +1602,15 @@ between 1 and 76.</p>
<dt class="sig sig-object py" id="nanoarrow.int8">
<span class="sig-name descname"><span class="pre">int8</span></span><span
class="sig-paren">(</span><em class="sig-param"><span class="n"><span
class="pre">nullable</span></span><span class="p"><span
class="pre">:</span></span><span class="w"> </span><span class="n"><span
class="pre">bool</span></span><span class="w"> </span><span class="o"><span
class="pre">=</span></span><span class="w"> </span><span
class="default_value"><span class="pre">True</span></span></em><span
class="sig-paren" [...]
<dd><p>Create an instance of a signed 8-bit integer type.</p>
-<section id="id64">
-<h2>Parameters<a class="headerlink" href="#id64" title="Link to this
heading">#</a></h2>
+<section id="id65">
+<h2>Parameters<a class="headerlink" href="#id65" title="Link to this
heading">#</a></h2>
<dl class="simple">
<dt>nullable<span class="classifier">bool, optional</span></dt><dd><p>Use
<code class="docutils literal notranslate"><span
class="pre">False</span></code> to mark this field as non-nullable.</p>
</dd>
</dl>
</section>
-<section id="id65">
-<h2>Examples<a class="headerlink" href="#id65" title="Link to this
heading">#</a></h2>
+<section id="id66">
+<h2>Examples<a class="headerlink" href="#id66" title="Link to this
heading">#</a></h2>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </span><span class="n">na</span><span
class="o">.</span><span class="n">int8</span><span class="p">()</span>
<span class="go">Schema(INT8)</span>
@@ -1604,15 +1623,15 @@ between 1 and 76.</p>
<dt class="sig sig-object py" id="nanoarrow.interval_day_time">
<span class="sig-name descname"><span
class="pre">interval_day_time</span></span><span class="sig-paren">(</span><em
class="sig-param"><span class="n"><span class="pre">nullable</span></span><span
class="p"><span class="pre">:</span></span><span class="w"> </span><span
class="n"><span class="pre">bool</span></span><span class="w"> </span><span
class="o"><span class="pre">=</span></span><span class="w"> </span><span
class="default_value"><span class="pre">True</span></span></em><span clas [...]
<dd><p>Create an instance of an interval type measured as a day/time pair.</p>
-<section id="id66">
-<h2>Parameters<a class="headerlink" href="#id66" title="Link to this
heading">#</a></h2>
+<section id="id67">
+<h2>Parameters<a class="headerlink" href="#id67" title="Link to this
heading">#</a></h2>
<dl class="simple">
<dt>nullable<span class="classifier">bool, optional</span></dt><dd><p>Use
<code class="docutils literal notranslate"><span
class="pre">False</span></code> to mark this field as non-nullable.</p>
</dd>
</dl>
</section>
-<section id="id67">
-<h2>Examples<a class="headerlink" href="#id67" title="Link to this
heading">#</a></h2>
+<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">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </span><span class="n">na</span><span
class="o">.</span><span class="n">interval_day_time</span><span
class="p">()</span>
<span class="go">Schema(INTERVAL_DAY_TIME)</span>
@@ -1626,15 +1645,15 @@ between 1 and 76.</p>
<span class="sig-name descname"><span
class="pre">interval_month_day_nano</span></span><span
class="sig-paren">(</span><em class="sig-param"><span class="n"><span
class="pre">nullable</span></span><span class="p"><span
class="pre">:</span></span><span class="w"> </span><span class="n"><span
class="pre">bool</span></span><span class="w"> </span><span class="o"><span
class="pre">=</span></span><span class="w"> </span><span
class="default_value"><span class="pre">True</span></span></em><spa [...]
<dd><p>Create an instance of an interval type measured as a
month/day/nanosecond
tuple.</p>
-<section id="id68">
-<h2>Parameters<a class="headerlink" href="#id68" title="Link to this
heading">#</a></h2>
+<section id="id69">
+<h2>Parameters<a class="headerlink" href="#id69" title="Link to this
heading">#</a></h2>
<dl class="simple">
<dt>nullable<span class="classifier">bool, optional</span></dt><dd><p>Use
<code class="docutils literal notranslate"><span
class="pre">False</span></code> to mark this field as non-nullable.</p>
</dd>
</dl>
</section>
-<section id="id69">
-<h2>Examples<a class="headerlink" href="#id69" title="Link to this
heading">#</a></h2>
+<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">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </span><span class="n">na</span><span
class="o">.</span><span class="n">interval_month_day_nano</span><span
class="p">()</span>
<span class="go">Schema(INTERVAL_MONTH_DAY_NANO)</span>
@@ -1647,15 +1666,15 @@ tuple.</p>
<dt class="sig sig-object py" id="nanoarrow.interval_months">
<span class="sig-name descname"><span
class="pre">interval_months</span></span><span class="sig-paren">(</span><em
class="sig-param"><span class="n"><span class="pre">nullable</span></span><span
class="p"><span class="pre">:</span></span><span class="w"> </span><span
class="n"><span class="pre">bool</span></span><span class="w"> </span><span
class="o"><span class="pre">=</span></span><span class="w"> </span><span
class="default_value"><span class="pre">True</span></span></em><span class=
[...]
<dd><p>Create an instance of an interval type measured in months.</p>
-<section id="id70">
-<h2>Parameters<a class="headerlink" href="#id70" title="Link to this
heading">#</a></h2>
+<section id="id71">
+<h2>Parameters<a class="headerlink" href="#id71" title="Link to this
heading">#</a></h2>
<dl class="simple">
<dt>nullable<span class="classifier">bool, optional</span></dt><dd><p>Use
<code class="docutils literal notranslate"><span
class="pre">False</span></code> to mark this field as non-nullable.</p>
</dd>
</dl>
</section>
-<section id="id71">
-<h2>Examples<a class="headerlink" href="#id71" title="Link to this
heading">#</a></h2>
+<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">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </span><span class="n">na</span><span
class="o">.</span><span class="n">interval_months</span><span
class="p">()</span>
<span class="go">Schema(INTERVAL_MONTHS)</span>
@@ -1668,15 +1687,15 @@ tuple.</p>
<dt class="sig sig-object py" id="nanoarrow.large_binary">
<span class="sig-name descname"><span
class="pre">large_binary</span></span><span class="sig-paren">(</span><em
class="sig-param"><span class="n"><span class="pre">nullable</span></span><span
class="p"><span class="pre">:</span></span><span class="w"> </span><span
class="n"><span class="pre">bool</span></span><span class="w"> </span><span
class="o"><span class="pre">=</span></span><span class="w"> </span><span
class="default_value"><span class="pre">True</span></span></em><span class="si
[...]
<dd><p>Create an instance of a variable-length binary type that uses 64-bit
offsets.</p>
-<section id="id72">
-<h2>Parameters<a class="headerlink" href="#id72" title="Link to this
heading">#</a></h2>
+<section id="id73">
+<h2>Parameters<a class="headerlink" href="#id73" title="Link to this
heading">#</a></h2>
<dl class="simple">
<dt>nullable<span class="classifier">bool, optional</span></dt><dd><p>Use
<code class="docutils literal notranslate"><span
class="pre">False</span></code> to mark this field as non-nullable.</p>
</dd>
</dl>
</section>
-<section id="id73">
-<h2>Examples<a class="headerlink" href="#id73" title="Link to this
heading">#</a></h2>
+<section id="id74">
+<h2>Examples<a class="headerlink" href="#id74" title="Link to this
heading">#</a></h2>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </span><span class="n">na</span><span
class="o">.</span><span class="n">large_binary</span><span class="p">()</span>
<span class="go">Schema(LARGE_BINARY)</span>
@@ -1690,15 +1709,15 @@ tuple.</p>
<span class="sig-name descname"><span
class="pre">large_string</span></span><span class="sig-paren">(</span><em
class="sig-param"><span class="n"><span class="pre">nullable</span></span><span
class="p"><span class="pre">:</span></span><span class="w"> </span><span
class="n"><span class="pre">bool</span></span><span class="w"> </span><span
class="o"><span class="pre">=</span></span><span class="w"> </span><span
class="default_value"><span class="pre">True</span></span></em><span class="si
[...]
<dd><p>Create an instance of a variable-length UTF-8 encoded string type
that uses 64-bit offsets.</p>
-<section id="id74">
-<h2>Parameters<a class="headerlink" href="#id74" title="Link to this
heading">#</a></h2>
+<section id="id75">
+<h2>Parameters<a class="headerlink" href="#id75" title="Link to this
heading">#</a></h2>
<dl class="simple">
<dt>nullable<span class="classifier">bool, optional</span></dt><dd><p>Use
<code class="docutils literal notranslate"><span
class="pre">False</span></code> to mark this field as non-nullable.</p>
</dd>
</dl>
</section>
-<section id="id75">
-<h2>Examples<a class="headerlink" href="#id75" title="Link to this
heading">#</a></h2>
+<section id="id76">
+<h2>Examples<a class="headerlink" href="#id76" title="Link to this
heading">#</a></h2>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </span><span class="n">na</span><span
class="o">.</span><span class="n">large_string</span><span class="p">()</span>
<span class="go">Schema(LARGE_STRING)</span>
@@ -1711,15 +1730,15 @@ that uses 64-bit offsets.</p>
<dt class="sig sig-object py" id="nanoarrow.null">
<span class="sig-name descname"><span class="pre">null</span></span><span
class="sig-paren">(</span><em class="sig-param"><span class="n"><span
class="pre">nullable</span></span><span class="p"><span
class="pre">:</span></span><span class="w"> </span><span class="n"><span
class="pre">bool</span></span><span class="w"> </span><span class="o"><span
class="pre">=</span></span><span class="w"> </span><span
class="default_value"><span class="pre">True</span></span></em><span
class="sig-paren" [...]
<dd><p>Create an instance of a null type.</p>
-<section id="id76">
-<h2>Parameters<a class="headerlink" href="#id76" title="Link to this
heading">#</a></h2>
+<section id="id77">
+<h2>Parameters<a class="headerlink" href="#id77" title="Link to this
heading">#</a></h2>
<dl class="simple">
<dt>nullable<span class="classifier">bool, optional</span></dt><dd><p>Use
<code class="docutils literal notranslate"><span
class="pre">False</span></code> to mark this field as non-nullable.</p>
</dd>
</dl>
</section>
-<section id="id77">
-<h2>Examples<a class="headerlink" href="#id77" title="Link to this
heading">#</a></h2>
+<section id="id78">
+<h2>Examples<a class="headerlink" href="#id78" title="Link to this
heading">#</a></h2>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </span><span class="n">na</span><span
class="o">.</span><span class="n">null</span><span class="p">()</span>
<span class="go">Schema(NULL)</span>
@@ -1735,8 +1754,8 @@ that uses 64-bit offsets.</p>
<p>The Schema is nanoarrow’s high-level data type representation, encompasing
the role of PyArrow’s <code class="docutils literal notranslate"><span
class="pre">Schema</span></code>, <code class="docutils literal
notranslate"><span class="pre">Field</span></code>, and <code class="docutils
literal notranslate"><span class="pre">DataType</span></code>. This scope
maps to that of the ArrowSchema in the Arrow C Data interface.</p>
-<section id="id78">
-<h2>Parameters<a class="headerlink" href="#id78" title="Link to this
heading">#</a></h2>
+<section id="id79">
+<h2>Parameters<a class="headerlink" href="#id79" title="Link to this
heading">#</a></h2>
<dl class="simple">
<dt>obj :</dt><dd><p>A <a class="reference internal" href="#nanoarrow.Type"
title="nanoarrow.Type"><code class="xref py py-class docutils literal
notranslate"><span class="pre">Type</span></code></a> specifier or a
schema-like object. A schema-like object
includes:
@@ -1754,8 +1773,8 @@ the nullability is preserved from the passed object).</p>
</dd>
</dl>
</section>
-<section id="id79">
-<h2>Examples<a class="headerlink" href="#id79" title="Link to this
heading">#</a></h2>
+<section id="id80">
+<h2>Examples<a class="headerlink" href="#id80" title="Link to this
heading">#</a></h2>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </span><span class="kn">import</span> <span
class="nn">pyarrow</span> <span class="k">as</span> <span class="nn">pa</span>
<span class="gp">>>> </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>
@@ -1773,15 +1792,15 @@ the nullability is preserved from the passed
object).</p>
<dt class="sig sig-object py" id="nanoarrow.string">
<span class="sig-name descname"><span class="pre">string</span></span><span
class="sig-paren">(</span><em class="sig-param"><span class="n"><span
class="pre">nullable</span></span><span class="p"><span
class="pre">:</span></span><span class="w"> </span><span class="n"><span
class="pre">bool</span></span><span class="w"> </span><span class="o"><span
class="pre">=</span></span><span class="w"> </span><span
class="default_value"><span class="pre">True</span></span></em><span
class="sig-pare [...]
<dd><p>Create an instance of a variable-length UTF-8 encoded string type.</p>
-<section id="id80">
-<h2>Parameters<a class="headerlink" href="#id80" title="Link to this
heading">#</a></h2>
+<section id="id81">
+<h2>Parameters<a class="headerlink" href="#id81" title="Link to this
heading">#</a></h2>
<dl class="simple">
<dt>nullable<span class="classifier">bool, optional</span></dt><dd><p>Use
<code class="docutils literal notranslate"><span
class="pre">False</span></code> to mark this field as non-nullable.</p>
</dd>
</dl>
</section>
-<section id="id81">
-<h2>Examples<a class="headerlink" href="#id81" title="Link to this
heading">#</a></h2>
+<section id="id82">
+<h2>Examples<a class="headerlink" href="#id82" title="Link to this
heading">#</a></h2>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </span><span class="n">na</span><span
class="o">.</span><span class="n">string</span><span class="p">()</span>
<span class="go">Schema(STRING)</span>
@@ -1794,8 +1813,8 @@ the nullability is preserved from the passed object).</p>
<dt class="sig sig-object py" id="nanoarrow.struct">
<span class="sig-name descname"><span class="pre">struct</span></span><span
class="sig-paren">(</span><em class="sig-param"><span class="n"><span
class="pre">fields</span></span></em>, <em class="sig-param"><span
class="n"><span class="pre">nullable</span></span><span class="o"><span
class="pre">=</span></span><span class="default_value"><span
class="pre">True</span></span></em><span class="sig-paren">)</span> <span
class="sig-return"><span class="sig-return-icon">→</span> <span c [...]
<dd><p>Create a type representing a named sequence of fields.</p>
-<section id="id82">
-<h2>Parameters<a class="headerlink" href="#id82" title="Link to this
heading">#</a></h2>
+<section id="id83">
+<h2>Parameters<a class="headerlink" href="#id83" title="Link to this
heading">#</a></h2>
<dl class="simple">
<dt>fields :</dt><dd><ul class="simple">
<li><p>A dictionary whose keys are field names and values are schema-like
objects</p></li>
@@ -1808,8 +1827,8 @@ from the tuple, the field name is inherited from the
schema-like object.</p></li
</dd>
</dl>
</section>
-<section id="id83">
-<h2>Examples<a class="headerlink" href="#id83" title="Link to this
heading">#</a></h2>
+<section id="id84">
+<h2>Examples<a class="headerlink" href="#id84" title="Link to this
heading">#</a></h2>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </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">Schema(STRUCT, fields=[Schema(INT32)])</span>
@@ -1826,8 +1845,8 @@ from the tuple, the field name is inherited from the
schema-like object.</p></li
<dt class="sig sig-object py" id="nanoarrow.time32">
<span class="sig-name descname"><span class="pre">time32</span></span><span
class="sig-paren">(</span><em class="sig-param"><span class="n"><span
class="pre">unit</span></span><span class="p"><span
class="pre">:</span></span><span class="w"> </span><span class="n"><span
class="pre">str</span><span class="w"> </span><span class="p"><span
class="pre">|</span></span><span class="w"> </span><a class="reference
internal" href="#nanoarrow.TimeUnit" title="nanoarrow.schema.TimeUnit"><span
class [...]
<dd><p>Create an instance of a 32-bit time of day type.</p>
-<section id="id84">
-<h2>Parameters<a class="headerlink" href="#id84" title="Link to this
heading">#</a></h2>
+<section id="id85">
+<h2>Parameters<a class="headerlink" href="#id85" title="Link to this
heading">#</a></h2>
<dl>
<dt>unit<span class="classifier">str or <a class="reference internal"
href="#nanoarrow.TimeUnit" title="nanoarrow.TimeUnit"><code class="xref py
py-class docutils literal notranslate"><span
class="pre">TimeUnit</span></code></a></span></dt><dd><p>The unit of values
stored by this type.</p>
</dd>
@@ -1835,8 +1854,8 @@ from the tuple, the field name is inherited from the
schema-like object.</p></li
</dd>
</dl>
</section>
-<section id="id85">
-<h2>Examples<a class="headerlink" href="#id85" title="Link to this
heading">#</a></h2>
+<section id="id86">
+<h2>Examples<a class="headerlink" href="#id86" title="Link to this
heading">#</a></h2>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </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">Schema(TIME32, unit=SECOND)</span>
@@ -1849,8 +1868,8 @@ from the tuple, the field name is inherited from the
schema-like object.</p></li
<dt class="sig sig-object py" id="nanoarrow.time64">
<span class="sig-name descname"><span class="pre">time64</span></span><span
class="sig-paren">(</span><em class="sig-param"><span class="n"><span
class="pre">unit</span></span><span class="p"><span
class="pre">:</span></span><span class="w"> </span><span class="n"><span
class="pre">str</span><span class="w"> </span><span class="p"><span
class="pre">|</span></span><span class="w"> </span><a class="reference
internal" href="#nanoarrow.TimeUnit" title="nanoarrow.schema.TimeUnit"><span
class [...]
<dd><p>Create an instance of a 64-bit time of day type.</p>
-<section id="id86">
-<h2>Parameters<a class="headerlink" href="#id86" title="Link to this
heading">#</a></h2>
+<section id="id87">
+<h2>Parameters<a class="headerlink" href="#id87" title="Link to this
heading">#</a></h2>
<dl>
<dt>unit<span class="classifier">str or <a class="reference internal"
href="#nanoarrow.TimeUnit" title="nanoarrow.TimeUnit"><code class="xref py
py-class docutils literal notranslate"><span
class="pre">TimeUnit</span></code></a></span></dt><dd><p>The unit of values
stored by this type.</p>
</dd>
@@ -1858,8 +1877,8 @@ from the tuple, the field name is inherited from the
schema-like object.</p></li
</dd>
</dl>
</section>
-<section id="id87">
-<h2>Examples<a class="headerlink" href="#id87" title="Link to this
heading">#</a></h2>
+<section id="id88">
+<h2>Examples<a class="headerlink" href="#id88" title="Link to this
heading">#</a></h2>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </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">Schema(TIME64, unit=MICRO)</span>
@@ -1872,8 +1891,8 @@ from the tuple, the field name is inherited from the
schema-like object.</p></li
<dt class="sig sig-object py" id="nanoarrow.timestamp">
<span class="sig-name descname"><span class="pre">timestamp</span></span><span
class="sig-paren">(</span><em class="sig-param"><span class="n"><span
class="pre">unit</span></span><span class="p"><span
class="pre">:</span></span><span class="w"> </span><span class="n"><span
class="pre">str</span><span class="w"> </span><span class="p"><span
class="pre">|</span></span><span class="w"> </span><a class="reference
internal" href="#nanoarrow.TimeUnit" title="nanoarrow.schema.TimeUnit"><span cl
[...]
<dd><p>Create an instance of a timestamp type.</p>
-<section id="id88">
-<h2>Parameters<a class="headerlink" href="#id88" title="Link to this
heading">#</a></h2>
+<section id="id89">
+<h2>Parameters<a class="headerlink" href="#id89" title="Link to this
heading">#</a></h2>
<dl>
<dt>unit<span class="classifier">str or <a class="reference internal"
href="#nanoarrow.TimeUnit" title="nanoarrow.TimeUnit"><code class="xref py
py-class docutils literal notranslate"><span
class="pre">TimeUnit</span></code></a></span></dt><dd><p>The unit of values
stored by this type.</p>
</dd>
@@ -1881,8 +1900,8 @@ from the tuple, the field name is inherited from the
schema-like object.</p></li
</dd>
</dl>
</section>
-<section id="id89">
-<h2>Examples<a class="headerlink" href="#id89" title="Link to this
heading">#</a></h2>
+<section id="id90">
+<h2>Examples<a class="headerlink" href="#id90" title="Link to this
heading">#</a></h2>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </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">Schema(TIMESTAMP, unit=SECOND)</span>
@@ -1897,15 +1916,15 @@ from the tuple, the field name is inherited from the
schema-like object.</p></li
<dt class="sig sig-object py" id="nanoarrow.uint16">
<span class="sig-name descname"><span class="pre">uint16</span></span><span
class="sig-paren">(</span><em class="sig-param"><span class="n"><span
class="pre">nullable</span></span><span class="p"><span
class="pre">:</span></span><span class="w"> </span><span class="n"><span
class="pre">bool</span></span><span class="w"> </span><span class="o"><span
class="pre">=</span></span><span class="w"> </span><span
class="default_value"><span class="pre">True</span></span></em><span
class="sig-pare [...]
<dd><p>Create an instance of an unsigned 16-bit integer type.</p>
-<section id="id90">
-<h2>Parameters<a class="headerlink" href="#id90" title="Link to this
heading">#</a></h2>
+<section id="id91">
+<h2>Parameters<a class="headerlink" href="#id91" title="Link to this
heading">#</a></h2>
<dl class="simple">
<dt>nullable<span class="classifier">bool, optional</span></dt><dd><p>Use
<code class="docutils literal notranslate"><span
class="pre">False</span></code> to mark this field as non-nullable.</p>
</dd>
</dl>
</section>
-<section id="id91">
-<h2>Examples<a class="headerlink" href="#id91" title="Link to this
heading">#</a></h2>
+<section id="id92">
+<h2>Examples<a class="headerlink" href="#id92" title="Link to this
heading">#</a></h2>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </span><span class="n">na</span><span
class="o">.</span><span class="n">uint16</span><span class="p">()</span>
<span class="go">Schema(UINT16)</span>
@@ -1918,15 +1937,15 @@ from the tuple, the field name is inherited from the
schema-like object.</p></li
<dt class="sig sig-object py" id="nanoarrow.uint32">
<span class="sig-name descname"><span class="pre">uint32</span></span><span
class="sig-paren">(</span><em class="sig-param"><span class="n"><span
class="pre">nullable</span></span><span class="p"><span
class="pre">:</span></span><span class="w"> </span><span class="n"><span
class="pre">bool</span></span><span class="w"> </span><span class="o"><span
class="pre">=</span></span><span class="w"> </span><span
class="default_value"><span class="pre">True</span></span></em><span
class="sig-pare [...]
<dd><p>Create an instance of an unsigned 32-bit integer type.</p>
-<section id="id92">
-<h2>Parameters<a class="headerlink" href="#id92" title="Link to this
heading">#</a></h2>
+<section id="id93">
+<h2>Parameters<a class="headerlink" href="#id93" title="Link to this
heading">#</a></h2>
<dl class="simple">
<dt>nullable<span class="classifier">bool, optional</span></dt><dd><p>Use
<code class="docutils literal notranslate"><span
class="pre">False</span></code> to mark this field as non-nullable.</p>
</dd>
</dl>
</section>
-<section id="id93">
-<h2>Examples<a class="headerlink" href="#id93" title="Link to this
heading">#</a></h2>
+<section id="id94">
+<h2>Examples<a class="headerlink" href="#id94" title="Link to this
heading">#</a></h2>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </span><span class="n">na</span><span
class="o">.</span><span class="n">uint32</span><span class="p">()</span>
<span class="go">Schema(UINT32)</span>
@@ -1939,15 +1958,15 @@ from the tuple, the field name is inherited from the
schema-like object.</p></li
<dt class="sig sig-object py" id="nanoarrow.uint64">
<span class="sig-name descname"><span class="pre">uint64</span></span><span
class="sig-paren">(</span><em class="sig-param"><span class="n"><span
class="pre">nullable</span></span><span class="p"><span
class="pre">:</span></span><span class="w"> </span><span class="n"><span
class="pre">bool</span></span><span class="w"> </span><span class="o"><span
class="pre">=</span></span><span class="w"> </span><span
class="default_value"><span class="pre">True</span></span></em><span
class="sig-pare [...]
<dd><p>Create an instance of an unsigned 32-bit integer type.</p>
-<section id="id94">
-<h2>Parameters<a class="headerlink" href="#id94" title="Link to this
heading">#</a></h2>
+<section id="id95">
+<h2>Parameters<a class="headerlink" href="#id95" title="Link to this
heading">#</a></h2>
<dl class="simple">
<dt>nullable<span class="classifier">bool, optional</span></dt><dd><p>Use
<code class="docutils literal notranslate"><span
class="pre">False</span></code> to mark this field as non-nullable.</p>
</dd>
</dl>
</section>
-<section id="id95">
-<h2>Examples<a class="headerlink" href="#id95" title="Link to this
heading">#</a></h2>
+<section id="id96">
+<h2>Examples<a class="headerlink" href="#id96" title="Link to this
heading">#</a></h2>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </span><span class="n">na</span><span
class="o">.</span><span class="n">uint64</span><span class="p">()</span>
<span class="go">Schema(UINT64)</span>
@@ -1960,15 +1979,15 @@ from the tuple, the field name is inherited from the
schema-like object.</p></li
<dt class="sig sig-object py" id="nanoarrow.uint8">
<span class="sig-name descname"><span class="pre">uint8</span></span><span
class="sig-paren">(</span><em class="sig-param"><span class="n"><span
class="pre">nullable</span></span><span class="p"><span
class="pre">:</span></span><span class="w"> </span><span class="n"><span
class="pre">bool</span></span><span class="w"> </span><span class="o"><span
class="pre">=</span></span><span class="w"> </span><span
class="default_value"><span class="pre">True</span></span></em><span
class="sig-paren [...]
<dd><p>Create an instance of an unsigned 8-bit integer type.</p>
-<section id="id96">
-<h2>Parameters<a class="headerlink" href="#id96" title="Link to this
heading">#</a></h2>
+<section id="id97">
+<h2>Parameters<a class="headerlink" href="#id97" title="Link to this
heading">#</a></h2>
<dl class="simple">
<dt>nullable<span class="classifier">bool, optional</span></dt><dd><p>Use
<code class="docutils literal notranslate"><span
class="pre">False</span></code> to mark this field as non-nullable.</p>
</dd>
</dl>
</section>
-<section id="id97">
-<h2>Examples<a class="headerlink" href="#id97" title="Link to this
heading">#</a></h2>
+<section id="id98">
+<h2>Examples<a class="headerlink" href="#id98" title="Link to this
heading">#</a></h2>
<div class="doctest highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="gp">>>> </span><span
class="kn">import</span> <span class="nn">nanoarrow</span> <span
class="k">as</span> <span class="nn">na</span>
<span class="gp">>>> </span><span class="n">na</span><span
class="o">.</span><span class="n">uint8</span><span class="p">()</span>
<span class="go">Schema(UINT8)</span>
@@ -2032,8 +2051,8 @@ from the tuple, the field name is inherited from the
schema-like object.</p></li
<li class="toc-h3 nav-item toc-entry"><a class="reference internal nav-link"
href="#nanoarrow.Array.chunk"><code class="docutils literal notranslate"><span
class="pre">Array.chunk()</span></code></a></li>
<li class="toc-h3 nav-item toc-entry"><a class="reference internal nav-link"
href="#nanoarrow.Array.device"><code class="docutils literal notranslate"><span
class="pre">Array.device</span></code></a></li>
<li class="toc-h3 nav-item toc-entry"><a class="reference internal nav-link"
href="#nanoarrow.Array.inspect"><code class="docutils literal
notranslate"><span class="pre">Array.inspect()</span></code></a></li>
-<li class="toc-h3 nav-item toc-entry"><a class="reference internal nav-link"
href="#nanoarrow.Array.iter_buffers"><code class="docutils literal
notranslate"><span class="pre">Array.iter_buffers()</span></code></a></li>
<li class="toc-h3 nav-item toc-entry"><a class="reference internal nav-link"
href="#nanoarrow.Array.iter_children"><code class="docutils literal
notranslate"><span class="pre">Array.iter_children()</span></code></a></li>
+<li class="toc-h3 nav-item toc-entry"><a class="reference internal nav-link"
href="#nanoarrow.Array.iter_chunk_views"><code class="docutils literal
notranslate"><span class="pre">Array.iter_chunk_views()</span></code></a></li>
<li class="toc-h3 nav-item toc-entry"><a class="reference internal nav-link"
href="#nanoarrow.Array.iter_chunks"><code class="docutils literal
notranslate"><span class="pre">Array.iter_chunks()</span></code></a></li>
<li class="toc-h3 nav-item toc-entry"><a class="reference internal nav-link"
href="#nanoarrow.Array.iter_py"><code class="docutils literal
notranslate"><span class="pre">Array.iter_py()</span></code></a></li>
<li class="toc-h3 nav-item toc-entry"><a class="reference internal nav-link"
href="#nanoarrow.Array.iter_scalar"><code class="docutils literal
notranslate"><span class="pre">Array.iter_scalar()</span></code></a></li>
@@ -2041,6 +2060,7 @@ from the tuple, the field name is inherited from the
schema-like object.</p></li
<li class="toc-h3 nav-item toc-entry"><a class="reference internal nav-link"
href="#nanoarrow.Array.n_buffers"><code class="docutils literal
notranslate"><span class="pre">Array.n_buffers</span></code></a></li>
<li class="toc-h3 nav-item toc-entry"><a class="reference internal nav-link"
href="#nanoarrow.Array.n_children"><code class="docutils literal
notranslate"><span class="pre">Array.n_children</span></code></a></li>
<li class="toc-h3 nav-item toc-entry"><a class="reference internal nav-link"
href="#nanoarrow.Array.n_chunks"><code class="docutils literal
notranslate"><span class="pre">Array.n_chunks</span></code></a></li>
+<li class="toc-h3 nav-item toc-entry"><a class="reference internal nav-link"
href="#nanoarrow.Array.offset"><code class="docutils literal notranslate"><span
class="pre">Array.offset</span></code></a></li>
<li class="toc-h3 nav-item toc-entry"><a class="reference internal nav-link"
href="#nanoarrow.Array.schema"><code class="docutils literal notranslate"><span
class="pre">Array.schema</span></code></a></li>
</ul>
</li>
diff --git a/main/searchindex.js b/main/searchindex.js
index 436f6db6..09035655 100644
--- a/main/searchindex.js
+++ b/main/searchindex.js
@@ -1 +1 @@
-Search.setIndex({"alltitles": {"API Reference": [[8, "api-reference"]], "Array
Stream utilities": [[6, "array-stream-utilities"]], "Array Streams": [[3,
"array-streams"]], "Array streams": [[2, "array-streams"]], "Arrays": [[2,
"arrays"], [3, "arrays"]], "Arrow C Data Interface": [[5,
"arrow-c-data-interface"]], "Arrow C Device Interface": [[7,
"arrow-c-device-interface"]], "Arrow C data/nanoarrow interface basics": [[0,
"arrow-c-data-nanoarrow-interface-basics"]], "Base classes and util [...]
\ No newline at end of file
+Search.setIndex({"alltitles": {"API Reference": [[8, "api-reference"]], "Array
Stream utilities": [[6, "array-stream-utilities"]], "Array Streams": [[3,
"array-streams"]], "Array streams": [[2, "array-streams"]], "Arrays": [[2,
"arrays"], [3, "arrays"]], "Arrow C Data Interface": [[5,
"arrow-c-data-interface"]], "Arrow C Device Interface": [[7,
"arrow-c-device-interface"]], "Arrow C data/nanoarrow interface basics": [[0,
"arrow-c-data-nanoarrow-interface-basics"]], "Base classes and util [...]
\ No newline at end of file
