Form Processing

A Django ModelForm generates a form field for each selected editable model field, mapping type, max_length, blank, choices, labels and help text, and its save() writes the instance. Meta must name fields or exclude, or class creation raises ImproperlyConfigured.

Since Django 5.0, {{ form }} renders django/forms/div.html: top-level errors, then one <div> per visible field holding its label, help text, errors and widget. By hand, use each BoundField's label_tag, help_text, errors and the field itself.

A Django Field coerces and validates input into a Python value; its Widget renders the HTML and extracts the raw value. For a native picker use DateInput(attrs={'type': 'date'}, format='%Y-%m-%d'), because browsers accept only ISO dates.

Bind a ModelForm for the order and an inline formset with instance=order to request.POST, validate both, save the order, set formset.instance to it and call formset.save(), which stamps each new line with the order's key.

A bound Django formset reads its form count from hidden <prefix>-TOTAL_FORMS and <prefix>-INITIAL_FORMS fields. The error means they were not posted under the expected prefix: render {{ formset.management_form }} and use the same prefix on GET and POST.

Django's ModelForm.save(commit=False) returns the model instance populated from cleaned_data but not saved. After setting extra fields and calling instance.save(), you call form.save_m2m(), because many-to-many rows need the saved instance's primary key.

Django's is_valid() runs full_clean(): for each field in declared order, Field.clean() calls to_python(), validate() and run_validators(), then clean_<field>() if that passed. After every field, the form's clean() runs, even if fields failed.

A Django field with required=True (the default) rejects a cleaned value that is empty: None, '', or an empty list, tuple or dict. An unticked checkbox cleans to False, and a required BooleanField treats False as missing.

A Django formset is a class, built by formset_factory, that repeats one form on a page and validates the copies together. Unbound, it renders max(initial, min_num) + extra forms, trimmed to max_num unless the initial rows alone exceed it.

Django stores form errors in form.errors, a dict keyed by field name plus 'all' for form-wide errors. non_field_errors() returns that 'all' list, and errors.as_json() serialises every error as message and code.

A Django FileField's widget reads only from the form's files dict, so the form must be built with files=request.FILES, and the HTML form must use enctype="multipart/form-data"; otherwise request.FILES is empty and the field sees no file.

Cross-form rules go in clean() on a BaseFormSet subclass passed to the factory with formset=. It runs after every form is cleaned; a ValidationError raised there lands in formset.non_form_errors(), which the template must render explicitly.

In a Django ModelForm, instance= supplies the initial values on GET and tells save() which row to update on POST. A POST form built without instance= starts from a new object, so save() inserts a duplicate row instead of updating.

After a Django ModelForm's clean(), _post_clean() copies cleaned data onto the instance, runs the model's field validation and clean(), then validate_unique() and validate_constraints(). Those last two only run if ModelForm.clean() ran, so overrides must call super().clean().

as_field_group() renders one field's label, help text, errors and widget through a field template, django/forms/field.html by default. To restyle every field, point a custom FORM_RENDERER's field_template_name at your own template.

An inner Media class lists the CSS, by medium, and JavaScript a widget or form needs. form.media merges all widgets' assets plus the form's own, dropping duplicates but keeping order; {{ form.media }} renders the tags.

Django's default form renderer, DjangoTemplates, uses its own engine that loads the built-in form templates and apps' templates folders, not the project's TEMPLATES DIRS. Set FORM_RENDERER to TemplatesSetting, or a subclass, to make overrides work.

Put a Django cross-field rule in the form's clean(): read both dates with cleaned_data.get(), compare only when both exist, and call add_error('check_out', ...). A field that failed validation is absent, so indexing raises KeyError.

A Django ValidationError's code lets tests, views and error_messages overrides identify the error without parsing text, and params let the message be translated and reworded with placeholders filled in at render time.

A Django field with disabled=True ignores whatever is submitted and cleans the form's initial value, so a tampered POST cannot change it. A readonly attribute is only a browser hint; the submitted value is validated and used.

Pass a user-scoped queryset to the model formset on both GET and POST, because without one it covers every row of the model; and use edit_only=True, since extra=0 or max_num does not stop a client posting new rows.

With fields = 'all' a Django ModelForm accepts and saves every editable field, including staff-only ones like status, and any column added later. Hiding inputs in the template does not help; a crafted POST sets them.

A Django ModelForm excludes fields that are not on the form from model validation, and skips any unique check or UniqueConstraint that involves one. A constraint on (applicant, pet) is never checked, so the duplicate reaches the database.

In Django, put reusable single-value checks in validators, type conversion in a custom Field's to_python(), rules needing this form's context in clean_<field>(), and rules spanning fields in the form's clean().

Set Django ChoiceField choices per request by passing a callable or assigning self.fields['name'].choices in the form's init, never on the class. ChoiceField cleans to strings; use TypedChoiceField with coerce=int for integers.

Keep rendering the widget with {{ field }}, labels with label_tag or legend_tag, errors with {{ field.errors }}, and give help text the id <auto_id>_helptext: Django's aria-describedby on the input points at those ids.