drf-haystack 1.9.3__py3-none-any.whl

drf_haystack/__init__.py

@@ -0,0 +1,6 @@
+__title__ = "drf-haystack"
+__version__ = "1.9.3"
+__author__ = "Rolf Haavard Blindheim"
+__license__ = "MIT License"
+
+VERSION = __version__

drf_haystack/constants.py

@@ -0,0 +1,5 @@
+from django.conf import settings
+
+DRF_HAYSTACK_NEGATION_KEYWORD = getattr(settings, "DRF_HAYSTACK_NEGATION_KEYWORD", "not")
+GEO_SRID = getattr(settings, "GEO_SRID", 4326)
+DRF_HAYSTACK_SPATIAL_QUERY_PARAM = getattr(settings, "DRF_HAYSTACK_SPATIAL_QUERY_PARAM", "from")

drf_haystack/fields.py

@@ -0,0 +1,102 @@
+from rest_framework import fields
+
+
+class DRFHaystackFieldMixin:
+    prefix_field_names = False
+
+    def __init__(self, **kwargs):
+        self.prefix_field_names = kwargs.pop("prefix_field_names", False)
+        super().__init__(**kwargs)
+
+    def bind(self, field_name, parent):
+        """
+        Initializes the field name and parent for the field instance.
+        Called when a field is added to the parent serializer instance.
+        Taken from DRF and modified to support drf_haystack multiple index
+        functionality.
+        """
+
+        # In order to enforce a consistent style, we error if a redundant
+        # 'source' argument has been used. For example:
+        # my_field = serializer.CharField(source='my_field')
+        assert self.source != field_name, (
+            f"It is redundant to specify `source='{field_name}'` on field '{self.__class__.__name__}' in "
+            f"serializer '{parent.__class__.__name__}', because it is the same as the field name. "
+            "Remove the `source` keyword argument."
+        )
+
+        self.field_name = field_name
+        self.parent = parent
+
+        # `self.label` should default to being based on the field name.
+        if self.label is None:
+            self.label = field_name.replace("_", " ").capitalize()
+
+        # self.source should default to being the same as the field name.
+        if self.source is None:
+            self.source = self.convert_field_name(field_name)
+
+        # self.source_attrs is a list of attributes that need to be looked up
+        # when serializing the instance, or populating the validated data.
+        if self.source == "*":
+            self.source_attrs = []
+        else:
+            self.source_attrs = self.source.split(".")
+
+    def convert_field_name(self, field_name):
+        if not self.prefix_field_names:
+            return field_name
+        return field_name.split("__")[-1]
+
+
+class HaystackBooleanField(DRFHaystackFieldMixin, fields.BooleanField):
+    pass
+
+
+class HaystackCharField(DRFHaystackFieldMixin, fields.CharField):
+    pass
+
+
+class HaystackDateField(DRFHaystackFieldMixin, fields.DateField):
+    pass
+
+
+class HaystackDateTimeField(DRFHaystackFieldMixin, fields.DateTimeField):
+    pass
+
+
+class HaystackDecimalField(DRFHaystackFieldMixin, fields.DecimalField):
+    pass
+
+
+class HaystackFloatField(DRFHaystackFieldMixin, fields.FloatField):
+    pass
+
+
+class HaystackIntegerField(DRFHaystackFieldMixin, fields.IntegerField):
+    pass
+
+
+class HaystackMultiValueField(DRFHaystackFieldMixin, fields.ListField):
+    pass
+
+
+class FacetDictField(fields.DictField):
+    """
+    A special DictField which passes the key attribute down to the children's
+    ``to_representation()`` in order to let the serializer know what field they're
+    currently processing.
+    """
+
+    def to_representation(self, value):
+        return {str(key): self.child.to_representation(key, val) for key, val in value.items()}
+
+
+class FacetListField(fields.ListField):
+    """
+    The ``FacetListField`` just pass along the key derived from
+    ``FacetDictField``.
+    """
+
+    def to_representation(self, key, data):
+        return [self.child.to_representation(key, item) for item in data]

drf_haystack/filters.py

@@ -0,0 +1,257 @@
+import operator
+from functools import reduce
+
+from django.core.exceptions import ImproperlyConfigured
+from haystack.query import SearchQuerySet
+from rest_framework.filters import BaseFilterBackend, OrderingFilter
+
+from drf_haystack.query import BoostQueryBuilder, FacetQueryBuilder, FilterQueryBuilder, SpatialQueryBuilder
+
+
+class BaseHaystackFilterBackend(BaseFilterBackend):
+    """
+    A base class from which all Haystack filter backend classes should inherit.
+    """
+
+    query_builder_class = None
+
+    @staticmethod
+    def get_request_filters(request):
+        return request.query_params.copy()
+
+    def apply_filters(self, queryset, applicable_filters=None, applicable_exclusions=None):
+        """
+        Apply constructed filters and excludes and return the queryset
+
+        :param queryset: queryset to filter
+        :param applicable_filters: filters which are passed directly to queryset.filter()
+        :param applicable_exclusions: filters which are passed directly to queryset.exclude()
+        :returns filtered queryset
+        """
+        if applicable_filters:
+            queryset = queryset.filter(applicable_filters)
+        if applicable_exclusions:
+            queryset = queryset.exclude(applicable_exclusions)
+        return queryset
+
+    def build_filters(self, view, filters=None):
+        """
+        Get the query builder instance and return constructed query filters.
+        """
+        query_builder = self.get_query_builder(backend=self, view=view)
+        return query_builder.build_query(**(filters or {}))
+
+    def process_filters(self, filters, queryset, view):
+        """
+        Convenient hook to do any post-processing of the filters before they
+        are applied to the queryset.
+        """
+        return filters
+
+    def filter_queryset(self, request, queryset, view):
+        """
+        Return the filtered queryset.
+        """
+        applicable_filters, applicable_exclusions = self.build_filters(view, filters=self.get_request_filters(request))
+        return self.apply_filters(
+            queryset=queryset,
+            applicable_filters=self.process_filters(applicable_filters, queryset, view),
+            applicable_exclusions=self.process_filters(applicable_exclusions, queryset, view),
+        )
+
+    def get_query_builder(self, *args, **kwargs):
+        """
+        Return the query builder class instance that should be used to
+        build the query which is passed to the search engine backend.
+        """
+        query_builder = self.get_query_builder_class()
+        return query_builder(*args, **kwargs)
+
+    def get_query_builder_class(self):
+        """
+        Return the class to use for building the query.
+        Defaults to using `self.query_builder_class`.
+
+        You may want to override this if you need to provide different
+        methods of building the query sent to the search engine backend.
+        """
+        assert self.query_builder_class is not None, (
+            f"'{self.__class__.__name__}' should either include a `query_builder_class` attribute, "
+            "or override the `get_query_builder_class()` method."
+        )
+        return self.query_builder_class
+
+
+class HaystackFilter(BaseHaystackFilterBackend):
+    """
+    A filter backend that compiles a haystack compatible filtering query.
+    """
+
+    query_builder_class = FilterQueryBuilder
+    default_operator = operator.and_
+    default_same_param_operator = operator.or_
+
+
+class HaystackAutocompleteFilter(HaystackFilter):
+    """
+    A filter backend to perform autocomplete search.
+
+    Must be run against fields that are either `NgramField` or
+    `EdgeNgramField`.
+    """
+
+    def process_filters(self, filters, queryset, view):
+        if not filters:
+            return filters
+
+        query_bits = []
+        for field_name, query in filters.children:
+            for word in query.split(" "):
+                bit = queryset.query.clean(word.strip())
+                kwargs = {field_name: bit}
+                query_bits.append(view.query_object(**kwargs))
+        return reduce(operator.and_, filter(lambda x: x, query_bits))
+
+
+class HaystackGEOSpatialFilter(BaseHaystackFilterBackend):
+    """
+    A base filter backend for doing geo spatial filtering.
+    If using this filter make sure to provide a `point_field` with the name of
+    your the `LocationField` of your index.
+
+    We'll always do the somewhat slower but more accurate `dwithin`
+    (radius) filter.
+    """
+
+    query_builder_class = SpatialQueryBuilder
+    point_field = "coordinates"
+
+    def apply_filters(self, queryset, applicable_filters=None, applicable_exclusions=None):
+        if applicable_filters:
+            queryset = queryset.dwithin(**applicable_filters["dwithin"]).distance(**applicable_filters["distance"])
+        return queryset
+
+    def filter_queryset(self, request, queryset, view):
+        return self.apply_filters(queryset, self.build_filters(view, filters=self.get_request_filters(request)))
+
+
+class HaystackHighlightFilter(HaystackFilter):
+    """
+    A filter backend which adds support for ``highlighting`` on the
+    SearchQuerySet level (the fast one).
+    Note that you need to use a search backend which supports highlighting
+    in order to use this.
+
+    This will add a ``hightlighted`` entry to your response, encapsulating the
+    highlighted words in an `<em>highlighted results</em>` block.
+    """
+
+    def filter_queryset(self, request, queryset, view):
+        queryset = super().filter_queryset(request, queryset, view)
+        if self.get_request_filters(request) and isinstance(queryset, SearchQuerySet):
+            queryset = queryset.highlight()
+        return queryset
+
+
+class HaystackBoostFilter(BaseHaystackFilterBackend):
+    """
+    Filter backend for applying term boost on query time.
+
+    Apply by adding a comma separated ``boost`` query parameter containing
+    a the term you want to boost and a floating point or integer for
+    the boost value. The boost value is based around ``1.0`` as 100% - no boost.
+
+    Gives a slight increase in relevance for documents that include "banana":
+        /api/v1/search/?boost=banana,1.1
+    """
+
+    query_builder_class = BoostQueryBuilder
+    query_param = "boost"
+
+    def apply_filters(self, queryset, applicable_filters=None, applicable_exclusions=None):
+        if applicable_filters:
+            queryset = queryset.boost(**applicable_filters)
+        return queryset
+
+    def filter_queryset(self, request, queryset, view):
+        return self.apply_filters(queryset, self.build_filters(view, filters=self.get_request_filters(request)))
+
+
+class HaystackFacetFilter(BaseHaystackFilterBackend):
+    """
+    Filter backend for faceting search results.
+    This backend does not apply regular filtering.
+
+    Faceting field options can be set by using the ``field_options`` attribute
+    on the serializer, and can be overridden by query parameters. Dates will be
+    parsed by the ``python-dateutil.parser()`` which can handle most date formats.
+
+    Query parameters is parsed in the following format:
+      ?field1=option1:value1,option2:value2&field2=option1:value1,option2:value2
+    where each options ``key:value`` pair is separated by the ``view.lookup_sep`` attribute.
+    """
+
+    query_builder_class = FacetQueryBuilder
+
+    def apply_filters(self, queryset, applicable_filters=None, applicable_exclusions=None):
+        """
+        Apply faceting to the queryset
+        """
+        for field, options in applicable_filters["field_facets"].items():
+            queryset = queryset.facet(field, **options)
+
+        for field, options in applicable_filters["date_facets"].items():
+            queryset = queryset.date_facet(field, **options)
+
+        for field, options in applicable_filters["query_facets"].items():
+            queryset = queryset.query_facet(field, **options)
+
+        return queryset
+
+    def filter_queryset(self, request, queryset, view):
+        return self.apply_filters(queryset, self.build_filters(view, filters=self.get_request_filters(request)))
+
+
+class HaystackOrderingFilter(OrderingFilter):
+    """
+    Some docstring here!
+    """
+
+    def get_default_valid_fields(self, queryset, view, context=None):
+        if context is None:
+            context = {}
+        valid_fields = super().get_default_valid_fields(queryset, view, context)
+
+        # Check if we need to support aggregate serializers
+        serializer_class = view.get_serializer_class()
+        if hasattr(serializer_class.Meta, "serializers"):
+            raise NotImplementedError("Ordering on aggregate serializers is not yet implemented.")
+
+        return valid_fields
+
+    def get_valid_fields(self, queryset, view, context=None):
+        if context is None:
+            context = {}
+        valid_fields = getattr(view, "ordering_fields", self.ordering_fields)
+
+        if valid_fields is None:
+            return self.get_default_valid_fields(queryset, view, context)
+
+        elif valid_fields == "__all__":
+            # View explicitly allows filtering on all model fields.
+            if not queryset.query.models:
+                raise ImproperlyConfigured(
+                    f"Cannot use {self.__class__.__name__} with '__all__' as 'ordering_fields' attribute on a view "
+                    "which has no 'index_models' set. Either specify some 'ordering_fields', "
+                    "set the 'index_models' attribute or override the 'get_queryset' "
+                    "method and pass some 'index_models'."
+                )
+
+            model_fields = (
+                [(field.name, field.verbose_name) for field in model._meta.fields] for model in queryset.query.models
+            )
+            valid_fields = list(set(reduce(operator.concat, model_fields)))
+        else:
+            valid_fields = [(item, item) if isinstance(item, str) else item for item in valid_fields]
+
+        return valid_fields

drf_haystack/generics.py

@@ -0,0 +1,102 @@
+from django.contrib.contenttypes.models import ContentType
+from django.http import Http404
+from haystack.backends import SQ
+from haystack.query import SearchQuerySet
+from rest_framework.generics import GenericAPIView
+
+from drf_haystack.filters import HaystackFilter
+
+
+class HaystackGenericAPIView(GenericAPIView):
+    """
+    Base class for all haystack generic views.
+    """
+
+    # Use `index_models` to filter on which search index models we
+    # should include in the search result.
+    index_models = []
+
+    object_class = SearchQuerySet
+    query_object = SQ
+
+    # Override document_uid_field with whatever field in your index
+    # you use to uniquely identify a single document. This value will be
+    # used wherever the view references the `lookup_field` kwarg.
+    document_uid_field = "id"
+    lookup_sep = ","
+
+    # If set to False, DB lookups are done on a per-object basis,
+    # resulting in in many individual trips to the database. If True,
+    # the SearchQuerySet will group similar objects into a single query.
+    load_all = False
+
+    filter_backends = [HaystackFilter]
+
+    def get_queryset(self, index_models=None):
+        """
+        Get the list of items for this view.
+        Returns ``self.queryset`` if defined and is a ``self.object_class``
+        instance.
+
+        @:param index_models: override `self.index_models`
+        """
+        if index_models is None:
+            index_models = []
+        if self.queryset is not None and isinstance(self.queryset, self.object_class):
+            queryset = self.queryset.all()
+        else:
+            queryset = self.object_class()._clone()
+            if len(index_models):
+                queryset = queryset.models(*index_models)
+            elif len(self.index_models):
+                queryset = queryset.models(*self.index_models)
+        return queryset
+
+    def get_object(self):
+        """
+        Fetch a single document from the data store according to whatever
+        unique identifier is available for that document in the
+        SearchIndex.
+
+        In cases where the view has multiple ``index_models``, add a ``model`` query
+        parameter containing a single `app_label.model` name to the request in order
+        to override which model to include in the SearchQuerySet.
+
+        Example:
+            /api/v1/search/42/?model=myapp.person
+        """
+        queryset = self.get_queryset()
+        if "model" in self.request.query_params:
+            try:
+                app_label, model = map(str.lower, self.request.query_params["model"].split(".", 1))
+                ctype = ContentType.objects.get(app_label=app_label, model=model)
+                queryset = self.get_queryset(index_models=[ctype.model_class()])
+            except (ValueError, ContentType.DoesNotExist):
+                raise Http404(
+                    "Could not find any models matching '{}'. Make sure to use a valid "
+                    "'app_label.model' name for the 'model' query parameter.".format(self.request.query_params["model"])
+                )
+
+        lookup_url_kwarg = self.lookup_url_kwarg or self.lookup_field
+        if lookup_url_kwarg not in self.kwargs:
+            raise AttributeError(
+                f"Expected view {self.__class__.__name__} to be called with a URL keyword argument "
+                f"named '{lookup_url_kwarg}'. Fix your URL conf, or set the `.lookup_field` "
+                "attribute on the view correctly."
+            )
+        queryset = queryset.filter(self.query_object((self.document_uid_field, self.kwargs[lookup_url_kwarg])))
+        count = queryset.count()
+        if count == 1:
+            return queryset[0]
+        elif count > 1:
+            raise Http404("Multiple results matches the given query. Expected a single result.")
+
+        raise Http404("No result matches the given query.")
+
+    def filter_queryset(self, queryset):
+        queryset = super().filter_queryset(queryset)
+
+        if self.load_all:
+            queryset = queryset.load_all()
+
+        return queryset

drf_haystack/mixins.py

@@ -0,0 +1,116 @@
+from rest_framework.decorators import action
+from rest_framework.response import Response
+
+from drf_haystack.filters import HaystackFacetFilter
+
+
+class MoreLikeThisMixin:
+    """
+    Mixin class for supporting "more like this" on an API View.
+    """
+
+    @action(detail=True, methods=["get"], url_path="more-like-this")
+    def more_like_this(self, request, pk=None):
+        """
+        Sets up a detail route for ``more-like-this`` results.
+        Note that you'll need backend support in order to take advantage of this.
+
+        This will add ie. ^search/{pk}/more-like-this/$ to your existing ^search pattern.
+        """
+        obj = self.get_object().object
+        queryset = self.filter_queryset(self.get_queryset()).more_like_this(obj)
+
+        page = self.paginate_queryset(queryset)
+        if page is not None:
+            serializer = self.get_serializer(page, many=True)
+            return self.get_paginated_response(serializer.data)
+
+        serializer = self.get_serializer(queryset, many=True)
+        return Response(serializer.data)
+
+
+class FacetMixin:
+    """
+    Mixin class for supporting faceting on an API View.
+    """
+
+    facet_filter_backends = [HaystackFacetFilter]
+    facet_serializer_class = None
+    facet_objects_serializer_class = None
+    facet_query_params_text = "selected_facets"
+
+    @action(detail=False, methods=["get"], url_path="facets")
+    def facets(self, request):
+        """
+        Sets up a list route for ``faceted`` results.
+        This will add ie ^search/facets/$ to your existing ^search pattern.
+        """
+        queryset = self.filter_facet_queryset(self.get_queryset())
+
+        for facet in request.query_params.getlist(self.facet_query_params_text):
+            if ":" not in facet:
+                continue
+
+            field, value = facet.split(":", 1)
+            if value:
+                queryset = queryset.narrow(f'{field}:"{queryset.query.clean(value)}"')
+
+        serializer = self.get_facet_serializer(queryset.facet_counts(), objects=queryset, many=False)
+        return Response(serializer.data)
+
+    def filter_facet_queryset(self, queryset):
+        """
+        Given a search queryset, filter it with whichever facet filter backends
+        in use.
+        """
+        for backend in list(self.facet_filter_backends):
+            queryset = backend().filter_queryset(self.request, queryset, self)
+
+        if self.load_all:
+            queryset = queryset.load_all()
+
+        return queryset
+
+    def get_facet_serializer(self, *args, **kwargs):
+        """
+        Return the facet serializer instance that should be used for
+        serializing faceted output.
+        """
+        assert "objects" in kwargs, "`objects` is a required argument to `get_facet_serializer()`"
+
+        facet_serializer_class = self.get_facet_serializer_class()
+        kwargs["context"] = self.get_serializer_context()
+        kwargs["context"].update({
+            "objects": kwargs.pop("objects"),
+            "facet_query_params_text": self.facet_query_params_text,
+        })
+        return facet_serializer_class(*args, **kwargs)
+
+    def get_facet_serializer_class(self):
+        """
+        Return the class to use for serializing facets.
+        Defaults to using ``self.facet_serializer_class``.
+        """
+        if self.facet_serializer_class is None:
+            raise AttributeError(
+                f"{self.__class__.__name__} should either include a `facet_serializer_class` attribute, "
+                f"or override {self.__class__.__name__}.get_facet_serializer_class() method."
+            )
+        return self.facet_serializer_class
+
+    def get_facet_objects_serializer(self, *args, **kwargs):
+        """
+        Return the serializer instance which should be used for
+        serializing faceted objects.
+        """
+        facet_objects_serializer_class = self.get_facet_objects_serializer_class()
+        kwargs["context"] = self.get_serializer_context()
+        return facet_objects_serializer_class(*args, **kwargs)
+
+    def get_facet_objects_serializer_class(self):
+        """
+        Return the class to use for serializing faceted objects.
+        Defaults to using the views ``self.serializer_class`` if not
+        ``self.facet_objects_serializer_class`` is set.
+        """
+        return self.facet_objects_serializer_class or super().get_serializer_class()