wagtail 6.0.2__py3-none-any.whl → 6.1rc1__py3-none-any.whl

wagtail/locales/locale/en/LC_MESSAGES/django.po

@@ -8,7 +8,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: PACKAGE VERSION\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2024-01-24 13:51+0000\n"
+"POT-Creation-Date: 2024-04-18 17:28+0100\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <LL@li.org>\n"

wagtail/locales/tests.py

@@ -20,7 +20,10 @@ class TestLocaleIndexView(AdminTemplateTestUtils, WagtailTestUtils, TestCase):
         response = self.get()
         self.assertEqual(response.status_code, 200)
         self.assertTemplateUsed(response, "wagtailadmin/generic/index.html")
-        self.assertBreadcrumbsNotRendered(response.content)
+        self.assertBreadcrumbsItemsRendered(
+            [{"url": "", "label": "Locales"}],
+            response.content,
+        )
 
 
 class TestLocaleCreateView(AdminTemplateTestUtils, WagtailTestUtils, TestCase):
@@ -43,7 +46,13 @@ class TestLocaleCreateView(AdminTemplateTestUtils, WagtailTestUtils, TestCase):
         response = self.get()
         self.assertEqual(response.status_code, 200)
         self.assertTemplateUsed(response, "wagtaillocales/create.html")
-        self.assertBreadcrumbsNotRendered(response.content)
+        self.assertBreadcrumbsItemsRendered(
+            [
+                {"label": "Locales", "url": "/admin/locales/"},
+                {"label": "New: Locale", "url": ""},
+            ],
+            response.content,
+        )
 
         self.assertEqual(
             response.context["form"].fields["language_code"].choices, [("fr", "French")]
@@ -116,7 +125,13 @@ class TestLocaleEditView(AdminTemplateTestUtils, WagtailTestUtils, TestCase):
         response = self.get()
         self.assertEqual(response.status_code, 200)
         self.assertTemplateUsed(response, "wagtaillocales/edit.html")
-        self.assertBreadcrumbsNotRendered(response.content)
+        self.assertBreadcrumbsItemsRendered(
+            [
+                {"url": "/admin/locales/", "label": "Locales"},
+                {"url": "", "label": str(self.english)},
+            ],
+            response.content,
+        )
 
         self.assertEqual(
             response.context["form"].fields["language_code"].choices,

wagtail/locales/views.py

@@ -98,7 +98,6 @@ class LocaleViewSet(ModelViewSet):
     model = Locale
     permission_policy = locale_permission_policy
     add_to_reference_index = False
-    _show_breadcrumbs = False
 
     index_view_class = IndexView
     add_view_class = CreateView

wagtail/management/commands/rebuild_references_index.py

@@ -38,7 +38,9 @@ class Command(BaseCommand):
 
         with transaction.atomic():
             with disable_reference_index_auto_update():
-                ReferenceIndex.objects.all().delete()
+                # Use `_raw_delete` to avoid loading instances into memory
+                all_references = ReferenceIndex.objects.all()
+                all_references._raw_delete(using=all_references.db)
 
             for model in apps.get_models():
                 if not ReferenceIndex.is_indexed(model):

wagtail/migrations/0092_alter_collectionviewrestriction_password_and_more.py

@@ -0,0 +1,33 @@
+# Generated by Django 4.2.7 on 2024-02-01 21:21
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('wagtailcore', '0091_remove_revision_submitted_for_moderation'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='collectionviewrestriction',
+            name='password',
+            field=models.CharField(blank=True, help_text='Shared passwords should not be used to protect sensitive content. Anyone who has this password will be able to view the content.', max_length=255, verbose_name='shared password'),
+        ),
+        migrations.AlterField(
+            model_name='collectionviewrestriction',
+            name='restriction_type',
+            field=models.CharField(choices=[('none', 'Public'), ('password', 'Private, accessible with a shared password'), ('login', 'Private, accessible to any logged-in users'), ('groups', 'Private, accessible to users in specific groups')], max_length=20),
+        ),
+        migrations.AlterField(
+            model_name='pageviewrestriction',
+            name='password',
+            field=models.CharField(blank=True, help_text='Shared passwords should not be used to protect sensitive content. Anyone who has this password will be able to view the content.', max_length=255, verbose_name='shared password'),
+        ),
+        migrations.AlterField(
+            model_name='pageviewrestriction',
+            name='restriction_type',
+            field=models.CharField(choices=[('none', 'Public'), ('password', 'Private, accessible with a shared password'), ('login', 'Private, accessible to any logged-in users'), ('groups', 'Private, accessible to users in specific groups')], max_length=20),
+        ),
+    ]

wagtail/migrations/0093_uploadedfile.py

@@ -0,0 +1,53 @@
+# Generated by Django 4.2.7 on 2024-02-12 21:04
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ("contenttypes", "0002_remove_content_type_name"),
+        ("wagtailcore", "0092_alter_collectionviewrestriction_password_and_more"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="UploadedFile",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("file", models.FileField(max_length=200, upload_to="wagtail_uploads")),
+                (
+                    "for_content_type",
+                    models.ForeignKey(
+                        null=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="uploads",
+                        to="contenttypes.contenttype",
+                        verbose_name="for content type",
+                    ),
+                ),
+                (
+                    "uploaded_by_user",
+                    models.ForeignKey(
+                        blank=True,
+                        editable=False,
+                        null=True,
+                        on_delete=django.db.models.deletion.SET_NULL,
+                        to=settings.AUTH_USER_MODEL,
+                        verbose_name="uploaded by user",
+                    ),
+                ),
+            ],
+        ),
+    ]

wagtail/models/__init__.py

@@ -9,12 +9,16 @@ should implement low-level generic functionality which is then imported by highe
 as Page.
 """
 
+from __future__ import annotations
+
 import functools
 import logging
 import posixpath
 import uuid
 from io import StringIO
+from typing import TYPE_CHECKING
 from urllib.parse import urlparse
+from warnings import warn
 
 from django import forms
 from django.conf import settings
@@ -92,6 +96,7 @@ from wagtail.signals import (
     workflow_submitted,
 )
 from wagtail.url_routing import RouteResult
+from wagtail.utils.deprecation import RemovedInWagtail70Warning
 from wagtail.utils.timestamps import ensure_utc
 
 from .audit_log import (  # noqa: F401
@@ -100,16 +105,6 @@ from .audit_log import (  # noqa: F401
     LogEntryQuerySet,
     ModelLogEntry,
 )
-from .collections import (  # noqa: F401
-    BaseCollectionManager,
-    Collection,
-    CollectionManager,
-    CollectionMember,
-    CollectionViewRestriction,
-    GroupCollectionPermission,
-    GroupCollectionPermissionManager,
-    get_root_collection_id,
-)
 from .copying import _copy, _copy_m2m_relations, _extract_field_data  # noqa: F401
 from .i18n import (  # noqa: F401
     BootstrapTranslatableMixin,
@@ -120,11 +115,25 @@ from .i18n import (  # noqa: F401
     bootstrap_translatable_model,
     get_translatable_models,
 )
+from .media import (  # noqa: F401
+    BaseCollectionManager,
+    Collection,
+    CollectionManager,
+    CollectionMember,
+    CollectionViewRestriction,
+    GroupCollectionPermission,
+    GroupCollectionPermissionManager,
+    UploadedFile,
+    get_root_collection_id,
+)
 from .reference_index import ReferenceIndex  # noqa: F401
 from .sites import Site, SiteManager, SiteRootPath  # noqa: F401
 from .specific import SpecificMixin
 from .view_restrictions import BaseViewRestriction
 
+if TYPE_CHECKING:
+    from django.http import HttpRequest
+
 logger = logging.getLogger("wagtail")
 
 PAGE_TEMPLATE_VAR = "page"
@@ -1266,7 +1275,6 @@ class Page(AbstractPage, index.Indexed, ClusterableModel, metaclass=PageBase):
     exclude_fields_in_copy = []
     default_exclude_fields_in_copy = [
         "id",
-        "path",
         "depth",
         "numchild",
         "url_path",
@@ -1283,6 +1291,43 @@ class Page(AbstractPage, index.Indexed, ClusterableModel, metaclass=PageBase):
     promote_panels = []
     settings_panels = []
 
+    @staticmethod
+    def route_for_request(request: "HttpRequest", path: str) -> RouteResult | None:
+        """
+        Find the page route for the given HTTP request object, and URL path. The route
+        result (`page`, `args`, and `kwargs`) will be cached via
+        `request._wagtail_route_for_request`.
+        """
+        if not hasattr(request, "_wagtail_route_for_request"):
+            try:
+                # we need a valid Site object for this request in order to proceed
+                if site := Site.find_for_request(request):
+                    path_components = [
+                        component for component in path.split("/") if component
+                    ]
+                    request._wagtail_route_for_request = (
+                        site.root_page.localized.specific.route(
+                            request, path_components
+                        )
+                    )
+                else:
+                    request._wagtail_route_for_request = None
+            except Http404:
+                # .route() can raise Http404
+                request._wagtail_route_for_request = None
+
+        return request._wagtail_route_for_request
+
+    @staticmethod
+    def find_for_request(request: "HttpRequest", path: str) -> "Page" | None:
+        """
+        Find the page for the given HTTP request object, and URL path. The full
+        page route will be cached via `request._wagtail_route_for_request`
+        """
+        result = Page.route_for_request(request, path)
+        if result is not None:
+            return result[0]
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         if not self.id:
@@ -1625,6 +1670,11 @@ class Page(AbstractPage, index.Indexed, ClusterableModel, metaclass=PageBase):
 
             try:
                 subpage = self.get_children().get(slug=child_slug)
+                # Cache the parent page on the subpage to avoid another db query
+                # Treebeard's get_parent will use the `_cached_parent_obj` attribute if it exists
+                # And update = False
+                setattr(subpage, "_cached_parent_obj", self)
+
             except Page.DoesNotExist:
                 raise Http404
 
@@ -2549,9 +2599,7 @@ class Page(AbstractPage, index.Indexed, ClusterableModel, metaclass=PageBase):
 
         return PageViewRestriction.objects.filter(page_id__in=page_ids_to_check)
 
-    password_required_template = getattr(
-        settings, "PASSWORD_REQUIRED_TEMPLATE", "wagtailcore/password_required.html"
-    )
+    password_required_template = None
 
     def serve_password_required_response(self, request, form, action_url):
         """
@@ -2561,10 +2609,32 @@ class Page(AbstractPage, index.Indexed, ClusterableModel, metaclass=PageBase):
             (and zero or more hidden fields that also need to be output on the template)
         action_url = URL that this form should be POSTed to
         """
+
+        password_required_template = self.password_required_template
+
+        if not password_required_template:
+            password_required_template = getattr(
+                settings,
+                "WAGTAIL_PASSWORD_REQUIRED_TEMPLATE",
+                "wagtailcore/password_required.html",
+            )
+
+            if hasattr(settings, "PASSWORD_REQUIRED_TEMPLATE"):
+                warn(
+                    "The `PASSWORD_REQUIRED_TEMPLATE` setting is deprecated - use `WAGTAIL_PASSWORD_REQUIRED_TEMPLATE` instead.",
+                    category=RemovedInWagtail70Warning,
+                )
+
+                password_required_template = getattr(
+                    settings,
+                    "PASSWORD_REQUIRED_TEMPLATE",
+                    password_required_template,
+                )
+
         context = self.get_context(request)
         context["form"] = form
         context["action_url"] = action_url
-        return TemplateResponse(request, self.password_required_template, context)
+        return TemplateResponse(request, password_required_template, context)
 
     def with_content_json(self, content):
         """
@@ -2727,7 +2797,31 @@ class RevisionQuerySet(models.QuerySet):
         )
 
 
-RevisionsManager = models.Manager.from_queryset(RevisionQuerySet)
+class RevisionsManager(models.Manager.from_queryset(RevisionQuerySet)):
+    def previous_revision_id_subquery(self, revision_fk_name="revision"):
+        """
+        Returns a Subquery that can be used to annotate a queryset with the ID
+        of the previous revision, based on the revision_fk_name field. Useful
+        to avoid N+1 queries when generating comparison links between revisions.
+
+        The logic is similar to Revision.get_previous().pk.
+        """
+        fk = revision_fk_name
+        return Subquery(
+            Revision.objects.filter(
+                base_content_type_id=OuterRef(f"{fk}__base_content_type_id"),
+                object_id=OuterRef(f"{fk}__object_id"),
+            )
+            .filter(
+                Q(
+                    created_at=OuterRef(f"{fk}__created_at"),
+                    pk__lt=OuterRef(f"{fk}__pk"),
+                )
+                | Q(created_at__lt=OuterRef(f"{fk}__created_at"))
+            )
+            .order_by("-created_at", "-pk")
+            .values_list("pk", flat=True)[:1]
+        )
 
 
 class PageRevisionsManager(RevisionsManager):
@@ -3520,7 +3614,7 @@ class WorkflowManager(models.Manager):
         return self.filter(active=True)
 
 
-class Workflow(ClusterableModel):
+class AbstractWorkflow(ClusterableModel):
     name = models.CharField(max_length=255, verbose_name=_("name"))
     active = models.BooleanField(
         verbose_name=_("active"),
@@ -3609,9 +3703,14 @@ class Workflow(ClusterableModel):
     class Meta:
         verbose_name = _("workflow")
         verbose_name_plural = _("workflows")
+        abstract = True
 
 
-class GroupApprovalTask(Task):
+class Workflow(AbstractWorkflow):
+    pass
+
+
+class AbstractGroupApprovalTask(Task):
     groups = models.ManyToManyField(
         Group,
         verbose_name=_("groups"),
@@ -3643,24 +3742,37 @@ class GroupApprovalTask(Task):
 
         return super().start(workflow_state, user=user)
 
+    def _user_in_groups(self, user):
+        # Cache the check whether "this user is in any of this
+        # GroupApprovalTask's groups" on the user object, in case we do it
+        # against the same user and task multiple times in a request.
+        # Use a dict to map the task id to the check result, in case we also
+        # check against different GroupApprovalTasks for the same user.
+        cache_attr = "_group_approval_task_checks"
+        if not (checks_cache := getattr(user, cache_attr, {})):
+            setattr(user, cache_attr, checks_cache)
+
+        if self.pk not in checks_cache:
+            checks_cache[self.pk] = self.groups.filter(
+                id__in=user.groups.all()
+            ).exists()
+
+        return checks_cache[self.pk]
+
     def user_can_access_editor(self, obj, user):
-        return (
-            self.groups.filter(id__in=user.groups.all()).exists() or user.is_superuser
-        )
+        return user.is_superuser or self._user_in_groups(user)
 
     def locked_for_user(self, obj, user):
-        return not (
-            self.groups.filter(id__in=user.groups.all()).exists() or user.is_superuser
-        )
+        return not (user.is_superuser or self._user_in_groups(user))
 
     def user_can_lock(self, obj, user):
-        return self.groups.filter(id__in=user.groups.all()).exists()
+        return self._user_in_groups(user)
 
     def user_can_unlock(self, obj, user):
         return False
 
     def get_actions(self, obj, user):
-        if self.groups.filter(id__in=user.groups.all()).exists() or user.is_superuser:
+        if user.is_superuser or self._user_in_groups(user):
             return [
                 ("reject", _("Request changes"), True),
                 ("approve", _("Approve"), False),
@@ -3670,10 +3782,8 @@ class GroupApprovalTask(Task):
         return []
 
     def get_task_states_user_can_moderate(self, user, **kwargs):
-        if self.groups.filter(id__in=user.groups.all()).exists() or user.is_superuser:
-            return TaskState.objects.filter(
-                status=TaskState.STATUS_IN_PROGRESS, task=self.task_ptr
-            )
+        if user.is_superuser or self._user_in_groups(user):
+            return self.task_states.filter(status=TaskState.STATUS_IN_PROGRESS)
         else:
             return TaskState.objects.none()
 
@@ -3682,10 +3792,15 @@ class GroupApprovalTask(Task):
         return _("Members of the chosen Wagtail Groups can approve this task")
 
     class Meta:
+        abstract = True
         verbose_name = _("Group approval task")
         verbose_name_plural = _("Group approval tasks")
 
 
+class GroupApprovalTask(AbstractGroupApprovalTask):
+    pass
+
+
 class WorkflowStateQuerySet(models.QuerySet):
     def active(self):
         """
@@ -4118,10 +4233,10 @@ class WorkflowState(models.Model):
 
 class BaseTaskStateManager(models.Manager):
     def reviewable_by(self, user):
-        tasks = Task.objects.filter(active=True)
+        tasks = Task.objects.filter(active=True).specific()
         states = TaskState.objects.none()
         for task in tasks:
-            states = states | task.specific.get_task_states_user_can_moderate(user=user)
+            states = states | task.get_task_states_user_can_moderate(user=user)
         return states
 
 

wagtail/models/i18n.py

@@ -378,7 +378,7 @@ def bootstrap_translatable_model(model, locale):
     This function populates the "translation_key", and "locale" fields on model instances that were created
     before wagtail-localize was added to the site.
 
-    This can be called from a data migration, or instead you could use the "boostrap_translatable_models"
+    This can be called from a data migration, or instead you could use the "bootstrap_translatable_models"
     management command.
     """
     for instance in (

wagtail/models/{collections.py → media.py}

@@ -1,4 +1,6 @@
+from django.conf import settings
 from django.contrib.auth.models import Group, Permission
+from django.contrib.contenttypes.models import ContentType
 from django.db import models
 from django.utils.html import format_html
 from django.utils.safestring import mark_safe
@@ -12,13 +14,16 @@ from .view_restrictions import BaseViewRestriction
 
 
 class CollectionQuerySet(TreeQuerySet):
+    def get_min_depth(self):
+        return self.aggregate(models.Min("depth"))["depth__min"] or 2
+
     def get_indented_choices(self):
         """
         Return a list of (id, label) tuples for use as a list of choices in a collection chooser
         dropdown, where the label is formatted with get_indented_name to provide a tree layout.
         The indent level is chosen to place the minimum-depth collection at indent 0.
         """
-        min_depth = self.aggregate(models.Min("depth"))["depth__min"] or 2
+        min_depth = self.get_min_depth()
         return [
             (collection.pk, collection.get_indented_name(min_depth, html=True))
             for collection in self
@@ -90,7 +95,7 @@ class Collection(MP_Node):
         Renders this Collection's name as a formatted string that displays its hierarchical depth via indentation.
         If indentation_start_depth is supplied, the Collection's depth is rendered relative to that depth.
         indentation_start_depth defaults to 2, the depth of the first non-Root Collection.
-        Pass html=True to get a HTML representation, instead of the default plain-text.
+        Pass html=True to get an HTML representation, instead of the default plain-text.
 
         Example text output: "    ↳ Pies"
         Example HTML output: "    &#x21b3 Pies"
@@ -188,3 +193,29 @@ class GroupCollectionPermission(models.Model):
         unique_together = ("group", "collection", "permission")
         verbose_name = _("group collection permission")
         verbose_name_plural = _("group collection permissions")
+
+
+class UploadedFile(models.Model):
+    """
+    Temporary storage for media fields uploaded through the multiple image/document uploader.
+    When validation rules (e.g. required metadata fields) prevent creating an Image/Document object from the file alone.
+    In this case, the file is stored against this model, to be turned into an Image/Document object once the full form
+    has been filled in.
+    """
+
+    for_content_type = models.ForeignKey(
+        ContentType,
+        verbose_name=_("for content type"),
+        related_name="uploads",
+        on_delete=models.CASCADE,
+        null=True,
+    )
+    file = models.FileField(upload_to="wagtail_uploads", max_length=200)
+    uploaded_by_user = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        verbose_name=_("uploaded by user"),
+        null=True,
+        blank=True,
+        editable=False,
+        on_delete=models.SET_NULL,
+    )

wagtail/models/reference_index.py

@@ -160,7 +160,7 @@ class ReferenceIndex(models.Model):
     # linked by a ParentalKey.
     tracked_models = set()
 
-    # Ths set of models that can appear as the 'from' object in the reference index.
+    # The set of models that can appear as the 'from' object in the reference index.
     # This only includes those registered with `register_model`, and NOT child models linked
     # by ParentalKey (object references on those are recorded under the parent).
     indexed_models = set()

wagtail/models/view_restrictions.py

@@ -19,13 +19,20 @@ class BaseViewRestriction(models.Model):
 
     RESTRICTION_CHOICES = (
         (NONE, _("Public")),
-        (LOGIN, _("Private, accessible to logged-in users")),
-        (PASSWORD, _("Private, accessible with the following password")),
+        (PASSWORD, _("Private, accessible with a shared password")),
+        (LOGIN, _("Private, accessible to any logged-in users")),
         (GROUPS, _("Private, accessible to users in specific groups")),
     )
 
     restriction_type = models.CharField(max_length=20, choices=RESTRICTION_CHOICES)
-    password = models.CharField(verbose_name=_("password"), max_length=255, blank=True)
+    password = models.CharField(
+        verbose_name=_("shared password"),
+        max_length=255,
+        blank=True,
+        help_text=_(
+            "Shared passwords should not be used to protect sensitive content. Anyone who has this password will be able to view the content."
+        ),
+    )
     groups = models.ManyToManyField(Group, verbose_name=_("groups"), blank=True)
 
     def accept_request(self, request):

wagtail/project_template/project_name/settings/base.py

@@ -172,3 +172,9 @@ WAGTAILSEARCH_BACKENDS = {
 # Base URL to use when referring to full URLs within the Wagtail admin backend -
 # e.g. in notification emails. Don't include '/admin' or a trailing slash
 WAGTAILADMIN_BASE_URL = "http://example.com"
+
+# Allowed file extensions for documents in the document library.
+# This can be omitted to allow all files, but note that this may present a security risk
+# if untrusted users are allowed to upload files -
+# see https://docs.wagtail.org/en/stable/advanced_topics/deploying.html#user-uploaded-files
+WAGTAILDOCS_EXTENSIONS = ['csv', 'docx', 'key', 'odt', 'pdf', 'pptx', 'rtf', 'txt', 'xlsx', 'zip']

wagtail/project_template/requirements.txt

@@ -1,2 +1,2 @@
 Django>=4.2,<5.1
-wagtail>=6.0,<6.1
+wagtail==6.1rc1

wagtail/rich_text/__init__.py

@@ -1,6 +1,7 @@
 import re
 from functools import lru_cache
 from html import unescape
+from typing import List
 
 from django.core.validators import MaxLengthValidator
 from django.db.models import Model
@@ -26,23 +27,23 @@ def get_rewriter():
     return MultiRuleRewriter(
         [
             LinkRewriter(
-                {
-                    linktype: handler.expand_db_attributes
+                bulk_rules={
+                    linktype: handler.expand_db_attributes_many
                     for linktype, handler in link_rules.items()
                 },
-                {
+                reference_extractors={
                     linktype: handler.extract_references
                     for linktype, handler in link_rules.items()
                 },
             ),
             EmbedRewriter(
-                {
-                    embedtype: handler.expand_db_attributes
+                bulk_rules={
+                    embedtype: handler.expand_db_attributes_many
                     for embedtype, handler in embed_rules.items()
                 },
-                {
-                    linktype: handler.extract_references
-                    for linktype, handler in embed_rules.items()
+                reference_extractors={
+                    embedtype: handler.extract_references
+                    for embedtype, handler in embed_rules.items()
                 },
             ),
         ]
@@ -130,6 +131,14 @@ class EntityHandler:
         model = cls.get_model()
         return model._default_manager.get(id=attrs["id"])
 
+    @classmethod
+    def get_many(cls, attrs_list: List[dict]) -> List[Model]:
+        model = cls.get_model()
+        instance_ids = [attrs.get("id") for attrs in attrs_list]
+        instances_by_id = model._default_manager.in_bulk(instance_ids)
+        instances_by_str_id = {str(k): v for k, v in instances_by_id.items()}
+        return [instances_by_str_id.get(str(id_)) for id_ in instance_ids]
+
     @staticmethod
     def expand_db_attributes(attrs: dict) -> str:
         """
@@ -138,6 +147,14 @@ class EntityHandler:
         """
         raise NotImplementedError
 
+    @classmethod
+    def expand_db_attributes_many(cls, attrs_list: List[dict]) -> List[str]:
+        """
+        Given a list of attribute dicts from a list of entity tags stored in
+        the database, return the real HTML representation of each one.
+        """
+        return list(map(cls.expand_db_attributes, attrs_list))
+
     @classmethod
     def extract_references(cls, attrs):
         """