Improve detection of async callables

starlette/_utils.py

@@ -0,0 +1,12 @@
+import asyncio
+import functools
+import typing
+
+
+def iscoroutinefunction(obj: typing.Any) -> bool:
+    while isinstance(obj, functools.partial):
+        obj = obj.func
+
+    return asyncio.iscoroutinefunction(obj) or (
+        callable(obj) and asyncio.iscoroutinefunction(obj.__call__)
+    )

starlette/authentication.py

@@ -1,8 +1,8 @@
-import asyncio
 import functools
 import inspect
 import typing
 
+from starlette._utils import iscoroutinefunction
 from starlette.exceptions import HTTPException
 from starlette.requests import HTTPConnection, Request
 from starlette.responses import RedirectResponse, Response
@@ -52,7 +52,7 @@ async def websocket_wrapper(
 
             return websocket_wrapper
 
-        elif asyncio.iscoroutinefunction(func):
+        elif iscoroutinefunction(func):
             # Handle async request/response functions.
             @functools.wraps(func)
             async def async_wrapper(

starlette/background.py

@@ -1,4 +1,3 @@
-import asyncio
 import sys
 import typing
 
@@ -7,6 +6,7 @@
 else:  # pragma: no cover
     from typing_extensions import ParamSpec
 
+from starlette._utils import iscoroutinefunction
 from starlette.concurrency import run_in_threadpool
 
 P = ParamSpec("P")
@@ -19,7 +19,7 @@ def __init__(
         self.func = func
         self.args = args
         self.kwargs = kwargs
-        self.is_async = asyncio.iscoroutinefunction(func)
+        self.is_async = iscoroutinefunction(func)
 
     async def __call__(self) -> None:
         if self.is_async:

starlette/endpoints.py

@@ -1,8 +1,8 @@
-import asyncio
 import json
 import typing
 
 from starlette import status
+from starlette._utils import iscoroutinefunction
 from starlette.concurrency import run_in_threadpool
 from starlette.exceptions import HTTPException
 from starlette.requests import Request
@@ -37,7 +37,7 @@ async def dispatch(self) -> None:
         handler: typing.Callable[[Request], typing.Any] = getattr(
             self, handler_name, self.method_not_allowed
         )
-        is_async = asyncio.iscoroutinefunction(handler)
+        is_async = iscoroutinefunction(handler)
         if is_async:
             response = await handler(request)
         else:

starlette/exceptions.py

@@ -1,7 +1,7 @@
-import asyncio
 import http
 import typing
 
+from starlette._utils import iscoroutinefunction
 from starlette.concurrency import run_in_threadpool
 from starlette.requests import Request
 from starlette.responses import PlainTextResponse, Response
@@ -94,7 +94,7 @@ async def sender(message: Message) -> None:
                 raise RuntimeError(msg) from exc
 
             request = Request(scope, receive=receive)
-            if asyncio.iscoroutinefunction(handler):
+            if iscoroutinefunction(handler):
                 response = await handler(request, exc)
             else:
                 response = await run_in_threadpool(handler, request, exc)

starlette/middleware/errors.py

@@ -1,9 +1,9 @@
-import asyncio
 import html
 import inspect
 import traceback
 import typing
 
+from starlette._utils import iscoroutinefunction
 from starlette.concurrency import run_in_threadpool
 from starlette.requests import Request
 from starlette.responses import HTMLResponse, PlainTextResponse, Response
@@ -168,7 +168,7 @@ async def _send(message: Message) -> None:
                     response = self.error_response(request, exc)
                 else:
                     # Use an installed 500 error handler.
-                    if asyncio.iscoroutinefunction(self.handler):
+                    if iscoroutinefunction(self.handler):
                         response = await self.handler(request, exc)
                     else:
                         response = await run_in_threadpool(self.handler, request, exc)

starlette/routing.py

@@ -1,4 +1,3 @@
-import asyncio
 import contextlib
 import functools
 import inspect
@@ -10,6 +9,7 @@
 import warnings
 from enum import Enum
 
+from starlette._utils import iscoroutinefunction
 from starlette.concurrency import run_in_threadpool
 from starlette.convertors import CONVERTOR_TYPES, Convertor
 from starlette.datastructures import URL, Headers, URLPath
@@ -600,7 +600,7 @@ async def startup(self) -> None:
         Run any `.on_startup` event handlers.
         """
         for handler in self.on_startup:
-            if asyncio.iscoroutinefunction(handler):
+            if iscoroutinefunction(handler):
                 await handler()
             else:
                 handler()
@@ -610,7 +610,7 @@ async def shutdown(self) -> None:
         Run any `.on_shutdown` event handlers.
         """
         for handler in self.on_shutdown:
-            if asyncio.iscoroutinefunction(handler):
+            if iscoroutinefunction(handler):
                 await handler()
             else:
                 handler()

starlette/testclient.py

@@ -1,4 +1,3 @@
-import asyncio
 import contextlib
 import http
 import inspect
@@ -16,6 +15,7 @@
 import requests
 from anyio.streams.stapled import StapledObjectStream
 
+from starlette._utils import iscoroutinefunction
 from starlette.types import Message, Receive, Scope, Send
 from starlette.websockets import WebSocketDisconnect
 
@@ -84,10 +84,7 @@ def _get_reason_phrase(status_code: int) -> str:
 def _is_asgi3(app: typing.Union[ASGI2App, ASGI3App]) -> bool:
     if inspect.isclass(app):
         return hasattr(app, "__await__")
-    elif inspect.isfunction(app):
-        return asyncio.iscoroutinefunction(app)
-    call = getattr(app, "__call__", None)
-    return asyncio.iscoroutinefunction(call)
+    return iscoroutinefunction(app)
 
 
 class _WrapASGI2:

tests/test__utils.py

@@ -0,0 +1,79 @@
+import functools
+
+from starlette._utils import iscoroutinefunction
+
+
+def test_async_func():
+    async def async_func():
+        ...  # pragma: no cover
+
+    def func():
+        ...  # pragma: no cover
+
+    assert iscoroutinefunction(async_func)
+    assert not iscoroutinefunction(func)
+
+
+def test_async_partial():
+    async def async_func(a, b):
+        ...  # pragma: no cover
+
+    def func(a, b):
+        ...  # pragma: no cover
+
+    partial = functools.partial(async_func, 1)
+    assert iscoroutinefunction(partial)
+
+    partial = functools.partial(func, 1)
+    assert not iscoroutinefunction(partial)
+
+
+def test_async_method():
+    class Async:
+        async def method(self):
+            ...  # pragma: no cover
+
+    class Sync:
+        def method(self):
+            ...  # pragma: no cover
+
+    assert iscoroutinefunction(Async().method)
+    assert not iscoroutinefunction(Sync().method)
+
+
+def test_async_object_call():
+    class Async:
+        async def __call__(self):
+            ...  # pragma: no cover
+
+    class Sync:
+        def __call__(self):
+            ...  # pragma: no cover
+
+    assert iscoroutinefunction(Async())
+    assert not iscoroutinefunction(Sync())
+
+
+def test_async_partial_object_call():
+    class Async:
+        async def __call__(self, a, b):
+            ...  # pragma: no cover
+
+    class Sync:
+        def __call__(self, a, b):
+            ...  # pragma: no cover
+
+    partial = functools.partial(Async(), 1)
+    assert iscoroutinefunction(partial)
+
+    partial = functools.partial(Sync(), 1)
+    assert not iscoroutinefunction(partial)
+
+
+def test_async_nested_partial():
+    async def async_func(a, b):
+        ...  # pragma: no cover
+
+    partial = functools.partial(async_func, b=2)
+    nested_partial = functools.partial(partial, a=1)
+    assert iscoroutinefunction(nested_partial)