Refs #33476 -- Reformatted code with Black.

1 files changed, 191 insertions, 91 deletions

diff --git a/django/contrib/admin/helpers.py b/django/contrib/admin/helpers.py
index dae626b550..2e7a20a49b 100644
--- a/django/contrib/admin/helpers.py
+++ b/django/contrib/admin/helpers.py
@@ -2,43 +2,57 @@ import json
 
 from django import forms
 from django.contrib.admin.utils import (
-    display_for_field, flatten_fieldsets, help_text_for_field, label_for_field,
-    lookup_field, quote,
+    display_for_field,
+    flatten_fieldsets,
+    help_text_for_field,
+    label_for_field,
+    lookup_field,
+    quote,
 )
 from django.core.exceptions import ObjectDoesNotExist
 from django.db.models.fields.related import (
-    ForeignObjectRel, ManyToManyRel, OneToOneField,
+    ForeignObjectRel,
+    ManyToManyRel,
+    OneToOneField,
 )
 from django.forms.utils import flatatt
 from django.template.defaultfilters import capfirst, linebreaksbr
 from django.urls import NoReverseMatch, reverse
 from django.utils.html import conditional_escape, format_html
 from django.utils.safestring import mark_safe
-from django.utils.translation import gettext, gettext_lazy as _
+from django.utils.translation import gettext
+from django.utils.translation import gettext_lazy as _
 
-ACTION_CHECKBOX_NAME = '_selected_action'
+ACTION_CHECKBOX_NAME = "_selected_action"
 
 
 class ActionForm(forms.Form):
-    action = forms.ChoiceField(label=_('Action:'))
+    action = forms.ChoiceField(label=_("Action:"))
     select_across = forms.BooleanField(
-        label='',
+        label="",
         required=False,
         initial=0,
-        widget=forms.HiddenInput({'class': 'select-across'}),
+        widget=forms.HiddenInput({"class": "select-across"}),
     )
 
 
-checkbox = forms.CheckboxInput({'class': 'action-select'}, lambda value: False)
+checkbox = forms.CheckboxInput({"class": "action-select"}, lambda value: False)
 
 
 class AdminForm:
-    def __init__(self, form, fieldsets, prepopulated_fields, readonly_fields=None, model_admin=None):
+    def __init__(
+        self,
+        form,
+        fieldsets,
+        prepopulated_fields,
+        readonly_fields=None,
+        model_admin=None,
+    ):
         self.form, self.fieldsets = form, fieldsets
-        self.prepopulated_fields = [{
-            'field': form[field_name],
-            'dependencies': [form[f] for f in dependencies]
-        } for field_name, dependencies in prepopulated_fields.items()]
+        self.prepopulated_fields = [
+            {"field": form[field_name], "dependencies": [form[f] for f in dependencies]}
+            for field_name, dependencies in prepopulated_fields.items()
+        ]
         self.model_admin = model_admin
         if readonly_fields is None:
             readonly_fields = ()
@@ -46,18 +60,19 @@ class AdminForm:
 
     def __repr__(self):
         return (
-            f'<{self.__class__.__qualname__}: '
-            f'form={self.form.__class__.__qualname__} '
-            f'fieldsets={self.fieldsets!r}>'
+            f"<{self.__class__.__qualname__}: "
+            f"form={self.form.__class__.__qualname__} "
+            f"fieldsets={self.fieldsets!r}>"
         )
 
     def __iter__(self):
         for name, options in self.fieldsets:
             yield Fieldset(
-                self.form, name,
+                self.form,
+                name,
                 readonly_fields=self.readonly_fields,
                 model_admin=self.model_admin,
-                **options
+                **options,
             )
 
     @property
@@ -77,24 +92,34 @@ class AdminForm:
 
 
 class Fieldset:
-    def __init__(self, form, name=None, readonly_fields=(), fields=(), classes=(),
-                 description=None, model_admin=None):
+    def __init__(
+        self,
+        form,
+        name=None,
+        readonly_fields=(),
+        fields=(),
+        classes=(),
+        description=None,
+        model_admin=None,
+    ):
         self.form = form
         self.name, self.fields = name, fields
-        self.classes = ' '.join(classes)
+        self.classes = " ".join(classes)
         self.description = description
         self.model_admin = model_admin
         self.readonly_fields = readonly_fields
 
     @property
     def media(self):
-        if 'collapse' in self.classes:
-            return forms.Media(js=['admin/js/collapse.js'])
+        if "collapse" in self.classes:
+            return forms.Media(js=["admin/js/collapse.js"])
         return forms.Media()
 
     def __iter__(self):
         for field in self.fields:
-            yield Fieldline(self.form, field, self.readonly_fields, model_admin=self.model_admin)
+            yield Fieldline(
+                self.form, field, self.readonly_fields, model_admin=self.model_admin
+            )
 
 
 class Fieldline:
@@ -116,15 +141,19 @@ class Fieldline:
     def __iter__(self):
         for i, field in enumerate(self.fields):
             if field in self.readonly_fields:
-                yield AdminReadonlyField(self.form, field, is_first=(i == 0), model_admin=self.model_admin)
+                yield AdminReadonlyField(
+                    self.form, field, is_first=(i == 0), model_admin=self.model_admin
+                )
             else:
                 yield AdminField(self.form, field, is_first=(i == 0))
 
     def errors(self):
         return mark_safe(
-            '\n'.join(
-                self.form[f].errors.as_ul() for f in self.fields if f not in self.readonly_fields
-            ).strip('\n')
+            "\n".join(
+                self.form[f].errors.as_ul()
+                for f in self.fields
+                if f not in self.readonly_fields
+            ).strip("\n")
         )
 
 
@@ -139,18 +168,19 @@ class AdminField:
         classes = []
         contents = conditional_escape(self.field.label)
         if self.is_checkbox:
-            classes.append('vCheckboxLabel')
+            classes.append("vCheckboxLabel")
 
         if self.field.field.required:
-            classes.append('required')
+            classes.append("required")
         if not self.is_first:
-            classes.append('inline')
-        attrs = {'class': ' '.join(classes)} if classes else {}
+            classes.append("inline")
+        attrs = {"class": " ".join(classes)} if classes else {}
         # checkboxes should not have a label suffix as the checkbox appears
         # to the left of the label.
         return self.field.label_tag(
-            contents=mark_safe(contents), attrs=attrs,
-            label_suffix='' if self.is_checkbox else None,
+            contents=mark_safe(contents),
+            attrs=attrs,
+            label_suffix="" if self.is_checkbox else None,
         )
 
     def errors(self):
@@ -163,7 +193,7 @@ class AdminReadonlyField:
         # {{ field.name }} must be a useful class name to identify the field.
         # For convenience, store other field-related data here too.
         if callable(field):
-            class_name = field.__name__ if field.__name__ != '<lambda>' else ''
+            class_name = field.__name__ if field.__name__ != "<lambda>" else ""
         else:
             class_name = field
 
@@ -183,11 +213,11 @@ class AdminReadonlyField:
             is_hidden = False
 
         self.field = {
-            'name': class_name,
-            'label': label,
-            'help_text': help_text,
-            'field': field,
-            'is_hidden': is_hidden,
+            "name": class_name,
+            "label": label,
+            "help_text": help_text,
+            "field": field,
+            "is_hidden": is_hidden,
         }
         self.form = form
         self.model_admin = model_admin
@@ -200,11 +230,16 @@ class AdminReadonlyField:
         attrs = {}
         if not self.is_first:
             attrs["class"] = "inline"
-        label = self.field['label']
-        return format_html('<label{}>{}{}</label>', flatatt(attrs), capfirst(label), self.form.label_suffix)
+        label = self.field["label"]
+        return format_html(
+            "<label{}>{}{}</label>",
+            flatatt(attrs),
+            capfirst(label),
+            self.form.label_suffix,
+        )
 
     def get_admin_url(self, remote_field, remote_obj):
-        url_name = 'admin:%s_%s_change' % (
+        url_name = "admin:%s_%s_change" % (
             remote_field.model._meta.app_label,
             remote_field.model._meta.model_name,
         )
@@ -220,7 +255,12 @@ class AdminReadonlyField:
 
     def contents(self):
         from django.contrib.admin.templatetags.admin_list import _boolean_icon
-        field, obj, model_admin = self.field['field'], self.form.instance, self.model_admin
+
+        field, obj, model_admin = (
+            self.field["field"],
+            self.form.instance,
+            self.model_admin,
+        )
         try:
             f, attr, value = lookup_field(field, obj, model_admin)
         except (AttributeError, ValueError, ObjectDoesNotExist):
@@ -230,10 +270,10 @@ class AdminReadonlyField:
                 widget = self.form[field].field.widget
                 # This isn't elegant but suffices for contrib.auth's
                 # ReadOnlyPasswordHashWidget.
-                if getattr(widget, 'read_only', False):
+                if getattr(widget, "read_only", False):
                     return widget.render(field, value)
             if f is None:
-                if getattr(attr, 'boolean', False):
+                if getattr(attr, "boolean", False):
                     result_repr = _boolean_icon(value)
                 else:
                     if hasattr(value, "__html__"):
@@ -244,8 +284,8 @@ class AdminReadonlyField:
                 if isinstance(f.remote_field, ManyToManyRel) and value is not None:
                     result_repr = ", ".join(map(str, value.all()))
                 elif (
-                    isinstance(f.remote_field, (ForeignObjectRel, OneToOneField)) and
-                    value is not None
+                    isinstance(f.remote_field, (ForeignObjectRel, OneToOneField))
+                    and value is not None
                 ):
                     result_repr = self.get_admin_url(f.remote_field, value)
                 else:
@@ -258,10 +298,20 @@ class InlineAdminFormSet:
     """
     A wrapper around an inline formset for use in the admin system.
     """
-    def __init__(self, inline, formset, fieldsets, prepopulated_fields=None,
-                 readonly_fields=None, model_admin=None, has_add_permission=True,
-                 has_change_permission=True, has_delete_permission=True,
-                 has_view_permission=True):
+
+    def __init__(
+        self,
+        inline,
+        formset,
+        fieldsets,
+        prepopulated_fields=None,
+        readonly_fields=None,
+        model_admin=None,
+        has_add_permission=True,
+        has_change_permission=True,
+        has_delete_permission=True,
+        has_view_permission=True,
+    ):
         self.opts = inline
         self.formset = formset
         self.fieldsets = fieldsets
@@ -272,7 +322,7 @@ class InlineAdminFormSet:
         if prepopulated_fields is None:
             prepopulated_fields = {}
         self.prepopulated_fields = prepopulated_fields
-        self.classes = ' '.join(inline.classes) if inline.classes else ''
+        self.classes = " ".join(inline.classes) if inline.classes else ""
         self.has_add_permission = has_add_permission
         self.has_change_permission = has_change_permission
         self.has_delete_permission = has_delete_permission
@@ -282,25 +332,43 @@ class InlineAdminFormSet:
         if self.has_change_permission:
             readonly_fields_for_editing = self.readonly_fields
         else:
-            readonly_fields_for_editing = self.readonly_fields + flatten_fieldsets(self.fieldsets)
+            readonly_fields_for_editing = self.readonly_fields + flatten_fieldsets(
+                self.fieldsets
+            )
 
-        for form, original in zip(self.formset.initial_forms, self.formset.get_queryset()):
+        for form, original in zip(
+            self.formset.initial_forms, self.formset.get_queryset()
+        ):
             view_on_site_url = self.opts.get_view_on_site_url(original)
             yield InlineAdminForm(
-                self.formset, form, self.fieldsets, self.prepopulated_fields,
-                original, readonly_fields_for_editing, model_admin=self.opts,
+                self.formset,
+                form,
+                self.fieldsets,
+                self.prepopulated_fields,
+                original,
+                readonly_fields_for_editing,
+                model_admin=self.opts,
                 view_on_site_url=view_on_site_url,
             )
         for form in self.formset.extra_forms:
             yield InlineAdminForm(
-                self.formset, form, self.fieldsets, self.prepopulated_fields,
-                None, self.readonly_fields, model_admin=self.opts,
+                self.formset,
+                form,
+                self.fieldsets,
+                self.prepopulated_fields,
+                None,
+                self.readonly_fields,
+                model_admin=self.opts,
             )
         if self.has_add_permission:
             yield InlineAdminForm(
-                self.formset, self.formset.empty_form,
-                self.fieldsets, self.prepopulated_fields, None,
-                self.readonly_fields, model_admin=self.opts,
+                self.formset,
+                self.formset.empty_form,
+                self.fieldsets,
+                self.prepopulated_fields,
+                None,
+                self.readonly_fields,
+                model_admin=self.opts,
             )
 
     def fields(self):
@@ -317,42 +385,49 @@ class InlineAdminFormSet:
                 if form_field is not None:
                     widget_is_hidden = form_field.widget.is_hidden
                 yield {
-                    'name': field_name,
-                    'label': meta_labels.get(field_name) or label_for_field(
+                    "name": field_name,
+                    "label": meta_labels.get(field_name)
+                    or label_for_field(
                         field_name,
                         self.opts.model,
                         self.opts,
                         form=empty_form,
                     ),
-                    'widget': {'is_hidden': widget_is_hidden},
-                    'required': False,
-                    'help_text': meta_help_texts.get(field_name) or help_text_for_field(field_name, self.opts.model),
+                    "widget": {"is_hidden": widget_is_hidden},
+                    "required": False,
+                    "help_text": meta_help_texts.get(field_name)
+                    or help_text_for_field(field_name, self.opts.model),
                 }
             else:
                 form_field = empty_form.fields[field_name]
                 label = form_field.label
                 if label is None:
-                    label = label_for_field(field_name, self.opts.model, self.opts, form=empty_form)
+                    label = label_for_field(
+                        field_name, self.opts.model, self.opts, form=empty_form
+                    )
                 yield {
-                    'name': field_name,
-                    'label': label,
-                    'widget': form_field.widget,
-                    'required': form_field.required,
-                    'help_text': form_field.help_text,
+                    "name": field_name,
+                    "label": label,
+                    "widget": form_field.widget,
+                    "required": form_field.required,
+                    "help_text": form_field.help_text,
                 }
 
     def inline_formset_data(self):
         verbose_name = self.opts.verbose_name
-        return json.dumps({
-            'name': '#%s' % self.formset.prefix,
-            'options': {
-                'prefix': self.formset.prefix,
-                'addText': gettext('Add another %(verbose_name)s') % {
-                    'verbose_name': capfirst(verbose_name),
+        return json.dumps(
+            {
+                "name": "#%s" % self.formset.prefix,
+                "options": {
+                    "prefix": self.formset.prefix,
+                    "addText": gettext("Add another %(verbose_name)s")
+                    % {
+                        "verbose_name": capfirst(verbose_name),
+                    },
+                    "deleteText": gettext("Remove"),
                 },
-                'deleteText': gettext('Remove'),
             }
-        })
+        )
 
     @property
     def forms(self):
@@ -374,31 +449,51 @@ class InlineAdminForm(AdminForm):
     """
     A wrapper around an inline form for use in the admin system.
     """
-    def __init__(self, formset, form, fieldsets, prepopulated_fields, original,
-                 readonly_fields=None, model_admin=None, view_on_site_url=None):
+
+    def __init__(
+        self,
+        formset,
+        form,
+        fieldsets,
+        prepopulated_fields,
+        original,
+        readonly_fields=None,
+        model_admin=None,
+        view_on_site_url=None,
+    ):
         self.formset = formset
         self.model_admin = model_admin
         self.original = original
         self.show_url = original and view_on_site_url is not None
         self.absolute_url = view_on_site_url
-        super().__init__(form, fieldsets, prepopulated_fields, readonly_fields, model_admin)
+        super().__init__(
+            form, fieldsets, prepopulated_fields, readonly_fields, model_admin
+        )
 
     def __iter__(self):
         for name, options in self.fieldsets:
             yield InlineFieldset(
-                self.formset, self.form, name, self.readonly_fields,
-                model_admin=self.model_admin, **options
+                self.formset,
+                self.form,
+                name,
+                self.readonly_fields,
+                model_admin=self.model_admin,
+                **options,
             )
 
     def needs_explicit_pk_field(self):
         return (
             # Auto fields are editable, so check for auto or non-editable pk.
-            self.form._meta.model._meta.auto_field or not self.form._meta.model._meta.pk.editable or
+            self.form._meta.model._meta.auto_field
+            or not self.form._meta.model._meta.pk.editable
+            or
             # Also search any parents for an auto field. (The pk info is
             # propagated to child models so that does not need to be checked
             # in parents.)
-            any(parent._meta.auto_field or not parent._meta.model._meta.pk.editable
-                for parent in self.form._meta.model._meta.get_parent_list())
+            any(
+                parent._meta.auto_field or not parent._meta.model._meta.pk.editable
+                for parent in self.form._meta.model._meta.get_parent_list()
+            )
         )
 
     def pk_field(self):
@@ -413,10 +508,12 @@ class InlineAdminForm(AdminForm):
 
     def deletion_field(self):
         from django.forms.formsets import DELETION_FIELD_NAME
+
         return AdminField(self.form, DELETION_FIELD_NAME, False)
 
     def ordering_field(self):
         from django.forms.formsets import ORDERING_FIELD_NAME
+
         return AdminField(self.form, ORDERING_FIELD_NAME, False)
 
 
@@ -429,11 +526,14 @@ class InlineFieldset(Fieldset):
         fk = getattr(self.formset, "fk", None)
         for field in self.fields:
             if not fk or fk.name != field:
-                yield Fieldline(self.form, field, self.readonly_fields, model_admin=self.model_admin)
+                yield Fieldline(
+                    self.form, field, self.readonly_fields, model_admin=self.model_admin
+                )
 
 
 class AdminErrorList(forms.utils.ErrorList):
     """Store errors for the form/formsets in an add/change view."""
+
     def __init__(self, form, inline_formsets):
         super().__init__()