httpunk 0.4.1__tar.gz → 0.4.2__tar.gz

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

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

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: httpunk
-Version: 0.4.1
+Version: 0.4.2
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License

{httpunk-0.4.1 → 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.1 → 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.1 → 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