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):
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):
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):
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__(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):
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):
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):
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
