Question about migrating from extract to extract_bound

[wangxiaoying]

I have a rust struct that contains a view of a ndarray with float type (that I'm going to manipulate in rust later):

use ndarray::{ArrayViewMut2, Axis, Ix2};
use numpy::{PyArray, PyArrayMethods};
use pyo3::{types::PyAnyMethods, FromPyObject, PyAny, PyResult};

pub struct Float64Block<'a> {
    data: ArrayViewMut2<'a, f64>,
}

My existing code of implementing extract is this:

impl<'a> FromPyObject<'a> for Float64Block<'a> {
    fn extract(ob: &'a PyAny) -> PyResult<Self> {
        let array = ob.downcast::<PyArray<f64, Ix2>>()?;
        let data = unsafe { array.as_array_mut() };
        Ok(Float64Block { data })
    }
}

The above code works fine. But I would encounter this lifetime issue when I migrate this code to extract_bound. In particular:

impl<'a> FromPyObject<'a> for Float64Block<'a> {
    fn extract_bound(ob: &pyo3::Bound<'a, PyAny>) -> PyResult<Self> {
        let array: &pyo3::Bound<'a, PyArray<f64, Ix2>> = ob.downcast()?;
        let data: ArrayViewMut2<'a, f64> = unsafe { array.as_array_mut() };
        let rs: Float64Block<'a> = Float64Block { data };
        Ok(rs)
    }
}

would result in the following compiler error:

error: lifetime may not live long enough
  --> src/pandas/pandas_columns/float64.rs:26:19
   |
15 | impl<'a> FromPyObject<'a> for Float64Block<'a> {
   |      -- lifetime `'a` defined here
...
23 |     fn extract_bound(ob: &pyo3::Bound<'a, PyAny>) -> PyResult<Self> {
   |                          - let's call the lifetime of this reference `'1`
...
26 |         let data: ArrayViewMut2<'a, f64> = unsafe { array.as_array_mut() };
   |                   ^^^^^^^^^^^^^^^^^^^^^^ type annotation requires that `'1` must outlive `'a`
   |
   = note: requirement occurs because of the type `ArrayBase<ViewRepr<&mut f64>, Dim<[usize; 2]>>`, which makes the generic argument `ViewRepr<&mut f64>` invariant
   = note: the struct `ArrayBase<S, D>` is invariant over the parameter `S`
   = help: see <https://doc.rust-lang.org/nomicon/subtyping.html> for more information about variance

Since I cannot change the function's signature like to fn extract_bound<'b: 'a>(ob: &'b pyo3::Bound<'a, PyAny>). Are there any suggestions on how should I handle this case?

[davidhewitt]

I think the solution here is you should use the FromPyObjectBound trait instead, which does have the additional lifetime.

https://docs.rs/pyo3/latest/pyo3/conversion/trait.FromPyObjectBound.html

We are intending to merge those adjustments into FromPyObject eventually, probably in 0.24. We're just taking time to be certain on the final design and evaluate if there's other changes we want to make to the trait at the same time. #4390

[davidhewitt]

Ah, but we sealed that trait while we weren't sure if we wanted users to implement it. 🤔

[wangxiaoying]

Thanks @davidhewitt for the quick reply!

It looks like the FromPyObjectBound is something needed in my case but it is indeed sealed. Are there any other workarounds that I can do under 0.22? Otherwise I guess I need to use the gil-refs feature and redirect to my old extract implementation for now.

[mejrs]

You should probably just make a function to do this. This also has the advantage that you can mark it unsafe, which you can't with FromPyObject.

[wangxiaoying]

Got it, thanks!