Ticket #10403: django-10403.diff

django/contrib/admin/options.py

@@ -2 +2 @@
 from django import forms
 from django.forms.formsets import all_valid
 from django.forms.models import (modelform_factory, modelformset_factory,
-    inlineformset_factory, BaseInlineFormSet)
+    inlineformset_factory, InlineFormSet)
 from django.contrib.contenttypes.models import ContentType
 from django.contrib.admin import widgets, helpers
 from django.contrib.admin.util import unquote, flatten_fieldsets, get_deleted_objects, model_format_dict
@@ -1302 +1302 @@
     """
     model = None
     fk_name = None
-    formset = BaseInlineFormSet
+    formset = InlineFormSet
     extra = 3
     max_num = None
     template = None
@@ -1332 +1332 @@
     media = property(_media)
 
     def get_formset(self, request, obj=None, **kwargs):
-        """Returns a BaseInlineFormSet class for use in admin add/change views."""
+        """Returns a InlineFormSet class for use in admin add/change views."""
         if self.declared_fieldsets:
             fields = flatten_fieldsets(self.declared_fieldsets)
         else:

django/contrib/admin/validation.py

@@ -1 +1 @@
 from django.core.exceptions import ImproperlyConfigured
 from django.db import models
 from django.db.models.fields import FieldDoesNotExist
-from django.forms.models import (BaseModelForm, BaseModelFormSet, fields_for_model,
+from django.forms.models import (BaseModelForm, ModelFormSet, fields_for_model,
     _get_foreign_key)
 from django.contrib.admin import ListFilter, FieldListFilter
 from django.contrib.admin.util import get_fields_from_path, NotRelationField
@@ -206 +206 @@
                 % cls.__name__)
 
     # formset
-    if hasattr(cls, 'formset') and not issubclass(cls.formset, BaseModelFormSet):
+    if hasattr(cls, 'formset') and not issubclass(cls.formset, ModelFormSet):
         raise ImproperlyConfigured("'%s.formset' does not inherit from "
-                "BaseModelFormSet." % cls.__name__)
+                "ModelFormSet." % cls.__name__)
 
     # exclude
     if hasattr(cls, 'exclude') and cls.exclude:

django/contrib/contenttypes/generic.py

@@ -10 +10 @@
 from django.db.models.fields.related import RelatedField, Field, ManyToManyRel
 from django.db.models.loading import get_model
 from django.forms import ModelForm
-from django.forms.models import BaseModelFormSet, modelformset_factory, save_instance
+from django.forms.models import ModelFormSet, modelformset_factory, save_instance
 from django.contrib.admin.options import InlineModelAdmin, flatten_fieldsets
 from django.contrib.contenttypes.models import ContentType
 from django.utils.encoding import smart_unicode
@@ -310 +310 @@
         self.multiple = True
         self.through = None
 
-class BaseGenericInlineFormSet(BaseModelFormSet):
+class BaseGenericInlineFormSet(ModelFormSet):
     """
     A formset for generic inline objects to a parent.
     """
@@ -341 +341 @@
 
     @classmethod
     def get_default_prefix(cls):
-        opts = cls.model._meta
+        opts = cls.form._meta.model._meta
         return '-'.join((opts.app_label, opts.object_name.lower(),
                         cls.ct_field.name, cls.ct_fk_field.name,
         ))

django/contrib/formtools/wizard/views.py

@@ -155 +155 @@
 
         # walk through the ne created list of forms
         for form in init_form_list.itervalues():
-            if issubclass(form, formsets.BaseFormSet):
-                # if the element is based on BaseFormSet (FormSet/ModelFormSet)
+            if issubclass(form, formsets.FormSet):
+                # if the element is based on FormSet (FormSet/ModelFormSet)
                 # we need to override the form variable.
                 form = form.form
             # check if any form contains a FileField, if yes, we need a
@@ -383 +383 @@
         if issubclass(self.form_list[step], forms.ModelForm):
             # If the form is based on ModelForm, add instance if available.
             kwargs.update({'instance': self.get_form_instance(step)})
-        elif issubclass(self.form_list[step], forms.models.BaseModelFormSet):
+        elif issubclass(self.form_list[step], forms.models.ModelFormSet):
             # If the form is based on ModelFormSet, add queryset if available.
             kwargs.update({'queryset': self.get_form_instance(step)})
         return self.form_list[step](**kwargs)

django/forms/formsets.py

@@ +1 @@
+import warnings
+
 from forms import Form
-from django.core.exceptions import ValidationError
+from django.core.exceptions import ValidationError, ImproperlyConfigured
 from django.utils.encoding import StrAndUnicode
 from django.utils.safestring import mark_safe
 from django.utils.translation import ugettext as _
@@ -7 +9 @@
 from widgets import Media, HiddenInput
 from util import ErrorList
 
-__all__ = ('BaseFormSet', 'all_valid')
+__all__ = ('BaseFormSet', 'FormSet', 'all_valid')
 
 # special field names
 TOTAL_FORM_COUNT = 'TOTAL_FORMS'
@@ -28 +30 @@
         self.base_fields[MAX_NUM_FORM_COUNT] = IntegerField(required=False, widget=HiddenInput)
         super(ManagementForm, self).__init__(*args, **kwargs)
 
-class BaseFormSet(StrAndUnicode):
+
+class FormSet(StrAndUnicode):
     """
     A collection of instances of the same Form class.
     """
+
+    form = None
+    extra = 1
+    can_order = False
+    can_delete = False
+    max_num = None
+
     def __init__(self, data=None, files=None, auto_id='id_%s', prefix=None,
                  initial=None, error_class=ErrorList):
         self.is_bound = data is not None or files is not None
@@ -43 +53 @@
         self.error_class = error_class
         self._errors = None
         self._non_form_errors = None
+        # check declaration of FormSet
+        if self.form is None:
+            raise ImproperlyConfigured("FormSet declaration does not contain "
+                "'form' value.")
         # construct the forms in the formset
         self._construct_forms()
 
@@ -344 +358 @@
         forms = u' '.join([form.as_ul() for form in self])
         return mark_safe(u'\n'.join([unicode(self.management_form), forms]))
 
-def formset_factory(form, formset=BaseFormSet, extra=1, can_order=False,
-                    can_delete=False, max_num=None):
+class BaseFormSet(FormSet):
+    warnings.warn("BaseFormSet has been renamed to FormSet.",
+        PendingDeprecationWarning)
+
+def formset_factory(form, formset=FormSet, **kwargs):
     """Return a FormSet for the given form class."""
-    attrs = {'form': form, 'extra': extra,
-             'can_order': can_order, 'can_delete': can_delete,
-             'max_num': max_num}
-    return type(form.__name__ + 'FormSet', (formset,), attrs)
+
+    warnings.warn("formset_factory is deprecated. Use a declarative FormSet "
+                      "instead.", PendingDeprecationWarning)
+
+    kwargs.update({'form': form,})
+    return type(form.__name__ + 'FormSet', (formset,), kwargs)
 
 def all_valid(formsets):
     """Returns true if every formset in formsets is valid."""

django/forms/models.py

@@ -3 +3 @@
 and database field objects.
 """
 
+import warnings
+
 from django.utils.encoding import smart_unicode, force_unicode
 from django.utils.datastructures import SortedDict
 from django.utils.text import get_text_list, capfirst
@@ -16 +18 @@
 from fields import Field, ChoiceField
 from widgets import SelectMultiple, HiddenInput, MultipleHiddenInput
 from widgets import media_property
-from formsets import BaseFormSet, formset_factory
+from formsets import FormSet, formset_factory
 
 __all__ = (
     'ModelForm', 'BaseModelForm', 'model_to_dict', 'fields_for_model',
@@ -406 +408 @@
 
 # ModelFormSets ##############################################################
 
-class BaseModelFormSet(BaseFormSet):
+class ModelFormSet(FormSet):
     """
     A ``FormSet`` for editing a queryset and/or adding new objects to it.
     """
-    model = None
 
     def __init__(self, data=None, files=None, auto_id='id_%s', prefix=None,
                  queryset=None, **kwargs):
         self.queryset = queryset
         defaults = {'data': data, 'files': files, 'auto_id': auto_id, 'prefix': prefix}
         defaults.update(kwargs)
-        super(BaseModelFormSet, self).__init__(**defaults)
+        super(ModelFormSet, self).__init__(**defaults)
+
+    @property
+    def model(cls):
+        return cls.form._meta.model
 
     def initial_form_count(self):
         """Returns the number of forms that are required in this FormSet."""
         if not (self.data or self.files):
             return len(self.get_queryset())
-        return super(BaseModelFormSet, self).initial_form_count()
+        return super(ModelFormSet, self).initial_form_count()
 
     def _existing_object(self, pk):
         if not hasattr(self, '_object_dict'):
@@ -435 +440 @@
             # Import goes here instead of module-level because importing
             # django.db has side effects.
             from django.db import connections
-            pk_key = "%s-%s" % (self.add_prefix(i), self.model._meta.pk.name)
+            pk_key = "%s-%s" % (self.add_prefix(i), 
+                self.model._meta.pk.name)
             pk = self.data[pk_key]
             pk_field = self.model._meta.pk
             pk = pk_field.get_db_prep_lookup('exact', pk,
@@ -445 +451 @@
             kwargs['instance'] = self._existing_object(pk)
         if i < self.initial_form_count() and not kwargs.get('instance'):
             kwargs['instance'] = self.get_queryset()[i]
-        return super(BaseModelFormSet, self)._construct_form(i, **kwargs)
+        return super(ModelFormSet, self)._construct_form(i, **kwargs)
 
     def get_queryset(self):
         if not hasattr(self, '_queryset'):
@@ -649 +655 @@
                 qs = self.model._default_manager.get_query_set()
             qs = qs.using(form.instance._state.db)
             form.fields[self._pk_field.name] = ModelChoiceField(qs, initial=pk_value, required=False, widget=HiddenInput)
-        super(BaseModelFormSet, self).add_fields(form, index)
+        super(ModelFormSet, self).add_fields(form, index)
 
-def modelformset_factory(model, form=ModelForm, formfield_callback=None,
-                         formset=BaseModelFormSet,
-                         extra=1, can_delete=False, can_order=False,
-                         max_num=None, fields=None, exclude=None):
+class BaseModelFormSet(ModelFormSet):
+    warnings.warn("BaseModelFormSet has been renamed to ModelFormSet.",
+        PendingDeprecationWarning)
+
+def modelformset_factory(model, form=ModelForm, formset=ModelFormSet,
+                formfield_callback=None, fields=None, exclude=None, **kwargs):
     """
     Returns a FormSet class for the given Django model class.
     """
+
+    warnings.warn("modelformset_factory is deprecated. Use a declarative "
+                    "ModelFormSet instead.", PendingDeprecationWarning)
+
+
     form = modelform_factory(model, form=form, fields=fields, exclude=exclude,
                              formfield_callback=formfield_callback)
-    FormSet = formset_factory(form, formset, extra=extra, max_num=max_num,
-                              can_order=can_order, can_delete=can_delete)
-    FormSet.model = model
-    return FormSet
-
+    return formset_factory(form, formset, **kwargs)
 
 # InlineFormSets #############################################################
 
-class BaseInlineFormSet(BaseModelFormSet):
-    """A formset for child objects related to a parent."""
-    def __init__(self, data=None, files=None, instance=None,
-                 save_as_new=False, prefix=None, queryset=None):
-        from django.db.models.fields.related import RelatedObject
-        if instance is None:
-            self.instance = self.fk.rel.to()
-        else:
-            self.instance = instance
-        self.save_as_new = save_as_new
-        # is there a better way to get the object descriptor?
-        self.rel_name = RelatedObject(self.fk.rel.to, self.model, self.fk).get_accessor_name()
-        if queryset is None:
-            queryset = self.model._default_manager
-        qs = queryset.filter(**{self.fk.name: self.instance})
-        super(BaseInlineFormSet, self).__init__(data, files, prefix=prefix,
-                                                queryset=qs)
-
-    def initial_form_count(self):
-        if self.save_as_new:
-            return 0
-        return super(BaseInlineFormSet, self).initial_form_count()
-
-
-    def _construct_form(self, i, **kwargs):
-        form = super(BaseInlineFormSet, self)._construct_form(i, **kwargs)
-        if self.save_as_new:
-            # Remove the primary key from the form's data, we are only
-            # creating new instances
-            form.data[form.add_prefix(self._pk_field.name)] = None
-
-            # Remove the foreign key from the form's data
-            form.data[form.add_prefix(self.fk.name)] = None
-
-        # Set the fk value here so that the form can do it's validation.
-        setattr(form.instance, self.fk.get_attname(), self.instance.pk)
-        return form
-
-    @classmethod
-    def get_default_prefix(cls):
-        from django.db.models.fields.related import RelatedObject
-        return RelatedObject(cls.fk.rel.to, cls.model, cls.fk).get_accessor_name().replace('+','')
-
-    def save_new(self, form, commit=True):
-        # Use commit=False so we can assign the parent key afterwards, then
-        # save the object.
-        obj = form.save(commit=False)
-        pk_value = getattr(self.instance, self.fk.rel.field_name)
-        setattr(obj, self.fk.get_attname(), getattr(pk_value, 'pk', pk_value))
-        if commit:
-            obj.save()
-        # form.save_m2m() can be called via the formset later on if commit=False
-        if commit and hasattr(form, 'save_m2m'):
-            form.save_m2m()
-        return obj
-
-    def add_fields(self, form, index):
-        super(BaseInlineFormSet, self).add_fields(form, index)
-        if self._pk_field == self.fk:
-            name = self._pk_field.name
-            kwargs = {'pk_field': True}
-        else:
-            # The foreign key field might not be on the form, so we poke at the
-            # Model field to get the label, since we need that for error messages.
-            name = self.fk.name
-            kwargs = {
-                'label': getattr(form.fields.get(name), 'label', capfirst(self.fk.verbose_name))
-            }
-            if self.fk.rel.field_name != self.fk.rel.to._meta.pk.name:
-                kwargs['to_field'] = self.fk.rel.field_name
-
-        form.fields[name] = InlineForeignKeyField(self.instance, **kwargs)
-
-        # Add the generated field to form._meta.fields if it's defined to make
-        # sure validation isn't skipped on that field.
-        if form._meta.fields:
-            if isinstance(form._meta.fields, tuple):
-                form._meta.fields = list(form._meta.fields)
-            form._meta.fields.append(self.fk.name)
-
-    def get_unique_error_message(self, unique_check):
-        unique_check = [field for field in unique_check if field != self.fk.name]
-        return super(BaseInlineFormSet, self).get_unique_error_message(unique_check)
-
-
 def _get_foreign_key(parent_model, model, fk_name=None, can_fail=False):
     """
     Finds and returns the ForeignKey from model to parent if there is one
@@ -793 +717 @@
     return fk
 
 
-def inlineformset_factory(parent_model, model, form=ModelForm,
-                          formset=BaseInlineFormSet, fk_name=None,
-                          fields=None, exclude=None,
-                          extra=3, can_order=False, can_delete=True, max_num=None,
-                          formfield_callback=None):
+
+class InlineFormSetMetaclass(type):
+
+    def __new__(cls, name, bases, attrs):
+        try:
+            parents = [b for b in bases if issubclass(b, InlineFormSet)]
+        except NameError:
+            # we are defining InlineFormSet ourselves
+            parents = None
+
+        new_class = super(InlineFormSetMetaclass, cls).__new__(cls, name,
+                            bases, attrs)
+        if not parents:
+            return new_class
+
+        # Find parent model
+        parent_model = attrs.get('parent_model', None)
+        fk_name = attrs.get('fk_name', None)
+        form = attrs.get('form', None)
+        for base in parents:
+            parent_model = parent_model or getattr(base, 'parent_model', None)
+            fk_name = fk_name or getattr(base, 'fk_name', None)
+            form = form or getattr(base, 'form', None)
+
+        # enforce a max_num=1 when the foreign key 
+        # to the parent model is unique.
+        if form and parent_model:
+            new_class.fk = _get_foreign_key(parent_model, 
+                form._meta.model, fk_name=fk_name)
+            if new_class.fk.unique:
+                new_class.max_num = 1
+
+        new_class.parent_model = parent_model
+        new_class.fk_name = fk_name
+        new_class.form = form
+
+        return new_class
+
+
+class InlineFormSet(ModelFormSet):
+    """A formset for child objects related to a parent."""
+    __metaclass__ = InlineFormSetMetaclass
+
+    parent_model = None
+    fk_name = None
+
+    def __init__(self, data=None, files=None, instance=None,
+                 save_as_new=False, prefix=None, queryset=None):
+
+        from django.db.models.fields.related import RelatedObject
+        if instance is None:
+            self.instance = self.fk.rel.to()
+        else:
+            self.instance = instance
+        self.save_as_new = save_as_new
+        # is there a better way to get the object descriptor?
+        self.rel_name = RelatedObject(self.fk.rel.to, self.form._meta.model, 
+                                        self.fk).get_accessor_name()
+        if queryset is None:
+            queryset = self.form._meta.model._default_manager
+        qs = queryset.filter(**{self.fk.name: self.instance})
+        super(InlineFormSet, self).__init__(data, files, prefix=prefix,
+                                                queryset=qs)
+
+    def initial_form_count(self):
+        if self.save_as_new:
+            return 0
+        return super(InlineFormSet, self).initial_form_count()
+
+
+    def _construct_form(self, i, **kwargs):
+        form = super(InlineFormSet, self)._construct_form(i, **kwargs)
+        if self.save_as_new:
+            # Remove the primary key from the form's data, we are only
+            # creating new instances
+            form.data[form.add_prefix(self._pk_field.name)] = None
+
+            # Remove the foreign key from the form's data
+            form.data[form.add_prefix(self.fk.name)] = None
+
+        # Set the fk value here so that the form can do it's validation.
+        setattr(form.instance, self.fk.get_attname(), self.instance.pk)
+        return form
+
+    @classmethod
+    def get_default_prefix(cls):
+        from django.db.models.fields.related import RelatedObject
+        fk = _get_foreign_key(cls.parent_model, cls.form._meta.model, 
+                                fk_name=cls.fk_name)
+        return RelatedObject(fk.rel.to, cls.form._meta.model,
+                                fk).get_accessor_name().replace('+','')
+
+    def save_new(self, form, commit=True):
+        # Use commit=False so we can assign the parent key afterwards, then
+        # save the object.
+        obj = form.save(commit=False)
+        pk_value = getattr(self.instance, self.fk.rel.field_name)
+        setattr(obj, self.fk.get_attname(), getattr(pk_value, 'pk', pk_value))
+        if commit:
+            obj.save()
+        # form.save_m2m() can be called via the formset later on if commit=False
+        if commit and hasattr(form, 'save_m2m'):
+            form.save_m2m()
+        return obj
+
+    def add_fields(self, form, index):
+        super(InlineFormSet, self).add_fields(form, index)
+        if self._pk_field == self.fk:
+            name = self._pk_field.name
+            kwargs = {'pk_field': True}
+        else:
+            # The foreign key field might not be on the form, so we poke at the
+            # Model field to get the label, since we need that for error messages.
+            name = self.fk.name
+            kwargs = {
+                'label': getattr(form.fields.get(name), 'label', capfirst(self.fk.verbose_name))
+            }
+            if self.fk.rel.field_name != self.fk.rel.to._meta.pk.name:
+                kwargs['to_field'] = self.fk.rel.field_name
+
+        form.fields[name] = InlineForeignKeyField(self.instance, **kwargs)
+
+        # Add the generated field to form._meta.fields if it's defined to make
+        # sure validation isn't skipped on that field.
+        if form._meta.fields:
+            if isinstance(form._meta.fields, tuple):
+                form._meta.fields = list(form._meta.fields)
+            form._meta.fields.append(self.fk.name)
+
+    def get_unique_error_message(self, unique_check):
+        unique_check = [field for field in unique_check if field != self.fk.name]
+        return super(InlineFormSet, self).get_unique_error_message(unique_check)
+
+class BaseInlineFormSet(InlineFormSet):
+    warnings.warn("BaseInlineFormSet has been renamed to InlineFormSet.",
+        PendingDeprecationWarning)
+
+def inlineformset_factory(parent_model, model, formset=InlineFormSet, 
+                            fk_name=None, **kwargs):
     """
     Returns an ``InlineFormSet`` for the given kwargs.
 
     You must provide ``fk_name`` if ``model`` has more than one ``ForeignKey``
     to ``parent_model``.
     """
-    fk = _get_foreign_key(parent_model, model, fk_name=fk_name)
-    # enforce a max_num=1 when the foreign key to the parent model is unique.
-    if fk.unique:
-        max_num = 1
-    kwargs = {
-        'form': form,
-        'formfield_callback': formfield_callback,
+
+    warnings.warn("inlineformset_factory is deprecated. Use a declarative "
+                    "InlineFormSet instead.", PendingDeprecationWarning)
+
+    kwargs.update({
         'formset': formset,
-        'extra': extra,
-        'can_delete': can_delete,
-        'can_order': can_order,
-        'fields': fields,
-        'exclude': exclude,
-        'max_num': max_num,
-    }
-    FormSet = modelformset_factory(model, **kwargs)
-    FormSet.fk = fk
-    return FormSet
+        'parent_model': parent_model,
+        'fk_name': fk_name,
+    })
+    return modelformset_factory(model, **kwargs)
 
 
 # Fields #####################################################################

tests/regressiontests/admin_views/models.py

@@ -9 +9 @@
 from django.core.mail import EmailMessage
 from django.db import models
 from django import forms
-from django.forms.models import BaseModelFormSet
+from django.forms.models import ModelFormSet
 from django.contrib.auth.models import User
 from django.contrib.contenttypes import generic
 from django.contrib.contenttypes.models import ContentType
@@ -243 +243 @@
     def __unicode__(self):
         return self.name
 
-class BasePersonModelFormSet(BaseModelFormSet):
+class BasePersonModelFormSet(ModelFormSet):
     def clean(self):
         for person_dict in self.cleaned_data:
             person = person_dict.get('id')

tests/regressiontests/forms/tests/formsets.py

@@ -1 +1 @@
 # -*- coding: utf-8 -*-
 from django.forms import Form, CharField, IntegerField, ValidationError, DateField
-from django.forms.formsets import formset_factory, BaseFormSet
+from django.forms.formsets import formset_factory, FormSet
 from django.utils.unittest import TestCase
 
 
@@ -18 +18 @@
     name = CharField()
 
 
-class BaseFavoriteDrinksFormSet(BaseFormSet):
+class BaseFavoriteDrinksFormSet(FormSet):
     def clean(self):
         seen_drinks = []
 
@@ -29 +29 @@
             seen_drinks.append(drink['name'])
 
 
-class EmptyFsetWontValidate(BaseFormSet):
+class EmptyFsetWontValidate(FormSet):
     def clean(self):
         raise ValidationError("Clean method called")
 
@@ -791 +791 @@
             pass
 
         # Formets can override the default iteration order
-        class BaseReverseFormSet(BaseFormSet):
+        class BaseReverseFormSet(FormSet):
             def __iter__(self):
                 for form in reversed(self.forms):
                     yield form

tests/regressiontests/model_formsets_regress/tests.py

@@ -1 +1 @@
 from django import forms
 from django.forms.formsets import BaseFormSet, DELETION_FIELD_NAME
 from django.forms.util import ErrorDict, ErrorList
-from django.forms.models import modelform_factory, inlineformset_factory, modelformset_factory, BaseModelFormSet
+from django.forms.models import modelform_factory, inlineformset_factory, modelformset_factory, ModelFormSet
 from django.test import TestCase
 
 from models import User, UserSite, Restaurant, Manager, Network, Host
@@ -305 +305 @@
 
 class FormfieldShouldDeleteFormTests(TestCase):
     """
-    Regression for #14099: BaseModelFormSet should use ModelFormSet method _should_delete_form
+    Regression for #14099: ModelFormSet should use ModelFormSet method _should_delete_form
     """
 
-    class BaseCustomDeleteModelFormSet(BaseModelFormSet, BaseCustomDeleteFormSet):
+    class BaseCustomDeleteModelFormSet(ModelFormSet, BaseCustomDeleteFormSet):
         """ Model FormSet with CustomDelete MixIn """
 
     class CustomDeleteUserForm(forms.ModelForm):

tests/regressiontests/modeladmin/tests.py

@@ -10 +10 @@
 from django.contrib.admin import (SimpleListFilter,
      BooleanFieldListFilter)
 from django.core.exceptions import ImproperlyConfigured
-from django.forms.models import BaseModelFormSet
+from django.forms.models import ModelFormSet
 from django.forms.widgets import Select
 from django.test import TestCase
 from django.utils import unittest
@@ -1326 +1326 @@
 
         self.assertRaisesRegexp(
             ImproperlyConfigured,
-            "'ValidationTestInline.formset' does not inherit from BaseModelFormSet.",
+            "'ValidationTestInline.formset' does not inherit from ModelFormSet.",
             validate,
             ValidationTestModelAdmin,
             ValidationTestModel,
         )
 
-        class RealModelFormSet(BaseModelFormSet):
+        class RealModelFormSet(ModelFormSet):
             pass
 
         class ValidationTestInline(TabularInline):