Questo problema è stato risolto in Django 1.9 con form_kwargs .

Ho un Django Form che assomiglia a questo:

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)

Chiamo questo modulo con qualcosa del genere:

form = ServiceForm(affiliate=request.affiliate)

Dove request.affiliate l'utente che ha effettuato l'accesso. Funziona come previsto.

Il mio problema è che ora voglio trasformare questo singolo modulo in un formset. Quello che non riesco a capire è come posso trasmettere le informazioni di affiliazione ai singoli moduli durante la creazione del formset. Secondo i documenti per fare un formset da questo ho bisogno di fare qualcosa del genere:

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

E poi ho bisogno di crearlo in questo modo:

formset = ServiceFormSet()

Ora come posso passare affiliate = request.affiliate ai singoli moduli in questo modo?

Vorrei usare functools.partial e 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)

Penso che questo sia l'approccio più pulito e non influisca in alcun modo su ServiceForm (ovvero rendendo difficile la sottoclasse).

Modo documento ufficiale

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

Costruirei la classe del modulo in modo dinamico in una funzione, in modo che abbia accesso all'affiliato tramite chiusura:

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

Come bonus, non è necessario riscrivere il queryset nel campo delle opzioni. Il rovescio della medaglia è che la sottoclasse è un po 'funky. (Qualsiasi sottoclasse deve essere creata in modo simile.)

modificare:

In risposta a un commento, puoi chiamare questa funzione in qualsiasi luogo in cui utilizzeresti il ​​nome della classe:

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)
    ...

Questo è ciò che ha funzionato per me, 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):

Spero che aiuti qualcuno, mi ha impiegato abbastanza tempo per capirlo;)

Mi piace la soluzione di chiusura per essere "più pulito" e più Pythonic (quindi da +1 a mmarshall answer) ma i moduli Django hanno anche un meccanismo di callback che puoi usare per filtrare i queryset nei form.

Inoltre, non è documentato, che penso sia un indicatore che gli sviluppatori di Django potrebbero non apprezzare tanto.

Quindi fondamentalmente crei lo stesso formset ma aggiungi il callback:

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

Questo sta creando un'istanza di una classe che assomiglia a questa:

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

Questo dovrebbe darti l'idea generale. È un po 'più complesso rendere il callback un metodo oggetto come questo, ma ti dà un po' più di flessibilità rispetto a fare un semplice callback di funzione.

Volevo inserire questo come commento alla risposta di Carl Meyers, ma poiché ciò richiede punti, l'ho appena inserito qui. Mi ci sono volute 2 ore per capire, quindi spero che possa aiutare qualcuno.

Una nota sull'uso di inlineformset_factory.

Ho usato quella soluzione da solo e ha funzionato perfettamente, fino a quando non l'ho provata con inlineformset_factory. Stavo eseguendo Django 1.0.2 e ho avuto una strana eccezione KeyError. Ho aggiornato all'ultimo trunk e ha funzionato direttamente.

Ora posso usarlo in questo modo:

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

A partire da commit e091c18f50266097f648efc7cac2503968e9d217 il mar 14 ago 23:44:46 2012 +0200 la soluzione accettata non può più funzionare.

La versione corrente della funzione django.forms.models.modelform_factory () utilizza una "tecnica di costruzione del tipo", chiamando la funzione type () sul modulo passato per ottenere il tipo di metaclasse, quindi usando il risultato per costruire un oggetto di classe del suo digitare al volo ::

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

Questo significa che anche un curryed o un partialoggetto passato anziché un modulo "fa mordere l'anatra", per così dire: chiamerà una funzione con i parametri di costruzione di un ModelFormClassoggetto, restituendo il messaggio di errore:

function() argument 1 must be code, not str

Per ovviare a questo ho scritto una funzione generatore che utilizza una chiusura per restituire una sottoclasse di qualsiasi classe specificata come primo parametro, che quindi chiama super.__init__dopo aver updateing kwargs con quelli forniti nella chiamata della funzione generatore:

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

Quindi nel tuo codice chiamerai il form factory come ::

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

avvertimenti:

• questo ha ricevuto pochissimi test, almeno per ora
• i parametri forniti potrebbero scontrarsi e sovrascrivere quelli usati da qualunque codice utilizzerà l'oggetto restituito dal costruttore

La soluzione di Carl Meyer sembra molto elegante. Ho provato a implementarlo per i modelformset. Avevo l'impressione di non poter chiamare metodi statici all'interno di una classe, ma il seguente funziona inspiegabilmente:

class MyModel(models.Model):
  myField = models.CharField(max_length=10)

class MyForm(ModelForm):
  _request = None
  class Meta:
    model = MyModel

    def __init__(self,*args,**kwargs):      
      self._request = kwargs.pop('request', None)
      super(MyForm,self).__init__(*args,**kwargs)

class MyFormsetBase(BaseModelFormSet):
  _request = None

def __init__(self,*args,**kwargs):
  self._request = kwargs.pop('request', None)
  subFormClass = self.form
  self.form = curry(subFormClass,request=self._request)
  super(MyFormsetBase,self).__init__(*args,**kwargs)

MyFormset =  modelformset_factory(MyModel,formset=MyFormsetBase,extra=1,max_num=10,can_delete=True)
MyFormset.form = staticmethod(curry(MyForm,request=MyFormsetBase._request))

Dal mio punto di vista, se faccio qualcosa del genere:

formset = MyFormset(request.POST,queryset=MyModel.objects.all(),request=request)

Quindi la parola chiave "richiesta" viene propagata a tutte le forme membro del mio formset. Sono contento, ma non ho idea del perché funzioni, sembra sbagliato. Eventuali suggerimenti?

Ho trascorso un po 'di tempo a cercare di capire questo problema prima di vedere questo post.

La soluzione che mi è venuta in mente è stata la soluzione di chiusura (ed è una soluzione che ho usato prima con i moduli del modello Django).

Ho provato il metodo curry () come descritto sopra, ma non sono riuscito a farlo funzionare con Django 1.0, quindi alla fine sono tornato al metodo di chiusura.

Il metodo di chiusura è molto accurato e l'unica leggera stranezza è che la definizione della classe è nidificata all'interno della vista o in un'altra funzione. Penso che il fatto che questo mi sembri strano sia un problema con la mia precedente esperienza di programmazione e penso che qualcuno con un background in linguaggi più dinamici non batterebbe le palpebre!

Ho dovuto fare una cosa simile. Questo è simile alla currysoluzione:

def form_with_my_variable(myvar):
   class MyForm(ServiceForm):
     def __init__(self, myvar=myvar, *args, **kwargs):
       super(SeriveForm, self).__init__(myvar=myvar, *args, **kwargs)
   return MyForm

factory = inlineformset_factory(..., form=form_with_my_variable(myvar), ... )

sulla base di questa risposta ho trovato una soluzione più chiara:

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

    @staticmethod
    def make_service_form(affiliate):
        self.affiliate = affiliate
        return ServiceForm

Ed eseguirlo in vista come

formset_factory(form=ServiceForm.make_service_form(affiliate))

Sono un principiante qui, quindi non posso aggiungere commenti. Spero che anche questo codice funzioni:

ServiceFormSet = formset_factory(ServiceForm, extra=3)

ServiceFormSet.formset = staticmethod(curry(ServiceForm, affiliate=request.affiliate))

come per l'aggiunta di parametri aggiuntivi al formset BaseFormSetinvece che al form.