update

Author: sansyrox

src/asyncio.rs

@@ -23,12 +23,9 @@ pub(crate) fn empty_context(py: Python<'_>) -> PyResult<&Bound<'_, PyAny>> {
 }
 
 #[inline(always)]
-pub(crate) fn copy_context(py: Python) -> Py<PyAny> {
-    // Use the fast FFI path for CPython
-    // Note: PyPy support would require a different implementation, but robyn targets CPython
-    let ctx = unsafe {
+pub(crate) fn copy_context(py: Python) -> PyResult<Py<PyAny>> {
+    unsafe {
         let ptr = pyo3::ffi::PyContext_CopyCurrent();
-        Bound::from_owned_ptr(py, ptr)
-    };
-    ctx.unbind()
+        Ok(Bound::from_owned_ptr_or_err(py, ptr)?.unbind())
+    }
 }

src/callbacks.rs

@@ -53,12 +53,12 @@ impl PyDoneAwaitable {
 
 #[pyclass(frozen, module = "robyn._robyn")]
 pub(crate) struct PyErrAwaitable {
-    result: PyResult<()>,
+    err: PyErr,
 }
 
 impl PyErrAwaitable {
-    pub(crate) fn new(result: PyResult<()>) -> Self {
-        Self { result }
+    pub(crate) fn new(err: PyErr) -> Self {
+        Self { err }
     }
 }
 
@@ -73,7 +73,7 @@ impl PyErrAwaitable {
     }
 
     fn __next__(&self, py: Python) -> PyResult<()> {
-        Err(self.result.as_ref().err().unwrap().clone_ref(py))
+        Err(self.err.clone_ref(py))
     }
 }
 
@@ -230,6 +230,9 @@ impl PyFutureAwaitable {
         self.event_loop.clone_ref(py)
     }
 
+    /// Single-callback optimization: only the most recent callback is stored.
+    /// This is intentional — this type is internal to the robyn runtime and in
+    /// practice asyncio registers at most one done-callback per future.
     #[pyo3(signature = (cb, context=None))]
     fn add_done_callback(
         pyself: PyRef<'_, Self>,
@@ -257,11 +260,18 @@ impl PyFutureAwaitable {
         Ok(())
     }
 
+    /// Clears the single stored callback (see `add_done_callback`).
+    /// The `cb` argument is accepted for asyncio protocol compatibility but
+    /// is not used for matching — the sole stored callback is always removed.
     #[allow(unused)]
     fn remove_done_callback(&self, cb: Py<PyAny>) -> i32 {
         let mut ack = self.ack.write().unwrap();
-        *ack = None;
-        1
+        if ack.is_some() {
+            *ack = None;
+            1
+        } else {
+            0
+        }
     }
 
     #[allow(unused)]

src/runtime.rs

@@ -1,6 +1,6 @@
 use futures::FutureExt;
 use pyo3::{prelude::*, IntoPyObjectExt};
-use std::{future::Future, sync::Arc};
+use std::{future::Future, sync::Arc, sync::OnceLock};
 use tokio::{runtime::Builder as RuntimeBuilder, task::JoinHandle};
 
 #[cfg(unix)]
@@ -151,7 +151,7 @@ pub(crate) fn done_future_into_py(
 }
 
 #[inline(always)]
-pub(crate) fn err_future_into_py(py: Python, err: PyResult<()>) -> PyResult<Bound<PyAny>> {
+pub(crate) fn err_future_into_py(py: Python, err: PyErr) -> PyResult<Bound<PyAny>> {
     PyErrAwaitable::new(err).into_bound_py_any(py)
 }
 
@@ -247,32 +247,30 @@ where
     Ok(py_fut.into_bound(py))
 }
 
-// Wrapper function to replace pyo3_async_runtimes::tokio::future_into_py
-// This function matches the signature and converts Result<T, E> to FutureResultToPy
+static SHARED_BLOCKING_RUNNER: OnceLock<Arc<BlockingRunner>> = OnceLock::new();
+
+fn shared_blocking_runner() -> Arc<BlockingRunner> {
+    SHARED_BLOCKING_RUNNER
+        .get_or_init(|| Arc::new(BlockingRunner::new(1, 30)))
+        .clone()
+}
+
 pub fn future_into_py<F>(py: Python, fut: F) -> PyResult<Bound<PyAny>>
 where
     F: Future<Output = Result<(), anyhow::Error>> + Send + 'static,
 {
-    // Try to get the tokio runtime handle
-    // When called from Python code, we might not be in a tokio async context
-    // So we try try_current() first, and if that fails, fall back to pyo3_async_runtimes
     match tokio::runtime::Handle::try_current() {
         Ok(rt_handle) => {
-            // We have a handle, use our optimized implementation
-            // Get the event loop from Python
             let asyncio = py.import("asyncio")?;
             let event_loop = asyncio
-                .call_method0("get_event_loop")
+                .call_method0("get_running_loop")
                 .or_else(|_| asyncio.call_method0("new_event_loop"))?;
             let event_loop: Py<PyAny> = event_loop.unbind();
 
-            // Create a simple blocking runner (1 thread, 30s timeout)
-            let blocking_runner = Arc::new(BlockingRunner::new(1, 30));
+            let blocking_runner = shared_blocking_runner();
 
-            // Create RuntimeRef
             let rt_ref = RuntimeRef::new(rt_handle, blocking_runner, Arc::new(event_loop));
 
-            // Convert the future to use FutureResultToPy
             let wrapped_fut = async move {
                 match fut.await {
                     Ok(()) => FutureResultToPy::None,
@@ -286,13 +284,9 @@ where
                 }
             };
 
-            // Use the futlike implementation (better for most cases)
             future_into_py_futlike(rt_ref, py, wrapped_fut)
         }
         Err(_) => {
-            // Fall back to pyo3_async_runtimes when we can't get the handle
-            // This happens when called from Python code that's not in a tokio async context
-            // Convert Result<(), anyhow::Error> to PyResult<()> for pyo3_async_runtimes
             let py_fut = fut.map(|result| {
                 result.map_err(|e| {
                     PyErr::new::<pyo3::exceptions::PyRuntimeError, _>(format!(