httpunk 0.4.2__tar.gz → 0.4.4__tar.gz

{httpunk-0.4.2 → httpunk-0.4.4}/Cargo.lock

@@ -20,12 +20,28 @@ version = "1.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fc652a48c352aef3ea3aed32080501cf3ef6ed5da78602a020c991775b0aff04"
 
+[[package]]
+name = "cc"
+version = "1.4.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "54413ede23c2daf518f35156dfde027feb2374004d63bd497f983c8db9c0e313"
+dependencies = [
+ "find-msvc-tools",
+ "shlex",
+]
+
 [[package]]
 name = "equivalent"
 version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
 
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef25905e51abafe4dcea6c15fec58c57b601cdbd0ee53d22ea1d3016c587d39b"
+
 [[package]]
 name = "fnv"
 version = "1.0.7"
@@ -118,12 +134,13 @@ checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
 
 [[package]]
 name = "httpunk"
-version = "0.4.2"
+version = "0.4.4"
 dependencies = [
  "bytes",
  "h2",
  "http",
  "hyper",
+ "mimalloc",
  "pyo3",
  "vendor-h2",
  "vendor-hyper",
@@ -179,6 +196,24 @@ version = "0.2.189"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"
 
+[[package]]
+name = "libmimalloc-sys"
+version = "0.1.49"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a45a52f43e1c16f667ccfe4dd8c85b7f7c204fd5e3bf46c5b0db9a5c3c0b8e9"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "mimalloc"
+version = "0.1.52"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d4139bb28d14ad1facf21d5eb8825051b326e172d216b39f6d31df53cc97862"
+dependencies = [
+ "libmimalloc-sys",
+]
+
 [[package]]
 name = "once_cell"
 version = "1.21.4"
@@ -278,6 +313,12 @@ dependencies = [
  "proc-macro2",
 ]
 
+[[package]]
+name = "shlex"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
+
 [[package]]
 name = "slab"
 version = "0.4.12"

{httpunk-0.4.2 → httpunk-0.4.4}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "httpunk"
-version = "0.4.2"
+version = "0.4.4"
 description = "The Rust HTTP library for Python"
 authors = [
     "Giovanni Barillari <g@baro.dev>",
@@ -39,22 +39,19 @@ name = "_httpunk"
 crate-type = ["cdylib"]
 
 [features]
+mimalloc = ["dep:mimalloc"]
 # Never enabled. Exists only so the optional crates.io `h2`/`hyper` deps are
 # referenced (no "unused optional dependency"), keeping them in Cargo.lock for
 # advisory scanning while they stay uncompiled. See the dependency comments.
 _audit = ["dep:h2", "dep:hyper"]
 
 [dependencies]
-pyo3 = { version = "=0.29", features = ["extension-module", "generate-import-lib"] }
-# Used by the PyO3 layer (src/py): `http::HeaderMap` (the HeaderMap wrapper) and
-# `bytes` buffers in the codecs.
 bytes = "1"
 http = "1.1"
-# The vendored crates, as workspace members (own their crate roots → byte-identical
-# to upstream, and fmt/clippy-excludable via `cargo fmt -p _httpunk`).
+mimalloc = { version = "0.1.49", default-features = false, features = ["local_dynamic_tls"], optional = true }
+pyo3 = { version = "=0.29", features = ["extension-module", "generate-import-lib"] }
 vendor-h2 = { path = "crates/vendor-h2" }
 vendor-hyper = { path = "crates/vendor-hyper", features = ["client", "server", "http1"] }
-# Vendored hyper-util proxy matcher (pure sans-IO selection logic; `from_system` off).
 vendor-hyper-util = { path = "crates/vendor-hyper-util" }
 # NOT compiled: the crates.io `h2`/`hyper` — vendored into crates/vendor-*/ (see
 # THIRD-PARTY.md). Optional + gated behind the never-enabled `_audit` feature so

{httpunk-0.4.2 → httpunk-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: httpunk
-Version: 0.4.2
+Version: 0.4.4
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License
@@ -20,7 +20,7 @@ Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Rust
 Classifier: Topic :: Internet :: WWW/HTTP
-Requires-Dist: tonio~=0.9.17 ; python_full_version >= '3.14' and extra == 'tonio'
+Requires-Dist: tonio~=0.10.0 ; python_full_version >= '3.14' and extra == 'tonio'
 Provides-Extra: tonio
 License-File: LICENSE
 Summary: The Rust HTTP library for Python

{httpunk-0.4.2 → httpunk-0.4.4}/httpunk/_backend/asyncio.py

@@ -445,6 +445,19 @@ class AsyncioBackend:
             await asyncio.gather(*losers, return_exceptions=True)
         return winner.result()
 
+    async def select_events(self, *events):
+        """Resume once ANY of `events` is set (see the tonio twin): one `asyncio.wait`
+        over the events' `wait()` futures, the losers cancelled and drained on the way
+        out — also when this wait is itself cancelled. No verdict: the caller reads the
+        events' flags."""
+        waits = [asyncio.ensure_future(e.wait()) for e in events]
+        try:
+            await asyncio.wait(waits, return_when=asyncio.FIRST_COMPLETED)
+        finally:
+            for w in waits:
+                w.cancel()
+            await asyncio.gather(*waits, return_exceptions=True)
+
     def queue(self):
         """An unbounded queue as `(sender, receiver)`: `sender.send(x)` is sync;
         `await receiver.receive()` yields items in order."""

{httpunk-0.4.2 → httpunk-0.4.4}/httpunk/_backend/tonio.py

@@ -7,8 +7,8 @@ across coroutines — so a future asyncio/trio backend is a drop-in replacement.
 
 import ssl as _ssl
 
-from tonio import colored as _colored
-from tonio._net._tls import _is_eof  # private: the TLS clean-EOF test `TLSStream.receive_some` applies
+from tonio import Waiter as _Waiter, colored as _colored
+from tonio._tonio import get_runtime as _get_runtime  # private: the runtime's µs clock (`_clock`), see `bounded_reader`
 from tonio.colored.net import SocketStream as _SocketStream, open_tcp_stream as _open_tcp_stream
 from tonio.colored.net.tls import TLSStream as _TLSStream, open_tls_over_tcp_stream as _open_tls_over_tcp_stream
 from tonio.colored.sync import Lock as _Lock, Semaphore as _Semaphore
@@ -100,140 +100,114 @@ class TonioBackend:
         return tls, tls._ssl.selected_alpn_protocol()
 
     def receive_nowait(self, transport, max_bytes=65536):
-        """A synchronous, non-blocking read: whatever bytes are immediately
-        available without suspending, `b""` at EOF, or `None` if nothing is ready
-        right now. The readiness primitive hyper's server drain (`poll_read_body`
-        inside `poll_drain_or_close_read`) relies on. EOF and not-ready are distinct.
-
-        - **Plain socket**: tonio's sockets are non-blocking under the hood (its own
-          `recv` does exactly this `_sock.recv` inline before ever suspending), so
-          we read the raw socket directly rather than route through the timer-backed
-          `timeout(..., 0)`, which cannot express an instantaneous peek.
-        - **TLS (`TLSStream`)**: the raw socket carries *ciphertext*, so reading it
-          would bypass decryption (and a `TLSStream` has no `.socket` anyway). The
-          non-blocking-plaintext equivalent is the SSLObject's already-decrypted
-          buffer: `pending()` bytes can be `read()` without touching the BIO/socket.
-          tonio's `_SSLProxy` serialises EVERY use of its `SSLObject` — the parked
-          reader's `_read` included — under one `threading.Lock`; the peek takes that
-          same lock (private API, tonio and httpunk share an author) so its
-          pending-then-read is ONE step against a reader decrypting on another thread,
-          never a `read()` of bytes the reader just consumed.
-          (Necessarily conservative — tonio exposes no non-blocking "decrypt more",
-          so unread ciphertext on the socket reads as "nothing ready"; the drain
-          then closes rather than reuses, which matches hyper's cheap-drain-or-close.
-          EOF is never reported for TLS either — it is only knowable by decrypting.)
-        - A peek beside a parked plain-socket reader is safe: both are one `recv`
-          syscall on the same non-blocking socket, the bytes go to exactly one of
-          them, and the loser's `EAGAIN` sends it back to waiting (tonio `recv`)."""
-        if isinstance(transport, _TLSStream):  # peek only already-decrypted plaintext
-            ssl_obj = transport._ssl
-            with ssl_obj._lock:  # tonio `_SSLProxy._lock`: the SSLObject's one lock
-                pending = ssl_obj._inner.pending()
-                return ssl_obj._inner.read(min(max_bytes, pending)) if pending else None
-        try:
-            return transport.socket._sock.recv(max_bytes)  # b"" only at EOF
-        except (BlockingIOError, InterruptedError):
-            return None
+        """A synchronous, non-blocking read: whatever bytes are immediately available
+        without suspending, `b""` at EOF, or `None` if nothing is ready right now. The
+        readiness primitive hyper's server drain (`poll_read_body` inside
+        `poll_drain_or_close_read`) relies on. EOF and not-ready are distinct.
+
+        tonio's own no-wait read on both streams (`receive_some_nowait`: `NotReady` is
+        this seam's `None`). On a plain socket it is one `recv` (EAGAIN clears the
+        readiness bits, as tonio's `recv` does). Over TLS it decrypts what the socket
+        already holds — feeds the ingress BIO without suspending — the way hyper's read
+        over rustls does, so the server's drain finds a small unread body instead of
+        closing; a close_notify already in the socket is `b""`, an abrupt close raises
+        `ResourceBroken` (a `broken_transport_errors` shape, like the plain socket's
+        `ConnectionResetError`). Beside a parked reader: on a plain socket both are one
+        `recv` on the same non-blocking socket and the bytes go to exactly one of them;
+        over TLS the parked reader holds the receive lock, so the peek answers `None`
+        whatever the socket holds — hyper's `require_empty_read` looks at its `read_buf`
+        the same way, and ciphertext not yet decrypted is invisible to it too."""
+        data = transport.receive_some_nowait(max_bytes)
+        return None if data is transport.NotReady else data
 
     def bounded_reader(self, transport):
         """Chosen ONCE per connection: how `transport`'s reads are bounded by a deadline —
         the h1 server's head-read deadline (hyper `header_read_timeout`) riding the read
         itself, so no task is spawned per head and no parked read is ever cancelled.
         Returns `async read(max_bytes, deadline) -> bytes | b"" (EOF) | None (expired)`;
-        `deadline` is an instant on this backend's `monotonic` clock. The transport's kind
-        is fixed for the connection's life, so the dispatch happens here, never per read,
-        and the plain-socket reader is one coroutine over bound methods resolved here —
-        the cost of tonio's own `receive_some`, plus one arm on the (cold) timer path.
+        `deadline` is an instant on this backend's `monotonic` clock (seconds, the seam's
+        unit). The transport's kind is fixed for the connection's life, so the dispatch
+        happens here, never per read, over bound methods resolved here.
+
+        Both readers are tonio's own `wait_readable(timeout)` loop inlined over the
+        stream's no-wait read and its readiness waiter — the same primitives, without the
+        coroutine frame per park and without the seconds -> µs -> seconds round trip: the
+        deadline is converted once per read, and each park compares it with the runtime's
+        µs clock (`_clock`, read off the runtime cached at bind time rather than through
+        `get_runtime()` on every pass; private API — tonio and httpunk share an author).
 
         Bytes first, hyper's order (`poll_read_head`: `parse` -> `poll_read`, and the timer
-        is polled only once that returned Pending): every pass tries the syscall before it
-        looks at the clock, and a wake that finds bytes returns them, whatever the timer did.
-
-        - **Plain socket**: the syscall comes first — the readiness bits are stale-set after
-          any successful read (nothing but a failed syscall clears them), exactly as tokio's
-          readiness word is when hyper's `poll_read` runs, so both pay one `EAGAIN` probe
-          per head; only on `EAGAIN` (`clear_r`, as tonio's own `recv`) is the remaining time
-          computed. Past the deadline that is the answer at once: hyper's Pending followed
-          by a ready timer poll (`new_header_timeout`) — no zero-length timer is ever
-          armed. Otherwise the socket's own arm (`_io_arm_r(timeout)`) puts the readiness
-          wait and the timer on ONE suspension (a `Waiter` with a timer). Both wakes resume
-          with `None`; the readiness word tells them apart: a readiness wake set bits
-          before waking (`set_readiness` precedes `wake`), a timer wake set none — so a
-          bare `_io_arm_r()` after the wake asks "readable?": `None` = bits set (read now),
-          a waiter = the timer fired. That waiter is never awaited: a stale reader slot,
-          overwritten by the next arm, harmless by tonio's contract. One reader per socket,
-          and `clear_r` runs only on this reader's failed syscall, so nothing consumes the
-          bits in between. Every arm is computed from the absolute deadline, so a spurious
-          readiness wake (`EAGAIN` after a wake) re-arms for the remaining time.
-        - **TLS (`TLSStream`)**: `TLSStream.receive_some` is `_ssl_dance(_read)` with
-          `_recv` feeding the ingress BIO from the raw socket; this is that dance with the
-          raw read bounded (private API — tonio and httpunk share an author; keep in step
-          with `tonio/_colored/_net/_tls.py`).
+        is polled only once that returned Pending): every pass tries the read before it
+        looks at the clock, so a wake that finds bytes returns them, whatever the timer
+        did. The readiness bits are stale-set after any successful read (nothing but a
+        failed syscall clears them), exactly as tokio's readiness word is when hyper's
+        `poll_read` runs, so both pay one `EAGAIN` probe per head; only on `NotReady`
+        (which cleared the bits) is the remaining time computed. Past the deadline that is
+        the answer at once — hyper's Pending followed by a ready timer poll
+        (`new_header_timeout`) — and no zero-length timer is ever armed. Otherwise the
+        waiter puts the readiness wait and the timer on ONE suspension, and after the wake
+        the readiness question is asked BEFORE the next read: `None` = the bits are set
+        (read now), a waiter = none are, so the timer fired (a stale reader slot, overwritten
+        by the next arm, harmless by tonio's contract). That question is not optional: the
+        socket's `_io_clear_r` is tick-guarded — it clears the bits only if no readiness
+        edge landed since an arm last SAW them set — so a wake followed straight by a read
+        leaves the edge unobserved, the next head's `EAGAIN` clear is ignored, and that head
+        pays a second syscall (measured: 3 reads and 2 arms per request instead of 2 and 1).
+        Every arm is computed from the absolute deadline, so a wake that finds nothing to
+        read re-arms for what is left.
+
+        - **Plain socket**: `waiter_readable(µs)` is the socket's own arm: `None` when the
+          bits landed between the probe and the arm (read now), else the waiter; bare, it
+          is the readiness question.
+        - **TLS (`TLSStream`)**: `watch_readable()` holds the receive lock across the arm
+          and the park (as tonio's `wait_readable` does); its waiter is `None` when
+          plaintext is already decoded, the raw socket's arm otherwise, and the lock's own
+          hand-off when a parked reader holds it; `ready()` is the question (plaintext
+          pending, or the socket's bare arm). A "not ready" wake loops back to the clock
+          rather than returning: after a lock hand-off nothing was armed, so it is not a
+          verdict there (that hand-off never happens in httpunk — one reader per connection
+          — but the loop stays exact). `receive_some_nowait` decrypts.
         A transport is one of tonio's two streams — a `TLSStream` or a `SocketStream` —
         and nothing else; anything else fails here, at setup, not on a read."""
+        runtime = _get_runtime()  # one runtime per process, bound once per connection
         if isinstance(transport, _TLSStream):
-            return self._tls_bounded_reader(transport)
-        return self._socket_bounded_reader(transport.socket)
+            return self._tls_bounded_reader(transport, runtime)
+        return self._socket_bounded_reader(transport, runtime)
 
     @staticmethod
-    def _socket_bounded_reader(sock):
-        arm, clear, recv = sock._io_arm_r, sock._io_clear_r, sock._sock.recv
+    def _socket_bounded_reader(stream, runtime):
+        nowait, arm, not_ready = stream.receive_some_nowait, stream.waiter_readable, stream.NotReady
 
         async def read(max_bytes, deadline):
-            while True:
-                try:
-                    return recv(max_bytes)  # bytes first: hyper's `poll_read` before its timer poll
-                except InterruptedError:
-                    continue
-                except BlockingIOError:
-                    clear()  # EAGAIN: the bits were stale (or a spurious wake) — now the timer
-                micros = round((deadline - _now()) * 1_000_000)
-                if micros <= 0:
+            deadline_micros = int(deadline * 1_000_000)  # the seam's seconds -> the runtime clock's µs, once per read
+            while (data := nowait(max_bytes)) is not_ready:  # bytes first; EAGAIN clears the bits
+                remaining = deadline_micros - runtime._clock
+                if remaining <= 0:
                     return None  # nothing readable and the deadline passed: hyper's timer poll is ready
-                waiter = arm(micros)
-                if waiter is None:
-                    continue  # bits landed between the EAGAIN and the arm: read now
-                await waiter
-                if arm() is not None:  # no readiness bits: the timer woke us
-                    return None
+                if (waiter := arm(remaining)) is not None:  # None: bits landed between the probe and the arm
+                    await waiter
+                    if arm() is not None:  # the readiness question: no bits = the timer woke us
+                        return None
+            return data
 
         return read
 
     @staticmethod
-    def _tls_bounded_reader(stream):
-        ssl_obj = stream._ssl
-        raw_read = TonioBackend._socket_bounded_reader(stream.transport.socket)
+    def _tls_bounded_reader(stream, runtime):
+        nowait, watch, not_ready = stream.receive_some_nowait, stream.watch_readable, stream.NotReady
 
         async def read(max_bytes, deadline):
-            stream._check_ready()
-            try:
-                while True:
-                    try:
-                        ret, want_read, to_send = ssl_obj._read(max_bytes)
-                    except (_ssl.SSLError, _ssl.CertificateError) as exc:
-                        stream._set_broken()
-                        raise ResourceBroken from exc
-                    if to_send:
-                        await stream._send(to_send)
-                    elif want_read:
-                        recv_count = stream._recv_count
-                        async with stream._lock_recv:
-                            if recv_count == stream._recv_count:  # nobody fed the BIO meanwhile
-                                data = await raw_read(65536, deadline)
-                                if data is None:
-                                    return None
-                                if not data:
-                                    ssl_obj._ingress_write_eof()
-                                else:
-                                    stream._recv_est_size = max(stream._recv_est_size, len(data))
-                                    ssl_obj._ingress_write(data)
-                                stream._recv_count += 1
-                    if not want_read:
-                        return ret
-            except ResourceBroken as exc:
-                if stream._compat_https and _is_eof(exc.__cause__):
-                    return b""
-                raise
+            deadline_micros = int(deadline * 1_000_000)
+            while (data := nowait(max_bytes)) is not_ready:
+                remaining = deadline_micros - runtime._clock
+                if remaining <= 0:
+                    return None
+                with watch() as watcher:  # the receive lock is held across the park, as tonio's own wait
+                    if (waiter := watcher.waiter(remaining)) is not None:
+                        await waiter
+                        if not watcher.ready():  # the readiness question: nothing readable, back to the clock
+                            continue
+            return data
 
         return read
 
@@ -294,6 +268,12 @@ class TonioBackend:
     spawn_without_results = staticmethod(_colored.spawn.without_results)
 
     select = staticmethod(_colored.select)
+    # `await select_events(*events)`: resume once ANY of the events is set — ONE suspension
+    # of the calling task (tonio's merged waiter), no wrapper tasks, no scope, nothing to
+    # cancel; returns no verdict, the caller reads the events' flags. The race of "pump
+    # done" against "peer gone" in `_send_async_body` (h1 and h2): hyper's
+    # `PipeToSendStream` polling `poll_reset` beside the body future, in one task.
+    select_events = staticmethod(_Waiter.any)
     scope = staticmethod(_colored.scope)
     lock = _Lock
     event = _colored.Event

{httpunk-0.4.2 → httpunk-0.4.4}/httpunk/_common.py

@@ -44,16 +44,6 @@ async def read_all(aiter):
     return b"".join([chunk async for chunk in aiter])
 
 
-PUMP_DONE = object()  # sentinel: the async-body pump finished (`event_result`)
-PUMP_ABANDONED = object()  # sentinel: the peer abandoned the exchange first (`event_result`)
-
-
-async def event_result(evt, value):
-    """Await `evt`, then return `value` — a labelled racer for a one-shot `select`."""
-    await evt.wait()
-    return value
-
-
 async def aclose_body(body):
     """Deterministically close an async body once its pump is done with it — tonio
     finalizes nothing, so an async generator left unclosed never runs its cleanup."""

{httpunk-0.4.2 → httpunk-0.4.4}/httpunk/h1/client.py

@@ -276,7 +276,10 @@ class Connection(H1Framing, H1ClientState):
             # gets bytes delivered before the request treats them as the violation they
             # are — the watcher through the idle rules, since the exchange is not yet
             # active — so the outcome is the same either way; a plain-socket `recv` is
-            # one syscall. The TLS peek reads only already-decrypted plaintext.)
+            # one syscall. Over TLS the parked watcher holds the receive lock, so the peek
+            # sees nothing while it is parked: bytes still ciphertext in the socket reach
+            # the watcher's read instead — hyper's `read_buf` over rustls holds decrypted
+            # bytes only, and its next `poll_read_head` parses the rest as the response too.)
             transport = self.transport_ref()
             pending = self.backend.receive_nowait(transport, _READ_SIZE) if transport is not None else b""
             if pending:

{httpunk-0.4.2 → httpunk-0.4.4}/httpunk/h1/server.py

@@ -38,7 +38,7 @@ from collections.abc import AsyncIterator, Awaitable
 from typing import TYPE_CHECKING, Any
 
 from .. import _backend
-from .._common import PUMP_ABANDONED, PUMP_DONE, BaseServer, aclose_body, event_result, read_all
+from .._common import BaseServer, aclose_body, read_all
 from .._httpunk import (
     H1_NEXT_CLOSE,
     H1_NEXT_DRAIN,
@@ -623,25 +623,26 @@ class ServerConnection(H1Framing, H1ServerState):
         connection (so `mid_message_detect_eof`) while the body's next chunk is pending,
         so a parked producer (SSE, long poll) does not hold a dead exchange. Same shape as
         the h2 driver's `_send_async_body`: ONE pump task per response; this caller waits
-        once for "pump done" or "peer closed". On the FIN the pump is CANCELLED (hyper
+        ONCE, one suspension on both events (`select_events`: hyper's `PipeToSendStream`
+        polls `poll_reset` beside the body future in one task — no racer tasks, no scope
+        to cancel; a `select` here measured 5 µs and a 100 ms p99 tail per response), and
+        the flags afterwards are the verdict. On the FIN the pump is CANCELLED (hyper
         drops the body future) at its suspension — the app's `await`, or, h1 having no
         write pump, possibly inside a chunk write: harmless, this connection is closed
         right below and a truncated body is what the client gets regardless (hyper:
         `IncompleteMessage`, io dropped). Also cancelled if this task is cancelled or
         unwinds: neither backend cancels scope children on a body exception, and joining
-        a parked pump would hang. (A per-chunk `select` measured 4-5x slower.)"""
+        a parked pump would hang. (A per-chunk wait measured 4-5x slower.)"""
         await self._arm_watcher(req)  # the FIN is consumable now: make sure a read is parked
         done, box = self.backend.event(), []
         abandoned = False
         async with self.backend.scope() as scope:
             scope.spawn(self._pump_async_body(body, trailers, done, box))
             try:
-                winner = await self.backend.select(
-                    event_result(done, PUMP_DONE), event_result(req._peer_closed_evt, PUMP_ABANDONED)
-                )
+                await self.backend.select_events(done, req._peer_closed_evt)
                 # The event also marks the window's close (`_close_window`), which cannot
                 # precede this response's own completion — the state's flag is the verdict.
-                abandoned = winner is PUMP_ABANDONED and self.peer_closed_flag(req._seq) and not done.is_set()
+                abandoned = not done.is_set() and self.peer_closed_flag(req._seq)
             finally:
                 if not done.is_set():
                     scope.cancel()  # leave with the pump gone, whatever ended the wait

{httpunk-0.4.2 → httpunk-0.4.4}/httpunk/h2/connection.py

@@ -25,7 +25,7 @@ crates/vendor-h2), paths relative to its `src/`.
 import contextlib
 
 from .. import _backend
-from .._common import PUMP_ABANDONED, PUMP_DONE, aclose_body, aiter_body, event_result
+from .._common import aclose_body, aiter_body
 from .._httpunk import (
     H2_FLAG_CAPACITY,
     H2_FLAG_CONN_DONE,
@@ -433,21 +433,22 @@ class H2ConnectionBase(H2Streams):
     async def _send_async_body(self, st, body, trailers):
         """Stream an ASYNC body and fail fast on a peer reset — hyper's `PipeToSendStream`
         (proto/h2/mod.rs), which polls `poll_reset` while it waits for the body's next
-        chunk. ONE pump task per response queues each chunk; this caller waits once for
-        "pump done" or "stream reset". On a reset the pump is CANCELLED (hyper dropping
-        the body future) at the app's own `await` or the flow-control wait — DATA is
-        queued for the write pump, never written by this task, so no write is
-        interrupted. The scope exit does not wait for a CANCELLED child to unwind, so
-        wait for the pump's own `done` (set in its `finally`, after the producer's
-        cleanup ran)."""
+        chunk — in ONE task. ONE pump task per response queues each chunk; this caller
+        waits ONCE, one suspension on both events (`select_events`: no racer tasks, no
+        scope to cancel), for "pump done" or "stream reset", and the flags afterwards
+        are the verdict. On a reset the pump is CANCELLED (hyper dropping the body
+        future) at the app's own `await` or the flow-control wait — DATA is queued for
+        the write pump, never written by this task, so no write is interrupted. The
+        scope exit does not wait for a CANCELLED child to unwind, so wait for the pump's
+        own `done` (set in its `finally`, after the producer's cleanup ran)."""
         backend = self.backend
         done, box = backend.event(), []
         abandoned = False
         async with backend.scope() as scope:
             scope.spawn(self._pump_async_body(st, body, trailers, done, box))
             try:
-                winner = await backend.select(event_result(done, PUMP_DONE), event_result(st.reset_evt, PUMP_ABANDONED))
-                abandoned = winner is PUMP_ABANDONED and not done.is_set()
+                await backend.select_events(done, st.reset_evt)
+                abandoned = not done.is_set()  # the wait ended, the pump did not: the reset did
             finally:
                 if not done.is_set():
                     scope.cancel()  # leave with the pump gone, whatever ended the wait

{httpunk-0.4.2 → httpunk-0.4.4}/pyproject.toml

@@ -37,7 +37,7 @@ requires-python = ">=3.10"
 dependencies = []
 
 [project.optional-dependencies]
-tonio = ["tonio~=0.9.17; python_version >= '3.14'"]
+tonio = ["tonio~=0.10.0; python_version >= '3.14'"]
 
 [dependency-groups]
 build = [

{httpunk-0.4.2 → httpunk-0.4.4}/src/lib.rs

@@ -1,3 +1,7 @@
+#[cfg(feature = "mimalloc")]
+#[global_allocator]
+static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
+
 use pyo3::prelude::*;
 use std::sync::OnceLock;
 

httpunk-0.4.4/tests/_transport.py

@@ -0,0 +1,24 @@
+"""Test-side stand-in for the piece of tonio's `SocketStream` the backend's bounded
+reader binds at connection setup (`TonioBackend.bounded_reader`): the no-wait read
+`receive_some_nowait(n)` -> bytes | b"" | `NotReady`, and `waiter_readable(micros)` ->
+None (readable now) or a waiter to park on. A stub transport mixes this in and plugs its
+buffer in through three sync hooks: `_readable()`, `_recv_now(n)` (raises
+`BlockingIOError` when nothing is there), and `_park(timeout_micros)` -> an awaitable
+that resumes when bytes/EOF may have landed or the timer fired (never called by a stub
+that is always readable)."""
+
+
+class StubStream:
+    class NotReady:  # the stream's own sentinel, compared by identity (`transport.NotReady`)
+        pass
+
+    def receive_some_nowait(self, max_bytes=65536):
+        try:
+            return self._recv_now(max_bytes)
+        except BlockingIOError:
+            return self.NotReady
+
+    def waiter_readable(self, timeout=None):
+        if self._readable():
+            return None
+        return self._park(timeout)

{httpunk-0.4.2 → httpunk-0.4.4}/tests/test_asyncio_backend.py

@@ -246,6 +246,46 @@ async def test_select_cancels_racers_when_itself_cancelled():
     assert set(cancelled) == {"x", "y"}
 
 
+@pytest.mark.asyncio
+async def test_select_events_resumes_on_either_event_without_a_verdict():
+    # One wait on both events (the `_send_async_body` race): resumes once ANY is set,
+    # at once when one already is, returns nothing — the flags are the answer.
+    backend = AsyncioBackend()
+    a, b = backend.event(), backend.event()
+    a.set()
+    assert await backend.select_events(a, b) is None
+    a, b = backend.event(), backend.event()
+    loop = asyncio.get_running_loop()
+    loop.call_soon(b.set)
+    await backend.select_events(a, b)
+    assert not a.is_set() and b.is_set()
+    b.clear()
+    loop.call_soon(b.set)  # the events are reusable after a clear
+    await backend.select_events(a, b)
+    assert b.is_set()
+
+
+@pytest.mark.asyncio
+async def test_select_events_leaves_no_waiter_behind():
+    # The loser's wait is cancelled and drained: no task is left parked on the event, and
+    # cancelling the wait itself drains both.
+    backend = AsyncioBackend()
+    a, b = backend.event(), backend.event()
+    before = len(asyncio.all_tasks())
+    asyncio.get_running_loop().call_soon(a.set)
+    await backend.select_events(a, b)
+    assert len(asyncio.all_tasks()) == before  # the loser's wait task is gone
+    a, b = backend.event(), backend.event()
+    sel = asyncio.ensure_future(backend.select_events(a, b))
+    for _ in range(3):
+        await asyncio.sleep(0)  # both waits parked
+    sel.cancel()
+    with pytest.raises(asyncio.CancelledError):
+        await sel
+    await asyncio.sleep(0)
+    assert len(asyncio.all_tasks()) == before
+
+
 @pytest.mark.asyncio
 async def test_scope_spawn_cancel_and_join():
     backend = AsyncioBackend()