codex 1.6.0a5__py3-none-any.whl → 1.6.0a7__py3-none-any.whl

codex/views/browser/browser.py

@@ -1,18 +1,13 @@
 """Views for browsing comic library."""
 
-from copy import deepcopy
-from math import ceil, floor, log10
-from os import sep
-from pathlib import Path
+from math import floor, log10
 from types import MappingProxyType
-from typing import TYPE_CHECKING, ClassVar
+from typing import TYPE_CHECKING
 
-from django.core.paginator import EmptyPage, Paginator
 from django.db.models import Max
 from drf_spectacular.utils import extend_schema
 from rest_framework.response import Response
 
-from codex.exceptions import SeeOtherRedirectError
 from codex.logger.logging import get_logger
 from codex.models import (
     AdminFlag,
@@ -24,14 +19,16 @@ from codex.models import (
     Publisher,
     Series,
     StoryArc,
-    Timestamp,
     Volume,
 )
 from codex.serializers.browser.page import BrowserPageSerializer
-from codex.serializers.choices import DEFAULTS
-from codex.views.auth import IsAuthenticatedOrEnabledNonUsers
-from codex.views.browser.browser_breadcrumbs import BrowserBreadcrumbsView
-from codex.views.browser.const import MAX_OBJ_PER_PAGE
+from codex.util import max_none
+from codex.views.browser.title import BrowserTitleView
+from codex.views.const import (
+    COMIC_GROUP,
+    FOLDER_GROUP,
+    STORY_ARC_GROUP,
+)
 
 if TYPE_CHECKING:
     from django.db.models.query import QuerySet
@@ -40,10 +37,9 @@ if TYPE_CHECKING:
 LOG = get_logger(__name__)
 
 
-class BrowserView(BrowserBreadcrumbsView):
+class BrowserView(BrowserTitleView):
     """Browse comics with a variety of filters and sorts."""
 
-    permission_classes: ClassVar[list] = [IsAuthenticatedOrEnabledNonUsers]  # type: ignore
     serializer_class = BrowserPageSerializer
 
     ADMIN_FLAG_VALUE_KEY_MAP = MappingProxyType(
@@ -52,7 +48,7 @@ class BrowserView(BrowserBreadcrumbsView):
             AdminFlag.FlagChoices.IMPORT_METADATA.value: "import_metadata",
         }
     )
-
+    TARGET = "browser"
     _GROUP_INSTANCE_SELECT_RELATED: MappingProxyType[
         type[BrowserGroupModel], tuple[str | None, ...]
     ] = MappingProxyType(
@@ -66,45 +62,43 @@ class BrowserView(BrowserBreadcrumbsView):
             StoryArc: (None,),
         }
     )
-    DEFAULT_ROUTE = MappingProxyType(
-        {
-            "name": "browser",
-            "params": deepcopy(DEFAULTS["breadcrumbs"][0]),
-        }
-    )
-    _OPDS_M2M_RELS = (
-        "characters",
-        "genres",
-        "locations",
-        "series_groups",
-        "story_arc_numbers",
-        "story_arc_numbers__story_arc",
-        "tags",
-        "teams",
-        "contributors",
-        "contributors__role",
-        "contributors__person",
-    )
-    TARGET = "browser"
 
     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.group_instance: BrowserGroupModel | None = None
         self.valid_nav_groups: tuple[str, ...] = ()
 
-    def _raise_redirect(self, reason, route_mask=None, settings_mask=None):
-        """Redirect the client to a valid group url."""
-        route = deepcopy(dict(self.DEFAULT_ROUTE))
-        if route_mask:
-            route["params"].update(route_mask)  # type: ignore
-        settings = deepcopy(dict(self.params))
-        if settings_mask:
-            settings.update(settings_mask)
-        detail = {"route": route, "settings": settings, "reason": reason}
-        raise SeeOtherRedirectError(detail=detail)
+    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, ...] = (
+                    self._GROUP_INSTANCE_SELECT_RELATED[self.group_class]
+                )
+                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!"
+                    self.raise_redirect(reason, route_mask={"group": group})
+        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."""
@@ -112,16 +106,19 @@ class BrowserView(BrowserBreadcrumbsView):
         #   A valid nav group or 'c'
         #   the child of the current nav group or 'c'
         group = self.kwargs["group"]
-        if group == self.FOLDER_GROUP:
+        if group == FOLDER_GROUP:
             return group
-        if group == self.STORY_ARC_GROUP:
+        if group == STORY_ARC_GROUP:
             pks = self.kwargs.get("pks")
-            return self.COMIC_GROUP if pks else group
+            return COMIC_GROUP if pks else group
         if group == self.valid_nav_groups[-1]:
             # special case for lowest valid group
-            return self.COMIC_GROUP
+            return COMIC_GROUP
         return self.valid_nav_groups[self.valid_nav_groups.index(group) + 1]
 
+    ################
+    # MAIN QUERIES #
+    ################
     def _get_common_queryset(self, model):
         """Create queryset common to group & books."""
         object_filter = self.get_query_filters(model, False)
@@ -162,167 +159,16 @@ class BrowserView(BrowserBreadcrumbsView):
             count = 0
         return qs, count
 
-    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, ...] = (
-                    self._GROUP_INSTANCE_SELECT_RELATED[self.group_class]
-                )
-                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!"
-                    self._raise_redirect(reason, route_mask={"group": group})
-        elif self.group_class:
-            self.group_query = self.group_class.objects.none()
+    def _get_page_mtime(self, group_qs):
+        if self.group_instance:
+            page_updated_at_max = self.group_instance.updated_at
         else:
-            self.group_query = Comic.objects.none()
-        self.group_instance = self.group_query.first()
-
-    def _get_root_group_name(self):
-        if not self.model:
-            reason = "No model set in browser"
-            raise ValueError(reason)
-        plural = self.model._meta.verbose_name_plural
-        if not plural:
-            reason = f"No plural name for {self.model}"
-            raise ValueError(reason)
-        return plural.capitalize()
-
-    def _get_folder_parent_name(self):
-        """Get title for a folder browser page."""
-        group_instance: Folder = self.group_instance  # type: ignore
-        if not group_instance.path:
-            return ""
-
-        parent_path = Path(group_instance.path).parent
-        if not self.is_admin():
-            try:
-                # remove library path for not admins
-                library_path_parent = Path(group_instance.library.path).parent
-                parent_path = parent_path.relative_to(library_path_parent)
-            except ValueError:
-                parent_path = ""
-
-        parent_path_str = str(parent_path)
-        parent_path_str = parent_path_str.removeprefix(".")
-        if parent_path_str and parent_path_str[0] != sep:
-            parent_path_str = sep + parent_path_str
-        return parent_path_str
-
-    def _get_browser_page_title(self):
-        """Get the proper title for this browse level."""
-        group_count = 0
-        group_name = ""
-        pks = self.kwargs.get("pks")
-        if not pks:
-            group_name = self._get_root_group_name()
-        else:
-            group_instance = self.group_instance
-            if group_instance:
-                if isinstance(group_instance, Volume):
-                    group_count = group_instance.series.volume_count
-                elif isinstance(group_instance, Comic):
-                    group_count = group_instance.volume.issue_count
-                group_name = group_instance.name
-
-        return {
-            "group_name": group_name,
-            "group_count": group_count,
-        }
-
-    def _check_page_in_bounds(self, total_count):
-        """Redirect page out of bounds."""
-        pks = self.kwargs.get("pks")
-        page = self.kwargs.get("page", 1)
-        num_pages = ceil(total_count / MAX_OBJ_PER_PAGE)
-        if (not pks and page == 1) or (page >= 1 and page <= num_pages):
-            # Don't redirect if on the root page for the group.
-            # Or page within valid range.
-            return num_pages
-
-        # Adjust route mask for redirect
-        group = self.kwargs.get("group")
-        if num_pages and page > 1:
-            # Try page 1 first.
-            new_page = num_pages if num_pages and page > num_pages else 1
-            pks = pks if pks else "0"
-        else:
-            # Redirect to root for the group.
-            pks = "0"
-            new_page = 1
-
-        reason = f"{page=} does not exist!"
-        route_changes = {"group": group, "pks": pks, "page": new_page}
-        return self._raise_redirect(reason, route_mask=route_changes)
-
-    def _paginate_section(self, model, qs, page):
-        """Paginate a group or Comic section."""
-        orphans = 0 if self.model_group == "f" or self.params.get("q") else 5
-        paginator = Paginator(qs, MAX_OBJ_PER_PAGE, orphans=orphans)
-        try:
-            qs = paginator.page(page).object_list
-        except EmptyPage:
-            if model != Folder:
-                model_name = self.model.__name__ if self.model else "NO_MODEL"
-                LOG.warning(f"No {model_name}s on page {page}")
-            qs = model.objects.none()
+            page_updated_at_max = group_qs.aggregate(max=Max("updated_at"))["max"]
 
-        return qs
-
-    def _paginate_groups(self, group_qs, total_group_count):
-        """Paginate the group object list before books."""
-        if total_group_count:
-            page = self.kwargs.get("page", 1)
-            page_group_qs = self._paginate_section(self.model, group_qs, page)
-        else:
-            page_group_qs = self.model.objects.none()  # type: ignore
-        return page_group_qs
-
-    def _paginate_books(self, book_qs, total_group_count, page_obj_count):
-        """Paginate the book object list based on how many group/folders are showing."""
-        if page_obj_count >= MAX_OBJ_PER_PAGE:
-            # No books for this page
-            page_book_qs = Comic.objects.none()
-        else:
-            group_remainder = total_group_count % MAX_OBJ_PER_PAGE
-            if page_obj_count:
-                # There are books after the groups on the same page
-                # Manually add books without the paginator
-                book_limit = MAX_OBJ_PER_PAGE - group_remainder
-                page_book_qs = book_qs[:book_limit]
-            else:
-                # There are books after the groups on a new page
-                if group_remainder:
-                    book_offset = MAX_OBJ_PER_PAGE - group_remainder
-                    page_book_qs = book_qs[book_offset:]
-                else:
-                    page_book_qs = book_qs
-
-                num_group_and_mixed_pages = ceil(total_group_count / MAX_OBJ_PER_PAGE)
-                book_only_page = self.kwargs.get("page", 1) - num_group_and_mixed_pages
-                page_book_qs = self._paginate_section(
-                    Comic, page_book_qs, book_only_page
-                )
-        return page_book_qs
+        agg_func = self.get_bookmark_updated_at_aggregate(self.model, True)
+        page_bookmark_updated_at = group_qs.aggregate(max=agg_func)["max"]
 
-    def _paginate(self, group_qs, book_qs, group_count, book_count):
-        """Paginate the queryset into a group and book object lists."""
-        num_pages = self._check_page_in_bounds(group_count + book_count)
-        page_group_qs = self._paginate_groups(group_qs, group_count)
-        page_group_count = page_group_qs.count()
-        page_book_qs = self._paginate_books(book_qs, group_count, page_group_count)
-        page_book_count = page_book_qs.count()
-
-        return page_group_qs, page_book_qs, num_pages, page_group_count, page_book_count
+        return max_none(page_updated_at_max, page_bookmark_updated_at)
 
     @staticmethod
     def _get_zero_pad(book_qs):
@@ -340,9 +186,12 @@ class BrowserView(BrowserBreadcrumbsView):
         group_qs, group_count = self._get_group_queryset()
         book_qs, book_count = self._get_book_queryset()
         # Paginate
-        group_qs, book_qs, num_pages, page_group_count, page_book_count = (
-            self._paginate(group_qs, book_qs, group_count, book_count)
+        group_qs, book_qs, num_pages, page_group_count, page_book_count = self.paginate(
+            group_qs, book_qs, group_count, book_count
         )
+        mtime = self._get_page_mtime(
+            group_qs
+        )  # TODO should this be after paginate or not?
         if page_group_count:
             group_qs = self.annotate_card_aggregates(group_qs, self.model)
         if page_book_count:
@@ -356,25 +205,20 @@ class BrowserView(BrowserBreadcrumbsView):
 
         recovered_group_list = self.re_cover_multi_groups(group_qs)
         total_count = page_group_count + page_book_count
-        return recovered_group_list, book_qs, num_pages, total_count, zero_pad
+        return recovered_group_list, book_qs, num_pages, total_count, zero_pad, mtime
 
     def get_object(self):
         """Validate settings and get the querysets."""
-        group_list, book_qs, num_pages, total_count, zero_pad = (
+        group_list, book_qs, num_pages, total_count, zero_pad, mtime = (
             self._get_group_and_books()
         )
 
         # get additional context
         parent_breadcrumbs = self.get_parent_breadcrumbs()
-        title = self._get_browser_page_title()
+        title = self.get_browser_page_title()
         # needs to happen after pagination
         # runs obj list query twice :/
         libraries_exist = Library.objects.filter(covers_only=False).exists()
-        covers_timestamp = int(
-            Timestamp.objects.get(
-                key=Timestamp.TimestampChoices.COVERS.value
-            ).updated_at.timestamp()
-        )
 
         # construct final data structure
         return MappingProxyType(
@@ -389,135 +233,11 @@ class BrowserView(BrowserBreadcrumbsView):
                 "total_count": total_count,
                 "admin_flags": self.admin_flags,
                 "libraries_exist": libraries_exist,
-                "covers_timestamp": covers_timestamp,
+                "mtime": mtime,
             }
         )
 
-    def _get_valid_browse_top_groups(self):
-        """Get valid top groups for the current settings.
-
-        Valid top groups are determined by the Browser Settings.
-        """
-        valid_top_groups = []
-
-        show = self.params["show"]
-        for nav_group, allowed in show.items():
-            if allowed:
-                valid_top_groups.append(nav_group)
-        # Issues is always a valid top group
-        valid_top_groups += [self.COMIC_GROUP]
-
-        return valid_top_groups
-
-    def _validate_top_group(self, valid_top_groups):
-        nav_group = self.kwargs.get("group")
-        top_group = self.params.get("top_group")
-        if top_group not in valid_top_groups:
-            reason = f"top_group {top_group} not in valid nav groups, changed to "
-            if nav_group in valid_top_groups:
-                valid_top_group = nav_group
-                reason += "nav group: "
-            else:
-                valid_top_group = valid_top_groups[0]
-                reason += "first valid top group "
-            reason += valid_top_group
-            pks = self.kwargs.get("pks", ())
-            page = self.kwargs["page"]
-            route = {"group": nav_group, "pks": pks, "page": page}
-            settings_mask = {"top_group": valid_top_group}
-            self._raise_redirect(reason, route, settings_mask)
-
-    def set_valid_browse_nav_groups(self, valid_top_groups):
-        """Get valid nav groups for the current settings.
-
-        Valid nav groups are the top group and below that are also
-        enabled in browser settings.
-
-        May always navigate to root 'r' nav group.
-        """
-        top_group = self.params["top_group"]
-        nav_group = self.kwargs["group"]
-        valid_nav_groups = [self.ROOT_GROUP]
-
-        for possible_index, possible_nav_group in enumerate(valid_top_groups):
-            if top_group == possible_nav_group:
-                # all the nav groups past this point,
-                # 'c' is obscured by the web reader url, but valid for opds
-                tail_top_groups = valid_top_groups[possible_index:]
-                valid_nav_groups += tail_top_groups
-
-                if nav_group not in valid_nav_groups:
-                    reason = (
-                        f"Nav group {nav_group} unavailable, "
-                        f"redirect to {self.ROOT_GROUP}"
-                    )
-                    self._raise_redirect(reason)
-                break
-        self.valid_nav_groups = tuple(valid_nav_groups)
-
-    def _validate_folder_settings(self):
-        """Check that all the view variables for folder mode are set right."""
-        # Check folder view admin flag
-        if not self.admin_flags["folder_view"]:
-            reason = "folder view disabled"
-            valid_top_groups = self._get_valid_browse_top_groups()
-            settings_mask = {"top_group": valid_top_groups[0]}
-            self._raise_redirect(reason, settings_mask=settings_mask)
-
-        valid_top_groups = (self.FOLDER_GROUP,)
-        self._validate_top_group(valid_top_groups)
-        self.valid_nav_groups = valid_top_groups
-
-    def _validate_browser_group_settings(self):
-        """Check that all the view variables for browser mode are set right."""
-        # Validate Browser top_group
-        # Change top_group if its not in the valid top groups
-        valid_top_groups = self._get_valid_browse_top_groups()
-        self._validate_top_group(valid_top_groups)
-
-        # Validate pks
-        nav_group = self.kwargs["group"]
-        pks = self.kwargs["pks"]
-        if nav_group == self.ROOT_GROUP and (pks and 0 not in pks):
-            # r never has pks
-            reason = f"Redirect r with {pks=} to pks 0"
-            self._raise_redirect(reason)
-
-        # Validate Browser nav_group
-        # Redirect if nav group is wrong
-        self.set_valid_browse_nav_groups(valid_top_groups)
-
-    def _validate_story_arc_settings(self):
-        """Validate story arc settings."""
-        valid_top_groups = (self.STORY_ARC_GROUP,)
-        self._validate_top_group(valid_top_groups)
-        self.valid_nav_groups = valid_top_groups
-
-    def validate_settings(self):
-        """Validate group and top group settings."""
-        group = self.kwargs["group"]
-        if group == self.FOLDER_GROUP:
-            self._validate_folder_settings()
-        elif group == self.STORY_ARC_GROUP:
-            self._validate_story_arc_settings()
-        else:
-            self._validate_browser_group_settings()
-
-        # Validate order
-        if self.order_key == "filename" and not self.admin_flags["folder_view"]:
-            pks = self.kwargs["pks"]
-            page = self.kwargs["page"]
-            route_changes = {"group": group, "pks": pks, "page": page}
-            reason = "order by filename not allowed by admin flag."
-            settings_mask = {"order_by": "sort_name"}
-            self._raise_redirect(reason, route_changes, settings_mask)
-
-    def init_request(self):
-        """Initialize request."""
-        super().init_request()
-        self._set_group_query_and_instance()
-
-    @extend_schema(request=BrowserBreadcrumbsView.input_serializer_class)
+    @extend_schema(request=BrowserTitleView.input_serializer_class)
     def get(self, *_args, **_kwargs):
         """Get browser settings."""
         self.init_request()

codex/views/browser/choices.py

@@ -1,7 +1,6 @@
 """View for marking comics read and unread."""
 
 from types import MappingProxyType
-from typing import ClassVar
 
 import pycountry
 from caseconverter import snakecase
@@ -27,7 +26,6 @@ from codex.serializers.browser.filters import (
     CharListField,
 )
 from codex.serializers.models.pycountry import PyCountrySerializer
-from codex.views.auth import IsAuthenticatedOrEnabledNonUsers
 from codex.views.browser.filters.annotations import (
     BrowserAnnotationsFilterView,
 )
@@ -50,38 +48,32 @@ _FIELD_TO_REL_MODEL_MAP = MappingProxyType(
         ),
     }
 )
+_NULL_NAMED_ROW = MappingProxyType({"pk": -1, "name": "_none_"})
+_BACK_REL_MAP = MappingProxyType(
+    {
+        ContributorPerson: "contributor__",
+        StoryArc: "storyarcnumber__",
+        IdentifierType: "identifier__",
+    }
+)
+_CLASS_REL_MAP = MappingProxyType(
+    {
+        Publisher: "publisher",
+        Imprint: "imprint",
+        Series: "series",
+        Volume: "volume",
+        Comic: "pk",
+        Folder: "parent_folder",
+        StoryArc: "story_arc_numbers__story_arc",
+        IdentifierType: "identifiers__identifier_type",
+    }
+)
+_SERIALIZER_MANY = False
 
 
 class BrowserChoicesViewBase(BrowserAnnotationsFilterView):
     """Get choices for filter dialog."""
 
-    permission_classes: ClassVar[list] = [IsAuthenticatedOrEnabledNonUsers]  # type: ignore
-
-    _CONTRIBUTORS_PERSON_REL = "contributors__person"
-    _STORY_ARC_REL = "story_arc_numbers__story_arc"
-    _IDENTIFIERS_REL = "identifiers__identifier_type"
-    _NULL_NAMED_ROW = MappingProxyType({"pk": -1, "name": "_none_"})
-    _BACK_REL_MAP = MappingProxyType(
-        {
-            ContributorPerson: "contributor__",
-            StoryArc: "storyarcnumber__",
-            IdentifierType: "identifier__",
-        }
-    )
-    _REL_MAP = MappingProxyType(
-        {
-            Publisher: "publisher",
-            Imprint: "imprint",
-            Series: "series",
-            Volume: "volume",
-            Comic: "pk",
-            Folder: "parent_folder",
-            StoryArc: "story_arc_numbers__story_arc",
-            IdentifierType: "identifiers__identifier_type",
-        }
-    )
-    _SERIALIZER_MANY = False
-
     @staticmethod
     def get_field_choices_query(comic_qs, field_name):
         """Get distinct values for the field."""
@@ -97,8 +89,8 @@ class BrowserChoicesViewBase(BrowserAnnotationsFilterView):
             LOG.error("No model to make filter choices!")
             m2m_filter = {}
         else:
-            model_rel: str = self._REL_MAP[self.model]  # type: ignore
-            back_rel = self._BACK_REL_MAP.get(model, "")
+            model_rel: str = _CLASS_REL_MAP[self.model]  # type: ignore
+            back_rel = _BACK_REL_MAP.get(model, "")
             back_rel += "comic__"
             back_rel += model_rel
             back_rel += "__in"
@@ -137,7 +129,7 @@ class BrowserChoicesViewBase(BrowserAnnotationsFilterView):
         """Return choices."""
         self.init_request()
         obj = self.get_object()
-        serializer = self.get_serializer(obj, many=self._SERIALIZER_MANY)
+        serializer = self.get_serializer(obj, many=_SERIALIZER_MANY)
         return Response(serializer.data)
 
 
@@ -225,7 +217,7 @@ class BrowserChoicesView(BrowserChoicesViewBase):
         # rows. :(
         if self.does_m2m_null_exist(comic_qs, rel):
             choices = list(qs)
-            choices.append(self._NULL_NAMED_ROW)
+            choices.append(_NULL_NAMED_ROW)
         else:
             choices = qs
         return choices

codex/views/browser/filters/annotations.py

@@ -5,10 +5,10 @@ from django.db.models.expressions import Value
 from django.db.models.fields import PositiveSmallIntegerField
 
 from codex.models.comic import Comic
-from codex.views.browser.base import BrowserBaseView
+from codex.views.browser.validate import BrowserValidateView
 
 
-class BrowserAnnotationsFilterView(BrowserBaseView):
+class BrowserAnnotationsFilterView(BrowserValidateView):
     """Annotations that also filter."""
 
     ONE_INTEGERFIELD = Value(1, PositiveSmallIntegerField())

codex/views/browser/filters/bookmark.py

@@ -2,20 +2,16 @@
 
 from django.db.models import Q
 
-from codex.serializers.choices import CHOICES
-
 
 class BookmarkFilterMixin:
     """BookmarkFilter view methods."""
 
-    _BOOKMARK_FILTERS = frozenset(set(CHOICES["bookmarkFilter"].keys()) - {"ALL"})
-
     def get_bm_rel(self, model):
         """Create bookmark relation."""
         rel_prefix = self.get_rel_prefix(model)  # type: ignore
         return rel_prefix + "bookmark"
 
-    def _get_my_bookmark_filter(self, bm_rel):
+    def get_my_bookmark_filter(self, bm_rel):
         """Get a filter for my session or user defined bookmarks."""
         if self.request.user.is_authenticated:  # type: ignore
             my_bookmarks_kwargs = {f"{bm_rel}__user": self.request.user}  # type: ignore
@@ -28,11 +24,15 @@ class BookmarkFilterMixin:
 
     def get_bookmark_filter(self, model):
         """Build bookmark query."""
-        choice = self.params["filters"].get("bookmark", "ALL")  # type: ignore
-        if choice in self._BOOKMARK_FILTERS:
+        choice = self.params["filters"].get("bookmark", "")  # type: ignore
+        if choice:
             bm_rel = self.get_bm_rel(model)
-            my_bookmark_filter = self._get_my_bookmark_filter(bm_rel)
-            if choice in ("UNREAD", "IN_PROGRESS"):
+            my_bookmark_filter = self.get_my_bookmark_filter(bm_rel)
+            if choice == "READ":
+                bookmark_filter = my_bookmark_filter & Q(
+                    **{f"{bm_rel}__finished": True}
+                )
+            else:
                 my_not_finished_filter = my_bookmark_filter & Q(
                     **{f"{bm_rel}__finished__in": (False, None)}
                 )
@@ -42,10 +42,6 @@ class BookmarkFilterMixin:
                     bookmark_filter = my_not_finished_filter & Q(
                         **{f"{bm_rel}__page__gt": 0}
                     )
-            else:  # READ
-                bookmark_filter = my_bookmark_filter & Q(
-                    **{f"{bm_rel}__finished": True}
-                )
         else:
             bookmark_filter = Q()
         return bookmark_filter