arrowbricks 3.2.0__tar.gz → 5.0.0__tar.gz

{arrowbricks-3.2.0 → arrowbricks-5.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arrowbricks
-Version: 3.2.0
+Version: 5.0.0
 Requires-Dist: arro3-core>=0.8 ; extra == 'arro3'
 Provides-Extra: arro3
 License-File: LICENSE
@@ -212,6 +212,15 @@ except ArrowbricksError:
 
 ## Arrow vs. row-tuple fetches
 
+From 4.0, Arrow fetches and `ReplayableArrowChunk.to_table()` return
+`arrowbricks._core.Table`. It exposes `num_rows`, `num_columns`,
+`column_names`, `len(table)` and the Arrow capsule interfaces. For methods
+such as `.column()`, `.schema` or `.to_batches()`, first convert with
+`arro3.core.Table.from_arrow(table)`, `pyarrow.table(table)` or
+`polars.from_arrow(table)`. DuckDB can consume it directly.
+`write_ipc_stream` requires `__arrow_c_stream__`; wrap an array-only producer
+in a table before passing it in.
+
 Everything above works with zero dependencies installed *except* row-tuple fetches. `fetchall_arrow`/`fetchmany_arrow` return an Arrow table straight from the Rust core -- the faster path if your code can consume Arrow directly (DuckDB, pyarrow, polars, a Parquet writer, ...):
 
 ```python

{arrowbricks-3.2.0 → arrowbricks-5.0.0}/README.md

@@ -200,6 +200,15 @@ except ArrowbricksError:
 
 ## Arrow vs. row-tuple fetches
 
+From 4.0, Arrow fetches and `ReplayableArrowChunk.to_table()` return
+`arrowbricks._core.Table`. It exposes `num_rows`, `num_columns`,
+`column_names`, `len(table)` and the Arrow capsule interfaces. For methods
+such as `.column()`, `.schema` or `.to_batches()`, first convert with
+`arro3.core.Table.from_arrow(table)`, `pyarrow.table(table)` or
+`polars.from_arrow(table)`. DuckDB can consume it directly.
+`write_ipc_stream` requires `__arrow_c_stream__`; wrap an array-only producer
+in a table before passing it in.
+
 Everything above works with zero dependencies installed *except* row-tuple fetches. `fetchall_arrow`/`fetchmany_arrow` return an Arrow table straight from the Rust core -- the faster path if your code can consume Arrow directly (DuckDB, pyarrow, polars, a Parquet writer, ...):
 
 ```python

{arrowbricks-3.2.0 → arrowbricks-5.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "arrowbricks"
-version = "3.2.0"
+version = "5.0.0"
 description = "Runs SQL against a Databricks SQL warehouse via the Statement Execution API and hands you the result as Arrow -- a DB-API-ish Cursor (fetchone/fetchmany/fetchall/fetchall_arrow) or NDJSON streaming. Rust/PyO3 core throughout -- zero required runtime dependencies."
 readme = "README.md"
 license = "MIT"
@@ -15,12 +15,8 @@ requires-python = ">=3.11"
 dependencies = []
 
 [project.optional-dependencies]
-# pyo3-arrow's own Table.column()/schema methods are designed to hand back
-# the caller's *real* arro3.core objects for further arro3-ecosystem
-# interop (not a value pyo3-arrow can materialize itself), so
-# fetchone/fetchmany/fetchall need this installed. `pip install
-# arrowbricks[arro3]` -- or handle rows as Arrow via fetchall_arrow/
-# fetchmany_arrow instead, which don't need it at all.
+# Row materialization converts our capsule table through arro3-core.
+# Arrow fetches and streaming do not need this optional dependency.
 arro3 = ["arro3-core>=0.8"]
 
 [project.urls]
@@ -80,6 +76,7 @@ dev = [
 
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
 # Bare `pytest`/`pytest -q` (no explicit path) covers tests/ -- including
 # tests/arro3_free (nested here on purpose; see its own conftest.py for why
 # that doesn't pull arro3 into its collection) -- but NOT

{arrowbricks-3.2.0 → arrowbricks-5.0.0}/rust/arrowbricks_core/Cargo.lock

@@ -81,7 +81,6 @@ dependencies = [
  "atoi",
  "base64 0.23.1",
  "chrono",
- "comfy-table",
  "half",
  "lexical-core",
  "num-traits",
@@ -178,7 +177,7 @@ dependencies = [
 
 [[package]]
 name = "arrowbricks_core"
-version = "3.2.0"
+version = "5.0.0"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -193,7 +192,6 @@ dependencies = [
  "memchr",
  "proptest",
  "pyo3",
- "pyo3-arrow",
  "pyo3-async-runtimes",
  "pythonize",
  "reqwest",
@@ -303,9 +301,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1aa79e62e7697b8e29b513a68abacf485adcd1fe8284a4316c5ae868e6633327"
 dependencies = [
  "iana-time-zone",
- "js-sys",
  "num-traits",
- "wasm-bindgen",
  "windows-link",
 ]
 
@@ -329,16 +325,6 @@ dependencies = [
  "memchr",
 ]
 
-[[package]]
-name = "comfy-table"
-version = "7.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "958c5d6ecf1f214b4c2bbbbf6ab9523a864bd136dcf71a7e8904799acfe1ad47"
-dependencies = [
- "unicode-segmentation",
- "unicode-width",
-]
-
 [[package]]
 name = "const-random"
 version = "0.1.18"
@@ -889,7 +875,7 @@ dependencies = [
  "jni-sys",
  "log",
  "simd_cesu8",
- "thiserror 2.0.20",
+ "thiserror",
  "walkdir",
  "windows-link",
 ]
@@ -1039,16 +1025,6 @@ dependencies = [
  "twox-hash",
 ]
 
-[[package]]
-name = "matrixmultiply"
-version = "0.3.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f607c237553f086e7043417a51df26b2eb899d3caff94e6a67592ff992fedc7"
-dependencies = [
- "autocfg",
- "rawpointer",
-]
-
 [[package]]
 name = "memchr"
 version = "2.8.3"
@@ -1066,21 +1042,6 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
-[[package]]
-name = "ndarray"
-version = "0.17.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "520080814a7a6b4a6e9070823bb24b4531daac8c4627e08ba5de8c5ef2f2752d"
-dependencies = [
- "matrixmultiply",
- "num-complex",
- "num-integer",
- "num-traits",
- "portable-atomic",
- "portable-atomic-util",
- "rawpointer",
-]
-
 [[package]]
 name = "num-bigint"
 version = "0.5.1"
@@ -1129,23 +1090,6 @@ dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "numpy"
-version = "0.29.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a5b15d63a5ff39e378daed0e1340d3a5964703ea9712eb09a0dc66fade996f4"
-dependencies = [
- "half",
- "libc",
- "ndarray",
- "num-complex",
- "num-integer",
- "num-traits",
- "pyo3",
- "pyo3-build-config",
- "rustc-hash",
-]
-
 [[package]]
 name = "once_cell"
 version = "1.21.4"
@@ -1194,15 +1138,6 @@ version = "1.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3d20d5497ef88037a52ff98267d066e7f11fcc5e99bbfbd58a42336193aacec3"
 
-[[package]]
-name = "portable-atomic-util"
-version = "0.2.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2a106d1259c23fac8e543272398ae0e3c0b8d33c88ed73d0cc71b0f1d902618"
-dependencies = [
- "portable-atomic",
-]
-
 [[package]]
 name = "potential_utf"
 version = "0.1.5"
@@ -1255,9 +1190,6 @@ version = "0.29.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4688ddedf473e32662b9b067670129a8afb8c18e351482c70d62ba4a88171e8b"
 dependencies = [
- "chrono",
- "chrono-tz",
- "indexmap",
  "libc",
  "once_cell",
  "portable-atomic",
@@ -1266,27 +1198,6 @@ dependencies = [
  "pyo3-macros",
 ]
 
-[[package]]
-name = "pyo3-arrow"
-version = "0.19.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d5ddf226a2dbf7607570d0657c2bf6fbe299208368b2914f3dd7e7ba0b57688"
-dependencies = [
- "arrow-array",
- "arrow-buffer",
- "arrow-cast",
- "arrow-data",
- "arrow-schema",
- "arrow-select",
- "chrono",
- "chrono-tz",
- "half",
- "indexmap",
- "numpy",
- "pyo3",
- "thiserror 1.0.69",
-]
-
 [[package]]
 name = "pyo3-async-runtimes"
 version = "0.29.0"
@@ -1413,12 +1324,6 @@ dependencies = [
  "rand_core",
 ]
 
-[[package]]
-name = "rawpointer"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "60a357793950651c4ed0f3f52338f53b2f809f32d83a07f72909fa13e4c6c1e3"
-
 [[package]]
 name = "regex"
 version = "1.13.1"
@@ -1499,12 +1404,6 @@ dependencies = [
  "windows-sys 0.52.0",
 ]
 
-[[package]]
-name = "rustc-hash"
-version = "2.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b1e7f9a428571be2dc5bc0505c13fb6bf936822b894ec87abf8a08a4e51742d"
-
 [[package]]
 name = "rustc_version"
 version = "0.4.1"
@@ -1850,33 +1749,13 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
-[[package]]
-name = "thiserror"
-version = "1.0.69"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
-dependencies = [
- "thiserror-impl 1.0.69",
-]
-
 [[package]]
 name = "thiserror"
 version = "2.0.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec86235f5fcc2a73650310756d2ac5b138a5780bbbdfae3eeccec992c435ba4f"
 dependencies = [
- "thiserror-impl 2.0.20",
-]
-
-[[package]]
-name = "thiserror-impl"
-version = "1.0.69"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.119",
+ "thiserror-impl",
 ]
 
 [[package]]
@@ -2047,18 +1926,6 @@ version = "1.0.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
 
-[[package]]
-name = "unicode-segmentation"
-version = "1.13.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c6f5d3c3b1bf09027a88a6bc961fc00497d651009560b5463668dc81b0fa87a8"
-
-[[package]]
-name = "unicode-width"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
-
 [[package]]
 name = "untrusted"
 version = "0.9.0"

{arrowbricks-3.2.0 → arrowbricks-5.0.0}/rust/arrowbricks_core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "arrowbricks_core"
-version = "3.2.0"
+version = "5.0.0"
 edition = "2024"
 readme = "README.md"
 
@@ -11,7 +11,10 @@ crate-type = ["cdylib", "rlib"]
 [dependencies]
 # Depend on the components we use. The umbrella `arrow` crate also builds
 # arithmetic, string, and row kernels even with default-features disabled.
-arrow-array = "59.1.0"
+# `ffi` backs src/arrow_ffi.rs, this crate's own Arrow PyCapsule bridge.
+# `chrono-tz` lets arrow-json format Databricks' named-zone timestamps
+# ("Etc/UTC"); pyo3-arrow used to enable it implicitly.
+arrow-array = { version = "59.1.0", features = ["ffi", "chrono-tz"] }
 arrow-buffer = "59.1.0"
 arrow-ipc = "59.1.0"
 arrow-schema = "59.1.0"
@@ -20,15 +23,14 @@ bytes = "1.12.1"
 # Already in the dependency graph; vectorized newline search in NDJSON output.
 memchr = "2"
 # Already an unconditional transitive dependency of arrow-cast (pulled in by
-# pyo3-arrow) at this exact version -- declared directly here too so
+# arrow-json) at this exact version -- declared directly here too so
 # json_convert.rs can decode BINARY columns without hand-rolling base64. No
 # new code ships that wasn't already linked in (feature unification, same
 # reasoning as chrono/rustls below).
 base64 = "0.23"
-# Already an unconditional transitive dependency of pyo3-arrow (see its own
-# comment below) -- declared directly here too so json_convert.rs can parse
-# DATE/TIMESTAMP/TIMESTAMP_NTZ strings without hand-rolling calendar
-# arithmetic. No new code ships that wasn't already linked in.
+# Already an unconditional transitive dependency of arrow-array -- declared
+# directly here too so json_convert.rs can parse DATE/TIMESTAMP/TIMESTAMP_NTZ
+# strings without hand-rolling calendar arithmetic. No new code ships that wasn't already linked in.
 chrono = { version = "0.4", default-features = false, features = ["std"] }
 # Decompresses cloud-fetch chunk bytes when the server honors our
 # `result_compression: LZ4_FRAME` request (see client.rs's execute_statement)
@@ -36,12 +38,6 @@ chrono = { version = "0.4", default-features = false, features = ["std"] }
 # Pure Rust, no C toolchain dependency -- unlike reqwest's TLS stack below.
 lz4_flex = { version = "0.14", default-features = false, features = ["frame", "std"] }
 pyo3 = { version = "0.29.1", features = ["abi3-py311"] }
-# pyo3-arrow's only optional feature is buffer_protocol (on by default),
-# which we don't use -- numpy/chrono/chrono-tz/arrow-cast(prettyprint) below
-# it are unconditional dependencies of the crate itself, not features, so
-# they ship regardless; not worth dropping pyo3-arrow over that (reimplementing
-# the Arrow C Data Interface ourselves is a much bigger risk than the MBs saved).
-pyo3-arrow = { version = "0.19.0", default-features = false }
 pyo3-async-runtimes = { version = "0.29.0", features = ["tokio-runtime"] }
 pythonize = "0.29.0"
 # reqwest's own `rustls` feature is hardcoded to `__rustls-aws-lc-rs`, no way
@@ -135,9 +131,3 @@ opt-level = "s"
 strip = true
 lto = true
 codegen-units = 1
-
-[profile.release.package.pyo3-arrow]
-# This bridge is dominated by interoperability helpers. Optimizing it for
-# size saves ~32 KiB on macOS arm64; the IPC decoder keeps opt-level="s".
-# Replay and live-query benchmarks are recorded in benchmarks/2026-09-06.md.
-opt-level = "z"

{arrowbricks-3.2.0 → arrowbricks-5.0.0}/rust/arrowbricks_core/README.md

@@ -63,12 +63,11 @@ asyncio.run(main())
 ```
 
 `table` implements the [Arrow C Data Interface](https://arrow.apache.org/docs/format/CDataInterface.html)
-(`__arrow_c_stream__`/`__arrow_c_array__`) -- any consumer that speaks that
-protocol (DuckDB, pyarrow, arro3) can import it with zero copies, no extra
-dependency needed. Note: `table.column(i)`/`table.schema` (materializing
-native Python values) are `pyo3-arrow` methods designed to hand back the
-caller's own *real* `arro3.core` objects -- they need `arro3-core` installed,
-unlike the table object itself.
+(`__arrow_c_stream__`/`__arrow_c_schema__`) -- any consumer that speaks that
+protocol (DuckDB, pyarrow, polars, arro3) can import it with zero copies, no
+extra dependency needed. The table itself only exposes `num_rows`,
+`num_columns`, `column_names` and `len()`; to read values, import it into an
+Arrow library first (e.g. `arro3.core.Table.from_arrow(table)`).
 
 ## API
 

arrowbricks-5.0.0/rust/arrowbricks_core/src/arrow_ffi.rs

@@ -0,0 +1,106 @@
+//! Arrow PyCapsule interface, both directions, on arrow-rs's own
+//! `ffi_stream` -- replaces `pyo3-arrow`, whose `Table.__arrow_c_stream__`
+//! honors `requested_schema` via `arrow_cast::cast` and so kept the whole cast
+//! kernel (~1.8 MiB, a third of `.text`) linked in for a feature no caller of
+//! this crate used.
+
+use std::ffi::CStr;
+
+use arrow_array::ffi::FFI_ArrowSchema;
+use arrow_array::ffi_stream::{ArrowArrayStreamReader, FFI_ArrowArrayStream};
+use arrow_array::{RecordBatch, RecordBatchIterator};
+use arrow_schema::SchemaRef;
+use pyo3::exceptions::PyRuntimeError;
+use pyo3::prelude::*;
+use pyo3::types::{PyCapsule, PyCapsuleMethods};
+
+const STREAM_CAPSULE: &CStr = c"arrow_array_stream";
+const SCHEMA_CAPSULE: &CStr = c"arrow_schema";
+
+/// An in-memory Arrow table. Consume it through `__arrow_c_stream__`
+/// (arro3, pyarrow, polars, DuckDB, ...); the attributes are just enough to
+/// inspect a result without importing another Arrow library.
+#[pyclass(name = "Table", module = "arrowbricks._core", frozen)]
+pub struct PyTable {
+    batches: Vec<RecordBatch>,
+    schema: SchemaRef,
+}
+
+impl PyTable {
+    pub fn try_new(batches: Vec<RecordBatch>, schema: SchemaRef) -> PyResult<Self> {
+        // A stream advertises one schema for every batch. Exporting different
+        // buffer layouts under it can make consumers misinterpret memory.
+        // Like the previous bridge, ignore metadata and nullability differences.
+        if batches.iter().any(|batch| {
+            let fields = batch.schema_ref().fields();
+            fields.len() != schema.fields().len()
+                || fields.iter().zip(schema.fields()).any(|(actual, expected)| {
+                    actual.name() != expected.name() || !actual.data_type().equals_datatype(expected.data_type())
+                })
+        }) {
+            return Err(PyRuntimeError::new_err("All batches must have same schema"));
+        }
+        Ok(Self { batches, schema })
+    }
+}
+
+#[pymethods]
+impl PyTable {
+    #[getter]
+    fn num_rows(&self) -> usize {
+        self.batches.iter().map(RecordBatch::num_rows).sum()
+    }
+
+    #[getter]
+    fn num_columns(&self) -> usize {
+        self.schema.fields().len()
+    }
+
+    #[getter]
+    fn column_names(&self) -> Vec<String> {
+        self.schema.fields().iter().map(|f| f.name().clone()).collect()
+    }
+
+    fn __len__(&self) -> usize {
+        self.num_rows()
+    }
+
+    fn __repr__(&self) -> String {
+        format!(
+            "arrowbricks.Table(num_rows={}, num_columns={})",
+            self.num_rows(),
+            self.num_columns()
+        )
+    }
+
+    /// `requested_schema` is ignored, as the PyCapsule interface allows: the
+    /// consumer checks the schema it actually gets.
+    #[pyo3(signature = (requested_schema=None))]
+    fn __arrow_c_stream__<'py>(
+        &self,
+        py: Python<'py>,
+        requested_schema: Option<Bound<'py, PyAny>>,
+    ) -> PyResult<Bound<'py, PyCapsule>> {
+        let _ = requested_schema;
+        let reader = RecordBatchIterator::new(self.batches.clone().into_iter().map(Ok), self.schema.clone());
+        PyCapsule::new_with_value(py, FFI_ArrowArrayStream::new(Box::new(reader)), STREAM_CAPSULE)
+    }
+
+    fn __arrow_c_schema__<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyCapsule>> {
+        let schema =
+            FFI_ArrowSchema::try_from(self.schema.as_ref()).map_err(|e| PyRuntimeError::new_err(e.to_string()))?;
+        PyCapsule::new_with_value(py, schema, SCHEMA_CAPSULE)
+    }
+}
+
+/// Imports any object implementing `__arrow_c_stream__`.
+pub fn import_stream(obj: &Bound<'_, PyAny>) -> PyResult<ArrowArrayStreamReader> {
+    let capsule = obj.call_method0("__arrow_c_stream__")?.cast_into::<PyCapsule>()?;
+    let ptr = capsule
+        .pointer_checked(Some(STREAM_CAPSULE))?
+        .cast::<FFI_ArrowArrayStream>();
+    // SAFETY: the capsule name check guarantees an `ArrowArrayStream`;
+    // `from_raw` moves it out and marks the capsule's copy released, so the
+    // capsule destructor does not release it a second time.
+    unsafe { ArrowArrayStreamReader::from_raw(ptr.as_ptr()) }.map_err(|e| PyRuntimeError::new_err(e.to_string()))
+}

{arrowbricks-3.2.0 → arrowbricks-5.0.0}/rust/arrowbricks_core/src/client/sea.rs

@@ -381,6 +381,9 @@ impl DbClient {
             session_id,
         };
         let result = self.submit_and_poll_inner(body, stats).await;
+        if result.is_ok() {
+            self.note_warehouse_running();
+        }
         checkin.finish(result.is_ok());
         result
     }

{arrowbricks-3.2.0 → arrowbricks-5.0.0}/rust/arrowbricks_core/src/client.rs

@@ -217,13 +217,18 @@ pub const MAX_SPLIT_PARTS: usize = 8;
 /// silently could.
 const DEFAULT_CHUNK_FETCH_CONCURRENCY: usize = 64;
 
-/// How long the Thrift path polls `GetOperationStatus` when a statement
-/// doesn't finish within its `getDirectResults` budget (see
-/// `execute_lazy_thrift`) -- shorter than SEA's `POLL_INTERVAL` (2s) since
-/// this path exists specifically to be fast for small/quick queries; a
-/// query slow enough to need many polls pays a modest, bounded amount of
-/// extra round trips either way.
-pub(crate) const THRIFT_POLL_INTERVAL: Duration = Duration::from_millis(200);
+/// Sleep before the `attempt`-th (0-based) re-poll of Thrift
+/// `GetOperationStatus` when a statement doesn't finish within its
+/// `getDirectResults` budget (see `execute_lazy_thrift`): a short ramp
+/// (10/25/50/100ms), then 200ms steady. A fixed 200ms made a statement that
+/// finished just after the first poll pay a full 200ms of pure sleep; the
+/// ramp costs at most four extra cheap RPCs before settling at the old
+/// steady rate. Shorter than SEA's `POLL_INTERVAL` (2s) since this path
+/// exists specifically to be fast for small/quick queries.
+pub(crate) fn thrift_poll_delay(attempt: usize) -> Duration {
+    const RAMP_MS: [u64; 5] = [10, 25, 50, 100, 200];
+    Duration::from_millis(RAMP_MS[attempt.min(RAMP_MS.len() - 1)])
+}
 
 /// Request hints on `TExecuteStatementReq.getDirectResults`/`TFetchResultsReq` --
 /// how much of the result the server should try to hand back in one RPC.
@@ -644,6 +649,15 @@ impl DbClient {
         .await
     }
 
+    /// Refreshes `ensure_warehouse_running`'s RUNNING cache. Also called once a
+    /// statement reaches a successful terminal state (SEA's `submit_and_poll`,
+    /// Thrift's `submit_and_await_thrift_statement`): a statement that just ran
+    /// proves the warehouse is up as well as the REST GET does, so steady
+    /// traffic with gaps under the TTL never pays that GET again.
+    pub(crate) fn note_warehouse_running(&self) {
+        *self.warehouse_confirmed_running_at.lock().unwrap() = Some(Instant::now());
+    }
+
     /// Shared by both protocols -- plain REST against `/api/2.0/sql/warehouses/{id}`,
     /// nothing SEA- or Thrift-specific about it (see AGENTS.md for why the
     /// Thrift path didn't always call this).
@@ -660,7 +674,7 @@ impl DbClient {
         let url = format!("{}/api/2.0/sql/warehouses/{}", self.host, self.warehouse_id);
         let data: WarehouseStatusBody = self.authed_json(reqwest::Method::GET, &url, None, None).await?;
         if data.state == "RUNNING" {
-            *self.warehouse_confirmed_running_at.lock().unwrap() = Some(Instant::now());
+            self.note_warehouse_running();
             return Ok(());
         }
         if data.state == "STOPPED" {
@@ -673,7 +687,7 @@ impl DbClient {
             tokio::time::sleep(POLL_INTERVAL).await;
             let data: WarehouseStatusBody = self.authed_json(reqwest::Method::GET, &url, None, None).await?;
             if data.state == "RUNNING" {
-                *self.warehouse_confirmed_running_at.lock().unwrap() = Some(Instant::now());
+                self.note_warehouse_running();
                 return Ok(());
             }
         }

{arrowbricks-3.2.0 → arrowbricks-5.0.0}/rust/arrowbricks_core/src/lib.rs

@@ -1,3 +1,4 @@
+mod arrow_ffi;
 pub mod client;
 pub mod heartbeat;
 pub mod json_convert;
@@ -12,11 +13,10 @@ use pyo3::exceptions::{PyRuntimeError, PyStopAsyncIteration, PyValueError};
 use pyo3::prelude::*;
 use pyo3::sync::PyOnceLock;
 use pyo3::types::PyBytes;
-use pyo3_arrow::PyTable;
-use pyo3_arrow::input::AnyRecordBatch;
 use pyo3_async_runtimes::TaskLocals;
 use tokio::sync::Mutex as AsyncMutex;
 
+use arrow_ffi::PyTable;
 use client::{
     ApiError, ApiErrorKind, CancelHandle, DbClient, EventSink, Protocol, QueryStatsAccumulator, QueryStatsData,
     TokenFuture, TokenProvider,
@@ -33,9 +33,8 @@ use pipeline::{NdjsonStream, ResultStream};
 #[pyfunction]
 #[pyo3(signature = (stream, buf))]
 fn write_ipc_stream(py: Python<'_>, stream: Bound<'_, PyAny>, buf: Bound<'_, PyAny>) -> PyResult<()> {
-    let any_rb: AnyRecordBatch = stream.extract()?;
-    let mut reader = any_rb.into_reader()?;
-    let schema = reader.schema();
+    let mut reader = arrow_ffi::import_stream(&stream)?;
+    let schema = arrow_array::RecordBatchReader::schema(&reader);
     let mut ipc_buf: Vec<u8> = Vec::new();
     {
         let mut writer = arrow_ipc::writer::StreamWriter::try_new(&mut ipc_buf, &schema)
@@ -70,7 +69,7 @@ fn read_ipc_stream(data: Bound<'_, PyBytes>) -> PyResult<PyTable> {
     let (batches, schema) = py
         .detach(|| pipeline::decode_ipc_stream(&blob))
         .map_err(|e| PyRuntimeError::new_err(e.message))?;
-    PyTable::try_new(batches, schema).map_err(|e| PyRuntimeError::new_err(e.to_string()))
+    PyTable::try_new(batches, schema)
 }
 
 /// Wraps a `PyErr` raised by the caller's own `token_provider` callable (its
@@ -804,7 +803,7 @@ fn column_pairs(columns: &[client::ColumnDescription]) -> Vec<(String, Option<St
 /// schema rather than a schema-less `Table`.
 fn batches_to_pytable(batches: Vec<RecordBatch>, schema: Option<SchemaRef>) -> PyResult<PyTable> {
     let schema = schema.unwrap_or_else(|| Arc::new(Schema::empty()));
-    PyTable::try_new(batches, schema).map_err(|e| PyRuntimeError::new_err(e.to_string()))
+    PyTable::try_new(batches, schema)
 }
 
 #[pymethods]
@@ -854,11 +853,7 @@ impl PyResultSet {
     /// `Cursor.description`'s shape. `None` before any fetch (the caller
     /// should fall back to `columns`, the manifest-based pre-fetch
     /// estimate). Computed directly from the decoded `arrow_schema::Schema`
-    /// here rather than via a returned `Table`'s own `.schema` property --
-    /// that property specifically requires a *real* `arro3.core` install to
-    /// construct its return value (by pyo3-arrow's own design, so callers
-    /// get their own runtime's Schema type back), which would reintroduce
-    /// exactly the dependency this crate's callers don't have.
+    /// here, so no Arrow library is needed to read it.
     fn schema<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
         let inner = self.inner.clone();
         pyo3_async_runtimes::tokio::future_into_py(py, async move {
@@ -1065,6 +1060,7 @@ impl PyNdjsonStreamIter {
 fn _core(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(write_ipc_stream, m)?)?;
     m.add_function(wrap_pyfunction!(read_ipc_stream, m)?)?;
+    m.add_class::<PyTable>()?;
     m.add_class::<PyDbClient>()?;
     m.add_class::<PyResultSet>()?;
     m.add_class::<PyHeartbeat>()?;

{arrowbricks-3.2.0 → arrowbricks-5.0.0}/rust/arrowbricks_core/src/pipeline/ndjson.rs

@@ -576,6 +576,25 @@ mod tests {
         assert_eq!(string_lines[3], r#"{"id":4,"value":1.5}"#); // finite values untouched
     }
 
+    /// Databricks sends TIMESTAMP as `Timestamp(us, "Etc/UTC")`. A named zone
+    /// needs arrow-array's `chrono-tz` feature, which pyo3-arrow used to
+    /// enable implicitly; without it this errors ("only offset based
+    /// timezones supported").
+    #[test]
+    fn encode_ndjson_lines_handles_a_named_timezone() {
+        use arrow_array::TimestampMicrosecondArray;
+        use arrow_schema::{Field, Schema, TimeUnit};
+        let array = TimestampMicrosecondArray::from(vec![1_767_225_600_000_000]).with_timezone("Etc/UTC");
+        let schema = Arc::new(Schema::new(vec![Field::new(
+            "ts",
+            DataType::Timestamp(TimeUnit::Microsecond, Some("Etc/UTC".into())),
+            false,
+        )]));
+        let batch = RecordBatch::try_new(schema, vec![Arc::new(array)]).unwrap();
+        let lines = encode_ndjson_lines(std::slice::from_ref(&batch), false).unwrap();
+        assert_eq!(lines[0], r#"{"ts":"2026-01-01T00:00:00Z"}"#);
+    }
+
     #[test]
     fn encode_ndjson_lines_leaves_a_real_null_alone_when_requested() {
         use arrow_array::{Float64Array, Int64Array};

{arrowbricks-3.2.0 → arrowbricks-5.0.0}/rust/arrowbricks_core/src/pipeline/sea.rs

@@ -465,7 +465,7 @@ pub async fn execute_lazy_prefer_inline(
 
 /// Full submit -> poll -> fetch -> reorder -> decode pipeline. Returns the
 /// assembled batches in logical (chunk_index) order plus their schema, ready
-/// to hand to `pyo3_arrow::PyTable` for a zero-copy Arrow C Data Interface
+/// to hand to `arrow_ffi::PyTable` for a zero-copy Arrow C Data Interface
 /// handoff back to Python (consumable by DuckDB/pyarrow/arro3 directly).
 ///
 /// Decode of each reordered chunk is pushed onto `spawn_blocking` rather

{arrowbricks-3.2.0 → arrowbricks-5.0.0}/rust/arrowbricks_core/src/pipeline/thrift_exec.rs

@@ -140,7 +140,7 @@ async fn submit_and_await_thrift_statement(
         stats.set_in_flight(CancelHandle::Thrift {
             operation: operation.clone(),
         });
-        loop {
+        for attempt in 0.. {
             let status = client.thrift_get_operation_status_raw(&operation, stats).await?;
             if let Some(e) = status.terminal_error() {
                 stats.clear_in_flight();
@@ -150,9 +150,10 @@ async fn submit_and_await_thrift_statement(
                 stats.clear_in_flight();
                 break;
             }
-            tokio::time::sleep(crate::client::THRIFT_POLL_INTERVAL).await;
+            tokio::time::sleep(crate::client::thrift_poll_delay(attempt)).await;
         }
     }
+    client.note_warehouse_running();
 
     Ok(ThriftStatementReady {
         operation,

{arrowbricks-3.2.0 → arrowbricks-5.0.0}/rust/arrowbricks_core/tests/wiremock_pipeline.rs

@@ -1187,6 +1187,52 @@ async fn session_is_created_once_and_reused_across_sequential_statements() {
     }
 }
 
+/// SEA counterpart of `wiremock_thrift.rs`'s cache-refresh test: a SUCCEEDED
+/// statement refreshes `ensure_warehouse_running`'s cache, so the third of
+/// three statements ~600ms apart (1s TTL) needs no second warehouse GET.
+#[tokio::test]
+async fn successful_statement_refreshes_the_warehouse_running_cache() {
+    let server = MockServer::start().await;
+    mount_warehouse_running(&server).await;
+    Mock::given(method("POST"))
+        .and(path("/api/2.0/sql/sessions"))
+        .respond_with(ResponseTemplate::new(200).set_body_json(json!({"session_id": "sess-0"})))
+        .mount(&server)
+        .await;
+    Mock::given(method("POST"))
+        .and(path("/api/2.0/sql/statements"))
+        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
+            "statement_id": STATEMENT_ID,
+            "status": {"state": "SUCCEEDED"},
+            "manifest": {"chunks": []},
+        })))
+        .mount(&server)
+        .await;
+
+    let client = Arc::new(
+        DbClient::new(&server.uri(), WAREHOUSE_ID, "fake-token")
+            .with_protocol(Protocol::Sea)
+            .with_warehouse_confirmed_running_ttl(1.0),
+    );
+    for i in 0..3 {
+        if i > 0 {
+            tokio::time::sleep(std::time::Duration::from_millis(600)).await;
+        }
+        run_pipeline(client.clone(), "SELECT 1", None, None, None)
+            .await
+            .unwrap();
+    }
+
+    let warehouse_gets = server
+        .received_requests()
+        .await
+        .unwrap()
+        .iter()
+        .filter(|r| r.method == wiremock::http::Method::GET && r.url.path().starts_with("/api/2.0/sql/warehouses/"))
+        .count();
+    assert_eq!(warehouse_gets, 1);
+}
+
 #[tokio::test]
 async fn session_creation_failure_falls_back_to_catalog_on_the_statement_body() {
     let server = MockServer::start().await;

{arrowbricks-3.2.0 → arrowbricks-5.0.0}/rust/arrowbricks_core/tests/wiremock_thrift.rs

@@ -1187,6 +1187,126 @@ async fn thrift_session_is_created_once_and_reused_across_sequential_statements(
     );
 }
 
+/// A successful statement refreshes `ensure_warehouse_running`'s RUNNING
+/// cache. With a 1s TTL and ~600ms gaps, the third statement is >1s
+/// after the only warehouse GET but <1s after the second statement
+/// succeeded -- so exactly one GET only if success refreshes the cache.
+#[tokio::test]
+async fn thrift_successful_statement_refreshes_the_warehouse_running_cache() {
+    let server = MockServer::start().await;
+    mount_open_session_always(&server, b"sess").await;
+    mount_close_operation_ok(&server).await;
+
+    let schema = test_schema();
+    let schema_for_mock = schema.clone();
+    Mock::given(method("POST"))
+        .and(path(thrift_path()))
+        .and(IsThriftRpc("ExecuteStatement"))
+        .respond_with(move |_req: &Request| {
+            ResponseTemplate::new(200).set_body_raw(
+                small_execute_statement_success(b"op".to_vec(), &schema_for_mock),
+                "application/x-thrift",
+            )
+        })
+        .mount(&server)
+        .await;
+
+    let client = Arc::new(
+        DbClient::new(&server.uri(), WAREHOUSE_ID, "fake-token")
+            .with_protocol(Protocol::Thrift)
+            .with_warehouse_confirmed_running_ttl(1.0),
+    );
+    for i in 0..3 {
+        if i > 0 {
+            tokio::time::sleep(std::time::Duration::from_millis(600)).await;
+        }
+        let mut stream = execute_lazy_thrift(client.clone(), "SELECT 1", None, None, None)
+            .await
+            .unwrap();
+        stream.fetchall_arrow().await.unwrap();
+    }
+
+    let warehouse_gets = server
+        .received_requests()
+        .await
+        .unwrap()
+        .iter()
+        .filter(|r| r.method == wiremock::http::Method::GET && r.url.path().starts_with("/api/2.0/sql/warehouses/"))
+        .count();
+    assert_eq!(
+        warehouse_gets, 1,
+        "a statement that just succeeded proves the warehouse is running -- no further GET within the TTL"
+    );
+}
+
+/// `GetOperationStatus` polling ramps up (10/25/50/100ms, then 200ms) instead
+/// of a fixed 200ms: two RUNNING polls then FINISHED must cost ~35ms of
+/// sleep, not the old fixed 400ms.
+#[tokio::test]
+async fn thrift_polling_ramps_up_so_a_quick_statement_returns_fast() {
+    let server = MockServer::start().await;
+    mount_open_session_always(&server, b"sess").await;
+    mount_close_operation_ok(&server).await;
+
+    Mock::given(method("POST"))
+        .and(path(thrift_path()))
+        .and(IsThriftRpc("ExecuteStatement"))
+        .respond_with(ResponseTemplate::new(200).set_body_raw(
+            build_execute_statement_resp(b"op-p", b"opsecret-p", None),
+            "application/x-thrift",
+        ))
+        .mount(&server)
+        .await;
+
+    let poll_calls = Arc::new(AtomicUsize::new(0));
+    let poll_calls_for_mock = poll_calls.clone();
+    Mock::given(method("POST"))
+        .and(path(thrift_path()))
+        .and(IsThriftRpc("GetOperationStatus"))
+        .respond_with(move |_req: &Request| {
+            let n = poll_calls_for_mock.fetch_add(1, Ordering::SeqCst);
+            let state = if n < 2 {
+                operation_state::RUNNING
+            } else {
+                operation_state::FINISHED
+            };
+            ResponseTemplate::new(200)
+                .set_body_raw(build_get_operation_status_resp(state, None), "application/x-thrift")
+        })
+        .mount(&server)
+        .await;
+
+    let schema = test_schema();
+    let (schema_bytes, batch_bytes) = build_schema_and_batch_messages(&schema, &[(0, 1)]);
+    Mock::given(method("POST"))
+        .and(path(thrift_path()))
+        .and(IsThriftRpc("FetchResults"))
+        .respond_with(ResponseTemplate::new(200).set_body_raw(
+            build_fetch_results_resp(&FetchSpec {
+                has_more_rows: false,
+                arrow_batches: vec![(batch_bytes[0].clone(), 1)],
+                metadata: Some((false, Some(schema_bytes))),
+                ..Default::default()
+            }),
+            "application/x-thrift",
+        ))
+        .mount(&server)
+        .await;
+
+    let client = thrift_client(&server);
+    let t0 = std::time::Instant::now();
+    let mut stream = execute_lazy_thrift(client, "SELECT 1", None, None, None).await.unwrap();
+    let submit_elapsed = t0.elapsed();
+    let (batches, _) = stream.fetchall_arrow().await.unwrap();
+
+    assert_eq!(poll_calls.load(Ordering::SeqCst), 3);
+    assert_ids_in_order(&batches, 1);
+    assert!(
+        submit_elapsed < std::time::Duration::from_millis(300),
+        "two RUNNING polls should cost ~35ms of ramped sleep, not 2x200ms: took {submit_elapsed:?}"
+    );
+}
+
 #[tokio::test]
 async fn thrift_pool_exhaustion_falls_back_to_a_throwaway_session_that_still_succeeds() {
     let server = MockServer::start().await;

{arrowbricks-3.2.0 → arrowbricks-5.0.0}/rust/arrowbricks_core/tests_py/test_ipc_stream.py

@@ -164,3 +164,41 @@ def test_read_ipc_stream_allows_another_python_thread_to_run():
         thread.join(timeout=5)
     assert result.num_rows == 100_000
     assert ran_during_decode, "IPC decoding must release the interpreter lock"
+
+
+def test_table_exports_are_independent_and_outlive_the_table():
+    source = core.Table.from_pydict({"id": core.Array([1, 2], type=core.DataType.int64())})
+    buf = io.BytesIO()
+    arrowbricks_core.write_ipc_stream(source, buf)
+    table = arrowbricks_core.read_ipc_stream(buf.getvalue())
+    assert len(table) == 2
+    assert table.column_names == ["id"]
+    # A capsule discarded without a consumer must release only its own reader.
+    unused = table.__arrow_c_stream__()
+    del unused
+    first = table.__arrow_c_stream__(requested_schema=None)
+    second = table.__arrow_c_stream__()
+    del table, source, buf
+    gc.collect()
+
+    class Export:
+        def __init__(self, capsule):
+            self.capsule = capsule
+
+        def __arrow_c_stream__(self, requested_schema=None):
+            return self.capsule
+
+    for capsule in (first, second):
+        assert core.Table.from_arrow(Export(capsule))["id"].to_pylist() == [1, 2]
+    # Each capsule can be consumed only once; a second import must error.
+    with pytest.raises(RuntimeError):
+        arrowbricks_core.write_ipc_stream(Export(first), io.BytesIO())
+
+
+def test_write_ipc_stream_rejects_a_schema_capsule():
+    class WrongCapsule:
+        def __arrow_c_stream__(self):
+            return core.Schema([core.Field("id", core.DataType.int64())]).__arrow_c_schema__()
+
+    with pytest.raises(ValueError):
+        arrowbricks_core.write_ipc_stream(WrongCapsule(), io.BytesIO())

{arrowbricks-3.2.0 → arrowbricks-5.0.0}/rust/arrowbricks_core/tests_py/test_thrift.py

@@ -11,6 +11,7 @@ from __future__ import annotations
 
 import pytest
 import thrift_mock as tm
+from arro3.core import Table
 
 from arrowbricks import _core as arrowbricks_core
 
@@ -51,7 +52,7 @@ async def test_thrift_execute_returns_data_inline_via_direct_results(mock_thrift
     result = await client.execute("SELECT * FROM t")
     table = await result.fetchall_arrow()
     assert table.num_rows == 3
-    assert table.column("id").to_pylist() == [0, 1, 2]
+    assert Table.from_arrow(table).column("id").to_pylist() == [0, 1, 2]
 
 
 @pytest.mark.asyncio
@@ -88,7 +89,7 @@ async def test_thrift_multi_batch_fetch_preserves_order(mock_thrift_server):
     result = await client.execute("SELECT * FROM t ORDER BY id")
     table = await result.fetchall_arrow()
     assert table.num_rows == total_rows
-    assert table.column("id").to_pylist() == list(range(total_rows))
+    assert Table.from_arrow(table).column("id").to_pylist() == list(range(total_rows))
 
 
 @pytest.mark.asyncio
@@ -133,7 +134,7 @@ async def test_thrift_lz4_compressed_result_links_are_decompressed(mock_thrift_s
     result = await client.execute("SELECT * FROM t")
     table = await result.fetchall_arrow()
     assert table.num_rows == 4
-    assert table.column("id").to_pylist() == [0, 1, 2, 3]
+    assert Table.from_arrow(table).column("id").to_pylist() == [0, 1, 2, 3]
 
 
 @pytest.mark.asyncio
@@ -222,4 +223,4 @@ async def test_thrift_is_the_default_protocol_when_omitted(mock_thrift_server):
     client = arrowbricks_core.Client(host=server.host, warehouse_id=WAREHOUSE_ID, token="fake")
     result = await client.execute("SELECT * FROM t")
     table = await result.fetchall_arrow()
-    assert table.column("id").to_pylist() == [0, 1]
+    assert Table.from_arrow(table).column("id").to_pylist() == [0, 1]

{arrowbricks-3.2.0 → arrowbricks-5.0.0}/src/arrowbricks/__init__.py

@@ -1,3 +1,7 @@
+# PEP 810 (Python 3.15+): defer loading these submodules until a name from
+# them is first used. Older Pythons ignore this list and import eagerly.
+__lazy_modules__ = ["arrowbricks._streaming", "arrowbricks.client", "arrowbricks.cursor"]
+
 from ._core import ArrowbricksError, AuthError, QueryStats, StatementError, TransientError
 from ._streaming import (
     HEARTBEAT,

{arrowbricks-3.2.0 → arrowbricks-5.0.0}/src/arrowbricks/_core.pyi

@@ -2,7 +2,19 @@ from collections.abc import Awaitable, Callable
 from typing import Any, BinaryIO, Literal
 
 def write_ipc_stream(stream: Any, buf: BinaryIO) -> None: ...  # stream: anything implementing __arrow_c_stream__
-def read_ipc_stream(data: bytes) -> Any: ...  # Arrow table (__arrow_c_stream__)
+
+class Table:
+    @property
+    def num_rows(self) -> int: ...
+    @property
+    def num_columns(self) -> int: ...
+    @property
+    def column_names(self) -> list[str]: ...
+    def __len__(self) -> int: ...
+    def __arrow_c_stream__(self, requested_schema: object | None = None) -> object: ...
+    def __arrow_c_schema__(self) -> object: ...
+
+def read_ipc_stream(data: bytes) -> Table: ...
 
 class _Heartbeat:
     def __repr__(self) -> str: ...
@@ -49,14 +61,14 @@ class ResultSet:
     # for Cursor.description-style compatibility.
     columns: list[tuple[str, str | None]]
 
-    async def fetchmany_arrow(self, n: int) -> Any: ...  # Arrow table (__arrow_c_stream__)
-    async def fetchall_arrow(self) -> Any: ...  # Arrow table (__arrow_c_stream__)
+    async def fetchmany_arrow(self, n: int) -> Table: ...
+    async def fetchall_arrow(self) -> Table: ...
     def fetchall_arrow_streamed(self, total_timeout_s: float | None = None) -> FetchallArrowStreamedIter: ...
     async def schema(self) -> list[tuple[str, str]] | None: ...  # real schema, known after >=1 fetch
 
 class FetchallArrowStreamedIter:
     def __aiter__(self) -> FetchallArrowStreamedIter: ...
-    async def __anext__(self) -> Any: ...  # Arrow table (__arrow_c_stream__) | _Heartbeat
+    async def __anext__(self) -> Table | _Heartbeat: ...
 
 class NdjsonStreamIter:
     def __aiter__(self) -> NdjsonStreamIter: ...

{arrowbricks-3.2.0 → arrowbricks-5.0.0}/src/arrowbricks/_streaming.py

@@ -11,14 +11,16 @@ Python-side Arrow-to-JSON conversion step at all.
 
 from __future__ import annotations
 
-import asyncio
 import contextlib
 from collections.abc import AsyncIterator, Awaitable, Iterator
-from typing import Any, BinaryIO, TypeVar, cast
+from typing import TYPE_CHECKING, Any, BinaryIO, TypeVar, cast
 
 from . import _core
 from .client import DatabricksClient
 
+if TYPE_CHECKING:
+    import asyncio
+
 __all__ = [
     "HEARTBEAT",
     "QueryTimeout",
@@ -131,6 +133,10 @@ async def await_with_heartbeat(
     Yields HEARTBEAT zero or more times, then yields the awaitable's real
     result exactly once. Re-raises whatever `aw` raised, or QueryTimeout if
     `total_timeout_s` elapses first."""
+    # Imported here, not at module level: asyncio costs ~27 ms to import and
+    # only this coroutine (already running inside a loop) needs it.
+    import asyncio
+
     task: asyncio.Task[T] = asyncio.ensure_future(aw)
     loop = asyncio.get_running_loop()
     deadline = loop.time() + total_timeout_s if total_timeout_s is not None else None

{arrowbricks-3.2.0 → arrowbricks-5.0.0}/src/arrowbricks/cursor.py

@@ -52,6 +52,9 @@ def _table_to_rows(table: Any) -> list[Row]:
     if table.num_rows == 0:
         return []
     try:
+        from arro3.core import Table
+
+        table = Table.from_arrow(table)
         columns = [table.column(i).combine_chunks().to_pylist() for i in range(table.num_columns)]
     except ModuleNotFoundError as exc:
         raise ModuleNotFoundError(