Add files using upload-large-folder tool

testbed/django__django/django/__init__.py

@@ -0,0 +1,24 @@
+from django.utils.version import get_version
+
+VERSION = (5, 0, 0, "alpha", 0)
+
+__version__ = get_version(VERSION)
+
+
+def setup(set_prefix=True):
+    """
+    Configure the settings (this happens as a side effect of accessing the
+    first setting), configure logging and populate the app registry.
+    Set the thread-local urlresolvers script prefix if `set_prefix` is True.
+    """
+    from django.apps import apps
+    from django.conf import settings
+    from django.urls import set_script_prefix
+    from django.utils.log import configure_logging
+
+    configure_logging(settings.LOGGING_CONFIG, settings.LOGGING)
+    if set_prefix:
+        set_script_prefix(
+            "/" if settings.FORCE_SCRIPT_NAME is None else settings.FORCE_SCRIPT_NAME
+        )
+    apps.populate(settings.INSTALLED_APPS)

testbed/django__django/django/__main__.py

@@ -0,0 +1,9 @@
+"""
+Invokes django-admin when the django module is run as a script.
+
+Example: python -m django check
+"""
+from django.core import management
+
+if __name__ == "__main__":
+    management.execute_from_command_line()

testbed/django__django/django/shortcuts.py

@@ -0,0 +1,155 @@
+"""
+This module collects helper functions and classes that "span" multiple levels
+of MVC. In other words, these functions/classes introduce controlled coupling
+for convenience's sake.
+"""
+from django.http import (
+    Http404,
+    HttpResponse,
+    HttpResponsePermanentRedirect,
+    HttpResponseRedirect,
+)
+from django.template import loader
+from django.urls import NoReverseMatch, reverse
+from django.utils.functional import Promise
+
+
+def render(
+    request, template_name, context=None, content_type=None, status=None, using=None
+):
+    """
+    Return an HttpResponse whose content is filled with the result of calling
+    django.template.loader.render_to_string() with the passed arguments.
+    """
+    content = loader.render_to_string(template_name, context, request, using=using)
+    return HttpResponse(content, content_type, status)
+
+
+def redirect(to, *args, permanent=False, **kwargs):
+    """
+    Return an HttpResponseRedirect to the appropriate URL for the arguments
+    passed.
+
+    The arguments could be:
+
+        * A model: the model's `get_absolute_url()` function will be called.
+
+        * A view name, possibly with arguments: `urls.reverse()` will be used
+          to reverse-resolve the name.
+
+        * A URL, which will be used as-is for the redirect location.
+
+    Issues a temporary redirect by default; pass permanent=True to issue a
+    permanent redirect.
+    """
+    redirect_class = (
+        HttpResponsePermanentRedirect if permanent else HttpResponseRedirect
+    )
+    return redirect_class(resolve_url(to, *args, **kwargs))
+
+
+def _get_queryset(klass):
+    """
+    Return a QuerySet or a Manager.
+    Duck typing in action: any class with a `get()` method (for
+    get_object_or_404) or a `filter()` method (for get_list_or_404) might do
+    the job.
+    """
+    # If it is a model class or anything else with ._default_manager
+    if hasattr(klass, "_default_manager"):
+        return klass._default_manager.all()
+    return klass
+
+
+def get_object_or_404(klass, *args, **kwargs):
+    """
+    Use get() to return an object, or raise an Http404 exception if the object
+    does not exist.
+
+    klass may be a Model, Manager, or QuerySet object. All other passed
+    arguments and keyword arguments are used in the get() query.
+
+    Like with QuerySet.get(), MultipleObjectsReturned is raised if more than
+    one object is found.
+    """
+    queryset = _get_queryset(klass)
+    if not hasattr(queryset, "get"):
+        klass__name = (
+            klass.__name__ if isinstance(klass, type) else klass.__class__.__name__
+        )
+        raise ValueError(
+            "First argument to get_object_or_404() must be a Model, Manager, "
+            "or QuerySet, not '%s'." % klass__name
+        )
+    try:
+        return queryset.get(*args, **kwargs)
+    except queryset.model.DoesNotExist:
+        raise Http404(
+            "No %s matches the given query." % queryset.model._meta.object_name
+        )
+
+
+def get_list_or_404(klass, *args, **kwargs):
+    """
+    Use filter() to return a list of objects, or raise an Http404 exception if
+    the list is empty.
+
+    klass may be a Model, Manager, or QuerySet object. All other passed
+    arguments and keyword arguments are used in the filter() query.
+    """
+    queryset = _get_queryset(klass)
+    if not hasattr(queryset, "filter"):
+        klass__name = (
+            klass.__name__ if isinstance(klass, type) else klass.__class__.__name__
+        )
+        raise ValueError(
+            "First argument to get_list_or_404() must be a Model, Manager, or "
+            "QuerySet, not '%s'." % klass__name
+        )
+    obj_list = list(queryset.filter(*args, **kwargs))
+    if not obj_list:
+        raise Http404(
+            "No %s matches the given query." % queryset.model._meta.object_name
+        )
+    return obj_list
+
+
+def resolve_url(to, *args, **kwargs):
+    """
+    Return a URL appropriate for the arguments passed.
+
+    The arguments could be:
+
+        * A model: the model's `get_absolute_url()` function will be called.
+
+        * A view name, possibly with arguments: `urls.reverse()` will be used
+          to reverse-resolve the name.
+
+        * A URL, which will be returned as-is.
+    """
+    # If it's a model, use get_absolute_url()
+    if hasattr(to, "get_absolute_url"):
+        return to.get_absolute_url()
+
+    if isinstance(to, Promise):
+        # Expand the lazy instance, as it can cause issues when it is passed
+        # further to some Python functions like urlparse.
+        to = str(to)
+
+    # Handle relative URLs
+    if isinstance(to, str) and to.startswith(("./", "../")):
+        return to
+
+    # Next try a reverse URL resolution.
+    try:
+        return reverse(to, args=args, kwargs=kwargs)
+    except NoReverseMatch:
+        # If this is a callable, re-raise.
+        if callable(to):
+            raise
+        # If this doesn't "feel" like a URL, re-raise.
+        if "/" not in to and "." not in to:
+            raise
+
+    # Finally, fall back and assume it's a URL
+    return to

testbed/django__django/django/views/__init__.py

@@ -0,0 +1,3 @@
+from django.views.generic.base import View
+
+__all__ = ["View"]

testbed/django__django/django/views/csrf.py

@@ -0,0 +1,79 @@
+from pathlib import Path
+
+from django.conf import settings
+from django.http import HttpResponseForbidden
+from django.template import Context, Engine, TemplateDoesNotExist, loader
+from django.utils.translation import gettext as _
+from django.utils.version import get_docs_version
+
+CSRF_FAILURE_TEMPLATE_NAME = "403_csrf.html"
+
+
+def builtin_template_path(name):
+    """
+    Return a path to a builtin template.
+
+    Avoid calling this function at the module level or in a class-definition
+    because __file__ may not exist, e.g. in frozen environments.
+    """
+    return Path(__file__).parent / "templates" / name
+
+
+def csrf_failure(request, reason="", template_name=CSRF_FAILURE_TEMPLATE_NAME):
+    """
+    Default view used when request fails CSRF protection
+    """
+    from django.middleware.csrf import REASON_NO_CSRF_COOKIE, REASON_NO_REFERER
+
+    c = {
+        "title": _("Forbidden"),
+        "main": _("CSRF verification failed. Request aborted."),
+        "reason": reason,
+        "no_referer": reason == REASON_NO_REFERER,
+        "no_referer1": _(
+            "You are seeing this message because this HTTPS site requires a "
+            "“Referer header” to be sent by your web browser, but none was "
+            "sent. This header is required for security reasons, to ensure "
+            "that your browser is not being hijacked by third parties."
+        ),
+        "no_referer2": _(
+            "If you have configured your browser to disable “Referer” headers, "
+            "please re-enable them, at least for this site, or for HTTPS "
+            "connections, or for “same-origin” requests."
+        ),
+        "no_referer3": _(
+            'If you are using the <meta name="referrer" '
+            'content="no-referrer"> tag or including the “Referrer-Policy: '
+            "no-referrer” header, please remove them. The CSRF protection "
+            "requires the “Referer” header to do strict referer checking. If "
+            "you’re concerned about privacy, use alternatives like "
+            '<a rel="noreferrer" …> for links to third-party sites.'
+        ),
+        "no_cookie": reason == REASON_NO_CSRF_COOKIE,
+        "no_cookie1": _(
+            "You are seeing this message because this site requires a CSRF "
+            "cookie when submitting forms. This cookie is required for "
+            "security reasons, to ensure that your browser is not being "
+            "hijacked by third parties."
+        ),
+        "no_cookie2": _(
+            "If you have configured your browser to disable cookies, please "
+            "re-enable them, at least for this site, or for “same-origin” "
+            "requests."
+        ),
+        "DEBUG": settings.DEBUG,
+        "docs_version": get_docs_version(),
+        "more": _("More information is available with DEBUG=True."),
+    }
+    try:
+        t = loader.get_template(template_name)
+    except TemplateDoesNotExist:
+        if template_name == CSRF_FAILURE_TEMPLATE_NAME:
+            # If the default template doesn't exist, use the fallback template.
+            with builtin_template_path("csrf_403.html").open(encoding="utf-8") as fh:
+                t = Engine().from_string(fh.read())
+            c = Context(c)
+        else:
+            # Raise if a developer-specified template doesn't exist.
+            raise
+    return HttpResponseForbidden(t.render(c))

testbed/django__django/django/views/debug.py

@@ -0,0 +1,665 @@
+import functools
+import inspect
+import itertools
+import re
+import sys
+import types
+import warnings
+from pathlib import Path
+
+from django.conf import settings
+from django.http import Http404, HttpResponse, HttpResponseNotFound
+from django.template import Context, Engine, TemplateDoesNotExist
+from django.template.defaultfilters import pprint
+from django.urls import resolve
+from django.utils import timezone
+from django.utils.datastructures import MultiValueDict
+from django.utils.encoding import force_str
+from django.utils.module_loading import import_string
+from django.utils.regex_helper import _lazy_re_compile
+from django.utils.version import PY311, get_docs_version
+from django.views.decorators.debug import coroutine_functions_to_sensitive_variables
+
+# Minimal Django templates engine to render the error templates
+# regardless of the project's TEMPLATES setting. Templates are
+# read directly from the filesystem so that the error handler
+# works even if the template loader is broken.
+DEBUG_ENGINE = Engine(
+    debug=True,
+    libraries={"i18n": "django.templatetags.i18n"},
+)
+
+
+def builtin_template_path(name):
+    """
+    Return a path to a builtin template.
+
+    Avoid calling this function at the module level or in a class-definition
+    because __file__ may not exist, e.g. in frozen environments.
+    """
+    return Path(__file__).parent / "templates" / name
+
+
+class ExceptionCycleWarning(UserWarning):
+    pass
+
+
+class CallableSettingWrapper:
+    """
+    Object to wrap callable appearing in settings.
+    * Not to call in the debug page (#21345).
+    * Not to break the debug page if the callable forbidding to set attributes
+      (#23070).
+    """
+
+    def __init__(self, callable_setting):
+        self._wrapped = callable_setting
+
+    def __repr__(self):
+        return repr(self._wrapped)
+
+
+def technical_500_response(request, exc_type, exc_value, tb, status_code=500):
+    """
+    Create a technical server error response. The last three arguments are
+    the values returned from sys.exc_info() and friends.
+    """
+    reporter = get_exception_reporter_class(request)(request, exc_type, exc_value, tb)
+    if request.accepts("text/html"):
+        html = reporter.get_traceback_html()
+        return HttpResponse(html, status=status_code)
+    else:
+        text = reporter.get_traceback_text()
+        return HttpResponse(
+            text, status=status_code, content_type="text/plain; charset=utf-8"
+        )
+
+
+@functools.lru_cache
+def get_default_exception_reporter_filter():
+    # Instantiate the default filter for the first time and cache it.
+    return import_string(settings.DEFAULT_EXCEPTION_REPORTER_FILTER)()
+
+
+def get_exception_reporter_filter(request):
+    default_filter = get_default_exception_reporter_filter()
+    return getattr(request, "exception_reporter_filter", default_filter)
+
+
+def get_exception_reporter_class(request):
+    default_exception_reporter_class = import_string(
+        settings.DEFAULT_EXCEPTION_REPORTER
+    )
+    return getattr(
+        request, "exception_reporter_class", default_exception_reporter_class
+    )
+
+
+def get_caller(request):
+    resolver_match = request.resolver_match
+    if resolver_match is None:
+        try:
+            resolver_match = resolve(request.path)
+        except Http404:
+            pass
+    return "" if resolver_match is None else resolver_match._func_path
+
+
+class SafeExceptionReporterFilter:
+    """
+    Use annotations made by the sensitive_post_parameters and
+    sensitive_variables decorators to filter out sensitive information.
+    """
+
+    cleansed_substitute = "********************"
+    hidden_settings = _lazy_re_compile(
+        "API|TOKEN|KEY|SECRET|PASS|SIGNATURE|HTTP_COOKIE", flags=re.I
+    )
+
+    def cleanse_setting(self, key, value):
+        """
+        Cleanse an individual setting key/value of sensitive content. If the
+        value is a dictionary, recursively cleanse the keys in that dictionary.
+        """
+        if key == settings.SESSION_COOKIE_NAME:
+            is_sensitive = True
+        else:
+            try:
+                is_sensitive = self.hidden_settings.search(key)
+            except TypeError:
+                is_sensitive = False
+
+        if is_sensitive:
+            cleansed = self.cleansed_substitute
+        elif isinstance(value, dict):
+            cleansed = {k: self.cleanse_setting(k, v) for k, v in value.items()}
+        elif isinstance(value, list):
+            cleansed = [self.cleanse_setting("", v) for v in value]
+        elif isinstance(value, tuple):
+            cleansed = tuple([self.cleanse_setting("", v) for v in value])
+        else:
+            cleansed = value
+
+        if callable(cleansed):
+            cleansed = CallableSettingWrapper(cleansed)
+
+        return cleansed
+
+    def get_safe_settings(self):
+        """
+        Return a dictionary of the settings module with values of sensitive
+        settings replaced with stars (*********).
+        """
+        settings_dict = {}
+        for k in dir(settings):
+            if k.isupper():
+                settings_dict[k] = self.cleanse_setting(k, getattr(settings, k))
+        return settings_dict
+
+    def get_safe_request_meta(self, request):
+        """
+        Return a dictionary of request.META with sensitive values redacted.
+        """
+        if not hasattr(request, "META"):
+            return {}
+        return {k: self.cleanse_setting(k, v) for k, v in request.META.items()}
+
+    def get_safe_cookies(self, request):
+        """
+        Return a dictionary of request.COOKIES with sensitive values redacted.
+        """
+        if not hasattr(request, "COOKIES"):
+            return {}
+        return {k: self.cleanse_setting(k, v) for k, v in request.COOKIES.items()}
+
+    def is_active(self, request):
+        """
+        This filter is to add safety in production environments (i.e. DEBUG
+        is False). If DEBUG is True then your site is not safe anyway.
+        This hook is provided as a convenience to easily activate or
+        deactivate the filter on a per request basis.
+        """
+        return settings.DEBUG is False
+
+    def get_cleansed_multivaluedict(self, request, multivaluedict):
+        """
+        Replace the keys in a MultiValueDict marked as sensitive with stars.
+        This mitigates leaking sensitive POST parameters if something like
+        request.POST['nonexistent_key'] throws an exception (#21098).
+        """
+        sensitive_post_parameters = getattr(request, "sensitive_post_parameters", [])
+        if self.is_active(request) and sensitive_post_parameters:
+            multivaluedict = multivaluedict.copy()
+            for param in sensitive_post_parameters:
+                if param in multivaluedict:
+                    multivaluedict[param] = self.cleansed_substitute
+        return multivaluedict
+
+    def get_post_parameters(self, request):
+        """
+        Replace the values of POST parameters marked as sensitive with
+        stars (*********).
+        """
+        if request is None:
+            return {}
+        else:
+            sensitive_post_parameters = getattr(
+                request, "sensitive_post_parameters", []
+            )
+            if self.is_active(request) and sensitive_post_parameters:
+                cleansed = request.POST.copy()
+                if sensitive_post_parameters == "__ALL__":
+                    # Cleanse all parameters.
+                    for k in cleansed:
+                        cleansed[k] = self.cleansed_substitute
+                    return cleansed
+                else:
+                    # Cleanse only the specified parameters.
+                    for param in sensitive_post_parameters:
+                        if param in cleansed:
+                            cleansed[param] = self.cleansed_substitute
+                    return cleansed
+            else:
+                return request.POST
+
+    def cleanse_special_types(self, request, value):
+        try:
+            # If value is lazy or a complex object of another kind, this check
+            # might raise an exception. isinstance checks that lazy
+            # MultiValueDicts will have a return value.
+            is_multivalue_dict = isinstance(value, MultiValueDict)
+        except Exception as e:
+            return "{!r} while evaluating {!r}".format(e, value)
+
+        if is_multivalue_dict:
+            # Cleanse MultiValueDicts (request.POST is the one we usually care about)
+            value = self.get_cleansed_multivaluedict(request, value)
+        return value
+
+    def get_traceback_frame_variables(self, request, tb_frame):
+        """
+        Replace the values of variables marked as sensitive with
+        stars (*********).
+        """
+        sensitive_variables = None
+
+        # Coroutines don't have a proper `f_back` so they need to be inspected
+        # separately. Handle this by stashing the registered sensitive
+        # variables in a global dict indexed by `hash(file_path:line_number)`.
+        if (
+            tb_frame.f_code.co_flags & inspect.CO_COROUTINE != 0
+            and tb_frame.f_code.co_name != "sensitive_variables_wrapper"
+        ):
+            key = hash(
+                f"{tb_frame.f_code.co_filename}:{tb_frame.f_code.co_firstlineno}"
+            )
+            sensitive_variables = coroutine_functions_to_sensitive_variables.get(
+                key, None
+            )
+
+        if sensitive_variables is None:
+            # Loop through the frame's callers to see if the
+            # sensitive_variables decorator was used.
+            current_frame = tb_frame
+            while current_frame is not None:
+                if (
+                    current_frame.f_code.co_name == "sensitive_variables_wrapper"
+                    and "sensitive_variables_wrapper" in current_frame.f_locals
+                ):
+                    # The sensitive_variables decorator was used, so take note
+                    # of the sensitive variables' names.
+                    wrapper = current_frame.f_locals["sensitive_variables_wrapper"]
+                    sensitive_variables = getattr(wrapper, "sensitive_variables", None)
+                    break
+                current_frame = current_frame.f_back
+
+        cleansed = {}
+        if self.is_active(request) and sensitive_variables:
+            if sensitive_variables == "__ALL__":
+                # Cleanse all variables
+                for name in tb_frame.f_locals:
+                    cleansed[name] = self.cleansed_substitute
+            else:
+                # Cleanse specified variables
+                for name, value in tb_frame.f_locals.items():
+                    if name in sensitive_variables:
+                        value = self.cleansed_substitute
+                    else:
+                        value = self.cleanse_special_types(request, value)
+                    cleansed[name] = value
+        else:
+            # Potentially cleanse the request and any MultiValueDicts if they
+            # are one of the frame variables.
+            for name, value in tb_frame.f_locals.items():
+                cleansed[name] = self.cleanse_special_types(request, value)
+
+        if (
+            tb_frame.f_code.co_name == "sensitive_variables_wrapper"
+            and "sensitive_variables_wrapper" in tb_frame.f_locals
+        ):
+            # For good measure, obfuscate the decorated function's arguments in
+            # the sensitive_variables decorator's frame, in case the variables
+            # associated with those arguments were meant to be obfuscated from
+            # the decorated function's frame.
+            cleansed["func_args"] = self.cleansed_substitute
+            cleansed["func_kwargs"] = self.cleansed_substitute
+
+        return cleansed.items()
+
+
+class ExceptionReporter:
+    """Organize and coordinate reporting on exceptions."""
+
+    @property
+    def html_template_path(self):
+        return builtin_template_path("technical_500.html")
+
+    @property
+    def text_template_path(self):
+        return builtin_template_path("technical_500.txt")
+
+    def __init__(self, request, exc_type, exc_value, tb, is_email=False):
+        self.request = request
+        self.filter = get_exception_reporter_filter(self.request)
+        self.exc_type = exc_type
+        self.exc_value = exc_value
+        self.tb = tb
+        self.is_email = is_email
+
+        self.template_info = getattr(self.exc_value, "template_debug", None)
+        self.template_does_not_exist = False
+        self.postmortem = None
+
+    def _get_raw_insecure_uri(self):
+        """
+        Return an absolute URI from variables available in this request. Skip
+        allowed hosts protection, so may return insecure URI.
+        """
+        return "{scheme}://{host}{path}".format(
+            scheme=self.request.scheme,
+            host=self.request._get_raw_host(),
+            path=self.request.get_full_path(),
+        )
+
+    def get_traceback_data(self):
+        """Return a dictionary containing traceback information."""
+        if self.exc_type and issubclass(self.exc_type, TemplateDoesNotExist):
+            self.template_does_not_exist = True
+            self.postmortem = self.exc_value.chain or [self.exc_value]
+
+        frames = self.get_traceback_frames()
+        for i, frame in enumerate(frames):
+            if "vars" in frame:
+                frame_vars = []
+                for k, v in frame["vars"]:
+                    v = pprint(v)
+                    # Trim large blobs of data
+                    if len(v) > 4096:
+                        v = "%s… <trimmed %d bytes string>" % (v[0:4096], len(v))
+                    frame_vars.append((k, v))
+                frame["vars"] = frame_vars
+            frames[i] = frame
+
+        unicode_hint = ""
+        if self.exc_type and issubclass(self.exc_type, UnicodeError):
+            start = getattr(self.exc_value, "start", None)
+            end = getattr(self.exc_value, "end", None)
+            if start is not None and end is not None:
+                unicode_str = self.exc_value.args[1]
+                unicode_hint = force_str(
+                    unicode_str[max(start - 5, 0) : min(end + 5, len(unicode_str))],
+                    "ascii",
+                    errors="replace",
+                )
+        from django import get_version
+
+        if self.request is None:
+            user_str = None
+        else:
+            try:
+                user_str = str(self.request.user)
+            except Exception:
+                # request.user may raise OperationalError if the database is
+                # unavailable, for example.
+                user_str = "[unable to retrieve the current user]"
+
+        c = {
+            "is_email": self.is_email,
+            "unicode_hint": unicode_hint,
+            "frames": frames,
+            "request": self.request,
+            "request_meta": self.filter.get_safe_request_meta(self.request),
+            "request_COOKIES_items": self.filter.get_safe_cookies(self.request).items(),
+            "user_str": user_str,
+            "filtered_POST_items": list(
+                self.filter.get_post_parameters(self.request).items()
+            ),
+            "settings": self.filter.get_safe_settings(),
+            "sys_executable": sys.executable,
+            "sys_version_info": "%d.%d.%d" % sys.version_info[0:3],
+            "server_time": timezone.now(),
+            "django_version_info": get_version(),
+            "sys_path": sys.path,
+            "template_info": self.template_info,
+            "template_does_not_exist": self.template_does_not_exist,
+            "postmortem": self.postmortem,
+        }
+        if self.request is not None:
+            c["request_GET_items"] = self.request.GET.items()
+            c["request_FILES_items"] = self.request.FILES.items()
+            c["request_insecure_uri"] = self._get_raw_insecure_uri()
+            c["raising_view_name"] = get_caller(self.request)
+
+        # Check whether exception info is available
+        if self.exc_type:
+            c["exception_type"] = self.exc_type.__name__
+        if self.exc_value:
+            c["exception_value"] = str(self.exc_value)
+            if exc_notes := getattr(self.exc_value, "__notes__", None):
+                c["exception_notes"] = "\n" + "\n".join(exc_notes)
+        if frames:
+            c["lastframe"] = frames[-1]
+        return c
+
+    def get_traceback_html(self):
+        """Return HTML version of debug 500 HTTP error page."""
+        with self.html_template_path.open(encoding="utf-8") as fh:
+            t = DEBUG_ENGINE.from_string(fh.read())
+        c = Context(self.get_traceback_data(), use_l10n=False)
+        return t.render(c)
+
+    def get_traceback_text(self):
+        """Return plain text version of debug 500 HTTP error page."""
+        with self.text_template_path.open(encoding="utf-8") as fh:
+            t = DEBUG_ENGINE.from_string(fh.read())
+        c = Context(self.get_traceback_data(), autoescape=False, use_l10n=False)
+        return t.render(c)
+
+    def _get_source(self, filename, loader, module_name):
+        source = None
+        if hasattr(loader, "get_source"):
+            try:
+                source = loader.get_source(module_name)
+            except ImportError:
+                pass
+            if source is not None:
+                source = source.splitlines()
+        if source is None:
+            try:
+                with open(filename, "rb") as fp:
+                    source = fp.read().splitlines()
+            except OSError:
+                pass
+        return source
+
+    def _get_lines_from_file(
+        self, filename, lineno, context_lines, loader=None, module_name=None
+    ):
+        """
+        Return context_lines before and after lineno from file.
+        Return (pre_context_lineno, pre_context, context_line, post_context).
+        """
+        source = self._get_source(filename, loader, module_name)
+        if source is None:
+            return None, [], None, []
+
+        # If we just read the source from a file, or if the loader did not
+        # apply tokenize.detect_encoding to decode the source into a
+        # string, then we should do that ourselves.
+        if isinstance(source[0], bytes):
+            encoding = "ascii"
+            for line in source[:2]:
+                # File coding may be specified. Match pattern from PEP-263
+                # (https://www.python.org/dev/peps/pep-0263/)
+                match = re.search(rb"coding[:=]\s*([-\w.]+)", line)
+                if match:
+                    encoding = match[1].decode("ascii")
+                    break
+            source = [str(sline, encoding, "replace") for sline in source]
+
+        lower_bound = max(0, lineno - context_lines)
+        upper_bound = lineno + context_lines
+
+        try:
+            pre_context = source[lower_bound:lineno]
+            context_line = source[lineno]
+            post_context = source[lineno + 1 : upper_bound]
+        except IndexError:
+            return None, [], None, []
+        return lower_bound, pre_context, context_line, post_context
+
+    def _get_explicit_or_implicit_cause(self, exc_value):
+        explicit = getattr(exc_value, "__cause__", None)
+        suppress_context = getattr(exc_value, "__suppress_context__", None)
+        implicit = getattr(exc_value, "__context__", None)
+        return explicit or (None if suppress_context else implicit)
+
+    def get_traceback_frames(self):
+        # Get the exception and all its causes
+        exceptions = []
+        exc_value = self.exc_value
+        while exc_value:
+            exceptions.append(exc_value)
+            exc_value = self._get_explicit_or_implicit_cause(exc_value)
+            if exc_value in exceptions:
+                warnings.warn(
+                    "Cycle in the exception chain detected: exception '%s' "
+                    "encountered again." % exc_value,
+                    ExceptionCycleWarning,
+                )
+                # Avoid infinite loop if there's a cyclic reference (#29393).
+                break
+
+        frames = []
+        # No exceptions were supplied to ExceptionReporter
+        if not exceptions:
+            return frames
+
+        # In case there's just one exception, take the traceback from self.tb
+        exc_value = exceptions.pop()
+        tb = self.tb if not exceptions else exc_value.__traceback__
+        while True:
+            frames.extend(self.get_exception_traceback_frames(exc_value, tb))
+            try:
+                exc_value = exceptions.pop()
+            except IndexError:
+                break
+            tb = exc_value.__traceback__
+        return frames
+
+    def get_exception_traceback_frames(self, exc_value, tb):
+        exc_cause = self._get_explicit_or_implicit_cause(exc_value)
+        exc_cause_explicit = getattr(exc_value, "__cause__", True)
+        if tb is None:
+            yield {
+                "exc_cause": exc_cause,
+                "exc_cause_explicit": exc_cause_explicit,
+                "tb": None,
+                "type": "user",
+            }
+        while tb is not None:
+            # Support for __traceback_hide__ which is used by a few libraries
+            # to hide internal frames.
+            if tb.tb_frame.f_locals.get("__traceback_hide__"):
+                tb = tb.tb_next
+                continue
+            filename = tb.tb_frame.f_code.co_filename
+            function = tb.tb_frame.f_code.co_name
+            lineno = tb.tb_lineno - 1
+            loader = tb.tb_frame.f_globals.get("__loader__")
+            module_name = tb.tb_frame.f_globals.get("__name__") or ""
+            (
+                pre_context_lineno,
+                pre_context,
+                context_line,
+                post_context,
+            ) = self._get_lines_from_file(
+                filename,
+                lineno,
+                7,
+                loader,
+                module_name,
+            )
+            if pre_context_lineno is None:
+                pre_context_lineno = lineno
+                pre_context = []
+                context_line = "<source code not available>"
+                post_context = []
+
+            colno = tb_area_colno = ""
+            if PY311:
+                _, _, start_column, end_column = next(
+                    itertools.islice(
+                        tb.tb_frame.f_code.co_positions(), tb.tb_lasti // 2, None
+                    )
+                )
+                if start_column and end_column:
+                    underline = "^" * (end_column - start_column)
+                    spaces = " " * (start_column + len(str(lineno + 1)) + 2)
+                    colno = f"\n{spaces}{underline}"
+                    tb_area_spaces = " " * (
+                        4
+                        + start_column
+                        - (len(context_line) - len(context_line.lstrip()))
+                    )
+                    tb_area_colno = f"\n{tb_area_spaces}{underline}"
+            yield {
+                "exc_cause": exc_cause,
+                "exc_cause_explicit": exc_cause_explicit,
+                "tb": tb,
+                "type": "django" if module_name.startswith("django.") else "user",
+                "filename": filename,
+                "function": function,
+                "lineno": lineno + 1,
+                "vars": self.filter.get_traceback_frame_variables(
+                    self.request, tb.tb_frame
+                ),
+                "id": id(tb),
+                "pre_context": pre_context,
+                "context_line": context_line,
+                "post_context": post_context,
+                "pre_context_lineno": pre_context_lineno + 1,
+                "colno": colno,
+                "tb_area_colno": tb_area_colno,
+            }
+            tb = tb.tb_next
+
+
+def technical_404_response(request, exception):
+    """Create a technical 404 error response. `exception` is the Http404."""
+    try:
+        error_url = exception.args[0]["path"]
+    except (IndexError, TypeError, KeyError):
+        error_url = request.path_info[1:]  # Trim leading slash
+
+    try:
+        tried = exception.args[0]["tried"]
+    except (IndexError, TypeError, KeyError):
+        resolved = True
+        tried = request.resolver_match.tried if request.resolver_match else None
+    else:
+        resolved = False
+        if not tried or (  # empty URLconf
+            request.path == "/"
+            and len(tried) == 1
+            and len(tried[0]) == 1  # default URLconf
+            and getattr(tried[0][0], "app_name", "")
+            == getattr(tried[0][0], "namespace", "")
+            == "admin"
+        ):
+            return default_urlconf(request)
+
+    urlconf = getattr(request, "urlconf", settings.ROOT_URLCONF)
+    if isinstance(urlconf, types.ModuleType):
+        urlconf = urlconf.__name__
+
+    with builtin_template_path("technical_404.html").open(encoding="utf-8") as fh:
+        t = DEBUG_ENGINE.from_string(fh.read())
+    reporter_filter = get_default_exception_reporter_filter()
+    c = Context(
+        {
+            "urlconf": urlconf,
+            "root_urlconf": settings.ROOT_URLCONF,
+            "request_path": error_url,
+            "urlpatterns": tried,
+            "resolved": resolved,
+            "reason": str(exception),
+            "request": request,
+            "settings": reporter_filter.get_safe_settings(),
+            "raising_view_name": get_caller(request),
+        }
+    )
+    return HttpResponseNotFound(t.render(c))
+
+
+def default_urlconf(request):
+    """Create an empty URLconf 404 error response."""
+    with builtin_template_path("default_urlconf.html").open(encoding="utf-8") as fh:
+        t = DEBUG_ENGINE.from_string(fh.read())
+    c = Context(
+        {
+            "version": get_docs_version(),
+        }
+    )
+
+    return HttpResponse(t.render(c))

testbed/django__django/django/views/decorators/clickjacking.py

@@ -0,0 +1,90 @@
+from functools import wraps
+
+from asgiref.sync import iscoroutinefunction
+
+
+def xframe_options_deny(view_func):
+    """
+    Modify a view function so its response has the X-Frame-Options HTTP
+    header set to 'DENY' as long as the response doesn't already have that
+    header set. Usage:
+
+    @xframe_options_deny
+    def some_view(request):
+        ...
+    """
+
+    if iscoroutinefunction(view_func):
+
+        async def _view_wrapper(*args, **kwargs):
+            response = await view_func(*args, **kwargs)
+            if response.get("X-Frame-Options") is None:
+                response["X-Frame-Options"] = "DENY"
+            return response
+
+    else:
+
+        def _view_wrapper(*args, **kwargs):
+            response = view_func(*args, **kwargs)
+            if response.get("X-Frame-Options") is None:
+                response["X-Frame-Options"] = "DENY"
+            return response
+
+    return wraps(view_func)(_view_wrapper)
+
+
+def xframe_options_sameorigin(view_func):
+    """
+    Modify a view function so its response has the X-Frame-Options HTTP
+    header set to 'SAMEORIGIN' as long as the response doesn't already have
+    that header set. Usage:
+
+    @xframe_options_sameorigin
+    def some_view(request):
+        ...
+    """
+
+    if iscoroutinefunction(view_func):
+
+        async def _view_wrapper(*args, **kwargs):
+            response = await view_func(*args, **kwargs)
+            if response.get("X-Frame-Options") is None:
+                response["X-Frame-Options"] = "SAMEORIGIN"
+            return response
+
+    else:
+
+        def _view_wrapper(*args, **kwargs):
+            response = view_func(*args, **kwargs)
+            if response.get("X-Frame-Options") is None:
+                response["X-Frame-Options"] = "SAMEORIGIN"
+            return response
+
+    return wraps(view_func)(_view_wrapper)
+
+
+def xframe_options_exempt(view_func):
+    """
+    Modify a view function by setting a response variable that instructs
+    XFrameOptionsMiddleware to NOT set the X-Frame-Options HTTP header. Usage:
+
+    @xframe_options_exempt
+    def some_view(request):
+        ...
+    """
+
+    if iscoroutinefunction(view_func):
+
+        async def _view_wrapper(*args, **kwargs):
+            response = await view_func(*args, **kwargs)
+            response.xframe_options_exempt = True
+            return response
+
+    else:
+
+        def _view_wrapper(*args, **kwargs):
+            response = view_func(*args, **kwargs)
+            response.xframe_options_exempt = True
+            return response
+
+    return wraps(view_func)(_view_wrapper)

testbed/django__django/django/views/decorators/debug.py

@@ -0,0 +1,145 @@
+import inspect
+from functools import wraps
+
+from asgiref.sync import iscoroutinefunction
+
+from django.http import HttpRequest
+
+coroutine_functions_to_sensitive_variables = {}
+
+
+def sensitive_variables(*variables):
+    """
+    Indicate which variables used in the decorated function are sensitive so
+    that those variables can later be treated in a special way, for example
+    by hiding them when logging unhandled exceptions.
+
+    Accept two forms:
+
+    * with specified variable names:
+
+        @sensitive_variables('user', 'password', 'credit_card')
+        def my_function(user):
+            password = user.pass_word
+            credit_card = user.credit_card_number
+            ...
+
+    * without any specified variable names, in which case consider all
+      variables are sensitive:
+
+        @sensitive_variables()
+        def my_function()
+            ...
+    """
+    if len(variables) == 1 and callable(variables[0]):
+        raise TypeError(
+            "sensitive_variables() must be called to use it as a decorator, "
+            "e.g., use @sensitive_variables(), not @sensitive_variables."
+        )
+
+    def decorator(func):
+        if iscoroutinefunction(func):
+            sensitive_variables_wrapper = func
+
+            wrapped_func = func
+            while getattr(wrapped_func, "__wrapped__", None) is not None:
+                wrapped_func = wrapped_func.__wrapped__
+
+            try:
+                file_path = inspect.getfile(wrapped_func)
+                _, first_file_line = inspect.getsourcelines(wrapped_func)
+            except TypeError:  # Raises for builtins or native functions.
+                raise ValueError(
+                    f"{func.__name__} cannot safely be wrapped by "
+                    "@sensitive_variables, make it either non-async or defined in a "
+                    "Python file (not a builtin or from a native extension)."
+                )
+            else:
+                key = hash(f"{file_path}:{first_file_line}")
+
+            if variables:
+                coroutine_functions_to_sensitive_variables[key] = variables
+            else:
+                coroutine_functions_to_sensitive_variables[key] = "__ALL__"
+
+        else:
+
+            @wraps(func)
+            def sensitive_variables_wrapper(*func_args, **func_kwargs):
+                if variables:
+                    sensitive_variables_wrapper.sensitive_variables = variables
+                else:
+                    sensitive_variables_wrapper.sensitive_variables = "__ALL__"
+                return func(*func_args, **func_kwargs)
+
+        return sensitive_variables_wrapper
+
+    return decorator
+
+
+def sensitive_post_parameters(*parameters):
+    """
+    Indicate which POST parameters used in the decorated view are sensitive,
+    so that those parameters can later be treated in a special way, for example
+    by hiding them when logging unhandled exceptions.
+
+    Accept two forms:
+
+    * with specified parameters:
+
+        @sensitive_post_parameters('password', 'credit_card')
+        def my_view(request):
+            pw = request.POST['password']
+            cc = request.POST['credit_card']
+            ...
+
+    * without any specified parameters, in which case consider all
+      variables are sensitive:
+
+        @sensitive_post_parameters()
+        def my_view(request)
+            ...
+    """
+    if len(parameters) == 1 and callable(parameters[0]):
+        raise TypeError(
+            "sensitive_post_parameters() must be called to use it as a "
+            "decorator, e.g., use @sensitive_post_parameters(), not "
+            "@sensitive_post_parameters."
+        )
+
+    def decorator(view):
+        if iscoroutinefunction(view):
+
+            @wraps(view)
+            async def sensitive_post_parameters_wrapper(request, *args, **kwargs):
+                if not isinstance(request, HttpRequest):
+                    raise TypeError(
+                        "sensitive_post_parameters didn't receive an HttpRequest "
+                        "object. If you are decorating a classmethod, make sure to use "
+                        "@method_decorator."
+                    )
+                if parameters:
+                    request.sensitive_post_parameters = parameters
+                else:
+                    request.sensitive_post_parameters = "__ALL__"
+                return await view(request, *args, **kwargs)
+
+        else:
+
+            @wraps(view)
+            def sensitive_post_parameters_wrapper(request, *args, **kwargs):
+                if not isinstance(request, HttpRequest):
+                    raise TypeError(
+                        "sensitive_post_parameters didn't receive an HttpRequest "
+                        "object. If you are decorating a classmethod, make sure to use "
+                        "@method_decorator."
+                    )
+                if parameters:
+                    request.sensitive_post_parameters = parameters
+                else:
+                    request.sensitive_post_parameters = "__ALL__"
+                return view(request, *args, **kwargs)
+
+        return sensitive_post_parameters_wrapper
+
+    return decorator

testbed/django__django/django/views/decorators/vary.py

@@ -0,0 +1,44 @@
+from functools import wraps
+
+from asgiref.sync import iscoroutinefunction
+
+from django.utils.cache import patch_vary_headers
+
+
+def vary_on_headers(*headers):
+    """
+    A view decorator that adds the specified headers to the Vary header of the
+    response. Usage:
+
+       @vary_on_headers('Cookie', 'Accept-language')
+       def index(request):
+           ...
+
+    Note that the header names are not case-sensitive.
+    """
+
+    def decorator(func):
+        if iscoroutinefunction(func):
+
+            async def _view_wrapper(request, *args, **kwargs):
+                response = await func(request, *args, **kwargs)
+                patch_vary_headers(response, headers)
+                return response
+
+        else:
+
+            def _view_wrapper(request, *args, **kwargs):
+                response = func(request, *args, **kwargs)
+                patch_vary_headers(response, headers)
+                return response
+
+        return wraps(func)(_view_wrapper)
+
+    return decorator
+
+
+vary_on_cookie = vary_on_headers("Cookie")
+vary_on_cookie.__doc__ = (
+    'A view decorator that adds "Cookie" to the Vary header of a response. This '
+    "indicates that a page's contents depends on cookies."
+)

testbed/django__django/django/views/generic/__init__.py

@@ -0,0 +1,39 @@
+from django.views.generic.base import RedirectView, TemplateView, View
+from django.views.generic.dates import (
+    ArchiveIndexView,
+    DateDetailView,
+    DayArchiveView,
+    MonthArchiveView,
+    TodayArchiveView,
+    WeekArchiveView,
+    YearArchiveView,
+)
+from django.views.generic.detail import DetailView
+from django.views.generic.edit import CreateView, DeleteView, FormView, UpdateView
+from django.views.generic.list import ListView
+
+__all__ = [
+    "View",
+    "TemplateView",
+    "RedirectView",
+    "ArchiveIndexView",
+    "YearArchiveView",
+    "MonthArchiveView",
+    "WeekArchiveView",
+    "DayArchiveView",
+    "TodayArchiveView",
+    "DateDetailView",
+    "DetailView",
+    "FormView",
+    "CreateView",
+    "UpdateView",
+    "DeleteView",
+    "ListView",
+    "GenericViewError",
+]
+
+
+class GenericViewError(Exception):
+    """A problem in a generic view."""
+
+    pass

testbed/django__django/django/views/generic/dates.py

@@ -0,0 +1,795 @@
+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 YearMixin:
+    """Mixin for views manipulating year-based data."""
+
+    year_format = "%Y"
+    year = None
+
+    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 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_next_year(self, date):
+        """Get the next valid year."""
+        return _get_next_prev(self, date, is_previous=False, period="year")
+
+    def get_previous_year(self, date):
+        """Get the previous valid year."""
+        return _get_next_prev(self, date, is_previous=True, period="year")
+
+    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_current_year(self, date):
+        """Return the start date of the current interval."""
+        return date.replace(month=1, day=1)
+
+
+class MonthMixin:
+    """Mixin for views manipulating month-based data."""
+
+    month_format = "%b"
+    month = None
+
+    def get_month_format(self):
+        """
+        Get a month format string in strptime syntax to be used to parse the
+        month from url variables.
+        """
+        return self.month_format
+
+    def get_month(self):
+        """Return the month for which this view should display data."""
+        month = self.month
+        if month is None:
+            try:
+                month = self.kwargs["month"]
+            except KeyError:
+                try:
+                    month = self.request.GET["month"]
+                except KeyError:
+                    raise Http404(_("No month specified"))
+        return month
+
+    def get_next_month(self, date):
+        """Get the next valid month."""
+        return _get_next_prev(self, date, is_previous=False, period="month")
+
+    def get_previous_month(self, date):
+        """Get the previous valid month."""
+        return _get_next_prev(self, date, is_previous=True, period="month")
+
+    def _get_next_month(self, date):
+        """
+        Return the start date of the next interval.
+
+        The interval is defined by start date <= item date < next start date.
+        """
+        if date.month == 12:
+            try:
+                return date.replace(year=date.year + 1, month=1, day=1)
+            except ValueError:
+                raise Http404(_("Date out of range"))
+        else:
+            return date.replace(month=date.month + 1, day=1)
+
+    def _get_current_month(self, date):
+        """Return the start date of the previous interval."""
+        return date.replace(day=1)
+
+
+class DayMixin:
+    """Mixin for views manipulating day-based data."""
+
+    day_format = "%d"
+    day = None
+
+    def get_day_format(self):
+        """
+        Get a day format string in strptime syntax to be used to parse the day
+        from url variables.
+        """
+        return self.day_format
+
+    def get_day(self):
+        """Return the day for which this view should display data."""
+        day = self.day
+        if day is None:
+            try:
+                day = self.kwargs["day"]
+            except KeyError:
+                try:
+                    day = self.request.GET["day"]
+                except KeyError:
+                    raise Http404(_("No day specified"))
+        return day
+
+    def get_next_day(self, date):
+        """Get the next valid day."""
+        return _get_next_prev(self, date, is_previous=False, period="day")
+
+    def get_previous_day(self, date):
+        """Get the previous valid day."""
+        return _get_next_prev(self, date, is_previous=True, period="day")
+
+    def _get_next_day(self, date):
+        """
+        Return the start date of the next interval.
+
+        The interval is defined by start date <= item date < next start date.
+        """
+        return date + datetime.timedelta(days=1)
+
+    def _get_current_day(self, date):
+        """Return the start date of the current interval."""
+        return date
+
+
+class WeekMixin:
+    """Mixin for views manipulating week-based data."""
+
+    week_format = "%U"
+    week = None
+
+    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_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_next_week(self, date):
+        """Get the next valid week."""
+        return _get_next_prev(self, date, is_previous=False, period="week")
+
+    def get_previous_week(self, date):
+        """Get the previous valid week."""
+        return _get_next_prev(self, date, is_previous=True, period="week")
+
+    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_current_week(self, date):
+        """Return the start date of the current interval."""
+        return date - datetime.timedelta(self._get_weekday(date))
+
+    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)
+
+
+class DateMixin:
+    """Mixin class for views manipulating date-based data."""
+
+    date_field = None
+    allow_future = False
+
+    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_allow_future(self):
+        """
+        Return `True` if the view should be allowed to display objects from
+        the future.
+        """
+        return self.allow_future
+
+    # Note: the following three methods only work in subclasses that also
+    # inherit SingleObjectMixin or MultipleObjectMixin.
+
+    @cached_property
+    def uses_datetime_field(self):
+        """
+        Return `True` if the date field is a `DateTimeField` and `False`
+        if it's a `DateField`.
+        """
+        model = self.get_queryset().model if self.model is None else self.model
+        field = model._meta.get_field(self.get_date_field())
+        return isinstance(field, models.DateTimeField)
+
+    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):
+        """
+        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}
+
+
+class BaseDateListView(MultipleObjectMixin, DateMixin, View):
+    """Abstract base class for date-based views displaying a list of objects."""
+
+    allow_empty = False
+    date_list_period = "year"
+
+    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_dated_items(self):
+        """Obtain the list of dates and items."""
+        raise NotImplementedError(
+            "A DateView must provide an implementation of get_dated_items()"
+        )
+
+    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
+
+    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_date_list_period(self):
+        """
+        Get the aggregation period for the list of dates: 'year', 'month', or
+        'day'.
+        """
+        return self.date_list_period
+
+    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
+
+
+class BaseArchiveIndexView(BaseDateListView):
+    """
+    Base class for archives of date-based items. Requires a response mixin.
+    """
+
+    context_object_name = "latest"
+
+    def get_dated_items(self):
+        """Return (date_list, items, extra_context) for this request."""
+        qs = self.get_dated_queryset()
+        date_list = self.get_date_list(qs, ordering="DESC")
+
+        if not date_list:
+            qs = qs.none()
+
+        return (date_list, qs, {})
+
+
+class ArchiveIndexView(MultipleObjectTemplateResponseMixin, BaseArchiveIndexView):
+    """Top-level archive of date-based items."""
+
+    template_name_suffix = "_archive"
+
+
+class BaseYearArchiveView(YearMixin, BaseDateListView):
+    """List of objects published in a given year."""
+
+    date_list_period = "month"
+    make_object_list = False
+
+    def get_dated_items(self):
+        """Return (date_list, items, extra_context) for this request."""
+        year = self.get_year()
+
+        date_field = self.get_date_field()
+        date = _date_from_string(year, self.get_year_format())
+
+        since = self._make_date_lookup_arg(date)
+        until = self._make_date_lookup_arg(self._get_next_year(date))
+        lookup_kwargs = {
+            "%s__gte" % date_field: since,
+            "%s__lt" % date_field: until,
+        }
+
+        qs = self.get_dated_queryset(**lookup_kwargs)
+        date_list = self.get_date_list(qs)
+
+        if not self.get_make_object_list():
+            # We need this to be a queryset since parent classes introspect it
+            # to find information about the model.
+            qs = qs.none()
+
+        return (
+            date_list,
+            qs,
+            {
+                "year": date,
+                "next_year": self.get_next_year(date),
+                "previous_year": self.get_previous_year(date),
+            },
+        )
+
+    def get_make_object_list(self):
+        """
+        Return `True` if this view should contain the full list of objects in
+        the given year.
+        """
+        return self.make_object_list
+
+
+class YearArchiveView(MultipleObjectTemplateResponseMixin, BaseYearArchiveView):
+    """List of objects published in a given year."""
+
+    template_name_suffix = "_archive_year"
+
+
+class BaseMonthArchiveView(YearMixin, MonthMixin, BaseDateListView):
+    """List of objects published in a given month."""
+
+    date_list_period = "day"
+
+    def get_dated_items(self):
+        """Return (date_list, items, extra_context) for this request."""
+        year = self.get_year()
+        month = self.get_month()
+
+        date_field = self.get_date_field()
+        date = _date_from_string(
+            year, self.get_year_format(), month, self.get_month_format()
+        )
+
+        since = self._make_date_lookup_arg(date)
+        until = self._make_date_lookup_arg(self._get_next_month(date))
+        lookup_kwargs = {
+            "%s__gte" % date_field: since,
+            "%s__lt" % date_field: until,
+        }
+
+        qs = self.get_dated_queryset(**lookup_kwargs)
+        date_list = self.get_date_list(qs)
+
+        return (
+            date_list,
+            qs,
+            {
+                "month": date,
+                "next_month": self.get_next_month(date),
+                "previous_month": self.get_previous_month(date),
+            },
+        )
+
+
+class MonthArchiveView(MultipleObjectTemplateResponseMixin, BaseMonthArchiveView):
+    """List of objects published in a given month."""
+
+    template_name_suffix = "_archive_month"
+
+
+class BaseWeekArchiveView(YearMixin, WeekMixin, BaseDateListView):
+    """List of objects published in a given week."""
+
+    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),
+            },
+        )
+
+
+class WeekArchiveView(MultipleObjectTemplateResponseMixin, BaseWeekArchiveView):
+    """List of objects published in a given week."""
+
+    template_name_suffix = "_archive_week"
+
+
+class BaseDayArchiveView(YearMixin, MonthMixin, DayMixin, BaseDateListView):
+    """List of objects published on a given day."""
+
+    def get_dated_items(self):
+        """Return (date_list, items, extra_context) for this request."""
+        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(),
+        )
+
+        return self._get_dated_items(date)
+
+    def _get_dated_items(self, date):
+        """
+        Do the actual heavy lifting of getting the dated items; this accepts a
+        date object so that TodayArchiveView can be trivial.
+        """
+        lookup_kwargs = self._make_single_date_lookup(date)
+        qs = self.get_dated_queryset(**lookup_kwargs)
+
+        return (
+            None,
+            qs,
+            {
+                "day": date,
+                "previous_day": self.get_previous_day(date),
+                "next_day": self.get_next_day(date),
+                "previous_month": self.get_previous_month(date),
+                "next_month": self.get_next_month(date),
+            },
+        )
+
+
+class DayArchiveView(MultipleObjectTemplateResponseMixin, BaseDayArchiveView):
+    """List of objects published on a given day."""
+
+    template_name_suffix = "_archive_day"
+
+
+class BaseTodayArchiveView(BaseDayArchiveView):
+    """List of objects published today."""
+
+    def get_dated_items(self):
+        """Return (date_list, items, extra_context) for this request."""
+        return self._get_dated_items(datetime.date.today())
+
+
+class TodayArchiveView(MultipleObjectTemplateResponseMixin, BaseTodayArchiveView):
+    """List of objects published today."""
+
+    template_name_suffix = "_archive_day"
+
+
+class BaseDateDetailView(YearMixin, MonthMixin, DayMixin, DateMixin, BaseDetailView):
+    """
+    Detail view of a single object on a single date; this differs from the
+    standard DetailView by accepting a year/month/day in the URL.
+    """
+
+    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)
+
+
+class DateDetailView(SingleObjectTemplateResponseMixin, BaseDateDetailView):
+    """
+    Detail view of a single object on a single date; this differs from the
+    standard DetailView by accepting a year/month/day in the URL.
+    """
+
+    template_name_suffix = "_detail"
+
+
+def _date_from_string(
+    year, year_format, month="", month_format="", day="", day_format="", delim="__"
+):
+    """
+    Get a datetime.date object given a format string and a year, month, and day
+    (only year is mandatory). Raise a 404 for an invalid date.
+    """
+    format = year_format + delim + month_format + delim + day_format
+    datestr = str(year) + delim + str(month) + delim + str(day)
+    try:
+        return datetime.datetime.strptime(datestr, format).date()
+    except ValueError:
+        raise Http404(
+            _("Invalid date string “%(datestr)s” given format “%(format)s”")
+            % {
+                "datestr": datestr,
+                "format": format,
+            }
+        )
+
+
+def _get_next_prev(generic_view, date, is_previous, period):
+    """
+    Get the next or the previous valid date. The idea is to allow links on
+    month/day views to never be 404s by never providing a date that'll be
+    invalid for the given view.
+
+    This is a bit complicated since it handles different intervals of time,
+    hence the coupling to generic_view.
+
+    However in essence the logic comes down to:
+
+        * If allow_empty and allow_future are both true, this is easy: just
+          return the naive result (just the next/previous day/week/month,
+          regardless of object existence.)
+
+        * If allow_empty is true, allow_future is false, and the naive result
+          isn't in the future, then return it; otherwise return None.
+
+        * If allow_empty is false and allow_future is true, return the next
+          date *that contains a valid object*, even if it's in the future. If
+          there are no next objects, return None.
+
+        * If allow_empty is false and allow_future is false, return the next
+          date that contains a valid object. If that date is in the future, or
+          if there are no next objects, return None.
+    """
+    date_field = generic_view.get_date_field()
+    allow_empty = generic_view.get_allow_empty()
+    allow_future = generic_view.get_allow_future()
+
+    get_current = getattr(generic_view, "_get_current_%s" % period)
+    get_next = getattr(generic_view, "_get_next_%s" % period)
+
+    # Bounds of the current interval
+    start, end = get_current(date), get_next(date)
+
+    # If allow_empty is True, the naive result will be valid
+    if allow_empty:
+        if is_previous:
+            result = get_current(start - datetime.timedelta(days=1))
+        else:
+            result = end
+
+        if allow_future or result <= timezone_today():
+            return result
+        else:
+            return None
+
+    # Otherwise, we'll need to go to the database to look for an object
+    # whose date_field is at least (greater than/less than) the given
+    # naive result
+    else:
+        # Construct a lookup and an ordering depending on whether we're doing
+        # a previous date or a next date lookup.
+        if is_previous:
+            lookup = {"%s__lt" % date_field: generic_view._make_date_lookup_arg(start)}
+            ordering = "-%s" % date_field
+        else:
+            lookup = {"%s__gte" % date_field: generic_view._make_date_lookup_arg(end)}
+            ordering = date_field
+
+        # Filter out objects in the future if appropriate.
+        if not allow_future:
+            # Fortunately, to match the implementation of allow_future,
+            # we need __lte, which doesn't conflict with __lt above.
+            if generic_view.uses_datetime_field:
+                now = timezone.now()
+            else:
+                now = timezone_today()
+            lookup["%s__lte" % date_field] = now
+
+        qs = generic_view.get_queryset().filter(**lookup).order_by(ordering)
+
+        # Snag the first object from the queryset; if it doesn't exist that
+        # means there's no next/previous link available.
+        try:
+            result = getattr(qs[0], date_field)
+        except IndexError:
+            return None
+
+        # Convert datetimes to dates in the current time zone.
+        if generic_view.uses_datetime_field:
+            if settings.USE_TZ:
+                result = timezone.localtime(result)
+            result = result.date()
+
+        # Return the first day of the period.
+        return get_current(result)
+
+
+def timezone_today():
+    """Return the current date in the current time zone."""
+    if settings.USE_TZ:
+        return timezone.localdate()
+    else:
+        return datetime.date.today()

testbed/django__django/django/views/generic/edit.py

@@ -0,0 +1,274 @@
+from django.core.exceptions import ImproperlyConfigured
+from django.forms import Form
+from django.forms import models as model_forms
+from django.http import HttpResponseRedirect
+from django.views.generic.base import ContextMixin, TemplateResponseMixin, View
+from django.views.generic.detail import (
+    BaseDetailView,
+    SingleObjectMixin,
+    SingleObjectTemplateResponseMixin,
+)
+
+
+class FormMixin(ContextMixin):
+    """Provide a way to show and handle a form in a request."""
+
+    initial = {}
+    form_class = None
+    success_url = None
+    prefix = None
+
+    def get_initial(self):
+        """Return the initial data to use for forms on this view."""
+        return self.initial.copy()
+
+    def get_prefix(self):
+        """Return the prefix to use for forms."""
+        return self.prefix
+
+    def get_form_class(self):
+        """Return the form class to use."""
+        return self.form_class
+
+    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_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_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 form_valid(self, form):
+        """If the form is valid, redirect to the supplied URL."""
+        return HttpResponseRedirect(self.get_success_url())
+
+    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 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)
+
+
+class ModelFormMixin(FormMixin, SingleObjectMixin):
+    """Provide a way to show and handle a ModelForm in a request."""
+
+    fields = None
+
+    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)
+
+    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
+
+    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
+
+    def form_valid(self, form):
+        """If the form is valid, save the associated model."""
+        self.object = form.save()
+        return super().form_valid(form)
+
+
+class ProcessFormView(View):
+    """Render a form on GET and processes it on POST."""
+
+    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 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)
+
+    # PUT is a valid HTTP verb for creating (with a known URL) or editing an
+    # object, note that browsers only support POST for now.
+    def put(self, *args, **kwargs):
+        return self.post(*args, **kwargs)
+
+
+class BaseFormView(FormMixin, ProcessFormView):
+    """A base view for displaying a form."""
+
+
+class FormView(TemplateResponseMixin, BaseFormView):
+    """A view for displaying a form and rendering a template response."""
+
+
+class BaseCreateView(ModelFormMixin, ProcessFormView):
+    """
+    Base view for creating a new object instance.
+
+    Using this base class requires subclassing to provide a response mixin.
+    """
+
+    def get(self, request, *args, **kwargs):
+        self.object = None
+        return super().get(request, *args, **kwargs)
+
+    def post(self, request, *args, **kwargs):
+        self.object = None
+        return super().post(request, *args, **kwargs)
+
+
+class CreateView(SingleObjectTemplateResponseMixin, BaseCreateView):
+    """
+    View for creating a new object, with a response rendered by a template.
+    """
+
+    template_name_suffix = "_form"
+
+
+class BaseUpdateView(ModelFormMixin, ProcessFormView):
+    """
+    Base view for updating an existing object.
+
+    Using this base class requires subclassing to provide a response mixin.
+    """
+
+    def get(self, request, *args, **kwargs):
+        self.object = self.get_object()
+        return super().get(request, *args, **kwargs)
+
+    def post(self, request, *args, **kwargs):
+        self.object = self.get_object()
+        return super().post(request, *args, **kwargs)
+
+
+class UpdateView(SingleObjectTemplateResponseMixin, BaseUpdateView):
+    """View for updating an object, with a response rendered by a template."""
+
+    template_name_suffix = "_form"
+
+
+class DeletionMixin:
+    """Provide the ability to delete objects."""
+
+    success_url = None
+
+    def delete(self, request, *args, **kwargs):
+        """
+        Call the delete() method on the fetched object and then redirect to the
+        success URL.
+        """
+        self.object = self.get_object()
+        success_url = self.get_success_url()
+        self.object.delete()
+        return HttpResponseRedirect(success_url)
+
+    # Add support for browsers which only accept GET and POST for now.
+    def post(self, request, *args, **kwargs):
+        return self.delete(request, *args, **kwargs)
+
+    def get_success_url(self):
+        if self.success_url:
+            return self.success_url.format(**self.object.__dict__)
+        else:
+            raise ImproperlyConfigured("No URL to redirect to. Provide a success_url.")
+
+
+class BaseDeleteView(DeletionMixin, FormMixin, BaseDetailView):
+    """
+    Base view for deleting an object.
+
+    Using this base class requires subclassing to provide a response mixin.
+    """
+
+    form_class = Form
+
+    def post(self, request, *args, **kwargs):
+        # Set self.object before the usual form processing flow.
+        # Inlined because having DeletionMixin as the first base, for
+        # get_success_url(), makes leveraging super() with ProcessFormView
+        # overly complex.
+        self.object = self.get_object()
+        form = self.get_form()
+        if form.is_valid():
+            return self.form_valid(form)
+        else:
+            return self.form_invalid(form)
+
+    def form_valid(self, form):
+        success_url = self.get_success_url()
+        self.object.delete()
+        return HttpResponseRedirect(success_url)
+
+
+class DeleteView(SingleObjectTemplateResponseMixin, BaseDeleteView):
+    """
+    View for deleting an object retrieved with self.get_object(), with a
+    response rendered by a template.
+    """
+
+    template_name_suffix = "_confirm_delete"

testbed/django__django/django/views/generic/list.py

@@ -0,0 +1,220 @@
+from django.core.exceptions import ImproperlyConfigured
+from django.core.paginator import InvalidPage, Paginator
+from django.db.models import QuerySet
+from django.http import Http404
+from django.utils.translation import gettext as _
+from django.views.generic.base import ContextMixin, TemplateResponseMixin, View
+
+
+class MultipleObjectMixin(ContextMixin):
+    """A mixin for views manipulating multiple objects."""
+
+    allow_empty = True
+    queryset = None
+    model = None
+    paginate_by = None
+    paginate_orphans = 0
+    context_object_name = None
+    paginator_class = Paginator
+    page_kwarg = "page"
+    ordering = None
+
+    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_ordering(self):
+        """Return the field or fields to use for ordering the queryset."""
+        return self.ordering
+
+    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 get_paginate_by(self, queryset):
+        """
+        Get the number of items to paginate by, or ``None`` for no pagination.
+        """
+        return self.paginate_by
+
+    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_paginate_orphans(self):
+        """
+        Return the maximum number of orphans extend the last page by when
+        paginating.
+        """
+        return self.paginate_orphans
+
+    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_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_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)
+
+
+class BaseListView(MultipleObjectMixin, View):
+    """A base view for displaying a list of objects."""
+
+    def get(self, request, *args, **kwargs):
+        self.object_list = self.get_queryset()
+        allow_empty = self.get_allow_empty()
+
+        if not allow_empty:
+            # When pagination is enabled and object_list is a queryset,
+            # it's better to do a cheap query than to load the unpaginated
+            # queryset in memory.
+            if self.get_paginate_by(self.object_list) is not None and hasattr(
+                self.object_list, "exists"
+            ):
+                is_empty = not self.object_list.exists()
+            else:
+                is_empty = not self.object_list
+            if is_empty:
+                raise Http404(
+                    _("Empty list and “%(class_name)s.allow_empty” is False.")
+                    % {
+                        "class_name": self.__class__.__name__,
+                    }
+                )
+        context = self.get_context_data()
+        return self.render_to_response(context)
+
+
+class MultipleObjectTemplateResponseMixin(TemplateResponseMixin):
+    """Mixin for responding with a template and list of objects."""
+
+    template_name_suffix = "_list"
+
+    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
+
+
+class ListView(MultipleObjectTemplateResponseMixin, BaseListView):
+    """
+    Render some list of objects, set by `self.model` or `self.queryset`.
+    `self.queryset` can actually be any iterable of items, not just a queryset.
+    """

testbed/django__django/django/views/i18n.py

@@ -0,0 +1,251 @@
+import json
+import os
+import re
+from pathlib import Path
+
+from django.apps import apps
+from django.conf import settings
+from django.http import HttpResponse, HttpResponseRedirect, JsonResponse
+from django.template import Context, Engine
+from django.urls import translate_url
+from django.utils.formats import get_format
+from django.utils.http import url_has_allowed_host_and_scheme
+from django.utils.translation import check_for_language, get_language
+from django.utils.translation.trans_real import DjangoTranslation
+from django.views.generic import View
+
+LANGUAGE_QUERY_PARAMETER = "language"
+
+
+def builtin_template_path(name):
+    """
+    Return a path to a builtin template.
+
+    Avoid calling this function at the module level or in a class-definition
+    because __file__ may not exist, e.g. in frozen environments.
+    """
+    return Path(__file__).parent / "templates" / name
+
+
+def set_language(request):
+    """
+    Redirect to a given URL while setting the chosen language in the session
+    (if enabled) and in a cookie. The URL and the language code need to be
+    specified in the request parameters.
+
+    Since this view changes how the user will see the rest of the site, it must
+    only be accessed as a POST request. If called as a GET request, it will
+    redirect to the page in the request (the 'next' parameter) without changing
+    any state.
+    """
+    next_url = request.POST.get("next", request.GET.get("next"))
+    if (
+        next_url or request.accepts("text/html")
+    ) and not url_has_allowed_host_and_scheme(
+        url=next_url,
+        allowed_hosts={request.get_host()},
+        require_https=request.is_secure(),
+    ):
+        next_url = request.META.get("HTTP_REFERER")
+        if not url_has_allowed_host_and_scheme(
+            url=next_url,
+            allowed_hosts={request.get_host()},
+            require_https=request.is_secure(),
+        ):
+            next_url = "/"
+    response = HttpResponseRedirect(next_url) if next_url else HttpResponse(status=204)
+    if request.method == "POST":
+        lang_code = request.POST.get(LANGUAGE_QUERY_PARAMETER)
+        if lang_code and check_for_language(lang_code):
+            if next_url:
+                next_trans = translate_url(next_url, lang_code)
+                if next_trans != next_url:
+                    response = HttpResponseRedirect(next_trans)
+            response.set_cookie(
+                settings.LANGUAGE_COOKIE_NAME,
+                lang_code,
+                max_age=settings.LANGUAGE_COOKIE_AGE,
+                path=settings.LANGUAGE_COOKIE_PATH,
+                domain=settings.LANGUAGE_COOKIE_DOMAIN,
+                secure=settings.LANGUAGE_COOKIE_SECURE,
+                httponly=settings.LANGUAGE_COOKIE_HTTPONLY,
+                samesite=settings.LANGUAGE_COOKIE_SAMESITE,
+            )
+    return response
+
+
+def get_formats():
+    """Return all formats strings required for i18n to work."""
+    FORMAT_SETTINGS = (
+        "DATE_FORMAT",
+        "DATETIME_FORMAT",
+        "TIME_FORMAT",
+        "YEAR_MONTH_FORMAT",
+        "MONTH_DAY_FORMAT",
+        "SHORT_DATE_FORMAT",
+        "SHORT_DATETIME_FORMAT",
+        "FIRST_DAY_OF_WEEK",
+        "DECIMAL_SEPARATOR",
+        "THOUSAND_SEPARATOR",
+        "NUMBER_GROUPING",
+        "DATE_INPUT_FORMATS",
+        "TIME_INPUT_FORMATS",
+        "DATETIME_INPUT_FORMATS",
+    )
+    return {attr: get_format(attr) for attr in FORMAT_SETTINGS}
+
+
+class JavaScriptCatalog(View):
+    """
+    Return the selected language catalog as a JavaScript library.
+
+    Receive the list of packages to check for translations in the `packages`
+    kwarg either from the extra dictionary passed to the path() function or as
+    a plus-sign delimited string from the request. Default is 'django.conf'.
+
+    You can override the gettext domain for this view, but usually you don't
+    want to do that as JavaScript messages go to the djangojs domain. This
+    might be needed if you deliver your JavaScript source from Django templates.
+    """
+
+    domain = "djangojs"
+    packages = None
+
+    def get(self, request, *args, **kwargs):
+        locale = get_language()
+        domain = kwargs.get("domain", self.domain)
+        # If packages are not provided, default to all installed packages, as
+        # DjangoTranslation without localedirs harvests them all.
+        packages = kwargs.get("packages", "")
+        packages = packages.split("+") if packages else self.packages
+        paths = self.get_paths(packages) if packages else None
+        self.translation = DjangoTranslation(locale, domain=domain, localedirs=paths)
+        context = self.get_context_data(**kwargs)
+        return self.render_to_response(context)
+
+    def get_paths(self, packages):
+        allowable_packages = {
+            app_config.name: app_config for app_config in apps.get_app_configs()
+        }
+        app_configs = [
+            allowable_packages[p] for p in packages if p in allowable_packages
+        ]
+        if len(app_configs) < len(packages):
+            excluded = [p for p in packages if p not in allowable_packages]
+            raise ValueError(
+                "Invalid package(s) provided to JavaScriptCatalog: %s"
+                % ",".join(excluded)
+            )
+        # paths of requested packages
+        return [os.path.join(app.path, "locale") for app in app_configs]
+
+    @property
+    def _num_plurals(self):
+        """
+        Return the number of plurals for this catalog language, or 2 if no
+        plural string is available.
+        """
+        match = re.search(r"nplurals=\s*(\d+)", self._plural_string or "")
+        if match:
+            return int(match[1])
+        return 2
+
+    @property
+    def _plural_string(self):
+        """
+        Return the plural string (including nplurals) for this catalog language,
+        or None if no plural string is available.
+        """
+        if "" in self.translation._catalog:
+            for line in self.translation._catalog[""].split("\n"):
+                if line.startswith("Plural-Forms:"):
+                    return line.split(":", 1)[1].strip()
+        return None
+
+    def get_plural(self):
+        plural = self._plural_string
+        if plural is not None:
+            # This should be a compiled function of a typical plural-form:
+            # Plural-Forms: nplurals=3; plural=n%10==1 && n%100!=11 ? 0 :
+            #               n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2;
+            plural = [
+                el.strip()
+                for el in plural.split(";")
+                if el.strip().startswith("plural=")
+            ][0].split("=", 1)[1]
+        return plural
+
+    def get_catalog(self):
+        pdict = {}
+        catalog = {}
+        translation = self.translation
+        seen_keys = set()
+        while True:
+            for key, value in translation._catalog.items():
+                if key == "" or key in seen_keys:
+                    continue
+                if isinstance(key, str):
+                    catalog[key] = value
+                elif isinstance(key, tuple):
+                    msgid, cnt = key
+                    pdict.setdefault(msgid, {})[cnt] = value
+                else:
+                    raise TypeError(key)
+                seen_keys.add(key)
+            if translation._fallback:
+                translation = translation._fallback
+            else:
+                break
+
+        num_plurals = self._num_plurals
+        for k, v in pdict.items():
+            catalog[k] = [v.get(i, "") for i in range(num_plurals)]
+        return catalog
+
+    def get_context_data(self, **kwargs):
+        return {
+            "catalog": self.get_catalog(),
+            "formats": get_formats(),
+            "plural": self.get_plural(),
+        }
+
+    def render_to_response(self, context, **response_kwargs):
+        def indent(s):
+            return s.replace("\n", "\n  ")
+
+        with builtin_template_path("i18n_catalog.js").open(encoding="utf-8") as fh:
+            template = Engine().from_string(fh.read())
+        context["catalog_str"] = (
+            indent(json.dumps(context["catalog"], sort_keys=True, indent=2))
+            if context["catalog"]
+            else None
+        )
+        context["formats_str"] = indent(
+            json.dumps(context["formats"], sort_keys=True, indent=2)
+        )
+
+        return HttpResponse(
+            template.render(Context(context)), 'text/javascript; charset="utf-8"'
+        )
+
+
+class JSONCatalog(JavaScriptCatalog):
+    """
+    Return the selected language catalog as a JSON object.
+
+    Receive the same parameters as JavaScriptCatalog and return a response
+    with a JSON object of the following format:
+
+        {
+            "catalog": {
+                # Translations catalog
+            },
+            "formats": {
+                # Language formats for date, time, etc.
+            },
+            "plural": '...'  # Expression for plural forms, or null.
+        }
+    """
+
+    def render_to_response(self, context, **response_kwargs):
+        return JsonResponse(context)

testbed/django__django/django/views/static.py

@@ -0,0 +1,121 @@
+"""
+Views and functions for serving static files. These are only to be used
+during development, and SHOULD NOT be used in a production setting.
+"""
+import mimetypes
+import posixpath
+from pathlib import Path
+
+from django.http import FileResponse, Http404, HttpResponse, HttpResponseNotModified
+from django.template import Context, Engine, TemplateDoesNotExist, loader
+from django.utils._os import safe_join
+from django.utils.http import http_date, parse_http_date
+from django.utils.translation import gettext as _
+from django.utils.translation import gettext_lazy
+
+
+def builtin_template_path(name):
+    """
+    Return a path to a builtin template.
+
+    Avoid calling this function at the module level or in a class-definition
+    because __file__ may not exist, e.g. in frozen environments.
+    """
+    return Path(__file__).parent / "templates" / name
+
+
+def serve(request, path, document_root=None, show_indexes=False):
+    """
+    Serve static files below a given point in the directory structure.
+
+    To use, put a URL pattern such as::
+
+        from django.views.static import serve
+
+        path('<path:path>', serve, {'document_root': '/path/to/my/files/'})
+
+    in your URLconf. You must provide the ``document_root`` param. You may
+    also set ``show_indexes`` to ``True`` if you'd like to serve a basic index
+    of the directory.  This index view will use the template hardcoded below,
+    but if you'd like to override it, you can create a template called
+    ``static/directory_index.html``.
+    """
+    path = posixpath.normpath(path).lstrip("/")
+    fullpath = Path(safe_join(document_root, path))
+    if fullpath.is_dir():
+        if show_indexes:
+            return directory_index(path, fullpath)
+        raise Http404(_("Directory indexes are not allowed here."))
+    if not fullpath.exists():
+        raise Http404(_("“%(path)s” does not exist") % {"path": fullpath})
+    # Respect the If-Modified-Since header.
+    statobj = fullpath.stat()
+    if not was_modified_since(
+        request.META.get("HTTP_IF_MODIFIED_SINCE"), statobj.st_mtime
+    ):
+        return HttpResponseNotModified()
+    content_type, encoding = mimetypes.guess_type(str(fullpath))
+    content_type = content_type or "application/octet-stream"
+    response = FileResponse(fullpath.open("rb"), content_type=content_type)
+    response.headers["Last-Modified"] = http_date(statobj.st_mtime)
+    if encoding:
+        response.headers["Content-Encoding"] = encoding
+    return response
+
+
+# Translatable string for static directory index template title.
+template_translatable = gettext_lazy("Index of %(directory)s")
+
+
+def directory_index(path, fullpath):
+    try:
+        t = loader.select_template(
+            [
+                "static/directory_index.html",
+                "static/directory_index",
+            ]
+        )
+    except TemplateDoesNotExist:
+        with builtin_template_path("directory_index.html").open(encoding="utf-8") as fh:
+            t = Engine(libraries={"i18n": "django.templatetags.i18n"}).from_string(
+                fh.read()
+            )
+        c = Context()
+    else:
+        c = {}
+    files = []
+    for f in fullpath.iterdir():
+        if not f.name.startswith("."):
+            url = str(f.relative_to(fullpath))
+            if f.is_dir():
+                url += "/"
+            files.append(url)
+    c.update(
+        {
+            "directory": path + "/",
+            "file_list": files,
+        }
+    )
+    return HttpResponse(t.render(c))
+
+
+def was_modified_since(header=None, mtime=0):
+    """
+    Was something modified since the user last downloaded it?
+
+    header
+      This is the value of the If-Modified-Since header.  If this is None,
+      I'll just return True.
+
+    mtime
+      This is the modification time of the item we're talking about.
+    """
+    try:
+        if header is None:
+            raise ValueError
+        header_mtime = parse_http_date(header)
+        if int(mtime) > header_mtime:
+            raise ValueError
+    except (ValueError, OverflowError):
+        return True
+    return False

testbed/django__django/django/views/templates/csrf_403.html

@@ -0,0 +1,84 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta http-equiv="content-type" content="text/html; charset=utf-8">
+  <meta name="robots" content="NONE,NOARCHIVE">
+  <title>403 Forbidden</title>
+  <style type="text/css">
+    html * { padding:0; margin:0; }
+    body * { padding:10px 20px; }
+    body * * { padding:0; }
+    body { font:small sans-serif; background:#eee; color:#000; }
+    body>div { border-bottom:1px solid #ddd; }
+    h1 { font-weight:normal; margin-bottom:.4em; }
+    h1 span { font-size:60%; color:#666; font-weight:normal; }
+    #info { background:#f6f6f6; }
+    #info ul { margin: 0.5em 4em; }
+    #info p, #summary p { padding-top:10px; }
+    #summary { background: #ffc; }
+    #explanation { background:#eee; border-bottom: 0px none; }
+  </style>
+</head>
+<body>
+<div id="summary">
+  <h1>{{ title }} <span>(403)</span></h1>
+  <p>{{ main }}</p>
+{% if no_referer %}
+  <p>{{ no_referer1 }}</p>
+  <p>{{ no_referer2 }}</p>
+  <p>{{ no_referer3 }}</p>
+{% endif %}
+{% if no_cookie %}
+  <p>{{ no_cookie1 }}</p>
+  <p>{{ no_cookie2 }}</p>
+{% endif %}
+</div>
+{% if DEBUG %}
+<div id="info">
+  <h2>Help</h2>
+    {% if reason %}
+    <p>Reason given for failure:</p>
+    <pre>
+    {{ reason }}
+    </pre>
+    {% endif %}
+
+  <p>In general, this can occur when there is a genuine Cross Site Request Forgery, or when
+  <a
+  href="https://docs.djangoproject.com/en/{{ docs_version }}/ref/csrf/">Django’s
+  CSRF mechanism</a> has not been used correctly.  For POST forms, you need to
+  ensure:</p>
+
+  <ul>
+    <li>Your browser is accepting cookies.</li>
+
+    <li>The view function passes a <code>request</code> to the template’s <a
+    href="https://docs.djangoproject.com/en/dev/topics/templates/#django.template.backends.base.Template.render"><code>render</code></a>
+    method.</li>
+
+    <li>In the template, there is a <code>{% templatetag openblock %} csrf_token
+    {% templatetag closeblock %}</code> template tag inside each POST form that
+    targets an internal URL.</li>
+
+    <li>If you are not using <code>CsrfViewMiddleware</code>, then you must use
+    <code>csrf_protect</code> on any views that use the <code>csrf_token</code>
+    template tag, as well as those that accept the POST data.</li>
+
+    <li>The form has a valid CSRF token. After logging in in another browser
+    tab or hitting the back button after a login, you may need to reload the
+    page with the form, because the token is rotated after a login.</li>
+  </ul>
+
+  <p>You’re seeing the help section of this page because you have <code>DEBUG =
+  True</code> in your Django settings file. Change that to <code>False</code>,
+  and only the initial error message will be displayed.  </p>
+
+  <p>You can customize this page using the CSRF_FAILURE_VIEW setting.</p>
+</div>
+{% else %}
+<div id="explanation">
+  <p><small>{{ more }}</small></p>
+</div>
+{% endif %}
+</body>
+</html>

testbed/django__django/django/views/templates/directory_index.html

@@ -0,0 +1,21 @@
+{% load i18n %}
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta http-equiv="Content-type" content="text/html; charset=utf-8">
+    <meta http-equiv="Content-Language" content="en-us">
+    <meta name="robots" content="NONE,NOARCHIVE">
+    <title>{% blocktranslate %}Index of {{ directory }}{% endblocktranslate %}</title>
+  </head>
+  <body>
+    <h1>{% blocktranslate %}Index of {{ directory }}{% endblocktranslate %}</h1>
+    <ul>
+      {% if directory != "/" %}
+      <li><a href="../">../</a></li>
+      {% endif %}
+      {% for f in file_list %}
+      <li><a href="{{ f|urlencode }}">{{ f }}</a></li>
+      {% endfor %}
+    </ul>
+  </body>
+</html>

testbed/django__django/django/views/templates/technical_404.html

@@ -0,0 +1,82 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta http-equiv="content-type" content="text/html; charset=utf-8">
+  <title>Page not found at {{ request.path_info }}</title>
+  <meta name="robots" content="NONE,NOARCHIVE">
+  <style type="text/css">
+    html * { padding:0; margin:0; }
+    body * { padding:10px 20px; }
+    body * * { padding:0; }
+    body { font:small sans-serif; background:#eee; color:#000; }
+    body>div { border-bottom:1px solid #ddd; }
+    h1 { font-weight:normal; margin-bottom:.4em; }
+    h1 span { font-size:60%; color:#666; font-weight:normal; }
+    table { border:none; border-collapse: collapse; width:100%; }
+    td, th { vertical-align:top; padding:2px 3px; }
+    th { width:12em; text-align:right; color:#666; padding-right:.5em; }
+    #info { background:#f6f6f6; }
+    #info ol { margin: 0.5em 4em; }
+    #info ol li { font-family: monospace; }
+    #summary { background: #ffc; }
+    #explanation { background:#eee; border-bottom: 0px none; }
+    pre.exception_value { font-family: sans-serif; color: #575757; font-size: 1.5em; margin: 10px 0 10px 0; }
+  </style>
+</head>
+<body>
+  <div id="summary">
+    <h1>Page not found <span>(404)</span></h1>
+    {% if reason and resolved %}<pre class="exception_value">{{ reason }}</pre>{% endif %}
+    <table class="meta">
+      <tr>
+        <th>Request Method:</th>
+        <td>{{ request.META.REQUEST_METHOD }}</td>
+      </tr>
+      <tr>
+        <th>Request URL:</th>
+        <td>{{ request.build_absolute_uri }}</td>
+      </tr>
+      {% if raising_view_name %}
+      <tr>
+        <th>Raised by:</th>
+        <td>{{ raising_view_name }}</td>
+      </tr>
+      {% endif %}
+    </table>
+  </div>
+  <div id="info">
+    {% if urlpatterns %}
+      <p>
+      Using the URLconf defined in <code>{{ urlconf }}</code>,
+      Django tried these URL patterns, in this order:
+      </p>
+      <ol>
+        {% for pattern in urlpatterns %}
+          <li>
+            {% for pat in pattern %}
+                {{ pat.pattern }}
+                {% if forloop.last and pat.name %}[name='{{ pat.name }}']{% endif %}
+            {% endfor %}
+          </li>
+        {% endfor %}
+      </ol>
+      <p>
+        {% if request_path %}
+          The current path, <code>{{ request_path }}</code>,
+        {% else %}
+          The empty path
+        {% endif %}
+        {% if resolved %}matched the last one.{% else %}didn’t match any of these.{% endif %}
+      </p>
+    {% endif %}
+  </div>
+
+  <div id="explanation">
+    <p>
+      You’re seeing this error because you have <code>DEBUG = True</code> in
+      your Django settings file. Change that to <code>False</code>, and Django
+      will display a standard 404 page.
+    </p>
+  </div>
+</body>
+</html>

testbed/django__django/django/views/templates/technical_500.html

@@ -0,0 +1,491 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta http-equiv="content-type" content="text/html; charset=utf-8">
+  <meta name="robots" content="NONE,NOARCHIVE">
+  <title>{% if exception_type %}{{ exception_type }}{% else %}Report{% endif %}
+         {% if request %} at {{ request.path_info }}{% endif %}</title>
+  <style type="text/css">
+    html * { padding:0; margin:0; }
+    body * { padding:10px 20px; }
+    body * * { padding:0; }
+    body { font:small sans-serif; background-color:#fff; color:#000; }
+    body>div { border-bottom:1px solid #ddd; }
+    h1 { font-weight:normal; }
+    h2 { margin-bottom:.8em; }
+    h3 { margin:1em 0 .5em 0; }
+    h4 { margin:0 0 .5em 0; font-weight: normal; }
+    code, pre { font-size: 100%; white-space: pre-wrap; word-break: break-word; }
+    summary { cursor: pointer; }
+    table { border:1px solid #ccc; border-collapse: collapse; width:100%; background:white; }
+    tbody td, tbody th { vertical-align:top; padding:2px 3px; }
+    thead th {
+      padding:1px 6px 1px 3px; background:#fefefe; text-align:left;
+      font-weight:normal; font-size:11px; border:1px solid #ddd;
+    }
+    tbody th { width:12em; text-align:right; color:#666; padding-right:.5em; }
+    table.vars { margin:5px 10px 2px 40px; width: auto; }
+    table.vars td, table.req td { font-family:monospace; }
+    table td.code { width:100%; }
+    table td.code pre { overflow:hidden; }
+    table.source th { color:#666; }
+    table.source td { font-family:monospace; white-space:pre; border-bottom:1px solid #eee; }
+    ul.traceback { list-style-type:none; color: #222; }
+    ul.traceback li.cause { word-break: break-word; }
+    ul.traceback li.frame { padding-bottom:1em; color:#4f4f4f; }
+    ul.traceback li.user { background-color:#e0e0e0; color:#000 }
+    div.context { padding:10px 0; overflow:hidden; }
+    div.context ol { padding-left:30px; margin:0 10px; list-style-position: inside; }
+    div.context ol li { font-family:monospace; white-space:pre; color:#777; cursor:pointer; padding-left: 2px; }
+    div.context ol li pre { display:inline; }
+    div.context ol.context-line li { color:#464646; background-color:#dfdfdf; padding: 3px 2px; }
+    div.context ol.context-line li span { position:absolute; right:32px; }
+    .user div.context ol.context-line li { background-color:#bbb; color:#000; }
+    .user div.context ol li { color:#666; }
+    div.commands, summary.commands { margin-left: 40px; }
+    div.commands a, summary.commands { color:#555; text-decoration:none; }
+    .user div.commands a { color: black; }
+    #summary { background: #ffc; }
+    #summary h2 { font-weight: normal; color: #666; }
+    #explanation { background:#eee; }
+    #template, #template-not-exist { background:#f6f6f6; }
+    #template-not-exist ul { margin: 0 0 10px 20px; }
+    #template-not-exist .postmortem-section { margin-bottom: 3px; }
+    #unicode-hint { background:#eee; }
+    #traceback { background:#eee; }
+    #requestinfo { background:#f6f6f6; padding-left:120px; }
+    #summary table { border:none; background:transparent; }
+    #requestinfo h2, #requestinfo h3 { position:relative; margin-left:-100px; }
+    #requestinfo h3 { margin-bottom:-1em; }
+    .error { background: #ffc; }
+    .specific { color:#cc3300; font-weight:bold; }
+    h2 span.commands { font-size:.7em; font-weight:normal; }
+    span.commands a:link {color:#5E5694;}
+    pre.exception_value { font-family: sans-serif; color: #575757; font-size: 1.5em; margin: 10px 0 10px 0; }
+    .append-bottom { margin-bottom: 10px; }
+    .fname { user-select: all; }
+  </style>
+  {% if not is_email %}
+  <script>
+    function hideAll(elems) {
+      for (var e = 0; e < elems.length; e++) {
+        elems[e].style.display = 'none';
+      }
+    }
+    window.onload = function() {
+      hideAll(document.querySelectorAll('ol.pre-context'));
+      hideAll(document.querySelectorAll('ol.post-context'));
+      hideAll(document.querySelectorAll('div.pastebin'));
+    }
+    function toggle() {
+      for (var i = 0; i < arguments.length; i++) {
+        var e = document.getElementById(arguments[i]);
+        if (e) {
+          e.style.display = e.style.display == 'none' ? 'block': 'none';
+        }
+      }
+      return false;
+    }
+    function switchPastebinFriendly(link) {
+      s1 = "Switch to copy-and-paste view";
+      s2 = "Switch back to interactive view";
+      link.textContent = link.textContent.trim() == s1 ? s2: s1;
+      toggle('browserTraceback', 'pastebinTraceback');
+      return false;
+    }
+  </script>
+  {% endif %}
+</head>
+<body>
+<div id="summary">
+  <h1>{% if exception_type %}{{ exception_type }}{% else %}Report{% endif %}
+      {% if request %} at {{ request.path_info }}{% endif %}</h1>
+  <pre class="exception_value">{% if exception_value %}{{ exception_value|force_escape }}{% if exception_notes %}{{ exception_notes }}{% endif %}{% else %}No exception message supplied{% endif %}</pre>
+  <table class="meta">
+{% if request %}
+    <tr>
+      <th>Request Method:</th>
+      <td>{{ request.META.REQUEST_METHOD }}</td>
+    </tr>
+    <tr>
+      <th>Request URL:</th>
+      <td>{{ request_insecure_uri }}</td>
+    </tr>
+{% endif %}
+    <tr>
+      <th>Django Version:</th>
+      <td>{{ django_version_info }}</td>
+    </tr>
+{% if exception_type %}
+    <tr>
+      <th>Exception Type:</th>
+      <td>{{ exception_type }}</td>
+    </tr>
+{% endif %}
+{% if exception_type and exception_value %}
+    <tr>
+      <th>Exception Value:</th>
+      <td><pre>{{ exception_value|force_escape }}</pre></td>
+    </tr>
+{% endif %}
+{% if lastframe %}
+    <tr>
+      <th>Exception Location:</th>
+      <td><span class="fname">{{ lastframe.filename }}</span>, line {{ lastframe.lineno }}, in {{ lastframe.function }}</td>
+    </tr>
+{% endif %}
+{% if raising_view_name %}
+    <tr>
+      <th>Raised during:</th>
+      <td>{{ raising_view_name }}</td>
+    </tr>
+{% endif %}
+    <tr>
+      <th>Python Executable:</th>
+      <td>{{ sys_executable }}</td>
+    </tr>
+    <tr>
+      <th>Python Version:</th>
+      <td>{{ sys_version_info }}</td>
+    </tr>
+    <tr>
+      <th>Python Path:</th>
+      <td><pre>{{ sys_path|pprint }}</pre></td>
+    </tr>
+    <tr>
+      <th>Server time:</th>
+      <td>{{server_time|date:"r"}}</td>
+    </tr>
+  </table>
+</div>
+{% if unicode_hint %}
+<div id="unicode-hint">
+    <h2>Unicode error hint</h2>
+    <p>The string that could not be encoded/decoded was: <strong>{{ unicode_hint }}</strong></p>
+</div>
+{% endif %}
+{% if template_does_not_exist %}
+<div id="template-not-exist">
+    <h2>Template-loader postmortem</h2>
+    {% if postmortem %}
+        <p class="append-bottom">Django tried loading these templates, in this order:</p>
+        {% for entry in postmortem %}
+            <p class="postmortem-section">Using engine <code>{{ entry.backend.name }}</code>:</p>
+            <ul>
+                {% if entry.tried %}
+                    {% for attempt in entry.tried %}
+                        <li><code>{{ attempt.0.loader_name }}</code>: {{ attempt.0.name }} ({{ attempt.1 }})</li>
+                    {% endfor %}
+                {% else %}
+                    <li>This engine did not provide a list of tried templates.</li>
+                {% endif %}
+            </ul>
+        {% endfor %}
+    {% else %}
+        <p>No templates were found because your 'TEMPLATES' setting is not configured.</p>
+    {% endif %}
+</div>
+{% endif %}
+{% if template_info %}
+<div id="template">
+   <h2>Error during template rendering</h2>
+   <p>In template <code>{{ template_info.name }}</code>, error at line <strong>{{ template_info.line }}</strong></p>
+   <h3>{{ template_info.message|force_escape }}</h3>
+   <table class="source{% if template_info.top %} cut-top{% endif %}
+      {% if template_info.bottom != template_info.total %} cut-bottom{% endif %}">
+   {% for source_line in template_info.source_lines %}
+   {% if source_line.0 == template_info.line %}
+   <tr class="error"><th>{{ source_line.0 }}</th>
+     <td>{{ template_info.before }}<span class="specific">{{ template_info.during }}</span>{{ template_info.after }}</td>
+   </tr>
+   {% else %}
+      <tr><th>{{ source_line.0 }}</th>
+      <td>{{ source_line.1 }}</td></tr>
+   {% endif %}
+   {% endfor %}
+   </table>
+</div>
+{% endif %}
+{% if frames %}
+<div id="traceback">
+  <h2>Traceback{% if not is_email %} <span class="commands"><a href="#" onclick="return switchPastebinFriendly(this);">
+    Switch to copy-and-paste view</a></span>{% endif %}
+  </h2>
+  <div id="browserTraceback">
+    <ul class="traceback">
+      {% for frame in frames %}
+        {% ifchanged frame.exc_cause %}{% if frame.exc_cause %}
+          <li class="cause"><h3>
+          {% if frame.exc_cause_explicit %}
+            The above exception ({{ frame.exc_cause|force_escape }}) was the direct cause of the following exception:
+          {% else %}
+            During handling of the above exception ({{ frame.exc_cause|force_escape }}), another exception occurred:
+          {% endif %}
+        </h3></li>
+        {% endif %}{% endifchanged %}
+        <li class="frame {{ frame.type }}">
+          {% if frame.tb %}
+            <code class="fname">{{ frame.filename }}</code>, line {{ frame.lineno }}, in {{ frame.function }}
+          {% elif forloop.first %}
+            None
+          {% else %}
+            Traceback: None
+          {% endif %}
+
+          {% if frame.context_line %}
+            <div class="context" id="c{{ frame.id }}">
+              {% if frame.pre_context and not is_email %}
+                <ol start="{{ frame.pre_context_lineno }}" class="pre-context" id="pre{{ frame.id }}">
+                {% for line in frame.pre_context %}
+                  <li onclick="toggle('pre{{ frame.id }}', 'post{{ frame.id }}')"><pre>{{ line }}</pre></li>
+                {% endfor %}
+                </ol>
+              {% endif %}
+              <ol start="{{ frame.lineno }}" class="context-line">
+                <li onclick="toggle('pre{{ frame.id }}', 'post{{ frame.id }}')"><pre>{{ frame.context_line }}{{ frame.colno }}</pre>{% if not is_email %} <span>…</span>{% endif %}</li>
+              </ol>
+              {% if frame.post_context and not is_email  %}
+                <ol start='{{ frame.lineno|add:"1" }}' class="post-context" id="post{{ frame.id }}">
+                  {% for line in frame.post_context %}
+                  <li onclick="toggle('pre{{ frame.id }}', 'post{{ frame.id }}')"><pre>{{ line }}</pre></li>
+                  {% endfor %}
+              </ol>
+              {% endif %}
+            </div>
+          {% endif %}
+
+          {% if frame.vars %}
+            {% if is_email %}
+              <div class="commands">
+                <h2>Local Vars</h2>
+              </div>
+            {% else %}
+              <details>
+                <summary class="commands">Local vars</summary>
+            {% endif %}
+            <table class="vars" id="v{{ frame.id }}">
+              <thead>
+                <tr>
+                  <th>Variable</th>
+                  <th>Value</th>
+                </tr>
+              </thead>
+              <tbody>
+                {% for var in frame.vars|dictsort:0 %}
+                  <tr>
+                    <td>{{ var.0 }}</td>
+                    <td class="code"><pre>{{ var.1 }}</pre></td>
+                  </tr>
+                {% endfor %}
+              </tbody>
+            </table>
+            {% if not is_email %}</details>{% endif %}
+          {% endif %}
+        </li>
+      {% endfor %}
+    </ul>
+  </div>
+{% if not is_email %}
+  <form action="https://dpaste.com/" name="pasteform" id="pasteform" method="post">
+  <div id="pastebinTraceback" class="pastebin">
+    <input type="hidden" name="language" value="PythonConsole">
+    <input type="hidden" name="title"
+      value="{{ exception_type }}{% if request %} at {{ request.path_info }}{% endif %}">
+    <input type="hidden" name="source" value="Django Dpaste Agent">
+    <input type="hidden" name="poster" value="Django">
+    <textarea name="content" id="traceback_area" cols="140" rows="25">
+Environment:
+
+{% if request %}
+Request Method: {{ request.META.REQUEST_METHOD }}
+Request URL: {{ request_insecure_uri }}
+{% endif %}
+Django Version: {{ django_version_info }}
+Python Version: {{ sys_version_info }}
+Installed Applications:
+{{ settings.INSTALLED_APPS|pprint }}
+Installed Middleware:
+{{ settings.MIDDLEWARE|pprint }}
+
+{% if template_does_not_exist %}Template loader postmortem
+{% if postmortem %}Django tried loading these templates, in this order:
+{% for entry in postmortem %}
+Using engine {{ entry.backend.name }}:
+{% if entry.tried %}{% for attempt in entry.tried %}    * {{ attempt.0.loader_name }}: {{ attempt.0.name }} ({{ attempt.1 }})
+{% endfor %}{% else %}    This engine did not provide a list of tried templates.
+{% endif %}{% endfor %}
+{% else %}No templates were found because your 'TEMPLATES' setting is not configured.
+{% endif %}{% endif %}{% if template_info %}
+Template error:
+In template {{ template_info.name }}, error at line {{ template_info.line }}
+   {{ template_info.message|force_escape }}
+{% for source_line in template_info.source_lines %}{% if source_line.0 == template_info.line %}   {{ source_line.0 }} : {{ template_info.before }} {{ template_info.during }} {{ template_info.after }}{% else %}   {{ source_line.0 }} : {{ source_line.1 }}{% endif %}{% endfor %}{% endif %}
+
+Traceback (most recent call last):{% for frame in frames %}
+{% ifchanged frame.exc_cause %}{% if frame.exc_cause %}{% if frame.exc_cause_explicit %}
+The above exception ({{ frame.exc_cause|force_escape }}) was the direct cause of the following exception:
+{% else %}
+During handling of the above exception ({{ frame.exc_cause|force_escape }}), another exception occurred:
+{% endif %}{% endif %}{% endifchanged %}  {% if frame.tb %}File "{{ frame.filename }}"{% if frame.context_line %}, line {{ frame.lineno }}{% endif %}, in {{ frame.function }}
+{% if frame.context_line %}    {% spaceless %}{{ frame.context_line }}{% endspaceless %}{{ frame.tb_area_colno }}{% endif %}{% elif forloop.first %}None{% else %}Traceback: None{% endif %}{% endfor %}
+
+Exception Type: {{ exception_type }}{% if request %} at {{ request.path_info }}{% endif %}
+Exception Value: {{ exception_value|force_escape }}{% if exception_notes %}{{ exception_notes }}{% endif %}
+</textarea>
+  <br><br>
+  <input type="submit" value="Share this traceback on a public website">
+  </div>
+</form>
+{% endif %}
+</div>
+{% endif %}
+
+<div id="requestinfo">
+  <h2>Request information</h2>
+
+{% if request %}
+  {% if user_str %}
+    <h3 id="user-info">USER</h3>
+    <p>{{ user_str }}</p>
+  {% endif %}
+
+  <h3 id="get-info">GET</h3>
+  {% if request.GET %}
+    <table class="req">
+      <thead>
+        <tr>
+          <th>Variable</th>
+          <th>Value</th>
+        </tr>
+      </thead>
+      <tbody>
+        {% for k, v in request_GET_items %}
+          <tr>
+            <td>{{ k }}</td>
+            <td class="code"><pre>{{ v|pprint }}</pre></td>
+          </tr>
+        {% endfor %}
+      </tbody>
+    </table>
+  {% else %}
+    <p>No GET data</p>
+  {% endif %}
+
+  <h3 id="post-info">POST</h3>
+  {% if filtered_POST_items %}
+    <table class="req">
+      <thead>
+        <tr>
+          <th>Variable</th>
+          <th>Value</th>
+        </tr>
+      </thead>
+      <tbody>
+        {% for k, v in filtered_POST_items %}
+          <tr>
+            <td>{{ k }}</td>
+            <td class="code"><pre>{{ v|pprint }}</pre></td>
+          </tr>
+        {% endfor %}
+      </tbody>
+    </table>
+  {% else %}
+    <p>No POST data</p>
+  {% endif %}
+
+  <h3 id="files-info">FILES</h3>
+  {% if request.FILES %}
+    <table class="req">
+      <thead>
+        <tr>
+          <th>Variable</th>
+          <th>Value</th>
+        </tr>
+      </thead>
+      <tbody>
+        {% for k, v in request_FILES_items %}
+          <tr>
+            <td>{{ k }}</td>
+            <td class="code"><pre>{{ v|pprint }}</pre></td>
+          </tr>
+        {% endfor %}
+      </tbody>
+    </table>
+  {% else %}
+    <p>No FILES data</p>
+  {% endif %}
+
+  <h3 id="cookie-info">COOKIES</h3>
+  {% if request.COOKIES %}
+    <table class="req">
+      <thead>
+        <tr>
+          <th>Variable</th>
+          <th>Value</th>
+        </tr>
+      </thead>
+      <tbody>
+        {% for k, v in request_COOKIES_items %}
+          <tr>
+            <td>{{ k }}</td>
+            <td class="code"><pre>{{ v|pprint }}</pre></td>
+          </tr>
+        {% endfor %}
+      </tbody>
+    </table>
+  {% else %}
+    <p>No cookie data</p>
+  {% endif %}
+
+  <h3 id="meta-info">META</h3>
+  <table class="req">
+    <thead>
+      <tr>
+        <th>Variable</th>
+        <th>Value</th>
+      </tr>
+    </thead>
+    <tbody>
+      {% for k, v in request_meta.items|dictsort:0 %}
+        <tr>
+          <td>{{ k }}</td>
+          <td class="code"><pre>{{ v|pprint }}</pre></td>
+        </tr>
+      {% endfor %}
+    </tbody>
+  </table>
+{% else %}
+  <p>Request data not supplied</p>
+{% endif %}
+
+  <h3 id="settings-info">Settings</h3>
+  <h4>Using settings module <code>{{ settings.SETTINGS_MODULE }}</code></h4>
+  <table class="req">
+    <thead>
+      <tr>
+        <th>Setting</th>
+        <th>Value</th>
+      </tr>
+    </thead>
+    <tbody>
+      {% for k, v in settings.items|dictsort:0 %}
+        <tr>
+          <td>{{ k }}</td>
+          <td class="code"><pre>{{ v|pprint }}</pre></td>
+        </tr>
+      {% endfor %}
+    </tbody>
+  </table>
+
+</div>
+{% if not is_email %}
+  <div id="explanation">
+    <p>
+      You’re seeing this error because you have <code>DEBUG = True</code> in your
+      Django settings file. Change that to <code>False</code>, and Django will
+      display a standard page generated by the handler for this status code.
+    </p>
+  </div>
+{% endif %}
+</body>
+</html>

testbed/django__django/django/views/templates/technical_500.txt

@@ -0,0 +1,66 @@
+{% firstof exception_type 'Report' %}{% if request %} at {{ request.path_info }}{% endif %}
+{% firstof exception_value 'No exception message supplied' %}
+{% if request %}
+Request Method: {{ request.META.REQUEST_METHOD }}
+Request URL: {{ request_insecure_uri }}{% endif %}
+Django Version: {{ django_version_info }}
+Python Executable: {{ sys_executable }}
+Python Version: {{ sys_version_info }}
+Python Path: {{ sys_path }}
+Server time: {{server_time|date:"r"}}
+Installed Applications:
+{{ settings.INSTALLED_APPS|pprint }}
+Installed Middleware:
+{{ settings.MIDDLEWARE|pprint }}
+{% if template_does_not_exist %}Template loader postmortem
+{% if postmortem %}Django tried loading these templates, in this order:
+{% for entry in postmortem %}
+Using engine {{ entry.backend.name }}:
+{% if entry.tried %}{% for attempt in entry.tried %}    * {{ attempt.0.loader_name }}: {{ attempt.0.name }} ({{ attempt.1 }})
+{% endfor %}{% else %}    This engine did not provide a list of tried templates.
+{% endif %}{% endfor %}
+{% else %}No templates were found because your 'TEMPLATES' setting is not configured.
+{% endif %}
+{% endif %}{% if template_info %}
+Template error:
+In template {{ template_info.name }}, error at line {{ template_info.line }}
+   {{ template_info.message }}
+{% for source_line in template_info.source_lines %}{% if source_line.0 == template_info.line %}   {{ source_line.0 }} : {{ template_info.before }} {{ template_info.during }} {{ template_info.after }}{% else %}   {{ source_line.0 }} : {{ source_line.1 }}{% endif %}{% endfor %}{% endif %}{% if frames %}
+
+Traceback (most recent call last):
+{% for frame in frames %}{% ifchanged frame.exc_cause %}{% if frame.exc_cause %}
+{% if frame.exc_cause_explicit %}The above exception ({{ frame.exc_cause }}) was the direct cause of the following exception:{% else %}During handling of the above exception ({{ frame.exc_cause }}), another exception occurred:{% endif %}
+{% endif %}{% endifchanged %}  {% if frame.tb %}File "{{ frame.filename }}"{% if frame.context_line %}, line {{ frame.lineno }}{% endif %}, in {{ frame.function }}
+{% if frame.context_line %}    {% spaceless %}{{ frame.context_line }}{% endspaceless %}{{ frame.tb_area_colno }}{% endif %}{% elif forloop.first %}None{% else %}Traceback: None{% endif %}
+{% endfor %}
+{% if exception_type %}Exception Type: {{ exception_type }}{% if request %} at {{ request.path_info }}{% endif %}
+{% if exception_value %}Exception Value: {{ exception_value }}{% endif %}{% if exception_notes %}{{ exception_notes }}{% endif %}{% endif %}{% endif %}
+{% if raising_view_name %}Raised during: {{ raising_view_name }}{% endif %}
+{% if request %}Request information:
+{% if user_str %}USER: {{ user_str }}{% endif %}
+
+GET:{% for k, v in request_GET_items %}
+{{ k }} = {{ v|stringformat:"r" }}{% empty %} No GET data{% endfor %}
+
+POST:{% for k, v in filtered_POST_items %}
+{{ k }} = {{ v|stringformat:"r" }}{% empty %} No POST data{% endfor %}
+
+FILES:{% for k, v in request_FILES_items %}
+{{ k }} = {{ v|stringformat:"r" }}{% empty %} No FILES data{% endfor %}
+
+COOKIES:{% for k, v in request_COOKIES_items %}
+{{ k }} = {{ v|stringformat:"r" }}{% empty %} No cookie data{% endfor %}
+
+META:{% for k, v in request_meta.items|dictsort:0 %}
+{{ k }} = {{ v|stringformat:"r" }}{% endfor %}
+{% else %}Request data not supplied
+{% endif %}
+Settings:
+Using settings module {{ settings.SETTINGS_MODULE }}{% for k, v in settings.items|dictsort:0 %}
+{{ k }} = {{ v|stringformat:"r" }}{% endfor %}
+
+{% if not is_email %}
+You’re seeing this error because you have DEBUG = True in your
+Django settings file. Change that to False, and Django will
+display a standard page generated by the handler for this status code.
+{% endif %}

testbed/django__django/docs/_ext/djangodocs.py

@@ -0,0 +1,396 @@
+"""
+Sphinx plugins for Django documentation.
+"""
+import json
+import os
+import re
+
+from docutils import nodes
+from docutils.parsers.rst import Directive
+from docutils.statemachine import ViewList
+from sphinx import addnodes
+from sphinx.builders.html import StandaloneHTMLBuilder
+from sphinx.directives.code import CodeBlock
+from sphinx.domains.std import Cmdoption
+from sphinx.errors import ExtensionError
+from sphinx.util import logging
+from sphinx.util.console import bold
+from sphinx.writers.html import HTMLTranslator
+
+logger = logging.getLogger(__name__)
+# RE for option descriptions without a '--' prefix
+simple_option_desc_re = re.compile(r"([-_a-zA-Z0-9]+)(\s*.*?)(?=,\s+(?:/|-|--)|$)")
+
+
+def setup(app):
+    app.add_crossref_type(
+        directivename="setting",
+        rolename="setting",
+        indextemplate="pair: %s; setting",
+    )
+    app.add_crossref_type(
+        directivename="templatetag",
+        rolename="ttag",
+        indextemplate="pair: %s; template tag",
+    )
+    app.add_crossref_type(
+        directivename="templatefilter",
+        rolename="tfilter",
+        indextemplate="pair: %s; template filter",
+    )
+    app.add_crossref_type(
+        directivename="fieldlookup",
+        rolename="lookup",
+        indextemplate="pair: %s; field lookup type",
+    )
+    app.add_object_type(
+        directivename="django-admin",
+        rolename="djadmin",
+        indextemplate="pair: %s; django-admin command",
+        parse_node=parse_django_admin_node,
+    )
+    app.add_directive("django-admin-option", Cmdoption)
+    app.add_config_value("django_next_version", "0.0", True)
+    app.add_directive("versionadded", VersionDirective)
+    app.add_directive("versionchanged", VersionDirective)
+    app.add_builder(DjangoStandaloneHTMLBuilder)
+    app.set_translator("djangohtml", DjangoHTMLTranslator)
+    app.set_translator("json", DjangoHTMLTranslator)
+    app.add_node(
+        ConsoleNode,
+        html=(visit_console_html, None),
+        latex=(visit_console_dummy, depart_console_dummy),
+        man=(visit_console_dummy, depart_console_dummy),
+        text=(visit_console_dummy, depart_console_dummy),
+        texinfo=(visit_console_dummy, depart_console_dummy),
+    )
+    app.add_directive("console", ConsoleDirective)
+    app.connect("html-page-context", html_page_context_hook)
+    app.add_role("default-role-error", default_role_error)
+    return {"parallel_read_safe": True}
+
+
+class VersionDirective(Directive):
+    has_content = True
+    required_arguments = 1
+    optional_arguments = 1
+    final_argument_whitespace = True
+    option_spec = {}
+
+    def run(self):
+        if len(self.arguments) > 1:
+            msg = """Only one argument accepted for directive '{directive_name}::'.
+            Comments should be provided as content,
+            not as an extra argument.""".format(
+                directive_name=self.name
+            )
+            raise self.error(msg)
+
+        env = self.state.document.settings.env
+        ret = []
+        node = addnodes.versionmodified()
+        ret.append(node)
+
+        if self.arguments[0] == env.config.django_next_version:
+            node["version"] = "Development version"
+        else:
+            node["version"] = self.arguments[0]
+
+        node["type"] = self.name
+        if self.content:
+            self.state.nested_parse(self.content, self.content_offset, node)
+        try:
+            env.get_domain("changeset").note_changeset(node)
+        except ExtensionError:
+            # Sphinx < 1.8: Domain 'changeset' is not registered
+            env.note_versionchange(node["type"], node["version"], node, self.lineno)
+        return ret
+
+
+class DjangoHTMLTranslator(HTMLTranslator):
+    """
+    Django-specific reST to HTML tweaks.
+    """
+
+    # Don't use border=1, which docutils does by default.
+    def visit_table(self, node):
+        self.context.append(self.compact_p)
+        self.compact_p = True
+        # Needed by Sphinx.
+        self._table_row_indices.append(0)
+        self.body.append(self.starttag(node, "table", CLASS="docutils"))
+
+    def depart_table(self, node):
+        self.compact_p = self.context.pop()
+        self._table_row_indices.pop()
+        self.body.append("</table>\n")
+
+    def visit_desc_parameterlist(self, node):
+        self.body.append("(")  # by default sphinx puts <big> around the "("
+        self.first_param = 1
+        self.optional_param_level = 0
+        self.param_separator = node.child_text_separator
+        self.required_params_left = sum(
+            isinstance(c, addnodes.desc_parameter) for c in node.children
+        )
+
+    def depart_desc_parameterlist(self, node):
+        self.body.append(")")
+
+    #
+    # Turn the "new in version" stuff (versionadded/versionchanged) into a
+    # better callout -- the Sphinx default is just a little span,
+    # which is a bit less obvious that I'd like.
+    #
+    # FIXME: these messages are all hardcoded in English. We need to change
+    # that to accommodate other language docs, but I can't work out how to make
+    # that work.
+    #
+    version_text = {
+        "versionchanged": "Changed in Django %s",
+        "versionadded": "New in Django %s",
+    }
+
+    def visit_versionmodified(self, node):
+        self.body.append(self.starttag(node, "div", CLASS=node["type"]))
+        version_text = self.version_text.get(node["type"])
+        if version_text:
+            title = "%s%s" % (version_text % node["version"], ":" if len(node) else ".")
+            self.body.append('<span class="title">%s</span> ' % title)
+
+    def depart_versionmodified(self, node):
+        self.body.append("</div>\n")
+
+    # Give each section a unique ID -- nice for custom CSS hooks
+    def visit_section(self, node):
+        old_ids = node.get("ids", [])
+        node["ids"] = ["s-" + i for i in old_ids]
+        node["ids"].extend(old_ids)
+        super().visit_section(node)
+        node["ids"] = old_ids
+
+
+def parse_django_admin_node(env, sig, signode):
+    command = sig.split(" ")[0]
+    env.ref_context["std:program"] = command
+    title = "django-admin %s" % sig
+    signode += addnodes.desc_name(title, title)
+    return command
+
+
+class DjangoStandaloneHTMLBuilder(StandaloneHTMLBuilder):
+    """
+    Subclass to add some extra things we need.
+    """
+
+    name = "djangohtml"
+
+    def finish(self):
+        super().finish()
+        logger.info(bold("writing templatebuiltins.js..."))
+        xrefs = self.env.domaindata["std"]["objects"]
+        templatebuiltins = {
+            "ttags": [
+                n
+                for ((t, n), (k, a)) in xrefs.items()
+                if t == "templatetag" and k == "ref/templates/builtins"
+            ],
+            "tfilters": [
+                n
+                for ((t, n), (k, a)) in xrefs.items()
+                if t == "templatefilter" and k == "ref/templates/builtins"
+            ],
+        }
+        outfilename = os.path.join(self.outdir, "templatebuiltins.js")
+        with open(outfilename, "w") as fp:
+            fp.write("var django_template_builtins = ")
+            json.dump(templatebuiltins, fp)
+            fp.write(";\n")
+
+
+class ConsoleNode(nodes.literal_block):
+    """
+    Custom node to override the visit/depart event handlers at registration
+    time. Wrap a literal_block object and defer to it.
+    """
+
+    tagname = "ConsoleNode"
+
+    def __init__(self, litblk_obj):
+        self.wrapped = litblk_obj
+
+    def __getattr__(self, attr):
+        if attr == "wrapped":
+            return self.__dict__.wrapped
+        return getattr(self.wrapped, attr)
+
+
+def visit_console_dummy(self, node):
+    """Defer to the corresponding parent's handler."""
+    self.visit_literal_block(node)
+
+
+def depart_console_dummy(self, node):
+    """Defer to the corresponding parent's handler."""
+    self.depart_literal_block(node)
+
+
+def visit_console_html(self, node):
+    """Generate HTML for the console directive."""
+    if self.builder.name in ("djangohtml", "json") and node["win_console_text"]:
+        # Put a mark on the document object signaling the fact the directive
+        # has been used on it.
+        self.document._console_directive_used_flag = True
+        uid = node["uid"]
+        self.body.append(
+            """\
+<div class="console-block" id="console-block-%(id)s">
+<input class="c-tab-unix" id="c-tab-%(id)s-unix" type="radio" name="console-%(id)s" \
+checked>
+<label for="c-tab-%(id)s-unix" title="Linux/macOS">&#xf17c/&#xf179</label>
+<input class="c-tab-win" id="c-tab-%(id)s-win" type="radio" name="console-%(id)s">
+<label for="c-tab-%(id)s-win" title="Windows">&#xf17a</label>
+<section class="c-content-unix" id="c-content-%(id)s-unix">\n"""
+            % {"id": uid}
+        )
+        try:
+            self.visit_literal_block(node)
+        except nodes.SkipNode:
+            pass
+        self.body.append("</section>\n")
+
+        self.body.append(
+            '<section class="c-content-win" id="c-content-%(id)s-win">\n' % {"id": uid}
+        )
+        win_text = node["win_console_text"]
+        highlight_args = {"force": True}
+        linenos = node.get("linenos", False)
+
+        def warner(msg):
+            self.builder.warn(msg, (self.builder.current_docname, node.line))
+
+        highlighted = self.highlighter.highlight_block(
+            win_text, "doscon", warn=warner, linenos=linenos, **highlight_args
+        )
+        self.body.append(highlighted)
+        self.body.append("</section>\n")
+        self.body.append("</div>\n")
+        raise nodes.SkipNode
+    else:
+        self.visit_literal_block(node)
+
+
+class ConsoleDirective(CodeBlock):
+    """
+    A reStructuredText directive which renders a two-tab code block in which
+    the second tab shows a Windows command line equivalent of the usual
+    Unix-oriented examples.
+    """
+
+    required_arguments = 0
+    # The 'doscon' Pygments formatter needs a prompt like this. '>' alone
+    # won't do it because then it simply paints the whole command line as a
+    # gray comment with no highlighting at all.
+    WIN_PROMPT = r"...\> "
+
+    def run(self):
+        def args_to_win(cmdline):
+            changed = False
+            out = []
+            for token in cmdline.split():
+                if token[:2] == "./":
+                    token = token[2:]
+                    changed = True
+                elif token[:2] == "~/":
+                    token = "%HOMEPATH%\\" + token[2:]
+                    changed = True
+                elif token == "make":
+                    token = "make.bat"
+                    changed = True
+                if "://" not in token and "git" not in cmdline:
+                    out.append(token.replace("/", "\\"))
+                    changed = True
+                else:
+                    out.append(token)
+            if changed:
+                return " ".join(out)
+            return cmdline
+
+        def cmdline_to_win(line):
+            if line.startswith("# "):
+                return "REM " + args_to_win(line[2:])
+            if line.startswith("$ # "):
+                return "REM " + args_to_win(line[4:])
+            if line.startswith("$ ./manage.py"):
+                return "manage.py " + args_to_win(line[13:])
+            if line.startswith("$ manage.py"):
+                return "manage.py " + args_to_win(line[11:])
+            if line.startswith("$ ./runtests.py"):
+                return "runtests.py " + args_to_win(line[15:])
+            if line.startswith("$ ./"):
+                return args_to_win(line[4:])
+            if line.startswith("$ python3"):
+                return "py " + args_to_win(line[9:])
+            if line.startswith("$ python"):
+                return "py " + args_to_win(line[8:])
+            if line.startswith("$ "):
+                return args_to_win(line[2:])
+            return None
+
+        def code_block_to_win(content):
+            bchanged = False
+            lines = []
+            for line in content:
+                modline = cmdline_to_win(line)
+                if modline is None:
+                    lines.append(line)
+                else:
+                    lines.append(self.WIN_PROMPT + modline)
+                    bchanged = True
+            if bchanged:
+                return ViewList(lines)
+            return None
+
+        env = self.state.document.settings.env
+        self.arguments = ["console"]
+        lit_blk_obj = super().run()[0]
+
+        # Only do work when the djangohtml HTML Sphinx builder is being used,
+        # invoke the default behavior for the rest.
+        if env.app.builder.name not in ("djangohtml", "json"):
+            return [lit_blk_obj]
+
+        lit_blk_obj["uid"] = str(env.new_serialno("console"))
+        # Only add the tabbed UI if there is actually a Windows-specific
+        # version of the CLI example.
+        win_content = code_block_to_win(self.content)
+        if win_content is None:
+            lit_blk_obj["win_console_text"] = None
+        else:
+            self.content = win_content
+            lit_blk_obj["win_console_text"] = super().run()[0].rawsource
+
+        # Replace the literal_node object returned by Sphinx's CodeBlock with
+        # the ConsoleNode wrapper.
+        return [ConsoleNode(lit_blk_obj)]
+
+
+def html_page_context_hook(app, pagename, templatename, context, doctree):
+    # Put a bool on the context used to render the template. It's used to
+    # control inclusion of console-tabs.css and activation of the JavaScript.
+    # This way it's include only from HTML files rendered from reST files where
+    # the ConsoleDirective is used.
+    context["include_console_assets"] = getattr(
+        doctree, "_console_directive_used_flag", False
+    )
+
+
+def default_role_error(
+    name, rawtext, text, lineno, inliner, options=None, content=None
+):
+    msg = (
+        "Default role used (`single backticks`): %s. Did you mean to use two "
+        "backticks for ``code``, or miss an underscore for a `link`_ ?" % rawtext
+    )
+    logger.warning(msg, location=(inliner.document.current_source, lineno))
+    return [nodes.Text(text)], []

testbed/django__django/docs/_theme/djangodocs-epub/epub-cover.html

@@ -0,0 +1,10 @@
+{%- extends "epub/epub-cover.html" %}
+
+{% block content %}
+  <div class="epub-cover">
+    <h1>Django Documentation</h1>
+    <h2><em>Release {{ release }}</em></h2>
+    <h3>{{ copyright }}</h3>
+    <p>{{ last_updated }}</p>
+  </div>
+{% endblock %}

testbed/django__django/docs/_theme/djangodocs-epub/static/epub.css

@@ -0,0 +1,66 @@
+h1 { margin-top: 0; }
+
+/* Keep lists a bit narrow to maximize page estate regarding width. */
+ol, ul {
+    margin: 0;
+    padding: 0 0 0 1.3em;
+}
+
+/* Images should never exceed the width of the page. */
+img { max-width: 100%; }
+
+/* Don't display URL after links, this is not print. */
+.link-target { display: none; }
+
+/* This is the front cover page of the book. */
+.epub-cover { text-align: center; }
+.epub-cover h1 { margin: 4em 0 0 0; }
+.epub-cover h2 { margin: 1em 0; }
+.epub-cover h3 { margin: 3em 0 2em 0; }
+
+/* Code examples should never exceed the width of the page, so wrap instead. */
+pre, span.pre { white-space: pre-wrap; }
+
+pre {
+    background-color: #f6f6f6;
+    border: 0;
+    padding: 0.5em;
+    font-size: 90%;
+}
+
+/* Header for some code blocks. */
+.code-block-caption {
+    background-color: #393939;
+    color: white;
+    margin: 0;
+    padding: 0.5em;
+    font: bold 90% monospace;
+}
+.literal-block-wrapper pre {
+    margin-top: 0;
+}
+
+a:link, a:visited { color: #396623; }
+a:hover { color: #1d3311; }
+
+/* Use special styled note boxes from the default theme, but with the left side
+fitted after the icon, to allow text resizing with breaking. */
+.note, .admonition {
+    background-position: 9px 0.8em;
+    background-repeat: no-repeat;
+    padding: 0.8em 1em 0.8em 65px;
+    margin: 1em 0;
+    border: 0.01em solid black;
+}
+
+.note, .admonition { background-image: url(docicons-note.png); }
+div.admonition-philosophy { background-image: url(docicons-philosophy.png); }
+div.admonition-behind-the-scenes { background-image: url(docicons-behindscenes.png); }
+.admonition.warning { background-image: url(docicons-warning.png); }
+
+.admonition-title {
+    font-weight: bold;
+    margin: 0;
+}
+
+.admonition .last { margin-bottom: 0; }

testbed/django__django/docs/_theme/djangodocs-epub/theme.conf

@@ -0,0 +1,8 @@
+[theme]
+inherit = epub
+stylesheet = epub.css
+pygments_style = trac
+
+[options]
+relbar1 = false
+footer = false

testbed/django__django/docs/_theme/djangodocs/genindex.html

@@ -0,0 +1,4 @@
+{% extends "basic/genindex.html" %}
+
+{% block bodyclass %}{% endblock %}
+{% block sidebarwrapper %}{% endblock %}

testbed/django__django/docs/_theme/djangodocs/layout.html

@@ -0,0 +1,147 @@
+{% extends "basic/layout.html" %}
+
+{%- macro secondnav() %}
+  {%- if prev %}
+    &laquo; <a href="{{ prev.link|e }}" title="{{ prev.title|e }}">previous</a>
+    {{ reldelim2 }}
+  {%- endif %}
+  {%- if parents %}
+    <a href="{{ parents.0.link|e }}" title="{{ parents.0.title|e }}" accesskey="U">up</a>
+  {%- else %}
+    <a title="{{ docstitle }}" href="{{ pathto('index') }}" accesskey="U">up</a>
+  {%- endif %}
+  {%- if next %}
+  {{ reldelim2 }}
+    <a href="{{ next.link|e }}" title="{{ next.title|e }}">next</a> &raquo;
+  {%- endif %}
+{%- endmacro %}
+
+{% block extrahead %}
+{# When building htmlhelp (CHM format) disable jQuery inclusion, #}
+{# as it causes problems in compiled CHM files.                  #}
+{% if builder != "htmlhelp" %}
+{{ super() }}
+<script src="{{ pathto('templatebuiltins.js', 1) }}"></script>
+<script>
+(function($) {
+    if (!django_template_builtins) {
+       // templatebuiltins.js missing, do nothing.
+       return;
+    }
+    $(document).ready(function() {
+        // Hyperlink Django template tags and filters
+        var base = "{{ pathto('ref/templates/builtins') }}";
+        if (base == "#") {
+            // Special case for builtins.html itself
+            base = "";
+        }
+        // Tags are keywords, class '.k'
+        $("div.highlight\\-html\\+django span.k").each(function(i, elem) {
+             var tagname = $(elem).text();
+             if ($.inArray(tagname, django_template_builtins.ttags) != -1) {
+                 var fragment = tagname.replace(/_/, '-');
+                 $(elem).html("<a href='" + base + "#" + fragment + "'>" + tagname + "</a>");
+             }
+        });
+        // Filters are functions, class '.nf'
+        $("div.highlight\\-html\\+django span.nf").each(function(i, elem) {
+             var filtername = $(elem).text();
+             if ($.inArray(filtername, django_template_builtins.tfilters) != -1) {
+                 var fragment = filtername.replace(/_/, '-');
+                 $(elem).html("<a href='" + base + "#" + fragment + "'>" + filtername + "</a>");
+             }
+        });
+    });
+})(jQuery);
+{%- if include_console_assets -%}
+(function($) {
+    $(document).ready(function() {
+        $(".c-tab-unix").on("click", function() {
+            $("section.c-content-unix").show();
+            $("section.c-content-win").hide();
+            $(".c-tab-unix").prop("checked", true);
+        });
+        $(".c-tab-win").on("click", function() {
+            $("section.c-content-win").show();
+            $("section.c-content-unix").hide();
+            $(".c-tab-win").prop("checked", true);
+        });
+    });
+})(jQuery);
+{%- endif -%}
+</script>
+{% endif %}
+{%- if include_console_assets -%}
+<link rel="stylesheet" href="{{ pathto('_static/console-tabs.css', 1) }}">
+{%- endif -%}
+{% endblock %}
+
+{% block document %}
+  <div id="custom-doc" class="{% block bodyclass %}{{ 'yui-t6' if pagename != 'index' else '' }}{% endblock %}">
+    <div id="hd">
+      <h1><a href="{{ pathto('index') }}">{{ docstitle }}</a></h1>
+      <div id="global-nav">
+        <a title="Home page" href="{{ pathto('index') }}">Home</a> {{ reldelim2 }}
+        <a title="Table of contents" href="{{ pathto('contents') }}">Table of contents</a> {{ reldelim2 }}
+        <a title="Global index" href="{{ pathto('genindex') }}">Index</a> {{ reldelim2 }}
+        <a title="Module index" href="{{ pathto('py-modindex') }}">Modules</a>
+      </div>
+      <div class="nav">{{ secondnav() }}</div>
+    </div>
+
+    <div id="bd">
+      <div id="yui-main">
+        <div class="yui-b">
+          <div class="yui-g" id="{{ pagename|replace('/', '-') }}">
+            {% block body %}{% endblock %}
+          </div>
+        </div>
+      </div>
+      {% block sidebarwrapper %}
+        {% if pagename != 'index' %}
+          <div class="yui-b" id="sidebar">
+            {{ sidebar() }}
+            {%- if last_updated %}
+              <h3>Last update:</h3>
+              <p class="topless">{{ last_updated }}</p>
+            {%- endif %}
+          </div>
+        {% endif %}
+      {% endblock %}
+    </div>
+
+    <div id="ft">
+      <div class="nav">{{ secondnav() }}</div>
+    </div>
+  </div>
+{% endblock %}
+
+{% block sidebarrel %}
+  <h3>Browse</h3>
+  <ul>
+    {% if prev %}
+      <li>Prev: <a href="{{ prev.link }}">{{ prev.title }}</a></li>
+    {% endif %}
+    {% if next %}
+      <li>Next: <a href="{{ next.link }}">{{ next.title }}</a></li>
+    {% endif %}
+  </ul>
+  <h3>You are here:</h3>
+  <ul>
+      <li>
+        <a href="{{ pathto('index') }}">{{ docstitle }}</a>
+        {% for p in parents %}
+          <ul><li><a href="{{ p.link }}">{{ p.title }}</a>
+        {% endfor %}
+        <ul><li>{{ title }}</li></ul>
+        {% for p in parents %}</li></ul>{% endfor %}
+      </li>
+  </ul>
+{% endblock %}
+
+{# Empty some default blocks out #}
+{% block relbar1 %}{% endblock %}
+{% block relbar2 %}{% endblock %}
+{% block sidebar1 %}{% endblock %}
+{% block sidebar2 %}{% endblock %}
+{% block footer %}{% endblock %}

testbed/django__django/docs/_theme/djangodocs/modindex.html

@@ -0,0 +1,3 @@
+{% extends "basic/modindex.html" %}
+{% block bodyclass %}{% endblock %}
+{% block sidebarwrapper %}{% endblock %}

testbed/django__django/docs/_theme/djangodocs/search.html

@@ -0,0 +1,3 @@
+{% extends "basic/search.html" %}
+{% block bodyclass %}{% endblock %}
+{% block sidebarwrapper %}{% endblock %}

testbed/django__django/docs/_theme/djangodocs/static/console-tabs.css

@@ -0,0 +1,46 @@
+@import url("{{ pathto('_static/fontawesome/css/fa-brands.min.css', 1) }}");
+
+.console-block {
+  text-align: right;
+}
+
+.console-block *:before,
+.console-block *:after {
+  box-sizing: border-box;
+}
+
+.console-block > section {
+  display: none;
+  text-align: left;
+}
+
+.console-block > input.c-tab-unix,
+.console-block > input.c-tab-win {
+  display: none;
+}
+
+.console-block > label {
+  display: inline-block;
+  padding: 4px 8px;
+  font-weight: normal;
+  text-align: center;
+  color: #bbb;
+  border: 1px solid transparent;
+  font-family: fontawesome;
+}
+
+.console-block > input:checked + label {
+  color: #555;
+  border: 1px solid #ddd;
+  border-top: 2px solid #ab5603;
+  border-bottom: 1px solid #fff;
+}
+
+.console-block > .c-tab-unix:checked ~ .c-content-unix,
+.console-block > .c-tab-win:checked  ~ .c-content-win {
+  display: block;
+}
+
+.console-block pre {
+  margin-top: 0px;
+}

testbed/django__django/docs/_theme/djangodocs/static/default.css

@@ -0,0 +1,3 @@
+@import url(reset-fonts-grids.css);
+@import url(djangodocs.css);
+@import url(homepage.css);

testbed/django__django/docs/_theme/djangodocs/static/djangodocs.css

@@ -0,0 +1,145 @@
+/*** setup ***/
+html { background:#092e20;}
+body { font:12px/1.5 Verdana,sans-serif; background:#092e20; color: white;}
+#custom-doc { width:76.54em;*width:74.69em;min-width:995px; max-width:100em; margin:auto; text-align:left; padding-top:16px; margin-top:0;}
+#hd { padding: 4px 0 12px 0; }
+#bd { background:#234F32; }
+#ft { color:#487858; font-size:90%; padding-bottom: 2em; }
+
+/*** links ***/
+a {text-decoration: none;}
+a img {border: none;}
+a:link, a:visited { color:#ffc757; }
+#bd a:link, #bd a:visited { color:#ab5603; text-decoration:underline; }
+#bd #sidebar a:link, #bd #sidebar a:visited { color:#ffc757; text-decoration:none; }
+a:hover { color:#ffe761; }
+#bd a:hover { background-color:#E0FFB8; color:#234f32; text-decoration:none; }
+#bd #sidebar a:hover { color:#ffe761; background:none; }
+h2 a, h3 a, h4 a { text-decoration:none !important; }
+a.reference em { font-style: normal; }
+
+/*** sidebar ***/
+#sidebar div.sphinxsidebarwrapper { font-size:92%; margin-right: 14px; }
+#sidebar h3, #sidebar h4 { color: white; font-size: 125%; }
+#sidebar a { color: white; }
+#sidebar ul ul { margin-top:0; margin-bottom:0; }
+#sidebar li { margin-top: 0.2em; margin-bottom: 0.2em; }
+
+/*** nav ***/
+div.nav { margin: 0; font-size: 11px; text-align: right; color: #487858;}
+#hd div.nav { margin-top: -27px; }
+#ft div.nav { margin-bottom: -18px; }
+#hd h1 a { color: white; }
+#global-nav { position:absolute; top:5px; margin-left: -5px; padding:7px 0; color:#263E2B; }
+#global-nav a:link, #global-nav a:visited {color:#487858;}
+#global-nav a {padding:0 4px;}
+#global-nav a.about {padding-left:0;}
+#global-nav:hover {color:#fff;}
+#global-nav:hover a:link, #global-nav:hover a:visited  { color:#ffc757; }
+
+/*** content ***/
+#yui-main div.yui-b { position: relative; }
+#yui-main div.yui-b { margin: 0 0 0 20px; background: white; color: black; padding: 0.3em 2em 1em 2em; }
+
+/*** basic styles ***/
+dd { margin-left:15px; }
+h1,h2,h3,h4,h5,h6,h7,h8,h9,h10,h11,h12 { margin-top:1em; font-family:"Trebuchet MS",sans-serif; font-weight:normal; }
+h1 { font-size:218%; margin-top:0.6em; margin-bottom:.4em; line-height:1.1em; }
+h2 { font-size:175%; margin-bottom:.6em; line-height:1.2em; color:#092e20; }
+h3 { font-size:150%; font-weight:bold; margin-bottom:.2em; color:#487858; }
+h4 { font-size:125%; font-weight:bold; margin-top:1.5em; margin-bottom:3px; }
+h5 { font-size:110%; font-weight:bold; margin-top:1em; margin-bottom:3px; }
+h6,h7,h8,h9,h10,h11,h12 { font-weight:bold; margin-bottom:3px; }
+div.figure { text-align: center; }
+div.figure p.caption { font-size:1em; margin-top:0; margin-bottom:1.5em; color: #555;}
+hr { color:#ccc; background-color:#ccc; height:1px; border:0; }
+p, ul, dl { margin-top:.6em; margin-bottom:1em; padding-bottom: 0.1em;}
+#yui-main div.yui-b img { max-width: 50em; margin-left: auto; margin-right: auto; display: block; }
+caption { font-size:1em; font-weight:bold; margin-top:0.5em; margin-bottom:0.5em; margin-left: 2px; text-align: center; }
+blockquote { padding: 0 1em; margin: 1em 0; font:125%/1.2em "Trebuchet MS", sans-serif; color:#234f32; border-left:2px solid #94da3a; }
+strong { font-weight: bold; }
+em { font-style: italic; }
+ins { font-weight: bold; text-decoration: none; }
+
+/*** lists ***/
+ul { padding-left:30px; }
+ol { padding-left:30px; }
+ol.arabic li { list-style-type: decimal; }
+ul li { list-style-type:square; margin-bottom:.4em; }
+ul ul li { list-style-type:disc; }
+ul ul ul li { list-style-type:circle; }
+ol li { margin-bottom: .4em; }
+ul ul { padding-left:1.2em; }
+ul ul ul { padding-left:1em; }
+ul.linklist, ul.toc { padding-left:0; }
+ul.toc ul { margin-left:.6em; }
+ul.toc ul li { list-style-type:square; }
+ul.toc ul ul li { list-style-type:disc; }
+ul.linklist li, ul.toc li { list-style-type:none; }
+dt { font-weight:bold; margin-top:.5em; font-size:1.1em; }
+dd { margin-bottom:.8em; }
+ol.toc { margin-bottom: 2em; }
+ol.toc li { font-size:125%; padding: .5em; line-height:1.2em; clear: right; }
+ol.toc li.b { background-color: #E0FFB8; }
+ol.toc li a:hover { background-color: transparent !important; text-decoration: underline !important; }
+ol.toc span.release-date { color:#487858; float: right; font-size: 85%; padding-right: .5em; }
+ol.toc span.comment-count { font-size: 75%; color: #999; }
+
+/*** tables ***/
+table { color:#000; margin-bottom: 1em; width: 100%; }
+table.docutils td p { margin-top:0; margin-bottom:.5em; }
+table.docutils td, table.docutils th { border-bottom:1px solid #dfdfdf; padding:4px 2px;}
+table.docutils thead th { border-bottom:2px solid #dfdfdf; text-align:left; font-weight: bold; white-space: nowrap; }
+table.docutils thead th p { margin: 0; padding: 0; }
+table.docutils { border-collapse:collapse; }
+
+/*** code blocks ***/
+.literal { color:#234f32; white-space:nowrap; }
+dt > tt.literal { white-space: normal; }
+#sidebar .literal { color:white; background:transparent; font-size:11px; }
+h4 .literal { color: #234f32; font-size: 13px; }
+pre { font-size:small; background:#E0FFB8; border:1px solid #94da3a; border-width:1px 0; margin: 1em 0; padding: .3em .4em; overflow: hidden; line-height: 1.3em; white-space: pre-wrap;}
+dt .literal, table .literal { background:none; }
+#bd a.reference { text-decoration: none; }
+#bd a.reference tt.literal { border-bottom: 1px #234f32 dotted; }
+div.code-block-caption { color: white; background-color: #234F32; margin: 0; padding: 2px 5px; width: 100%; font-family: monospace; font-size: small; line-height: 1.3em; }
+div.code-block-caption .literal {color: white; }
+div.literal-block-wrapper pre { margin-top: 0; }
+
+/* Restore colors of pygments hyperlinked code */
+#bd .highlight .k a:link, #bd .highlight .k a:visited { color: #000000; text-decoration: none; border-bottom: 1px dotted #000000; }
+#bd .highlight .nf a:link, #bd .highlight .nf a:visited { color: #990000; text-decoration: none; border-bottom: 1px dotted #990000; }
+
+
+/*** notes & admonitions ***/
+.note, .admonition { padding:.8em 1em .8em; margin: 1em 0; border:1px solid #94da3a; }
+.admonition-title { font-weight:bold; margin-top:0 !important; margin-bottom:0 !important;}
+.admonition .last { margin-bottom:0 !important; }
+.note, .admonition { padding-left:65px; background:url(docicons-note.png) .8em .8em no-repeat;}
+div.admonition-philosophy { padding-left:65px; background:url(docicons-philosophy.png) .8em .8em no-repeat;}
+div.admonition-behind-the-scenes { padding-left:65px; background:url(docicons-behindscenes.png) .8em .8em no-repeat;}
+.admonition.warning { background:url(docicons-warning.png) .8em .8em no-repeat; border:1px solid #ffc83c;}
+
+/*** versionadded/changes ***/
+div.versionadded, div.versionchanged {  }
+div.versionadded span.title, div.versionchanged span.title, span.versionmodified { font-weight: bold; }
+div.versionadded, div.versionchanged, div.deprecated { color:#555; }
+
+/*** p-links ***/
+a.headerlink { color: #c60f0f; font-size: 0.8em; margin-left: 4px; opacity: 0; text-decoration: none; }
+h1:hover > a.headerlink, h2:hover > a.headerlink, h3:hover > a.headerlink, h4:hover > a.headerlink, h5:hover > a.headerlink, h6:hover > a.headerlink, dt:hover > a.headerlink { opacity: 1; }
+a.headerlink:focus { opacity: 1; }
+
+/*** index ***/
+table.indextable td { text-align: left; vertical-align: top;}
+table.indextable dl, table.indextable dd { margin-top: 0; margin-bottom: 0; }
+table.indextable tr.pcap { height: 10px; }
+table.indextable tr.cap { margin-top: 10px; background-color: #f2f2f2;}
+
+/*** page-specific overrides ***/
+div#contents ul { margin-bottom: 0;}
+div#contents ul li { margin-bottom: 0;}
+div#contents ul ul li { margin-top: 0.3em;}
+
+/*** IE hacks ***/
+* pre { width: 100%; }

testbed/django__django/docs/_theme/djangodocs/static/fontawesome/LICENSE.txt

@@ -0,0 +1,34 @@
+Font Awesome Free License
+-------------------------
+
+Font Awesome Free is free, open source, and GPL friendly. You can use it for
+commercial projects, open source projects, or really almost whatever you want.
+Full Font Awesome Free license: https://fontawesome.com/license.
+
+# Icons: CC BY 4.0 License (https://creativecommons.org/licenses/by/4.0/)
+In the Font Awesome Free download, the CC BY 4.0 license applies to all icons
+packaged as SVG and JS file types.
+
+# Fonts: SIL OFL 1.1 License (https://scripts.sil.org/OFL)
+In the Font Awesome Free download, the SIL OLF license applies to all icons
+packaged as web and desktop font files.
+
+# Code: MIT License (https://opensource.org/licenses/MIT)
+In the Font Awesome Free download, the MIT license applies to all non-font and
+non-icon files.
+
+# Attribution
+Attribution is required by MIT, SIL OLF, and CC BY licenses. Downloaded Font
+Awesome Free files already contain embedded comments with sufficient
+attribution, so you shouldn't need to do anything additional when using these
+files normally.
+
+We've kept attribution comments terse, so we ask that you do not actively work
+to remove them from files, especially code. They're a great way for folks to 
+learn about Font Awesome.
+
+# Brand Icons
+All brand icons are trademarks of their respective owners. The use of these
+trademarks does not indicate endorsement of the trademark holder by Font
+Awesome, nor vice versa. **Please do not use brand logos for any purpose except
+to represent the company, product, or service to which they refer.**

testbed/django__django/docs/_theme/djangodocs/static/fontawesome/README.md

@@ -0,0 +1,7 @@
+# Font Awesome 5.0.4
+
+Thanks for downloading Font Awesome! We're so excited you're here.
+
+Our documentation is available online. Just head here:
+
+https://fontawesome.com

testbed/django__django/docs/_theme/djangodocs/static/fontawesome/css/fa-brands.min.css

@@ -0,0 +1,5 @@
+/*!
+ * Font Awesome Free 5.0.4 by @fontawesome - http://fontawesome.com
+ * License - http://fontawesome.com/license (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License)
+ */
+@font-face{font-family:Font Awesome\ 5 Brands;font-style:normal;font-weight:400;src:url(../webfonts/fa-brands-400.eot);src:url(../webfonts/fa-brands-400.eot?#iefix) format("embedded-opentype"),url(../webfonts/fa-brands-400.woff2) format("woff2"),url(../webfonts/fa-brands-400.woff) format("woff"),url(../webfonts/fa-brands-400.ttf) format("truetype"),url(../webfonts/fa-brands-400.svg#fontawesome) format("svg")}.fab{font-family:Font Awesome\ 5 Brands}

testbed/django__django/docs/_theme/djangodocs/static/homepage.css

@@ -0,0 +1,22 @@
+#index p.rubric { font-size:150%; font-weight:normal; margin-bottom:.2em; color:#487858; }
+
+#index div.section dt { font-weight: normal; }
+
+#index #s-getting-help { float: right; width: 35em; background: #E1ECE2; padding: 1em; margin: 2em 0 2em 2em; }
+#index #s-getting-help h2 { margin: 0; }
+
+#index #s-django-documentation div.section div.section h3 { margin: 0; }
+#index #s-django-documentation div.section div.section { background: #E1ECE2; padding: 1em; margin: 2em 0 2em 40.3em; }
+#index #s-django-documentation div.section div.section a.reference { white-space: nowrap; }
+
+#index #s-using-django dl,
+#index #s-add-on-contrib-applications dl,
+#index #s-solving-specific-problems dl,
+#index #s-reference dl
+    { float: left; width: 41em; }
+
+#index #s-add-on-contrib-applications,
+#index #s-solving-specific-problems,
+#index #s-reference,
+#index #s-and-all-the-rest
+    { clear: left; }

testbed/django__django/docs/_theme/djangodocs/static/reset-fonts-grids.css

@@ -0,0 +1,8 @@
+/*
+Copyright (c) 2008, Yahoo! Inc. All rights reserved.
+Code licensed under the BSD License:
+http://developer.yahoo.net/yui/license.txt
+version: 2.5.1
+*/
+html{color:#000;background:#FFF;}body,div,dl,dt,dd,ul,ol,li,h1,h2,h3,h4,h5,h6,pre,code,form,fieldset,legend,input,textarea,p,blockquote,th,td{margin:0;padding:0;}table{border-collapse:collapse;border-spacing:0;}fieldset,img{border:0;}address,caption,cite,code,dfn,em,strong,th,var{font-style:normal;font-weight:normal;}li{list-style:none;}caption,th{text-align:left;}h1,h2,h3,h4,h5,h6{font-size:100%;font-weight:normal;}q:before,q:after{content:'';}abbr,acronym {border:0;font-variant:normal;}sup {vertical-align:text-top;}sub {vertical-align:text-bottom;}input,textarea,select{font-family:inherit;font-size:inherit;font-weight:inherit;}input,textarea,select{*font-size:100%;}legend{color:#000;}body {font:13px/1.231 arial,helvetica,clean,sans-serif;*font-size:small;*font:x-small;}table {font-size:inherit;font:100%;}pre,code,kbd,samp,tt{font-family:monospace;*font-size:108%;line-height:100%;}
+body{text-align:center;}#ft{clear:both;}#doc,#doc2,#doc3,#doc4,.yui-t1,.yui-t2,.yui-t3,.yui-t4,.yui-t5,.yui-t6,.yui-t7{margin:auto;text-align:left;width:57.69em;*width:56.25em;min-width:750px;}#doc2{width:73.076em;*width:71.25em;}#doc3{margin:auto 10px;width:auto;}#doc4{width:74.923em;*width:73.05em;}.yui-b{position:relative;}.yui-b{_position:static;}#yui-main .yui-b{position:static;}#yui-main{width:100%;}.yui-t1 #yui-main,.yui-t2 #yui-main,.yui-t3 #yui-main{float:right;margin-left:-25em;}.yui-t4 #yui-main,.yui-t5 #yui-main,.yui-t6 #yui-main{float:left;margin-right:-25em;}.yui-t1 .yui-b{float:left;width:12.30769em;*width:12.00em;}.yui-t1 #yui-main .yui-b{margin-left:13.30769em;*margin-left:13.05em;}.yui-t2 .yui-b{float:left;width:13.8461em;*width:13.50em;}.yui-t2 #yui-main .yui-b{margin-left:14.8461em;*margin-left:14.55em;}.yui-t3 .yui-b{float:left;width:23.0769em;*width:22.50em;}.yui-t3 #yui-main .yui-b{margin-left:24.0769em;*margin-left:23.62em;}.yui-t4 .yui-b{float:right;width:13.8456em;*width:13.50em;}.yui-t4 #yui-main .yui-b{margin-right:14.8456em;*margin-right:14.55em;}.yui-t5 .yui-b{float:right;width:18.4615em;*width:18.00em;}.yui-t5 #yui-main .yui-b{margin-right:19.4615em;*margin-right:19.125em;}.yui-t6 .yui-b{float:right;width:23.0769em;*width:22.50em;}.yui-t6 #yui-main .yui-b{margin-right:24.0769em;*margin-right:23.62em;}.yui-t7 #yui-main .yui-b{display:block;margin:0 0 1em 0;}#yui-main .yui-b{float:none;width:auto;}.yui-gb .yui-u,.yui-g .yui-gb .yui-u,.yui-gb .yui-g,.yui-gb .yui-gb,.yui-gb .yui-gc,.yui-gb .yui-gd,.yui-gb .yui-ge,.yui-gb .yui-gf,.yui-gc .yui-u,.yui-gc .yui-g,.yui-gd .yui-u{float:left;}.yui-g .yui-u,.yui-g .yui-g,.yui-g .yui-gb,.yui-g .yui-gc,.yui-g .yui-gd,.yui-g .yui-ge,.yui-g .yui-gf,.yui-gc .yui-u,.yui-gd .yui-g,.yui-g .yui-gc .yui-u,.yui-ge .yui-u,.yui-ge .yui-g,.yui-gf .yui-g,.yui-gf .yui-u{float:right;}.yui-g div.first,.yui-gb div.first,.yui-gc div.first,.yui-gd div.first,.yui-ge div.first,.yui-gf div.first,.yui-g .yui-gc div.first,.yui-g .yui-ge div.first,.yui-gc div.first div.first{float:left;}.yui-g .yui-u,.yui-g .yui-g,.yui-g .yui-gb,.yui-g .yui-gc,.yui-g .yui-gd,.yui-g .yui-ge,.yui-g .yui-gf{width:49.1%;}.yui-gb .yui-u,.yui-g .yui-gb .yui-u,.yui-gb .yui-g,.yui-gb .yui-gb,.yui-gb .yui-gc,.yui-gb .yui-gd,.yui-gb .yui-ge,.yui-gb .yui-gf,.yui-gc .yui-u,.yui-gc .yui-g,.yui-gd .yui-u{width:32%;margin-left:1.99%;}.yui-gb .yui-u{*margin-left:1.9%;*width:31.9%;}.yui-gc div.first,.yui-gd .yui-u{width:66%;}.yui-gd div.first{width:32%;}.yui-ge div.first,.yui-gf .yui-u{width:74.2%;}.yui-ge .yui-u,.yui-gf div.first{width:24%;}.yui-g .yui-gb div.first,.yui-gb div.first,.yui-gc div.first,.yui-gd div.first{margin-left:0;}.yui-g .yui-g .yui-u,.yui-gb .yui-g .yui-u,.yui-gc .yui-g .yui-u,.yui-gd .yui-g .yui-u,.yui-ge .yui-g .yui-u,.yui-gf .yui-g .yui-u{width:49%;*width:48.1%;*margin-left:0;}.yui-g .yui-gb div.first,.yui-gb .yui-gb div.first{*margin-right:0;*width:32%;_width:31.7%;}.yui-g .yui-gc div.first,.yui-gd .yui-g{width:66%;}.yui-gb .yui-g div.first{*margin-right:4%;_margin-right:1.3%;}.yui-gb .yui-gc div.first,.yui-gb .yui-gd div.first{*margin-right:0;}.yui-gb .yui-gb .yui-u,.yui-gb .yui-gc .yui-u{*margin-left:1.8%;_margin-left:4%;}.yui-g .yui-gb .yui-u{_margin-left:1.0%;}.yui-gb .yui-gd .yui-u{*width:66%;_width:61.2%;}.yui-gb .yui-gd div.first{*width:31%;_width:29.5%;}.yui-g .yui-gc .yui-u,.yui-gb .yui-gc .yui-u{width:32%;_float:right;margin-right:0;_margin-left:0;}.yui-gb .yui-gc div.first{width:66%;*float:left;*margin-left:0;}.yui-gb .yui-ge .yui-u,.yui-gb .yui-gf .yui-u{margin:0;}.yui-gb .yui-gb .yui-u{_margin-left:.7%;}.yui-gb .yui-g div.first,.yui-gb .yui-gb div.first{*margin-left:0;}.yui-gc .yui-g .yui-u,.yui-gd .yui-g .yui-u{*width:48.1%;*margin-left:0;}s .yui-gb .yui-gd div.first{width:32%;}.yui-g .yui-gd div.first{_width:29.9%;}.yui-ge .yui-g{width:24%;}.yui-gf .yui-g{width:74.2%;}.yui-gb .yui-ge div.yui-u,.yui-gb .yui-gf div.yui-u{float:right;}.yui-gb .yui-ge div.first,.yui-gb .yui-gf div.first{float:left;}.yui-gb .yui-ge .yui-u,.yui-gb .yui-gf div.first{*width:24%;_width:20%;}.yui-gb .yui-ge div.first,.yui-gb .yui-gf .yui-u{*width:73.5%;_width:65.5%;}.yui-ge div.first .yui-gd .yui-u{width:65%;}.yui-ge div.first .yui-gd div.first{width:32%;}#bd:after,.yui-g:after,.yui-gb:after,.yui-gc:after,.yui-gd:after,.yui-ge:after,.yui-gf:after{content:".";display:block;height:0;clear:both;visibility:hidden;}#bd,.yui-g,.yui-gb,.yui-gc,.yui-gd,.yui-ge,.yui-gf{zoom:1;}

testbed/django__django/docs/_theme/djangodocs/theme.conf

@@ -0,0 +1,4 @@
+[theme]
+inherit = basic
+stylesheet = default.css
+pygments_style = trac

testbed/django__django/docs/faq/admin.txt

@@ -0,0 +1,111 @@
+==============
+FAQ: The admin
+==============
+
+I can't log in. When I enter a valid username and password, it just brings up the login page again, with no error messages.
+===========================================================================================================================
+
+The login cookie isn't being set correctly, because the domain of the cookie
+sent out by Django doesn't match the domain in your browser. Try setting the
+:setting:`SESSION_COOKIE_DOMAIN` setting to match your domain. For example, if
+you're going to "https://www.example.com/admin/" in your browser, set
+``SESSION_COOKIE_DOMAIN = 'www.example.com'``.
+
+I can't log in. When I enter a valid username and password, it brings up the login page again, with a "Please enter a correct username and password" error.
+===========================================================================================================================================================
+
+If you're sure your username and password are correct, make sure your user
+account has :attr:`~django.contrib.auth.models.User.is_active` and
+:attr:`~django.contrib.auth.models.User.is_staff` set to True. The admin site
+only allows access to users with those two fields both set to True.
+
+How do I automatically set a field's value to the user who last edited the object in the admin?
+===============================================================================================
+
+The :class:`~django.contrib.admin.ModelAdmin` class provides customization hooks
+that allow you to transform an object as it saved, using details from the
+request. By extracting the current user from the request, and customizing the
+:meth:`~django.contrib.admin.ModelAdmin.save_model` hook, you can update an
+object to reflect the user that edited it. See :ref:`the documentation on
+ModelAdmin methods <model-admin-methods>` for an example.
+
+How do I limit admin access so that objects can only be edited by the users who created them?
+=============================================================================================
+
+The :class:`~django.contrib.admin.ModelAdmin` class also provides customization
+hooks that allow you to control the visibility and editability of objects in the
+admin. Using the same trick of extracting the user from the request, the
+:meth:`~django.contrib.admin.ModelAdmin.get_queryset` and
+:meth:`~django.contrib.admin.ModelAdmin.has_change_permission` can be used to
+control the visibility and editability of objects in the admin.
+
+My admin-site CSS and images showed up fine using the development server, but they're not displaying when using mod_wsgi.
+=========================================================================================================================
+
+See :ref:`serving the admin files <serving-the-admin-files>`
+in the "How to use Django with mod_wsgi" documentation.
+
+My "list_filter" contains a ManyToManyField, but the filter doesn't display.
+============================================================================
+
+Django won't bother displaying the filter for a ``ManyToManyField`` if there
+are no related objects.
+
+For example, if your :attr:`~django.contrib.admin.ModelAdmin.list_filter`
+includes :doc:`sites </ref/contrib/sites>`, and there are no sites in your
+database, it won't display a "Site" filter. In that case, filtering by site
+would be meaningless.
+
+Some objects aren't appearing in the admin.
+===========================================
+
+Inconsistent row counts may be caused by missing foreign key values or a
+foreign key field incorrectly set to :attr:`null=False
+<django.db.models.Field.null>`. If you have a record with a
+:class:`~django.db.models.ForeignKey` pointing to a nonexistent object and
+that foreign key is included is
+:attr:`~django.contrib.admin.ModelAdmin.list_display`, the record will not be
+shown in the admin changelist because the Django model is declaring an
+integrity constraint that is not implemented at the database level.
+
+How can I customize the functionality of the admin interface?
+=============================================================
+
+You've got several options. If you want to piggyback on top of an add/change
+form that Django automatically generates, you can attach arbitrary JavaScript
+modules to the page via the model's class Admin :ref:`js parameter
+<modeladmin-asset-definitions>`. That parameter is a list of URLs, as strings,
+pointing to JavaScript modules that will be included within the admin form via
+a ``<script>`` tag.
+
+If you want more flexibility than is feasible by tweaking the auto-generated
+forms, feel free to write custom views for the admin. The admin is powered by
+Django itself, and you can write custom views that hook into the authentication
+system, check permissions and do whatever else they need to do.
+
+If you want to customize the look-and-feel of the admin interface, read the
+next question.
+
+The dynamically-generated admin site is ugly! How can I change it?
+==================================================================
+
+We like it, but if you don't agree, you can modify the admin site's
+presentation by editing the CSS stylesheet and/or associated image files. The
+site is built using semantic HTML and plenty of CSS hooks, so any changes you'd
+like to make should be possible by editing the stylesheet.
+
+.. _admin-browser-support:
+
+What browsers are supported for using the admin?
+================================================
+
+The admin provides a fully-functional experience to the recent versions of
+modern, web standards compliant browsers. On desktop this means Chrome, Edge,
+Firefox, Opera, Safari, and others.
+
+On mobile and tablet devices, the admin provides a responsive experience for
+web standards compliant browsers. This includes the major browsers on both
+Android and iOS.
+
+Depending on feature support, there *may* be minor stylistic differences
+between browsers. These are considered acceptable variations in rendering.

testbed/django__django/docs/faq/contributing.txt

@@ -0,0 +1,107 @@
+======================
+FAQ: Contributing code
+======================
+
+.. _new-contributors-faq:
+
+How can I get started contributing code to Django?
+==================================================
+
+Thanks for asking! We've written an entire document devoted to this question.
+It's titled :doc:`Contributing to Django </internals/contributing/index>`.
+
+I submitted a bug fix in the ticket system several weeks ago. Why are you ignoring my patch?
+============================================================================================
+
+Don't worry: We're not ignoring you!
+
+It's important to understand there is a difference between "a ticket is being
+ignored" and "a ticket has not been attended to yet." Django's ticket system
+contains hundreds of open tickets, of various degrees of impact on end-user
+functionality, and Django's developers have to review and prioritize.
+
+On top of that: the people who work on Django are all volunteers. As a result,
+the amount of time that we have to work on the framework is limited and will
+vary from week to week depending on our spare time. If we're busy, we may not
+be able to spend as much time on Django as we might want.
+
+The best way to make sure tickets do not get hung up on the way to checkin is
+to make it dead easy, even for someone who may not be intimately familiar with
+that area of the code, to understand the problem and verify the fix:
+
+* Are there clear instructions on how to reproduce the bug? If this
+  touches a dependency (such as Pillow), a contrib module, or a specific
+  database, are those instructions clear enough even for someone not
+  familiar with it?
+
+* If there are several patches attached to the ticket, is it clear what
+  each one does, which ones can be ignored and which matter?
+
+* Does the patch include a unit test? If not, is there a very clear
+  explanation why not? A test expresses succinctly what the problem is,
+  and shows that the patch actually fixes it.
+
+If your patch stands no chance of inclusion in Django, we won't ignore it --
+we'll just close the ticket. So if your ticket is still open, it doesn't mean
+we're ignoring you; it just means we haven't had time to look at it yet.
+
+When and how might I remind the team of a patch I care about?
+=============================================================
+
+A polite, well-timed message to the mailing list is one way to get attention.
+To determine the right time, you need to keep an eye on the schedule. If you
+post your message right before a release deadline, you're not likely to get the
+sort of attention you require.
+
+Gentle IRC reminders can also work -- again, strategically timed if possible.
+During a bug sprint would be a very good time, for example.
+
+Another way to get traction is to pull several related tickets together. When
+someone sits down to review a bug in an area they haven't touched for
+a while, it can take a few minutes to remember all the fine details of how
+that area of code works. If you collect several minor bug fixes together into
+a similarly themed group, you make an attractive target, as the cost of coming
+up to speed on an area of code can be spread over multiple tickets.
+
+Please refrain from emailing anyone personally or repeatedly raising the same
+issue over and over again. This sort of behavior will not gain you any
+additional attention -- certainly not the attention that you need in order to
+get your issue addressed.
+
+But I've reminded you several times and you keep ignoring my patch!
+===================================================================
+
+Seriously - we're not ignoring you. If your patch stands no chance of
+inclusion in Django, we'll close the ticket. For all the other tickets, we
+need to prioritize our efforts, which means that some tickets will be
+addressed before others.
+
+One of the criteria that is used to prioritize bug fixes is the number of
+people that will likely be affected by a given bug. Bugs that have the
+potential to affect many people will generally get priority over those that
+are edge cases.
+
+Another reason that a bug might be ignored for a while is if the bug is a
+symptom of a larger problem. While we can spend time writing, testing and
+applying lots of little patches, sometimes the right solution is to rebuild. If
+a rebuild or refactor of a particular component has been proposed or is
+underway, you may find that bugs affecting that component will not get as much
+attention. Again, this is a matter of prioritizing scarce resources. By
+concentrating on the rebuild, we can close all the little bugs at once, and
+hopefully prevent other little bugs from appearing in the future.
+
+Whatever the reason, please keep in mind that while you may hit a particular
+bug regularly, it doesn't necessarily follow that every single Django user
+will hit the same bug. Different users use Django in different ways, stressing
+different parts of the code under different conditions. When we evaluate the
+relative priorities, we are generally trying to consider the needs of the
+entire community, instead of prioritizing the impact on one particular user.
+This doesn't mean that we think your problem is unimportant -- just that in the
+limited time we have available, we will always err on the side of making 10
+people happy rather than making a single person happy.
+
+I'm sure my ticket is absolutely 100% perfect, can I mark it as "Ready For Checkin" myself?
+===========================================================================================
+
+Sorry, no. It's always better to get another set of eyes on a ticket. If
+you're having trouble getting that second set of eyes, see questions above.

testbed/django__django/docs/faq/general.txt

@@ -0,0 +1,219 @@
+============
+FAQ: General
+============
+
+Why does this project exist?
+============================
+
+Django grew from a very practical need: World Online, a newspaper web
+operation, is responsible for building intensive web applications on journalism
+deadlines. In the fast-paced newsroom, World Online often has only a matter of
+hours to take a complicated web application from concept to public launch.
+
+At the same time, the World Online web developers have consistently been
+perfectionists when it comes to following best practices of web development.
+
+In fall 2003, the World Online developers (Adrian Holovaty and Simon Willison)
+ditched PHP and began using Python to develop its websites. As they built
+intensive, richly interactive sites such as Lawrence.com, they began to extract
+a generic web development framework that let them build web applications more
+and more quickly. They tweaked this framework constantly, adding improvements
+over two years.
+
+In summer 2005, World Online decided to open-source the resulting software,
+Django. Django would not be possible without a whole host of open-source
+projects -- `Apache`_, `Python`_, and `PostgreSQL`_ to name a few -- and we're
+thrilled to be able to give something back to the open-source community.
+
+.. _Apache: https://httpd.apache.org/
+.. _Python: https://www.python.org/
+.. _PostgreSQL: https://www.postgresql.org/
+
+What does "Django" mean, and how do you pronounce it?
+=====================================================
+
+Django is named after `Django Reinhardt`_, a jazz manouche guitarist from the 1930s
+to early 1950s. To this day, he's considered one of the best guitarists of all time.
+
+Listen to his music. You'll like it.
+
+Django is pronounced **JANG**-oh. Rhymes with FANG-oh. The "D" is silent.
+
+We've also recorded an `audio clip of the pronunciation`_.
+
+.. _Django Reinhardt: https://en.wikipedia.org/wiki/Django_Reinhardt
+.. _audio clip of the pronunciation: https://www.red-bean.com/~adrian/django_pronunciation.mp3
+
+Is Django stable?
+=================
+
+Yes, it's quite stable. Companies like Disqus, Instagram, Pinterest, and
+Mozilla have been using Django for many years. Sites built on Django have
+weathered traffic spikes of over 50 thousand hits per second.
+
+Does Django scale?
+==================
+
+Yes. Compared to development time, hardware is cheap, and so Django is
+designed to take advantage of as much hardware as you can throw at it.
+
+Django uses a "shared-nothing" architecture, which means you can add hardware
+at any level -- database servers, caching servers or web/application servers.
+
+The framework cleanly separates components such as its database layer and
+application layer. And it ships with a simple-yet-powerful
+:doc:`cache framework </topics/cache>`.
+
+Who's behind this?
+==================
+
+Django was originally developed at World Online, the web department of a
+newspaper in Lawrence, Kansas, USA. Django's now run by an international
+`team of volunteers <https://www.djangoproject.com/foundation/teams/>`_.
+
+How is Django licensed?
+=======================
+
+Django is distributed under :source:`the 3-clause BSD license <LICENSE>`. This
+is an open source license granting broad permissions to modify and redistribute
+Django.
+
+Why does Django include Python's license file?
+==============================================
+
+Django includes code from the Python standard library. Python is distributed
+under a permissive open source license. :source:`A copy of the Python license
+<LICENSE.python>` is included with Django for compliance with Python's terms.
+
+Which sites use Django?
+=======================
+
+`DjangoSites.org`_ features a constantly growing list of Django-powered sites.
+
+.. _DjangoSites.org: https://djangosites.org
+
+.. _faq-mtv:
+
+Django appears to be a MVC framework, but you call the Controller the "view", and the View the "template". How come you don't use the standard names?
+=====================================================================================================================================================
+
+Well, the standard names are debatable.
+
+In our interpretation of MVC, the "view" describes the data that gets presented
+to the user. It's not necessarily *how* the data *looks*, but *which* data is
+presented. The view describes *which data you see*, not *how you see it.* It's
+a subtle distinction.
+
+So, in our case, a "view" is the Python callback function for a particular URL,
+because that callback function describes which data is presented.
+
+Furthermore, it's sensible to separate content from presentation -- which is
+where templates come in. In Django, a "view" describes which data is presented,
+but a view normally delegates to a template, which describes *how* the data is
+presented.
+
+Where does the "controller" fit in, then? In Django's case, it's probably the
+framework itself: the machinery that sends a request to the appropriate view,
+according to the Django URL configuration.
+
+If you're hungry for acronyms, you might say that Django is a "MTV" framework
+-- that is, "model", "template", and "view." That breakdown makes much more
+sense.
+
+At the end of the day, it comes down to getting stuff done. And, regardless of
+how things are named, Django gets stuff done in a way that's most logical to
+us.
+
+<Framework X> does <feature Y> -- why doesn't Django?
+=====================================================
+
+We're well aware that there are other awesome web frameworks out there, and
+we're not averse to borrowing ideas where appropriate. However, Django was
+developed precisely because we were unhappy with the status quo, so please be
+aware that "because <Framework X> does it" is not going to be sufficient reason
+to add a given feature to Django.
+
+Why did you write all of Django from scratch, instead of using other Python libraries?
+======================================================================================
+
+When Django was originally written, Adrian and Simon spent quite a bit of time
+exploring the various Python web frameworks available.
+
+In our opinion, none of them were completely up to snuff.
+
+We're picky. You might even call us perfectionists. (With deadlines.)
+
+Over time, we stumbled across open-source libraries that did things we'd
+already implemented. It was reassuring to see other people solving similar
+problems in similar ways, but it was too late to integrate outside code: We'd
+already written, tested and implemented our own framework bits in several
+production settings -- and our own code met our needs delightfully.
+
+In most cases, however, we found that existing frameworks/tools inevitably had
+some sort of fundamental, fatal flaw that made us squeamish. No tool fit our
+philosophies 100%.
+
+Like we said: We're picky.
+
+We've documented our philosophies on the
+:doc:`design philosophies page </misc/design-philosophies>`.
+
+Is Django a content-management-system (CMS)?
+============================================
+
+No, Django is not a CMS, or any sort of "turnkey product" in and of itself.
+It's a web framework; it's a programming tool that lets you build websites.
+
+For example, it doesn't make much sense to compare Django to something like
+Drupal_, because Django is something you use to *create* things like Drupal.
+
+Yes, Django's automatic admin site is fantastic and timesaving -- but the admin
+site is one module of Django the framework. Furthermore, although Django has
+special conveniences for building "CMS-y" apps, that doesn't mean it's not just
+as appropriate for building "non-CMS-y" apps (whatever that means!).
+
+.. _Drupal: https://www.drupal.org/
+
+How can I download the Django documentation to read it offline?
+===============================================================
+
+The Django docs are available in the ``docs`` directory of each Django tarball
+release. These docs are in reST (reStructuredText) format, and each text file
+corresponds to a web page on the official Django site.
+
+Because the documentation is :source:`stored in revision control <docs>`, you
+can browse documentation changes just like you can browse code changes.
+
+Technically, the docs on Django's site are generated from the latest development
+versions of those reST documents, so the docs on the Django site may offer more
+information than the docs that come with the latest Django release.
+
+How do I cite Django?
+=====================
+
+It's difficult to give an official citation format, for two reasons: citation
+formats can vary wildly between publications, and citation standards for
+software are still a matter of some debate.
+
+For example, `APA style`_,  would dictate something like:
+
+.. code-block:: text
+
+    Django (Version 1.5) [Computer Software]. (2013). Retrieved from https://www.djangoproject.com/.
+
+However, the only true guide is what your publisher will accept, so get a copy
+of those guidelines and fill in the gaps as best you can.
+
+If your referencing style guide requires a publisher name, use "Django Software
+Foundation".
+
+If you need a publishing location, use "Lawrence, Kansas".
+
+If you need a web address, use https://www.djangoproject.com/.
+
+If you need a name, just use "Django", without any tagline.
+
+If you need a publication date, use the year of release of the version you're
+referencing (e.g., 2013 for v1.5)
+
+.. _APA style: https://apastyle.apa.org/

testbed/django__django/docs/faq/help.txt

@@ -0,0 +1,93 @@
+=================
+FAQ: Getting Help
+=================
+
+How do I do X? Why doesn't Y work? Where can I go to get help?
+==============================================================
+
+First, please check if your question is answered on the :doc:`FAQ
+</faq/index>`. Also, search for answers using your favorite search engine, and
+in `the forum`_.
+
+.. _`the forum`: https://forum.djangoproject.com/
+
+If you can't find an answer, please take a few minutes to formulate your
+question well. Explaining the problems you are facing clearly will help others
+help you. See the StackOverflow guide on `asking good questions`_.
+
+.. _`asking good questions`: https://stackoverflow.com/help/how-to-ask
+
+Then, please post it in one of the following channels:
+
+* The Django Forum section `"Using Django"`_. This is for web-based
+  discussions.
+* The |django-users| mailing list. This is for email-based discussions.
+* The `#django IRC channel`_ on the Libera.Chat IRC network. This is for
+  chat-based discussions. If you're new to IRC, see the `Libera.Chat
+  documentation`_ for different ways to connect.
+
+.. _`"Using Django"`: https://forum.djangoproject.com/c/users/6
+.. _#django IRC channel: https://web.libera.chat/#django
+.. _Libera.Chat documentation: https://libera.chat/guides/connect
+
+In all these channels please abide by the `Django Code of Conduct`_. In
+summary, being friendly and patient, considerate, respectful, and careful in
+your choice of words.
+
+.. _Django Code of Conduct: https://www.djangoproject.com/conduct/
+
+.. _message-does-not-appear-on-django-users:
+
+Why hasn't my message appeared on *django-users*?
+=================================================
+
+|django-users| has a lot of subscribers. This is good for the community, as
+it means many people are available to contribute answers to questions.
+Unfortunately, it also means that |django-users| is an attractive target for
+spammers.
+
+In order to combat the spam problem, when you join the |django-users| mailing
+list, we manually moderate the first message you send to the list. This means
+that spammers get caught, but it also means that your first question to the
+list might take a little longer to get answered. We apologize for any
+inconvenience that this policy may cause.
+
+Nobody answered my question! What should I do?
+==============================================
+
+Try making your question more specific, or provide a better example of your
+problem.
+
+As with most open-source projects, the folks on these channels are volunteers.
+If nobody has answered your question, it may be because nobody knows the
+answer, it may be because nobody can understand the question, or it may be that
+everybody that can help is busy.
+
+You can also try asking on a different channel. But please don't post your
+question in all three channels in quick succession.
+
+You might notice we have a second mailing list, called |django-developers|.
+This list is for discussion of the development of Django itself. Please don't
+email support questions to this mailing list. Asking a tech support question
+there is considered impolite, and you will likely be directed to ask on
+|django-users|.
+
+I think I've found a bug! What should I do?
+===========================================
+
+Detailed instructions on how to handle a potential bug can be found in our
+:ref:`Guide to contributing to Django <reporting-bugs>`.
+
+I think I've found a security problem! What should I do?
+========================================================
+
+If you think you've found a security problem with Django, please send a message
+to security@djangoproject.com. This is a private list only open to long-time,
+highly trusted Django developers, and its archives are not publicly readable.
+
+Due to the sensitive nature of security issues, we ask that if you think you
+have found a security problem, *please* don't post a message on the forum, IRC,
+or one of the public mailing lists. Django has a
+:ref:`policy for handling security issues <reporting-security-issues>`;
+while a defect is outstanding, we would like to minimize any damage that
+could be inflicted through public knowledge of that defect.

testbed/django__django/docs/faq/index.txt

@@ -0,0 +1,15 @@
+==========
+Django FAQ
+==========
+
+.. toctree::
+   :maxdepth: 2
+
+   general
+   install
+   usage
+   help
+   models
+   admin
+   contributing
+   troubleshooting

testbed/django__django/docs/faq/install.txt

@@ -0,0 +1,90 @@
+=================
+FAQ: Installation
+=================
+
+How do I get started?
+=====================
+
+#. `Download the code`_.
+#. Install Django (read the :doc:`installation guide </intro/install>`).
+#. Walk through the :doc:`tutorial </intro/tutorial01>`.
+#. Check out the rest of the :doc:`documentation </index>`, and `ask questions`_ if you
+   run into trouble.
+
+.. _`Download the code`: https://www.djangoproject.com/download/
+.. _ask questions: https://www.djangoproject.com/community/
+
+What are Django's prerequisites?
+================================
+
+Django requires Python. See the table in the next question for the versions of
+Python that work with each version of Django. Other Python libraries may be
+required for some use cases, but you'll receive an error about them as they're
+needed.
+
+For a development environment -- if you just want to experiment with Django --
+you don't need to have a separate web server installed or database server.
+
+Django comes with its own :djadmin:`lightweight development server<runserver>`.
+For a production environment, Django follows the WSGI spec, :pep:`3333`, which
+means it can run on a variety of web servers. See :doc:`Deploying Django
+</howto/deployment/index>` for more information.
+
+Django runs `SQLite`_ by default, which is included in Python installations.
+For a production environment, we recommend PostgreSQL_; but we also officially
+support MariaDB_, MySQL_, `SQLite`_, and Oracle_. See :doc:`Supported Databases
+</ref/databases>` for more information.
+
+.. _Python: https://www.python.org/
+.. _PostgreSQL: https://www.postgresql.org/
+.. _MariaDB: https://mariadb.org/
+.. _MySQL: https://www.mysql.com/
+.. _`SQLite`: https://www.sqlite.org/
+.. _Oracle: https://www.oracle.com/
+
+.. _faq-python-version-support:
+
+What Python version can I use with Django?
+==========================================
+
+============== ===============
+Django version Python versions
+============== ===============
+3.2            3.6, 3.7, 3.8, 3.9, 3.10 (added in 3.2.9)
+4.0            3.8, 3.9, 3.10
+4.1            3.8, 3.9, 3.10, 3.11 (added in 4.1.3)
+4.2            3.8, 3.9, 3.10, 3.11
+5.0            3.10, 3.11, 3.12
+============== ===============
+
+For each version of Python, only the latest micro release (A.B.C) is officially
+supported. You can find the latest micro version for each series on the `Python
+download page <https://www.python.org/downloads/>`_.
+
+Typically, we will support a Python version up to and including the first
+Django LTS release whose security support ends after security support for that
+version of Python ends. For example, Python 3.3 security support ended
+September 2017 and Django 1.8 LTS security support ended April 2018. Therefore
+Django 1.8 is the last version to support Python 3.3.
+
+What Python version should I use with Django?
+=============================================
+
+Since newer versions of Python are often faster, have more features, and are
+better supported, the latest version of Python 3 is recommended.
+
+You don't lose anything in Django by using an older release, but you don't take
+advantage of the improvements and optimizations in newer Python releases.
+Third-party applications for use with Django are free to set their own version
+requirements.
+
+Should I use the stable version or development version?
+=======================================================
+
+Generally, if you're using code in production, you should be using a
+stable release. The Django project publishes a full stable release
+every eight months or so, with bugfix updates in between. These stable
+releases contain the API that is covered by our backwards
+compatibility guarantees; if you write code against stable releases,
+you shouldn't have any problems upgrading when the next official
+version is released.

testbed/django__django/docs/faq/models.txt

@@ -0,0 +1,97 @@
+=========================
+FAQ: Databases and models
+=========================
+
+.. _faq-see-raw-sql-queries:
+
+How can I see the raw SQL queries Django is running?
+====================================================
+
+Make sure your Django :setting:`DEBUG` setting is set to ``True``.
+Then do this:
+
+.. code-block:: pycon
+
+    >>> from django.db import connection
+    >>> connection.queries
+    [{'sql': 'SELECT polls_polls.id, polls_polls.question, polls_polls.pub_date FROM polls_polls',
+    'time': '0.002'}]
+
+``connection.queries`` is only available if :setting:`DEBUG` is ``True``.
+It's a list of dictionaries in order of query execution. Each dictionary has
+the following:
+
+* ``sql`` - The raw SQL statement
+* ``time`` - How long the statement took to execute, in seconds.
+
+``connection.queries`` includes all SQL statements -- INSERTs, UPDATES,
+SELECTs, etc. Each time your app hits the database, the query will be recorded.
+
+If you are using :doc:`multiple databases</topics/db/multi-db>`, you can use the
+same interface on each member of the ``connections`` dictionary:
+
+.. code-block:: pycon
+
+    >>> from django.db import connections
+    >>> connections["my_db_alias"].queries
+
+If you need to clear the query list manually at any point in your functions,
+call ``reset_queries()``, like this::
+
+    from django.db import reset_queries
+
+    reset_queries()
+
+Can I use Django with a preexisting database?
+=============================================
+
+Yes. See :doc:`Integrating with a legacy database </howto/legacy-databases>`.
+
+If I make changes to a model, how do I update the database?
+===========================================================
+
+Take a look at Django's support for :mod:`schema migrations
+<django.db.migrations>`.
+
+If you don't mind clearing data, your project's ``manage.py`` utility has a
+:djadmin:`flush` option to reset the database to the state it was in
+immediately after :djadmin:`migrate` was executed.
+
+Do Django models support multiple-column primary keys?
+======================================================
+
+No. Only single-column primary keys are supported.
+
+But this isn't an issue in practice, because there's nothing stopping you from
+adding other constraints (using the ``unique_together`` model option or
+creating the constraint directly in your database), and enforcing the
+uniqueness at that level. Single-column primary keys are needed for things such
+as the admin interface to work; e.g., you need a single value to specify
+an object to edit or delete.
+
+Does Django support NoSQL databases?
+====================================
+
+NoSQL databases are not officially supported by Django itself. There are,
+however, a number of side projects and forks which allow NoSQL functionality in
+Django.
+
+You can take a look on `the wiki page`_ which discusses some projects.
+
+.. _the wiki page: https://code.djangoproject.com/wiki/NoSqlSupport
+
+How do I add database-specific options to my CREATE TABLE statements, such as specifying MyISAM as the table type?
+==================================================================================================================
+
+We try to avoid adding special cases in the Django code to accommodate all the
+database-specific options such as table type, etc. If you'd like to use any of
+these options, create a migration with a
+:class:`~django.db.migrations.operations.RunSQL` operation that contains
+``ALTER TABLE`` statements that do what you want to do.
+
+For example, if you're using MySQL and want your tables to use the MyISAM table
+type, use the following SQL:
+
+.. code-block:: sql
+
+    ALTER TABLE myapp_mytable ENGINE=MyISAM;

testbed/django__django/docs/faq/troubleshooting.txt

@@ -0,0 +1,57 @@
+===============
+Troubleshooting
+===============
+
+This page contains some advice about errors and problems commonly encountered
+during the development of Django applications.
+
+.. _troubleshooting-django-admin:
+
+Problems running ``django-admin``
+=================================
+
+``command not found: django-admin``
+-----------------------------------
+
+:doc:`django-admin </ref/django-admin>` should be on your system path if you
+installed Django via ``pip``. If it's not in your path, ensure you have your
+virtual environment activated and you can try running the equivalent command
+``python -m django``.
+
+macOS permissions
+-----------------
+
+If you're using macOS, you may see the message "permission denied" when
+you try to run ``django-admin``. This is because, on Unix-based systems like
+macOS, a file must be marked as "executable" before it can be run as a program.
+To do this, open Terminal.app and navigate (using the ``cd`` command) to the
+directory where :doc:`django-admin </ref/django-admin>` is installed, then
+run the command ``sudo chmod +x django-admin``.
+
+Miscellaneous
+=============
+
+I'm getting a ``UnicodeDecodeError``. What am I doing wrong?
+------------------------------------------------------------
+
+This class of errors happen when a bytestring containing non-ASCII sequences is
+transformed into a Unicode string and the specified encoding is incorrect. The
+output generally looks like this:
+
+.. code-block:: pytb
+
+    UnicodeDecodeError: 'ascii' codec can't decode byte 0x?? in position ?:
+    ordinal not in range(128)
+
+The resolution mostly depends on the context, however here are two common
+pitfalls producing this error:
+
+* Your system locale may be a default ASCII locale, like the "C" locale on
+  UNIX-like systems (can be checked by the ``locale`` command). If it's the
+  case, please refer to your system documentation to learn how you can change
+  this to a UTF-8 locale.
+
+Related resources:
+
+* :doc:`Unicode in Django </ref/unicode>`
+* https://wiki.python.org/moin/UnicodeDecodeError