codex 1.6.0a9__py3-none-any.whl → 1.6.0a10__py3-none-any.whl

codex/views/browser/cover.py

@@ -9,12 +9,12 @@ 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 import Comic, Volume
 from codex.models.paths import CustomCover
-from codex.serializers.choices import DEFAULTS
+from codex.serializers.browser.settings import BrowserCoverInputSerializer
 from codex.views.browser.annotations import BrowserAnnotationsView
 from codex.views.const import (
-    GROUP_RELATION,
+    CUSTOM_COVER_GROUP_RELATION,
     MISSING_COVER_FN,
     MISSING_COVER_NAME_MAP,
     STATIC_IMG_PATH,
@@ -39,6 +39,7 @@ class WEBPRenderer(BaseRenderer):
 class CoverView(BrowserAnnotationsView):
     """ComicCover View."""
 
+    input_serializer_class = BrowserCoverInputSerializer
     renderer_classes = (WEBPRenderer,)
     content_type = "image/webp"
     TARGET = "cover"
@@ -56,39 +57,21 @@ class CoverView(BrowserAnnotationsView):
         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_custom_cover(self):
+        """Get Custom Cover."""
+        if self.model == Volume or not self.params.get("custom_covers"):
+            return None
+        group = self.kwargs["group"]
+        group_rel = CUSTOM_COVER_GROUP_RELATION[group]
+        pks = self.kwargs["pks"]
+        comic_filter = {f"{group_rel}__in": pks}
+        qs = CustomCover.objects.filter(**comic_filter)
+        qs = qs.only("pk")
+        return qs.first()
 
     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)
@@ -99,40 +82,15 @@ class CoverView(BrowserAnnotationsView):
         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()
+        elif custom_cover := self._get_custom_cover():
+            cover_pk = custom_cover.pk
+            custom = True
         else:
-            cover_pk, custom = self._get_first_cover()
+            cover_pk, custom = self._get_dynamic_cover()
         return cover_pk, custom
 
     def _get_missing_cover_path(self):
@@ -168,10 +126,16 @@ class CoverView(BrowserAnnotationsView):
                 thumb_image_data = f.read()
         return thumb_image_data, content_type
 
-    @extend_schema(responses={(200, content_type): OpenApiTypes.BINARY})
+    @extend_schema(
+        parameters=[BrowserAnnotationsView.input_serializer_class],
+        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)
+        try:
+            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)
+        except Exception:
+            LOG.exception("get")

codex/views/browser/filters/annotations.py

@@ -20,10 +20,10 @@ class BrowserAnnotationsFilterView(BrowserValidateView, BookmarkFilterMixin):
         super().__init__(*args, **kwargs)
         self.init_bookmark_data()
 
-    def _get_query_filters(self, model, group, pks, bookmark_filter):
+    def _get_query_filters(self, model, group, pks, bookmark_filter, page_mtime=False):  # noqa: PLR0913
         """Return all the filters except the group filter."""
         object_filter = self.get_group_acl_filter(model)
-        object_filter &= self.get_group_filter(model, group, pks)
+        object_filter &= self.get_group_filter(group, pks, page_mtime=page_mtime)
         object_filter &= self.get_comic_field_filter(model)
         if bookmark_filter:
             # not needed because OuterRef is applied next
@@ -45,17 +45,25 @@ class BrowserAnnotationsFilterView(BrowserValidateView, BookmarkFilterMixin):
             qs = qs.filter(**{f"{ann_name}__gt": 0})
         return qs
 
-    def get_filtered_queryset(self, model, group=None, pks=None, bookmark_filter=True):
+    def get_filtered_queryset(  # noqa: PLR0913
+        self, model, group=None, pks=None, bookmark_filter=True, page_mtime=False
+    ):
         """Get a filtered queryset for the model."""
-        object_filter = self._get_query_filters(model, group, pks, bookmark_filter)
+        object_filter = self._get_query_filters(
+            model, group, pks, bookmark_filter, page_mtime=page_mtime
+        )
         qs = model.objects.filter(object_filter)
         qs = self.apply_search_filter(qs, model)
         return self._filter_by_child_count(qs, model)
 
-    def get_group_mtime(self, model, group=None, pks=None):
+    def get_group_mtime(self, model, group=None, pks=None, page_mtime=False):
         """Get a filtered mtime for browser pages and mtime checker."""
         qs = self.get_filtered_queryset(
-            model, group=group, pks=pks, bookmark_filter=self.is_bookmark_filtered
+            model,
+            group=group,
+            pks=pks,
+            bookmark_filter=self.is_bookmark_filtered,
+            page_mtime=page_mtime,
         )
         qs = qs.annotate(max_updated_at=Max("updated_at"))
 

codex/views/browser/filters/group.py

@@ -2,8 +2,11 @@
 
 from django.db.models import Q
 
-from codex.models import Comic
-from codex.views.const import FOLDER_GROUP, GROUP_MODEL_MAP, GROUP_RELATION
+from codex.views.const import (
+    FILTER_ONLY_GROUP_RELATION,
+    FOLDER_GROUP,
+    GROUP_RELATION,
+)
 from codex.views.session import SessionView
 
 
@@ -12,25 +15,31 @@ class GroupFilterView(SessionView):
 
     SESSION_KEY = SessionView.BROWSER_SESSION_KEY
 
-    def get_group_filter(self, model, group=None, pks=None):
+    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 ("metadata", "mtime") or page_mtime:
+            # metadata, mtime, browser.page_mtime
+            rel = "pk"
+        elif target in ("choices", "cover"):
+            rel = FILTER_ONLY_GROUP_RELATION[group]
+        else:
+            rel = GROUP_RELATION[group]
+
+        rel += "__in"
+        return rel
+
+    def get_group_filter(self, group=None, pks=None, page_mtime=False):
         """Get filter for the displayed group."""
         if group is None:
             group = self.kwargs["group"]
         if pks is None:
             pks = self.kwargs["pks"]
 
-        if pks and 0 not in pks:  # type: ignore
-            if model == GROUP_MODEL_MAP.get(group):
-                # metadata only
-                rel = "pk"
-            elif model == Comic and group == FOLDER_GROUP:
-                # choices & covers
-                rel = "folders"
-            else:
-                rel = GROUP_RELATION[group]
-
-            rel += "__in"
-            group_filter_dict = {rel: pks}  # type: ignore
+        if pks and 0 not in pks:
+            rel = self._get_rel_for_pks(group, page_mtime)
+            group_filter_dict = {rel: pks}
         elif group == FOLDER_GROUP:
             group_filter_dict = {"parent_folder": None}
         else:

codex/views/browser/filters/search.py

@@ -135,11 +135,10 @@ class SearchFilterView(ComicFieldFilterView):
             if comic_ids:
                 # Prefilter comic ids. If nothing is allowed, don't search.
                 sqs = sqs.filter_comic_ids(comic_ids)
-                binary = (
+                if (
                     self.TARGET in frozenset({"cover", "choices"})
-                    or self.params.get("order_by", "") != "search_score"
-                )
-                if binary:
+                    or self.params.get("order_by", "") != "search_score"  # type: ignore
+                ):
                     scored_pks = self._get_binary_search_scores(sqs)
                 else:
                     score_pairs, prev_pks, next_pks, scored_pks = (

codex/views/browser/metadata.py

@@ -13,8 +13,10 @@ from codex.librarian.importer.const import (
 )
 from codex.logger.logging import get_logger
 from codex.models import AdminFlag, Comic
-from codex.serializers.browser.metadata import MetadataSerializer
+from codex.models.functions import JsonGroupArray
+from codex.serializers.browser.metadata import PREFETCH_PREFIX, MetadataSerializer
 from codex.views.browser.annotations import BrowserAnnotationsView
+from codex.views.const import METADATA_GROUP_RELATION
 
 LOG = get_logger(__name__)
 _ADMIN_OR_FILE_VIEW_ENABLED_COMIC_VALUE_FIELDS = frozenset({"path"})
@@ -54,6 +56,13 @@ class MetadataView(BrowserAnnotationsView):
         }
     )
 
+    def init_request(self):
+        """Initialize request."""
+        self.set_admin_flags()
+        self.parse_params()
+        self.set_model()
+        self.set_rel_prefix()
+
     def set_valid_browse_nav_groups(self, valid_top_groups):  # noqa: ARG002
         """Limited allowed nav groups for metadata."""
         group = self.kwargs["group"]
@@ -79,6 +88,7 @@ class MetadataView(BrowserAnnotationsView):
     ):
         """Annotate the intersection of value and fk fields."""
         (filtered_qs, qs) = querysets
+
         for field in fields:
             # Annotate variant counts
             # If 1 variant, annotate value, otherwise None
@@ -133,6 +143,52 @@ class MetadataView(BrowserAnnotationsView):
         )
         return qs
 
+    def _query_groups(self):
+        """Query the through models to show group lists."""
+        groups = {}
+        if not self.model:
+            return groups
+        group = self.kwargs["group"]
+        rel = METADATA_GROUP_RELATION.get(group)
+        if not rel:
+            return groups
+        rel = rel + "__in"
+        pks = self.kwargs["pks"]
+        group_filter = {rel: pks}
+
+        for field_name in _GROUP_RELS:
+            try:
+                field = self.model._meta.get_field(field_name)
+            except FieldDoesNotExist:
+                continue
+            model = field.related_model
+            if not model:
+                continue
+
+            qs = model.objects.filter(**group_filter)
+            qs = qs.only("name").distinct()
+            group_by = self.get_group_by(model)
+            qs = qs.group_by(group_by)
+            qs = qs.annotate(ids=JsonGroupArray("id", distinct=True))
+            qs = qs.values("ids", "name")
+            groups[field_name] = qs
+        return groups
+
+    @staticmethod
+    def _get_optimized_m2m_query(key, qs):
+        if key == "contributors":
+            qs = qs.prefetch_related(*_CONTRIBUTOR_RELATIONS)
+            qs = qs.only(*_CONTRIBUTOR_RELATIONS)
+        elif key == "story_arc_numbers":
+            qs = qs.select_related("story_arc")
+            qs = qs.only("story_arc", "number")
+        elif key == "identifiers":
+            qs = qs.select_related("identifier_type")
+            qs = qs.only("identifier_type", "nss", "url")
+        else:
+            qs = qs.only("name")
+        return qs
+
     def _query_m2m_intersections(self, filtered_qs):
         """Query the through models to figure out m2m intersections."""
         # Speed ok, but still does a query per m2m model
@@ -140,31 +196,17 @@ class MetadataView(BrowserAnnotationsView):
         pk_field = self.rel_prefix + "pk"
         comic_pks = filtered_qs.values_list(pk_field, flat=True)
         comic_pks_count = comic_pks.count()
-        for field_name in COMIC_M2M_FIELD_NAMES | _GROUP_RELS:
-            try:
-                if (
-                    field_name in _GROUP_RELS
-                    and self.model
-                    and not self.model._meta.get_field(field_name)
-                ):
-                    continue
-            except FieldDoesNotExist:
-                continue
-
+        for field_name in COMIC_M2M_FIELD_NAMES:
             model = Comic._meta.get_field(field_name).related_model
             if not model:
                 reason = f"No model found for comic field: {field_name}"
                 raise ValueError(reason)
 
             intersection_qs = model.objects.filter(comic__pk__in=comic_pks)
-            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
             )
+            intersection_qs = self._get_optimized_m2m_query(field_name, intersection_qs)
 
             m2m_intersections[field_name] = intersection_qs
         return m2m_intersections
@@ -185,42 +227,37 @@ class MetadataView(BrowserAnnotationsView):
         """Values for highlighting the current group."""
         if self.model and not self.is_model_comic:
             # move the name of the group to the correct field
-            group_field = self.model.__name__.lower()
+            field = self.model.__name__.lower() + "_list"
             group_obj = {"pk": obj.pk, "name": obj.name}
-            setattr(obj, group_field, group_obj)
+            group_list = [group_obj]
+            setattr(obj, field, group_list)
             obj.name = None
 
-    @staticmethod
-    def _get_optimized_m2m_query(key, qs):
-        # XXX The prefetch gets removed by field.set() :(
-        if key == "contributors":
-            qs = qs.prefetch_related(*_CONTRIBUTOR_RELATIONS).only(
-                *_CONTRIBUTOR_RELATIONS
-            )
-        elif key == "story_arc_numbers":
-            qs = qs.prefetch_related("story_arc")
-            qs = qs.only("story_arc", "number")
-        elif key == "identifiers":
-            qs = qs.prefetch_related("identifier_type")
-            qs = qs.only("identifier_type", "nss", "url")
-        else:
-            qs = qs.only("name")
-        return qs
-
     @classmethod
     def _copy_m2m_intersections(cls, obj, m2m_intersections):
         """Copy the m2m intersections into the object."""
-        for key, value in m2m_intersections.items():
-            optimized_qs = cls._get_optimized_m2m_query(key, value)
-            if hasattr(obj, key) and key not in _GROUP_RELS:
+        # XXX It might even be faster to copy everything to a dict and not use the obj.
+        for key, qs in m2m_intersections.items():
+            serializer_key = (
+                f"{PREFETCH_PREFIX}{key}"
+                if key in ("identifiers", "contributors", "story_arc_numbers")
+                else key
+            )
+            if hasattr(obj, serializer_key):
                 # real db fields need to use their special set method.
-                field = getattr(obj, key)
-                field.set(optimized_qs)
+                field = getattr(obj, serializer_key)
+                field.set(
+                    qs,
+                    clear=True,
+                )
             else:
                 # fake db field is just a queryset attached.
-                if key in _GROUP_RELS:
-                    optimized_qs = optimized_qs[0] if len(optimized_qs) else None
-                setattr(obj, key, optimized_qs)
+                setattr(obj, serializer_key, qs)
+
+    @staticmethod
+    def _copy_groups(obj, groups):
+        for field, group_qs in groups.items():
+            setattr(obj, field + "_list", group_qs)
 
     @staticmethod
     def _copy_conflicting_simple_fields(obj):
@@ -230,10 +267,11 @@ class MetadataView(BrowserAnnotationsView):
             val = getattr(obj, conflict_field)
             setattr(obj, field, val)
 
-    def _copy_annotations_into_comic_fields(self, obj, m2m_intersections):
+    def _copy_annotations_into_comic_fields(self, obj, groups, m2m_intersections):
         """Copy a bunch of values that i couldn't fit cleanly in the main queryset."""
         self._path_security(obj)
         self._highlight_current_group(obj)
+        self._copy_groups(obj, groups)
         self._copy_m2m_intersections(obj, m2m_intersections)
         if not self.is_model_comic:
             self._copy_conflicting_simple_fields(obj)
@@ -270,10 +308,11 @@ class MetadataView(BrowserAnnotationsView):
         except (IndexError, ValueError) as exc:
             self._raise_not_found(exc)
 
+        groups = self._query_groups()
         m2m_intersections = self._query_m2m_intersections(filtered_qs)
-        return self._copy_annotations_into_comic_fields(obj, m2m_intersections)  # type: ignore
+        return self._copy_annotations_into_comic_fields(obj, groups, m2m_intersections)  # type: ignore
 
-    @extend_schema(request=BrowserAnnotationsView.input_serializer_class)
+    @extend_schema(parameters=[BrowserAnnotationsView.input_serializer_class])
     def get(self, *_args, **_kwargs):
         """Get metadata for a filtered browse group."""
         # Init

codex/views/browser/mtime.py

@@ -1,7 +1,6 @@
 """Get the mtimes for the submitted groups."""
 
-from types import MappingProxyType
-
+from drf_spectacular.utils import extend_schema
 from rest_framework.response import Response
 
 from codex.logger.logging import get_logger
@@ -21,24 +20,13 @@ class MtimeView(BrowserAnnotationsFilterView):
     serializer_class = MtimeSerializer
 
     REPARSE_JSON_FIELDS = frozenset({"groups", "filters"})
+    TARGET = "mtime"
 
     def __init__(self, *args, **kwargs) -> None:
         """Initialize."""
         super().__init__(*args, **kwargs)
         self.init_bookmark_data()
 
-    def parse_params(self):
-        """Parse GET params."""
-        try:
-            validated_data = super().parse_params()
-            params = dict(self.params)
-            params["groups"] = validated_data["groups"]  # type: ignore
-            self.params = MappingProxyType(params)
-
-        except Exception:
-            LOG.exception("parse")
-            raise
-
     def _get_group_mtime(self, item):
         """Get one group's mtimes."""
         group = item["group"]
@@ -59,6 +47,7 @@ class MtimeView(BrowserAnnotationsFilterView):
             max_mtime = max_none(max_mtime, mtime)
         return max_mtime
 
+    @extend_schema(parameters=[GroupsMtimeSerializer])
     def get(self, *args, **kwargs):
         """Get the mtimes for the submitted groups."""
         # Parse Request

codex/views/browser/order_by.py

@@ -6,7 +6,6 @@ from codex.models import Comic
 from codex.views.browser.filters.annotations import (
     BrowserAnnotationsFilterView,
 )
-from codex.views.const import FOLDER_GROUP
 
 
 class BrowserOrderByView(BrowserAnnotationsFilterView):
@@ -14,11 +13,7 @@ class BrowserOrderByView(BrowserAnnotationsFilterView):
 
     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 == FOLDER_GROUP else "sort_name"
-        self.order_key: str = order_key
+        self.order_key: str = self.params["order_by"]
         order_reverse = self.params.get("order_reverse")
         self.order_agg_func = Max if order_reverse else Min
 

codex/views/browser/settings.py

@@ -1,6 +1,7 @@
 """Browser session view."""
 
 from codex.serializers.browser.settings import BrowserSettingsSerializer
+from codex.views.const import GROUP_ORDER
 from codex.views.settings import SettingsView
 
 
@@ -11,3 +12,55 @@ class BrowserSettingsView(SettingsView):
     serializer_class = BrowserSettingsSerializer  # type: ignore
 
     SESSION_KEY = SettingsView.BROWSER_SESSION_KEY
+
+    @staticmethod
+    def _strip_breadcrumb_names(params):
+        """Remove names from breadcrumbs."""
+        breadcrumbs = params.get("breadcrumbs")
+        if not breadcrumbs:
+            return params
+        nameless_breadcrumbs = []
+        for crumb in breadcrumbs:
+            crumb.pop("name", None)
+            nameless_breadcrumbs.append(crumb)
+        params["breadcrumbs"] = nameless_breadcrumbs
+        return params
+
+    @staticmethod
+    def _validate_browse_top_group(params, group, top_group):
+        """Validate top group for browse groups."""
+        show = params["show"]
+        if group == "r" or (
+            show.get(top_group)
+            and GROUP_ORDER.index(top_group) < GROUP_ORDER.index(group)
+        ):
+            return
+
+        for show_group, on in show.items():
+            if on:
+                params["top_group"] = show_group
+                break
+        else:
+            params["top_group"] = "c"
+
+    @classmethod
+    def _validate_top_group(cls, params, group, top_group):
+        """Validate top group."""
+        if group == top_group:
+            return
+
+        if group in ("f", "a"):
+            params["top_group"] = group
+        else:
+            cls._validate_browse_top_group(params, group, top_group)
+
+    def validate_settings_get(self, validated_data, params):
+        """Change bad settings."""
+        top_group = params["top_group"]
+        group = validated_data.get("group", "r") if validated_data else "r"
+        self._validate_top_group(params, group, top_group)
+
+        if not validated_data.get("breadcrumb_names", True):
+            params = self._strip_breadcrumb_names(params)
+
+        return params

codex/views/browser/validate.py

@@ -15,6 +15,7 @@ from codex.views.const import (
 )
 
 LOG = get_logger(__name__)
+_NO_TOP_GROUP_VALIDATE = frozenset({"metadata"})
 
 
 class BrowserValidateView(BrowserBaseView):
@@ -55,6 +56,8 @@ class BrowserValidateView(BrowserBaseView):
         return valid_top_groups
 
     def _validate_top_group(self, valid_top_groups):
+        # if self.TARGET in _NO_TOP_GROUP_VALIDATE:
+        #    return
         nav_group = self.kwargs.get("group")
         top_group = self.params.get("top_group")
         if top_group not in valid_top_groups:

codex/views/const.py

@@ -67,6 +67,25 @@ GROUP_RELATION = MappingProxyType(
         STORY_ARC_GROUP: "story_arc_numbers__story_arc",
     }
 )
+FILTER_ONLY_GROUP_RELATION = MappingProxyType(
+    {
+        **GROUP_NAME_MAP,
+        FOLDER_GROUP: "folders",
+        STORY_ARC_GROUP: "story_arc_numbers__story_arc",
+    }
+)
+METADATA_GROUP_RELATION = MappingProxyType(
+    {
+        **GROUP_NAME_MAP,
+        COMIC_GROUP: "pk",
+        # Possible to list all groups in a non group view, but could get crazy.
+        # FOLDER_GROUP: "comic__folder",
+        # STORY_ARC_GROUP: "comic__story_arc_number__story_arc"
+    }
+)
+CUSTOM_COVER_GROUP_RELATION = MappingProxyType(
+    {**GROUP_NAME_MAP, FOLDER_GROUP: "folder", STORY_ARC_GROUP: "storyarc"}
+)
 GROUP_ORDER = "rpisv"
 MODEL_REL_MAP = MappingProxyType(
     {
@@ -98,8 +117,12 @@ GROUP_MODELS = (
     Imprint,
     Series,
     Volume,
-    Comic,
     Folder,
+    StoryArc,
+)
+STATS_GROUP_MODELS = (
+    *GROUP_MODELS,
+    Comic,
 )
 METADATA_MODELS = (
     AgeRating,