Refs #33476 -- Reformatted code with Black.

django/contrib/admindocs/apps.py

@@ -3,5 +3,5 @@ from django.utils.translation import gettext_lazy as _
 
 
 class AdminDocsConfig(AppConfig):
-    name = 'django.contrib.admindocs'
+    name = "django.contrib.admindocs"
     verbose_name = _("Administrative Documentation")

django/contrib/admindocs/middleware.py

@@ -10,6 +10,7 @@ class XViewMiddleware(MiddlewareMixin):
     """
     Add an X-View header to internal HEAD requests.
     """
+
     def process_view(self, request, view_func, view_args, view_kwargs):
         """
         If the request method is HEAD and either the IP is internal or the
@@ -17,14 +18,16 @@ class XViewMiddleware(MiddlewareMixin):
         header indicating the view function. This is used to lookup the view
         function for an arbitrary page.
         """
-        if not hasattr(request, 'user'):
+        if not hasattr(request, "user"):
             raise ImproperlyConfigured(
                 "The XView middleware requires authentication middleware to "
                 "be installed. Edit your MIDDLEWARE setting to insert "
                 "'django.contrib.auth.middleware.AuthenticationMiddleware'."
             )
-        if request.method == 'HEAD' and (request.META.get('REMOTE_ADDR') in settings.INTERNAL_IPS or
-                                         (request.user.is_active and request.user.is_staff)):
+        if request.method == "HEAD" and (
+            request.META.get("REMOTE_ADDR") in settings.INTERNAL_IPS
+            or (request.user.is_active and request.user.is_staff)
+        ):
             response = HttpResponse()
-            response.headers['X-View'] = get_view_name(view_func)
+            response.headers["X-View"] = get_view_name(view_func)
             return response

django/contrib/admindocs/urls.py

@@ -3,48 +3,48 @@ from django.urls import path, re_path
 
 urlpatterns = [
     path(
-        '',
-        views.BaseAdminDocsView.as_view(template_name='admin_doc/index.html'),
-        name='django-admindocs-docroot',
+        "",
+        views.BaseAdminDocsView.as_view(template_name="admin_doc/index.html"),
+        name="django-admindocs-docroot",
     ),
     path(
-        'bookmarklets/',
+        "bookmarklets/",
         views.BookmarkletsView.as_view(),
-        name='django-admindocs-bookmarklets',
+        name="django-admindocs-bookmarklets",
     ),
     path(
-        'tags/',
+        "tags/",
         views.TemplateTagIndexView.as_view(),
-        name='django-admindocs-tags',
+        name="django-admindocs-tags",
     ),
     path(
-        'filters/',
+        "filters/",
         views.TemplateFilterIndexView.as_view(),
-        name='django-admindocs-filters',
+        name="django-admindocs-filters",
     ),
     path(
-        'views/',
+        "views/",
         views.ViewIndexView.as_view(),
-        name='django-admindocs-views-index',
+        name="django-admindocs-views-index",
     ),
     path(
-        'views/<view>/',
+        "views/<view>/",
         views.ViewDetailView.as_view(),
-        name='django-admindocs-views-detail',
+        name="django-admindocs-views-detail",
     ),
     path(
-        'models/',
+        "models/",
         views.ModelIndexView.as_view(),
-        name='django-admindocs-models-index',
+        name="django-admindocs-models-index",
     ),
     re_path(
-        r'^models/(?P<app_label>[^\.]+)\.(?P<model_name>[^/]+)/$',
+        r"^models/(?P<app_label>[^\.]+)\.(?P<model_name>[^/]+)/$",
         views.ModelDetailView.as_view(),
-        name='django-admindocs-models-detail',
+        name="django-admindocs-models-detail",
     ),
     path(
-        'templates/<path:template>/',
+        "templates/<path:template>/",
         views.TemplateDetailView.as_view(),
-        name='django-admindocs-templates',
+        name="django-admindocs-templates",
     ),
 ]

django/contrib/admindocs/utils.py

@@ -20,12 +20,12 @@ else:
 
 
 def get_view_name(view_func):
-    if hasattr(view_func, 'view_class'):
+    if hasattr(view_func, "view_class"):
         klass = view_func.view_class
-        return f'{klass.__module__}.{klass.__qualname__}'
+        return f"{klass.__module__}.{klass.__qualname__}"
     mod_name = view_func.__module__
-    view_name = getattr(view_func, '__qualname__', view_func.__class__.__name__)
-    return mod_name + '.' + view_name
+    view_name = getattr(view_func, "__qualname__", view_func.__class__.__name__)
+    return mod_name + "." + view_name
 
 
 def parse_docstring(docstring):
@@ -33,12 +33,12 @@ def parse_docstring(docstring):
     Parse out the parts of a docstring.  Return (title, body, metadata).
     """
     if not docstring:
-        return '', '', {}
+        return "", "", {}
     docstring = cleandoc(docstring)
-    parts = re.split(r'\n{2,}', docstring)
+    parts = re.split(r"\n{2,}", docstring)
     title = parts[0]
     if len(parts) == 1:
-        body = ''
+        body = ""
         metadata = {}
     else:
         parser = HeaderParser()
@@ -61,14 +61,14 @@ def parse_rst(text, default_reference_context, thing_being_parsed=None):
     Convert the string from reST to an XHTML fragment.
     """
     overrides = {
-        'doctitle_xform': True,
-        'initial_header_level': 3,
+        "doctitle_xform": True,
+        "initial_header_level": 3,
         "default_reference_context": default_reference_context,
-        "link_base": reverse('django-admindocs-docroot').rstrip('/'),
-        'raw_enabled': False,
-        'file_insertion_enabled': False,
+        "link_base": reverse("django-admindocs-docroot").rstrip("/"),
+        "raw_enabled": False,
+        "file_insertion_enabled": False,
     }
-    thing_being_parsed = thing_being_parsed and '<%s>' % thing_being_parsed
+    thing_being_parsed = thing_being_parsed and "<%s>" % thing_being_parsed
     # Wrap ``text`` in some reST that sets the default role to ``cmsreference``,
     # then restores it.
     source = """
@@ -80,21 +80,23 @@ def parse_rst(text, default_reference_context, thing_being_parsed=None):
 """
     parts = docutils.core.publish_parts(
         source % text,
-        source_path=thing_being_parsed, destination_path=None,
-        writer_name='html', settings_overrides=overrides,
+        source_path=thing_being_parsed,
+        destination_path=None,
+        writer_name="html",
+        settings_overrides=overrides,
     )
-    return mark_safe(parts['fragment'])
+    return mark_safe(parts["fragment"])
 
 
 #
 # reST roles
 #
 ROLES = {
-    'model': '%s/models/%s/',
-    'view': '%s/views/%s/',
-    'template': '%s/templates/%s/',
-    'filter': '%s/filters/#%s',
-    'tag': '%s/tags/#%s',
+    "model": "%s/models/%s/",
+    "view": "%s/views/%s/",
+    "template": "%s/templates/%s/",
+    "filter": "%s/filters/#%s",
+    "tag": "%s/tags/#%s",
 }
 
 
@@ -105,48 +107,59 @@ def create_reference_role(rolename, urlbase):
         node = docutils.nodes.reference(
             rawtext,
             text,
-            refuri=(urlbase % (
-                inliner.document.settings.link_base,
-                text.lower(),
-            )),
-            **options
+            refuri=(
+                urlbase
+                % (
+                    inliner.document.settings.link_base,
+                    text.lower(),
+                )
+            ),
+            **options,
         )
         return [node], []
+
     docutils.parsers.rst.roles.register_canonical_role(rolename, _role)
 
 
-def default_reference_role(name, rawtext, text, lineno, inliner, options=None, content=None):
+def default_reference_role(
+    name, rawtext, text, lineno, inliner, options=None, content=None
+):
     if options is None:
         options = {}
     context = inliner.document.settings.default_reference_context
     node = docutils.nodes.reference(
         rawtext,
         text,
-        refuri=(ROLES[context] % (
-            inliner.document.settings.link_base,
-            text.lower(),
-        )),
-        **options
+        refuri=(
+            ROLES[context]
+            % (
+                inliner.document.settings.link_base,
+                text.lower(),
+            )
+        ),
+        **options,
     )
     return [node], []
 
 
 if docutils_is_available:
-    docutils.parsers.rst.roles.register_canonical_role('cmsreference', default_reference_role)
+    docutils.parsers.rst.roles.register_canonical_role(
+        "cmsreference", default_reference_role
+    )
 
     for name, urlbase in ROLES.items():
         create_reference_role(name, urlbase)
 
 # Match the beginning of a named, unnamed, or non-capturing groups.
-named_group_matcher = _lazy_re_compile(r'\(\?P(<\w+>)')
-unnamed_group_matcher = _lazy_re_compile(r'\(')
-non_capturing_group_matcher = _lazy_re_compile(r'\(\?\:')
+named_group_matcher = _lazy_re_compile(r"\(\?P(<\w+>)")
+unnamed_group_matcher = _lazy_re_compile(r"\(")
+non_capturing_group_matcher = _lazy_re_compile(r"\(\?\:")
 
 
 def replace_metacharacters(pattern):
     """Remove unescaped metacharacters from the pattern."""
     return re.sub(
-        r'((?:^|(?<!\\))(?:\\\\)*)(\\?)([?*+^$]|\\[bBAZ])',
+        r"((?:^|(?<!\\))(?:\\\\)*)(\\?)([?*+^$]|\\[bBAZ])",
         lambda m: m[1] + m[3] if m[2] else m[1],
         pattern,
     )
@@ -158,9 +171,9 @@ def _get_group_start_end(start, end, pattern):
     for idx, val in enumerate(pattern[end:]):
         # Check for unescaped `(` and `)`. They mark the start and end of a
         # nested group.
-        if val == '(' and prev_char != '\\':
+        if val == "(" and prev_char != "\\":
             unmatched_open_brackets += 1
-        elif val == ')' and prev_char != '\\':
+        elif val == ")" and prev_char != "\\":
             unmatched_open_brackets -= 1
         prev_char = val
         # If brackets are balanced, the end of the string for the current named
@@ -204,11 +217,11 @@ def replace_unnamed_groups(pattern):
     3. ^(?P<a>\w+)/b/(\w+) ==> ^(?P<a>\w+)/b/<var>
     4. ^(?P<a>\w+)/b/((x|y)\w+) ==> ^(?P<a>\w+)/b/<var>
     """
-    final_pattern, prev_end = '', None
+    final_pattern, prev_end = "", None
     for start, end, _ in _find_groups(pattern, unnamed_group_matcher):
         if prev_end:
             final_pattern += pattern[prev_end:start]
-        final_pattern += pattern[:start] + '<var>'
+        final_pattern += pattern[:start] + "<var>"
         prev_end = end
     return final_pattern + pattern[prev_end:]
 
@@ -221,7 +234,7 @@ def remove_non_capturing_groups(pattern):
     3. ^a(?:\w+)/b(?:\w+) => ^a/b
     """
     group_start_end_indices = _find_groups(pattern, non_capturing_group_matcher)
-    final_pattern, prev_end = '', None
+    final_pattern, prev_end = "", None
     for start, end, _ in group_start_end_indices:
         final_pattern += pattern[prev_end:start]
         prev_end = end

django/contrib/admindocs/views.py

@@ -8,7 +8,9 @@ from django.contrib import admin
 from django.contrib.admin.views.decorators import staff_member_required
 from django.contrib.admindocs import utils
 from django.contrib.admindocs.utils import (
-    remove_non_capturing_groups, replace_metacharacters, replace_named_groups,
+    remove_non_capturing_groups,
+    replace_metacharacters,
+    replace_named_groups,
     replace_unnamed_groups,
 )
 from django.core.exceptions import ImproperlyConfigured, ViewDoesNotExist
@@ -20,7 +22,9 @@ from django.utils._os import safe_join
 from django.utils.decorators import method_decorator
 from django.utils.functional import cached_property
 from django.utils.inspect import (
-    func_accepts_kwargs, func_accepts_var_args, get_func_full_args,
+    func_accepts_kwargs,
+    func_accepts_var_args,
+    get_func_full_args,
     method_has_no_args,
 )
 from django.utils.translation import gettext as _
@@ -29,34 +33,37 @@ from django.views.generic import TemplateView
 from .utils import get_view_name
 
 # Exclude methods starting with these strings from documentation
-MODEL_METHODS_EXCLUDE = ('_', 'add_', 'delete', 'save', 'set_')
+MODEL_METHODS_EXCLUDE = ("_", "add_", "delete", "save", "set_")
 
 
 class BaseAdminDocsView(TemplateView):
     """
     Base view for admindocs views.
     """
+
     @method_decorator(staff_member_required)
     def dispatch(self, request, *args, **kwargs):
         if not utils.docutils_is_available:
             # Display an error message for people without docutils
-            self.template_name = 'admin_doc/missing_docutils.html'
+            self.template_name = "admin_doc/missing_docutils.html"
             return self.render_to_response(admin.site.each_context(request))
         return super().dispatch(request, *args, **kwargs)
 
     def get_context_data(self, **kwargs):
-        return super().get_context_data(**{
-            **kwargs,
-            **admin.site.each_context(self.request),
-        })
+        return super().get_context_data(
+            **{
+                **kwargs,
+                **admin.site.each_context(self.request),
+            }
+        )
 
 
 class BookmarkletsView(BaseAdminDocsView):
-    template_name = 'admin_doc/bookmarklets.html'
+    template_name = "admin_doc/bookmarklets.html"
 
 
 class TemplateTagIndexView(BaseAdminDocsView):
-    template_name = 'admin_doc/template_tag_index.html'
+    template_name = "admin_doc/template_tag_index.html"
 
     def get_context_data(self, **kwargs):
         tags = []
@@ -67,27 +74,33 @@ class TemplateTagIndexView(BaseAdminDocsView):
             pass
         else:
             app_libs = sorted(engine.template_libraries.items())
-            builtin_libs = [('', lib) for lib in engine.template_builtins]
+            builtin_libs = [("", lib) for lib in engine.template_builtins]
             for module_name, library in builtin_libs + app_libs:
                 for tag_name, tag_func in library.tags.items():
                     title, body, metadata = utils.parse_docstring(tag_func.__doc__)
-                    title = title and utils.parse_rst(title, 'tag', _('tag:') + tag_name)
-                    body = body and utils.parse_rst(body, 'tag', _('tag:') + tag_name)
+                    title = title and utils.parse_rst(
+                        title, "tag", _("tag:") + tag_name
+                    )
+                    body = body and utils.parse_rst(body, "tag", _("tag:") + tag_name)
                     for key in metadata:
-                        metadata[key] = utils.parse_rst(metadata[key], 'tag', _('tag:') + tag_name)
-                    tag_library = module_name.split('.')[-1]
-                    tags.append({
-                        'name': tag_name,
-                        'title': title,
-                        'body': body,
-                        'meta': metadata,
-                        'library': tag_library,
-                    })
-        return super().get_context_data(**{**kwargs, 'tags': tags})
+                        metadata[key] = utils.parse_rst(
+                            metadata[key], "tag", _("tag:") + tag_name
+                        )
+                    tag_library = module_name.split(".")[-1]
+                    tags.append(
+                        {
+                            "name": tag_name,
+                            "title": title,
+                            "body": body,
+                            "meta": metadata,
+                            "library": tag_library,
+                        }
+                    )
+        return super().get_context_data(**{**kwargs, "tags": tags})
 
 
 class TemplateFilterIndexView(BaseAdminDocsView):
-    template_name = 'admin_doc/template_filter_index.html'
+    template_name = "admin_doc/template_filter_index.html"
 
     def get_context_data(self, **kwargs):
         filters = []
@@ -98,27 +111,35 @@ class TemplateFilterIndexView(BaseAdminDocsView):
             pass
         else:
             app_libs = sorted(engine.template_libraries.items())
-            builtin_libs = [('', lib) for lib in engine.template_builtins]
+            builtin_libs = [("", lib) for lib in engine.template_builtins]
             for module_name, library in builtin_libs + app_libs:
                 for filter_name, filter_func in library.filters.items():
                     title, body, metadata = utils.parse_docstring(filter_func.__doc__)
-                    title = title and utils.parse_rst(title, 'filter', _('filter:') + filter_name)
-                    body = body and utils.parse_rst(body, 'filter', _('filter:') + filter_name)
+                    title = title and utils.parse_rst(
+                        title, "filter", _("filter:") + filter_name
+                    )
+                    body = body and utils.parse_rst(
+                        body, "filter", _("filter:") + filter_name
+                    )
                     for key in metadata:
-                        metadata[key] = utils.parse_rst(metadata[key], 'filter', _('filter:') + filter_name)
-                    tag_library = module_name.split('.')[-1]
-                    filters.append({
-                        'name': filter_name,
-                        'title': title,
-                        'body': body,
-                        'meta': metadata,
-                        'library': tag_library,
-                    })
-        return super().get_context_data(**{**kwargs, 'filters': filters})
+                        metadata[key] = utils.parse_rst(
+                            metadata[key], "filter", _("filter:") + filter_name
+                        )
+                    tag_library = module_name.split(".")[-1]
+                    filters.append(
+                        {
+                            "name": filter_name,
+                            "title": title,
+                            "body": body,
+                            "meta": metadata,
+                            "library": tag_library,
+                        }
+                    )
+        return super().get_context_data(**{**kwargs, "filters": filters})
 
 
 class ViewIndexView(BaseAdminDocsView):
-    template_name = 'admin_doc/view_index.html'
+    template_name = "admin_doc/view_index.html"
 
     def get_context_data(self, **kwargs):
         views = []
@@ -128,18 +149,20 @@ class ViewIndexView(BaseAdminDocsView):
         except ImproperlyConfigured:
             view_functions = []
         for (func, regex, namespace, name) in view_functions:
-            views.append({
-                'full_name': get_view_name(func),
-                'url': simplify_regex(regex),
-                'url_name': ':'.join((namespace or []) + (name and [name] or [])),
-                'namespace': ':'.join(namespace or []),
-                'name': name,
-            })
-        return super().get_context_data(**{**kwargs, 'views': views})
+            views.append(
+                {
+                    "full_name": get_view_name(func),
+                    "url": simplify_regex(regex),
+                    "url_name": ":".join((namespace or []) + (name and [name] or [])),
+                    "namespace": ":".join(namespace or []),
+                    "name": name,
+                }
+            )
+        return super().get_context_data(**{**kwargs, "views": views})
 
 
 class ViewDetailView(BaseAdminDocsView):
-    template_name = 'admin_doc/view_detail.html'
+    template_name = "admin_doc/view_detail.html"
 
     @staticmethod
     def _get_view_func(view):
@@ -159,52 +182,56 @@ class ViewDetailView(BaseAdminDocsView):
                 return getattr(getattr(import_module(mod), klass), func)
 
     def get_context_data(self, **kwargs):
-        view = self.kwargs['view']
+        view = self.kwargs["view"]
         view_func = self._get_view_func(view)
         if view_func is None:
             raise Http404
         title, body, metadata = utils.parse_docstring(view_func.__doc__)
-        title = title and utils.parse_rst(title, 'view', _('view:') + view)
-        body = body and utils.parse_rst(body, 'view', _('view:') + view)
+        title = title and utils.parse_rst(title, "view", _("view:") + view)
+        body = body and utils.parse_rst(body, "view", _("view:") + view)
         for key in metadata:
-            metadata[key] = utils.parse_rst(metadata[key], 'model', _('view:') + view)
-        return super().get_context_data(**{
-            **kwargs,
-            'name': view,
-            'summary': title,
-            'body': body,
-            'meta': metadata,
-        })
+            metadata[key] = utils.parse_rst(metadata[key], "model", _("view:") + view)
+        return super().get_context_data(
+            **{
+                **kwargs,
+                "name": view,
+                "summary": title,
+                "body": body,
+                "meta": metadata,
+            }
+        )
 
 
 class ModelIndexView(BaseAdminDocsView):
-    template_name = 'admin_doc/model_index.html'
+    template_name = "admin_doc/model_index.html"
 
     def get_context_data(self, **kwargs):
         m_list = [m._meta for m in apps.get_models()]
-        return super().get_context_data(**{**kwargs, 'models': m_list})
+        return super().get_context_data(**{**kwargs, "models": m_list})
 
 
 class ModelDetailView(BaseAdminDocsView):
-    template_name = 'admin_doc/model_detail.html'
+    template_name = "admin_doc/model_detail.html"
 
     def get_context_data(self, **kwargs):
-        model_name = self.kwargs['model_name']
+        model_name = self.kwargs["model_name"]
         # Get the model class.
         try:
-            app_config = apps.get_app_config(self.kwargs['app_label'])
+            app_config = apps.get_app_config(self.kwargs["app_label"])
         except LookupError:
             raise Http404(_("App %(app_label)r not found") % self.kwargs)
         try:
             model = app_config.get_model(model_name)
         except LookupError:
-            raise Http404(_("Model %(model_name)r not found in app %(app_label)r") % self.kwargs)
+            raise Http404(
+                _("Model %(model_name)r not found in app %(app_label)r") % self.kwargs
+            )
 
         opts = model._meta
 
         title, body, metadata = utils.parse_docstring(model.__doc__)
-        title = title and utils.parse_rst(title, 'model', _('model:') + model_name)
-        body = body and utils.parse_rst(body, 'model', _('model:') + model_name)
+        title = title and utils.parse_rst(title, "model", _("model:") + model_name)
+        body = body and utils.parse_rst(body, "model", _("model:") + model_name)
 
         # Gather fields/field descriptions.
         fields = []
@@ -215,45 +242,63 @@ class ModelDetailView(BaseAdminDocsView):
                 data_type = field.remote_field.model.__name__
                 app_label = field.remote_field.model._meta.app_label
                 verbose = utils.parse_rst(
-                    (_("the related `%(app_label)s.%(data_type)s` object") % {
-                        'app_label': app_label, 'data_type': data_type,
-                    }),
-                    'model',
-                    _('model:') + data_type,
+                    (
+                        _("the related `%(app_label)s.%(data_type)s` object")
+                        % {
+                            "app_label": app_label,
+                            "data_type": data_type,
+                        }
+                    ),
+                    "model",
+                    _("model:") + data_type,
                 )
             else:
                 data_type = get_readable_field_data_type(field)
                 verbose = field.verbose_name
-            fields.append({
-                'name': field.name,
-                'data_type': data_type,
-                'verbose': verbose or '',
-                'help_text': field.help_text,
-            })
+            fields.append(
+                {
+                    "name": field.name,
+                    "data_type": data_type,
+                    "verbose": verbose or "",
+                    "help_text": field.help_text,
+                }
+            )
 
         # Gather many-to-many fields.
         for field in opts.many_to_many:
             data_type = field.remote_field.model.__name__
             app_label = field.remote_field.model._meta.app_label
             verbose = _("related `%(app_label)s.%(object_name)s` objects") % {
-                'app_label': app_label,
-                'object_name': data_type,
+                "app_label": app_label,
+                "object_name": data_type,
             }
-            fields.append({
-                'name': "%s.all" % field.name,
-                "data_type": 'List',
-                'verbose': utils.parse_rst(_("all %s") % verbose, 'model', _('model:') + opts.model_name),
-            })
-            fields.append({
-                'name': "%s.count" % field.name,
-                'data_type': 'Integer',
-                'verbose': utils.parse_rst(_("number of %s") % verbose, 'model', _('model:') + opts.model_name),
-            })
+            fields.append(
+                {
+                    "name": "%s.all" % field.name,
+                    "data_type": "List",
+                    "verbose": utils.parse_rst(
+                        _("all %s") % verbose, "model", _("model:") + opts.model_name
+                    ),
+                }
+            )
+            fields.append(
+                {
+                    "name": "%s.count" % field.name,
+                    "data_type": "Integer",
+                    "verbose": utils.parse_rst(
+                        _("number of %s") % verbose,
+                        "model",
+                        _("model:") + opts.model_name,
+                    ),
+                }
+            )
 
         methods = []
         # Gather model methods.
         for func_name, func in model.__dict__.items():
-            if inspect.isfunction(func) or isinstance(func, (cached_property, property)):
+            if inspect.isfunction(func) or isinstance(
+                func, (cached_property, property)
+            ):
                 try:
                     for exclude in MODEL_METHODS_EXCLUDE:
                         if func_name.startswith(exclude):
@@ -262,70 +307,96 @@ class ModelDetailView(BaseAdminDocsView):
                     continue
                 verbose = func.__doc__
                 verbose = verbose and (
-                    utils.parse_rst(cleandoc(verbose), 'model', _('model:') + opts.model_name)
+                    utils.parse_rst(
+                        cleandoc(verbose), "model", _("model:") + opts.model_name
+                    )
                 )
                 # Show properties, cached_properties, and methods without
                 # arguments as fields. Otherwise, show as a 'method with
                 # arguments'.
                 if isinstance(func, (cached_property, property)):
-                    fields.append({
-                        'name': func_name,
-                        'data_type': get_return_data_type(func_name),
-                        'verbose': verbose or ''
-                    })
-                elif method_has_no_args(func) and not func_accepts_kwargs(func) and not func_accepts_var_args(func):
-                    fields.append({
-                        'name': func_name,
-                        'data_type': get_return_data_type(func_name),
-                        'verbose': verbose or '',
-                    })
+                    fields.append(
+                        {
+                            "name": func_name,
+                            "data_type": get_return_data_type(func_name),
+                            "verbose": verbose or "",
+                        }
+                    )
+                elif (
+                    method_has_no_args(func)
+                    and not func_accepts_kwargs(func)
+                    and not func_accepts_var_args(func)
+                ):
+                    fields.append(
+                        {
+                            "name": func_name,
+                            "data_type": get_return_data_type(func_name),
+                            "verbose": verbose or "",
+                        }
+                    )
                 else:
                     arguments = get_func_full_args(func)
                     # Join arguments with ', ' and in case of default value,
                     # join it with '='. Use repr() so that strings will be
                     # correctly displayed.
-                    print_arguments = ', '.join([
-                        '='.join([arg_el[0], *map(repr, arg_el[1:])])
-                        for arg_el in arguments
-                    ])
-                    methods.append({
-                        'name': func_name,
-                        'arguments': print_arguments,
-                        'verbose': verbose or '',
-                    })
+                    print_arguments = ", ".join(
+                        [
+                            "=".join([arg_el[0], *map(repr, arg_el[1:])])
+                            for arg_el in arguments
+                        ]
+                    )
+                    methods.append(
+                        {
+                            "name": func_name,
+                            "arguments": print_arguments,
+                            "verbose": verbose or "",
+                        }
+                    )
 
         # Gather related objects
         for rel in opts.related_objects:
             verbose = _("related `%(app_label)s.%(object_name)s` objects") % {
-                'app_label': rel.related_model._meta.app_label,
-                'object_name': rel.related_model._meta.object_name,
+                "app_label": rel.related_model._meta.app_label,
+                "object_name": rel.related_model._meta.object_name,
             }
             accessor = rel.get_accessor_name()
-            fields.append({
-                'name': "%s.all" % accessor,
-                'data_type': 'List',
-                'verbose': utils.parse_rst(_("all %s") % verbose, 'model', _('model:') + opts.model_name),
-            })
-            fields.append({
-                'name': "%s.count" % accessor,
-                'data_type': 'Integer',
-                'verbose': utils.parse_rst(_("number of %s") % verbose, 'model', _('model:') + opts.model_name),
-            })
-        return super().get_context_data(**{
-            **kwargs,
-            'name': opts.label,
-            'summary': title,
-            'description': body,
-            'fields': fields,
-            'methods': methods,
-        })
+            fields.append(
+                {
+                    "name": "%s.all" % accessor,
+                    "data_type": "List",
+                    "verbose": utils.parse_rst(
+                        _("all %s") % verbose, "model", _("model:") + opts.model_name
+                    ),
+                }
+            )
+            fields.append(
+                {
+                    "name": "%s.count" % accessor,
+                    "data_type": "Integer",
+                    "verbose": utils.parse_rst(
+                        _("number of %s") % verbose,
+                        "model",
+                        _("model:") + opts.model_name,
+                    ),
+                }
+            )
+        return super().get_context_data(
+            **{
+                **kwargs,
+                "name": opts.label,
+                "summary": title,
+                "description": body,
+                "fields": fields,
+                "methods": methods,
+            }
+        )
 
 
 class TemplateDetailView(BaseAdminDocsView):
-    template_name = 'admin_doc/template_detail.html'
+    template_name = "admin_doc/template_detail.html"
 
     def get_context_data(self, **kwargs):
-        template = self.kwargs['template']
+        template = self.kwargs["template"]
         templates = []
         try:
             default_engine = Engine.get_default()
@@ -339,18 +410,22 @@ class TemplateDetailView(BaseAdminDocsView):
                 if template_file.exists():
                     template_contents = template_file.read_text()
                 else:
-                    template_contents = ''
-                templates.append({
-                    'file': template_file,
-                    'exists': template_file.exists(),
-                    'contents': template_contents,
-                    'order': index,
-                })
-        return super().get_context_data(**{
-            **kwargs,
-            'name': template,
-            'templates': templates,
-        })
+                    template_contents = ""
+                templates.append(
+                    {
+                        "file": template_file,
+                        "exists": template_file.exists(),
+                        "contents": template_contents,
+                        "order": index,
+                    }
+                )
+        return super().get_context_data(
+            **{
+                **kwargs,
+                "name": template,
+                "templates": templates,
+            }
+        )
 
 
 ####################
@@ -360,12 +435,12 @@ class TemplateDetailView(BaseAdminDocsView):
 
 def get_return_data_type(func_name):
     """Return a somewhat-helpful data type given a function name"""
-    if func_name.startswith('get_'):
-        if func_name.endswith('_list'):
-            return 'List'
-        elif func_name.endswith('_count'):
-            return 'Integer'
-    return ''
+    if func_name.startswith("get_"):
+        if func_name.endswith("_list"):
+            return "List"
+        elif func_name.endswith("_count"):
+            return "Integer"
+    return ""
 
 
 def get_readable_field_data_type(field):
@@ -377,7 +452,7 @@ def get_readable_field_data_type(field):
     return field.description % field.__dict__
 
 
-def extract_views_from_urlpatterns(urlpatterns, base='', namespace=None):
+def extract_views_from_urlpatterns(urlpatterns, base="", namespace=None):
     """
     Return a list of views from a list of urlpatterns.
 
@@ -385,17 +460,19 @@ def extract_views_from_urlpatterns(urlpatterns, base='', namespace=None):
     """
     views = []
     for p in urlpatterns:
-        if hasattr(p, 'url_patterns'):
+        if hasattr(p, "url_patterns"):
             try:
                 patterns = p.url_patterns
             except ImportError:
                 continue
-            views.extend(extract_views_from_urlpatterns(
-                patterns,
-                base + str(p.pattern),
-                (namespace or []) + (p.namespace and [p.namespace] or [])
-            ))
-        elif hasattr(p, 'callback'):
+            views.extend(
+                extract_views_from_urlpatterns(
+                    patterns,
+                    base + str(p.pattern),
+                    (namespace or []) + (p.namespace and [p.namespace] or []),
+                )
+            )
+        elif hasattr(p, "callback"):
             try:
                 views.append((p.callback, base + str(p.pattern), namespace, p.name))
             except ViewDoesNotExist:
@@ -415,6 +492,6 @@ def simplify_regex(pattern):
     pattern = replace_named_groups(pattern)
     pattern = replace_unnamed_groups(pattern)
     pattern = replace_metacharacters(pattern)
-    if not pattern.startswith('/'):
-        pattern = '/' + pattern
+    if not pattern.startswith("/"):
+        pattern = "/" + pattern
     return pattern