codex 1.7.0a0__py3-none-any.whl → 1.7.0a2__py3-none-any.whl

codex/views/browser/filters/search/fts.py

@@ -1,9 +1,6 @@
 """Search Filters Methods."""
 
-from django.db.models.query import Q
-
 from codex.logger.logging import get_logger
-from codex.models import Comic, StoryArc
 from codex.views.browser.filters.search.field.filter import BrowserFieldQueryFilter
 
 LOG = get_logger(__name__)
@@ -12,27 +9,16 @@ LOG = get_logger(__name__)
 class BrowserFTSFilter(BrowserFieldQueryFilter):
     """Search Filters Methods."""
 
-    @staticmethod
-    def _get_fts_filter(model, text):
-        """Get the filter dict."""
-        prefix = (
-            ""
-            if model == Comic
-            else "storyarcnumber__comic__"
-            if model == StoryArc
-            else "comic__"
-        )
-        # Custom Lookup defined in codex.models
-        rel = prefix + "comicfts__match"
-        return {rel: text}
-
     def get_fts_filter(self, model, text):
         """Perform the search and return the scores as a dict."""
         fts_filter = {}
         try:
             if text:
-                fts_filter = self._get_fts_filter(model, text)
+                rel = self.get_rel_prefix(model)
+                # Custom lookup defined in codex.models
+                rel += "comicfts__match"
+                fts_filter[rel] = text
         except Exception:
             LOG.exception("Getting Full Text Search Filter.")
             self.search_error = "Error creating full text search filter"
-        return Q(**fts_filter)
+        return fts_filter

codex/views/browser/filters/search/parse.py

@@ -1,8 +1,12 @@
 """Search Filters Methods."""
 
 import re
+from types import MappingProxyType
+
+from django.db.models.query import Q
 
 from codex.logger.logging import get_logger
+from codex.models import AdminFlag
 from codex.models.comic import ComicFTS
 from codex.views.browser.filters.search.aliases import ALIAS_FIELD_MAP
 from codex.views.browser.filters.search.fts import BrowserFTSFilter
@@ -56,24 +60,43 @@ _TOKEN_RE = re.compile(_TOKEN_REXP, flags=re.IGNORECASE)
 class SearchFilterView(BrowserFTSFilter):
     """Search Query Parser."""
 
+    ADMIN_FLAG_VALUE_KEY_MAP = MappingProxyType(
+        {
+            AdminFlag.FlagChoices.FOLDER_VIEW.value: "folder_view",
+        }
+    )
+
     def __init__(self, *args, **kwargs):
         """Initialize search variables."""
         super().__init__(*args, **kwargs)
+        self._admin_flags: MappingProxyType[str, bool] | None = None
         self.fts_mode = False
         self.search_mode = False
         self.search_error = ""
 
+    @property
+    def admin_flags(self) -> MappingProxyType[str, bool]:
+        """Set browser relevant admin flags."""
+        if self._admin_flags is None:
+            if self.ADMIN_FLAG_VALUE_KEY_MAP:
+                admin_pairs = AdminFlag.objects.filter(
+                    key__in=self.ADMIN_FLAG_VALUE_KEY_MAP.keys()
+                ).values_list("key", "on")
+            else:
+                admin_pairs = ()
+            admin_flags = {}
+            for key, on in admin_pairs:
+                export_key = self.ADMIN_FLAG_VALUE_KEY_MAP[key]
+                admin_flags[export_key] = on
+            self._admin_flags = MappingProxyType(admin_flags)
+        return self._admin_flags
+
     def _is_path_column_allowed(self):
         """Is path column allowed."""
-        if not self.is_admin():  # type: ignore
-            if not "folder_view" not in self.admin_flags:  # type: ignore
-                # Ensure admin flags for Cover View
-                self.set_admin_flags()  # type: ignore
-            return bool(self.admin_flags.get("folder_view"))  # type: ignore
-        return True
+        return self.is_admin or bool(self.admin_flags["folder_view"])
 
     @staticmethod
-    def _is_column_operators_used(exp):
+    def _is_column_operators_used(exp) -> bool:
         """Detect column expression operators, but not inside quotes."""
         for match in _COLUMN_EXPRESSION_OPERATORS_RE.finditer(exp):
             if match.group("star"):
@@ -149,7 +172,7 @@ class SearchFilterView(BrowserFTSFilter):
         field_exclude_q_list = []
         for preop, field_token_pairs in field_tokens_dict.items():
             if preop == "not":
-                exclude_q_list, filter_q_list = self.get_search_field_filters(
+                exclude_q_list, include_q_list = self.get_search_field_filters(
                     model, field_token_pairs
                 )
             else:
@@ -157,37 +180,44 @@ class SearchFilterView(BrowserFTSFilter):
                 # XXX cannot do OR queries with MATCH, it decontextualizes MATCH somehow.
                 if preop == "or":
                     self.search_error = "OR preceding column tokens with operator expressions will act as AND"
-                filter_q_list, exclude_q_list = self.get_search_field_filters(
+                include_q_list, exclude_q_list = self.get_search_field_filters(
                     model, field_token_pairs
                 )
-            field_filter_q_list += filter_q_list
+            field_filter_q_list += include_q_list
             field_exclude_q_list += exclude_q_list
-        fts_filter = self.get_fts_filter(model, fts_text)
-        return field_exclude_q_list, field_filter_q_list, fts_filter
 
-    def _apply_search_filter_list(self, qs, filter_list, exclude):
+        fts_filter_dict = self.get_fts_filter(model, fts_text)
+        if fts_filter_dict:
+            self.fts_mode = True
+            fts_q = Q(**fts_filter_dict)
+        else:
+            fts_q = Q()
+
+        return field_filter_q_list, field_exclude_q_list, fts_q
+
+    def _create_search_filter(self, filter_list):
         """Apply search filter lists. Separate filter clauses are employed for m2m searches."""
+        combined_q = Q()
         for q in filter_list:
             if not q:
                 continue
-            qs = qs.exclude(q) if exclude else qs.filter(q)
+            combined_q &= q
             self.search_mode = True
 
-        return qs
+        return combined_q
 
-    def apply_search_filter(self, qs, model):
+    def get_search_filters(self, model):
         """Preparse search, search and return the filter and scores."""
+        include_q = Q()
+        exclude_q = Q()
+        fts_q = Q()
         try:
-            field_exclude_q_list, field_filter_q_list, fts_filter = (
+            field_filter_q_list, field_exclude_q_list, fts_q = (
                 self._create_search_filters(model)
             )
-
             # Apply filters
-            qs = self._apply_search_filter_list(qs, field_exclude_q_list, True)
-            qs = self._apply_search_filter_list(qs, field_filter_q_list, False)
-            if fts_filter:
-                qs = qs.filter(fts_filter)
-                self.search_mode = self.fts_mode = True
+            include_q = self._create_search_filter(field_filter_q_list)
+            exclude_q = self._create_search_filter(field_exclude_q_list)
 
         except Exception as exc:
             msg = "Creating search filters"
@@ -195,7 +225,7 @@ class SearchFilterView(BrowserFTSFilter):
             msg = f"{msg} - {exc}"
             self.search_error = msg
 
-        return qs
+        return include_q, exclude_q, fts_q
 
     def _is_search_results_limited(self) -> bool:
         """Get search result limit from params."""

codex/views/browser/group_mtime.py

@@ -0,0 +1,83 @@
+"""Group Mtime Function."""
+
+from logging import DEBUG, WARNING
+
+from django.db.models.aggregates import Aggregate, Max
+from django.db.models.functions import Greatest
+from django.db.utils import OperationalError
+
+from codex.logger.logging import get_logger
+from codex.models.functions import JsonGroupArray
+from codex.views.browser.filters.filter import BrowserFilterView
+from codex.views.const import EPOCH_START, EPOCH_START_DATETIMEFIELD, NONE_DATETIMEFIELD
+
+_FTS5_PREFIX = "fts5: "
+LOG = get_logger(__name__)
+
+
+class BrowserGroupMtimeView(BrowserFilterView):
+    """Annotations that also filter."""
+
+    def __init__(self, *args, **kwargs):
+        """Initialize memoized values."""
+        super().__init__(*args, **kwargs)
+        self._is_bookmark_filtered: bool | None = None
+
+    @property
+    def is_bookmark_filtered(self):
+        """Is bookmark filter in effect."""
+        if self._is_bookmark_filtered is None:
+            self._is_bookmark_filtered = bool(
+                self.params.get("filters", {}).get("bookmark")
+            )
+        return self._is_bookmark_filtered
+
+    def _handle_operational_error(self, err):
+        msg = err.args[0] if err.args else ""
+        if msg.startswith(_FTS5_PREFIX):
+            level = DEBUG
+            self.search_error = msg.removeprefix(_FTS5_PREFIX)
+        else:
+            level = WARNING
+            msg = str(err)
+        LOG.log(level, f"Query Error: {msg}")
+
+    def get_max_bookmark_updated_at_aggregate(
+        self, model, agg_func: type[Aggregate] = Max, default=NONE_DATETIMEFIELD
+    ):
+        """Get filtered maximum bookmark updated_at relation."""
+        bm_rel = self._get_bm_rel(model)
+        bm_filter = self._get_my_bookmark_filter(bm_rel)
+        bmua_rel = f"{bm_rel}__updated_at"
+        args = {"default": default, "filter": bm_filter}
+        if agg_func is JsonGroupArray:
+            args["distinct"] = True
+        return agg_func(bmua_rel, **args)
+
+    def get_group_mtime(self, model, group=None, pks=None, page_mtime=False):
+        """Get a filtered mtime for browser pages and mtime checker."""
+        qs = self.get_filtered_queryset(
+            model,
+            group=group,
+            pks=pks,
+            page_mtime=page_mtime,
+            bookmark_filter=self.is_bookmark_filtered,
+        )
+        mua = Max("updated_at", default=EPOCH_START_DATETIMEFIELD)
+        mbua = self.get_max_bookmark_updated_at_aggregate(
+            model, default=EPOCH_START_DATETIMEFIELD
+        )
+
+        try:
+            qs = qs.annotate(max=Greatest(mua, mbua))
+            # Forcing inner joins makes search work
+            # Can't run demote_joins on aggregate.
+            qs = self.force_inner_joins(qs)
+            first = qs.first()
+            mtime = first.max if first else EPOCH_START
+        except OperationalError as exc:
+            self._handle_operational_error(exc)
+            mtime = None
+        if mtime == NotImplemented:
+            mtime = None
+        return mtime

codex/views/browser/metadata/__init__.py

@@ -0,0 +1 @@
+"""Metadata View."""

codex/views/browser/metadata/annotate.py

@@ -0,0 +1,109 @@
+"""Metadata Annotations."""
+
+from django.db.models import Count, IntegerField, Sum, Value
+
+from codex.logger.logging import get_logger
+from codex.models import Comic
+from codex.views.browser.annotate.card import BrowserAnnotateCardView
+
+LOG = get_logger(__name__)
+_ADMIN_OR_FILE_VIEW_ENABLED_COMIC_VALUE_FIELDS = frozenset({"path"})
+_COMIC_VALUE_FIELDS_CONFLICTING = frozenset(
+    {
+        "created_at",
+        "name",
+        "path",
+        "updated_at",
+    }
+)
+_DISABLED_VALUE_FIELD_NAMES = frozenset(
+    {"id", "pk", "sort_name", "stat"} | _COMIC_VALUE_FIELDS_CONFLICTING
+)
+_COMIC_VALUE_FIELD_NAMES = frozenset(
+    # contains path
+    field.name
+    for field in Comic._meta.get_fields()
+    if not field.is_relation and field.name not in _DISABLED_VALUE_FIELD_NAMES
+)
+_COMIC_VALUE_FIELDS_CONFLICTING_PREFIX = "conflict_"
+_COMIC_RELATED_VALUE_FIELDS = frozenset({"series__volume_count", "volume__issue_count"})
+_PATH_GROUPS = frozenset({"c", "f"})
+_SUM_FIELDS = frozenset({"page_count", "size"})
+
+
+class MetadataAnnotateView(BrowserAnnotateCardView):
+    """Metadata Annotations."""
+
+    def _get_comic_value_fields(self):
+        """Include the path field for staff."""
+        fields = set(_COMIC_VALUE_FIELD_NAMES)
+        group = self.kwargs["group"]
+        if (
+            not (self.is_admin and self.admin_flags["folder_view"])
+            or group not in _PATH_GROUPS
+        ):
+            fields -= _ADMIN_OR_FILE_VIEW_ENABLED_COMIC_VALUE_FIELDS
+        return tuple(fields)
+
+    def _intersection_annotate(
+        self,
+        querysets,
+        fields,
+        related_suffix="",
+        annotation_prefix="",
+    ):
+        """Annotate the intersection of value and fk fields."""
+        (filtered_qs, qs) = querysets
+
+        for field in fields:
+            # Annotate variant counts
+            # If 1 variant, annotate value, otherwise None
+            ann_field = annotation_prefix + field.replace("__", "_")
+
+            full_field = self.rel_prefix + field
+
+            if field in _SUM_FIELDS:
+                val = Sum(full_field)
+            else:
+                # group_by makes the filter work, but prevents its
+                # use as a subquery in the big query.
+                sq = filtered_qs.alias(
+                    filter_count=Count(full_field, distinct=True)
+                ).filter(filter_count=1)
+                sq = self.add_group_by(sq)
+                sq = self.force_inner_joins(sq)
+                sq = sq.values_list(full_field + related_suffix, flat=True)
+                try:
+                    val = sq[0]
+                except IndexError:
+                    val = None
+                if field.endswith("count"):
+                    output_field = IntegerField()
+                else:
+                    output_field = Comic._meta.get_field(field).__class__()
+                val = Value(val, output_field)
+            qs = qs.annotate(**{ann_field: val})
+
+        return filtered_qs, qs
+
+    def _annotate_values_and_fks(self, qs, filtered_qs):
+        """Annotate comic values and comic foreign key values."""
+        # Simple Values
+        querysets = (filtered_qs, qs)
+        if qs.model is not Comic:
+            comic_value_fields = self._get_comic_value_fields()
+            querysets = self._intersection_annotate(querysets, comic_value_fields)
+
+            # Conflicting Simple Values
+            querysets = self._intersection_annotate(
+                querysets,
+                _COMIC_VALUE_FIELDS_CONFLICTING,
+                annotation_prefix=_COMIC_VALUE_FIELDS_CONFLICTING_PREFIX,
+            )
+
+        # Foreign Keys with special count values
+        _, qs = self._intersection_annotate(
+            querysets,
+            _COMIC_RELATED_VALUE_FIELDS,
+        )
+        return qs

codex/views/browser/metadata/copy_intersections.py

@@ -0,0 +1,90 @@
+"""Copy Intersections Into Comic Fields."""
+
+from codex.logger.logging import get_logger
+from codex.models.comic import Comic
+from codex.serializers.browser.metadata import PREFETCH_PREFIX
+from codex.views.browser.metadata.query_intersections import (
+    MetadataQueryIntersectionsView,
+)
+
+LOG = get_logger(__name__)
+_COMIC_VALUE_FIELDS_CONFLICTING = frozenset(
+    {
+        "created_at",
+        "name",
+        "path",
+        "updated_at",
+    }
+)
+_COMIC_VALUE_FIELDS_CONFLICTING_PREFIX = "conflict_"
+_PATH_GROUPS = frozenset({"c", "f"})
+
+
+class MetadataCopyIntersectionsView(MetadataQueryIntersectionsView):
+    """Copy Intersections Into Comic Fields."""
+
+    def _path_security(self, obj):
+        """Secure filesystem information for acl situation."""
+        group = self.kwargs["group"]
+        is_path_group = group in _PATH_GROUPS
+        if is_path_group:
+            if self.is_admin:
+                return
+            if self.admin_flags["folder_view"]:
+                obj.path = obj.search_path()
+        else:
+            obj.path = ""
+
+    def _highlight_current_group(self, obj):
+        """Values for highlighting the current group."""
+        if self.model and self.model is not Comic:
+            # move the name of the group to the correct field
+            field = self.model.__name__.lower() + "_list"
+            group_list = self.model.objects.filter(pk__in=obj.ids).values("name")
+            setattr(obj, field, group_list)
+            obj.name = None
+
+    @classmethod
+    def _copy_m2m_intersections(cls, obj, m2m_intersections):
+        """Copy the m2m intersections into the object."""
+        # XXX It might even be faster to copy everything to a dict and not use the obj.
+        for key, qs in m2m_intersections.items():
+            serializer_key = (
+                f"{PREFETCH_PREFIX}{key}"
+                if key in ("identifiers", "contributors", "story_arc_numbers")
+                else key
+            )
+            if hasattr(obj, serializer_key):
+                # real db fields need to use their special set method.
+                field = getattr(obj, serializer_key)
+                field.set(
+                    qs,
+                    clear=True,
+                )
+            else:
+                # fake db field is just a queryset attached.
+                setattr(obj, serializer_key, qs)
+
+    @staticmethod
+    def _copy_groups(obj, groups):
+        for field, group_qs in groups.items():
+            setattr(obj, field + "_list", group_qs)
+
+    @staticmethod
+    def _copy_conflicting_simple_fields(obj):
+        for field in _COMIC_VALUE_FIELDS_CONFLICTING:
+            """Copy conflicting fields over naturral fields."""
+            conflict_field = _COMIC_VALUE_FIELDS_CONFLICTING_PREFIX + field
+            val = getattr(obj, conflict_field)
+            setattr(obj, field, val)
+
+    def copy_intersections_into_comic_fields(self, obj, groups, m2m_intersections):
+        """Copy a bunch of values that i couldn't fit cleanly in the main queryset."""
+        self._path_security(obj)
+        self._highlight_current_group(obj)
+        self._copy_groups(obj, groups)
+        self._copy_m2m_intersections(obj, m2m_intersections)
+        if self.model is not Comic:
+            self._copy_conflicting_simple_fields(obj)
+
+        return obj

codex/views/browser/metadata/metadata.py

@@ -0,0 +1,83 @@
+"""Aggregate Group and Comic Metadata View."""
+
+from types import MappingProxyType
+
+from drf_spectacular.utils import extend_schema
+from rest_framework.exceptions import NotFound
+from rest_framework.response import Response
+
+from codex.logger.logging import get_logger
+from codex.models import AdminFlag
+from codex.serializers.browser.metadata import MetadataSerializer
+from codex.serializers.browser.settings import BrowserFilterChoicesInputSerilalizer
+from codex.views.browser.metadata.copy_intersections import (
+    MetadataCopyIntersectionsView,
+)
+
+LOG = get_logger(__name__)
+
+
+class MetadataView(MetadataCopyIntersectionsView):
+    """Aggregate Group and Comic Metadata View."""
+
+    serializer_class = MetadataSerializer
+    input_serializer_class = BrowserFilterChoicesInputSerilalizer
+    TARGET = "metadata"
+    ADMIN_FLAG_VALUE_KEY_MAP = MappingProxyType(
+        {
+            AdminFlag.FlagChoices.FOLDER_VIEW.value: "folder_view",
+        }
+    )
+
+    def _get_valid_browse_nav_groups(self, valid_top_groups):  # noqa: ARG002
+        """Limited allowed nav groups for metadata."""
+        # Overrides method in browser.validate
+        group = self.kwargs["group"]
+        return (group,)
+
+    def _raise_not_found(self, exc=None):
+        """Raise an exception if the object is not found."""
+        pks = self.kwargs["pks"]
+        group = self.kwargs["group"]
+        detail = f"Filtered metadata for {group}/{pks} not found"
+        raise NotFound(detail=detail) from exc
+
+    def get_object(self):
+        """Create a comic-like object from the current browser group."""
+        # Comic model goes through the same code path as groups because
+        # values dicts don't copy relations to the serializer. The values
+        # dict is necessary because of the folders view union in browser.py.
+
+        qs = self.get_filtered_queryset(self.model)
+        filtered_qs = qs
+
+        # Annotate
+        qs = self.annotate_order_aggregates(qs)
+        qs = self.annotate_card_aggregates(qs)
+        qs = self._annotate_values_and_fks(qs, filtered_qs)
+        qs = self.add_group_by(qs)
+        qs = self.force_inner_joins(qs)
+
+        # Get Object
+        try:
+            obj = qs[0]
+            if not obj:
+                reason = "Empty obj"
+                raise ValueError(reason)  # noqa TRY301
+        except (IndexError, ValueError) as exc:
+            return self._raise_not_found(exc)
+
+        # Hacks to add to object after query
+        groups, m2m_intersections = self.query_intersections(filtered_qs)
+        return self.copy_intersections_into_comic_fields(obj, groups, m2m_intersections)
+
+    @extend_schema(parameters=[input_serializer_class])
+    def get(self, *_args, **_kwargs):
+        """Get metadata for a filtered browse group."""
+        # Init
+        try:
+            obj = self.get_object()
+            serializer = self.get_serializer(obj)
+            return Response(serializer.data)
+        except Exception:
+            LOG.exception(f"Getting metadata {self.kwargs}")

codex/views/browser/metadata/query_intersections.py

@@ -0,0 +1,112 @@
+"""Metadata query fk & m2m intersections."""
+
+from types import MappingProxyType
+
+from django.db.models import Count
+
+from codex.librarian.importer.const import COMIC_M2M_FIELD_NAMES
+from codex.logger.logging import get_logger
+from codex.models import Comic
+from codex.models.functions import JsonGroupArray
+from codex.views.browser.metadata.annotate import MetadataAnnotateView
+from codex.views.const import METADATA_GROUP_RELATION
+
+LOG = get_logger(__name__)
+_CONTRIBUTOR_RELATIONS = ("role", "person")
+_GROUP_RELS = MappingProxyType(
+    {
+        "i": ("publisher",),
+        "s": (
+            "publisher",
+            "imprint",
+        ),
+        "v": (
+            "publisher",
+            "imprint",
+            "series",
+        ),
+        "c": ("publisher", "imprint", "series", "volume"),
+    }
+)
+
+
+class MetadataQueryIntersectionsView(MetadataAnnotateView):
+    """Metadata query fk & m2m intersections."""
+
+    def _query_groups(self):
+        """Query the through models to show group lists."""
+        groups = {}
+        if not self.model:
+            return groups
+        group = self.kwargs["group"]
+        rel = METADATA_GROUP_RELATION.get(group)
+        if not rel:
+            return groups
+        rel = rel + "__in"
+        pks = self.kwargs["pks"]
+        group_filter = {rel: pks}
+
+        for field_name in _GROUP_RELS.get(group, ()):
+            field = self.model._meta.get_field(field_name)
+            model = field.related_model
+            if not model:
+                continue
+
+            qs = model.objects.filter(**group_filter)
+            qs = qs.only("name").distinct()
+            qs = qs.group_by("name")
+            qs = qs.annotate(ids=JsonGroupArray("id", distinct=True))
+            qs = qs.values("ids", "name")
+            groups[field_name] = qs
+        return groups
+
+    @staticmethod
+    def _get_optimized_m2m_query(key, qs):
+        if key == "contributors":
+            qs = qs.prefetch_related(*_CONTRIBUTOR_RELATIONS)
+            qs = qs.only(*_CONTRIBUTOR_RELATIONS)
+        elif key == "story_arc_numbers":
+            qs = qs.select_related("story_arc")
+            qs = qs.only("story_arc", "number")
+        elif key == "identifiers":
+            qs = qs.select_related("identifier_type")
+            qs = qs.only("identifier_type", "nss", "url")
+        else:
+            qs = qs.only("name")
+        return qs
+
+    def _get_m2m_intersection_query(self, field_name, comic_pks, comic_pks_count):
+        """Get intersection query for one field."""
+        model = Comic._meta.get_field(field_name).related_model
+        if not model:
+            reason = f"No model found for comic field: {field_name}"
+            raise ValueError(reason)
+
+        intersection_qs = model.objects.filter(comic__pk__in=comic_pks)
+        intersection_qs = intersection_qs.alias(count=Count("comic")).filter(
+            count=comic_pks_count
+        )
+        return self._get_optimized_m2m_query(field_name, intersection_qs)
+
+    def _query_m2m_intersections(self, filtered_qs):
+        """Query the through models to figure out m2m intersections."""
+        # Speed ok, but still does a query per m2m model
+        m2m_intersections = {}
+        pk_field = self.rel_prefix + "pk"
+        comic_pks = filtered_qs.distinct().values_list(pk_field, flat=True)
+        # In fts mode the join doesn't work for the query.
+        # Evaluating it now is probably faster than running the filter for every m2m anyway.
+        comic_pks = set(comic_pks)
+        comic_pks_count = len(comic_pks)
+
+        for field_name in COMIC_M2M_FIELD_NAMES:
+            m2m_intersections[field_name] = self._get_m2m_intersection_query(
+                field_name, comic_pks, comic_pks_count
+            )
+        return m2m_intersections
+
+    def query_intersections(self, filtered_qs):
+        """Query complex intersections."""
+        groups = self._query_groups()
+        m2m_intersections = self._query_m2m_intersections(filtered_qs)
+        return groups, m2m_intersections