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

codex/views/browser/annotate/__init__.py

@@ -1 +0,0 @@
-"""Browser annotation methods."""

codex/views/browser/annotate/bookmark.py

@@ -1,112 +0,0 @@
-"""Base view for metadata annotations."""
-
-from django.db.models import (
-    Case,
-    F,
-    Sum,
-    Value,
-    When,
-)
-from django.db.models.fields import BooleanField, PositiveSmallIntegerField
-from django.db.models.functions import Least
-from django.db.models.functions.comparison import Coalesce
-
-from codex.logger.logging import get_logger
-from codex.models import (
-    Comic,
-)
-from codex.models.functions import JsonGroupArray
-from codex.views.browser.annotate.order import BrowserAnnotateOrderView
-
-LOG = get_logger(__name__)
-
-
-class BrowserAnnotateBookmarkView(BrowserAnnotateOrderView):
-    """Base class for views that need special metadata annotations."""
-
-    def _get_group_bookmark_page_annotation(
-        self, qs, bm_rel, bm_filter, page_rel, finished_rel
-    ):
-        """Get bookmark page subquery."""
-        finished_filter = {finished_rel: True}
-        prefix = "" if qs.model is Comic else self.rel_prefix
-        page_count = prefix + "page_count"
-        # Can't use a filtered relation for page & finished because of this
-        # page_count case.
-        bookmark_page_case = Case(
-            When(**{bm_rel: None}, then=0),
-            When(**finished_filter, then=page_count),
-            default=page_rel,
-            output_field=PositiveSmallIntegerField(),
-        )
-        return Sum(
-            bookmark_page_case,
-            default=0,
-            filter=bm_filter,
-            output_field=PositiveSmallIntegerField(),
-            distinct=True,
-        )
-
-    @classmethod
-    def _get_group_bookmark_finished_annotation(cls, qs, bm_filter, finished_rel):
-        """Get finished_count subquery."""
-        finished_count = Sum(
-            finished_rel,
-            default=0,
-            filter=bm_filter,
-            output_field=PositiveSmallIntegerField(),
-            # distinct breaks this sum and only returns one. idk why.
-        )
-        qs = qs.alias(finished_count=finished_count)
-
-        finished_aggregate = Case(
-            When(finished_count=F("child_count"), then=True),
-            When(finished_count=0, then=False),
-            default=None,
-            output_field=BooleanField(),
-        )
-        return qs, finished_aggregate
-
-    def annotate_bookmarks(self, qs):
-        """Hoist up bookmark annotations."""
-        bm_rel = self._get_bm_rel(qs.model)
-        bm_filter = self._get_my_bookmark_filter(bm_rel)
-        page_rel = f"{bm_rel}__page"
-        finished_rel = f"{bm_rel}__finished"
-
-        if qs.model is Comic:
-            bookmark_page = Sum(page_rel, filter=bm_filter, default=0)
-            finished_aggregate = Sum(finished_rel, filter=bm_filter, default=False)
-        else:
-            bookmark_page = self._get_group_bookmark_page_annotation(
-                qs, bm_rel, bm_filter, page_rel, finished_rel
-            )
-            qs, finished_aggregate = self._get_group_bookmark_finished_annotation(
-                qs, bm_filter, finished_rel
-            )
-
-        if (
-            (self.TARGET == "browser" and qs.model is Comic)
-            or self.is_opds_acquisition
-            or self.TARGET == "metadata"
-        ):
-            qs = qs.annotate(page=bookmark_page)
-        else:
-            qs = qs.alias(page=bookmark_page)
-
-        qs = qs.annotate(finished=finished_aggregate)
-
-        if not self.bmua_is_max:
-            mbmua = self.get_max_bookmark_updated_at_aggregate(qs.model, JsonGroupArray)
-            qs = qs.annotate(bookmark_updated_ats=mbmua)
-        return qs
-
-    def annotate_progress(self, qs):
-        """Compute progress for each member of a qs."""
-        # Requires bookmark and annotation hoisted from bookmarks.
-        # Requires page_count native to comic or aggregated
-        # Page counts can be null with metadata turned off.
-        # Least guard is for rare instances when bookmarks are set to
-        # invalid high values
-        progress = Least(Coalesce(F("page"), 0) * 100.0 / F("page_count"), Value(100.0))
-        return qs.annotate(progress=progress)

codex/views/browser/annotate/card.py

@@ -1,61 +0,0 @@
-"""Base view for metadata annotations."""
-
-from types import MappingProxyType
-
-from django.db.models import (
-    Value,
-)
-from django.db.models.aggregates import Count
-from django.db.models.fields import CharField
-
-from codex.logger.logging import get_logger
-from codex.models.comic import Comic
-from codex.models.functions import JsonGroupArray
-from codex.models.groups import BrowserGroupModel, Imprint, Publisher, Series, Volume
-from codex.views.browser.annotate.bookmark import BrowserAnnotateBookmarkView
-
-_GROUP_BY: MappingProxyType[type[BrowserGroupModel], str] = MappingProxyType(
-    {Publisher: "sort_name", Imprint: "sort_name", Series: "sort_name", Volume: "name"}
-)
-LOG = get_logger(__name__)
-
-
-class BrowserAnnotateCardView(BrowserAnnotateBookmarkView):
-    """Base class for views that need special metadata annotations."""
-
-    def add_group_by(self, qs):
-        """Get the group by for the model."""
-        if group_by := _GROUP_BY.get(qs.model):  # type: ignore
-            qs = qs.group_by(group_by)
-        return qs
-
-    def _annotate_child_count(self, qs):
-        """Annotate child chount for card."""
-        if qs.model is Comic:
-            return qs
-        rel = self.rel_prefix + "pk"
-        count_func = Count(rel, distinct=True)
-        ann = {"child_count": count_func}
-        if self.TARGET == "opds2":
-            if qs.model is not Comic:
-                qs = qs.alias(**ann)
-        else:
-            qs = qs.annotate(**ann)
-        return qs
-
-    def _annotate_group(self, qs):
-        """Annotate Group."""
-        value = "c" if qs.model is Comic else self.model_group  # type: ignore
-        return qs.annotate(group=Value(value, CharField(max_length=1)))
-
-    def annotate_card_aggregates(self, qs):
-        """Annotate aggregates that appear the browser card."""
-        if qs.model is Comic:
-            # comic adds order_value for cards late
-            qs = self.annotate_order_value(qs)
-        qs = self._annotate_group(qs)
-        qs = self.annotate_group_names(qs)
-        qs = self._annotate_child_count(qs)
-        qs = self.annotate_bookmarks(qs)
-        qs = self.annotate_progress(qs)
-        return qs.annotate(updated_ats=JsonGroupArray("updated_at", distinct=True))

codex/views/browser/annotate/order.py

@@ -1,247 +0,0 @@
-"""Base view for metadata annotations."""
-
-from os import sep
-from types import MappingProxyType
-
-from django.db.models import (
-    F,
-    FilteredRelation,
-    Q,
-    Value,
-)
-from django.db.models.aggregates import Avg, Max, Min, Sum
-from django.db.models.fields import CharField
-from django.db.models.functions import Reverse, Right, StrIndex
-
-from codex.logger.logging import get_logger
-from codex.models import (
-    Comic,
-    Folder,
-    StoryArc,
-)
-from codex.models.functions import ComicFTSRank, JsonGroupArray
-from codex.views.browser.order_by import (
-    BrowserOrderByView,
-)
-from codex.views.const import (
-    NONE_INTEGERFIELD,
-    STORY_ARC_GROUP,
-)
-from codex.views.mixins import SharedAnnotationsMixin
-
-_ORDER_AGGREGATE_FUNCS = MappingProxyType(
-    # These are annotated to order_value because they're simple relations
-    {
-        "age_rating": Avg,
-        "community_rating": Avg,
-        "created_at": Min,
-        "critical_rating": Avg,
-        "date": Min,
-        "page_count": Sum,
-        "size": Sum,
-        "updated_at": Min,
-    }
-)
-_ANNOTATED_ORDER_FIELDS = frozenset(
-    # These are annotated with their own functions
-    {
-        "filename",
-        "sort_name",
-        "search_score",
-        "bookmark_updated_at",
-        "story_arc_number",
-    }
-)
-
-LOG = get_logger(__name__)
-
-
-class BrowserAnnotateOrderView(BrowserOrderByView, SharedAnnotationsMixin):
-    """Base class for views that need special metadata annotations."""
-
-    CARD_TARGETS = frozenset({"browser", "metadata"})
-    _OPDS_TARGETS = frozenset({"opds1", "opds2"})
-    _PAGE_COUNT_TARGETS = frozenset(CARD_TARGETS | _OPDS_TARGETS)
-    _COVER_AND_CARD_TARGETS = frozenset(CARD_TARGETS | {"cover"})
-
-    def __init__(self, *args, **kwargs):
-        """Set params for the type checker."""
-        super().__init__(*args, **kwargs)
-        self._order_agg_func: type[Min | Max] | None = None
-        self._is_opds_acquisition: bool | None = None
-        self._opds_acquisition_groups: frozenset[str] | None = None
-        self.bmua_is_max = False
-
-    @property
-    def opds_acquisition_groups(self):
-        """Memoize the opds acquisition groups."""
-        if self._opds_acquisition_groups is None:
-            groups = {"a", "f", "c"}
-            groups |= {*self.valid_nav_groups[-2:]}
-            self._opds_acquisition_groups = frozenset(groups)
-        return self._opds_acquisition_groups
-
-    @property
-    def is_opds_acquisition(self):
-        """Memoize if we're in an opds acquisition view."""
-        if self._is_opds_acquisition is None:
-            is_opds_acquisition = self.TARGET in self._OPDS_TARGETS
-            if is_opds_acquisition:
-                group = self.kwargs.get("group")
-                is_opds_acquisition &= group in self.opds_acquisition_groups
-                if is_opds_acquisition and group == "a":
-                    pks = self.kwargs["pks"]
-                    is_opds_acquisition &= bool(pks and 0 not in pks)
-            self._is_opds_acquisition = is_opds_acquisition
-        return self._is_opds_acquisition
-
-    @property
-    def order_agg_func(self):
-        """Get the order aggregate function."""
-        if self._order_agg_func is None:
-            order_reverse = self.params.get("order_reverse")
-            self._order_agg_func = Max if order_reverse else Min
-        return self._order_agg_func
-
-    def _alias_sort_names(self, qs):
-        """Annotate sort_name."""
-        if self.order_key != "sort_name" and not (
-            qs.model is StoryArc and self.order_key == "story_arc_number"
-        ):
-            return qs
-        pks = self.kwargs.get("pks")
-        show = MappingProxyType(self.params["show"])  # type: ignore
-        # TODO too many annotations for order?
-        #   Move other annotations to card.
-        #   eager publisher for imprint of course
-        sort_name_annotations = self.get_sort_name_annotations(
-            qs.model, self.model_group, pks, show
-        )
-        if sort_name_annotations:
-            qs = qs.alias(**sort_name_annotations)
-            if qs.model is Comic:
-                self._comic_sort_names = tuple(sort_name_annotations.keys())
-        return qs
-
-    def _alias_filename(self, qs):
-        """Calculate filename from path in the db."""
-        if self.order_key != "filename":
-            return qs
-        if qs.model is Folder:
-            filename = F("name")
-        else:
-            prefix = "" if qs.model == Comic else self.rel_prefix
-            path_rel = prefix + "path"
-            filename = self.order_agg_func(
-                Right(
-                    path_rel,
-                    StrIndex(Reverse(F(path_rel)), Value(sep)) - 1,  # type: ignore
-                    output_field=CharField(),
-                )
-            )
-        return qs.alias(filename=filename)
-
-    def _alias_story_arc_number(self, qs):
-        if self.order_key != "story_arc_number":
-            return qs
-
-        # Get story_arc__pk
-        group = self.kwargs["group"]
-        pks = self.kwargs["pks"]
-        if group == STORY_ARC_GROUP and pks:
-            story_arc_pks = pks
-        else:
-            story_arc_pks = self.params.get("filters", {}).get(  # type: ignore
-                "story_arcs", ()
-            )
-
-        # If we have one annotate it.
-        if story_arc_pks:
-            rel = self.get_rel_prefix(qs.model) + "story_arc_numbers"
-            condition_rel = "pk" if qs.model is StoryArc else rel + "__story_arc"
-            condition = Q(**{f"{condition_rel}__in": story_arc_pks})
-            qs = qs.alias(
-                selected_story_arc_number=FilteredRelation(rel, condition=condition),
-            )
-            story_arc_number = self.order_agg_func("selected_story_arc_number__number")
-        else:
-            story_arc_number = NONE_INTEGERFIELD
-
-        return qs.alias(story_arc_number=story_arc_number)
-
-    def _annotate_page_count(self, qs):
-        """Hoist up total page_count of children."""
-        # Used for sorting and progress
-        if qs.model is Comic or (
-            self.order_key != "page_count"
-            and self.TARGET not in self._PAGE_COUNT_TARGETS
-        ):
-            return qs
-
-        rel = self.rel_prefix + "page_count"
-        page_count_sum = Sum(rel, distinct=True)
-        if self.TARGET == "browser":
-            qs = qs.alias(page_count=page_count_sum)
-        else:
-            qs = qs.annotate(page_count=page_count_sum)
-        return qs
-
-    def _annotate_bookmark_updated_at(self, qs):
-        if self.is_opds_acquisition or self.order_key == "bookmark_updated_at":
-            bmua_agg = self.get_max_bookmark_updated_at_aggregate(
-                qs.model, agg_func=self.order_agg_func
-            )
-            # This is used by annotate.bookmark to avoid a
-            # similar query.
-            self.bmua_is_max = self.order_agg_func is Max
-            qs = qs.annotate(bookmark_updated_at=bmua_agg)
-        # This is used by the serializer to compute mtime
-        return qs.annotate(bmua_is_max=Value(self.bmua_is_max))
-
-    def annotate_order_value(self, qs):
-        """Annotate a main key for sorting and browser card display."""
-        # Determine order func
-        if self.TARGET == "metadata":
-            return qs
-        if qs.model is Folder and self.order_key == "filename":
-            order_value = F("name")
-        elif qs.model is Comic or self.order_key in _ANNOTATED_ORDER_FIELDS:
-            # These are annotated in browser_annotaions
-            order_value = F(self.order_key)
-        else:
-            agg_func = _ORDER_AGGREGATE_FUNCS[self.order_key]
-            agg_func = self.order_agg_func if agg_func == Min else agg_func
-            field = self.rel_prefix + self.order_key
-            order_value = agg_func(field)
-
-        if self.TARGET == "browser":
-            qs = qs.annotate(order_value=order_value)
-        else:
-            qs = qs.alias(order_value=order_value)
-        return qs
-
-    def _annotate_search_scores(self, qs):
-        """Annotate Search Scores."""
-        if (
-            self.TARGET not in self._COVER_AND_CARD_TARGETS
-            or self.order_key != "search_score"
-        ):
-            return qs
-
-        # Rank is always the max of the relations, cannot aggregate?
-        # group by here fixes duplicates with story_arc, probably because it's a long relation
-        return qs.annotate(search_score=ComicFTSRank()).group_by("id")
-
-    def annotate_order_aggregates(self, qs):
-        """Annotate common aggregates between browser and metadata."""
-        qs = qs.annotate(ids=JsonGroupArray("id", distinct=True))
-        qs = self._annotate_search_scores(qs)
-        qs = self._alias_sort_names(qs)
-        qs = self._alias_filename(qs)
-        qs = self._alias_story_arc_number(qs)
-        qs = self._annotate_page_count(qs)
-        qs = self._annotate_bookmark_updated_at(qs)
-        if qs.model is not Comic:
-            # comic orders on indexed fields when it can
-            qs = self.annotate_order_value(qs)
-        return qs

codex/views/browser/filters/filter.py

@@ -1,69 +0,0 @@
-"""Browser Filters."""
-
-from django.db.models.query import QuerySet
-from django.db.models.query_utils import Q
-
-from codex.logger.logging import get_logger
-from codex.models.comic import Comic
-from codex.views.browser.filters.bookmark import BrowserFilterBookmarkView
-
-LOG = get_logger(__name__)
-
-
-class BrowserFilterView(BrowserFilterBookmarkView):
-    """Browser Filters."""
-
-    TARGET = ""
-
-    def force_inner_joins(self, qs):
-        """Force INNER JOINS to filter empty groups."""
-        demote_tables = {"codex_library"}
-        if qs.model is not Comic:
-            demote_tables.add("codex_comic")
-        if self.fts_mode:
-            # Forcing INNER JOINS required to make fts5 work
-            demote_tables.add("codex_comicfts")
-        return qs.demote_joins(demote_tables)
-
-    def _get_query_filters(
-        self,
-        model,
-        group=None,
-        pks=None,
-        page_mtime=False,
-        bookmark_filter=True,
-    ) -> Q:
-        """Return all the filters except the group filter."""
-        big_include_filter = Q()
-        big_exclude_filter = Q()
-        big_include_filter &= self.get_group_acl_filter(model, self.request.user)
-        big_include_filter &= self.get_group_filter(group, pks, page_mtime=page_mtime)
-        big_include_filter &= self.get_comic_field_filter(model)
-        if bookmark_filter:
-            big_include_filter &= self.get_bookmark_filter(model)
-        include_search_filter, exclude_search_filter, fts_q = self.get_search_filters(
-            model
-        )
-        big_include_filter &= include_search_filter
-        big_exclude_filter &= exclude_search_filter
-
-        return big_include_filter & ~big_exclude_filter & fts_q
-
-    def get_filtered_queryset(
-        self,
-        model,
-        group=None,
-        pks=None,
-        page_mtime=False,
-        bookmark_filter=True,
-    ) -> QuerySet:
-        """Get a filtered queryset for the model."""
-        query_filters = self._get_query_filters(
-            model,
-            group=group,
-            pks=pks,
-            page_mtime=page_mtime,
-            bookmark_filter=bookmark_filter,
-        )
-        # Distinct necissary for folder view with search
-        return model.objects.filter(query_filters).distinct()

codex/views/browser/group_mtime.py

@@ -1,83 +0,0 @@
-"""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

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

codex/views/browser/metadata/annotate.py

@@ -1,109 +0,0 @@
-"""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