boring-http 2.0.3__tar.gz → 2.1.0__tar.gz

boring_http-2.0.3/README.md → boring_http-2.1.0/PKG-INFO

@@ -1,3 +1,13 @@
+Metadata-Version: 2.3
+Name: boring-http
+Version: 2.1.0
+Summary: Asyncio HTTP client on BoringSSL: HTTP/1.1, HTTP/2 and HTTP/3 over QUIC v1 and v2, WebSocket on all three, HTTP and SOCKS proxies, headers in your order
+Requires-Dist: boring-ssl2>=1.2.0
+Requires-Dist: ssl2>=2.0.1
+Requires-Python: >=3.14
+Project-URL: Repository, https://github.com/baobien-dev/boring-http
+Description-Content-Type: text/markdown
+
 # boring-http
 
 An asyncio HTTP client on BoringSSL through `ssl2` and `boring-ssl2`. HTTP/1.1, HTTP/2 and HTTP/3 over QUIC v1 and v2, WebSocket on all three, HTTP and SOCKS proxies, headers sent in the order you give them, cookies, redirects, phased timeouts, gzip, deflate, brotli and zstd decoding. Runs on asyncio and on uvloop. Requires Python 3.14.
@@ -90,6 +100,8 @@ asyncio.run(main())
 
 A single number sets every phase and the total, so the request gives up after that many seconds whatever it was doing. With a `Timeout` the phases are separate: `connect` covers opening a connection, the proxy, TCP and the TLS or QUIC handshake included, `read` is the longest wait for the next bytes, `total` caps the whole exchange including redirects, and the error names whichever ran out.
 
+A body is held to what the application reads: over HTTP/2 and HTTP/3 the stream window opens again only as chunks are taken, so a response nobody reads stops at one window (`INITIAL_WINDOW_SIZE` or `initial_max_stream_data_bidi_local`), while the connection window keeps opening on arrival so other streams go on. An HTTP/3 upload keeps at most 1 MiB of the body unsent before it asks the body for the next chunk; HTTP/1.1 and HTTP/2 uploads wait on the socket and the peer's window.
+
 ## HTTP/3
 
 ```python

boring_http-2.0.3/PKG-INFO → boring_http-2.1.0/README.md

@@ -1,13 +1,3 @@
-Metadata-Version: 2.3
-Name: boring-http
-Version: 2.0.3
-Summary: Asyncio HTTP client on BoringSSL: HTTP/1.1, HTTP/2 and HTTP/3 over QUIC v1 and v2, WebSocket on all three, HTTP and SOCKS proxies, headers in your order
-Requires-Dist: boring-ssl2>=1.2.0
-Requires-Dist: ssl2>=2.0.1
-Requires-Python: >=3.14
-Project-URL: Repository, https://github.com/baobien-dev/boring-http
-Description-Content-Type: text/markdown
-
 # boring-http
 
 An asyncio HTTP client on BoringSSL through `ssl2` and `boring-ssl2`. HTTP/1.1, HTTP/2 and HTTP/3 over QUIC v1 and v2, WebSocket on all three, HTTP and SOCKS proxies, headers sent in the order you give them, cookies, redirects, phased timeouts, gzip, deflate, brotli and zstd decoding. Runs on asyncio and on uvloop. Requires Python 3.14.
@@ -100,6 +90,8 @@ asyncio.run(main())
 
 A single number sets every phase and the total, so the request gives up after that many seconds whatever it was doing. With a `Timeout` the phases are separate: `connect` covers opening a connection, the proxy, TCP and the TLS or QUIC handshake included, `read` is the longest wait for the next bytes, `total` caps the whole exchange including redirects, and the error names whichever ran out.
 
+A body is held to what the application reads: over HTTP/2 and HTTP/3 the stream window opens again only as chunks are taken, so a response nobody reads stops at one window (`INITIAL_WINDOW_SIZE` or `initial_max_stream_data_bidi_local`), while the connection window keeps opening on arrival so other streams go on. An HTTP/3 upload keeps at most 1 MiB of the body unsent before it asks the body for the next chunk; HTTP/1.1 and HTTP/2 uploads wait on the socket and the peer's window.
+
 ## HTTP/3
 
 ```python

{boring_http-2.0.3 → boring_http-2.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "boring-http"
-version = "2.0.3"
+version = "2.1.0"
 description = "Asyncio HTTP client on BoringSSL: HTTP/1.1, HTTP/2 and HTTP/3 over QUIC v1 and v2, WebSocket on all three, HTTP and SOCKS proxies, headers in your order"
 readme = "README.md"
 requires-python = ">=3.14"

{boring_http-2.0.3 → boring_http-2.1.0}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "boring-http"
-version = "2.0.3"
+version = "2.1.0"
 description = "Asyncio HTTP client on BoringSSL: HTTP/1.1, HTTP/2 and HTTP/3 over QUIC v1 and v2, WebSocket on all three, HTTP and SOCKS proxies, headers in your order"
 readme = "README.md"
 requires-python = ">=3.14"

{boring_http-2.0.3 → boring_http-2.1.0}/src/boring_http/http2.py

@@ -105,7 +105,8 @@ class Http2Stream:
         self.waiter: asyncio.Future[None] | None = None
         self.trailers = Headers()
         self.block = bytearray()
-        self.received = 0
+        # what the application took since the last WINDOW_UPDATE for this stream
+        self.consumed = 0
         self.finished = False
 
     def fail(self, error: BaseException) -> None:
@@ -382,7 +383,9 @@ class Http2Connection:
         try:
             while True:
                 if stream.chunks:
-                    yield stream.take()
+                    data = stream.take()
+                    await self.credit(stream, len(data))
+                    yield data
                 elif stream.error is not None:
                     raise stream.error
                 elif stream.finished:
@@ -409,6 +412,24 @@ class Http2Connection:
                 )
             )
 
+    async def credit(self, stream: Http2Stream, size: int) -> None:
+        # the stream window opens again as the application takes data, so a reader that stops holds the server at one window
+        stream.consumed += size
+        if (
+            stream.consumed > self._local_window // 2
+            and not stream.finished
+            and not self.closed
+        ):
+            increment, stream.consumed = stream.consumed, 0
+            await self._write(
+                self._frame(
+                    FrameType.WINDOW_UPDATE,
+                    0,
+                    stream.identifier,
+                    struct.pack("!I", increment),
+                )
+            )
+
     async def _write(self, data: bytes) -> None:
         async with self._write_lock:
             await self._transport.write(data)
@@ -512,15 +533,7 @@ class Http2Connection:
             if flags & END_STREAM:
                 stream.finished = True
             stream.wake()
-            stream.received += len(payload)
-            if stream.received > self._local_window // 2 and not stream.finished:
-                updates = self._frame(
-                    FrameType.WINDOW_UPDATE,
-                    0,
-                    identifier,
-                    struct.pack("!I", stream.received),
-                )
-                stream.received = 0
+        # the connection window opens on arrival, so one stream that is not read leaves the others their share
         self._connection_received += len(payload)
         if self._connection_received > self._connection_window // 2:
             updates += self._frame(
@@ -657,6 +670,7 @@ class Http2StreamTransport:
         while not self._pending:
             if stream.chunks:
                 self._pending = stream.take()
+                await self._connection.credit(stream, len(self._pending))
             elif stream.error is not None:
                 raise stream.error
             elif stream.finished:

{boring_http-2.0.3 → boring_http-2.1.0}/src/boring_http/http3.py

@@ -94,6 +94,8 @@ class Http3Settings:
 
 # RFC 8470 section 5.2: the requests a client may send before the handshake, since a server may see them twice
 SAFE_METHODS = frozenset({"GET", "HEAD", "OPTIONS"})
+# how much of a body may wait unsent in its QUIC stream before the next chunk is taken from the caller
+SEND_BUFFER = 1 << 20
 
 
 class StreamFrames:
@@ -266,6 +268,7 @@ class Http3Connection:
             async with deadline.phase("write"):
                 async for chunk in request.body.chunks():
                     self._quic.send(stream_id, self._frame(FrameType.DATA, chunk))
+                    await self._quic.drain(stream_id, SEND_BUFFER)
                 self._quic.send(stream_id, b"", end=True)
         frames = StreamFrames(self._quic, stream_id, deadline)
         status, headers = await self._response_head(frames, stream_id)
@@ -554,6 +557,8 @@ class Http3StreamTransport:
             + Writer.encode_varint(len(data))
             + data,
         )
+        async with self._deadline.phase("write"):
+            await self._quic.drain(self._stream_id, SEND_BUFFER)
 
     async def close(self) -> None:
         if not self._closed:

{boring_http-2.0.3 → boring_http-2.1.0}/src/boring_http/quic/connection.py

@@ -499,6 +499,29 @@ class QuicConnection:
         if end:
             stream.end()
 
+    def unsent(self, stream_id: int) -> int:
+        stream = self._send_streams.get(stream_id)
+        return 0 if stream is None else stream.unsent
+
+    def stream_read(self, stream_id: int, size: int) -> bool:
+        # the stream window opens again as the application takes data, so a reader that stops holds the server at one window
+        receive = self._receive_streams.get(stream_id)
+        if receive is None or receive.final_size is not None:
+            return False
+        receive.read += size
+        window = (
+            self._parameters.initial_max_stream_data_bidi_local
+            if stream_id % 4 < 2
+            else self._parameters.initial_max_stream_data_uni
+        )
+        if receive.max_data - receive.read >= window // 2:
+            return False
+        receive.max_data = receive.read + window
+        self._pending[EncryptionLevel.APPLICATION].append(
+            MaxStreamData(stream_id, receive.max_data)
+        )
+        return True
+
     def reset_stream(self, stream_id: int, error: int) -> None:
         stream = self._send_streams.get(stream_id)
         if stream is not None and not stream.reset_sent:
@@ -935,16 +958,6 @@ class QuicConnection:
             if data:
                 receive.chunks.append(data)
             self._readable[stream_id] = receive
-            window = (
-                self._parameters.initial_max_stream_data_bidi_local
-                if bidirectional
-                else self._parameters.initial_max_stream_data_uni
-            )
-            if receive.max_data - receive.consumed < window // 2 and not end:
-                receive.max_data = receive.consumed + window
-                self._pending[EncryptionLevel.APPLICATION].append(
-                    MaxStreamData(stream_id, receive.max_data)
-                )
             if end:
                 del self._receive_streams[stream_id]
         if (

{boring_http-2.0.3 → boring_http-2.1.0}/src/boring_http/quic/protocol.py

@@ -135,6 +135,8 @@ class QuicClient:
         )
         self._inboxes: dict[int, Inbox] = {}
         self._unsent: deque[bytes] = deque()
+        # set after every flush, so a writer waiting for its stream to drain looks again
+        self._progress = asyncio.Event()
         self._closed = False
         self.incoming: asyncio.Queue[int] = asyncio.Queue()
         self.datagrams: asyncio.Queue[bytes] = asyncio.Queue()
@@ -261,7 +263,10 @@ class QuicClient:
         while True:
             if inbox.chunks:
                 chunks, inbox.chunks = inbox.chunks, []
-                return chunks[0] if len(chunks) == 1 else b"".join(chunks)
+                data = chunks[0] if len(chunks) == 1 else b"".join(chunks)
+                if self._connection.stream_read(stream_id, len(data)):
+                    self._flush_soon()
+                return data
             if inbox.error is not None:
                 raise inbox.error
             if inbox.ended:
@@ -270,6 +275,17 @@ class QuicClient:
             await inbox.waiter
             inbox.waiter = None
 
+    async def drain(self, stream_id: int, limit: int) -> None:
+        # a writer waits while more than limit bytes of its stream are unsent, so a large body is never queued whole
+        while self._connection.unsent(stream_id) > limit:
+            inbox = self._inboxes.get(stream_id)
+            if inbox is not None and inbox.error is not None:
+                raise inbox.error
+            if self._terminated.done():
+                raise RemoteDisconnected("QUIC connection closed with data unsent")
+            self._progress.clear()
+            await self._progress.wait()
+
     def close(self, error: int = 0, reason: str = "") -> None:
         if not self._terminated.done():
             self._connection.close(error, reason)
@@ -385,6 +401,7 @@ class QuicClient:
                 # these count as lost, and the connection goes back to the size every path carries
                 self._connection.datagram_too_long()
             index = end
+        self._progress.set()
         self._dispatch()
         self._arm_timer()
         if len(datagrams) >= MAX_BURST and not self._unsent and self._pacer is None:
@@ -492,3 +509,4 @@ class QuicClient:
             inbox.wake()
         if not self._terminated.done():
             self._terminated.set_result(ConnectionTerminated(0, str(error), False))
+        self._progress.set()

{boring_http-2.0.3 → boring_http-2.1.0}/src/boring_http/quic/streams.py

@@ -24,6 +24,10 @@ class SendStream:
     def active(self) -> bool:
         return bool(self.pending) or (self.ended and not self.fin_sent)
 
+    @property
+    def unsent(self) -> int:
+        return sum(len(data) for _, data in self.pending) - self.position
+
     def write(self, data: bytes) -> None:
         if self.ended:
             raise ProtocolError(f"stream {self.stream_id} already ended")
@@ -90,6 +94,8 @@ class ReceiveStream:
         self.stream_id = stream_id
         self.max_data = max_data
         self.consumed = 0
+        # what the application has taken, which is what moves max_data
+        self.read = 0
         # in-order data the application has not been handed yet
         self.chunks: list[bytes] = []
         self.fragments: dict[int, bytes] = {}