def __new__(cls, name, bases, attrs): if name in cls.plugins_with_extra_fields: ExtraFieldsMixin.media = media_property(ExtraFieldsMixin) bases = (ExtraFieldsMixin,) + bases if name in cls.plugins_with_sharables: SharableGlossaryMixin.media = media_property(SharableGlossaryMixin) bases = (SharableGlossaryMixin,) + bases attrs['fields'] += (('save_shared_glossary', 'save_as_identifier'), 'shared_glossary',) attrs['sharable_fields'] = cls.plugins_with_sharables[name] base_model = SharableCascadeElement else: base_model = CascadeElement if name in settings.CMSPLUGIN_CASCADE['plugins_with_extra_render_templates'].keys(): RenderTemplateMixin.media = media_property(RenderTemplateMixin) bases = (RenderTemplateMixin,) + bases model_mixins = attrs.pop('model_mixins', ()) if name == 'SegmentPlugin': # SegmentPlugin shall additionally inherit from configured mixin classes model_mixins += tuple(import_string(mc[0]) for mc in settings.CMSPLUGIN_CASCADE['segmentation_mixins']) module = attrs.get('__module__') app_label = attrs.get('app_label', module.split('.')[0]) attrs['model'] = create_proxy_model(name, app_label, model_mixins, base_model, module=module) if is_installed('reversion'): import reversion.revisions if not reversion.revisions.is_registered(base_model): reversion.revisions.register(base_model) # handle ambiguous plugin names by appending a symbol if 'name' in attrs and settings.CMSPLUGIN_CASCADE['plugin_prefix']: attrs['name'] = mark_safe_lazy(string_concat( settings.CMSPLUGIN_CASCADE['plugin_prefix'], " ", attrs['name'])) return super(CascadePluginBaseMetaclass, cls).__new__(cls, name, bases, attrs)
def __new__(cls, name, bases, attrs): model_mixins = attrs.pop('model_mixins', ()) if name in cls.plugins_with_extra_fields: ExtraFieldsMixin.media = media_property(ExtraFieldsMixin) bases = (ExtraFieldsMixin,) + bases if name in cls.plugins_with_bookmark: bases = (SectionMixin,) + bases model_mixins = (SectionModelMixin,) + model_mixins if name in cls.plugins_with_sharables: SharableGlossaryMixin.media = media_property(SharableGlossaryMixin) bases = (SharableGlossaryMixin,) + bases attrs['fields'] += (('save_shared_glossary', 'save_as_identifier'), 'shared_glossary',) attrs['sharable_fields'] = cls.plugins_with_sharables[name] base_model = SharableCascadeElement else: base_model = CascadeElement if name in cls.plugins_with_extra_render_templates: RenderTemplateMixin.media = media_property(RenderTemplateMixin) bases = (RenderTemplateMixin,) + bases if name == 'SegmentPlugin': # SegmentPlugin shall additionally inherit from configured mixin classes model_mixins += tuple(import_string(mc[0]) for mc in settings.CMSPLUGIN_CASCADE['segmentation_mixins']) module = attrs.get('__module__') attrs['model'] = create_proxy_model(name, model_mixins, base_model, module=module) if is_installed('reversion'): import reversion.revisions if not reversion.revisions.is_registered(base_model): reversion.revisions.register(base_model) # handle ambiguous plugin names by appending a symbol if 'name' in attrs and settings.CMSPLUGIN_CASCADE['plugin_prefix']: attrs['name'] = mark_safe_lazy(string_concat( settings.CMSPLUGIN_CASCADE['plugin_prefix'], " ", attrs['name'])) return super(CascadePluginBaseMetaclass, cls).__new__(cls, name, bases, attrs)
def __new__(cls, name, bases, attrs): if name in cls.plugins_with_extrafields: ExtraFieldsMixin.media = media_property(ExtraFieldsMixin) bases = (ExtraFieldsMixin, ) + bases if name in cls.plugins_with_sharables: SharableGlossaryMixin.media = media_property(SharableGlossaryMixin) bases = (SharableGlossaryMixin, ) + bases attrs['fields'] += ( ('save_shared_glossary', 'save_as_identifier'), 'shared_glossary', ) attrs['sharable_fields'] = cls.plugins_with_sharables[name] base_model = SharableCascadeElement else: base_model = CascadeElement if name == 'SegmentPlugin': # SegmentPlugin shall additionally inherit from configured mixin classes bases = tuple( import_by_path(mc) for mc in settings.CASCADE_SEGMENTATION_MIXINS) + bases model_mixins = attrs.pop('model_mixins', ()) attrs['model'] = CascadePluginBaseMetaclass.create_model( name, model_mixins, base_model) return super(CascadePluginBaseMetaclass, cls).__new__(cls, name, bases, attrs)
def __new__(cls, name, bases, attrs): if name in cls.plugins_with_extrafields: ExtraFieldsMixin.media = media_property(ExtraFieldsMixin) bases = (ExtraFieldsMixin, ) + bases if name in cls.plugins_with_sharables: SharableGlossaryMixin.media = media_property(SharableGlossaryMixin) bases = (SharableGlossaryMixin, ) + bases attrs['fields'] += ( ('save_shared_glossary', 'save_as_identifier'), 'shared_glossary', ) attrs['sharable_fields'] = cls.plugins_with_sharables[name] base_model = SharableCascadeElement else: base_model = CascadeElement if name in getattr( settings, 'CASCADE_PLUGINS_WITH_EXTRA_RENDER_TEMPLATES').keys(): RenderTemplateMixin.media = media_property(RenderTemplateMixin) bases = (RenderTemplateMixin, ) + bases model_mixins = attrs.pop('model_mixins', ()) if name == 'SegmentPlugin': # SegmentPlugin shall additionally inherit from configured mixin classes model_mixins += tuple( import_by_path(mc[0]) for mc in settings.CASCADE_SEGMENTATION_MIXINS) attrs['model'] = create_proxy_model(name, model_mixins, base_model) if is_installed('reversion'): import reversion reversion.register(attrs['model']) return super(CascadePluginBaseMetaclass, cls).__new__(cls, name, bases, attrs)
def __new__(cls, name, bases, attrs): if name in cls.plugins_with_extrafields: ExtraFieldsMixin.media = media_property(ExtraFieldsMixin) bases = (ExtraFieldsMixin,) + bases if name in cls.plugins_with_sharables: SharableGlossaryMixin.media = media_property(SharableGlossaryMixin) bases = (SharableGlossaryMixin,) + bases attrs['fields'] += (('save_shared_glossary', 'save_as_identifier'), 'shared_glossary',) attrs['sharable_fields'] = cls.plugins_with_sharables[name] base_model = SharableCascadeElement else: base_model = CascadeElement if name in getattr(settings, 'CASCADE_PLUGINS_WITH_EXTRA_RENDER_TEMPLATES').keys(): RenderTemplateMixin.media = media_property(RenderTemplateMixin) bases = (RenderTemplateMixin,) + bases model_mixins = attrs.pop('model_mixins', ()) if name == 'SegmentPlugin': # SegmentPlugin shall additionally inherit from configured mixin classes model_mixins += tuple(import_string(mc[0]) for mc in settings.CASCADE_SEGMENTATION_MIXINS) attrs['model'] = create_proxy_model(name, model_mixins, base_model) if is_installed('reversion'): import reversion if not reversion.is_registered(base_model): reversion.register(base_model) return super(CascadePluginBaseMetaclass, cls).__new__(cls, name, bases, attrs)
def __new__(cls, name, bases, attrs): if name in cls.plugins_with_extrafields: ExtraFieldsMixin.media = media_property(ExtraFieldsMixin) bases = (ExtraFieldsMixin,) + bases if name in cls.plugins_with_sharables: SharableGlossaryMixin.media = media_property(SharableGlossaryMixin) bases = (SharableGlossaryMixin,) + bases attrs['fields'] += (('save_shared_glossary', 'save_as_identifier'), 'shared_glossary',) attrs['sharable_fields'] = cls.plugins_with_sharables[name] base_model = SharableCascadeElement else: base_model = CascadeElement model_mixins = attrs.pop('model_mixins', ()) attrs['model'] = CascadePluginBaseMetaclass.create_model(name, model_mixins, base_model) return super(CascadePluginBaseMetaclass, cls).__new__(cls, name, bases, attrs)
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
def __new__(cls, name, bases, attrs): attrs['base_fields'] = get_declared_fields(bases, attrs) new_class = super(DeclarativeFieldsMetaclass, cls).__new__(cls, name, bases, attrs) if 'media' not in attrs: new_class.media = media_property(new_class) return new_class
def __new__(cls, name, bases, attrs): base_fields = [] for creation_counter, form_element_entry in enumerate(form_element_entries): plugin = form_element_entry.get_plugin(request=request) # We simply make sure the plugin exists. We don't handle # exceptions relate to the non-existent plugins here. They # are istead handled in registry. if plugin: plugin_form_field_instances = plugin._get_form_field_instances( form_element_entry = form_element_entry, origin = origin, kwargs_update_func = origin_kwargs_update_func, return_func = origin_return_func, extra = {'counter': creation_counter} ) for form_field_name, form_field_instance in plugin_form_field_instances: base_fields.append((form_field_name, form_field_instance)) attrs['base_fields'] = SortedDict(base_fields) new_class = super(DeclarativeFieldsMetaclass, cls).__new__( cls, name, bases, attrs ) if 'media' not in attrs: new_class.media = media_property(new_class) return new_class
def __new__(mcs, name, bases, attrs): new_class = super(MediaDefiningClass, mcs).__new__(mcs, name, bases, attrs) if 'media' not in attrs: new_class.media = media_property(new_class) return new_class
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): 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
def __new__(cls, name, bases, attrs): # get all valid existing Fields and sort them fields = [(field_name, attrs.pop(field_name)) for field_name, obj in \ attrs.items() if isinstance(obj, forms.Field)] fields.sort(lambda x, y: cmp(x[1].creation_counter, y[1].creation_counter)) # get all Fields from base classes for base in bases[::-1]: if hasattr(base, 'base_fields'): fields = base.base_fields.items() + fields # add the fields as "our" base fields attrs['base_fields'] = SortedDict(fields) # Meta class available? if 'Meta' in attrs and hasattr(attrs['Meta'], 'document') and \ issubclass(attrs['Meta'].document, BaseDocument): doc_fields = SortedDict() formfield_generator = getattr(attrs['Meta'], 'formfield_generator', \ MongoFormFieldGenerator)() widgets = getattr(attrs["Meta"], "widgets", {}) # walk through the document fields for field_name, field in iter_valid_fields(attrs['Meta']): # add field and override clean method to respect mongoengine-validator # use to get a custom widget if hasattr(field, 'get_custom_widget'): widget = field.get_custom_widget() else: widget = widgets.get(field_name, None) if widget: doc_fields[field_name] = formfield_generator.generate( field, widget=widget) else: doc_fields[field_name] = formfield_generator.generate( field) if not isinstance(field, FileField): doc_fields[field_name].clean = mongoengine_validate_wrapper( field, doc_fields[field_name].clean, field._validate) # write the new document fields to base_fields doc_fields.update(attrs['base_fields']) attrs['base_fields'] = doc_fields # maybe we need the Meta class later attrs['_meta'] = attrs.get('Meta', object()) new_class = super(MongoFormMetaClass, cls).__new__(cls, name, bases, attrs) if 'media' not in attrs: new_class.media = media_property(new_class) 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(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
def __new__(cls, name, bases, attrs): if name in cls.plugins_with_extrafields: ExtraFieldsMixin.media = media_property(ExtraFieldsMixin) bases = (ExtraFieldsMixin,) + bases if name in cls.plugins_with_sharables: SharableGlossaryMixin.media = media_property(SharableGlossaryMixin) bases = (SharableGlossaryMixin,) + bases attrs['fields'] += (('save_shared_glossary', 'save_as_identifier'), 'shared_glossary',) attrs['sharable_fields'] = cls.plugins_with_sharables[name] base_model = SharableCascadeElement else: base_model = CascadeElement if name == 'SegmentPlugin': # SegmentPlugin shall additionally inherit from configured mixin classes bases = tuple(import_by_path(mc) for mc in settings.CASCADE_SEGMENTATION_MIXINS) + bases model_mixins = attrs.pop('model_mixins', ()) attrs['model'] = create_proxy_model(name, model_mixins, base_model) return super(CascadePluginBaseMetaclass, cls).__new__(cls, name, bases, attrs)
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
def __new__(cls, name, bases, attrs): if name in cls.plugins_with_extrafields: ExtraFieldsMixin.media = media_property(ExtraFieldsMixin) bases = (ExtraFieldsMixin, ) + bases if name in cls.plugins_with_sharables: SharableGlossaryMixin.media = media_property(SharableGlossaryMixin) bases = (SharableGlossaryMixin, ) + bases attrs['fields'] += ( ('save_shared_glossary', 'save_as_identifier'), 'shared_glossary', ) attrs['sharable_fields'] = cls.plugins_with_sharables[name] base_model = SharableCascadeElement else: base_model = CascadeElement model_mixins = attrs.pop('model_mixins', ()) attrs['model'] = CascadePluginBaseMetaclass.create_model( name, model_mixins, base_model) return super(CascadePluginBaseMetaclass, cls).__new__(cls, name, bases, attrs)
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, 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 _add_media(self, model_admin, widget): if not hasattr(model_admin, 'Media'): model_admin.__class__.Media = type('Media', (object,), dict()) model_admin.__class__.media = media_property(model_admin.__class__) def _get_media(obj): return Media(media=getattr(obj, 'Media', None)) media = _get_media(model_admin) + widget.media + _get_media(AutocompleteFilter) + _get_media(self) for name in MEDIA_TYPES: setattr(model_admin.Media, name, getattr(media, "_" + name))
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
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
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 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) # EDIT JTANAY : COMMENT "DECLARED_FIELDS" # 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(new_class.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(new_class.declared_fields) else: fields = new_class.declared_fields new_class.base_fields = fields return new_class
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
def __new__(cls, name, bases, attrs): columns = [(c, attrs.pop(c)) for c, obj in attrs.items() \ if isinstance(obj, Column)] columns.sort(key=lambda x: x[1].creation_counter) for base in reversed(bases): columns = getattr(base, 'base_columns', {}).items() + columns attrs['base_columns'] = SortedDict(columns) new_class = super(DataTableDeclarativeMeta, cls).__new__(cls, name, bases, attrs) new_class._meta = DataTableOptions() for base in reversed(bases): new_class._meta.update(getattr(base, '_meta', None)) new_class._meta.update(getattr(new_class, 'Meta', None)) if 'media' not in attrs: new_class.media = media_property(new_class) return new_class
def __new__(cls, name, bases, attrs): try: parents = [b for b in bases if issubclass(b, DataTables)] except NameError: parents = None new_class = super(DataTablesMetaclass, 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 = ModelTableOptions(getattr(new_class, 'Meta', None)) try: declared_params = dict(opts.params) except TypeError: declared_params = {} try: jsonTemplatePath = opts.template except TypeError: jsonTemplatePath = None try: index = map(lambda x: x[1], opts.index) columnIndexNameMap = dict(zip(range(len(index)),index)) except TypeError: columnIndexNameMap = None try: MyColumnNames = map(lambda x: x[0], opts.index) #columnIndexNameMap = dict(zip(range(len(index)),index)) except TypeError: columnIndexNameMap = None try: searchableColumns = map(lambda y: y[1], filter(lambda x: x[2],opts.index)) #list(opts.search) except TypeError: # try: # searchableColumns = list(opts.index) # except TypeError: searchableColumns = None new_class.declared_params = declared_params new_class.jsonTemplatePath = jsonTemplatePath new_class.columnIndexNameMap = columnIndexNameMap new_class.searchableColumns = searchableColumns new_class.MyColumnNames = MyColumnNames return new_class
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
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
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
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
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 #attrs 里有 fields 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. 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): 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
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
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
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
def __new__(cls, name, bases, attrs): attrs["base_panes"] = get_declared_panes(bases, attrs) new_class = super(DeclarativePanesMetaclass, cls).__new__(cls, name, bases, attrs) if "media" not in attrs: new_class.media = media_property(new_class) return new_class
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
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
def __new__(cls, name, bases, attrs): new_class = super(ColumnMeta, cls).__new__(cls, name, bases, attrs) if 'media' not in attrs: new_class.media = media_property(new_class) 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(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
def __new__(cls, name, bases, attrs): # get all valid existing Fields and sort them fields = [(field_name, attrs.pop(field_name)) for field_name, obj in \ attrs.items() if isinstance(obj, forms.Field)] fields.sort( lambda x, y: cmp(x[1].creation_counter, y[1].creation_counter)) # get all Fields from base classes for base in bases[::-1]: if hasattr(base, 'base_fields'): fields = base.base_fields.items() + fields # add the fields as "our" base fields attrs['base_fields'] = SortedDict(fields) # Meta class available? if 'Meta' in attrs and hasattr(attrs['Meta'], 'document') and \ issubclass(attrs['Meta'].document, BaseDocument): doc_fields = SortedDict() formfield_generator = getattr(attrs['Meta'], 'formfield_generator', \ MongoFormFieldGenerator)() widgets = getattr(attrs["Meta"], "widgets", {}) # walk through the document fields for field_name, field in iter_valid_fields(attrs['Meta']): # add field and override clean method to respect mongoengine-validator # use to get a custom widget if hasattr(field, 'get_custom_widget'): widget = field.get_custom_widget() else: widget = widgets.get(field_name, None) if widget: doc_fields[field_name] = formfield_generator.generate( field, widget=widget) else: doc_fields[field_name] = formfield_generator.generate( field) if not isinstance(field, FileField): doc_fields[ field_name].clean = mongoengine_validate_wrapper( field, doc_fields[field_name].clean, field._validate) # write the new document fields to base_fields doc_fields.update(attrs['base_fields']) attrs['base_fields'] = doc_fields # maybe we need the Meta class later attrs['_meta'] = attrs.get('Meta', object()) new_class = super(MongoFormMetaClass, cls).__new__(cls, name, bases, attrs) if 'media' not in attrs: new_class.media = media_property(new_class) return new_class
def __new__(cls, name, bases, attrs): attrs['base_entries'] = get_declared_objects(bases, attrs, Entry, 'entries') new_class = super(DeclarativeEntriesMetaclass, cls).__new__(cls, name, bases, attrs) if 'media' not in attrs: new_class.media = media_property(new_class) return new_class