httpcore2 2.2.0__tar.gz → 2.4.0__tar.gz

{httpcore2-2.2.0 → httpcore2-2.4.0}/CHANGELOG.md

@@ -4,6 +4,23 @@ 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.4.0 (June 11th, 2026)
+
+### Fixed
+
+* Move HTTP/2 stream events cleanup inside `_state_lock`. ([#1013](https://github.com/pydantic/httpx2/pull/1013))
+* Release the HTTP/2 semaphore permit on `NoAvailableStreamIDError`. ([#1012](https://github.com/pydantic/httpx2/pull/1012))
+* Use `RLock` instead of `Lock` to prevent a thread deadlock. ([#1008](https://github.com/pydantic/httpx2/pull/1008))
+
+## 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`.
@@ -64,7 +81,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)
 
@@ -142,7 +159,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)
 
@@ -200,7 +217,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)
@@ -265,7 +282,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.2.0 → httpcore2-2.4.0}/PKG-INFO

@@ -1,16 +1,17 @@
 Metadata-Version: 2.4
 Name: httpcore2
-Version: 2.2.0
+Version: 2.4.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
 License-File: LICENSE.md
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Web Environment
+Classifier: Framework :: AnyIO
 Classifier: Framework :: AsyncIO
 Classifier: Framework :: Trio
 Classifier: Intended Audience :: Developers
@@ -25,10 +26,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 +63,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 +125,7 @@ The motivation for `httpcore` is:
 The `httpcore` package has the following dependencies...
 
 * `h11`
-* `certifi`
+* `truststore`
 
 And the following optional extras...
 
@@ -154,6 +151,23 @@ 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.4.0 (June 11th, 2026)
+
+### Fixed
+
+* Move HTTP/2 stream events cleanup inside `_state_lock`. ([#1013](https://github.com/pydantic/httpx2/pull/1013))
+* Release the HTTP/2 semaphore permit on `NoAvailableStreamIDError`. ([#1012](https://github.com/pydantic/httpx2/pull/1012))
+* Use `RLock` instead of `Lock` to prevent a thread deadlock. ([#1008](https://github.com/pydantic/httpx2/pull/1008))
+
+## 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`.
@@ -214,7 +228,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)
 
@@ -292,7 +306,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)
 
@@ -350,7 +364,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)
@@ -415,7 +429,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.2.0 → httpcore2-2.4.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.2.0 → httpcore2-2.4.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.2.0 → httpcore2-2.4.0}/httpcore2/_api.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import contextlib
 import typing
+from collections.abc import Generator
 
 from ._models import URL, Extensions, HeaderTypes, Response
 from ._sync.connection_pool import ConnectionPool
@@ -55,7 +56,7 @@ def stream(
     headers: HeaderTypes = None,
     content: bytes | typing.Iterator[bytes] | None = None,
     extensions: Extensions | None = None,
-) -> typing.Iterator[Response]:
+) -> Generator[Response]:
     """
     Sends an HTTP request, returning the response within a content manager.
 

{httpcore2-2.2.0 → httpcore2-2.4.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.2.0 → httpcore2-2.4.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.2.0 → httpcore2-2.4.0}/httpcore2/_async/http11.py

@@ -28,11 +28,7 @@ logger = logging.getLogger("httpcore2.http11")
 
 
 # A subset of `h11.Event` types supported by `_send_event`
-H11SendEvent = typing.Union[
-    h11.Request,
-    h11.Data,
-    h11.EndOfMessage,
-]
+H11SendEvent = h11.Request | h11.Data | h11.EndOfMessage
 
 
 class HTTPConnectionState(enum.IntEnum):
@@ -85,9 +81,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.2.0 → httpcore2-2.4.0}/httpcore2/_async/http2.py

@@ -14,11 +14,7 @@ import h2.exceptions
 import h2.settings
 
 from .._backends.base import AsyncNetworkStream
-from .._exceptions import (
-    ConnectionNotAvailable,
-    LocalProtocolError,
-    RemoteProtocolError,
-)
+from .._exceptions import ConnectionNotAvailable, LocalProtocolError, RemoteProtocolError
 from .._models import Origin, Request, Response
 from .._synchronization import AsyncLock, AsyncSemaphore, AsyncShieldCancellation
 from .._trace import Trace
@@ -29,7 +25,7 @@ logger = logging.getLogger("httpcore2.http2")
 
 
 def has_body_headers(request: Request) -> bool:
-    return any(k.lower() == b"content-length" or k.lower() == b"transfer-encoding" for k, v in request.headers)
+    return any(k.lower() == b"content-length" or k.lower() == b"transfer-encoding" for k, _v in request.headers)
 
 
 class HTTPConnectionState(enum.IntEnum):
@@ -120,9 +116,10 @@ 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
+            await self._max_streams_semaphore.release()
             raise ConnectionNotAvailable()
 
         try:
@@ -161,11 +158,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
 
@@ -275,7 +272,7 @@ class AsyncHTTP2Connection(AsyncConnectionInterface):
                 break
 
         status_code = 200
-        headers = []
+        headers: list[tuple[bytes, bytes]] = []
         assert event.headers is not None
         for k, v in event.headers:
             if k == b":status":
@@ -377,8 +374,8 @@ class AsyncHTTP2Connection(AsyncConnectionInterface):
 
     async def _response_closed(self, stream_id: int) -> None:
         await self._max_streams_semaphore.release()
-        del self._events[stream_id]
         async with self._state_lock:
+            del self._events[stream_id]
             if self._connection_terminated and not self._events:
                 await self.aclose()
 
@@ -387,7 +384,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 +401,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 +432,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.2.0 → httpcore2-2.4.0}/httpcore2/_async/http_proxy.py

@@ -24,8 +24,8 @@ from .connection_pool import AsyncConnectionPool
 from .http11 import AsyncHTTP11Connection
 from .interfaces import AsyncConnectionInterface
 
-ByteOrStr = typing.Union[bytes, str]
-HeadersAsSequence = typing.Sequence[typing.Tuple[ByteOrStr, ByteOrStr]]
+ByteOrStr = bytes | str
+HeadersAsSequence = typing.Sequence[tuple[ByteOrStr, ByteOrStr]]
 HeadersAsMapping = typing.Mapping[ByteOrStr, ByteOrStr]
 
 
@@ -42,12 +42,12 @@ def merge_headers(
     """
     default_headers = [] if default_headers is None else list(default_headers)
     override_headers = [] if override_headers is None else list(override_headers)
-    has_override = set(key.lower() for key, value in override_headers)
+    has_override = set(key.lower() for key, _value in override_headers)
     default_headers = [(key, value) for key, value in default_headers if key.lower() not in has_override]
     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.
     """
@@ -278,7 +278,7 @@ class AsyncTunnelHTTPConnection(AsyncConnectionInterface):
                 if connect_response.status < 200 or connect_response.status > 299:
                     reason_bytes = connect_response.extensions.get("reason_phrase", b"")
                     reason_str = reason_bytes.decode("ascii", errors="ignore")
-                    msg = "%d %s" % (connect_response.status, reason_str)
+                    msg = f"{connect_response.status} {reason_str}"
                     await self._connection.aclose()
                     raise ProxyError(msg)
 

{httpcore2-2.2.0 → httpcore2-2.4.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.2.0 → httpcore2-2.4.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()