Refs #33476 -- Reformatted code with Black.

1 files changed, 103 insertions, 72 deletions

diff --git a/django/forms/forms.py b/django/forms/forms.py
index 589b4693fd..952b974130 100644
--- a/django/forms/forms.py
+++ b/django/forms/forms.py
@@ -19,15 +19,17 @@ from django.utils.translation import gettext as _
 
 from .renderers import get_default_renderer
 
-__all__ = ('BaseForm', 'Form')
+__all__ = ("BaseForm", "Form")
 
 
 class DeclarativeFieldsMetaclass(MediaDefiningClass):
     """Collect Fields declared on the base classes."""
+
     def __new__(mcs, name, bases, attrs):
         # Collect fields from current class and remove them from attrs.
-        attrs['declared_fields'] = {
-            key: attrs.pop(key) for key, value in list(attrs.items())
+        attrs["declared_fields"] = {
+            key: attrs.pop(key)
+            for key, value in list(attrs.items())
             if isinstance(value, Field)
         }
 
@@ -37,7 +39,7 @@ class DeclarativeFieldsMetaclass(MediaDefiningClass):
         declared_fields = {}
         for base in reversed(new_class.__mro__):
             # Collect fields from base class.
-            if hasattr(base, 'declared_fields'):
+            if hasattr(base, "declared_fields"):
                 declared_fields.update(base.declared_fields)
 
             # Field shadowing.
@@ -58,20 +60,32 @@ class BaseForm(RenderableFormMixin):
     improvements to the form API should be made to this class, not to the Form
     class.
     """
+
     default_renderer = None
     field_order = None
     prefix = None
     use_required_attribute = True
 
-    template_name = 'django/forms/default.html'
-    template_name_p = 'django/forms/p.html'
-    template_name_table = 'django/forms/table.html'
-    template_name_ul = 'django/forms/ul.html'
-    template_name_label = 'django/forms/label.html'
+    template_name = "django/forms/default.html"
+    template_name_p = "django/forms/p.html"
+    template_name_table = "django/forms/table.html"
+    template_name_ul = "django/forms/ul.html"
+    template_name_label = "django/forms/label.html"
 
-    def __init__(self, data=None, files=None, auto_id='id_%s', prefix=None,
-                 initial=None, error_class=ErrorList, label_suffix=None,
-                 empty_permitted=False, field_order=None, use_required_attribute=None, renderer=None):
+    def __init__(
+        self,
+        data=None,
+        files=None,
+        auto_id="id_%s",
+        prefix=None,
+        initial=None,
+        error_class=ErrorList,
+        label_suffix=None,
+        empty_permitted=False,
+        field_order=None,
+        use_required_attribute=None,
+        renderer=None,
+    ):
         self.is_bound = data is not None or files is not None
         self.data = MultiValueDict() if data is None else data
         self.files = MultiValueDict() if files is None else files
@@ -81,7 +95,7 @@ class BaseForm(RenderableFormMixin):
         self.initial = initial or {}
         self.error_class = error_class
         # Translators: This is the default suffix added to form field labels
-        self.label_suffix = label_suffix if label_suffix is not None else _(':')
+        self.label_suffix = label_suffix if label_suffix is not None else _(":")
         self.empty_permitted = empty_permitted
         self._errors = None  # Stores the errors after clean() has been called.
 
@@ -99,8 +113,8 @@ class BaseForm(RenderableFormMixin):
 
         if self.empty_permitted and self.use_required_attribute:
             raise ValueError(
-                'The empty_permitted and use_required_attribute arguments may '
-                'not both be True.'
+                "The empty_permitted and use_required_attribute arguments may "
+                "not both be True."
             )
 
         # Initialize form renderer. Use a global default if not specified
@@ -141,11 +155,11 @@ class BaseForm(RenderableFormMixin):
             is_valid = "Unknown"
         else:
             is_valid = self.is_bound and not self._errors
-        return '<%(cls)s bound=%(bound)s, valid=%(valid)s, fields=(%(fields)s)>' % {
-            'cls': self.__class__.__name__,
-            'bound': self.is_bound,
-            'valid': is_valid,
-            'fields': ';'.join(self.fields),
+        return "<%(cls)s bound=%(bound)s, valid=%(valid)s, fields=(%(fields)s)>" % {
+            "cls": self.__class__.__name__,
+            "bound": self.is_bound,
+            "valid": is_valid,
+            "fields": ";".join(self.fields),
         }
 
     def _bound_items(self):
@@ -168,10 +182,11 @@ class BaseForm(RenderableFormMixin):
             field = self.fields[name]
         except KeyError:
             raise KeyError(
-                "Key '%s' not found in '%s'. Choices are: %s." % (
+                "Key '%s' not found in '%s'. Choices are: %s."
+                % (
                     name,
                     self.__class__.__name__,
-                    ', '.join(sorted(self.fields)),
+                    ", ".join(sorted(self.fields)),
                 )
             )
         bound_field = field.get_bound_field(self, name)
@@ -196,11 +211,11 @@ class BaseForm(RenderableFormMixin):
 
         Subclasses may wish to override.
         """
-        return '%s-%s' % (self.prefix, field_name) if self.prefix else field_name
+        return "%s-%s" % (self.prefix, field_name) if self.prefix else field_name
 
     def add_initial_prefix(self, field_name):
         """Add an 'initial' prefix for checking dynamic initial values."""
-        return 'initial-%s' % self.add_prefix(field_name)
+        return "initial-%s" % self.add_prefix(field_name)
 
     def _widget_data_value(self, widget, html_name):
         # value_from_datadict() gets the data from the data dictionaries.
@@ -208,11 +223,13 @@ class BaseForm(RenderableFormMixin):
         # widgets split data over several HTML fields.
         return widget.value_from_datadict(self.data, self.files, html_name)
 
-    def _html_output(self, normal_row, error_row, row_ender, help_text_html, errors_on_separate_row):
+    def _html_output(
+        self, normal_row, error_row, row_ender, help_text_html, errors_on_separate_row
+    ):
         "Output HTML. Used by as_table(), as_ul(), as_p()."
         warnings.warn(
-            'django.forms.BaseForm._html_output() is deprecated. '
-            'Please use .render() and .get_context() instead.',
+            "django.forms.BaseForm._html_output() is deprecated. "
+            "Please use .render() and .get_context() instead.",
             RemovedInDjango50Warning,
             stacklevel=2,
         )
@@ -222,13 +239,17 @@ class BaseForm(RenderableFormMixin):
 
         for name, bf in self._bound_items():
             field = bf.field
-            html_class_attr = ''
+            html_class_attr = ""
             bf_errors = self.error_class(bf.errors)
             if bf.is_hidden:
                 if bf_errors:
                     top_errors.extend(
-                        [_('(Hidden field %(name)s) %(error)s') % {'name': name, 'error': str(e)}
-                         for e in bf_errors])
+                        [
+                            _("(Hidden field %(name)s) %(error)s")
+                            % {"name": name, "error": str(e)}
+                            for e in bf_errors
+                        ]
+                    )
                 hidden_fields.append(str(bf))
             else:
                 # Create a 'class="..."' attribute if the row should have any
@@ -242,30 +263,33 @@ class BaseForm(RenderableFormMixin):
 
                 if bf.label:
                     label = conditional_escape(bf.label)
-                    label = bf.label_tag(label) or ''
+                    label = bf.label_tag(label) or ""
                 else:
-                    label = ''
+                    label = ""
 
                 if field.help_text:
                     help_text = help_text_html % field.help_text
                 else:
-                    help_text = ''
+                    help_text = ""
 
-                output.append(normal_row % {
-                    'errors': bf_errors,
-                    'label': label,
-                    'field': bf,
-                    'help_text': help_text,
-                    'html_class_attr': html_class_attr,
-                    'css_classes': css_classes,
-                    'field_name': bf.html_name,
-                })
+                output.append(
+                    normal_row
+                    % {
+                        "errors": bf_errors,
+                        "label": label,
+                        "field": bf,
+                        "help_text": help_text,
+                        "html_class_attr": html_class_attr,
+                        "css_classes": css_classes,
+                        "field_name": bf.html_name,
+                    }
+                )
 
         if top_errors:
             output.insert(0, error_row % top_errors)
 
         if hidden_fields:  # Insert any hidden fields in the last row.
-            str_hidden = ''.join(hidden_fields)
+            str_hidden = "".join(hidden_fields)
             if output:
                 last_row = output[-1]
                 # Chop off the trailing row_ender (e.g. '</td></tr>') and
@@ -275,22 +299,22 @@ class BaseForm(RenderableFormMixin):
                     # that users write): if there are only top errors, we may
                     # not be able to conscript the last row for our purposes,
                     # so insert a new, empty row.
-                    last_row = (normal_row % {
-                        'errors': '',
-                        'label': '',
-                        'field': '',
-                        'help_text': '',
-                        'html_class_attr': html_class_attr,
-                        'css_classes': '',
-                        'field_name': '',
-                    })
+                    last_row = normal_row % {
+                        "errors": "",
+                        "label": "",
+                        "field": "",
+                        "help_text": "",
+                        "html_class_attr": html_class_attr,
+                        "css_classes": "",
+                        "field_name": "",
+                    }
                     output.append(last_row)
-                output[-1] = last_row[:-len(row_ender)] + str_hidden + row_ender
+                output[-1] = last_row[: -len(row_ender)] + str_hidden + row_ender
             else:
                 # If there aren't any rows in the output, just append the
                 # hidden fields.
                 output.append(str_hidden)
-        return mark_safe('\n'.join(output))
+        return mark_safe("\n".join(output))
 
     def get_context(self):
         fields = []
@@ -301,7 +325,8 @@ class BaseForm(RenderableFormMixin):
             if bf.is_hidden:
                 if bf_errors:
                     top_errors += [
-                        _('(Hidden field %(name)s) %(error)s') % {'name': name, 'error': str(e)}
+                        _("(Hidden field %(name)s) %(error)s")
+                        % {"name": name, "error": str(e)}
                         for e in bf_errors
                     ]
                 hidden_fields.append(bf)
@@ -310,18 +335,18 @@ class BaseForm(RenderableFormMixin):
                 # RemovedInDjango50Warning.
                 if not isinstance(errors_str, SafeString):
                     warnings.warn(
-                        f'Returning a plain string from '
-                        f'{self.error_class.__name__} is deprecated. Please '
-                        f'customize via the template system instead.',
+                        f"Returning a plain string from "
+                        f"{self.error_class.__name__} is deprecated. Please "
+                        f"customize via the template system instead.",
                         RemovedInDjango50Warning,
                     )
                     errors_str = mark_safe(errors_str)
                 fields.append((bf, errors_str))
         return {
-            'form': self,
-            'fields': fields,
-            'hidden_fields': hidden_fields,
-            'errors': top_errors,
+            "form": self,
+            "fields": fields,
+            "hidden_fields": hidden_fields,
+            "errors": top_errors,
         }
 
     def non_field_errors(self):
@@ -332,7 +357,7 @@ class BaseForm(RenderableFormMixin):
         """
         return self.errors.get(
             NON_FIELD_ERRORS,
-            self.error_class(error_class='nonfield', renderer=self.renderer),
+            self.error_class(error_class="nonfield", renderer=self.renderer),
         )
 
     def add_error(self, field, error):
@@ -358,7 +383,7 @@ class BaseForm(RenderableFormMixin):
             # do the hard work of making sense of the input.
             error = ValidationError(error)
 
-        if hasattr(error, 'error_dict'):
+        if hasattr(error, "error_dict"):
             if field is not None:
                 raise TypeError(
                     "The argument `field` must be `None` when the `error` "
@@ -373,9 +398,13 @@ class BaseForm(RenderableFormMixin):
             if field not in self.errors:
                 if field != NON_FIELD_ERRORS and field not in self.fields:
                     raise ValueError(
-                        "'%s' has no field named '%s'." % (self.__class__.__name__, field))
+                        "'%s' has no field named '%s'."
+                        % (self.__class__.__name__, field)
+                    )
                 if field == NON_FIELD_ERRORS:
-                    self._errors[field] = self.error_class(error_class='nonfield', renderer=self.renderer)
+                    self._errors[field] = self.error_class(
+                        error_class="nonfield", renderer=self.renderer
+                    )
                 else:
                     self._errors[field] = self.error_class(renderer=self.renderer)
             self._errors[field].extend(error_list)
@@ -384,8 +413,8 @@ class BaseForm(RenderableFormMixin):
 
     def has_error(self, field, code=None):
         return field in self.errors and (
-            code is None or
-            any(error.code == code for error in self.errors.as_data()[field])
+            code is None
+            or any(error.code == code for error in self.errors.as_data()[field])
         )
 
     def full_clean(self):
@@ -415,8 +444,8 @@ class BaseForm(RenderableFormMixin):
                 else:
                     value = field.clean(value)
                 self.cleaned_data[name] = value
-                if hasattr(self, 'clean_%s' % name):
-                    value = getattr(self, 'clean_%s' % name)()
+                if hasattr(self, "clean_%s" % name):
+                    value = getattr(self, "clean_%s" % name)()
                     self.cleaned_data[name] = value
             except ValidationError as e:
                 self.add_error(name, e)
@@ -493,8 +522,10 @@ class BaseForm(RenderableFormMixin):
             value = value()
         # If this is an auto-generated default date, nix the microseconds
         # for standardized handling. See #22502.
-        if (isinstance(value, (datetime.datetime, datetime.time)) and
-                not field.widget.supports_microseconds):
+        if (
+            isinstance(value, (datetime.datetime, datetime.time))
+            and not field.widget.supports_microseconds
+        ):
             value = value.replace(microsecond=0)
         return value