simple reference example

[brentp]

Hi, I've seen similar questions here and perhaps here but I'm not able to grok the answer. I created a complete example here:
https://github.com/brentp/pyo3_ref/blob/main/src/lib.rs#L20

I'm not following how to get a mutable reference so the user can the field of a struct in python.

In short, given:

struct Data {
    x: [f64; 1000],
}

#[pyclass] 
struct PyData {
    data: Data
}

how can I expose the ability to mutate Data from python:

#[pymethods]
impl PyData {
    fn set_data(&mut self, i: usize, x: f64, py: Python<'_>) {
        // ???
        self.data.as_ref(py).x[i] = x;
    }
}

As you'll see in the github repo, I have another struct that returns the PyData. I'd like it to look like this in python:

outer.data[i] = 33.33

thanks for any pointers.

[brentp]

I found a way to make this work with Arc<Mutex<T>>> here
Does this approximates a best-practices way to approach this?

[adamreichold]

Usually not as the Py smart pointer together with the GIL basically serves the same purpose as Arc<Mutex<T>> in pure Rust code.

It usually depends on whether you want to share data structures between Rust code "behind the scenes" or with Python code. But I am not sure which roles Outer and PyData play in your example.

Generally speaking, if you want to share something with Python code by reference, then you need to put it into a Py<..> pointer.

If you just want to modify the interior of #[pyclass], you just add a #[pymethod] taking &mut self and our internal PyCell will perform the necessary borrow checking at runtime.

So the following should work:

pub struct Data {
    x: [f64; 1000],
}

#[pyclass]
pub struct PyData {
    data: Data,
}

#[pymethods]
impl PyData {
    fn set_data(&mut self, i: usize, x: f64) {
         self.data[i] = x;
    }
}

#[pyclass]
struct PyOuter {
    data: Py<PyData>,
}


#[pymethods]
impl PyOuter {
    #[getter]
    fn data(&mut self, py: Python<'_>) -> PyData {
        self.data.clone_ref(py)
    }
}

When you have something wrapped in Py<..>, you need the GIL to access it mutable, so from the outside you would need to do something like

#[pymethods]
impl PyOuter {
    fn set_data(&mut self, i: usize, x: f64, py: Python<'_>) {
         self.data.borrow_mut().data[i] = x;
    }
}

[brentp]

Thanks very much, I was able to get something working with this approach here

I am trying to provide python bindings to a rust library. So many of the python calls will need to access and call methods on the underlying rust struct. So it seems the PyCell stuff is the way to go.

[brentp]

I added this branch which actually contains the code I want to wrap with pyo3. (I should have done this to start as it's quite simple).

I want the python class (Variant) to own the underlying rust structure (vcf::Record) but I don't see a way to create new python references to the Variant without cloning.

In short, if I have:

#[pyclass]
struct Variant {
    inner: vcf::Record, // vcf::Record is the owned rust struct
}

how can I get another python reference to Variant? With the Arc<>, I can do:

clone = Variant { inner: Arc::clone(&self.inner) }

[adamreichold]

You need to change your self parameter, e.g. to basically clone the current reference:

#[pymethods]
impl Variant {
  fn clone_me(slf: Py<Self>) -> Py<Self> {
     slf
  }
}

[brentp]

thanks for the continued help. I again check through the examples and the docs, but it seems using references like this is not common. If there's an example I missed, please let me know.

Now I'm not understanding how to get Py<T> from T in the rust code within a #[pymethods] impl. so given:

#[pyclass]
struct Variant {
    inner: vcf::Record,
}

#[pyclass]
struct Info {
    variant: Py<Variant>,
}

#[pymethods]
impl Variant {
    /* ... */
    fn clone_me(slf: Py<Self>) -> Py<Self> {
        slf
    }

    #[getter]
    fn info(&self, py: Python<'_>) -> PyResult<Py<Info>> {
        // Q: how to get Py<Variant> from &mut Variant here?
        let v: Py<Variant> = Py::new(py, self);
        //                                 ^^^^^^^^^^^^^^^^^^ expected `Py<Variant>`, found `Py<&Variant>`
        let clone = Variant::clone_me(v);
        let info = Info { variant: clone };
        Py::new(py, info)
    }

how do I get a Py<Variant> inside of variant.info which accepts &mut self ?
Full code is here

thanks again.
-Brent

[adamreichold]

how do I get a Py inside of variant.info which accepts &mut self ?

It works the other way around, you take Py<Self> and get a &mut Self from that in the same way that our macros usually do automatically for you:

#[pymethods]
impl Variant {
    #[getter]
    fn info(slf: Py<Self>, py: Python<'_>) -> PyResult<Py<Info>> {
        let mut this: PyRefMut<Self> = slf.try_borrow_mut(py)?;
        let this: &mut Self = &mut *this;
        // Work with `this`...
        let info = Info { variant: slf };
        Py::new(py, info)
    }
}

[brentp]

thank you! That's working as:

    #[getter]
    fn info(slf: Py<Self>, py: Python<'_>) -> PyResult<Py<Info>> {
        let info = Info { variant: slf };
        Py::new(py, info)
    }