wagtail 6.3.2__py3-none-any.whl → 6.4rc1__py3-none-any.whl

wagtail/models/i18n.py

@@ -56,7 +56,7 @@ class Locale(models.Model):
     @classmethod
     def get_default(cls):
         """
-        Returns the default Locale based on the site's LANGUAGE_CODE setting
+        Returns the default Locale based on the site's ``LANGUAGE_CODE`` setting.
         """
         return cls.objects.get_for_language(settings.LANGUAGE_CODE)
 
@@ -309,7 +309,7 @@ class TranslatableMixin(models.Model):
         """
         Finds the translation in the specified locale.
 
-        If there is no translation in that locale, this returns None.
+        If there is no translation in that locale, this returns ``None``.
         """
         try:
             return self.get_translation(locale)

wagtail/models/panels.py

@@ -0,0 +1,37 @@
+# Placeholder for panel types defined in wagtail.admin.panels.
+# These are needed because we wish to define properties such as `content_panels` on core models
+# such as Page, but importing from wagtail.admin would create a circular import. We therefore use a
+# placeholder object, and swap it out for the real panel class inside
+# `wagtail.admin.panels.model_utils.expand_panel_list` at the same time as converting strings to
+# FieldPanel instances.
+
+from django.conf import settings
+from django.utils.functional import cached_property
+from django.utils.module_loading import import_string
+
+
+class PanelPlaceholder:
+    def __init__(self, path, args, kwargs):
+        self.path = path
+        self.args = args
+        self.kwargs = kwargs
+
+    @cached_property
+    def panel_class(self):
+        return import_string(self.path)
+
+    def construct(self):
+        return self.panel_class(*self.args, **self.kwargs)
+
+
+class CommentPanelPlaceholder(PanelPlaceholder):
+    def __init__(self):
+        super().__init__(
+            "wagtail.admin.panels.CommentPanel",
+            [],
+            {},
+        )
+
+    def construct(self):
+        if getattr(settings, "WAGTAILADMIN_COMMENTS_ENABLED", True):
+            return super().construct()

wagtail/models/sites.py

@@ -160,7 +160,8 @@ class Site(models.Model):
 
     @staticmethod
     def _find_for_request(request):
-        hostname = split_domain_port(request.get_host())[0]
+        # Use `_get_raw_host` to avoid ALLOWED_HOSTS checks
+        hostname = split_domain_port(request._get_raw_host())[0]
         port = request.get_port()
         site = None
         try:
@@ -206,15 +207,15 @@ class Site(models.Model):
     def get_site_root_paths():
         """
         Return a list of `SiteRootPath` instances, most specific path
-        first - used to translate url_paths into actual URLs with hostnames
+        first - used to translate url_paths into actual URLs with hostnames.
 
         Each root path is an instance of the `SiteRootPath` named tuple,
         and have the following attributes:
 
-        - `site_id` - The ID of the Site record
-        - `root_path` - The internal URL path of the site's home page (for example '/home/')
-        - `root_url` - The scheme/domain name of the site (for example 'https://www.example.com/')
-        - `language_code` - The language code of the site (for example 'en')
+        - ``site_id`` - The ID of the Site record
+        - ``root_path`` - The internal URL path of the site's home page (for example '/home/')
+        - ``root_url`` - The scheme/domain name of the site (for example 'https://www.example.com/')
+        - ``language_code`` - The language code of the site (for example 'en')
         """
         result = cache.get(
             SITE_ROOT_PATHS_CACHE_KEY, version=SITE_ROOT_PATHS_CACHE_VERSION

wagtail/permission_policies/pages.py

@@ -166,7 +166,7 @@ class PagePermissionPolicy(OwnershipPermissionPolicy):
             return Page.objects.filter(depth=1)
         else:
             codenames = self._get_permission_codenames(
-                {"add", "change", "publish", "lock"}
+                {"add", "change", "publish", "lock", "unlock", "bulk_delete"}
             )
             return [
                 perm.page
@@ -195,7 +195,7 @@ class PagePermissionPolicy(OwnershipPermissionPolicy):
             return base_queryset
 
         explorable_pages = self.instances_user_has_any_permission_for(
-            user, {"add", "change", "publish", "lock"}
+            user, {"add", "change", "publish", "lock", "unlock", "bulk_delete"}
         )
 
         # For all pages with specific permissions, add their ancestors as

wagtail/project_template/project_name/settings/base.py

@@ -156,6 +156,10 @@ STORAGES = {
     },
 }
 
+# Django sets a maximum of 1000 fields per form by default, but particularly complex page models
+# can exceed this limit within Wagtail's page editor.
+DATA_UPLOAD_MAX_NUMBER_FIELDS = 10_000
+
 
 # Wagtail settings
 

wagtail/project_template/requirements.txt

@@ -1,2 +1,2 @@
 Django>=5.1,<5.2
-wagtail>=6.3,<6.4
+wagtail==6.4rc1

wagtail/query.py

@@ -147,11 +147,17 @@ class SpecificQuerySetMixin:
         super().__init__(*args, **kwargs)
         # set by PageQuerySet.defer_streamfields()
         self._defer_streamfields = False
+        self._specific_select_related_fields = ()
+        self._specific_prefetch_related_lookups = ()
 
     def _clone(self):
         """Ensure clones inherit custom attribute values."""
         clone = super()._clone()
         clone._defer_streamfields = self._defer_streamfields
+        clone._specific_select_related_fields = self._specific_select_related_fields
+        clone._specific_prefetch_related_lookups = (
+            self._specific_prefetch_related_lookups
+        )
         return clone
 
     def specific(self, defer=False):
@@ -179,6 +185,137 @@ class SpecificQuerySetMixin:
             (SpecificIterable, DeferredSpecificIterable),
         )
 
+    def select_related(self, *fields, for_specific_subqueries: bool = False):
+        """
+        Overrides Django's native :meth:`~django.db.models.query.QuerySet.select_related`
+        to allow related objects to be fetched by the subqueries made when a specific
+        queryset is evaluated.
+
+        When ``for_specific_subqueries`` is ``False`` (the default), the method functions
+        exactly like the original method. However, when ``True``, ``fields`` are
+        **required**, and must match names of ForeignKey fields on all specific models
+        that might be included in the result (which can include fields inherited from
+        concrete parents). Unlike when ``for_specific_subqueries`` is ``False``, no
+        validation is applied to ``fields`` when the method is called. Rather, that when
+        the method is called. Instead, that validation is applied for each individual
+        subquery when the queryset is evaluated. This difference in behaviour should be
+        taken into account when experimenting with ``for_specific_subqueries=True`` .
+
+        As with Django's native implementation, you chain multiple applications of
+        ``select_related()`` with ``for_specific_subqueries=True`` to progressively add
+        to the list of fields to be fetched. For example:
+
+        .. code-block:: python
+
+            # Fetch 'author' when retrieving specific page data
+            queryset = Page.objects.specific().select_related("author", for_specific_subqueries=True)
+
+            # We're rendering cards with images, so fetch the listing image too
+            queryset = queryset.select_related("listing_image", for_specific_subqueries=True)
+
+            # Fetch some key taxonomy data too
+            queryset = queryset.select_related("topic", "target_audience", for_specific_subqueries=True)
+
+        As with Django's native implementation, ``None`` can be supplied in place of
+        ``fields`` to negate a previous application of ``select_related()``. By default,
+        this will only work for cases where ``select_related()`` was called without
+        ``for_specific_subqueries``, or with ``for_specific_subqueries=False``. However,
+        you can use ``for_specific_subqueries=True`` to negate subquery-specific
+        applications too. For example:
+
+        .. code-block:: python
+
+            # Fetch 'author' and 'listing_image' when retrieving specific page data
+            queryset = Page.objects.specific().select_related(
+                "author",
+                "listing_image",
+                for_specific_subqueries=True
+            )
+
+            # I've changed my mind. Do not fetch any additional data
+            queryset = queryset.select_related(None, for_specific_subqueries=True)
+        """
+
+        if not for_specific_subqueries:
+            return super().select_related(*fields)
+        if not fields:
+            raise ValueError(
+                "'fields' must be specified when calling select_related() with for_specific_subqueries=True"
+            )
+        clone = self._chain()
+        if fields == (None,):
+            clone._specific_select_related_fields = ()
+        else:
+            clone._specific_select_related_fields = (
+                self._specific_select_related_fields + fields
+            )
+        return clone
+
+    def prefetch_related(self, *lookups, for_specific_subqueries: bool = False):
+        """
+        Overrides Django's native :meth:`~django.db.models.query.QuerySet.prefetch_related`
+        implementation to allow related objects to be fetched alongside the subqueries made
+        when a specific queryset is evaluated.
+
+        When ``for_specific_subqueries`` is ``False`` (the default), the method functions
+        exactly like the original method. However, when ``True``, ``lookups`` are
+        **required**, and must match names of related fields on all specific models that
+        might be included in the result (which can include relationships inherited from
+        concrete parents). Unlike when ``for_specific_subqueries`` is ``False``, no
+        validation is applied to ``lookups`` when the method is called. Instead, that
+        validation is applied for each individual subquery when the queryset is
+        evaluated. This difference in behaviour should be taken into account when
+        experimenting with ``for_specific_subqueries=True``.
+
+        As with Django's native implementation, you chain multiple applications of
+        ``prefetch_related()`` with ``for_specific_subqueries=True`` to progressively
+        add to the list of lookups to be made. For example:
+
+        .. code-block:: python
+
+            # Fetch 'contributors' when retrieving specific page data
+            queryset = Page.objects.specific().prefetch_related("contributors", for_specific_subqueries=True)
+
+            # We're rendering cards with images, so prefetch listing image renditions too
+            queryset = queryset.prefetch_related("listing_image__renditions", for_specific_subqueries=True)
+
+            # Fetch some key taxonomy data also
+            queryset = queryset.prefetch_related("tags", for_specific_subqueries=True)
+
+        As with Django's native implementation, ``None`` can be supplied in place of
+        ``lookups`` to negate a previous application of ``prefetch_related()``. By default,
+        this will only work for cases where ``prefetch_related()`` was called without
+        ``for_specific_subqueries``, or with ``for_specific_subqueries=False``. However,
+        you can use ``for_specific_subqueries=True`` to negate subquery-specific
+        applications too. For example:
+
+        .. code-block:: python
+
+            # Fetch 'contributors' and 'listing_image' renditions when retrieving specific page data
+            queryset = Page.objects.specific().prefetch_related(
+                "contributors",
+                "listing_image__renditions",
+                for_specific_subqueries=True
+            )
+
+            # I've changed my mind. Do not make any additional queries
+            queryset = queryset.prefetch_related(None, for_specific_subqueries=True)
+        """
+        if not for_specific_subqueries:
+            return super().prefetch_related(*lookups)
+        if not lookups:
+            raise ValueError(
+                "'lookups' must be provided when calling prefetch_related() with for_specific_subqueries=True"
+            )
+        clone = self._chain()
+        if lookups == (None,):
+            clone._specific_prefetch_related_lookups = ()
+        else:
+            clone._specific_prefetch_related_lookups = (
+                self._specific_prefetch_related_lookups + lookups
+            )
+        return clone
+
 
 class PageQuerySet(SearchableQuerySetMixin, SpecificQuerySetMixin, TreeQuerySet):
     def live_q(self):
@@ -561,6 +698,14 @@ class SpecificIterable(ModelIterable):
                 model = content_types[content_type].model_class() or qs.model
                 items = model.objects.filter(pk__in=pks)
 
+                if qs._specific_select_related_fields:
+                    items = items.select_related(*qs._specific_select_related_fields)
+
+                if qs._specific_prefetch_related_lookups:
+                    items = items.prefetch_related(
+                        *qs._specific_prefetch_related_lookups
+                    )
+
                 if qs._defer_streamfields and hasattr(items, "defer_streamfields"):
                     items = items.defer_streamfields()
 

wagtail/search/backends/database/mysql/mysql.py

@@ -1,7 +1,12 @@
 import warnings
 from collections import OrderedDict
 
-from django.db import DEFAULT_DB_ALIAS, NotSupportedError, connections, transaction
+from django.db import (
+    NotSupportedError,
+    connections,
+    router,
+    transaction,
+)
 from django.db.models import Case, When
 from django.db.models.aggregates import Avg, Count
 from django.db.models.constants import LOOKUP_SEP
@@ -151,17 +156,22 @@ class ObjectIndexer:
 
 
 class Index:
-    def __init__(self, backend, db_alias=None):
+    def __init__(self, backend):
         self.backend = backend
         self.name = self.backend.index_name
-        self.db_alias = DEFAULT_DB_ALIAS if db_alias is None else db_alias
-        self.connection = connections[self.db_alias]
-        if self.connection.vendor != "mysql":
+
+        self.read_connection = connections[router.db_for_read(IndexEntry)]
+        self.write_connection = connections[router.db_for_write(IndexEntry)]
+
+        if (
+            self.read_connection.vendor != "mysql"
+            or self.write_connection.vendor != "mysql"
+        ):
             raise NotSupportedError(
-                "You must select a MySQL database " "to use MySQL search."
+                "You must select a MySQL database to use MySQL search."
             )
 
-        self.entries = IndexEntry._default_manager.using(self.db_alias)
+        self.entries = IndexEntry._default_manager.all()
 
     def add_model(self, model):
         pass
@@ -201,11 +211,9 @@ class Index:
         ).update(title_norm=lavg / F("title_length"))
 
     def delete_stale_model_entries(self, model):
-        existing_pks = (
-            model._default_manager.using(self.db_alias)
-            .annotate(object_id=Cast("pk", TextField()))
-            .values("object_id")
-        )
+        existing_pks = model._default_manager.annotate(
+            object_id=Cast("pk", TextField())
+        ).values("object_id")
         content_types_pks = get_descendants_content_types_pks(model)
         stale_entries = self.entries.filter(
             content_type_id__in=content_types_pks
@@ -276,7 +284,7 @@ class Index:
             update_method(content_type_pk, indexers)
 
     def delete_item(self, item):
-        item.index_entries.all()._raw_delete(using=self.db_alias)
+        item.index_entries.all()._raw_delete(using=self.write_connection.alias)
 
     def __str__(self):
         return self.name
@@ -610,7 +618,7 @@ class MySQLSearchRebuilder:
 class MySQLSearchAtomicRebuilder(MySQLSearchRebuilder):
     def __init__(self, index):
         super().__init__(index)
-        self.transaction = transaction.atomic(using=index.db_alias)
+        self.transaction = transaction.atomic(using=index.write_connection.alias)
         self.transaction_opened = False
 
     def start(self):
@@ -650,11 +658,11 @@ class MySQLSearchBackend(BaseSearchBackend):
         if params.get("ATOMIC_REBUILD", False):
             self.rebuilder_class = self.atomic_rebuilder_class
 
-    def get_index_for_model(self, model, db_alias=None):
-        return Index(self, db_alias)
+    def get_index_for_model(self, model):
+        return Index(self)
 
     def get_index_for_object(self, obj):
-        return self.get_index_for_model(obj._meta.model, obj._state.db)
+        return self.get_index_for_model(obj._meta.model)
 
     def reset_index(self):
         for connection in [

wagtail/search/backends/database/postgres/postgres.py

@@ -3,7 +3,12 @@ from collections import OrderedDict
 from functools import reduce
 
 from django.contrib.postgres.search import SearchQuery, SearchRank, SearchVector
-from django.db import DEFAULT_DB_ALIAS, NotSupportedError, connections, transaction
+from django.db import (
+    NotSupportedError,
+    connections,
+    router,
+    transaction,
+)
 from django.db.models import Avg, Count, F, Manager, Q, TextField, Value
 from django.db.models.constants import LOOKUP_SEP
 from django.db.models.functions import Cast, Length
@@ -163,20 +168,22 @@ class ObjectIndexer:
 
 
 class Index:
-    def __init__(self, backend, db_alias=None):
+    def __init__(self, backend):
         self.backend = backend
         self.name = self.backend.index_name
-        self.db_alias = DEFAULT_DB_ALIAS if db_alias is None else db_alias
-        self.connection = connections[self.db_alias]
-        if self.connection.vendor != "postgresql":
+
+        self.read_connection = connections[router.db_for_read(IndexEntry)]
+        self.write_connection = connections[router.db_for_write(IndexEntry)]
+
+        if (
+            self.read_connection.vendor != "postgresql"
+            or self.write_connection.vendor != "postgresql"
+        ):
             raise NotSupportedError(
-                "You must select a PostgreSQL database " "to use PostgreSQL search."
+                "You must select a PostgreSQL database to use PostgreSQL search."
             )
 
-        # Whether to allow adding items via the faster upsert method available in Postgres >=9.5
-        self._enable_upsert = self.connection.pg_version >= 90500
-
-        self.entries = IndexEntry._default_manager.using(self.db_alias)
+        self.entries = IndexEntry._default_manager.all()
 
     def add_model(self, model):
         pass
@@ -216,11 +223,9 @@ class Index:
         ).update(title_norm=lavg / F("title_length"))
 
     def delete_stale_model_entries(self, model):
-        existing_pks = (
-            model._default_manager.using(self.db_alias)
-            .annotate(object_id=Cast("pk", TextField()))
-            .values("object_id")
-        )
+        existing_pks = model._default_manager.annotate(
+            object_id=Cast("pk", TextField())
+        ).values("object_id")
         content_types_pks = get_descendants_content_types_pks(model)
         stale_entries = self.entries.filter(
             content_type_id__in=content_types_pks
@@ -237,8 +242,21 @@ class Index:
     def add_item(self, obj):
         self.add_items(obj._meta.model, [obj])
 
-    def add_items_upsert(self, content_type_pk, indexers):
-        compiler = InsertQuery(IndexEntry).get_compiler(connection=self.connection)
+    def add_items(self, model, objs):
+        search_fields = model.get_search_fields()
+        if not search_fields:
+            return
+
+        indexers = [ObjectIndexer(obj, self.backend) for obj in objs]
+
+        # TODO: Delete unindexed objects while dealing with proxy models.
+        if not indexers:
+            return
+
+        content_type_pk = get_content_type_pk(model)
+        compiler = InsertQuery(IndexEntry).get_compiler(
+            connection=self.write_connection
+        )
         title_sql = []
         autocomplete_sql = []
         body_sql = []
@@ -251,7 +269,7 @@ class Index:
             value = compiler.prepare_value(
                 IndexEntry._meta.get_field("title"), indexer.title
             )
-            sql, params = value.as_sql(compiler, self.connection)
+            sql, params = value.as_sql(compiler, self.write_connection)
             title_sql.append(sql)
             data_params.extend(params)
 
@@ -259,7 +277,7 @@ class Index:
             value = compiler.prepare_value(
                 IndexEntry._meta.get_field("autocomplete"), indexer.autocomplete
             )
-            sql, params = value.as_sql(compiler, self.connection)
+            sql, params = value.as_sql(compiler, self.write_connection)
             autocomplete_sql.append(sql)
             data_params.extend(params)
 
@@ -267,7 +285,7 @@ class Index:
             value = compiler.prepare_value(
                 IndexEntry._meta.get_field("body"), indexer.body
             )
-            sql, params = value.as_sql(compiler, self.connection)
+            sql, params = value.as_sql(compiler, self.write_connection)
             body_sql.append(sql)
             data_params.extend(params)
 
@@ -278,7 +296,7 @@ class Index:
             ]
         )
 
-        with self.connection.cursor() as cursor:
+        with self.write_connection.cursor() as cursor:
             cursor.execute(
                 """
                 INSERT INTO %s (content_type_id, object_id, title, autocomplete, body, title_norm)
@@ -295,65 +313,8 @@ class Index:
 
         self._refresh_title_norms()
 
-    def add_items_update_then_create(self, content_type_pk, indexers):
-        ids_and_data = {}
-        for indexer in indexers:
-            ids_and_data[indexer.id] = (
-                indexer.title,
-                indexer.autocomplete,
-                indexer.body,
-            )
-
-        index_entries_for_ct = self.entries.filter(content_type_id=content_type_pk)
-        indexed_ids = frozenset(
-            index_entries_for_ct.filter(object_id__in=ids_and_data.keys()).values_list(
-                "object_id", flat=True
-            )
-        )
-        for indexed_id in indexed_ids:
-            title, autocomplete, body = ids_and_data[indexed_id]
-            index_entries_for_ct.filter(object_id=indexed_id).update(
-                title=title, autocomplete=autocomplete, body=body
-            )
-
-        to_be_created = []
-        for object_id in ids_and_data.keys():
-            if object_id not in indexed_ids:
-                title, autocomplete, body = ids_and_data[object_id]
-                to_be_created.append(
-                    IndexEntry(
-                        content_type_id=content_type_pk,
-                        object_id=object_id,
-                        title=title,
-                        autocomplete=autocomplete,
-                        body=body,
-                    )
-                )
-
-        self.entries.bulk_create(to_be_created)
-
-        self._refresh_title_norms()
-
-    def add_items(self, model, objs):
-        search_fields = model.get_search_fields()
-        if not search_fields:
-            return
-
-        indexers = [ObjectIndexer(obj, self.backend) for obj in objs]
-
-        # TODO: Delete unindexed objects while dealing with proxy models.
-        if indexers:
-            content_type_pk = get_content_type_pk(model)
-
-            update_method = (
-                self.add_items_upsert
-                if self._enable_upsert
-                else self.add_items_update_then_create
-            )
-            update_method(content_type_pk, indexers)
-
     def delete_item(self, item):
-        item.index_entries.all()._raw_delete(using=self.db_alias)
+        item.index_entries.all()._raw_delete(using=self.write_connection.alias)
 
     def __str__(self):
         return self.name
@@ -709,7 +670,7 @@ class PostgresSearchRebuilder:
 class PostgresSearchAtomicRebuilder(PostgresSearchRebuilder):
     def __init__(self, index):
         super().__init__(index)
-        self.transaction = transaction.atomic(using=index.db_alias)
+        self.transaction = transaction.atomic(using=index.write_connection.alias)
         self.transaction_opened = False
 
     def start(self):
@@ -750,11 +711,11 @@ class PostgresSearchBackend(BaseSearchBackend):
         if params.get("ATOMIC_REBUILD", False):
             self.rebuilder_class = self.atomic_rebuilder_class
 
-    def get_index_for_model(self, model, db_alias=None):
-        return Index(self, db_alias)
+    def get_index_for_model(self, model):
+        return Index(self)
 
     def get_index_for_object(self, obj):
-        return self.get_index_for_model(obj._meta.model, obj._state.db)
+        return self.get_index_for_model(obj._meta.model)
 
     def reset_index(self):
         for connection in [