def __new__(cls, class_name, bases, attrs):
    fields = sorted(((field_name, attrs.pop(field_name))
                     for field_name, obj in attrs.items()
                     if isinstance(obj, forms.Field)),
                    key=lambda obj: obj[1].creation_counter)
    for base in bases[::-1]:
      if hasattr(base, '_base_fields'):
        fields = base._base_fields.items() + fields
    declared_fields = datastructures.OrderedDict()
    for field_name, obj in fields:
      declared_fields[field_name] = obj
    opts = ModelFormOptions(attrs.get('Meta', None))
    attrs['_meta'] = opts

    base_models = []
    for base in bases:
      base_opts = getattr(base, '_meta', None)
      base_model = getattr(base_opts, 'model', None)
      if base_model is not None:
        base_models.append(base_model)
    if len(base_models) > 1:
      raise exceptions.ImproperlyConfigured(
          "%s's base classes define more than one model." % class_name)

    if opts.model is not None:
      if base_models and base_models[0] is not opts.model:
        raise exceptions.ImproperlyConfigured(
            '%s defines a different model than its parent.' % class_name)

      model_fields = datastructures.OrderedDict()
      for name, prop in sorted(opts.model.properties().iteritems(),
                               key=lambda prop: prop[1].creation_counter):
        if opts.fields and name not in opts.fields:
          continue
        if opts.exclude and name in opts.exclude:
          continue
        form_field = prop.get_form_field(
          help_text=opts.help_texts.get(name, None))
        if form_field is not None:
          model_fields[name] = form_field

      for bad_attr_name in ModelFormMetaclass.bad_attr_names:
        if model_fields.has_key(bad_attr_name):
          raise ImproperlyConfigured("When you use ModelForm, you can not"
                                     " use these names as field names: %s"
                                     % str(ModelFormMetaclass.bad_attr_names))

      # Preserve order in model definition
      original_ordered_names = model_fields.keys()
      model_fields.update(declared_fields)
      extra_index = len(original_ordered_names)
      for name, field in model_fields.iteritems():
        if name in original_ordered_names:
          field._position_hint = original_ordered_names.index(name)
        else:
          field._position_hint = extra_index
          extra_index += 1
          
      attrs['_base_fields'] = model_fields

      props = opts.model.properties()
      for name, field in model_fields.iteritems():
        prop = props.get(name)
        if prop:
          def check_for_property_field(form, value, prop=prop):
            property_clean(prop, value)
            return True
          field.validators.append(check_for_property_field)
    else:
      attrs['_base_fields'] = declared_fields
    # corresponds with form not rendered
    # maybe i should handle this in forms.FormMeta
    return super(ModelFormMetaclass, cls).__new__(cls,
                                                  class_name, bases, attrs)
Constructor for a new ModelForm class instance.
dataset/ETHPy150Open IanLewis/kay/kay/utils/forms/modelform.py/ModelFormMetaclass.__new__