Merge pull request #3 from awestlake87/other-runtimes

Support for other runtimes (closes #2)

Author: awestlake87

.githooks/pre-commit

@@ -1,3 +1,3 @@
 #!/bin/bash
 
-cargo check --all-targets --features testing
+cargo check --all-targets --all-features

.githooks/pre-push

@@ -1,4 +1,4 @@
 #!/bin/bash
 
 make clippy
-cargo test --features testing
+make test

.github/workflows/ci.yml

@@ -84,29 +84,16 @@ jobs:
         name: Prepare LD_LIBRARY_PATH (Ubuntu only)
         run: echo LD_LIBRARY_PATH=${pythonLocation}/lib >> $GITHUB_ENV
 
-      - name: Build docs
-        run: cargo doc --no-default-features --features testing --verbose --target ${{ matrix.platform.rust-target }}
-
       - name: Build (no features)
         run: cargo build --no-default-features --verbose --target ${{ matrix.platform.rust-target }}
 
       - name: Build (all additive features)
-        run: cargo build --no-default-features --features testing --verbose --target ${{ matrix.platform.rust-target }}
+        run: cargo build --all-features --verbose --target ${{ matrix.platform.rust-target }}
 
       # Run tests (except on PyPy, because no embedding API).
       - if: matrix.python-version != 'pypy-3.6'
         name: Test
-        run: cargo test --no-default-features --features testing --target ${{ matrix.platform.rust-target }}
-
-      # Run tests again, but in abi3 mode
-      - if: matrix.python-version != 'pypy-3.6'
-        name: Test (abi3)
-        run: cargo test --no-default-features --features testing --target ${{ matrix.platform.rust-target }}
-
-      # Run tests again, for abi3-py36 (the minimal Python version)
-      - if: (matrix.python-version != 'pypy-3.6') && (matrix.python-version != '3.6')
-        name: Test (abi3-py36)
-        run: cargo test --no-default-features --features testing --target ${{ matrix.platform.rust-target }}
+        run: cargo test --all-features --target ${{ matrix.platform.rust-target }}
 
       - name: Install python test dependencies
         run: |
@@ -138,7 +125,7 @@ jobs:
       - uses: actions-rs/cargo@v1
         with:
           command: test 
-          args: --features testing
+          args: --all-features
         env:
           CARGO_INCREMENTAL: 0
           RUSTFLAGS: "-Zprofile -Ccodegen-units=1 -Cinline-threshold=0 -Clink-dead-code -Coverflow-checks=off -Cpanic=abort -Zpanic_abort_tests"

.github/workflows/guide.yml

@@ -21,7 +21,7 @@ jobs:
         # This adds the docs to gh-pages-build/doc
       - name: Build the doc
         run: |
-          cargo doc --no-deps --features testing
+          cargo doc --no-deps --all-features
           mkdir -p gh-pages-build
           cp -r target/doc gh-pages-build/doc
           echo "<meta http-equiv=refresh content=0;url=pyo3_asyncio/index.html>" > gh-pages-build/doc/index.html

Cargo.toml

@@ -2,30 +2,74 @@
 name = "pyo3-asyncio"
 version = "0.13.0"
 authors = ["Andrew J Westlake <[email protected]>"]
+readme = "README.md"
+keywords = ["pyo3", "pyo3-asyncio", "python", "cpython", "ffi", "async", "asyncio"]
+homepage = "https://github.com/awestlake87/pyo3-asyncio"
+repository = "https://github.com/awestlake87/pyo3-asyncio"
+documentation = "https://docs.rs/crate/pyo3-asyncio/"
+categories = ["api-bindings", "development-tools::ffi"]
+license = "Apache-2.0"
+exclude = ["/.gitignore", "/codecov.yml", "/Makefile"]
 edition = "2018"
 
+
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [features]
+async-std-runtime = ["async-std"]
 testing = ["clap"]
+tokio-runtime = ["tokio"]
 default = []
 
 [[test]]
-name = "test_asyncio"
-path = "pytests/test_asyncio.rs"
+name = "test_async_std_asyncio"
+path = "pytests/test_async_std_asyncio.rs"
+harness = false
+required-features = ["async-std-runtime", "testing"]
+
+[[test]]
+name = "test_async_std_run_forever"
+path = "pytests/test_async_std_run_forever.rs"
 harness = false
-required-features = ["testing"]
+required-features = ["async-std-runtime", "testing"]
 
 [[test]]
-name = "test_run_forever"
-path = "pytests/test_run_forever.rs"
+name = "test_tokio_current_thread_asyncio"
+path = "pytests/test_tokio_current_thread_asyncio.rs"
 harness = false
-required-features = ["testing"]
+required-features = ["tokio-runtime", "testing"]
+
+[[test]]
+name = "test_tokio_current_thread_run_forever"
+path = "pytests/test_tokio_current_thread_run_forever.rs"
+harness = false
+required-features = ["tokio-runtime", "testing"]
+
+[[test]]
+name = "test_tokio_multi_thread_asyncio"
+path = "pytests/test_tokio_multi_thread_asyncio.rs"
+harness = false
+required-features = ["tokio-runtime", "testing"]
+
+[[test]]
+name = "test_tokio_multi_thread_run_forever"
+path = "pytests/test_tokio_multi_thread_run_forever.rs"
+harness = false
+required-features = ["tokio-runtime", "testing"]
 
 [dependencies]
 clap = { version = "2.33", optional = true }
 futures = "0.3"
 lazy_static = "1.4"
 once_cell = "1.5"
 pyo3 = "0.13"
-tokio = { version = "1.0", features = ["full"] }
+
+[dependencies.async-std]
+version = "1.9"
+features = ["unstable"]
+optional = true
+
+[dependencies.tokio]
+version = "1.0" 
+features = ["full"]
+optional = true

Makefile

@@ -12,7 +12,7 @@ lint: fmt clippy
 	@true
 
 test: lint
-	cargo test --features testing
+	cargo test --all-features
 
 publish: test
 	cargo publish

README.md

@@ -13,9 +13,18 @@
 
 > PyO3 Asyncio is a _brand new_ part of the broader PyO3 ecosystem. Feel free to open any issues for feature requests or bugfixes for this crate.
 
+## Known Problems
+
+Currently, this library can give spurious failures during finalization. A solution should be released for PyO3 soon, but in the meantime you can add this patch to your `Cargo.toml` to use the master branch for PyO3
+
+```toml
+[patch.crates-io]
+pyo3 = { git = "https://github.com/PyO3/pyo3" }
+```
+
 ## Quickstart
 
-Here we initialize the runtime, import Python's `asyncio` library and run the given future to completion using Python's default `EventLoop` and Tokio. Inside the future, we convert `asyncio` sleep into a Rust future and await it.
+Here we initialize the runtime, import Python's `asyncio` library and run the given future to completion using Python's default `EventLoop` and `async-std`. Inside the future, we convert `asyncio` sleep into a Rust future and await it.
 
 More details on the usage of this library can be found in the [API docs](https://awestlake87.github.io/pyo3-asyncio/master/doc).
 
@@ -29,7 +38,7 @@ fn main() {
             let asyncio: PyObject = py.import("asyncio")?.into();
 
             // Run the event loop until the given future completes
-            pyo3_asyncio::run_until_complete(py, async move {
+            pyo3_asyncio::async_std::run_until_complete(py, async move {
                 Python::with_gil(|py| {
                     // convert asyncio.sleep into a Rust Future
                     pyo3_asyncio::into_future(

pytests/common/mod.rs

@@ -0,0 +1,37 @@
+use std::{future::Future, thread, time::Duration};
+
+use pyo3::prelude::*;
+
+pub(super) const TEST_MOD: &'static str = r#"
+import asyncio 
+
+async def py_sleep(duration):
+    await asyncio.sleep(duration)
+
+async def sleep_for_1s(sleep_for):
+    await sleep_for(1)
+"#;
+
+pub(super) fn test_into_future(
+    py: Python,
+) -> PyResult<impl Future<Output = PyResult<()>> + Send + 'static> {
+    let test_mod: PyObject =
+        PyModule::from_code(py, TEST_MOD, "test_rust_coroutine/test_mod.py", "test_mod")?.into();
+
+    Ok(async move {
+        Python::with_gil(|py| {
+            pyo3_asyncio::into_future(
+                py,
+                test_mod
+                    .call_method1(py, "py_sleep", (1.into_py(py),))?
+                    .as_ref(py),
+            )
+        })?
+        .await?;
+        Ok(())
+    })
+}
+
+pub(super) fn test_blocking_sleep() {
+    thread::sleep(Duration::from_secs(1));
+}

pytests/test_async_std_asyncio.rs

@@ -0,0 +1,111 @@
+mod common;
+
+use std::{future::Future, time::Duration};
+
+use async_std::task;
+use pyo3::{prelude::*, wrap_pyfunction};
+
+use pyo3_asyncio::{
+    async_std::testing::{new_sync_test, test_main},
+    testing::Test,
+};
+
+#[pyfunction]
+fn sleep_for(py: Python, secs: &PyAny) -> PyResult<PyObject> {
+    let secs = secs.extract()?;
+
+    pyo3_asyncio::async_std::into_coroutine(py, async move {
+        task::sleep(Duration::from_secs(secs)).await;
+        Python::with_gil(|py| Ok(py.None()))
+    })
+}
+
+fn test_into_coroutine(
+    py: Python,
+) -> PyResult<impl Future<Output = PyResult<()>> + Send + 'static> {
+    let sleeper_mod: Py<PyModule> = PyModule::new(py, "rust_sleeper")?.into();
+
+    sleeper_mod
+        .as_ref(py)
+        .add_wrapped(wrap_pyfunction!(sleep_for))?;
+
+    let test_mod: PyObject = PyModule::from_code(
+        py,
+        common::TEST_MOD,
+        "test_rust_coroutine/test_mod.py",
+        "test_mod",
+    )?
+    .into();
+
+    Ok(async move {
+        Python::with_gil(|py| {
+            pyo3_asyncio::into_future(
+                py,
+                test_mod
+                    .call_method1(py, "sleep_for_1s", (sleeper_mod.getattr(py, "sleep_for")?,))?
+                    .as_ref(py),
+            )
+        })?
+        .await?;
+        Ok(())
+    })
+}
+
+fn test_async_sleep<'p>(
+    py: Python<'p>,
+) -> PyResult<impl Future<Output = PyResult<()>> + Send + 'static> {
+    let asyncio = PyObject::from(py.import("asyncio")?);
+
+    Ok(async move {
+        task::sleep(Duration::from_secs(1)).await;
+
+        Python::with_gil(|py| {
+            pyo3_asyncio::into_future(py, asyncio.as_ref(py).call_method1("sleep", (1.0,))?)
+        })?
+        .await?;
+
+        Ok(())
+    })
+}
+
+fn main() {
+    test_main(
+        "PyO3 Asyncio Test Suite",
+        vec![
+            Test::new_async(
+                "test_async_sleep".into(),
+                Python::with_gil(|py| {
+                    test_async_sleep(py)
+                        .map_err(|e| {
+                            e.print_and_set_sys_last_vars(py);
+                        })
+                        .unwrap()
+                }),
+            ),
+            new_sync_test("test_blocking_sleep".into(), || {
+                common::test_blocking_sleep();
+                Ok(())
+            }),
+            Test::new_async(
+                "test_into_coroutine".into(),
+                Python::with_gil(|py| {
+                    test_into_coroutine(py)
+                        .map_err(|e| {
+                            e.print_and_set_sys_last_vars(py);
+                        })
+                        .unwrap()
+                }),
+            ),
+            Test::new_async(
+                "test_into_future".into(),
+                Python::with_gil(|py| {
+                    common::test_into_future(py)
+                        .map_err(|e| {
+                            e.print_and_set_sys_last_vars(py);
+                        })
+                        .unwrap()
+                }),
+            ),
+        ],
+    )
+}

pytests/test_async_std_run_forever.rs

@@ -0,0 +1,40 @@
+use std::time::Duration;
+
+use pyo3::prelude::*;
+
+fn dump_err(py: Python<'_>) -> impl FnOnce(PyErr) + '_ {
+    move |e| {
+        // We can't display Python exceptions via std::fmt::Display,
+        // so print the error here manually.
+        e.print_and_set_sys_last_vars(py);
+    }
+}
+
+fn main() {
+    Python::with_gil(|py| {
+        pyo3_asyncio::with_runtime(py, || {
+            async_std::task::spawn(async move {
+                async_std::task::sleep(Duration::from_secs(1)).await;
+
+                Python::with_gil(|py| {
+                    let event_loop = pyo3_asyncio::get_event_loop(py);
+
+                    event_loop
+                        .call_method1(
+                            "call_soon_threadsafe",
+                            (event_loop.getattr("stop").map_err(dump_err(py)).unwrap(),),
+                        )
+                        .map_err(dump_err(py))
+                        .unwrap();
+                })
+            });
+
+            pyo3_asyncio::run_forever(py)?;
+
+            println!("test test_run_forever ... ok");
+            Ok(())
+        })
+        .map_err(dump_err(py))
+        .unwrap();
+    })
+}