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

codex/views/opds/v1/facets.py

@@ -2,13 +2,14 @@
 
 from dataclasses import dataclass
 from types import MappingProxyType
+from typing import Any
 
 from django.urls import reverse
 
 from codex.models import AdminFlag
 from codex.views.browser.browser import BrowserView
-from codex.views.opds.const import MimeType, Rel
-from codex.views.opds.util import update_href_query_params
+from codex.views.opds.const import MimeType, Rel, UserAgentNames
+from codex.views.opds.util import get_user_agent_name, update_href_query_params
 from codex.views.opds.v1.data import OPDS1Link
 from codex.views.opds.v1.entry.data import OPDS1EntryData, OPDS1EntryObject
 from codex.views.opds.v1.entry.entry import OPDS1Entry
@@ -81,13 +82,61 @@ DEFAULT_FACETS = {
 class OPDS1FacetsView(BrowserView):
     """OPDS 1 Facets methods."""
 
-    OPDS = 1
-    # Overwritten by get_object()
-    use_facets = False
-    skip_order_facets = False
-    acquisition_groups = frozenset()
-    mime_type_map = MimeType.FILE_TYPE_MAP
-    obj = MappingProxyType({})
+    def __init__(self, *args, **kwargs):
+        """Initialize properties."""
+        super().__init__(*args, **kwargs)
+        self._user_agent_name: str | None = None
+        self._mime_type_map: MappingProxyType[str, str] | None = None
+        self._use_facets: bool | None = None
+        self._obj: MappingProxyType[str, Any] | None = None
+
+    @property
+    def user_agent_name(self) -> str:
+        """Memoize user agent name."""
+        if self._user_agent_name is None:
+            self._user_agent_name = get_user_agent_name(self.request)
+        return self._user_agent_name
+
+    @property
+    def mime_type_map(self) -> MappingProxyType[str, str]:
+        """Memoize mime type map."""
+        if self._mime_type_map is None:
+            self._mime_type_map = (
+                MimeType.SIMPLE_FILE_TYPE_MAP
+                if self.user_agent_name in UserAgentNames.SIMPLE_DOWNLOAD_MIME_TYPES
+                else MimeType.FILE_TYPE_MAP
+            )
+        return self._mime_type_map
+
+    @property
+    def use_facets(self) -> bool:
+        """Memoize use_facets."""
+        if self._use_facets is None:
+            self._use_facets = self.user_agent_name in UserAgentNames.FACET_SUPPORT
+        return self._use_facets
+
+    @property
+    def obj(self) -> MappingProxyType[str, Any]:
+        """Get the browser page and serialize it for this subclass."""
+        if self._obj is None:
+            group_qs, book_qs, num_pages, total_count, zero_pad, mtime = (
+                self._get_group_and_books()
+            )
+            book_qs = book_qs.select_related("series", "volume", "language")
+
+            title = self.get_browser_page_title()
+            self._obj = MappingProxyType(
+                {
+                    "title": title,
+                    "groups": group_qs,
+                    "books": book_qs,
+                    "zero_pad": zero_pad,
+                    "num_pages": num_pages,
+                    "total_count": total_count,
+                    "mtime": mtime,
+                }
+            )
+        return self._obj
 
     def _facet(self, kwargs, facet_group, facet_title, new_query_params):
         kwargs = pop_name(kwargs)
@@ -120,9 +169,9 @@ class OPDS1FacetsView(BrowserView):
         )
         qps = {**self.request.GET}
         qps.update(query_params)
-        zero_pad = self.obj["zero_pad"]
+        zero_pad: int = self.obj["zero_pad"]  # type: ignore
         data = OPDS1EntryData(
-            self.acquisition_groups, zero_pad, False, self.mime_type_map
+            self.opds_acquisition_groups, zero_pad, False, self.mime_type_map
         )
         return OPDS1Entry(entry_obj, qps, data)
 
@@ -185,7 +234,11 @@ class OPDS1FacetsView(BrowserView):
     def facets(self, entries=False, root=True):
         """Return facets."""
         facets = []
-        if not self.skip_order_facets:
+        group = self.kwargs.get("group")
+        add_order_facets = (
+            group != "c" and self.user_agent_name not in UserAgentNames.CLIENT_REORDERS
+        )
+        if not add_order_facets:
             facets += self._facet_group(FacetGroups.ORDER_BY, entries)
             facets += self._facet_group(FacetGroups.ORDER_REVERSE, entries)
         if root:

codex/views/opds/v1/feed.py

@@ -1,6 +1,5 @@
 """OPDS v1 feed."""
 
-from types import MappingProxyType
 from typing import TYPE_CHECKING, Any
 
 from drf_spectacular.utils import extend_schema
@@ -14,10 +13,10 @@ from codex.serializers.browser.settings import OPDSSettingsSerializer
 from codex.serializers.opds.v1 import (
     OPDS1TemplateSerializer,
 )
-from codex.views.const import FALSY, MAX_OBJ_PER_PAGE
+from codex.settings.settings import FALSY
+from codex.views.const import MAX_OBJ_PER_PAGE
 from codex.views.opds.auth import OPDSTemplateView
-from codex.views.opds.const import BLANK_TITLE, MimeType, UserAgentNames
-from codex.views.opds.util import get_user_agent_name
+from codex.views.opds.const import BLANK_TITLE
 from codex.views.opds.v1.entry.data import OPDS1EntryData
 from codex.views.opds.v1.entry.entry import OPDS1Entry
 from codex.views.opds.v1.links import (
@@ -54,14 +53,14 @@ class OPDS1FeedView(OPDS1LinksView, OPDSTemplateView):
     def opds_ns(self):
         """Dynamic opds namespace."""
         try:
-            return OpdsNs.ACQUISITION if self.is_aq_feed else OpdsNs.CATALOG
+            return OpdsNs.ACQUISITION if self.is_opds_acquisition else OpdsNs.CATALOG
         except Exception:
             LOG.exception("Getting OPDS v1 namespace")
 
     @property
     def is_acquisition(self):
         """Is acquisition."""
-        return self.is_aq_feed
+        return self.is_opds_acquisition
 
     @property
     def id_tag(self):
@@ -127,7 +126,7 @@ class OPDS1FeedView(OPDS1LinksView, OPDSTemplateView):
         if objs := self.obj.get(key):
             zero_pad: int = self.obj["zero_pad"]  # type: ignore
             data = OPDS1EntryData(
-                self.acquisition_groups, zero_pad, metadata, self.mime_type_map
+                self.opds_acquisition_groups, zero_pad, metadata, self.mime_type_map
             )
             fallback = bool(self.admin_flags.get("folder_view"))
             import_pks = set()
@@ -165,65 +164,8 @@ class OPDS1FeedView(OPDS1LinksView, OPDSTemplateView):
             LOG.exception("Getting OPDS v1 entries")
         return entries
 
-    def get_object(self):  # type: ignore
-        """Get the browser page and serialize it for this subclass."""
-        group_qs, book_qs, num_pages, total_count, zero_pad, mtime = (
-            super()._get_group_and_books()
-        )
-        book_qs = book_qs.select_related("series", "volume", "language")
-
-        title = self.get_browser_page_title()
-        self.obj = MappingProxyType(
-            {
-                "title": title,
-                "groups": group_qs,
-                "books": book_qs,
-                "zero_pad": zero_pad,
-                "num_pages": num_pages,
-                "total_count": total_count,
-                "mtime": mtime,
-            }
-        )
-
-        self.is_aq_feed = self.model_group in ("c", "f")
-
-        # Do not return a Mapping despite the type. Return self for the serializer.
-        return self
-
-    def _set_user_agent_variables(self):
-        """Set User Agent variables."""
-        user_agent_name = get_user_agent_name(self.request)
-
-        self.user_facets = user_agent_name in UserAgentNames.FACET_SUPPORT
-        self.skip_order_facets = user_agent_name in UserAgentNames.CLIENT_REORDERS
-        if user_agent_name in UserAgentNames.SIMPLE_DOWNLOAD_MIME_TYPES:
-            self.mime_type_map = MimeType.SIMPLE_FILE_TYPE_MAP
-
-    def set_opds_request_type(self):
-        """Set the opds request type variables."""
-        group = self.kwargs.get("group")
-        if group == "a":
-            self.acquisition_groups = frozenset({"a", "c"})
-            pks = self.kwargs["pks"]
-            self.is_opds_1_acquisition = group in self.acquisition_groups and pks
-        else:
-            self.acquisition_groups = frozenset({*self.valid_nav_groups[-2:]} | {"c"})
-            self.is_opds_1_acquisition = group in self.acquisition_groups
-        self.is_opds_metadata = (
-            self.request.GET.get("opdsMetadata", "").lower() not in FALSY
-        )
-
-    def init_request(self):
-        """Initialize request."""
-        super().init_request()
-        self.set_opds_request_type()
-        self._set_user_agent_variables()
-        self.skip_order_facets |= self.kwargs.get("group") == "c"
-
     @extend_schema(parameters=[input_serializer_class])
     def get(self, *_args, **_kwargs):
         """Get the feed."""
-        self.init_request()
-        obj = self.get_object()
-        serializer = self.get_serializer(obj)
+        serializer = self.get_serializer(self)
         return Response(serializer.data, content_type=self.content_type)

codex/views/opds/v1/links.py

@@ -112,7 +112,6 @@ class OPDS1LinksView(OPDS1FacetsView):
             "name": "opds:v1:feed",
         }
     )
-    is_aq_feed = False
 
     def is_top_link_displayed(self, top_link):
         """Determine if this top link should be displayed."""
@@ -160,7 +159,9 @@ class OPDS1LinksView(OPDS1FacetsView):
         """Create all the links."""
         links = []
         try:
-            mime_type = MimeType.ACQUISITION if self.is_aq_feed else MimeType.NAV
+            mime_type = (
+                MimeType.ACQUISITION if self.is_opds_acquisition else MimeType.NAV
+            )
             links += [
                 OPDS1Link("self", self.request.get_full_path(), mime_type),
                 OPDS1Link(
@@ -193,9 +194,9 @@ class OPDS1LinksView(OPDS1FacetsView):
             name=name,
             summary=top_link.desc,
         )
-        zero_pad = self.obj["zero_pad"]
+        zero_pad: int = self.obj["zero_pad"]  # type: ignore
         data = OPDS1EntryData(
-            self.acquisition_groups, zero_pad, False, self.mime_type_map
+            self.opds_acquisition_groups, zero_pad, False, self.mime_type_map
         )
         return OPDS1Entry(entry_obj, top_link.query_params, data)
 

codex/views/opds/v2/feed.py

@@ -9,7 +9,7 @@ from codex.logger.logging import get_logger
 from codex.models import AdminFlag
 from codex.serializers.browser.settings import OPDSSettingsSerializer
 from codex.serializers.opds.v2 import OPDS2FeedSerializer
-from codex.views.const import FALSY, MAX_OBJ_PER_PAGE
+from codex.views.const import MAX_OBJ_PER_PAGE
 from codex.views.opds.auth import OPDSAuthMixin
 from codex.views.opds.const import BLANK_TITLE
 from codex.views.opds.v2.const import (
@@ -176,16 +176,10 @@ class OPDS2FeedView(OPDSAuthMixin, OPDS2PublicationView):
 
     def get_object(self):
         """Get the browser page and serialize it for this subclass."""
-        group_qs, book_qs, num_pages, total_count, zero_pad, mtime = (
-            self._get_group_and_books()
-        )
+        group_qs, book_qs, _, total_count, zero_pad, mtime = self.group_and_books
         title = self.get_browser_page_title()
         # convert browser_page into opds page
 
-        # instance vars
-        self.is_aq_feed = self.model_group in ("c", "f")
-        self.num_pages = num_pages
-
         # opds page
         title = self._title(title)
         number_of_items = total_count
@@ -214,31 +208,11 @@ class OPDS2FeedView(OPDSAuthMixin, OPDS2PublicationView):
             }
         )
 
-    def set_opds_request_type(self):
-        """Set opds request type variables."""
-        group = self.kwargs.get("group")
-        if group in {"f", "a"}:
-            pks = self.kwargs["pks"]
-            self.is_opds_2_acquisition = bool(pks)
-        else:
-            acquisition_groups = frozenset(self.valid_nav_groups[-2:])
-            self.is_opds_2_acquisition = group in acquisition_groups
-        self.is_opds_metadata = (
-            self.request.GET.get("opdsMetadata", "").lower() not in FALSY
-        )
-
-    def init_request(self):
-        """Initialize request."""
-        super().init_request()
-        self.set_opds_request_type()
-        # self._detect_user_agent()
-
     @extend_schema(
         parameters=[input_serializer_class],
     )
     def get(self, *_args, **_kwargs):
         """Get the feed."""
-        self.init_request()
         obj = self.get_object()
         serializer = self.get_serializer(obj)
         return Response(serializer.data)

codex/views/opds/v2/links.py

@@ -2,12 +2,14 @@
 
 from copy import deepcopy
 from dataclasses import dataclass
+from datetime import datetime
 from urllib.parse import parse_qsl, urlparse
 
+from django.db.models import QuerySet
 from django.urls import reverse
 
+from codex.settings.settings import FALSY
 from codex.views.browser.browser import BrowserView
-from codex.views.const import FALSY
 from codex.views.opds.const import MimeType, Rel
 from codex.views.opds.util import update_href_query_params
 from codex.views.util import pop_name
@@ -43,7 +45,30 @@ class LinkData:
 class OPDS2LinksView(BrowserView):
     """Links methods for OPDS 2.0 Feed."""
 
-    num_pages = 0  # For pyright. Overwritten every run.
+    def __init__(self, *args, **kwargs):
+        """Initialize properties."""
+        super().__init__(*args, **kwargs)
+        self._num_pages: int | None = None
+        self._group_and_books: (
+            tuple[QuerySet, QuerySet, int, int, int | None, datetime | None] | None
+        ) = None
+
+    @property
+    def group_and_books(
+        self,
+    ) -> tuple[QuerySet, QuerySet, int, int, int | None, datetime | None]:
+        """Memoize Group And Books for num_pages."""
+        # group_qs, book_qs, num_pages, total_count, zero_pad, mtime
+        if self._group_and_books is None:
+            self._group_and_books = self._get_group_and_books()
+        return self._group_and_books
+
+    @property
+    def num_pages(self) -> int:
+        """Memoize num_pages."""
+        if self._num_pages is None:
+            self._num_pages = self.group_and_books[2]
+        return self._num_pages
 
     def _href_page_validate(self, kwargs, data):
         """Validate the page bounds."""

codex/views/opds/v2/publications.py

@@ -5,8 +5,9 @@ from math import floor
 from types import MappingProxyType
 from urllib.parse import quote_plus
 
-from codex.librarian.covers.create import CoverCreateMixin
+from codex.librarian.covers.create import THUMBNAIL_HEIGHT, THUMBNAIL_WIDTH
 from codex.models import Comic
+from codex.settings.settings import FALSY
 from codex.views.opds.const import AUTHOR_ROLES, MimeType, Rel
 from codex.views.opds.util import get_contributors, get_m2m_objects
 from codex.views.opds.v2.top_links import HrefData, LinkData, OPDS2TopLinksView
@@ -30,8 +31,6 @@ _CONTRIBUTOR_ROLES = frozenset({x for s in _MD_CONTRIBUTOR_MAP.values() for x in
 class OPDS2PublicationView(OPDS2TopLinksView):
     """Publication Methods for OPDS 2.0 feed."""
 
-    is_opds_metadata = False
-
     def _images(self, obj):
         # Images
         kwargs = {"group": obj.group, "pks": obj.ids}
@@ -46,8 +45,8 @@ class OPDS2PublicationView(OPDS2TopLinksView):
             Rel.THUMBNAIL,
             href_data,
             mime_type=MimeType.WEBP,
-            height=CoverCreateMixin.THUMBNAIL_HEIGHT,
-            width=CoverCreateMixin.THUMBNAIL_WIDTH,
+            height=THUMBNAIL_HEIGHT,
+            width=THUMBNAIL_WIDTH,
         )
 
         cover_link = self.link(link_data)
@@ -115,7 +114,7 @@ class OPDS2PublicationView(OPDS2TopLinksView):
             "title": title,
         }
         self._publication_optional_metadata(md, obj)
-        if self.is_opds_metadata:
+        if self.request.GET.get("opdsMetadata", "").lower() not in FALSY:
             self._publication_extended_metadata(md, obj)
         return md
 

codex/views/opds/v2/top_links.py

@@ -26,10 +26,7 @@ class OPDS2TopLinksView(OPDS2LinksView):
         link_data = LinkData(Rel.SEARCH, href_data, template="{?query}")
         return self.link(link_data)
 
-    def __init__(self, *args, **kwargs):
-        """Initialize static links."""
-        super().__init__(*args, **kwargs)
-
+    def _get_static_links(self):
         start_href_data = HrefData(
             {}, url_name="opds:v2:start", absolute_query_params=True
         )
@@ -46,7 +43,7 @@ class OPDS2TopLinksView(OPDS2LinksView):
             mime_type=MimeType.HTML,
         )
 
-        self._static_links = (
+        return (
             self._link_auth(),
             self._link_search(),
             self.link(start_link_data),
@@ -73,7 +70,7 @@ class OPDS2TopLinksView(OPDS2LinksView):
         up_link_data = LinkData(Rel.UP, up_href_data)
         links_data = [
             self.link_self(),
-            *self._static_links,
+            *self._get_static_links(),
             self._link_page("first", 1),
             self._link_page("previous", page - 1),
             self._link_page("next", page + 1),

codex/views/public.py

@@ -3,10 +3,10 @@
 from rest_framework.generics import GenericAPIView
 from rest_framework.mixins import RetrieveModelMixin
 
+from codex.choices import ADMIN_FLAG_CHOICES
 from codex.logger.logging import get_logger
 from codex.models import AdminFlag
 from codex.serializers.auth import AuthAdminFlagsSerializer
-from codex.serializers.choices import CHOICES
 
 LOG = get_logger(__name__)
 _ADMIN_FLAG_KEYS = frozenset(
@@ -27,7 +27,7 @@ class AdminFlagsView(GenericAPIView, RetrieveModelMixin):
         """Get admin flags."""
         flags = {}
         for obj in self.get_queryset():  # type: ignore
-            name = CHOICES["admin"]["adminFlags"][obj.key].lower().replace(" ", "_")
+            name = ADMIN_FLAG_CHOICES[obj.key].lower().replace(" ", "_")
             flags[name] = obj.on
         return flags
 

codex/views/reader/arcs.py

@@ -1,7 +1,5 @@
 """Reader get Arcs methods."""
 
-from types import MappingProxyType
-
 from codex.models import AdminFlag
 from codex.util import max_none
 from codex.views.const import (
@@ -17,7 +15,6 @@ class ReaderArcsView(ReaderBooksView):
     def __init__(self, *args, **kwargs):
         """Initialize instance vars."""
         super().__init__(*args, **kwargs)
-        self.params: MappingProxyType = MappingProxyType({})
 
     def _get_group_arc(self, book, attr, browser_arc_group, arcs, max_mtime):
         """Append the volume arc."""

codex/views/reader/books.py

@@ -3,9 +3,10 @@
 from typing import TYPE_CHECKING
 
 from django.db.models import F
+from django.db.models.query import Q
 
 from codex.models import Bookmark, Comic
-from codex.views.bookmark import BookmarkFilterBaseView
+from codex.views.bookmark import BookmarkBaseView
 from codex.views.browser.filters.field import ComicFieldFilterView
 from codex.views.const import (
     FOLDER_GROUP,
@@ -14,8 +15,8 @@ from codex.views.const import (
     NONE_INTEGERFIELD,
     STORY_ARC_GROUP,
 )
-from codex.views.mixins import SharedAnnotationsMixin
-from codex.views.reader.init import ReaderInitView
+from codex.views.mixins import BookmarkSearchMixin, SharedAnnotationsMixin
+from codex.views.reader.params import ReaderParamsView
 
 if TYPE_CHECKING:
     from collections.abc import Mapping
@@ -33,7 +34,9 @@ _COMIC_FIELDS = (
 )
 
 
-class ReaderBooksView(BookmarkFilterBaseView, ReaderInitView, SharedAnnotationsMixin):
+class ReaderBooksView(
+    BookmarkBaseView, ReaderParamsView, SharedAnnotationsMixin, BookmarkSearchMixin
+):
     """Get Books methods."""
 
     def _get_reader_arc_pks(
@@ -62,6 +65,36 @@ class ReaderBooksView(BookmarkFilterBaseView, ReaderInitView, SharedAnnotationsM
 
         return arc_pks
 
+    def _get_comics_filter(self, rel, arc, arc_pks):
+        """Build the filter."""
+        group_acl_filter = self.get_group_acl_filter(Comic, self.request.user)
+        nav_filter = {f"{rel}__in": arc_pks}
+        query_filter = group_acl_filter & Q(**nav_filter)
+        if browser_filters := arc.get("filters"):
+            # no search at this time.
+            query_filter &= ComicFieldFilterView.get_all_comic_field_filters(
+                "", browser_filters
+            )
+        return query_filter
+
+    def _get_comics_annotation_and_ordering(self, model, arc_group, arc_pks, ordering):
+        """Get ordering for query."""
+        sort_name_annotations = {}
+        if arc_group in ("v", "s"):
+            show = self.params["show"]
+            model_group = "i" if arc_group == "s" else "s"
+            sort_name_annotations = self.get_sort_name_annotations(
+                model, model_group, arc_pks, show
+            )
+            if sort_name_annotations and model is Comic:
+                ordering += (*sort_name_annotations.keys(),)
+            ordering += (
+                "issue_number",
+                "issue_suffix",
+                "sort_name",
+            )
+        return sort_name_annotations, tuple(ordering)
+
     def _get_comics_list(self):
         """Get the reader naviation group filter."""
         arc: Mapping = self.params.get("arc", {})  # type: ignore
@@ -74,63 +107,45 @@ class ReaderBooksView(BookmarkFilterBaseView, ReaderInitView, SharedAnnotationsM
         fields = _COMIC_FIELDS
         arc_pk_rel = rel + "__pk"
         arc_index = NONE_INTEGERFIELD
-        ordering = ()
         arc_pk_select_related = (rel,)
         select_related = ()
         prefetch_related = ()
+        ordering = ()
 
         if arc_group == STORY_ARC_GROUP:
-            prefetch_related = (*prefetch_related, rel)
             arc_index = F("story_arc_numbers__number")
-            ordering = ("arc_index", "date", "pk")
             arc_pk_select_related = ()
+            prefetch_related = (*prefetch_related, rel)
+            ordering = ("arc_index", "date", "pk")
         elif arc_group == FOLDER_GROUP:
-            select_related = (rel,)
             fields = (*_COMIC_FIELDS, rel)
+            select_related = (rel,)
             ordering = ("path", "pk")
 
         arc_pks = self._get_reader_arc_pks(
             arc, arc_pk_select_related, prefetch_related, arc_pk_rel, arc_group
         )
-        nav_filter = {f"{rel}__in": arc_pks}
-        group_acl_filter = self.get_group_acl_filter(Comic)
 
-        qs = Comic.objects.filter(group_acl_filter).filter(**nav_filter)
-        if browser_filters := arc.get("filters"):
-            # no search at this time.
-            field_filters = ComicFieldFilterView.get_all_comic_field_filters(
-                "", browser_filters
-            )
-            qs = qs.filter(field_filters)
+        query_filter = self._get_comics_filter(rel, arc, arc_pks)
+        qs = Comic.objects.filter(query_filter)
 
         if select_related:
             qs = qs.select_related(*select_related)
         if prefetch_related:
             qs = qs.prefetch_related(*prefetch_related)
-        qs = (
-            qs.only(*fields)
-            .annotate(
-                issue_count=F("volume__issue_count"),
-            )
-            .annotate(
-                arc_pk=F(arc_pk_rel),
-                arc_index=arc_index,
-            )
-            .annotate(mtime=F("updated_at"))
+        qs = qs.only(*fields)
+        qs = self.annotate_group_names(qs)
+        qs = qs.annotate(
+            issue_count=F("volume__issue_count"),
+            arc_pk=F(arc_pk_rel),
+            arc_index=arc_index,
+            mtime=F("updated_at"),
         )
-        qs = self.annotate_group_names(qs, Comic)
-        if arc_group in ("v", "s"):
-            show = self.params["show"]
-            model_group = "i" if arc_group == "s" else "s"
-            qs, comic_sort_names = self.alias_sort_names(
-                qs, Comic, pks=arc_pks, model_group=model_group, show=show
-            )
-            ordering = (
-                *comic_sort_names,
-                "issue_number",
-                "issue_suffix",
-                "sort_name",
-            )
+        sort_names_alias, ordering = self._get_comics_annotation_and_ordering(
+            qs.model, arc_group, arc_pks, ordering
+        )
+        if sort_names_alias:
+            qs = qs.alias(**sort_names_alias)
         qs = qs.order_by(*ordering)
         return qs, arc_group
 
@@ -153,7 +168,8 @@ class ReaderBooksView(BookmarkFilterBaseView, ReaderInitView, SharedAnnotationsM
         Yields 1 to 3 books
         """
         comics, arc_group = self._get_comics_list()
-        bookmark_filter = self.get_bookmark_search_kwargs()
+        auth_filter = self.get_bookmark_auth_filter()
+        bookmark_filter = self.get_bookmark_search_kwargs(auth_filter)
         books = {}
         prev_book = None
         pk = self.kwargs.get("pk")

codex/views/reader/page.py

@@ -9,10 +9,12 @@ from drf_spectacular.utils import OpenApiParameter, extend_schema
 from rest_framework.exceptions import NotFound
 from rest_framework.negotiation import BaseContentNegotiation
 
+from codex.librarian.bookmark.tasks import BookmarkUpdateTask
+from codex.librarian.mp_queue import LIBRARIAN_QUEUE
 from codex.logger.logging import get_logger
-from codex.models import Comic
+from codex.models.comic import Comic, FileType
+from codex.settings.settings import FALSY
 from codex.views.bookmark import BookmarkBaseView
-from codex.views.const import FALSY
 from codex.views.util import chunker
 
 LOG = get_logger(__name__)
@@ -55,20 +57,24 @@ class ReaderPageView(BookmarkBaseView):
         )
         if not do_bookmark:
             return
-        page = self.kwargs.get("page")
-        updates = {"page": page}
+
+        auth_filter = self.get_bookmark_auth_filter()
         pk = self.kwargs.get("pk")
         comic_filter = {"pk": pk}
-        self.update_bookmarks(updates, comic_filter)
+        page = self.kwargs.get("page")
+        updates = {"page": page}
+
+        task = BookmarkUpdateTask(auth_filter, comic_filter, updates)
+        LIBRARIAN_QUEUE.put(task)
 
     def _get_page_image(self):
         """Get the image data and content type."""
-        group_acl_filter = self.get_group_acl_filter(Comic)
+        group_acl_filter = self.get_group_acl_filter(Comic, self.request.user)
         pk = self.kwargs.get("pk")
         comic = Comic.objects.filter(group_acl_filter).only("path").get(pk=pk)
         page = self.kwargs.get("page")
         to_pixmap = self.request.GET.get("pixmap", "").lower() not in FALSY
-        if comic.file_type == Comic.FileType.PDF.value and not to_pixmap:
+        if comic.file_type == FileType.PDF.value and not to_pixmap:
             content_type = _PDF_MIME_TYPE
         else:
             content_type = self.content_type