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

wagtail/rich_text/pages.py

@@ -1,3 +1,6 @@
+from typing import List
+
+from django.db.models import Model
 from django.utils.html import escape
 
 from wagtail.models import Page
@@ -12,16 +15,24 @@ class PageLinkHandler(LinkHandler):
         return Page
 
     @classmethod
-    def get_instance(cls, attrs):
-        return super().get_instance(attrs).specific
+    def get_many(cls, attrs_list: List[dict]) -> List[Model]:
+        # Override LinkHandler.get_many to reduce database queries through the
+        # use of PageQuerySet.specific() instead of QuerySet.in_bulk().
+        instance_ids = [attrs.get("id") for attrs in attrs_list]
+        qs = Page.objects.filter(id__in=instance_ids).defer_streamfields().specific()
+        pages_by_str_id = {str(page.id): page for page in qs}
+        return [pages_by_str_id.get(str(id_)) for id_ in instance_ids]
+
+    @classmethod
+    def expand_db_attributes(cls, attrs: dict) -> str:
+        return cls.expand_db_attributes_many([attrs])[0]
 
     @classmethod
-    def expand_db_attributes(cls, attrs):
-        try:
-            page = cls.get_instance(attrs)
-            return '<a href="%s">' % escape(page.localized.specific.url)
-        except Page.DoesNotExist:
-            return "<a>"
+    def expand_db_attributes_many(cls, attrs_list: List[dict]) -> List[str]:
+        return [
+            '<a href="%s">' % escape(page.localized.url) if page else "<a>"
+            for page in cls.get_many(attrs_list)
+        ]
 
     @classmethod
     def extract_references(self, attrs):

wagtail/rich_text/rewriters.py

@@ -3,13 +3,16 @@ Utility classes for rewriting elements of HTML-like strings
 """
 
 import re
+from collections import defaultdict
+from itertools import chain
+from typing import Callable, Tuple
 
 FIND_A_TAG = re.compile(r"<a(\b[^>]*)>")
 FIND_EMBED_TAG = re.compile(r"<embed(\b[^>]*)/>")
 FIND_ATTRS = re.compile(r'([\w-]+)\="([^"]*)"')
 
 
-def extract_attrs(attr_string):
+def extract_attrs(attr_string: str) -> dict:
     """
     helper method to extract tag attributes, as a dict of un-escaped strings
     """
@@ -25,101 +28,170 @@ def extract_attrs(attr_string):
     return attributes
 
 
-class EmbedRewriter:
-    """
-    Rewrites <embed embedtype="foo" /> tags within rich text into the HTML fragment given by the
-    embed rule for 'foo'. Each embed rule is a function that takes a dict of attributes and
-    returns the HTML fragment.
-    """
-
-    def __init__(self, embed_rules, reference_extractors=None):
-        self.embed_rules = embed_rules
+class TagRewriter:
+    def __init__(self, rules=None, bulk_rules=None, reference_extractors=None):
+        self.rules = rules or {}
+        self.bulk_rules = bulk_rules or {}
         self.reference_extractors = reference_extractors or {}
 
-    def replace_tag(self, match):
-        attrs = extract_attrs(match.group(1))
-        try:
-            rule = self.embed_rules[attrs["embedtype"]]
-        except KeyError:
-            # silently drop any tags with an unrecognised or missing embedtype attribute
-            return ""
-        return rule(attrs)
+    def get_opening_tag_regex(self):
+        raise NotImplementedError
 
-    def __call__(self, html):
-        return FIND_EMBED_TAG.sub(self.replace_tag, html)
+    def get_tag_type_from_attrs(self, attrs):
+        raise NotImplementedError
+
+    def get_tag_replacements(self, tag_type, attrs_list):
+        # Note: return an empty list for cases when you don't want any replacements made
+        raise NotImplementedError
+
+    def __call__(self, html: str) -> str:
+        matches_by_tag_type, attrs_by_tag_type = self.extract_tags(html)
+
+        replacements = [
+            self.get_tag_replacements(tag_type, attrs_list)
+            for tag_type, attrs_list in attrs_by_tag_type.items()
+        ]
+
+        offset = 0
+        for match, replacement in zip(
+            chain(*matches_by_tag_type.values()), chain(*replacements)
+        ):
+            html = (
+                html[: match.start() + offset]
+                + replacement
+                + html[match.end() + offset :]
+            )
+
+            offset += len(replacement) - match.end() + match.start()
+
+        return html
+
+    def extract_tags(self, html: str) -> Tuple[dict, dict]:
+        """Helper method to extract and group HTML tags and their attributes.
+
+        Returns the full list of regex matches grouped by tag type as well as
+        the tag attribute dictionaries grouped by tag type.
+        """
+        matches_by_tag_type = defaultdict(list)
+        attrs_by_tag_type = defaultdict(list)
+
+        # Regex used to match <tag ...> tags in the HTML.
+        re_pattern = self.get_opening_tag_regex()
+
+        for match in re_pattern.finditer(html):
+            attrs = extract_attrs(match.group(1))
+            tag_type = self.get_tag_type_from_attrs(attrs)
+
+            matches_by_tag_type[tag_type].append(match)
+            attrs_by_tag_type[tag_type].append(attrs)
+
+        return matches_by_tag_type, attrs_by_tag_type
+
+    def convert_rule_to_bulk_rule(self, rule: Callable) -> Callable:
+        def bulk_rule(args):
+            return list(map(rule, args))
+
+        return bulk_rule
 
     def extract_references(self, html):
-        for match in FIND_EMBED_TAG.findall(html):
+        re_pattern = self.get_opening_tag_regex()
+        for match in re_pattern.findall(html):
             attrs = extract_attrs(match)
-            if (
-                "embedtype" not in attrs
-                or attrs["embedtype"] not in self.reference_extractors
-            ):
+            tag_type = self.get_tag_type_from_attrs(attrs)
+
+            if tag_type not in self.reference_extractors:
                 continue
 
-            yield from self.reference_extractors[attrs["embedtype"]](attrs)
+            yield from self.reference_extractors[tag_type](attrs)
+
+        return []
 
 
-class LinkRewriter:
+class EmbedRewriter(TagRewriter):
     """
-    Rewrites <a linktype="foo"> tags within rich text into the HTML fragment given by the
-    rule for 'foo'. Each link rule is a function that takes a dict of attributes and
-    returns the HTML fragment for the opening tag (only).
+    Rewrites <embed embedtype="foo" /> tags within rich text into the HTML
+    fragment given by the embed rule for 'foo'. Each embed rule is a function
+    that takes a dict of attributes and returns the HTML fragment.
     """
 
-    def __init__(self, link_rules, reference_extractors=None):
-        self.link_rules = link_rules
-        self.reference_extractors = reference_extractors or {}
+    def get_opening_tag_regex(self):
+        return FIND_EMBED_TAG
+
+    def get_tag_type_from_attrs(self, attrs):
+        return attrs.get("embedtype")
 
-    def replace_tag(self, match):
-        attrs = extract_attrs(match.group(1))
+    def get_tag_replacements(self, tag_type, attrs_list):
         try:
-            link_type = attrs["linktype"]
+            rule = self.bulk_rules[tag_type]
+        except KeyError:
+            rule = None
+
+        if not rule:
+            try:
+                rule = self.rules[tag_type]
+            except KeyError:
+                pass
+            else:
+                rule = self.convert_rule_to_bulk_rule(rule)
+
+        # Silently drop any tags with an unrecognised or missing embedtype attribute.
+        return rule(attrs_list) if rule else [""] * len(attrs_list)
+
+
+class LinkRewriter(TagRewriter):
+    """
+    Rewrites <a linktype="foo"> tags within rich text into the HTML fragment
+    given by the rule for 'foo'. Each link rule is a function that takes a dict
+    of attributes and returns the HTML fragment for the opening tag (only).
+    """
+
+    def get_opening_tag_regex(self):
+        return FIND_A_TAG
+
+    def get_tag_type_from_attrs(self, attrs):
+        try:
+            return attrs["linktype"]
         except KeyError:
-            link_type = None
             href = attrs.get("href", None)
             if href:
                 # From href attribute we try to detect only the linktypes that we
                 # currently support (`external` & `email`, `page` has a default handler)
                 # from the link chooser.
                 if href.startswith(("http:", "https:")):
-                    link_type = "external"
+                    return "external"
                 elif href.startswith("mailto:"):
-                    link_type = "email"
+                    return "email"
                 elif href.startswith("#"):
-                    link_type = "anchor"
+                    return "anchor"
 
-            if not link_type:
-                # otherwise return ordinary links without a linktype unchanged
-                return match.group(0)
+    def get_tag_replacements(self, tag_type, attrs_list):
+        if not tag_type:
+            # We want to leave links without a linktype attribute unchanged,
+            # for example <a name="important-anchor">, so we return an empty
+            # list here so that no tag replacements are made.
+            return []
 
         try:
-            rule = self.link_rules[link_type]
+            rule = self.bulk_rules[tag_type]
         except KeyError:
-            if link_type in ["email", "external", "anchor"]:
-                # If no rule is registered for supported types
-                # return ordinary links without a linktype unchanged
-                return match.group(0)
-            # unrecognised link type
-            return "<a>"
-
-        return rule(attrs)
-
-    def __call__(self, html):
-        return FIND_A_TAG.sub(self.replace_tag, html)
-
-    def extract_references(self, html):
-        for match in FIND_A_TAG.findall(html):
-            attrs = extract_attrs(match)
-            if (
-                "linktype" not in attrs
-                or attrs["linktype"] not in self.reference_extractors
-            ):
-                continue
-
-            yield from self.reference_extractors[attrs["linktype"]](attrs)
-
-        return []
+            rule = None
+
+        if not rule:
+            try:
+                rule = self.rules[tag_type]
+            except KeyError:
+                if tag_type in ["email", "external", "anchor"]:
+                    # We also want to leave links with certain known linktype
+                    # attributes alone even if there are no richtext rules
+                    # registered for those types, for example
+                    # <a href="https://wagtail.org">, so we return an empty
+                    # list here so that no tag replacements are made.
+                    return []
+            else:
+                rule = self.convert_rule_to_bulk_rule(rule)
+
+        # Replace unrecognised link types with an empty link.
+        return rule(attrs_list) if rule else ["<a>"] * len(attrs_list)
 
 
 class MultiRuleRewriter:

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

@@ -276,10 +276,10 @@ class Index:
             update_method(content_type_pk, indexers)
 
     def delete_item(self, item):
-        item.index_entries.using(self.db_alias).delete()
+        item.index_entries.all()._raw_delete(using=self.db_alias)
 
     def __str__(self):
-        return self.nam
+        return self.name
 
 
 class MySQLSearchQueryCompiler(BaseSearchQueryCompiler):
@@ -662,7 +662,7 @@ class MySQLSearchBackend(BaseSearchBackend):
             for connection in connections.all()
             if connection.vendor == "mysql"
         ]:
-            IndexEntry._default_manager.using(connection.alias).delete()
+            IndexEntry._default_manager.all()._raw_delete(using=connection.alias)
 
     def add_type(self, model):
         pass  # Not needed.

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

@@ -353,7 +353,7 @@ class Index:
             update_method(content_type_pk, indexers)
 
     def delete_item(self, item):
-        item.index_entries.using(self.db_alias).delete()
+        item.index_entries.all()._raw_delete(using=self.db_alias)
 
     def __str__(self):
         return self.name
@@ -434,7 +434,7 @@ class PostgresSearchQueryCompiler(BaseSearchQueryCompiler):
             return SearchQuery(lexemes, search_type="raw", config=config)
 
         elif isinstance(query, Phrase):
-            return SearchQuery(query.query_string, search_type="phrase")
+            return SearchQuery(query.query_string, search_type="phrase", config=config)
 
         elif isinstance(query, Boost):
             # Not supported
@@ -762,7 +762,7 @@ class PostgresSearchBackend(BaseSearchBackend):
             for connection in connections.all()
             if connection.vendor == "postgresql"
         ]:
-            IndexEntry._default_manager.using(connection.alias).delete()
+            IndexEntry._default_manager.all()._raw_delete(using=connection.alias)
 
     def add_type(self, model):
         pass  # Not needed.

wagtail/search/backends/database/sqlite/sqlite.py

@@ -270,7 +270,7 @@ class Index:
             update_method(content_type_pk, indexers)
 
     def delete_item(self, item):
-        item.index_entries.using(self.db_alias).delete()
+        item.index_entries.all()._raw_delete(using=self.db_alias)
 
     def __str__(self):
         return self.name
@@ -685,7 +685,7 @@ class SQLiteSearchBackend(BaseSearchBackend):
             for connection in connections.all()
             if connection.vendor == "sqlite"
         ]:
-            IndexEntry._default_manager.using(connection.alias).delete()
+            IndexEntry._default_manager.all()._raw_delete(using=connection.alias)
 
     def add_type(self, model):
         pass  # Not needed.

wagtail/search/backends/elasticsearch7.py

@@ -52,6 +52,8 @@ class Elasticsearch7Mapping:
 
     type_map = {
         "AutoField": "integer",
+        "SmallAutoField": "integer",
+        "BigAutoField": "long",
         "BinaryField": "binary",
         "BooleanField": "boolean",
         "CharField": "string",
@@ -69,10 +71,12 @@ class Elasticsearch7Mapping:
         "NullBooleanField": "boolean",
         "PositiveIntegerField": "integer",
         "PositiveSmallIntegerField": "integer",
+        "PositiveBigIntegerField": "long",
         "SlugField": "string",
         "SmallIntegerField": "integer",
         "TextField": "string",
         "TimeField": "date",
+        "URLField": "string",
     }
 
     keyword_type = "keyword"

wagtail/search/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"
@@ -22,10 +22,10 @@ msgstr ""
 msgid "Wagtail search"
 msgstr ""
 
-#: models.py:76
+#: models.py:65
 msgid "index entry"
 msgstr ""
 
-#: models.py:77
+#: models.py:66
 msgid "index entries"
 msgstr ""

wagtail/search/tests/test_postgres_backend.py

@@ -4,6 +4,7 @@ from django.db import connection
 from django.test import TestCase
 from django.test.utils import override_settings
 
+from wagtail.search.query import Phrase
 from wagtail.search.tests.test_backends import BackendTests
 from wagtail.test.search import models
 
@@ -172,3 +173,52 @@ class TestPostgresSearchBackend(BackendTests, TestCase):
             [r.title for r in results],
             ["JavaScript: The good parts", "JavaScript: The Definitive Guide"],
         )
+
+
+@unittest.skipUnless(
+    connection.vendor == "postgresql", "The current database is not PostgreSQL"
+)
+@override_settings(
+    WAGTAILSEARCH_BACKENDS={
+        "default": {
+            "BACKEND": "wagtail.search.backends.database.postgres.postgres",
+            "SEARCH_CONFIG": "dutch",
+        }
+    }
+)
+class TestPostgresLanguageTextSearch(TestCase):
+    backend_path = "wagtail.search.backends.database.postgres.postgres"
+
+    def setUp(self):
+        # get search backend by backend_path
+        BackendTests.setUp(self)
+
+        book = models.Book.objects.create(
+            title="Nu is beter dan nooit",
+            publication_date="1999-05-01",
+            number_of_pages=333,
+        )
+        self.backend.add(book)
+        self.book = book
+
+    def test_search_language_plain_text(self):
+        results = self.backend.search("Nu is beter dan nooit", models.Book)
+        self.assertEqual(list(results), [self.book])
+
+        results = self.backend.search("is beter", models.Book)
+        self.assertEqual(list(results), [self.book])
+
+        # search deals even with variations
+        results = self.backend.search("zijn beter", models.Book)
+        self.assertEqual(list(results), [self.book])
+
+        # search deals even when there are minor typos
+        results = self.backend.search("zij beter dan", models.Book)
+        self.assertEqual(list(results), [self.book])
+
+    def test_search_language_phrase_text(self):
+        results = self.backend.search(Phrase("Nu is beter"), models.Book)
+        self.assertEqual(list(results), [self.book])
+
+        results = self.backend.search(Phrase("Nu zijn beter"), models.Book)
+        self.assertEqual(list(results), [self.book])

wagtail/sites/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"
@@ -50,33 +50,33 @@ msgstr ""
 msgid "Default"
 msgstr ""
 
-#: views.py:33
+#: views.py:36
 msgid "Add site"
 msgstr ""
 
-#: views.py:34
+#: views.py:37
 #, python-format
 msgid "Site '%(object)s' created."
 msgstr ""
 
-#: views.py:35 views.py:40
+#: views.py:38 views.py:43
 msgid "The site could not be saved due to errors."
 msgstr ""
 
-#: views.py:39
+#: views.py:42
 #, python-format
 msgid "Site '%(object)s' updated."
 msgstr ""
 
-#: views.py:41 views.py:47
+#: views.py:44 views.py:50
 msgid "Delete site"
 msgstr ""
 
-#: views.py:46
+#: views.py:49
 #, python-format
 msgid "Site '%(object)s' deleted."
 msgstr ""
 
-#: views.py:48
+#: views.py:51
 msgid "Are you sure you want to delete this site?"
 msgstr ""

wagtail/sites/tests.py

@@ -20,7 +20,25 @@ class TestSiteIndexView(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": "Sites"}],
+            response.content,
+        )
+
+    def test_num_queries(self):
+        # Warm up the cache
+        self.get()
+        with self.assertNumQueries(9):
+            self.get()
+
+        sites = [
+            Site(hostname=f"host {i}", port=f"800{i}", root_page_id=2)
+            for i in range(10)
+        ]
+        Site.objects.bulk_create(sites)
+
+        with self.assertNumQueries(9):
+            self.get()
 
 
 class TestSiteCreateView(AdminTemplateTestUtils, WagtailTestUtils, TestCase):
@@ -56,8 +74,13 @@ class TestSiteCreateView(AdminTemplateTestUtils, WagtailTestUtils, TestCase):
     def test_simple(self):
         response = self.get()
         self.assertEqual(response.status_code, 200)
-        self.assertTemplateUsed(response, "wagtailsites/create.html")
-        self.assertBreadcrumbsNotRendered(response.content)
+        self.assertBreadcrumbsItemsRendered(
+            [
+                {"label": "Sites", "url": "/admin/sites/"},
+                {"label": "New: Site", "url": ""},
+            ],
+            response.content,
+        )
 
     def test_create(self):
         response = self.post(
@@ -201,14 +224,19 @@ class TestSiteEditView(AdminTemplateTestUtils, WagtailTestUtils, TestCase):
     def test_simple(self):
         response = self.get()
         self.assertEqual(response.status_code, 200)
-        self.assertTemplateUsed(response, "wagtailsites/edit.html")
-        self.assertBreadcrumbsNotRendered(response.content)
+        self.assertBreadcrumbsItemsRendered(
+            [
+                {"url": "/admin/sites/", "label": "Sites"},
+                {"url": "", "label": str(self.localhost)},
+            ],
+            response.content,
+        )
 
         url_finder = AdminURLFinder(self.user)
         expected_url = "/admin/sites/edit/%d/" % self.localhost.id
         self.assertEqual(url_finder.get_edit_url(self.localhost), expected_url)
 
-    def test_nonexistant_redirect(self):
+    def test_nonexistent_redirect(self):
         self.assertEqual(self.get(site_id=100000).status_code, 404)
 
     def test_edit(self):
@@ -357,7 +385,7 @@ class TestSiteDeleteView(AdminTemplateTestUtils, WagtailTestUtils, TestCase):
         self.assertTemplateUsed(response, "wagtailadmin/generic/confirm_delete.html")
         self.assertBreadcrumbsNotRendered(response.content)
 
-    def test_nonexistant_redirect(self):
+    def test_nonexistent_redirect(self):
         self.assertEqual(self.get(site_id=100000).status_code, 404)
 
     def test_posting_deletes_site(self):
@@ -396,7 +424,6 @@ class TestLimitedPermissions(WagtailTestUtils, TestCase):
     def test_get_create_view(self):
         response = self.client.get(reverse("wagtailsites:add"))
         self.assertEqual(response.status_code, 200)
-        self.assertTemplateUsed(response, "wagtailsites/create.html")
 
     def test_create(self):
         response = self.client.post(
@@ -418,7 +445,6 @@ class TestLimitedPermissions(WagtailTestUtils, TestCase):
         edit_url = reverse("wagtailsites:edit", args=(self.localhost.id,))
         response = self.client.get(edit_url)
         self.assertEqual(response.status_code, 200)
-        self.assertTemplateUsed(response, "wagtailsites/edit.html")
 
     def test_edit(self):
         edit_url = reverse("wagtailsites:edit", args=(self.localhost.id,))

wagtail/sites/views.py

@@ -28,6 +28,9 @@ class IndexView(generic.IndexView):
         ),
     ]
 
+    def get_base_queryset(self):
+        return super().get_base_queryset().select_related("root_page")
+
 
 class CreateView(generic.CreateView):
     page_title = _("Add site")
@@ -53,7 +56,6 @@ class SiteViewSet(ModelViewSet):
     model = Site
     permission_policy = site_permission_policy
     add_to_reference_index = False
-    _show_breadcrumbs = False
 
     index_view_class = IndexView
     add_view_class = CreateView