Esto se solucionó en Django 1.9 con form_kwargs .

Tengo un formulario de Django que se ve así:

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)

Llamo a este formulario con algo como esto:

form = ServiceForm(affiliate=request.affiliate)

¿Dónde request.affiliateestá el usuario conectado? Esto funciona según lo previsto.

Mi problema es que ahora quiero convertir este formulario único en un conjunto de formularios. Lo que no puedo entender es cómo puedo pasar la información del afiliado a los formularios individuales al crear el conjunto de formularios. De acuerdo con los documentos para hacer un formulario de esto, necesito hacer algo como esto:

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

Y luego necesito crearlo así:

formset = ServiceFormSet()

Ahora, ¿cómo puedo pasar afiliado = request.affiliate a los formularios individuales de esta manera?

Me gustaría utilizar functools.partial y 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)

Creo que este es el enfoque más limpio y no afecta a ServiceForm de ninguna manera (es decir, al dificultar la subclase).

Manera oficial del documento

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

Construiría la clase de formulario dinámicamente en una función, para que tenga acceso al afiliado a través del cierre:

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 beneficio adicional, no tiene que volver a escribir el conjunto de consultas en el campo de opción. La desventaja es que la subclase es un poco funky. (Cualquier subclase debe hacerse de manera similar).

editar:

En respuesta a un comentario, puede llamar a esta función sobre cualquier lugar donde usaría el nombre de la clase:

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

Esto es lo que funcionó para mí, 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 ayude a alguien, me tomó el tiempo suficiente para resolverlo;)

Me gusta la solución de cierre por ser "más limpia" y más Pythonic (por lo tanto, +1 a la respuesta de mmarshall) pero los formularios de Django también tienen un mecanismo de devolución de llamada que puede usar para filtrar conjuntos de consultas en conjuntos de formularios.

Tampoco está documentado, lo que creo que es un indicador de que a los desarrolladores de Django no les gustará tanto.

Entonces, básicamente, crea su conjunto de formularios de la misma manera pero agrega la devolución de llamada:

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

Esto está creando una instancia de una clase que se ve así:

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

Esto debería darte la idea general. Es un poco más complejo hacer que la devolución de llamada sea un método de objeto como este, pero le brinda un poco más de flexibilidad en lugar de hacer una devolución de llamada de función simple.

Quería colocar esto como un comentario a la respuesta de Carl Meyers, pero como eso requiere puntos, simplemente lo coloqué aquí. Me llevó 2 horas entenderlo, así que espero que ayude a alguien.

Una nota sobre el uso de inlineformset_factory.

Utilicé esa solución por mi cuenta y funcionó perfectamente, hasta que la probé con inlineformset_factory. Estaba ejecutando Django 1.0.2 y obtuve una extraña excepción KeyError. Actualicé a la última troncal y funcionó directamente.

Ahora puedo usarlo de manera similar a esto:

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

A partir de commit e091c18f50266097f648efc7cac2503968e9d217 el martes 14 de agosto 23:44:46 2012 +0200 la solución aceptada ya no puede funcionar.

La versión actual de la función django.forms.models.modelform_factory () utiliza una "técnica de construcción de tipos", que llama a la función type () en el formulario pasado para obtener el tipo de metaclase, luego usa el resultado para construir un objeto de clase de su escriba sobre la marcha ::

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

Esto significa incluso un currypartial objeto ed o pasado en lugar de una forma "hace que el pato te muerda", por así decirlo: llamará a una función con los parámetros de construcción de un ModelFormClassobjeto, devolviendo el mensaje de error ::

function() argument 1 must be code, not str

Para evitar esto, escribí una función de generador que usa un cierre para devolver una subclase de cualquier clase especificada como primer parámetro, que luego llama super.__init__después updatede enviar los kwargs con los que se proporcionan en la llamada de la función del generador ::

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

Luego, en su código, llamará a la fábrica de formularios como ::

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

advertencias:

• esto recibió muy pocas pruebas, al menos por ahora
• los parámetros proporcionados podrían entrar en conflicto y sobrescribir los utilizados por cualquier código que use el objeto devuelto por el constructor

La solución de Carl Meyer se ve muy elegante. Intenté implementarlo para modelformsets. Tenía la impresión de que no podía llamar a métodos estáticos dentro de una clase, pero lo siguiente funciona inexplicablemente:

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

En mi opinión, si hago algo como esto:

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

Luego, la palabra clave "solicitud" se propaga a todos los formularios de miembros de mi conjunto de formularios. Estoy contento, pero no tengo idea de por qué está funcionando, parece estar mal. ¿Alguna sugerencia?

Pasé algún tiempo tratando de resolver este problema antes de ver esta publicación.

La solución que se me ocurrió fue la solución de cierre (y es una solución que he usado antes con los formularios modelo Django).

Probé el método curry () como se describió anteriormente, pero no pude hacerlo funcionar con Django 1.0, así que al final volví al método de cierre.

El método de cierre es muy claro y la única rareza es que la definición de clase está anidada dentro de la vista u otra función. ¡Creo que el hecho de que esto me parezca extraño es un problema de mi experiencia previa en programación y creo que alguien con experiencia en lenguajes más dinámicos no pestañearía!

Tuve que hacer algo similar. Esto es similar a la currysolución:

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

En base a esta respuesta , encontré una solución más 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

Y ejecutarlo a la vista como

formset_factory(form=ServiceForm.make_service_form(affiliate))

Soy un novato aquí, así que no puedo agregar comentarios. Espero que este código también funcione:

ServiceFormSet = formset_factory(ServiceForm, extra=3)

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

en cuanto a agregar parámetros adicionales al conjunto BaseFormSetde formularios en lugar del formulario.