Use split arrow crates for smaller dependency footprint (#362)

* Use split arrow crates for smaller dependency footprint

* simpler cargo.toml

Author: kylebarron

Cargo.lock

@@ -25,8 +25,9 @@ name = "fastexcel"
 crate-type = ["cdylib"]
 
 [dependencies]
-# There's a lot of stuff we don't want here, such as serde support
-arrow = { version = "^55.2.0", default-features = false, features = ["ffi"] }
+arrow-schema = "^55.2.0"
+arrow-array = { version = "^55.2.0", features = ["ffi"] }
+arrow-pyarrow = { version = "^55.2.0", optional = true }
 calamine = { version = "^0.30.0", features = ["dates"] }
 chrono = { version = "^0.4.41", default-features = false }
 log = "0.4.27"
@@ -42,7 +43,7 @@ rstest = { version = "^0.26.1", default-features = false }
 [features]
 default = ["extension-module", "pyarrow"]
 extension-module = ["pyo3/extension-module"]
-pyarrow = ["arrow/pyarrow"]
+pyarrow = ["dep:arrow-pyarrow"]
 # feature for tests only. This makes Python::with_gil auto-initialize Python
 # interpreters, which allows us to instantiate Python objects in tests
 # (see https://pyo3.rs/v0.22.3/features#auto-initialize)

Cargo.toml

@@ -1,8 +1,8 @@
 use std::ffi::c_void;
 
-use arrow::array::Array;
-use arrow::ffi::{FFI_ArrowArray, FFI_ArrowSchema};
-use arrow::record_batch::RecordBatch;
+use arrow_array::ffi::{FFI_ArrowArray, FFI_ArrowSchema};
+use arrow_array::{Array, RecordBatch, StructArray};
+use arrow_schema::Schema;
 use pyo3::exceptions::PyValueError;
 use pyo3::ffi::PyCapsule_New;
 use pyo3::prelude::*;
@@ -11,7 +11,7 @@ use pyo3::types::PyCapsule;
 /// Creates a PyCapsule containing an ArrowSchema
 pub fn schema_to_pycapsule<'py>(
     py: Python<'py>,
-    schema: &arrow::datatypes::Schema,
+    schema: &Schema,
 ) -> PyResult<Bound<'py, PyCapsule>> {
     let schema_ptr = Box::into_raw(Box::new(FFI_ArrowSchema::try_from(schema).map_err(
         |e| PyValueError::new_err(format!("Failed to convert schema to FFI format: {}", e)),
@@ -78,7 +78,7 @@ pub fn record_batch_to_pycapsules<'py>(
     let schema_capsule = schema_to_pycapsule(py, record_batch.schema().as_ref())?;
 
     // For record batches, we need to convert to a struct array
-    let struct_array = arrow::array::StructArray::from(record_batch.clone());
+    let struct_array = StructArray::from(record_batch.clone());
     let array_capsule = array_to_pycapsule(py, &struct_array)?;
 
     Ok((schema_capsule, array_capsule))

src/arrow_capsule.rs

@@ -1,9 +1,7 @@
 use std::sync::Arc;
 
-use arrow::{
-    array::{Array, NullArray, RecordBatch},
-    datatypes::{Field, Schema},
-};
+use arrow_array::{Array, ArrayRef, NullArray, RecordBatch};
+use arrow_schema::{Field, Schema};
 use calamine::{Data as CalData, DataRef as CalDataRef, DataType, Range};
 
 use crate::{
@@ -77,7 +75,7 @@ mod array_impls {
     use std::fmt::Debug;
     use std::sync::Arc;
 
-    use arrow::array::{
+    use arrow_array::{
         Array, BooleanArray, Date32Array, DurationMillisecondArray, Float64Array, Int64Array,
         StringArray, TimestampMillisecondArray,
     };
@@ -570,10 +568,7 @@ pub(crate) fn record_batch_from_data_and_columns_with_errors(
         let dtype = *column_info.dtype();
 
         let (array, new_cell_errors) = match dtype {
-            DType::Null => (
-                Arc::new(NullArray::new(limit - offset)) as Arc<dyn arrow::array::Array>,
-                vec![],
-            ),
+            DType::Null => (Arc::new(NullArray::new(limit - offset)) as ArrayRef, vec![]),
             DType::Int => create_int_array_with_errors(data, col_idx, offset, limit),
             DType::Float => create_float_array_with_errors(data, col_idx, offset, limit),
             DType::String => create_string_array_with_errors(data, col_idx, offset, limit),

src/data.rs

@@ -5,7 +5,7 @@ use std::{
     sync::OnceLock,
 };
 
-use arrow::datatypes::{DataType as ArrowDataType, TimeUnit};
+use arrow_schema::{DataType as ArrowDataType, TimeUnit};
 use calamine::{CellErrorType, CellType, DataType, Range};
 use log::warn;
 use pyo3::{

src/types/dtype.rs

@@ -3,9 +3,9 @@ use std::{
     io::{BufReader, Cursor},
 };
 
+use arrow_array::RecordBatch;
 #[cfg(feature = "pyarrow")]
-use arrow::pyarrow::ToPyArrow;
-use arrow::record_batch::RecordBatch;
+use arrow_pyarrow::ToPyArrow;
 use pyo3::{Bound, IntoPyObjectExt, PyAny, PyResult, Python, pyclass, pymethods};
 
 use calamine::{

src/types/python/excelreader.rs

@@ -1,6 +1,6 @@
 use std::{fmt::Display, str::FromStr};
 
-use arrow::datatypes::Field;
+use arrow_schema::Field;
 use calamine::DataType;
 use pyo3::{PyResult, pyclass, pymethods};
 

src/types/python/excelsheet/column_info.rs

@@ -5,9 +5,9 @@ use calamine::{CellType, Range, Sheet as CalamineSheet, SheetVisible as Calamine
 use column_info::{AvailableColumns, ColumnInfoNoDtype};
 use std::{cmp, collections::HashSet, fmt::Debug, str::FromStr};
 
+use arrow_array::RecordBatch;
 #[cfg(feature = "pyarrow")]
-use arrow::pyarrow::ToPyArrow;
-use arrow::record_batch::RecordBatch;
+use arrow_pyarrow::ToPyArrow;
 
 use pyo3::{
     Bound, IntoPyObject, IntoPyObjectExt, PyAny, PyObject, PyResult,