class UpdateView

def form_valid(self, form):
    """
    If the form is valid, save the associated model.
    """
    self.object = form.save()
    return super(ModelFormMixin, self).form_valid(form)

def form_valid(self, form):
    """
    If the form is valid, redirect to the supplied URL.
    """
    return HttpResponseRedirect(self.get_success_url())

def get(self, request, *args, **kwargs):
    self.object = self.get_object()
    return super(BaseUpdateView, self).get(request, *args, **kwargs)

def get(self, request, *args, **kwargs):
    """
    Handles GET requests and instantiates a blank version of the form.
    """
    form_class = self.get_form_class()
    form = self.get_form(form_class)
    return self.render_to_response(self.get_context_data(form=form))

def get_context_data(self, **kwargs):
    """
    If an object has been supplied, inject it into the context with the
    supplied context_object_name name.
    """
    context = {}
    if self.object:
        context['object'] = self.object
        context_object_name = self.get_context_object_name(self.object)
        if context_object_name:
            context[context_object_name] = self.object
    context.update(kwargs)
    return super(ModelFormMixin, self).get_context_data(**context)

def get_context_data(self, **kwargs):
    """
    Insert the single object into the context dict.
    """
    context = {}
    context_object_name = self.get_context_object_name(self.object)
    if context_object_name:
        context[context_object_name] = self.object
    context.update(kwargs)
    return super(SingleObjectMixin, self).get_context_data(**context)

def get_context_data(self, **kwargs):
    if 'view' not in kwargs:
        kwargs['view'] = self
    return kwargs

def get_form_class(self):
    """
    Returns the form class to use in this view.
    """
    if self.form_class:
        return self.form_class
    else:
        if self.model is not None:
            # If a model has been explicitly provided, use it
            model = self.model
        elif hasattr(self, 'object') and self.object is not None:
            # If this view is operating on a single object, use
            # the class of that object
            model = self.object.__class__
        else:
            # Try to get a queryset and extract the model class
            # from that
            model = self.get_queryset().model
        return model_forms.modelform_factory(model)

def get_form_class(self):
    """
    Returns the form class to use in this view
    """
    return self.form_class

def get_form_kwargs(self):
    """
    Returns the keyword arguments for instantiating the form.
    """
    kwargs = super(ModelFormMixin, self).get_form_kwargs()
    kwargs.update({'instance': self.object})
    return kwargs

def get_form_kwargs(self):
    """
    Returns the keyword arguments for instantiating the form.
    """
    kwargs = {'initial': self.get_initial()}
    if self.request.method in ('POST', 'PUT'):
        kwargs.update({
            'data': self.request.POST,
            'files': self.request.FILES,
        })
    return kwargs

def get_success_url(self):
    """
    Returns the supplied URL.
    """
    if self.success_url:
        url = self.success_url % self.object.__dict__
    else:
        try:
            url = self.object.get_absolute_url()
        except AttributeError:
            raise ImproperlyConfigured(
                "No URL to redirect to.  Either provide a url or define"
                " a get_absolute_url method on the Model.")
    return url

def get_success_url(self):
    """
    Returns the supplied success URL.
    """
    if self.success_url:
        # Forcing possible reverse_lazy evaluation
        url = force_text(self.success_url)
    else:
        raise ImproperlyConfigured(
            "No URL to redirect to. Provide a success_url.")
    return url

def get_template_names(self):
    """
    Return a list of template names to be used for the request. May not be
    called if render_to_response is overridden. Returns the following list:
    * the value of ``template_name`` on the view (if provided)
    * the contents of the ``template_name_field`` field on the
      object instance that the view is operating upon (if available)
    * ``<app_label>/<object_name><template_name_suffix>.html``        
    """
    try:
        names = super(SingleObjectTemplateResponseMixin, self).get_template_names()
    except ImproperlyConfigured:
        # If template_name isn't specified, it's not a problem --
        # we just start with an empty list.
        names = []
    # If self.template_name_field is set, grab the value of the field
    # of that name from the object; this is the most specific template
    # name, if given.
    if self.object and self.template_name_field:
        name = getattr(self.object, self.template_name_field, None)
        if name:
            names.insert(0, name)
    # The least-specific option is the default <app>/<model>_detail.html;
    # only use this if the object in question is a model.
    if isinstance(self.object, models.Model):
        names.append("%s/%s%s.html" % (
            self.object._meta.app_label,
            self.object._meta.object_name.lower(),
            self.template_name_suffix
        ))
    elif hasattr(self, 'model') and self.model is not None and issubclass(self.model, models.Model):
        names.append("%s/%s%s.html" % (
            self.model._meta.app_label,
            self.model._meta.object_name.lower(),
            self.template_name_suffix
        ))
    return names

def get_template_names(self):
    """
    Returns a list of template names to be used for the request. Must return
    a list. May not be called if render_to_response is overridden.
    """
    if self.template_name is None:
        raise ImproperlyConfigured(
            "TemplateResponseMixin requires either a definition of "
            "'template_name' or an implementation of 'get_template_names()'")
    else:
        return [self.template_name]

def post(self, request, *args, **kwargs):
    self.object = self.get_object()
    return super(BaseUpdateView, self).post(request, *args, **kwargs)

def post(self, request, *args, **kwargs):
    """
    Handles POST requests, instantiating a form instance with the passed
    POST variables and then checked for validity.
    """
    form_class = self.get_form_class()
    form = self.get_form(form_class)
    if form.is_valid():
        return self.form_valid(form)
    else:
        return self.form_invalid(form)