punkreq 0.2.2__tar.gz → 0.2.4__tar.gz

{punkreq-0.2.2 → punkreq-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: punkreq
-Version: 0.2.2
+Version: 0.2.4
 Summary: An async HTTP client built on httpunk
 Project-URL: Homepage, https://github.com/gi0baro/punkreq
 Project-URL: Funding, https://github.com/sponsors/gi0baro
@@ -24,11 +24,11 @@ Classifier: Programming Language :: Python :: 3.15
 Classifier: Programming Language :: Python :: Free Threading :: 3 - Stable
 Classifier: Topic :: Internet :: WWW/HTTP
 Requires-Python: >=3.10
-Requires-Dist: httpunk~=0.4.0
+Requires-Dist: httpunk~=0.4.4
 Provides-Extra: brotli
 Requires-Dist: brotli~=1.2.0; extra == 'brotli'
 Provides-Extra: tonio
-Requires-Dist: tonio~=0.9.16; (python_version >= '3.14') and extra == 'tonio'
+Requires-Dist: tonio~=0.10.0; (python_version >= '3.14') and extra == 'tonio'
 Description-Content-Type: text/markdown
 
 # punkreq

{punkreq-0.2.2 → punkreq-0.2.4}/punkreq/_connect.py

@@ -4,13 +4,14 @@ import os
 import ssl
 import typing
 
+from httpunk.exceptions import HTTPunkError
 from httpunk.h1.client import H1Connection
 from httpunk.h2.client import H2Connection
 
 from ._exceptions import ConnectError, UnsupportedProtocol
 
 
-__all__ = ["Connector", "Origin", "connect_errors", "create_ssl_context", "origin_for_url"]
+__all__ = ["Connector", "Origin", "connect_errors", "create_ssl_context", "enter_connection", "origin_for_url"]
 
 DEFAULT_PORTS = {"http": 80, "https": 443}
 
@@ -83,17 +84,32 @@ def create_ssl_context(verify: VerifyTypes = True, cert: CertTypes | None = None
 
 
 def connect_errors(backend: typing.Any) -> tuple[type[BaseException], ...]:
-    """What a dial or a TLS handshake fails with on `backend`: the OS and ssl
-    errors, plus the backend's own transport failure. tonio's `ResourceBroken`
+    """What a dial, a TLS handshake or the HTTP handshake fails with on
+    `backend`: the OS and ssl errors, the backend's own transport failure, and
+    httpunk's errors (the peer hanging up or misbehaving while the connection
+    is entered, or during a proxy's CONNECT). tonio's `ResourceBroken`
     is a plain `Exception`, not an `OSError`, and its TLS layer raises it in
     place of the ssl error, so `(OSError, ssl.SSLError)` alone lets a failed
     handshake on tonio escape as an unmapped exception."""
-    return (OSError, ssl.SSLError, *backend.broken_transport_errors)
+    return (OSError, ssl.SSLError, HTTPunkError, *backend.broken_transport_errors)
+
+
+async def enter_connection(conn: typing.Any, transport: typing.Any, backend: typing.Any) -> typing.Any:
+    """Run `conn`'s HTTP handshake (`__aenter__`) and return it. Until that
+    completes the transport we dialed is still ours to close: httpunk closes
+    it on `__aexit__`, which a failed or interrupted `__aenter__` never
+    reaches (h2 waits there for the peer's SETTINGS, pumps already running)."""
+    try:
+        await conn.__aenter__()
+    except BaseException:
+        backend.close_transport(transport)
+        raise
+    return conn
 
 
 class Connector:
-    """The default connector: dial `origin` and return the protocol-matching,
-    un-entered httpunk connection."""
+    """The default connector: dial `origin` and return the protocol-matching
+    httpunk connection, entered."""
 
     def __init__(
         self,
@@ -126,12 +142,14 @@ class Connector:
     async def __call__(self, origin: Origin) -> H1Connection | H2Connection:
         try:
             if origin.scheme == "https":
-                return await self._connect_tls(origin)
-            return await self._connect_tcp(origin)
+                conn, stream = await self._connect_tls(origin)
+            else:
+                conn, stream = await self._connect_tcp(origin)
+            return await enter_connection(conn, stream, self._backend)
         except connect_errors(self._backend) as exc:
             raise ConnectError(f"Failed to connect to {origin}: {exc}")
 
-    async def _connect_tls(self, origin: Origin) -> H1Connection | H2Connection:
+    async def _connect_tls(self, origin: Origin) -> tuple[H1Connection | H2Connection, typing.Any]:
         # our context already carries the offer; a backend-created default one
         # (no context given) is configured per dial
         alpn = None if self._ssl_context is not None else self.alpn
@@ -139,12 +157,12 @@ class Connector:
             origin.host, origin.port, alpn=alpn, ssl_context=self._ssl_context
         )
         if selected == "h2" or not self._http1:
-            return H2Connection(stream, authority=origin.authority, scheme="https", backend=self._backend)
-        return H1Connection(stream, authority=origin.authority, backend=self._backend)
+            return H2Connection(stream, authority=origin.authority, scheme="https", backend=self._backend), stream
+        return H1Connection(stream, authority=origin.authority, backend=self._backend), stream
 
-    async def _connect_tcp(self, origin: Origin) -> H1Connection | H2Connection:
+    async def _connect_tcp(self, origin: Origin) -> tuple[H1Connection | H2Connection, typing.Any]:
         stream = await self._backend.connect_tcp(origin.host, origin.port)
         if not self._http1:
             # h2 prior knowledge over cleartext (reqwest's http2_prior_knowledge)
-            return H2Connection(stream, authority=origin.authority, scheme="http", backend=self._backend)
-        return H1Connection(stream, authority=origin.authority, backend=self._backend)
+            return H2Connection(stream, authority=origin.authority, scheme="http", backend=self._backend), stream
+        return H1Connection(stream, authority=origin.authority, backend=self._backend), stream

{punkreq-0.2.2 → punkreq-0.2.4}/punkreq/_pool.py

@@ -133,7 +133,11 @@ class ConnectionPool:
 
             if action == "dial":
                 conn = await self._dial(origin, connect_timeout)
-                return self._install(origin, conn)
+                installed = self._install(origin, conn)
+                if installed is None:
+                    await self._close_conn(conn)
+                    raise RuntimeError("The connection pool is closed.")
+                return installed
 
             # action == "wait": either a coalesced dial or pool capacity
             await self._wait(value, deadline)
@@ -181,12 +185,19 @@ class ConnectionPool:
         with self._lock:
             self._closed = True
             conns = []
+            dialing = []
             for host in self._hosts.values():
                 if host.shared is not None:
                     conns.append(host.shared)
                 conns.extend(conn for conn, _ in host.idle)
+                if host.dialing is not None:
+                    dialing.append(host.dialing)
             self._hosts.clear()
             self._count = 0
+        # acquirers coalesced on a dial still in flight: its entry is gone, so
+        # nothing else would ever set their event
+        for event in dialing:
+            event.set()
         for conn in conns:
             await self._close_conn(conn)
         self._wake_waiters()
@@ -250,24 +261,38 @@ class ConnectionPool:
             return "wait", event, stale
 
     async def _dial(self, origin: Origin, connect_timeout: float | None) -> typing.Any:
+        if connect_timeout is None:
+            try:
+                return await self._connector(origin)
+            except BaseException:
+                self._abandon_dial(origin)
+                raise
+
+        abandoned, dialed, lock = False, [], threading.Lock()
+
+        async def dial():
+            conn = await self._connector(origin)
+            with lock:
+                if not abandoned:
+                    dialed.append(conn)
+                    return
+            # the caller is gone: nobody takes it
+            await self._close_conn(conn)
+
         try:
-            if connect_timeout is None:
-                conn = await self._connector(origin)
-                await conn.__aenter__()
-            else:
-                result, completed = await self._backend.timeout(self._dial_inner(origin), connect_timeout)
-                if not completed:
-                    raise ConnectTimeout(f"Timed out connecting to {origin}")
-                conn = result
+            _, completed = await self._backend.timeout(dial(), connect_timeout)
+            if not completed:
+                raise ConnectTimeout(f"Timed out connecting to {origin}")
         except BaseException:
+            with lock:
+                abandoned = True
+                conn = dialed.pop() if dialed else None
+            if conn is not None:
+                # the caller gave up: hand over closing
+                self._backend.spawn_detached(self._close_conn(conn))
             self._abandon_dial(origin)
             raise
-        return conn
-
-    async def _dial_inner(self, origin: Origin) -> typing.Any:
-        conn = await self._connector(origin)
-        await conn.__aenter__()
-        return conn
+        return dialed.pop()
 
     def _abandon_dial(self, origin: Origin) -> None:
         with self._lock:
@@ -281,9 +306,13 @@ class ConnectionPool:
             event.set()
         self._wake_waiters()
 
-    def _install(self, origin: Origin, conn: typing.Any) -> tuple[typing.Any, bool, bool]:
-        """Record a freshly-dialed connection and settle the origin's mode."""
+    def _install(self, origin: Origin, conn: typing.Any) -> tuple[typing.Any, bool, bool] | None:
+        """Record a freshly-dialed connection and settle the origin's mode.
+        None when the pool was closed while dialing: the connection is not
+        recorded, and is the caller's to close."""
         with self._lock:
+            if self._closed:
+                return None
             host = self._hosts.setdefault(origin, _HostState())
             event, host.dialing = host.dialing, None
             if _is_multiplexed(conn):

{punkreq-0.2.2 → punkreq-0.2.4}/punkreq/_proxies.py

@@ -10,7 +10,7 @@ from httpunk.h2.client import H2Connection
 from httpunk.util.proxy import Matcher
 
 from ._config import Proxy
-from ._connect import Connector, Origin, connect_errors
+from ._connect import Connector, Origin, connect_errors, enter_connection
 from ._exceptions import ConnectError, ProxyError
 from ._headers import Headers
 from ._urls import URL
@@ -112,7 +112,7 @@ class ProxyConnector:
         transport = await self._dial_proxy(intercept)
         conn = H1Connection(transport, authority=origin.authority, backend=self._backend)
         setattr(conn, PROXY_ATTR, ProxyInfo(auth=intercept.basic_auth(), headers=self._config.headers))
-        return conn
+        return await enter_connection(conn, transport, self._backend)
 
     async def _tunnel(self, origin: Origin, intercept: typing.Any) -> typing.Any:
         transport = await self._dial_proxy(intercept)
@@ -149,5 +149,7 @@ class ProxyConnector:
             raise ProxyError(f"Cannot open a TLS tunnel to {origin} via proxy {intercept.uri}: {exc}")
 
         if selected == "h2" or not self._http1:
-            return H2Connection(tls, authority=origin.authority, scheme="https", backend=self._backend)
-        return H1Connection(tls, authority=origin.authority, backend=self._backend)
+            conn = H2Connection(tls, authority=origin.authority, scheme="https", backend=self._backend)
+        else:
+            conn = H1Connection(tls, authority=origin.authority, backend=self._backend)
+        return await enter_connection(conn, tls, self._backend)

{punkreq-0.2.2 → punkreq-0.2.4}/punkreq/_transport.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import contextlib
 import functools
 import threading
 import typing
@@ -302,12 +303,37 @@ class PoolTransport:
             raise TimeoutException("Exceeded the total request timeout", request=request)
         return remaining if phase is None else min(phase, remaining)
 
+    async def _abort_response(self, response):
+        with contextlib.suppress(Exception):
+            await response.aclose()
+
     async def _send_on(self, conn: typing.Any, request: Request, read_timeout: float | None) -> typing.Any:
         proxy_info = getattr(conn, PROXY_ATTR, None)
         httpunk_request = _to_httpunk_request(request, h2=_is_multiplexed(conn), proxy=proxy_info)
         if read_timeout is None:
             return await conn.send_request(httpunk_request)
-        result, completed = await self._backend.timeout(conn.send_request(httpunk_request), read_timeout)
-        if not completed:
-            raise ReadTimeout("Timed out waiting for the response", request=request)
-        return result
+
+        abandoned, sent, lock = False, [], threading.Lock()
+
+        async def send():
+            response = await conn.send_request(httpunk_request)
+            with lock:
+                if not abandoned:
+                    sent.append(response)
+                    return
+            # the caller is gone: nobody takes it
+            await self._abort_response(response)
+
+        try:
+            _, completed = await self._backend.timeout(send(), read_timeout)
+            if not completed:
+                raise ReadTimeout("Timed out waiting for the response", request=request)
+        except BaseException:
+            with lock:
+                abandoned = True
+                response = sent.pop() if sent else None
+            if response is not None:
+                # the caller gave up: hand over closing
+                self._backend.spawn_detached(self._abort_response(response))
+            raise
+        return sent.pop()

punkreq-0.2.4/punkreq/_version.py

@@ -0,0 +1 @@
+__version__ = "0.2.4"

{punkreq-0.2.2 → punkreq-0.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "punkreq"
-version = "0.2.2"
+version = "0.2.4"
 description = "An async HTTP client built on httpunk"
 readme = "README.md"
 license = "BSD-3-Clause"
@@ -32,12 +32,12 @@ classifiers = [
 ]
 
 dependencies = [
-    "httpunk~=0.4.0",
+    "httpunk~=0.4.4",
 ]
 
 [project.optional-dependencies]
 brotli = ["brotli~=1.2.0"]
-tonio = ["tonio~=0.9.16; python_version >= '3.14'"]
+tonio = ["tonio~=0.10.0; python_version >= '3.14'"]
 
 [dependency-groups]
 lint = [

{punkreq-0.2.2 → punkreq-0.2.4}/tests/fakes.py

@@ -117,6 +117,7 @@ class FakeConnector:
             raise punkreq.ConnectError(f"boom dialing {origin}")
         conn = FakeConnection(self.handler, multiplexed=self.multiplexed)
         self.connections.append(conn)
+        await conn.__aenter__()  # a connector hands back an entered connection
         return conn
 
     @property

{punkreq-0.2.2 → punkreq-0.2.4}/tests/test_connect.py

@@ -41,12 +41,12 @@ async def test_connector_alpn_offer_from_flags(http1, http2, offer):
     context = ssl.create_default_context()
     connector = Connector(backend=backend, ssl_context=context, http1=http1, http2=http2)
     assert connector.alpn == offer
-    await connector(Origin("https", "example.com", 443))
+    await connector._connect_tls(Origin("https", "example.com", 443))
     assert backend.calls == [(None, context)]  # already on the context: no per-dial offer
 
 
 async def test_connector_default_context_configured_per_dial():
     backend = RecordingBackend("h2")
     connector = Connector(backend=backend)
-    await connector(Origin("https", "example.com", 443))
+    await connector._connect_tls(Origin("https", "example.com", 443))
     assert backend.calls == [(("h2", "http/1.1"), None)]

punkreq-0.2.2/punkreq/_version.py

@@ -1 +0,0 @@
-__version__ = "0.2.2"