class WeekArchiveView

from django.views.generic import WeekArchiveView
List of objects published in a given week.

Attributes

  Defined in
allow_empty = False BaseDateListView
allow_empty = True MultipleObjectMixin
allow_future = False DateMixin
content_type = None TemplateResponseMixin
context_object_name = None MultipleObjectMixin
date_field = None DateMixin
date_list_period = 'year' BaseDateListView
extra_context = None ContextMixin
http_method_names = ['get', 'post', 'put', 'patch', 'delete', 'head', 'options', 'trace'] View
model = None MultipleObjectMixin
ordering = None MultipleObjectMixin
page_kwarg = 'page' MultipleObjectMixin
paginate_by = None MultipleObjectMixin
paginate_orphans = 0 MultipleObjectMixin
paginator_class = <class 'django.core.paginator.Paginator'> MultipleObjectMixin
queryset = None MultipleObjectMixin
response_class = <class 'django.template.response.TemplateResponse'> TemplateResponseMixin
template_engine = None TemplateResponseMixin
template_name = None TemplateResponseMixin
template_name_suffix = '_archive_week' WeekArchiveView
template_name_suffix = '_list' MultipleObjectTemplateResponseMixin
uses_datetime_field = <django.utils.functional.cached_property object at 0x7f18455a4ca0> DateMixin
view_is_async = False View
week = None WeekMixin
week_format = '%U' WeekMixin
year = None YearMixin
year_format = '%Y' YearMixin
Expand Collapse

Methods

def __init__(self, **kwargs): View

Constructor. Called in the URLconf; can contain helpful extra
keyword arguments, and other things.
53
54
55
56
57
58
59
60
61
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

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

def _get_current_week(self, date): WeekMixin

Return the start date of the current interval.
216
217
218
def _get_current_week(self, date):
    """Return the start date of the current interval."""
    return date - datetime.timedelta(self._get_weekday(date))

def _get_current_year(self, date): YearMixin

Return the start date of the current interval.
66
67
68
def _get_current_year(self, date):
    """Return the start date of the current interval."""
    return date.replace(month=1, day=1)

def _get_next_week(self, date): WeekMixin

Return the start date of the next interval.

The interval is defined by start date <= item date < next start date.
205
206
207
208
209
210
211
212
213
def _get_next_week(self, date):
    """
    Return the start date of the next interval.
    The interval is defined by start date <= item date < next start date.
    """
    try:
        return date + datetime.timedelta(days=7 - self._get_weekday(date))
    except OverflowError:
        raise Http404(_("Date out of range"))

def _get_next_year(self, date): YearMixin

Return the start date of the next interval.

The interval is defined by start date <= item date < next start date.
55
56
57
58
59
60
61
62
63
def _get_next_year(self, date):
    """
    Return the start date of the next interval.
    The interval is defined by start date <= item date < next start date.
    """
    try:
        return date.replace(year=date.year + 1, month=1, day=1)
    except ValueError:
        raise Http404(_("Date out of range"))

def _get_weekday(self, date): WeekMixin

Return the weekday for a given date.

The first day according to the week format is 0 and the last day is 6.
220
221
222
223
224
225
226
227
228
229
230
231
def _get_weekday(self, date):
    """
    Return the weekday for a given date.
    The first day according to the week format is 0 and the last day is 6.
    """
    week_format = self.get_week_format()
    if week_format in {"%W", "%V"}:  # week starts on Monday
        return date.weekday()
    elif week_format == "%U":  # week starts on Sunday
        return (date.weekday() + 1) % 7
    else:
        raise ValueError("unknown week format: %s" % week_format)

def _make_date_lookup_arg(self, value): DateMixin

Convert a date into a datetime when the date field is a DateTimeField.

When time zone support is enabled, `date` is assumed to be in the
current time zone, so that displayed items are consistent with the URL.
269
270
271
272
273
274
275
276
277
278
279
def _make_date_lookup_arg(self, value):
    """
    Convert a date into a datetime when the date field is a DateTimeField.
    When time zone support is enabled, `date` is assumed to be in the
    current time zone, so that displayed items are consistent with the URL.
    """
    if self.uses_datetime_field:
        value = datetime.datetime.combine(value, datetime.time.min)
        if settings.USE_TZ:
            value = timezone.make_aware(value)
    return value

def _make_single_date_lookup(self, date): DateMixin

Get the lookup kwargs for filtering on a single date.

If the date field is a DateTimeField, we can't just filter on
date_field=date because that doesn't take the time into account.
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
def _make_single_date_lookup(self, date):
    """
    Get the lookup kwargs for filtering on a single date.
    If the date field is a DateTimeField, we can't just filter on
    date_field=date because that doesn't take the time into account.
    """
    date_field = self.get_date_field()
    if self.uses_datetime_field:
        since = self._make_date_lookup_arg(date)
        until = self._make_date_lookup_arg(date + datetime.timedelta(days=1))
        return {
            "%s__gte" % date_field: since,
            "%s__lt" % date_field: until,
        }
    else:
        # Skip self._make_date_lookup_arg, it's a no-op in this branch.
        return {date_field: date}

def as_view(cls, **initkwargs): View

Main entry point for a request-response process.
 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
118
@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:
        markcoroutinefunction(view)
    return view

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

133
134
135
136
137
138
139
140
141
142
143
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 get(self, request, *args, **kwargs): BaseDateListView

308
309
310
311
312
313
def get(self, request, *args, **kwargs):
    self.date_list, self.object_list, extra_context = self.get_dated_items()
    context = self.get_context_data(
        object_list=self.object_list, date_list=self.date_list, **extra_context
    )
    return self.render_to_response(context)

def get_allow_empty(self): MultipleObjectMixin

Return ``True`` if the view should display empty lists and ``False``
if a 404 should be raised instead.
106
107
108
109
110
111
def get_allow_empty(self):
    """
    Return ``True`` if the view should display empty lists and ``False``
    if a 404 should be raised instead.
    """
    return self.allow_empty

def get_allow_future(self): DateMixin

Return `True` if the view should be allowed to display objects from
the future.
249
250
251
252
253
254
def get_allow_future(self):
    """
    Return `True` if the view should be allowed to display objects from
    the future.
    """
    return self.allow_future

def get_context_data(self, **kwargs):

MultipleObjectMixin

Get the context for this view.
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
def get_context_data(self, *, object_list=None, **kwargs):
    """Get the context for this view."""
    queryset = object_list if object_list is not None else self.object_list
    page_size = self.get_paginate_by(queryset)
    context_object_name = self.get_context_object_name(queryset)
    if page_size:
        paginator, page, queryset, is_paginated = self.paginate_queryset(
            queryset, page_size
        )
        context = {
            "paginator": paginator,
            "page_obj": page,
            "is_paginated": is_paginated,
            "object_list": queryset,
        }
    else:
        context = {
            "paginator": None,
            "page_obj": None,
            "is_paginated": False,
            "object_list": queryset,
        }
    if context_object_name is not None:
        context[context_object_name] = queryset
    context.update(kwargs)
    return super().get_context_data(**context)

ContextMixin

29
30
31
32
33
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, object_list): MultipleObjectMixin

Get the name of the item to be used in the context.
113
114
115
116
117
118
119
120
def get_context_object_name(self, object_list):
    """Get the name of the item to be used in the context."""
    if self.context_object_name:
        return self.context_object_name
    elif hasattr(object_list, "model"):
        return "%s_list" % object_list.model._meta.model_name
    else:
        return None

def get_date_field(self): DateMixin

Get the name of the date field to be used to filter by.
241
242
243
244
245
246
247
def get_date_field(self):
    """Get the name of the date field to be used to filter by."""
    if self.date_field is None:
        raise ImproperlyConfigured(
            "%s.date_field is required." % self.__class__.__name__
        )
    return self.date_field

def get_date_list(self, queryset, date_type=None, ordering='ASC'): BaseDateListView

Get a date list by calling `queryset.dates/datetimes()`, checking
along the way for empty lists that aren't allowed.
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
def get_date_list(self, queryset, date_type=None, ordering="ASC"):
    """
    Get a date list by calling `queryset.dates/datetimes()`, checking
    along the way for empty lists that aren't allowed.
    """
    date_field = self.get_date_field()
    allow_empty = self.get_allow_empty()
    if date_type is None:
        date_type = self.get_date_list_period()
    if self.uses_datetime_field:
        date_list = queryset.datetimes(date_field, date_type, ordering)
    else:
        date_list = queryset.dates(date_field, date_type, ordering)
    if date_list is not None and not date_list and not allow_empty:
        raise Http404(
            _("No %(verbose_name_plural)s available")
            % {
                "verbose_name_plural": queryset.model._meta.verbose_name_plural,
            }
        )
    return date_list

def get_date_list_period(self): BaseDateListView

Get the aggregation period for the list of dates: 'year', 'month', or
'day'.
357
358
359
360
361
362
def get_date_list_period(self):
    """
    Get the aggregation period for the list of dates: 'year', 'month', or
    'day'.
    """
    return self.date_list_period

def get_dated_items(self):

BaseWeekArchiveView

Return (date_list, items, extra_context) for this request.
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
def get_dated_items(self):
    """Return (date_list, items, extra_context) for this request."""
    year = self.get_year()
    week = self.get_week()
    date_field = self.get_date_field()
    week_format = self.get_week_format()
    week_choices = {"%W": "1", "%U": "0", "%V": "1"}
    try:
        week_start = week_choices[week_format]
    except KeyError:
        raise ValueError(
            "Unknown week format %r. Choices are: %s"
            % (
                week_format,
                ", ".join(sorted(week_choices)),
            )
        )
    year_format = self.get_year_format()
    if week_format == "%V" and year_format != "%G":
        raise ValueError(
            "ISO week directive '%s' is incompatible with the year "
            "directive '%s'. Use the ISO year '%%G' instead."
            % (
                week_format,
                year_format,
            )
        )
    date = _date_from_string(year, year_format, week_start, "%w", week, week_format)
    since = self._make_date_lookup_arg(date)
    until = self._make_date_lookup_arg(self._get_next_week(date))
    lookup_kwargs = {
        "%s__gte" % date_field: since,
        "%s__lt" % date_field: until,
    }
    qs = self.get_dated_queryset(**lookup_kwargs)
    return (
        None,
        qs,
        {
            "week": date,
            "next_week": self.get_next_week(date),
            "previous_week": self.get_previous_week(date),
        },
    )

BaseDateListView

Obtain the list of dates and items.
315
316
317
318
319
def get_dated_items(self):
    """Obtain the list of dates and items."""
    raise NotImplementedError(
        "A DateView must provide an implementation of get_dated_items()"
    )

def get_dated_queryset(self, **lookup): BaseDateListView

Get a queryset properly filtered according to `allow_future` and any
extra lookup kwargs.
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
def get_dated_queryset(self, **lookup):
    """
    Get a queryset properly filtered according to `allow_future` and any
    extra lookup kwargs.
    """
    qs = self.get_queryset().filter(**lookup)
    date_field = self.get_date_field()
    allow_future = self.get_allow_future()
    allow_empty = self.get_allow_empty()
    paginate_by = self.get_paginate_by(qs)
    if not allow_future:
        now = timezone.now() if self.uses_datetime_field else timezone_today()
        qs = qs.filter(**{"%s__lte" % date_field: now})
    if not allow_empty:
        # When pagination is enabled, it's better to do a cheap query
        # than to load the unpaginated queryset in memory.
        is_empty = not qs if paginate_by is None else not qs.exists()
        if is_empty:
            raise Http404(
                _("No %(verbose_name_plural)s available")
                % {
                    "verbose_name_plural": qs.model._meta.verbose_name_plural,
                }
            )
    return qs

def get_next_week(self, date): WeekMixin

Get the next valid week.
197
198
199
def get_next_week(self, date):
    """Get the next valid week."""
    return _get_next_prev(self, date, is_previous=False, period="week")

def get_next_year(self, date): YearMixin

Get the next valid year.
47
48
49
def get_next_year(self, date):
    """Get the next valid year."""
    return _get_next_prev(self, date, is_previous=False, period="year")

def get_ordering(self):

BaseDateListView

Return the field or fields to use for ordering the queryset; use the
date field by default.
321
322
323
324
325
326
def get_ordering(self):
    """
    Return the field or fields to use for ordering the queryset; use the
    date field by default.
    """
    return "-%s" % self.get_date_field() if self.ordering is None else self.ordering

MultipleObjectMixin

Return the field or fields to use for ordering the queryset.
49
50
51
def get_ordering(self):
    """Return the field or fields to use for ordering the queryset."""
    return self.ordering

def get_paginate_by(self, queryset): MultipleObjectMixin

Get the number of items to paginate by, or ``None`` for no pagination.
81
82
83
84
85
def get_paginate_by(self, queryset):
    """
    Get the number of items to paginate by, or ``None`` for no pagination.
    """
    return self.paginate_by

def get_paginate_orphans(self): MultipleObjectMixin

Return the maximum number of orphans extend the last page by when
paginating.
 99
100
101
102
103
104
def get_paginate_orphans(self):
    """
    Return the maximum number of orphans extend the last page by when
    paginating.
    """
    return self.paginate_orphans

def get_paginator(self, queryset, per_page, orphans=0, allow_empty_first_page=True, **kwargs): MultipleObjectMixin

Return an instance of the paginator for this view.
87
88
89
90
91
92
93
94
95
96
97
def get_paginator(
    self, queryset, per_page, orphans=0, allow_empty_first_page=True, **kwargs
):
    """Return an instance of the paginator for this view."""
    return self.paginator_class(
        queryset,
        per_page,
        orphans=orphans,
        allow_empty_first_page=allow_empty_first_page,
        **kwargs,
    )

def get_previous_week(self, date): WeekMixin

Get the previous valid week.
201
202
203
def get_previous_week(self, date):
    """Get the previous valid week."""
    return _get_next_prev(self, date, is_previous=True, period="week")

def get_previous_year(self, date): YearMixin

Get the previous valid year.
51
52
53
def get_previous_year(self, date):
    """Get the previous valid year."""
    return _get_next_prev(self, date, is_previous=True, period="year")

def get_queryset(self): MultipleObjectMixin

Return the list of items for this view.

The return value must be an iterable and may be an instance of
`QuerySet` in which case `QuerySet` specific behavior will be enabled.
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
def get_queryset(self):
    """
    Return the list of items for this view.
    The return value must be an iterable and may be an instance of
    `QuerySet` in which case `QuerySet` specific behavior will be enabled.
    """
    if self.queryset is not None:
        queryset = self.queryset
        if isinstance(queryset, QuerySet):
            queryset = queryset.all()
    elif self.model is not None:
        queryset = 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__}
        )
    ordering = self.get_ordering()
    if ordering:
        if isinstance(ordering, str):
            ordering = (ordering,)
        queryset = queryset.order_by(*ordering)
    return queryset

def get_template_names(self):

MultipleObjectTemplateResponseMixin

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.
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
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.
    """
    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 the list is a queryset, we'll invent a template name based on the
    # app and model name. This name gets put at the end of the template
    # name list so that user-supplied names override the automatically-
    # generated ones.
    if hasattr(self.object_list, "model"):
        opts = self.object_list.model._meta
        names.append(
            "%s/%s%s.html"
            % (opts.app_label, opts.model_name, self.template_name_suffix)
        )
    elif not names:
        raise ImproperlyConfigured(
            "%(cls)s requires either a 'template_name' attribute "
            "or a get_queryset() method that returns a QuerySet."
            % {
                "cls": self.__class__.__name__,
            }
        )
    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.
206
207
208
209
210
211
212
213
214
215
216
217
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 get_week(self): WeekMixin

Return the week for which this view should display data.
184
185
186
187
188
189
190
191
192
193
194
195
def get_week(self):
    """Return the week for which this view should display data."""
    week = self.week
    if week is None:
        try:
            week = self.kwargs["week"]
        except KeyError:
            try:
                week = self.request.GET["week"]
            except KeyError:
                raise Http404(_("No week specified"))
    return week

def get_week_format(self): WeekMixin

Get a week format string in strptime syntax to be used to parse the
week from url variables.
177
178
179
180
181
182
def get_week_format(self):
    """
    Get a week format string in strptime syntax to be used to parse the
    week from url variables.
    """
    return self.week_format

def get_year(self): YearMixin

Return the year for which this view should display data.
34
35
36
37
38
39
40
41
42
43
44
45
def get_year(self):
    """Return the year for which this view should display data."""
    year = self.year
    if year is None:
        try:
            year = self.kwargs["year"]
        except KeyError:
            try:
                year = self.request.GET["year"]
            except KeyError:
                raise Http404(_("No year specified"))
    return year

def get_year_format(self): YearMixin

Get a year format string in strptime syntax to be used to parse the
year from url variables.
27
28
29
30
31
32
def get_year_format(self):
    """
    Get a year format string in strptime syntax to be used to parse the
    year from url variables.
    """
    return self.year_format

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

145
146
147
148
149
150
151
152
153
154
155
156
157
158
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},
    )
    response = HttpResponseNotAllowed(self._allowed_methods())
    if self.view_is_async:
        async def func():
            return response
        return func()
    else:
        return response

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

Handle responding to requests for the OPTIONS HTTP verb.
163
164
165
166
167
168
169
170
171
172
173
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 paginate_queryset(self, queryset, page_size): MultipleObjectMixin

Paginate the queryset, if needed.
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
def paginate_queryset(self, queryset, page_size):
    """Paginate the queryset, if needed."""
    paginator = self.get_paginator(
        queryset,
        page_size,
        orphans=self.get_paginate_orphans(),
        allow_empty_first_page=self.get_allow_empty(),
    )
    page_kwarg = self.page_kwarg
    page = self.kwargs.get(page_kwarg) or self.request.GET.get(page_kwarg) or 1
    try:
        page_number = int(page)
    except ValueError:
        if page == "last":
            page_number = paginator.num_pages
        else:
            raise Http404(
                _("Page is not “last”, nor can it be converted to an int.")
            )
    try:
        page = paginator.page(page_number)
        return (paginator, page, page.object_list, page.has_other_pages())
    except InvalidPage as e:
        raise Http404(
            _("Invalid page (%(page_number)s): %(message)s")
            % {"page_number": page_number, "message": str(e)}
        )

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.
190
191
192
193
194
195
196
197
198
199
200
201
202
203
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.
125
126
127
128
129
130
131
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