PyRefMut<_, T> vs &Bound<_, T> vs T

[taegyunkim]

Hi,

Suppose we have a pure rust function in an external crate that I can't modify the source code, and which take the ownership of the passed arg.

pub fn rust_func(arg: T) -> anyhow::Result<()>; 

To call this from Python,
I initially created

#[pyclass]
pub struct TWrapper {
     inner: T
}

and the following

pub fn call_rust_func(py_arg: TWrapper) -> anyhow::Result<()> {
  rust_func(py_arg.inner)
}

After reading https://pyo3.rs/v0.23.5/types#pyo3s-smart-pointers, I wondered whehter this would require unnecessary copying of the py_arg.
So I was wondering whether

pub struct TWrapper{
    inner: Option<T> 
}

pub fn call_rust_func(py_arg: &Bound<_, TWrapper>) -> anyhow::Result<()> {
  let inner = (*py_arg.try_borrow_mut?).take().unwrap(); // omit error checking for simplicity
  rust_func(inner)
}

would be more efficient.

Then I also realized that the following also works

pub fn call_rust_func(mut py_arg: PyRefMut<_, TWrapper>) -> anyhow::Result<()>{
  let inner = (*py_arg).take().unwrap();
  rust_func(inner)
}

I wonder which one should be preferred in terms of performance, avoiding any unnecessary copy?

And if I can update the source code to put #[pyfunction] and #[pyclass] decorators on rust_func and T, does PyO3 make sure that the rust_func take ownership of the passed argument without copying?

[davidhewitt]

PyO3 doesn't support transfer of ownership out of Python objects and it's unlikely to be planned, see #2225

PyRefMut<T> and &Bound<T> are mostly equivalent and you can use whichever you prefer. &Bound<T> allows you to make the borrow shorter, which might be useful in concurrent situations.