loopmini 0.1.1__tar.gz → 0.2.2__tar.gz

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

@@ -8,13 +8,16 @@ on:
 
 jobs:
   test:
+    strategy:
+      matrix:
+        python-version: ['3.11', '3.12', '3.13', '3.14']
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v7
       - uses: dtolnay/rust-toolchain@stable
       - uses: actions/setup-python@v7
         with:
-          python-version: '3.12'
+          python-version: ${{ matrix.python-version }}
       - run: pip install -e '.[dev]'
       - run: pytest -q
 
@@ -28,7 +31,7 @@ jobs:
       - uses: actions/checkout@v7
       - uses: PyO3/maturin-action@v1
         with:
-          args: --release --out dist -i python3.10 -i python3.11 -i python3.12 -i python3.13
+          args: --release --out dist -i python3.11 -i python3.12 -i python3.13 -i python3.14
           manylinux: auto
       - uses: actions/upload-artifact@v7
         with:
@@ -57,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.1.1 → loopmini-0.2.2}/Cargo.lock

@@ -65,22 +65,10 @@ checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
 
 [[package]]
 name = "loopmini"
-version = "0.1.1"
+version = "0.2.2"
 dependencies = [
  "polling",
  "pyo3",
- "tokio",
-]
-
-[[package]]
-name = "mio"
-version = "1.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30d65c71f1ce40ab09135ce117d742b9f8a19ff91a41a8b57ed50bc2de59c427"
-dependencies = [
- "libc",
- "wasi",
- "windows-sys",
 ]
 
 [[package]]
@@ -203,16 +191,6 @@ dependencies = [
  "windows-sys",
 ]
 
-[[package]]
-name = "socket2"
-version = "0.6.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3d1e2c7f27f8d4cb10542a02c49005dbd6e93095799d6f3be745fae9f8fedd4"
-dependencies = [
- "libc",
- "windows-sys",
-]
-
 [[package]]
 name = "syn"
 version = "2.0.119"
@@ -230,31 +208,12 @@ version = "0.13.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
 
-[[package]]
-name = "tokio"
-version = "1.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "202caea871b69668250d242070849eb495be178ed697a3e98aebce5bc81a0bed"
-dependencies = [
- "libc",
- "mio",
- "pin-project-lite",
- "socket2",
- "windows-sys",
-]
-
 [[package]]
 name = "unicode-ident"
 version = "1.0.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
 
-[[package]]
-name = "wasi"
-version = "0.11.1+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
-
 [[package]]
 name = "windows-link"
 version = "0.2.1"

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

@@ -1,6 +1,6 @@
 [package]
 name = "loopmini"
-version = "0.1.1"
+version = "0.2.2"
 edition = "2021"
 license = "Apache-2.0"
 description = "Rust-backed asyncio event loop"
@@ -12,12 +12,9 @@ name = "loopmini"
 crate-type = ["cdylib", "rlib"]
 
 [dependencies]
-pyo3 = { version = ">=0.28", features = ["py-clone"] }
+pyo3 = { version = ">=0.28", features = ["py-clone"], optional = true }
 polling = "3"
-tokio = { version = "1", features = ["rt", "time", "net"] }
-
-[dev-dependencies]
-tokio = { version = "1", features = ["rt-multi-thread"] }
 
 [features]
-extension-module = ["pyo3/extension-module"]
+python = ["dep:pyo3"]
+extension-module = ["python", "pyo3/extension-module"]

loopmini-0.2.2/DEV.md

@@ -0,0 +1,101 @@
+# Developer guide
+
+## Why this exists
+
+Kernmini's Rust engine (see kernmini `meta/ROUGH.md`, "Separate project idea: a Rust-backed asyncio loop" and the 2026-08-28 review) needs Python kernels to run arbitrary user asyncio code. loopmini tests whether a Rust reactor can host that loop with full asyncio compatibility. The compatibility bar is the full public asyncio surface, because solveit users run arbitrary packages; the strategy is maximal reuse of CPython's own asyncio machinery, with Rust owning only what Python cannot express well.
+
+## Crate/Python split
+
+A key goal is that Rust crates and PyO3 wrappers share code: the same reactor must be drivable by a pure-Rust kernel (as kernmini's native crate will be). The implementation has two layers plus module registration:
+
+- `src/reactor.rs`: `Reactor<H>`, a PyO3-free, Tokio-free core generic over the handle type. It owns the ready queue, timer map, fd interest map (oneshot `polling` sources, re-armed on delivery), thread-safe `schedule_ts` + notify, and the turn phases: `next_timeout` / `poll` / `process` / `take_batch` / `requeue_front`. `poll` holds no locks, so a driver may block in it with the GIL released. PyO3 is optional and the default Cargo build is pure Rust, so a Rust consumer instantiates `Reactor<RustHandle>` without linking Python.
+- `src/pyreactor.rs`: `PyReactor`, compiled by the `python` feature and exposed by maturin's `extension-module` feature. It provides the Python-facing pyclass, scheduling and readiness methods, and the canonical dispatch loop (`check_signals` each turn, `py.detach` around `poll`, EINTR retry, and the injected-exception requeue rule, which must exist exactly once). The driver blocks directly in the core poller with the GIL released. Rust runtimes keep their futures on worker threads and wake the loop with its thread-safe scheduling path.
+- `src/lib.rs`: module registration and the public re-exports (`ReactorCore`, `PyReactor`) for embedding crates.
+
+Python (`python/loopmini/loop.py`) subclasses `asyncio.BaseEventLoop`, delegating scheduling to the reactor while inheriting task/future creation, executors, exception handling, high-level networking, TLS orchestration, servers, subprocess entry points, and buffered sendfile. Reactor-neutral implementations of socket operations and accepting connections are borrowed from `BaseSelectorEventLoop`; Unix connection/server methods and pipe transports are borrowed from `_UnixSelectorEventLoop`. Loopmini supplies the hooks those implementations call. This reuse buys exact CPython contextvars, cancellation, introspection, lifecycle, and version-specific semantics. `run_forever` on the main thread routes signals through `signal.set_wakeup_fd` into an fd watched by the reactor.
+
+## Implemented surface
+
+Beyond the scheduling core, loopmini implements TCP transports (`SockTransport`, speaking both `Protocol` and `BufferedProtocol`, with `TCP_NODELAY`), UDP (`DatagramTransport`), signal dispatch through the `set_wakeup_fd` socketpair, and the reactor's reader/writer registrations. CPython supplies the high-level TCP/UDP/TLS/Unix/server operations, Unix pipe transports, flow control, and buffered sendfile. `subproc.py` prepares `Popen` in the executor because fork/exec blocks, then gives it to CPython's `BaseSubprocessTransport`; one reaper thread per child reports exit through the loop's thread-safe scheduling path.
+
+Contracts learned from the oracles, kept working by them: `remove_reader` cancels the stored `Handle`, so an already-queued readiness callback for a removed fd never fires; `connection_lost` is scheduled exactly once however `close()`, `abort()`, and fatal errors overlap; and a Unix socket path is unlinked at close only when its inode still matches the one bound. A cancelled timer leaves the reactor's timer map at once: `schedule_at` returns a `(deadline µs, seq)` key, the `TimerHandle` subclass carries it, and `_timer_handle_cancelled` removes the entry. Retention until the original deadline would grow memory for an hour per cancelled `wait_for(..., 3600)`. The reactor clock carries a constant offset captured at loop creation because aiohttp compares `loop.time()` with `time.monotonic`. A socket transport sends its bytearray directly rather than holding an explicit `memoryview` export across a potentially raising `send`, whose traceback could otherwise keep the buffer unresizable.
+
+## Deliberately not implemented yet
+
+Native sendfile and Windows. `BaseEventLoop` provides the portable buffered sendfile fallback; the socket transport declares that capability rather than pretending to support the platform-native fast path.
+
+## Tests
+
+The tiers, so the inner loop stays seconds:
+
+- `pytest -q` per change (~2s).
+- `pytest -m oracle -n auto` when a feature lands, not per edit.
+- `pytest -m bench -s` and `pytest -m soak -s` only when performance or stability is the question.
+- `chkstyle` once, at the final PR stage, never per edit.
+
+To test against another Python version locally (the workspace venv is pinned, so
+plain `uv run --python` refuses): `uv run --no-project --python 3.14 --with
+'.[dev]' pytest -q` from the repo root. uv builds against its managed
+interpreter into its cache, so repeat runs are fast and there is no venv to
+maintain. CI runs the same suite on every supported version.
+
+`pytest -q`. Eleven integration stories, deliberately few: scheduling/tasks/threads (timers, contextvars, gather, TaskGroup, timeout, cancellation, cross-thread wakeup, to_thread), socket I/O through the reactor (accept/connect/backpressure on a 5MB payload), asyncio streams echo with drain backpressure, a background task surviving between `run_until_complete` calls (the kernel-persistence story), KeyboardInterrupt injection with the loop reused afterwards, uvicorn serving an ASGI app fetched by urllib and by httpx-over-anyio, TLS echo against a throwaway openssl cert, a subprocess round-trip (exec and shell, streams and communicate), and the interrupt-torture story: window-scoped `PyThreadState_SetAsyncExc` injection under stream/timer/cross-thread load, mirroring kernmini's `sync_execution_context` contract (0.5s by default; `LOOPMINI_TORTURE_SECONDS` extends it), and the KI-at-`_run`-entry orphan repro that pins the traceback-depth requeue rule. Rust-side unit tests should exist only for reactor invariants Python stories cannot reach.
+
+Two CPython 3.13 facts the torture test depends on, discovered the hard way:
+an async-injected exception raised at an eval-breaker check escapes the
+raising frame even past a same-frame `try/except` (open regression
+[gh-139622](https://github.com/python/cpython/issues/139622); 3.12 and 3.14
+unaffected), so the guard must sit in a parent frame; and a busy window
+shorter than the GIL switch interval (5ms) is invisible to a sampling thread,
+because the GIL is only ever released while the window is closed.
+
+## The compatibility oracles
+
+Four external suites are the conformance measure, run in-repo through
+`tests/test_oracle.py` (marked `oracle`, deselected by default):
+
+```bash
+pytest -m oracle -n auto          # all four suites, one worker per module
+pytest -m oracle -k uvloop        # one suite; add "and test_tcp" etc. for one module
+```
+
+`tests/oracle_util.py` fetches and caches what each suite needs under `~/.cache/loopmini-oracle` (override with `LOOPMINI_ORACLE_CACHE`). Modified external source trees are content-addressed by the source of their adapter function, so changing an adapter creates a fresh fixture while unchanged fixtures retain their cache:
+
+- CPython's own test_asyncio (uvloop's strategy). This uv-managed Python ships
+  without the stdlib `test` package, so the matching source tarball is fetched
+  and its functional modules run under a loopmini event-loop policy. Suites
+  asserting standard-loop internals (base_events, selector_events,
+  unix_events) are not fair oracles and are excluded.
+- anyio's test suite, via its sanctioned alternative-loop mechanism: the sdist
+  matching the installed version is unpacked and a loopmini entry added to
+  `asyncio_params` in its conftest. Runs as a subprocess; requires the anyio
+  test deps (`trustme`, `blockbuster`) in the venv. blockbuster's
+  blocking-call detector allowlists Popen's blocking os.read only under
+  `asyncio/base_events.py`, which is one reason the Popen spawn goes through
+  the executor.
+- uvloop's test suite, from a source clone (`LOOPMINI_UVLOOP_REPO`, default
+  `~/aai-ws/links/uvloop`): its loop-parameterized test classes are cloned
+  onto loopmini with `implementation='asyncio'`, so branchy tests take the
+  standard-loop expectation paths. `test_tcp` needs pyOpenSSL and is skipped
+  without it.
+- aiohttp's test suite: the sdist is unpacked, uvloop is stubbed to loopmini in its conftest so `--aiohttp-loop=uvloop` selects it, and its blockbuster fixture gains an allowlist entry for the same unlink-if-unchanged stat used by asyncio's Unix loop. It runs pure-Python aiohttp (`AIOHTTP_NO_EXTENSIONS=1`) with a private `--basetemp`, because permission tests leave chmod-000 directories that pytest's numbered-directory sweeper cannot remove under aiohttp's `filterwarnings = error`. Deselections and their reasons live in `test_oracle.py`.
+
+Status on 2026-08-28: all green; 26 oracle stories, including about 4,200 aiohttp tests, complete in about 26 seconds under xdist on the development Mac.
+
+## The soak gate
+
+`pytest -m soak -s` runs a kernel-shaped workload on one loopmini loop for
+`LOOPMINI_SOAK_SECONDS` (default 30): a fasthtml app on uvicorn under
+threaded httpx load, a websocket echo server with a bot-style client, a
+housekeeping tick, and periodic cells submitted from another thread, as a
+kernel would. It asserts zero errors, bounded fd growth, and that every
+component made progress. It watches stability, not speed.
+
+## Benchmarks
+
+`pytest -m bench -s` prints loopmini vs the standard loop on loop-bound microbenchmarks; informational, never gating. Numbers on 2026-08-28 (M-series macOS): call_soon 1.04x, sleep0 1.03x, tcp_echo 1.02x, task spawn 1.17x (stdlib=1.0); the corresponding extra cost is approximately 0.5µs per scheduled callback, 0.5µs per `sleep(0)` suspend/resume, 1.1µs per TCP echo, and 0.3µs per spawned task. Median 1ms-timer overshoot is 0.188ms versus 0.156ms.
+
+## Style and releases
+
+fastai style (`chkstyle` before committing). Releases via fastship; the tree
+carries the next version.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loopmini
-Version: 0.1.1
+Version: 0.2.2
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Requires-Dist: fastship>=0.0.11 ; extra == 'dev'
@@ -20,7 +20,7 @@ License-File: LICENSE
 Summary: Rust-backed asyncio event loop
 Author-email: Jeremy Howard <github@jhoward.fastmail.fm>
 License: Apache-2.0
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 Project-URL: Homepage, https://github.com/AnswerDotAI/loopmini
 Project-URL: Issues, https://github.com/AnswerDotAI/loopmini/issues
@@ -48,9 +48,9 @@ pip install loopmini
 
 ## Design
 
-The Python side subclasses `asyncio.AbstractEventLoop` and reuses the stock `Task`, `Future`, `Handle`, and `sslproto` machinery. Contextvars, cancellation, and task introspection therefore behave exactly as in the standard loop. CPython releases change little that loopmini must track, because the version-sensitive objects are CPython's own.
+The Python side subclasses `asyncio.BaseEventLoop` and reuses its task, future, executor, error-handling, networking, server, sendfile, and subprocess machinery. Reactor-neutral socket, Unix, pipe, and accept implementations come directly from CPython's selector loop. Loopmini supplies the scheduling and fd-readiness hooks plus socket and datagram transports, so version-sensitive asyncio behavior remains CPython's own.
 
-The Rust side owns fd readiness, timers, and cross-thread wakeup. A small level-triggered reactor core (the `polling` crate, kqueue/epoll) is hosted on a Tokio current-thread runtime, which waits on the reactor's own pollable fd. This split preserves the level-triggered `add_reader` contract that asyncio requires and Tokio's edge-triggered driver cannot express. Rust futures spawned on the runtime advance during every blocking poll, with the GIL released, on the same thread and reactor as the Python loop.
+The Rust side owns fd readiness, timers, and cross-thread wakeup through a small level-triggered reactor core (`polling`, using kqueue/epoll). The Python driver blocks directly in the reactor with the GIL released. The same PyO3-free core is available to Rust consumers; embedding runtimes can run futures on their own workers and wake the Python loop through its thread-safe scheduling path.
 
 ## Compatibility
 
@@ -62,6 +62,5 @@ A KeyboardInterrupt injected while the loop runs (the kernel interrupt mechanism
 
 ## Performance
 
-Throughput matches the standard loop on real I/O workloads. A 30-second soak serving a fasthtml app under concurrent HTTP and websocket load holds a 2.6ms median response with no fd or memory growth. Microbenchmarks run 5 to 15% slower than the standard loop, and creating a task costs about twice as much, because each schedule crosses the Python/Rust boundary. uvloop is faster where speed is the requirement.
-
+Throughput matches the standard loop on real I/O workloads. A 30-second soak serving a fasthtml app under concurrent HTTP and websocket load holds a 2.6ms median response with no fd or memory growth. There is a small overhead involved in getting the better interrupt semantics, due to having to cross the Rust boundary. It applies only when something is scheduled onto the loop, and is then under 1µs per operation: `create_task`, an `await` that suspends, `asyncio.sleep`, or `call_soon`. Code that stays inside Python, including an `await` that does not suspend, pays nothing. The median overshoot of a 1ms timer is ~0.2ms, similar to Python's standard loop.
 

{loopmini-0.1.1 → loopmini-0.2.2}/README.md

@@ -20,9 +20,9 @@ pip install loopmini
 
 ## Design
 
-The Python side subclasses `asyncio.AbstractEventLoop` and reuses the stock `Task`, `Future`, `Handle`, and `sslproto` machinery. Contextvars, cancellation, and task introspection therefore behave exactly as in the standard loop. CPython releases change little that loopmini must track, because the version-sensitive objects are CPython's own.
+The Python side subclasses `asyncio.BaseEventLoop` and reuses its task, future, executor, error-handling, networking, server, sendfile, and subprocess machinery. Reactor-neutral socket, Unix, pipe, and accept implementations come directly from CPython's selector loop. Loopmini supplies the scheduling and fd-readiness hooks plus socket and datagram transports, so version-sensitive asyncio behavior remains CPython's own.
 
-The Rust side owns fd readiness, timers, and cross-thread wakeup. A small level-triggered reactor core (the `polling` crate, kqueue/epoll) is hosted on a Tokio current-thread runtime, which waits on the reactor's own pollable fd. This split preserves the level-triggered `add_reader` contract that asyncio requires and Tokio's edge-triggered driver cannot express. Rust futures spawned on the runtime advance during every blocking poll, with the GIL released, on the same thread and reactor as the Python loop.
+The Rust side owns fd readiness, timers, and cross-thread wakeup through a small level-triggered reactor core (`polling`, using kqueue/epoll). The Python driver blocks directly in the reactor with the GIL released. The same PyO3-free core is available to Rust consumers; embedding runtimes can run futures on their own workers and wake the Python loop through its thread-safe scheduling path.
 
 ## Compatibility
 
@@ -34,5 +34,4 @@ A KeyboardInterrupt injected while the loop runs (the kernel interrupt mechanism
 
 ## Performance
 
-Throughput matches the standard loop on real I/O workloads. A 30-second soak serving a fasthtml app under concurrent HTTP and websocket load holds a 2.6ms median response with no fd or memory growth. Microbenchmarks run 5 to 15% slower than the standard loop, and creating a task costs about twice as much, because each schedule crosses the Python/Rust boundary. uvloop is faster where speed is the requirement.
-
+Throughput matches the standard loop on real I/O workloads. A 30-second soak serving a fasthtml app under concurrent HTTP and websocket load holds a 2.6ms median response with no fd or memory growth. There is a small overhead involved in getting the better interrupt semantics, due to having to cross the Rust boundary. It applies only when something is scheduled onto the loop, and is then under 1µs per operation: `create_task`, an `await` that suspends, `asyncio.sleep`, or `call_soon`. Code that stays inside Python, including an `await` that does not suspend, pays nothing. The median overshoot of a 1ms timer is ~0.2ms, similar to Python's standard loop.

{loopmini-0.1.1 → loopmini-0.2.2}/pyproject.toml

@@ -7,7 +7,7 @@ name = "loopmini"
 dynamic = ["version"]
 description = "Rust-backed asyncio event loop"
 license = {text = "Apache-2.0"}
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 readme = "README.md"
 authors = [{name = "Jeremy Howard", email = "github@jhoward.fastmail.fm"}]
 classifiers = [

loopmini-0.2.2/python/loopmini/loop.py

@@ -0,0 +1,251 @@
+"An asyncio event loop whose reactor (fd readiness, timers, cross-thread wakeup) runs in Rust."
+import errno, functools, os, signal, socket, subprocess, sys, threading, time, weakref
+from asyncio import base_events, events, selector_events, sslproto, unix_events
+from ._core import Reactor
+from .transports import SockTransport, DatagramTransport
+from .subproc import SubprocessTransport
+
+__all__ = ["Loop", "new_event_loop"]
+
+_SelLoop = selector_events.BaseSelectorEventLoop
+_UnixLoop = unix_events._UnixSelectorEventLoop
+
+def _fileno(fd): return fd if isinstance(fd, int) else fd.fileno()
+
+def _sighandler_noop(signum, frame): pass
+
+def _timed_run(h, run):
+    "Debug-mode dispatch: log callbacks exceeding `loop.slow_callback_duration`, like the standard loop"
+    t0 = time.monotonic()
+    run()
+    dt = time.monotonic() - t0
+    if dt >= h._loop.slow_callback_duration: base_events.logger.warning('Executing %s took %.3f seconds', base_events._format_handle(h), dt)
+
+class _TimedHandle(events.Handle):
+    def _run(self): _timed_run(self, lambda: events.Handle._run(self))
+
+class _TimerHandle(events.TimerHandle):
+    "A stock TimerHandle plus the reactor key that lets cancellation drop the timer at once."
+    __slots__ = ('_reactor_key',)
+
+class _TimedTimerHandle(_TimerHandle):
+    def _run(self): _timed_run(self, lambda: events.TimerHandle._run(self))
+
+# Tests and log scrapers match on '<Handle ...>' reprs, so the subclasses keep those names
+_TimedHandle.__name__ = _TimedHandle.__qualname__ = 'Handle'
+_TimerHandle.__name__ = _TimerHandle.__qualname__ = 'TimerHandle'
+_TimedTimerHandle.__name__ = _TimedTimerHandle.__qualname__ = 'TimerHandle'
+
+class Loop(base_events.BaseEventLoop):
+    def __init__(self,
+        reactor=None, # A `_core.Reactor`-shaped object; an embedding host passes one on its own runtime
+    ):
+        super().__init__()
+        self._r = reactor if reactor is not None else Reactor()
+        # Anchor the reactor clock to time.monotonic (same underlying clock, so the
+        # offset is constant): libraries compare loop.time() against monotonic directly
+        self._time_offset = time.monotonic() - self._r.time()
+        self._signal_handlers = {}
+        self._unix_server_sockets = {}
+        self._transports = weakref.WeakValueDictionary()
+        self._readers,self._writers = {},{}
+
+    def time(self): return self._r.time() + self._time_offset
+
+    def _call_soon(self, callback, args, context):
+        h = (_TimedHandle if self._debug else events.Handle)(callback, args, self, context)
+        if h._source_traceback: del h._source_traceback[-1]
+        self._r.schedule(h)
+        return h
+
+    def call_soon_threadsafe(self, callback, *args, context=None):
+        self._check_closed()
+        self._check_callback(callback, 'call_soon_threadsafe')
+        h = (_TimedHandle if self._debug else events.Handle)(callback, args, self, context)
+        if h._source_traceback: del h._source_traceback[-1]
+        self._r.schedule_ts(h)
+        return h
+
+    def call_at(self, when, callback, *args, context=None):
+        if when is None: raise TypeError('when cannot be None')
+        self._check_closed()
+        if self._debug:
+            self._check_thread()
+            self._check_callback(callback, 'call_at')
+        h = (_TimedTimerHandle if self._debug else _TimerHandle)(when, callback, args, self, context)
+        if h._source_traceback: del h._source_traceback[-1]
+        h._reactor_key = self._r.schedule_at(when - self._time_offset, h)
+        return h
+
+    def _timer_handle_cancelled(self, handle):
+        # False (already fired) is fine: dispatch skips the promoted handle's cancelled flag
+        self._r.cancel_timer(handle._reactor_key)
+
+    def run_forever(self):
+        self._run_forever_setup()
+        main = threading.current_thread() is threading.main_thread()
+        try:
+            if main: old_wakeup = self._setup_signal_wakeup()
+            try: self._r.run()
+            finally:
+                if main: self._teardown_signal_wakeup(old_wakeup)
+        finally: self._run_forever_cleanup()
+
+    def _setup_signal_wakeup(self):
+        self._ssock,self._csock = socket.socketpair()
+        for s in (self._ssock,self._csock): s.setblocking(False)
+        old = signal.set_wakeup_fd(self._csock.fileno())
+        self.add_reader(self._ssock.fileno(), self._drain_signal_sock)
+        return old
+
+    def _drain_signal_sock(self):
+        try: data = self._ssock.recv(4096)
+        except (BlockingIOError, InterruptedError): return
+        for sig in data:
+            h = self._signal_handlers.get(sig)
+            if h is not None and not h.cancelled(): self._r.schedule(h)
+
+    def add_signal_handler(self, sig, callback, *args):
+        self._check_callback(callback, 'add_signal_handler')
+        h = events.Handle(callback, args, self, None)
+        self._signal_handlers[sig] = h
+        try: signal.signal(sig, _sighandler_noop)
+        except OSError as e:
+            del self._signal_handlers[sig]
+            if e.errno == errno.EINVAL: raise RuntimeError(f'sig {sig} cannot be caught') from None
+            raise
+        except ValueError:
+            del self._signal_handlers[sig]
+            raise
+
+    def remove_signal_handler(self, sig):
+        if sig not in self._signal_handlers: return False
+        del self._signal_handlers[sig]
+        try: signal.signal(sig, signal.default_int_handler if sig == signal.SIGINT else signal.SIG_DFL)
+        except OSError as e:
+            if e.errno == errno.EINVAL: raise RuntimeError(f'sig {sig} cannot be caught') from None
+            raise
+        return True
+
+    def _teardown_signal_wakeup(self, old):
+        self.remove_reader(self._ssock.fileno())
+        signal.set_wakeup_fd(old)
+        self._ssock.close()
+        self._csock.close()
+
+    def stop(self): self._r.stop()
+
+    def close(self):
+        if self.is_running(): raise RuntimeError('Cannot close a running event loop')
+        if self.is_closed(): return
+        for sig in list(self._signal_handlers): self.remove_signal_handler(sig)
+        self._r.close()
+        super().close()
+
+    def _add_io(self, fd, callback, args, handles, add, context=None):
+        fd = _fileno(fd)
+        h = events.Handle(callback, args, self, context)
+        old = handles.get(fd)
+        if old is not None: old.cancel()
+        handles[fd] = h
+        add(fd, h)
+        return h
+
+    def _remove_io(self, fd, handles, remove):
+        # A queued readiness callback may still fire this turn; cancelling the stored
+        # handle makes the dispatcher skip it, matching the standard loop's remove_reader
+        fd = _fileno(fd)
+        h = handles.pop(fd, None)
+        if h is not None: h.cancel()
+        if fd < 0: return False
+        return remove(fd)
+
+    def add_reader(self, fd, callback, *args): return self._add_io(fd, callback, args, self._readers, self._r.add_reader)
+    def remove_reader(self, fd): return self._remove_io(fd, self._readers, self._r.remove_reader)
+    def add_writer(self, fd, callback, *args): return self._add_io(fd, callback, args, self._writers, self._r.add_writer)
+    def remove_writer(self, fd): return self._remove_io(fd, self._writers, self._r.remove_writer)
+    def _add_reader(self, fd, callback, *args): return self.add_reader(fd, callback, *args)
+    def _remove_reader(self, fd): return self.remove_reader(fd)
+    def _add_writer(self, fd, callback, *args): return self.add_writer(fd, callback, *args)
+    def _remove_writer(self, fd): return self.remove_writer(fd)
+
+    _ensure_fd_no_transport,_sock_read_done,_sock_write_done = _SelLoop._ensure_fd_no_transport,_SelLoop._sock_read_done,_SelLoop._sock_write_done
+    sock_recv,_sock_recv = _SelLoop.sock_recv,_SelLoop._sock_recv
+    sock_recv_into,_sock_recv_into = _SelLoop.sock_recv_into,_SelLoop._sock_recv_into
+    sock_recvfrom,_sock_recvfrom = _SelLoop.sock_recvfrom,_SelLoop._sock_recvfrom
+    sock_recvfrom_into,_sock_recvfrom_into = _SelLoop.sock_recvfrom_into,_SelLoop._sock_recvfrom_into
+    sock_sendall,_sock_sendall = _SelLoop.sock_sendall,_SelLoop._sock_sendall
+    sock_sendto,_sock_sendto = _SelLoop.sock_sendto,_SelLoop._sock_sendto
+    sock_accept,_sock_accept = _SelLoop.sock_accept,_SelLoop._sock_accept
+    sock_connect,_sock_connect,_sock_connect_cb = _SelLoop.sock_connect,_SelLoop._sock_connect,_SelLoop._sock_connect_cb
+
+    def _make_socket_transport(self, sock, protocol, waiter=None, *, extra=None, server=None, context=None):
+        # The accept path (gh: _accept_connection2) swallows transport-creation errors
+        # outside debug mode; report before re-raising so server-side bugs are never silent
+        try: return SockTransport(self, sock, protocol, waiter, extra, server, context)
+        except (SystemExit, KeyboardInterrupt): raise
+        except BaseException as e:
+            if server is not None: self.call_exception_handler(dict(message='loopmini: error creating server-side transport', exception=e, socket=sock))
+            raise
+
+    def _make_ssl_transport(self, sock, protocol, sslcontext, waiter=None, *, server_side=False, server_hostname=None, extra=None, server=None,
+        ssl_handshake_timeout=None, ssl_shutdown_timeout=None, call_connection_made=True, context=None):
+        ssl_protocol = sslproto.SSLProtocol(self, protocol, sslcontext, waiter, server_side, server_hostname,
+            call_connection_made=call_connection_made, ssl_handshake_timeout=ssl_handshake_timeout, ssl_shutdown_timeout=ssl_shutdown_timeout)
+        SockTransport(self, sock, ssl_protocol, extra=extra, server=server, context=context)
+        return ssl_protocol._app_transport
+
+    def _make_datagram_transport(self, sock, protocol, address=None, waiter=None, extra=None):
+        return DatagramTransport(self, sock, protocol, address, waiter, extra)
+    def _make_read_pipe_transport(self, pipe, protocol, waiter=None, extra=None): return unix_events._UnixReadPipeTransport(self, pipe, protocol, waiter, extra)
+    def _make_write_pipe_transport(self, pipe, protocol, waiter=None, extra=None):
+        return unix_events._UnixWritePipeTransport(self, pipe, protocol, waiter, extra)
+
+    async def _make_subprocess_transport(self, protocol, args, shell, stdin, stdout, stderr, bufsize, extra=None, **kwargs):
+        popen = functools.partial(subprocess.Popen, args, shell=shell, stdin=stdin, stdout=stdout, stderr=stderr, bufsize=bufsize, **kwargs)
+        proc = await self.run_in_executor(None, popen)
+        waiter = self.create_future()
+        transport = SubprocessTransport(self, protocol, args, shell, stdin, stdout, stderr, bufsize, proc, waiter, extra, **kwargs)
+        try: await waiter
+        except BaseException:
+            transport.close()
+            await transport._wait()
+            raise
+        return transport
+
+    _start_serving = _SelLoop._start_serving
+    _accept_connection = _SelLoop._accept_connection
+    _accept_connection2 = _SelLoop._accept_connection2
+
+    def _stop_serving(self, sock):
+        path = sock.getsockname() if sock in self._unix_server_sockets else None
+        self.remove_reader(sock.fileno())
+        sock.close()
+        if path is None: return
+        inode = self._unix_server_sockets.pop(sock)
+        try:
+            if os.stat(path).st_ino == inode: os.unlink(path)
+        except OSError: pass
+
+    create_unix_connection = _UnixLoop.create_unix_connection
+    create_unix_server = _UnixLoop.create_unix_server
+
+if not hasattr(base_events.BaseEventLoop, '_run_forever_setup'):  # the helpers first appear in 3.12; transcribed from 3.11's inline run_forever, which is frozen
+    def _run_forever_setup(self):
+        self._check_closed()
+        self._check_running()
+        self._set_coroutine_origin_tracking(self._debug)
+        self._thread_id = threading.get_ident()
+        self._old_agen_hooks = sys.get_asyncgen_hooks()
+        sys.set_asyncgen_hooks(firstiter=self._asyncgen_firstiter_hook, finalizer=self._asyncgen_finalizer_hook)
+        events._set_running_loop(self)
+    def _run_forever_cleanup(self):
+        self._thread_id = None
+        events._set_running_loop(None)
+        self._set_coroutine_origin_tracking(False)
+        sys.set_asyncgen_hooks(*self._old_agen_hooks)
+    Loop._run_forever_setup, Loop._run_forever_cleanup = _run_forever_setup, _run_forever_cleanup
+
+def new_event_loop(reactor=None):
+    "An event loop on a Rust reactor, for `asyncio.run(..., loop_factory=new_event_loop)`."
+    return Loop(reactor)

loopmini-0.2.2/python/loopmini/subproc.py

@@ -0,0 +1,20 @@
+"A nonblocking process spawn feeding asyncio's standard subprocess transport."
+import threading
+from asyncio import base_subprocess
+
+__all__ = ["SubprocessTransport"]
+
+class SubprocessTransport(base_subprocess.BaseSubprocessTransport):
+    def __init__(self, loop, protocol, args, shell, stdin, stdout, stderr, bufsize, proc, waiter=None, extra=None, **kwargs):
+        self._prepared_proc = proc
+        super().__init__(loop, protocol, args, shell, stdin, stdout, stderr, bufsize, waiter, extra, **kwargs)
+        threading.Thread(target=self._reap, daemon=True).start()
+
+    def _start(self, **kwargs):
+        self._proc = self._prepared_proc
+        del self._prepared_proc
+
+    def _reap(self):
+        returncode = self._proc.wait()
+        try: self._loop.call_soon_threadsafe(self._process_exited, returncode)
+        except RuntimeError: pass