feat: support anyio with a Cargo feature

Asyncio is the standard and de facto main Python async runtime.
Among non-standard runtime, only trio seems to have substantial traction,
especially thanks to the anyio project.
There is indeed a strong trend for anyio (e.g. FastApi), which can
justify a dedicated support.

Author: wyfo

Cargo.toml

@@ -63,6 +63,9 @@ pyo3-build-config = { path = "pyo3-build-config", version = "0.21.0-dev", featur
 [features]
 default = ["macros"]
 
+# Switch coroutine implementation to anyio instead of asyncio
+anyio = ["macros"]
+
 # Enables pyo3::inspect module and additional type information on FromPyObject
 # and IntoPy traits
 experimental-inspect = []

guide/src/async-await.md

@@ -22,8 +22,6 @@ async fn sleep(seconds: f64, result: Option<PyObject>) -> Option<PyObject> {
 }
 ```
 
-*Python awaitables instantiated with this method can only be awaited in *asyncio* context. Other Python async runtime may be supported in the future.*
-
 ## `Send + 'static` constraint
 
 Resulting future of an `async fn` decorated by `#[pyfunction]` must be `Send + 'static` to be embedded in a Python object.
@@ -85,6 +83,13 @@ async fn cancellable(#[pyo3(cancel_handle)]mut cancel: CancelHandle) {
 }
 ```
 
+## *asyncio* vs. *anyio*
+
+By default, Python awaitables instantiated with `async fn` can only be awaited in *asyncio* context. 
+
+PyO3 can also target [*anyio*](https://github.com/agronholm/anyio) with the dedicated `anyio` Cargo feature. With it enabled, `async fn` become awaitable both in *asyncio* or [*trio*](https://github.com/python-trio/trio) context.
+However, it requires to have the [*sniffio*](https://github.com/python-trio/sniffio) (or *anyio*) library installed.
+
 ## The `Coroutine` type
 
 To make a Rust future awaitable in Python, PyO3 defines a [`Coroutine`]({{#PYO3_DOCS_URL}}/pyo3/coroutine/struct.Coroutine.html) type, which implements the Python [coroutine protocol](https://docs.python.org/3/library/collections.abc.html#collections.abc.Coroutine). 

guide/src/building_and_distribution.md

@@ -62,6 +62,7 @@ There are many ways to go about this: it is possible to use `cargo` to build the
 PyO3 has some Cargo features to configure projects for building Python extension modules:
  - The `extension-module` feature, which must be enabled when building Python extension modules.
  - The `abi3` feature and its version-specific `abi3-pyXY` companions, which are used to opt-in to the limited Python API in order to support multiple Python versions in a single wheel.
+- The `anyio` feature, making PyO3 coroutines target [*anyio*](https://github.com/agronholm/anyio) instead of *asyncio*; either [*sniffio*](https://github.com/python-trio/sniffio) or *anyio* should be added as dependency of the Python extension.
 
 This section describes each of these packaging tools before describing how to build manually without them. It then proceeds with an explanation of the `extension-module` feature. Finally, there is a section describing PyO3's `abi3` features.
 

newsfragments/3612.added.md

@@ -0,0 +1 @@
+Support anyio with a Cargo feature

pytests/Cargo.toml

@@ -7,7 +7,8 @@ edition = "2021"
 publish = false
 
 [dependencies]
-pyo3 = { path = "../", features = ["extension-module"] }
+futures = "0.3.29"
+pyo3 = { path = "../", features = ["extension-module", "anyio"] }
 
 [build-dependencies]
 pyo3-build-config = { path = "../pyo3-build-config" }

pytests/requirements-dev.txt

@@ -1,3 +1,4 @@
+anyio[trio]>=4.0
 hypothesis>=3.55
 pytest>=6.0
 pytest-asyncio>=0.21

pytests/src/anyio.rs

@@ -0,0 +1,21 @@
+use futures::channel::oneshot;
+use pyo3::prelude::*;
+use std::thread;
+use std::time::Duration;
+
+#[pyfunction]
+async fn sleep(seconds: f64, result: Option<PyObject>) -> Option<PyObject> {
+    let (tx, rx) = oneshot::channel();
+    thread::spawn(move || {
+        thread::sleep(Duration::from_secs_f64(seconds));
+        tx.send(()).unwrap();
+    });
+    rx.await.unwrap();
+    result
+}
+
+#[pymodule]
+pub fn anyio(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
+    m.add_function(wrap_pyfunction!(sleep, m)?)?;
+    Ok(())
+}

pytests/src/lib.rs

@@ -2,6 +2,7 @@ use pyo3::prelude::*;
 use pyo3::types::PyDict;
 use pyo3::wrap_pymodule;
 
+pub mod anyio;
 pub mod awaitable;
 pub mod buf_and_str;
 pub mod comparisons;
@@ -18,6 +19,7 @@ pub mod subclassing;
 
 #[pymodule]
 fn pyo3_pytests(py: Python<'_>, m: &PyModule) -> PyResult<()> {
+    m.add_wrapped(wrap_pymodule!(anyio::anyio))?;
     m.add_wrapped(wrap_pymodule!(awaitable::awaitable))?;
     #[cfg(not(Py_LIMITED_API))]
     m.add_wrapped(wrap_pymodule!(buf_and_str::buf_and_str))?;
@@ -39,6 +41,7 @@ fn pyo3_pytests(py: Python<'_>, m: &PyModule) -> PyResult<()> {
 
     let sys = PyModule::import(py, "sys")?;
     let sys_modules: &PyDict = sys.getattr("modules")?.downcast()?;
+    sys_modules.set_item("pyo3_pytests.anyio", m.getattr("anyio")?)?;
     sys_modules.set_item("pyo3_pytests.awaitable", m.getattr("awaitable")?)?;
     sys_modules.set_item("pyo3_pytests.buf_and_str", m.getattr("buf_and_str")?)?;
     sys_modules.set_item("pyo3_pytests.comparisons", m.getattr("comparisons")?)?;

pytests/tests/test_anyio.py

@@ -0,0 +1,14 @@
+import asyncio
+
+from pyo3_pytests.anyio import sleep
+import trio
+
+
+def test_asyncio():
+    assert asyncio.run(sleep(0)) is None
+    assert asyncio.run(sleep(0.1, 42)) == 42
+
+
+def test_trio():
+    assert trio.run(sleep, 0) is None
+    assert trio.run(sleep, 0.1, 42) == 42

src/coroutine.rs

@@ -18,8 +18,12 @@ use crate::{
     IntoPy, Py, PyErr, PyObject, PyResult, Python,
 };
 
+#[cfg(feature = "anyio")]
+mod anyio;
 mod asyncio;
 pub(crate) mod cancel;
+#[cfg(feature = "anyio")]
+mod trio;
 pub(crate) mod waker;
 
 use crate::coroutine::cancel::ThrowCallback;