rloop 0.1.3__tar.gz → 0.1.5__tar.gz

{rloop-0.1.3 → rloop-0.1.5}/Cargo.lock

@@ -10,15 +10,15 @@ checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487"
 
 [[package]]
 name = "autocfg"
-version = "1.4.0"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 
 [[package]]
 name = "cc"
-version = "1.2.24"
+version = "1.2.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16595d3be041c03b09d08d0858631facccee9221e579704070e6e9e4915d3bc7"
+checksum = "2352e5597e9c544d5e6d9c95190d5d27738ade584fa8db0a16e130e5c2b5296e"
 dependencies = [
  "shlex",
 ]
@@ -43,9 +43,9 @@ checksum = "f4c7245a08504955605670dbf141fceab975f15ca21570696aebe9d2e71576bd"
 
 [[package]]
 name = "libc"
-version = "0.2.172"
+version = "0.2.174"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d750af042f7ef4f724306de029d18836c26c1765a54a6a3f094cbd23a7267ffa"
+checksum = "1171693293099992e19cddea4e8b849964e9846f4acee11b3948bcc337be8776"
 
 [[package]]
 name = "log"
@@ -82,9 +82,9 @@ checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
 
 [[package]]
 name = "papaya"
-version = "0.2.1"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6827e3fc394523c21d4464d02c0bb1c19966ea4a58a9844ad6d746214179d2bc"
+checksum = "f92dd0b07c53a0a0c764db2ace8c541dc47320dad97c2200c2a637ab9dd2328f"
 dependencies = [
  "equivalent",
  "seize",
@@ -92,9 +92,9 @@ dependencies = [
 
 [[package]]
 name = "portable-atomic"
-version = "1.11.0"
+version = "1.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "350e9b48cbc6b0e028b0473b114454c6316e57336ee184ceab6e53f72c178b3e"
+checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483"
 
 [[package]]
 name = "proc-macro2"
@@ -107,9 +107,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.25.0"
+version = "0.25.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f239d656363bcee73afef85277f1b281e8ac6212a1d42aa90e55b90ed43c47a4"
+checksum = "8970a78afe0628a3e3430376fc5fd76b6b45c4d43360ffd6cdd40bdde72b682a"
 dependencies = [
  "anyhow",
  "indoc",
@@ -125,9 +125,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.25.0"
+version = "0.25.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "755ea671a1c34044fa165247aaf6f419ca39caa6003aee791a0df2713d8f1b6d"
+checksum = "458eb0c55e7ece017adeba38f2248ff3ac615e53660d7c71a238d7d2a01c7598"
 dependencies = [
  "once_cell",
  "python3-dll-a",
@@ -136,9 +136,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.25.0"
+version = "0.25.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc95a2e67091e44791d4ea300ff744be5293f394f1bafd9f78c080814d35956e"
+checksum = "7114fe5457c61b276ab77c5055f206295b812608083644a5c5b2640c3102565c"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -146,9 +146,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.25.0"
+version = "0.25.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a179641d1b93920829a62f15e87c0ed791b6c8db2271ba0fd7c2686090510214"
+checksum = "a8725c0a622b374d6cb051d11a0983786448f7785336139c3c94f5aa6bef7e50"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -158,9 +158,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.25.0"
+version = "0.25.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9dff85ebcaab8c441b0e3f7ae40a6963ecea8a9f5e74f647e33fcf5ec9a1e89e"
+checksum = "4109984c22491085343c05b0dbc54ddc405c3cf7b4374fc533f5c3313a572ccc"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -189,7 +189,7 @@ dependencies = [
 
 [[package]]
 name = "rloop"
-version = "0.1.3"
+version = "0.1.5"
 dependencies = [
  "anyhow",
  "libc",
@@ -218,19 +218,19 @@ checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
 [[package]]
 name = "socket2"
-version = "0.5.10"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e22376abed350d73dd1cd119b57ffccad95b4e585a7cda43e286245ce23c0678"
+checksum = "233504af464074f9d066d7b5416c5f9b894a5862a6506e306f7b816cdd6f1807"
 dependencies = [
  "libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "syn"
-version = "2.0.101"
+version = "2.0.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ce2b7fc941b3a24138a0a7cf8e858bfc6a992e7978a068a5c760deb0ed43caf"
+checksum = "17b6f705963418cdb9927482fa304bc562ece2fdd4f616084c50b7023b435a40"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -257,9 +257,9 @@ checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3"
 
 [[package]]
 name = "wasi"
-version = "0.11.0+wasi-snapshot-preview1"
+version = "0.11.1+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
 
 [[package]]
 name = "windows-sys"

{rloop-0.1.3 → rloop-0.1.5}/Cargo.toml

@@ -1,10 +1,10 @@
 [package]
 name = "rloop"
-version = "0.1.3"
+version = "0.1.5"
 description = "An asyncio event loop implemented in Rust"
 authors = ["Giovanni Barillari <g@baro.dev>"]
 license = "BSD-3-Clause"
-edition = "2021"
+edition = "2024"
 
 keywords = ["asyncio"]
 
@@ -27,14 +27,14 @@ include = [
 
 [lib]
 name = "_rloop"
-crate-type = ["cdylib"]
+crate-type = ["cdylib", "rlib"]
 
 [dependencies]
 anyhow = "=1.0"
 mio = { version = "=1.0", features = ["net", "os-ext", "os-poll"] }
 papaya = "=0.2"
 pyo3 = { version = "=0.25", features = ["anyhow", "extension-module", "generate-import-lib"] }
-socket2 = { version = "=0.5", features = ["all"] }
+socket2 = { version = "=0.6", features = ["all"] }
 
 [target.'cfg(unix)'.dependencies]
 libc = "0.2.159"

{rloop-0.1.3 → rloop-0.1.5}/PKG-INFO

@@ -1,11 +1,12 @@
 Metadata-Version: 2.4
 Name: rloop
-Version: 0.1.3
+Version: 0.1.5
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Operating System :: MacOS
 Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: Free Threading :: 2 - Beta
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
@@ -16,18 +17,10 @@ Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Rust
-Requires-Dist: ruff~=0.5.0 ; extra == 'lint'
-Requires-Dist: pytest~=7.4.2 ; extra == 'test'
-Requires-Dist: pytest-asyncio~=0.21.1 ; extra == 'test'
-Requires-Dist: rloop[lint,test] ; extra == 'dev'
-Provides-Extra: lint
-Provides-Extra: test
-Provides-Extra: dev
 License-File: LICENSE
 Summary: An asyncio event loop implemented in Rust
 Keywords: asyncio
 Home-Page: https://github.com/gi0baro/rloop
-Author: Giovanni Barillari <g@baro.dev>
 Author-email: Giovanni Barillari <g@baro.dev>
 License: BSD-3-Clause
 Requires-Python: >=3.9

{rloop-0.1.3 → rloop-0.1.5}/pyproject.toml

@@ -9,6 +9,7 @@ classifiers = [
     'License :: OSI Approved :: BSD License',
     'Operating System :: MacOS',
     'Operating System :: POSIX :: Linux',
+    'Programming Language :: Python :: Free Threading :: 2 - Beta',
     'Programming Language :: Python :: 3',
     'Programming Language :: Python :: 3.9',
     'Programming Language :: Python :: 3.10',
@@ -32,15 +33,23 @@ dynamic = [
 requires-python = '>=3.9'
 dependencies = []
 
-[project.optional-dependencies]
+[dependency-groups]
+build = [
+    'maturin~=1.8',
+]
 lint = [
-    'ruff~=0.5.0',
+    'ruff~=0.11',
 ]
 test = [
-    'pytest~=7.4.2',
-    'pytest-asyncio~=0.21.1',
+    'pytest~=8.3',
+    'pytest-asyncio~=0.26',
+]
+
+all = [
+    { include-group = 'build' },
+    { include-group = 'lint' },
+    { include-group = 'test' },
 ]
-dev = ['rloop[lint,test]']
 
 [project.urls]
 Homepage = 'https://github.com/gi0baro/rloop'
@@ -48,7 +57,7 @@ Funding = 'https://github.com/sponsors/gi0baro'
 Source = 'https://github.com/gi0baro/rloop'
 
 [build-system]
-requires = ['maturin>=1.1.0,<2']
+requires = ['maturin>=1.8.0,<2']
 build-backend = 'maturin'
 
 [tool.maturin]

{rloop-0.1.3 → rloop-0.1.5}/rloop/__init__.py

@@ -1,5 +1,4 @@
-from asyncio.events import BaseDefaultEventLoopPolicy as __BasePolicy
-
+from ._compat import _BaseEventLoopPolicy as __BasePolicy
 from ._rloop import __version__ as __version__
 from .loop import RLoop
 

rloop-0.1.5/rloop/_compat.py

@@ -0,0 +1,11 @@
+import sys
+
+
+_PYV = int(sys.version_info.major * 100 + sys.version_info.minor)
+_PY_311 = 311
+_PY_314 = 314
+
+if _PYV < 314:
+    from asyncio.events import BaseDefaultEventLoopPolicy as _BaseEventLoopPolicy
+else:
+    from asyncio.events import _BaseDefaultEventLoopPolicy as _BaseEventLoopPolicy  # noqa

{rloop-0.1.3 → rloop-0.1.5}/rloop/loop.py

@@ -391,7 +391,7 @@ class RLoop(__BaseLoop, __asyncio.AbstractEventLoop):
                 exceptions = [exc for sub in exceptions for exc in sub]
                 try:
                     if all_errors:
-                        raise ExceptionGroup('create_connection failed', exceptions)
+                        raise ExceptionGroup('create_connection failed', exceptions)  # noqa: F821
                     if len(exceptions) == 1:
                         raise exceptions[0]
                     else:

{rloop-0.1.3 → rloop-0.1.5}/src/event_loop.rs

@@ -3,29 +3,25 @@ use std::{
     io::Read,
     mem,
     os::fd::{AsRawFd, FromRawFd},
-    sync::{atomic, Mutex, RwLock},
+    sync::{Arc, Mutex, RwLock, atomic},
     time::{Duration, Instant},
 };
 
 use anyhow::Result;
-use mio::{event, net::TcpListener, Interest, Poll, Token};
+use mio::{Interest, Poll, Token, Waker, event, net::TcpListener};
 use pyo3::prelude::*;
 
 use crate::{
     handles::{BoxedHandle, CBHandle, Handle, TimerHandle},
     io::Source,
-    log::{log_exc_to_py_ctx, LogExc},
+    log::{LogExc, log_exc_to_py_ctx},
     py::{copy_context, weakset},
     server::Server,
     tcp::{TCPReadHandle, TCPServer, TCPServerRef, TCPTransport, TCPWriteHandle},
     time::Timer,
-    utils::{py_allow_threads, syscall},
 };
 
-const WAKEB: &[u8; 1] = b"\0";
-
 enum IOHandle {
-    Internal,
     Py(PyHandleData),
     Signals,
     TCPListener(TCPListenerHandleData),
@@ -43,11 +39,10 @@ struct TCPListenerHandleData {
     server: TCPServerRef,
 }
 
-pub(crate) struct EventLoopRunState {
+pub struct EventLoopRunState {
     buf: Box<[u8]>,
     events: event::Events,
     pub read_buf: Box<[u8]>,
-    sock: socket2::Socket,
     tick_last: u128,
 }
 
@@ -55,14 +50,13 @@ pub(crate) struct EventLoopRunState {
 pub struct EventLoop {
     idle: atomic::AtomicBool,
     io: Mutex<Poll>,
+    waker: Arc<Waker>,
     handles_io: papaya::HashMap<Token, IOHandle>,
     handles_ready: Mutex<VecDeque<BoxedHandle>>,
     handles_sched: Mutex<BinaryHeap<Timer>>,
     epoch: Instant,
     counter_ready: atomic::AtomicUsize,
     ssock: RwLock<Option<(socket2::Socket, socket2::Socket)>>,
-    wsock: Mutex<Option<socket2::Socket>>,
-    wsock_fd: atomic::AtomicI32,
     closed: atomic::AtomicBool,
     exc_handler: RwLock<PyObject>,
     exception_handler: RwLock<PyObject>,
@@ -88,46 +82,6 @@ pub struct EventLoop {
 }
 
 impl EventLoop {
-    fn run_pre(&self) -> Result<EventLoopRunState> {
-        // wake sockets
-        let (sock_r, sock_w) = socket2::Socket::pair(socket2::Domain::UNIX, socket2::Type::STREAM, None)?;
-        sock_r.set_nonblocking(true)?;
-        sock_w.set_nonblocking(true)?;
-        let token = Token(sock_r.as_raw_fd() as usize);
-        let mut source = Source::FD(sock_r.as_raw_fd());
-        {
-            let guard = self.io.lock().unwrap();
-            guard.registry().register(&mut source, token, Interest::READABLE)?;
-        }
-        self.handles_io.pin().insert(token, IOHandle::Internal);
-        {
-            let mut guard = self.wsock.lock().unwrap();
-            self.wsock_fd.store(sock_w.as_raw_fd(), atomic::Ordering::Relaxed);
-            *guard = Some(sock_w);
-        }
-
-        Ok(EventLoopRunState {
-            buf: vec![0; 4096].into_boxed_slice(),
-            events: event::Events::with_capacity(128),
-            read_buf: vec![0; 262_144].into_boxed_slice(),
-            tick_last: 0,
-            sock: sock_r,
-        })
-    }
-
-    fn run_post(&self, state: &mut EventLoopRunState) {
-        // cleanup wake sockets
-        self.wsock.lock().unwrap().take();
-        self.wsock_fd.store(-1, atomic::Ordering::Relaxed);
-        let token = Token(state.sock.as_raw_fd() as usize);
-        let mut source = Source::FD(state.sock.as_raw_fd());
-        {
-            let guard = self.io.lock().unwrap();
-            _ = guard.registry().deregister(&mut source);
-        }
-        self.handles_io.pin().remove(&token);
-    }
-
     #[inline]
     fn step(&self, py: Python, state: &mut EventLoopRunState) -> std::result::Result<(), std::io::Error> {
         let mut sched_time: Option<u64> = None;
@@ -154,33 +108,29 @@ impl EventLoop {
         }
 
         // I/O
-        let poll_result = match skip_poll {
-            true => {
-                state.events.clear();
-                Ok(())
+        let poll_result = if skip_poll {
+            Ok(())
+        } else {
+            let idle_swap = !matches!(sched_time, Some(0));
+            if idle_swap {
+                self.idle.store(true, atomic::Ordering::Release);
             }
-            false => {
-                let idle_swap = !matches!(sched_time, Some(0));
+            let res = py.allow_threads(|| {
+                let mut io = self.io.lock().unwrap();
+                let res = io.poll(&mut state.events, sched_time.map(Duration::from_micros));
                 if idle_swap {
-                    self.idle.store(true, atomic::Ordering::Release);
+                    self.idle.store(false, atomic::Ordering::Release);
                 }
-                let res = py_allow_threads!(py, {
-                    let mut io = self.io.lock().unwrap();
-                    let res = io.poll(&mut state.events, sched_time.map(Duration::from_micros));
-                    if idle_swap {
-                        self.idle.store(false, atomic::Ordering::Release);
-                    }
-                    if let Err(ref err) = res {
-                        if err.kind() == std::io::ErrorKind::Interrupted {
-                            // if we got an interrupt, we retry ready events (as we might need to process signals)
-                            let _ = io.poll(&mut state.events, Some(Duration::from_millis(0)));
-                        }
+                if let Err(ref err) = res {
+                    if err.kind() == std::io::ErrorKind::Interrupted {
+                        // if we got an interrupt, we retry ready events (as we might need to process signals)
+                        let _ = io.poll(&mut state.events, Some(Duration::from_millis(0)));
                     }
-                    res
-                });
-                state.tick_last = Instant::now().duration_since(self.epoch).as_micros();
+                }
                 res
-            }
+            });
+            state.tick_last = Instant::now().duration_since(self.epoch).as_micros();
+            res
         };
 
         let mut cb_handles = {
@@ -190,7 +140,7 @@ impl EventLoop {
         self.counter_ready
             .fetch_sub(cb_handles.len(), atomic::Ordering::Release);
 
-        {
+        if !skip_poll {
             let io_handles = self.handles_io.pin();
             for event in &state.events {
                 // NOTE: cancellation is not necessary as we have custom futures
@@ -199,7 +149,6 @@ impl EventLoop {
                         IOHandle::Py(handle) => self.handle_io_py(py, event, handle, &mut cb_handles),
                         IOHandle::TCPListener(handle) => self.handle_io_tcpl(py, handle, &io_handles, &mut cb_handles),
                         IOHandle::TCPStream(_) => self.handle_io_tcps(event, &mut cb_handles),
-                        IOHandle::Internal => self.handle_io_internal(&mut state.sock, &mut state.buf),
                         IOHandle::Signals => self.handle_io_signals(py, &mut state.buf, &mut cb_handles),
                     }
                 }
@@ -245,11 +194,6 @@ impl EventLoop {
         len
     }
 
-    #[inline]
-    fn handle_io_internal(&self, socket: &mut socket2::Socket, buf: &mut [u8]) {
-        self.read_from_sock(socket, buf);
-    }
-
     #[inline]
     fn handle_io_py(
         &self,
@@ -338,8 +282,9 @@ impl EventLoop {
 
     #[inline(always)]
     fn wake(&self) {
-        let fd = self.wsock_fd.load(atomic::Ordering::Relaxed);
-        _ = syscall!(write(fd, WAKEB.as_ptr().cast(), 1));
+        if self.idle.load(atomic::Ordering::Acquire) {
+            _ = self.waker.wake();
+        }
     }
 
     pub(crate) fn tcp_listener_add(&self, listener: TcpListener, server: TCPServerRef) {
@@ -486,9 +431,7 @@ impl EventLoop {
             guard.push_back(Box::new(handle));
         }
         self.counter_ready.fetch_add(1, atomic::Ordering::Release);
-        if self.idle.load(atomic::Ordering::Acquire) {
-            self.wake();
-        }
+        self.wake();
 
         Ok(())
     }
@@ -509,9 +452,7 @@ impl EventLoop {
             guard.push_back(Box::new(handle));
         }
         self.counter_ready.fetch_add(1, atomic::Ordering::Release);
-        if self.idle.load(atomic::Ordering::Acquire) {
-            self.wake();
-        }
+        self.wake();
 
         Ok(())
     }
@@ -532,9 +473,7 @@ impl EventLoop {
             guard.push_back(Box::new(handle));
         }
         self.counter_ready.fetch_add(1, atomic::Ordering::Release);
-        if self.idle.load(atomic::Ordering::Acquire) {
-            self.wake();
-        }
+        self.wake();
 
         Ok(())
     }
@@ -559,9 +498,7 @@ impl EventLoop {
                 .map_err(|_| anyhow::anyhow!("lock acquisition failed"))?;
             guard.push(timer);
         }
-        if self.idle.load(atomic::Ordering::Acquire) {
-            self.wake();
-        }
+        self.wake();
 
         Ok(())
     }
@@ -592,9 +529,7 @@ impl EventLoop {
                 .map_err(|_| anyhow::anyhow!("lock acquisition failed"))?;
             guard.push(timer);
         }
-        if self.idle.load(atomic::Ordering::Acquire) {
-            self.wake();
-        }
+        self.wake();
 
         Ok(())
     }
@@ -625,9 +560,40 @@ impl EventLoop {
                 .map_err(|_| anyhow::anyhow!("lock acquisition failed"))?;
             guard.push(timer);
         }
-        if self.idle.load(atomic::Ordering::Acquire) {
-            self.wake();
+        self.wake();
+
+        Ok(())
+    }
+
+    #[allow(clippy::missing_errors_doc)]
+    pub fn schedule_handle(&self, handle: impl Handle + Send + 'static, delay: Option<Duration>) -> Result<()> {
+        match delay {
+            Some(delay) => {
+                let when = (Instant::now().duration_since(self.epoch) + delay).as_micros();
+                let timer = Timer {
+                    handle: Box::new(handle),
+                    when,
+                };
+                {
+                    let mut guard = self
+                        .handles_sched
+                        .lock()
+                        .map_err(|_| anyhow::anyhow!("lock acquisition failed"))?;
+                    guard.push(timer);
+                }
+            }
+            None => {
+                {
+                    let mut guard = self
+                        .handles_ready
+                        .lock()
+                        .map_err(|_| anyhow::anyhow!("lock acquisition failed"))?;
+                    guard.push_back(Box::new(handle));
+                }
+                self.counter_ready.fetch_add(1, atomic::Ordering::Release);
+            }
         }
+        self.wake();
 
         Ok(())
     }
@@ -637,17 +603,19 @@ impl EventLoop {
 impl EventLoop {
     #[new]
     fn new(py: Python) -> PyResult<Self> {
+        let poll = Poll::new()?;
+        let waker = Waker::new(poll.registry(), Token(0))?;
+
         Ok(Self {
             idle: atomic::AtomicBool::new(false),
-            io: Mutex::new(Poll::new()?),
+            io: Mutex::new(poll),
+            waker: Arc::new(waker),
             handles_io: papaya::HashMap::with_capacity(128),
             handles_ready: Mutex::new(VecDeque::with_capacity(128)),
             handles_sched: Mutex::new(BinaryHeap::with_capacity(32)),
             epoch: Instant::now(),
             counter_ready: atomic::AtomicUsize::new(0),
             ssock: RwLock::new(None),
-            wsock: Mutex::new(None),
-            wsock_fd: atomic::AtomicI32::new(-1),
             closed: atomic::AtomicBool::new(false),
             exc_handler: RwLock::new(py.None()),
             exception_handler: RwLock::new(py.None()),
@@ -900,10 +868,7 @@ impl EventLoop {
             guard.push_back(bhandle);
         }
         self.counter_ready.fetch_add(1, atomic::Ordering::Release);
-        // wake when necessary
-        if self.idle.load(atomic::Ordering::Acquire) {
-            self.wake();
-        }
+        self.wake();
 
         handle
     }
@@ -1160,24 +1125,28 @@ impl EventLoop {
     }
 
     fn _run(&self, py: Python) -> PyResult<()> {
-        let mut state = self.run_pre()?;
+        let mut state = EventLoopRunState {
+            buf: vec![0; 4096].into_boxed_slice(),
+            events: event::Events::with_capacity(128),
+            read_buf: vec![0; 262_144].into_boxed_slice(),
+            tick_last: 0,
+        };
 
         loop {
             if self.stopping.load(atomic::Ordering::Acquire) {
                 break;
             }
             if let Err(err) = self.step(py, &mut state) {
-                if err.kind() == std::io::ErrorKind::Interrupted
-                    && self.sig_loop_handled.swap(false, atomic::Ordering::Relaxed)
-                {
-                    continue;
+                if err.kind() == std::io::ErrorKind::Interrupted {
+                    if self.sig_loop_handled.swap(false, atomic::Ordering::Relaxed) {
+                        continue;
+                    }
+                    break;
                 }
-                self.run_post(&mut state);
                 return Err(err.into());
             }
         }
 
-        self.run_post(&mut state);
         Ok(())
     }
 }

{rloop-0.1.3 → rloop-0.1.5}/src/handles.rs

@@ -1,4 +1,4 @@
-use pyo3::{prelude::*, IntoPyObjectExt};
+use pyo3::{IntoPyObjectExt, prelude::*};
 use std::sync::atomic;
 
 use crate::{
@@ -10,7 +10,7 @@ use crate::{
 #[cfg(not(PyPy))]
 use crate::py::run_in_ctx1;
 
-pub(crate) trait Handle {
+pub trait Handle {
     fn run(&self, py: Python, event_loop: &EventLoop, state: &mut EventLoopRunState);
     fn cancelled(&self) -> bool {
         false

{rloop-0.1.3 → rloop-0.1.5}/src/io.rs

@@ -5,7 +5,7 @@ use std::os::fd::RawFd;
 #[cfg(windows)]
 use std::os::windows::io::RawSocket;
 
-use mio::{event::Source as MioSource, net::TcpListener, Interest, Registry, Token};
+use mio::{Interest, Registry, Token, event::Source as MioSource, net::TcpListener};
 
 pub(crate) enum Source {
     TCPListener(TcpListener),

{rloop-0.1.3 → rloop-0.1.5}/src/lib.rs

@@ -2,7 +2,7 @@ use pyo3::prelude::*;
 use std::sync::OnceLock;
 
 pub mod event_loop;
-mod handles;
+pub mod handles;
 mod io;
 mod log;
 mod py;

{rloop-0.1.3 → rloop-0.1.5}/src/tcp.rs

@@ -3,10 +3,10 @@ use std::os::fd::{AsRawFd, FromRawFd};
 
 use anyhow::Result;
 use mio::{
-    net::{TcpListener, TcpStream},
     Interest,
+    net::{TcpListener, TcpStream},
 };
-use pyo3::{buffer::PyBuffer, prelude::*, types::PyBytes, IntoPyObjectExt};
+use pyo3::{IntoPyObjectExt, buffer::PyBuffer, prelude::*, types::PyBytes};
 use std::{
     borrow::Cow,
     cell::RefCell,

rloop-0.1.5/src/utils.rs

@@ -0,0 +1,12 @@
+macro_rules! syscall {
+    ($fn: ident ( $($arg: expr),* $(,)* ) ) => {{
+        let res = unsafe { libc::$fn($($arg, )*) };
+        if res < 0 {
+            Err(std::io::Error::last_os_error())
+        } else {
+            Ok(res)
+        }
+    }};
+}
+
+pub(crate) use syscall;

{rloop-0.1.3 → rloop-0.1.5}/tests/test_handles.py

@@ -1,3 +1,6 @@
+import threading
+
+
 def run_loop(loop):
     async def run():
         loop.stop()
@@ -57,3 +60,39 @@ def test_call_at(loop):
     dt = loop.time() - t0
 
     assert dt >= delay
+
+
+def test_call_soon_threadsafe(loop):
+    calls = []
+
+    def cb(arg):
+        calls.append(arg)
+
+    def wake(cond):
+        with cond:
+            cond.notify_all()
+
+    def stop():
+        loop.stop()
+
+    def trun(cond1, cond2, loop, cb):
+        with cond1:
+            cond1.wait()
+        loop.call_soon_threadsafe(cb, 2)
+        with cond2:
+            cond2.wait()
+        loop.call_soon_threadsafe(cb, 4)
+
+    cond1 = threading.Condition()
+    cond2 = threading.Condition()
+    t = threading.Thread(target=trun, args=(cond1, cond2, loop, cb))
+    t.start()
+
+    loop.call_soon(cb, 1)
+    loop.call_soon(wake, cond1)
+    loop.call_later(0.5, cb, 3)
+    loop.call_later(0.6, wake, cond2)
+    loop.call_later(1.0, stop)
+    loop.run_forever()
+
+    assert calls == [1, 2, 3, 4]

rloop-0.1.3/rloop/_compat.py

@@ -1,5 +0,0 @@
-import sys
-
-
-_PYV = int(sys.version_info.major * 100 + sys.version_info.minor)
-_PY_311 = 311

rloop-0.1.3/src/utils.rs

@@ -1,27 +0,0 @@
-#[cfg(not(Py_GIL_DISABLED))]
-macro_rules! py_allow_threads {
-    ($py:expr, $func:tt) => {
-        $py.allow_threads(|| $func)
-    };
-}
-
-#[cfg(Py_GIL_DISABLED)]
-macro_rules! py_allow_threads {
-    ($py:expr, $func:tt) => {
-        $func
-    };
-}
-
-macro_rules! syscall {
-    ($fn: ident ( $($arg: expr),* $(,)* ) ) => {{
-        let res = unsafe { libc::$fn($($arg, )*) };
-        if res < 0 {
-            Err(std::io::Error::last_os_error())
-        } else {
-            Ok(res)
-        }
-    }};
-}
-
-pub(super) use py_allow_threads;
-pub(crate) use syscall;