class UpdateView

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

Attributes

  Defined in
content_type = None TemplateResponseMixin
context_object_name = None SingleObjectMixin
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
Expand Collapse

Methods

def __init__(self, **kwargs): View

Constructor. Called in the URLconf; can contain helpful extra
keyword arguments, and other things.
39
40
41
42
43
44
45
46
47
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 six.iteritems(kwargs):
        setattr(self, key, value)

def _allowed_methods(self): View

109
110
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.
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
@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("You tried to pass in the %s method name as a "
                            "keyword argument to %s(). Don't do that."
                            % (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)
        if hasattr(self, 'get') and not hasattr(self, 'head'):
            self.head = self.get
        self.request = request
        self.args = args
        self.kwargs = kwargs
        return self.dispatch(request, *args, **kwargs)
    # take name and docstring from class
    update_wrapper(view, cls, updated=())
    # and possible attributes set by decorators
    # like csrf_exempt from dispatch
    update_wrapper(view, cls.dispatch, assigned=())
    return view

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

81
82
83
84
85
86
87
88
89
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, re-render the context data with the
data-filled form and errors.
110
111
112
113
114
115
def form_invalid(self, form):
    """
    If the form is invalid, re-render the context data with the
    data-filled form and errors.
    """
    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.
189
190
191
192
193
194
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)

FormMixin

If the form is valid, redirect to the supplied URL.
104
105
106
107
108
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

Handles GET requests and instantiates a blank version of the form.
266
267
268
def get(self, request, *args, **kwargs):
    self.object = self.get_object()
    return super(BaseUpdateView, self).get(request, *args, **kwargs)

ProcessFormView

Handles GET requests and instantiates a blank version of the form.
201
202
203
204
205
206
def get(self, request, *args, **kwargs):
    """
    Handles GET requests and instantiates a blank version of the form.
    """
    form = self.get_form()
    return self.render_to_response(self.get_context_data(form=form))

def get_context_data(self, **kwargs):

SingleObjectMixin

Insert the single object into the context dict.
 96
 97
 98
 99
100
101
102
103
104
105
106
107
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(SingleObjectMixin, self).get_context_data(**context)

ContextMixin

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

def get_context_object_name(self, obj): SingleObjectMixin

Get the name to use for the object.
85
86
87
88
89
90
91
92
93
94
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

Returns an instance of the form to be used in this view.
68
69
70
71
72
73
74
def get_form(self, form_class=None):
    """
    Returns 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

Returns the form class to use in this view.
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
def get_form_class(self):
    """
    Returns 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 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
        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

Returns the form class to use in this view
62
63
64
65
66
def get_form_class(self):
    """
    Returns the form class to use in this view
    """
    return self.form_class

def get_form_kwargs(self):

ModelFormMixin

Returns the keyword arguments for instantiating the form.
155
156
157
158
159
160
161
162
def get_form_kwargs(self):
    """
    Returns the keyword arguments for instantiating the form.
    """
    kwargs = super(ModelFormMixin, self).get_form_kwargs()
    if hasattr(self, 'object'):
        kwargs.update({'instance': self.object})
    return kwargs

FormMixin

Returns the keyword arguments for instantiating the form.
76
77
78
79
80
81
82
83
84
85
86
87
88
89
def get_form_kwargs(self):
    """
    Returns 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

Returns the initial data to use for forms on this view.
50
51
52
53
54
def get_initial(self):
    """
    Returns the initial data to use for forms on this view.
    """
    return self.initial.copy()

def get_object(self, queryset=None): SingleObjectMixin

Returns the object the view is displaying.

By default this requires `self.queryset` and a `pk` or `slug` argument
in the URLconf, but subclasses can override this to return any object.
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
def get_object(self, queryset=None):
    """
    Returns the object the view is displaying.
    By default this requires `self.queryset` and a `pk` or `slug` argument
    in the URLconf, but 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, None)
    slug = self.kwargs.get(self.slug_url_kwarg, None)
    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."
                             % 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

Returns the prefix to use for forms on this view
56
57
58
59
60
def get_prefix(self):
    """
    Returns the prefix to use for forms on this view
    """
    return self.prefix

def get_queryset(self): SingleObjectMixin

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

Note that this method is called by the default implementation of
`get_object` and may not be called if `get_object` is overridden.
59
60
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.
    Note that 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
82
83
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

Returns the supplied URL.
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
def get_success_url(self):
    """
    Returns the supplied URL.
    """
    if self.success_url:
        # force_text can be removed with deprecation warning
        self.success_url = force_text(self.success_url)
        if PERCENT_PLACEHOLDER_REGEX.search(self.success_url):
            warnings.warn(
                "%()s placeholder style in success_url is deprecated. "
                "Please replace them by the {} Python format syntax.",
                RemovedInDjango110Warning, stacklevel=2
            )
            url = self.success_url % self.object.__dict__
        else:
            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

Returns the supplied success URL.
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
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):

SingleObjectTemplateResponseMixin

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>/<model_name><template_name_suffix>.html``
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
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>/<model_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.model_name,
                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.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

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.
139
140
141
142
143
144
145
146
147
148
149
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 http_method_not_allowed(self, request, *args, **kwargs): View

91
92
93
94
95
96
97
98
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 http.HttpResponseNotAllowed(self._allowed_methods())

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

Handles responding to requests for the OPTIONS HTTP verb.
100
101
102
103
104
105
106
107
def options(self, request, *args, **kwargs):
    """
    Handles responding to requests for the OPTIONS HTTP verb.
    """
    response = http.HttpResponse()
    response['Allow'] = ', '.join(self._allowed_methods())
    response['Content-Length'] = '0'
    return response

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

BaseUpdateView

Handles POST requests, instantiating a form instance with the passed
POST variables and then checked for validity.
270
271
272
def post(self, request, *args, **kwargs):
    self.object = self.get_object()
    return super(BaseUpdateView, self).post(request, *args, **kwargs)

ProcessFormView

Handles POST requests, instantiating a form instance with the passed
POST variables and then checked for validity.
208
209
210
211
212
213
214
215
216
217
def post(self, request, *args, **kwargs):
    """
    Handles POST requests, instantiating a form instance with the passed
    POST variables and then checked for validity.
    """
    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

221
222
def put(self, *args, **kwargs):
    return self.post(*args, **kwargs)

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

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

If any keyword arguments are provided, they will be
passed to the constructor of the response class.
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
def render_to_response(self, context, **response_kwargs):
    """
    Returns a response, using the `response_class` for this
    view, with a template rendered with the given context.
    If any keyword arguments are provided, they will be
    passed 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
    )