httpcore2 2.0.0__tar.gz → 2.1.0__tar.gz

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

@@ -4,9 +4,40 @@ 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/).
 
-## Unreleased
+## 2.1.0 (May 15th, 2026)
 
-- Fix `max_keepalive_connections` not being properly handled. (#1000)
+### Removed
+
+* Drop support for Python 3.8 and 3.9. ([#208](https://github.com/pydantic/httpx2/pull/208))
+
+### Added
+
+* Add support for Python 3.14. ([#208](https://github.com/pydantic/httpx2/pull/208))
+* Bundle `LICENSE.md` in the sdist. ([#938](https://github.com/pydantic/httpx2/pull/938))
+
+### Fixed
+
+* Wait for positive flow-control credit when a peer's `SETTINGS` frame drives a stream's send window negative, instead of letting h2 raise `LocalProtocolError`. ([#935](https://github.com/pydantic/httpx2/pull/935))
+
+## 2.0.0
+
+Official first release of `httpcore2`. No changes since `2.0.0b1`.
+
+## 2.0.0b1
+
+First release of `httpcore2`, a fork of [`httpcore`](https://github.com/encode/httpcore) maintained by Pydantic. Forked from `httpcore 1.0.9`.
+
+### Breaking changes
+
+* **Renamed package**: `httpcore` -> `httpcore2`. `import httpcore` becomes `import httpcore2`. No other public API changed.
+
+### Fixed
+
+* Fix `max_keepalive_connections` not being properly handled. (Inherited from upstream PR [encode/httpcore#1000](https://github.com/encode/httpcore/pull/1000).)
+
+---
+
+Historical entries below are from upstream `encode/httpcore`.
 
 ## Version 1.0.9 (April 24th, 2025)
 

{httpcore2-2.0.0 → httpcore2-2.1.0}/LICENSE.md

@@ -1,3 +1,4 @@
+Copyright © 2026 to present Pydantic Services Inc. and individual contributors.
 Copyright © 2020, [Encode OSS Ltd](https://www.encode.io/).
 All rights reserved.
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: httpcore2
-Version: 2.0.0
+Version: 2.1.0
 Summary: A minimal low-level HTTP client.
 Project-URL: Documentation, https://www.encode.io/httpcore
 Project-URL: Homepage, https://www.encode.io/httpcore/
@@ -18,13 +18,13 @@ Classifier: License :: OSI Approved :: BSD License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Internet :: WWW/HTTP
-Requires-Python: >=3.8
+Requires-Python: >=3.10
 Requires-Dist: certifi
 Requires-Dist: h11>=0.16
 Provides-Extra: asyncio
@@ -154,9 +154,40 @@ 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/).
 
-## Unreleased
+## 2.1.0 (May 15th, 2026)
 
-- Fix `max_keepalive_connections` not being properly handled. (#1000)
+### Removed
+
+* Drop support for Python 3.8 and 3.9. ([#208](https://github.com/pydantic/httpx2/pull/208))
+
+### Added
+
+* Add support for Python 3.14. ([#208](https://github.com/pydantic/httpx2/pull/208))
+* Bundle `LICENSE.md` in the sdist. ([#938](https://github.com/pydantic/httpx2/pull/938))
+
+### Fixed
+
+* Wait for positive flow-control credit when a peer's `SETTINGS` frame drives a stream's send window negative, instead of letting h2 raise `LocalProtocolError`. ([#935](https://github.com/pydantic/httpx2/pull/935))
+
+## 2.0.0
+
+Official first release of `httpcore2`. No changes since `2.0.0b1`.
+
+## 2.0.0b1
+
+First release of `httpcore2`, a fork of [`httpcore`](https://github.com/encode/httpcore) maintained by Pydantic. Forked from `httpcore 1.0.9`.
+
+### Breaking changes
+
+* **Renamed package**: `httpcore` -> `httpcore2`. `import httpcore` becomes `import httpcore2`. No other public API changed.
+
+### Fixed
+
+* Fix `max_keepalive_connections` not being properly handled. (Inherited from upstream PR [encode/httpcore#1000](https://github.com/encode/httpcore/pull/1000).)
+
+---
+
+Historical entries below are from upstream `encode/httpcore`.
 
 ## Version 1.0.9 (April 24th, 2025)
 

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

@@ -55,9 +55,7 @@ except ImportError:  # pragma: nocover
 
     class AnyIOBackend:  # type: ignore
         def __init__(self, *args, **kwargs):  # type: ignore
-            msg = (
-                "Attempted to use 'httpcore2.AnyIOBackend' but 'anyio' is not installed."
-            )
+            msg = "Attempted to use 'httpcore2.AnyIOBackend' but 'anyio' is not installed."
             raise RuntimeError(msg)
 
 

{httpcore2-2.0.0 → httpcore2-2.1.0}/httpcore2/_async/connection.py

@@ -58,9 +58,7 @@ class AsyncHTTPConnection(AsyncConnectionInterface):
         self._local_address = local_address
         self._uds = uds
 
-        self._network_backend: AsyncNetworkBackend = (
-            AutoBackend() if network_backend is None else network_backend
-        )
+        self._network_backend: AsyncNetworkBackend = AutoBackend() if network_backend is None else network_backend
         self._connection: AsyncConnectionInterface | None = None
         self._connect_failed: bool = False
         self._request_lock = AsyncLock()
@@ -68,9 +66,7 @@ class AsyncHTTPConnection(AsyncConnectionInterface):
 
     async def handle_async_request(self, request: Request) -> Response:
         if not self.can_handle_request(request.url.origin):
-            raise RuntimeError(
-                f"Attempted to send request to {request.url.origin} on connection to {self._origin}"
-            )
+            raise RuntimeError(f"Attempted to send request to {request.url.origin} on connection to {self._origin}")
 
         try:
             async with self._request_lock:
@@ -78,10 +74,7 @@ class AsyncHTTPConnection(AsyncConnectionInterface):
                     stream = await self._connect(request)
 
                     ssl_object = stream.get_extra_info("ssl_object")
-                    http2_negotiated = (
-                        ssl_object is not None
-                        and ssl_object.selected_alpn_protocol() == "h2"
-                    )
+                    http2_negotiated = ssl_object is not None and ssl_object.selected_alpn_protocol() == "h2"
                     if http2_negotiated or (self._http2 and not self._http1):
                         from .http2 import AsyncHTTP2Connection
 
@@ -129,27 +122,18 @@ class AsyncHTTPConnection(AsyncConnectionInterface):
                         "timeout": timeout,
                         "socket_options": self._socket_options,
                     }
-                    async with Trace(
-                        "connect_unix_socket", logger, request, kwargs
-                    ) as trace:
-                        stream = await self._network_backend.connect_unix_socket(
-                            **kwargs
-                        )
+                    async with Trace("connect_unix_socket", logger, request, kwargs) as trace:
+                        stream = await self._network_backend.connect_unix_socket(**kwargs)
                         trace.return_value = stream
 
                 if self._origin.scheme in (b"https", b"wss"):
-                    ssl_context = (
-                        default_ssl_context()
-                        if self._ssl_context is None
-                        else self._ssl_context
-                    )
+                    ssl_context = default_ssl_context() if self._ssl_context is None else self._ssl_context
                     alpn_protocols = ["http/1.1", "h2"] if self._http2 else ["http/1.1"]
                     ssl_context.set_alpn_protocols(alpn_protocols)
 
                     kwargs = {
                         "ssl_context": ssl_context,
-                        "server_hostname": sni_hostname
-                        or self._origin.host.decode("ascii"),
+                        "server_hostname": sni_hostname or self._origin.host.decode("ascii"),
                         "timeout": timeout,
                     }
                     async with Trace("start_tls", logger, request, kwargs) as trace:
@@ -177,11 +161,7 @@ class AsyncHTTPConnection(AsyncConnectionInterface):
             # 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.
-            return (
-                self._http2
-                and (self._origin.scheme == b"https" or not self._http1)
-                and not self._connect_failed
-            )
+            return self._http2 and (self._origin.scheme == b"https" or not self._http1) and not self._connect_failed
         return self._connection.is_available()
 
     def has_expired(self) -> bool:

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

@@ -30,9 +30,7 @@ class AsyncPoolRequest:
         self.connection = None
         self._connection_acquired = AsyncEvent()
 
-    async def wait_for_connection(
-        self, timeout: float | None = None
-    ) -> AsyncConnectionInterface:
+    async def wait_for_connection(self, timeout: float | None = None) -> AsyncConnectionInterface:
         if self.connection is None:
             await self._connection_acquired.wait(timeout=timeout)
         assert self.connection is not None
@@ -93,17 +91,11 @@ class AsyncConnectionPool(AsyncRequestInterface):
         """
         self._ssl_context = ssl_context
         self._proxy = proxy
-        self._max_connections = (
-            sys.maxsize if max_connections is None else max_connections
-        )
+        self._max_connections = sys.maxsize if max_connections is None else max_connections
         self._max_keepalive_connections = (
-            sys.maxsize
-            if max_keepalive_connections is None
-            else max_keepalive_connections
-        )
-        self._max_keepalive_connections = min(
-            self._max_connections, self._max_keepalive_connections
+            sys.maxsize if max_keepalive_connections is None else max_keepalive_connections
         )
+        self._max_keepalive_connections = min(self._max_connections, self._max_keepalive_connections)
 
         self._keepalive_expiry = keepalive_expiry
         self._http1 = http1
@@ -112,9 +104,7 @@ class AsyncConnectionPool(AsyncRequestInterface):
         self._local_address = local_address
         self._uds = uds
 
-        self._network_backend = (
-            AutoBackend() if network_backend is None else network_backend
-        )
+        self._network_backend = AutoBackend() if network_backend is None else network_backend
         self._socket_options = socket_options
 
         # The mutable state on a connection pool is the queue of incoming requests,
@@ -206,13 +196,9 @@ class AsyncConnectionPool(AsyncRequestInterface):
         """
         scheme = request.url.scheme.decode()
         if scheme == "":
-            raise UnsupportedProtocol(
-                "Request URL is missing an 'http://' or 'https://' protocol."
-            )
+            raise UnsupportedProtocol("Request URL is missing an 'http://' or 'https://' protocol.")
         if scheme not in ("http", "https", "ws", "wss"):
-            raise UnsupportedProtocol(
-                f"Request URL has an unsupported protocol '{scheme}://'."
-            )
+            raise UnsupportedProtocol(f"Request URL has an unsupported protocol '{scheme}://'.")
 
         timeouts = request.extensions.get("timeout", {})
         timeout = timeouts.get("pool", None)
@@ -235,9 +221,7 @@ class AsyncConnectionPool(AsyncRequestInterface):
 
                 try:
                     # Send the request on the assigned connection.
-                    response = await connection.handle_async_request(
-                        pool_request.request
-                    )
+                    response = await connection.handle_async_request(pool_request.request)
                 except ConnectionNotAvailable:
                     # In some cases a connection may initially be available to
                     # handle a request, but then become unavailable.
@@ -263,9 +247,7 @@ class AsyncConnectionPool(AsyncRequestInterface):
         return Response(
             status=response.status,
             headers=response.headers,
-            content=PoolByteStream(
-                stream=response.stream, pool_request=pool_request, pool=self
-            ),
+            content=PoolByteStream(stream=response.stream, pool_request=pool_request, pool=self),
             extensions=response.extensions,
         )
 
@@ -293,8 +275,7 @@ class AsyncConnectionPool(AsyncRequestInterface):
                 closing_connections.append(connection)
             elif (
                 connection.is_idle()
-                and sum(connection.is_idle() for connection in self._connections)
-                > self._max_keepalive_connections
+                and sum(connection.is_idle() for connection in self._connections) > self._max_keepalive_connections
             ):
                 # log: "closing idle connection"
                 self._connections.remove(connection)
@@ -309,9 +290,7 @@ class AsyncConnectionPool(AsyncRequestInterface):
                 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()
-            ]
+            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:
             #
@@ -369,21 +348,15 @@ class AsyncConnectionPool(AsyncRequestInterface):
         class_name = self.__class__.__name__
         with self._optional_thread_lock:
             request_is_queued = [request.is_queued() for request in self._requests]
-            connection_is_idle = [
-                connection.is_idle() for connection in self._connections
-            ]
+            connection_is_idle = [connection.is_idle() for connection in self._connections]
 
             num_active_requests = request_is_queued.count(False)
             num_queued_requests = request_is_queued.count(True)
             num_active_connections = connection_is_idle.count(False)
             num_idle_connections = connection_is_idle.count(True)
 
-        requests_info = (
-            f"Requests: {num_active_requests} active, {num_queued_requests} queued"
-        )
-        connection_info = (
-            f"Connections: {num_active_connections} active, {num_idle_connections} idle"
-        )
+        requests_info = f"Requests: {num_active_requests} active, {num_queued_requests} queued"
+        connection_info = f"Connections: {num_active_connections} active, {num_idle_connections} idle"
 
         return f"<{class_name} [{requests_info} | {connection_info}]>"
 

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

@@ -66,10 +66,7 @@ class AsyncHTTP11Connection(AsyncConnectionInterface):
 
     async def handle_async_request(self, request: Request) -> Response:
         if not self.can_handle_request(request.url.origin):
-            raise RuntimeError(
-                f"Attempted to send request to {request.url.origin} on connection "
-                f"to {self._origin}"
-            )
+            raise RuntimeError(f"Attempted to send request to {request.url.origin} on connection to {self._origin}")
 
         async with self._state_lock:
             if self._state in (HTTPConnectionState.NEW, HTTPConnectionState.IDLE):
@@ -82,9 +79,7 @@ class AsyncHTTP11Connection(AsyncConnectionInterface):
         try:
             kwargs = {"request": request}
             try:
-                async with Trace(
-                    "send_request_headers", logger, request, kwargs
-                ) as trace:
+                async with Trace("send_request_headers", logger, request, kwargs) as trace:
                     await self._send_request_headers(**kwargs)
                 async with Trace("send_request_body", logger, request, kwargs) as trace:
                     await self._send_request_body(**kwargs)
@@ -96,9 +91,7 @@ class AsyncHTTP11Connection(AsyncConnectionInterface):
                 # error response.
                 pass
 
-            async with Trace(
-                "receive_response_headers", logger, request, kwargs
-            ) as trace:
+            async with Trace("receive_response_headers", logger, request, kwargs) as trace:
                 (
                     http_version,
                     status,
@@ -116,9 +109,7 @@ class AsyncHTTP11Connection(AsyncConnectionInterface):
             network_stream = self._network_stream
 
             # CONNECT or Upgrade request
-            if (status == 101) or (
-                (request.method == b"CONNECT") and (200 <= status < 300)
-            ):
+            if (status == 101) or ((request.method == b"CONNECT") and (200 <= status < 300)):
                 network_stream = AsyncHTTP11UpgradeStream(network_stream, trailing_data)
 
             return Response(
@@ -180,10 +171,7 @@ class AsyncHTTP11Connection(AsyncConnectionInterface):
             event = await self._receive_event(timeout=timeout)
             if isinstance(event, h11.Response):
                 break
-            if (
-                isinstance(event, h11.InformationalResponse)
-                and event.status_code == 101
-            ):
+            if isinstance(event, h11.InformationalResponse) and event.status_code == 101:
                 break
 
         http_version = b"HTTP/" + event.http_version
@@ -207,17 +195,13 @@ class AsyncHTTP11Connection(AsyncConnectionInterface):
             elif isinstance(event, (h11.EndOfMessage, h11.PAUSED)):
                 break
 
-    async def _receive_event(
-        self, timeout: float | None = None
-    ) -> h11.Event | type[h11.PAUSED]:
+    async def _receive_event(self, timeout: float | None = None) -> h11.Event | type[h11.PAUSED]:
         while True:
             with map_exceptions({h11.RemoteProtocolError: RemoteProtocolError}):
                 event = self._h11_state.next_event()
 
             if event is h11.NEED_DATA:
-                data = await self._network_stream.read(
-                    self.READ_NUM_BYTES, timeout=timeout
-                )
+                data = await self._network_stream.read(self.READ_NUM_BYTES, timeout=timeout)
 
                 # If we feed this case through h11 we'll raise an exception like:
                 #
@@ -238,10 +222,7 @@ class AsyncHTTP11Connection(AsyncConnectionInterface):
 
     async def _response_closed(self) -> None:
         async with self._state_lock:
-            if (
-                self._h11_state.our_state is h11.DONE
-                and self._h11_state.their_state is h11.DONE
-            ):
+            if self._h11_state.our_state is h11.DONE and self._h11_state.their_state is h11.DONE:
                 self._state = HTTPConnectionState.IDLE
                 self._h11_state.start_next_cycle()
                 if self._keepalive_expiry is not None:
@@ -279,9 +260,8 @@ class AsyncHTTP11Connection(AsyncConnectionInterface):
         # If the HTTP connection is idle but the socket is readable, then the
         # only valid state is that the socket is about to return b"", indicating
         # a server-initiated disconnect.
-        server_disconnected = (
-            self._state == HTTPConnectionState.IDLE
-            and self._network_stream.get_extra_info("is_readable")
+        server_disconnected = self._state == HTTPConnectionState.IDLE and self._network_stream.get_extra_info(
+            "is_readable"
         )
 
         return keepalive_expired or server_disconnected
@@ -294,18 +274,12 @@ class AsyncHTTP11Connection(AsyncConnectionInterface):
 
     def info(self) -> str:
         origin = str(self._origin)
-        return (
-            f"{origin!r}, HTTP/1.1, {self._state.name}, "
-            f"Request Count: {self._request_count}"
-        )
+        return f"{origin!r}, HTTP/1.1, {self._state.name}, Request Count: {self._request_count}"
 
     def __repr__(self) -> str:
         class_name = self.__class__.__name__
         origin = str(self._origin)
-        return (
-            f"<{class_name} [{origin!r}, {self._state.name}, "
-            f"Request Count: {self._request_count}]>"
-        )
+        return f"<{class_name} [{origin!r}, {self._state.name}, Request Count: {self._request_count}]>"
 
     # These context managers are not used in the standard flow, but are
     # useful for testing or working with connection instances directly.
@@ -332,9 +306,7 @@ class HTTP11ConnectionByteStream:
         kwargs = {"request": self._request}
         try:
             async with Trace("receive_response_body", logger, self._request, kwargs):
-                async with safe_async_iterate(
-                    self._connection._receive_response_body(**kwargs)
-                ) as iterator:
+                async with safe_async_iterate(self._connection._receive_response_body(**kwargs)) as iterator:
                     async for chunk in iterator:
                         yield chunk
         except BaseException as exc: