Dies wurde in Django 1.9 mit behoben form_kwargs.

Ich habe ein Django-Formular, das so aussieht:

class ServiceForm(forms.Form):
    option = forms.ModelChoiceField(queryset=ServiceOption.objects.none())
    rate = forms.DecimalField(widget=custom_widgets.SmallField())
    units = forms.IntegerField(min_value=1, widget=custom_widgets.SmallField())

    def __init__(self, *args, **kwargs):
        affiliate = kwargs.pop('affiliate')
        super(ServiceForm, self).__init__(*args, **kwargs)
        self.fields["option"].queryset = ServiceOption.objects.filter(affiliate=affiliate)

Ich rufe dieses Formular so auf:

form = ServiceForm(affiliate=request.affiliate)

Wo request.affiliate ist der angemeldete Benutzer. Dies funktioniert wie vorgesehen.

Mein Problem ist, dass ich dieses einzelne Formular jetzt in ein Formset umwandeln möchte. Was ich nicht herausfinden kann, ist, wie ich die Affiliate-Informationen beim Erstellen des Formsets an die einzelnen Formulare übergeben kann. Laut den Dokumenten, um daraus ein Formset zu machen, muss ich so etwas tun:

ServiceFormSet = forms.formsets.formset_factory(ServiceForm, extra=3)

Und dann muss ich es so erstellen:

formset = ServiceFormSet()

Wie kann ich nun affiliate=request.affiliate auf diese Weise an die einzelnen Formulare übergeben?

ich würde … benutzen functools.partial und functools.wraps:

from functools import partial, wraps
from django.forms.formsets import formset_factory

ServiceFormSet = formset_factory(wraps(ServiceForm)(partial(ServiceForm, affiliate=request.affiliate)), extra=3)

Ich denke, dies ist der sauberste Ansatz und wirkt sich in keiner Weise auf ServiceForm aus (z. B. indem es schwierig wird, Unterklassen zu bilden).

Offizieller Dokumentenweg

Django 2.0:

ArticleFormSet = formset_factory(MyArticleForm)
formset = ArticleFormSet(form_kwargs={'user': request.user})

https://docs.djangoproject.com/en/2.0/topics/forms/formsets/#passing-custom-parameters-to-formset-forms

Ich würde die Form-Klasse dynamisch in einer Funktion aufbauen, damit sie per Closure Zugriff auf den Affiliate hat:

def make_service_form(affiliate):
    class ServiceForm(forms.Form):
        option = forms.ModelChoiceField(
                queryset=ServiceOption.objects.filter(affiliate=affiliate))
        rate = forms.DecimalField(widget=custom_widgets.SmallField())
        units = forms.IntegerField(min_value=1, 
                widget=custom_widgets.SmallField())
    return ServiceForm

Als Bonus müssen Sie das Abfrageset im Optionsfeld nicht neu schreiben. Der Nachteil ist, dass die Unterklassenbildung etwas unkonventionell ist. (Jede Unterklasse muss auf ähnliche Weise erstellt werden.)

bearbeiten:

Als Antwort auf einen Kommentar können Sie diese Funktion an jeder Stelle aufrufen, an der Sie den Klassennamen verwenden würden:

def view(request):
    affiliate = get_object_or_404(id=request.GET.get('id'))
    formset_cls = formset_factory(make_service_form(affiliate))
    formset = formset_cls(request.POST)
    ...

Folgendes hat bei mir funktioniert, Django 1.7:

from django.utils.functional import curry    

lols = {'lols':'lols'}
formset = modelformset_factory(MyModel, form=myForm, extra=0)
formset.form = staticmethod(curry(MyForm, lols=lols))
return formset

#form.py
class MyForm(forms.ModelForm):

    def __init__(self, lols, *args, **kwargs):

Hoffe, es hilft jemandem, ich habe lange genug gebraucht, um es herauszufinden;)

Ich mag die Schließungslösung, weil sie “sauberer” und pythonischer ist (also +1 an mmarshall answer), aber Django-Formulare haben auch einen Rückrufmechanismus, den Sie zum Filtern von Abfragesätzen in Formsets verwenden können.

Es ist auch nicht dokumentiert, was meiner Meinung nach ein Hinweis darauf ist, dass die Django-Entwickler es möglicherweise nicht so sehr mögen.

Also erstellen Sie Ihr Formset im Grunde gleich, fügen aber den Callback hinzu:

ServiceFormSet = forms.formsets.formset_factory(
    ServiceForm, extra=3, formfield_callback=Callback('option', affiliate).cb)

Dies erstellt eine Instanz einer Klasse, die so aussieht:

class Callback(object):
    def __init__(self, field_name, aff):
        self._field_name = field_name
        self._aff = aff
    def cb(self, field, **kwargs):
        nf = field.formfield(**kwargs)
        if field.name == self._field_name:  # this is 'options' field
            nf.queryset = ServiceOption.objects.filter(affiliate=self._aff)
        return nf

Dies sollte Ihnen die allgemeine Vorstellung vermitteln. Es ist etwas komplexer, den Callback zu einer Objektmethode wie dieser zu machen, gibt Ihnen aber etwas mehr Flexibilität im Gegensatz zu einem einfachen Funktions-Callback.

Ich wollte dies als Kommentar zu Carl Meyers Antwort platzieren, aber da dafür Punkte erforderlich sind, habe ich es einfach hier platziert. Ich habe 2 Stunden gebraucht, um es herauszufinden, also hoffe ich, dass es jemandem helfen wird.

Ein Hinweis zur Verwendung der inlineformset_factory.

Ich habe diese Lösung selbst verwendet und sie hat perfekt funktioniert, bis ich sie mit der inlineformset_factory ausprobiert habe. Ich habe Django 1.0.2 ausgeführt und eine seltsame KeyError-Ausnahme erhalten. Ich habe auf den neuesten Trunk aufgerüstet und es hat direkt funktioniert.

Ich kann es jetzt ähnlich verwenden:

BookFormSet = inlineformset_factory(Author, Book, form=BookForm)
BookFormSet.form = staticmethod(curry(BookForm, user=request.user))

Ab Commit e091c18f50266097f648efc7cac2503968e9d217 am Dienstag, 14. August, 23:44:46 2012 +0200 funktioniert die akzeptierte Lösung nicht mehr.

Die aktuelle Version der Funktion django.forms.models.modelform_factory() verwendet eine “Typkonstruktionstechnik”, ruft die type()-Funktion auf dem übergebenen Formular auf, um den Metaklassentyp zu erhalten, und verwendet dann das Ergebnis, um ein Klassenobjekt davon zu erstellen on the fly eingeben::

# Instatiate type(form) in order to use the same metaclass as form.
return type(form)(class_name, (form,), form_class_attrs)

Das bedeutet sogar ein curryed oder partial Objekt, das anstelle eines Formulars übergeben wird, “bewirkt sozusagen, dass die Ente dich beißt”: Es ruft eine Funktion mit den Konstruktionsparametern von a auf ModelFormClass Objekt, das die Fehlermeldung zurückgibt::

function() argument 1 must be code, not str

Um dies zu umgehen, habe ich eine Generatorfunktion geschrieben, die eine Schließung verwendet, um eine Unterklasse einer beliebigen Klasse zurückzugeben, die als erster Parameter angegeben ist und dann aufruft super.__init__ nach updateVerändern der Kwargs mit denen, die beim Aufruf der Generatorfunktion geliefert werden:

def class_gen_with_kwarg(cls, **additionalkwargs):
  """class generator for subclasses with additional 'stored' parameters (in a closure)
     This is required to use a formset_factory with a form that need additional 
     initialization parameters (see http://stackoverflow.com/questions/622982/django-passing-custom-form-parameters-to-formset)
  """
  class ClassWithKwargs(cls):
      def __init__(self, *args, **kwargs):
          kwargs.update(additionalkwargs)
          super(ClassWithKwargs, self).__init__(*args, **kwargs)
  return ClassWithKwargs

Dann rufen Sie in Ihrem Code die Formularfabrik auf als:

MyFormSet = inlineformset_factory(ParentModel, Model,form = class_gen_with_kwarg(MyForm, user=self.request.user))

Vorbehalte:

• Dies wurde zumindest vorerst nur sehr wenig getestet
• Angegebene Parameter könnten kollidieren und diejenigen überschreiben, die von irgendeinem Code verwendet werden, der das vom Konstruktor zurückgegebene Objekt verwendet