class UpdateView

from django.views.generic import UpdateView
View for updating an object, with a response rendered by a template.

Attributes

  Defined in
content_type = None TemplateResponseMixin
context_object_name = None SingleObjectMixin
extra_context = None ContextMixin
fields = None ModelFormMixin
form_class = None FormMixin
http_method_names = ['get', 'post', 'put', 'patch', 'delete', 'head', 'options', 'trace'] View
initial = {} FormMixin
model = None SingleObjectMixin
pk_url_kwarg = 'pk' SingleObjectMixin
prefix = None FormMixin
query_pk_and_slug = False SingleObjectMixin
queryset = None SingleObjectMixin
response_class = <class 'django.template.response.TemplateResponse'> TemplateResponseMixin
slug_field = 'slug' SingleObjectMixin
slug_url_kwarg = 'slug' SingleObjectMixin
success_url = None FormMixin
template_engine = None TemplateResponseMixin
template_name = None TemplateResponseMixin
template_name_field = None SingleObjectTemplateResponseMixin
template_name_suffix = '_detail' SingleObjectTemplateResponseMixin
template_name_suffix = '_form' UpdateView
view_is_async = False View
Expand Collapse

Methods

def __init__(self, **kwargs): View

Constructor. Called in the URLconf; can contain helpful extra
keyword arguments, and other things.
52
53
54
55
56
57
58
59
60
def __init__(self, **kwargs):
    """
    Constructor. Called in the URLconf; can contain helpful extra
    keyword arguments, and other things.
    """
    # Go through keyword arguments, and either save their values to our
    # instance, or raise an error.
    for key, value in kwargs.items():
        setattr(self, key, value)

def _allowed_methods(self): View

168
169
def _allowed_methods(self):
    return [m.upper() for m in self.http_method_names if hasattr(self, m)]

def as_view(cls, **initkwargs): View

Main entry point for a request-response process.
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
@classonlymethod
def as_view(cls, **initkwargs):
    """Main entry point for a request-response process."""
    for key in initkwargs:
        if key in cls.http_method_names:
            raise TypeError(
                "The method name %s is not accepted as a keyword argument "
                "to %s()." % (key, cls.__name__)
            )
        if not hasattr(cls, key):
            raise TypeError(
                "%s() received an invalid keyword %r. as_view "
                "only accepts arguments that are already "
                "attributes of the class." % (cls.__name__, key)
            )
    def view(request, *args, **kwargs):
        self = cls(**initkwargs)
        self.setup(request, *args, **kwargs)
        if not hasattr(self, "request"):
            raise AttributeError(
                "%s instance has no 'request' attribute. Did you override "
                "setup() and forget to call super()?" % cls.__name__
            )
        return self.dispatch(request, *args, **kwargs)
    view.view_class = cls
    view.view_initkwargs = initkwargs
    # __name__ and __qualname__ are intentionally left unchanged as
    # view_class should be used to robustly determine the name of the view
    # instead.
    view.__doc__ = cls.__doc__
    view.__module__ = cls.__module__
    view.__annotations__ = cls.dispatch.__annotations__
    # Copy possible attributes set by decorators, e.g. @csrf_exempt, from
    # the dispatch method.
    view.__dict__.update(cls.dispatch.__dict__)
    # Mark the callback if the view class is async.
    if cls.view_is_async:
        view._is_coroutine = asyncio.coroutines._is_coroutine
    return view

def dispatch(self, request, *args, **kwargs): View

132
133
134
135
136
137
138
139
140
141
142
def dispatch(self, request, *args, **kwargs):
    # Try to dispatch to the right method; if a method doesn't exist,
    # defer to the error handler. Also defer to the error handler if the
    # request method isn't on the approved list.
    if request.method.lower() in self.http_method_names:
        handler = getattr(
            self, request.method.lower(), self.http_method_not_allowed
        )
    else:
        handler = self.http_method_not_allowed
    return handler(request, *args, **kwargs)

def form_invalid(self, form): FormMixin

If the form is invalid, render the invalid form.
67
68
69
def form_invalid(self, form):
    """If the form is invalid, render the invalid form."""
    return self.render_to_response(self.get_context_data(form=form))

def form_valid(self, form):

ModelFormMixin

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

FormMixin

If the form is valid, redirect to the supplied URL.
63
64
65
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):

BaseUpdateView

Handle GET requests: instantiate a blank version of the form.
202
203
204
def get(self, request, *args, **kwargs):
    self.object = self.get_object()
    return super().get(request, *args, **kwargs)

ProcessFormView

Handle GET requests: instantiate a blank version of the form.
142
143
144
def get(self, request, *args, **kwargs):
    """Handle GET requests: instantiate a blank version of the form."""
    return self.render_to_response(self.get_context_data())

def get_context_data(self, **kwargs):

FormMixin

Insert the form into the context dict.
71
72
73
74
75
def get_context_data(self, **kwargs):
    """Insert the form into the context dict."""
    if "form" not in kwargs:
        kwargs["form"] = self.get_form()
    return super().get_context_data(**kwargs)

SingleObjectMixin

Insert the single object into the context dict.
 92
 93
 94
 95
 96
 97
 98
 99
100
101
def get_context_data(self, **kwargs):
    """Insert the single object into the context dict."""
    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().get_context_data(**context)

ContextMixin

28
29
30
31
32
def get_context_data(self, **kwargs):
    kwargs.setdefault("view", self)
    if self.extra_context is not None:
        kwargs.update(self.extra_context)
    return kwargs

def get_context_object_name(self, obj): SingleObjectMixin

Get the name to use for the object.
83
84
85
86
87
88
89
90
def get_context_object_name(self, obj):
    """Get the name to use for the object."""
    if self.context_object_name:
        return self.context_object_name
    elif isinstance(obj, models.Model):
        return obj._meta.model_name
    else:
        return None

def get_form(self, form_class=None): FormMixin

Return an instance of the form to be used in this view.
35
36
37
38
39
def get_form(self, form_class=None):
    """Return an instance of the form to be used in this view."""
    if form_class is None:
        form_class = self.get_form_class()
    return form_class(**self.get_form_kwargs())

def get_form_class(self):

ModelFormMixin

Return the form class to use in this view.
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
def get_form_class(self):
    """Return the form class to use in this view."""
    if self.fields is not None and self.form_class:
        raise ImproperlyConfigured(
            "Specifying both 'fields' and 'form_class' is not permitted."
        )
    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 getattr(self, "object", None) 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
        if self.fields is None:
            raise ImproperlyConfigured(
                "Using ModelFormMixin (base class of %s) without "
                "the 'fields' attribute is prohibited." % self.__class__.__name__
            )
        return model_forms.modelform_factory(model, fields=self.fields)

FormMixin

Return the form class to use.
31
32
33
def get_form_class(self):
    """Return the form class to use."""
    return self.form_class

def get_form_kwargs(self):

ModelFormMixin

Return the keyword arguments for instantiating the form.
112
113
114
115
116
117
def get_form_kwargs(self):
    """Return the keyword arguments for instantiating the form."""
    kwargs = super().get_form_kwargs()
    if hasattr(self, "object"):
        kwargs.update({"instance": self.object})
    return kwargs

FormMixin

Return the keyword arguments for instantiating the form.
41
42
43
44
45
46
47
48
49
50
51
52
53
54
def get_form_kwargs(self):
    """Return the keyword arguments for instantiating the form."""
    kwargs = {
        "initial": self.get_initial(),
        "prefix": self.get_prefix(),
    }
    if self.request.method in ("POST", "PUT"):
        kwargs.update(
            {
                "data": self.request.POST,
                "files": self.request.FILES,
            }
        )
    return kwargs

def get_initial(self): FormMixin

Return the initial data to use for forms on this view.
23
24
25
def get_initial(self):
    """Return the initial data to use for forms on this view."""
    return self.initial.copy()

def get_object(self, queryset=None): SingleObjectMixin

Return the object the view is displaying.

Require `self.queryset` and a `pk` or `slug` argument in the URLconf.
Subclasses can override this to return any object.
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
def get_object(self, queryset=None):
    """
    Return the object the view is displaying.
    Require `self.queryset` and a `pk` or `slug` argument in the URLconf.
    Subclasses can override this to return any object.
    """
    # Use a custom queryset if provided; this is required for subclasses
    # like DateDetailView
    if queryset is None:
        queryset = self.get_queryset()
    # Next, try looking up by primary key.
    pk = self.kwargs.get(self.pk_url_kwarg)
    slug = self.kwargs.get(self.slug_url_kwarg)
    if pk is not None:
        queryset = queryset.filter(pk=pk)
    # Next, try looking up by slug.
    if slug is not None and (pk is None or self.query_pk_and_slug):
        slug_field = self.get_slug_field()
        queryset = queryset.filter(**{slug_field: slug})
    # If none of those are defined, it's an error.
    if pk is None and slug is None:
        raise AttributeError(
            "Generic detail view %s must be called with either an object "
            "pk or a slug in the URLconf." % self.__class__.__name__
        )
    try:
        # Get the single item from the filtered queryset
        obj = queryset.get()
    except queryset.model.DoesNotExist:
        raise Http404(
            _("No %(verbose_name)s found matching the query")
            % {"verbose_name": queryset.model._meta.verbose_name}
        )
    return obj

def get_prefix(self): FormMixin

Return the prefix to use for forms.
27
28
29
def get_prefix(self):
    """Return the prefix to use for forms."""
    return self.prefix

def get_queryset(self): SingleObjectMixin

Return the `QuerySet` that will be used to look up the object.

This method is called by the default implementation of get_object() and
may not be called if get_object() is overridden.
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
def get_queryset(self):
    """
    Return the `QuerySet` that will be used to look up the object.
    This method is called by the default implementation of get_object() and
    may not be called if get_object() is overridden.
    """
    if self.queryset is None:
        if self.model:
            return self.model._default_manager.all()
        else:
            raise ImproperlyConfigured(
                "%(cls)s is missing a QuerySet. Define "
                "%(cls)s.model, %(cls)s.queryset, or override "
                "%(cls)s.get_queryset()." % {"cls": self.__class__.__name__}
            )
    return self.queryset.all()

def get_slug_field(self): SingleObjectMixin

Get the name of a slug field to be used to look up by slug.
79
80
81
def get_slug_field(self):
    """Get the name of a slug field to be used to look up by slug."""
    return self.slug_field

def get_success_url(self):

ModelFormMixin

Return the URL to redirect to after processing a valid form.
119
120
121
122
123
124
125
126
127
128
129
130
131
def get_success_url(self):
    """Return the URL to redirect to after processing a valid form."""
    if self.success_url:
        url = self.success_url.format(**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

FormMixin

Return the URL to redirect to after processing a valid form.
57
58
59
60
61
def get_success_url(self):
    """Return the URL to redirect to after processing a valid form."""
    if not self.success_url:
        raise ImproperlyConfigured("No URL to redirect to. Provide a success_url.")
    return str(self.success_url)  # success_url may be lazy

def get_template_names(self):

SingleObjectTemplateResponseMixin

Return a list of template names to be used for the request. May not be
called if render_to_response() is overridden. Return 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>/<model_name><template_name_suffix>.html``
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
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. Return 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>/<model_name><template_name_suffix>.html``
    """
    try:
        names = super().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):
            object_meta = self.object._meta
            names.append(
                "%s/%s%s.html"
                % (
                    object_meta.app_label,
                    object_meta.model_name,
                    self.template_name_suffix,
                )
            )
        elif getattr(self, "model", None) is not None and issubclass(
            self.model, models.Model
        ):
            names.append(
                "%s/%s%s.html"
                % (
                    self.model._meta.app_label,
                    self.model._meta.model_name,
                    self.template_name_suffix,
                )
            )
        # If we still haven't managed to find any template names, we should
        # re-raise the ImproperlyConfigured to alert the user.
        if not names:
            raise
    return names

TemplateResponseMixin

Return 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.
196
197
198
199
200
201
202
203
204
205
206
207
def get_template_names(self):
    """
    Return 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 http_method_not_allowed(self, request, *args, **kwargs): View

144
145
146
147
148
149
150
151
def http_method_not_allowed(self, request, *args, **kwargs):
    logger.warning(
        "Method Not Allowed (%s): %s",
        request.method,
        request.path,
        extra={"status_code": 405, "request": request},
    )
    return HttpResponseNotAllowed(self._allowed_methods())

def options(self, request, *args, **kwargs): View

Handle responding to requests for the OPTIONS HTTP verb.
153
154
155
156
157
158
159
160
161
162
163
def options(self, request, *args, **kwargs):
    """Handle responding to requests for the OPTIONS HTTP verb."""
    response = HttpResponse()
    response.headers["Allow"] = ", ".join(self._allowed_methods())
    response.headers["Content-Length"] = "0"
    if self.view_is_async:
        async def func():
            return response
        return func()
    else:
        return response

def post(self, request, *args, **kwargs):

BaseUpdateView

Handle POST requests: instantiate a form instance with the passed
POST variables and then check if it's valid.
206
207
208
def post(self, request, *args, **kwargs):
    self.object = self.get_object()
    return super().post(request, *args, **kwargs)

ProcessFormView

Handle POST requests: instantiate a form instance with the passed
POST variables and then check if it's valid.
146
147
148
149
150
151
152
153
154
155
def post(self, request, *args, **kwargs):
    """
    Handle POST requests: instantiate a form instance with the passed
    POST variables and then check if it's valid.
    """
    form = self.get_form()
    if form.is_valid():
        return self.form_valid(form)
    else:
        return self.form_invalid(form)

def put(self, *args, **kwargs): ProcessFormView

159
160
def put(self, *args, **kwargs):
    return self.post(*args, **kwargs)

def render_to_response(self, context, **response_kwargs): TemplateResponseMixin

Return a response, using the `response_class` for this view, with a
template rendered with the given context.

Pass response_kwargs to the constructor of the response class.
180
181
182
183
184
185
186
187
188
189
190
191
192
193
def render_to_response(self, context, **response_kwargs):
    """
    Return a response, using the `response_class` for this view, with a
    template rendered with the given context.
    Pass response_kwargs to the constructor of the response class.
    """
    response_kwargs.setdefault("content_type", self.content_type)
    return self.response_class(
        request=self.request,
        template=self.get_template_names(),
        context=context,
        using=self.template_engine,
        **response_kwargs,
    )

def setup(self, request, *args, **kwargs): View

Initialize attributes shared by all view methods.
124
125
126
127
128
129
130
def setup(self, request, *args, **kwargs):
    """Initialize attributes shared by all view methods."""
    if hasattr(self, "get") and not hasattr(self, "head"):
        self.head = self.get
    self.request = request
    self.args = args
    self.kwargs = kwargs