Added pyo3_asyncio::async_std::main attribute

Author: Andrew J Westlake

Cargo.toml

@@ -12,15 +12,21 @@ 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
+[workspace]
+members = ["pyo3-asyncio-macros"]
 
 [features]
 async-std-runtime = ["async-std"]
+attributes = ["pyo3-asyncio-macros"]
 testing = ["clap"]
 tokio-runtime = ["tokio"]
 default = []
 
+[[example]]
+name = "async_std"
+path = "examples/async_std.rs"
+required-features = ["async-std-runtime"]
+
 [[test]]
 name = "test_async_std_asyncio"
 path = "pytests/test_async_std_asyncio.rs"
@@ -63,6 +69,7 @@ futures = "0.3"
 lazy_static = "1.4"
 once_cell = "1.5"
 pyo3 = "0.13"
+pyo3-asyncio-macros = { path = "pyo3-asyncio-macros", version = "=0.13.0", optional = true }
 
 [dependencies.async-std]
 version = "1.9"

README.md

@@ -31,36 +31,17 @@ More details on the usage of this library can be found in the [API docs](https:/
 ```rust no_run
 use pyo3::prelude::*;
 
-fn main() {
-    Python::with_gil(|py| {
-        // Initialize the runtime
-        pyo3_asyncio::with_runtime(py, || {
-            let asyncio: PyObject = py.import("asyncio")?.into();
-            
-            // Run the event loop until the given future completes
-            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(
-                        asyncio.call_method1(
-                            py, 
-                            "sleep", 
-                            (1.into_py(py),)
-                        )?
-                        .as_ref(py)
-                    )
-                })?
-                .await?;
-
-                Ok(())
-            })?;
-
-            Ok(())
-        })
-        .map_err(|e| {
-            e.print_and_set_sys_last_vars(py);  
-        })
-        .unwrap();
-    })
+#[pyo3_asyncio::async_std::main]
+async fn main() -> PyResult<()> {
+    let fut = Python::with_gil(|py| {
+        let asyncio = py.import("asyncio")?;
+
+        // convert asyncio.sleep into a Rust Future
+        pyo3_asyncio::into_future(asyncio.call_method1("sleep", (1.into_py(py),))?)
+    })?;
+
+    fut.await?;
+
+    Ok(())
 }
 ```

examples/async_std.rs

@@ -0,0 +1,15 @@
+#[pyo3_asyncio::async_std::main]
+async fn main() -> PyResult<()> {
+    let fut = Python::with_gil(|py| {
+        let asyncio = py.import("asyncio")?;
+
+        // convert asyncio.sleep into a Rust Future
+        pyo3_asyncio::into_future(asyncio.call_method1("sleep", (1.into_py(py),))?)
+    })?;
+
+    println!("sleeping for 1s");
+    fut.await?;
+    println!("done");
+
+    Ok(())
+}

pyo3-asyncio-macros/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "pyo3-asyncio-macros"
+version = "0.13.0"
+authors = ["Andrew J Westlake <[email protected]>"]
+edition = "2018"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+quote = "1"
+syn = { version = "1", features = ["full"] }

pyo3-asyncio-macros/src/lib.rs

@@ -0,0 +1,68 @@
+#![forbid(unsafe_code, future_incompatible, rust_2018_idioms)]
+#![deny(missing_debug_implementations, nonstandard_style)]
+#![recursion_limit = "512"]
+
+use proc_macro::TokenStream;
+use quote::{quote, quote_spanned};
+use syn::spanned::Spanned;
+
+/// Enables an async main function.
+///
+/// # Examples
+///
+/// ```ignore
+/// #[pyo3_asyncio::async_std::main]
+/// async fn main() -> PyResult<()> {
+///     Ok(())
+/// }
+/// ```
+#[cfg(not(test))] // NOTE: exporting main breaks tests, we should file an issue.
+#[proc_macro_attribute]
+pub fn async_std_main(_attr: TokenStream, item: TokenStream) -> TokenStream {
+    let input = syn::parse_macro_input!(item as syn::ItemFn);
+
+    let ret = &input.sig.output;
+    let inputs = &input.sig.inputs;
+    let name = &input.sig.ident;
+    let body = &input.block;
+    let attrs = &input.attrs;
+    let vis = &input.vis;
+
+    if name != "main" {
+        return TokenStream::from(quote_spanned! { name.span() =>
+            compile_error!("only the main function can be tagged with #[async_std::main]"),
+        });
+    }
+
+    if input.sig.asyncness.is_none() {
+        return TokenStream::from(quote_spanned! { input.span() =>
+            compile_error!("the async keyword is missing from the function declaration"),
+        });
+    }
+
+    let result = quote! {
+        #vis fn main() {
+            #(#attrs)*
+            async fn main(#inputs) #ret {
+                #body
+            }
+
+            use pyo3::prelude::*;
+
+            Python::with_gil(|py| {
+                pyo3_asyncio::with_runtime(py, || {
+                    pyo3_asyncio::async_std::run_until_complete(py, main())?;
+
+                    Ok(())
+                })
+                .map_err(|e| {
+                    e.print_and_set_sys_last_vars(py);
+                })
+                .unwrap();
+            });
+        }
+
+    };
+
+    result.into()
+}

src/async_std.rs

@@ -5,6 +5,9 @@ use pyo3::prelude::*;
 
 use crate::generic::{self, JoinError, Runtime};
 
+#[cfg(feature = "attributes")]
+pub use pyo3_asyncio_macros::async_std_main as main;
+
 struct AsyncStdJoinError;
 
 impl JoinError for AsyncStdJoinError {