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 a4c44d10 update documentation for tag main
a4c44d10 is described below
commit a4c44d1081a4f247c244cf08d40e2ae27f130656
Author: GitHub Actions <[email protected]>
AuthorDate: Mon Feb 19 19:03:29 2024 +0000
update documentation for tag main
---
main/_sources/getting-started/python.rst.txt | 47 +---
main/genindex.html | 6 +-
main/getting-started/python.html | 47 +---
main/objects.inv | Bin 21086 -> 21088 bytes
main/r/pkgdown.yml | 2 +-
main/reference/c.html | 6 +-
main/reference/index.html | 2 +
main/reference/python.html | 402 ++++++++++++++++++---------
main/searchindex.js | 2 +-
9 files changed, 302 insertions(+), 212 deletions(-)
diff --git a/main/_sources/getting-started/python.rst.txt
b/main/_sources/getting-started/python.rst.txt
index 2b909e13..a7d00b6c 100644
--- a/main/_sources/getting-started/python.rst.txt
+++ b/main/_sources/getting-started/python.rst.txt
@@ -99,6 +99,11 @@ parse it into a view to extract deserialized parameters.
- decimal_bitwidth: 128
- decimal_precision: 10
- decimal_scale: 3
+ - dictionary_ordered: False
+ - map_keys_sorted: False
+ - nullable: True
+ - storage_type_id: 24
+ - type_id: 24
Advanced users can allocate an empty ``CSchema`` and populate its
contents by passing its ``._addr()`` to a schema-exporting function.
@@ -143,7 +148,7 @@ Interface
<https://arrow.apache.org/docs/format/CDataInterface.html>`__
- length: 4
- offset: 0
- null_count: 1
- - buffers: (2939032895680, 2939032895616, 2939032895744)
+ - buffers: (3678035706048, 3678035705984, 3678035706112)
- dictionary: NULL
- children[0]:
@@ -162,9 +167,9 @@ into a view to extract deserialized content:
- offset: 0
- null_count: 1
- buffers[3]:
- - <bool validity[1 b] 11100000>
- - <int32 data_offset[20 b] 0 3 6 11 11>
- - <string data[11 b] b'onetwothree'>
+ - validity <bool[1 b] 11100000>
+ - data_offset <int32[20 b] 0 3 6 11 11>
+ - data <string[11 b] b'onetwothree'>
- dictionary: NULL
- children[0]:
@@ -202,20 +207,7 @@ Interface
<https://arrow.apache.org/docs/format/CDataInterface.html>`__
::
<nanoarrow.c_lib.CArrayStream>
- - get_schema(): <nanoarrow.c_lib.CSchema struct>
- - format: '+s'
- - name: ''
- - flags: 0
- - metadata: NULL
- - dictionary: NULL
- - children[1]:
- 'some_column': <nanoarrow.c_lib.CSchema int32>
- - format: 'i'
- - name: 'some_column'
- - flags: 2
- - metadata: NULL
- - dictionary: NULL
- - children[0]:
+ - get_schema(): struct<some_column: int32>
You can pull the next array from the stream using ``.get_next()`` or use
it like an iterator. The ``.get_next()`` method will raise
@@ -228,7 +220,7 @@ it like an iterator. The ``.get_next()`` method will raise
::
- <nanoarrow.c_lib.CArray struct>
+ <nanoarrow.c_lib.CArray struct<some_column: int32>>
- length: 3
- offset: 0
- null_count: 0
@@ -239,7 +231,7 @@ it like an iterator. The ``.get_next()`` method will raise
- length: 3
- offset: 0
- null_count: 0
- - buffers: (0, 2939033026688)
+ - buffers: (0, 3678035837056)
- dictionary: NULL
- children[0]:
@@ -255,20 +247,7 @@ suitable exporting function:
::
<nanoarrow.c_lib.CArrayStream>
- - get_schema(): <nanoarrow.c_lib.CSchema struct>
- - format: '+s'
- - name: ''
- - flags: 0
- - metadata: NULL
- - dictionary: NULL
- - children[1]:
- 'some_column': <nanoarrow.c_lib.CSchema int32>
- - format: 'i'
- - name: 'some_column'
- - flags: 2
- - metadata: NULL
- - dictionary: NULL
- - children[0]:
+ - get_schema(): struct<some_column: int32>
Development
-----------
diff --git a/main/genindex.html b/main/genindex.html
index 82d12d04..f1eab91b 100644
--- a/main/genindex.html
+++ b/main/genindex.html
@@ -672,7 +672,7 @@ document.write(`
</li>
<li><a
href="reference/c.html#_CPPv423ArrowBufferAppendUnsafeP11ArrowBufferPKv7int64_t">ArrowBufferAppendUnsafe
(C++ function)</a>
</li>
- <li><a
href="reference/c.html#_CPPv422ArrowBufferDeallocatorPFvP20ArrowBufferAllocatorP7uint8_t7int64_tEPv">ArrowBufferDeallocator
(C++ function)</a>
+ <li><a
href="reference/c.html#_CPPv422ArrowBufferDeallocator30ArrowBufferDeallocatorCallbackPv">ArrowBufferDeallocator
(C++ function)</a>
</li>
<li><a
href="reference/c.html#_CPPv415ArrowBufferInitP11ArrowBuffer">ArrowBufferInit
(C++ function)</a>
</li>
@@ -1229,6 +1229,8 @@ document.write(`
<table style="width: 100%" class="indextable genindextable"><tr>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="reference/python.html#nanoarrow.c_array">c_array() (in
module nanoarrow)</a>
+</li>
+ <li><a
href="reference/python.html#nanoarrow.c_array_from_buffers">c_array_from_buffers()
(in module nanoarrow)</a>
</li>
<li><a
href="reference/python.html#nanoarrow.c_array_stream">c_array_stream() (in
module nanoarrow)</a>
</li>
@@ -1236,6 +1238,8 @@ document.write(`
</li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
+ <li><a href="reference/python.html#nanoarrow.c_buffer">c_buffer() (in
module nanoarrow)</a>
+</li>
<li><a href="reference/python.html#nanoarrow.c_schema">c_schema() (in
module nanoarrow)</a>
</li>
<li><a
href="reference/python.html#nanoarrow.c_schema_view">c_schema_view() (in module
nanoarrow)</a>
diff --git a/main/getting-started/python.html b/main/getting-started/python.html
index a3baa850..e37ab5fe 100644
--- a/main/getting-started/python.html
+++ b/main/getting-started/python.html
@@ -466,6 +466,11 @@ parse it into a view to extract deserialized
parameters.</p>
<span class="o">-</span> <span class="n">decimal_bitwidth</span><span
class="p">:</span> <span class="mi">128</span>
<span class="o">-</span> <span class="n">decimal_precision</span><span
class="p">:</span> <span class="mi">10</span>
<span class="o">-</span> <span class="n">decimal_scale</span><span
class="p">:</span> <span class="mi">3</span>
+<span class="o">-</span> <span class="n">dictionary_ordered</span><span
class="p">:</span> <span class="kc">False</span>
+<span class="o">-</span> <span class="n">map_keys_sorted</span><span
class="p">:</span> <span class="kc">False</span>
+<span class="o">-</span> <span class="n">nullable</span><span
class="p">:</span> <span class="kc">True</span>
+<span class="o">-</span> <span class="n">storage_type_id</span><span
class="p">:</span> <span class="mi">24</span>
+<span class="o">-</span> <span class="n">type_id</span><span
class="p">:</span> <span class="mi">24</span>
</pre></div>
</div>
<p>Advanced users can allocate an empty <code class="docutils literal
notranslate"><span class="pre">CSchema</span></code> and populate its
@@ -503,7 +508,7 @@ Interface</a>
<span class="o">-</span> <span class="n">length</span><span class="p">:</span>
<span class="mi">4</span>
<span class="o">-</span> <span class="n">offset</span><span class="p">:</span>
<span class="mi">0</span>
<span class="o">-</span> <span class="n">null_count</span><span
class="p">:</span> <span class="mi">1</span>
-<span class="o">-</span> <span class="n">buffers</span><span
class="p">:</span> <span class="p">(</span><span
class="mi">2939032895680</span><span class="p">,</span> <span
class="mi">2939032895616</span><span class="p">,</span> <span
class="mi">2939032895744</span><span class="p">)</span>
+<span class="o">-</span> <span class="n">buffers</span><span
class="p">:</span> <span class="p">(</span><span
class="mi">3678035706048</span><span class="p">,</span> <span
class="mi">3678035705984</span><span class="p">,</span> <span
class="mi">3678035706112</span><span class="p">)</span>
<span class="o">-</span> <span class="n">dictionary</span><span
class="p">:</span> <span class="n">NULL</span>
<span class="o">-</span> <span class="n">children</span><span
class="p">[</span><span class="mi">0</span><span class="p">]:</span>
</pre></div>
@@ -519,9 +524,9 @@ into a view to extract deserialized content:</p>
<span class="o">-</span> <span class="n">offset</span><span class="p">:</span>
<span class="mi">0</span>
<span class="o">-</span> <span class="n">null_count</span><span
class="p">:</span> <span class="mi">1</span>
<span class="o">-</span> <span class="n">buffers</span><span
class="p">[</span><span class="mi">3</span><span class="p">]:</span>
- <span class="o">-</span> <span class="o"><</span><span
class="nb">bool</span> <span class="n">validity</span><span
class="p">[</span><span class="mi">1</span> <span class="n">b</span><span
class="p">]</span> <span class="mi">11100000</span><span class="o">></span>
- <span class="o">-</span> <span class="o"><</span><span
class="n">int32</span> <span class="n">data_offset</span><span
class="p">[</span><span class="mi">20</span> <span class="n">b</span><span
class="p">]</span> <span class="mi">0</span> <span class="mi">3</span> <span
class="mi">6</span> <span class="mi">11</span> <span class="mi">11</span><span
class="o">></span>
- <span class="o">-</span> <span class="o"><</span><span
class="n">string</span> <span class="n">data</span><span
class="p">[</span><span class="mi">11</span> <span class="n">b</span><span
class="p">]</span> <span class="sa">b</span><span
class="s1">'onetwothree'</span><span class="o">></span>
+ <span class="o">-</span> <span class="n">validity</span> <span
class="o"><</span><span class="nb">bool</span><span class="p">[</span><span
class="mi">1</span> <span class="n">b</span><span class="p">]</span> <span
class="mi">11100000</span><span class="o">></span>
+ <span class="o">-</span> <span class="n">data_offset</span> <span
class="o"><</span><span class="n">int32</span><span class="p">[</span><span
class="mi">20</span> <span class="n">b</span><span class="p">]</span> <span
class="mi">0</span> <span class="mi">3</span> <span class="mi">6</span> <span
class="mi">11</span> <span class="mi">11</span><span class="o">></span>
+ <span class="o">-</span> <span class="n">data</span> <span
class="o"><</span><span class="n">string</span><span class="p">[</span><span
class="mi">11</span> <span class="n">b</span><span class="p">]</span> <span
class="sa">b</span><span class="s1">'onetwothree'</span><span
class="o">></span>
<span class="o">-</span> <span class="n">dictionary</span><span
class="p">:</span> <span class="n">NULL</span>
<span class="o">-</span> <span class="n">children</span><span
class="p">[</span><span class="mi">0</span><span class="p">]:</span>
</pre></div>
@@ -553,20 +558,7 @@ Interface</a>
</pre></div>
</div>
<div class="highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="o"><</span><span
class="n">nanoarrow</span><span class="o">.</span><span
class="n">c_lib</span><span class="o">.</span><span
class="n">CArrayStream</span><span class="o">></span>
-<span class="o">-</span> <span class="n">get_schema</span><span
class="p">():</span> <span class="o"><</span><span
class="n">nanoarrow</span><span class="o">.</span><span
class="n">c_lib</span><span class="o">.</span><span class="n">CSchema</span>
<span class="n">struct</span><span class="o">></span>
- <span class="o">-</span> <span class="nb">format</span><span
class="p">:</span> <span class="s1">'+s'</span>
- <span class="o">-</span> <span class="n">name</span><span class="p">:</span>
<span class="s1">''</span>
- <span class="o">-</span> <span class="n">flags</span><span
class="p">:</span> <span class="mi">0</span>
- <span class="o">-</span> <span class="n">metadata</span><span
class="p">:</span> <span class="n">NULL</span>
- <span class="o">-</span> <span class="n">dictionary</span><span
class="p">:</span> <span class="n">NULL</span>
- <span class="o">-</span> <span class="n">children</span><span
class="p">[</span><span class="mi">1</span><span class="p">]:</span>
- <span class="s1">'some_column'</span><span class="p">:</span>
<span class="o"><</span><span class="n">nanoarrow</span><span
class="o">.</span><span class="n">c_lib</span><span class="o">.</span><span
class="n">CSchema</span> <span class="n">int32</span><span class="o">></span>
- <span class="o">-</span> <span class="nb">format</span><span
class="p">:</span> <span class="s1">'i'</span>
- <span class="o">-</span> <span class="n">name</span><span
class="p">:</span> <span class="s1">'some_column'</span>
- <span class="o">-</span> <span class="n">flags</span><span
class="p">:</span> <span class="mi">2</span>
- <span class="o">-</span> <span class="n">metadata</span><span
class="p">:</span> <span class="n">NULL</span>
- <span class="o">-</span> <span class="n">dictionary</span><span
class="p">:</span> <span class="n">NULL</span>
- <span class="o">-</span> <span class="n">children</span><span
class="p">[</span><span class="mi">0</span><span class="p">]:</span>
+<span class="o">-</span> <span class="n">get_schema</span><span
class="p">():</span> <span class="n">struct</span><span
class="o"><</span><span class="n">some_column</span><span class="p">:</span>
<span class="n">int32</span><span class="o">></span>
</pre></div>
</div>
<p>You can pull the next array from the stream using <code class="docutils
literal notranslate"><span class="pre">.get_next()</span></code> or use
@@ -576,7 +568,7 @@ it like an iterator. The <code class="docutils literal
notranslate"><span class=
<span class="nb">print</span><span class="p">(</span><span
class="n">array</span><span class="p">)</span>
</pre></div>
</div>
-<div class="highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="o"><</span><span
class="n">nanoarrow</span><span class="o">.</span><span
class="n">c_lib</span><span class="o">.</span><span class="n">CArray</span>
<span class="n">struct</span><span class="o">></span>
+<div class="highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="o"><</span><span
class="n">nanoarrow</span><span class="o">.</span><span
class="n">c_lib</span><span class="o">.</span><span class="n">CArray</span>
<span class="n">struct</span><span class="o"><</span><span
class="n">some_column</span><span class="p">:</span> <span
class="n">int32</span><span class="o">>></span>
<span class="o">-</span> <span class="n">length</span><span class="p">:</span>
<span class="mi">3</span>
<span class="o">-</span> <span class="n">offset</span><span class="p">:</span>
<span class="mi">0</span>
<span class="o">-</span> <span class="n">null_count</span><span
class="p">:</span> <span class="mi">0</span>
@@ -587,7 +579,7 @@ it like an iterator. The <code class="docutils literal
notranslate"><span class=
<span class="o">-</span> <span class="n">length</span><span
class="p">:</span> <span class="mi">3</span>
<span class="o">-</span> <span class="n">offset</span><span
class="p">:</span> <span class="mi">0</span>
<span class="o">-</span> <span class="n">null_count</span><span
class="p">:</span> <span class="mi">0</span>
- <span class="o">-</span> <span class="n">buffers</span><span
class="p">:</span> <span class="p">(</span><span class="mi">0</span><span
class="p">,</span> <span class="mi">2939033026688</span><span class="p">)</span>
+ <span class="o">-</span> <span class="n">buffers</span><span
class="p">:</span> <span class="p">(</span><span class="mi">0</span><span
class="p">,</span> <span class="mi">3678035837056</span><span class="p">)</span>
<span class="o">-</span> <span class="n">dictionary</span><span
class="p">:</span> <span class="n">NULL</span>
<span class="o">-</span> <span class="n">children</span><span
class="p">[</span><span class="mi">0</span><span class="p">]:</span>
</pre></div>
@@ -600,20 +592,7 @@ suitable exporting function:</p>
</pre></div>
</div>
<div class="highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="o"><</span><span
class="n">nanoarrow</span><span class="o">.</span><span
class="n">c_lib</span><span class="o">.</span><span
class="n">CArrayStream</span><span class="o">></span>
-<span class="o">-</span> <span class="n">get_schema</span><span
class="p">():</span> <span class="o"><</span><span
class="n">nanoarrow</span><span class="o">.</span><span
class="n">c_lib</span><span class="o">.</span><span class="n">CSchema</span>
<span class="n">struct</span><span class="o">></span>
- <span class="o">-</span> <span class="nb">format</span><span
class="p">:</span> <span class="s1">'+s'</span>
- <span class="o">-</span> <span class="n">name</span><span class="p">:</span>
<span class="s1">''</span>
- <span class="o">-</span> <span class="n">flags</span><span
class="p">:</span> <span class="mi">0</span>
- <span class="o">-</span> <span class="n">metadata</span><span
class="p">:</span> <span class="n">NULL</span>
- <span class="o">-</span> <span class="n">dictionary</span><span
class="p">:</span> <span class="n">NULL</span>
- <span class="o">-</span> <span class="n">children</span><span
class="p">[</span><span class="mi">1</span><span class="p">]:</span>
- <span class="s1">'some_column'</span><span class="p">:</span>
<span class="o"><</span><span class="n">nanoarrow</span><span
class="o">.</span><span class="n">c_lib</span><span class="o">.</span><span
class="n">CSchema</span> <span class="n">int32</span><span class="o">></span>
- <span class="o">-</span> <span class="nb">format</span><span
class="p">:</span> <span class="s1">'i'</span>
- <span class="o">-</span> <span class="n">name</span><span
class="p">:</span> <span class="s1">'some_column'</span>
- <span class="o">-</span> <span class="n">flags</span><span
class="p">:</span> <span class="mi">2</span>
- <span class="o">-</span> <span class="n">metadata</span><span
class="p">:</span> <span class="n">NULL</span>
- <span class="o">-</span> <span class="n">dictionary</span><span
class="p">:</span> <span class="n">NULL</span>
- <span class="o">-</span> <span class="n">children</span><span
class="p">[</span><span class="mi">0</span><span class="p">]:</span>
+<span class="o">-</span> <span class="n">get_schema</span><span
class="p">():</span> <span class="n">struct</span><span
class="o"><</span><span class="n">some_column</span><span class="p">:</span>
<span class="n">int32</span><span class="o">></span>
</pre></div>
</div>
</section>
diff --git a/main/objects.inv b/main/objects.inv
index 82fa7807..ebcc8492 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 e6923816..d3595e06 100644
--- a/main/r/pkgdown.yml
+++ b/main/r/pkgdown.yml
@@ -2,5 +2,5 @@ pandoc: 2.9.2.1
pkgdown: 2.0.7
pkgdown_sha: ~
articles: {}
-last_built: 2024-02-16T21:21Z
+last_built: 2024-02-19T19:03Z
diff --git a/main/reference/c.html b/main/reference/c.html
index 47bf18ef..b060b0e8 100644
--- a/main/reference/c.html
+++ b/main/reference/c.html
@@ -1623,8 +1623,8 @@ document.write(`
</dd></dl>
<dl class="cpp function">
-<dt class="sig sig-object cpp"
id="_CPPv422ArrowBufferDeallocatorPFvP20ArrowBufferAllocatorP7uint8_t7int64_tEPv">
-<span
id="_CPPv322ArrowBufferDeallocatorPFvP20ArrowBufferAllocatorP7uint8_t7int64_tEPv"></span><span
id="_CPPv222ArrowBufferDeallocatorPFvP20ArrowBufferAllocatorP7uint8_t7int64_tEPv"></span><span
class="target"
id="group__nanoarrow-malloc_1ga47bb3e6551ae911f2a7a084724617099"></span><span
class="k"><span class="pre">struct</span></span><span class="w"> </span><a
class="reference internal" href="#_CPPv420ArrowBufferAllocator"
title="ArrowBufferAllocator"><span class="n"><span class="pre">A [...]
+<dt class="sig sig-object cpp"
id="_CPPv422ArrowBufferDeallocator30ArrowBufferDeallocatorCallbackPv">
+<span
id="_CPPv322ArrowBufferDeallocator30ArrowBufferDeallocatorCallbackPv"></span><span
id="_CPPv222ArrowBufferDeallocator30ArrowBufferDeallocatorCallbackPv"></span><span
id="ArrowBufferDeallocator__ArrowBufferDeallocatorCallback.voidP"></span><span
class="target"
id="group__nanoarrow-malloc_1ga023a1cbc68e32fec004d078e38f2dba1"></span><span
class="k"><span class="pre">struct</span></span><span class="w"> </span><a
class="reference internal" href="#_CPPv420ArrowBufferAllocator" title="Ar [...]
<dd><p>Create a custom deallocator. </p>
<p>Creates a buffer allocator with only a free method that can be used to
attach a custom deallocator to an <a class="reference internal"
href="#struct_arrow_buffer"><span class="std std-ref">ArrowBuffer</span></a>.
This may be used to avoid copying an existing buffer that was not allocated
using the infrastructure provided here (e.g., by an R or Python object). </p>
</dd></dl>
@@ -2714,7 +2714,7 @@ document.write(`
<li class="toc-h3 nav-item toc-entry"><a class="reference internal nav-link"
href="#_CPPv412ArrowReallocPv7int64_t"><code class="docutils literal
notranslate"><span class="pre">ArrowRealloc()</span></code></a></li>
<li class="toc-h3 nav-item toc-entry"><a class="reference internal nav-link"
href="#_CPPv49ArrowFreePv"><code class="docutils literal notranslate"><span
class="pre">ArrowFree()</span></code></a></li>
<li class="toc-h3 nav-item toc-entry"><a class="reference internal nav-link"
href="#_CPPv427ArrowBufferAllocatorDefaultv"><code class="docutils literal
notranslate"><span
class="pre">ArrowBufferAllocatorDefault()</span></code></a></li>
-<li class="toc-h3 nav-item toc-entry"><a class="reference internal nav-link"
href="#_CPPv422ArrowBufferDeallocatorPFvP20ArrowBufferAllocatorP7uint8_t7int64_tEPv"><code
class="docutils literal notranslate"><span
class="pre">ArrowBufferDeallocator()</span></code></a></li>
+<li class="toc-h3 nav-item toc-entry"><a class="reference internal nav-link"
href="#_CPPv422ArrowBufferDeallocator30ArrowBufferDeallocatorCallbackPv"><code
class="docutils literal notranslate"><span
class="pre">ArrowBufferDeallocator()</span></code></a></li>
</ul>
</li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#error-handling">Error handling</a><ul class="visible nav section-nav
flex-column">
diff --git a/main/reference/index.html b/main/reference/index.html
index 83f5dc5a..34abed17 100644
--- a/main/reference/index.html
+++ b/main/reference/index.html
@@ -405,8 +405,10 @@ document.write(`
<li class="toctree-l2"><a class="reference internal"
href="python.html#nanoarrow.binary"><code class="docutils literal
notranslate"><span class="pre">binary()</span></code></a></li>
<li class="toctree-l2"><a class="reference internal"
href="python.html#nanoarrow.bool"><code class="docutils literal
notranslate"><span class="pre">bool()</span></code></a></li>
<li class="toctree-l2"><a class="reference internal"
href="python.html#nanoarrow.c_array"><code class="docutils literal
notranslate"><span class="pre">c_array()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal"
href="python.html#nanoarrow.c_array_from_buffers"><code class="docutils literal
notranslate"><span class="pre">c_array_from_buffers()</span></code></a></li>
<li class="toctree-l2"><a class="reference internal"
href="python.html#nanoarrow.c_array_stream"><code class="docutils literal
notranslate"><span class="pre">c_array_stream()</span></code></a></li>
<li class="toctree-l2"><a class="reference internal"
href="python.html#nanoarrow.c_array_view"><code class="docutils literal
notranslate"><span class="pre">c_array_view()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal"
href="python.html#nanoarrow.c_buffer"><code class="docutils literal
notranslate"><span class="pre">c_buffer()</span></code></a></li>
<li class="toctree-l2"><a class="reference internal"
href="python.html#nanoarrow.c_schema"><code class="docutils literal
notranslate"><span class="pre">c_schema()</span></code></a></li>
<li class="toctree-l2"><a class="reference internal"
href="python.html#nanoarrow.c_schema_view"><code class="docutils literal
notranslate"><span class="pre">c_schema_view()</span></code></a></li>
<li class="toctree-l2"><a class="reference internal"
href="python.html#nanoarrow.c_version"><code class="docutils literal
notranslate"><span class="pre">c_version()</span></code></a></li>
diff --git a/main/reference/python.html b/main/reference/python.html
index 837f5875..f17e1b0f 100644
--- a/main/reference/python.html
+++ b/main/reference/python.html
@@ -570,7 +570,7 @@ categories can be identified. Type values can be used in
place of
<dl class="py function">
<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">requested_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><a
class="headerlink" href="#nanoarrow.allocate_c_array" title="Link to this
definition">#</a></dt>
+<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="examples">
<h2>Examples<a class="headerlink" href="#examples" title="Link to this
heading">#</a></h2>
@@ -585,7 +585,7 @@ categories can be identified. Type values can be used in
place of
<dl class="py function">
<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><a class="headerlink"
href="#nanoarrow.allocate_c_array_stream" title="Link to this
definition">#</a></dt>
+<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="id1">
<h2>Examples<a class="headerlink" href="#id1" title="Link to this
heading">#</a></h2>
@@ -603,7 +603,7 @@ categories can be identified. Type values can be used in
place of
<dl class="py function">
<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><a class="headerlink"
href="#nanoarrow.allocate_c_schema" title="Link to this definition">#</a></dt>
+<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="id2">
<h2>Examples<a class="headerlink" href="#id2" title="Link to this
heading">#</a></h2>
@@ -660,29 +660,112 @@ categories can be identified. Type values can be used in
place of
<dl class="py function">
<dt class="sig sig-object py" id="nanoarrow.c_array">
-<span class="sig-name descname"><span class="pre">c_array</span></span><span
class="sig-paren">(</span><em class="sig-param"><span class="n"><span
class="pre">obj</span></span><span class="o"><span
class="pre">=</span></span><span class="default_value"><span
class="pre">None</span></span></em>, <em class="sig-param"><span
class="n"><span class="pre">requested_schema</span></span><span class="o"><span
class="pre">=</span></span><span class="default_value"><span
class="pre">None</span></sp [...]
+<span class="sig-name descname"><span class="pre">c_array</span></span><span
class="sig-paren">(</span><em class="sig-param"><span class="n"><span
class="pre">obj</span></span></em>, <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
[...]
<dd><p>ArrowArray wrapper</p>
<p>This class provides a user-facing interface to access the fields of an
ArrowArray
as defined in the Arrow C Data interface, holding an optional reference to a
<code class="xref py py-class docutils literal notranslate"><span
class="pre">CSchema</span></code> that can be used to safely deserialize the
content.</p>
<p>These objects are created using <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>, which accepts any array-like
-object according to the Arrow PyCapsule interface.</p>
+object according to the Arrow PyCapsule interface, Python buffer protocol,
+or iterable of Python objects.</p>
<p>This Python wrapper allows access to array fields but does not automatically
deserialize their content: use <a class="reference internal"
href="#nanoarrow.c_array_view" title="nanoarrow.c_array_view"><code class="xref
py py-func docutils literal notranslate"><span
class="pre">c_array_view()</span></code></a> to validate 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">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">ArrowSchema</span></code> to avoid copies while inspecting an
+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="id6">
-<h2>Examples<a class="headerlink" href="#id6" 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>
+<h2>Parameters<a class="headerlink" href="#id6" 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>
+</dd>
+<dt>schema<span class="classifier">schema-like or None</span></dt><dd><p>A
schema-like object 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> or None. This value
+will be used to request a data type from <code class="docutils literal
notranslate"><span class="pre">obj</span></code>; however, the conversion
+is best-effort (i.e., the data type of the returned <code class="docutils
literal notranslate"><span class="pre">CArray</span></code> may be
+different than <code class="docutils literal notranslate"><span
class="pre">schema</span></code>).</p>
+</dd>
+</dl>
+</section>
+<section id="id7">
+<h2>Examples<a class="headerlink" href="#id7" 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>
+<span class="gp">>>> </span><span class="c1"># Create from Python
buffer (e.g., numpy array)</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>
-<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="n">pa</span><span
class="o">.</span><span class="n">array</span><span class="p">([</span><span
class="s2">"one"</span><span class="p">,</span> <span
class="s2">"two"</span><span class="p">,</span> <span
class="s2">"three"</span><span class="p">,</span> <s [...]
+<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="n">np</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="gp">>>> </span><span class="c1"># Create from Arrow
PyCapsule (e.g., pyarrow array)</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">array</span> <span
class="o">=</span> <span class="n">na</span><span class="o">.</span><span
class="n">c_array</span><span class="p">(</span><span class="n">pa</span><span
class="o">.</span><span class="n">array</span><span class="p">([</span><span
class="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="gp">>>> </span><span class="c1"># Access array
fields</span>
<span class="gp">>>> </span><span class="n">array</span><span
class="o">.</span><span class="n">length</span>
-<span class="go">4</span>
+<span class="go">3</span>
<span class="gp">>>> </span><span class="n">array</span><span
class="o">.</span><span class="n">null_count</span>
-<span class="go">1</span>
+<span class="go">0</span>
+</pre></div>
+</div>
+</section>
+</dd></dl>
+
+<dl class="py function">
+<dt class="sig sig-object py" id="nanoarrow.c_array_from_buffers">
+<span class="sig-name descname"><span
class="pre">c_array_from_buffers</span></span><span
class="sig-paren">(</span><em class="sig-param"><span class="n"><span
class="pre">schema</span></span></em>, <em class="sig-param"><span
class="n"><span class="pre">length</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">buffers</span></span><span cla [...]
+<dd><p>Create an ArrowArray wrapper from components</p>
+<p>Given a schema, build an ArrowArray buffer-wise. This allows almost any
array
+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="id8">
+<h2>Parameters<a class="headerlink" href="#id8" 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>
+<dt>length<span class="classifier">int</span></dt><dd><p>The length of the
output array.</p>
+</dd>
+<dt>buffers<span class="classifier">Iterable of buffer-like or
None</span></dt><dd><p>An iterable of buffers as sanitized by <a
class="reference internal" href="#nanoarrow.c_buffer"
title="nanoarrow.c_buffer"><code class="xref py py-func docutils literal
notranslate"><span class="pre">c_buffer()</span></code></a>. Any object
+supporting the Python Buffer protocol is accepted. Buffer data types
+are not checked. A buffer value of <code class="docutils literal
notranslate"><span class="pre">None</span></code> will skip setting a buffer
+(i.e., that buffer will be of length zero and its pointer will
+be <code class="docutils literal notranslate"><span
class="pre">NULL</span></code>).</p>
+</dd>
+<dt>null_count<span class="classifier">int, optional</span></dt><dd><p>The
number of null values, if known in advance. If -1 (the default),
+the null count will be calculated based on the validity bitmap. If
+the validity bitmap was set to <code class="docutils literal
notranslate"><span class="pre">None</span></code>, the calculated null count
+will be zero.</p>
+</dd>
+<dt>offset<span class="classifier">int, optional</span></dt><dd><p>The logical
offset from the start of the array.</p>
+</dd>
+<dt>children<span class="classifier">Iterable of
array-like</span></dt><dd><p>An iterable of arrays used to set child fields of
the array. Can contain
+any object accepted by <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>. Must contain the
exact number of
+required children as specifed by <code class="docutils literal
notranslate"><span class="pre">schema</span></code>.</p>
+</dd>
+<dt>validation_level: None or str, optional</dt><dd><p>One of “none” (no
check), “minimal” (check buffer sizes that do not require
+dereferencing buffer content), “default” (check all buffer sizes), or “full”
+(check all buffer sizes and all buffer content). The default, <code
class="docutils literal notranslate"><span class="pre">None</span></code>,
+will validate at the “default” level where possible.</p>
+</dd>
+<dt>move<span class="classifier">bool, optional</span></dt><dd><p>Use <code
class="docutils literal notranslate"><span class="pre">True</span></code> to
move ownership of any input buffers or children to the
+output array.</p>
+</dd>
+</dl>
+</section>
+<section id="id9">
+<h2>Examples<a class="headerlink" href="#id9" 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>
+<span class="go"><nanoarrow.c_lib.CArrayView></span>
+<span class="go">- storage_type: 'uint8'</span>
+<span class="go">- length: 5</span>
+<span class="go">- offset: 0</span>
+<span class="go">- null_count: 0</span>
+<span class="go">- buffers[2]:</span>
+<span class="go"> - validity <bool[0 b] ></span>
+<span class="go"> - data <uint8[5 b] 49 50 51 52 53></span>
+<span class="go">- dictionary: NULL</span>
+<span class="go">- children[0]:</span>
</pre></div>
</div>
</section>
@@ -690,13 +773,13 @@ imported structure.</p>
<dl class="py function">
<dt class="sig sig-object py" id="nanoarrow.c_array_stream">
-<span class="sig-name descname"><span
class="pre">c_array_stream</span></span><span class="sig-paren">(</span><em
class="sig-param"><span class="n"><span class="pre">obj</span></span><span
class="o"><span class="pre">=</span></span><span class="default_value"><span
class="pre">None</span></span></em>, <em class="sig-param"><span
class="n"><span class="pre">requested_schema</span></span><span class="o"><span
class="pre">=</span></span><span class="default_value"><span
class="pre">None</sp [...]
+<span class="sig-name descname"><span
class="pre">c_array_stream</span></span><span class="sig-paren">(</span><em
class="sig-param"><span class="n"><span class="pre">obj</span></span><span
class="o"><span class="pre">=</span></span><span class="default_value"><span
class="pre">None</span></span></em>, <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> [...]
<dd><p>ArrowArrayStream wrapper</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="id7">
-<h2>Examples<a class="headerlink" href="#id7" title="Link to this
heading">#</a></h2>
+<section id="id10">
+<h2>Examples<a class="headerlink" href="#id10" 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>
@@ -731,7 +814,7 @@ These objects are usually created using
<cite>nanoarrow.c_array_stream()</cite>.
<dl class="py function">
<dt class="sig sig-object py" id="nanoarrow.c_array_view">
-<span class="sig-name descname"><span
class="pre">c_array_view</span></span><span class="sig-paren">(</span><em
class="sig-param"><span class="n"><span class="pre">obj</span></span></em>, <em
class="sig-param"><span class="n"><span
class="pre">requested_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">→</sp [...]
+<span class="sig-name descname"><span
class="pre">c_array_view</span></span><span class="sig-paren">(</span><em
class="sig-param"><span class="n"><span class="pre">obj</span></span></em>, <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 [...]
<dd><p>ArrowArrayView wrapper</p>
<p>The <code class="docutils literal notranslate"><span
class="pre">ArrowArrayView</span></code> is a nanoarrow C library structure
that provides
structured access to buffers addresses, buffer sizes, and buffer
@@ -739,8 +822,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="id8">
-<h2>Examples<a class="headerlink" href="#id8" title="Link to this
heading">#</a></h2>
+<section id="id11">
+<h2>Examples<a class="headerlink" href="#id11" 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>
@@ -756,6 +839,47 @@ IPC). The offset and length of this view are independent
of its parent
</section>
</dd></dl>
+<dl class="py function">
+<dt class="sig sig-object py" id="nanoarrow.c_buffer">
+<span class="sig-name descname"><span class="pre">c_buffer</span></span><span
class="sig-paren">(</span><em class="sig-param"><span class="n"><span
class="pre">obj</span></span></em>, <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 clas
[...]
+<dd><p>Owning, read-only ArrowBuffer wrapper</p>
+<p>If obj implements the Python buffer protocol, <code class="docutils literal
notranslate"><span class="pre">c_buffer()</span></code> wraps
+obj in nanoarrow’s owning buffer structure, the ArrowBuffer,
+such that it can be used to construct arrays. The ownership of the
+underlying buffer is handled by the Python buffer protocol
+(i.e., <code class="docutils literal notranslate"><span
class="pre">PyObject_GetBuffer()</span></code> and <code class="docutils
literal notranslate"><span class="pre">PyBuffer_Release()</span></code>).</p>
+<p>If obj is iterable, a buffer will be allocated and populated with
+the contents of obj according to <code class="docutils literal
notranslate"><span class="pre">schema</span></code>. The
+<code class="docutils literal notranslate"><span
class="pre">schema</span></code> parameter is required to create a buffer from
+a Python iterable. The <code class="docutils literal notranslate"><span
class="pre">struct</span></code> module is currently used to encode
+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="id12">
+<h2>Parameters<a class="headerlink" href="#id12" 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>
+</dd>
+<dt>schema<span class="classifier">schema-like, optional</span></dt><dd><p>The
data type of the desired buffer 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>. Only values that
make sense as buffer types are
+allowed (e.g., integer types, floating-point types, interval types,
+decimal types, binary, string, fixed-size binary).</p>
+</dd>
+</dl>
+</section>
+<section id="id13">
+<h2>Examples<a class="headerlink" href="#id13" 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">CBuffer(uint8[4 b] 49 50 51 52)</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="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">CBuffer(int32[12 b] 1 2 3)</span>
+</pre></div>
+</div>
+</section>
+</dd></dl>
+
<dl class="py function">
<dt class="sig sig-object py" id="nanoarrow.c_schema">
<span class="sig-name descname"><span class="pre">c_schema</span></span><span
class="sig-paren">(</span><em class="sig-param"><span class="n"><span
class="pre">obj</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">CSchema</span></span></span><a
class="hea [...]
@@ -770,8 +894,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="id9">
-<h2>Examples<a class="headerlink" href="#id9" title="Link to this
heading">#</a></h2>
+<section id="id14">
+<h2>Examples<a class="headerlink" href="#id14" 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>
@@ -793,8 +917,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="id10">
-<h2>Examples<a class="headerlink" href="#id10" title="Link to this
heading">#</a></h2>
+<section id="id15">
+<h2>Examples<a class="headerlink" href="#id15" 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>
@@ -822,15 +946,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="id11">
-<h2>Parameters<a class="headerlink" href="#id11" title="Link to this
heading">#</a></h2>
+<section id="id16">
+<h2>Parameters<a class="headerlink" href="#id16" 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="id12">
-<h2>Examples<a class="headerlink" href="#id12" title="Link to this
heading">#</a></h2>
+<section id="id17">
+<h2>Examples<a class="headerlink" href="#id17" 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>
@@ -843,15 +967,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="id13">
-<h2>Parameters<a class="headerlink" href="#id13" title="Link to this
heading">#</a></h2>
+<section id="id18">
+<h2>Parameters<a class="headerlink" href="#id18" 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="id14">
-<h2>Examples<a class="headerlink" href="#id14" title="Link to this
heading">#</a></h2>
+<section id="id19">
+<h2>Examples<a class="headerlink" href="#id19" 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>
@@ -864,8 +988,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="id15">
-<h2>Parameters<a class="headerlink" href="#id15" title="Link to this
heading">#</a></h2>
+<section id="id20">
+<h2>Parameters<a class="headerlink" href="#id20" 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>
@@ -876,8 +1000,8 @@ between 1 and 38.</p>
</dd>
</dl>
</section>
-<section id="id16">
-<h2>Examples<a class="headerlink" href="#id16" 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">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>
@@ -890,8 +1014,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="id17">
-<h2>Parameters<a class="headerlink" href="#id17" title="Link to this
heading">#</a></h2>
+<section id="id22">
+<h2>Parameters<a class="headerlink" href="#id22" 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>
@@ -902,8 +1026,8 @@ between 1 and 76.</p>
</dd>
</dl>
</section>
-<section id="id18">
-<h2>Examples<a class="headerlink" href="#id18" title="Link to this
heading">#</a></h2>
+<section id="id23">
+<h2>Examples<a class="headerlink" href="#id23" 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>
@@ -916,8 +1040,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="id19">
-<h2>Parameters<a class="headerlink" href="#id19" title="Link to this
heading">#</a></h2>
+<section id="id24">
+<h2>Parameters<a class="headerlink" href="#id24" 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>
@@ -925,8 +1049,8 @@ between 1 and 76.</p>
</dd>
</dl>
</section>
-<section id="id20">
-<h2>Examples<a class="headerlink" href="#id20" title="Link to this
heading">#</a></h2>
+<section id="id25">
+<h2>Examples<a class="headerlink" href="#id25" 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>
@@ -939,8 +1063,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="id21">
-<h2>Parameters<a class="headerlink" href="#id21" title="Link to this
heading">#</a></h2>
+<section id="id26">
+<h2>Parameters<a class="headerlink" href="#id26" 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>
@@ -948,8 +1072,8 @@ between 1 and 76.</p>
</dd>
</dl>
</section>
-<section id="id22">
-<h2>Examples<a class="headerlink" href="#id22" title="Link to this
heading">#</a></h2>
+<section id="id27">
+<h2>Examples<a class="headerlink" href="#id27" 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>
@@ -962,15 +1086,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="id23">
-<h2>Parameters<a class="headerlink" href="#id23" title="Link to this
heading">#</a></h2>
+<section id="id28">
+<h2>Parameters<a class="headerlink" href="#id28" 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="id24">
-<h2>Examples<a class="headerlink" href="#id24" title="Link to this
heading">#</a></h2>
+<section id="id29">
+<h2>Examples<a class="headerlink" href="#id29" 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>
@@ -983,15 +1107,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="id25">
-<h2>Parameters<a class="headerlink" href="#id25" title="Link to this
heading">#</a></h2>
+<section id="id30">
+<h2>Parameters<a class="headerlink" href="#id30" 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="id26">
-<h2>Examples<a class="headerlink" href="#id26" title="Link to this
heading">#</a></h2>
+<section id="id31">
+<h2>Examples<a class="headerlink" href="#id31" 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>
@@ -1004,15 +1128,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="id27">
-<h2>Parameters<a class="headerlink" href="#id27" title="Link to this
heading">#</a></h2>
+<section id="id32">
+<h2>Parameters<a class="headerlink" href="#id32" 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="id28">
-<h2>Examples<a class="headerlink" href="#id28" title="Link to this
heading">#</a></h2>
+<section id="id33">
+<h2>Examples<a class="headerlink" href="#id33" 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>
@@ -1025,15 +1149,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="id29">
-<h2>Parameters<a class="headerlink" href="#id29" title="Link to this
heading">#</a></h2>
+<section id="id34">
+<h2>Parameters<a class="headerlink" href="#id34" 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="id30">
-<h2>Examples<a class="headerlink" href="#id30" 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">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>
@@ -1046,15 +1170,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="id31">
-<h2>Parameters<a class="headerlink" href="#id31" title="Link to this
heading">#</a></h2>
+<section id="id36">
+<h2>Parameters<a class="headerlink" href="#id36" 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="id32">
-<h2>Examples<a class="headerlink" href="#id32" title="Link to this
heading">#</a></h2>
+<section id="id37">
+<h2>Examples<a class="headerlink" href="#id37" 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>
@@ -1067,15 +1191,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="id33">
-<h2>Parameters<a class="headerlink" href="#id33" title="Link to this
heading">#</a></h2>
+<section id="id38">
+<h2>Parameters<a class="headerlink" href="#id38" 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="id34">
-<h2>Examples<a class="headerlink" href="#id34" 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">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>
@@ -1088,15 +1212,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="id35">
-<h2>Parameters<a class="headerlink" href="#id35" title="Link to this
heading">#</a></h2>
+<section id="id40">
+<h2>Parameters<a class="headerlink" href="#id40" 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="id36">
-<h2>Examples<a class="headerlink" href="#id36" title="Link to this
heading">#</a></h2>
+<section id="id41">
+<h2>Examples<a class="headerlink" href="#id41" 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>
@@ -1109,15 +1233,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="id37">
-<h2>Parameters<a class="headerlink" href="#id37" title="Link to this
heading">#</a></h2>
+<section id="id42">
+<h2>Parameters<a class="headerlink" href="#id42" 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="id38">
-<h2>Examples<a class="headerlink" href="#id38" title="Link to this
heading">#</a></h2>
+<section id="id43">
+<h2>Examples<a class="headerlink" href="#id43" 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>
@@ -1131,15 +1255,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="id39">
-<h2>Parameters<a class="headerlink" href="#id39" title="Link to this
heading">#</a></h2>
+<section id="id44">
+<h2>Parameters<a class="headerlink" href="#id44" 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="id40">
-<h2>Examples<a class="headerlink" href="#id40" title="Link to this
heading">#</a></h2>
+<section id="id45">
+<h2>Examples<a class="headerlink" href="#id45" 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>
@@ -1152,15 +1276,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="id41">
-<h2>Parameters<a class="headerlink" href="#id41" title="Link to this
heading">#</a></h2>
+<section id="id46">
+<h2>Parameters<a class="headerlink" href="#id46" 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="id42">
-<h2>Examples<a class="headerlink" href="#id42" title="Link to this
heading">#</a></h2>
+<section id="id47">
+<h2>Examples<a class="headerlink" href="#id47" 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>
@@ -1173,15 +1297,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="id43">
-<h2>Parameters<a class="headerlink" href="#id43" title="Link to this
heading">#</a></h2>
+<section id="id48">
+<h2>Parameters<a class="headerlink" href="#id48" 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="id44">
-<h2>Examples<a class="headerlink" href="#id44" title="Link to this
heading">#</a></h2>
+<section id="id49">
+<h2>Examples<a class="headerlink" href="#id49" 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>
@@ -1195,15 +1319,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="id45">
-<h2>Parameters<a class="headerlink" href="#id45" title="Link to this
heading">#</a></h2>
+<section id="id50">
+<h2>Parameters<a class="headerlink" href="#id50" 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="id46">
-<h2>Examples<a class="headerlink" href="#id46" title="Link to this
heading">#</a></h2>
+<section id="id51">
+<h2>Examples<a class="headerlink" href="#id51" 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>
@@ -1216,15 +1340,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="id47">
-<h2>Parameters<a class="headerlink" href="#id47" title="Link to this
heading">#</a></h2>
+<section id="id52">
+<h2>Parameters<a class="headerlink" href="#id52" 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="id48">
-<h2>Examples<a class="headerlink" href="#id48" title="Link to this
heading">#</a></h2>
+<section id="id53">
+<h2>Examples<a class="headerlink" href="#id53" 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>
@@ -1240,8 +1364,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="id49">
-<h2>Parameters<a class="headerlink" href="#id49" title="Link to this
heading">#</a></h2>
+<section id="id54">
+<h2>Parameters<a class="headerlink" href="#id54" 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:
@@ -1259,8 +1383,8 @@ the nullability is preserved from the passed object).</p>
</dd>
</dl>
</section>
-<section id="id50">
-<h2>Examples<a class="headerlink" href="#id50" title="Link to this
heading">#</a></h2>
+<section id="id55">
+<h2>Examples<a class="headerlink" href="#id55" 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>
@@ -1278,15 +1402,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="id51">
-<h2>Parameters<a class="headerlink" href="#id51" title="Link to this
heading">#</a></h2>
+<section id="id56">
+<h2>Parameters<a class="headerlink" href="#id56" 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="id52">
-<h2>Examples<a class="headerlink" href="#id52" title="Link to this
heading">#</a></h2>
+<section id="id57">
+<h2>Examples<a class="headerlink" href="#id57" 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>
@@ -1299,8 +1423,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="id53">
-<h2>Parameters<a class="headerlink" href="#id53" title="Link to this
heading">#</a></h2>
+<section id="id58">
+<h2>Parameters<a class="headerlink" href="#id58" 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>
@@ -1313,8 +1437,8 @@ from the tuple, the field name is inherited from the
schema-like object.</p></li
</dd>
</dl>
</section>
-<section id="id54">
-<h2>Examples<a class="headerlink" href="#id54" title="Link to this
heading">#</a></h2>
+<section id="id59">
+<h2>Examples<a class="headerlink" href="#id59" 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>
@@ -1331,8 +1455,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="id55">
-<h2>Parameters<a class="headerlink" href="#id55" title="Link to this
heading">#</a></h2>
+<section id="id60">
+<h2>Parameters<a class="headerlink" href="#id60" 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>
@@ -1340,8 +1464,8 @@ from the tuple, the field name is inherited from the
schema-like object.</p></li
</dd>
</dl>
</section>
-<section id="id56">
-<h2>Examples<a class="headerlink" href="#id56" title="Link to this
heading">#</a></h2>
+<section id="id61">
+<h2>Examples<a class="headerlink" href="#id61" 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>
@@ -1354,8 +1478,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="id57">
-<h2>Parameters<a class="headerlink" href="#id57" title="Link to this
heading">#</a></h2>
+<section id="id62">
+<h2>Parameters<a class="headerlink" href="#id62" 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>
@@ -1363,8 +1487,8 @@ from the tuple, the field name is inherited from the
schema-like object.</p></li
</dd>
</dl>
</section>
-<section id="id58">
-<h2>Examples<a class="headerlink" href="#id58" title="Link to this
heading">#</a></h2>
+<section id="id63">
+<h2>Examples<a class="headerlink" href="#id63" 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>
@@ -1377,8 +1501,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="id59">
-<h2>Parameters<a class="headerlink" href="#id59" title="Link to this
heading">#</a></h2>
+<section id="id64">
+<h2>Parameters<a class="headerlink" href="#id64" 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>
@@ -1386,8 +1510,8 @@ from the tuple, the field name is inherited from the
schema-like object.</p></li
</dd>
</dl>
</section>
-<section id="id60">
-<h2>Examples<a class="headerlink" href="#id60" title="Link to this
heading">#</a></h2>
+<section id="id65">
+<h2>Examples<a class="headerlink" href="#id65" 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>
@@ -1402,15 +1526,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="id61">
-<h2>Parameters<a class="headerlink" href="#id61" title="Link to this
heading">#</a></h2>
+<section id="id66">
+<h2>Parameters<a class="headerlink" href="#id66" 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="id62">
-<h2>Examples<a class="headerlink" href="#id62" title="Link to this
heading">#</a></h2>
+<section id="id67">
+<h2>Examples<a class="headerlink" href="#id67" 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>
@@ -1423,15 +1547,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="id63">
-<h2>Parameters<a class="headerlink" href="#id63" title="Link to this
heading">#</a></h2>
+<section id="id68">
+<h2>Parameters<a class="headerlink" href="#id68" 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="id64">
-<h2>Examples<a class="headerlink" href="#id64" title="Link to this
heading">#</a></h2>
+<section id="id69">
+<h2>Examples<a class="headerlink" href="#id69" 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>
@@ -1444,15 +1568,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="id65">
-<h2>Parameters<a class="headerlink" href="#id65" title="Link to this
heading">#</a></h2>
+<section id="id70">
+<h2>Parameters<a class="headerlink" href="#id70" 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="id66">
-<h2>Examples<a class="headerlink" href="#id66" title="Link to this
heading">#</a></h2>
+<section id="id71">
+<h2>Examples<a class="headerlink" href="#id71" 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>
@@ -1465,15 +1589,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="id67">
-<h2>Parameters<a class="headerlink" href="#id67" title="Link to this
heading">#</a></h2>
+<section id="id72">
+<h2>Parameters<a class="headerlink" href="#id72" 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="id68">
-<h2>Examples<a class="headerlink" href="#id68" title="Link to this
heading">#</a></h2>
+<section id="id73">
+<h2>Examples<a class="headerlink" href="#id73" 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>
@@ -1555,8 +1679,10 @@ from the tuple, the field name is inherited from the
schema-like object.</p></li
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#nanoarrow.binary"><code class="docutils literal notranslate"><span
class="pre">binary()</span></code></a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#nanoarrow.bool"><code class="docutils literal notranslate"><span
class="pre">bool()</span></code></a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#nanoarrow.c_array"><code class="docutils literal notranslate"><span
class="pre">c_array()</span></code></a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#nanoarrow.c_array_from_buffers"><code class="docutils literal
notranslate"><span class="pre">c_array_from_buffers()</span></code></a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#nanoarrow.c_array_stream"><code class="docutils literal
notranslate"><span class="pre">c_array_stream()</span></code></a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#nanoarrow.c_array_view"><code class="docutils literal notranslate"><span
class="pre">c_array_view()</span></code></a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#nanoarrow.c_buffer"><code class="docutils literal notranslate"><span
class="pre">c_buffer()</span></code></a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#nanoarrow.c_schema"><code class="docutils literal notranslate"><span
class="pre">c_schema()</span></code></a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#nanoarrow.c_schema_view"><code class="docutils literal
notranslate"><span class="pre">c_schema_view()</span></code></a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#nanoarrow.c_version"><code class="docutils literal notranslate"><span
class="pre">c_version()</span></code></a></li>
diff --git a/main/searchindex.js b/main/searchindex.js
index dc5a9c82..5cbdd3c4 100644
--- a/main/searchindex.js
+++ b/main/searchindex.js
@@ -1 +1 @@
-Search.setIndex({"docnames": ["getting-started/cpp", "getting-started/index",
"getting-started/python", "getting-started/r", "index", "reference/c",
"reference/cpp", "reference/device", "reference/index", "reference/ipc",
"reference/python", "reference/r", "reference/testing", "roadmap"],
"filenames": ["getting-started/cpp.rst", "getting-started/index.rst",
"getting-started/python.rst", "getting-started/r.rst", "index.rst",
"reference/c.rst", "reference/cpp.rst", "reference/device.rst", [...]
\ No newline at end of file
+Search.setIndex({"docnames": ["getting-started/cpp", "getting-started/index",
"getting-started/python", "getting-started/r", "index", "reference/c",
"reference/cpp", "reference/device", "reference/index", "reference/ipc",
"reference/python", "reference/r", "reference/testing", "roadmap"],
"filenames": ["getting-started/cpp.rst", "getting-started/index.rst",
"getting-started/python.rst", "getting-started/r.rst", "index.rst",
"reference/c.rst", "reference/cpp.rst", "reference/device.rst", [...]
\ No newline at end of file
