def __init__(self, data=None, files=None, auto_id='id_%s', prefix=None,
             initial=None, error_class=ErrorList, label_suffix=None,
             empty_permitted=False, instance=None):
    opts = self._meta
    if opts.model is None:
        raise ValueError('ModelForm has no model class specified.')
    if instance is None:
        # if we didn't get an instance, instantiate a new one
        self.instance = opts.model()
        object_data = {}
    else:
        self.instance = instance
        object_data = model_to_dict(instance, opts.fields, opts.exclude)
    # if initial was provided, it should override the values from instance
    if initial is not None:
        object_data.update(initial)
    # self._validate_unique will be set to True by BaseModelForm.clean().
    # It is False by default so overriding self.clean() and failing to call
    # super will stop validate_unique from being called.
    self._validate_unique = False
    super(BaseModelForm, self).__init__(data, files, auto_id, prefix, object_data,
                                        error_class, label_suffix, empty_permitted)

def add_initial_prefix(self, field_name):
    """
    Add a 'initial' prefix for checking dynamic initial values
    """
    return 'initial-%s' % self.add_prefix(field_name)

def add_prefix(self, field_name):
    """
    Returns the field name with a prefix appended, if this Form has a
    prefix set.
    Subclasses may wish to override.
    """
    return '%s-%s' % (self.prefix, field_name) if self.prefix else field_name

def as_p(self):
    "Returns this form rendered as HTML <p>s."
    return self._html_output(
        normal_row = '<p%(html_class_attr)s>%(label)s %(field)s%(help_text)s</p>',
        error_row = '%s',
        row_ender = '</p>',
        help_text_html = ' <span class="helptext">%s</span>',
        errors_on_separate_row = True)

def as_table(self):
    "Returns this form rendered as HTML <tr>s -- excluding the <table></table>."
    return self._html_output(
        normal_row = '<tr%(html_class_attr)s><th>%(label)s</th><td>%(errors)s%(field)s%(help_text)s</td></tr>',
        error_row = '<tr><td colspan="2">%s</td></tr>',
        row_ender = '</td></tr>',
        help_text_html = '<br /><span class="helptext">%s</span>',
        errors_on_separate_row = False)

def as_ul(self):
    "Returns this form rendered as HTML <li>s -- excluding the <ul></ul>."
    return self._html_output(
        normal_row = '<li%(html_class_attr)s>%(errors)s%(label)s %(field)s%(help_text)s</li>',
        error_row = '<li>%s</li>',
        row_ender = '</li>',
        help_text_html = ' <span class="helptext">%s</span>',
        errors_on_separate_row = False)

def clean(self):
    self._validate_unique = True
    return self.cleaned_data

def full_clean(self):
    """
    Cleans all of self.data and populates self._errors and
    self.cleaned_data.
    """
    self._errors = ErrorDict()
    if not self.is_bound: # Stop further processing.
        return
    self.cleaned_data = {}
    # If the form is permitted to be empty, and none of the form data has
    # changed from the initial data, short circuit any validation.
    if self.empty_permitted and not self.has_changed():
        return
    self._clean_fields()
    self._clean_form()
    self._post_clean()

def has_changed(self):
    """
    Returns True if data differs from initial.
    """
    return bool(self.changed_data)

def hidden_fields(self):
    """
    Returns a list of all the BoundField objects that are hidden fields.
    Useful for manual form layout in templates.
    """
    return [field for field in self if field.is_hidden]

def is_multipart(self):
    """
    Returns True if the form needs to be multipart-encoded, i.e. it has
    FileInput. Otherwise, False.
    """
    for field in self.fields.values():
        if field.widget.needs_multipart_form:
            return True
    return False

def is_valid(self):
    """
    Returns True if the form has no errors. Otherwise, False. If errors are
    being ignored, returns False.
    """
    return self.is_bound and not bool(self.errors)

def non_field_errors(self):
    """
    Returns an ErrorList of errors that aren't associated with a particular
    field -- i.e., from Form.clean(). Returns an empty ErrorList if there
    are none.
    """
    return self.errors.get(NON_FIELD_ERRORS, self.error_class())

def save(self, commit=True):
    """
    Saves this ``form``'s cleaned_data into model instance
    ``self.instance``.
    If commit=True, then the changes to ``instance`` will be saved to the
    database. Returns ``instance``.
    """
    if self.instance.pk is None:
        fail_message = 'created'
    else:
        fail_message = 'changed'
    return save_instance(self, self.instance, self._meta.fields,
                         fail_message, commit, self._meta.exclude,
                         construct=False)

def validate_unique(self):
    """
    Calls the instance's validate_unique() method and updates the form's
    validation errors if any were raised.
    """
    exclude = self._get_validation_exclusions()
    try:
        self.instance.validate_unique(exclude=exclude)
    except ValidationError as e:
        self._update_errors(e)

def visible_fields(self):
    """
    Returns a list of BoundField objects that aren't hidden fields.
    The opposite of the hidden_fields() method.
    """
    return [field for field in self if not field.is_hidden]