Returning PyArray from struct

[realiti4]

Hi,

I'm having a little bit of an issue when I try to use structs. I want to return an array to python, but without a luck. I tried many things, read docs, search online but coudn't find. I'd appreciate if you could point out what I am doing wrong. I am new to Rust and rust-numpy.

Here is an example code:

#[pyclass]
pub struct Process {
    data: Array1<f64>
}

#[pymethods]
impl Process {
    #[new]
    fn new(value: PyReadonlyArray1<f64>) -> Self {
        let array = value.as_array().to_owned();

        Process { 
            data: array
        }
    }

    fn my_array(&self) -> PyArray1<f64> {
        // return array
    }
}

[adamreichold]

In this case, since you store a ndarray::Array1 and have a shared reference to &self, you need to copy the underlying array into a NumPy array using the ToPyArray trait, e.g.

fn my_array(&self, py: Python<'_>) -> PyArray1<f64> {
    self.data.to_pyarray(py)
}

[realiti4]

Hi, thanks a lot, I think it works now. I tried it, got the following error:

102 |     fn my_array(&self, py: Python<'_>) -> PyArray1<f64> {
    |                                           ------------- expected `PyArray<f64, Dim<[usize; 1]>>` because of return type
103 |         self.data.to_pyarray(py)
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ expected `PyArray<f64, Dim<[usize; 1]>>`, found `&PyArray<f64, Dim<[usize; 1]>>`

Tried this and it works. Is this usage correct?

fn my_array(&self, py: Python<'_>) -> Py<PyArray1<f64>> {
        self.data.to_pyarray(py).to_owned()
    }

Why does it returning just PyArray work in a normal function like below, but I had to use smart pointer Py above?

#[pyfn(m)]
#[pyo3(name = "pow")]
fn pow_py<'py>(py: Python<'py>, x: PyReadonlyArrayDyn<'py, f64>) -> &'py PyArray1<f64> {
  let x = x.as_array();
  let result = pow(x);
  
  result.into_pyarray(py)
}

[adamreichold]

I am sorry, there was a typo in the proposed implementation. You can return a reference from a method just as you can from a function, e.g.

fn my_array(&self, py: Python<'_>) -> &PyArray1<f64> {
    self.data.to_pyarray(py)
}

should work.

[realiti4]

I am getting the following error when returning a reference

102 |     fn my_array(&self, py: Python<'_>) -> &PyArray1<f64> {
    |                 -      -- has type `pyo3::Python<'1>`
    |                 |
    |                 let's call the lifetime of this reference `'2`
103 |         self.data.to_pyarray(py)
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ method was supposed to return data with lifetime `'2` but it is returning data with lifetime `'1`

[adamreichold]

Ah yes, for methods, the inferred lifetime is always that attached to the &self reference, so you have to make the lifetime explicit, i.e.

fn my_array<'py>(&self, py: Python<'py>) -> &'py PyArray1<f64> {
    self.data.to_pyarray(py)
}

(The inferred version would have been

fn my_array<'a, 'b>(&'a self, py: Python<'b>) -> &'a PyArray1<f64> {
    self.data.to_pyarray(py)
}

which does not work as you describe.)

[realiti4]

Oh, it all make sense now. Thanks a lot for helping me out.