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

codex/views/browser/browser.py

@@ -121,9 +121,7 @@ class BrowserView(BrowserTitleView):
     ################
     def _get_common_queryset(self, model):
         """Create queryset common to group & books."""
-        object_filter = self.get_query_filters(model, False)
-        qs = model.objects.filter(object_filter)
-        qs = self.filter_by_annotations(qs, model)
+        qs = self.get_filtered_queryset(model)
         count_group_by = self.get_group_by(model)
         count = qs.group_by(count_group_by).count()
         if count:
@@ -184,14 +182,12 @@ class BrowserView(BrowserTitleView):
     def _get_group_and_books(self):
         """Create the main queries with filters, annotation and pagination."""
         group_qs, group_count = self._get_group_queryset()
+        mtime = self._get_page_mtime(group_qs)
         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
         )
-        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:
@@ -203,13 +199,12 @@ class BrowserView(BrowserTitleView):
         # print(group_qs.explain())
         # print(group_qs.query)
 
-        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, mtime
+        return group_qs, 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, mtime = (
+        group_qs, book_qs, num_pages, total_count, zero_pad, mtime = (
             self._get_group_and_books()
         )
 
@@ -226,7 +221,7 @@ class BrowserView(BrowserTitleView):
                 "breadcrumbs": parent_breadcrumbs,
                 "title": title,
                 "model_group": self.model_group,
-                "groups": group_list,
+                "groups": group_qs,
                 "books": book_qs,
                 "zero_pad": zero_pad,
                 "num_pages": num_pages,

codex/views/browser/choices.py

@@ -12,12 +12,7 @@ from codex.logger.logging import get_logger
 from codex.models import (
     Comic,
     ContributorPerson,
-    Folder,
-    Imprint,
-    Publisher,
-    Series,
     StoryArc,
-    Volume,
 )
 from codex.models.named import IdentifierType
 from codex.serializers.browser.choices import CHOICES_SERIALIZER_CLASS_MAP
@@ -48,7 +43,6 @@ _FIELD_TO_REL_MODEL_MAP = MappingProxyType(
         ),
     }
 )
-_NULL_NAMED_ROW = MappingProxyType({"pk": -1, "name": "_none_"})
 _BACK_REL_MAP = MappingProxyType(
     {
         ContributorPerson: "contributor__",
@@ -56,24 +50,15 @@ _BACK_REL_MAP = MappingProxyType(
         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
+_NULL_NAMED_ROW = MappingProxyType({"pk": -1, "name": "_none_"})
 
 
 class BrowserChoicesViewBase(BrowserAnnotationsFilterView):
     """Get choices for filter dialog."""
 
+    SERIALIZER_MANY = False
+    TARGET = "choices"
+
     @staticmethod
     def get_field_choices_query(comic_qs, field_name):
         """Get distinct values for the field."""
@@ -85,21 +70,13 @@ class BrowserChoicesViewBase(BrowserAnnotationsFilterView):
 
     def get_m2m_field_query(self, model, comic_qs: QuerySet):
         """Get distinct m2m value objects for the relation."""
-        if self.model is None:
-            LOG.error("No model to make filter choices!")
-            m2m_filter = {}
-        else:
-            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"
-            m2m_filter = {back_rel: comic_qs}
+        back_rel = _BACK_REL_MAP.get(model, "")
+        m2m_filter = {f"{back_rel}comic__in": comic_qs}
         return model.objects.filter(**m2m_filter).values("pk", "name").distinct()
 
     @staticmethod
     def does_m2m_null_exist(comic_qs, rel):
-        """Get if null values exists for an m2m field."""
+        """Get if comics exist in the filter without values exists for an m2m field."""
         return comic_qs.filter(**{f"{rel}__isnull": True}).exists()
 
     def get_rel_and_model(self, field_name):
@@ -114,22 +91,18 @@ class BrowserChoicesViewBase(BrowserAnnotationsFilterView):
             rel = field_name
             model = remote_field.model if remote_field else None
 
-        rel = self.rel_prefix + rel
-
         return rel, model
 
     def get_object(self):
         """Get the comic subquery use for the choices."""
-        object_filter = self.get_query_filters(self.model, choices=True)
-        qs = self.model.objects.filter(object_filter)  # type: ignore
-        return self.filter_by_annotations(qs, self.model, binary=True)
+        return self.get_filtered_queryset(Comic)
 
     @extend_schema(request=BrowserAnnotationsFilterView.input_serializer_class)
     def get(self, *_args, **_kwargs):
         """Return choices."""
         self.init_request()
         obj = self.get_object()
-        serializer = self.get_serializer(obj, many=_SERIALIZER_MANY)
+        serializer = self.get_serializer(obj, many=self.SERIALIZER_MANY)
         return Response(serializer.data)
 
 
@@ -162,6 +135,7 @@ class BrowserChoicesAvailableView(BrowserChoicesViewBase):
     def get_object(self):
         """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:
@@ -174,9 +148,9 @@ class BrowserChoicesAvailableView(BrowserChoicesViewBase):
             else:
                 count = self._get_field_choices_count(qs, rel)
 
-            filters = self.params.get("filters", {})
             try:
-                flag = count > 1 or field_name in filters  # type: ignore
+                is_filter_set = bool(filters.get(field_name))
+                flag = is_filter_set or count > 1  # type: ignore
             except TypeError:
                 flag = False
             data[field_name] = flag
@@ -187,7 +161,9 @@ class BrowserChoicesView(BrowserChoicesViewBase):
     """Get choices for filter dialog."""
 
     # serializer_class = Dynamic class determined in get()
-    _SERIALIZER_MANY = True
+    SERIALIZER_MANY = True
+    # HACK get_serializer(data, many=True) requires this to be set for the debug API view
+    queryset = Comic.objects.none()
 
     def _get_field_choices(self, comic_qs, field_name):
         """Create a pk:name object for fields without tables."""

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.filters.bookmark import BookmarkFilterMixin
 from codex.views.browser.validate import BrowserValidateView
 
 
-class BrowserAnnotationsFilterView(BrowserValidateView):
+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/field.py

@@ -5,7 +5,6 @@ from types import MappingProxyType
 from django.db.models import Q
 
 from codex.models.comic import Comic
-from codex.views.browser.filters.bookmark import BookmarkFilterMixin
 from codex.views.browser.filters.group import GroupFilterView
 
 _FILTER_REL_MAP = MappingProxyType(
@@ -17,7 +16,7 @@ _FILTER_REL_MAP = MappingProxyType(
 )
 
 
-class ComicFieldFilterView(GroupFilterView, BookmarkFilterMixin):
+class ComicFieldFilterView(GroupFilterView):
     """Comic field filters."""
 
     def _filter_by_comic_field(self, field, rel_prefix):

codex/views/browser/filters/group.py

@@ -2,7 +2,8 @@
 
 from django.db.models import Q
 
-from codex.views.const import FOLDER_GROUP, GROUP_RELATION
+from codex.models import Comic
+from codex.views.const import FOLDER_GROUP, GROUP_MODEL_MAP, GROUP_RELATION
 from codex.views.session import SessionView
 
 
@@ -11,18 +12,22 @@ class GroupFilterView(SessionView):
 
     SESSION_KEY = SessionView.BROWSER_SESSION_KEY
 
-    def get_group_filter(self, choices):
+    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 == 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 += GROUP_RELATION[group]
-            group_relation += "__in"
-            group_filter_dict = {group_relation: pks}  # type: ignore
+                rel = GROUP_RELATION[group]
+
+            rel += "__in"
+            group_filter_dict = {rel: pks}  # type: ignore
         elif group == FOLDER_GROUP:
             group_filter_dict = {"parent_folder": None}
         else:

codex/views/browser/filters/search.py

@@ -30,6 +30,8 @@ class SearchScorePks:
 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
@@ -115,7 +117,7 @@ class SearchFilterView(ComicFieldFilterView):
 
         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:
@@ -128,13 +130,21 @@ class SearchFilterView(ComicFieldFilterView):
         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:
@@ -171,17 +181,16 @@ class SearchFilterView(ComicFieldFilterView):
         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

@@ -8,7 +8,9 @@ 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
@@ -52,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)
@@ -153,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
             )
@@ -185,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):
@@ -244,26 +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_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
@@ -273,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):  # noqa: ARG002
-        """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/const.py

@@ -64,6 +64,18 @@ GROUP_RELATION = MappingProxyType(
         STORY_ARC_GROUP: "story_arc_numbers__story_arc",
     }
 )
+GROUP_ORDER = "rpisv"
+MODEL_REL_MAP = MappingProxyType(
+    {
+        Publisher: "publisher",
+        Imprint: "imprint",
+        Series: "series",
+        Volume: "volume",
+        Folder: "parent_folder",
+        StoryArc: "story_arc_numbers__story_arc",
+        Comic: "pk",
+    }
+)
 GROUP_MODEL_MAP: MappingProxyType[str, type[BrowserGroupModel] | None] = (
     MappingProxyType(
         {