class PasswordResetView

from django.contrib.auth.views import PasswordResetView
A view for displaying a form and rendering a template response.

Attributes

  Defined in
content_type = None TemplateResponseMixin
email_template_name = 'registration/password_reset_email.html' PasswordResetView
extra_context = None ContextMixin
extra_context = None PasswordContextMixin
extra_email_context = None PasswordResetView
form_class = <class 'django.contrib.auth.forms.PasswordResetForm'> PasswordResetView
form_class = None FormMixin
from_email = None PasswordResetView
html_email_template_name = None PasswordResetView
http_method_names = ['get', 'post', 'put', 'patch', 'delete', 'head', 'options', 'trace'] View
initial = {} FormMixin
prefix = None FormMixin
response_class = <class 'django.template.response.TemplateResponse'> TemplateResponseMixin
subject_template_name = 'registration/password_reset_subject.txt' PasswordResetView
success_url = None FormMixin
success_url = reverse_lazy('password_reset_done') PasswordResetView
template_engine = None TemplateResponseMixin
template_name = None TemplateResponseMixin
template_name = 'registration/password_reset_form.html' PasswordResetView
title = gettext_lazy('Password reset') PasswordResetView
token_generator = <django.contrib.auth.tokens.PasswordResetTokenGenerator object at 0x7fc0f7867ac0> PasswordResetView
Expand Collapse

Methods

def _allowed_methods(self): View

117
118
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.
47
48
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
77
78
79
80
@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__)
    return view

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

PasswordResetView

224
225
226
@method_decorator(csrf_protect)
def dispatch(self, *args, **kwargs):
    return super().dispatch(*args, **kwargs)

View

 93
 94
 95
 96
 97
 98
 99
100
101
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.
61
62
63
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):

PasswordResetView

If the form is valid, redirect to the supplied URL.
228
229
230
231
232
233
234
235
236
237
238
239
240
def form_valid(self, form):
    opts = {
        'use_https': self.request.is_secure(),
        'token_generator': self.token_generator,
        'from_email': self.from_email,
        'email_template_name': self.email_template_name,
        'subject_template_name': self.subject_template_name,
        'request': self.request,
        'html_email_template_name': self.html_email_template_name,
        'extra_email_context': self.extra_email_context,
    }
    form.save(**opts)
    return super().form_valid(form)

FormMixin

If the form is valid, redirect to the supplied URL.
57
58
59
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): ProcessFormView

Handle GET requests: instantiate a blank version of the form.
133
134
135
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):

PasswordContextMixin

203
204
205
206
207
208
209
def get_context_data(self, **kwargs):
    context = super().get_context_data(**kwargs)
    context.update({
        'title': self.title,
        **(self.extra_context or {})
    })
    return context

FormMixin

Insert the form into the context dict.
65
66
67
68
69
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)

ContextMixin

22
23
24
25
26
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_form(self, form_class=None): FormMixin

Return an instance of the form to be used in this view.
31
32
33
34
35
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): FormMixin

Return the form class to use.
27
28
29
def get_form_class(self):
    """Return the form class to use."""
    return self.form_class

def get_form_kwargs(self): FormMixin

Return the keyword arguments for instantiating the form.
37
38
39
40
41
42
43
44
45
46
47
48
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.
19
20
21
def get_initial(self):
    """Return the initial data to use for forms on this view."""
    return self.initial.copy()

def get_prefix(self): FormMixin

Return the prefix to use for forms.
23
24
25
def get_prefix(self):
    """Return the prefix to use for forms."""
    return self.prefix

def get_success_url(self): FormMixin

Return the URL to redirect to after processing a valid form.
51
52
53
54
55
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): 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.
144
145
146
147
148
149
150
151
152
153
154
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

103
104
105
106
107
108
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 __init__(self, **kwargs): View

Constructor. Called in the URLconf; can contain helpful extra
keyword arguments, and other things.
37
38
39
40
41
42
43
44
45
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 options(self, request, *args, **kwargs): View

Handle responding to requests for the OPTIONS HTTP verb.
110
111
112
113
114
115
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'
    return response

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

Handle POST requests: instantiate a form instance with the passed
POST variables and then check if it's valid.
137
138
139
140
141
142
143
144
145
146
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

150
151
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.
128
129
130
131
132
133
134
135
136
137
138
139
140
141
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.
85
86
87
88
89
90
91
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