modelform_factory should use the form's metaclass

[Joseph Spiros]

Currently, django.forms.models.modelform_factory always uses ModelFormMetaclass to create the returned form class, even in cases when the provided form class has specified its own metaclass. I've attached a patch which fixes this. Even though metaclass will always be set for ModelForm subclasses, I retained the default functionality should there have been a case where a form class without a metaclass was provided to modelform_factory.

[Mitar]

I am not sure that this is the case. I play a lot with metaclasses here and it seems to work?

[Joseph Spiros]

Replying to mitar:

I am not sure that this is the case. I play a lot with metaclasses here and it seems to work?

Metaclasses work, but only if you directly instantiate the ModelForm subclass yourself. modelform_factory dynamically creates a new form class with the passed-in class as the parent, and uses ModelFormMetaclass as the constructor. So, when using modelform_factory with ModelForm subclasses that have a custom metaclass set, that custom metaclass is ignored.

[Honza Král]

We still need some tests to verify the fix, but the issue is valid

[jakub_vysoky]

I've made some tests for this, but it seems it really works.. Can you look at it?

​https://github.com/kvbik/django/commit/c342c3089ac169fbcf285b34f65a73fd834886a7

[jakub_vysoky]

I hope I made myself clear, that it does work for me even without the patch. But maybe you need something more specific and you can put some more tests for that.

[Stephen Burrows]

I've looked into this issue and there actually is a problem here. Essentially, the ModelFormMetaclass will be run twice.

Suppose I define the following modelform subclass:

class MyModelFormMetaclass(ModelFormMetaclass):
    run = 0
    def __new__(*args, **kwargs):
        return ModelFormMetaclass.__new__(*args, **kwargs)

class MyModelForm(ModelForm):
    __metaclass__ = MyModelFormMetaclass

If I use modelform_factory in its current state, the following calls occur:

1. a call to ModelFormMetaclass.__new__
2. a super() call by ModelFormMetaclass [1]
3. a call to MyModelFormMetaclass.__new__ in the course of the super call. This is how type works, apparently.
4. a call to ModelFormMetaclass.__new__ during MyModelFormMetaclass.__new__

This should be corrected not only because it's inelegant to be calling ModelFormMetaclass.__new__ twice and not only because it's odd that the code currently doesn't call the form's actual metaclass on principle, but also because this can cause real issues.

Just to pick an example, if I try to modify the base_fields of the form in my custom metaclass *after* calling ModelFormMetaclass myself, my changes will be overridden by ModelFormMetaclass once the stack gets back up to it.

[1] ​http://code.djangoproject.com/browser/django/trunk/django/forms/models.py#L194

[Stephen Burrows]

Updated the patch to r16322 - tests run with no unexpected failures. Added tests that fail iff the patch is not applied. Changed type to Bug since an erroneous behavior is being corrected.

[Carl Meyer]

In [16334]:

Fixed #14082 -- Use metaclass of provided ModelForm subclass in modelform_factory. Thanks jspiros and Stephen Burrows for the patch.