codex 1.5.19__py3-none-any.whl → 1.6.0a0__py3-none-any.whl

codex/views/browser/metadata.py

@@ -1,8 +1,10 @@
 """View for marking comics read and unread."""
 
+from types import MappingProxyType
 from typing import ClassVar
 
-from django.db.models import Count, F, IntegerField, Subquery, Value
+from django.core.exceptions import FieldDoesNotExist
+from django.db.models import Count, IntegerField, Sum, Value
 from drf_spectacular.utils import extend_schema
 from rest_framework.exceptions import NotFound
 from rest_framework.response import Response
@@ -10,7 +12,7 @@ from rest_framework.response import Response
 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.metadata import MetadataSerializer
+from codex.serializers.browser.metadata import MetadataSerializer
 from codex.views.auth import IsAuthenticatedOrEnabledNonUsers
 from codex.views.browser.browser_annotations import BrowserAnnotationsView
 
@@ -25,7 +27,7 @@ _COMIC_VALUE_FIELDS_CONFLICTING = frozenset(
     }
 )
 _DISABLED_VALUE_FIELD_NAMES = frozenset(
-    {"id", "pk", "stat"} | _COMIC_VALUE_FIELDS_CONFLICTING
+    {"id", "pk", "sort_name", "stat"} | _COMIC_VALUE_FIELDS_CONFLICTING
 )
 _COMIC_VALUE_FIELD_NAMES = frozenset(
     # contains path
@@ -37,6 +39,8 @@ _COMIC_VALUE_FIELDS_CONFLICTING_PREFIX = "conflict_"
 _COMIC_RELATED_VALUE_FIELDS = frozenset({"series__volume_count", "volume__issue_count"})
 _PATH_GROUPS = ("c", "f")
 _CONTRIBUTOR_RELATIONS = ("role", "person")
+_SUM_FIELDS = frozenset({"page_count", "size"})
+_GROUP_RELS = frozenset({"publisher", "imprint", "series", "volume"})
 
 
 class MetadataView(BrowserAnnotationsView):
@@ -44,16 +48,24 @@ class MetadataView(BrowserAnnotationsView):
 
     permission_classes: ClassVar[list] = [IsAuthenticatedOrEnabledNonUsers]  # type: ignore
     serializer_class = MetadataSerializer
+    TARGET = "metadata"
+    ADMIN_FLAG_VALUE_KEY_MAP = MappingProxyType(
+        {
+            AdminFlag.FlagChoices.FOLDER_VIEW.value: "folder_view",
+            AdminFlag.FlagChoices.DYNAMIC_GROUP_COVERS.value: "dynamic_group_covers",
+        }
+    )
 
     def _get_comic_value_fields(self):
         """Include the path field for staff."""
         fields = set(_COMIC_VALUE_FIELD_NAMES)
+        group = self.kwargs["group"]
         if (
-            not (self._is_enabled_folder_view() and self.is_admin())
-            or self.group not in _PATH_GROUPS
+            not (self.admin_flags["folder_view"] and self.is_admin())
+            or group not in _PATH_GROUPS
         ):
             fields -= _ADMIN_OR_FILE_VIEW_ENABLED_COMIC_VALUE_FIELDS
-        return fields
+        return tuple(fields)
 
     def _intersection_annotate(
         self,
@@ -63,46 +75,43 @@ class MetadataView(BrowserAnnotationsView):
         annotation_prefix="",
     ):
         """Annotate the intersection of value and fk fields."""
-        (simple_qs, qs) = querysets
+        (filtered_qs, qs) = querysets
         for field in fields:
             # Annotate variant counts
-            # Have to use simple_qs because every annotation in the loop
-            # corrupts the the main qs
             # If 1 variant, annotate value, otherwise None
-            full_field = self.rel_prefix + field
-
-            sq = (
-                simple_qs.values("id")
-                .order_by()  # just in case
-                .annotate(count=Count(full_field, distinct=True))
-                .filter(count=1)
-                .values_list(full_field + related_suffix, flat=True)
-            )
+            ann_field = annotation_prefix + field.replace("__", "_")
 
-            # The subquery above would work without this python dual evaluation
-            # if we could group by only model.id. However, the SQL standard and
-            # therefore Django, states that anything selected must be grouped by,
-            # which leads to multiple query results instead of null or one result.
-            # The query only version of this from 0.9.14 worked in most cases, but
-            # fractured on the language tag for some reason.
-            val = Value(None, IntegerField()) if len(sq) != 1 else Subquery(sq)
+            full_field = self.rel_prefix + field
 
-            ann_field = (annotation_prefix + field).replace("__", "_")
+            if field in _SUM_FIELDS:
+                val = Sum(full_field)
+            else:
+                # group_by makes the filter work, but prevents its
+                # use as a subquery in the big query.
+                group_by = self.get_group_by()
+                sq = (
+                    filtered_qs.alias(filter_count=Count(full_field, distinct=True))
+                    .filter(filter_count=1)
+                    .group_by(group_by)
+                    .values_list(full_field + related_suffix, flat=True)
+                )
+                try:
+                    val = sq[0]
+                except IndexError:
+                    val = None
+                if field.endswith("count"):
+                    output_field = IntegerField()
+                else:
+                    output_field = Comic._meta.get_field(field).__class__()
+                val = Value(val, output_field)
             qs = qs.annotate(**{ann_field: val})
 
-        return simple_qs, qs
+        return filtered_qs, qs
 
-    def _annotate_aggregates(self, qs):
-        """Annotate aggregate values."""
-        if not self.is_model_comic:
-            size_func = self.get_aggregate_func(self.model, "size")
-            qs = qs.annotate(size=size_func)
-        return self.annotate_common_aggregates(qs, self.model, {})
-
-    def _annotate_values_and_fks(self, qs, simple_qs):
+    def _annotate_values_and_fks(self, qs, filtered_qs):
         """Annotate comic values and comic foreign key values."""
         # Simple Values
-        querysets = (simple_qs, qs)
+        querysets = (filtered_qs, qs)
         if not self.is_model_comic:
             comic_value_fields = self._get_comic_value_fields()
             querysets = self._intersection_annotate(querysets, comic_value_fields)
@@ -113,9 +122,6 @@ class MetadataView(BrowserAnnotationsView):
                 _COMIC_VALUE_FIELDS_CONFLICTING,
                 annotation_prefix=_COMIC_VALUE_FIELDS_CONFLICTING_PREFIX,
             )
-        elif self.is_admin() or self._is_enabled_folder_view():
-            qs = qs.annotate(library_path=F("library__path"))
-            querysets = (simple_qs, qs)
 
         # Foreign Keys with special count values
         _, qs = self._intersection_annotate(
@@ -124,49 +130,54 @@ class MetadataView(BrowserAnnotationsView):
         )
         return qs
 
-    @staticmethod
-    def _get_intersection_queryset(qs, count_rel, comic_pks):
-        """Create an intersection queryset."""
-        return (
-            qs.annotate(count=Count(count_rel))
-            .order_by()
-            .filter(count=comic_pks.count())
-        )
-
-    def _query_m2m_intersections(self, simple_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
         m2m_intersections = {}
         pk_field = self.rel_prefix + "pk"
-        comic_pks = simple_qs.values_list(pk_field, flat=True)
-        for field_name in COMIC_M2M_FIELD_NAMES:
+        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
+
             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)
-            # order_by() is very important for grouping
-            intersection_qs = self._get_intersection_queryset(
-                intersection_qs, "comic", 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)
+            intersection_qs = intersection_qs.alias(count=Count("comic")).filter(
+                count=comic_pks_count
             )
+
             m2m_intersections[field_name] = intersection_qs
         return m2m_intersections
 
     def _path_security(self, obj):
         """Secure filesystem information for acl situation."""
-        is_path_group = self.group in _PATH_GROUPS
+        group = self.kwargs["group"]
+        is_path_group = group in _PATH_GROUPS
         if is_path_group:
             if self.is_admin():
                 return
-            if self._is_enabled_folder_view():
+            if self.admin_flags["folder_view"]:
                 obj.path = obj.search_path()
         else:
             obj.path = ""
 
     def _highlight_current_group(self, obj):
         """Values for highlighting the current group."""
-        obj.group = self.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()
@@ -196,12 +207,14 @@ class MetadataView(BrowserAnnotationsView):
         """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):
+            if hasattr(obj, key) and key not in _GROUP_RELS:
                 # real db fields need to use their special set method.
                 field = getattr(obj, key)
                 field.set(optimized_qs)
             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)
 
     @staticmethod
@@ -220,16 +233,13 @@ class MetadataView(BrowserAnnotationsView):
         if not self.is_model_comic:
             self._copy_conflicting_simple_fields(obj)
 
-        # filename
-        if self.model == Comic:
-            obj.filename = obj.filename()
-
         return obj
 
     def _raise_not_found(self, exc=None):
         """Raise an exception if the object is not found."""
-        pk = self.kwargs["pk"]
-        detail = f"Filtered metadata for {self.group}/{pk} not found"
+        pks = self.kwargs["pks"]
+        group = self.kwargs["group"]
+        detail = f"Filtered metadata for {group}/{pks} not found"
         raise NotFound(detail=detail) from exc
 
     def get_object(self):
@@ -239,63 +249,47 @@ class MetadataView(BrowserAnnotationsView):
         # dict is necessary because of the folders view union in browser.py.
 
         if self.model is None:
-            raise NotFound(detail=f"Cannot get metadata for {self.group=}")
-
-        if self.model == Comic:
-            search_scores = None
-        else:
-            search_scores: dict | None = self.get_search_scores()
-            if search_scores is None:
-                self._raise_not_found()
-        object_filter = self.get_query_filters_without_group(self.model, search_scores)  # type: ignore
-        pk = self.kwargs["pk"]
-        qs = self.model.objects.filter(object_filter, pk=pk)
-
-        qs = self._annotate_aggregates(qs)
-        simple_qs = qs
-
-        qs = self._annotate_values_and_fks(qs, simple_qs)
+            # TODO this looks redundant after set_browse_model
+            group = self.kwargs["group"]
+            raise NotFound(detail=f"Cannot get metadata for {group=}")
+
+        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)
+        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.first()
+            obj = qs_list[0]
             if not obj:
                 reason = "Empty obj"
                 raise ValueError(reason)  # noqa TRY301
         except (IndexError, ValueError) as exc:
             self._raise_not_found(exc)
 
-        m2m_intersections = self._query_m2m_intersections(simple_qs)
+        m2m_intersections = self._query_m2m_intersections(filtered_qs)
         return self._copy_annotations_into_comic_fields(obj, m2m_intersections)  # type: ignore
 
-    def _is_enabled_folder_view(self):
-        if self._efv_flag is None:
-            self._efv_flag = (
-                AdminFlag.objects.only("on")
-                .get(key=AdminFlag.FlagChoices.FOLDER_VIEW.value)
-                .on
-            )
-        return self._efv_flag
-
-    def _validate(self):
-        self.model = self.GROUP_MODEL_MAP[self.group]
-        if self.model is None:
-            raise NotFound(detail=f"Cannot get metadata for {self.group=}")
-        self.is_model_comic = self.group == self.COMIC_GROUP
+    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."""
         # Init
         try:
-            self._efv_flag = None
-            self.parse_params()
-            self.group = self.kwargs["group"]
-            self._validate()
-            self.set_rel_prefix(self.model)
-            self.set_order_key()
-
+            self.init_request()
             obj = self.get_object()
-
             serializer = self.get_serializer(obj)
             return Response(serializer.data)
         except Exception:

codex/views/const.py

@@ -1,3 +1,20 @@
 """Common view constants."""
 
+from types import MappingProxyType
+
+from codex.settings.settings import CODEX_PATH
+
 FALSY = {None, "", "false", "0", False}
+GROUP_NAME_MAP = MappingProxyType(
+    {"p": "publisher", "i": "imprint", "s": "series", "v": "volume"}
+)
+STATIC_IMG_PATH = CODEX_PATH / "static_root/img"
+MISSING_COVER_NAME_MAP = MappingProxyType(
+    {
+        **GROUP_NAME_MAP,
+        "f": "folder",
+        "a": "story-arc",
+    }
+)
+MISSING_COVER_FN = "missing-cover-165.webp"
+MISSING_COVER_PATH = STATIC_IMG_PATH / MISSING_COVER_FN

codex/views/cover.py

@@ -13,6 +13,7 @@ from codex.librarian.covers.path import CoverPathMixin
 from codex.librarian.mp_queue import LIBRARIAN_QUEUE
 from codex.logger.logging import get_logger
 from codex.views.auth import GroupACLMixin, IsAuthenticatedOrEnabledNonUsers
+from codex.views.const import MISSING_COVER_FN, MISSING_COVER_NAME_MAP, STATIC_IMG_PATH
 
 LOG = get_logger(__name__)
 
@@ -37,23 +38,40 @@ class CoverView(APIView, GroupACLMixin):
     renderer_classes = (WEBPRenderer,)
     content_type = "image/webp"
 
+    def _get_missing_cover_path(self):
+        # Get the missing cover, which is a default svg if fetched for a group.
+        data = self.request.GET
+        group: str = data.get("group", "c")  # type: ignore
+        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
+
     @extend_schema(responses={(200, content_type): OpenApiTypes.BINARY})
     def get(self, *_args, **_kwargs):
         """Get comic cover."""
-        # thumb_image_data = None
+        thumb_image_data = None
+        content_type = "image/webp"
+
         pk = self.kwargs.get("pk")
         cover_path = CoverPathMixin.get_cover_path(pk)
-        thumb_image_data = None
         if not cover_path.exists():
             thumb_image_data = CoverCreateMixin.create_cover_from_path(
                 pk, cover_path, LOG, LIBRARIAN_QUEUE
             )
             if not thumb_image_data:
-                cover_path = CoverPathMixin.MISSING_COVER_PATH
+                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 HttpResponse(thumb_image_data, content_type=self.content_type)
+        return HttpResponse(thumb_image_data, content_type=content_type)

codex/views/download.py

@@ -18,15 +18,6 @@ class DownloadView(APIView, GroupACLMixin):
     permission_classes: ClassVar[list] = [IsAuthenticatedOrEnabledNonUsers]  # type: ignore
     content_type = "application/vnd.comicbook+zip"
 
-    _DOWNLOAD_SELECT_RELATED = ("series", "volume")
-    _DOWNLOAD_FIELDS = (
-        "path",
-        "series",
-        "volume",
-        "issue_number",
-        "issue_suffix",
-        "name",
-    )
     AS_ATTACHMENT = True
 
     @extend_schema(responses={(200, content_type): OpenApiTypes.BINARY})
@@ -37,8 +28,7 @@ class DownloadView(APIView, GroupACLMixin):
             group_acl_filter = self.get_group_acl_filter(Comic)
             comic = (
                 Comic.objects.filter(group_acl_filter)
-                .select_related(*self._DOWNLOAD_SELECT_RELATED)
-                .only(*self._DOWNLOAD_FIELDS)
+                .only("path", "file_type")
                 .get(pk=pk)
             )
         except Comic.DoesNotExist as err:
@@ -55,11 +45,12 @@ class DownloadView(APIView, GroupACLMixin):
         else:
             content_type += "octet-stream"
 
+        filename = comic.get_filename()
         return FileResponse(
             comic_file,
             as_attachment=self.AS_ATTACHMENT,
             content_type=content_type,
-            filename=comic.filename(),
+            filename=filename,
         )
 
 

codex/views/error.py

@@ -22,8 +22,8 @@ def codex_exception_handler(exc, context):
             status.HTTP_400_BAD_REQUEST,
             status.HTTP_404_NOT_FOUND,
         ):
-            opds_start = reverse(name)
-            response = redirect(opds_start, permanent=False)
+            url = reverse(name)
+            response = redirect(url, permanent=False)
 
     if not response:
         response = exception_handler(exc, context)

codex/views/frontend.py

@@ -5,6 +5,7 @@ from typing import ClassVar
 from rest_framework.renderers import TemplateHTMLRenderer
 from rest_framework.response import Response
 
+from codex.serializers.route import RouteSerializer
 from codex.views.session import BrowserSessionViewBase
 
 
@@ -16,6 +17,8 @@ class IndexView(BrowserSessionViewBase):
 
     def get(self, *_args, **_kwargs):
         """Get the app index page."""
-        last_route = self.get_from_session("route")
+        last_route = self.get_last_route(name=False)
+        serializer = RouteSerializer(last_route)
+        last_route = serializer.data
         extra_context = {"last_route": last_route}
         return Response(extra_context)

codex/views/mixins.py

@@ -0,0 +1,76 @@
+"""Cross view annotation methods."""
+
+from django.db.models.expressions import F
+
+from codex.models.comic import Comic, Imprint, Volume
+from codex.views.const import GROUP_NAME_MAP
+
+_SHOW_GROUPS = tuple(GROUP_NAME_MAP.keys())
+
+
+class SharedAnnotationsMixin:
+    """Cross view annotation methods."""
+
+    @staticmethod
+    def _get_order_groups(pks, model_group):
+        """Annotate sort_name."""
+        if not pks or len(pks) > 1:
+            order_groups = _SHOW_GROUPS
+        elif model_group == "c":
+            order_groups = ()
+        else:
+            for index, nav_group in enumerate(_SHOW_GROUPS):
+                if nav_group == model_group:
+                    order_groups = _SHOW_GROUPS[index + 1 :]
+                    break
+            else:
+                order_groups = _SHOW_GROUPS
+        return order_groups
+
+    @classmethod
+    def alias_sort_names(cls, qs, model, pks, model_group, show=None):  # noqa PLR0193
+        """Annotate sort names for browser subclasses and reader."""
+        sort_name_annotations = {}
+        comic_sort_names = []
+        if model == Comic:
+            order_groups = cls._get_order_groups(pks, model_group)
+            for order_group in order_groups:
+                if show and not show.get(order_group):
+                    continue
+                group_name = GROUP_NAME_MAP[order_group]
+                ann_name = f"{group_name}_sort_name"
+                name_field = "name" if group_name == "volume" else "sort_name"
+                sort_name = F(f"{group_name}__{name_field}")
+                sort_name_annotations[ann_name] = sort_name
+                comic_sort_names.append(ann_name)
+        elif model == Volume:
+            sort_name_annotations["sort_name"] = F("name")
+
+        if sort_name_annotations:
+            qs = qs.alias(**sort_name_annotations)
+        return qs, comic_sort_names
+
+    @classmethod
+    def annotate_group_names(cls, qs, model):
+        """Annotate name fields by hoisting them up."""
+        # Optimized to only lookup what is used on the frontend
+        target = cls.TARGET  # type: ignore
+        if target not in frozenset({"browser", "opds1", "opds2", "reader"}):
+            return qs
+        group_names = {}
+        if model == Comic:
+            if target != "reader":
+                group_names["publisher_name"] = F("publisher__name")
+                if target == "opds2":
+                    group_names["imprint_name"] = F("imprint__name")
+            group_names.update(
+                {
+                    "series_name": F("series__name"),
+                    "volume_name": F("volume__name"),
+                }
+            )
+        elif model == Volume:
+            group_names["series_name"] = F("series__name")
+        elif model == Imprint:
+            group_names["publisher_name"] = F("publisher__name")
+        return qs.annotate(**group_names)

codex/views/opds/urls.py

@@ -0,0 +1,28 @@
+"""OPDS URLs."""
+
+from django.urls import reverse
+from rest_framework.generics import GenericAPIView
+from rest_framework.response import Response
+
+from codex.serializers.choices import DEFAULTS
+from codex.serializers.opds.urls import OPDSURLsSerializer
+
+OPDS_VERSIONS = (1, 2)
+
+
+class OPDSURLsView(GenericAPIView):
+    """OPDS URLs."""
+
+    serializer_class = OPDSURLsSerializer
+
+    def get(self, *args, **kwargs):
+        """Resolve the urls."""
+        obj = {}
+        route = DEFAULTS["breadcrumbs"][0]
+        for version in OPDS_VERSIONS:
+            key = f"v{version}"
+            name = f"opds:v{version}:feed"
+            value = reverse(name, kwargs=route)
+            obj[key] = value
+        serializer = self.get_serializer(obj)
+        return Response(serializer.data)

codex/views/opds/util.py

@@ -38,10 +38,10 @@ def update_href_query_params(href, old_query_params, new_query_params=None):
     return href
 
 
-def get_contributor_people(comic_pk, roles, exclude=False):
+def get_contributor_people(comic_pks, roles, exclude=False):
     """Get contributors that are not authors."""
     people = ContributorPerson.objects.filter(
-        contributor__comic=comic_pk,
+        contributor__comic__in=comic_pks,
     )
     if exclude:
         people = people.exclude(contributor__role__name__in=roles)
@@ -50,9 +50,9 @@ def get_contributor_people(comic_pk, roles, exclude=False):
     return people.distinct().only("name")
 
 
-def get_contributors(comic_pk, roles, exclude=False):
+def get_contributors(comic_pks, roles, exclude=False):
     """Get credits that are not part of other roles."""
-    contributors = Contributor.objects.filter(comic=comic_pk)
+    contributors = Contributor.objects.filter(comic__in=comic_pks)
     if exclude:
         contributors = contributors.exclude(role__name__in=roles)
     else:
@@ -60,7 +60,7 @@ def get_contributors(comic_pk, roles, exclude=False):
     return contributors.annotate(name=F("person__name"), role_name=F("role__name"))
 
 
-def get_m2m_objects(pk) -> dict:
+def get_m2m_objects(pks) -> dict:
     """Get Category labels."""
     cats = {}
     for model in OPDS_M2M_MODELS:
@@ -68,7 +68,7 @@ def get_m2m_objects(pk) -> dict:
         rel = "comic"
         if model == StoryArc:
             rel = "storyarcnumber__" + rel
-        comic_filter = {rel: pk}
+        comic_filter = {rel + "__in": pks}
         qs = model.objects.filter(**comic_filter).order_by("name").only("name")
         cats[table] = qs
 
@@ -80,7 +80,7 @@ def full_redirect_view(url_name):
 
     def func(request):
         """Redirect to view, forwarding query strings and auth."""
-        kwargs = DEFAULTS["route"]
+        kwargs = DEFAULTS["breadcrumbs"][0]
         url = reverse(url_name, kwargs=kwargs)
 
         # Forward the query string.

codex/views/opds/v1/entry/data.py

@@ -9,7 +9,7 @@ class OPDS1EntryObject:
     """Fake entry db object for top link & facet entries."""
 
     group: str = ""
-    pk: int = 0
+    ids: frozenset[int] = frozenset()
     name: str = ""
     summary: str = ""
     fake: bool = True
@@ -20,6 +20,6 @@ class OPDS1EntryData:
     """Entry Data class to avoid to many args."""
 
     acquisition_groups: frozenset
-    issue_number_max: int
+    zero_pad: int
     metadata: bool
     mime_type_map: Mapping[str, str]