httpcore2 2.1.0__tar.gz → 2.3.0__tar.gz

{httpcore2-2.1.0 → httpcore2-2.3.0}/CHANGELOG.md

@@ -4,6 +4,19 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
+## 2.3.0 (June 1st, 2026)
+
+### Changed
+
+* Use `truststore` instead of `certifi` for default SSL verification, loading the operating system's trust store. ([#1002](https://github.com/pydantic/httpx2/pull/1002))
+* Rewrite `_assign_requests_to_connections` as a single-pass loop. ([#974](https://github.com/pydantic/httpx2/pull/974))
+* Use `anyio`'s `fast_acquire` for `Lock` and `Semaphore`. ([#970](https://github.com/pydantic/httpx2/pull/970))
+* Use `memoryview` in `write()` to avoid copies. ([#954](https://github.com/pydantic/httpx2/pull/954))
+
+## 2.2.0 (May 16th, 2026)
+
+No changes since `2.1.0`. Version bumped to stay in lockstep with `httpx2`.
+
 ## 2.1.0 (May 15th, 2026)
 
 ### Removed
@@ -60,7 +73,7 @@ Historical entries below are from upstream `encode/httpcore`.
 ## 1.0.5 (March 27th, 2024)
 
 - Handle `EndOfStream` exception for anyio backend. (#899)
-- Allow trio `0.25.*` series in package dependancies. (#903)
+- Allow trio `0.25.*` series in package dependencies. (#903)
 
 ## 1.0.4 (February 21st, 2024)
 
@@ -138,7 +151,7 @@ The project versioning policy is now explicitly governed by SEMVER. See https://
 - Allow `ws` and `wss` schemes. Allows us to properly support websocket upgrade connections. (#625)
 - Forwarding HTTP proxies use a connection-per-remote-host. Required by some proxy implementations. (#637)
 - Don't raise `RuntimeError` when closing a connection pool with active connections. Removes some error cases when cancellations are used. (#631)
-- Lazy import `anyio`, so that it's no longer a hard dependancy, and isn't imported if unused. (#639)
+- Lazy import `anyio`, so that it's no longer a hard dependency, and isn't imported if unused. (#639)
 
 ## 0.16.2 (November 25th, 2022)
 
@@ -196,7 +209,7 @@ The project versioning policy is now explicitly governed by SEMVER. See https://
 ## 0.14.1 (November 12th, 2021)
 
 - `max_connections` becomes optional. (Pull #429)
-- `certifi` is now included in the install dependancies. (Pull #428)
+- `certifi` is now included in the install dependencies. (Pull #428)
 - `h2` is now strictly optional. (Pull #428)
 
 ## 0.14.0 (November 11th, 2021)
@@ -261,7 +274,7 @@ Note that `curio` support is not currently available in 0.14.0. If you're using
 
 ### Fixed
 
-- More resiliant testing for closed connections. (Pull #311)
+- More resilient testing for closed connections. (Pull #311)
 - Don't raise exceptions on ungraceful connection closes. (Pull #310)
 
 ## 0.13.0 (April 21st, 2021)

{httpcore2-2.1.0 → httpcore2-2.3.0}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: httpcore2
-Version: 2.1.0
+Version: 2.3.0
 Summary: A minimal low-level HTTP client.
-Project-URL: Documentation, https://www.encode.io/httpcore
-Project-URL: Homepage, https://www.encode.io/httpcore/
-Project-URL: Source, https://github.com/encode/httpcore
+Project-URL: Changelog, https://github.com/pydantic/httpx2/blob/main/src/httpcore2/CHANGELOG.md
+Project-URL: Homepage, https://github.com/pydantic/httpx2
+Project-URL: Source, https://github.com/pydantic/httpx2/blob/main/src/httpcore2
 Author-email: Tom Christie <tom@tomchristie.com>
 Maintainer-email: "Pydantic Services Inc." <engineering@pydantic.dev>
 License-Expression: BSD-3-Clause
@@ -25,10 +25,10 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Internet :: WWW/HTTP
 Requires-Python: >=3.10
-Requires-Dist: certifi
 Requires-Dist: h11>=0.16
+Requires-Dist: truststore>=0.10
 Provides-Extra: asyncio
-Requires-Dist: anyio<5.0,>=4.0; extra == 'asyncio'
+Requires-Dist: anyio<5.0,>=4.5.0; extra == 'asyncio'
 Provides-Extra: http2
 Requires-Dist: h2<5,>=3; extra == 'http2'
 Provides-Extra: socks
@@ -62,10 +62,6 @@ Some things HTTP Core does do:
 * Provides both sync and async interfaces.
 * Async backend support for `asyncio` and `trio`.
 
-## Requirements
-
-Python 3.8+
-
 ## Installation
 
 For HTTP/1.1 only support, install with:
@@ -128,7 +124,7 @@ The motivation for `httpcore` is:
 The `httpcore` package has the following dependencies...
 
 * `h11`
-* `certifi`
+* `truststore`
 
 And the following optional extras...
 
@@ -154,6 +150,19 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
+## 2.3.0 (June 1st, 2026)
+
+### Changed
+
+* Use `truststore` instead of `certifi` for default SSL verification, loading the operating system's trust store. ([#1002](https://github.com/pydantic/httpx2/pull/1002))
+* Rewrite `_assign_requests_to_connections` as a single-pass loop. ([#974](https://github.com/pydantic/httpx2/pull/974))
+* Use `anyio`'s `fast_acquire` for `Lock` and `Semaphore`. ([#970](https://github.com/pydantic/httpx2/pull/970))
+* Use `memoryview` in `write()` to avoid copies. ([#954](https://github.com/pydantic/httpx2/pull/954))
+
+## 2.2.0 (May 16th, 2026)
+
+No changes since `2.1.0`. Version bumped to stay in lockstep with `httpx2`.
+
 ## 2.1.0 (May 15th, 2026)
 
 ### Removed
@@ -210,7 +219,7 @@ Historical entries below are from upstream `encode/httpcore`.
 ## 1.0.5 (March 27th, 2024)
 
 - Handle `EndOfStream` exception for anyio backend. (#899)
-- Allow trio `0.25.*` series in package dependancies. (#903)
+- Allow trio `0.25.*` series in package dependencies. (#903)
 
 ## 1.0.4 (February 21st, 2024)
 
@@ -288,7 +297,7 @@ The project versioning policy is now explicitly governed by SEMVER. See https://
 - Allow `ws` and `wss` schemes. Allows us to properly support websocket upgrade connections. (#625)
 - Forwarding HTTP proxies use a connection-per-remote-host. Required by some proxy implementations. (#637)
 - Don't raise `RuntimeError` when closing a connection pool with active connections. Removes some error cases when cancellations are used. (#631)
-- Lazy import `anyio`, so that it's no longer a hard dependancy, and isn't imported if unused. (#639)
+- Lazy import `anyio`, so that it's no longer a hard dependency, and isn't imported if unused. (#639)
 
 ## 0.16.2 (November 25th, 2022)
 
@@ -346,7 +355,7 @@ The project versioning policy is now explicitly governed by SEMVER. See https://
 ## 0.14.1 (November 12th, 2021)
 
 - `max_connections` becomes optional. (Pull #429)
-- `certifi` is now included in the install dependancies. (Pull #428)
+- `certifi` is now included in the install dependencies. (Pull #428)
 - `h2` is now strictly optional. (Pull #428)
 
 ## 0.14.0 (November 11th, 2021)
@@ -411,7 +420,7 @@ Note that `curio` support is not currently available in 0.14.0. If you're using
 
 ### Fixed
 
-- More resiliant testing for closed connections. (Pull #311)
+- More resilient testing for closed connections. (Pull #311)
 - Don't raise exceptions on ungraceful connection closes. (Pull #310)
 
 ## 0.13.0 (April 21st, 2021)

{httpcore2-2.1.0 → httpcore2-2.3.0}/README.md

@@ -23,10 +23,6 @@ Some things HTTP Core does do:
 * Provides both sync and async interfaces.
 * Async backend support for `asyncio` and `trio`.
 
-## Requirements
-
-Python 3.8+
-
 ## Installation
 
 For HTTP/1.1 only support, install with:
@@ -89,7 +85,7 @@ The motivation for `httpcore` is:
 The `httpcore` package has the following dependencies...
 
 * `h11`
-* `certifi`
+* `truststore`
 
 And the following optional extras...
 

{httpcore2-2.1.0 → httpcore2-2.3.0}/httpcore2/__init__.py

@@ -51,7 +51,7 @@ from ._sync import (
 # The 'httpcore2.AnyIOBackend' class is conditional on 'anyio' being installed.
 try:
     from ._backends.anyio import AnyIOBackend
-except ImportError:  # pragma: nocover
+except ImportError:  # pragma: no cover
 
     class AnyIOBackend:  # type: ignore
         def __init__(self, *args, **kwargs):  # type: ignore
@@ -62,7 +62,7 @@ except ImportError:  # pragma: nocover
 # The 'httpcore2.TrioBackend' class is conditional on 'trio' being installed.
 try:
     from ._backends.trio import TrioBackend
-except ImportError:  # pragma: nocover
+except ImportError:  # pragma: no cover
 
     class TrioBackend:  # type: ignore
         def __init__(self, *args, **kwargs):  # type: ignore

{httpcore2-2.1.0 → httpcore2-2.3.0}/httpcore2/_async/__init__.py

@@ -6,7 +6,7 @@ from .interfaces import AsyncConnectionInterface
 
 try:
     from .http2 import AsyncHTTP2Connection
-except ImportError:  # pragma: nocover
+except ImportError:  # pragma: no cover
 
     class AsyncHTTP2Connection:  # type: ignore
         def __init__(self, *args, **kwargs) -> None:  # type: ignore
@@ -18,7 +18,7 @@ except ImportError:  # pragma: nocover
 
 try:
     from .socks_proxy import AsyncSOCKSProxy
-except ImportError:  # pragma: nocover
+except ImportError:  # pragma: no cover
 
     class AsyncSOCKSProxy:  # type: ignore
         def __init__(self, *args, **kwargs) -> None:  # type: ignore

{httpcore2-2.1.0 → httpcore2-2.3.0}/httpcore2/_async/connection_pool.py

@@ -229,7 +229,7 @@ class AsyncConnectionPool(AsyncRequestInterface):
                     # In this case we clear the connection and try again.
                     pool_request.clear_connection()
                 else:
-                    break  # pragma: nocover
+                    break  # pragma: no cover
 
         except BaseException as exc:
             with self._optional_thread_lock:
@@ -259,38 +259,49 @@ class AsyncConnectionPool(AsyncRequestInterface):
         Called whenever a new request is added or removed from the pool.
 
         Any closing connections are returned, allowing the I/O for closing
-        those connections to be handled seperately.
+        those connections to be handled separately.
         """
-        closing_connections = []
+        closing_connections: list[AsyncConnectionInterface] = []
+        retained_connections: list[AsyncConnectionInterface] = []
 
-        # First we handle cleaning up any connections that are closed,
-        # have expired their keep-alive, or surplus idle connections.
-        for connection in list(self._connections):
+        # First we handle cleaning up any connections that are closed
+        # or have expired their keep-alive, in a single pass.
+        for connection in self._connections:
             if connection.is_closed():
-                # log: "removing closed connection"
-                self._connections.remove(connection)
+                continue
             elif connection.has_expired():
-                # log: "closing expired connection"
-                self._connections.remove(connection)
-                closing_connections.append(connection)
-            elif (
-                connection.is_idle()
-                and sum(connection.is_idle() for connection in self._connections) > self._max_keepalive_connections
-            ):
-                # log: "closing idle connection"
-                self._connections.remove(connection)
                 closing_connections.append(connection)
+            else:
+                retained_connections.append(connection)
+
+        # Then we close any surplus idle connections, to enforce the
+        # max_keepalive_connections setting.
+        idle_surplus = (
+            sum(connection.is_idle() for connection in retained_connections) - self._max_keepalive_connections
+        )
+        if idle_surplus > 0:
+            kept: list[AsyncConnectionInterface] = []
+            for connection in retained_connections:
+                if idle_surplus > 0 and connection.is_idle():
+                    closing_connections.append(connection)
+                    idle_surplus -= 1
+                else:
+                    kept.append(connection)
+            retained_connections = kept
+
+        self._connections = retained_connections
+
+        # Snapshot the set of reusable connections once, rather than rebuilding
+        # it per queued request — this is what brings the loop from O(N*M) to
+        # O(N+M) in the common case.
+        available_connections = [connection for connection in self._connections if connection.is_available()]
+        new_connection_budget = self._max_connections - len(self._connections)
 
         # Assign queued requests to connections.
-        queued_requests = [request for request in self._requests if request.is_queued()]
-        for pool_request in queued_requests:
+        for pool_request in self._requests:
+            if not pool_request.is_queued():
+                continue
             origin = pool_request.request.url.origin
-            available_connections = [
-                connection
-                for connection in self._connections
-                if connection.can_handle_request(origin) and connection.is_available()
-            ]
-            idle_connections = [connection for connection in self._connections if connection.is_idle()]
 
             # There are three cases for how we may be able to handle the request:
             #
@@ -298,24 +309,26 @@ class AsyncConnectionPool(AsyncRequestInterface):
             # 2. We can create a new connection to handle the request.
             # 3. We can close an idle connection and then create a new connection
             #    to handle the request.
-            if available_connections:
-                # log: "reusing existing connection"
-                connection = available_connections[0]
-                pool_request.assign_to_connection(connection)
-            elif len(self._connections) < self._max_connections:
-                # log: "creating new connection"
-                connection = self.create_connection(origin)
-                self._connections.append(connection)
-                pool_request.assign_to_connection(connection)
-            elif idle_connections:
-                # log: "closing idle connection"
-                connection = idle_connections[0]
-                self._connections.remove(connection)
-                closing_connections.append(connection)
-                # log: "creating new connection"
-                connection = self.create_connection(origin)
-                self._connections.append(connection)
-                pool_request.assign_to_connection(connection)
+            for connection in available_connections:
+                if connection.can_handle_request(origin):
+                    pool_request.assign_to_connection(connection)
+                    break
+            else:
+                if new_connection_budget > 0:
+                    connection = self.create_connection(origin)
+                    self._connections.append(connection)
+                    pool_request.assign_to_connection(connection)
+                    new_connection_budget -= 1
+                    continue
+                for idx, connection in enumerate(available_connections):
+                    if connection.is_idle():
+                        del available_connections[idx]
+                        self._connections.remove(connection)
+                        closing_connections.append(connection)
+                        connection = self.create_connection(origin)
+                        self._connections.append(connection)
+                        pool_request.assign_to_connection(connection)
+                        break
 
         return closing_connections
 

{httpcore2-2.1.0 → httpcore2-2.3.0}/httpcore2/_async/http11.py

@@ -85,9 +85,9 @@ class AsyncHTTP11Connection(AsyncConnectionInterface):
                     await self._send_request_body(**kwargs)
             except WriteError:
                 # If we get a write error while we're writing the request,
-                # then we supress this error and move on to attempting to
+                # then we suppress this error and move on to attempting to
                 # read the response. Servers can sometimes close the request
-                # pre-emptively and then respond with a well formed HTTP
+                # preemptively and then respond with a well formed HTTP
                 # error response.
                 pass
 

{httpcore2-2.1.0 → httpcore2-2.3.0}/httpcore2/_async/http2.py

@@ -120,7 +120,7 @@ class AsyncHTTP2Connection(AsyncConnectionInterface):
         try:
             stream_id = self._h2_state.get_next_available_stream_id()
             self._events[stream_id] = []
-        except h2.exceptions.NoAvailableStreamIDError:  # pragma: nocover
+        except h2.exceptions.NoAvailableStreamIDError:  # pragma: no cover
             self._used_all_stream_ids = True
             self._request_count -= 1
             raise ConnectionNotAvailable()
@@ -161,11 +161,11 @@ class AsyncHTTP2Connection(AsyncConnectionInterface):
                 #
                 # In this case we'll have stored the event, and should raise
                 # it as a RemoteProtocolError.
-                if self._connection_terminated:  # pragma: nocover
+                if self._connection_terminated:  # pragma: no cover
                     raise RemoteProtocolError(self._connection_terminated)
                 # If h2 raises a protocol error in some other state then we
                 # must somehow have made a protocol violation.
-                raise LocalProtocolError(exc)  # pragma: nocover
+                raise LocalProtocolError(exc)  # pragma: no cover
 
             raise exc
 
@@ -387,7 +387,7 @@ class AsyncHTTP2Connection(AsyncConnectionInterface):
                 if self._keepalive_expiry is not None:
                     now = time.monotonic()
                     self._expire_at = now + self._keepalive_expiry
-                if self._used_all_stream_ids:  # pragma: nocover
+                if self._used_all_stream_ids:  # pragma: no cover
                     await self.aclose()
 
     async def aclose(self) -> None:
@@ -404,7 +404,7 @@ class AsyncHTTP2Connection(AsyncConnectionInterface):
         timeout = timeouts.get("read", None)
 
         if self._read_exception is not None:
-            raise self._read_exception  # pragma: nocover
+            raise self._read_exception  # pragma: no cover
 
         try:
             data = await self._network_stream.read(self.READ_NUM_BYTES, timeout)
@@ -435,11 +435,11 @@ class AsyncHTTP2Connection(AsyncConnectionInterface):
             data_to_send = self._h2_state.data_to_send()
 
             if self._write_exception is not None:
-                raise self._write_exception  # pragma: nocover
+                raise self._write_exception  # pragma: no cover
 
             try:
                 await self._network_stream.write(data_to_send, timeout)
-            except Exception as exc:  # pragma: nocover
+            except Exception as exc:  # pragma: no cover
                 # If we get a network error we should:
                 #
                 # 1. Save the exception and just raise it immediately on any future write.

{httpcore2-2.1.0 → httpcore2-2.3.0}/httpcore2/_async/http_proxy.py

@@ -47,7 +47,7 @@ def merge_headers(
     return default_headers + override_headers
 
 
-class AsyncHTTPProxy(AsyncConnectionPool):  # pragma: nocover
+class AsyncHTTPProxy(AsyncConnectionPool):  # pragma: no cover
     """
     A connection pool that sends requests via an HTTP proxy.
     """

{httpcore2-2.1.0 → httpcore2-2.3.0}/httpcore2/_async/interfaces.py

@@ -82,18 +82,18 @@ class AsyncRequestInterface:
             await response.aclose()
 
     async def handle_async_request(self, request: Request) -> Response:
-        raise NotImplementedError()  # pragma: nocover
+        raise NotImplementedError()  # pragma: no cover
 
 
 class AsyncConnectionInterface(AsyncRequestInterface):
     async def aclose(self) -> None:
-        raise NotImplementedError()  # pragma: nocover
+        raise NotImplementedError()  # pragma: no cover
 
     def info(self) -> str:
-        raise NotImplementedError()  # pragma: nocover
+        raise NotImplementedError()  # pragma: no cover
 
     def can_handle_request(self, origin: Origin) -> bool:
-        raise NotImplementedError()  # pragma: nocover
+        raise NotImplementedError()  # pragma: no cover
 
     def is_available(self) -> bool:
         """
@@ -111,7 +111,7 @@ class AsyncConnectionInterface(AsyncRequestInterface):
         required exceptions if multiple requests are attempted over a connection
         that ends up being established as HTTP/1.1.
         """
-        raise NotImplementedError()  # pragma: nocover
+        raise NotImplementedError()  # pragma: no cover
 
     def has_expired(self) -> bool:
         """
@@ -120,13 +120,13 @@ class AsyncConnectionInterface(AsyncRequestInterface):
         This either means that the connection is idle and it has passed the
         expiry time on its keep-alive, or that server has sent an EOF.
         """
-        raise NotImplementedError()  # pragma: nocover
+        raise NotImplementedError()  # pragma: no cover
 
     def is_idle(self) -> bool:
         """
         Return `True` if the connection is currently idle.
         """
-        raise NotImplementedError()  # pragma: nocover
+        raise NotImplementedError()  # pragma: no cover
 
     def is_closed(self) -> bool:
         """
@@ -135,4 +135,4 @@ class AsyncConnectionInterface(AsyncRequestInterface):
         Used when a response is closed to determine if the connection may be
         returned to the connection pool or not.
         """
-        raise NotImplementedError()  # pragma: nocover
+        raise NotImplementedError()  # pragma: no cover

{httpcore2-2.1.0 → httpcore2-2.3.0}/httpcore2/_async/socks_proxy.py

@@ -96,7 +96,7 @@ async def _init_socks5_connection(
         raise ProxyError(f"Proxy Server could not connect: {reply_code}.")
 
 
-class AsyncSOCKSProxy(AsyncConnectionPool):  # pragma: nocover
+class AsyncSOCKSProxy(AsyncConnectionPool):  # pragma: no cover
     """
     A connection pool that sends requests via an HTTP proxy.
     """
@@ -254,7 +254,7 @@ class AsyncSocks5Connection(AsyncConnectionInterface):
                     http2_negotiated = ssl_object is not None and ssl_object.selected_alpn_protocol() == "h2"
 
                     # Create the HTTP/1.1 or HTTP/2 connection
-                    if http2_negotiated or (self._http2 and not self._http1):  # pragma: nocover
+                    if http2_negotiated or (self._http2 and not self._http1):  # pragma: no cover
                         from .http2 import AsyncHTTP2Connection
 
                         self._connection = AsyncHTTP2Connection(
@@ -271,7 +271,7 @@ class AsyncSocks5Connection(AsyncConnectionInterface):
                 except Exception as exc:
                     self._connect_failed = True
                     raise exc
-            elif not self._connection.is_available():  # pragma: nocover
+            elif not self._connection.is_available():  # pragma: no cover
                 raise ConnectionNotAvailable()
 
         return await self._connection.handle_async_request(request)
@@ -284,7 +284,7 @@ class AsyncSocks5Connection(AsyncConnectionInterface):
             await self._connection.aclose()
 
     def is_available(self) -> bool:
-        if self._connection is None:  # pragma: nocover
+        if self._connection is None:  # pragma: no cover
             # If HTTP/2 support is enabled, and the resulting connection could
             # end up as HTTP/2 then we should indicate the connection as being
             # available to service multiple requests.
@@ -294,22 +294,22 @@ class AsyncSocks5Connection(AsyncConnectionInterface):
         return self._connection.is_available()
 
     def has_expired(self) -> bool:
-        if self._connection is None:  # pragma: nocover
+        if self._connection is None:  # pragma: no cover
             return self._connect_failed
         return self._connection.has_expired()
 
     def is_idle(self) -> bool:
-        if self._connection is None:  # pragma: nocover
+        if self._connection is None:  # pragma: no cover
             return self._connect_failed
         return self._connection.is_idle()
 
     def is_closed(self) -> bool:
-        if self._connection is None:  # pragma: nocover
+        if self._connection is None:  # pragma: no cover
             return self._connect_failed
         return self._connection.is_closed()
 
     def info(self) -> str:
-        if self._connection is None:  # pragma: nocover
+        if self._connection is None:  # pragma: no cover
             return "CONNECTION FAILED" if self._connect_failed else "CONNECTING"
         return self._connection.info()
 

{httpcore2-2.1.0 → httpcore2-2.3.0}/httpcore2/_backends/anyio.py

@@ -33,7 +33,7 @@ class AnyIOStream(AsyncNetworkStream):
             with anyio.fail_after(timeout):
                 try:
                     return await self._stream.receive(max_bytes=max_bytes)
-                except anyio.EndOfStream:  # pragma: nocover
+                except anyio.EndOfStream:  # pragma: no cover
                     return b""
 
     async def write(self, buffer: bytes, timeout: float | None = None) -> None:
@@ -74,7 +74,7 @@ class AnyIOStream(AsyncNetworkStream):
                         standard_compatible=False,
                         server_side=False,
                     )
-            except Exception as exc:  # pragma: nocover
+            except Exception as exc:  # pragma: no cover
                 await self.aclose()
                 raise exc
         return AnyIOStream(ssl_stream)
@@ -102,7 +102,7 @@ class AnyIOBackend(AsyncNetworkBackend):
         timeout: float | None = None,
         local_address: str | None = None,
         socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
-    ) -> AsyncNetworkStream:  # pragma: nocover
+    ) -> AsyncNetworkStream:  # pragma: no cover
         if socket_options is None:
             socket_options = []
         exc_map = {
@@ -127,7 +127,7 @@ class AnyIOBackend(AsyncNetworkBackend):
         path: str,
         timeout: float | None = None,
         socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
-    ) -> AsyncNetworkStream:  # pragma: nocover
+    ) -> AsyncNetworkStream:  # pragma: no cover
         if socket_options is None:
             socket_options = []
         exc_map = {
@@ -143,4 +143,4 @@ class AnyIOBackend(AsyncNetworkBackend):
         return AnyIOStream(stream)
 
     async def sleep(self, seconds: float) -> None:
-        await anyio.sleep(seconds)  # pragma: nocover
+        await anyio.sleep(seconds)  # pragma: no cover

{httpcore2-2.1.0 → httpcore2-2.3.0}/httpcore2/_backends/auto.py

@@ -41,10 +41,10 @@ class AutoBackend(AsyncNetworkBackend):
         path: str,
         timeout: float | None = None,
         socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
-    ) -> AsyncNetworkStream:  # pragma: nocover
+    ) -> AsyncNetworkStream:  # pragma: no cover
         await self._init_backend()
         return await self._backend.connect_unix_socket(path, timeout=timeout, socket_options=socket_options)
 
-    async def sleep(self, seconds: float) -> None:  # pragma: nocover
+    async def sleep(self, seconds: float) -> None:  # pragma: no cover
         await self._init_backend()
         return await self._backend.sleep(seconds)