def __new__(cls, name, bases, attrs):
        formfield_callback = attrs.pop('formfield_callback', None)

        try:
            parents = [b for b in bases if issubclass(b, SearchForm)]
        except NameError:
            # We are defining SearchForm itself.
            parents = None
        declared_fields = get_declared_fields(bases, attrs, False)
        new_class = super(SearchFormMetaclass, cls).__new__(cls, name, bases, attrs)
        if not parents:
            return new_class
        
        if 'media' not in attrs:
            new_class.media = caching_media_property(new_class)
        opts = new_class._meta = SearchFormOptions(getattr(new_class, 'Meta', None))
        # TODO remove this? Currently BaseSearchForm.__init__ throws an error if
        # no model is defined.
        if opts.model:
            # If a model is defined, extract form fields from it.
            fields = fields_for_model(opts.model, opts.fields, opts.exclude, opts.widgets, formfield_callback)
            # Override default model fields with any custom declared ones
            # (plus, include all the other declared fields).
            fields.update(declared_fields)
        else:
            fields = declared_fields
        if opts.sort_field:
            fields['sort_by'] = make_sortfield(fields, ordering=opts.model._meta.ordering)
        new_class.declared_fields = declared_fields
        new_class.base_fields = fields
        return new_class
Example #2
0
    def __new__(cls, name, bases, attrs):
        formfield_callback = attrs.pop('formfield_callback', None)
        try:
            parents = [b for b in bases if issubclass(b, DocumentForm)]
        except NameError:
            # We are defining ModelForm itself.
            parents = None
        declared_fields = get_declared_fields(bases, attrs, False)
        new_class = super(DocumentFormMetaclass,
                          cls).__new__(cls, name, bases, attrs)
        if not parents:
            return new_class

        opts = new_class._meta = DocumentFormOptions(
            getattr(new_class, 'Meta', None))
        if opts.document:
            # If a model is defined, extract form fields from it.
            fields = fields_for_document(opts.document, opts.fields,
                                         opts.exclude, formfield_callback)
            # Override default model fields with any custom declared ones
            # (plus, include all the other declared fields).
            fields.update(declared_fields)
        else:
            fields = declared_fields
        new_class.declared_fields = declared_fields
        new_class.base_fields = fields
        return new_class
Example #3
0
    def __new__(cls, name, bases, attrs):
        try:
            parents = [b for b in bases if issubclass(b, PrefForm)]
        except NameError:
            # We are defining PrefForm itself.
            parents = None
        declared_fields = get_declared_fields(bases, attrs, False)
        new_class = super(PrefFormMetaclass, cls).__new__(cls, name, bases, attrs)
        if not parents:
            return new_class

        if 'media' not in attrs:
            new_class.media = media_property(new_class)
        opts = new_class._meta = PrefFormOptions(getattr(new_class, 'Meta', None))
        if opts.app:
            # If an app is defined, extract form fields from it.
            fields = fields_for_app(opts.app, opts.fields,
                                      opts.exclude, opts.owner_class)
            # Override default model fields with any custom declared ones
            # (plus, include all the other declared fields).
            fields.update(declared_fields)
        else:
            fields = declared_fields
        new_class.declared_fields = declared_fields
        new_class.base_fields = fields
        return new_class
Example #4
0
    def __new__(cls, name, bases, attrs):
        formfield_callback = attrs.pop('formfield_callback', None)
        try:
            parents = [b for b in bases if issubclass(b, DocumentForm)]
        except NameError:
            # We are defining ModelForm itself.
            parents = None
        declared_fields = get_declared_fields(bases, attrs, False)
        new_class = super(DocumentFormMetaclass, cls).__new__(cls, name, bases,
                attrs)
        if not parents:
            return new_class

        opts = new_class._meta = DocumentFormOptions(
            getattr(new_class, 'Meta', None)
        )
        if opts.document:
            # If a model is defined, extract form fields from it.
            fields = fields_for_document(opts.document, opts.fields,
                                      opts.exclude, formfield_callback)
            # Override default model fields with any custom declared ones
            # (plus, include all the other declared fields).
            fields.update(declared_fields)
        else:
            fields = declared_fields
        new_class.declared_fields = declared_fields
        new_class.base_fields = fields
        return new_class
Example #5
0
File: forms.py Project: bjornua/dna
    def __new__(cls, name, bases, attrs):
        try:
            parents = [b for b in bases if issubclass(b, DocumentForm)]
        except NameError:
            # We are defining ModelForm itself.
            parents = None

        declared_fields = get_declared_fields(bases, attrs, False)
        new_class = super(DocumentFormMetaClass,
                          cls).__new__(cls, name, bases, attrs)

        if not parents:
            return new_class

        if 'media' not in attrs:
            new_class.media = media_property(new_class)

        opts = new_class._meta = DocumentFormOptions(
            getattr(new_class, 'Meta', None))

        if opts.document:
            # If a document is defined, extract form fields from it.
            fields = fields_for_document(opts.document, opts.properties,
                                         opts.exclude)
            # Override default docuemnt fields with any custom declared ones
            # (plus, include all the other declared fields).
            fields.update(declared_fields)
        else:
            fields = declared_fields

        new_class.declared_fields = declared_fields
        new_class.base_fields = fields
        return new_class
    def __new__(cls, name, bases, attrs):
        formfield_callback = attrs.pop("formfield_callback", None)
        try:
            parents = [b for b in bases if issubclass(b, ModelForm)]
        except NameError:
            # We are defining ModelForm itself.
            parents = None
        declared_fields = get_declared_fields(bases, attrs, False)
        new_class = super(CachedModelFormMetaclass, cls).__new__(cls, name, bases, attrs)
        if not parents:
            return new_class

        if "media" not in attrs:
            new_class.media = media_property(new_class)
        opts = new_class._meta = CachedModelFormOptions(getattr(new_class, "Meta", None))
        if opts.objects:
            formfield_callback = make_formfield_callback(formfield_callback, opts.objects)
        if opts.model:
            # If a model is defined, extract form fields from it.
            fields = fields_for_model(opts.model, opts.fields, opts.exclude, opts.widgets, formfield_callback)
            # make sure opts.fields doesn't specify an invalid field
            none_model_fields = [k for k, v in list(fields.items()) if not v]
            missing_fields = set(none_model_fields) - set(declared_fields.keys())
            if missing_fields:
                message = "Unknown field(s) (%s) specified for %s"
                message = message % (", ".join(missing_fields), opts.model.__name__)
                raise FieldError(message)
            # Override default model fields with any custom declared ones
            # (plus, include all the other declared fields).
            fields.update(declared_fields)
        else:
            fields = declared_fields
        new_class.declared_fields = declared_fields
        new_class.base_fields = fields
        return new_class
Example #7
0
 def __new__(cls, name, bases, attrs):
     try:
         parents = [b for b in bases if issubclass(b, DocumentForm)]
     except NameError:
         # We are defining ModelForm itself.
         parents = None
         
     declared_fields = get_declared_fields(bases, attrs, False)
     new_class = super(DocumentFormMetaClass, cls).__new__(cls, name, bases,
                 attrs)
             
     if not parents:
         return new_class
     
     if 'media' not in attrs:
         new_class.media = media_property(new_class)
 
     opts = new_class._meta = DocumentFormOptions(getattr(new_class, 
                                             'Meta', None))
     
     if opts.document:
         # If a document is defined, extract form fields from it.
         fields = fields_for_document(opts.document, opts.properties,
                                      opts.exclude)
         # Override default docuemnt fields with any custom declared ones
         # (plus, include all the other declared fields).
         fields.update(declared_fields)
     else:
         fields = declared_fields
 
     new_class.declared_fields = declared_fields
     new_class.base_fields = fields
     return new_class
Example #8
0
 def __new__(cls, name, bases, attrs):
   # We store attrs as ModelFormMetaclass.__new__ clears all fields from it
   attrs_copy = attrs.copy()
   new_class = super(ParentsIncludedModelFormMetaclass, cls).__new__(cls, name, bases, attrs)
   # All declared fields + model fields from parent classes
   fields_without_current_model = forms.get_declared_fields(bases, attrs_copy, True)
   new_class.base_fields.update(fields_without_current_model)
   return new_class
Example #9
0
 def __new__(cls, name, bases, attrs):
     # We store attrs as ModelFormMetaclass.__new__ clears all fields from it
     attrs_copy = attrs.copy()
     new_class = super(ParentsIncludedModelFormMetaclass, cls).__new__(cls, name, bases, attrs)
     # All declared fields + model fields from parent classes
     fields_without_current_model = get_declared_fields(bases, attrs_copy, True)
     new_class.base_fields.update(fields_without_current_model)
     return new_class
Example #10
0
    def __new__(cls, name, bases, attrs):
        formfield_callback = attrs.pop('formfield_callback', None)
        try:
            parents = [b for b in bases if issubclass(b, ModelForm)]
        except NameError:
            # We are defining ModelForm itself.
            parents = None
        declared_fields = get_declared_fields(bases, attrs, False)
        new_class = super(ModelFormMetaclass, cls) \
            .__new__(cls, name, bases, attrs)
        if not parents:
            return new_class

        if 'media' not in attrs:
            new_class.media = media_property(new_class)
        opts = new_class._meta = ModelFormOptions(
            getattr(new_class, 'Meta', None))

        if opts.model:
            # If a model is defined, extract form fields from it.
            if opts.fields is None and opts.exclude is None:
                # This should be some kind of assertion error once deprecation
                # cycle is complete.
                warnings.warn(
                    "Creating a ModelForm without either the 'fields' attribute "
                    "or the 'exclude' attribute is deprecated - form %s "
                    "needs updating" % name,
                    DeprecationWarning,
                    stacklevel=2)
            '''
            if opts.fields == ALL_FIELDS:
                # sentinel for fields_for_model to indicate "get the list of
                # fields from the model"
                opts.fields = None
            '''
            fields = fields_for_model(opts.model, opts.fields, opts.exclude,
                                      opts.widgets, formfield_callback,
                                      opts.labels, opts.help_texts,
                                      opts.error_messages)

            # make sure opts.fields doesn't specify an invalid field
            none_model_fields = [k for k, v in fields.items() if not v]
            missing_fields = set(none_model_fields) - \
                             set(declared_fields.keys())
            if missing_fields:
                message = 'Unknown field(s) (%s) specified for %s'
                message = message % (', '.join(missing_fields),
                                     opts.model.__name__)
                raise FieldError(message)
            # Override default model fields with any custom declared ones
            # (plus, include all the other declared fields).
            fields.update(declared_fields)
        else:
            fields = declared_fields
        new_class.declared_fields = declared_fields
        new_class.base_fields = fields
        return new_class
Example #11
0
    def __new__(cls, name, bases, attrs):
        # let django do all the work of finding declared/inherited fields
        tmp_fields = get_declared_fields(bases, attrs, with_base_fields=False)
        declared_fields = {}
        declared_subforms = {}
        declared_subform_labels = {}
        # sort declared fields into sub-form overrides and regular fields
        for fname, f in six.iteritems(tmp_fields):
            if isinstance(f, SubformField):
                # FIXME: pass can_delete, can_delete from subformfield to formset?
                declared_subforms[fname] = f.formclass
                # if a declared subform fields has a label specified, store it
                if hasattr(f, 'form_label') and f.form_label is not None:
                    declared_subform_labels[fname] = f.form_label
                # if a subformclass has a label, use that
                elif hasattr(f.formclass, 'form_label') and \
                         f.formclass.form_label is not None:
                    declared_subform_labels[fname] = f.formclass.form_label
            else:
                declared_fields[fname] = f

        new_class = super(XmlObjectFormType,
                          cls).__new__(cls, name, bases, attrs)

        # use django's default model form options for fields, exclude, widgets, etc.
        opts = new_class._meta = SubformAwareModelFormOptions(
            getattr(new_class, 'Meta', None))
        if opts.model:
            # if a model is defined, get xml fields and any subform classes
            fields, subforms, formsets, subform_labels = formfields_for_xmlobject(
                opts.model, options=opts, declared_subforms=declared_subforms)

            # Override default model fields with any custom declared ones
            # (plus, include all the other declared fields).
            fields.update(declared_fields)

            # store all of the dynamically generated xmlobjectforms for nodefields
            new_class.subforms = subforms

            # and for listfields
            new_class.formsets = formsets

            # labels for subforms that couldn't be set by formfields_for_xmlobject
            # declared subform labels should supercede verbose xmlobject field names
            subform_labels.update(declared_subform_labels)
            new_class.subform_labels = subform_labels

        else:
            fields = declared_fields
            new_class.subforms = {}
            new_class.formsets = {}

        new_class.declared_fields = declared_fields
        new_class.base_fields = fields

        return new_class
Example #12
0
    def __new__(cls, name, bases, attrs):
        formfield_callback = attrs.pop('formfield_callback', None)
        try:
            parents = [b for b in bases if issubclass(b, ModelForm)]
        except NameError:
            # We are defining ModelForm itself.
            parents = None
        declared_fields = get_declared_fields(bases, attrs, False)
        new_class = super(ModelFormMetaclass, cls) \
            .__new__(cls, name, bases, attrs)
        if not parents:
            return new_class

        if 'media' not in attrs:
            new_class.media = media_property(new_class)
        opts = new_class._meta = ModelFormOptions(getattr(new_class, 'Meta', None))

        if opts.model:
            # If a model is defined, extract form fields from it.
            if opts.fields is None and opts.exclude is None:
                # This should be some kind of assertion error once deprecation
                # cycle is complete.
                warnings.warn("Creating a ModelForm without either the 'fields' attribute "
                              "or the 'exclude' attribute is deprecated - form %s "
                              "needs updating" % name,
                              DeprecationWarning, stacklevel=2)

            '''
            if opts.fields == ALL_FIELDS:
                # sentinel for fields_for_model to indicate "get the list of
                # fields from the model"
                opts.fields = None
            '''
            fields = fields_for_model(opts.model, opts.fields, opts.exclude,
                                      opts.widgets, formfield_callback,
                                      opts.labels, opts.help_texts, 
                                      opts.error_messages)

            # make sure opts.fields doesn't specify an invalid field
            none_model_fields = [k for k, v in fields.items() if not v]
            missing_fields = set(none_model_fields) - \
                             set(declared_fields.keys())
            if missing_fields:
                message = 'Unknown field(s) (%s) specified for %s'
                message = message % (', '.join(missing_fields),
                                     opts.model.__name__)
                raise FieldError(message)
            # Override default model fields with any custom declared ones
            # (plus, include all the other declared fields).
            fields.update(declared_fields)
        else:
            fields = declared_fields
        new_class.declared_fields = declared_fields
        new_class.base_fields = fields
        return new_class
Example #13
0
    def __new__(cls, name, bases, attrs):
        # let django do all the work of finding declared/inherited fields
        tmp_fields = get_declared_fields(bases, attrs, with_base_fields=False)
        declared_fields = {}
        declared_subforms = {}
        declared_subform_labels = {}
        # sort declared fields into sub-form overrides and regular fields
        for fname, f in six.iteritems(tmp_fields):
            if isinstance(f, SubformField):
                # FIXME: pass can_delete, can_delete from subformfield to formset?
                declared_subforms[fname] = f.formclass
                # if a declared subform fields has a label specified, store it
                if hasattr(f, 'form_label') and f.form_label is not None:
                    declared_subform_labels[fname] = f.form_label
                # if a subformclass has a label, use that
                elif hasattr(f.formclass, 'form_label') and \
                         f.formclass.form_label is not None:
                    declared_subform_labels[fname] = f.formclass.form_label
            else:
                declared_fields[fname] = f

        new_class = super(XmlObjectFormType, cls).__new__(cls, name, bases, attrs)

        # use django's default model form options for fields, exclude, widgets, etc.
        opts = new_class._meta =  SubformAwareModelFormOptions(getattr(new_class, 'Meta',  None))
        if opts.model:
            # if a model is defined, get xml fields and any subform classes
            fields, subforms, formsets, subform_labels = formfields_for_xmlobject(opts.model, options=opts,
                    declared_subforms=declared_subforms)

            # Override default model fields with any custom declared ones
            # (plus, include all the other declared fields).
            fields.update(declared_fields)

            # store all of the dynamically generated xmlobjectforms for nodefields
            new_class.subforms = subforms

            # and for listfields
            new_class.formsets = formsets

            # labels for subforms that couldn't be set by formfields_for_xmlobject
            # declared subform labels should supercede verbose xmlobject field names
            subform_labels.update(declared_subform_labels)
            new_class.subform_labels = subform_labels

        else:
            fields = declared_fields
            new_class.subforms = {}
            new_class.formsets = {}

        new_class.declared_fields = declared_fields
        new_class.base_fields = fields

        return new_class
Example #14
0
    def __new__(cls, name, bases, attrs):
        formfield_callback = attrs.pop('formfield_callback', None)
        try:
            parents = [b for b in bases if issubclass(b, ModelForm)]
        except NameError:
            # We are defining ModelForm itself.
            parents = None
        declared_fields = get_declared_fields(bases, attrs, False)
        new_class = super(ModelFormMetaclass,
                          cls).__new__(cls, name, bases, attrs)
        if not parents:
            return new_class

        if 'media' not in attrs:
            new_class.media = media_property(new_class)
        opts = new_class._meta = ModelFormOptions(
            getattr(new_class, 'Meta', None))

        # We check if a string was passed to `fields` or `exclude`,
        # which is likely to be a mistake where the user typed ('foo') instead
        # of ('foo',)
        for opt in ['fields', 'exclude']:
            value = getattr(opts, opt)
            if isinstance(value, six.string_types):
                msg = ("%(model)s.Meta.%(opt)s cannot be a string. "
                       "Did you mean to type: ('%(value)s',)?" % {
                           'model': new_class.__name__,
                           'opt': opt,
                           'value': value,
                       })
                raise TypeError(msg)

        if opts.model:
            # If a model is defined, extract form fields from it.
            fields = fields_for_model(opts.model, opts.fields, opts.exclude,
                                      opts.widgets, formfield_callback)
            # make sure opts.fields doesn't specify an invalid field
            none_model_fields = [k for k, v in six.iteritems(fields) if not v]
            missing_fields = set(none_model_fields) - \
                             set(declared_fields.keys())
            if missing_fields:
                message = 'Unknown field(s) (%s) specified for %s'
                message = message % (', '.join(missing_fields),
                                     opts.model.__name__)
                raise FieldError(message)
            # Override default model fields with any custom declared ones
            # (plus, include all the other declared fields).
            fields.update(declared_fields)
        else:
            fields = declared_fields
        new_class.declared_fields = declared_fields
        new_class.base_fields = fields
        return new_class
Example #15
0
    def __new__(cls, name, bases, attrs):
        formfield_callback = attrs.pop('formfield_callback', None)
        try:
            parents = [b for b in bases if issubclass(b, ModelForm)]
        except NameError:
            # We are defining ModelForm itself.
            parents = None
        declared_fields = get_declared_fields(bases, attrs, False)
        new_class = super(ModelFormMetaclass, cls).__new__(cls, name, bases,
                attrs)
        if not parents:
            return new_class

        if 'media' not in attrs:
            new_class.media = media_property(new_class)
        opts = new_class._meta = ModelFormOptions(getattr(new_class, 'Meta', None))

        # We check if a string was passed to `fields` or `exclude`,
        # which is likely to be a mistake where the user typed ('foo') instead
        # of ('foo',)
        for opt in ['fields', 'exclude']:
            value = getattr(opts, opt)
            if isinstance(value, six.string_types):
                msg = ("%(model)s.Meta.%(opt)s cannot be a string. "
                       "Did you mean to type: ('%(value)s',)?" % {
                           'model': new_class.__name__,
                           'opt': opt,
                           'value': value,
                       })
                raise TypeError(msg)

        if opts.model:
            # If a model is defined, extract form fields from it.
            fields = fields_for_model(opts.model, opts.fields,
                                      opts.exclude, opts.widgets, formfield_callback)
            # make sure opts.fields doesn't specify an invalid field
            none_model_fields = [k for k, v in six.iteritems(fields) if not v]
            missing_fields = set(none_model_fields) - \
                             set(declared_fields.keys())
            if missing_fields:
                message = 'Unknown field(s) (%s) specified for %s'
                message = message % (', '.join(missing_fields),
                                     opts.model.__name__)
                raise FieldError(message)
            # Override default model fields with any custom declared ones
            # (plus, include all the other declared fields).
            fields.update(declared_fields)
        else:
            fields = declared_fields
        new_class.declared_fields = declared_fields
        new_class.base_fields = fields
        return new_class
    def __new__(cls, name, bases, attrs):
        formfield_callback = attrs.pop('formfield_callback', None)
        try:
            parents = [
                b for b in bases
                if issubclass(b, DocumentForm) or
                issubclass(b, EmbeddedDocumentForm)
            ]
        except NameError:
            # We are defining DocumentForm itself.
            parents = None
        declared_fields = get_declared_fields(bases, attrs, False)
        new_class = super(DocumentFormMetaclass, cls).__new__(cls, name,
                                                              bases, attrs)
        if not parents:
            return new_class

        if 'media' not in attrs:
            new_class.media = media_property(new_class)
        
        opts = new_class._meta = ModelFormOptions(
            getattr(new_class, 'Meta', None)
        )
        if opts.document:
            formfield_generator = getattr(opts,
                                          'formfield_generator',
                                          _fieldgenerator)
            
            # If a model is defined, extract form fields from it.
            fields = fields_for_document(opts.document, opts.fields,
                                         opts.exclude, opts.widgets,
                                         formfield_callback,
                                         formfield_generator)
            # make sure opts.fields doesn't specify an invalid field
            none_document_fields = [k for k, v in fields.items() if not v]
            missing_fields = (set(none_document_fields) -
                              set(declared_fields.keys()))
            if missing_fields:
                message = 'Unknown field(s) (%s) specified for %s'
                message = message % (', '.join(missing_fields),
                                     opts.model.__name__)
                raise FieldError(message)
            # Override default model fields with any custom declared ones
            # (plus, include all the other declared fields).
            fields.update(declared_fields)
        else:
            fields = declared_fields
            
        new_class.declared_fields = declared_fields
        new_class.base_fields = fields
        return new_class
Example #17
0
    def __new__(cls, name, bases, attrs):
        super_new = super(TranslateableModelFormMetaclass, cls).__new__

        formfield_callback = attrs.pop("formfield_callback", None)
        declared_fields = get_declared_fields(bases, attrs, False)
        new_class = super_new(cls, name, bases, attrs)

        if "media" not in attrs:
            new_class.media = media_property(new_class)
        opts = new_class._meta = ModelFormOptions(getattr(new_class, "Meta", attrs.get("Meta", None)))
        if opts.model:
            if not issubclass(opts.model, TranslateableModel):
                raise Exception("Only TranslateableModel subclasses may use TranslateableModelForm")
            mopts = opts.model._meta

            shared_fields = mopts.get_all_field_names()

            sfieldnames = [field for field in opts.fields or [] if field in shared_fields]
            tfieldnames = [field for field in opts.fields or [] if field not in shared_fields]
            sexclude = [field for field in opts.exclude or [] if field in shared_fields]
            texclude = [field for field in opts.exclude or [] if field not in shared_fields]

            if not sfieldnames:
                sfieldnames = None
            if not tfieldnames:
                tfieldnames = None

            # If a model is defined, extract form fields from it.
            sfields = fields_for_model(opts.model, sfieldnames, sexclude, opts.widgets, formfield_callback)
            tfields = fields_for_model(
                mopts.translations_model, tfieldnames, texclude, opts.widgets, formfield_callback
            )

            fields = sfields
            fields.update(tfields)

            # make sure opts.fields doesn't specify an invalid field
            none_model_fields = [k for k, v in fields.iteritems() if not v]
            missing_fields = set(none_model_fields) - set(declared_fields.keys())
            if missing_fields:
                message = "Unknown field(s) (%s) specified for %s"
                message = message % (", ".join(missing_fields), opts.model.__name__)
                raise FieldError(message)
            # Override default model fields with any custom declared ones
            # (plus, include all the other declared fields).
            fields.update(declared_fields)
        else:
            fields = declared_fields
        new_class.declared_fields = declared_fields
        new_class.base_fields = fields
        return new_class
Example #18
0
    def __new__(mcs, name, bases, attrs):
        declared_fields = get_declared_fields(bases, attrs, False)
        new_class = super(ModelFormMetaclass,
                          mcs).__new__(mcs, name, bases, attrs)

        if bases == (BaseEGModelForm, ):
            return new_class

        if 'media' not in attrs:
            new_class.media = media_property(new_class)
        opts = new_class._meta = ModelFormOptions(
            getattr(new_class, 'Meta', None))

        if opts.model:
            # If a model is defined, extract form fields from it.
            if opts.fields is None and opts.exclude is None:
                raise ImproperlyConfigured(
                    "Creating a ModelForm without either the 'fields' attribute "
                    "or the 'exclude' attribute is prohibited; form %s "
                    "needs updating." % name)

            if opts.fields == ALL_FIELDS:
                # Sentinel for fields_for_model to indicate "get the list of
                # fields from the model"
                opts.fields = None

            fields = fields_for_model(opts.model, opts.fields, opts.exclude,
                                      opts.widgets, opts.localized_fields,
                                      opts.labels, opts.help_texts,
                                      opts.error_messages)

            # make sure opts.fields doesn't specify an invalid field
            none_model_fields = [k for k, v in six.iteritems(fields) if not v]
            missing_fields = (set(none_model_fields) -
                              set(declared_fields.keys()))
            if missing_fields:
                message = 'Unknown field(s) (%s) specified for %s'
                message = message % (', '.join(missing_fields),
                                     opts.model.__name__)
                raise FieldError(message)
            # Override default model fields with any custom declared ones
            # (plus, include all the other declared fields).
            fields.update(declared_fields)
        else:
            fields = declared_fields

        new_class.base_fields = fields
        new_class.declared_fields = declared_fields
        return new_class
Example #19
0
    def __new__(cls, name, bases, attrs):
        formfield_callback = attrs.pop('formfield_callback', None)
        try:
            parents = [
                b for b in bases if issubclass(b, DocumentForm)
                or issubclass(b, EmbeddedDocumentForm)
            ]
        except NameError:
            # We are defining DocumentForm itself.
            parents = None
        declared_fields = get_declared_fields(bases, attrs, False)
        new_class = super(DocumentFormMetaclass,
                          cls).__new__(cls, name, bases, attrs)
        if not parents:
            return new_class

        if 'media' not in attrs:
            new_class.media = media_property(new_class)

        opts = new_class._meta = ModelFormOptions(
            getattr(new_class, 'Meta', None))
        if opts.document:
            formfield_generator = getattr(opts, 'formfield_generator',
                                          _fieldgenerator)

            # If a model is defined, extract form fields from it.
            fields = fields_for_document(opts.document, opts.fields,
                                         opts.exclude, opts.widgets,
                                         formfield_callback,
                                         formfield_generator)
            # make sure opts.fields doesn't specify an invalid field
            none_document_fields = [k for k, v in fields.items() if not v]
            missing_fields = (set(none_document_fields) -
                              set(declared_fields.keys()))
            if missing_fields:
                message = 'Unknown field(s) (%s) specified for %s'
                message = message % (', '.join(missing_fields),
                                     opts.model.__name__)
                raise FieldError(message)
            # Override default model fields with any custom declared ones
            # (plus, include all the other declared fields).
            fields.update(declared_fields)
        else:
            fields = declared_fields

        new_class.declared_fields = declared_fields
        new_class.base_fields = fields
        return new_class
Example #20
0
    def __new__(mcs, name, bases, attrs):
        declared_fields = get_declared_fields(bases, attrs, False)
        new_class = super(ModelFormMetaclass, mcs).__new__(mcs, name, bases, attrs)

        if bases == (BaseEGModelForm,):
            return new_class

        if 'media' not in attrs:
            new_class.media = media_property(new_class)
        opts = new_class._meta = ModelFormOptions(getattr(new_class, 'Meta', None))

        if opts.model:
            # If a model is defined, extract form fields from it.
            if opts.fields is None and opts.exclude is None:
                raise ImproperlyConfigured(
                    "Creating a ModelForm without either the 'fields' attribute "
                    "or the 'exclude' attribute is prohibited; form %s "
                    "needs updating." % name
                )

            if opts.fields == ALL_FIELDS:
                # Sentinel for fields_for_model to indicate "get the list of
                # fields from the model"
                opts.fields = None

            fields = fields_for_model(opts.model, opts.fields, opts.exclude,
                                      opts.widgets, opts.localized_fields,
                                      opts.labels, opts.help_texts,
                                      opts.error_messages)

            # make sure opts.fields doesn't specify an invalid field
            none_model_fields = [k for k, v in six.iteritems(fields) if not v]
            missing_fields = (set(none_model_fields) -
                              set(declared_fields.keys()))
            if missing_fields:
                message = 'Unknown field(s) (%s) specified for %s'
                message = message % (', '.join(missing_fields),
                                     opts.model.__name__)
                raise FieldError(message)
            # Override default model fields with any custom declared ones
            # (plus, include all the other declared fields).
            fields.update(declared_fields)
        else:
            fields = declared_fields

        new_class.base_fields = fields
        new_class.declared_fields = declared_fields
        return new_class
Example #21
0
    def __new__(cls, name, bases, attrs):
        fields = [(field_name, attrs.pop(field_name))
                  for field_name, obj in attrs.items()
                  if isinstance(obj, Field)]
        fields.sort(
            lambda x, y: cmp(x[1].creation_counter, y[1].creation_counter))

        # If this class is subclassing another Form, add that Form's fields.
        # Note that we loop over the bases in *reverse*. This is necessary in
        # order to preserve the correct order of fields.
        for base in bases[::-1]:
            if hasattr(base, 'base_fields'):
                fields = base.base_fields.items() + fields

        attrs['base_fields'] = SortedDictFromList(fields)

        # rest of this method is taken from actual django
        # source for ModelFormMetaclass class
        formfield_callback = attrs.pop('formfield_callback',
                                       lambda f: f.formfield())
        try:
            parents = [b for b in bases if issubclass(b, BaseModelForm)]
        except NameError:
            # We are defining ModelForm itself.
            parents = None
        declared_fields = get_declared_fields(bases, attrs, False)
        new_class = super(SmartModelFormMetaclass,
                          cls).__new__(cls, name, bases, attrs)
        if not parents:
            return new_class

        if 'media' not in attrs:
            new_class.media = media_property(new_class)
        opts = new_class._meta = ModelFormOptions(
            getattr(new_class, 'Meta', None))
        if opts.model:
            # If a model is defined, extract form fields from it.
            fields = fields_for_model(opts.model, opts.fields, opts.exclude,
                                      formfield_callback)
            # Override default model fields with any custom declared ones
            # (plus, include all the other declared fields).
            fields.update(declared_fields)
        else:
            fields = declared_fields
        new_class.declared_fields = declared_fields
        new_class.base_fields = fields
        return new_class
Example #22
0
    def __new__(cls, name, bases, attrs):
        formfield_callback = attrs.pop('formfield_callback', None)
        try:
            # HACK: Had to replace baseclass
            # TODO: Report that this can not overrode, there should be something else.
            parents = [b for b in bases if issubclass(b, MultilingualModelForm)]
        except NameError:
            # We are defining ModelForm itself.
            parents = None
        declared_fields = get_declared_fields(bases, attrs, False)
        new_class = super(MultilingualModelFormMetaclass, cls).__new__(cls, name, bases,
                attrs)
        if not parents:
            return new_class

        if 'media' not in attrs:
            new_class.media = media_property(new_class)
        opts = new_class._meta = ModelFormOptions(getattr(new_class, 'Meta', None))
        if opts.model:
            # If a model is defined, extract form fields from it.
            fields = fields_for_model(opts.model, opts.fields,
                                      opts.exclude, opts.widgets, formfield_callback)
            found_fields = [k for k, v in fields.items() if v is not None]

            #HACK: This is update of original method. I should be able to change it to overrides
            translation_model = getattr(opts.model._meta, 'translation_model', None)
            if translation_model:
                if opts.exclude is None:
                    exclude = ['id', 'language_code', 'master'] + found_fields
                else:
                    exclude = list(opts.exclude) + ['id', 'language_code', 'master'] + found_fields

                translated_fields = fields_for_model(
                    translation_model, opts.fields, exclude, opts.widgets, formfield_callback
                )

                fields.update(translated_fields)

            # Override default model fields with any custom declared ones
            # (plus, include all the other declared fields).
            fields.update(declared_fields)
        else:
            fields = declared_fields
        new_class.declared_fields = declared_fields
        new_class.base_fields = fields
        return new_class
Example #23
0
    def __new__(cls, name, bases, attrs):
        try:
            parents = [b for b in bases if issubclass(b, DocumentForm)]
        except NameError:
            # We are defining ModelForm itself.
            parents = None

        declared_fields = get_declared_fields(bases, attrs, False)
        new_class = super(DocumentFormMetaClass, cls).__new__(cls, name, bases, attrs)

        if not parents:
            return new_class

        if "media" not in attrs:
            new_class.media = media_property(new_class)

        opts = new_class._meta = DocumentFormOptions(getattr(new_class, "Meta", None))
        if opts.schema:
            fields = fields_for_document(
                opts.schema, opts.properties, opts.exclude, formfield_callback=opts.formfield_callback
            )
            # Override default docuemnt fields with any custom declared ones
            # (plus, include all the other declared fields).
            new_class.serialized_fields = fields.keys()
            fields.update(declared_fields)
        elif opts.document:  # TODO this should no longer be necessary
            # If a document is defined, extract form fields from it.
            fields = fields_for_document(
                opts.document,
                opts.properties,
                opts.exclude,
                formfield_callback=opts.formfield_callback,
                dotpath=opts.dotpath,
            )
            # Override default docuemnt fields with any custom declared ones
            # (plus, include all the other declared fields).
            new_class.serialized_fields = fields.keys()
            fields.update(declared_fields)
        else:
            fields = declared_fields

        new_class.declared_fields = declared_fields
        new_class.base_fields = fields
        return new_class
Example #24
0
    def __new__(cls, name, bases, attrs):
        fields = [(field_name, attrs.pop(field_name)) for field_name, obj in attrs.items() if isinstance(obj, Field)]
        fields.sort(lambda x, y: cmp(x[1].creation_counter, y[1].creation_counter))

        # If this class is subclassing another Form, add that Form's fields.
        # Note that we loop over the bases in *reverse*. This is necessary in
        # order to preserve the correct order of fields.
        for base in bases[::-1]:
            if hasattr(base, 'base_fields'):
                fields = base.base_fields.items() + fields

        attrs['base_fields'] = SortedDictFromList(fields)

        # rest of this method is taken from actual django 
        # source for ModelFormMetaclass class
        formfield_callback = attrs.pop('formfield_callback',
                lambda f: f.formfield())
        try:
            parents = [b for b in bases if issubclass(b, BaseModelForm)]
        except NameError:
            # We are defining ModelForm itself.
            parents = None
        declared_fields = get_declared_fields(bases, attrs, False)
        new_class = super(SmartModelFormMetaclass, cls).__new__(cls, name, bases,
                attrs)
        if not parents:
            return new_class

        if 'media' not in attrs:
            new_class.media = media_property(new_class)
        opts = new_class._meta = ModelFormOptions(getattr(new_class, 'Meta', None))
        if opts.model:
            # If a model is defined, extract form fields from it.
            fields = fields_for_model(opts.model, opts.fields,
                                      opts.exclude, formfield_callback)
            # Override default model fields with any custom declared ones
            # (plus, include all the other declared fields).
            fields.update(declared_fields)
        else:
            fields = declared_fields
        new_class.declared_fields = declared_fields
        new_class.base_fields = fields
        return new_class
Example #25
0
    def __new__(cls, name, bases, attrs):
        try:
            parents = [b for b in bases if issubclass(b, DocumentForm) or
                                           issubclass(b, EmbeddedDocumentForm)]
        except NameError:
            # We are defining DocumentForm itself.
            parents = None
        new_class = super(DocumentFormMetaClass, cls).__new__(cls, name, bases,
                attrs)
        if not parents:
            return new_class

        if 'media' not in attrs:
            new_class.media = media_property(new_class)
        opts = new_class._meta = DocumentFormOptions(getattr(new_class, 'Meta', None))
        declared_fields = get_declared_fields(bases, attrs, False)
        if opts.document:
            # If a document is defined, extract form fields from it.
            fields = fields_for_document(opts.document, opts.fields,
                                      opts.exclude, opts.widgets, opts.formfield_generator)
            # make sure fields doesn't specify an invalid field
            none_document_fields = [k for k, v in fields.iteritems() if not v]
            missing_fields = set(none_document_fields) - \
                             set(declared_fields.keys())
            if missing_fields:
                message = 'Unknown field(s) (%s) specified for %s'
                message = message % (', '.join(missing_fields),
                                     opts.document.__name__)
                raise FieldError(message)
            # Override default document fields with any custom declared ones
            # (plus, include all the other declared fields).
            fields.update(declared_fields)
            # filter fields not supported by ``formfield_generator`` and not
            # replaced by ``declared_fields``
            for n, f in fields.items():
                if not f:
                    del fields[n]
        else:
            fields = declared_fields
        new_class.declared_fields = declared_fields
        new_class.base_fields = fields
        return new_class
Example #26
0
    def __new__(mcs, name, bases, attrs):
        formfield_callback = attrs.pop(
            'formfield_callback', lambda f, **kwargs: f.formfield(**kwargs))
        try:
            parents = [b for b in bases if issubclass(b, MapModelForm)]
        except NameError:
            # We are defining MapModelForm itself.
            parents = None
        declared_fields = get_declared_fields(bases, attrs, False)
        new_class = super(MapModelFormMetaclass,
                          mcs).__new__(mcs, name, bases, attrs)
        if not parents:
            return new_class

        if 'media' not in attrs:
            new_class.media = forms.widgets.media_property(new_class)
        opts = new_class._meta = MapModelFormOptions(
            getattr(new_class, 'Meta', None))
        if opts.model:
            # If a model is defined, extract form fields from it.
            fields = forms.models.fields_for_model(opts.model, opts.fields,
                                                   opts.exclude, opts.widgets,
                                                   formfield_callback)

            # Override default model fields with any custom declared ones
            # (plus, include all the other declared fields).
            fields.update(declared_fields)
        else:
            fields = declared_fields

        # Transform base fields by extracting types mentioned in 'maps'
        initial_data_keymap = apply_maps_to_modelform_fields(
            fields,
            opts.maps,
            default_field_class=opts.default_field_class,
            default_template=opts.template)

        new_class.initial_data_keymap = initial_data_keymap
        new_class.declared_fields = declared_fields
        new_class.base_fields = fields
        return new_class
Example #27
0
    def __new__(mcs, name, bases, attrs):
        formfield_callback = attrs.pop('formfield_callback',
                lambda f, **kwargs: f.formfield(**kwargs))
        try:
            parents = [b for b in bases if issubclass(b, MapModelForm)]
        except NameError:
            # We are defining MapModelForm itself.
            parents = None
        #declared_fields = forms.models.get_declared_fields(bases, attrs, False)
        #Above line fails in django1.7 
        declared_fields = get_declared_fields(bases, attrs, False)
        new_class = super(MapModelFormMetaclass, mcs).__new__(mcs, name, bases,
                attrs)
        if not parents:
            return new_class

        if 'media' not in attrs:
            new_class.media = forms.widgets.media_property(new_class)
        opts = new_class._meta = MapModelFormOptions(
                getattr(new_class, 'Meta', None))
        if opts.model:
            # If a model is defined, extract form fields from it.
            fields = forms.models.fields_for_model(opts.model, opts.fields,
                                      opts.exclude, opts.widgets, 
                                      formfield_callback)

            # Override default model fields with any custom declared ones
            # (plus, include all the other declared fields).
            fields.update(declared_fields)
        else:
            fields = declared_fields

        # Transform base fields by extracting types mentioned in 'maps'
        initial_data_keymap = apply_maps_to_modelform_fields(
                fields, opts.maps, default_field_class=opts.default_field_class,
                default_template=opts.template)

        new_class.initial_data_keymap = initial_data_keymap
        new_class.declared_fields = declared_fields
        new_class.base_fields = fields
        return new_class
Example #28
0
 def __new__(cls, name, bases, attrs):
     formfield_callback = attrs.pop('formfield_callback', None)
     try:
         parents = [b for b in bases if issubclass(b, ModelForm)]
     except NameError:
         # defining ModelForm itself
         parents = None
     declared_fields = get_declared_fields(bases, attrs, False)
     new_class = super(ModelFormMetaclass, cls).__new__(cls, name, bases,
         attrs)
     if not parents:
         return new_class
     opts = new_class._meta = ModelFormOptions(getattr(new_class, 'Meta',
         None))
     if opts.model:
         # if model is defined then extract the fields from the associated
         # FOM Object
         fields = fields_for_model(opts.model, opts.fields, opts.exclude,
             formfield_callback)
         # override default FOM Object's fields with any custom declared ones
         fields.update(declared_fields)
     new_class.declared_fields = declared_fields
     new_class.base_fields = fields
     return new_class
Example #29
0
    def __new__(cls, name, bases, attrs):
        formfield_callback = attrs.pop('formfield_callback', None)
        try:
            parents = [b for b in bases if issubclass(b, HTML5ModelForm)]
        except NameError:
            # We are defining ModelForm itself.
            parents = None
        declared_fields = get_declared_fields(bases, attrs, False)
        new_class = super(HTML5ModelFormMetaclass, cls).__new__(cls, name, bases,
                attrs)
        if not parents:
            return new_class

        if 'media' not in attrs:
            new_class.media = media_property(new_class)
        opts = new_class._meta = original.ModelFormOptions(getattr(new_class, 'Meta', None))
        if opts.model:
            # If a model is defined, extract form fields from it.
            fields = fields_for_model(opts.model, opts.fields,
                                      opts.exclude, opts.widgets, formfield_callback)
            # make sure opts.fields doesn't specify an invalid field
            none_model_fields = [k for k, v in fields.iteritems() if not v]
            missing_fields = set(none_model_fields) - \
                             set(declared_fields.keys())
            if missing_fields:
                message = 'Unknown field(s) (%s) specified for %s'
                message = message % (', '.join(missing_fields),
                                     opts.model.__name__)
                raise FieldError(message)

            fields.update(declared_fields)
        else:
            fields = declared_fields
        new_class.declared_fields = declared_fields
        new_class.base_fields = fields
        return new_class
Example #30
0
    def __new__(cls, name, bases, attrs):
        formfield_callback = attrs.pop('formfield_callback', None)
        try:
            parents = [b for b in bases if issubclass(b, BaseModelForm)]
            # for Django<=1.6, fix bug in forms.models:  ^^^^^^^^^^^^^
        except NameError:
            # We are defining ModelForm itself.
            parents = None
        declared_fields = get_declared_fields(bases, attrs, False)
        new_class = super(PatchedModelFormMetaclass,
                          cls).__new__(cls, name, bases, attrs)
        if not parents:
            return new_class

        if 'media' not in attrs:
            new_class.media = media_property(new_class)
        opts = new_class._meta = ModelFormOptions(
            getattr(new_class, 'Meta', None))

        # We check if a string was passed to `fields` or `exclude`,
        # which is likely to be a mistake where the user typed ('foo') instead
        # of ('foo',)
        for opt in ['fields', 'exclude', 'localized_fields']:
            value = getattr(opts, opt)
            if isinstance(value, six.string_types) and value != ALL_FIELDS:
                msg = ("%(model)s.Meta.%(opt)s cannot be a string. "
                       "Did you mean to type: ('%(value)s',)?" % {
                           'model': new_class.__name__,
                           'opt': opt,
                           'value': value,
                       })
                raise TypeError(msg)

        if opts.model:
            # If a model is defined, extract form fields from it.

            if opts.fields is None and opts.exclude is None:
                # This should be some kind of assertion error once deprecation
                # cycle is complete.
                warnings.warn(
                    "Creating a ModelForm without either the 'fields' attribute "
                    "or the 'exclude' attribute is deprecated - form %s "
                    "needs updating" % name,
                    PendingDeprecationWarning,
                    stacklevel=2)

            if opts.fields == ALL_FIELDS:
                # sentinel for fields_for_model to indicate "get the list of
                # fields from the model"
                opts.fields = None

            fields = fields_for_model(opts.model, opts.fields, opts.exclude,
                                      opts.widgets, formfield_callback,
                                      opts.localized_fields, opts.labels,
                                      opts.help_texts, opts.error_messages)

            # make sure opts.fields doesn't specify an invalid field
            none_model_fields = [k for k, v in six.iteritems(fields) if not v]
            missing_fields = set(none_model_fields) - \
                             set(declared_fields.keys())
            if missing_fields:
                message = 'Unknown field(s) (%s) specified for %s'
                message = message % (', '.join(missing_fields),
                                     opts.model.__name__)
                raise FieldError(message)
            # Override default model fields with any custom declared ones
            # (plus, include all the other declared fields).
            fields.update(declared_fields)
        else:
            fields = declared_fields
        new_class.declared_fields = declared_fields
        new_class.base_fields = fields
        return new_class
Example #31
0
    def __new__(cls, name, bases, attrs):
        formfield_callback = attrs.pop('formfield_callback', None)
        try:
            parents = [b for b in bases if issubclass(b, ModelForm)]
        except NameError:
            # We are defining ModelForm itself.
            parents = None
        declared_fields = get_declared_fields(bases, attrs, False)
        new_class = super(ModelFormMetaclass, cls).__new__(cls, name, bases,
                attrs)
        if not parents:
            return new_class

        if 'media' not in attrs:
            new_class.media = media_property(new_class)
        opts = new_class._meta = ModelFormOptions(getattr(new_class, 'Meta', None))

        # We check if a string was passed to `fields` or `exclude`,
        # which is likely to be a mistake where the user typed ('foo') instead
        # of ('foo',)
        for opt in ['fields', 'exclude', 'localized_fields']:
            value = getattr(opts, opt)
            if isinstance(value, six.string_types) and value != ALL_FIELDS:
                msg = ("%(model)s.Meta.%(opt)s cannot be a string. "
                       "Did you mean to type: ('%(value)s',)?" % {
                           'model': new_class.__name__,
                           'opt': opt,
                           'value': value,
                       })
                raise TypeError(msg)

        if opts.model:
            # If a model is defined, extract form fields from it.

            if opts.fields is None and opts.exclude is None:
                # This should be some kind of assertion error once deprecation
                # cycle is complete.
                warnings.warn("Creating a ModelForm without either the 'fields' attribute "
                              "or the 'exclude' attribute is deprecated - form %s "
                              "needs updating" % name,
                              PendingDeprecationWarning, stacklevel=2)

            if opts.fields == ALL_FIELDS:
                # sentinel for fields_for_model to indicate "get the list of
                # fields from the model"
                opts.fields = None

            fields = fields_for_model(opts.model, opts.fields, opts.exclude,
                                      opts.widgets, formfield_callback, opts.localized_fields)

            # make sure opts.fields doesn't specify an invalid field
            none_model_fields = [k for k, v in six.iteritems(fields) if not v]
            missing_fields = set(none_model_fields) - \
                             set(declared_fields.keys())
            if missing_fields:
                message = 'Unknown field(s) (%s) specified for %s'
                message = message % (', '.join(missing_fields),
                                     opts.model.__name__)
                raise FieldError(message)
            # Override default model fields with any custom declared ones
            # (plus, include all the other declared fields).
            fields.update(declared_fields)
        else:
            fields = declared_fields
        new_class.declared_fields = declared_fields
        new_class.base_fields = fields
        return new_class
Example #32
0
    def __new__(cls, name, bases, attrs):
        
        """
        Django 1.3 fix, that removes all Meta.fields and Meta.exclude
        fieldnames that are in the translatable model. This ensures
        that the superclass' init method doesnt throw a validation
        error
        """
        fields = []
        exclude = []
        fieldsets = []
        if "Meta" in attrs:
            meta = attrs["Meta"]
            if getattr(meta, "fieldsets", False):
                fieldsets = meta.fieldsets
                meta.fieldsets = []
            if getattr(meta, "fields", False):
                fields = meta.fields
                meta.fields = []
            if getattr(meta, "exclude", False):
                exclude = meta.exclude
                meta.exclude = []
        # End 1.3 fix
        
        super_new = super(TranslatableModelFormMetaclass, cls).__new__
        
        formfield_callback = attrs.pop('formfield_callback', None)
        declared_fields = get_declared_fields(bases, attrs, False)
        new_class = super_new(cls, name, bases, attrs)
        
        # Start 1.3 fix
        if fields:
            new_class.Meta.fields = fields
        if exclude:
            new_class.Meta.exclude = exclude
        if fieldsets:
            new_class.Meta.fieldsets = fieldsets
        # End 1.3 fix

        if not getattr(new_class, "Meta", None):
            class Meta:
                exclude = ['language_code']
            new_class.Meta = Meta
        elif not getattr(new_class.Meta, 'exclude', None):
            new_class.Meta.exclude = ['language_code']
        elif getattr(new_class.Meta, 'exclude', False):
            if 'language_code' not in new_class.Meta.exclude:
                new_class.Meta.exclude.append("language_code")

        if 'Media' not in attrs:
            new_class.media = media_property(new_class)
        opts = new_class._meta = ModelFormOptions(getattr(new_class, 'Meta', attrs.get('Meta', None)))
        if opts.model:
            # bail out if a wrong model uses this form class
            if not issubclass(opts.model, TranslatableModel):
                raise TypeError(
                    "Only TranslatableModel subclasses may use TranslatableModelForm"
                )
            mopts = opts.model._meta
            
            shared_fields = mopts.get_all_field_names()
            
            # split exclude and include fieldnames into shared and translated
            sfieldnames = [field for field in opts.fields or [] if field in shared_fields]
            tfieldnames = [field for field in opts.fields or [] if field not in shared_fields]
            sexclude = [field for field in opts.exclude or [] if field in shared_fields]
            texclude = [field for field in opts.exclude or [] if field not in shared_fields]
            
            # required by fields_for_model
            if not sfieldnames :
                sfieldnames = None if not fields else []
            if not tfieldnames:
                tfieldnames = None if not fields else []
            
            # If a model is defined, extract form fields from it.
            sfields = fields_for_model(opts.model, sfieldnames, sexclude,
                                       opts.widgets, formfield_callback)
            tfields = fields_for_model(mopts.translations_model, tfieldnames,
                                       texclude, opts.widgets, formfield_callback)
            
            fields = sfields
            fields.update(tfields)
            
            # make sure opts.fields doesn't specify an invalid field
            none_model_fields = [k for k, v in fields.iteritems() if not v]
            missing_fields = set(none_model_fields) - \
                             set(declared_fields.keys())
            if missing_fields:
                message = 'Unknown field(s) (%s) specified for %s'
                message = message % (', '.join(missing_fields),
                                     opts.model.__name__)
                raise FieldError(message)
            # Override default model fields with any custom declared ones
            # (plus, include all the other declared fields).
            fields.update(declared_fields)
            
            if new_class._meta.exclude:
                new_class._meta.exclude = list(new_class._meta.exclude)
            else:
                new_class._meta.exclude = []
                
            for field in (mopts.translations_accessor, 'master'):
                if not field in new_class._meta.exclude:
                    new_class._meta.exclude.append(field)
        else:
            fields = declared_fields
        new_class.declared_fields = declared_fields
        new_class.base_fields = fields
        # always exclude the FKs
        return new_class
Example #33
0
 def __new__(cls, name, bases, attrs):
     
     """
     Django 1.3 fix, that removes all Meta.fields and Meta.exclude
     fieldnames that are in the translatable model. This ensures
     that the superclass' init method doesnt throw a validation
     error
     """
     fields = []
     exclude = []
     if "Meta" in attrs:
         meta = attrs["Meta"]
         if getattr(meta, "fields", False):
             fields = meta.fields
             meta.fields = []
         if getattr(meta, "exclude", False):
             exclude = meta.exclude
             meta.exclude = []
     # End 1.3 fix
     
     super_new = super(TranslatableModelFormMetaclass, cls).__new__
     
     formfield_callback = attrs.pop('formfield_callback', None)
     declared_fields = get_declared_fields(bases, attrs, False)
     new_class = super_new(cls, name, bases, attrs)
     
     # Start 1.3 fix
     if fields:
         new_class.Meta.fields = fields
     if exclude:
         new_class.Meta.exclude = exclude
     # End 1.3 fix
     if 'Media' not in attrs:
         new_class.media = media_property(new_class)
     opts = new_class._meta = ModelFormOptions(getattr(new_class, 'Meta', attrs.get('Meta', None)))
     if opts.model:
         # bail out if a wrong model uses this form class
         if not issubclass(opts.model, TranslatableModel):
             raise TypeError(
                 "Only TranslatableModel subclasses may use TranslatableModelForm"
             )
         mopts = opts.model._meta
         
         shared_fields = mopts.get_all_field_names()
         
         # split exclude and include fieldnames into shared and translated
         sfieldnames = [field for field in opts.fields or [] if field in shared_fields]
         tfieldnames = [field for field in opts.fields or [] if field not in shared_fields]
         sexclude = [field for field in opts.exclude or [] if field in shared_fields]
         texclude = [field for field in opts.exclude or [] if field not in shared_fields]
         
         # required by fields_for_model
         if not sfieldnames:
             sfieldnames = None
         if not tfieldnames:
             tfieldnames = None  
         
         # If a model is defined, extract form fields from it.
         sfields = fields_for_model(opts.model, sfieldnames, sexclude,
                                    opts.widgets, formfield_callback)
         tfields = fields_for_model(mopts.translations_model, tfieldnames,
                                    texclude, opts.widgets, formfield_callback)
         
         fields = sfields
         fields.update(tfields)
         
         # make sure opts.fields doesn't specify an invalid field
         none_model_fields = [k for k, v in fields.iteritems() if not v]
         missing_fields = set(none_model_fields) - \
                          set(declared_fields.keys())
         if missing_fields:
             message = 'Unknown field(s) (%s) specified for %s'
             message = message % (', '.join(missing_fields),
                                  opts.model.__name__)
             raise FieldError(message)
         # Override default model fields with any custom declared ones
         # (plus, include all the other declared fields).
         fields.update(declared_fields)
         
         if new_class._meta.exclude:
             new_class._meta.exclude = list(new_class._meta.exclude)
         else:
             new_class._meta.exclude = []
             
         for field in (mopts.translations_accessor, 'master'):
             if not field in new_class._meta.exclude:
                 new_class._meta.exclude.append(field)
     else:
         fields = declared_fields
     new_class.declared_fields = declared_fields
     new_class.base_fields = fields
     # always exclude the FKs
     return new_class