plain 0.13.1__py3-none-any.whl → 0.14.0__py3-none-any.whl

plain/cli/README.md

@@ -108,11 +108,11 @@ Some packages, like [plain-dev](https://plainframework.com/docs/plain-dev/),
 never show up in `INSTALLED_PACKAGES` but still have CLI commands.
 These are detected via Python entry points.
 
-An example with `pyproject.toml` and Poetry:
+An example with `pyproject.toml` and UV:
 
 ```toml
 # pyproject.toml
-[tool.poetry.plugins."plain.cli"]
+[project.entry-points."plain.cli"]
 "dev" = "plain.dev:cli"
 "pre-commit" = "plain.dev.precommit:cli"
 "contrib" = "plain.dev.contribute:cli"

plain/cli/cli.py

@@ -232,10 +232,10 @@ def preflight_checks(package_label, deploy, fail_level, databases):
             if visible_issue_count == 0
             else "1 issue"
             if visible_issue_count == 1
-            else "%s issues" % visible_issue_count,
+            else f"{visible_issue_count} issues",
             len(all_issues) - visible_issue_count,
         )
-        msg = click.style("SystemCheckError: %s" % header, fg="red") + body + footer
+        msg = click.style(f"SystemCheckError: {header}", fg="red") + body + footer
         raise click.ClickException(msg)
     else:
         if visible_issue_count:
@@ -245,7 +245,7 @@ def preflight_checks(package_label, deploy, fail_level, databases):
                 if visible_issue_count == 0
                 else "1 issue"
                 if visible_issue_count == 1
-                else "%s issues" % visible_issue_count,
+                else f"{visible_issue_count} issues",
                 len(all_issues) - visible_issue_count,
             )
             msg = header + body + footer
@@ -422,21 +422,17 @@ class AppCLIGroup(click.Group):
     MODULE_NAME = "app.cli"
 
     def list_commands(self, ctx):
-        try:
-            find_spec(self.MODULE_NAME)
+        if find_spec(self.MODULE_NAME):
             return ["app"]
-        except ModuleNotFoundError:
+        else:
             return []
 
     def get_command(self, ctx, name):
         if name != "app":
             return
 
-        try:
-            cli = importlib.import_module(self.MODULE_NAME)
-            return cli.cli
-        except ModuleNotFoundError:
-            return
+        cli = importlib.import_module(self.MODULE_NAME)
+        return cli.cli
 
 
 class PlainCommandCollection(click.CommandCollection):

plain/cli/packages.py

@@ -36,11 +36,15 @@ class InstalledPackagesGroup(click.Group):
     def get_command(self, ctx, name):
         # Try it as plain.x and just x (we don't know ahead of time which it is, but prefer plain.x)
         for n in [self.PLAIN_APPS_PREFIX + name, name]:
-            try:
-                cli = importlib.import_module(f"{n}.{self.MODULE_NAME}")
-            except ModuleNotFoundError:
+            if not find_spec(n):
+                # plain.<name> doesn't exist at all
+                continue
+
+            if not find_spec(f"{n}.{self.MODULE_NAME}"):
                 continue
 
+            cli = importlib.import_module(f"{n}.{self.MODULE_NAME}")
+
             # Get the app's cli.py group
             try:
                 return cli.cli

plain/cli/startup.py

@@ -10,9 +10,9 @@ def _print_bold(s):
 
 
 def _print_italic(s):
-    print("\x1B[3m", end="")
+    print("\x1b[3m", end="")
     print(s)
-    print("\x1B[0m", end="")
+    print("\x1b[0m", end="")
 
 
 _print_bold("\n⬣ Welcome to the Plain shell! ⬣")

plain/csrf/middleware.py

@@ -4,6 +4,7 @@ Cross Site Request Forgery Middleware.
 This module provides a middleware that implements protection
 against request forgeries from other sites.
 """
+
 import logging
 import string
 from collections import defaultdict

plain/exceptions.py

@@ -1,6 +1,7 @@
 """
 Global Plain exception and warning classes.
 """
+
 import operator
 
 from plain.utils.hashable import make_hashable
@@ -209,7 +210,7 @@ class ValidationError(Exception):
         return repr(list(self))
 
     def __repr__(self):
-        return "ValidationError(%s)" % self
+        return f"ValidationError({self})"
 
     def __eq__(self, other):
         if not isinstance(other, ValidationError):

plain/forms/forms.py

@@ -172,7 +172,7 @@ class BaseForm:
         if not isinstance(error, ValidationError):
             raise TypeError(
                 "The argument `error` must be an instance of "
-                "`ValidationError`, not `%s`." % type(error).__name__
+                f"`ValidationError`, not `{type(error).__name__}`."
             )
 
         if hasattr(error, "error_dict"):
@@ -221,9 +221,9 @@ class BaseForm:
         self._post_clean()
 
     def _field_data_value(self, field, html_name):
-        if hasattr(self, "parse_%s" % html_name):
+        if hasattr(self, f"parse_{html_name}"):
             # Allow custom parsing from form data/files at the form level
-            return getattr(self, "parse_%s" % html_name)()
+            return getattr(self, f"parse_{html_name}")()
 
         return field.value_from_form_data(self.data, self.files, html_name)
 
@@ -242,8 +242,8 @@ class BaseForm:
                 else:
                     value = field.clean(value)
                 self.cleaned_data[name] = value
-                if hasattr(self, "clean_%s" % name):
-                    value = getattr(self, "clean_%s" % name)()
+                if hasattr(self, f"clean_{name}"):
+                    value = getattr(self, f"clean_{name}")()
                     self.cleaned_data[name] = value
             except ValidationError as e:
                 self.add_error(name, e)

plain/http/multipartparser.py

@@ -4,6 +4,7 @@ Multi-part parsing for file uploads.
 Exposes one class, ``MultiPartParser``, which feeds chunks of uploaded data to
 file upload handlers for processing.
 """
+
 import base64
 import binascii
 import collections
@@ -70,14 +71,13 @@ class MultiPartParser:
         # Content-Type should contain multipart and the boundary information.
         content_type = META.get("CONTENT_TYPE", "")
         if not content_type.startswith("multipart/"):
-            raise MultiPartParserError("Invalid Content-Type: %s" % content_type)
+            raise MultiPartParserError(f"Invalid Content-Type: {content_type}")
 
         try:
             content_type.encode("ascii")
         except UnicodeEncodeError:
             raise MultiPartParserError(
-                "Invalid non-ASCII Content-Type in multipart: %s"
-                % force_str(content_type)
+                f"Invalid non-ASCII Content-Type in multipart: {force_str(content_type)}"
             )
 
         # Parse the header to get the boundary to split the parts.
@@ -85,7 +85,7 @@ class MultiPartParser:
         boundary = opts.get("boundary")
         if not boundary or not self.boundary_re.fullmatch(boundary):
             raise MultiPartParserError(
-                "Invalid boundary in multipart: %s" % force_str(boundary)
+                f"Invalid boundary in multipart: {force_str(boundary)}"
             )
 
         # Content-Length should contain the length of the body we are about
@@ -97,7 +97,7 @@ class MultiPartParser:
 
         if content_length < 0:
             # This means we shouldn't continue...raise an error.
-            raise MultiPartParserError("Invalid content length: %r" % content_length)
+            raise MultiPartParserError(f"Invalid content length: {content_length!r}")
 
         self._boundary = boundary.encode("ascii")
         self._input_data = input_data

plain/http/request.py

@@ -81,7 +81,7 @@ class HttpRequest:
 
     def __repr__(self):
         if self.method is None or not self.get_full_path():
-            return "<%s>" % self.__class__.__name__
+            return f"<{self.__class__.__name__}>"
         return f"<{self.__class__.__name__}: {self.method} {self.get_full_path()!r}>"
 
     def __getstate__(self):
@@ -157,9 +157,9 @@ class HttpRequest:
         if domain and validate_host(domain, allowed_hosts):
             return host
         else:
-            msg = "Invalid HTTP_HOST header: %r." % host
+            msg = f"Invalid HTTP_HOST header: {host!r}."
             if domain:
-                msg += " You may need to add %r to ALLOWED_HOSTS." % domain
+                msg += f" You may need to add {domain!r} to ALLOWED_HOSTS."
             else:
                 msg += (
                     " The domain name provided is not valid according to RFC 1034/1035."
@@ -227,7 +227,7 @@ class HttpRequest:
         if location is None:
             # Make it an absolute url (but schemeless and domainless) for the
             # edge case that the path starts with '//'.
-            location = "//%s" % self.get_full_path()
+            location = f"//{self.get_full_path()}"
         else:
             # Coerce lazy locations.
             location = str(location)
@@ -671,7 +671,7 @@ class MediaType:
         params_str = "".join(f"; {k}={v}" for k, v in self.params.items())
         return "{}{}{}".format(
             self.main_type,
-            ("/%s" % self.sub_type) if self.sub_type else "",
+            (f"/{self.sub_type}") if self.sub_type else "",
             params_str,
         )
 

plain/http/response.py

@@ -7,6 +7,7 @@ import re
 import sys
 import time
 from email.header import Header
+from functools import cached_property
 from http.client import responses
 from http.cookies import SimpleCookie
 from urllib.parse import urlparse
@@ -72,7 +73,7 @@ class ResponseHeaders(CaseInsensitiveMapping):
             if mime_encode:
                 value = Header(value, "utf-8", maxlinelen=sys.maxsize).encode()
             else:
-                e.reason += ", HTTP response headers must be in %s format" % charset
+                e.reason += f", HTTP response headers must be in {charset} format"
                 raise
         return value
 
@@ -181,7 +182,7 @@ class ResponseBase:
     @property
     def _content_type_for_repr(self):
         return (
-            ', "%s"' % self.headers["Content-Type"]
+            ', "{}"'.format(self.headers["Content-Type"])
             if "Content-Type" in self.headers
             else ""
         )
@@ -236,8 +237,8 @@ class ResponseBase:
         if expires is not None:
             if isinstance(expires, datetime.datetime):
                 if timezone.is_naive(expires):
-                    expires = timezone.make_aware(expires, datetime.timezone.utc)
-                delta = expires - datetime.datetime.now(tz=datetime.timezone.utc)
+                    expires = timezone.make_aware(expires, datetime.UTC)
+                delta = expires - datetime.datetime.now(tz=datetime.UTC)
                 # Add one second so the date matches exactly (a fraction of
                 # time gets lost between converting to a timedelta and
                 # then the date string).
@@ -332,14 +333,14 @@ class ResponseBase:
         signals.request_finished.send(sender=self._handler_class)
 
     def write(self, content):
-        raise OSError("This %s instance is not writable" % self.__class__.__name__)
+        raise OSError(f"This {self.__class__.__name__} instance is not writable")
 
     def flush(self):
         pass
 
     def tell(self):
         raise OSError(
-            "This %s instance cannot tell its position" % self.__class__.__name__
+            f"This {self.__class__.__name__} instance cannot tell its position"
         )
 
     # These methods partially implement a stream-like object interface.
@@ -355,7 +356,7 @@ class ResponseBase:
         return False
 
     def writelines(self, lines):
-        raise OSError("This %s instance is not writable" % self.__class__.__name__)
+        raise OSError(f"This {self.__class__.__name__} instance is not writable")
 
 
 class Response(ResponseBase):
@@ -390,7 +391,7 @@ class Response(ResponseBase):
         return obj_dict
 
     def __repr__(self):
-        return "<%(cls)s status_code=%(status_code)d%(content_type)s>" % {
+        return "<%(cls)s status_code=%(status_code)d%(content_type)s>" % {  # noqa: UP031
             "cls": self.__class__.__name__,
             "status_code": self.status_code,
             "content_type": self._content_type_for_repr,
@@ -423,6 +424,10 @@ class Response(ResponseBase):
         # Create a list of properly encoded bytestrings to support write().
         self._container = [content]
 
+    @cached_property
+    def text(self):
+        return self.content.decode(self.charset or "utf-8")
+
     def __iter__(self):
         return iter(self._container)
 
@@ -461,7 +466,7 @@ class StreamingResponse(ResponseBase):
         self.streaming_content = streaming_content
 
     def __repr__(self):
-        return "<%(cls)s status_code=%(status_code)d%(content_type)s>" % {
+        return "<%(cls)s status_code=%(status_code)d%(content_type)s>" % {  # noqa: UP031
             "cls": self.__class__.__qualname__,
             "status_code": self.status_code,
             "content_type": self._content_type_for_repr,
@@ -470,8 +475,8 @@ class StreamingResponse(ResponseBase):
     @property
     def content(self):
         raise AttributeError(
-            "This %s instance has no `content` attribute. Use "
-            "`streaming_content` instead." % self.__class__.__name__
+            f"This {self.__class__.__name__} instance has no `content` attribute. Use "
+            "`streaming_content` instead."
         )
 
     @property
@@ -586,14 +591,14 @@ class ResponseRedirectBase(Response):
         parsed = urlparse(str(redirect_to))
         if parsed.scheme and parsed.scheme not in self.allowed_schemes:
             raise DisallowedRedirect(
-                "Unsafe redirect to URL with protocol '%s'" % parsed.scheme
+                f"Unsafe redirect to URL with protocol '{parsed.scheme}'"
             )
 
     url = property(lambda self: self["Location"])
 
     def __repr__(self):
         return (
-            '<%(cls)s status_code=%(status_code)d%(content_type)s, url="%(url)s">'
+            '<%(cls)s status_code=%(status_code)d%(content_type)s, url="%(url)s">'  # noqa: UP031
             % {
                 "cls": self.__class__.__name__,
                 "status_code": self.status_code,
@@ -661,7 +666,7 @@ class ResponseNotAllowed(Response):
         self["Allow"] = ", ".join(permitted_methods)
 
     def __repr__(self):
-        return "<%(cls)s [%(methods)s] status_code=%(status_code)d%(content_type)s>" % {
+        return "<%(cls)s [%(methods)s] status_code=%(status_code)d%(content_type)s>" % {  # noqa: UP031
             "cls": self.__class__.__name__,
             "status_code": self.status_code,
             "content_type": self._content_type_for_repr,

plain/internal/files/locks.py

@@ -16,6 +16,7 @@ Example Usage::
     ...     locks.lock(f, locks.LOCK_EX)
     ...     f.write('Plain')
 """
+
 import os
 
 __all__ = ("LOCK_EX", "LOCK_SH", "LOCK_NB", "lock", "unlock")

plain/internal/files/move.py

@@ -46,8 +46,7 @@ def file_move_safe(
     try:
         if not allow_overwrite and os.access(new_file_name, os.F_OK):
             raise FileExistsError(
-                "Destination file %s exists and allow_overwrite is False."
-                % new_file_name
+                f"Destination file {new_file_name} exists and allow_overwrite is False."
             )
 
         os.rename(old_file_name, new_file_name)

plain/internal/files/uploadhandler.py

@@ -1,6 +1,7 @@
 """
 Base file upload handler classes, and the built-in concrete subclasses
 """
+
 import os
 from io import BytesIO
 

plain/internal/files/utils.py

@@ -7,7 +7,7 @@ from plain.exceptions import SuspiciousFileOperation
 def validate_file_name(name, allow_relative_path=False):
     # Remove potentially dangerous names
     if os.path.basename(name) in {"", ".", ".."}:
-        raise SuspiciousFileOperation("Could not derive file name from '%s'" % name)
+        raise SuspiciousFileOperation(f"Could not derive file name from '{name}'")
 
     if allow_relative_path:
         # Use PurePosixPath() because this branch is checked only in
@@ -16,10 +16,10 @@ def validate_file_name(name, allow_relative_path=False):
         path = pathlib.PurePosixPath(name)
         if path.is_absolute() or ".." in path.parts:
             raise SuspiciousFileOperation(
-                "Detected path traversal attempt in '%s'" % name
+                f"Detected path traversal attempt in '{name}'"
             )
     elif name != os.path.basename(name):
-        raise SuspiciousFileOperation("File name '%s' includes path elements" % name)
+        raise SuspiciousFileOperation(f"File name '{name}' includes path elements")
 
     return name
 

plain/internal/handlers/base.py

@@ -45,7 +45,7 @@ class BaseHandler:
 
             if mw_instance is None:
                 raise ImproperlyConfigured(
-                    "Middleware factory %s returned None." % middleware_path
+                    f"Middleware factory {middleware_path} returned None."
                 )
 
             if hasattr(mw_instance, "process_view"):
@@ -126,14 +126,10 @@ class BaseHandler:
             if isinstance(callback, types.FunctionType):  # FBV
                 name = f"The view {callback.__module__}.{callback.__name__}"
             else:  # CBV
-                name = "The view {}.{}.__call__".format(
-                    callback.__module__,
-                    callback.__class__.__name__,
-                )
+                name = f"The view {callback.__module__}.{callback.__class__.__name__}.__call__"
         if response is None:
             raise ValueError(
-                "%s didn't return a Response object. It returned None "
-                "instead." % name
+                f"{name} didn't return a Response object. It returned None " "instead."
             )
 
 

plain/internal/handlers/exception.py

@@ -85,9 +85,7 @@ def response_for_exception(request, exc):
 
         # The request logger receives events for any problematic request
         # The security logger receives events for all SuspiciousOperations
-        security_logger = logging.getLogger(
-            "plain.security.%s" % exc.__class__.__name__
-        )
+        security_logger = logging.getLogger(f"plain.security.{exc.__class__.__name__}")
         security_logger.error(
             str(exc),
             exc_info=exc,

plain/internal/handlers/wsgi.py

@@ -138,7 +138,7 @@ class WSGIHandler(base.BaseHandler):
 
         response._handler_class = self.__class__
 
-        status = "%d %s" % (response.status_code, response.reason_phrase)
+        status = "%d %s" % (response.status_code, response.reason_phrase)  # noqa: UP031
         response_headers = [
             *response.items(),
             *(("Set-Cookie", c.output(header="")) for c in response.cookies.values()),

plain/internal/middleware/slash.py

@@ -34,7 +34,7 @@ class RedirectSlashMiddleware:
         if settings.APPEND_SLASH and not request.path_info.endswith("/"):
             urlconf = getattr(request, "urlconf", None)
             if not is_valid_path(request.path_info, urlconf):
-                match = is_valid_path("%s/" % request.path_info, urlconf)
+                match = is_valid_path(f"{request.path_info}/", urlconf)
                 if match:
                     view = match.func
                     return getattr(view, "should_append_slash", True)
@@ -52,13 +52,10 @@ class RedirectSlashMiddleware:
         new_path = escape_leading_slashes(new_path)
         if settings.DEBUG and request.method in ("POST", "PUT", "PATCH"):
             raise RuntimeError(
-                "You called this URL via {method}, but the URL doesn't end "
+                f"You called this URL via {request.method}, but the URL doesn't end "
                 "in a slash and you have APPEND_SLASH set. Plain can't "
-                "redirect to the slash URL while maintaining {method} data. "
-                "Change your form to point to {url} (note the trailing "
-                "slash), or set APPEND_SLASH=False in your Plain settings.".format(
-                    method=request.method,
-                    url=request.get_host() + new_path,
-                )
+                f"redirect to the slash URL while maintaining {request.method} data. "
+                f"Change your form to point to {request.get_host() + new_path} (note the trailing "
+                "slash), or set APPEND_SLASH=False in your Plain settings."
             )
         return new_path

plain/packages/config.py

@@ -35,7 +35,7 @@ class PackageConfig:
             self.label = package_name.rpartition(".")[2]
         if not self.label.isidentifier():
             raise ImproperlyConfigured(
-                "The app label '%s' is not a valid Python identifier." % self.label
+                f"The app label '{self.label}' is not a valid Python identifier."
             )
 
         # Filesystem path to the application directory e.g.
@@ -71,15 +71,15 @@ class PackageConfig:
                 paths = list(set(paths))
         if len(paths) > 1:
             raise ImproperlyConfigured(
-                "The app module {!r} has multiple filesystem locations ({!r}); "
+                f"The app module {module!r} has multiple filesystem locations ({paths!r}); "
                 "you must configure this app with an PackageConfig subclass "
-                "with a 'path' class attribute.".format(module, paths)
+                "with a 'path' class attribute."
             )
         elif not paths:
             raise ImproperlyConfigured(
-                "The app module %r has no filesystem location, "
+                f"The app module {module!r} has no filesystem location, "
                 "you must configure this app with an PackageConfig subclass "
-                "with a 'path' class attribute." % module
+                "with a 'path' class attribute."
             )
         return paths[0]
 
@@ -170,7 +170,7 @@ class PackageConfig:
                 ]
                 msg = f"Module '{mod_path}' does not contain a '{cls_name}' class."
                 if candidates:
-                    msg += " Choices are: %s." % ", ".join(candidates)
+                    msg += " Choices are: {}.".format(", ".join(candidates))
                 raise ImportError(msg)
             else:
                 # Re-trigger the module import exception.
@@ -179,9 +179,7 @@ class PackageConfig:
         # Check for obvious errors. (This check prevents duck typing, but
         # it could be removed if it became a problem in practice.)
         if not issubclass(package_config_class, PackageConfig):
-            raise ImproperlyConfigured(
-                "'%s' isn't a subclass of PackageConfig." % entry
-            )
+            raise ImproperlyConfigured(f"'{entry}' isn't a subclass of PackageConfig.")
 
         # Obtain package name here rather than in PackageClass.__init__ to keep
         # all error checking for entries in INSTALLED_PACKAGES in one place.
@@ -189,18 +187,14 @@ class PackageConfig:
             try:
                 package_name = package_config_class.name
             except AttributeError:
-                raise ImproperlyConfigured("'%s' must supply a name attribute." % entry)
+                raise ImproperlyConfigured(f"'{entry}' must supply a name attribute.")
 
         # Ensure package_name points to a valid module.
         try:
             package_module = import_module(package_name)
         except ImportError:
             raise ImproperlyConfigured(
-                "Cannot import '{}'. Check that '{}.{}.name' is correct.".format(
-                    package_name,
-                    package_config_class.__module__,
-                    package_config_class.__qualname__,
-                )
+                f"Cannot import '{package_name}'. Check that '{package_config_class.__module__}.{package_config_class.__qualname__}.name' is correct."
             )
 
         # Entry is a path to an app config class.

plain/packages/registry.py

@@ -90,7 +90,7 @@ class Packages:
                 if package_config.label in self.package_configs:
                     raise ImproperlyConfigured(
                         "Package labels aren't unique, "
-                        "duplicates: %s" % package_config.label
+                        f"duplicates: {package_config.label}"
                     )
 
                 self.package_configs[package_config.label] = package_config
@@ -103,8 +103,9 @@ class Packages:
             duplicates = [name for name, count in counts.most_common() if count > 1]
             if duplicates:
                 raise ImproperlyConfigured(
-                    "Package names aren't unique, "
-                    "duplicates: %s" % ", ".join(duplicates)
+                    "Package names aren't unique, " "duplicates: {}".format(
+                        ", ".join(duplicates)
+                    )
                 )
 
             self.packages_ready = True
@@ -154,10 +155,10 @@ class Packages:
         try:
             return self.package_configs[package_label]
         except KeyError:
-            message = "No installed app with label '%s'." % package_label
+            message = f"No installed app with label '{package_label}'."
             for package_config in self.get_package_configs():
                 if package_config.name == package_label:
-                    message += " Did you mean '%s'?" % package_config.label
+                    message += f" Did you mean '{package_config.label}'?"
                     break
             raise LookupError(message)
 
@@ -223,17 +224,15 @@ class Packages:
                 and model.__module__ == app_models[model_name].__module__
             ):
                 warnings.warn(
-                    "Model '{}.{}' was already registered. Reloading models is not "
+                    f"Model '{package_label}.{model_name}' was already registered. Reloading models is not "
                     "advised as it can lead to inconsistencies, most notably with "
-                    "related models.".format(package_label, model_name),
+                    "related models.",
                     RuntimeWarning,
                     stacklevel=2,
                 )
             else:
                 raise RuntimeError(
-                    "Conflicting '{}' models in application '{}': {} and {}.".format(
-                        model_name, package_label, app_models[model_name], model
-                    )
+                    f"Conflicting '{model_name}' models in application '{package_label}': {app_models[model_name]} and {model}."
                 )
         app_models[model_name] = model
         self.do_pending_operations(model)
@@ -321,8 +320,9 @@ class Packages:
         }
         if not available.issubset(installed):
             raise ValueError(
-                "Available packages isn't a subset of installed packages, extra packages: %s"
-                % ", ".join(available - installed)
+                "Available packages isn't a subset of installed packages, extra packages: {}".format(
+                    ", ".join(available - installed)
+                )
             )
 
         self.stored_package_configs.append(self.package_configs)

plain/paginator.py

@@ -142,8 +142,7 @@ class Page(collections.abc.Sequence):
     def __getitem__(self, index):
         if not isinstance(index, int | slice):
             raise TypeError(
-                "Page indices must be integers or slices, not %s."
-                % type(index).__name__
+                f"Page indices must be integers or slices, not {type(index).__name__}."
             )
         # The object_list is converted to a list so that if it was a QuerySet
         # it won't be a database hit per __getitem__.