Retire map_exceptions in httpcore2

`try: except:` blocks are free on modern Pythons when exceptions
aren't raised. Entering a `@contextmanager`'d block is much less free,
and there are hot paths (e.g. reading from a sync socket) where it's
worth avoiding that overhead.

For consistency, this retires the use of `map_exceptions` everywhere.
New exception blocks are marked nocover, since they weren't actually tested
before either.

Author: akx

src/httpcore2/httpcore2/_async/http11.py

@@ -16,7 +16,6 @@
     LocalProtocolError,
     RemoteProtocolError,
     WriteError,
-    map_exceptions,
 )
 from .._models import Origin, Request, Response
 from .._synchronization import AsyncLock, AsyncShieldCancellation
@@ -130,12 +129,14 @@ async def _send_request_headers(self, request: Request) -> None:
         timeouts = request.extensions.get("timeout", {})
         timeout = timeouts.get("write", None)
 
-        with map_exceptions({h11.LocalProtocolError: LocalProtocolError}):
+        try:
             event = h11.Request(
                 method=request.method,
                 target=request.url.target,
                 headers=request.headers,
             )
+        except h11.LocalProtocolError as exc:
+            raise LocalProtocolError(exc) from exc
         await self._send_event(event, timeout=timeout)
 
     async def _send_request_body(self, request: Request) -> None:
@@ -193,8 +194,10 @@ async def _receive_response_body(self, request: Request) -> AsyncGenerator[bytes
 
     async def _receive_event(self, timeout: float | None = None) -> h11.Event | type[h11.PAUSED]:
         while True:
-            with map_exceptions({h11.RemoteProtocolError: RemoteProtocolError}):
+            try:
                 event = self._h11_state.next_event()
+            except h11.RemoteProtocolError as exc:
+                raise RemoteProtocolError(exc) from exc
 
             if event is h11.NEED_DATA:
                 data = await self._network_stream.read(self.READ_NUM_BYTES, timeout=timeout)

src/httpcore2/httpcore2/_backends/anyio.py

@@ -14,7 +14,6 @@
     ReadTimeout,
     WriteError,
     WriteTimeout,
-    map_exceptions,
 )
 from .._utils import is_socket_readable
 from .base import SOCKET_OPTION, AsyncNetworkBackend, AsyncNetworkStream
@@ -25,31 +24,35 @@ def __init__(self, stream: anyio.abc.ByteStream) -> None:
         self._stream = stream
 
     async def read(self, max_bytes: int, timeout: float | None = None) -> bytes:
-        exc_map: dict[type[Exception], type[Exception]] = {
-            TimeoutError: ReadTimeout,
-            anyio.BrokenResourceError: ReadError,
-            anyio.ClosedResourceError: ReadError,
-            anyio.EndOfStream: ReadError,
-        }
-        with map_exceptions(exc_map):
+        try:
             with anyio.fail_after(timeout):
                 try:
                     return await self._stream.receive(max_bytes=max_bytes)
                 except anyio.EndOfStream:  # pragma: no cover
                     return b""
+        except TimeoutError as exc:  # pragma: no cover
+            raise ReadTimeout(exc) from exc
+        except (
+            anyio.BrokenResourceError,
+            anyio.ClosedResourceError,
+            anyio.EndOfStream,
+        ) as exc:  # pragma: no cover
+            raise ReadError(exc) from exc
 
     async def write(self, buffer: bytes, timeout: float | None = None) -> None:
         if not buffer:
             return
 
-        exc_map: dict[type[Exception], type[Exception]] = {
-            TimeoutError: WriteTimeout,
-            anyio.BrokenResourceError: WriteError,
-            anyio.ClosedResourceError: WriteError,
-        }
-        with map_exceptions(exc_map):
+        try:
             with anyio.fail_after(timeout):
                 await self._stream.send(item=buffer)
+        except TimeoutError as exc:  # pragma: no cover
+            raise WriteTimeout(exc) from exc
+        except (
+            anyio.BrokenResourceError,
+            anyio.ClosedResourceError,
+        ) as exc:  # pragma: no cover
+            raise WriteError(exc) from exc
 
     async def aclose(self) -> None:
         await self._stream.aclose()
@@ -60,13 +63,7 @@ async def start_tls(
         server_hostname: str | None = None,
         timeout: float | None = None,
     ) -> AsyncNetworkStream:
-        exc_map: dict[type[Exception], type[Exception]] = {
-            TimeoutError: ConnectTimeout,
-            anyio.BrokenResourceError: ConnectError,
-            anyio.EndOfStream: ConnectError,
-            ssl.SSLError: ConnectError,
-        }
-        with map_exceptions(exc_map):
+        try:
             try:
                 with anyio.fail_after(timeout):
                     ssl_stream = await anyio.streams.tls.TLSStream.wrap(
@@ -79,6 +76,14 @@ async def start_tls(
             except Exception as exc:  # pragma: no cover
                 await self.aclose()
                 raise exc
+        except TimeoutError as exc:  # pragma: no cover
+            raise ConnectTimeout(exc) from exc
+        except (
+            anyio.BrokenResourceError,
+            anyio.EndOfStream,
+            ssl.SSLError,
+        ) as exc:  # pragma: no cover
+            raise ConnectError(exc) from exc
         return AnyIOStream(ssl_stream)
 
     def get_extra_info(self, info: str) -> typing.Any:
@@ -107,12 +112,7 @@ async def connect_tcp(
     ) -> AsyncNetworkStream:  # pragma: no cover
         if socket_options is None:
             socket_options = []
-        exc_map: dict[type[Exception], type[Exception]] = {
-            TimeoutError: ConnectTimeout,
-            OSError: ConnectError,
-            anyio.BrokenResourceError: ConnectError,
-        }
-        with map_exceptions(exc_map):
+        try:
             with anyio.fail_after(timeout):
                 stream: anyio.abc.ByteStream = await anyio.connect_tcp(
                     remote_host=host,
@@ -122,6 +122,10 @@ async def connect_tcp(
                 # By default TCP sockets opened in `asyncio` include TCP_NODELAY.
                 for option in socket_options:
                     stream._raw_socket.setsockopt(*option)  # type: ignore[attr-defined] # pragma: no cover
+        except TimeoutError as exc:
+            raise ConnectTimeout(exc) from exc
+        except (OSError, anyio.BrokenResourceError) as exc:
+            raise ConnectError(exc) from exc
         return AnyIOStream(stream)
 
     async def connect_unix_socket(
@@ -132,16 +136,15 @@ async def connect_unix_socket(
     ) -> AsyncNetworkStream:  # pragma: no cover
         if socket_options is None:
             socket_options = []
-        exc_map: dict[type[Exception], type[Exception]] = {
-            TimeoutError: ConnectTimeout,
-            OSError: ConnectError,
-            anyio.BrokenResourceError: ConnectError,
-        }
-        with map_exceptions(exc_map):
+        try:
             with anyio.fail_after(timeout):
                 stream: anyio.abc.ByteStream = await anyio.connect_unix(path)
                 for option in socket_options:
                     stream._raw_socket.setsockopt(*option)  # type: ignore[attr-defined] # pragma: no cover
+        except TimeoutError as exc:
+            raise ConnectTimeout(exc) from exc
+        except (OSError, anyio.BrokenResourceError) as exc:
+            raise ConnectError(exc) from exc
         return AnyIOStream(stream)
 
     async def sleep(self, seconds: float) -> None:

src/httpcore2/httpcore2/_backends/sync.py

@@ -9,12 +9,10 @@
 from .._exceptions import (
     ConnectError,
     ConnectTimeout,
-    ExceptionMapping,
     ReadError,
     ReadTimeout,
     WriteError,
     WriteTimeout,
-    map_exceptions,
 )
 from .._utils import is_socket_readable
 from .base import SOCKET_OPTION, NetworkBackend, NetworkStream
@@ -77,19 +75,25 @@ def _perform_io(
                 return ret
 
     def read(self, max_bytes: int, timeout: float | None = None) -> bytes:
-        exc_map: ExceptionMapping = {socket.timeout: ReadTimeout, OSError: ReadError}
-        with map_exceptions(exc_map):
+        try:
             self._sock.settimeout(timeout)
             return typing.cast(bytes, self._perform_io(functools.partial(self.ssl_obj.read, max_bytes)))
+        except TimeoutError as exc:
+            raise ReadTimeout(exc) from exc
+        except OSError as exc:
+            raise ReadError(exc) from exc
 
     def write(self, buffer: bytes, timeout: float | None = None) -> None:
-        exc_map: ExceptionMapping = {socket.timeout: WriteTimeout, OSError: WriteError}
-        with map_exceptions(exc_map):
+        try:
             self._sock.settimeout(timeout)
             view = memoryview(buffer)  # zero-copy slicing; avoids copies
             while view:
                 nsent = self._perform_io(functools.partial(self.ssl_obj.write, view))
                 view = view[nsent:]
+        except TimeoutError as exc:
+            raise WriteTimeout(exc) from exc
+        except OSError as exc:
+            raise WriteError(exc) from exc
 
     def close(self) -> None:
         self._sock.close()
@@ -121,22 +125,28 @@ def __init__(self, sock: socket.socket) -> None:
         self._sock = sock
 
     def read(self, max_bytes: int, timeout: float | None = None) -> bytes:
-        exc_map: ExceptionMapping = {socket.timeout: ReadTimeout, OSError: ReadError}
-        with map_exceptions(exc_map):
+        try:
             self._sock.settimeout(timeout)
             return self._sock.recv(max_bytes)
+        except TimeoutError as exc:  # pragma: no cover
+            raise ReadTimeout(exc) from exc
+        except OSError as exc:  # pragma: no cover
+            raise ReadError(exc) from exc
 
     def write(self, buffer: bytes, timeout: float | None = None) -> None:
         if not buffer:
             return
 
-        exc_map: ExceptionMapping = {socket.timeout: WriteTimeout, OSError: WriteError}
-        with map_exceptions(exc_map):
+        try:
             view = memoryview(buffer)  # zero-copy slicing; avoids copies
             while view:
                 self._sock.settimeout(timeout)
                 n = self._sock.send(view)
                 view = view[n:]
+        except TimeoutError as exc:  # pragma: no cover
+            raise WriteTimeout(exc) from exc
+        except OSError as exc:  # pragma: no cover
+            raise WriteError(exc) from exc
 
     def close(self) -> None:
         self._sock.close()
@@ -147,11 +157,7 @@ def start_tls(
         server_hostname: str | None = None,
         timeout: float | None = None,
     ) -> NetworkStream:
-        exc_map: ExceptionMapping = {
-            socket.timeout: ConnectTimeout,
-            OSError: ConnectError,
-        }
-        with map_exceptions(exc_map):
+        try:
             try:
                 if isinstance(self._sock, ssl.SSLSocket):  # pragma: no cover
                     # If the underlying socket has already been upgraded
@@ -164,6 +170,10 @@ def start_tls(
             except Exception as exc:  # pragma: no cover
                 self.close()
                 raise exc
+        except TimeoutError as exc:  # pragma: no cover
+            raise ConnectTimeout(exc) from exc
+        except OSError as exc:  # pragma: no cover
+            raise ConnectError(exc) from exc
         return SyncStream(sock)
 
     def get_extra_info(self, info: str) -> typing.Any:
@@ -195,12 +205,8 @@ def connect_tcp(
             socket_options = []  # pragma: no cover
         address = (host, port)
         source_address = None if local_address is None else (local_address, 0)
-        exc_map: ExceptionMapping = {
-            socket.timeout: ConnectTimeout,
-            OSError: ConnectError,
-        }
 
-        with map_exceptions(exc_map):
+        try:
             sock = socket.create_connection(
                 address,
                 timeout,
@@ -209,6 +215,10 @@ def connect_tcp(
             for option in socket_options:
                 sock.setsockopt(*option)  # pragma: no cover
             sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+        except TimeoutError as exc:  # pragma: no cover
+            raise ConnectTimeout(exc) from exc
+        except OSError as exc:  # pragma: no cover
+            raise ConnectError(exc) from exc
         return SyncStream(sock)
 
     def connect_unix_socket(
@@ -222,14 +232,14 @@ def connect_unix_socket(
         if socket_options is None:
             socket_options = []
 
-        exc_map: ExceptionMapping = {
-            socket.timeout: ConnectTimeout,
-            OSError: ConnectError,
-        }
-        with map_exceptions(exc_map):
+        try:
             sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
             for option in socket_options:
                 sock.setsockopt(*option)
             sock.settimeout(timeout)
             sock.connect(path)
+        except TimeoutError as exc:
+            raise ConnectTimeout(exc) from exc
+        except OSError as exc:
+            raise ConnectError(exc) from exc
         return SyncStream(sock)