CHANGELOG.md

@@ -4,7 +4,13 @@ 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/).
 
-## 1.0.0 (November 6th, 2023)
+## 1.0.1 (November 3rd, 2023)
+
+- Fix pool timeout to account for the total time spent retrying. (#823)
+- Raise a neater RuntimeError when the correct async deps are not installed. (#826)
+- Add support for synchronous TLS-in-TLS streams. (#840)
+
+## 1.0.0 (October 6th, 2023)
 
 From version 1.0 our async support is now optional, as the package has minimal dependencies by default.
 

httpcore/__init__.py

@@ -130,7 +130,7 @@ def __init__(self, *args, **kwargs):  # type: ignore
     "WriteError",
 ]
 
-__version__ = "1.0.0"
+__version__ = "1.0.1"
 
 
 __locals = locals()

httpcore/_async/connection_pool.py

@@ -1,11 +1,12 @@
 import ssl
 import sys
+import time
 from types import TracebackType
 from typing import AsyncIterable, AsyncIterator, Iterable, List, Optional, Type
 
 from .._backends.auto import AutoBackend
 from .._backends.base import SOCKET_OPTION, AsyncNetworkBackend
-from .._exceptions import ConnectionNotAvailable, UnsupportedProtocol
+from .._exceptions import ConnectionNotAvailable, PoolTimeout, UnsupportedProtocol
 from .._models import Origin, Request, Response
 from .._synchronization import AsyncEvent, AsyncLock, AsyncShieldCancellation
 from .connection import AsyncHTTPConnection
@@ -220,15 +221,20 @@ async def handle_async_request(self, request: Request) -> Response:
             )
 
         status = RequestStatus(request)
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("pool", None)
+
+        if timeout is not None:
+            deadline = time.monotonic() + timeout
+        else:
+            deadline = float("inf")
 
         async with self._pool_lock:
             self._requests.append(status)
             await self._close_expired_connections()
             await self._attempt_to_acquire_connection(status)
 
         while True:
-            timeouts = request.extensions.get("timeout", {})
-            timeout = timeouts.get("pool", None)
             try:
                 connection = await status.wait_for_connection(timeout=timeout)
             except BaseException as exc:
@@ -263,6 +269,10 @@ async def handle_async_request(self, request: Request) -> Response:
             else:
                 break
 
+            timeout = deadline - time.monotonic()
+            if timeout < 0:
+                raise PoolTimeout  # pragma: nocover
+
         # When we return the response, we wrap the stream in a special class
         # that handles notifying the connection pool once the response
         # has been released.
@@ -316,6 +326,10 @@ async def aclose(self) -> None:
             self._requests = []
 
     async def __aenter__(self) -> "AsyncConnectionPool":
+        # Acquiring the pool lock here ensures that we have the
+        # correct dependencies installed as early as possible.
+        async with self._pool_lock:
+            pass
         return self
 
     async def __aexit__(

httpcore/_backends/sync.py

@@ -145,12 +145,6 @@ def start_tls(
         server_hostname: typing.Optional[str] = None,
         timeout: typing.Optional[float] = None,
     ) -> NetworkStream:
-        if isinstance(self._sock, ssl.SSLSocket):  # pragma: no cover
-            raise RuntimeError(
-                "Attempted to add a TLS layer on top of the existing "
-                "TLS stream, which is not supported by httpcore package"
-            )
-
         exc_map: ExceptionMapping = {
             socket.timeout: ConnectTimeout,
             OSError: ConnectError,

httpcore/_sync/connection_pool.py

@@ -1,11 +1,12 @@
 import ssl
 import sys
+import time
 from types import TracebackType
 from typing import Iterable, Iterator, Iterable, List, Optional, Type
 
 from .._backends.sync import SyncBackend
 from .._backends.base import SOCKET_OPTION, NetworkBackend
-from .._exceptions import ConnectionNotAvailable, UnsupportedProtocol
+from .._exceptions import ConnectionNotAvailable, PoolTimeout, UnsupportedProtocol
 from .._models import Origin, Request, Response
 from .._synchronization import Event, Lock, ShieldCancellation
 from .connection import HTTPConnection
@@ -220,15 +221,20 @@ def handle_request(self, request: Request) -> Response:
             )
 
         status = RequestStatus(request)
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("pool", None)
+
+        if timeout is not None:
+            deadline = time.monotonic() + timeout
+        else:
+            deadline = float("inf")
 
         with self._pool_lock:
             self._requests.append(status)
             self._close_expired_connections()
             self._attempt_to_acquire_connection(status)
 
         while True:
-            timeouts = request.extensions.get("timeout", {})
-            timeout = timeouts.get("pool", None)
             try:
                 connection = status.wait_for_connection(timeout=timeout)
             except BaseException as exc:
@@ -263,6 +269,10 @@ def handle_request(self, request: Request) -> Response:
             else:
                 break
 
+            timeout = deadline - time.monotonic()
+            if timeout < 0:
+                raise PoolTimeout  # pragma: nocover
+
         # When we return the response, we wrap the stream in a special class
         # that handles notifying the connection pool once the response
         # has been released.
@@ -316,6 +326,10 @@ def close(self) -> None:
             self._requests = []
 
     def __enter__(self) -> "ConnectionPool":
+        # Acquiring the pool lock here ensures that we have the
+        # correct dependencies installed as early as possible.
+        with self._pool_lock:
+            pass
         return self
 
     def __exit__(

httpcore/_synchronization.py

@@ -24,13 +24,23 @@ def current_async_library() -> str:
     try:
         import sniffio
     except ImportError:  # pragma: nocover
-        return "asyncio"
-
-    environment = sniffio.current_async_library()
+        environment = "asyncio"
+    else:
+        environment = sniffio.current_async_library()
 
     if environment not in ("asyncio", "trio"):  # pragma: nocover
         raise RuntimeError("Running under an unsupported async environment.")
 
+    if environment == "asyncio" and anyio is None:  # pragma: nocover
+        raise RuntimeError(
+            "Running with asyncio requires installation of 'httpcore[asyncio]'."
+        )
+
+    if environment == "trio" and trio is None:  # pragma: nocover
+        raise RuntimeError(
+            "Running with trio requires installation of 'httpcore[trio]'."
+        )
+
     return environment
 
 
@@ -45,16 +55,8 @@ def setup(self) -> None:
         """
         self._backend = current_async_library()
         if self._backend == "trio":
-            if trio is None:  # pragma: nocover
-                raise RuntimeError(
-                    "Running with trio requires installation of 'httpcore[trio]'."
-                )
             self._trio_lock = trio.Lock()
-        else:
-            if anyio is None:  # pragma: nocover
-                raise RuntimeError(
-                    "Running with asyncio requires installation of 'httpcore[asyncio]'."
-                )
+        elif self._backend == "asyncio":
             self._anyio_lock = anyio.Lock()
 
     async def __aenter__(self) -> "AsyncLock":
@@ -63,7 +65,7 @@ async def __aenter__(self) -> "AsyncLock":
 
         if self._backend == "trio":
             await self._trio_lock.acquire()
-        else:
+        elif self._backend == "asyncio":
             await self._anyio_lock.acquire()
 
         return self
@@ -76,7 +78,7 @@ async def __aexit__(
     ) -> None:
         if self._backend == "trio":
             self._trio_lock.release()
-        else:
+        elif self._backend == "asyncio":
             self._anyio_lock.release()
 
 
@@ -91,16 +93,8 @@ def setup(self) -> None:
         """
         self._backend = current_async_library()
         if self._backend == "trio":
-            if trio is None:  # pragma: nocover
-                raise RuntimeError(
-                    "Running with trio requires installation of 'httpcore[trio]'."
-                )
             self._trio_event = trio.Event()
-        else:
-            if anyio is None:  # pragma: nocover
-                raise RuntimeError(
-                    "Running with asyncio requires installation of 'httpcore[asyncio]'."
-                )
+        elif self._backend == "asyncio":
             self._anyio_event = anyio.Event()
 
     def set(self) -> None:
@@ -109,30 +103,20 @@ def set(self) -> None:
 
         if self._backend == "trio":
             self._trio_event.set()
-        else:
+        elif self._backend == "asyncio":
             self._anyio_event.set()
 
     async def wait(self, timeout: Optional[float] = None) -> None:
         if not self._backend:
             self.setup()
 
         if self._backend == "trio":
-            if trio is None:  # pragma: nocover
-                raise RuntimeError(
-                    "Running with trio requires installation of 'httpcore[trio]'."
-                )
-
             trio_exc_map: ExceptionMapping = {trio.TooSlowError: PoolTimeout}
             timeout_or_inf = float("inf") if timeout is None else timeout
             with map_exceptions(trio_exc_map):
                 with trio.fail_after(timeout_or_inf):
                     await self._trio_event.wait()
-        else:
-            if anyio is None:  # pragma: nocover
-                raise RuntimeError(
-                    "Running with asyncio requires installation of 'httpcore[asyncio]'."
-                )
-
+        elif self._backend == "asyncio":
             anyio_exc_map: ExceptionMapping = {TimeoutError: PoolTimeout}
             with map_exceptions(anyio_exc_map):
                 with anyio.fail_after(timeout):
@@ -151,20 +135,10 @@ def setup(self) -> None:
         """
         self._backend = current_async_library()
         if self._backend == "trio":
-            if trio is None:  # pragma: nocover
-                raise RuntimeError(
-                    "Running with trio requires installation of 'httpcore[trio]'."
-                )
-
             self._trio_semaphore = trio.Semaphore(
                 initial_value=self._bound, max_value=self._bound
             )
-        else:
-            if anyio is None:  # pragma: nocover
-                raise RuntimeError(
-                    "Running with asyncio requires installation of 'httpcore[asyncio]'."
-                )
-
+        elif self._backend == "asyncio":
             self._anyio_semaphore = anyio.Semaphore(
                 initial_value=self._bound, max_value=self._bound
             )
@@ -175,13 +149,13 @@ async def acquire(self) -> None:
 
         if self._backend == "trio":
             await self._trio_semaphore.acquire()
-        else:
+        elif self._backend == "asyncio":
             await self._anyio_semaphore.acquire()
 
     async def release(self) -> None:
         if self._backend == "trio":
             self._trio_semaphore.release()
-        else:
+        elif self._backend == "asyncio":
             self._anyio_semaphore.release()
 
 
@@ -201,24 +175,14 @@ def __init__(self) -> None:
         self._backend = current_async_library()
 
         if self._backend == "trio":
-            if trio is None:  # pragma: nocover
-                raise RuntimeError(
-                    "Running with trio requires installation of 'httpcore[trio]'."
-                )
-
             self._trio_shield = trio.CancelScope(shield=True)
-        else:
-            if anyio is None:  # pragma: nocover
-                raise RuntimeError(
-                    "Running with asyncio requires installation of 'httpcore[asyncio]'."
-                )
-
+        elif self._backend == "asyncio":
             self._anyio_shield = anyio.CancelScope(shield=True)
 
     def __enter__(self) -> "AsyncShieldCancellation":
         if self._backend == "trio":
             self._trio_shield.__enter__()
-        else:
+        elif self._backend == "asyncio":
             self._anyio_shield.__enter__()
         return self
 
@@ -230,7 +194,7 @@ def __exit__(
     ) -> None:
         if self._backend == "trio":
             self._trio_shield.__exit__(exc_type, exc_value, traceback)
-        else:
+        elif self._backend == "asyncio":
             self._anyio_shield.__exit__(exc_type, exc_value, traceback)
 
 

requirements.txt

@@ -3,8 +3,8 @@
 # Docs
 mkdocs==1.5.3
 mkdocs-autorefs==0.5.0
-mkdocs-material==9.4.2
-mkdocs-material-extensions==1.2
+mkdocs-material==9.4.7
+mkdocs-material-extensions==1.3
 mkdocstrings[python-legacy]==0.22.0
 jinja2==3.1.2
 
@@ -13,13 +13,13 @@ build==1.0.3
 twine
 
 # Tests & Linting
-black==23.7.0
+black==23.10.1
 coverage[toml]==7.3.0
 ruff==0.0.291
 mypy==1.5.1
-trio-typing==0.8.0
+trio-typing==0.9.0
 types-certifi==2021.10.8.3
-pytest==7.4.0
+pytest==7.4.3
 pytest-httpbin==2.0.0
 pytest-trio==0.7.0
 werkzeug<2.1  # See: https://github.com/postmanlabs/httpbin/issues/673