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

codex/views/browser/browser.py

@@ -2,8 +2,10 @@
 
 from math import ceil, floor, log10
 from types import MappingProxyType
+from typing import TYPE_CHECKING
 
-from django.db.models import Max
+from django.db.models import Max, Subquery
+from django.db.models.expressions import OuterRef
 from django.db.utils import OperationalError
 from drf_spectacular.utils import extend_schema
 from rest_framework.response import Response
@@ -11,9 +13,12 @@ from rest_framework.response import Response
 from codex.logger.logging import get_logger
 from codex.models import (
     AdminFlag,
+    BrowserGroupModel,
     Comic,
     Folder,
+    Imprint,
     Library,
+    Volume,
 )
 from codex.serializers.browser.page import BrowserPageSerializer
 from codex.views.browser.title import BrowserTitleView
@@ -21,10 +26,24 @@ from codex.views.const import (
     COMIC_GROUP,
     FOLDER_GROUP,
     MAX_OBJ_PER_PAGE,
+    NONE_DATETIMEFIELD,
     STORY_ARC_GROUP,
 )
 
+if TYPE_CHECKING:
+    from django.db.models.query import QuerySet
+
+
 LOG = get_logger(__name__)
+_GROUP_INSTANCE_SELECT_RELATED: MappingProxyType[
+    type[BrowserGroupModel], tuple[str | None, ...]
+] = MappingProxyType(
+    {
+        Comic: ("series", "volume"),
+        Volume: ("series",),
+        Imprint: ("publisher",),
+    }
+)
 
 
 class BrowserView(BrowserTitleView):
@@ -40,31 +59,61 @@ class BrowserView(BrowserTitleView):
     )
     TARGET = "browser"
 
-    ########
-    # Init #
-    ########
+    def __init__(self, *args, **kwargs):
+        """Set params for the type checker."""
+        super().__init__(*args, **kwargs)
+        self.is_opds_2_acquisition = False
+        self.group_query: QuerySet = Comic.objects.none()
+        self.valid_nav_groups: tuple[str, ...] = ()
 
-    @property
-    def model_group(self):
+    def _set_group_query_and_instance(self):
+        """Create group_class instance."""
+        pks = self.kwargs.get("pks")
+        if pks and self.group_class:
+            try:
+                select_related: tuple[str | None, ...] = (
+                    _GROUP_INSTANCE_SELECT_RELATED.get(self.group_class, (None,))
+                )
+                self.group_query = self.group_class.objects.select_related(
+                    *select_related
+                ).filter(pk__in=pks)
+            except self.group_class.DoesNotExist:
+                group = self.kwargs.get("group")
+                page = self.kwargs.get("page")
+                if group == "r" and not pks and page == 1:
+                    self.group_query = self.group_class.objects.none()
+                else:
+                    reason = f"{group}__in={pks} does not exist!"
+                    settings_mask = {"breadcrumbs": []}
+                    self.raise_redirect(
+                        reason, route_mask={"group": group}, settings_mask=settings_mask
+                    )
+        elif self.group_class:
+            self.group_query = self.group_class.objects.none()
+        else:
+            self.group_query = Comic.objects.none()
+        self.group_instance = self.group_query.first()
+
+    def init_request(self):
+        """Initialize request."""
+        super().init_request()
+        self._set_group_query_and_instance()
+
+    def get_model_group(self):
         """Get the group of the models to browse."""
         # the model group shown must be:
         #   A valid nav group or 'c'
         #   the child of the current nav group or 'c'
-        if not self._model_group:
-            group = self.kwargs["group"]
-            if group == FOLDER_GROUP:
-                self._model_group = group
-            elif group == STORY_ARC_GROUP:
-                pks = self.kwargs.get("pks")
-                self._model_group = COMIC_GROUP if pks else group
-            elif group == self.valid_nav_groups[-1]:
-                # special case for lowest valid group
-                self._model_group = COMIC_GROUP
-            else:
-                self._model_group = self.valid_nav_groups[
-                    self.valid_nav_groups.index(group) + 1
-                ]
-        return self._model_group
+        group = self.kwargs["group"]
+        if group == FOLDER_GROUP:
+            return group
+        if group == STORY_ARC_GROUP:
+            pks = self.kwargs.get("pks")
+            return COMIC_GROUP if pks else group
+        if group == self.valid_nav_groups[-1]:
+            # special case for lowest valid group
+            return COMIC_GROUP
+        return self.valid_nav_groups[self.valid_nav_groups.index(group) + 1]
 
     ################
     # MAIN QUERIES #
@@ -85,8 +134,8 @@ class BrowserView(BrowserTitleView):
         """Create queryset common to group & books."""
         qs = self.get_filtered_queryset(model)
         limit = self._get_limit()
+        count_qs = self.add_group_by(qs, model)
         try:
-            count_qs = self.add_group_by(qs)
             if limit:
                 count_qs = count_qs[:limit]
             # Get count after filters and before any annotations or orders
@@ -99,19 +148,20 @@ class BrowserView(BrowserTitleView):
             qs = model.objects.none()
 
         if count:
-            qs = self.annotate_order_aggregates(qs)
-            qs = self.add_order_by(qs)
+            qs = self.annotate_order_aggregates(qs, model)
+            qs = self.add_order_by(qs, model)
             if limit:
                 qs = qs[:limit]
-        else:
-            qs = qs.order_by("pk")
 
         return qs, count
 
     def _get_group_queryset(self):
         """Create group queryset."""
-        if self.model is Comic:
-            qs = self.model.objects.none().order_by("pk")
+        if not self.model:
+            reason = "Model not set for browser queryset."
+            raise ValueError(reason)
+        if self.is_model_comic:
+            qs = self.model.objects.none()
             count = 0
         else:
             qs, count = self._get_common_queryset(self.model)
@@ -123,10 +173,28 @@ class BrowserView(BrowserTitleView):
         if self.model in (Comic, Folder):
             qs, count = self._get_common_queryset(Comic)
         else:
-            qs = Comic.objects.none().order_by("pk")
+            qs = Comic.objects.none()
             count = 0
         return qs, count
 
+    def _requery_max_bookmark_updated_at(self, group_qs):
+        """Get max updated at without bookmark filter and aware of multi-groups."""
+        if not self.is_bookmark_filtered:
+            return group_qs
+        if not self.model:
+            reason = "No model to compute max bookmark updated_at"
+            raise ValueError(reason)
+
+        qs = self.model.objects.filter(pk=OuterRef("pk"))
+
+        bm_rel, bm_filter = self.get_bookmark_rel_and_filter(self.model)
+        bm_updated_at_rel = f"{bm_rel}__updated_at"
+        max_bmua = Max(bm_updated_at_rel, default=NONE_DATETIMEFIELD, filter=bm_filter)
+
+        mbua = qs.aggregate(max=max_bmua)["max"]
+
+        return group_qs.annotate(max_bookmark_updated_at=Subquery(mbua))
+
     @staticmethod
     def _get_zero_pad(book_qs):
         """Get the zero padding for the display."""
@@ -139,16 +207,12 @@ class BrowserView(BrowserTitleView):
         return zero_pad
 
     def _get_page_mtime(self):
-        return self.get_group_mtime(self.model, page_mtime=True)
+        if not self.is_bookmark_filtered and self.group_instance:
+            # Nice optimization if we can get get it.
+            return self.group_instance.updated_at
 
-    def _debug_queries(self, group_count, book_count, group_qs, book_qs):
-        """Log query details."""
-        if group_count:
-            LOG.debug(group_qs.explain())
-            LOG.debug(group_qs.query)
-        if book_count:
-            LOG.debug(book_qs.explain())
-            LOG.debug(book_qs.query)
+        group_model = self.group_class if self.group_class else self.model
+        return self.get_group_mtime(group_model, page_mtime=True)
 
     def _get_group_and_books(self):
         """Create the main queries with filters, annotation and pagination."""
@@ -164,22 +228,22 @@ class BrowserView(BrowserTitleView):
 
         # Annotate
         if page_group_count:
-            group_qs = self.annotate_card_aggregates(group_qs)
-            group_qs = self.force_inner_joins(group_qs)
+            group_qs = self.annotate_card_aggregates(group_qs, self.model)
+            group_qs = self._requery_max_bookmark_updated_at(group_qs)
         if page_book_count:
             zero_pad = self._get_zero_pad(book_qs)
-            book_qs = self.annotate_card_aggregates(book_qs)
-            book_qs = self.force_inner_joins(book_qs)
+            book_qs = self.annotate_card_aggregates(book_qs, Comic)
         else:
             zero_pad = 1
 
-        # self._debug_queries(page_group_count, page_book_count, group_qs, book_qs)
+        # print(book_qs.explain())
+        # print(book_qs.query)
 
         total_page_count = page_group_count + page_book_count
         mtime = self._get_page_mtime()
         return group_qs, book_qs, num_pages, total_page_count, zero_pad, mtime
 
-    def get_object(self):  # type: ignore
+    def get_object(self):
         """Validate settings and get the querysets."""
         group_qs, book_qs, num_pages, total_count, zero_pad, mtime = (
             self._get_group_and_books()
@@ -191,6 +255,7 @@ class BrowserView(BrowserTitleView):
         # needs to happen after pagination
         # runs obj list query twice :/
         libraries_exist = Library.objects.filter(covers_only=False).exists()
+
         # construct final data structure
         return MappingProxyType(
             {
@@ -213,6 +278,7 @@ class BrowserView(BrowserTitleView):
     @extend_schema(parameters=[BrowserTitleView.input_serializer_class])
     def get(self, *_args, **_kwargs):
         """Get browser settings."""
+        self.init_request()
         data = self.get_object()
         serializer = self.get_serializer(data)
         return Response(serializer.data)

codex/views/browser/choices.py

@@ -1,14 +1,12 @@
 """View for marking comics read and unread."""
 
 from types import MappingProxyType
-from typing import Any
 
 from caseconverter import snakecase
 from django.db.models import QuerySet
 from drf_spectacular.utils import extend_schema
 from rest_framework.response import Response
 
-from codex.choices import DUMMY_NULL_NAME, VUETIFY_NULL_CODE
 from codex.logger.logging import get_logger
 from codex.models import (
     Comic,
@@ -23,26 +21,24 @@ from codex.serializers.browser.filters import (
     BrowserFilterChoicesSerializer,
 )
 from codex.serializers.browser.settings import BrowserFilterChoicesInputSerilalizer
-from codex.views.browser.filters.filter import BrowserFilterView
-from codex.views.session import (
-    CONTRIBUTOR_PERSON_UI_FIELD,
-    IDENTIFIER_TYPE_UI_FIELD,
-    STORY_ARC_UI_FIELD,
+from codex.serializers.choices import DUMMY_NULL_NAME, VUETIFY_NULL_CODE
+from codex.views.browser.filters.annotations import (
+    BrowserAnnotationsFilterView,
 )
 
 LOG = get_logger(__name__)
 
 _FIELD_TO_REL_MODEL_MAP = MappingProxyType(
     {
-        CONTRIBUTOR_PERSON_UI_FIELD: (
+        BrowserAnnotationsFilterView.CONTRIBUTOR_PERSON_UI_FIELD: (
             "contributors__person",
             ContributorPerson,
         ),
-        STORY_ARC_UI_FIELD: (
+        BrowserAnnotationsFilterView.STORY_ARC_UI_FIELD: (
             "story_arc_numbers__story_arc",
             StoryArc,
         ),
-        IDENTIFIER_TYPE_UI_FIELD: (
+        BrowserAnnotationsFilterView.IDENTIFIER_TYPE_UI_FIELD: (
             "identifiers__identifier_type",
             IdentifierType,
         ),
@@ -58,12 +54,18 @@ _BACK_REL_MAP = MappingProxyType(
 _NULL_NAMED_ROW = MappingProxyType({"pk": VUETIFY_NULL_CODE, "name": DUMMY_NULL_NAME})
 
 
-class BrowserChoicesViewBase(BrowserFilterView):
+class BrowserChoicesViewBase(BrowserAnnotationsFilterView):
     """Get choices for filter dialog."""
 
     input_serializer_class = BrowserFilterChoicesInputSerilalizer
     TARGET = "choices"
 
+    def init_request(self):
+        """Initialieze request."""
+        self.parse_params()
+        self.set_model()
+        self.set_rel_prefix()
+
     @staticmethod
     def get_field_choices_query(comic_qs, field_name):
         """Get distinct values for the field."""
@@ -98,13 +100,14 @@ class BrowserChoicesViewBase(BrowserFilterView):
 
         return rel, model
 
-    def get_object(self) -> QuerySet:  # type: ignore
+    def get_object(self):
         """Get the comic subquery use for the choices."""
         return self.get_filtered_queryset(Comic)
 
     @extend_schema(parameters=[input_serializer_class])
     def get(self, *_args, **_kwargs):
         """Return choices."""
+        self.init_request()
         obj = self.get_object()
         serializer = self.get_serializer(obj)
         return Response(serializer.data)
@@ -136,13 +139,13 @@ class BrowserChoicesAvailableView(BrowserChoicesViewBase):
 
         return count
 
-    def get_object(self) -> dict[str, Any]:  # type: ignore
+    def get_object(self):
         """Get choice counts."""
         qs = super().get_object()
         filters = self.params.get("filters", {})
         data = {}
         for field_name in self.serializer_class().get_fields():  # type: ignore
-            if field_name == "story_arcs" and qs.model is StoryArc:
+            if field_name == "story_arcs" and self.model == StoryArc:
                 # don't allow filtering on story arc in story arc view.
                 continue
             rel, m2m_model = self.get_rel_and_model(field_name)
@@ -185,7 +188,7 @@ class BrowserChoicesView(BrowserChoicesViewBase):
         field_name = self.kwargs.get("field_name", "")
         return snakecase(field_name)
 
-    def get_object(self) -> dict[str, Any]:  # type: ignore
+    def get_object(self):
         """Return choices with more than one choice."""
         qs = super().get_object()
         field_name = self._get_field_name()

codex/views/browser/cover.py

@@ -7,7 +7,7 @@ from drf_spectacular.types import OpenApiTypes
 from drf_spectacular.utils import extend_schema
 from rest_framework.renderers import BaseRenderer
 
-from codex.librarian.covers.create import CoverCreateThread
+from codex.librarian.covers.create import CoverCreateMixin
 from codex.librarian.covers.path import CoverPathMixin
 from codex.librarian.mp_queue import LIBRARIAN_QUEUE
 from codex.logger.logging import get_logger
@@ -15,7 +15,7 @@ from codex.models import Comic, Volume
 from codex.models.groups import Folder
 from codex.models.paths import CustomCover
 from codex.serializers.browser.settings import BrowserCoverInputSerializer
-from codex.views.browser.annotate.order import BrowserAnnotateOrderView
+from codex.views.browser.annotations import BrowserAnnotationsView
 from codex.views.const import (
     CUSTOM_COVER_GROUP_RELATION,
     GROUP_RELATION,
@@ -41,7 +41,7 @@ class WEBPRenderer(BaseRenderer):
         return data
 
 
-class CoverView(BrowserAnnotateOrderView):
+class CoverView(BrowserAnnotationsView):
     """ComicCover View."""
 
     input_serializer_class = BrowserCoverInputSerializer
@@ -49,7 +49,7 @@ class CoverView(BrowserAnnotateOrderView):
     content_type = "image/webp"
     TARGET = "cover"
     REPARSE_JSON_FIELDS = frozenset(
-        BrowserAnnotateOrderView.REPARSE_JSON_FIELDS | {"parent"}
+        BrowserAnnotationsView.REPARSE_JSON_FIELDS | {"parent"}
     )
 
     def get_group_filter(self, group=None, pks=None, page_mtime=False):
@@ -71,13 +71,22 @@ class CoverView(BrowserAnnotateOrderView):
             group_filter[f"{parent_rel}__pk__in"] = parent_pks
         return Q(**group_filter)
 
+    def get_model_group(self):
+        """Return the url group."""
+        return self.kwargs["group"]
+
+    def init_request(self):
+        """Initialize request."""
+        self.parse_params()
+        self.set_model()
+
     def _get_comic_cover(self):
         pks = self.kwargs["pks"]
         return pks[0], False
 
     def _get_custom_cover(self):
         """Get Custom Cover."""
-        if self.model is Volume or not self.params.get("custom_covers"):
+        if self.model == Volume or not self.params.get("custom_covers"):
             return None
         group = self.kwargs["group"]
         group_rel = CUSTOM_COVER_GROUP_RELATION[group]
@@ -90,8 +99,8 @@ class CoverView(BrowserAnnotateOrderView):
     def _get_dynamic_cover(self):
         """Get dynamic cover."""
         comic_qs = self.get_filtered_queryset(Comic)
-        comic_qs = self.annotate_order_aggregates(comic_qs)
-        comic_qs = self.add_order_by(comic_qs)
+        comic_qs = self.annotate_order_aggregates(comic_qs, Comic)
+        comic_qs = self.add_order_by(comic_qs, Comic)
         comic_qs = comic_qs.only("pk")
         comic = comic_qs.first()
         cover_pk = comic.pk if comic else 0
@@ -99,7 +108,7 @@ class CoverView(BrowserAnnotateOrderView):
 
     def _get_cover_pk(self) -> tuple[int, bool]:
         """Get Cover Pk queryset for comic queryset."""
-        if self.model is Comic:
+        if self.model == Comic:
             cover_pk, custom = self._get_comic_cover()
         elif custom_cover := self._get_custom_cover():
             cover_pk = custom_cover.pk
@@ -127,7 +136,7 @@ class CoverView(BrowserAnnotateOrderView):
 
         cover_path = CoverPathMixin.get_cover_path(pk, custom)
         if not cover_path.exists():
-            thumb_buffer = CoverCreateThread.create_cover_from_path(
+            thumb_buffer = CoverCreateMixin.create_cover_from_path(
                 pk, cover_path, LOG, LIBRARIAN_QUEUE, custom
             )
             if not thumb_buffer:
@@ -139,12 +148,13 @@ class CoverView(BrowserAnnotateOrderView):
         return cover_file, content_type
 
     @extend_schema(
-        parameters=[BrowserAnnotateOrderView.input_serializer_class],
+        parameters=[BrowserAnnotationsView.input_serializer_class],
         responses={(200, content_type): OpenApiTypes.BINARY},
     )
     def get(self, *args, **kwargs):  # type: ignore
         """Get comic cover."""
         try:
+            self.init_request()
             try:
                 pk, custom = self._get_cover_pk()
             except OperationalError as exc:

codex/views/browser/filters/annotations.py

@@ -0,0 +1,125 @@
+"""Annotations used by a filter."""
+
+from logging import DEBUG, WARNING
+
+from django.db.models.aggregates import Count, Max
+from django.db.models.functions import Coalesce, Greatest
+from django.db.utils import OperationalError
+
+from codex.logger.logging import get_logger
+from codex.models.comic import Comic
+from codex.views.browser.filters.bookmark import BookmarkFilterMixin
+from codex.views.browser.validate import BrowserValidateView
+from codex.views.const import (
+    EPOCH_START_DATETIMEFIELD,
+    ONE_INTEGERFIELD,
+)
+
+_CHILD_COUNT = "child_count"
+_FTS5_PREFIX = "fts5: "
+LOG = get_logger(__name__)
+
+
+class BrowserAnnotationsFilterView(BrowserValidateView, BookmarkFilterMixin):
+    """Annotations that also filter."""
+
+    TARGET = ""
+
+    def __init__(self, *args, **kwargs) -> None:
+        """Initialize."""
+        super().__init__(*args, **kwargs)
+        self.init_bookmark_data()
+
+    def _get_query_filters(  # noqa: PLR0913
+        self, model, group, pks, bookmark_filter, page_mtime=False, group_filter=True
+    ):
+        """Return all the filters except the group filter."""
+        # XXX all these ifs and flags are awful
+        object_filter = self.get_group_acl_filter(model)
+        if group_filter:
+            object_filter &= self.get_group_filter(group, pks, page_mtime=page_mtime)
+        object_filter &= self.get_comic_field_filter(model)
+        if bookmark_filter:
+            # not needed when used by outerrefl OuterRef is applied next
+            object_filter &= self.get_bookmark_filter(model)
+        return object_filter
+
+    def _filter_by_child_count(self, qs, model):
+        """Filter group by child count."""
+        rel = self.rel_prefix + "pk"
+        count_func = ONE_INTEGERFIELD if model == Comic else Count(rel, distinct=True)
+        ann = {_CHILD_COUNT: count_func}
+        if self.TARGET == "opds2":
+            if model != Comic:
+                qs = qs.alias(**ann)
+        else:
+            qs = qs.annotate(**ann)
+        if model != Comic:
+            qs = qs.filter(**{f"{_CHILD_COUNT}__gt": 0})
+        return qs
+
+    def get_filtered_queryset(  # noqa: PLR0913
+        self,
+        model,
+        group=None,
+        pks=None,
+        bookmark_filter=True,
+        page_mtime=False,
+        group_filter=True,
+    ):
+        """Get a filtered queryset for the model."""
+        object_filter = self._get_query_filters(
+            model,
+            group,
+            pks,
+            bookmark_filter,
+            page_mtime=page_mtime,
+            group_filter=group_filter,
+        )
+        qs = model.objects.filter(object_filter)
+        qs = self.apply_search_filter(qs, model)
+        return self._filter_by_child_count(qs, model)
+
+    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_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,
+            bookmark_filter=self.is_bookmark_filtered,
+            page_mtime=page_mtime,
+        )
+        qs = qs.annotate(max_updated_at=Max("updated_at"))
+
+        if self.is_bookmark_filtered:
+            bm_rel, bm_filter = self.get_bookmark_rel_and_filter(model)
+            qs = qs.filter(bm_filter)
+            ua_rel = bm_rel + "__updated_at"
+            mbua = Max(ua_rel)
+        else:
+            mbua = EPOCH_START_DATETIMEFIELD
+        qs = qs.annotate(max_bookmark_updated_at=mbua)
+
+        try:
+            mtime = qs.aggregate(
+                max=Greatest(
+                    Coalesce("max_bookmark_updated_at", EPOCH_START_DATETIMEFIELD),
+                    "max_updated_at",
+                )
+            )["max"]
+        except OperationalError as exc:
+            self._handle_operational_error(exc)
+            mtime = None
+        if mtime == NotImplemented:
+            mtime = None
+        return mtime

codex/views/browser/filters/bookmark.py

@@ -4,45 +4,46 @@ from typing import TYPE_CHECKING
 
 from django.db.models import Q
 
-from codex.views.browser.validate import BrowserValidateView
-
 if TYPE_CHECKING:
     from codex.models import BrowserGroupModel
 
 
-class BrowserFilterBookmarkView(BrowserValidateView):
+class BookmarkFilterMixin:
     """BookmarkFilter view methods."""
 
-    def __init__(self, *args, **kwargs):
+    def init_bookmark_data(self):
         """Initialize the bm_annotation_data."""
-        super().__init__(*args, **kwargs)
-        self._bm_rels: dict[BrowserGroupModel, str] = {}
-        self._bm_filters: dict[BrowserGroupModel, Q] = {}
+        self._bm_annotation_data: dict[BrowserGroupModel, tuple[str, Q]] = {}
 
     def _get_bm_rel(self, model):
         """Create bookmark relation."""
-        if model not in self._bm_rels:
-            rel_prefix = self.get_rel_prefix(model)  # type: ignore
-            self._bm_rels[model] = rel_prefix + "bookmark"
-        return self._bm_rels[model]
+        rel_prefix = self.get_rel_prefix(model)  # type: ignore
+        return rel_prefix + "bookmark"
 
     def _get_my_bookmark_filter(self, bm_rel):
         """Get a filter for my session or user defined bookmarks."""
-        if self.request.user and self.request.user.is_authenticated:
-            key = f"{bm_rel}__user"
-            value = self.request.user
+        if self.request.user.is_authenticated:  # type: ignore
+            my_bookmarks_kwargs = {f"{bm_rel}__user": self.request.user}  # type: ignore
         else:
             key = f"{bm_rel}__session__session_key"
-            value = self.request.session.session_key
-        my_bookmarks_kwargs = {key: value}
+            my_bookmarks_kwargs = {
+                key: self.request.session.session_key  # type: ignore
+            }
         return Q(**my_bookmarks_kwargs)
 
+    def get_bookmark_rel_and_filter(self, model):
+        """Get the bookmark rel and filter once."""
+        if model not in self._bm_annotation_data:
+            bm_rel = self._get_bm_rel(model)
+            bm_filter = self._get_my_bookmark_filter(bm_rel)
+            self._bm_annotation_data[model] = (bm_rel, bm_filter)
+        return self._bm_annotation_data[model]
+
     def get_bookmark_filter(self, model):
         """Build bookmark query."""
         choice: str = self.params.get("filters", {}).get("bookmark", "")  # type: ignore
         if choice:
-            bm_rel = self._get_bm_rel(model)
-            my_bookmark_filter = self._get_my_bookmark_filter(bm_rel)
+            bm_rel, my_bookmark_filter = self.get_bookmark_rel_and_filter(model)
             if choice == "READ":
                 bookmark_filter = my_bookmark_filter & Q(
                     **{f"{bm_rel}__finished": True}

codex/views/browser/filters/field.py

@@ -5,17 +5,12 @@ from types import MappingProxyType
 from django.db.models import Q
 
 from codex.views.browser.filters.group import GroupFilterView
-from codex.views.session import (
-    CONTRIBUTOR_PERSON_UI_FIELD,
-    IDENTIFIER_TYPE_UI_FIELD,
-    STORY_ARC_UI_FIELD,
-)
 
 _FILTER_REL_MAP = MappingProxyType(
     {
-        CONTRIBUTOR_PERSON_UI_FIELD: "contributors__person",
-        STORY_ARC_UI_FIELD: "story_arc_numbers__story_arc",
-        IDENTIFIER_TYPE_UI_FIELD: "identifiers__identifier_type",
+        GroupFilterView.CONTRIBUTOR_PERSON_UI_FIELD: "contributors__person",
+        GroupFilterView.STORY_ARC_UI_FIELD: "story_arc_numbers__story_arc",
+        GroupFilterView.IDENTIFIER_TYPE_UI_FIELD: "identifiers__identifier_type",
     }
 )