Source code
import datetime
from django.conf import settings
from django.core.exceptions import ImproperlyConfigured
from django.db import models
from django.http import Http404
from django.utils import timezone
from django.utils.functional import cached_property
from django.utils.translation import gettext as _
from django.views.generic.base import View
from django.views.generic.detail import (
BaseDetailView,
SingleObjectTemplateResponseMixin,
)
from django.views.generic.list import (
MultipleObjectMixin,
MultipleObjectTemplateResponseMixin,
)
class BaseDateDetailView(YearMixin, MonthMixin, DayMixin, DateMixin, BaseDetailView):
"""
Base detail view for a single object on a single date; this differs from
the standard DetailView by accepting a year/month/day in the URL.
This requires subclassing to provide a response mixin.
"""
def get_object(self, queryset=None):
"""Get the object this request displays."""
year = self.get_year()
month = self.get_month()
day = self.get_day()
date = _date_from_string(
year,
self.get_year_format(),
month,
self.get_month_format(),
day,
self.get_day_format(),
)
# Use a custom queryset if provided
qs = self.get_queryset() if queryset is None else queryset
if not self.get_allow_future() and date > datetime.date.today():
raise Http404(
_(
"Future %(verbose_name_plural)s not available because "
"%(class_name)s.allow_future is False."
)
% {
"verbose_name_plural": qs.model._meta.verbose_name_plural,
"class_name": self.__class__.__name__,
}
)
# Filter down a queryset from self.queryset using the date from the
# URL. This'll get passed as the queryset to DetailView.get_object,
# which'll handle the 404
lookup_kwargs = self._make_single_date_lookup(date)
qs = qs.filter(**lookup_kwargs)
return super().get_object(queryset=qs)
Run 1
The code is generally readable with clear imports, logical structure, and good variable naming. The main method is well-organized and focused, using meaningful intermediate variables like `year`, `month`, `day`, and `lookup_kwargs`. Comments explain non-obvious behavior, and action granularity is appropriate. However, the error-raising block contains dense string formatting that interrupts flow, and the `_date_from_string` call breaks from class methods to use a standalone function, which could confuse intent. The mixin inheritance with multiple base classes may require added cognitive load, though this is a common Django pattern. Overall, the code is concise but could benefit from extracting error handling or simplifying formatting logic.
Run 2
The code is highly readable with clear structure and intent. Imports are organized, class inheritance is logical, and the `get_object` method follows a clean sequential flow: parse date, validate future, filter queryset, delegate to super. Nesting is minimal with only one conditional block. Comments are concise and explain non-obvious logic. Naming is descriptive. Minor deductions: the long error message and string formatting occupy several lines, and some mixed levels of abstraction, but overall the code is concise, well-structured, and easy to follow.
Run 3
The code is generally readable with clear structure, consistent naming, and logical organization. Imports are well-grouped, and the class/method purpose is documented. The get_object method has a natural flow: parse date, validate future, filter queryset, delegate. Nesting is minimal, with only one conditional. However, some aspects reduce readability: the date parsing uses multiple helper calls that obscure intent slightly, and the error message construction is verbose and split across lines. Action granularity is mostly one action per line, but the qs assignment and filter operations could be clearer. The mixin-heavy inheritance pattern adds complexity for readers unfamiliar with Django's generic views. Overall, it's maintainable and idiomatic Django, though not perfectly self-explanatory for beginners.
Run 1
Code Structure: The class and method are logically organized, separating date parsing, queryset selection, validation, filtering, and object retrieval. Nesting: A single conditional keeps control flow shallow; the multiline exception adds visual complexity but not deep nesting. Clarity of intent: Descriptive method names, a useful docstring, and comments make the purpose clear, although external mixins and helpers require surrounding context, and 'qs' is abbreviated. Code length: The method is appropriately concise, but several imports are unused in this excerpt and the error construction is somewhat verbose. Action granularity: Most lines perform one clear action; multiline calls improve readability rather than combining unrelated operations. Reading flow: Execution follows a natural sequence from URL date components to the filtered object, with sensible whitespace and consistent formatting.
Run 2
Code Structure: Clearly organized around a single view class and a focused get_object method, with date parsing, validation, filtering, and retrieval separated logically. Nesting: Minimal nesting; one conditional and an early exception keep control flow straightforward. Clarity of intent: Descriptive method names, a useful class docstring, and explanatory comments make the purpose clear, although mixins and helper functions defined elsewhere require context. Code length: Mostly concise, but unused imports in this excerpt and the lengthy exception formatting add visual overhead. Action granularity: Each statement performs a distinct action; multiline calls and dictionary formatting remain readable. Reading flow: Follows a natural progression from URL date components to queryset selection, future-date validation, filtering, and superclass retrieval. The abbreviated variable qs is conventional but less explicit than queryset.
Run 3
Code Structure: The method is logically organized into date extraction, parsing, queryset selection, validation, filtering, and retrieval. Nesting: Control flow is shallow, with only one conditional; nested formatting expressions add minor visual complexity. Clarity of intent: Descriptive method names, a class docstring, and helpful comments make the purpose clear, though external mixins and helpers require context, and 'qs' is abbreviated. Code length: The implementation is concise, but several imports appear unused in this excerpt and the multiline error message occupies substantial space. Action granularity: Each statement performs a distinct operation; the conditional queryset assignment remains readable. Reading flow: Execution follows a natural sequence from URL date components to object retrieval, with whitespace separating stages effectively.