bumps

Signed-off-by: Robert Kruszewski <[email protected]>

Author: robert3005

vortex-python/src/arrays/from_arrow.rs

@@ -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()

vortex-python/src/arrays/into_array.rs

@@ -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()

vortex-python/src/arrays/mod.rs

@@ -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));

vortex-python/src/arrays/native.rs

@@ -172,7 +172,7 @@ impl PyNativeArray {
                 .add_subclass(subclass),
         )?
         .into_any()
-        .downcast_into::<PyNativeArray>()?)
+        .cast_into::<PyNativeArray>()?)
     }
 
     pub fn inner(&self) -> &ArrayRef {

vortex-python/src/arrays/py/array.rs

@@ -4,7 +4,7 @@
 use std::sync::Arc;
 
 use pyo3::prelude::*;
-use pyo3::{Bound, FromPyObject, Py, PyAny, PyResult};
+use pyo3::{Bound, FromPyObject, Py, PyAny};
 use vortex::EncodingRef;
 use vortex::dtype::DType;
 use vortex::error::VortexError;
@@ -26,11 +26,14 @@ pub struct PythonArray {
     pub(super) stats: ArrayStats,
 }
 
-impl<'py> FromPyObject<'py> for PythonArray {
-    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
-        let python_array = ob.downcast::<PyPythonArray>()?.get();
+impl<'py> FromPyObject<'_, 'py> for PythonArray {
+    type Error = PyErr;
+
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> Result<Self, Self::Error> {
+        let ob_cast = ob.cast::<PyPythonArray>()?;
+        let python_array = ob_cast.get();
         Ok(Self {
-            object: Arc::new(ob.clone().unbind()),
+            object: Arc::new(ob.to_owned().unbind()),
             encoding: python_array.encoding.clone(),
             len: python_array.len,
             dtype: python_array.dtype.clone(),

vortex-python/src/arrays/py/encoding.rs

@@ -6,7 +6,7 @@ use std::sync::Arc;
 use pyo3::exceptions::PyValueError;
 use pyo3::prelude::*;
 use pyo3::types::PyType;
-use pyo3::{Bound, FromPyObject, Py, PyAny, PyResult};
+use pyo3::{FromPyObject, Py, PyAny};
 use vortex::EncodingId;
 
 /// Wrapper struct encapsulating a Python encoding.
@@ -18,15 +18,17 @@ pub struct PythonEncoding {
 }
 
 /// Convert a Python class into a [`PythonEncoding`].
-impl<'py> FromPyObject<'py> for PythonEncoding {
-    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
-        let cls = ob.downcast::<PyType>()?;
+impl<'py> FromPyObject<'_, 'py> for PythonEncoding {
+    type Error = PyErr;
+
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> Result<Self, Self::Error> {
+        let cls = ob.cast::<PyType>()?;
 
         let id = EncodingId::new_arc(
             cls.getattr("id")
                 .map_err(|_| {
                     PyValueError::new_err(format!(
-                        "PyEncoding subclass {ob} must have an 'id' attribute"
+                        "PyEncoding subclass {cls:?} must have an 'id' attribute"
                     ))
                 })?
                 .extract::<String>()
@@ -36,7 +38,7 @@ impl<'py> FromPyObject<'py> for PythonEncoding {
 
         Ok(PythonEncoding {
             id,
-            cls: Arc::new(cls.clone().unbind()),
+            cls: Arc::new(cls.to_owned().unbind()),
         })
     }
 }

vortex-python/src/arrays/py/python.rs

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use pyo3::conversion::FromPyObjectBound;
+use pyo3::conversion::FromPyObject;
 use pyo3::prelude::*;
 use pyo3::types::PyType;
 use vortex::EncodingRef;
@@ -33,8 +33,7 @@ impl PyPythonArray {
         len: usize,
         dtype: PyDType,
     ) -> PyResult<PyClassInitializer<Self>> {
-        let encoding =
-            PythonEncoding::from_py_object_bound(cls.as_any().as_borrowed())?.to_encoding();
+        let encoding = PythonEncoding::extract(cls.as_any().as_borrowed())?.to_encoding();
         Ok(PyClassInitializer::from(PyArray).add_subclass(Self {
             encoding,
             len,

vortex-python/src/arrays/py/vtable.rs

@@ -60,7 +60,7 @@ impl VTable for PythonVTable {
 
             let bytes = obj
                 .call_method("__vx_metadata__", (), None)?
-                .downcast::<PyBytes>()
+                .cast::<PyBytes>()
                 .map_err(|_| vortex_err!("Expected array metadata to be Python bytes"))?
                 .as_bytes()
                 .to_vec();