handle sync views

before this you could use sync views, but had to override the middleware to handle that, now it works out of the box

Author: amirreza8002

django_async_extensions/utils/decorators.py

@@ -3,7 +3,7 @@
 from asgiref.sync import async_to_sync, iscoroutinefunction, sync_to_async
 
 
-def decorator_from_middleware_with_args(middleware_class):
+def decorator_from_middleware_with_args(middleware_class, async_only=True):
     """
     Like decorator_from_middleware, but return a function
     that accepts the arguments to be passed to the middleware_class.
@@ -16,22 +16,31 @@ def decorator_from_middleware_with_args(middleware_class):
          def my_view(request):
              # ...
     """
-    return make_middleware_decorator(middleware_class)
+    return make_middleware_decorator(middleware_class, async_only=async_only)
 
 
-def decorator_from_middleware(middleware_class):
+def decorator_from_middleware(middleware_class, async_only=True):
     """
     Given a middleware class (not an instance), return a view decorator. This
     lets you use middleware functionality on a per-view basis. The middleware
     is created with no params passed.
     """
-    return make_middleware_decorator(middleware_class)()
+    return make_middleware_decorator(middleware_class, async_only=async_only)()
 
 
-def make_middleware_decorator(middleware_class):
+def make_middleware_decorator(middleware_class, async_only=True):
     def _make_decorator(*m_args, **m_kwargs):
         def _decorator(view_func):
-            middleware = middleware_class(view_func, *m_args, **m_kwargs)
+            _view_func = view_func
+            if all(
+                [
+                    not iscoroutinefunction(view_func),
+                    not iscoroutinefunction(getattr(view_func, "__call__", None)),
+                    async_only,
+                ]
+            ):
+                _view_func = sync_to_async(view_func)
+            middleware = middleware_class(_view_func, *m_args, **m_kwargs)
 
             async def _pre_process_request(request, *args, **kwargs):
                 if hasattr(middleware, "process_request"):
@@ -87,7 +96,9 @@ async def callback(response):
                         return await middleware.process_response(request, response)
                 return response
 
-            if iscoroutinefunction(view_func):
+            if iscoroutinefunction(view_func) or iscoroutinefunction(
+                getattr(view_func, "__call__", view_func)
+            ):
 
                 async def _view_wrapper(request, *args, **kwargs):
                     result = await _pre_process_request(request, *args, **kwargs)

docs/middleware/decorate_views.md

@@ -6,9 +6,6 @@ they work almost exactly like django's [decorator_from_middleware](https://docs.
 and [decorator_from_middleware_with_args](https://docs.djangoproject.com/en/5.1/ref/utils/#django.utils.decorators.decorator_from_middleware_with_args) 
 but it expects an async middleware as described in [AsyncMiddlewareMixin](base.md)
 
-**Important:** if you are using a middleware that inherits from [AsyncMiddlewareMixin](base.md) you can only decorate async views
-if you need to decorate a sync view change middleware's `__init__()` method to accept async `get_response` argument.
-
 with an async view
 ```python
 from django.http.response import HttpResponse
@@ -30,12 +27,18 @@ async def my_view(request):
 ```
 
 
-if you need to use a sync view design your middleware like this
+if your view is sync, it'll be wrapped in `sync_to_async` before getting passed down to middleware.
+
+if you need, you can disable this by passing `async_only=False`.
+note that the middlewares presented in this package will error if you do that, so you have to override the `__init__()` and `__call__()` methods to handle that.
+
 ```python
-from django_async_extensions.middleware.base import AsyncMiddlewareMixin
+from django.http.response import HttpResponse
 
 from asgiref.sync import iscoroutinefunction, markcoroutinefunction
 
+from django_async_extensions.middleware.base import AsyncMiddlewareMixin
+from django_async_extensions.utils.decorators import decorator_from_middleware
 
 class MyMiddleware(AsyncMiddlewareMixin):
     sync_capable = True
@@ -51,6 +54,24 @@ class MyMiddleware(AsyncMiddlewareMixin):
         if self.async_mode:
             # Mark the class as async-capable.
             markcoroutinefunction(self)
+            
+    async def __call__(self, request):
+        response = None
+        if hasattr(self, "process_request"):
+            response = await self.process_request(request)
+        response = response or self.get_response(request) # here call the method in a sync manner, or handle it in another way
+        if hasattr(self, "process_response"):
+            response = await self.process_response(request, response)
+        return response
 
-        super().__init__()
+    async def process_request(self, request):
+        return HttpResponse()
+
+
+deco = decorator_from_middleware(MyMiddleware, async_only=False)
+
+
+@deco
+def my_view(request):
+    return HttpResponse()
 ```

tests/test_async_utils/test_decorators.py

@@ -12,9 +12,6 @@
 
 
 class ProcessViewMiddleware(AsyncMiddlewareMixin):
-    def __init__(self, get_response):
-        self.get_response = get_response
-
     async def process_view(self, request, view_func, view_args, view_kwargs):
         pass
 
@@ -49,9 +46,6 @@ async def __call__(self, request):
 
 
 class FullMiddleware(AsyncMiddlewareMixin):
-    def __init__(self, get_response):
-        self.get_response = get_response
-
     async def process_request(self, request):
         request.process_request_reached = True
 
@@ -72,6 +66,30 @@ async def process_response(self, request, response):
 full_dec = decorator_from_middleware(FullMiddleware)
 
 
+class MiddlewareSyncGetResponse(FullMiddleware):
+    sync_capable = True
+
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    async def __call__(self, request):
+        response = None
+        if hasattr(self, "process_request"):
+            response = await self.process_request(request)
+        response = response or self.get_response(request)
+        if hasattr(self, "process_response"):
+            response = await self.process_response(request, response)
+        return response
+
+
+full_sync_dec = decorator_from_middleware(MiddlewareSyncGetResponse, async_only=False)
+
+
+@full_sync_dec
+def process_view_sync(request):
+    return HttpResponse()
+
+
 class TestDecoratorFromMiddleware:
     """
     Tests for view decorators created using
@@ -89,7 +107,7 @@ def test_process_view_middleware(self):
     async def test_process_view_middleware_async(self, async_rf):
         await async_process_view(async_rf.get("/"))
 
-    async def test_sync_process_view_raises_in_async_context(self):
+    async def test_sync_process_view_in_async_context_errors(self):
         msg = (
             "You cannot use AsyncToSync in the same thread as an async event loop"
             " - just await the async function directly."
@@ -104,7 +122,7 @@ def test_callable_process_view_middleware(self):
         class_process_view(self.rf.get("/"))
 
     async def test_callable_process_view_middleware_async(self, async_rf):
-        await async_process_view(async_rf.get("/"))
+        await async_class_process_view(async_rf.get("/"))
 
     def test_full_dec_normal(self):
         """
@@ -142,6 +160,38 @@ async def normal_view(request):
         assert getattr(request, "process_template_response_reached", False) is False
         assert getattr(request, "process_response_reached", False)
 
+    def test_full_sync_dec_normal(self):
+        @full_sync_dec
+        def normal_view(request):
+            template = engines["django"].from_string("Hello world")
+            return HttpResponse(template.render())
+
+        request = self.rf.get("/")
+        normal_view(request)
+        assert getattr(request, "process_request_reached", False)
+        assert getattr(request, "process_view_reached", False)
+        # process_template_response must not be called for HttpResponse
+        assert getattr(request, "process_template_response_reached", False) is False
+        assert getattr(request, "process_response_reached", False)
+
+    async def test_full_sync_dec_normal_async(self, async_rf):
+        """
+        All methods of middleware are called for normal HttpResponses
+        """
+
+        @full_sync_dec
+        async def normal_view(request):
+            template = engines["django"].from_string("Hello world")
+            return HttpResponse(template.render())
+
+        request = async_rf.get("/")
+        await normal_view(request)
+        assert getattr(request, "process_request_reached", False)
+        assert getattr(request, "process_view_reached", False)
+        # process_template_response must not be called for HttpResponse
+        assert getattr(request, "process_template_response_reached", False) is False
+        assert getattr(request, "process_response_reached", False)
+
     def test_full_dec_templateresponse(self):
         """
         All methods of middleware are called for TemplateResponses in
@@ -195,3 +245,57 @@ async def template_response_view(request):
         assert getattr(request, "process_response_reached", False)
         # process_response saw the rendered content
         assert request.process_response_content == b"Hello world"
+
+    def test_full_sync_dec_templateresponse(self):
+        """
+        All methods of middleware are called for TemplateResponses in
+        the right sequence.
+        """
+
+        @full_sync_dec
+        def template_response_view(request):
+            template = engines["django"].from_string("Hello world")
+            return TemplateResponse(request, template)
+
+        request = self.rf.get("/")
+        response = template_response_view(request)
+        assert getattr(request, "process_request_reached", False)
+        assert getattr(request, "process_view_reached", False)
+        assert getattr(request, "process_template_response_reached", False)
+        # response must not be rendered yet.
+        assert response._is_rendered is False
+        # process_response must not be called until after response is rendered,
+        # otherwise some decorators like csrf_protect and gzip_page will not
+        # work correctly. See #16004
+        assert getattr(request, "process_response_reached", False) is False
+        response.render()
+        assert getattr(request, "process_response_reached", False)
+        # process_response saw the rendered content
+        assert request.process_response_content == b"Hello world"
+
+    async def test_full_sync_dec_templateresponse_async(self, async_rf):
+        """
+        All methods of middleware are called for TemplateResponses in
+        the right sequence.
+        """
+
+        @full_sync_dec
+        async def template_response_view(request):
+            template = engines["django"].from_string("Hello world")
+            return TemplateResponse(request, template)
+
+        request = async_rf.get("/")
+        response = await template_response_view(request)
+        assert getattr(request, "process_request_reached", False)
+        assert getattr(request, "process_view_reached", False)
+        assert getattr(request, "process_template_response_reached", False)
+        # response must not be rendered yet.
+        assert response._is_rendered is False
+        # process_response must not be called until after response is rendered,
+        # otherwise some decorators like csrf_protect and gzip_page will not
+        # work correctly. See #16004
+        assert getattr(request, "process_response_reached", False) is False
+        await sync_to_async(response.render)()
+        assert getattr(request, "process_response_reached", False)
+        # process_response saw the rendered content
+        assert request.process_response_content == b"Hello world"