Drop Django < 3.2, modernize the code

Add pyupgrade and django-upgrade to automatically take advantage of new
features of Python and Django.

Author: matthiask

.pre-commit-config.yaml

@@ -14,6 +14,16 @@ repos:
     rev: 0.10.1
     hooks:
     -   id: doc8
+-   repo: https://github.com/asottile/pyupgrade
+    rev: v2.29.1
+    hooks:
+    -   id: pyupgrade
+        args: [--py36-plus]
+-   repo: https://github.com/adamchainz/django-upgrade
+    rev: 1.4.0
+    hooks:
+    -   id: django-upgrade
+        args: [--target-version, "3.2"]
 -   repo: https://github.com/pycqa/isort
     rev: 5.10.1
     hooks:

README.rst

@@ -45,7 +45,7 @@ In addition to the built-in panels, a number of third-party panels are
 contributed by the community.
 
 The current stable version of the Debug Toolbar is 3.2.4. It works on
-Django ≥ 2.2.
+Django ≥ 3.2.
 
 Documentation, including installation and configuration instructions, is
 available at https://django-debug-toolbar.readthedocs.io/.

debug_toolbar/__init__.py

@@ -1,5 +1,3 @@
-import django
-
 from debug_toolbar.urls import app_name
 
 __all__ = ["VERSION"]
@@ -12,6 +10,3 @@
 # Code that discovers files or modules in INSTALLED_APPS imports this module.
 
 urls = "debug_toolbar.urls", app_name
-
-if django.VERSION < (3, 2):
-    default_app_config = "debug_toolbar.apps.DebugToolbarConfig"

debug_toolbar/management/commands/debugsqlshell.py

@@ -1,11 +1,10 @@
 from time import time
 
-import django
 import sqlparse
 from django.core.management.commands.shell import Command
 from django.db import connection
 
-if connection.vendor == "postgresql" and django.VERSION >= (3, 0, 0):
+if connection.vendor == "postgresql":
     from django.db.backends.postgresql import base as base_module
 else:
     from django.db.backends import utils as base_module
@@ -28,7 +27,7 @@ def execute(self, sql, params=()):
             end_time = time()
             duration = (end_time - start_time) * 1000
             formatted_sql = sqlparse.format(raw_sql, reindent=True)
-            print("{} [{:.2f}ms]".format(formatted_sql, duration))
+            print(f"{formatted_sql} [{duration:.2f}ms]")
 
 
 base_module.CursorDebugWrapper = PrintQueryWrapper

debug_toolbar/panels/cache.py

@@ -8,15 +8,9 @@
 except ImportError:
     ConnectionProxy = None
 
-import django
 from django.conf import settings
 from django.core import cache
-from django.core.cache import (
-    DEFAULT_CACHE_ALIAS,
-    CacheHandler,
-    cache as original_cache,
-    caches as original_caches,
-)
+from django.core.cache import DEFAULT_CACHE_ALIAS, CacheHandler
 from django.core.cache.backends.base import BaseCache
 from django.dispatch import Signal
 from django.middleware import cache as middleware_cache
@@ -69,7 +63,7 @@ def __init__(self, cache):
         self.cache = cache
 
     def __repr__(self):
-        return str("<CacheStatTracker for %s>") % repr(self.cache)
+        return "<CacheStatTracker for %s>" % repr(self.cache)
 
     def _get_func_info(self):
         frame = sys._getframe(3)
@@ -141,26 +135,17 @@ def decr_version(self, *args, **kwargs):
         return self.cache.decr_version(*args, **kwargs)
 
 
-if django.VERSION < (3, 2):
+class CacheHandlerPatch(CacheHandler):
+    def __init__(self, settings=None):
+        self._djdt_wrap = True
+        super().__init__(settings=settings)
 
-    class CacheHandlerPatch(CacheHandler):
-        def __getitem__(self, alias):
-            actual_cache = super().__getitem__(alias)
+    def create_connection(self, alias):
+        actual_cache = super().create_connection(alias)
+        if self._djdt_wrap:
             return CacheStatTracker(actual_cache)
-
-else:
-
-    class CacheHandlerPatch(CacheHandler):
-        def __init__(self, settings=None):
-            self._djdt_wrap = True
-            super().__init__(settings=settings)
-
-        def create_connection(self, alias):
-            actual_cache = super().create_connection(alias)
-            if self._djdt_wrap:
-                return CacheStatTracker(actual_cache)
-            else:
-                return actual_cache
+        else:
+            return actual_cache
 
 
 middleware_cache.caches = CacheHandlerPatch()
@@ -268,40 +253,26 @@ def title(self):
         )
 
     def enable_instrumentation(self):
-        if django.VERSION < (3, 2):
-            if isinstance(middleware_cache.caches, CacheHandlerPatch):
-                cache.caches = middleware_cache.caches
-            else:
-                cache.caches = CacheHandlerPatch()
-        else:
-            for alias in cache.caches:
-                if not isinstance(cache.caches[alias], CacheStatTracker):
-                    cache.caches[alias] = CacheStatTracker(cache.caches[alias])
+        for alias in cache.caches:
+            if not isinstance(cache.caches[alias], CacheStatTracker):
+                cache.caches[alias] = CacheStatTracker(cache.caches[alias])
 
-            if not isinstance(middleware_cache.caches, CacheHandlerPatch):
-                middleware_cache.caches = cache.caches
+        if not isinstance(middleware_cache.caches, CacheHandlerPatch):
+            middleware_cache.caches = cache.caches
 
         # Wrap the patched cache inside Django's ConnectionProxy
         if ConnectionProxy:
             cache.cache = ConnectionProxy(cache.caches, DEFAULT_CACHE_ALIAS)
 
     def disable_instrumentation(self):
-        if django.VERSION < (3, 2):
-            cache.caches = original_caches
-            cache.cache = original_cache
-            # While it can be restored to the original, any views that were
-            # wrapped with the cache_page decorator will continue to use a
-            # monkey patched cache.
-            middleware_cache.caches = original_caches
-        else:
-            for alias in cache.caches:
-                if isinstance(cache.caches[alias], CacheStatTracker):
-                    cache.caches[alias] = cache.caches[alias].cache
-            if ConnectionProxy:
-                cache.cache = ConnectionProxy(cache.caches, DEFAULT_CACHE_ALIAS)
-            # While it can be restored to the original, any views that were
-            # wrapped with the cache_page decorator will continue to use a
-            # monkey patched cache.
+        for alias in cache.caches:
+            if isinstance(cache.caches[alias], CacheStatTracker):
+                cache.caches[alias] = cache.caches[alias].cache
+        if ConnectionProxy:
+            cache.cache = ConnectionProxy(cache.caches, DEFAULT_CACHE_ALIAS)
+        # While it can be restored to the original, any views that were
+        # wrapped with the cache_page decorator will continue to use a
+        # monkey patched cache.
 
     def generate_stats(self, request, response):
         self.record_stats(

debug_toolbar/panels/profiling.py

@@ -30,7 +30,7 @@ def parent_classes(self):
 
     def background(self):
         r, g, b = hsv_to_rgb(*self.hsv)
-        return "rgb({:f}%,{:f}%,{:f}%)".format(r * 100, g * 100, b * 100)
+        return f"rgb({r * 100:f}%,{g * 100:f}%,{b * 100:f}%)"
 
     def func_std_string(self):  # match what old profile produced
         func_name = self.func

debug_toolbar/panels/settings.py

@@ -1,17 +1,12 @@
 from collections import OrderedDict
 
-import django
 from django.conf import settings
 from django.utils.translation import gettext_lazy as _
+from django.views.debug import get_default_exception_reporter_filter
 
 from debug_toolbar.panels import Panel
 
-if django.VERSION >= (3, 1):
-    from django.views.debug import get_default_exception_reporter_filter
-
-    get_safe_settings = get_default_exception_reporter_filter().get_safe_settings
-else:
-    from django.views.debug import get_safe_settings
+get_safe_settings = get_default_exception_reporter_filter().get_safe_settings
 
 
 class SettingsPanel(Panel):

debug_toolbar/panels/signals.py

@@ -97,7 +97,7 @@ def generate_stats(self, request, response):
                     receiver_class_name = getattr(
                         receiver.__self__, "__class__", type
                     ).__name__
-                    text = "{}.{}".format(receiver_class_name, receiver_name)
+                    text = f"{receiver_class_name}.{receiver_name}"
                 else:
                     text = receiver_name
                 receivers.append(text)

debug_toolbar/panels/sql/tracking.py

@@ -17,8 +17,6 @@
 class SQLQueryTriggered(Exception):
     """Thrown when template panel triggers a query"""
 
-    pass
-
 
 class ThreadLocalState(local):
     def __init__(self):

debug_toolbar/panels/sql/utils.py

@@ -26,8 +26,8 @@ def reformat_sql(sql, with_toggle=False):
     if not with_toggle:
         return formatted
     simple = simplify(parse_sql(sql, aligned_indent=False))
-    uncollapsed = '<span class="djDebugUncollapsed">{}</span>'.format(simple)
-    collapsed = '<span class="djDebugCollapsed djdt-hidden">{}</span>'.format(formatted)
+    uncollapsed = f'<span class="djDebugUncollapsed">{simple}</span>'
+    collapsed = f'<span class="djDebugCollapsed djdt-hidden">{formatted}</span>'
     return collapsed + uncollapsed
 
 

debug_toolbar/panels/sql/views.py

@@ -49,11 +49,11 @@ def sql_explain(request, verified_data):
                 # SQLite's EXPLAIN dumps the low-level opcodes generated for a query;
                 # EXPLAIN QUERY PLAN dumps a more human-readable summary
                 # See https://www.sqlite.org/lang_explain.html for details
-                cursor.execute("EXPLAIN QUERY PLAN {}".format(sql), params)
+                cursor.execute(f"EXPLAIN QUERY PLAN {sql}", params)
             elif vendor == "postgresql":
-                cursor.execute("EXPLAIN ANALYZE {}".format(sql), params)
+                cursor.execute(f"EXPLAIN ANALYZE {sql}", params)
             else:
-                cursor.execute("EXPLAIN {}".format(sql), params)
+                cursor.execute(f"EXPLAIN {sql}", params)
             headers = [d[0] for d in cursor.description]
             result = cursor.fetchall()
 

debug_toolbar/panels/templates/panel.py

@@ -42,7 +42,7 @@ def _request_context_bind_template(self, template):
     self.context_processors = OrderedDict()
     updates = {}
     for processor in processors:
-        name = "{}.{}".format(processor.__module__, processor.__name__)
+        name = f"{processor.__module__}.{processor.__name__}"
         context = processor(self.request)
         self.context_processors[name] = context
         updates.update(context)

debug_toolbar/panels/templates/views.py

@@ -44,7 +44,7 @@ def template_source(request):
         except TemplateDoesNotExist:
             pass
     else:
-        source = "Template Does Not Exist: {}".format(template_origin_name)
+        source = f"Template Does Not Exist: {template_origin_name}"
 
     try:
         from pygments import highlight

debug_toolbar/utils.py

@@ -27,7 +27,7 @@ def get_module_path(module_name):
     try:
         module = import_module(module_name)
     except ImportError as e:
-        raise ImproperlyConfigured("Error importing HIDE_IN_STACKTRACES: {}".format(e))
+        raise ImproperlyConfigured(f"Error importing HIDE_IN_STACKTRACES: {e}")
     else:
         source_path = inspect.getsourcefile(module)
         if source_path.endswith("__init__.py"):
@@ -157,7 +157,7 @@ def get_name_from_obj(obj):
 
     if hasattr(obj, "__module__"):
         module = obj.__module__
-        name = "{}.{}".format(module, name)
+        name = f"{module}.{name}"
 
     return name
 

tests/commands/test_debugsqlshell.py

@@ -1,14 +1,13 @@
 import io
 import sys
 
-import django
 from django.contrib.auth.models import User
 from django.core import management
 from django.db import connection
 from django.test import TestCase
 from django.test.utils import override_settings
 
-if connection.vendor == "postgresql" and django.VERSION >= (3, 0, 0):
+if connection.vendor == "postgresql":
     from django.db.backends.postgresql import base as base_module
 else:
     from django.db.backends import utils as base_module

tests/models.py

@@ -11,19 +11,8 @@ class Binary(models.Model):
     field = models.BinaryField()
 
 
-try:
-    from django.db.models import JSONField
-except ImportError:  # Django<3.1
-    try:
-        from django.contrib.postgres.fields import JSONField
-    except ImportError:  # psycopg2 not installed
-        JSONField = None
-
-
-if JSONField:
-
-    class PostgresJSON(models.Model):
-        field = JSONField()
+class JSON(models.Model):
+    field = models.JSONField()
 
 
 if settings.USE_GIS: