Isso foi corrigido no Django 1.9 com form_kwargs .

Eu tenho um formulário do Django que se parece com isso:

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)

Eu chamo este formulário com algo assim:

form = ServiceForm(affiliate=request.affiliate)

Onde request.affiliateestá o usuário conectado. Isso funciona como pretendido.

Meu problema é que agora quero transformar esse formulário único em um formset. O que não consigo descobrir é como posso passar as informações do afiliado para os formulários individuais ao criar o conjunto de formulários. De acordo com os documentos para criar um formset, preciso fazer algo assim:

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

E então eu preciso criá-lo assim:

formset = ServiceFormSet()

Agora, como posso passar o afiliado = request.affiliate para os formulários individuais dessa maneira?

Eu usaria 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)

Eu acho que essa é a abordagem mais limpa e não afeta o ServiceForm de forma alguma (ou seja, dificultando a subclasse).

Documento Oficial Way

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

Eu criaria a classe de formulário dinamicamente em uma função, para que ela tenha acesso ao afiliado por meio do fechamento:

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

Como bônus, você não precisa reescrever o conjunto de consultas no campo de opções. A desvantagem é que a subclasse é um pouco descolada. (Qualquer subclasse deve ser feita de maneira semelhante.)

editar:

Em resposta a um comentário, você pode chamar esta função sobre qualquer lugar em que usaria o nome da 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)
    ...

Isto é o que funcionou para mim, 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):

Espero que ajude alguém, demorei o suficiente para descobrir;)

Eu gosto da solução de fechamento por ser "mais limpa" e mais Pythonic (então marque com +1 para responder à mmarshall), mas os formulários do Django também têm um mecanismo de retorno de chamada que você pode usar para filtrar conjuntos de consultas em conjuntos de formulários.

Também não está documentado, o que eu acho que é um indicador que os desenvolvedores do Django podem não gostar tanto.

Então, você basicamente cria o seu formset da mesma forma, mas adiciona o retorno de chamada:

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

Isso está criando uma instância de uma classe que se parece com isso:

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

Isso deve lhe dar uma idéia geral. É um pouco mais complexo transformar o retorno de chamada em um método de objeto como esse, mas oferece um pouco mais de flexibilidade em vez de executar um retorno de chamada de função simples.

Eu queria colocar isso como um comentário na resposta de Carl Meyers, mas como isso exige pontos, eu apenas o coloquei aqui. Levei duas horas para descobrir, então espero que ajude alguém.

Uma observação sobre o uso do inlineformset_factory.

Usei essa solução sozinho e funcionou perfeitamente, até que tentei com o inlineformset_factory. Eu estava executando o Django 1.0.2 e recebi alguma exceção estranha do KeyError. Atualizei para o tronco mais recente e funcionou diretamente.

Agora posso usá-lo semelhante a este:

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

A partir da confirmação e091c18f50266097f648efc7cac2503968e9d217 em terça-feira, 14 de agosto às 23:44:46 2012 +0200, a solução aceita não pode mais funcionar.

A versão atual da função django.forms.models.modelform_factory () usa uma "técnica de construção de tipo", chamando a função type () no formulário passado para obter o tipo de metaclasse e, em seguida, usando o resultado para construir um objeto de classe digite em tempo real ::

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

Isso significa que mesmo um curryed ou partialobjeto passado em vez de um formulário "faz com que o pato o morde" por assim dizer: chamará uma função com os parâmetros de construção de um ModelFormClassobjeto, retornando a mensagem de erro:

function() argument 1 must be code, not str

Para contornar esse eu escrevi uma função de gerador que usa um fecho para retornar uma subclasse de qualquer classe especificada como primeiro parâmetro, que em seguida, chama super.__init__após updateing os kwargs com as fornecidas na chamada da função gerador ::

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

Em seu código, você chamará a fábrica de formulários como:

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

ressalvas:

• isso recebeu muito pouco teste, pelo menos por enquanto
• parâmetros fornecidos podem colidir e sobrescrever aqueles usados ​​por qualquer código que usará o objeto retornado pelo construtor

A solução de Carl Meyer parece muito elegante. Eu tentei implementá-lo para modelformsets. Fiquei com a impressão de que não podia chamar métodos estáticos em uma classe, mas o seguinte funciona inexplicavelmente:

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

Na minha opinião, se eu fizer algo assim:

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

Em seguida, a palavra-chave "request" é propagada para todos os formulários membros do meu formset. Estou satisfeito, mas não tenho ideia de por que isso está funcionando - parece errado. Alguma sugestão?

Passei algum tempo tentando descobrir esse problema antes de ver esta postagem.

A solução que eu encontrei foi a solução de fechamento (e é uma solução que eu usei antes com os formulários de modelo do Django).

Eu tentei o método curry () como descrito acima, mas simplesmente não consegui fazê-lo funcionar com o Django 1.0, então, no final, voltei ao método de fechamento.

O método de fechamento é muito elegante e a única pequena estranheza é que a definição de classe está aninhada dentro da visualização ou de outra função. Eu acho que o fato de isso parecer estranho para mim é uma dificuldade da minha experiência anterior em programação e acho que alguém com experiência em linguagens mais dinâmicas não se incomodaria!

Eu tive que fazer uma coisa semelhante. Isso é semelhante à currysolução:

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

Com base nesta resposta , encontrei uma solução mais clara:

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

E execute-o como

formset_factory(form=ServiceForm.make_service_form(affiliate))

Eu sou um novato aqui, então não posso adicionar comentários. Espero que este código funcione também:

ServiceFormSet = formset_factory(ServiceForm, extra=3)

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

como adicionar parâmetros adicionais ao formset em BaseFormSetvez de ao form.