使用 pyo3 在闭包方面实现装饰器

Question

作为学习练习，我正在尝试使用闭包在 pyo3 中实现参数化装饰器 function。 pyo3 文档包含一个（非参数化）装饰器的示例，它使用__call__方法实现为 class，我在此基础上构建并使用外部 class 和__call__方法创建了一个参数化装饰器，该方法返回内部 class 和调用目标 function 的__call__ ，它可以工作。 但是作为一个学习练习（我可以特别提高我对生命周期的理解）我想尝试在闭包方面实现同样的事情。 （注意，我以前用 C++ 中的 lambda 做过这个）

所以我的非参数化装饰器，在与编译器进行了一些试验和斗争之后，看起来像这样：

#[pyfunction]
pub fn exectime(py: Python, wraps: PyObject) -> PyResult<&PyCFunction> {
    PyCFunction::new_closure(
        py, None, None,
        move |args: &PyTuple, kwargs: Option<&PyDict>| -> PyResult<PyObject> {
            Python::with_gil(|py| {
                let now = Instant::now();
                let ret = wraps.call(py, args, kwargs);
                println!("elapsed (ms): {}", now.elapsed().as_millis());
                ret
            })
        }
    )
}

请注意，我需要将捕获的py包装在Python::with_gil中以使其工作。 试图将其扩展到我想出的嵌套装饰器：

#[pyfunction]
pub fn average_exectime(py: Python, n: usize) -> PyResult<&PyCFunction> {
    let f = move |args: &PyTuple, _kwargs: Option<&PyDict>| -> PyResult<&PyCFunction> {
        Python::with_gil(|py| {
            let wraps: PyObject = args.get_item(0)?.into();
            let g = move |args: &PyTuple, kwargs: Option<&PyDict>| -> PyResult<PyObject> {
                Python::with_gil(|py| {
                    let now = Instant::now();
                    for _ in 0..n-1 {
                        wraps.call(py, args, kwargs);
                    }
                    let ret = wraps.call(py, args, kwargs);
                    println!("elapsed (ms): {}", now.elapsed().as_millis());
                    ret
                })
            };
            PyCFunction::new_closure(py, None, None, g)
        })
    };
    PyCFunction::new_closure(py, None, None, f)
}

为此，编译器告诉我：

error: lifetime may not live long enough ] 44/45: poetry-rust-integration
  --> src/decorator.rs:48:13
   |
35 |         Python::with_gil(|py| {
   |                           --- return type of closure is Result<&'2 pyo3::types::PyCFunction, pyo3::PyErr>
   |                           |
   |                           has type `pyo3::Python<'1>`
...
48 |             PyCFunction::new_closure(py, None, None, g)
   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ returning this value requires that `'1` must outlive `'2`


    Building [=========================> ] 44/45: poetry-rust-integration                                                                                                                              error: aborting due to previous error

我已经尝试了各种生命周期参数，包括封闭生命周期都无济于事，我最终会遇到更多错误。 我想我不明白为什么编译器认为内部生命周期必须比另一个生命周期长？ 告诉编译器它们都具有相同的生命周期还不够吗？ 如果是这样，如何实现这一目标？

Answer 1

pub fn new_closure<'a, F, R>(
    py: Python<'a>,
    name: Option<&'static str>,
    doc: Option<&'static str>,
    closure: F
) -> PyResult<&'a PyCFunction>

所以你得到的&PyCFunction只对with_gil块的范围有效。

要使 function 的寿命超过 GIL 块，您需要将其转换为独立于 GIL 的引用。

Answer 2

非常感谢 Masklinn 解释了错误并为我指明了正确的方向。 我现在有这个工作解决方案：

#[pyfunction]
pub fn average_exectime(py: Python, n: usize) -> PyResult<&PyCFunction> {
    let f = move |args: &PyTuple, _kwargs: Option<&PyDict>| -> PyResult<Py<PyCFunction>> {
        Python::with_gil(|py| {
            let wraps: PyObject = args.get_item(0)?.into();
            let g = move |args: &PyTuple, kwargs: Option<&PyDict>| -> PyResult<PyObject> {
                Python::with_gil(|py| {
                    let now = Instant::now();
                    let mut result: PyObject = py.None();
                    for _ in 0..n {
                        result = wraps.call(py, args, kwargs)?;
                    }
                    println!("elapsed (ms): {}", now.elapsed().as_millis());
                    Ok(result)
                })
            };
            match PyCFunction::new_closure(py, None, None, g) {
                Ok(r) => Ok(r.into()),
                Err(e) => Err(e)
            }
        })
    };
    PyCFunction::new_closure(py, None, None, f)
}