Make show toolbar callback function async/sync compatible.

debug_toolbar/decorators.py

@@ -11,7 +11,7 @@ def require_show_toolbar(view):
     def inner(request, *args, **kwargs):
         from debug_toolbar.middleware import get_show_toolbar
 
-        show_toolbar = get_show_toolbar()
+        show_toolbar = get_show_toolbar(async_mode=False)
         if not show_toolbar(request):
             raise Http404
 

debug_toolbar/middleware.py

@@ -6,7 +6,12 @@
 import socket
 from functools import cache
 
-from asgiref.sync import iscoroutinefunction, markcoroutinefunction
+from asgiref.sync import (
+    async_to_sync,
+    iscoroutinefunction,
+    markcoroutinefunction,
+    sync_to_async,
+)
 from django.conf import settings
 from django.utils.module_loading import import_string
 
@@ -47,7 +52,12 @@ def show_toolbar(request):
 
 
 @cache
-def get_show_toolbar():
+def show_toolbar_func_or_path():
+    """
+    Fetch the show toolbar callback from settings
+
+    Cached to avoid importing multiple times.
+    """
     # If SHOW_TOOLBAR_CALLBACK is a string, which is the recommended
     # setup, resolve it to the corresponding callable.
     func_or_path = dt_settings.get_config()["SHOW_TOOLBAR_CALLBACK"]
@@ -57,6 +67,23 @@ def get_show_toolbar():
         return func_or_path
 
 
+def get_show_toolbar(async_mode):
+    """
+    Get the callback function to show the toolbar.
+
+    Will wrap the function with sync_to_async or
+    async_to_sync depending on the status of async_mode
+    and whether the underlying function is a coroutine.
+    """
+    show_toolbar = show_toolbar_func_or_path()
+    is_coroutine = iscoroutinefunction(show_toolbar)
+    if is_coroutine and not async_mode:
+        show_toolbar = async_to_sync(show_toolbar)
+    elif not is_coroutine and async_mode:
+        show_toolbar = sync_to_async(show_toolbar)
+    return show_toolbar
+
+
 class DebugToolbarMiddleware:
     """
     Middleware to set up Debug Toolbar on incoming request and render toolbar
@@ -82,7 +109,8 @@ def __call__(self, request):
         if self.async_mode:
             return self.__acall__(request)
         # Decide whether the toolbar is active for this request.
-        show_toolbar = get_show_toolbar()
+        show_toolbar = get_show_toolbar(async_mode=self.async_mode)
+
         if not show_toolbar(request) or DebugToolbar.is_toolbar_request(request):
             return self.get_response(request)
         toolbar = DebugToolbar(request, self.get_response)
@@ -103,8 +131,9 @@ def __call__(self, request):
 
     async def __acall__(self, request):
         # Decide whether the toolbar is active for this request.
-        show_toolbar = get_show_toolbar()
-        if not show_toolbar(request) or DebugToolbar.is_toolbar_request(request):
+        show_toolbar = get_show_toolbar(async_mode=self.async_mode)
+
+        if not await show_toolbar(request) or DebugToolbar.is_toolbar_request(request):
             response = await self.get_response(request)
             return response
 

docs/changes.rst

@@ -5,6 +5,8 @@ Pending
 -------
 
 * Added Django 5.2 to the tox matrix.
+* Wrap ``SHOW_TOOLBAR_CALLBACK`` function with ``sync_to_async``
+  or ``async_to_sync`` to allow sync/async compatibility.
 
 5.0.1 (2025-01-13)
 ------------------

tests/test_middleware.py

@@ -0,0 +1,93 @@
+import asyncio
+from unittest.mock import patch
+
+from django.contrib.auth.models import User
+from django.http import HttpResponse
+from django.test import AsyncRequestFactory, RequestFactory, TestCase, override_settings
+
+from debug_toolbar.middleware import DebugToolbarMiddleware
+
+
+def show_toolbar_if_staff(request):
+    # Hit the database, but always return True
+    return User.objects.exists() or True
+
+
+async def ashow_toolbar_if_staff(request):
+    # Hit the database, but always return True
+    has_users = await User.objects.afirst()
+    return has_users or True
+
+
+class MiddlewareSyncAsyncCompatibilityTestCase(TestCase):
+    def setUp(self):
+        self.factory = RequestFactory()
+        self.async_factory = AsyncRequestFactory()
+
+    @override_settings(DEBUG=True)
+    def test_sync_mode(self):
+        """
+        test middleware switches to sync (__call__) based on get_response type
+        """
+
+        request = self.factory.get("/")
+        middleware = DebugToolbarMiddleware(
+            lambda x: HttpResponse("<html><body>Test app</body></html>")
+        )
+
+        self.assertFalse(asyncio.iscoroutinefunction(middleware))
+
+        response = middleware(request)
+        self.assertEqual(response.status_code, 200)
+        self.assertIn(b"djdt", response.content)
+
+    @override_settings(DEBUG=True)
+    async def test_async_mode(self):
+        """
+        test middleware switches to async (__acall__) based on get_response type
+        and returns a coroutine
+        """
+
+        async def get_response(request):
+            return HttpResponse("<html><body>Test app</body></html>")
+
+        middleware = DebugToolbarMiddleware(get_response)
+        request = self.async_factory.get("/")
+
+        self.assertTrue(asyncio.iscoroutinefunction(middleware))
+
+        response = await middleware(request)
+        self.assertEqual(response.status_code, 200)
+        self.assertIn(b"djdt", response.content)
+
+    @override_settings(DEBUG=True)
+    @patch(
+        "debug_toolbar.middleware.show_toolbar_func_or_path",
+        return_value=ashow_toolbar_if_staff,
+    )
+    def test_async_show_toolbar_callback_sync_middleware(self, mocked_show):
+        def get_response(request):
+            return HttpResponse("<html><body>Hello world</body></html>")
+
+        middleware = DebugToolbarMiddleware(get_response)
+
+        request = self.factory.get("/")
+        response = middleware(request)
+        self.assertEqual(response.status_code, 200)
+        self.assertIn(b"djdt", response.content)
+
+    @override_settings(DEBUG=True)
+    @patch(
+        "debug_toolbar.middleware.show_toolbar_func_or_path",
+        return_value=show_toolbar_if_staff,
+    )
+    async def test_sync_show_toolbar_callback_async_middleware(self, mocked_show):
+        async def get_response(request):
+            return HttpResponse("<html><body>Hello world</body></html>")
+
+        middleware = DebugToolbarMiddleware(get_response)
+
+        request = self.async_factory.get("/")
+        response = await middleware(request)
+        self.assertEqual(response.status_code, 200)
+        self.assertIn(b"djdt", response.content)