Add files using upload-large-folder tool

testbed/django__django/django/utils/ipv6.py

@@ -0,0 +1,47 @@
+import ipaddress
+
+from django.core.exceptions import ValidationError
+from django.utils.translation import gettext_lazy as _
+
+
+def clean_ipv6_address(
+    ip_str, unpack_ipv4=False, error_message=_("This is not a valid IPv6 address.")
+):
+    """
+    Clean an IPv6 address string.
+
+    Raise ValidationError if the address is invalid.
+
+    Replace the longest continuous zero-sequence with "::", remove leading
+    zeroes, and make sure all hextets are lowercase.
+
+    Args:
+        ip_str: A valid IPv6 address.
+        unpack_ipv4: if an IPv4-mapped address is found,
+        return the plain IPv4 address (default=False).
+        error_message: An error message used in the ValidationError.
+
+    Return a compressed IPv6 address or the same value.
+    """
+    try:
+        addr = ipaddress.IPv6Address(int(ipaddress.IPv6Address(ip_str)))
+    except ValueError:
+        raise ValidationError(error_message, code="invalid")
+
+    if unpack_ipv4 and addr.ipv4_mapped:
+        return str(addr.ipv4_mapped)
+    elif addr.ipv4_mapped:
+        return "::ffff:%s" % str(addr.ipv4_mapped)
+
+    return str(addr)
+
+
+def is_valid_ipv6_address(ip_str):
+    """
+    Return whether or not the `ip_str` string is a valid IPv6 address.
+    """
+    try:
+        ipaddress.IPv6Address(ip_str)
+    except ValueError:
+        return False
+    return True

testbed/django__django/django/utils/log.py

@@ -0,0 +1,250 @@
+import logging
+import logging.config  # needed when logging_config doesn't start with logging.config
+from copy import copy
+
+from django.conf import settings
+from django.core import mail
+from django.core.mail import get_connection
+from django.core.management.color import color_style
+from django.utils.module_loading import import_string
+
+request_logger = logging.getLogger("django.request")
+
+# Default logging for Django. This sends an email to the site admins on every
+# HTTP 500 error. Depending on DEBUG, all other log records are either sent to
+# the console (DEBUG=True) or discarded (DEBUG=False) by means of the
+# require_debug_true filter. This configuration is quoted in
+# docs/ref/logging.txt; please amend it there if edited here.
+DEFAULT_LOGGING = {
+    "version": 1,
+    "disable_existing_loggers": False,
+    "filters": {
+        "require_debug_false": {
+            "()": "django.utils.log.RequireDebugFalse",
+        },
+        "require_debug_true": {
+            "()": "django.utils.log.RequireDebugTrue",
+        },
+    },
+    "formatters": {
+        "django.server": {
+            "()": "django.utils.log.ServerFormatter",
+            "format": "[{server_time}] {message}",
+            "style": "{",
+        }
+    },
+    "handlers": {
+        "console": {
+            "level": "INFO",
+            "filters": ["require_debug_true"],
+            "class": "logging.StreamHandler",
+        },
+        "django.server": {
+            "level": "INFO",
+            "class": "logging.StreamHandler",
+            "formatter": "django.server",
+        },
+        "mail_admins": {
+            "level": "ERROR",
+            "filters": ["require_debug_false"],
+            "class": "django.utils.log.AdminEmailHandler",
+        },
+    },
+    "loggers": {
+        "django": {
+            "handlers": ["console", "mail_admins"],
+            "level": "INFO",
+        },
+        "django.server": {
+            "handlers": ["django.server"],
+            "level": "INFO",
+            "propagate": False,
+        },
+    },
+}
+
+
+def configure_logging(logging_config, logging_settings):
+    if logging_config:
+        # First find the logging configuration function ...
+        logging_config_func = import_string(logging_config)
+
+        logging.config.dictConfig(DEFAULT_LOGGING)
+
+        # ... then invoke it with the logging settings
+        if logging_settings:
+            logging_config_func(logging_settings)
+
+
+class AdminEmailHandler(logging.Handler):
+    """An exception log handler that emails log entries to site admins.
+
+    If the request is passed as the first argument to the log record,
+    request data will be provided in the email report.
+    """
+
+    def __init__(self, include_html=False, email_backend=None, reporter_class=None):
+        super().__init__()
+        self.include_html = include_html
+        self.email_backend = email_backend
+        self.reporter_class = import_string(
+            reporter_class or settings.DEFAULT_EXCEPTION_REPORTER
+        )
+
+    def emit(self, record):
+        try:
+            request = record.request
+            subject = "%s (%s IP): %s" % (
+                record.levelname,
+                (
+                    "internal"
+                    if request.META.get("REMOTE_ADDR") in settings.INTERNAL_IPS
+                    else "EXTERNAL"
+                ),
+                record.getMessage(),
+            )
+        except Exception:
+            subject = "%s: %s" % (record.levelname, record.getMessage())
+            request = None
+        subject = self.format_subject(subject)
+
+        # Since we add a nicely formatted traceback on our own, create a copy
+        # of the log record without the exception data.
+        no_exc_record = copy(record)
+        no_exc_record.exc_info = None
+        no_exc_record.exc_text = None
+
+        if record.exc_info:
+            exc_info = record.exc_info
+        else:
+            exc_info = (None, record.getMessage(), None)
+
+        reporter = self.reporter_class(request, is_email=True, *exc_info)
+        message = "%s\n\n%s" % (
+            self.format(no_exc_record),
+            reporter.get_traceback_text(),
+        )
+        html_message = reporter.get_traceback_html() if self.include_html else None
+        self.send_mail(subject, message, fail_silently=True, html_message=html_message)
+
+    def send_mail(self, subject, message, *args, **kwargs):
+        mail.mail_admins(
+            subject, message, *args, connection=self.connection(), **kwargs
+        )
+
+    def connection(self):
+        return get_connection(backend=self.email_backend, fail_silently=True)
+
+    def format_subject(self, subject):
+        """
+        Escape CR and LF characters.
+        """
+        return subject.replace("\n", "\\n").replace("\r", "\\r")
+
+
+class CallbackFilter(logging.Filter):
+    """
+    A logging filter that checks the return value of a given callable (which
+    takes the record-to-be-logged as its only parameter) to decide whether to
+    log a record.
+    """
+
+    def __init__(self, callback):
+        self.callback = callback
+
+    def filter(self, record):
+        if self.callback(record):
+            return 1
+        return 0
+
+
+class RequireDebugFalse(logging.Filter):
+    def filter(self, record):
+        return not settings.DEBUG
+
+
+class RequireDebugTrue(logging.Filter):
+    def filter(self, record):
+        return settings.DEBUG
+
+
+class ServerFormatter(logging.Formatter):
+    default_time_format = "%d/%b/%Y %H:%M:%S"
+
+    def __init__(self, *args, **kwargs):
+        self.style = color_style()
+        super().__init__(*args, **kwargs)
+
+    def format(self, record):
+        msg = record.msg
+        status_code = getattr(record, "status_code", None)
+
+        if status_code:
+            if 200 <= status_code < 300:
+                # Put 2XX first, since it should be the common case
+                msg = self.style.HTTP_SUCCESS(msg)
+            elif 100 <= status_code < 200:
+                msg = self.style.HTTP_INFO(msg)
+            elif status_code == 304:
+                msg = self.style.HTTP_NOT_MODIFIED(msg)
+            elif 300 <= status_code < 400:
+                msg = self.style.HTTP_REDIRECT(msg)
+            elif status_code == 404:
+                msg = self.style.HTTP_NOT_FOUND(msg)
+            elif 400 <= status_code < 500:
+                msg = self.style.HTTP_BAD_REQUEST(msg)
+            else:
+                # Any 5XX, or any other status code
+                msg = self.style.HTTP_SERVER_ERROR(msg)
+
+        if self.uses_server_time() and not hasattr(record, "server_time"):
+            record.server_time = self.formatTime(record, self.datefmt)
+
+        record.msg = msg
+        return super().format(record)
+
+    def uses_server_time(self):
+        return self._fmt.find("{server_time}") >= 0
+
+
+def log_response(
+    message,
+    *args,
+    response=None,
+    request=None,
+    logger=request_logger,
+    level=None,
+    exception=None,
+):
+    """
+    Log errors based on HttpResponse status.
+
+    Log 5xx responses as errors and 4xx responses as warnings (unless a level
+    is given as a keyword argument). The HttpResponse status_code and the
+    request are passed to the logger's extra parameter.
+    """
+    # Check if the response has already been logged. Multiple requests to log
+    # the same response can be received in some cases, e.g., when the
+    # response is the result of an exception and is logged when the exception
+    # is caught, to record the exception.
+    if getattr(response, "_has_been_logged", False):
+        return
+
+    if level is None:
+        if response.status_code >= 500:
+            level = "error"
+        elif response.status_code >= 400:
+            level = "warning"
+        else:
+            level = "info"
+
+    getattr(logger, level)(
+        message,
+        *args,
+        extra={
+            "status_code": response.status_code,
+            "request": request,
+        },
+        exc_info=exception,
+    )
+    response._has_been_logged = True

testbed/django__django/django/utils/numberformat.py

@@ -0,0 +1,105 @@
+from decimal import Decimal
+
+from django.conf import settings
+from django.utils.safestring import mark_safe
+
+
+def format(
+    number,
+    decimal_sep,
+    decimal_pos=None,
+    grouping=0,
+    thousand_sep="",
+    force_grouping=False,
+    use_l10n=None,
+):
+    """
+    Get a number (as a number or string), and return it as a string,
+    using formats defined as arguments:
+
+    * decimal_sep: Decimal separator symbol (for example ".")
+    * decimal_pos: Number of decimal positions
+    * grouping: Number of digits in every group limited by thousand separator.
+        For non-uniform digit grouping, it can be a sequence with the number
+        of digit group sizes following the format used by the Python locale
+        module in locale.localeconv() LC_NUMERIC grouping (e.g. (3, 2, 0)).
+    * thousand_sep: Thousand separator symbol (for example ",")
+    """
+    if number is None or number == "":
+        return mark_safe(number)
+    if use_l10n is None:
+        use_l10n = True
+    use_grouping = use_l10n and settings.USE_THOUSAND_SEPARATOR
+    use_grouping = use_grouping or force_grouping
+    use_grouping = use_grouping and grouping != 0
+    # Make the common case fast
+    if isinstance(number, int) and not use_grouping and not decimal_pos:
+        return mark_safe(number)
+    # sign
+    sign = ""
+    # Treat potentially very large/small floats as Decimals.
+    if isinstance(number, float) and "e" in str(number).lower():
+        number = Decimal(str(number))
+    if isinstance(number, Decimal):
+        if decimal_pos is not None:
+            # If the provided number is too small to affect any of the visible
+            # decimal places, consider it equal to '0'.
+            cutoff = Decimal("0." + "1".rjust(decimal_pos, "0"))
+            if abs(number) < cutoff:
+                number = Decimal("0")
+
+        # Format values with more than 200 digits (an arbitrary cutoff) using
+        # scientific notation to avoid high memory usage in {:f}'.format().
+        _, digits, exponent = number.as_tuple()
+        if abs(exponent) + len(digits) > 200:
+            number = "{:e}".format(number)
+            coefficient, exponent = number.split("e")
+            # Format the coefficient.
+            coefficient = format(
+                coefficient,
+                decimal_sep,
+                decimal_pos,
+                grouping,
+                thousand_sep,
+                force_grouping,
+                use_l10n,
+            )
+            return "{}e{}".format(coefficient, exponent)
+        else:
+            str_number = "{:f}".format(number)
+    else:
+        str_number = str(number)
+    if str_number[0] == "-":
+        sign = "-"
+        str_number = str_number[1:]
+    # decimal part
+    if "." in str_number:
+        int_part, dec_part = str_number.split(".")
+        if decimal_pos is not None:
+            dec_part = dec_part[:decimal_pos]
+    else:
+        int_part, dec_part = str_number, ""
+    if decimal_pos is not None:
+        dec_part += "0" * (decimal_pos - len(dec_part))
+    dec_part = dec_part and decimal_sep + dec_part
+    # grouping
+    if use_grouping:
+        try:
+            # if grouping is a sequence
+            intervals = list(grouping)
+        except TypeError:
+            # grouping is a single value
+            intervals = [grouping, 0]
+        active_interval = intervals.pop(0)
+        int_part_gd = ""
+        cnt = 0
+        for digit in int_part[::-1]:
+            if cnt and cnt == active_interval:
+                if intervals:
+                    active_interval = intervals.pop(0) or active_interval
+                int_part_gd += thousand_sep[::-1]
+                cnt = 0
+            int_part_gd += digit
+            cnt += 1
+        int_part = int_part_gd[::-1]
+    return sign + int_part + dec_part

testbed/django__django/django/utils/safestring.py

@@ -0,0 +1,72 @@
+"""
+Functions for working with "safe strings": strings that can be displayed safely
+without further escaping in HTML. Marking something as a "safe string" means
+that the producer of the string has already turned characters that should not
+be interpreted by the HTML engine (e.g. '<') into the appropriate entities.
+"""
+
+from functools import wraps
+
+from django.utils.functional import keep_lazy
+
+
+class SafeData:
+    __slots__ = ()
+
+    def __html__(self):
+        """
+        Return the html representation of a string for interoperability.
+
+        This allows other template engines to understand Django's SafeData.
+        """
+        return self
+
+
+class SafeString(str, SafeData):
+    """
+    A str subclass that has been specifically marked as "safe" for HTML output
+    purposes.
+    """
+
+    __slots__ = ()
+
+    def __add__(self, rhs):
+        """
+        Concatenating a safe string with another safe bytestring or
+        safe string is safe. Otherwise, the result is no longer safe.
+        """
+        t = super().__add__(rhs)
+        if isinstance(rhs, SafeData):
+            return SafeString(t)
+        return t
+
+    def __str__(self):
+        return self
+
+
+SafeText = SafeString  # For backwards compatibility since Django 2.0.
+
+
+def _safety_decorator(safety_marker, func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        return safety_marker(func(*args, **kwargs))
+
+    return wrapper
+
+
+@keep_lazy(SafeString)
+def mark_safe(s):
+    """
+    Explicitly mark a string as safe for (HTML) output purposes. The returned
+    object can be used everywhere a string is appropriate.
+
+    If used on a method as a decorator, mark the returned data as safe.
+
+    Can be called multiple times on a single string.
+    """
+    if hasattr(s, "__html__"):
+        return s
+    if callable(s):
+        return _safety_decorator(mark_safe, s)
+    return SafeString(s)

testbed/django__django/django/utils/text.py

@@ -0,0 +1,455 @@
+import gzip
+import re
+import secrets
+import unicodedata
+from gzip import GzipFile
+from gzip import compress as gzip_compress
+from io import BytesIO
+
+from django.core.exceptions import SuspiciousFileOperation
+from django.utils.functional import SimpleLazyObject, keep_lazy_text, lazy
+from django.utils.regex_helper import _lazy_re_compile
+from django.utils.translation import gettext as _
+from django.utils.translation import gettext_lazy, pgettext
+
+
+@keep_lazy_text
+def capfirst(x):
+    """Capitalize the first letter of a string."""
+    if not x:
+        return x
+    if not isinstance(x, str):
+        x = str(x)
+    return x[0].upper() + x[1:]
+
+
+# Set up regular expressions
+re_words = _lazy_re_compile(r"<[^>]+?>|([^<>\s]+)", re.S)
+re_chars = _lazy_re_compile(r"<[^>]+?>|(.)", re.S)
+re_tag = _lazy_re_compile(r"<(/)?(\S+?)(?:(\s*/)|\s.*?)?>", re.S)
+re_newlines = _lazy_re_compile(r"\r\n|\r")  # Used in normalize_newlines
+re_camel_case = _lazy_re_compile(r"(((?<=[a-z])[A-Z])|([A-Z](?![A-Z]|$)))")
+
+
+@keep_lazy_text
+def wrap(text, width):
+    """
+    A word-wrap function that preserves existing line breaks. Expects that
+    existing line breaks are posix newlines.
+
+    Preserve all white space except added line breaks consume the space on
+    which they break the line.
+
+    Don't wrap long words, thus the output text may have lines longer than
+    ``width``.
+    """
+
+    def _generator():
+        for line in text.splitlines(True):  # True keeps trailing linebreaks
+            max_width = min((line.endswith("\n") and width + 1 or width), width)
+            while len(line) > max_width:
+                space = line[: max_width + 1].rfind(" ") + 1
+                if space == 0:
+                    space = line.find(" ") + 1
+                    if space == 0:
+                        yield line
+                        line = ""
+                        break
+                yield "%s\n" % line[: space - 1]
+                line = line[space:]
+                max_width = min((line.endswith("\n") and width + 1 or width), width)
+            if line:
+                yield line
+
+    return "".join(_generator())
+
+
+class Truncator(SimpleLazyObject):
+    """
+    An object used to truncate text, either by characters or words.
+    """
+
+    def __init__(self, text):
+        super().__init__(lambda: str(text))
+
+    def add_truncation_text(self, text, truncate=None):
+        if truncate is None:
+            truncate = pgettext(
+                "String to return when truncating text", "%(truncated_text)s…"
+            )
+        if "%(truncated_text)s" in truncate:
+            return truncate % {"truncated_text": text}
+        # The truncation text didn't contain the %(truncated_text)s string
+        # replacement argument so just append it to the text.
+        if text.endswith(truncate):
+            # But don't append the truncation text if the current text already
+            # ends in this.
+            return text
+        return "%s%s" % (text, truncate)
+
+    def chars(self, num, truncate=None, html=False):
+        """
+        Return the text truncated to be no longer than the specified number
+        of characters.
+
+        `truncate` specifies what should be used to notify that the string has
+        been truncated, defaulting to a translatable string of an ellipsis.
+        """
+        self._setup()
+        length = int(num)
+        text = unicodedata.normalize("NFC", self._wrapped)
+
+        # Calculate the length to truncate to (max length - end_text length)
+        truncate_len = length
+        for char in self.add_truncation_text("", truncate):
+            if not unicodedata.combining(char):
+                truncate_len -= 1
+                if truncate_len == 0:
+                    break
+        if html:
+            return self._truncate_html(length, truncate, text, truncate_len, False)
+        return self._text_chars(length, truncate, text, truncate_len)
+
+    def _text_chars(self, length, truncate, text, truncate_len):
+        """Truncate a string after a certain number of chars."""
+        s_len = 0
+        end_index = None
+        for i, char in enumerate(text):
+            if unicodedata.combining(char):
+                # Don't consider combining characters
+                # as adding to the string length
+                continue
+            s_len += 1
+            if end_index is None and s_len > truncate_len:
+                end_index = i
+            if s_len > length:
+                # Return the truncated string
+                return self.add_truncation_text(text[: end_index or 0], truncate)
+
+        # Return the original string since no truncation was necessary
+        return text
+
+    def words(self, num, truncate=None, html=False):
+        """
+        Truncate a string after a certain number of words. `truncate` specifies
+        what should be used to notify that the string has been truncated,
+        defaulting to ellipsis.
+        """
+        self._setup()
+        length = int(num)
+        if html:
+            return self._truncate_html(length, truncate, self._wrapped, length, True)
+        return self._text_words(length, truncate)
+
+    def _text_words(self, length, truncate):
+        """
+        Truncate a string after a certain number of words.
+
+        Strip newlines in the string.
+        """
+        words = self._wrapped.split()
+        if len(words) > length:
+            words = words[:length]
+            return self.add_truncation_text(" ".join(words), truncate)
+        return " ".join(words)
+
+    def _truncate_html(self, length, truncate, text, truncate_len, words):
+        """
+        Truncate HTML to a certain number of chars (not counting tags and
+        comments), or, if words is True, then to a certain number of words.
+        Close opened tags if they were correctly closed in the given HTML.
+
+        Preserve newlines in the HTML.
+        """
+        if words and length <= 0:
+            return ""
+
+        html4_singlets = (
+            "br",
+            "col",
+            "link",
+            "base",
+            "img",
+            "param",
+            "area",
+            "hr",
+            "input",
+        )
+
+        # Count non-HTML chars/words and keep note of open tags
+        pos = 0
+        end_text_pos = 0
+        current_len = 0
+        open_tags = []
+
+        regex = re_words if words else re_chars
+
+        while current_len <= length:
+            m = regex.search(text, pos)
+            if not m:
+                # Checked through whole string
+                break
+            pos = m.end(0)
+            if m[1]:
+                # It's an actual non-HTML word or char
+                current_len += 1
+                if current_len == truncate_len:
+                    end_text_pos = pos
+                continue
+            # Check for tag
+            tag = re_tag.match(m[0])
+            if not tag or current_len >= truncate_len:
+                # Don't worry about non tags or tags after our truncate point
+                continue
+            closing_tag, tagname, self_closing = tag.groups()
+            # Element names are always case-insensitive
+            tagname = tagname.lower()
+            if self_closing or tagname in html4_singlets:
+                pass
+            elif closing_tag:
+                # Check for match in open tags list
+                try:
+                    i = open_tags.index(tagname)
+                except ValueError:
+                    pass
+                else:
+                    # SGML: An end tag closes, back to the matching start tag,
+                    # all unclosed intervening start tags with omitted end tags
+                    open_tags = open_tags[i + 1 :]
+            else:
+                # Add it to the start of the open tags list
+                open_tags.insert(0, tagname)
+
+        if current_len <= length:
+            return text
+        out = text[:end_text_pos]
+        truncate_text = self.add_truncation_text("", truncate)
+        if truncate_text:
+            out += truncate_text
+        # Close any tags still open
+        for tag in open_tags:
+            out += "</%s>" % tag
+        # Return string
+        return out
+
+
+@keep_lazy_text
+def get_valid_filename(name):
+    """
+    Return the given string converted to a string that can be used for a clean
+    filename. Remove leading and trailing spaces; convert other spaces to
+    underscores; and remove anything that is not an alphanumeric, dash,
+    underscore, or dot.
+    >>> get_valid_filename("john's portrait in 2004.jpg")
+    'johns_portrait_in_2004.jpg'
+    """
+    s = str(name).strip().replace(" ", "_")
+    s = re.sub(r"(?u)[^-\w.]", "", s)
+    if s in {"", ".", ".."}:
+        raise SuspiciousFileOperation("Could not derive file name from '%s'" % name)
+    return s
+
+
+@keep_lazy_text
+def get_text_list(list_, last_word=gettext_lazy("or")):
+    """
+    >>> get_text_list(['a', 'b', 'c', 'd'])
+    'a, b, c or d'
+    >>> get_text_list(['a', 'b', 'c'], 'and')
+    'a, b and c'
+    >>> get_text_list(['a', 'b'], 'and')
+    'a and b'
+    >>> get_text_list(['a'])
+    'a'
+    >>> get_text_list([])
+    ''
+    """
+    if not list_:
+        return ""
+    if len(list_) == 1:
+        return str(list_[0])
+    return "%s %s %s" % (
+        # Translators: This string is used as a separator between list elements
+        _(", ").join(str(i) for i in list_[:-1]),
+        str(last_word),
+        str(list_[-1]),
+    )
+
+
+@keep_lazy_text
+def normalize_newlines(text):
+    """Normalize CRLF and CR newlines to just LF."""
+    return re_newlines.sub("\n", str(text))
+
+
+@keep_lazy_text
+def phone2numeric(phone):
+    """Convert a phone number with letters into its numeric equivalent."""
+    char2number = {
+        "a": "2",
+        "b": "2",
+        "c": "2",
+        "d": "3",
+        "e": "3",
+        "f": "3",
+        "g": "4",
+        "h": "4",
+        "i": "4",
+        "j": "5",
+        "k": "5",
+        "l": "5",
+        "m": "6",
+        "n": "6",
+        "o": "6",
+        "p": "7",
+        "q": "7",
+        "r": "7",
+        "s": "7",
+        "t": "8",
+        "u": "8",
+        "v": "8",
+        "w": "9",
+        "x": "9",
+        "y": "9",
+        "z": "9",
+    }
+    return "".join(char2number.get(c, c) for c in phone.lower())
+
+
+def _get_random_filename(max_random_bytes):
+    return b"a" * secrets.randbelow(max_random_bytes)
+
+
+def compress_string(s, *, max_random_bytes=None):
+    compressed_data = gzip_compress(s, compresslevel=6, mtime=0)
+
+    if not max_random_bytes:
+        return compressed_data
+
+    compressed_view = memoryview(compressed_data)
+    header = bytearray(compressed_view[:10])
+    header[3] = gzip.FNAME
+
+    filename = _get_random_filename(max_random_bytes) + b"\x00"
+
+    return bytes(header) + filename + compressed_view[10:]
+
+
+class StreamingBuffer(BytesIO):
+    def read(self):
+        ret = self.getvalue()
+        self.seek(0)
+        self.truncate()
+        return ret
+
+
+# Like compress_string, but for iterators of strings.
+def compress_sequence(sequence, *, max_random_bytes=None):
+    buf = StreamingBuffer()
+    filename = _get_random_filename(max_random_bytes) if max_random_bytes else None
+    with GzipFile(
+        filename=filename, mode="wb", compresslevel=6, fileobj=buf, mtime=0
+    ) as zfile:
+        # Output headers...
+        yield buf.read()
+        for item in sequence:
+            zfile.write(item)
+            data = buf.read()
+            if data:
+                yield data
+    yield buf.read()
+
+
+# Expression to match some_token and some_token="with spaces" (and similarly
+# for single-quoted strings).
+smart_split_re = _lazy_re_compile(
+    r"""
+    ((?:
+        [^\s'"]*
+        (?:
+            (?:"(?:[^"\\]|\\.)*" | '(?:[^'\\]|\\.)*')
+            [^\s'"]*
+        )+
+    ) | \S+)
+""",
+    re.VERBOSE,
+)
+
+
+def smart_split(text):
+    r"""
+    Generator that splits a string by spaces, leaving quoted phrases together.
+    Supports both single and double quotes, and supports escaping quotes with
+    backslashes. In the output, strings will keep their initial and trailing
+    quote marks and escaped quotes will remain escaped (the results can then
+    be further processed with unescape_string_literal()).
+
+    >>> list(smart_split(r'This is "a person\'s" test.'))
+    ['This', 'is', '"a person\\\'s"', 'test.']
+    >>> list(smart_split(r"Another 'person\'s' test."))
+    ['Another', "'person\\'s'", 'test.']
+    >>> list(smart_split(r'A "\"funky\" style" test.'))
+    ['A', '"\\"funky\\" style"', 'test.']
+    """
+    for bit in smart_split_re.finditer(str(text)):
+        yield bit[0]
+
+
+@keep_lazy_text
+def unescape_string_literal(s):
+    r"""
+    Convert quoted string literals to unquoted strings with escaped quotes and
+    backslashes unquoted::
+
+        >>> unescape_string_literal('"abc"')
+        'abc'
+        >>> unescape_string_literal("'abc'")
+        'abc'
+        >>> unescape_string_literal('"a \"bc\""')
+        'a "bc"'
+        >>> unescape_string_literal("'\'ab\' c'")
+        "'ab' c"
+    """
+    if not s or s[0] not in "\"'" or s[-1] != s[0]:
+        raise ValueError("Not a string literal: %r" % s)
+    quote = s[0]
+    return s[1:-1].replace(r"\%s" % quote, quote).replace(r"\\", "\\")
+
+
+@keep_lazy_text
+def slugify(value, allow_unicode=False):
+    """
+    Convert to ASCII if 'allow_unicode' is False. Convert spaces or repeated
+    dashes to single dashes. Remove characters that aren't alphanumerics,
+    underscores, or hyphens. Convert to lowercase. Also strip leading and
+    trailing whitespace, dashes, and underscores.
+    """
+    value = str(value)
+    if allow_unicode:
+        value = unicodedata.normalize("NFKC", value)
+    else:
+        value = (
+            unicodedata.normalize("NFKD", value)
+            .encode("ascii", "ignore")
+            .decode("ascii")
+        )
+    value = re.sub(r"[^\w\s-]", "", value.lower())
+    return re.sub(r"[-\s]+", "-", value).strip("-_")
+
+
+def camel_case_to_spaces(value):
+    """
+    Split CamelCase and convert to lowercase. Strip surrounding whitespace.
+    """
+    return re_camel_case.sub(r" \1", value).strip().lower()
+
+
+def _format_lazy(format_string, *args, **kwargs):
+    """
+    Apply str.format() on 'format_string' where format_string, args,
+    and/or kwargs might be lazy.
+    """
+    return format_string.format(*args, **kwargs)
+
+
+format_lazy = lazy(_format_lazy, str)

testbed/django__django/django/utils/timezone.py

@@ -0,0 +1,259 @@
+"""
+Timezone-related classes and functions.
+"""
+
+import functools
+import zoneinfo
+from contextlib import ContextDecorator
+from datetime import datetime, timedelta, timezone, tzinfo
+
+from asgiref.local import Local
+
+from django.conf import settings
+
+__all__ = [
+    "get_fixed_timezone",
+    "get_default_timezone",
+    "get_default_timezone_name",
+    "get_current_timezone",
+    "get_current_timezone_name",
+    "activate",
+    "deactivate",
+    "override",
+    "localtime",
+    "localdate",
+    "now",
+    "is_aware",
+    "is_naive",
+    "make_aware",
+    "make_naive",
+]
+
+
+def get_fixed_timezone(offset):
+    """Return a tzinfo instance with a fixed offset from UTC."""
+    if isinstance(offset, timedelta):
+        offset = offset.total_seconds() // 60
+    sign = "-" if offset < 0 else "+"
+    hhmm = "%02d%02d" % divmod(abs(offset), 60)
+    name = sign + hhmm
+    return timezone(timedelta(minutes=offset), name)
+
+
+# In order to avoid accessing settings at compile time,
+# wrap the logic in a function and cache the result.
+@functools.lru_cache
+def get_default_timezone():
+    """
+    Return the default time zone as a tzinfo instance.
+
+    This is the time zone defined by settings.TIME_ZONE.
+    """
+    return zoneinfo.ZoneInfo(settings.TIME_ZONE)
+
+
+# This function exists for consistency with get_current_timezone_name
+def get_default_timezone_name():
+    """Return the name of the default time zone."""
+    return _get_timezone_name(get_default_timezone())
+
+
+_active = Local()
+
+
+def get_current_timezone():
+    """Return the currently active time zone as a tzinfo instance."""
+    return getattr(_active, "value", get_default_timezone())
+
+
+def get_current_timezone_name():
+    """Return the name of the currently active time zone."""
+    return _get_timezone_name(get_current_timezone())
+
+
+def _get_timezone_name(timezone):
+    """
+    Return the offset for fixed offset timezones, or the name of timezone if
+    not set.
+    """
+    return timezone.tzname(None) or str(timezone)
+
+
+# Timezone selection functions.
+
+# These functions don't change os.environ['TZ'] and call time.tzset()
+# because it isn't thread safe.
+
+
+def activate(timezone):
+    """
+    Set the time zone for the current thread.
+
+    The ``timezone`` argument must be an instance of a tzinfo subclass or a
+    time zone name.
+    """
+    if isinstance(timezone, tzinfo):
+        _active.value = timezone
+    elif isinstance(timezone, str):
+        _active.value = zoneinfo.ZoneInfo(timezone)
+    else:
+        raise ValueError("Invalid timezone: %r" % timezone)
+
+
+def deactivate():
+    """
+    Unset the time zone for the current thread.
+
+    Django will then use the time zone defined by settings.TIME_ZONE.
+    """
+    if hasattr(_active, "value"):
+        del _active.value
+
+
+class override(ContextDecorator):
+    """
+    Temporarily set the time zone for the current thread.
+
+    This is a context manager that uses django.utils.timezone.activate()
+    to set the timezone on entry and restores the previously active timezone
+    on exit.
+
+    The ``timezone`` argument must be an instance of a ``tzinfo`` subclass, a
+    time zone name, or ``None``. If it is ``None``, Django enables the default
+    time zone.
+    """
+
+    def __init__(self, timezone):
+        self.timezone = timezone
+
+    def __enter__(self):
+        self.old_timezone = getattr(_active, "value", None)
+        if self.timezone is None:
+            deactivate()
+        else:
+            activate(self.timezone)
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        if self.old_timezone is None:
+            deactivate()
+        else:
+            _active.value = self.old_timezone
+
+
+# Templates
+
+
+def template_localtime(value, use_tz=None):
+    """
+    Check if value is a datetime and converts it to local time if necessary.
+
+    If use_tz is provided and is not None, that will force the value to
+    be converted (or not), overriding the value of settings.USE_TZ.
+
+    This function is designed for use by the template engine.
+    """
+    should_convert = (
+        isinstance(value, datetime)
+        and (settings.USE_TZ if use_tz is None else use_tz)
+        and not is_naive(value)
+        and getattr(value, "convert_to_local_time", True)
+    )
+    return localtime(value) if should_convert else value
+
+
+# Utilities
+
+
+def localtime(value=None, timezone=None):
+    """
+    Convert an aware datetime.datetime to local time.
+
+    Only aware datetimes are allowed. When value is omitted, it defaults to
+    now().
+
+    Local time is defined by the current time zone, unless another time zone
+    is specified.
+    """
+    if value is None:
+        value = now()
+    if timezone is None:
+        timezone = get_current_timezone()
+    # Emulate the behavior of astimezone() on Python < 3.6.
+    if is_naive(value):
+        raise ValueError("localtime() cannot be applied to a naive datetime")
+    return value.astimezone(timezone)
+
+
+def localdate(value=None, timezone=None):
+    """
+    Convert an aware datetime to local time and return the value's date.
+
+    Only aware datetimes are allowed. When value is omitted, it defaults to
+    now().
+
+    Local time is defined by the current time zone, unless another time zone is
+    specified.
+    """
+    return localtime(value, timezone).date()
+
+
+def now():
+    """
+    Return an aware or naive datetime.datetime, depending on settings.USE_TZ.
+    """
+    return datetime.now(tz=timezone.utc if settings.USE_TZ else None)
+
+
+# By design, these four functions don't perform any checks on their arguments.
+# The caller should ensure that they don't receive an invalid value like None.
+
+
+def is_aware(value):
+    """
+    Determine if a given datetime.datetime is aware.
+
+    The concept is defined in Python's docs:
+    https://docs.python.org/library/datetime.html#datetime.tzinfo
+
+    Assuming value.tzinfo is either None or a proper datetime.tzinfo,
+    value.utcoffset() implements the appropriate logic.
+    """
+    return value.utcoffset() is not None
+
+
+def is_naive(value):
+    """
+    Determine if a given datetime.datetime is naive.
+
+    The concept is defined in Python's docs:
+    https://docs.python.org/library/datetime.html#datetime.tzinfo
+
+    Assuming value.tzinfo is either None or a proper datetime.tzinfo,
+    value.utcoffset() implements the appropriate logic.
+    """
+    return value.utcoffset() is None
+
+
+def make_aware(value, timezone=None):
+    """Make a naive datetime.datetime in a given time zone aware."""
+    if timezone is None:
+        timezone = get_current_timezone()
+    # Check that we won't overwrite the timezone of an aware datetime.
+    if is_aware(value):
+        raise ValueError("make_aware expects a naive datetime, got %s" % value)
+    # This may be wrong around DST changes!
+    return value.replace(tzinfo=timezone)
+
+
+def make_naive(value, timezone=None):
+    """Make an aware datetime.datetime naive in a given time zone."""
+    if timezone is None:
+        timezone = get_current_timezone()
+    # Emulate the behavior of astimezone() on Python < 3.6.
+    if is_naive(value):
+        raise ValueError("make_naive() cannot be applied to a naive datetime")
+    return value.astimezone(timezone).replace(tzinfo=None)
+
+
+def _datetime_ambiguous_or_imaginary(dt, tz):
+    return tz.utcoffset(dt.replace(fold=not dt.fold)) != tz.utcoffset(dt)

testbed/django__django/django/utils/version.py

@@ -0,0 +1,121 @@
+import datetime
+import functools
+import os
+import subprocess
+import sys
+
+from django.utils.regex_helper import _lazy_re_compile
+
+# Private, stable API for detecting the Python version. PYXY means "Python X.Y
+# or later". So that third-party apps can use these values, each constant
+# should remain as long as the oldest supported Django version supports that
+# Python version.
+PY36 = sys.version_info >= (3, 6)
+PY37 = sys.version_info >= (3, 7)
+PY38 = sys.version_info >= (3, 8)
+PY39 = sys.version_info >= (3, 9)
+PY310 = sys.version_info >= (3, 10)
+PY311 = sys.version_info >= (3, 11)
+PY312 = sys.version_info >= (3, 12)
+
+
+def get_version(version=None):
+    """Return a PEP 440-compliant version number from VERSION."""
+    version = get_complete_version(version)
+
+    # Now build the two parts of the version number:
+    # main = X.Y[.Z]
+    # sub = .devN - for pre-alpha releases
+    #     | {a|b|rc}N - for alpha, beta, and rc releases
+
+    main = get_main_version(version)
+
+    sub = ""
+    if version[3] == "alpha" and version[4] == 0:
+        git_changeset = get_git_changeset()
+        if git_changeset:
+            sub = ".dev%s" % git_changeset
+
+    elif version[3] != "final":
+        mapping = {"alpha": "a", "beta": "b", "rc": "rc"}
+        sub = mapping[version[3]] + str(version[4])
+
+    return main + sub
+
+
+def get_main_version(version=None):
+    """Return main version (X.Y[.Z]) from VERSION."""
+    version = get_complete_version(version)
+    parts = 2 if version[2] == 0 else 3
+    return ".".join(str(x) for x in version[:parts])
+
+
+def get_complete_version(version=None):
+    """
+    Return a tuple of the django version. If version argument is non-empty,
+    check for correctness of the tuple provided.
+    """
+    if version is None:
+        from django import VERSION as version
+    else:
+        assert len(version) == 5
+        assert version[3] in ("alpha", "beta", "rc", "final")
+
+    return version
+
+
+def get_docs_version(version=None):
+    version = get_complete_version(version)
+    if version[3] != "final":
+        return "dev"
+    else:
+        return "%d.%d" % version[:2]
+
+
+@functools.lru_cache
+def get_git_changeset():
+    """Return a numeric identifier of the latest git changeset.
+
+    The result is the UTC timestamp of the changeset in YYYYMMDDHHMMSS format.
+    This value isn't guaranteed to be unique, but collisions are very unlikely,
+    so it's sufficient for generating the development version numbers.
+    """
+    # Repository may not be found if __file__ is undefined, e.g. in a frozen
+    # module.
+    if "__file__" not in globals():
+        return None
+    repo_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    git_log = subprocess.run(
+        "git log --pretty=format:%ct --quiet -1 HEAD",
+        capture_output=True,
+        shell=True,
+        cwd=repo_dir,
+        text=True,
+    )
+    timestamp = git_log.stdout
+    tz = datetime.timezone.utc
+    try:
+        timestamp = datetime.datetime.fromtimestamp(int(timestamp), tz=tz)
+    except ValueError:
+        return None
+    return timestamp.strftime("%Y%m%d%H%M%S")
+
+
+version_component_re = _lazy_re_compile(r"(\d+|[a-z]+|\.)")
+
+
+def get_version_tuple(version):
+    """
+    Return a tuple of version numbers (e.g. (1, 2, 3)) from the version
+    string (e.g. '1.2.3').
+    """
+    version_numbers = []
+    for item in version_component_re.split(version):
+        if item and item != ".":
+            try:
+                component = int(item)
+            except ValueError:
+                break
+            else:
+                version_numbers.append(component)
+    return tuple(version_numbers)

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

@@ -0,0 +1,84 @@
+from functools import wraps
+
+from asgiref.sync import iscoroutinefunction
+
+from django.middleware.cache import CacheMiddleware
+from django.utils.cache import add_never_cache_headers, patch_cache_control
+from django.utils.decorators import decorator_from_middleware_with_args
+
+
+def cache_page(timeout, *, cache=None, key_prefix=None):
+    """
+    Decorator for views that tries getting the page from the cache and
+    populates the cache if the page isn't in the cache yet.
+
+    The cache is keyed by the URL and some data from the headers.
+    Additionally there is the key prefix that is used to distinguish different
+    cache areas in a multi-site setup. You could use the
+    get_current_site().domain, for example, as that is unique across a Django
+    project.
+
+    Additionally, all headers from the response's Vary header will be taken
+    into account on caching -- just like the middleware does.
+    """
+    return decorator_from_middleware_with_args(CacheMiddleware)(
+        page_timeout=timeout,
+        cache_alias=cache,
+        key_prefix=key_prefix,
+    )
+
+
+def _check_request(request, decorator_name):
+    # Ensure argument looks like a request.
+    if not hasattr(request, "META"):
+        raise TypeError(
+            f"{decorator_name} didn't receive an HttpRequest. If you are "
+            "decorating a classmethod, be sure to use @method_decorator."
+        )
+
+
+def cache_control(**kwargs):
+    def _cache_controller(viewfunc):
+        if iscoroutinefunction(viewfunc):
+
+            async def _view_wrapper(request, *args, **kw):
+                _check_request(request, "cache_control")
+                response = await viewfunc(request, *args, **kw)
+                patch_cache_control(response, **kwargs)
+                return response
+
+        else:
+
+            def _view_wrapper(request, *args, **kw):
+                _check_request(request, "cache_control")
+                response = viewfunc(request, *args, **kw)
+                patch_cache_control(response, **kwargs)
+                return response
+
+        return wraps(viewfunc)(_view_wrapper)
+
+    return _cache_controller
+
+
+def never_cache(view_func):
+    """
+    Decorator that adds headers to a response so that it will never be cached.
+    """
+
+    if iscoroutinefunction(view_func):
+
+        async def _view_wrapper(request, *args, **kwargs):
+            _check_request(request, "never_cache")
+            response = await view_func(request, *args, **kwargs)
+            add_never_cache_headers(response)
+            return response
+
+    else:
+
+        def _view_wrapper(request, *args, **kwargs):
+            _check_request(request, "never_cache")
+            response = view_func(request, *args, **kwargs)
+            add_never_cache_headers(response)
+            return response
+
+    return wraps(view_func)(_view_wrapper)

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

@@ -0,0 +1,27 @@
+from functools import wraps
+
+from asgiref.sync import iscoroutinefunction
+
+
+def no_append_slash(view_func):
+    """
+    Mark a view function as excluded from CommonMiddleware's APPEND_SLASH
+    redirection.
+    """
+
+    # view_func.should_append_slash = False would also work, but decorators are
+    # nicer if they don't have side effects, so return a new function.
+
+    if iscoroutinefunction(view_func):
+
+        async def _view_wrapper(request, *args, **kwargs):
+            return await view_func(request, *args, **kwargs)
+
+    else:
+
+        def _view_wrapper(request, *args, **kwargs):
+            return view_func(request, *args, **kwargs)
+
+    _view_wrapper.should_append_slash = False
+
+    return wraps(view_func)(_view_wrapper)

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

@@ -0,0 +1,69 @@
+from functools import wraps
+
+from asgiref.sync import iscoroutinefunction
+
+from django.middleware.csrf import CsrfViewMiddleware, get_token
+from django.utils.decorators import decorator_from_middleware
+
+csrf_protect = decorator_from_middleware(CsrfViewMiddleware)
+csrf_protect.__name__ = "csrf_protect"
+csrf_protect.__doc__ = """
+This decorator adds CSRF protection in exactly the same way as
+CsrfViewMiddleware, but it can be used on a per view basis.  Using both, or
+using the decorator multiple times, is harmless and efficient.
+"""
+
+
+class _EnsureCsrfToken(CsrfViewMiddleware):
+    # Behave like CsrfViewMiddleware but don't reject requests or log warnings.
+    def _reject(self, request, reason):
+        return None
+
+
+requires_csrf_token = decorator_from_middleware(_EnsureCsrfToken)
+requires_csrf_token.__name__ = "requires_csrf_token"
+requires_csrf_token.__doc__ = """
+Use this decorator on views that need a correct csrf_token available to
+RequestContext, but without the CSRF protection that csrf_protect
+enforces.
+"""
+
+
+class _EnsureCsrfCookie(CsrfViewMiddleware):
+    def _reject(self, request, reason):
+        return None
+
+    def process_view(self, request, callback, callback_args, callback_kwargs):
+        retval = super().process_view(request, callback, callback_args, callback_kwargs)
+        # Force process_response to send the cookie
+        get_token(request)
+        return retval
+
+
+ensure_csrf_cookie = decorator_from_middleware(_EnsureCsrfCookie)
+ensure_csrf_cookie.__name__ = "ensure_csrf_cookie"
+ensure_csrf_cookie.__doc__ = """
+Use this decorator to ensure that a view sets a CSRF cookie, whether or not it
+uses the csrf_token template tag, or the CsrfViewMiddleware is used.
+"""
+
+
+def csrf_exempt(view_func):
+    """Mark a view function as being exempt from the CSRF view protection."""
+
+    # view_func.csrf_exempt = True would also work, but decorators are nicer
+    # if they don't have side effects, so return a new function.
+
+    if iscoroutinefunction(view_func):
+
+        async def _view_wrapper(request, *args, **kwargs):
+            return await view_func(request, *args, **kwargs)
+
+    else:
+
+        def _view_wrapper(request, *args, **kwargs):
+            return view_func(request, *args, **kwargs)
+
+    _view_wrapper.csrf_exempt = True
+
+    return wraps(view_func)(_view_wrapper)

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

@@ -0,0 +1,5 @@
+from django.middleware.gzip import GZipMiddleware
+from django.utils.decorators import decorator_from_middleware
+
+gzip_page = decorator_from_middleware(GZipMiddleware)
+gzip_page.__doc__ = "Decorator for views that gzips pages if the client supports it."

testbed/django__django/django/views/defaults.py

@@ -0,0 +1,149 @@
+from urllib.parse import quote
+
+from django.http import (
+    HttpResponseBadRequest,
+    HttpResponseForbidden,
+    HttpResponseNotFound,
+    HttpResponseServerError,
+)
+from django.template import Context, Engine, TemplateDoesNotExist, loader
+from django.views.decorators.csrf import requires_csrf_token
+
+ERROR_404_TEMPLATE_NAME = "404.html"
+ERROR_403_TEMPLATE_NAME = "403.html"
+ERROR_400_TEMPLATE_NAME = "400.html"
+ERROR_500_TEMPLATE_NAME = "500.html"
+ERROR_PAGE_TEMPLATE = """
+<!doctype html>
+<html lang="en">
+<head>
+  <title>%(title)s</title>
+</head>
+<body>
+  <h1>%(title)s</h1><p>%(details)s</p>
+</body>
+</html>
+"""
+
+
+# These views can be called when CsrfViewMiddleware.process_view() not run,
+# therefore need @requires_csrf_token in case the template needs
+# {% csrf_token %}.
+
+
+@requires_csrf_token
+def page_not_found(request, exception, template_name=ERROR_404_TEMPLATE_NAME):
+    """
+    Default 404 handler.
+
+    Templates: :template:`404.html`
+    Context:
+        request_path
+            The path of the requested URL (e.g., '/app/pages/bad_page/'). It's
+            quoted to prevent a content injection attack.
+        exception
+            The message from the exception which triggered the 404 (if one was
+            supplied), or the exception class name
+    """
+    exception_repr = exception.__class__.__name__
+    # Try to get an "interesting" exception message, if any (and not the ugly
+    # Resolver404 dictionary)
+    try:
+        message = exception.args[0]
+    except (AttributeError, IndexError):
+        pass
+    else:
+        if isinstance(message, str):
+            exception_repr = message
+    context = {
+        "request_path": quote(request.path),
+        "exception": exception_repr,
+    }
+    try:
+        template = loader.get_template(template_name)
+        body = template.render(context, request)
+    except TemplateDoesNotExist:
+        if template_name != ERROR_404_TEMPLATE_NAME:
+            # Reraise if it's a missing custom template.
+            raise
+        # Render template (even though there are no substitutions) to allow
+        # inspecting the context in tests.
+        template = Engine().from_string(
+            ERROR_PAGE_TEMPLATE
+            % {
+                "title": "Not Found",
+                "details": "The requested resource was not found on this server.",
+            },
+        )
+        body = template.render(Context(context))
+    return HttpResponseNotFound(body)
+
+
+@requires_csrf_token
+def server_error(request, template_name=ERROR_500_TEMPLATE_NAME):
+    """
+    500 error handler.
+
+    Templates: :template:`500.html`
+    Context: None
+    """
+    try:
+        template = loader.get_template(template_name)
+    except TemplateDoesNotExist:
+        if template_name != ERROR_500_TEMPLATE_NAME:
+            # Reraise if it's a missing custom template.
+            raise
+        return HttpResponseServerError(
+            ERROR_PAGE_TEMPLATE % {"title": "Server Error (500)", "details": ""},
+        )
+    return HttpResponseServerError(template.render())
+
+
+@requires_csrf_token
+def bad_request(request, exception, template_name=ERROR_400_TEMPLATE_NAME):
+    """
+    400 error handler.
+
+    Templates: :template:`400.html`
+    Context: None
+    """
+    try:
+        template = loader.get_template(template_name)
+    except TemplateDoesNotExist:
+        if template_name != ERROR_400_TEMPLATE_NAME:
+            # Reraise if it's a missing custom template.
+            raise
+        return HttpResponseBadRequest(
+            ERROR_PAGE_TEMPLATE % {"title": "Bad Request (400)", "details": ""},
+        )
+    # No exception content is passed to the template, to not disclose any
+    # sensitive information.
+    return HttpResponseBadRequest(template.render())
+
+
+@requires_csrf_token
+def permission_denied(request, exception, template_name=ERROR_403_TEMPLATE_NAME):
+    """
+    Permission denied (403) handler.
+
+    Templates: :template:`403.html`
+    Context:
+        exception
+            The message from the exception which triggered the 403 (if one was
+            supplied).
+
+    If the template does not exist, an Http403 response containing the text
+    "403 Forbidden" (as per RFC 9110 Section 15.5.4) will be returned.
+    """
+    try:
+        template = loader.get_template(template_name)
+    except TemplateDoesNotExist:
+        if template_name != ERROR_403_TEMPLATE_NAME:
+            # Reraise if it's a missing custom template.
+            raise
+        return HttpResponseForbidden(
+            ERROR_PAGE_TEMPLATE % {"title": "403 Forbidden", "details": ""},
+        )
+    return HttpResponseForbidden(
+        template.render(request=request, context={"exception": str(exception)})
+    )

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

@@ -0,0 +1,285 @@
+import logging
+
+from asgiref.sync import iscoroutinefunction, markcoroutinefunction
+
+from django.core.exceptions import ImproperlyConfigured
+from django.http import (
+    HttpResponse,
+    HttpResponseGone,
+    HttpResponseNotAllowed,
+    HttpResponsePermanentRedirect,
+    HttpResponseRedirect,
+)
+from django.template.response import TemplateResponse
+from django.urls import reverse
+from django.utils.decorators import classonlymethod
+from django.utils.functional import classproperty
+
+logger = logging.getLogger("django.request")
+
+
+class ContextMixin:
+    """
+    A default context mixin that passes the keyword arguments received by
+    get_context_data() as the template context.
+    """
+
+    extra_context = None
+
+    def get_context_data(self, **kwargs):
+        kwargs.setdefault("view", self)
+        if self.extra_context is not None:
+            kwargs.update(self.extra_context)
+        return kwargs
+
+
+class View:
+    """
+    Intentionally simple parent class for all views. Only implements
+    dispatch-by-method and simple sanity checking.
+    """
+
+    http_method_names = [
+        "get",
+        "post",
+        "put",
+        "patch",
+        "delete",
+        "head",
+        "options",
+        "trace",
+    ]
+
+    def __init__(self, **kwargs):
+        """
+        Constructor. Called in the URLconf; can contain helpful extra
+        keyword arguments, and other things.
+        """
+        # Go through keyword arguments, and either save their values to our
+        # instance, or raise an error.
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+
+    @classproperty
+    def view_is_async(cls):
+        handlers = [
+            getattr(cls, method)
+            for method in cls.http_method_names
+            if (method != "options" and hasattr(cls, method))
+        ]
+        if not handlers:
+            return False
+        is_async = iscoroutinefunction(handlers[0])
+        if not all(iscoroutinefunction(h) == is_async for h in handlers[1:]):
+            raise ImproperlyConfigured(
+                f"{cls.__qualname__} HTTP handlers must either be all sync or all "
+                "async."
+            )
+        return is_async
+
+    @classonlymethod
+    def as_view(cls, **initkwargs):
+        """Main entry point for a request-response process."""
+        for key in initkwargs:
+            if key in cls.http_method_names:
+                raise TypeError(
+                    "The method name %s is not accepted as a keyword argument "
+                    "to %s()." % (key, cls.__name__)
+                )
+            if not hasattr(cls, key):
+                raise TypeError(
+                    "%s() received an invalid keyword %r. as_view "
+                    "only accepts arguments that are already "
+                    "attributes of the class." % (cls.__name__, key)
+                )
+
+        def view(request, *args, **kwargs):
+            self = cls(**initkwargs)
+            self.setup(request, *args, **kwargs)
+            if not hasattr(self, "request"):
+                raise AttributeError(
+                    "%s instance has no 'request' attribute. Did you override "
+                    "setup() and forget to call super()?" % cls.__name__
+                )
+            return self.dispatch(request, *args, **kwargs)
+
+        view.view_class = cls
+        view.view_initkwargs = initkwargs
+
+        # __name__ and __qualname__ are intentionally left unchanged as
+        # view_class should be used to robustly determine the name of the view
+        # instead.
+        view.__doc__ = cls.__doc__
+        view.__module__ = cls.__module__
+        view.__annotations__ = cls.dispatch.__annotations__
+        # Copy possible attributes set by decorators, e.g. @csrf_exempt, from
+        # the dispatch method.
+        view.__dict__.update(cls.dispatch.__dict__)
+
+        # Mark the callback if the view class is async.
+        if cls.view_is_async:
+            markcoroutinefunction(view)
+
+        return view
+
+    def setup(self, request, *args, **kwargs):
+        """Initialize attributes shared by all view methods."""
+        if hasattr(self, "get") and not hasattr(self, "head"):
+            self.head = self.get
+        self.request = request
+        self.args = args
+        self.kwargs = kwargs
+
+    def dispatch(self, request, *args, **kwargs):
+        # Try to dispatch to the right method; if a method doesn't exist,
+        # defer to the error handler. Also defer to the error handler if the
+        # request method isn't on the approved list.
+        if request.method.lower() in self.http_method_names:
+            handler = getattr(
+                self, request.method.lower(), self.http_method_not_allowed
+            )
+        else:
+            handler = self.http_method_not_allowed
+        return handler(request, *args, **kwargs)
+
+    def http_method_not_allowed(self, request, *args, **kwargs):
+        logger.warning(
+            "Method Not Allowed (%s): %s",
+            request.method,
+            request.path,
+            extra={"status_code": 405, "request": request},
+        )
+        response = HttpResponseNotAllowed(self._allowed_methods())
+
+        if self.view_is_async:
+
+            async def func():
+                return response
+
+            return func()
+        else:
+            return response
+
+    def options(self, request, *args, **kwargs):
+        """Handle responding to requests for the OPTIONS HTTP verb."""
+        response = HttpResponse()
+        response.headers["Allow"] = ", ".join(self._allowed_methods())
+        response.headers["Content-Length"] = "0"
+
+        if self.view_is_async:
+
+            async def func():
+                return response
+
+            return func()
+        else:
+            return response
+
+    def _allowed_methods(self):
+        return [m.upper() for m in self.http_method_names if hasattr(self, m)]
+
+
+class TemplateResponseMixin:
+    """A mixin that can be used to render a template."""
+
+    template_name = None
+    template_engine = None
+    response_class = TemplateResponse
+    content_type = None
+
+    def render_to_response(self, context, **response_kwargs):
+        """
+        Return a response, using the `response_class` for this view, with a
+        template rendered with the given context.
+
+        Pass response_kwargs to the constructor of the response class.
+        """
+        response_kwargs.setdefault("content_type", self.content_type)
+        return self.response_class(
+            request=self.request,
+            template=self.get_template_names(),
+            context=context,
+            using=self.template_engine,
+            **response_kwargs,
+        )
+
+    def get_template_names(self):
+        """
+        Return a list of template names to be used for the request. Must return
+        a list. May not be called if render_to_response() is overridden.
+        """
+        if self.template_name is None:
+            raise ImproperlyConfigured(
+                "TemplateResponseMixin requires either a definition of "
+                "'template_name' or an implementation of 'get_template_names()'"
+            )
+        else:
+            return [self.template_name]
+
+
+class TemplateView(TemplateResponseMixin, ContextMixin, View):
+    """
+    Render a template. Pass keyword arguments from the URLconf to the context.
+    """
+
+    def get(self, request, *args, **kwargs):
+        context = self.get_context_data(**kwargs)
+        return self.render_to_response(context)
+
+
+class RedirectView(View):
+    """Provide a redirect on any GET request."""
+
+    permanent = False
+    url = None
+    pattern_name = None
+    query_string = False
+
+    def get_redirect_url(self, *args, **kwargs):
+        """
+        Return the URL redirect to. Keyword arguments from the URL pattern
+        match generating the redirect request are provided as kwargs to this
+        method.
+        """
+        if self.url:
+            url = self.url % kwargs
+        elif self.pattern_name:
+            url = reverse(self.pattern_name, args=args, kwargs=kwargs)
+        else:
+            return None
+
+        args = self.request.META.get("QUERY_STRING", "")
+        if args and self.query_string:
+            url = "%s?%s" % (url, args)
+        return url
+
+    def get(self, request, *args, **kwargs):
+        url = self.get_redirect_url(*args, **kwargs)
+        if url:
+            if self.permanent:
+                return HttpResponsePermanentRedirect(url)
+            else:
+                return HttpResponseRedirect(url)
+        else:
+            logger.warning(
+                "Gone: %s", request.path, extra={"status_code": 410, "request": request}
+            )
+            return HttpResponseGone()
+
+    def head(self, request, *args, **kwargs):
+        return self.get(request, *args, **kwargs)
+
+    def post(self, request, *args, **kwargs):
+        return self.get(request, *args, **kwargs)
+
+    def options(self, request, *args, **kwargs):
+        return self.get(request, *args, **kwargs)
+
+    def delete(self, request, *args, **kwargs):
+        return self.get(request, *args, **kwargs)
+
+    def put(self, request, *args, **kwargs):
+        return self.get(request, *args, **kwargs)
+
+    def patch(self, request, *args, **kwargs):
+        return self.get(request, *args, **kwargs)

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

@@ -0,0 +1,180 @@
+from django.core.exceptions import ImproperlyConfigured
+from django.db import models
+from django.http import Http404
+from django.utils.translation import gettext as _
+from django.views.generic.base import ContextMixin, TemplateResponseMixin, View
+
+
+class SingleObjectMixin(ContextMixin):
+    """
+    Provide the ability to retrieve a single object for further manipulation.
+    """
+
+    model = None
+    queryset = None
+    slug_field = "slug"
+    context_object_name = None
+    slug_url_kwarg = "slug"
+    pk_url_kwarg = "pk"
+    query_pk_and_slug = False
+
+    def get_object(self, queryset=None):
+        """
+        Return the object the view is displaying.
+
+        Require `self.queryset` and a `pk` or `slug` argument in the URLconf.
+        Subclasses can override this to return any object.
+        """
+        # Use a custom queryset if provided; this is required for subclasses
+        # like DateDetailView
+        if queryset is None:
+            queryset = self.get_queryset()
+
+        # Next, try looking up by primary key.
+        pk = self.kwargs.get(self.pk_url_kwarg)
+        slug = self.kwargs.get(self.slug_url_kwarg)
+        if pk is not None:
+            queryset = queryset.filter(pk=pk)
+
+        # Next, try looking up by slug.
+        if slug is not None and (pk is None or self.query_pk_and_slug):
+            slug_field = self.get_slug_field()
+            queryset = queryset.filter(**{slug_field: slug})
+
+        # If none of those are defined, it's an error.
+        if pk is None and slug is None:
+            raise AttributeError(
+                "Generic detail view %s must be called with either an object "
+                "pk or a slug in the URLconf." % self.__class__.__name__
+            )
+
+        try:
+            # Get the single item from the filtered queryset
+            obj = queryset.get()
+        except queryset.model.DoesNotExist:
+            raise Http404(
+                _("No %(verbose_name)s found matching the query")
+                % {"verbose_name": queryset.model._meta.verbose_name}
+            )
+        return obj
+
+    def get_queryset(self):
+        """
+        Return the `QuerySet` that will be used to look up the object.
+
+        This method is called by the default implementation of get_object() and
+        may not be called if get_object() is overridden.
+        """
+        if self.queryset is None:
+            if self.model:
+                return self.model._default_manager.all()
+            else:
+                raise ImproperlyConfigured(
+                    "%(cls)s is missing a QuerySet. Define "
+                    "%(cls)s.model, %(cls)s.queryset, or override "
+                    "%(cls)s.get_queryset()." % {"cls": self.__class__.__name__}
+                )
+        return self.queryset.all()
+
+    def get_slug_field(self):
+        """Get the name of a slug field to be used to look up by slug."""
+        return self.slug_field
+
+    def get_context_object_name(self, obj):
+        """Get the name to use for the object."""
+        if self.context_object_name:
+            return self.context_object_name
+        elif isinstance(obj, models.Model):
+            return obj._meta.model_name
+        else:
+            return None
+
+    def get_context_data(self, **kwargs):
+        """Insert the single object into the context dict."""
+        context = {}
+        if self.object:
+            context["object"] = self.object
+            context_object_name = self.get_context_object_name(self.object)
+            if context_object_name:
+                context[context_object_name] = self.object
+        context.update(kwargs)
+        return super().get_context_data(**context)
+
+
+class BaseDetailView(SingleObjectMixin, View):
+    """A base view for displaying a single object."""
+
+    def get(self, request, *args, **kwargs):
+        self.object = self.get_object()
+        context = self.get_context_data(object=self.object)
+        return self.render_to_response(context)
+
+
+class SingleObjectTemplateResponseMixin(TemplateResponseMixin):
+    template_name_field = None
+    template_name_suffix = "_detail"
+
+    def get_template_names(self):
+        """
+        Return a list of template names to be used for the request. May not be
+        called if render_to_response() is overridden. Return the following list:
+
+        * the value of ``template_name`` on the view (if provided)
+        * the contents of the ``template_name_field`` field on the
+          object instance that the view is operating upon (if available)
+        * ``<app_label>/<model_name><template_name_suffix>.html``
+        """
+        try:
+            names = super().get_template_names()
+        except ImproperlyConfigured:
+            # If template_name isn't specified, it's not a problem --
+            # we just start with an empty list.
+            names = []
+
+            # If self.template_name_field is set, grab the value of the field
+            # of that name from the object; this is the most specific template
+            # name, if given.
+            if self.object and self.template_name_field:
+                name = getattr(self.object, self.template_name_field, None)
+                if name:
+                    names.insert(0, name)
+
+            # The least-specific option is the default <app>/<model>_detail.html;
+            # only use this if the object in question is a model.
+            if isinstance(self.object, models.Model):
+                object_meta = self.object._meta
+                names.append(
+                    "%s/%s%s.html"
+                    % (
+                        object_meta.app_label,
+                        object_meta.model_name,
+                        self.template_name_suffix,
+                    )
+                )
+            elif getattr(self, "model", None) is not None and issubclass(
+                self.model, models.Model
+            ):
+                names.append(
+                    "%s/%s%s.html"
+                    % (
+                        self.model._meta.app_label,
+                        self.model._meta.model_name,
+                        self.template_name_suffix,
+                    )
+                )
+
+            # If we still haven't managed to find any template names, we should
+            # re-raise the ImproperlyConfigured to alert the user.
+            if not names:
+                raise
+
+        return names
+
+
+class DetailView(SingleObjectTemplateResponseMixin, BaseDetailView):
+    """
+    Render a "detail" view of an object.
+
+    By default this is a model instance looked up from `self.queryset`, but the
+    view will support display of *any* object by overriding `self.get_object()`.
+    """

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

@@ -0,0 +1,253 @@
+{% load i18n %}
+<!doctype html>
+{% get_current_language as LANGUAGE_CODE %}{% get_current_language_bidi as LANGUAGE_BIDI %}
+<html lang="{{ LANGUAGE_CODE|default:'en-us' }}" dir="{{ LANGUAGE_BIDI|yesno:'rtl,ltr,auto' }}">
+    <head>
+        <meta charset="utf-8">
+        <title>{% translate "The install worked successfully! Congratulations!" %}</title>
+        <meta name="viewport" content="width=device-width, initial-scale=1">
+        <style>
+          html {
+            line-height: 1.15;
+          }
+          a {
+            color: #19865C;
+          }
+          header {
+            border-bottom: 1px solid #efefef;
+          }
+          body {
+            max-width: 960px;
+            color: #525252;
+            font-family: "Segoe UI", system-ui, sans-serif;
+            margin: 0 auto;
+          }
+          main {
+            text-align: center;
+          }
+          h1, h2, h3, h4, h5, p, ul {
+            padding: 0;
+            margin: 0;
+            font-weight: 400;
+          }
+          header {
+            display: grid;
+            grid-template-columns: auto auto;
+            align-items: self-end;
+            justify-content: space-between;
+            gap: 7px;
+            padding-top: 20px;
+            padding-bottom: 10px;
+          }
+          .logo {
+            font-weight: 700;
+            font-size: 1.375rem;
+            text-decoration: none;
+          }
+          .figure {
+            margin-top: 19vh;
+            max-width: 265px;
+            position: relative;
+            z-index: -9;
+            overflow: visible;
+          }
+          .exhaust__line {
+            animation: thrust 70ms 100 ease-in-out alternate;
+          }
+          .smoke {
+            animation: smoke .1s 70 ease-in-out alternate;
+          }
+          @keyframes smoke {
+            0% {
+              transform: translate3d(-5px, 0, 0);
+            }
+            100% {
+              transform: translate3d(5px, 0, 0);
+            }
+          }
+          .flame {
+            animation: burnInner2 .1s 70 ease-in-out alternate;
+          }
+          @keyframes burnInner2 {
+            0% {
+              transform: translate3d(0, 0, 0);
+            }
+            100% {
+              transform: translate3d(0, 3px, 0);
+            }
+          }
+          @keyframes thrust {
+            0% {
+              opacity: 1;
+            }
+            100% {
+              opacity: .5;
+            }
+          }
+          @media (prefers-reduced-motion: reduce) {
+            .exhaust__line,
+            .smoke,
+            .flame {
+              animation: none;
+            }
+          }
+          h1 {
+            font-size: 1.375rem;
+            max-width: 32rem;
+            margin: 5px auto 0;
+          }
+          main p {
+            line-height: 1.25;
+            max-width: 26rem;
+            margin: 15px auto 0;
+          }
+          footer {
+            display: grid;
+            grid-template-columns: 1fr 1fr 1fr;
+            gap: 5px;
+            padding: 25px 0;
+            position: fixed;
+            box-sizing: border-box;
+            left: 50%;
+            bottom: 0;
+            width: 960px;
+            transform: translateX(-50%);
+            transform-style: preserve-3d;
+            border-top: 1px solid #efefef;
+          }
+          .option {
+            display: grid;
+            grid-template-columns: min-content 1fr;
+            gap: 10px;
+            box-sizing: border-box;
+            text-decoration: none;
+          }
+          .option svg {
+            width: 1.5rem;
+            height: 1.5rem;
+            fill: gray;
+            border: 1px solid #d6d6d6;
+            padding: 5px;
+            border-radius: 100%;
+          }
+          .option p {
+            font-weight: 300;
+            line-height: 1.25;
+            color: #525252;
+            display: table;
+          }
+          .option .option__heading {
+            color: #19865C;
+            font-size: 1.25rem;
+            font-weight: 400;
+          }
+          @media (max-width: 996px) {
+            body, footer {
+              max-width: 780px;
+            }
+          }
+          @media (max-width: 800px) {
+            footer {
+              height: 100%;
+              grid-template-columns: 1fr;
+              gap: 60px;
+              position: relative;
+              padding: 25px;
+            }
+            .figure {
+              margin-top: 10px;
+            }
+            main {
+              padding: 0 25px;
+            }
+            main h1 {
+              font-size: 1.25rem;
+            }
+            header {
+              grid-template-columns: 1fr;
+              padding-left: 20px;
+              padding-right: 20px;
+            }
+            footer {
+              width: 100%;
+              margin-top: 50px;
+            }
+          }
+          @media (min-width: 801px) and (max-height: 730px) {
+            .figure {
+              margin-top: 80px;
+            }
+          }
+          @media (min-width: 801px) and (max-height: 600px) {
+            footer {
+              position: relative;
+              margin: 135px auto 0;
+            }
+            .figure {
+              margin-top: 50px;
+            }
+          }
+          .sr-only {
+            clip: rect(1px, 1px, 1px, 1px);
+            clip-path: inset(50%);
+            height: 1px;
+            overflow: hidden;
+            position: absolute;
+            white-space: nowrap;
+            width: 1px;
+          }
+        </style>
+    </head>
+    <body>
+      <header>
+          <a class="logo" href="https://www.djangoproject.com/" target="_blank" rel="noopener">
+            django
+          </a>
+          <p>{% blocktranslate %}View <a href="https://docs.djangoproject.com/en/{{ version }}/releases/" target="_blank" rel="noopener">release notes</a> for Django {{ version }}{% endblocktranslate %}</p>
+      </header>
+      <main>
+        <svg class="figure" viewBox="0 0 508 268" aria-hidden="true">
+          <path d="M305.2 156.6c0 4.6-.5 9-1.6 13.2-2.5-4.4-5.6-8.4-9.2-12-4.6-4.6-10-8.4-16-11.2 2.8-11.2 4.5-22.9 5-34.6 1.8 1.4 3.5 2.9 5 4.5 10.5 10.3 16.8 24.5 16.8 40.1zm-75-10c-6 2.8-11.4 6.6-16 11.2-3.5 3.6-6.6 7.6-9.1 12-1-4.3-1.6-8.7-1.6-13.2 0-15.7 6.3-29.9 16.6-40.1 1.6-1.6 3.3-3.1 5.1-4.5.6 11.8 2.2 23.4 5 34.6z" fill="#2E3B39" fill-rule="nonzero"/>
+          <path d="M282.981 152.6c16.125-48.1 6.375-104-29.25-142.6-35.625 38.5-45.25 94.5-29.25 142.6h58.5z" stroke="#FFF" stroke-width="3.396" fill="#6DDCBD"/>
+          <path d="M271 29.7c-4.4-10.6-9.9-20.6-16.6-29.7-6.7 9-12.2 19-16.6 29.7H271z" stroke="#FFF" stroke-width="3" fill="#2E3B39"/>
+          <circle fill="#FFF" cx="254.3" cy="76.8" r="15.5"/>
+          <circle stroke="#FFF" stroke-width="7" fill="#6DDCBD" cx="254.3" cy="76.8" r="12.2"/>
+          <path class="smoke" d="M507.812 234.24c0-2.16-.632-4.32-1.58-6.24-3.318-6.72-11.85-11.52-21.804-11.52-1.106 0-2.212.12-3.318.24-.474-11.52-12.956-20.76-28.282-20.76-3.318 0-6.636.48-9.638 1.32-4.74-6.72-14.062-11.28-24.806-11.28-.79 0-1.58 0-2.37.12-.79 0-1.58-.12-2.37-.12-10.744 0-20.066 4.56-24.806 11.28a35.326 35.326 0 00-9.638-1.32c-15.642 0-28.282 9.6-28.282 21.48 0 1.32.158 2.76.474 3.96a26.09 26.09 0 00-4.424-.36c-8.058 0-15.01 3.12-19.118 7.8-3.476-1.68-7.742-2.76-12.324-2.76-12.008 0-21.804 7.08-22.752 15.96h-.158c-9.322 0-17.38 4.32-20.856 10.44-4.108-3.6-10.27-6-17.222-6h-1.264c-6.794 0-12.956 2.28-17.222 6-3.476-6.12-11.534-10.44-20.856-10.44h-.158c-.948-9-10.744-15.96-22.752-15.96-4.582 0-8.69.96-12.324 2.76-4.108-4.68-11.06-7.8-19.118-7.8-1.422 0-3.002.12-4.424.36.316-1.32.474-2.64.474-3.96 0-11.88-12.64-21.48-28.282-21.48-3.318 0-6.636.48-9.638 1.32-4.74-6.72-14.062-11.28-24.806-11.28-.79 0-1.58 0-2.37.12-.79 0-1.58-.12-2.37-.12-10.744 0-20.066 4.56-24.806 11.28a35.326 35.326 0 00-9.638-1.32c-15.326 0-27.808 9.24-28.282 20.76-1.106-.12-2.212-.24-3.318-.24-9.954 0-18.486 4.8-21.804 11.52-.948 1.92-1.58 4.08-1.58 6.24 0 4.8 2.528 9.12 6.636 12.36-.79 1.44-1.264 3.12-1.264 4.8 0 7.2 7.742 13.08 17.222 13.08h462.15c9.48 0 17.222-5.88 17.222-13.08 0-1.68-.474-3.36-1.264-4.8 4.582-3.24 7.11-7.56 7.11-12.36z" fill="#E6E9EE"/>
+          <path fill="#6DDCBD" d="M239 152h30v8h-30z"/>
+          <path class="exhaust__line" fill="#E6E9EE" d="M250 172h7v90h-7z"/>
+          <path class="flame" d="M250.27 178.834l-5.32-8.93s-2.47-5.7 3.458-6.118h10.26s6.232.266 3.306 6.194l-5.244 8.93s-3.23 4.37-6.46 0v-.076z" fill="#AA2247"/>
+        </svg>
+        <h1>{% translate "The install worked successfully! Congratulations!" %}</h1>
+        <p>{% blocktranslate %}You are seeing this page because <a href="https://docs.djangoproject.com/en/{{ version }}/ref/settings/#debug" target="_blank" rel="noopener">DEBUG=True</a> is in your settings file and you have not configured any URLs.{% endblocktranslate %}</p>
+      </main>
+      <footer>
+        <a class="option" href="https://docs.djangoproject.com/en/{{ version }}/" target="_blank" rel="noopener">
+          <svg viewBox="0 0 24 24" aria-hidden="true">
+            <path d="M9 21c0 .55.45 1 1 1h4c.55 0 1-.45 1-1v-1H9v1zm3-19C8.14 2 5 5.14 5 9c0 2.38 1.19 4.47 3 5.74V17c0 .55.45 1 1 1h6c.55 0 1-.45 1-1v-2.26c1.81-1.27 3-3.36 3-5.74 0-3.86-3.14-7-7-7zm2.85 11.1l-.85.6V16h-4v-2.3l-.85-.6A4.997 4.997 0 017 9c0-2.76 2.24-5 5-5s5 2.24 5 5c0 1.63-.8 3.16-2.15 4.1z"></path>
+          </svg>
+          <p>
+            <span class="option__heading">{% translate "Django Documentation" %}</span><span class="sr-only">.</span><br>
+            {% translate 'Topics, references, &amp; how-to’s' %}
+          </p>
+        </a>
+        <a class="option" href="https://docs.djangoproject.com/en/{{ version }}/intro/tutorial01/" target="_blank" rel="noopener">
+          <svg viewBox="0 0 24 24" aria-hidden="true">
+            <path d="M9.4 16.6L4.8 12l4.6-4.6L8 6l-6 6 6 6 1.4-1.4zm5.2 0l4.6-4.6-4.6-4.6L16 6l6 6-6 6-1.4-1.4z"></path>
+          </svg>
+          <p>
+            <span class="option__heading">{% translate "Tutorial: A Polling App" %}</span><span class="sr-only">.</span><br>
+            {% translate "Get started with Django" %}
+          </p>
+        </a>
+        <a class="option" href="https://www.djangoproject.com/community/" target="_blank" rel="noopener">
+          <svg viewBox="0 0 24 24" aria-hidden="true">
+            <path d="M16.5 13c-1.2 0-3.07.34-4.5 1-1.43-.67-3.3-1-4.5-1C5.33 13 1 14.08 1 16.25V19h22v-2.75c0-2.17-4.33-3.25-6.5-3.25zm-4 4.5h-10v-1.25c0-.54 2.56-1.75 5-1.75s5 1.21 5 1.75v1.25zm9 0H14v-1.25c0-.46-.2-.86-.52-1.22.88-.3 1.96-.53 3.02-.53 2.44 0 5 1.21 5 1.75v1.25zM7.5 12c1.93 0 3.5-1.57 3.5-3.5S9.43 5 7.5 5 4 6.57 4 8.5 5.57 12 7.5 12zm0-5.5c1.1 0 2 .9 2 2s-.9 2-2 2-2-.9-2-2 .9-2 2-2zm9 5.5c1.93 0 3.5-1.57 3.5-3.5S18.43 5 16.5 5 13 6.57 13 8.5s1.57 3.5 3.5 3.5zm0-5.5c1.1 0 2 .9 2 2s-.9 2-2 2-2-.9-2-2 .9-2 2-2z"></path>
+          </svg>
+          <p>
+            <span class="option__heading">{% translate "Django Community" %}</span><span class="sr-only">.</span><br>
+            {% translate "Connect, get help, or contribute" %}
+          </p>
+        </a>
+      </footer>
+    </body>
+</html>

testbed/django__django/django/views/templates/i18n_catalog.js

@@ -0,0 +1,102 @@
+{% autoescape off %}
+'use strict';
+{
+  const globals = this;
+  const django = globals.django || (globals.django = {});
+
+  {% if plural %}
+  django.pluralidx = function(n) {
+    const v = {{ plural }};
+    if (typeof v === 'boolean') {
+      return v ? 1 : 0;
+    } else {
+      return v;
+    }
+  };
+  {% else %}
+  django.pluralidx = function(count) { return (count == 1) ? 0 : 1; };
+  {% endif %}
+
+  /* gettext library */
+
+  django.catalog = django.catalog || {};
+  {% if catalog_str %}
+  const newcatalog = {{ catalog_str }};
+  for (const key in newcatalog) {
+    django.catalog[key] = newcatalog[key];
+  }
+  {% endif %}
+
+  if (!django.jsi18n_initialized) {
+    django.gettext = function(msgid) {
+      const value = django.catalog[msgid];
+      if (typeof value === 'undefined') {
+        return msgid;
+      } else {
+        return (typeof value === 'string') ? value : value[0];
+      }
+    };
+
+    django.ngettext = function(singular, plural, count) {
+      const value = django.catalog[singular];
+      if (typeof value === 'undefined') {
+        return (count == 1) ? singular : plural;
+      } else {
+        return value.constructor === Array ? value[django.pluralidx(count)] : value;
+      }
+    };
+
+    django.gettext_noop = function(msgid) { return msgid; };
+
+    django.pgettext = function(context, msgid) {
+      let value = django.gettext(context + '\x04' + msgid);
+      if (value.includes('\x04')) {
+        value = msgid;
+      }
+      return value;
+    };
+
+    django.npgettext = function(context, singular, plural, count) {
+      let value = django.ngettext(context + '\x04' + singular, context + '\x04' + plural, count);
+      if (value.includes('\x04')) {
+        value = django.ngettext(singular, plural, count);
+      }
+      return value;
+    };
+
+    django.interpolate = function(fmt, obj, named) {
+      if (named) {
+        return fmt.replace(/%\(\w+\)s/g, function(match){return String(obj[match.slice(2,-2)])});
+      } else {
+        return fmt.replace(/%s/g, function(match){return String(obj.shift())});
+      }
+    };
+
+
+    /* formatting library */
+
+    django.formats = {{ formats_str }};
+
+    django.get_format = function(format_type) {
+      const value = django.formats[format_type];
+      if (typeof value === 'undefined') {
+        return format_type;
+      } else {
+        return value;
+      }
+    };
+
+    /* add to global namespace */
+    globals.pluralidx = django.pluralidx;
+    globals.gettext = django.gettext;
+    globals.ngettext = django.ngettext;
+    globals.gettext_noop = django.gettext_noop;
+    globals.pgettext = django.pgettext;
+    globals.npgettext = django.npgettext;
+    globals.interpolate = django.interpolate;
+    globals.get_format = django.get_format;
+
+    django.jsi18n_initialized = true;
+  }
+};
+{% endautoescape %}