codex 1.7.1__py3-none-any.whl → 1.7.3__py3-none-any.whl

codex/views/opds/v1/links.py

@@ -105,7 +105,7 @@ class RootTopLinks:
 class OPDS1LinksView(OPDS1FacetsView):
     """OPDS 1 Links methods."""
 
-    # overwritten in get_object()
+    # overwritten in get_object method
     DEFAULT_ROUTE = MappingProxyType(
         {
             **OPDS1FacetsView.DEFAULT_ROUTE,
@@ -143,7 +143,7 @@ class OPDS1LinksView(OPDS1FacetsView):
     def _root_links(self):
         """Navigation Root Links."""
         links = []
-        if up_route := self.get_last_route():
+        if up_route := self.get_last_route(name=True):
             links += [self._link(up_route, Rel.UP)]
         page = self.kwargs.get("page", 1)
         if page > 1:
@@ -179,7 +179,7 @@ class OPDS1LinksView(OPDS1FacetsView):
                 for top_link in TopLinks.ALL + RootTopLinks.ALL:
                     if not self.is_top_link_displayed(top_link):
                         links += [self._top_link(top_link)]
-                if facets := self.facets():
+                if facets := self.facets(entries=False, root=True):
                     links += facets
         except Exception:
             LOG.exception("Getting OPDS v1 links")
@@ -194,11 +194,16 @@ class OPDS1LinksView(OPDS1FacetsView):
             name=name,
             summary=top_link.desc,
         )
-        zero_pad: int = self.obj["zero_pad"]  # type: ignore
+        zero_pad: int = self.obj["zero_pad"]
         data = OPDS1EntryData(
-            self.opds_acquisition_groups, zero_pad, False, self.mime_type_map
+            self.opds_acquisition_groups,
+            zero_pad,
+            metadata=False,
+            mime_type_map=self.mime_type_map,
+        )
+        return OPDS1Entry(
+            entry_obj, top_link.query_params, data, title_filename_fallback=False
         )
-        return OPDS1Entry(entry_obj, top_link.query_params, data)
 
     def add_top_links(self, top_links):
         """Add a list of top links as entries if they should be enabled."""

codex/views/opds/v2/const.py

@@ -31,7 +31,10 @@ FACETS = (
         "Order Direction",
         "orderReverse",
         "⇕",
-        (Facet(False, "Ascending"), Facet(True, "Descending")),
+        (
+            Facet(query_param_value=False, title="Ascending"),
+            Facet(query_param_value=True, title="Descending"),
+        ),
     ),
     FacetGroup(
         "Top Group",
@@ -114,5 +117,5 @@ class LinksSectionData:
 
 
 TOP_NAV_GROUP_SECTION_DATA = LinksSectionData(group_kwarg=True)
-GROUPS_SECTION_DATA = LinksSectionData("Groups", Rel.SUB, True)
+GROUPS_SECTION_DATA = LinksSectionData("Groups", Rel.SUB, group_kwarg=True)
 FACETS_SECTION_DATA = LinksSectionData(rel=Rel.FACET, links_key="links")

codex/views/opds/v2/feed.py

@@ -8,7 +8,7 @@ from rest_framework.response import Response
 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.serializers.opds.v2.feed import OPDS2FeedSerializer
 from codex.views.const import MAX_OBJ_PER_PAGE
 from codex.views.opds.auth import OPDSAuthMixin
 from codex.views.opds.const import BLANK_TITLE
@@ -20,7 +20,8 @@ from codex.views.opds.v2.const import (
     TOP_NAV_GROUP_SECTION_DATA,
     NavigationGroup,
 )
-from codex.views.opds.v2.links import HrefData, LinkData
+from codex.views.opds.v2.href import HrefData
+from codex.views.opds.v2.links import LinkData
 from codex.views.opds.v2.publications import OPDS2PublicationView
 
 LOG = get_logger(__name__)
@@ -55,9 +56,9 @@ class OPDS2FeedView(OPDSAuthMixin, OPDS2PublicationView):
 
     # def _detect_user_agent(self):
     #    """Hacks for individual clients."""
-    #    user_agent = self.request.headers.get("User-Agent")
+    #    user_agent = self.request.headers.get("User-Agent") # noqa: ERA001
     #    if not user_agent:
-    #        return
+    #        return # noqa: ERA001
 
     @staticmethod
     def _is_allowed(link_spec):
@@ -184,7 +185,7 @@ class OPDS2FeedView(OPDSAuthMixin, OPDS2PublicationView):
         title = self._title(title)
         number_of_items = total_count
         current_page = self.kwargs.get("page")
-        up_route = self.get_last_route()
+        up_route = self.get_last_route(name=True)
         links = self.get_links(up_route)
         facets = self._get_facets()
 

codex/views/opds/v2/href.py

@@ -0,0 +1,60 @@
+"""Href methods for OPDS v2.0 Feed."""
+
+from abc import ABC
+from dataclasses import dataclass
+
+from django.urls import reverse
+from rest_framework.views import APIView
+
+from codex.views.opds.util import update_href_query_params
+from codex.views.util import pop_name
+
+
+@dataclass
+class HrefData:
+    """Data for creating hrefs."""
+
+    kwargs: dict | None = None
+    query_params: dict | None = None
+    absolute_query_params: bool = False
+    url_name: str | None = None
+    min_page: int | None = None
+    max_page: int | None = None
+
+
+class OPDS2HrefMixin(APIView, ABC):
+    """Create links method."""
+
+    @property
+    def num_pages(self) -> int:
+        """Dummy."""
+        return 1
+
+    def _href_page_validate(self, kwargs, data):
+        """Validate the page bounds."""
+        min_page = 1 if data.min_page is None else data.min_page
+        max_page = self.num_pages if data.max_page is None else data.max_page
+        page = int(kwargs["page"])
+        return page >= min_page and page <= max_page
+
+    def _href_update_query_params(self, href, data):
+        """Update the query params."""
+        if data.absolute_query_params and data.query_params:
+            href = update_href_query_params(href, data.query_params)
+        elif hasattr(self, "request"):
+            # if request link and not init static links
+            href = update_href_query_params(
+                href, self.request.GET, new_query_params=data.query_params
+            )
+        return href
+
+    def href(self, data):
+        """Create an href."""
+        url_name = data.url_name if data.url_name else "opds:v2:feed"
+        kwargs = data.kwargs if data.kwargs is not None else self.kwargs
+        if "page" in kwargs and not self._href_page_validate(kwargs, data):
+            return None
+
+        kwargs = pop_name(kwargs)
+        href = reverse(url_name, kwargs=kwargs)
+        return self._href_update_query_params(href, data)

codex/views/opds/v2/links.py

@@ -1,30 +1,17 @@
 """Links methods for OPDS v2.0 Feed."""
 
+from collections.abc import Mapping
 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.opds.const import MimeType, Rel
-from codex.views.opds.util import update_href_query_params
-from codex.views.util import pop_name
-
-
-@dataclass
-class HrefData:
-    """Data for creating hrefs."""
-
-    kwargs: dict | None = None
-    query_params: dict | None = None
-    absolute_query_params: bool = False
-    url_name: str | None = None
-    min_page: int | None = None
-    max_page: int | None = None
+from codex.views.opds.v2.href import HrefData, OPDS2HrefMixin
 
 
 @dataclass
@@ -40,9 +27,10 @@ class LinkData:
     width: int | None = None
     href: str | None = None
     num_items: int | None = None
+    authenticate: Mapping | None = None
 
 
-class OPDS2LinksView(BrowserView):
+class OPDS2LinksView(OPDS2HrefMixin, BrowserView):
     """Links methods for OPDS 2.0 Feed."""
 
     def __init__(self, *args, **kwargs):
@@ -70,41 +58,12 @@ class OPDS2LinksView(BrowserView):
             self._num_pages = self.group_and_books[2]
         return self._num_pages
 
-    def _href_page_validate(self, kwargs, data):
-        """Validate the page bounds."""
-        min_page = 1 if data.min_page is None else data.min_page
-        max_page = self.num_pages if data.max_page is None else data.max_page
-        page = int(kwargs["page"])
-        return page >= min_page and page <= max_page
-
-    def _href_update_query_params(self, href, data):
-        """Update the query params."""
-        if data.absolute_query_params and data.query_params:
-            href = update_href_query_params(href, data.query_params)
-        elif hasattr(self, "request"):
-            # if request link and not init static links
-            href = update_href_query_params(
-                href, self.request.GET, new_query_params=data.query_params
-            )
-        return href
-
-    def _href(self, data):
-        """Create an href."""
-        url_name = data.url_name if data.url_name else "opds:v2:feed"
-        kwargs = data.kwargs if data.kwargs is not None else self.kwargs
-        if "page" in kwargs and not self._href_page_validate(kwargs, data):
-            return None
-
-        kwargs = pop_name(kwargs)
-        href = reverse(url_name, kwargs=kwargs)
-        return self._href_update_query_params(href, data)
-
     def link(self, data):
         """Create a link element."""
         if data.href:
             href = data.href
         else:
-            href = self._href(data.href_data)
+            href = self.href(data.href_data)
             if not href:
                 return None
         mime_type = data.mime_type if data.mime_type else MimeType.OPDS_JSON
@@ -118,8 +77,15 @@ class OPDS2LinksView(BrowserView):
             link["height"] = data.height
         if data.width:
             link["width"] = data.width
+
+        # Properties
+        if data.num_items or data.authenticate:
+            link["properties"] = {}
         if data.num_items:
-            link["properties"] = {"number_of_items": data.num_items}
+            link["properties"]["number_of_items"] = data.num_items
+        if data.authenticate:
+            link["properties"]["authenticate"] = data.authenticate
+
         return link
 
     @staticmethod

codex/views/opds/v2/progression.py

@@ -0,0 +1,136 @@
+"""OPDS 2 Progression view."""
+# https://github.com/opds-community/drafts/discussions/67#discussioncomment-6414507
+
+from types import MappingProxyType
+
+from django.db.models.expressions import F, Value
+from django.db.models.fields import FloatField
+from django.db.models.functions.comparison import Cast, Coalesce, Greatest, Least
+from django.db.models.query_utils import FilteredRelation
+from rest_framework.exceptions import ValidationError
+from rest_framework.response import Response
+
+from codex.logger.logging import get_logger
+from codex.serializers.opds.v2.progression import OPDS2ProgressionSerializer
+from codex.util import max_none
+from codex.views.auth import AuthFilterGenericAPIView
+from codex.views.bookmark import BookmarkFilterMixin, BookmarkPageView
+from codex.views.const import GROUP_MODEL_MAP
+from codex.views.opds.v2.href import HrefData, OPDS2HrefMixin
+
+_EMPTY_DEVICE = MappingProxyType(
+    {
+        "id": "",
+        "name": "",
+    }
+)
+LOG = get_logger(__name__)
+
+
+# This is an independent api requiring a separate get.
+class OPDS2ProgressionView(
+    BookmarkFilterMixin, OPDS2HrefMixin, BookmarkPageView, AuthFilterGenericAPIView
+):
+    """OPDS 2 Progression view."""
+
+    serializer_class = OPDS2ProgressionSerializer
+
+    @property
+    def modified(self):
+        """Get modified from bookmark."""
+        return self._obj.bookmark_updated_at  # type: ignore[reportAttributeAccessIssue]
+
+    @property
+    def device(self):
+        """Dummy device."""
+        # Codex doesn't record this.
+        return _EMPTY_DEVICE
+
+    @property
+    def title(self):
+        """The locator title is the page number."""
+        return f"Page {self._obj.page}"  # type: ignore[reportAttributeAccessIssue]
+
+    @property
+    def _progression_href(self):
+        """Build a Progression HRef."""
+        acq_kwargs = {
+            "pk": self._obj.pk,
+            "page": self._obj.page,  # type: ignore[reportAttributeAccessIssue]
+        }
+        max_page = max_none(self._obj.page_count - 1, 0)  # type: ignore[reportAttributeAccessIssue]
+        data = HrefData(
+            acq_kwargs,
+            url_name="opds:bin:page",
+            min_page=0,
+            max_page=max_page,
+        )
+        return self.href(data)
+
+    @property
+    def _locations(self):
+        """Build the Locations object."""
+        return {
+            "position": self._obj.page,  # type: ignore[reportAttributeAccessIssue]
+            "progression": self._obj.progress,  # type: ignore[reportAttributeAccessIssue]
+            "total_progression": self._obj.progress,  # type: ignore[reportAttributeAccessIssue]
+        }
+
+    @property
+    def locator(self):
+        """Build the Locator object."""
+        return {
+            "title": self.title,  # See publication.py:103
+            "href": self._progression_href,
+            "type": "image/jpeg",
+            "locations": self._locations,
+        }
+
+    def get_object(self):
+        """Build the progression data object."""
+        group = self.kwargs.get("group")
+        pk = self.kwargs.get("pk")
+
+        if not pk:
+            reason = f"Bad primary key for {group}:{pk}"
+            return ValidationError(reason, code="422")
+
+        model = GROUP_MODEL_MAP.get(group)
+        if not model:
+            reason = f"No model found for group {group}"
+            raise ValidationError(reason, code="422")
+
+        acl_filter = self.get_group_acl_filter(model, self.request.user)
+        qs = model.objects.filter(acl_filter).distinct()
+
+        bm_rel = self.get_bm_rel(model)
+        bm_filter = self.get_my_bookmark_filter(bm_rel)
+        progress = Least(
+            F("page") / Greatest(Cast(F("page_count"), FloatField()), 1.0), Value(1.0)
+        )
+
+        qs = qs.annotate(
+            my_bookmark=FilteredRelation("bookmark", condition=bm_filter),
+            bookmark_updated_at=F("my_bookmark__updated_at"),
+            page=Coalesce(F("my_bookmark__page"), 0),
+            progress=progress,
+        )
+        self._obj = qs.only("page_count").distinct().get(pk=pk)
+
+        return {
+            "modified": self.modified,
+            "device": self.device,
+            "locator": self.locator,
+        }
+
+    def get(self, *args, **kwargs):
+        """Get Response."""
+        try:
+            obj = self.get_object()
+            serializer = self.get_serializer(obj)
+            return Response(serializer.data)
+        except Exception:
+            LOG.exception("progression")
+            raise
+
+    # PUT handled by BookmarkPageView parent

codex/views/opds/v2/publications.py

@@ -10,15 +10,17 @@ 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
+from codex.views.opds.v2.href import HrefData
+from codex.views.opds.v2.links import LinkData
+from codex.views.opds.v2.top_links import OPDS2TopLinksView
 
 _MD_CONTRIBUTOR_MAP = MappingProxyType(
     {
         "author": AUTHOR_ROLES,
-        # "translator": {},
+        # "translator": {}, unused
         "editor": {"Editor"},
         "artist": {"CoverArtist"},
-        # "illustrator": {},
+        # "illustrator": {}, unused, could use penciller
         "letterer": {"Letterer"},
         "penciller": {"Penciller"},
         "colorist": {"Colorist"},
@@ -40,7 +42,9 @@ class OPDS2PublicationView(OPDS2TopLinksView):
             "dynamicCovers": False,
             "ts": ts,
         }
-        href_data = HrefData(kwargs, query_params, True, "opds:bin:cover")
+        href_data = HrefData(
+            kwargs, query_params, absolute_query_params=True, url_name="opds:bin:cover"
+        )
         link_data = LinkData(
             Rel.THUMBNAIL,
             href_data,
@@ -63,15 +67,13 @@ class OPDS2PublicationView(OPDS2TopLinksView):
     @staticmethod
     def _add_contributors(md, pks, key, roles):
         """Add contributors to metadata."""
-        if contributors := get_contributors(pks, roles):
+        if contributors := get_contributors(pks, roles, exclude=False):
             md[key] = contributors
 
     def _publication_optional_metadata(self, md, obj):
         """Add optional Publication Metadtata."""
         if subtitle := obj.name:
             md["subtitle"] = subtitle
-        # if identifier := obj.get("guid")
-        #   md["identifier"] = identifier
         if desc := obj.summary:
             md["description"] = desc
         if lang := obj.language:
@@ -87,25 +89,21 @@ class OPDS2PublicationView(OPDS2TopLinksView):
         """Publication m2m metadata only on the metadata alternate link."""
         for key, roles in _MD_CONTRIBUTOR_MAP.items():
             self._add_contributors(md, obj.ids, key, roles)
-        if contributors := get_contributors(obj.ids, _CONTRIBUTOR_ROLES, True):
+        if contributors := get_contributors(obj.ids, _CONTRIBUTOR_ROLES, exclude=True):
             md["contributor"] = contributors
 
         if m2m_objs := get_m2m_objects(obj.ids):
-            # XXX Subjects can also have links
+            # Subjects can also have links
             # https://readium.org/webpub-manifest/schema/subject-object.schema.json
-            subjects = []
-            for subjs in m2m_objs.values():
-                for subj in subjs:
-                    subjects.append(subj.name)
-            md["subject"] = subjects
+            md["subject"] = [subj.name for subjs in m2m_objs.values() for subj in subjs]
 
     def _publication_metadata(self, obj, zero_pad):
         title = Comic.get_title(
             obj,
             volume=False,
             name=False,
-            zero_pad=zero_pad,
             filename_fallback=self.title_filename_fallback,
+            zero_pad=zero_pad,
         )
         md = {
             "type": MimeType.BOOK,
@@ -127,10 +125,6 @@ class OPDS2PublicationView(OPDS2TopLinksView):
         download_mime_type = MimeType.FILE_TYPE_MAP.get(obj.file_type, MimeType.OCTET)
         self_kwargs = {"pk": obj.pk, "page": 1}
 
-        # This would be for comic streaming which is not supported by OPDS 2 yet?
-        # self_href_data = HrefData(self_kwargs, absolute_query_params=True)
-        # self_link_data = LinkData(Rel.SELF, self_href_data, mime_type=MimeType.OPDS_PUB)
-
         alt_kwargs = self_kwargs
         alt_href_data = HrefData(
             alt_kwargs,
@@ -154,11 +148,27 @@ class OPDS2PublicationView(OPDS2TopLinksView):
             acq_href_data,
             mime_type=download_mime_type,
         )
+        prog_kwargs = {"group": "c", "pk": obj.pk}
+        prog_href_data = HrefData(prog_kwargs, url_name="opds:v2:position")
+
+        auth_href_data = HrefData({}, url_name="opds:authentication:v1")
+        auth_link_data = LinkData(
+            Rel.AUTHENTICATION,
+            auth_href_data,
+            mime_type=MimeType.AUTHENTICATION,
+        )
+        auth_link = self.link(auth_link_data)
+
+        prog_link_data = LinkData(
+            Rel.PROGRESSION,
+            prog_href_data,
+            mime_type=MimeType.PROGRESSION,
+            authenticate=auth_link,
+        )
         links = [
-            # Comic streaming link (unsupported)
-            # self.link(self_link_data),
             self.link(alt_link_data),
             self.link(acq_link_data),
+            self.link(prog_link_data),
         ]
         pub["links"] = links
 

codex/views/opds/v2/top_links.py

@@ -1,7 +1,8 @@
 """OPDS v2.0 top links section methods."""
 
 from codex.views.opds.const import MimeType, Rel
-from codex.views.opds.v2.links import HrefData, LinkData, OPDS2LinksView
+from codex.views.opds.v2.href import HrefData
+from codex.views.opds.v2.links import LinkData, OPDS2LinksView
 
 
 class OPDS2TopLinksView(OPDS2LinksView):

codex/views/public.py

@@ -13,6 +13,7 @@ _ADMIN_FLAG_KEYS = frozenset(
     {
         AdminFlag.FlagChoices.NON_USERS.value,
         AdminFlag.FlagChoices.REGISTRATION.value,
+        AdminFlag.FlagChoices.BANNER_TEXT.value,
     }
 )
 
@@ -21,16 +22,22 @@ class AdminFlagsView(GenericAPIView, RetrieveModelMixin):
     """Get admin flags relevant to auth."""
 
     serializer_class = AuthAdminFlagsSerializer
-    queryset = AdminFlag.objects.filter(key__in=_ADMIN_FLAG_KEYS).only("key", "on")
+    queryset = AdminFlag.objects.filter(key__in=_ADMIN_FLAG_KEYS).only(
+        "key", "on", "value"
+    )
 
     def get_object(self):
         """Get admin flags."""
         flags = {}
-        for obj in self.get_queryset():  # type: ignore
+        for obj in self.get_queryset():
             name = ADMIN_FLAG_CHOICES[obj.key].lower().replace(" ", "_")
-            flags[name] = obj.on
+            if obj.key == AdminFlag.FlagChoices.BANNER_TEXT.value:
+                val = obj.value
+            else:
+                val = obj.on
+            flags[name] = val
         return flags
 
-    def get(self, request, *args, **kwargs):
+    def get(self, *args, **kwargs):
         """Get admin flags relevant to auth."""
-        return self.retrieve(request, *args, **kwargs)
+        return self.retrieve(*args, **kwargs)

codex/views/reader/books.py

@@ -6,7 +6,7 @@ from django.db.models import F
 from django.db.models.query import Q
 
 from codex.models import Bookmark, Comic
-from codex.views.bookmark import BookmarkBaseView
+from codex.views.bookmark import BookmarkAuthMixin
 from codex.views.browser.filters.field import ComicFieldFilterView
 from codex.views.const import (
     FOLDER_GROUP,
@@ -15,7 +15,7 @@ from codex.views.const import (
     NONE_INTEGERFIELD,
     STORY_ARC_GROUP,
 )
-from codex.views.mixins import BookmarkSearchMixin, SharedAnnotationsMixin
+from codex.views.mixins import SharedAnnotationsMixin
 from codex.views.reader.params import ReaderParamsView
 
 if TYPE_CHECKING:
@@ -34,9 +34,7 @@ _COMIC_FIELDS = (
 )
 
 
-class ReaderBooksView(
-    BookmarkBaseView, ReaderParamsView, SharedAnnotationsMixin, BookmarkSearchMixin
-):
+class ReaderBooksView(SharedAnnotationsMixin, BookmarkAuthMixin, ReaderParamsView):
     """Get Books methods."""
 
     def _get_reader_arc_pks(
@@ -81,10 +79,10 @@ class ReaderBooksView(
         """Get ordering for query."""
         sort_name_annotations = {}
         if arc_group in ("v", "s"):
+            parent_group = "i" if arc_group == "s" else "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
+                model, parent_group, arc_pks, show
             )
             if sort_name_annotations and model is Comic:
                 ordering += (*sort_name_annotations.keys(),)
@@ -97,7 +95,7 @@ class ReaderBooksView(
 
     def _get_comics_list(self):
         """Get the reader naviation group filter."""
-        arc: Mapping = self.params.get("arc", {})  # type: ignore
+        arc: Mapping = self.params.get("arc", {})
 
         arc_group = arc.get("group", "")
         if not GROUP_MODEL_MAP.get(arc_group):
@@ -149,6 +147,19 @@ class ReaderBooksView(
         qs = qs.order_by(*ordering)
         return qs, arc_group
 
+    @staticmethod
+    def _get_bookmark_filter(auth_filter, comic_filter=None):
+        """Get the search kwargs for a user's authentication state."""
+        # search kwargs are relative to the bookmark object.
+        search_kwargs = {}
+        search_kwargs.update(auth_filter)
+
+        if comic_filter:
+            for key, value in comic_filter.items():
+                search_kwargs[f"comic__{key}"] = value
+
+        return search_kwargs
+
     def _append_with_settings(self, book, bookmark_filter):
         """Append bookmark to book list."""
         book.settings = (
@@ -159,7 +170,8 @@ class ReaderBooksView(
         return book
 
     def get_book_collection(self):
-        """Get the -1, +1 window around the current issue.
+        """
+        Get the -1, +1 window around the current issue.
 
         Uses iteration in python. There are some complicated ways of
         doing this with __gt[0] & __lt[0] in the db, but I think they
@@ -169,7 +181,7 @@ class ReaderBooksView(
         """
         comics, arc_group = self._get_comics_list()
         auth_filter = self.get_bookmark_auth_filter()
-        bookmark_filter = self.get_bookmark_search_kwargs(auth_filter)
+        bookmark_filter = self._get_bookmark_filter(auth_filter)
         books = {}
         prev_book = None
         pk = self.kwargs.get("pk")