Removed 3.6 fallbacks / workarounds

Author: Andrew J Westlake

.github/workflows/ci.yml

@@ -140,7 +140,7 @@ jobs:
         run: cargo build --features=${{env.features}} --verbose --target ${{ matrix.platform.rust-target }}
 
       # uvloop doesn't compile under Windows or Python 3.11-dev
-      - if: ${{ matrix.platform.os != 'windows-latest' && matrix.python-version != "3.11-dev" }}
+      - if: ${{ matrix.platform.os != 'windows-latest' && matrix.python-version != '3.11-dev' }}
         name: Install pyo3-asyncio test dependencies
         run: |
           python -m pip install -U uvloop

README.md

@@ -656,10 +656,12 @@ There have been a few changes to the API in order to support proper cancellation
       let event_loop = pyo3_asyncio::get_running_loop(py)?;
 
       // *_with_loop conversions in 0.14
-      let fut = pyo3_asyncio::tokio::future_into_py_with_loop(
-          event_loop,
-          async move { Ok(Python::with_gil(|py| py.None())) }
-      )?;
+      //
+      // let fut = pyo3_asyncio::tokio::future_into_py_with_loop(
+      //     event_loop,
+      //     async move { Ok(Python::with_gil(|py| py.None())) }
+      // )?;
+      //
       // should be replaced with *_with_locals in 0.15
       //
       // contextvars can be copied with `copy_context` or supplied

pytests/test_async_std_asyncio.rs

@@ -300,15 +300,9 @@ asyncio.run(main())
 #[pyo3_asyncio::async_std::test]
 fn test_contextvars() -> PyResult<()> {
     Python::with_gil(|py| {
-        let contextvars = match py.import("contextvars") {
-            Ok(contextvars) => contextvars,
-            // Python 3.6 does not support contextvars, so early-out here
-            Err(_) => return Ok(()),
-        };
-
         let d = [
             ("asyncio", py.import("asyncio")?.into()),
-            ("contextvars", contextvars.into()),
+            ("contextvars", py.import("contextvars")?.into()),
             ("cvars_mod", wrap_pymodule!(cvars_mod)(py)),
         ]
         .into_py_dict(py);

pytests/tokio_asyncio/mod.rs

@@ -304,15 +304,9 @@ asyncio.run(main())
 #[pyo3_asyncio::tokio::test]
 fn test_contextvars() -> PyResult<()> {
     Python::with_gil(|py| {
-        let contextvars = match py.import("contextvars") {
-            Ok(contextvars) => contextvars,
-            // Python 3.6 does not support contextvars, so early-out here
-            Err(_) => return Ok(()),
-        };
-
         let d = [
             ("asyncio", py.import("asyncio")?.into()),
-            ("contextvars", contextvars.into()),
+            ("contextvars", py.import("contextvars")?.into()),
             ("cvars_mod", wrap_pymodule!(cvars_mod)(py)),
         ]
         .into_py_dict(py);

src/lib.rs

@@ -400,7 +400,7 @@ use pyo3::{
 };
 
 static ASYNCIO: OnceCell<PyObject> = OnceCell::new();
-static CONTEXTVARS: OnceCell<Option<PyObject>> = OnceCell::new();
+static CONTEXTVARS: OnceCell<PyObject> = OnceCell::new();
 static ENSURE_FUTURE: OnceCell<PyObject> = OnceCell::new();
 static GET_RUNNING_LOOP: OnceCell<PyObject> = OnceCell::new();
 
@@ -445,46 +445,27 @@ fn asyncio(py: Python) -> PyResult<&PyAny> {
 /// Get a reference to the Python Event Loop from Rust
 ///
 /// Equivalent to `asyncio.get_running_loop()` in Python 3.7+.
-/// > For Python 3.6, this function falls back to `asyncio.get_event_loop()` which has slightly
-/// different behaviour. See the [`asyncio.get_event_loop`](https://docs.python.org/3/library/asyncio-eventloop.html#asyncio.get_event_loop)
-/// docs to better understand the differences.
 pub fn get_running_loop(py: Python) -> PyResult<&PyAny> {
     // Ideally should call get_running_loop, but calls get_event_loop for compatibility when
     // get_running_loop is not available.
     GET_RUNNING_LOOP
         .get_or_try_init(|| -> PyResult<PyObject> {
             let asyncio = asyncio(py)?;
 
-            if asyncio.hasattr("get_running_loop")? {
-                // correct behaviour with Python 3.7+
-                Ok(asyncio.getattr("get_running_loop")?.into())
-            } else {
-                // Python 3.6 compatibility mode
-                Ok(asyncio.getattr("get_event_loop")?.into())
-            }
+            Ok(asyncio.getattr("get_running_loop")?.into())
         })?
         .as_ref(py)
         .call0()
 }
 
-/// Returns None only if contextvars cannot be imported (Python 3.6 fallback)
-fn contextvars(py: Python) -> Option<&PyAny> {
-    CONTEXTVARS
-        .get_or_init(|| match py.import("contextvars") {
-            Ok(contextvars) => Some(contextvars.into()),
-            Err(_) => None,
-        })
-        .as_ref()
-        .map(|contextvars| contextvars.as_ref(py))
+fn contextvars(py: Python) -> PyResult<&PyAny> {
+    Ok(CONTEXTVARS
+        .get_or_try_init(|| py.import("contextvars").map(|m| m.into()))?
+        .as_ref(py))
 }
 
-/// Returns Ok(None) only if contextvars cannot be imported (Python 3.6 fallback)
-fn copy_context(py: Python) -> PyResult<Option<&PyAny>> {
-    if let Some(contextvars) = contextvars(py) {
-        Ok(Some(contextvars.call_method0("copy_context")?))
-    } else {
-        Ok(None)
-    }
+fn copy_context(py: Python) -> PyResult<&PyAny> {
+    Ok(contextvars(py)?.call_method0("copy_context")?)
 }
 
 /// Task-local data to store for Python conversions.
@@ -520,12 +501,7 @@ impl TaskLocals {
 
     /// Capture the current task's contextvars
     pub fn copy_context(self, py: Python) -> PyResult<Self> {
-        // No-op if context cannot be copied (Python 3.6 fallback)
-        if let Some(cx) = copy_context(py)? {
-            Ok(self.with_context(cx))
-        } else {
-            Ok(self)
-        }
+        Ok(self.with_context(copy_context(py)?))
     }
 
     /// Get a reference to the event loop
@@ -596,12 +572,7 @@ fn call_soon_threadsafe(
     let py = event_loop.py();
 
     let kwargs = PyDict::new(py);
-
-    // Accommodate for the Python 3.6 fallback
-    // (call_soon_threadsafe does not support the context kwarg in 3.6)
-    if !context.is_none() {
-        kwargs.set_item("context", context)?;
-    }
+    kwargs.set_item("context", context)?;
 
     event_loop.call_method("call_soon_threadsafe", args, Some(kwargs))?;
     Ok(())
@@ -632,6 +603,7 @@ fn call_soon_threadsafe(
 ///     await asyncio.sleep(duration)
 /// "#;
 ///
+/// # #[cfg(feature = "tokio-runtime")]
 /// async fn py_sleep(seconds: f32) -> PyResult<()> {
 ///     let test_mod = Python::with_gil(|py| -> PyResult<PyObject> {
 ///         Ok(
@@ -646,8 +618,8 @@ fn call_soon_threadsafe(
 ///     })?;
 ///
 ///     Python::with_gil(|py| {
-///         pyo3_asyncio::into_future_with_loop(
-///             pyo3_asyncio::get_running_loop(py)?,
+///         pyo3_asyncio::into_future_with_locals(
+///             &pyo3_asyncio::tokio::get_current_locals(py)?,
 ///             test_mod
 ///                 .call_method1(py, "py_sleep", (seconds.into_py(py),))?
 ///                 .as_ref(py),