wagtail 7.1.2__py3-none-any.whl → 7.2rc1__py3-none-any.whl

wagtail/search/management/commands/update_index.py

@@ -1,205 +1 @@
-import collections
-
-from django.conf import settings
-from django.core.management.base import BaseCommand
-from django.db import transaction
-
-from wagtail.search.backends import get_search_backend
-from wagtail.search.index import get_indexed_models
-
-DEFAULT_CHUNK_SIZE = 1000
-
-
-def group_models_by_index(backend, models):
-    """
-    This takes a search backend and a list of models. By calling the
-    get_index_for_model method on the search backend, it groups the models into
-    the indices that they will be indexed into.
-
-    It returns an ordered mapping of indices to lists of models within each
-    index.
-
-    For example, Elasticsearch 2 requires all page models to be together, but
-    separate from other content types (eg, images and documents) to prevent
-    field mapping collisions:
-
-    >>> group_models_by_index(elasticsearch2_backend, [
-    ...     wagtailcore.Page,
-    ...     myapp.HomePage,
-    ...     myapp.StandardPage,
-    ...     wagtailimages.Image
-    ... ])
-    {
-        <Index wagtailcore_page>: [wagtailcore.Page, myapp.HomePage, myapp.StandardPage],
-        <Index wagtailimages_image>: [wagtailimages.Image],
-    }
-    """
-    indices = {}
-    models_by_index = collections.OrderedDict()
-
-    for model in models:
-        index = backend.get_index_for_model(model)
-
-        if index:
-            indices.setdefault(index.name, index)
-            models_by_index.setdefault(index.name, [])
-            models_by_index[index.name].append(model)
-
-    return collections.OrderedDict(
-        [
-            (indices[index_name], index_models)
-            for index_name, index_models in models_by_index.items()
-        ]
-    )
-
-
-class Command(BaseCommand):
-    def write(self, *args, **kwargs):
-        """Helper function that respects verbosity when printing."""
-        if self.verbosity > 0:
-            self.stdout.write(*args, **kwargs)
-
-    def update_backend(
-        self, backend_name, schema_only=False, chunk_size=DEFAULT_CHUNK_SIZE
-    ):
-        self.write("Updating backend: " + backend_name)
-
-        backend = get_search_backend(backend_name)
-
-        if not backend.rebuilder_class:
-            self.write("Backend '%s' doesn't require rebuilding" % backend_name)
-            return
-
-        models_grouped_by_index = group_models_by_index(
-            backend, get_indexed_models()
-        ).items()
-        if not models_grouped_by_index:
-            self.write(backend_name + ": No indices to rebuild")
-
-        for index, models in models_grouped_by_index:
-            self.write(backend_name + ": Rebuilding index %s" % index.name)
-
-            # Start rebuild
-            rebuilder = backend.rebuilder_class(index)
-            index = rebuilder.start()
-
-            # Add models
-            for model in models:
-                index.add_model(model)
-
-            # Add objects
-            object_count = 0
-            if not schema_only:
-                for model in models:
-                    self.write(
-                        "{}: {}.{} ".format(
-                            backend_name, model._meta.app_label, model.__name__
-                        ).ljust(35),
-                        ending="",
-                    )
-
-                    # Add items (chunk_size at a time)
-                    for chunk in self.print_iter_progress(
-                        self.queryset_chunks(
-                            model.get_indexed_objects().order_by("pk"), chunk_size
-                        )
-                    ):
-                        index.add_items(model, chunk)
-                        object_count += len(chunk)
-
-                    self.print_newline()
-
-            # Finish rebuild
-            rebuilder.finish()
-
-            self.write(backend_name + ": indexed %d objects" % object_count)
-            self.print_newline()
-
-    def add_arguments(self, parser):
-        parser.add_argument(
-            "--backend",
-            action="store",
-            dest="backend_name",
-            default=None,
-            help="Specify a backend to update",
-        )
-        parser.add_argument(
-            "--schema-only",
-            action="store_true",
-            dest="schema_only",
-            default=False,
-            help="Prevents loading any data into the index",
-        )
-        parser.add_argument(
-            "--chunk_size",
-            action="store",
-            dest="chunk_size",
-            default=DEFAULT_CHUNK_SIZE,
-            type=int,
-            help="Set number of records to be fetched at once for inserting into the index",
-        )
-
-    def handle(self, **options):
-        self.verbosity = options["verbosity"]
-
-        # Get list of backends to index
-        if options["backend_name"]:
-            # index only the passed backend
-            backend_names = [options["backend_name"]]
-        elif hasattr(settings, "WAGTAILSEARCH_BACKENDS"):
-            # index all backends listed in settings
-            backend_names = settings.WAGTAILSEARCH_BACKENDS.keys()
-        else:
-            # index the 'default' backend only
-            backend_names = ["default"]
-
-        # Update backends
-        for backend_name in backend_names:
-            self.update_backend(
-                backend_name,
-                schema_only=options.get("schema_only", False),
-                chunk_size=options.get("chunk_size"),
-            )
-
-    def print_newline(self):
-        self.write("")
-
-    def print_iter_progress(self, iterable):
-        """
-        Print a progress meter while iterating over an iterable. Use it as part
-        of a ``for`` loop::
-
-            for item in self.print_iter_progress(big_long_list):
-                self.do_expensive_computation(item)
-
-        A ``.`` character is printed for every value in the iterable,
-        a space every 10 items, and a new line every 50 items.
-        """
-        for i, value in enumerate(iterable, start=1):
-            yield value
-            self.write(".", ending="")
-            if i % 40 == 0:
-                self.print_newline()
-                self.write(" " * 35, ending="")
-
-            elif i % 10 == 0:
-                self.write(" ", ending="")
-
-            self.stdout.flush()
-
-    # Atomic so the count of models doesn't change as it is iterated
-    @transaction.atomic
-    def queryset_chunks(self, qs, chunk_size=DEFAULT_CHUNK_SIZE):
-        """
-        Yield a queryset in chunks of at most ``chunk_size``. The chunk yielded
-        will be a list, not a queryset. Iterating over the chunks is done in a
-        transaction so that the order and count of items in the queryset
-        remains stable.
-        """
-        i = 0
-        while True:
-            items = list(qs[i * chunk_size :][:chunk_size])
-            if not items:
-                break
-            yield items
-            i += 1
+from wagtailmodelsearch.management.commands.rebuild_modelsearch_index import *  # noqa: F403

wagtail/search/management/commands/wagtail_update_index.py

@@ -1,4 +1 @@
-# Alias for the update_index command, to avoid clashes with other packages
-# that implement an update_index command (such as django-haystack)
-
-from wagtail.search.management.commands.update_index import Command  # NOQA: F401
+from wagtailmodelsearch.management.commands.rebuild_modelsearch_index import *  # noqa: F403

wagtail/search/models.py

@@ -1,175 +1,49 @@
-from django.apps import apps
-from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
-from django.contrib.contenttypes.models import ContentType
-from django.db import connection, models
-from django.db.models.fields import TextField
-from django.db.models.fields.related import OneToOneField
-from django.db.models.functions import Cast
-from django.db.models.sql.where import WhereNode
-from django.utils.translation import gettext_lazy as _
+from django.db import models
+from django.db.models import OneToOneField
+from wagtailmodelsearch.abstract_models import (
+    AbstractIndexEntry,
+    AbstractSQLiteFTSIndexEntry,
+)
 
-from .index import class_is_indexed
-from .utils import get_descendants_content_types_pks
+# We import abstract models from the modelsearch app and define concrete implementations here in the
+# wagtail.search app. This preserves backwards compatibility for existing Wagtail projects that have
+# these models in the wagtailsearch namespace, and avoids the need to add modelsearch to INSTALLED_APPS.
 
 
-class TextIDGenericRelation(GenericRelation):
-    auto_created = True
-
-    def get_content_type_lookup(self, alias, remote_alias):
-        field = self.remote_field.model._meta.get_field(self.content_type_field_name)
-        return field.get_lookup("in")(
-            field.get_col(remote_alias), get_descendants_content_types_pks(self.model)
-        )
-
-    def get_object_id_lookup(self, alias, remote_alias):
-        from_field = self.remote_field.model._meta.get_field(self.object_id_field_name)
-        to_field = self.model._meta.pk
-        return from_field.get_lookup("exact")(
-            from_field.get_col(remote_alias), Cast(to_field.get_col(alias), from_field)
-        )
-
-    def get_extra_restriction(self, alias, remote_alias):
-        cond = WhereNode()
-        cond.add(self.get_content_type_lookup(alias, remote_alias), "AND")
-        cond.add(self.get_object_id_lookup(alias, remote_alias), "AND")
-        return cond
-
-    def resolve_related_fields(self):
-        return []
-
-
-class BaseIndexEntry(models.Model):
+class IndexEntry(AbstractIndexEntry):
     """
-    This is an abstract class that only contains fields common to all database vendors.
-    It should be extended by the models specific for each backend.
+    The IndexEntry model that will get created in the database.
     """
 
-    content_type = models.ForeignKey(
-        ContentType, on_delete=models.CASCADE, related_name="+"
-    )
-    # We do not use an IntegerField since primary keys are not always integers.
-    object_id = models.CharField(max_length=50)
-    content_object = GenericForeignKey()
-
-    # TODO: Add per-object boosting.
-    # This field stores the "Title Normalisation Factor"
-    # This factor is multiplied onto the rank of the title field.
-    # This allows us to apply a boost to results with shorter titles
-    # elevating more specific matches to the top.
-    title_norm = models.FloatField(default=1.0)
-
-    wagtail_reference_index_ignore = True
-
-    class Meta:
-        unique_together = ("content_type", "object_id")
-        verbose_name = _("index entry")
-        verbose_name_plural = _("index entries")
-        abstract = True
-
-    def __str__(self):
-        return f"{self.content_type.name}: {self.content_object}"
-
-    @property
-    def model(self):
-        return self.content_type.model
-
-    @classmethod
-    def add_generic_relations(cls):
-        for model in apps.get_models():
-            if class_is_indexed(model):
-                TextIDGenericRelation(cls).contribute_to_class(model, "index_entries")
-
-
-# AbstractIndexEntry will be defined depending on which database system we're using.
-if connection.vendor == "postgresql":
-    from django.contrib.postgres.indexes import GinIndex
-    from django.contrib.postgres.search import SearchVectorField
-
-    class AbstractPostgresIndexEntry(BaseIndexEntry):
-        """
-        This class is the specific IndexEntry model for PostgreSQL database systems.
-        It inherits the fields defined in BaseIndexEntry, and adds PostgreSQL-specific
-        fields (tsvectors), plus indexes for doing full-text search on those fields.
-        """
-
-        # TODO: Add per-object boosting.
-        autocomplete = SearchVectorField()
-        title = SearchVectorField()
-        body = SearchVectorField()
-
-        class Meta(BaseIndexEntry.Meta):
-            abstract = True
-            # An additional computed GIN index on 'title || body' is created in a SQL migration
-            # covers the default case of PostgresSearchQueryCompiler.get_index_vectors.
-            indexes = [
-                GinIndex(fields=["autocomplete"]),
-                GinIndex(fields=["title"]),
-                GinIndex(fields=["body"]),
-            ]
-
-    AbstractIndexEntry = AbstractPostgresIndexEntry
-
-elif connection.vendor == "sqlite":
-    from wagtail.search.backends.database.sqlite.utils import fts5_available
-
-    class AbstractSQLiteIndexEntry(BaseIndexEntry):
+    class Meta(AbstractIndexEntry.Meta):
         """
-        This class is the specific IndexEntry model for SQLite database systems. The autocomplete, title, and body fields store additional
+        Contains everything in the AbstractIndexEntry Meta class, but makes this model concrete.
         """
 
-        autocomplete = TextField(null=True)
-        title = TextField(null=False)
-        body = TextField(null=True)
-
-        class Meta(BaseIndexEntry.Meta):
-            abstract = True
-
-    AbstractIndexEntry = AbstractSQLiteIndexEntry
-
-    if fts5_available():
-
-        class SQLiteFTSIndexEntry(models.Model):
-            autocomplete = TextField(null=True)
-            title = TextField(null=False)
-            body = TextField(null=True)
-            index_entry = OneToOneField(
-                primary_key=True,
-                to="wagtailsearch.indexentry",
-                on_delete=models.CASCADE,
-                db_column="rowid",
-            )
+        abstract = False
 
-            class Meta:
-                db_table = "wagtailsearch_indexentry_fts"
 
-elif connection.vendor == "mysql":
+if AbstractSQLiteFTSIndexEntry:
+    # The SQLite backend additionally requires a second model with a OneToOneField to IndexEntry. If a
+    # SQLite connection is in use, modelsearch will define a AbstractSQLiteFTSIndexEntry model
+    # (otherwise this will be None).
 
-    class AbstractMySQLIndexEntry(BaseIndexEntry):
+    class SQLiteFTSIndexEntry(AbstractSQLiteFTSIndexEntry):
         """
-        This class is the specific IndexEntry model for MySQL database systems.
+        The SQLite FTS IndexEntry model that will get created in the database if using SQLite with FTS5 support.
         """
 
-        autocomplete = TextField(null=True)
-        title = TextField(null=False)
-        body = TextField(null=True)
-
-        class Meta(BaseIndexEntry.Meta):
-            abstract = True
-
-    AbstractIndexEntry = AbstractMySQLIndexEntry
-
-else:
-    AbstractIndexEntry = BaseIndexEntry
-
-
-class IndexEntry(AbstractIndexEntry):
-    """
-    The IndexEntry model that will get created in the database.
-    """
+        index_entry = OneToOneField(
+            primary_key=True,
+            to=IndexEntry,
+            on_delete=models.CASCADE,
+            db_column="rowid",
+        )
 
-    class Meta(AbstractIndexEntry.Meta):
-        """
-        Contains everything in the AbstractIndexEntry Meta class, but makes this model concrete.
-        """
+        class Meta(AbstractSQLiteFTSIndexEntry.Meta):
+            """
+            Contains everything in the AbstractSQLiteFTSIndexEntry Meta class, but makes this model concrete.
+            """
 
-        abstract = False
+            abstract = False
+            db_table = "wagtailsearch_indexentry_fts"

wagtail/search/query.py

@@ -1,114 +1 @@
-#
-# Base classes
-#
-
-
-class SearchQuery:
-    def __and__(self, other):
-        return And([self, other])
-
-    def __or__(self, other):
-        return Or([self, other])
-
-    def __invert__(self):
-        return Not(self)
-
-    def __repr__(self):
-        raise NotImplementedError
-
-
-#
-# Basic query classes
-#
-
-
-class PlainText(SearchQuery):
-    OPERATORS = ["and", "or"]
-    DEFAULT_OPERATOR = "and"
-
-    def __init__(
-        self, query_string: str, operator: str = DEFAULT_OPERATOR, boost: float = 1
-    ):
-        self.query_string = query_string
-        self.operator = operator.lower()
-        if self.operator not in self.OPERATORS:
-            raise ValueError("`operator` must be either 'or' or 'and'.")
-        self.boost = boost
-
-    def __repr__(self):
-        return "<PlainText {} operator={} boost={}>".format(
-            repr(self.query_string), repr(self.operator), repr(self.boost)
-        )
-
-
-class Phrase(SearchQuery):
-    def __init__(self, query_string: str):
-        self.query_string = query_string
-
-    def __repr__(self):
-        return f"<Phrase {repr(self.query_string)}>"
-
-
-class Fuzzy(SearchQuery):
-    OPERATORS = ["and", "or"]
-    DEFAULT_OPERATOR = "or"
-
-    def __init__(self, query_string: str, operator: str = DEFAULT_OPERATOR):
-        self.query_string = query_string
-        self.operator = operator.lower()
-        if self.operator not in self.OPERATORS:
-            raise ValueError("`operator` must be either 'or' or 'and'.")
-
-    def __repr__(self):
-        return f"<Fuzzy {repr(self.query_string)} operator={repr(self.operator)}>"
-
-
-class MatchAll(SearchQuery):
-    def __repr__(self):
-        return "<MatchAll>"
-
-
-class Boost(SearchQuery):
-    def __init__(self, subquery: SearchQuery, boost: float):
-        self.subquery = subquery
-        self.boost = boost
-
-    def __repr__(self):
-        return f"<Boost {repr(self.subquery)} boost={repr(self.boost)}>"
-
-
-#
-# Combinators
-#
-
-
-class And(SearchQuery):
-    def __init__(self, subqueries):
-        self.subqueries = subqueries
-
-    def __repr__(self):
-        return "<And {}>".format(
-            " ".join(repr(subquery) for subquery in self.subqueries)
-        )
-
-
-class Or(SearchQuery):
-    def __init__(self, subqueries):
-        self.subqueries = subqueries
-
-    def __repr__(self):
-        return "<Or {}>".format(
-            " ".join(repr(subquery) for subquery in self.subqueries)
-        )
-
-
-class Not(SearchQuery):
-    def __init__(self, subquery: SearchQuery):
-        self.subquery = subquery
-
-    def __repr__(self):
-        return f"<Not {repr(self.subquery)}>"
-
-
-MATCH_ALL = MatchAll()
-MATCH_NONE = Not(MATCH_ALL)
+from wagtailmodelsearch.query import *  # noqa: F403

wagtail/search/queryset.py

@@ -1,43 +1 @@
-from wagtail.search.backends import get_search_backend
-
-
-class SearchableQuerySetMixin:
-    def search(
-        self,
-        query,
-        fields=None,
-        operator=None,
-        order_by_relevance=True,
-        backend="default",
-    ):
-        """
-        This runs a search query on all the items in the QuerySet
-        """
-        search_backend = get_search_backend(backend)
-        return search_backend.search(
-            query,
-            self,
-            fields=fields,
-            operator=operator,
-            order_by_relevance=order_by_relevance,
-        )
-
-    def autocomplete(
-        self,
-        query,
-        fields=None,
-        operator=None,
-        order_by_relevance=True,
-        backend="default",
-    ):
-        """
-        This runs an autocomplete query on all the items in the QuerySet
-        """
-        search_backend = get_search_backend(backend)
-        return search_backend.autocomplete(
-            query,
-            self,
-            fields=fields,
-            operator=operator,
-            order_by_relevance=order_by_relevance,
-        )
+from wagtailmodelsearch.queryset import *  # noqa: F403

wagtail/search/signal_handlers.py

@@ -1,24 +1 @@
-from django.db.models.signals import post_delete, post_save
-
-from . import index
-from .tasks import insert_or_update_object_task
-
-
-def post_save_signal_handler(instance, **kwargs):
-    insert_or_update_object_task.enqueue(
-        instance._meta.app_label, instance._meta.model_name, str(instance.pk)
-    )
-
-
-def post_delete_signal_handler(instance, **kwargs):
-    index.remove_object(instance)
-
-
-def register_signal_handlers():
-    # Loop through list and register signal handlers for each one
-    for model in index.get_indexed_models():
-        if not getattr(model, "search_auto_update", True):
-            continue
-
-        post_save.connect(post_save_signal_handler, sender=model)
-        post_delete.connect(post_delete_signal_handler, sender=model)
+from wagtailmodelsearch.signal_handlers import *  # noqa: F403

wagtail/search/tasks.py

@@ -1,10 +1 @@
-from django.apps import apps
-from django_tasks import task
-
-from wagtail.search import index
-
-
-@task()
-def insert_or_update_object_task(app_label, model_name, pk):
-    model = apps.get_model(app_label, model_name)
-    index.insert_or_update_object(model.objects.get(pk=pk))
+from wagtailmodelsearch.tasks import *  # noqa: F403

wagtail/search/tests/test_elasticsearch.py

@@ -0,0 +1,22 @@
+import unittest
+
+from django.conf import settings
+from django.test import TestCase
+
+from wagtail.search.backends import get_search_backend
+from wagtail.utils.deprecation import RemovedInWagtail80Warning
+
+
+@unittest.skipIf(
+    "elasticsearch_with_index_option" not in settings.WAGTAILSEARCH_BACKENDS,
+    "No elasticsearch backend active",
+)
+class TestIndexOptionDeprecation(TestCase):
+    def test_index_option_deprecation_warning(self):
+        with self.assertWarnsMessage(
+            RemovedInWagtail80Warning,
+            "The INDEX option on Elasticsearch / OpenSearch backends is deprecated",
+        ):
+            backend = get_search_backend("elasticsearch_with_index_option")
+
+        self.assertEqual(backend.index_prefix, "wagtailtest_")