Handle async cancelled error explicitly

httpcore/_async/connection_pool.py

@@ -7,7 +7,12 @@
 from .._backends.base import SOCKET_OPTION, AsyncNetworkBackend
 from .._exceptions import ConnectionNotAvailable, UnsupportedProtocol
 from .._models import Origin, Request, Response
-from .._synchronization import AsyncEvent, AsyncLock, AsyncShieldCancellation
+from .._synchronization import (
+    EXCEPTION_OR_CANCELLED,
+    AsyncEvent,
+    AsyncLock,
+    AsyncShieldCancellation,
+)
 from .connection import AsyncHTTPConnection
 from .interfaces import AsyncConnectionInterface, AsyncRequestInterface
 
@@ -231,7 +236,7 @@ async def handle_async_request(self, request: Request) -> Response:
             timeout = timeouts.get("pool", None)
             try:
                 connection = await status.wait_for_connection(timeout=timeout)
-            except BaseException as exc:
+            except EXCEPTION_OR_CANCELLED as exc:
                 # If we timeout here, or if the task is cancelled, then make
                 # sure to remove the request from the queue before bubbling
                 # up the exception.
@@ -256,7 +261,7 @@ async def handle_async_request(self, request: Request) -> Response:
                     # status so that the request becomes queued again.
                     status.unset_connection()
                     await self._attempt_to_acquire_connection(status)
-            except BaseException as exc:
+            except EXCEPTION_OR_CANCELLED as exc:
                 with AsyncShieldCancellation():
                     await self.response_closed(status)
                 raise exc

httpcore/_async/http11.py

@@ -24,7 +24,11 @@
     map_exceptions,
 )
 from .._models import Origin, Request, Response
-from .._synchronization import AsyncLock, AsyncShieldCancellation
+from .._synchronization import (
+    EXCEPTION_OR_CANCELLED,
+    AsyncLock,
+    AsyncShieldCancellation,
+)
 from .._trace import Trace
 from .interfaces import AsyncConnectionInterface
 
@@ -126,7 +130,7 @@ async def handle_async_request(self, request: Request) -> Response:
                     "network_stream": self._network_stream,
                 },
             )
-        except BaseException as exc:
+        except EXCEPTION_OR_CANCELLED as exc:
             with AsyncShieldCancellation():
                 async with Trace("response_closed", logger, request) as trace:
                     await self._response_closed()
@@ -328,7 +332,7 @@ async def __aiter__(self) -> AsyncIterator[bytes]:
             async with Trace("receive_response_body", logger, self._request, kwargs):
                 async for chunk in self._connection._receive_response_body(**kwargs):
                     yield chunk
-        except BaseException as exc:
+        except EXCEPTION_OR_CANCELLED as exc:
             # If we get an exception while streaming the response,
             # we want to close the response (and possibly the connection)
             # before raising that exception.

httpcore/_async/http2.py

@@ -17,7 +17,12 @@
     RemoteProtocolError,
 )
 from .._models import Origin, Request, Response
-from .._synchronization import AsyncLock, AsyncSemaphore, AsyncShieldCancellation
+from .._synchronization import (
+    EXCEPTION_OR_CANCELLED,
+    AsyncLock,
+    AsyncSemaphore,
+    AsyncShieldCancellation,
+)
 from .._trace import Trace
 from .interfaces import AsyncConnectionInterface
 
@@ -107,7 +112,7 @@ async def handle_async_request(self, request: Request) -> Response:
                     kwargs = {"request": request}
                     async with Trace("send_connection_init", logger, request, kwargs):
                         await self._send_connection_init(**kwargs)
-                except BaseException as exc:
+                except EXCEPTION_OR_CANCELLED as exc:
                     with AsyncShieldCancellation():
                         await self.aclose()
                     raise exc
@@ -160,7 +165,7 @@ async def handle_async_request(self, request: Request) -> Response:
                     "stream_id": stream_id,
                 },
             )
-        except BaseException as exc:  # noqa: PIE786
+        except EXCEPTION_OR_CANCELLED as exc:  # noqa: PIE786
             with AsyncShieldCancellation():
                 kwargs = {"stream_id": stream_id}
                 async with Trace("response_closed", logger, request, kwargs):
@@ -573,7 +578,7 @@ async def __aiter__(self) -> typing.AsyncIterator[bytes]:
                     request=self._request, stream_id=self._stream_id
                 ):
                     yield chunk
-        except BaseException as exc:
+        except EXCEPTION_OR_CANCELLED as exc:
             # If we get an exception while streaming the response,
             # we want to close the response (and possibly the connection)
             # before raising that exception.

httpcore/_sync/connection_pool.py

@@ -7,7 +7,12 @@
 from .._backends.base import SOCKET_OPTION, NetworkBackend
 from .._exceptions import ConnectionNotAvailable, UnsupportedProtocol
 from .._models import Origin, Request, Response
-from .._synchronization import Event, Lock, ShieldCancellation
+from .._synchronization import (
+    EXCEPTION_OR_CANCELLED,
+    Event,
+    Lock,
+    ShieldCancellation,
+)
 from .connection import HTTPConnection
 from .interfaces import ConnectionInterface, RequestInterface
 
@@ -231,7 +236,7 @@ def handle_request(self, request: Request) -> Response:
             timeout = timeouts.get("pool", None)
             try:
                 connection = status.wait_for_connection(timeout=timeout)
-            except BaseException as exc:
+            except EXCEPTION_OR_CANCELLED as exc:
                 # If we timeout here, or if the task is cancelled, then make
                 # sure to remove the request from the queue before bubbling
                 # up the exception.
@@ -256,7 +261,7 @@ def handle_request(self, request: Request) -> Response:
                     # status so that the request becomes queued again.
                     status.unset_connection()
                     self._attempt_to_acquire_connection(status)
-            except BaseException as exc:
+            except EXCEPTION_OR_CANCELLED as exc:
                 with ShieldCancellation():
                     self.response_closed(status)
                 raise exc

httpcore/_sync/http11.py

@@ -24,7 +24,11 @@
     map_exceptions,
 )
 from .._models import Origin, Request, Response
-from .._synchronization import Lock, ShieldCancellation
+from .._synchronization import (
+    EXCEPTION_OR_CANCELLED,
+    Lock,
+    ShieldCancellation,
+)
 from .._trace import Trace
 from .interfaces import ConnectionInterface
 
@@ -126,7 +130,7 @@ def handle_request(self, request: Request) -> Response:
                     "network_stream": self._network_stream,
                 },
             )
-        except BaseException as exc:
+        except EXCEPTION_OR_CANCELLED as exc:
             with ShieldCancellation():
                 with Trace("response_closed", logger, request) as trace:
                     self._response_closed()
@@ -328,7 +332,7 @@ def __iter__(self) -> Iterator[bytes]:
             with Trace("receive_response_body", logger, self._request, kwargs):
                 for chunk in self._connection._receive_response_body(**kwargs):
                     yield chunk
-        except BaseException as exc:
+        except EXCEPTION_OR_CANCELLED as exc:
             # If we get an exception while streaming the response,
             # we want to close the response (and possibly the connection)
             # before raising that exception.

httpcore/_sync/http2.py

@@ -17,7 +17,12 @@
     RemoteProtocolError,
 )
 from .._models import Origin, Request, Response
-from .._synchronization import Lock, Semaphore, ShieldCancellation
+from .._synchronization import (
+    EXCEPTION_OR_CANCELLED,
+    Lock,
+    Semaphore,
+    ShieldCancellation,
+)
 from .._trace import Trace
 from .interfaces import ConnectionInterface
 
@@ -107,7 +112,7 @@ def handle_request(self, request: Request) -> Response:
                     kwargs = {"request": request}
                     with Trace("send_connection_init", logger, request, kwargs):
                         self._send_connection_init(**kwargs)
-                except BaseException as exc:
+                except EXCEPTION_OR_CANCELLED as exc:
                     with ShieldCancellation():
                         self.close()
                     raise exc
@@ -160,7 +165,7 @@ def handle_request(self, request: Request) -> Response:
                     "stream_id": stream_id,
                 },
             )
-        except BaseException as exc:  # noqa: PIE786
+        except EXCEPTION_OR_CANCELLED as exc:  # noqa: PIE786
             with ShieldCancellation():
                 kwargs = {"stream_id": stream_id}
                 with Trace("response_closed", logger, request, kwargs):
@@ -573,7 +578,7 @@ def __iter__(self) -> typing.Iterator[bytes]:
                     request=self._request, stream_id=self._stream_id
                 ):
                     yield chunk
-        except BaseException as exc:
+        except EXCEPTION_OR_CANCELLED as exc:
             # If we get an exception while streaming the response,
             # we want to close the response (and possibly the connection)
             # before raising that exception.

httpcore/_synchronization.py

@@ -1,21 +1,37 @@
 import threading
 from types import TracebackType
-from typing import Optional, Type
+from typing import Optional, Tuple, Type, Union
 
 import sniffio
 
 from ._exceptions import ExceptionMapping, PoolTimeout, map_exceptions
 
+
+EXCEPTION_OR_CANCELLED: Union[
+    Tuple[Type[BaseException]],
+    Tuple[Type[BaseException], Type[BaseException]],
+    Tuple[Type[BaseException], Type[BaseException], Type[BaseException]],
+] = (Exception,)
+
 # Our async synchronization primatives use either 'anyio' or 'trio' depending
 # on if they're running under asyncio or trio.
 
 try:
     import trio
+
+    EXCEPTION_OR_CANCELLED += (trio.Cancelled,)
 except ImportError:  # pragma: nocover
     trio = None  # type: ignore
 
 try:
     import anyio
+
+    try:
+        import asyncio
+
+        EXCEPTION_OR_CANCELLED += (asyncio.CancelledError,)
+    except ImportError:
+        pass
 except ImportError:  # pragma: nocover
     anyio = None  # type: ignore