A #pyclass that has another #pyclass as attribute

[piotryordanov]

I have created a #pyclass struct Bar that has the #pyclass struct foo as attribute.

This code runs as expected, but I have some questions:

1. Is this the only way of doing it, or is there a more efficient way?
2. Does this mean that everytime I'm accessing a Foo attribute (or calling one of its methods), I have to use Python::with_gil(|py| and thus acquire the GIL?
3. If (2) is yes, then how does this impact paralellisme?

Thank you very much!

use pyo3::{prelude::*, types::PyType};
use rust_decimal::prelude::FromPrimitive;
use rust_decimal::Decimal;

#[pyclass(get_all)]
#[derive(Debug)]
pub struct Foo {
    pub inner: Decimal,
}

#[pyclass(get_all, subclass)]
#[derive(Debug)]
pub struct Bar {
    pub foo: Py<Foo>,
}

#[pymethods]
impl Bar {
    #[new]
    fn new() -> PyResult<Bar> {
        Python::with_gil(|py| {
            let foo: Py<Foo> = Py::new(
                py,
                Foo {
                    inner: Decimal::from_f64(24.1).unwrap(),
                },
            )?;
            Ok(Bar { foo })
        })
    }

    fn test(&self) {
        Python::with_gil(|py| {
            let val = self.foo.borrow(py);
            println!("Za val is this {:?}", val);
        });
    }
}

[davidhewitt]

1. This looks generally correct to me.
2. You can make the access cheaper by using #[pyclass(frozen)], and then you can use .get() instead of .borrow(py) and don't need the GIL.
3. Thankfully (2) has an alternative :)

[piotryordanov]

Oh, thank you for mentioning the frozen. It looks like exactly what I needed!

Follow-up questions:

1. Is Py<T> a reference/pointer?
2. If my frozen class has a test: Py<Test> attribute that itself is not frozen, if I do foo.get().test do I get a mutatable ref to the Test object?

#[pyclass(get_all, set_all)]
#[derive(Debug)]
pub struct Test {
    pub mine: Decimal,
}

#[pyclass(get_all, frozen)]
#[derive(Debug)]
pub struct Foo {
    pub inner: Decimal,
    pub test: Py<Test>,
}

[davidhewitt]

1. Yep Py<T> is a pointer to the Python object of type T.
2. The test attribute can be mutable, yes. (That will depend on whether Test is also frozen). You'd need to do foo.get().test.borrow_mut(py).