punkreq 0.2.3__tar.gz → 0.3.0__tar.gz

{punkreq-0.2.3 → punkreq-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: punkreq
-Version: 0.2.3
+Version: 0.3.0
 Summary: An async HTTP client built on httpunk
 Project-URL: Homepage, https://github.com/gi0baro/punkreq
 Project-URL: Funding, https://github.com/sponsors/gi0baro
@@ -15,7 +15,6 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
@@ -23,8 +22,8 @@ Classifier: Programming Language :: Python :: 3.14
 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.4
+Requires-Python: >=3.11
+Requires-Dist: httpunk~=0.5.0
 Provides-Extra: brotli
 Requires-Dist: brotli~=1.2.0; extra == 'brotli'
 Provides-Extra: tonio

{punkreq-0.2.3 → punkreq-0.3.0}/punkreq/_connect.py

@@ -4,6 +4,7 @@ import os
 import ssl
 import typing
 
+from httpunk.exceptions import HTTPunkError
 from httpunk.h1.client import H1Connection
 from httpunk.h2.client import H2Connection
 
@@ -83,17 +84,19 @@ 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)
 
 
 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,8 +129,11 @@ 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 = await self._connect_tls(origin)
+            else:
+                conn = await self._connect_tcp(origin)
+            await conn.__aenter__()
+            return conn
         except connect_errors(self._backend) as exc:
             raise ConnectError(f"Failed to connect to {origin}: {exc}")
 

{punkreq-0.2.3 → punkreq-0.3.0}/punkreq/_pool.py

@@ -11,14 +11,14 @@ Concept mapping (hyper-util `client/pool/*.rs` ≡ `httpunk.util.pool` ≡ here)
   ≡ `_HostState.shared` + `.dialing` + `.mode`. Waiters re-attempt internally
   instead of surfacing `Canceled` — the same retry-by-calling-again
   semantics. A closed shared conn is ditched and redialed at checkout
-  (`Singled::poll_ready` reset; httpunk F35).
+  (`Singled::poll_ready` reset, as httpunk's `Singleton` does).
 * `Cache` (idle set, drop-returns-to-cache) ≡ `_HostState.idle` + `release()`.
   The park check (`discard or closed or busy`) matches httpunk's `_Lease`:
   `closed` mirrors `Cached::poll_ready`-sets-`is_closed` + `Drop` skipping
-  the put; `busy` is the runtime-forced extra (httpunk D3); closing on a
-  failed exchange instead of re-parking is httpunk's F51 choice. Like
-  httpunk's `Cache` (F50), there is no checkout-vs-connect race: an empty
-  idle set dials directly.
+  the put; `busy` is the runtime-forced extra httpunk also adds; closing on
+  a failed exchange instead of re-parking is httpunk's choice too. Like
+  httpunk's `Cache`, there is no checkout-vs-connect race: an empty idle
+  set dials directly.
 
 Policy layered on top (owner-owned, per the modern pool's design — its only
 culling surface is `Cache::retain(predicate)`, everything else is the
@@ -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.3 → punkreq-0.3.0}/punkreq/_proxies.py

@@ -112,6 +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))
+        await conn.__aenter__()
         return conn
 
     async def _tunnel(self, origin: Origin, intercept: typing.Any) -> typing.Any:
@@ -149,5 +150,8 @@ 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)
+        await conn.__aenter__()
+        return conn

{punkreq-0.2.3 → punkreq-0.3.0}/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.3.0/punkreq/_version.py

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

{punkreq-0.2.3 → punkreq-0.3.0}/pyproject.toml

@@ -4,11 +4,11 @@ build-backend = "hatchling.build"
 
 [project]
 name = "punkreq"
-version = "0.2.3"
+version = "0.3.0"
 description = "An async HTTP client built on httpunk"
 readme = "README.md"
 license = "BSD-3-Clause"
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 
 authors = [
     { name = "Giovanni Barillari", email = "g@baro.dev" }
@@ -22,7 +22,6 @@ classifiers = [
     "Operating System :: OS Independent",
     "Programming Language :: Python :: Free Threading :: 3 - Stable",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
@@ -32,7 +31,7 @@ classifiers = [
 ]
 
 dependencies = [
-    "httpunk~=0.4.4",
+    "httpunk~=0.5.0",
 ]
 
 [project.optional-dependencies]

{punkreq-0.2.3 → punkreq-0.3.0}/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.3 → punkreq-0.3.0}/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.3/punkreq/_version.py

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