Move body logic to Auth, add sync_auth_flow, add NoAuth

Author: florimondmanca

httpx/_auth.py

@@ -18,11 +18,10 @@ class Auth:
     To implement a custom authentication scheme, subclass `Auth` and override
     the `.auth_flow()` method.
 
-    If the authentication scheme does I/O, such as disk access or network calls, or uses
-    synchronization primitives such as locks, you should override `.async_auth_flow()`
-    to provide an async-friendly implementation that will be used by the `AsyncClient`.
-    Usage of sync I/O within an async codebase would block the event loop, and could
-    cause performance issues.
+    If the authentication scheme does I/O such as disk access or network calls, or uses
+    synchronization primitives such as locks, you should override `.sync_auth_flow()`
+    and/or `.async_auth_flow()` instead of `.auth_flow()` to provide specialized
+    implementations that will be used by `Client` and `AsyncClient` respectively.
     """
 
     requires_request_body = False
@@ -50,7 +49,34 @@ def auth_flow(self, request: Request) -> typing.Generator[Request, Response, Non
 
         You can dispatch as many requests as is necessary.
         """
-        yield request
+        raise NotImplementedError(
+            "Override 'auth_flow' to implement a custom auth class."
+        )  # pragma: no cover
+
+    def sync_auth_flow(
+        self, request: Request
+    ) -> typing.Generator[Request, Response, None]:
+        """
+        Execute the authentication flow synchronously.
+
+        By default, this defers to `.auth_flow()`. You should override this method
+        when the authentication scheme does I/O and/or uses concurrency primitives.
+        """
+        if self.requires_request_body:
+            request.read()
+
+        flow = self.auth_flow(request)
+        request = next(flow)
+
+        while True:
+            response = yield request
+            if self.requires_response_body:
+                response.read()
+
+            try:
+                request = flow.send(response)
+            except StopIteration:
+                break
 
     async def async_auth_flow(
         self, request: Request
@@ -59,20 +85,34 @@ async def async_auth_flow(
         Execute the authentication flow asynchronously.
 
         By default, this defers to `.auth_flow()`. You should override this method
-        when the authentication scheme does I/O, such as disk access or network calls,
-        or uses concurrency primitives such as locks.
+        when the authentication scheme does I/O and/or uses concurrency primitives.
         """
+        if self.requires_request_body:
+            await request.aread()
+
         flow = self.auth_flow(request)
         request = next(flow)
 
         while True:
             response = yield request
+            if self.requires_response_body:
+                await response.aread()
+
             try:
                 request = flow.send(response)
             except StopIteration:
                 break
 
 
+class NoAuth(Auth):
+    """
+    A 'do nothing' scheme for use when no authentication should be performed.
+    """
+
+    def auth_flow(self, request: Request) -> typing.Generator[Request, Response, None]:
+        yield request
+
+
 class FunctionAuth(Auth):
     """
     Allows the 'auth' argument to be passed as a simple callable function,

httpx/_client.py

@@ -4,7 +4,7 @@
 
 import httpcore
 
-from ._auth import Auth, BasicAuth, FunctionAuth
+from ._auth import Auth, BasicAuth, FunctionAuth, NoAuth
 from ._config import (
     DEFAULT_LIMITS,
     DEFAULT_MAX_REDIRECTS,
@@ -338,7 +338,7 @@ def _build_request_auth(
             if credentials is not None:
                 return BasicAuth(username=credentials[0], password=credentials[1])
 
-        return Auth()
+        return NoAuth()
 
     def _build_redirect_request(self, request: Request, response: Response) -> Request:
         """
@@ -760,15 +760,12 @@ def _send_handling_auth(
         auth: Auth,
         timeout: Timeout,
     ) -> Response:
-        if auth.requires_request_body:
-            request.read()
+        auth_flow = auth.sync_auth_flow(request)
+        request = auth_flow.send(None)  # type: ignore
 
-        auth_flow = auth.auth_flow(request)
-        request = next(auth_flow)
         while True:
             response = self._send_single_request(request, timeout)
-            if auth.requires_response_body:
-                response.read()
+
             try:
                 next_request = auth_flow.send(response)
             except StopIteration:
@@ -1362,15 +1359,12 @@ async def _send_handling_auth(
         auth: Auth,
         timeout: Timeout,
     ) -> Response:
-        if auth.requires_request_body:
-            await request.aread()
-
         auth_flow = auth.async_auth_flow(request)
-        request = await auth_flow.__anext__()
+        request = await auth_flow.asend(None)  # type: ignore
+
         while True:
             response = await self._send_single_request(request, timeout)
-            if auth.requires_response_body:
-                await response.aread()
+
             try:
                 next_request = await auth_flow.asend(response)
             except StopAsyncIteration: