PyArray as PyClass attribute

[MathieuMoalic]

Hi there,
I'm a rust beginner who needs some help to get started with a project.
I wish to have a PyArray as a class attribute. From python it would look like this:

a = MyClass()
a.array = np.ones(3)

#[pyclass]
struct MyClass {
    array: PyArray<f32>,
}

And then the compiler screams at me because "the trait Send is not implemented", but all of this I got from the documentation, I change to #[pyclass(unsendable)] but now PyArray need the Clone trait, this one I can't figure out is the workaroud. I think rust-numpy uses ndarray under the hood and I guess one way to make a setter and getter fronction that would translate from a PyArray to a ndarray that I could store in my struct.
As you could tell, I'm a bit in over my head here. Any help appreciated.

[adamreichold]

You will generally not interact with PyArray<..> by value, but rather with &'py PyArray<..>, that is a shared reference to an ndarray object bound to a lifetime 'py for which the GIL is held. Or - and this probably applies here - with Py<PyArray<..>> that is a reference-counted ndarray with shared ownership managed by Python's heap.

This is not really specific to PyArray though but for example applies to most types from pyo3::types as well. You can read up on the details in PyO3's guide.

So long story short, you probably want

#[pyclass]
struct MyClass {
    #[pyo3(get, set)]
    array: Py<PyArray1<f32>>,
}

[MathieuMoalic]

Ah thanks ! It's much clearer now !

[MathieuMoalic]

Maybe as a follow up, how do I operate on the Py<PyArray1> ? For exemple this class method:

    fn double_array(&mut self) {
        self.array *= 2;
    }

[adamreichold]

You need to dereference the Py point and borrow the interior of the PyArray to get an ndarray::ArrayViewMut on which you can then operate using the functionality provided by the ndarray crate.

The details are explained in this crate's docs but your method would most likely look like this:

#[pymethods]
impl MyClass {
    fn double_array(&self, py: Python<'_>) {
        let mut array = self.array.as_ref(py).readwrite();
        let mut array = array.as_array_mut();
        array *= 2.0;
    }
}

I known it is a bit of a mouthful when applied to a field. When passing an ndarray into a function, this is usually a bit simpler by just having PyReadwriteArray as the argument, e.g.

#[pyfunction]
fn double_array(mut array: PyReadwriteArray1<f32>) {
    let mut array = array.as_array_mut();
    array *= 2.0;
}

[MathieuMoalic]

That's perfect. Thank for the fast and clear answers ! I really appreciate it.