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

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):
         """

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/locale/he_IL/LC_MESSAGES/django.po

@@ -17,8 +17,8 @@ msgstr ""
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
 "Language: he_IL\n"
-"Plural-Forms: nplurals=4; plural=(n == 1 && n % 1 == 0) ? 0 : (n == 2 && n % "
-"1 == 0) ? 1: (n % 10 == 0 && n % 1 == 0 && n > 10) ? 2 : 3;\n"
+"Plural-Forms: nplurals=3; plural=(n == 1 && n % 1 == 0) ? 0 : (n == 2 && n % "
+"1 == 0) ? 1: 2;\n"
 
 msgid "Choose a root page"
 msgstr "בחרו עמוד מקור"

wagtail/sites/locale/ro/LC_MESSAGES/django.po

@@ -4,13 +4,14 @@
 #
 # Translators:
 # Dan Braghis, 2014-2016,2019
+# Madalin Popa, 2024
 msgid ""
 msgstr ""
 "Project-Id-Version: Wagtail\n"
 "Report-Msgid-Bugs-To: \n"
 "POT-Creation-Date: 2024-01-24 13:51+0000\n"
 "PO-Revision-Date: 2014-10-03 15:24+0000\n"
-"Last-Translator: Dan Braghis, 2014-2016,2019\n"
+"Last-Translator: Madalin Popa, 2024\n"
 "Language-Team: Romanian (http://app.transifex.com/torchbox/wagtail/language/"
 "ro/)\n"
 "MIME-Version: 1.0\n"
@@ -21,7 +22,7 @@ msgstr ""
 "2:1));\n"
 
 msgid "Wagtail sites"
-msgstr "Situri Wagtail"
+msgstr "Site-uri Wagtail"
 
 msgid "Choose a root page"
 msgstr "Alege o pagină de bază"