Required trait bounds for a generic function using FromPyObject::extract?

[AntoineRR]

I would like to create a function returning a generic type that is built from a PyObject using the FromPyObject<'_> trait. However I face some lifetime issues that I do not understand. Here is a sample that reproduces the issue I face:

#[derive(FromPyObject)]
pub struct Test {
    pub first: String,
    pub second: String,
}

pub fn from_py_generic<'a, T: FromPyObject<'a>>(obj: Py<PyAny>) -> PyResult<T> {
    Python::with_gil(|py| obj.extract(py))
}

This fails to compile with the following error:

error[E0521]: borrowed data escapes outside of closure_test                                                                                             
  --> src/lib.rs:26:27
   |
25 | pub fn from_py_generic<'a, T: FromPyObject<'a>>(obj: Py<PyAny>) -> PyResult<T> {
   |                        -- lifetime `'a` defined here
26 |     Python::with_gil(|py| obj.extract(py))
   |                       --  ^^^^^^^^^^^^^^^
   |                       |   |
   |                       |   `py` escapes the closure body here
   |                       |   argument requires that `'1` must outlive `'a`
   |                       `py` is a reference that is only valid in the closure body
   |                       has type `pyo3::Python<'1>`


error[E0597]: `obj` does not live long enough/45: pyo3_test                                                                                             
  --> src/lib.rs:26:27
   |
25 | pub fn from_py_generic<'a, T: FromPyObject<'a>>(obj: Py<PyAny>) -> PyResult<T> {
   |                        -- lifetime `'a` defined here
26 |     Python::with_gil(|py| obj.extract(py))
   |                      ---- ^^^------------
   |                      |    |
   |                      |    borrowed value does not live long enough
   |                      |    argument requires that `obj` is borrowed for `'a`
   |                      value captured here
27 | }
   | - `obj` dropped here while still borrowed

What is weird is that the following code compiles without errors:

pub fn from_py(obj: Py<PyAny>) -> PyResult<Test> {
    Python::with_gil(|py| obj.extract(py))
}

pub fn from_py_generic_pyclass<'a, T: PyClass + Clone>(obj: Py<PyAny>) -> PyResult<T> {
    Python::with_gil(|py| obj.extract(py)) // There is an impl of FromPyObject for T: Pyclass + Clone
}

I would like to avoid implementing PyClass for my structs even if I would be able to use from_py_generic_pyclass with this trait. Is there a way to use only the FromPyObject<'_> trait bound, or am I missing another trait bound to make this work?

[mejrs]

Try using

pub fn from_py_generic<T: for <'a> FromPyObject<'a>>(obj: Py<PyAny>) -> PyResult<T> {
    Python::with_gil(|py| obj.extract(py))
}

[AntoineRR]

Thank you, that solved my issue!
I didn't know about this syntax. For people facing this later, I found more details here -> https://doc.rust-lang.org/nomicon/hrtb.html