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

codex/views/browser/browser.py

@@ -2,10 +2,8 @@
 
 from math import ceil, floor, log10
 from types import MappingProxyType
-from typing import TYPE_CHECKING
 
-from django.db.models import Max, Subquery
-from django.db.models.expressions import OuterRef
+from django.db.models import Max
 from django.db.utils import OperationalError
 from drf_spectacular.utils import extend_schema
 from rest_framework.response import Response
@@ -13,12 +11,9 @@ 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
@@ -26,24 +21,10 @@ 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):
@@ -59,61 +40,31 @@ class BrowserView(BrowserTitleView):
     )
     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.valid_nav_groups: tuple[str, ...] = ()
+    ########
+    # Init #
+    ########
 
-    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):
+    @property
+    def 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'
-        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]
+        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
 
     ################
     # MAIN QUERIES #
@@ -134,8 +85,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
@@ -148,20 +99,19 @@ class BrowserView(BrowserTitleView):
             qs = model.objects.none()
 
         if count:
-            qs = self.annotate_order_aggregates(qs, model)
-            qs = self.add_order_by(qs, model)
+            qs = self.annotate_order_aggregates(qs)
+            qs = self.add_order_by(qs)
             if limit:
                 qs = qs[:limit]
+        else:
+            qs = qs.order_by("pk")
 
         return qs, count
 
     def _get_group_queryset(self):
         """Create group queryset."""
-        if not self.model:
-            reason = "Model not set for browser queryset."
-            raise ValueError(reason)
-        if self.is_model_comic:
-            qs = self.model.objects.none()
+        if self.model is Comic:
+            qs = self.model.objects.none().order_by("pk")
             count = 0
         else:
             qs, count = self._get_common_queryset(self.model)
@@ -173,28 +123,10 @@ class BrowserView(BrowserTitleView):
         if self.model in (Comic, Folder):
             qs, count = self._get_common_queryset(Comic)
         else:
-            qs = Comic.objects.none()
+            qs = Comic.objects.none().order_by("pk")
             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."""
@@ -207,12 +139,16 @@ class BrowserView(BrowserTitleView):
         return zero_pad
 
     def _get_page_mtime(self):
-        if not self.is_bookmark_filtered and self.group_instance:
-            # Nice optimization if we can get get it.
-            return self.group_instance.updated_at
+        return self.get_group_mtime(self.model, page_mtime=True)
 
-        group_model = self.group_class if self.group_class else self.model
-        return self.get_group_mtime(group_model, page_mtime=True)
+    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)
 
     def _get_group_and_books(self):
         """Create the main queries with filters, annotation and pagination."""
@@ -228,22 +164,22 @@ class BrowserView(BrowserTitleView):
 
         # Annotate
         if page_group_count:
-            group_qs = self.annotate_card_aggregates(group_qs, self.model)
-            group_qs = self._requery_max_bookmark_updated_at(group_qs)
+            group_qs = self.annotate_card_aggregates(group_qs)
+            group_qs = self.force_inner_joins(group_qs)
         if page_book_count:
             zero_pad = self._get_zero_pad(book_qs)
-            book_qs = self.annotate_card_aggregates(book_qs, Comic)
+            book_qs = self.annotate_card_aggregates(book_qs)
+            book_qs = self.force_inner_joins(book_qs)
         else:
             zero_pad = 1
 
-        # print(book_qs.explain())
-        # print(book_qs.query)
+        # self._debug_queries(page_group_count, page_book_count, group_qs, book_qs)
 
         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):
+    def get_object(self):  # type: ignore
         """Validate settings and get the querysets."""
         group_qs, book_qs, num_pages, total_count, zero_pad, mtime = (
             self._get_group_and_books()
@@ -255,7 +191,6 @@ 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(
             {
@@ -278,7 +213,6 @@ 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,12 +1,14 @@
 """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,
@@ -21,24 +23,26 @@ from codex.serializers.browser.filters import (
     BrowserFilterChoicesSerializer,
 )
 from codex.serializers.browser.settings import BrowserFilterChoicesInputSerilalizer
-from codex.serializers.choices import DUMMY_NULL_NAME, VUETIFY_NULL_CODE
-from codex.views.browser.filters.annotations import (
-    BrowserAnnotationsFilterView,
+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,
 )
 
 LOG = get_logger(__name__)
 
 _FIELD_TO_REL_MODEL_MAP = MappingProxyType(
     {
-        BrowserAnnotationsFilterView.CONTRIBUTOR_PERSON_UI_FIELD: (
+        CONTRIBUTOR_PERSON_UI_FIELD: (
             "contributors__person",
             ContributorPerson,
         ),
-        BrowserAnnotationsFilterView.STORY_ARC_UI_FIELD: (
+        STORY_ARC_UI_FIELD: (
             "story_arc_numbers__story_arc",
             StoryArc,
         ),
-        BrowserAnnotationsFilterView.IDENTIFIER_TYPE_UI_FIELD: (
+        IDENTIFIER_TYPE_UI_FIELD: (
             "identifiers__identifier_type",
             IdentifierType,
         ),
@@ -54,18 +58,12 @@ _BACK_REL_MAP = MappingProxyType(
 _NULL_NAMED_ROW = MappingProxyType({"pk": VUETIFY_NULL_CODE, "name": DUMMY_NULL_NAME})
 
 
-class BrowserChoicesViewBase(BrowserAnnotationsFilterView):
+class BrowserChoicesViewBase(BrowserFilterView):
     """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."""
@@ -100,14 +98,13 @@ class BrowserChoicesViewBase(BrowserAnnotationsFilterView):
 
         return rel, model
 
-    def get_object(self):
+    def get_object(self) -> QuerySet:  # type: ignore
         """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)
@@ -139,13 +136,13 @@ class BrowserChoicesAvailableView(BrowserChoicesViewBase):
 
         return count
 
-    def get_object(self):
+    def get_object(self) -> dict[str, Any]:  # type: ignore
         """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 self.model == StoryArc:
+            if field_name == "story_arcs" and qs.model is StoryArc:
                 # don't allow filtering on story arc in story arc view.
                 continue
             rel, m2m_model = self.get_rel_and_model(field_name)
@@ -188,7 +185,7 @@ class BrowserChoicesView(BrowserChoicesViewBase):
         field_name = self.kwargs.get("field_name", "")
         return snakecase(field_name)
 
-    def get_object(self):
+    def get_object(self) -> dict[str, Any]:  # type: ignore
         """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 CoverCreateMixin
+from codex.librarian.covers.create import CoverCreateThread
 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.annotations import BrowserAnnotationsView
+from codex.views.browser.annotate.order import BrowserAnnotateOrderView
 from codex.views.const import (
     CUSTOM_COVER_GROUP_RELATION,
     GROUP_RELATION,
@@ -41,7 +41,7 @@ class WEBPRenderer(BaseRenderer):
         return data
 
 
-class CoverView(BrowserAnnotationsView):
+class CoverView(BrowserAnnotateOrderView):
     """ComicCover View."""
 
     input_serializer_class = BrowserCoverInputSerializer
@@ -49,7 +49,7 @@ class CoverView(BrowserAnnotationsView):
     content_type = "image/webp"
     TARGET = "cover"
     REPARSE_JSON_FIELDS = frozenset(
-        BrowserAnnotationsView.REPARSE_JSON_FIELDS | {"parent"}
+        BrowserAnnotateOrderView.REPARSE_JSON_FIELDS | {"parent"}
     )
 
     def get_group_filter(self, group=None, pks=None, page_mtime=False):
@@ -71,22 +71,13 @@ class CoverView(BrowserAnnotationsView):
             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 == Volume or not self.params.get("custom_covers"):
+        if self.model is Volume or not self.params.get("custom_covers"):
             return None
         group = self.kwargs["group"]
         group_rel = CUSTOM_COVER_GROUP_RELATION[group]
@@ -99,8 +90,8 @@ class CoverView(BrowserAnnotationsView):
     def _get_dynamic_cover(self):
         """Get dynamic cover."""
         comic_qs = self.get_filtered_queryset(Comic)
-        comic_qs = self.annotate_order_aggregates(comic_qs, Comic)
-        comic_qs = self.add_order_by(comic_qs, Comic)
+        comic_qs = self.annotate_order_aggregates(comic_qs)
+        comic_qs = self.add_order_by(comic_qs)
         comic_qs = comic_qs.only("pk")
         comic = comic_qs.first()
         cover_pk = comic.pk if comic else 0
@@ -108,7 +99,7 @@ class CoverView(BrowserAnnotationsView):
 
     def _get_cover_pk(self) -> tuple[int, bool]:
         """Get Cover Pk queryset for comic queryset."""
-        if self.model == Comic:
+        if self.model is Comic:
             cover_pk, custom = self._get_comic_cover()
         elif custom_cover := self._get_custom_cover():
             cover_pk = custom_cover.pk
@@ -136,7 +127,7 @@ class CoverView(BrowserAnnotationsView):
 
         cover_path = CoverPathMixin.get_cover_path(pk, custom)
         if not cover_path.exists():
-            thumb_buffer = CoverCreateMixin.create_cover_from_path(
+            thumb_buffer = CoverCreateThread.create_cover_from_path(
                 pk, cover_path, LOG, LIBRARIAN_QUEUE, custom
             )
             if not thumb_buffer:
@@ -148,13 +139,12 @@ class CoverView(BrowserAnnotationsView):
         return cover_file, content_type
 
     @extend_schema(
-        parameters=[BrowserAnnotationsView.input_serializer_class],
+        parameters=[BrowserAnnotateOrderView.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/bookmark.py

@@ -4,46 +4,45 @@ 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 BookmarkFilterMixin:
+class BrowserFilterBookmarkView(BrowserValidateView):
     """BookmarkFilter view methods."""
 
-    def init_bookmark_data(self):
+    def __init__(self, *args, **kwargs):
         """Initialize the bm_annotation_data."""
-        self._bm_annotation_data: dict[BrowserGroupModel, tuple[str, Q]] = {}
+        super().__init__(*args, **kwargs)
+        self._bm_rels: dict[BrowserGroupModel, str] = {}
+        self._bm_filters: dict[BrowserGroupModel, Q] = {}
 
     def _get_bm_rel(self, model):
         """Create bookmark relation."""
-        rel_prefix = self.get_rel_prefix(model)  # type: ignore
-        return rel_prefix + "bookmark"
+        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]
 
     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
+        if self.request.user and self.request.user.is_authenticated:
+            key = f"{bm_rel}__user"
+            value = self.request.user
         else:
             key = f"{bm_rel}__session__session_key"
-            my_bookmarks_kwargs = {
-                key: self.request.session.session_key  # type: ignore
-            }
+            value = self.request.session.session_key
+        my_bookmarks_kwargs = {key: value}
         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, my_bookmark_filter = self.get_bookmark_rel_and_filter(model)
+            bm_rel = self._get_bm_rel(model)
+            my_bookmark_filter = self._get_my_bookmark_filter(bm_rel)
             if choice == "READ":
                 bookmark_filter = my_bookmark_filter & Q(
                     **{f"{bm_rel}__finished": True}

codex/views/browser/filters/field.py

@@ -5,12 +5,17 @@ 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(
     {
-        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",
+        CONTRIBUTOR_PERSON_UI_FIELD: "contributors__person",
+        STORY_ARC_UI_FIELD: "story_arc_numbers__story_arc",
+        IDENTIFIER_TYPE_UI_FIELD: "identifiers__identifier_type",
     }
 )
 

codex/views/browser/filters/filter.py

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

codex/views/browser/filters/group.py

@@ -2,26 +2,29 @@
 
 from django.db.models import Q
 
+from codex.views.browser.params import BrowserParamsView
 from codex.views.const import (
     FILTER_ONLY_GROUP_RELATION,
     FOLDER_GROUP,
     GROUP_RELATION,
 )
-from codex.views.session import SessionView
 
+_GROUP_REL_TARGETS = frozenset({"cover", "choices"})
+_PK_REL_TARGETS = frozenset({"metadata", "mtime"})
 
-class GroupFilterView(SessionView):
+
+class GroupFilterView(BrowserParamsView):
     """Group Filters."""
 
-    SESSION_KEY = SessionView.BROWSER_SESSION_KEY
+    SESSION_KEY = BrowserParamsView.BROWSER_SESSION_KEY
 
     def _get_rel_for_pks(self, group, page_mtime=False):
         """Get the relation from the model to the pks."""
         # XXX these TARGET refs might be better as subclass get rel methods.
         target: str = self.TARGET  # type: ignore
-        if target in ("cover", "choices"):
+        if target in _GROUP_REL_TARGETS:
             rel = FILTER_ONLY_GROUP_RELATION[group]
-        elif target in ("metadata", "mtime") or page_mtime:
+        elif target in _PK_REL_TARGETS or page_mtime:
             # metadata, mtime, browser.page_mtime
             rel = "pk"
         else:
@@ -42,8 +45,8 @@ class GroupFilterView(SessionView):
             rel = self._get_rel_for_pks(group, page_mtime)
             group_filter_dict = {rel: pks}
         elif group == FOLDER_GROUP:
+            # Top folder search
             group_filter_dict = {"parent_folder": None}
         else:
             group_filter_dict = {}
-
         return Q(**group_filter_dict)