Add function docstrings

Author: salty-ivy

debug_toolbar/middleware.py

@@ -79,38 +79,21 @@ def __init__(self, get_response):
             # __call__ to avoid swapping out dunder methods.
             markcoroutinefunction(self)
 
-    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()
-        if not show_toolbar(request) or DebugToolbar.is_toolbar_request(request):
-            return self.get_response(request)
-
-        toolbar = DebugToolbar(request, self.get_response)
-
-        # Activate instrumentation ie. monkey-patch.
-        for panel in toolbar.enabled_panels:
-            panel.enable_instrumentation()
-        try:
-            # Run panels like Django middleware.
-            response = toolbar.process_request(request)
-        finally:
-            clear_stack_trace_caches()
-            # Deactivate instrumentation ie. monkey-unpatch. This must run
-            # regardless of the response. Keep 'return' clauses below.
-            for panel in reversed(toolbar.enabled_panels):
-                panel.disable_instrumentation()
+    async def aget_response(self, request):
+        return await self.get_response(request)
 
-        return self._postprocess(request, response, toolbar)
+    async def aprocess_request(self, toolbar, request):
+        return await toolbar.process_request(request)
 
-    async def __acall__(self, request):
+    def __call__(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):
-            response = await self.get_response(request)
-            return response
+            return (
+                self.aget_response(request)
+                if self.async_mode
+                else self.get_response(request)
+            )
 
         toolbar = DebugToolbar(request, self.get_response)
 
@@ -119,20 +102,18 @@ async def __acall__(self, request):
             panel.enable_instrumentation()
         try:
             # Run panels like Django middleware.
-            response = await toolbar.process_request(request)
+            response = (
+                self.aprocess_request(toolbar, request)
+                if self.async_mode
+                else toolbar.process_request(request)
+            )
         finally:
             clear_stack_trace_caches()
             # Deactivate instrumentation ie. monkey-unpatch. This must run
             # regardless of the response. Keep 'return' clauses below.
             for panel in reversed(toolbar.enabled_panels):
                 panel.disable_instrumentation()
 
-        return self._postprocess(request, response, toolbar)
-
-    def _postprocess(self, request, response, toolbar):
-        """
-        Post-process the response.
-        """
         # Generate the stats for all requests when the toolbar is being shown,
         # but not necessarily inserted.
         for panel in reversed(toolbar.enabled_panels):
@@ -168,6 +149,69 @@ def _postprocess(self, request, response, toolbar):
                 response["Content-Length"] = len(response.content)
         return response
 
+    # 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):
+    #         response = await self.get_response(request)
+    #         return response
+
+    #     toolbar = DebugToolbar(request, self.get_response)
+
+    #     # Activate instrumentation ie. monkey-patch.
+    #     for panel in toolbar.enabled_panels:
+    #         panel.enable_instrumentation()
+    #     try:
+    #         # Run panels like Django middleware.
+    #         response = await toolbar.process_request(request)
+    #     finally:
+    #         clear_stack_trace_caches()
+    #         # Deactivate instrumentation ie. monkey-unpatch. This must run
+    #         # regardless of the response. Keep 'return' clauses below.
+    #         for panel in reversed(toolbar.enabled_panels):
+    #             panel.disable_instrumentation()
+
+    #     return self._postprocess(request, response, toolbar)
+
+    # def _postprocess(self, request, response, toolbar):
+    #     """
+    #     Post-process the response.
+    #     """
+    #     # Generate the stats for all requests when the toolbar is being shown,
+    #     # but not necessarily inserted.
+    #     for panel in reversed(toolbar.enabled_panels):
+    #         panel.generate_stats(request, response)
+    #         panel.generate_server_timing(request, response)
+
+    #     # Always render the toolbar for the history panel, even if it is not
+    #     # included in the response.
+    #     rendered = toolbar.render_toolbar()
+
+    #     for header, value in self.get_headers(request, toolbar.enabled_panels).items():
+    #         response.headers[header] = value
+
+    #     # Check for responses where the toolbar can't be inserted.
+    #     content_encoding = response.get("Content-Encoding", "")
+    #     content_type = response.get("Content-Type", "").split(";")[0]
+    #     if (
+    #         getattr(response, "streaming", False)
+    #         or content_encoding != ""
+    #         or content_type not in _HTML_TYPES
+    #     ):
+    #         return response
+
+    #     # Insert the toolbar in the response.
+    #     content = response.content.decode(response.charset)
+    #     insert_before = dt_settings.get_config()["INSERT_BEFORE"]
+    #     pattern = re.escape(insert_before)
+    #     bits = re.split(pattern, content, flags=re.IGNORECASE)
+    #     if len(bits) > 1:
+    #         bits[-2] += rendered
+    #         response.content = insert_before.join(bits)
+    #         if "Content-Length" in response:
+    #             response["Content-Length"] = len(response.content)
+    #     return response
+
     @staticmethod
     def get_headers(request, panels):
         headers = {}

tests/panels/test_async_panel_compatibility.py

@@ -7,6 +7,12 @@
 
 
 def set_custom_toolbar_config():
+    """
+    Set custom toolbar configuration.
+
+    Returns a new configuration with DISABLE_PANELS set to an empty dictionary.
+    This allows all panels to be enabled by default.
+    """
     new_settings = dt_settings.get_config().copy()
     new_settings["DISABLE_PANELS"] = {}
     return new_settings

tests/test_middleware_compatibility.py

@@ -12,24 +12,32 @@ def setUp(self):
         self.async_factory = AsyncRequestFactory()
 
     def test_sync_mode(self):
+        """
+        test middlware switches to sync (__call__) based on get_response type
+        """
+
         request = self.factory.get("/")
-        middleware = DebugToolbarMiddleware(lambda x: HttpResponse(""))
+        middleware = DebugToolbarMiddleware(
+            lambda x: HttpResponse("<html><body>Django debug toolbar</body></html>")
+        )
 
-        # test middlware switches to sync (__call__) based on get_response type
         self.assertFalse(asyncio.iscoroutinefunction(middleware))
 
         response = middleware(request)
         self.assertEqual(response.status_code, 200)
 
     async def test_async_mode(self):
+        """
+        test middlware switches to async (__acall__) based on get_response type
+        and returns a coroutine
+        """
+
         async def get_response(request):
             return HttpResponse("<html><body>Django debug toolbar</body></html>")
 
         middleware = DebugToolbarMiddleware(get_response)
         request = self.async_factory.get("/")
 
-        # test middlware switches to async (__acall__) based on get_response type
-        # and returns a coroutine
         self.assertTrue(asyncio.iscoroutinefunction(middleware))
 
         response = await middleware(request)