loopmini 0.2.1__tar.gz → 0.2.2__tar.gz

{loopmini-0.2.1 → loopmini-0.2.2}/.github/workflows/ci.yml

@@ -60,6 +60,12 @@ jobs:
       contents: write
     steps:
       - uses: actions/checkout@v7
+      - uses: dtolnay/rust-toolchain@stable
+      - id: crates-auth
+        uses: rust-lang/crates-io-auth-action@v1
+      - run: cargo publish
+        env:
+          CARGO_REGISTRY_TOKEN: ${{ steps.crates-auth.outputs.token }}
       - uses: actions/download-artifact@v8
         with:
           path: dist

{loopmini-0.2.1 → loopmini-0.2.2}/Cargo.lock

@@ -65,7 +65,7 @@ checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
 
 [[package]]
 name = "loopmini"
-version = "0.2.1"
+version = "0.2.2"
 dependencies = [
  "polling",
  "pyo3",

{loopmini-0.2.1 → loopmini-0.2.2}/Cargo.toml

@@ -1,11 +1,10 @@
 [package]
 name = "loopmini"
-version = "0.2.1"
+version = "0.2.2"
 edition = "2021"
 license = "Apache-2.0"
 description = "Rust-backed asyncio event loop"
 repository = "https://github.com/AnswerDotAI/loopmini"
-publish = false
 readme = "README.md"
 
 [lib]

{loopmini-0.2.1 → loopmini-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loopmini
-Version: 0.2.1
+Version: 0.2.2
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Requires-Dist: fastship>=0.0.11 ; extra == 'dev'

{loopmini-0.2.1 → loopmini-0.2.2}/src/pyreactor.rs

@@ -44,14 +44,22 @@ impl PyReactor {
                 // An injected async exception (e.g. KeyboardInterrupt) can surface at either
                 // Python call; only a handle whose _run began may be dropped without requeue.
                 let cancelled = h.bind(py).getattr(intern!(py, "_cancelled")).and_then(|v| v.extract::<bool>());
-                match cancelled { Err(e) => { self.core.requeue_front(std::iter::once(h).chain(it)); return Err(e); } Ok(true) => continue, Ok(false) => {} }
+                match cancelled {
+                    Err(e) => {
+                        self.core.requeue_front(std::iter::once(h).chain(it));
+                        return Err(e);
+                    }
+                    Ok(true) => continue,
+                    Ok(false) => {}
+                }
                 if let Err(e) = h.bind(py).call_method0(intern!(py, "_run")) {
                     // An injected exception surfacing at `_run`'s entry leaves a single-frame
                     // traceback: the callback never ran, so requeue the handle - dropping it
                     // would lose e.g. a task wakeup and orphan the task. A deeper traceback
                     // means the callback began, so the handle is consumed (CPython semantics).
                     let entry_only = e.traceback(py).map_or(true, |tb| tb.getattr("tb_next").ok().is_none_or(|n| n.is_none()));
-                    if entry_only { self.core.requeue_front(std::iter::once(h).chain(it)) } else { self.core.requeue_front(it) }
+                    if entry_only { self.core.requeue_front(std::iter::once(h).chain(it)) }
+                    else { self.core.requeue_front(it) }
                     return Err(e);
                 }
             }

{loopmini-0.2.1 → loopmini-0.2.2}/src/reactor.rs

@@ -79,7 +79,8 @@ impl<H: Clone> Reactor<H> {
         let mut inner = self.inner.lock().unwrap();
         let fresh = !inner.fds.contains_key(&fd);
         let e = inner.fds.entry(fd).or_default();
-        if write { e.writer = Some(h) } else { e.reader = Some(h) }
+        if write { e.writer = Some(h) }
+        else { e.reader = Some(h) }
         let ev = interest(fd, e);
         if fresh { unsafe { self.poller.add(fd as i32, ev) } } else { self.poller.modify(borrowed(fd), ev) }
     }
@@ -90,7 +91,11 @@ impl<H: Clone> Reactor<H> {
         let had = if write { e.writer.take().is_some() } else { e.reader.take().is_some() };
         let empty = e.reader.is_none() && e.writer.is_none();
         let ev = interest(fd, e);
-        if empty { inner.fds.remove(&fd); let _ = self.poller.delete(borrowed(fd)); } else { self.poller.modify(borrowed(fd), ev)? }
+        if empty {
+            inner.fds.remove(&fd);
+            let _ = self.poller.delete(borrowed(fd));
+        }
+        else { self.poller.modify(borrowed(fd), ev)? }
         Ok(had)
     }
 
@@ -122,11 +127,17 @@ impl<H: Clone> Reactor<H> {
     /// cross-thread handles, and say how long the driver may block in `poll`.
     pub fn next_timeout(&self) -> ControlFlow<(), Option<Duration>> {
         let mut inner = self.inner.lock().unwrap();
-        if inner.stop { inner.stop = false; return ControlFlow::Break(()) }
+        if inner.stop {
+            inner.stop = false;
+            return ControlFlow::Break(());
+        }
         let Inner { ready, timers, .. } = &mut *inner;
         self.drain_tsq(ready);
         let now = self.now_us();
-        while timers.first_key_value().is_some_and(|((when, _), _)| *when <= now) { let (_, h) = timers.pop_first().unwrap(); ready.push_back(h); }
+        while timers.first_key_value().is_some_and(|((when, _), _)| *when <= now) {
+            let (_, h) = timers.pop_first().unwrap();
+            ready.push_back(h);
+        }
         // Clamped like CPython's MAXIMUM_SELECT_TIMEOUT: a sleep(inf) timer saturates
         // to u64::MAX, and a pure-Rust consumer blocking in `poll` would hand that
         // timespec to kqueue, which rejects it with EINVAL
@@ -175,7 +186,10 @@ mod tests {
     fn cross_thread_schedule_wakes_poll() {
         let reactor = Arc::new(Reactor::new().unwrap());
         let sender = reactor.clone();
-        let thread = thread::spawn(move || { thread::sleep(Duration::from_millis(10)); sender.schedule_ts("ready").unwrap(); });
+        let thread = thread::spawn(move || {
+            thread::sleep(Duration::from_millis(10));
+            sender.schedule_ts("ready").unwrap();
+        });
         let events = reactor.poll(None).unwrap();
         reactor.process(&events);
         thread.join().unwrap();