boring-http 2.0.1__tar.gz → 2.0.2__tar.gz

{boring_http-2.0.1 → boring_http-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: boring-http
-Version: 2.0.1
+Version: 2.0.2
 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
@@ -98,7 +98,7 @@ async def main() -> None:
 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: `read` is the longest wait for the next bytes, `total` caps the whole exchange including redirects, and the error names whichever ran out.
+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.
 
 ## HTTP/3
 
@@ -453,7 +453,7 @@ async def main() -> None:
 asyncio.run(main())
 ```
 
-Over HTTP/1.1 this is the Upgrade handshake. Over HTTP/2 and HTTP/3 it is Extended CONNECT when the server advertises `SETTINGS_ENABLE_CONNECT_PROTOCOL`, otherwise the client opens an HTTP/1.1 connection for it. `subprotocols=[...]` offers subprotocols; `websocket.subprotocol` is the one chosen.
+Over HTTP/1.1 this is the Upgrade handshake. Over HTTP/2 and HTTP/3 it is Extended CONNECT when the server advertises `SETTINGS_ENABLE_CONNECT_PROTOCOL`, otherwise the client opens an HTTP/1.1 connection for it. `subprotocols=[...]` offers subprotocols; `websocket.subprotocol` is the one chosen. The `total` of `timeout` covers the handshake only; afterwards `read` and `write` still limit each wait, so `Timeout(read=None)` lets `receive()` wait through any silence.
 
 ## uvloop
 

{boring_http-2.0.1 → boring_http-2.0.2}/README.md

@@ -88,7 +88,7 @@ async def main() -> None:
 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: `read` is the longest wait for the next bytes, `total` caps the whole exchange including redirects, and the error names whichever ran out.
+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.
 
 ## HTTP/3
 
@@ -443,7 +443,7 @@ async def main() -> None:
 asyncio.run(main())
 ```
 
-Over HTTP/1.1 this is the Upgrade handshake. Over HTTP/2 and HTTP/3 it is Extended CONNECT when the server advertises `SETTINGS_ENABLE_CONNECT_PROTOCOL`, otherwise the client opens an HTTP/1.1 connection for it. `subprotocols=[...]` offers subprotocols; `websocket.subprotocol` is the one chosen.
+Over HTTP/1.1 this is the Upgrade handshake. Over HTTP/2 and HTTP/3 it is Extended CONNECT when the server advertises `SETTINGS_ENABLE_CONNECT_PROTOCOL`, otherwise the client opens an HTTP/1.1 connection for it. `subprotocols=[...]` offers subprotocols; `websocket.subprotocol` is the one chosen. The `total` of `timeout` covers the handshake only; afterwards `read` and `write` still limit each wait, so `Timeout(read=None)` lets `receive()` wait through any silence.
 
 ## uvloop
 

{boring_http-2.0.1 → boring_http-2.0.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "boring-http"
-version = "2.0.1"
+version = "2.0.2"
 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.1 → boring_http-2.0.2}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "boring-http"
-version = "2.0.1"
+version = "2.0.2"
 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.1 → boring_http-2.0.2}/src/boring_http/pool.py

@@ -68,7 +68,8 @@ class Pool:
                 await limit.acquire()
                 await self._total.acquire()
             try:
-                connection = await self._connector(url, proxy, quic)
+                async with deadline.phase("connect"):
+                    connection = await self._connector(url, proxy, quic)
             except BaseException:
                 limit.release()
                 self._total.release()

{boring_http-2.0.1 → boring_http-2.0.2}/src/boring_http/timing.py

@@ -45,6 +45,9 @@ class Deadline:
     def phase(self, name: Phase) -> PhaseTimer:
         return PhaseTimer(self, name)
 
+    def drop_total(self) -> None:
+        self._end = None
+
     def limit(self, name: Phase) -> tuple[float | None, bool]:
         # the total budget wins when it leaves less time than the phase's own limit, and the error then names the total
         limit = self._limits[name]

{boring_http-2.0.1 → boring_http-2.0.2}/src/boring_http/websocket.py

@@ -37,6 +37,8 @@ class WebSocket:
     ) -> None:
         self._transport = transport
         self._buffer = bytearray(leftover)
+        # the total covered the handshake; from here each read and write keeps only its phase limit
+        deadline.drop_total()
         self._deadline = deadline
         self._limit = max_message_size
         self._fragments: list[bytes] = []