pub fn future_into_py<F, T>(py: Python<'_>, fut: F) -> PyResult<&PyAny>where
    F: Future<Output = PyResult<T>> + Send + 'static,
    T: IntoPy<PyObject>,
Expand description

Convert a Rust Future into a Python awaitable

If the asyncio.Future returned by this conversion is cancelled via asyncio.Future.cancel, the Rust future will be cancelled as well (new behaviour in v0.15).

Python contextvars are preserved when calling async Python functions within the Rust future via into_future (new behaviour in v0.15).

Although contextvars are preserved for async Python functions, synchronous functions will unfortunately fail to resolve them when called within the Rust future. This is because the function is being called from a Rust thread, not inside an actual Python coroutine context.

As a workaround, you can get the contextvars from the current task locals using get_current_locals and TaskLocals::context, then wrap your synchronous function in a call to This will set the context, call the synchronous function, and restore the previous context when it returns or raises an exception.


  • py - The current PyO3 GIL guard
  • fut - The Rust future to be converted


use std::time::Duration;

use pyo3::prelude::*;

/// Awaitable sleep function
fn sleep_for<'p>(py: Python<'p>, secs: &'p PyAny) -> PyResult<&'p PyAny> {
    let secs = secs.extract()?;
    pyo3_asyncio::async_std::future_into_py(py, async move {