vortex-data
diff --git a/‎Cargo.lock‎
Lines changed: 12 additions & 12 deletions b/‎Cargo.lock‎
Lines changed: 12 additions & 12 deletions
diff --git a/‎Cargo.toml‎
Lines changed: 2 additions & 2 deletions b/‎Cargo.toml‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎uv.lock‎
Lines changed: 2 additions & 0 deletions b/‎uv.lock‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎vortex-python/src/arrays/from_arrow.rs‎
Lines changed: 5 additions & 5 deletions b/‎vortex-python/src/arrays/from_arrow.rs‎
Lines changed: 5 additions & 5 deletions
diff --git a/‎vortex-python/src/arrays/into_array.rs‎
Lines changed: 8 additions & 6 deletions b/‎vortex-python/src/arrays/into_array.rs‎
Lines changed: 8 additions & 6 deletions
diff --git a/‎vortex-python/src/arrays/mod.rs‎
Lines changed: 29 additions & 25 deletions b/‎vortex-python/src/arrays/mod.rs‎
Lines changed: 29 additions & 25 deletions
diff --git a/‎vortex-python/src/arrays/native.rs‎
Lines changed: 1 addition & 1 deletion b/‎vortex-python/src/arrays/native.rs‎
Lines changed: 1 addition & 1 deletion
@@ -159,8 +159,8 @@ primitive-types = { version = "0.14.0" }
 prost = "0.14"
 prost-build = "0.14"
 prost-types = "0.14"
-pyo3 = { version = "0.26.0" }
-pyo3-bytes = "0.4"
+pyo3 = { version = "0.27.0" }
+pyo3-bytes = "0.5"
 pyo3-log = "0.13.0"
 rand = "0.9.0"
 rand_distr = "0.5"
 
@@ -19,14 +19,14 @@ use crate::arrays::PyArrayRef;
 use crate::arrow::FromPyArrow;
 
 /// Convert an Arrow object to a Vortex array.
-pub(super) fn from_arrow(obj: &Bound<'_, PyAny>) -> PyResult<PyArrayRef> {
+pub(super) fn from_arrow(obj: &Borrowed<'_, '_, PyAny>) -> PyResult<PyArrayRef> {
     let pa = obj.py().import("pyarrow")?;
     let pa_array = pa.getattr("Array")?;
     let chunked_array = pa.getattr("ChunkedArray")?;
     let table = pa.getattr("Table")?;
 
     if obj.is_instance(&pa_array)? {
-        let arrow_array = ArrowArrayData::from_pyarrow_bound(obj).map(make_array)?;
+        let arrow_array = ArrowArrayData::from_pyarrow(&obj.as_borrowed()).map(make_array)?;
         let is_nullable = arrow_array.is_nullable();
         let enc_array = ArrayRef::from_arrow(arrow_array.as_ref(), is_nullable);
         Ok(PyArrayRef::from(enc_array))
@@ -35,20 +35,20 @@ pub(super) fn from_arrow(obj: &Bound<'_, PyAny>) -> PyResult<PyArrayRef> {
         let encoded_chunks = chunks
             .iter()
             .map(|a| {
-                ArrowArrayData::from_pyarrow_bound(a)
+                ArrowArrayData::from_pyarrow(&a.as_borrowed())
                     .map(make_array)
                     .map(|a| ArrayRef::from_arrow(a.as_ref(), false))
             })
             .collect::<PyResult<Vec<_>>>()?;
         let dtype: DType = obj
             .getattr("type")
-            .and_then(|v| DataType::from_pyarrow_bound(&v))
+            .and_then(|v| DataType::from_pyarrow(&v.as_borrowed()))
             .map(|dt| DType::from_arrow(&Field::new("_", dt, false)))?;
         Ok(PyArrayRef::from(
             ChunkedArray::try_new(encoded_chunks, dtype)?.into_array(),
         ))
     } else if obj.is_instance(&table)? {
-        let array_stream = ArrowArrayStreamReader::from_pyarrow_bound(obj)?;
+        let array_stream = ArrowArrayStreamReader::from_pyarrow(&obj.as_borrowed())?;
         let dtype = DType::from_arrow(array_stream.schema());
         let chunks = array_stream
             .into_iter()
 
@@ -6,7 +6,7 @@ use arrow_array::{RecordBatchReader as _, make_array};
 use arrow_data::ArrayData;
 use pyo3::exceptions::PyTypeError;
 use pyo3::types::PyAnyMethods;
-use pyo3::{Bound, FromPyObject, PyAny, PyResult};
+use pyo3::{Borrowed, FromPyObject, PyAny, PyErr};
 use vortex::ArrayRef;
 use vortex::arrow::FromArrowArray as _;
 use vortex::dtype::DType;
@@ -34,25 +34,27 @@ impl PyIntoArray {
     }
 }
 
-impl<'py> FromPyObject<'py> for PyIntoArray {
-    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
+impl<'py> FromPyObject<'_, 'py> for PyIntoArray {
+    type Error = PyErr;
+
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> Result<Self, Self::Error> {
         if ob.is_instance_of::<PyNativeArray>() || ob.is_instance_of::<PyPythonArray>() {
-            return PyArrayRef::extract_bound(ob).map(PyIntoArray);
+            return PyArrayRef::extract(ob).map(PyIntoArray);
         }
 
         let py = ob.py();
         let pa = py.import("pyarrow")?;
 
         if ob.is_instance(&pa.getattr("Array")?)? {
-            let arrow_array_data = ArrayData::from_pyarrow_bound(ob)?;
+            let arrow_array_data = ArrayData::from_pyarrow(&ob.as_borrowed())?;
             return Ok(PyIntoArray(PyVortex(ArrayRef::from_arrow(
                 make_array(arrow_array_data).as_ref(),
                 false,
             ))));
         }
 
         if ob.is_instance(&pa.getattr("Table")?)? {
-            let arrow_stream = ArrowArrayStreamReader::from_pyarrow_bound(ob)?;
+            let arrow_stream = ArrowArrayStreamReader::from_pyarrow(&ob.as_borrowed())?;
             let dtype = DType::from_arrow(arrow_stream.schema());
             let vortex_iter = arrow_stream
                 .into_iter()
 
@@ -80,15 +80,17 @@ pub(crate) fn init(py: Python, parent: &Bound<PyModule>) -> PyResult<()> {
 /// A type adapter used to extract an ArrayRef from a Python object.
 pub type PyArrayRef = PyVortex<ArrayRef>;
 
-impl<'py> FromPyObject<'py> for PyArrayRef {
-    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
+impl<'py> FromPyObject<'_, 'py> for PyArrayRef {
+    type Error = PyErr;
+
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> Result<Self, Self::Error> {
         // If it's already native, then we're done.
-        if let Ok(native) = ob.downcast::<PyNativeArray>() {
+        if let Ok(native) = ob.cast::<PyNativeArray>() {
             return Ok(Self(native.get().inner().clone()));
         }
 
         // Otherwise, if it's a subclass of `PyArray`, then we can extract the inner array.
-        PythonArray::extract_bound(ob).map(|instance| Self(instance.to_array()))
+        PythonArray::extract(ob).map(|instance| Self(instance.to_array()))
     }
 }
 
@@ -198,7 +200,7 @@ impl PyArray {
     /// :class:`~vortex.Array`
     #[staticmethod]
     fn from_arrow(obj: Bound<'_, PyAny>) -> PyResult<PyArrayRef> {
-        from_arrow::from_arrow(&obj)
+        from_arrow::from_arrow(&obj.as_borrowed())
     }
 
     /// Convert a Python range into a Vortex array.
@@ -241,13 +243,13 @@ impl PyArray {
     #[staticmethod]
     #[pyo3(signature = (range, *, dtype = None))]
     fn from_range(range: Bound<PyAny>, dtype: Option<Bound<PyDType>>) -> PyResult<PyArrayRef> {
-        let range = range.downcast::<PyRange>()?;
+        let range = range.cast::<PyRange>()?;
         let start = range.start()?;
         let stop = range.stop()?;
         let step = range.step()?;
 
         let (ptype, dtype) = if let Some(dtype) = dtype {
-            let dtype = dtype.downcast::<PyDType>()?.get().inner().clone();
+            let dtype = dtype.cast::<PyDType>()?.get().inner().clone();
             let DType::Primitive(ptype, ..) = &dtype else {
                 return Err(PyValueError::new_err(
                     "Cannot construct non-numeric array from a range.",
@@ -297,7 +299,7 @@ impl PyArray {
     /// ```
     fn to_arrow_array<'py>(self_: &'py Bound<'py, Self>) -> PyResult<Bound<'py, PyAny>> {
         // NOTE(ngates): for struct arrays, we could also return a RecordBatchStreamReader.
-        let array = PyArrayRef::extract_bound(self_.as_any())?.into_inner();
+        let array = PyArrayRef::extract(self_.as_any().as_borrowed())?.into_inner();
         let py = self_.py();
 
         if let Some(chunked_array) = array.as_opt::<ChunkedVTable>() {
@@ -347,15 +349,15 @@ impl PyArray {
     /// Returns the encoding ID of this array.
     #[getter]
     fn id(slf: &Bound<Self>) -> PyResult<String> {
-        Ok(PyArrayRef::extract_bound(slf.as_any())?
+        Ok(PyArrayRef::extract(slf.as_any().as_borrowed())?
             .encoding_id()
             .to_string())
     }
 
     /// Returns the number of bytes used by this array.
     #[getter]
     fn nbytes(slf: &Bound<Self>) -> PyResult<u64> {
-        Ok(PyArrayRef::extract_bound(slf.as_any())?.nbytes())
+        Ok(PyArrayRef::extract(slf.as_any().as_borrowed())?.nbytes())
     }
 
     /// Returns the data type of this array.
@@ -392,48 +394,50 @@ impl PyArray {
     fn dtype<'py>(slf: &'py Bound<'py, Self>) -> PyResult<Bound<'py, PyDType>> {
         PyDType::init(
             slf.py(),
-            PyArrayRef::extract_bound(slf.as_any())?.dtype().clone(),
+            PyArrayRef::extract(slf.as_any().as_borrowed())?
+                .dtype()
+                .clone(),
         )
     }
 
     ///Rust docs are *not* copied into Python for __lt__: https://github.com/PyO3/pyo3/issues/4326
     fn __lt__(slf: Bound<Self>, other: PyArrayRef) -> PyResult<PyArrayRef> {
-        let slf = PyArrayRef::extract_bound(slf.as_any())?.into_inner();
+        let slf = PyArrayRef::extract(slf.as_any().as_borrowed())?.into_inner();
         let inner = compare(&slf, &*other, Operator::Lt)?;
         Ok(PyArrayRef::from(inner))
     }
 
     ///Rust docs are *not* copied into Python for __le__: https://github.com/PyO3/pyo3/issues/4326
     fn __le__(slf: Bound<Self>, other: PyArrayRef) -> PyResult<PyArrayRef> {
-        let slf = PyArrayRef::extract_bound(slf.as_any())?.into_inner();
+        let slf = PyArrayRef::extract(slf.as_any().as_borrowed())?.into_inner();
         let inner = compare(&*slf, &*other, Operator::Lte)?;
         Ok(PyArrayRef::from(inner))
     }
 
     ///Rust docs are *not* copied into Python for __eq__: https://github.com/PyO3/pyo3/issues/4326
     fn __eq__(slf: Bound<Self>, other: PyArrayRef) -> PyResult<PyArrayRef> {
-        let slf = PyArrayRef::extract_bound(slf.as_any())?.into_inner();
+        let slf = PyArrayRef::extract(slf.as_any().as_borrowed())?.into_inner();
         let inner = compare(&*slf, &*other, Operator::Eq)?;
         Ok(PyArrayRef::from(inner))
     }
 
     ///Rust docs are *not* copied into Python for __ne__: https://github.com/PyO3/pyo3/issues/4326
     fn __ne__(slf: Bound<Self>, other: PyArrayRef) -> PyResult<PyArrayRef> {
-        let slf = PyArrayRef::extract_bound(slf.as_any())?.into_inner();
+        let slf = PyArrayRef::extract(slf.as_any().as_borrowed())?.into_inner();
         let inner = compare(&*slf, &*other, Operator::NotEq)?;
         Ok(PyArrayRef::from(inner))
     }
 
     ///Rust docs are *not* copied into Python for __ge__: https://github.com/PyO3/pyo3/issues/4326
     fn __ge__(slf: Bound<Self>, other: PyArrayRef) -> PyResult<PyArrayRef> {
-        let slf = PyArrayRef::extract_bound(slf.as_any())?.into_inner();
+        let slf = PyArrayRef::extract(slf.as_any().as_borrowed())?.into_inner();
         let inner = compare(&*slf, &*other, Operator::Gte)?;
         Ok(PyArrayRef::from(inner))
     }
 
     ///Rust docs are *not* copied into Python for __gt__: https://github.com/PyO3/pyo3/issues/4326
     fn __gt__(slf: Bound<Self>, other: PyArrayRef) -> PyResult<PyArrayRef> {
-        let slf = PyArrayRef::extract_bound(slf.as_any())?.into_inner();
+        let slf = PyArrayRef::extract(slf.as_any().as_borrowed())?.into_inner();
         let inner = compare(&*slf, &*other, Operator::Gt)?;
         Ok(PyArrayRef::from(inner))
     }
@@ -467,7 +471,7 @@ impl PyArray {
     /// ]
     /// ```
     fn filter(slf: Bound<Self>, mask: PyArrayRef) -> PyResult<PyArrayRef> {
-        let slf = PyArrayRef::extract_bound(slf.as_any())?.into_inner();
+        let slf = PyArrayRef::extract(slf.as_any().as_borrowed())?.into_inner();
         let mask = (&*mask as &dyn Array).to_bool().to_mask_fill_null_false();
         let inner = vortex::compute::filter(&*slf, &mask)?;
         Ok(PyArrayRef::from(inner))
@@ -546,7 +550,7 @@ impl PyArray {
     // TODO(ngates): return a vortex.Scalar
     fn scalar_at(slf: Bound<Self>, index: usize) -> PyResult<Bound<PyScalar>> {
         let py = slf.py();
-        let slf = PyArrayRef::extract_bound(slf.as_any())?.into_inner();
+        let slf = PyArrayRef::extract(slf.as_any().as_borrowed())?.into_inner();
         PyScalar::init(py, slf.scalar_at(index))
     }
 
@@ -592,7 +596,7 @@ impl PyArray {
     /// ]
     /// ```
     fn take(slf: Bound<Self>, indices: PyArrayRef) -> PyResult<PyArrayRef> {
-        let slf = PyArrayRef::extract_bound(slf.as_any())?.into_inner();
+        let slf = PyArrayRef::extract(slf.as_any().as_borrowed())?.into_inner();
 
         if !indices.dtype().is_int() {
             return Err(PyValueError::new_err(format!(
@@ -608,7 +612,7 @@ impl PyArray {
 
     #[pyo3(signature = (start, end))]
     fn slice(slf: Bound<Self>, start: usize, end: usize) -> PyResult<PyArrayRef> {
-        let slf = PyArrayRef::extract_bound(slf.as_any())?.into_inner();
+        let slf = PyArrayRef::extract(slf.as_any().as_borrowed())?.into_inner();
         let inner = slf.slice(start..end);
         Ok(PyArrayRef::from(inner))
     }
@@ -643,14 +647,14 @@ impl PyArray {
     ///
     /// Compressed arrays often have more complex, deeply nested encoding trees.
     fn display_tree(slf: &Bound<Self>) -> PyResult<String> {
-        Ok(PyArrayRef::extract_bound(slf.as_any())?
+        Ok(PyArrayRef::extract(slf.as_any().as_borrowed())?
             .display_tree()
             .to_string())
     }
 
     fn serialize(slf: &Bound<Self>, ctx: &PyArrayContext) -> PyResult<Vec<Vec<u8>>> {
         // FIXME(ngates): do not copy to vec, use buffer protocol
-        let array = PyArrayRef::extract_bound(slf.as_any())?;
+        let array = PyArrayRef::extract(slf.as_any().as_borrowed())?;
         Ok(array
             .serialize(ctx, &Default::default())?
             .into_iter()
@@ -666,7 +670,7 @@ impl PyArray {
         slf: &'py Bound<'py, Self>,
     ) -> PyResult<(Bound<'py, PyAny>, Bound<'py, PyAny>)> {
         let py = slf.py();
-        let array = PyArrayRef::extract_bound(slf.as_any())?.into_inner();
+        let array = PyArrayRef::extract(slf.as_any().as_borrowed())?.into_inner();
 
         let mut encoder = MessageEncoder::default();
         let buffers = encoder.encode(EncoderMessage::Array(&*array));
@@ -698,7 +702,7 @@ impl PyArray {
             return Self::__reduce__(slf);
         }
 
-        let array = PyArrayRef::extract_bound(slf.as_any())?.into_inner();
+        let array = PyArrayRef::extract(slf.as_any().as_borrowed())?.into_inner();
 
         let mut encoder = MessageEncoder::default();
         let array_buffers = encoder.encode(EncoderMessage::Array(&*array));
 
@@ -172,7 +172,7 @@ impl PyNativeArray {
                 .add_subclass(subclass),
         )?
         .into_any()
-        .downcast_into::<PyNativeArray>()?)
+        .cast_into::<PyNativeArray>()?)
     }
 
     pub fn inner(&self) -> &ArrayRef {
Original file line number	Diff line number	Diff line change
`@@ -172,7 +172,7 @@ impl PyNativeArray {`
`172`	`172`	`.add_subclass(subclass),`
`173`	`173`	`)?`
`174`	`174`	`.into_any()`
`175`		`- .downcast_into::<PyNativeArray>()?)`
	`175`	`+ .cast_into::<PyNativeArray>()?)`
`176`	`176`	`}`
`177`	`177`
`178`	`178`	`pub fn inner(&self) -> &ArrayRef {`