fixes

Author: egorsmkv

examples/03_streams.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import asyncio
 
 import rsloop

examples/04_unix_and_accepted_socket.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import asyncio
 import os
 import socket

examples/05_pipes_signals_subprocesses.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import asyncio
 import os
 import signal

python/rsloop/__init__.py

@@ -25,6 +25,31 @@
     "stop_profiler",
 )
 _T = __typing.TypeVar("_T")
+__ORIG_SET_EVENT_LOOP = __asyncio.set_event_loop
+
+
+def __set_event_loop(loop: Loop | None) -> None:
+    try:
+        __ORIG_SET_EVENT_LOOP(loop)
+        return
+    except (AssertionError, TypeError):
+        if loop is None or not isinstance(loop, Loop):
+            raise
+
+    # Python 3.8 rejects non-stdlib loop objects in set_event_loop() with a
+    # hard isinstance() assertion. Mirror the stdlib policy bookkeeping so
+    # get_event_loop() still returns the current rsloop instance.
+    policy = __asyncio.get_event_loop_policy()
+    local = getattr(policy, "_local", None)
+    if local is None:
+        raise
+    local._set_called = True
+    local._loop = loop
+
+
+if __asyncio.set_event_loop is __ORIG_SET_EVENT_LOOP:
+    __asyncio.set_event_loop = __set_event_loop
+    __asyncio.events.set_event_loop = __set_event_loop
 
 
 def new_event_loop() -> Loop:

scripts/build-wheels.sh

@@ -92,15 +92,20 @@ fi
 for version in "${PYTHON_VERSIONS[@]}"; do
   interpreter="$(uv python find "$version")"
   echo "Building release wheel for Python ${version} (${interpreter})"
-  uv run \
-    --no-project \
-    --python "$interpreter" \
-    --with maturin \
-    maturin build \
-    --release \
-    --interpreter "$interpreter" \
-    --out "$OUTPUT_DIR" \
-    "${MATURIN_ARGS[@]}"
+  maturin_cmd=(
+    uv run
+    --no-project
+    --python "$interpreter"
+    --with maturin
+    maturin build
+    --release
+    --interpreter "$interpreter"
+    --out "$OUTPUT_DIR"
+  )
+  if ((${#MATURIN_ARGS[@]})); then
+    maturin_cmd+=("${MATURIN_ARGS[@]}")
+  fi
+  "${maturin_cmd[@]}"
 done
 
 echo "Wheels written to $OUTPUT_DIR"

src/callbacks.rs

@@ -13,7 +13,6 @@ pub type CallbackId = u64;
 
 enum CallbackArgs {
     None,
-    One(Py<PyAny>),
     Many(Py<PyTuple>),
 }
 
@@ -50,12 +49,6 @@ impl ReadyCallback {
     ) -> Self {
         let args = match args.bind(py).len() {
             0 => CallbackArgs::None,
-            1 => CallbackArgs::One(
-                args.bind(py)
-                    .get_item(0)
-                    .expect("single callback arg missing")
-                    .unbind(),
-            ),
             _ => CallbackArgs::Many(args),
         };
 
@@ -127,23 +120,13 @@ impl ReadyCallback {
                 )
                 .map(Bound::unbind)
             },
-            CallbackArgs::One(arg) => unsafe {
-                Bound::from_owned_ptr_or_err(
-                    py,
-                    ffi::PyObject_CallOneArg(self.callback.as_ptr(), arg.as_ptr()),
-                )
-                .map(Bound::unbind)
-            },
             CallbackArgs::Many(args) => self.callback.call1(py, args.clone_ref(py)),
         }
     }
 
     pub fn clone_args_tuple(&self, py: Python<'_>) -> Py<PyTuple> {
         match &self.args {
             CallbackArgs::None => PyTuple::empty(py).unbind(),
-            CallbackArgs::One(arg) => PyTuple::new(py, [arg.clone_ref(py)])
-                .expect("failed to clone single callback arg")
-                .unbind(),
             CallbackArgs::Many(args) => args.clone_ref(py),
         }
     }

src/python_api.rs

@@ -8,7 +8,6 @@ use std::sync::OnceLock;
 use std::time::Duration;
 
 use pyo3::exceptions::{PyNotImplementedError, PyRuntimeError, PyTypeError, PyValueError};
-use pyo3::ffi;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyModule, PySlice, PyTuple};
 use pyo3_async_runtimes::TaskLocals;
@@ -123,13 +122,7 @@ fn create_asyncio_future_for_loop(py: Python<'_>, loop_obj: &Py<PyAny>) -> PyRes
 }
 
 fn create_asyncio_future_for_running_loop(py: Python<'_>) -> PyResult<Py<PyAny>> {
-    unsafe {
-        Bound::from_owned_ptr_or_err(
-            py,
-            ffi::compat::PyObject_CallNoArgs(asyncio_future_cls(py)?.as_ptr()),
-        )
-        .map(Bound::unbind)
-    }
+    asyncio_future_cls(py)?.call0(py)
 }
 
 fn create_asyncio_task_for_loop(
@@ -151,13 +144,7 @@ fn create_asyncio_task_for_loop(
 }
 
 fn create_asyncio_task_for_running_loop(py: Python<'_>, coro: Py<PyAny>) -> PyResult<Py<PyAny>> {
-    unsafe {
-        Bound::from_owned_ptr_or_err(
-            py,
-            ffi::PyObject_CallOneArg(asyncio_task_cls(py)?.as_ptr(), coro.as_ptr()),
-        )
-        .map(Bound::unbind)
-    }
+    asyncio_task_cls(py)?.call1(py, (coro,))
 }
 
 fn call_protocol_factory(

tests/test_run.py

@@ -0,0 +1,25 @@
+import asyncio
+import unittest
+
+import rsloop
+
+
+class RunTests(unittest.TestCase):
+    def test_set_event_loop_accepts_rsloop_loop(self) -> None:
+        loop = rsloop.new_event_loop()
+        try:
+            asyncio.set_event_loop(loop)
+            self.assertIs(asyncio.get_event_loop(), loop)
+        finally:
+            asyncio.set_event_loop(None)
+            loop.close()
+
+    def test_run_executes_coroutine(self) -> None:
+        async def main() -> str:
+            return "ok"
+
+        self.assertEqual(rsloop.run(main()), "ok")
+
+
+if __name__ == "__main__":
+    unittest.main()