httpunk 0.4.0__tar.gz → 0.4.1__tar.gz

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

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

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: httpunk
-Version: 0.4.0
+Version: 0.4.1
 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.1}/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.1}/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.1}/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.1}/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.1}/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 = [

{httpunk-0.4.0 → httpunk-0.4.1}/tests/test_backend.py

@@ -215,34 +215,56 @@ async def _bounded(sock, timeout=1.0):
 
 
 @pytest.mark.tonio
-async def test_receive_bounded_readable_at_once_never_parks():
-    sock = _FakeArmSocket(arms=[False], recvs=[b"head"])
+async def test_receive_bounded_readable_at_once_never_arms():
+    # The syscall comes first (hyper `poll_read` before its timer poll): bytes there = done.
+    sock = _FakeArmSocket(arms=[], recvs=[b"head"])
     assert await _bounded(sock) == b"head"
-    assert len(sock.calls) == 1  # bits were set: no wait
+    assert sock.calls == [] and sock.cleared == 0  # no arm, no clock, no clear
 
 
 @pytest.mark.tonio
 async def test_receive_bounded_timer_wake_is_told_by_the_readiness_word():
-    # park -> wake -> the readiness question hands out a waiter: no bits, so the timer fired.
-    sock = _FakeArmSocket(arms=[True, True], recvs=[])
+    # EAGAIN (the probe: stale bits, as tokio's readiness) -> clear -> arm with the remaining
+    # time -> park -> wake -> the readiness question hands out a waiter: no bits, the timer fired.
+    sock = _FakeArmSocket(arms=[True, True], recvs=[BlockingIOError])
     assert await _bounded(sock, 0.5) is None
     assert 499_000 < sock.calls[0] <= 500_000  # the arm carried the timer (micros; the clock ran a little)
     assert sock.calls[1] is None  # the question carries none
-    assert sock.cleared == 0  # no syscall on the timer path
+    assert sock.cleared == 1  # the one probe; no syscall after the timer wake
 
 
 @pytest.mark.tonio
 async def test_receive_bounded_readiness_wake_reads_bytes_first():
-    sock = _FakeArmSocket(arms=[True, False], recvs=[b"head"])
+    # EAGAIN -> clear -> arm -> park -> wake -> readable? yes -> the bytes.
+    sock = _FakeArmSocket(arms=[True, False], recvs=[BlockingIOError, b"head"])
     assert await _bounded(sock) == b"head"
+    assert sock.cleared == 1
+
+
+@pytest.mark.tonio
+async def test_receive_bounded_bits_landing_before_the_arm_read_at_once():
+    # EAGAIN -> clear -> arm finds the bits already set (data landed in between) -> read now.
+    sock = _FakeArmSocket(arms=[False], recvs=[BlockingIOError, b"head"])
+    assert await _bounded(sock) == b"head"
+    assert len(sock.calls) == 1 and sock.cleared == 1
 
 
 @pytest.mark.tonio
 async def test_receive_bounded_spurious_wake_rearms_with_the_remaining_time():
-    # park -> wake -> readable? yes -> EAGAIN (a spurious wake) -> clear -> re-arm, then bytes.
-    sock = _FakeArmSocket(arms=[True, False, True, False], recvs=[BlockingIOError, b"head"])
+    # ... -> park -> wake -> readable? yes -> EAGAIN (a spurious wake) -> clear -> re-arm, then bytes.
+    sock = _FakeArmSocket(arms=[True, False, True, False], recvs=[BlockingIOError, BlockingIOError, b"head"])
     assert await _bounded(sock, 0.5) == b"head"
-    assert sock.cleared == 1
+    assert sock.cleared == 2
     first, again = sock.calls[0], sock.calls[2]
     assert 499_000 < first <= 500_000
     assert 0 < again <= first  # the deadline is absolute: never reset to the full timeout
+
+
+@pytest.mark.tonio
+async def test_receive_bounded_past_deadline_expires_without_arming():
+    # Nothing readable and the deadline already passed (a spurious wake landing after it, a
+    # partial head whose next read starts late): hyper's Pending + a ready timer poll ->
+    # `None` at once. No zero-length timer is ever armed.
+    sock = _FakeArmSocket(arms=[], recvs=[BlockingIOError])
+    assert await _bounded(sock, -0.001) is None
+    assert sock.calls == [] and sock.cleared == 1

{httpunk-0.4.0 → httpunk-0.4.1}/tests/test_h1_server.py

@@ -1990,6 +1990,31 @@ async def test_server_header_read_timeout_bounds_the_watcher_hand_off():
     await conn.close()  # joins the watcher (its read ended by the close)
 
 
+@pytest.mark.tonio
+async def test_server_push_response_detect_eof_off_parks_nothing_until_asked():
+    """`send_response(detect_eof=False)` (httpunk's own knob): the head arms no
+    mid-message watcher — no read parked, no task — and the body still goes out; a
+    later `peer_closed()` arms on demand, exactly as it does before the head. The
+    default keeps today's arm (`test_server_header_read_timeout_bounds_the_watcher_hand_off`)."""
+    stub = _SilentStub(b"GET / HTTP/1.1\r\nhost: x\r\n\r\n")
+    conn = ServerConnection(stub)
+    await conn.start()
+    req = await conn.next_request()
+    stream = await req.send_response(200, headers={"content-length": "4"}, detect_eof=False)
+    assert not conn.has_watcher and not stub.parked.is_set()  # nothing parked by the head
+    await stream.send_data(b"ti")
+    assert not conn.has_watcher and not stub.parked.is_set()  # nor mid-body
+    seen = []
+    async with scope() as s:
+        s.spawn(_watch(req, seen))  # the explicit ask: arms now
+        await stub.parked.wait()
+        assert conn.has_watcher
+        await stream.send_data(b"ck", end_stream=True)  # the exchange completes: `False`
+    assert seen == [False]
+    assert stub.sent.endswith(b"tick")
+    await conn.close()  # joins the watcher (its read ended by the close)
+
+
 @pytest.mark.asyncio
 async def test_immediate_body_coalesces_with_the_head_up_to_the_codecs_buffer_cap():
     """hyper `WriteBuf` Flatten up to `max_buf_size`: an immediate body no larger than the

{httpunk-0.4.0 → httpunk-0.4.1}/tests/test_h2_server.py

@@ -489,14 +489,15 @@ async def test_server_response_date_header_option():
 @pytest.mark.tonio
 async def test_server_push_response_streams_data_frames():
     """`send_response` + `send_data(..., end_stream=True)`: HEADERS (with Date) then DATA
-    frames, END_STREAM on the last; the connection keeps multiplexing afterwards."""
+    frames, END_STREAM on the last; the connection keeps multiplexing afterwards.
+    `detect_eof` (the h1 twin's knob) is accepted and has no effect here."""
     listener, host, port = await _listener()
 
     async def serve():
         transport = await listener.accept()
         async with H2Server(transport) as server:
             async for req in server:
-                stream = await req.send_response(200, headers={"x-path": req.path})
+                stream = await req.send_response(200, headers={"x-path": req.path}, detect_eof=req.path == "/2")
                 await stream.send_data(b"a" * 10)
                 await stream.send_data(b"b" * 5, end_stream=True)