Help Wanted: future_into_py can’t be used inside async PyO3 methods due to Send bounds

[chitralverma]

When trying to call pyo3_async_runtimes::future_into_py inside an async PyO3 method (#[pymethods] pub async fn ...), compilation fails because the generated future captures a non-Send Python<'_> reference.

use pyo3::prelude::*;
use pyo3_async_runtimes::tokio::future_into_py;
use std::path::PathBuf;

#[pyclass]
pub struct Operator {
    core: Core,
}

#[pymethods]
impl Operator {
    #[pyo3(signature = (path, kwargs=None))]
    pub async fn stat(&self, path: PathBuf, kwargs: Option<Py<PyDict>>) -> PyResult<Metadata> {
        let this = self.core.clone();
        let path = path.to_string_lossy().to_string();

        let kwargs = Python::with_gil(|py| {
            kwargs.map(|v| v.bind(py).extract::<StatOptions>()).transpose()
        })?.unwrap_or_default();

        future_into_py(py, async move {
            this.stat_options(&path, kwargs.into())
                .await
                .map_err(format_pyerr)
                .map(Metadata::new)
        })
    }
}

Error:

error: future cannot be sent between threads safely
   --> src/operator.rs:489:1
    |
489 | #[pymethods]
    | ^^^^^^^^^^^^ future created by async block is not `Send`
    |
    = help: within `{async block@src/operator.rs:489:1: 489:13}`, the trait `std::marker::Send` is not implemented for `*mut pyo3::Python<'static>`
note: captured value is not `Send`
   --> src/operator.rs:489:1
    |
489 | #[pymethods]
    | ^^^^^^^^^^^^ has type `pyo3::Python<'_>` which is not `Send`
note: required by a bound in `new_coroutine`
   --> /.../pyo3-0.26.0/src/impl_/coroutine.rs:22:40
    |
15  | pub fn new_coroutine<'py, F, T, E>(
    |        ------------- required by a bound in this function
...
22  |     F: Future<Output = Result<T, E>> + Send + 'static,
    |                                        ^^^^ required by this bound in `new_coroutine`

This happens because the PyO3 async coroutine internally captures a Python<'_>, which is not Send, but future_into_py currently requires Future + Send + 'static.

Could pyo3_async_runtimes provide a *_non_send or similar variant usable inside async PyO3 methods? This would make it possible to use future_into_py ergonomically from PyO3’s experimental async methods without manual runtime bridging or Send issues.

Or if there is an alternate way of solving this, it will be a great help. thanks!

Context:

• PyO3: 0.26.0 (with experimental-async feature)
• pyo3_async_runtimes: 0.26.0
• Runtime: Tokio

[jessekrubin]

I am not sure and I am on a phone, but my gut says that the first thing I would try would be moving the future creation outside of the inner closure

use pyo3::prelude::*;
use pyo3_async_runtimes::tokio::future_into_py;
use std::path::PathBuf;

#[pyclass]
pub struct Operator {
    core: Core,
}

#[pymethods]
impl Operator {
    #[pyo3(signature = (path, kwargs=None))]
    pub async fn stat(&self, path: PathBuf, kwargs: Option<Py<PyDict>>) -> PyResult<Metadata> {
        let this = self.core.clone();
        let path = path.to_string_lossy().to_string();

        let kwargs = Python::with_gil(|py| {
            kwargs.map(|v| v.bind(py).extract::<StatOptions>()).transpose()
        })?.unwrap_or_default();

        let thingy =          this.stat_options(&path, kwargs.into());
        future_into_py(py, async move {
            thingy
                .await
                .map_err(format_pyerr)
                .map(Metadata::new)
        })
    }
}

[chitralverma]

@jessekrubin thanks for your response, but this doesn't work.

Here's an even simpler case

#[pymethods] // <-- future cannot be sent between threads safely, the trait `std::marker::Send` is not implemented for `*mut pyo3::Python<'static>`. note: captured value is not `Send`
impl Clazz {
    pub async fn stat3<'p>(&self,py: Python<'p>) -> PyResult<Bound<'p, PyAny>> {
        let thingy = async { Ok(12) };
        future_into_py(py, thingy) // <-- `py` is required by future_into_py
    }
}

Edit 1:

Managed to get the following to work, but now on python side i have to call await twice (await (await op.stat4("file.txt")))

#[pyo3(signature = (path, **kwargs))]
    pub async fn stat4<'p>(
        &self,
        path: PathBuf,
        kwargs: Option<Py<PyDict>>,
    ) -> PyResult<Py<PyAny>> {
        let this = self.core.clone();
        let path = path.to_string_lossy().to_string();

        let kwargs = Python::attach(|py| {
            kwargs
                .map(|v| v.bind(py).extract::<StatOptions>())
                .transpose()
        })?
        .unwrap_or_default();

        Python::attach(|py| {
            future_into_py(py, async move {
                this.stat_options(&path, kwargs.into())
                    .await
                    .map_err(format_pyerr)
                    .map(Metadata::new)
            })
            .and_then(|x| x.into_py_any(py))
        })
    }

[douglasdavis]

The method needs to be a regular function, not async. pyo3-async-runtimes future_into_py immediately returns a Python Future (that is avaitable on the Python side by internally adhering to Python async/futures interfaces). This is just an artifact of the design of the library; there’s WIP for supporting ‘async fn’ with PyO3 behind the experimental-async feature flag right now

…

On Tue, Oct 14, 2025, at 02:44, Chitral Verma wrote: *chitralverma* left a comment (PyO3/pyo3-async-runtimes#67) <#67 (comment)> @jessekrubin <https://github.com/jessekrubin> thanks for your response, but this doesn't work. Here's an even simpler case #[pymethods] // <-- future cannot be sent between threads safely, the trait `std::marker::Send` is not implemented for `*mut pyo3::Python<'static>`. note: captured value is not `Send` impl Clazz { pub async fn stat3<'p>(&self,py: Python<'p>) -> PyResult<Bound<'p, PyAny>> { let thingy = async { Ok(12) }; future_into_py(py, thingy) } } — Reply to this email directly, view it on GitHub <#67 (comment)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AAYNYKVHDSFWHWZMTXVHOQD3XSSVLAVCNFSM6AAAAACJCW6ECKVHI2DSMVQWIX3LMV43OSLTON2WKQ3PNVWWK3TUHMZTIMBQGUYTKMZZHA>. You are receiving this because you are subscribed to this thread.Message ID: ***@***.***>

[chitralverma]

there’s WIP for supporting ‘async fn’ with PyO3 behind the experimental-async feature flag right now

thanks @douglasdavis for the info. is there a tracking ticket or PR for this that i can watch?

[douglasdavis]

See this docs section: https://pyo3.rs/v0.26.0/async-await

…

On Tue, Oct 14, 2025, at 09:27, Chitral Verma wrote: *chitralverma* left a comment (PyO3/pyo3-async-runtimes#67) <#67 (comment)> > there’s WIP for supporting ‘async fn’ with PyO3 behind the experimental-async feature flag right now > thanks @douglasdavis <https://github.com/douglasdavis> for the info. is there a tracking ticket or PR for this that i can watch? — Reply to this email directly, view it on GitHub <#67 (comment)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AAYNYKW5XYTQS6GKQX5VY333XUB5XAVCNFSM6AAAAACJCW6ECKVHI2DSMVQWIX3LMV43OSLTON2WKQ3PNVWWK3TUHMZTIMBSGE2TCOJZGM>. You are receiving this because you were mentioned.Message ID: ***@***.***>

[jessekrubin]

@chitralverma aha! yes. my bad. I missed that it was an async function. It should not be async as @douglasdavis pointed out, which I forgot I do all over the place (eg https://github.com/jessekrubin/ry/blob/372b2b162558f19f190d9dad6f93e2610d02a2e6/crates/ryo3-reqwest/src/client.rs#L401)