Added some missing functions

Author: Andrew J Westlake

src/async_std.rs

@@ -288,6 +288,40 @@ where
     generic::future_into_py_with_loop::<AsyncStdRuntime, F>(event_loop, fut)
 }
 
+/// Convert a Rust Future into a Python awaitable
+///
+/// # Arguments
+/// * `event_loop` - The Python event loop that the awaitable should be attached to
+/// * `fut` - The Rust future to be converted
+///
+/// # Examples
+///
+/// ```
+/// use std::time::Duration;
+///
+/// use pyo3::prelude::*;
+///
+/// /// Awaitable sleep function
+/// #[pyfunction]
+/// fn sleep_for<'p>(py: Python<'p>, secs: &'p PyAny) -> PyResult<&'p PyAny> {
+///     let secs = secs.extract()?;
+///     pyo3_asyncio::async_std::future_into_py_with_locals(
+///         py,
+///         pyo3_asyncio::async_std::get_current_locals(py)?,
+///         async move {
+///             async_std::task::sleep(Duration::from_secs(secs)).await;
+///             Python::with_gil(|py| Ok(py.None()))
+///         }
+///     )
+/// }
+/// ```
+pub fn future_into_py_with_locals<F>(py: Python, locals: TaskLocals, fut: F) -> PyResult<&PyAny>
+where
+    F: Future<Output = PyResult<PyObject>> + Send + 'static,
+{
+    generic::future_into_py_with_locals::<AsyncStdRuntime, F>(py, locals, fut)
+}
+
 /// Convert a Rust Future into a Python awaitable
 ///
 /// Unlike [`future_into_py_with_loop`], this function will stop the Rust future from running when
@@ -458,6 +492,59 @@ where
     generic::local_future_into_py_with_loop::<AsyncStdRuntime, _>(event_loop, fut)
 }
 
+/// Convert a `!Send` Rust Future into a Python awaitable
+///
+/// # Arguments
+/// * `event_loop` - The Python event loop that the awaitable should be attached to
+/// * `fut` - The Rust future to be converted
+///
+/// # Examples
+///
+/// ```
+/// use std::{rc::Rc, time::Duration};
+///
+/// use pyo3::prelude::*;
+///
+/// /// Awaitable non-send sleep function
+/// #[pyfunction]
+/// fn sleep_for(py: Python, secs: u64) -> PyResult<&PyAny> {
+///     // Rc is non-send so it cannot be passed into pyo3_asyncio::async_std::future_into_py
+///     let secs = Rc::new(secs);
+///     Ok(pyo3_asyncio::async_std::local_future_into_py_with_locals(
+///         py,
+///         pyo3_asyncio::async_std::get_current_locals(py)?,
+///         async move {
+///             async_std::task::sleep(Duration::from_secs(*secs)).await;
+///             Python::with_gil(|py| Ok(py.None()))
+///         }
+///     )?.into())
+/// }
+///
+/// # #[cfg(all(feature = "async-std-runtime", feature = "attributes"))]
+/// #[pyo3_asyncio::async_std::main]
+/// async fn main() -> PyResult<()> {
+///     Python::with_gil(|py| {
+///         let py_future = sleep_for(py, 1)?;
+///         pyo3_asyncio::async_std::into_future(py_future)
+///     })?
+///     .await?;
+///
+///     Ok(())
+/// }
+/// # #[cfg(not(all(feature = "async-std-runtime", feature = "attributes")))]
+/// # fn main() {}
+/// ```
+pub fn local_future_into_py_with_locals<F>(
+    py: Python,
+    locals: TaskLocals,
+    fut: F,
+) -> PyResult<&PyAny>
+where
+    F: Future<Output = PyResult<PyObject>> + 'static,
+{
+    generic::local_future_into_py_with_locals::<AsyncStdRuntime, _>(py, locals, fut)
+}
+
 /// Convert a `!Send` Rust Future into a Python awaitable
 ///
 /// Unlike [`local_future_into_py_with_loop`], this function will stop the Rust future from running when

src/tokio.rs

@@ -304,6 +304,40 @@ where
     generic::future_into_py_with_loop::<TokioRuntime, F>(event_loop, fut)
 }
 
+/// Convert a Rust Future into a Python awaitable
+///
+/// # Arguments
+/// * `event_loop` - The Python event loop that the awaitable should be attached to
+/// * `fut` - The Rust future to be converted
+///
+/// # Examples
+///
+/// ```
+/// use std::time::Duration;
+///
+/// use pyo3::prelude::*;
+///
+/// /// Awaitable sleep function
+/// #[pyfunction]
+/// fn sleep_for<'p>(py: Python<'p>, secs: &'p PyAny) -> PyResult<&'p PyAny> {
+///     let secs = secs.extract()?;
+///     pyo3_asyncio::tokio::future_into_py_with_locals(
+///         py,
+///         pyo3_asyncio::tokio::get_current_locals(py)?,
+///         async move {
+///             tokio::time::sleep(Duration::from_secs(secs)).await;
+///             Python::with_gil(|py| Ok(py.None()))
+///         }
+///     )
+/// }
+/// ```
+pub fn future_into_py_with_locals<F>(py: Python, locals: TaskLocals, fut: F) -> PyResult<&PyAny>
+where
+    F: Future<Output = PyResult<PyObject>> + Send + 'static,
+{
+    generic::future_into_py_with_locals::<TokioRuntime, F>(py, locals, fut)
+}
+
 /// Convert a Rust Future into a Python awaitable
 ///
 /// Unlike [`future_into_py_with_loop`], this function will stop the Rust future from running when