Simplify patch set

Author: MarkusSintonen

docs/exceptions.md

@@ -9,7 +9,6 @@ The following exceptions may be raised when sending a request:
     * `httpcore.WriteTimeout`
 * `httpcore.NetworkError`
     * `httpcore.ConnectError`
-      * `httpcore.BrokenSocketError`
     * `httpcore.ReadError`
     * `httpcore.WriteError`
 * `httpcore.ProtocolError`

httpcore/__init__.py

@@ -9,7 +9,6 @@
     AsyncSOCKSProxy,
 )
 from ._backends.asyncio import AsyncioBackend
-from ._backends.auto import AutoBackend
 from ._backends.base import (
     SOCKET_OPTION,
     AsyncNetworkBackend,
@@ -20,7 +19,6 @@
 from ._backends.mock import AsyncMockBackend, AsyncMockStream, MockBackend, MockStream
 from ._backends.sync import SyncBackend
 from ._exceptions import (
-    BrokenSocketError,
     ConnectError,
     ConnectionNotAvailable,
     ConnectTimeout,
@@ -100,7 +98,6 @@ def __init__(self, *args, **kwargs):  # type: ignore
     "SOCKSProxy",
     # network backends, implementations
     "SyncBackend",
-    "AutoBackend",
     "AsyncioBackend",
     "AnyIOBackend",
     "TrioBackend",
@@ -131,7 +128,6 @@ def __init__(self, *args, **kwargs):  # type: ignore
     "WriteTimeout",
     "NetworkError",
     "ConnectError",
-    "BrokenSocketError",
     "ReadError",
     "WriteError",
 ]

httpcore/_backends/anyio.py

@@ -4,7 +4,6 @@
 import anyio
 
 from .._exceptions import (
-    BrokenSocketError,
     ConnectError,
     ConnectTimeout,
     ReadError,
@@ -83,9 +82,6 @@ async def start_tls(
         return AnyIOStream(ssl_stream)
 
     def get_extra_info(self, info: str) -> typing.Any:
-        if info == "is_readable":
-            sock = self._stream.extra(anyio.abc.SocketAttribute.raw_socket, None)
-            return is_socket_readable(sock)
         if info == "ssl_object":
             return self._stream.extra(anyio.streams.tls.TLSAttribute.ssl_object, None)
         if info == "client_addr":
@@ -94,6 +90,9 @@ def get_extra_info(self, info: str) -> typing.Any:
             return self._stream.extra(anyio.abc.SocketAttribute.remote_address, None)
         if info == "socket":
             return self._stream.extra(anyio.abc.SocketAttribute.raw_socket, None)
+        if info == "is_readable":
+            sock = self._stream.extra(anyio.abc.SocketAttribute.raw_socket, None)
+            return is_socket_readable(sock)
         return None
 
 
@@ -106,6 +105,8 @@ async def connect_tcp(
         local_address: typing.Optional[str] = None,
         socket_options: typing.Optional[typing.Iterable[SOCKET_OPTION]] = None,
     ) -> AsyncNetworkStream:
+        if socket_options is None:
+            socket_options = []  # pragma: no cover
         exc_map = {
             TimeoutError: ConnectTimeout,
             OSError: ConnectError,
@@ -119,15 +120,18 @@ async def connect_tcp(
                     local_host=local_address,
                 )
                 # By default TCP sockets opened in `asyncio` include TCP_NODELAY.
-                self._set_socket_options(stream, socket_options)
+                for option in socket_options:
+                    stream._raw_socket.setsockopt(*option)  # type: ignore[attr-defined] # pragma: no cover
         return AnyIOStream(stream)
 
     async def connect_unix_socket(
         self,
         path: str,
         timeout: typing.Optional[float] = None,
         socket_options: typing.Optional[typing.Iterable[SOCKET_OPTION]] = None,
-    ) -> AsyncNetworkStream:
+    ) -> AsyncNetworkStream:  # pragma: nocover
+        if socket_options is None:
+            socket_options = []
         exc_map = {
             TimeoutError: ConnectTimeout,
             OSError: ConnectError,
@@ -136,23 +140,9 @@ async def connect_unix_socket(
         with map_exceptions(exc_map):
             with anyio.fail_after(timeout):
                 stream: anyio.abc.ByteStream = await anyio.connect_unix(path)
-                self._set_socket_options(stream, socket_options)
+                for option in socket_options:
+                    stream._raw_socket.setsockopt(*option)  # type: ignore[attr-defined] # pragma: no cover
         return AnyIOStream(stream)
 
     async def sleep(self, seconds: float) -> None:
         await anyio.sleep(seconds)  # pragma: nocover
-
-    def _set_socket_options(
-        self,
-        stream: anyio.abc.ByteStream,
-        socket_options: typing.Optional[typing.Iterable[SOCKET_OPTION]] = None,
-    ) -> None:
-        if not socket_options:
-            return
-
-        sock = stream.extra(anyio.abc.SocketAttribute.raw_socket, None)
-        if sock is None:
-            raise BrokenSocketError()  # pragma: nocover
-
-        for option in socket_options:
-            sock.setsockopt(*option)

httpcore/_backends/asyncio.py

@@ -4,7 +4,6 @@
 from typing import Any, Dict, Iterable, Optional, Type
 
 from .._exceptions import (
-    BrokenSocketError,
     ConnectError,
     ConnectTimeout,
     ReadError,
@@ -144,8 +143,9 @@ def get_extra_info(self, info: str) -> Any:
             return self._sslobj
         if info in ("client_addr", "server_addr"):
             sock = self._raw_socket
-            if sock is None:
-                raise BrokenSocketError()  # pragma: nocover
+            if sock is None:  # pragma: nocover
+                # TODO replace with an explicit error such as BrokenSocketError
+                raise ConnectError()
             return sock.getsockname() if info == "client_addr" else sock.getpeername()
         if info == "socket":
             return self._raw_socket
@@ -220,8 +220,9 @@ def _set_socket_options(
             return
 
         sock = stream.get_extra_info("socket")
-        if sock is None:
-            raise BrokenSocketError()  # pragma: nocover
+        if sock is None:  # pragma: nocover
+            # TODO replace with an explicit error such as BrokenSocketError
+            raise ConnectError()
 
         for option in socket_options:
             sock.setsockopt(*option)

httpcore/_backends/auto.py

@@ -1,41 +1,22 @@
 import typing
-from importlib.util import find_spec
-from typing import Optional, Type
+from typing import Optional
 
-from .._synchronization import current_async_backend
+from .._synchronization import current_async_library
 from .base import SOCKET_OPTION, AsyncNetworkBackend, AsyncNetworkStream
 
-HAS_ANYIO = find_spec("anyio") is not None
-
 
 class AutoBackend(AsyncNetworkBackend):
-    @staticmethod
-    def set_default_backend(backend_class: Optional[Type[AsyncNetworkBackend]]) -> None:
-        setattr(AutoBackend, "_default_backend_class", backend_class)
-
     async def _init_backend(self) -> None:
-        if hasattr(self, "_backend"):
-            return
-
-        default_backend_class: Optional[Type[AsyncNetworkBackend]] = getattr(
-            AutoBackend, "_default_backend_class", None
-        )
-        if default_backend_class is not None:
-            self._backend = default_backend_class()
-            return
-
-        if current_async_backend() == "trio":
-            from .trio import TrioBackend
-
-            self._backend = TrioBackend()
-        elif HAS_ANYIO:
-            from .anyio import AnyIOBackend
+        if not (hasattr(self, "_backend")):
+            backend = current_async_library()
+            if backend == "trio":
+                from .trio import TrioBackend
 
-            self._backend = AnyIOBackend()
-        else:
-            from .asyncio import AsyncioBackend
+                self._backend: AsyncNetworkBackend = TrioBackend()
+            else:
+                from .anyio import AnyIOBackend
 
-            self._backend = AsyncioBackend()
+                self._backend = AnyIOBackend()
 
     async def connect_tcp(
         self,

httpcore/_backends/trio.py

@@ -117,6 +117,10 @@ async def connect_tcp(
         local_address: typing.Optional[str] = None,
         socket_options: typing.Optional[typing.Iterable[SOCKET_OPTION]] = None,
     ) -> AsyncNetworkStream:
+        # By default for TCP sockets, trio enables TCP_NODELAY.
+        # https://trio.readthedocs.io/en/stable/reference-io.html#trio.SocketStream
+        if socket_options is None:
+            socket_options = []  # pragma: no cover
         timeout_or_inf = float("inf") if timeout is None else timeout
         exc_map: ExceptionMapping = {
             trio.TooSlowError: ConnectTimeout,
@@ -128,15 +132,18 @@ async def connect_tcp(
                 stream: trio.abc.Stream = await trio.open_tcp_stream(
                     host=host, port=port, local_address=local_address
                 )
-                self._set_socket_options(stream, socket_options)
+                for option in socket_options:
+                    stream.setsockopt(*option)  # type: ignore[attr-defined] # pragma: no cover
         return TrioStream(stream)
 
     async def connect_unix_socket(
         self,
         path: str,
         timeout: typing.Optional[float] = None,
         socket_options: typing.Optional[typing.Iterable[SOCKET_OPTION]] = None,
-    ) -> AsyncNetworkStream:
+    ) -> AsyncNetworkStream:  # pragma: nocover
+        if socket_options is None:
+            socket_options = []
         timeout_or_inf = float("inf") if timeout is None else timeout
         exc_map: ExceptionMapping = {
             trio.TooSlowError: ConnectTimeout,
@@ -146,20 +153,9 @@ async def connect_unix_socket(
         with map_exceptions(exc_map):
             with trio.fail_after(timeout_or_inf):
                 stream: trio.abc.Stream = await trio.open_unix_socket(path)
-                self._set_socket_options(stream, socket_options)
+                for option in socket_options:
+                    stream.setsockopt(*option)  # type: ignore[attr-defined] # pragma: no cover
         return TrioStream(stream)
 
     async def sleep(self, seconds: float) -> None:
         await trio.sleep(seconds)  # pragma: nocover
-
-    def _set_socket_options(
-        self,
-        stream: trio.abc.Stream,
-        socket_options: typing.Optional[typing.Iterable[SOCKET_OPTION]] = None,
-    ) -> None:
-        # By default for TCP sockets, trio enables TCP_NODELAY.
-        # https://trio.readthedocs.io/en/stable/reference-io.html#trio.SocketStream
-        if not socket_options:
-            return
-        for option in socket_options:
-            stream.setsockopt(*option)  # type: ignore[attr-defined]

httpcore/_exceptions.py

@@ -73,10 +73,6 @@ class ConnectError(NetworkError):
     pass
 
 
-class BrokenSocketError(ConnectError):
-    pass
-
-
 class ReadError(NetworkError):
     pass
 

httpcore/_synchronization.py

@@ -1,6 +1,6 @@
 import threading
 from types import TracebackType
-from typing import Literal, Optional, Type
+from typing import Optional, Type
 
 from ._exceptions import ExceptionMapping, PoolTimeout, map_exceptions
 
@@ -18,28 +18,30 @@
     anyio = None  # type: ignore
 
 
-AsyncBackend = Literal["asyncio", "trio"]
-
-
-def current_async_backend() -> AsyncBackend:
+def current_async_library() -> str:
     # Determine if we're running under trio or asyncio.
     # See https://sniffio.readthedocs.io/en/latest/
     try:
         import sniffio
     except ImportError:  # pragma: nocover
-        backend: AsyncBackend = "asyncio"
+        environment = "asyncio"
     else:
-        backend = sniffio.current_async_library()  # type: ignore[assignment]
+        environment = sniffio.current_async_library()
 
-    if backend not in ("asyncio", "trio"):  # pragma: nocover
+    if environment not in ("asyncio", "trio"):  # pragma: nocover
         raise RuntimeError("Running under an unsupported async environment.")
 
-    if backend == "trio" and trio is None:  # pragma: nocover
+    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 backend
+    return environment
 
 
 class AsyncLock:
@@ -58,7 +60,7 @@ def setup(self) -> None:
         Detect if we're running under 'asyncio' or 'trio' and create
         a lock with the correct implementation.
         """
-        self._backend = current_async_backend()
+        self._backend = current_async_library()
         if self._backend == "trio":
             self._trio_lock = trio.Lock()
         elif self._backend == "asyncio":
@@ -116,7 +118,7 @@ def setup(self) -> None:
         Detect if we're running under 'asyncio' or 'trio' and create
         a lock with the correct implementation.
         """
-        self._backend = current_async_backend()
+        self._backend = current_async_library()
         if self._backend == "trio":
             self._trio_event = trio.Event()
         elif self._backend == "asyncio":
@@ -158,7 +160,7 @@ def setup(self) -> None:
         Detect if we're running under 'asyncio' or 'trio' and create
         a semaphore with the correct implementation.
         """
-        self._backend = current_async_backend()
+        self._backend = current_async_library()
         if self._backend == "trio":
             self._trio_semaphore = trio.Semaphore(
                 initial_value=self._bound, max_value=self._bound
@@ -197,7 +199,7 @@ def __init__(self) -> None:
         Detect if we're running under 'asyncio' or 'trio' and create
         a shielded scope with the correct implementation.
         """
-        self._backend = current_async_backend()
+        self._backend = current_async_library()
 
         if self._backend == "trio":
             self._trio_shield = trio.CancelScope(shield=True)

pyproject.toml

@@ -91,7 +91,10 @@ ignore_missing_imports = true
 
 [tool.pytest.ini_options]
 addopts = ["-rxXs", "--strict-config", "--strict-markers"]
-markers = ["copied_from(source, changes=None): mark test as copied from somewhere else, along with a description of changes made to accodomate e.g. our test setup"]
+markers = [
+    "copied_from(source, changes=None): mark test as copied from somewhere else, along with a description of changes made to accodomate e.g. our test setup",
+    "no_auto_backend_patch",  # TODO remove this marker once we have a way to define the asyncio backend in AutoBackend
+]
 filterwarnings = ["error"]
 
 [tool.coverage.run]

tests/benchmark/client.py

@@ -1,4 +1,5 @@
 import asyncio
+import os
 import sys
 import time
 from concurrent.futures import ThreadPoolExecutor
@@ -20,8 +21,7 @@
 CONCURRENCY = 20
 POOL_LIMIT = 100
 PROFILE = False
-httpcore.AutoBackend.set_default_backend(httpcore.AsyncioBackend)
-# httpcore.AutoBackend.set_default_backend(httpcore.AnyIOBackend)
+os.environ["HTTPCORE_PREFER_ANYIO"] = "0"
 
 
 def duration(start: float) -> int: