async middleware can be a regular function too

[abetkin]

Here is what we have in MiddlewareMixin:

    def _async_check(self):
        """
        If get_response is a coroutine function, turns us into async mode so
        a thread is not consumed during a whole request.
        """
        if asyncio.iscoroutinefunction(self.get_response):
            # Mark the class as async-capable, but do the actual switch
            # inside __call__ to avoid swapping out dunder methods
            self._is_coroutine = asyncio.coroutines._is_coroutine
        else:
            self._is_coroutine = None

This checks if the next middleware is a coroutine, and if not fallbacks to sync mode. However, I think this is redundant: if the middleware is async-capable, and we have an ASGI request, what else we need ti check?

The downside of _async_check is that this common usecase is not supported:

def MyMiddleware(get_response):

    def middleware(request):
        # Do some stuff with request that does not involve I/O
        request.vip_user = True
        return get_response(request)

    return middleware

MyMiddleware.async_capable=True

middleware(request) will return the response in sync case and a coroutine in the async case, despite being a regular function (because get_response is a coroutine function in the latter case).

Here is a patch that I use that explains a possible way to fix it:

def is_next_middleware_async_capable(mw):
    path = f'{mw.__class__.__module__}.{mw.__class__.__name__}'
    next_index = settings.MIDDLEWARE.index(path) + 1
    mw_class = import_string(settings.MIDDLEWARE[next_index])
    return mw_class.async_capable


def call_mw(mw, request, _call_mw=MiddlewareMixin.__call__):
    if isinstance(request, ASGIRequest) and is_next_middleware_async_capable(mw):
        return mw.__acall__(request)
    return _call_mw(mw, request)


MiddlewareMixin.__call__ = call_mw

Github project that shows the error: ​https://github.com/pwtail/django_bug