httpunk 0.4.0__tar.gz → 0.4.2__tar.gz

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

@@ -118,7 +118,7 @@ checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
 
 [[package]]
 name = "httpunk"
-version = "0.4.0"
+version = "0.4.2"
 dependencies = [
  "bytes",
  "h2",

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

@@ -1,6 +1,6 @@
 [package]
 name = "httpunk"
-version = "0.4.0"
+version = "0.4.2"
 description = "The Rust HTTP library for Python"
 authors = [
     "Giovanni Barillari <g@baro.dev>",

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: httpunk
-Version: 0.4.0
+Version: 0.4.2
 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.15 ; python_full_version >= '3.14' and extra == 'tonio'
+Requires-Dist: tonio~=0.9.17 ; python_full_version >= '3.14' and extra == 'tonio'
 Provides-Extra: tonio
 License-File: LICENSE
 Summary: The Rust HTTP library for Python
@@ -275,6 +275,12 @@ await stream.send_data(b"data: 2\n\n", end_stream=True)
 # stream.send_trailers({...}) ends the body with trailers; stream.send_reset() aborts it
 ```
 
+On HTTP/1, `send_response` arms the mid-message detection described above (the body may
+park between chunks); `detect_eof=False` skips that, so no read is parked for the response
+and a client that closes is noticed one write later, at the peer's RST, instead — unless
+`peer_closed()` asks, which still arms on demand. This is httpunk's own knob (hyper's read is
+always on); HTTP/2 accepts it and ignores it, a reset arrives through the connection anyway.
+
 `end_stream=True` on `send_response` is a bodyless response. Framing follows hyper: a
 `content-length` you set is honoured, otherwise the body is chunked (HTTP/1.1) or
 close-delimited (HTTP/1.0); on HEAD/204/304 body chunks are discarded, as hyper never polls

{httpunk-0.4.0 → httpunk-0.4.2}/README.md

@@ -239,6 +239,12 @@ await stream.send_data(b"data: 2\n\n", end_stream=True)
 # stream.send_trailers({...}) ends the body with trailers; stream.send_reset() aborts it
 ```
 
+On HTTP/1, `send_response` arms the mid-message detection described above (the body may
+park between chunks); `detect_eof=False` skips that, so no read is parked for the response
+and a client that closes is noticed one write later, at the peer's RST, instead — unless
+`peer_closed()` asks, which still arms on demand. This is httpunk's own knob (hyper's read is
+always on); HTTP/2 accepts it and ignores it, a reset arrives through the connection anyway.
+
 `end_stream=True` on `send_response` is a bodyless response. Framing follows hyper: a
 `content-length` you set is honoured, otherwise the body is chunked (HTTP/1.1) or
 close-delimited (HTTP/1.0); on HEAD/204/304 body chunks are discarded, as hyper never polls

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

@@ -145,10 +145,17 @@ class TonioBackend:
         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.
 
-        Bytes first, hyper's order (`poll_read_head` polls the timer only after `parse`
-        returned Pending): a wake that finds bytes returns them, whatever the timer did.
-
-        - **Plain socket**: the socket's own arm (`_io_arm_r(timeout)`) puts the readiness
+        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
@@ -174,18 +181,21 @@ class TonioBackend:
 
         async def read(max_bytes, deadline):
             while True:
-                micros = round((deadline - _now()) * 1_000_000)
-                waiter = arm(0 if micros < 0 else micros)
-                if waiter is not None:
-                    await waiter
-                    if arm() is not None:  # no readiness bits: the timer woke us
-                        return None
                 try:
-                    return recv(max_bytes)  # bytes first, whatever the timer did
+                    return recv(max_bytes)  # bytes first: hyper's `poll_read` before its timer poll
                 except InterruptedError:
                     continue
                 except BlockingIOError:
-                    clear()  # a spurious readiness wake: re-arm for the remaining time
+                    clear()  # EAGAIN: the bits were stale (or a spurious wake) — now the timer
+                micros = round((deadline - _now()) * 1_000_000)
+                if micros <= 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
 
         return read
 

{httpunk-0.4.0 → httpunk-0.4.2}/httpunk/_httpunk.pyi

@@ -867,6 +867,7 @@ H2_FLAG_WAKE: int  # bytes were queued: wake the write pump
 H2_FLAG_SLOT_FREED: int  # client: a MAX_CONCURRENT slot freed / the limit changed
 H2_FLAG_CONN_DONE: int  # the connection failed or finished: wake the role waiters
 H2_FLAG_STOP_ACCEPTING: int  # server: the graceful drain completed
+H2_FLAG_CAPACITY: int  # the connection-capacity queue moved: ask `next_capacity_wake`
 
 # `H2RecvHeadersVerdict.kind`.
 H2_HEADERS_IGNORED: int
@@ -1060,6 +1061,9 @@ class H2Streams:
     def stream_send_window(self, sid: int) -> int | None: ...
     @property
     def conn_send_window(self) -> int: ...
+    def next_capacity_wake(self) -> object | None:
+        """After `H2_FLAG_CAPACITY`: the stream handle now first in line for connection
+        window (wake its `window_evt`), or None."""
     @property
     def conn_recv_available(self) -> int: ...
     @property

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

@@ -238,9 +238,9 @@ class ServerRequest:
         self._conn.close_window(self._seq)
         self._peer_closed_evt.set()
 
-    async def respond(
+    def respond(
         self, status: int, *, headers: HeadersInput = None, body: Body = None, trailers: HeadersInput = None
-    ) -> None:
+    ) -> Awaitable[None]:
         """Send the whole response: head + body (+ trailers). `body` is None, `bytes`,
         or a (sync/async) iterable of `bytes`. hyper: `Server::encode` + the dispatcher
         polling the response `Body`. The pull convenience over `send_response`: same
@@ -258,9 +258,11 @@ class ServerRequest:
         cancelled at that await (hyper drops the body future) and has unwound — its
         cleanup ran — before this raises. Cancelling the task awaiting `respond()`
         cancels the producer the same way."""
-        await self._conn._send_response(self, status, headers, body, trailers)
+        return self._conn._send_response(self, status, headers, body, trailers)
 
-    async def send_response(self, status: int, *, headers: HeadersInput = None, end_stream: bool = False) -> SendStream:
+    def send_response(
+        self, status: int, *, headers: HeadersInput = None, end_stream: bool = False, detect_eof: bool = True
+    ) -> Awaitable[SendStream]:
         """Push-style response: send the head now and return a `SendStream` to write
         the body with (`send_data` / `send_trailers` / `send_reset`). `end_stream=True`
         = a bodyless response (hyper: a `Body` that `is_end_stream()` at encode time —
@@ -269,8 +271,18 @@ class ServerRequest:
         `content-length`, which the encoder honours (hyper `set_length`'s
         `existing_con_len`). hyper's h1 has no push API; this is the h1 twin of h2's
         `SendResponse::send_response -> SendStream`, over the same codec calls
-        `respond()` makes, so the wire behaviour is hyper's either way."""
-        return await self._conn._send_response_head(self, status, headers, end_stream=end_stream)
+        `respond()` makes, so the wire behaviour is hyper's either way.
+
+        `detect_eof` (httpunk's own — hyper has no per-response knob, its mid-message read
+        is always on; the connection-level twin is `half_close`): a push body may park
+        between chunks, so by default this head arms the mid-message watcher (hyper
+        `mid_message_detect_eof`) so a client FIN mid-response is seen as it lands. `False`
+        skips that ask: nothing is parked for this response, saving the watcher task and
+        its hand-off at the next head read. A client that closes then is noticed one write
+        later — at the kernel's RST, not at the FIN — unless something asks: `peer_closed()`
+        still arms on demand, exactly as it does before the head. Meant for a caller whose
+        disconnect detection IS that explicit ask (an ASGI `receive()`)."""
+        return self._conn._send_response_head(self, status, headers, end_stream=end_stream, detect_eof=detect_eof)
 
     def detach(self) -> bytes:
         """Take over the raw connection for a protocol upgrade (WebSocket, or a custom protocol):
@@ -323,7 +335,11 @@ class SendStream:
         Fails with `ConnectionClosedError` once the client closed its side mid-request
         (hyper: the connection errored with `IncompleteMessage`, nothing more is written)."""
         self._check_open()
-        await self._conn._check_peer_open(self._req)
+        conn, req = self._conn, self._req
+        if conn.peer_closed_flag(req._seq):
+            # hyper: once `mid_message_detect_eof` saw EOF the connection is errored and
+            # nothing more is written for this exchange. Poison + close, `IncompleteMessage`.
+            await conn._fail_response(req, H1IncompleteMessageError(_PEER_CLOSED_MSG))
         codec = self._codec
         try:
             if codec.body_is_eof():
@@ -336,28 +352,35 @@ class SendStream:
             # `serialize_end` on a body short of its Content-Length: hyper `end_body` ->
             # `User::BodyWriteAborted` + `Writing::Closed`. Same poison as a failed write.
             self._done = True
-            await self._conn._fail_response(self._req, exc)
+            await conn._fail_response(req, exc)
         if end_stream:
             self._done = True
         if buf:
-            await self._write(buf)
-        if end_stream:
-            await self._conn._finish_response(self._req)
+            try:
+                await conn.write(buf)
+            except BaseException as exc:
+                self._done = True
+                await conn._fail_response(req, exc)
+        if end_stream and (end := conn._finish_response(req)) is not None:
+            await end
 
     async def send_trailers(self, trailers: HeadersInput) -> None:
         """Finish a chunked body with a trailer block (hyper `Server::encode` allow-lists
         the fields named in the response's `Trailer` header; others are dropped, and a
         non-chunked body gets a bare terminator — `Encoder::encode_trailers`)."""
         self._check_open()
-        await self._conn._check_peer_open(self._req)
+        conn, req = self._conn, self._req
+        if conn.peer_closed_flag(req._seq):  # as `send_data`
+            await conn._fail_response(req, H1IncompleteMessageError(_PEER_CLOSED_MSG))
         hdrs = trailers if isinstance(trailers, HeaderMap) else HeaderMap(trailers)
         self._done = True
         try:
             buf = self._codec.serialize_trailers(hdrs)  # bare terminator unless the request said `TE: trailers`
+            await conn.write(buf)
         except BaseException as exc:
-            await self._conn._fail_response(self._req, exc)
-        await self._write(buf)
-        await self._conn._finish_response(self._req)
+            await conn._fail_response(req, exc)
+        if (end := conn._finish_response(req)) is not None:
+            await end
 
     async def send_reset(self, reason: int | None = None) -> None:
         """Abort the response. HTTP/1 has no per-stream reset frame, so this is what
@@ -373,13 +396,6 @@ class SendStream:
         if self._done:
             raise RuntimeError("response body already complete")
 
-    async def _write(self, data):
-        try:
-            await self._conn.write(data)
-        except BaseException as exc:
-            self._done = True
-            await self._conn._fail_response(self._req, exc)
-
 
 class ServerConnection(H1Framing, H1ServerState):
     """The server-side h1 driver: reads a request, hands back a `ServerRequest`,
@@ -602,12 +618,6 @@ class ServerConnection(H1Framing, H1ServerState):
             return transport.receive_some(n)
         return self._read_bounded(n, deadline)
 
-    async def _check_peer_open(self, req):
-        # hyper: once `mid_message_detect_eof` saw EOF the connection is errored and nothing
-        # more is written for this exchange. Poison + close, surface `IncompleteMessage`.
-        if self.peer_closed_flag(req._seq):
-            await self._fail_response(req, H1IncompleteMessageError(_PEER_CLOSED_MSG))
-
     async def _send_async_body(self, req, body, trailers):
         """Stream an ASYNC response body and fail fast on a client FIN. hyper polls the
         connection (so `mid_message_detect_eof`) while the body's next chunk is pending,
@@ -699,8 +709,16 @@ class ServerConnection(H1Framing, H1ServerState):
         if code == H1_NEXT_NONE:
             return None
         codec = self._codec
+        # hyper's `header_read_timeout` (slowloris defence, http1.rs L249; default 30s, `None`
+        # disables it): ONE deadline per head, armed at the first poll for it — i.e. from the
+        # moment the connection is idle between requests, so it covers the keep-alive wait
+        # plus the head's bytes — never reset by partial bytes (conn.rs `poll_read_head`:
+        # `h1_header_read_timeout_running` stays set until a head parses). The bound rides
+        # each read (`_read_bounded`), so no task is spawned per head and no parked read is
+        # ever cancelled.
+        deadline = None if self._header_read_timeout is None else self._now() + self._header_read_timeout
         try:
-            accepted = await self._read_request_head(code, obj)
+            accepted = await self._read_head_frames(code, obj, deadline)
         except H1ParseError:
             # hyper conn.rs `on_parse_error`: an HTTP/2 preface is `Parse::VersionH2` and
             # the connection errors (dropped: the abortive end); any other malformed head
@@ -722,6 +740,11 @@ class ServerConnection(H1Framing, H1ServerState):
             # the clean EOF below, so it surfaces as a clean end-of-iteration (F47).
             self._close(self.fail_read())
             return None
+        if accepted is _DEADLINE:
+            # Expiry is `Error::new_header_timeout` out of the dispatcher: closed, no
+            # response, the abortive end.
+            self._close(self.fail_read())
+            return None
         if accepted is None:  # clean EOF between requests (or a shutdown released the idle read)
             self.stop_serving()
             return None
@@ -756,22 +779,6 @@ class ServerConnection(H1Framing, H1ServerState):
             pass
         return dec.is_complete
 
-    async def _read_request_head(self, code, obj):
-        # hyper's `header_read_timeout` (slowloris defence, http1.rs L249; default 30s, `None`
-        # disables it): ONE deadline per head, armed at the first poll for it — i.e. from the
-        # moment the connection is idle between requests, so it covers the keep-alive wait
-        # plus the head's bytes — never reset by partial bytes (conn.rs `poll_read_head`:
-        # `h1_header_read_timeout_running` stays set until a head parses). Expiry is
-        # `Error::new_header_timeout` out of the dispatcher: closed, no response, the
-        # abortive end. The bound rides each read (`_read_bounded`), so no task is spawned
-        # per head and no parked read is ever cancelled.
-        deadline = None if self._header_read_timeout is None else self._now() + self._header_read_timeout
-        accepted = await self._read_head_frames(code, obj, deadline)
-        if accepted is _DEADLINE:
-            self._close(self.fail_read())
-            return None
-        return accepted
-
     async def _read_head_frames(self, code, obj, deadline):
         """Read + parse the next head from `begin_read`'s verdict: `READ_PARSE` = bytes of
         it are already buffered (pipelined), parse before touching the transport;
@@ -888,17 +895,20 @@ class ServerConnection(H1Framing, H1ServerState):
                 await self._send_head_and_body(self._codec, head, body, trailers)
             except BaseException as exc:
                 await self._fail_response(req, exc)
-        await self._finish_response(req)
+        if (end := self._finish_response(req)) is not None:
+            await end
 
-    async def _send_response_head(self, req, status, headers, *, end_stream):
+    async def _send_response_head(self, req, status, headers, *, end_stream, detect_eof):
         """The push path (`ServerRequest.send_response`): write the head now, return
         the `SendStream`. `end_stream` maps onto hyper's two encode inputs the same way a
         pull body does: True = no body (`_body_framing(None)`), False = a body of unknown
         length (streamed -> chunked, or length if the headers carry `content-length`).
         The peer-closed check is the claim's (`_claim_response`), which precedes this."""
         content_length, chunked = self._body_framing(None) if end_stream else (None, True)
-        # A push producer may park between chunks: make the FIN observable (`want`).
-        head = await self._respond_head(req, status, headers, content_length, chunked, want=not end_stream)
+        # A push producer may park between chunks: make the FIN observable (`want`) —
+        # unless the caller declined (`detect_eof=False`) or there is no body to park in.
+        want = detect_eof and not end_stream
+        head = await self._respond_head(req, status, headers, content_length, chunked, want=want)
         stream = SendStream(self, req, self._codec)
         if end_stream:
             stream._done = True
@@ -908,8 +918,8 @@ class ServerConnection(H1Framing, H1ServerState):
             await self.write(head)
         except BaseException as exc:
             await self._fail_response(req, exc)
-        if end_stream:
-            await self._finish_response(req)
+        if end_stream and (end := self._finish_response(req)) is not None:
+            await end
         return stream
 
     async def _respond_head(self, req, status, headers, content_length, chunked, *, want):
@@ -990,12 +1000,15 @@ class ServerConnection(H1Framing, H1ServerState):
         self._close(self.fail_response(req._seq))
         req._peer_closed_evt.set()
 
-    async def _finish_response(self, req):
+    def _finish_response(self, req):
         """Completion, shared by both paths: the response is fully on the wire — apply
         the head-time reuse decision (hyper `try_keep_alive` after `Writing::KeepAlive`),
         or hand off the tunnel for a protocol switch. One step in the state; the
         `peer_closed()` waiters wake after it. A non-reusable connection completes:
-        `try_keep_alive` closes it and the future `poll_shutdown`s — the orderly end."""
+        `try_keep_alive` closes it and the future `poll_shutdown`s — the orderly end.
+        Sync: the reusable case (the hot path) suspends nowhere; the close is handed back
+        as the awaitable to finish with (None otherwise), so no wrapper coroutine rides
+        every response."""
         switch, close, transport, leftover = self.finish_response(req._seq)
         req._peer_closed_evt.set()
         if switch:
@@ -1003,7 +1016,8 @@ class ServerConnection(H1Framing, H1ServerState):
             # the start of the tunnel) is the caller's; the state detached.
             req.upgraded = H1Upgraded(transport, leftover)
         elif close:
-            await self._shutdown(transport)
+            return self._shutdown(transport)
+        return None
 
 
 class H1Server(BaseServer[ServerRequest]):

{httpunk-0.4.0 → httpunk-0.4.2}/httpunk/h2/client.py

@@ -169,16 +169,41 @@ class Connection(H2ConnectionBase):
         """Send the request body concurrently with (not before) the caller awaiting
         the response head: h2's `SendStream` (body) and `ResponseFuture` (head) are
         independent — an early response that resets the request body (413 / redirect
-        during upload) must still deliver the received response. The write runs in the
-        connection's write scope so it can outlive `send_request` (full duplex) and is
-        torn down when the connection closes."""
-        self._write_scope.spawn(self._write_body(stream, body, trailers))
+        during upload) must still deliver the received response. hyper client.rs
+        `poll_pipe`: the pipe is polled once inline, and only if that leaves it pending
+        is it handed to the executor as a bare task that outlives `send_request` (full
+        duplex) and ends on its own — the body sent, or the stream stopped; `close()`
+        waits for the last one (`release_writers`), it never cancels them."""
+        offset = 0
+        if body is None or isinstance(body, bytes):
+            offset = self._send_body_inline(stream, body, trailers)
+            if offset is None:
+                return
+        if self.writer_start():  # refused: the stream is stopped already, nothing to write
+            self.backend.spawn_without_results(self._write_body(stream, body, trailers, offset))
+
+    def _send_body_inline(self, stream, body, trailers):
+        """The inline first poll of a buffered body (hyper's `Full`: one chunk, EOS
+        set): queue what the windows take NOW. Returns the offset a background writer
+        resumes from, or None when nothing is left to write — the body (and trailers)
+        fully queued, or the stream already stopped, which the response reader sees."""
+        try:
+            offset = self._try_send_data(stream, body, 0, trailers is None) if body else None
+            if offset is None and trailers is not None:
+                self._send_trailers(stream, trailers)
+        except Exception:
+            return None
+        return offset
 
-    async def _write_body(self, stream, body, trailers=None):
+    async def _write_body(self, stream, body, trailers, offset):
         # The stream may error/reset mid-send: that is surfaced when the response body
         # is read; a background writer has nowhere to propagate to.
-        with contextlib.suppress(Exception):
-            await self._send_body(stream, body, trailers)
+        try:
+            with contextlib.suppress(Exception):
+                await self._send_body(stream, body, trailers, offset)
+        finally:
+            if self.writer_end():
+                self._writers_evt.set()
 
 
 class H2Connection(BaseClientConnection):

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

@@ -27,6 +27,7 @@ import contextlib
 from .. import _backend
 from .._common import PUMP_ABANDONED, PUMP_DONE, aclose_body, aiter_body, event_result
 from .._httpunk import (
+    H2_FLAG_CAPACITY,
     H2_FLAG_CONN_DONE,
     H2_FLAG_SLOT_FREED,
     H2_FLAG_STOP_ACCEPTING,
@@ -70,9 +71,12 @@ class H2ConnectionBase(H2Streams):
         # pumps read it, `close()` closes it — never reassigned.
         self.backend = _backend.resolve(backend)
         self._transport = transport
-        # A scope for background request-body writers (client full-duplex send, F6) —
-        # the one group that legitimately gets CANCELLED at teardown.
-        self._write_scope = self.backend.scope()
+        # Set by the last background request-body writer to finish once `close()` is
+        # draining (client full-duplex send, F6): hyper's connection task ends only
+        # after every `PipeToSendStream` dropped its `conn_drop_ref`. Writers are bare
+        # tasks, never cancelled: a stopped stream (peer reset, GOAWAY, the connection
+        # failed or closed) is what ends one.
+        self._writers_evt = self.backend.event()
         # Orders socket writes: the write pump and the inline flushes (`_flush`).
         self._send_lock = self.backend.lock()
         # Wakes the write pump. Set by the driver after any verdict that appended to
@@ -109,6 +113,12 @@ class H2ConnectionBase(H2Streams):
             self._on_conn_done()
         if flags & H2_FLAG_STOP_ACCEPTING:
             self._on_stop_accepting()
+        if flags & H2_FLAG_CAPACITY:
+            # The front of the connection-capacity queue moved on: hand the turn
+            # to the next sender in line (h2 `assign_connection_capacity`).
+            handle = self.next_capacity_wake()
+            if handle is not None:
+                handle.window_evt.set()
 
     @staticmethod
     def _notify_stopped(handle, stop, notify_body):
@@ -187,7 +197,6 @@ class H2ConnectionBase(H2Streams):
         # Shared handshake start (h2 client.rs/server.rs `handshake`): the preface
         # (client) + our initial SETTINGS + the initial WINDOW_UPDATE(0) are queued by
         # the state and flushed here, BEFORE the pumps start, so nothing can precede them.
-        await self._write_scope.__aenter__()
         self.begin()
         await self._flush()
         # Bare tasks (`spawn_without_results`), never cancelled: every point they can
@@ -213,20 +222,21 @@ class H2ConnectionBase(H2Streams):
     async def close(self):
         # Stop the write pump by SIGNAL, flush-then-exit, and JOIN — never cancel it
         # (a cancellation landing between its take and its flush would lose control
-        # frames). Then cancel + join the body writers, drain what their teardown
-        # enqueued (h2 `codec.shutdown` = flush THEN shutdown, F23), shut the
-        # transport down — `FramedWrite::shutdown` ends in the IO's `poll_shutdown`
-        # (`close_notify` over TLS), which is also what ends the read pump's parked
-        # read — join it, and wake every straggler. On a transport that already died
-        # the alert cannot go out and the shutdown is the plain close hyper's drop
-        # would be: wire-identical.
+        # frames). Drain what is enqueued (h2 `codec.shutdown` = flush THEN shutdown,
+        # F23), shut the transport down — `FramedWrite::shutdown` ends in the IO's
+        # `poll_shutdown` (`close_notify` over TLS), which is also what ends the read
+        # pump's parked read — join it, and wake every straggler. On a transport that
+        # already died the alert cannot go out and the shutdown is the plain close
+        # hyper's drop would be: wire-identical. Last, wait for the background
+        # request-body writers: every stream is stopped by now, so each one wakes and
+        # exits — hyper's connection task likewise ends only after the last
+        # `PipeToSendStream` dropped its `conn_drop_ref`; the writers are never
+        # cancelled, here or there.
         self.stop_pump()
         self._write_evt.set()
         handle = self.take_pump_handle()
         if handle is not None:
             await handle
-        self._write_scope.cancel()
-        await self._write_scope.__aexit__(None, None, None)
         with contextlib.suppress(Exception):  # best-effort: the connection is closing regardless
             await self._flush()
         await self.backend.shutdown_transport(self._transport)
@@ -234,6 +244,8 @@ class H2ConnectionBase(H2Streams):
         if handle is not None:
             await handle
         self._fail(None)  # no-op when the pump already failed everyone (F44)
+        if not self.release_writers():
+            await self._writers_evt.wait()
 
     # ----- the write pump (h2 `poll_complete` draining its frame queue) -----
 
@@ -382,18 +394,19 @@ class H2ConnectionBase(H2Streams):
 
     # ----- sending (h2 share.rs SendStream over send.rs, hyper PipeToSendStream) -----
 
-    async def _send_body(self, st, body, trailers=None):
+    async def _send_body(self, st, body, trailers=None, offset=0):
         """Stream a body, marking END_STREAM on the final DATA frame (or on the
         trailing HEADERS), then close the send half. A bodyless message never reaches
-        here — its END_STREAM rode the HEADERS frame."""
+        here — its END_STREAM rode the HEADERS frame. `offset`: where a bytes body
+        resumes after the client's inline attempt queued its head (`_send_body_inline`)."""
         if isinstance(body, bytes):
             # hyper's `Full` body: one poll yields the whole chunk with `is_end_stream()`
             # set — one DATA carrying END_STREAM (or the trailers carry it, F45).
             if trailers is None:
-                await self._send_data(st, body, end_stream=True)
+                await self._send_data(st, body, end_stream=True, offset=offset)
                 return
             if body:
-                await self._send_data(st, body, end_stream=False)
+                await self._send_data(st, body, end_stream=False, offset=offset)
             self._send_trailers(st, trailers)
             return
         if body is not None and not isinstance(body, bytearray) and hasattr(body, "__aiter__"):
@@ -459,16 +472,16 @@ class H2ConnectionBase(H2Streams):
             await aclose_body(body)
             done.set()
 
-    async def _send_data(self, st, data, end_stream):
-        """Queue `data` as DATA frame(s), each reserved against min(connection window,
-        stream window, send-buffer room, peer max_frame_size) — h2 send.rs `send_data`
-        behind `poll_capacity`. `send_data` is one locked step (reserve + encode +
-        append — and, with END_STREAM on the last frame, the send half's close, as h2's;
-        on the server the request's recv half goes with it, hyper dropping the
-        `RecvStream`: `handle` is the reader to notify when its unread body was reset);
-        "no window now" is awaited on `window_evt` with the fixed waiter idiom: try,
-        clear, try again, wait (design §4)."""
-        offset = 0
+    def _try_send_data(self, st, data, offset, end_stream):
+        """Queue DATA frames from `data[offset:]` while the windows take them, each
+        reserved against min(connection window, stream window, send-buffer room, peer
+        max_frame_size) — h2 send.rs `send_data` behind `poll_capacity`. `send_data` is
+        one locked step (reserve + encode + append — and, with END_STREAM on the last
+        frame, the send half's close, as h2's; on the server the request's recv half
+        goes with it, hyper dropping the `RecvStream`: `handle` is the reader to notify
+        when its unread body was reset). Returns None once the last frame is queued, or
+        the offset to resume from on "no window now" (`sent == 0`, not `done`). Raises
+        the stopped error."""
         while True:
             v = self.send_data(st.id, data, offset, end_stream)
             if v.stopped is not None:
@@ -478,23 +491,25 @@ class H2ConnectionBase(H2Streams):
             if v.done:
                 if v.handle is not None:
                     self._notify_reset(v.handle, v.reader_stop)
-                return
+                return None
+            if not v.sent:
+                return offset
             offset += v.sent
-            if v.sent:
-                continue
+
+    async def _send_data(self, st, data, end_stream, offset=0):
+        """`_try_send_data` until the body is queued, awaiting "no window now" on
+        `window_evt` with the fixed waiter idiom: try, clear, try again, wait
+        (design §4)."""
+        while True:
+            offset = self._try_send_data(st, data, offset, end_stream)
+            if offset is None:
+                return
             st.window_evt.clear()
-            v = self.send_data(st.id, data, offset, end_stream)  # re-check after the clear
-            if v.stopped is not None:
-                raise self._stopped_error(st, v.stopped)
-            if v.flags:
-                self._after(v.flags)
-            if v.done:
-                if v.handle is not None:
-                    self._notify_reset(v.handle, v.reader_stop)
+            resumed = self._try_send_data(st, data, offset, end_stream)  # re-check after the clear
+            if resumed is None:
                 return
-            offset += v.sent
-            if not v.sent:
-                await st.window_evt.wait()
+            offset = resumed
+            await st.window_evt.wait()
 
     def _send_trailers(self, st, trailers):
         """The trailing HEADERS (END_STREAM) closes the send half in the same step

{httpunk-0.4.0 → httpunk-0.4.2}/httpunk/h2/server.py

@@ -110,11 +110,17 @@ class ServerRequest:
         cleanup ran — before this raises."""
         return self._conn._send_response(self._stream, status, headers, body, trailers)
 
-    async def send_response(self, status: int, *, headers: HeadersInput = None, end_stream: bool = False) -> SendStream:
+    async def send_response(
+        self, status: int, *, headers: HeadersInput = None, end_stream: bool = False, detect_eof: bool = True
+    ) -> SendStream:
         """Push-style response: send HEADERS now and return a `SendStream` to write the
         body with (`send_data` / `send_trailers` / `send_reset`). `end_stream=True` ends
         the stream on the HEADERS frame (a bodyless response). h2:
-        `SendResponse::send_response(response, end_of_stream) -> SendStream`."""
+        `SendResponse::send_response(response, end_of_stream) -> SendStream`.
+
+        `detect_eof` is accepted for API symmetry with the HTTP/1 twin and has no effect
+        here: a client abandoning the request is a RST_STREAM the connection's pump
+        delivers regardless (`reset_received`), there is no per-response read to arm."""
         await self._conn._send_response_head(self._stream, status, headers, end_stream=end_stream)
         stream = SendStream(self._conn, self._stream)
         if end_stream:

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

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