codex 1.6.0a6__py3-none-any.whl → 1.6.0a8__py3-none-any.whl

codex/views/browser/cover.py

@@ -0,0 +1,177 @@
+"""Comic cover thumbnail view."""
+
+from django.http import HttpResponse
+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.path import CoverPathMixin
+from codex.librarian.mp_queue import LIBRARIAN_QUEUE
+from codex.logger.logging import get_logger
+from codex.models import Comic, Folder, Volume
+from codex.models.paths import CustomCover
+from codex.serializers.choices import DEFAULTS
+from codex.views.browser.annotations import BrowserAnnotationsView
+from codex.views.const import (
+    GROUP_RELATION,
+    MISSING_COVER_FN,
+    MISSING_COVER_NAME_MAP,
+    STATIC_IMG_PATH,
+)
+
+LOG = get_logger(__name__)
+
+
+class WEBPRenderer(BaseRenderer):
+    """Render WEBP images."""
+
+    media_type = "image/webp"
+    format = "webp"
+    charset = None
+    render_style = "binary"
+
+    def render(self, data, *_args, **_kwargs):
+        """Return raw data."""
+        return data
+
+
+class CoverView(BrowserAnnotationsView):
+    """ComicCover View."""
+
+    renderer_classes = (WEBPRenderer,)
+    content_type = "image/webp"
+    TARGET = "cover"
+
+    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 _use_dynamic_cover(self):
+        if not self.params.get("dynamic_covers"):
+            return False
+        filters = self.params.get("filters", {})
+        for key, value in filters.items():
+            if key == "bookmark" and value != DEFAULTS["bookmarkFilter"]:
+                return True
+            if value:
+                return True
+
+        order_by = self.params.get("order_by")
+        default_order_by = "filename" if self.model == Folder else "sort_name"
+        if order_by != default_order_by:
+            return True
+
+        if self.params.get("order_reverse"):
+            return True
+
+        return False
+
+    def _get_dynamic_cover(self):
+        """Get dynamic cover."""
+        self.set_order_key()
+        pks = self.kwargs["pks"]
+
+        if self.model != Volume and self.params.get("custom_covers"):
+            group = self.kwargs["group"]
+            group_rel = "folder" if self.model == Folder else GROUP_RELATION[group]  # type: ignore
+            comic_filter = {f"{group_rel}__in": pks}
+            custom_cover = CustomCover.objects.filter(**comic_filter).only("pk").first()
+            if custom_cover:
+                return custom_cover.pk, True
+
+        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 = comic_qs.only("pk")
+        group_by = self.get_group_by(Comic)
+        comic_qs.group_by(group_by)
+        comic = comic_qs.first()
+        cover_pk = comic.pk if comic else 0
+        return cover_pk, False
+
+    def _get_first_cover(self):
+        """Get first cover."""
+        pks = self.kwargs["pks"]
+        order_by = (
+            "path"
+            if self.model == Folder
+            else "name"
+            if self.model == Volume
+            else "sort_name"
+        )
+        group_qs = self.model.objects.filter(pk__in=pks)  # type: ignore
+        group_qs = group_qs.order_by(order_by)
+        select_related = ["first_comic"]
+        custom_covers = self.params.get("custom_covers")
+        if custom_covers and self.model != Volume:
+            select_related.append("custom_cover")
+        group_qs = group_qs.select_related(*select_related)
+        group_qs = group_qs.group_by("id")  # type: ignore
+        group_obj = group_qs.first()
+        if custom_covers and self.model != Volume and group_obj.custom_cover:
+            return group_obj.custom_cover.pk, True
+        cover_pk = (
+            group_obj.first_comic.pk if group_obj and group_obj.first_comic else 0
+        )
+        return cover_pk, False
+
+    def _get_cover_pk(self) -> tuple[int, bool]:
+        """Get Cover Pk queryset for comic queryset."""
+        if self.model == Comic:
+            cover_pk, custom = self._get_comic_cover()
+        elif self._use_dynamic_cover():
+            cover_pk, custom = self._get_dynamic_cover()
+        else:
+            cover_pk, custom = self._get_first_cover()
+        return cover_pk, custom
+
+    def _get_missing_cover_path(self):
+        """Get the missing cover, which is a default svg if fetched for a group."""
+        group: str = self.kwargs["group"]
+        cover_name = MISSING_COVER_NAME_MAP.get(group)
+        if cover_name:
+            cover_fn = cover_name + ".svg"
+            content_type = "image/svg+xml"
+        else:
+            cover_fn = MISSING_COVER_FN
+            content_type = "image/webp"
+        cover_path = STATIC_IMG_PATH / cover_fn
+        return cover_path, content_type
+
+    def _get_cover_data(self, pk, custom):
+        thumb_image_data = None
+        content_type = "image/webp"
+
+        cover_path = CoverPathMixin.get_cover_path(pk, custom)
+        if not cover_path.exists():
+            thumb_image_data = CoverCreateMixin.create_cover_from_path(
+                pk, cover_path, LOG, LIBRARIAN_QUEUE, custom
+            )
+            if not thumb_image_data:
+                cover_path, content_type = self._get_missing_cover_path()
+        elif cover_path.stat().st_size == 0:
+            cover_path, content_type = self._get_missing_cover_path()
+
+        if not thumb_image_data:
+            # if not thumb_image_data:
+            with cover_path.open("rb") as f:
+                thumb_image_data = f.read()
+        return thumb_image_data, content_type
+
+    @extend_schema(responses={(200, content_type): OpenApiTypes.BINARY})
+    def get(self, *args, **kwargs):  # type: ignore
+        """Get comic cover."""
+        self.init_request()
+        pk, custom = self._get_cover_pk()
+        thumb_image_data, content_type = self._get_cover_data(pk, custom)
+        return HttpResponse(thumb_image_data, content_type=content_type)

codex/views/browser/filters/annotations.py

@@ -1,34 +1,35 @@
 """Annotations used by a filter."""
 
 from django.db.models.aggregates import Count
-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.filters.bookmark import BookmarkFilterMixin
+from codex.views.browser.validate import BrowserValidateView
 
 
-class BrowserAnnotationsFilterView(BrowserBaseView):
+class BrowserAnnotationsFilterView(BrowserValidateView, BookmarkFilterMixin):
     """Annotations that also filter."""
 
-    ONE_INTEGERFIELD = Value(1, PositiveSmallIntegerField())
+    def get_query_filters(self, model):
+        """Return all the filters except the group filter."""
+        object_filter = self.get_group_acl_filter(model)
+        object_filter &= self.get_bookmark_filter(model)
+        object_filter &= self.get_comic_field_filter(model)
+        object_filter &= self.get_group_filter(model)
+        return object_filter
 
-    def _annotate_child_count(self, qs, model):
-        """Annotate Child Count."""
+    def _filter_by_child_count(self, qs, model):
         if model == Comic:
-            child_count_sum = self.ONE_INTEGERFIELD
-        else:
-            child_count_sum = Count(self.rel_prefix + "pk", distinct=True)
-        if self.TARGET == "opds2":
-            if model != Comic:
-                qs = qs.alias(child_count=child_count_sum)
-        else:
-            qs = qs.annotate(child_count=child_count_sum)
-        if model != Comic:
-            qs = qs.filter(child_count__gt=0)
-        return qs
-
-    def filter_by_annotations(self, qs, model, binary=False):
-        """Filter queryset by annotations."""
-        qs = self._annotate_child_count(qs, model)
-        return self.apply_search_filter(qs, model, binary=binary)
+            return qs
+
+        rel = self.rel_prefix + "pk"
+        qs = qs.alias(pre_search_child_count=Count(rel, distinct=True))
+        return qs.filter(pre_search_child_count__gt=0)
+
+    def get_filtered_queryset(self, model):
+        """Get a filtered queryset for the model."""
+        object_filter = self.get_query_filters(model)
+
+        qs = model.objects.filter(object_filter)
+        qs = self._filter_by_child_count(qs, model)
+        return self.apply_search_filter(qs, model)

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

codex/views/browser/filters/field.py

@@ -5,18 +5,18 @@ from types import MappingProxyType
 from django.db.models import Q
 
 from codex.models.comic import Comic
-from codex.views.session import BrowserSessionViewBase
+from codex.views.browser.filters.group import GroupFilterView
 
 _FILTER_REL_MAP = MappingProxyType(
     {
-        BrowserSessionViewBase.CONTRIBUTOR_PERSON_UI_FIELD: "contributors__person",
-        BrowserSessionViewBase.STORY_ARC_UI_FIELD: "story_arc_numbers__story_arc",
-        BrowserSessionViewBase.IDENTIFIER_TYPE_UI_FIELD: "identifiers__identifier_type",
+        GroupFilterView.CONTRIBUTOR_PERSON_UI_FIELD: "contributors__person",
+        GroupFilterView.STORY_ARC_UI_FIELD: "story_arc_numbers__story_arc",
+        GroupFilterView.IDENTIFIER_TYPE_UI_FIELD: "identifiers__identifier_type",
     }
 )
 
 
-class ComicFieldFilter(BrowserSessionViewBase):
+class ComicFieldFilterView(GroupFilterView):
     """Comic field filters."""
 
     def _filter_by_comic_field(self, field, rel_prefix):

codex/views/browser/filters/group.py

@@ -2,25 +2,33 @@
 
 from django.db.models import Q
 
-from codex.views.auth import GroupACLMixin
+from codex.models import Comic
+from codex.views.const import FOLDER_GROUP, GROUP_MODEL_MAP, GROUP_RELATION
+from codex.views.session import SessionView
 
 
-class GroupFilterMixin(GroupACLMixin):
+class GroupFilterView(SessionView):
     """Group Filters."""
 
-    def get_group_filter(self, choices):
+    SESSION_KEY = SessionView.BROWSER_SESSION_KEY
+
+    def get_group_filter(self, model):
         """Get filter for the displayed group."""
         group = self.kwargs["group"]  # type: ignore
         pks = self.kwargs["pks"]  # type: ignore
         if pks:  # type: ignore
-            group_relation = "comic__" if choices else ""
-            if choices and group == self.FOLDER_GROUP:
-                group_relation += "folders"
+            if model == GROUP_MODEL_MAP.get(group):
+                # metadata only
+                rel = "pk"
+            elif model == Comic and group == FOLDER_GROUP:
+                # choices & covers
+                rel = "folders"
             else:
-                group_relation += self.GROUP_RELATION[group]
-            group_relation += "__in"
-            group_filter_dict = {group_relation: pks}  # type: ignore
-        elif group == self.FOLDER_GROUP:
+                rel = GROUP_RELATION[group]
+
+            rel += "__in"
+            group_filter_dict = {rel: pks}  # type: ignore
+        elif group == FOLDER_GROUP:
             group_filter_dict = {"parent_folder": None}
         else:
             group_filter_dict = {}

codex/views/browser/filters/search.py

@@ -9,12 +9,13 @@ from codex.logger.logging import get_logger
 from codex.models import Comic
 from codex.search.query import CodexSearchQuerySet
 from codex.settings.settings import DEBUG
-from codex.views.browser.const import MAX_OBJ_PER_PAGE
+from codex.views.browser.filters.field import ComicFieldFilterView
+from codex.views.const import MAX_OBJ_PER_PAGE
 
 LOG = get_logger(__name__)
-SEARCH_SCORE_MAX = 100.0
-SEARCH_SCORE_MIN = 0.001
-SEARCH_SCORE_EMPTY = 0.0
+_SEARCH_SCORE_MAX = 100.0
+_SEARCH_SCORE_MIN = 0.001
+_SEARCH_SCORE_EMPTY = 0.0
 
 
 @dataclass
@@ -26,9 +27,11 @@ class SearchScorePks:
     next_pks: tuple[int, ...] = ()
 
 
-class SearchFilterMixin:
+class SearchFilterView(ComicFieldFilterView):
     """Search Filters Methods."""
 
+    TARGET = ""
+
     def _is_search_results_limited(self) -> bool:
         """Get search result limit from params."""
         # user = self.request.user  # type: ignore
@@ -114,7 +117,7 @@ class SearchFilterMixin:
 
         return tuple(scores_pairs), tuple(prev_pks), tuple(next_pks), tuple(scored_pks)
 
-    def _get_search_scores(self, binary=False):
+    def _get_search_scores(self, model, qs):
         """Perform the search and return the scores as a dict."""
         text = self.params.get("q", "")  # type: ignore
         if not text:
@@ -127,13 +130,21 @@ class SearchFilterMixin:
         try:
             sqs = CodexSearchQuerySet()
             sqs = sqs.auto_query(text)  # .filter(score__gt=0.0)
-            binary = binary or self.params.get("order_by") != "search_score"  # type: ignore
-            if binary:
-                scored_pks = self._get_binary_search_scores(sqs)
-            else:
-                score_pairs, prev_pks, next_pks, scored_pks = (
-                    self._get_browser_search_scores(sqs)
+            prefix = "" if model == Comic else self.rel_prefix  # type: ignore
+            comic_ids = qs.values_list(prefix + "pk", flat=True)
+            if comic_ids:
+                # Prefilter comic ids. If nothing is allowed, don't search.
+                sqs = sqs.filter_comic_ids(comic_ids)
+                binary = (
+                    self.TARGET in frozenset({"cover", "choices"})
+                    or self.params.get("order_by", "") != "search_score"
                 )
+                if binary:
+                    scored_pks = self._get_binary_search_scores(sqs)
+                else:
+                    score_pairs, prev_pks, next_pks, scored_pks = (
+                        self._get_browser_search_scores(sqs)
+                    )
         except MemoryError:
             LOG.warning("Search engine needs more memory, results truncated.")
         except Exception:
@@ -154,10 +165,12 @@ class SearchFilterMixin:
                 when = {prefix + "pk": pk, "then": score}
                 whens.append(When(**when))
             if prev_pks:
-                whens.append(When(pk__in=prev_pks, then=SEARCH_SCORE_MAX))
+                whens.append(When(pk__in=prev_pks, then=_SEARCH_SCORE_MAX))
             if next_pks:
-                whens.append(When(pk__in=next_pks, then=SEARCH_SCORE_MIN))
-            search_score = self.order_agg_func(Case(*whens, default=SEARCH_SCORE_EMPTY))  # type: ignore
+                whens.append(When(pk__in=next_pks, then=_SEARCH_SCORE_MIN))
+            search_score = self.order_agg_func(  # type: ignore
+                Case(*whens, default=_SEARCH_SCORE_EMPTY)
+            )
         else:
             search_score = Value(0.0)
         return qs.annotate(search_score=search_score)
@@ -168,17 +181,16 @@ class SearchFilterMixin:
         rel = prefix + "pk__in"
         return {rel: scored_pks}
 
-    def apply_search_filter(self, qs, model, binary=False):
+    def apply_search_filter(self, qs, model):
         """Preparse search, search and return the filter and scores."""
         try:
             score_pairs, prev_pks, next_pks, scored_pks = self._get_search_scores(
-                binary
+                model, qs
             )
             qs = self.annotate_search_score(qs, model, score_pairs, prev_pks, next_pks)
             if score_pairs or scored_pks:
                 search_filter = self._get_search_query_filter(model, scored_pks)
                 qs = qs.filter(**search_filter)
-                self.cover_search_score_pairs = score_pairs
         except Exception:
             LOG.exception("Creating the search filter")
 

codex/views/browser/metadata.py

@@ -1,7 +1,6 @@
 """View for marking comics read and unread."""
 
 from types import MappingProxyType
-from typing import ClassVar
 
 from django.core.exceptions import FieldDoesNotExist
 from django.db.models import Count, IntegerField, Sum, Value
@@ -9,12 +8,13 @@ from drf_spectacular.utils import extend_schema
 from rest_framework.exceptions import NotFound
 from rest_framework.response import Response
 
-from codex.librarian.importer.const import COMIC_M2M_FIELD_NAMES
+from codex.librarian.importer.const import (
+    COMIC_M2M_FIELD_NAMES,
+)
 from codex.logger.logging import get_logger
 from codex.models import AdminFlag, Comic
 from codex.serializers.browser.metadata import MetadataSerializer
-from codex.views.auth import IsAuthenticatedOrEnabledNonUsers
-from codex.views.browser.browser_annotations import BrowserAnnotationsView
+from codex.views.browser.annotations import BrowserAnnotationsView
 
 LOG = get_logger(__name__)
 _ADMIN_OR_FILE_VIEW_ENABLED_COMIC_VALUE_FIELDS = frozenset({"path"})
@@ -37,7 +37,7 @@ _COMIC_VALUE_FIELD_NAMES = frozenset(
 )
 _COMIC_VALUE_FIELDS_CONFLICTING_PREFIX = "conflict_"
 _COMIC_RELATED_VALUE_FIELDS = frozenset({"series__volume_count", "volume__issue_count"})
-_PATH_GROUPS = ("c", "f")
+_PATH_GROUPS = frozenset({"c", "f"})
 _CONTRIBUTOR_RELATIONS = ("role", "person")
 _SUM_FIELDS = frozenset({"page_count", "size"})
 _GROUP_RELS = frozenset({"publisher", "imprint", "series", "volume"})
@@ -46,7 +46,6 @@ _GROUP_RELS = frozenset({"publisher", "imprint", "series", "volume"})
 class MetadataView(BrowserAnnotationsView):
     """Comic metadata."""
 
-    permission_classes: ClassVar[list] = [IsAuthenticatedOrEnabledNonUsers]  # type: ignore
     serializer_class = MetadataSerializer
     TARGET = "metadata"
     ADMIN_FLAG_VALUE_KEY_MAP = MappingProxyType(
@@ -55,6 +54,11 @@ class MetadataView(BrowserAnnotationsView):
         }
     )
 
+    def set_valid_browse_nav_groups(self, valid_top_groups):  # noqa: ARG002
+        """Limited allowed nav groups for metadata."""
+        group = self.kwargs["group"]
+        self.valid_nav_groups = (group,)
+
     def _get_comic_value_fields(self):
         """Include the path field for staff."""
         fields = set(_COMIC_VALUE_FIELD_NAMES)
@@ -156,6 +160,8 @@ class MetadataView(BrowserAnnotationsView):
             if field_name in _GROUP_RELS:
                 group_by = "name" if field_name == "volume" else "sort_name"
                 intersection_qs = intersection_qs.group_by(group_by)
+            if field_name == "identifiers":
+                intersection_qs = intersection_qs.select_related("identifier_type")
             intersection_qs = intersection_qs.alias(count=Count("comic")).filter(
                 count=comic_pks_count
             )
@@ -188,18 +194,18 @@ class MetadataView(BrowserAnnotationsView):
     def _get_optimized_m2m_query(key, qs):
         # XXX The prefetch gets removed by field.set() :(
         if key == "contributors":
-            optimized_qs = qs.prefetch_related(*_CONTRIBUTOR_RELATIONS).only(
+            qs = qs.prefetch_related(*_CONTRIBUTOR_RELATIONS).only(
                 *_CONTRIBUTOR_RELATIONS
             )
         elif key == "story_arc_numbers":
-            optimized_qs = qs.prefetch_related("story_arc").only("story_arc", "number")
+            qs = qs.prefetch_related("story_arc")
+            qs = qs.only("story_arc", "number")
         elif key == "identifiers":
-            optimized_qs = qs.prefetch_related("identifier_type").only(
-                "identifier_type", "nss", "url"
-            )
+            qs = qs.prefetch_related("identifier_type")
+            qs = qs.only("identifier_type", "nss", "url")
         else:
-            optimized_qs = qs.only("name")
-        return optimized_qs
+            qs = qs.only("name")
+        return qs
 
     @classmethod
     def _copy_m2m_intersections(cls, obj, m2m_intersections):
@@ -247,27 +253,17 @@ class MetadataView(BrowserAnnotationsView):
         # values dicts don't copy relations to the serializer. The values
         # dict is necessary because of the folders view union in browser.py.
 
-        if self.model is None:
-            # TODO this looks redundant after set_browse_model
-            group = self.kwargs["group"]
-            raise NotFound(detail=f"Cannot get metadata for {group=}")
+        qs = self.get_filtered_queryset(self.model)
 
-        object_filter = self.get_query_filters_without_group(self.model)  # type: ignore
-        pks = self.kwargs["pks"]
-        qs = self.model.objects.filter(object_filter, pk__in=pks)
-        qs = self.filter_by_annotations(qs, self.model, binary=True)
         filtered_qs = qs
         qs = self.annotate_order_aggregates(qs, self.model)
         qs = self.annotate_card_aggregates(qs, self.model)
-        qs = self.annotate_for_metadata(qs, self.model)
+        qs = self._annotate_values_and_fks(qs, filtered_qs)
         group_by = self.get_group_by()
         qs = qs.group_by(group_by)
-        qs = self._annotate_values_and_fks(qs, filtered_qs)
-
-        qs_list = self.re_cover_multi_groups(qs)
 
         try:
-            obj = qs_list[0]
+            obj = qs[0]
             if not obj:
                 reason = "Empty obj"
                 raise ValueError(reason)  # noqa TRY301
@@ -277,11 +273,6 @@ class MetadataView(BrowserAnnotationsView):
         m2m_intersections = self._query_m2m_intersections(filtered_qs)
         return self._copy_annotations_into_comic_fields(obj, m2m_intersections)  # type: ignore
 
-    def set_valid_browse_nav_groups(self, _valid_top_groups):
-        """Limited allowed nav groups for metadata."""
-        group = self.kwargs["group"]
-        self.valid_nav_groups = (group,)
-
     @extend_schema(request=BrowserAnnotationsView.input_serializer_class)
     def get(self, *_args, **_kwargs):
         """Get metadata for a filtered browse group."""

codex/views/browser/{browser_order_by.py → order_by.py}

@@ -6,22 +6,18 @@ from codex.models import Comic
 from codex.views.browser.filters.annotations import (
     BrowserAnnotationsFilterView,
 )
+from codex.views.const import FOLDER_GROUP
 
 
 class BrowserOrderByView(BrowserAnnotationsFilterView):
     """Base class for views that need ordering."""
 
-    def __init__(self, *args, **kwargs):
-        """Set params for the type checker."""
-        super().__init__(*args, **kwargs)
-        self.order_key: str = ""
-
     def set_order_key(self):
         """Get the default order key for the view."""
         order_key: str = self.params.get("order_by", "")  # type: ignore
         if not order_key:
             group = self.kwargs.get("group")
-            order_key = "filename" if group == self.FOLDER_GROUP else "sort_name"
+            order_key = "filename" if group == FOLDER_GROUP else "sort_name"
         self.order_key: str = order_key
         order_reverse = self.params.get("order_reverse")
         self.order_agg_func = Max if order_reverse else Min