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

codex/views/opds/v2/publications.py

@@ -82,9 +82,9 @@ class PublicationMixin(LinksMixin):
         ]
 
     @staticmethod
-    def _add_contributors(md, pk, key, roles):
+    def _add_contributors(md, pks, key, roles):
         """Add contributors to metadata."""
-        if contributors := get_contributors(pk, roles):
+        if contributors := get_contributors(pks, roles):
             md[key] = contributors
 
     def _publication_optional_metadata(self, md, obj):
@@ -107,11 +107,11 @@ class PublicationMixin(LinksMixin):
     def _publication_extended_metadata(self, md, obj):
         """Publication m2m metadata only on the metadata alternate link."""
         for key, roles in self._MD_CONTRIBUTOR_MAP.items():
-            self._add_contributors(md, obj.pk, key, roles)
-        if contributors := get_contributors(obj.pk, self._CONTRIBUTOR_ROLES, True):
+            self._add_contributors(md, obj.ids, key, roles)
+        if contributors := get_contributors(obj.ids, self._CONTRIBUTOR_ROLES, True):
             md["contributor"] = contributors
 
-        if m2m_objs := get_m2m_objects(obj.pk):
+        if m2m_objs := get_m2m_objects(obj.ids):
             # XXX Subjects can also have links
             # https://readium.org/webpub-manifest/schema/subject-object.schema.json
             subjects = []
@@ -120,12 +120,12 @@ class PublicationMixin(LinksMixin):
                     subjects.append(subj.name)
             md["subject"] = subjects
 
-    def _publication_metadata(self, obj, issue_number_max):
+    def _publication_metadata(self, obj, zero_pad):
         title = Comic.get_title(
             obj,
             volume=False,
             name=False,
-            issue_number_max=issue_number_max,
+            zero_pad=zero_pad,
             filename_fallback=self.title_filename_fallback,
         )
         md = {
@@ -139,15 +139,14 @@ class PublicationMixin(LinksMixin):
             self._publication_extended_metadata(md, obj)
         return md
 
-    def _publication(self, obj, issue_number_max):
+    def _publication(self, obj, zero_pad):
         pub = {}
-        pub["metadata"] = self._publication_metadata(obj, issue_number_max)
+        pub["metadata"] = self._publication_metadata(obj, zero_pad)
 
-        fn = Comic.get_filename(obj)
-        fn = quote_plus(fn)
+        fn = quote_plus(obj.get_filename())
 
         download_mime_type = MimeType.FILE_TYPE_MAP.get(obj.file_type, MimeType.OCTET)
-        self_kwargs = {"group": "c", "pk": obj.pk, "page": 1}
+        self_kwargs = {"pk": obj.pk, "page": 1}
 
         # This would be for comic streaming which is not supported by OPDS 2 yet?
         # self_href_data = HrefData(self_kwargs, absolute_query_params=True)
@@ -155,7 +154,10 @@ class PublicationMixin(LinksMixin):
 
         alt_kwargs = self_kwargs
         alt_href_data = HrefData(
-            alt_kwargs, {"opdsMetadata": 1}, absolute_query_params=True
+            alt_kwargs,
+            {"opdsMetadata": 1},
+            absolute_query_params=True,
+            url_name="opds:v2:acq",
         )
         alt_link_data = LinkData(
             Rel.ALTERNATE, alt_href_data, mime_type=MimeType.OPDS_PUB
@@ -186,13 +188,13 @@ class PublicationMixin(LinksMixin):
 
         return pub
 
-    def get_publications(self, book_qs, issue_number_max, title):
+    def get_publications(self, book_qs, zero_pad, title):
         """Get publications section."""
         groups = []
         publications = []
         self.title_filename_fallback = bool(self.admin_flags.get("folder_view"))
         for obj in book_qs:
-            pub = self._publication(obj, issue_number_max)
+            pub = self._publication(obj, zero_pad)
             publications.append(pub)
 
         if publications:

codex/views/opds/v2/top_links.py

@@ -21,7 +21,7 @@ class TopLinksMixin(LinksMixin):
         return self.link(link_data)
 
     def _link_search(self):
-        kwargs = {"group": "s", "pk": 0, "page": 1}
+        kwargs = {"group": "s", "pks": (0,), "page": 1}
         href_data = HrefData(kwargs, absolute_query_params=True, max_page=1)
         link_data = LinkData(Rel.SEARCH, href_data, template="{?query}")
         return self.link(link_data)
@@ -55,7 +55,7 @@ class TopLinksMixin(LinksMixin):
 
     def _top_route(self):
         group = "f" if self.kwargs.get("group") == "f" else "r"
-        return {"group": group, "pk": 0, "page": 1}
+        return {"group": group, "pks": (0,), "page": 1}
 
     def _link_page(self, rel, page):
         """Links to a page of results."""

codex/views/reader/page.py

@@ -1,5 +1,7 @@
 """Views for reading comic books."""
 
+from typing import ClassVar
+
 from comicbox.box import Comicbox
 from django.http import HttpResponse
 from drf_spectacular.types import OpenApiTypes
@@ -9,6 +11,7 @@ from rest_framework.negotiation import BaseContentNegotiation
 
 from codex.logger.logging import get_logger
 from codex.models import Comic
+from codex.views.auth import IsAuthenticatedOrEnabledNonUsers
 from codex.views.bookmark import BookmarkBaseView
 from codex.views.const import FALSY
 
@@ -40,6 +43,7 @@ class ReaderPageView(BookmarkBaseView):
     X_MOZ_PRE_HEADERS = frozenset({"prefetch", "preload", "prerender", "subresource"})
     content_type = "image/jpeg"
     content_negotiation_class = IgnoreClientContentNegotiation  # type: ignore
+    permission_classes: ClassVar[list] = [IsAuthenticatedOrEnabledNonUsers]  # type:ignore
 
     def _update_bookmark(self):
         """Update the bookmark if the bookmark param was passed."""

codex/views/reader/reader.py

@@ -1,29 +1,41 @@
 """Views for reading comic books."""
 
+from copy import deepcopy
+from types import MappingProxyType
+
 from comicbox.box import Comicbox
 from django.db.models import F, IntegerField, Value
 from django.urls import reverse
 from drf_spectacular.types import OpenApiTypes
 from drf_spectacular.utils import OpenApiParameter, extend_schema
-from rest_framework.exceptions import NotFound
+from rest_framework.exceptions import NotFound, ValidationError
 from rest_framework.response import Response
 
 from codex.librarian.importer.tasks import LazyImportComicsTask
 from codex.librarian.mp_queue import LIBRARIAN_QUEUE
 from codex.logger.logging import get_logger
 from codex.models import AdminFlag, Bookmark, Comic
-from codex.serializers.reader import ReaderComicsSerializer
+from codex.serializers.reader import ReaderArcSerializer, ReaderComicsSerializer
 from codex.serializers.redirect import ReaderRedirectSerializer
 from codex.views.bookmark import BookmarkBaseView
+from codex.views.mixins import SharedAnnotationsMixin
 from codex.views.session import BrowserSessionViewBase
 
 LOG = get_logger(__name__)
 
 
-class ReaderView(BookmarkBaseView):
+_MIN_CRUMB_WALKBACK_LEN = 3
+
+
+class ReaderView(
+    BookmarkBaseView,
+    BrowserSessionViewBase,
+    SharedAnnotationsMixin,
+):
     """Get info for displaying comic pages."""
 
     serializer_class = ReaderComicsSerializer
+    input_serializer_class = ReaderArcSerializer
 
     SETTINGS_ATTRS = ("fit_to", "two_pages", "reading_direction")
     _COMIC_FIELDS = (
@@ -37,60 +49,96 @@ class ReaderView(BookmarkBaseView):
         "updated_at",
     )
     _VALID_ARC_GROUPS = frozenset({"f", "s", "a"})
+    TARGET = "reader"
+
+    def __init__(self, *args, **kwargs):
+        """Initialize instance vars."""
+        super().__init__(*args, **kwargs)
+        self.series_pks: tuple[int, ...] = ()
+
+    def _get_series_pks_from_breadcrumbs(self):
+        """Get Multi-Group pks from the breadcrumbs."""
+        if self.series_pks:
+            return self.series_pks
+        breadcrumbs = self.get_from_session("breadcrumbs")
+        if breadcrumbs:
+            crumb = breadcrumbs[-1]
+            crumb_group = crumb.get("group")
+            if crumb_group == "v" and len(breadcrumbs) >= _MIN_CRUMB_WALKBACK_LEN:
+                crumb = breadcrumbs[-2]
+                crumb_group = crumb.get("group")
+            if crumb_group == "s":
+                self.series_pks = crumb.get("pks", ())
+
+        return self.series_pks
+
+    def _get_reader_arc_pks(
+        self, arc, arc_pk_select_related, prefetch_related, arc_pk_rel
+    ):
+        """Get the nav filter."""
+        arc_pks = arc.get("pks", ())
+        if not arc_pks:
+            comic_pk = self.kwargs["pk"]
+            try:
+                arc_pk_qs = Comic.objects.filter(pk=comic_pk)
+                arc_pk_qs = arc_pk_qs.select_related(*arc_pk_select_related)
+                arc_pk_qs = arc_pk_qs.prefetch_related(*prefetch_related)
+                arc_pk = arc_pk_qs.values_list(arc_pk_rel, flat=True)[0]
+            except IndexError:
+                arc_pk = 0
+
+            if arc_pk_rel == "series__pk":
+                multi_arc_pks = self._get_series_pks_from_breadcrumbs()
+                if not arc_pk or arc_pk in multi_arc_pks:
+                    arc_pks = multi_arc_pks
+            if not arc_pks:
+                arc_pks = (arc_pk,)
+
+        return arc_pks
 
     def _get_comics_list(self):
         """Get the reader naviation group filter."""
         select_related = ("series", "volume")
         prefetch_related = ()
 
-        arc_group = self.params.get("arc_group")
+        arc = self.params.get("arc", {})
+
+        arc_group = arc.get("group", "s")
         if arc_group == "a":
             # for story arcs
             rel = "story_arc_numbers__story_arc"
             fields = self._COMIC_FIELDS
-            arc_name_rel = "story_arc_numbers__story_arc__name"
             arc_pk_rel = "story_arc_numbers__story_arc__pk"
             prefetch_related = (*prefetch_related, "story_arc_numbers__story_arc")
             arc_index = F("story_arc_numbers__number")
-            ordering = ("arc_index", "date", *Comic.ORDERING)
+            ordering = ("arc_index", "date")
             arc_pk_select_related = ()
-            arc_pk_only = ("pk",)
         elif arc_group == self.FOLDER_GROUP:
             # folder mode
             rel = "parent_folder"
             fields = (*self._COMIC_FIELDS, "parent_folder")
             arc_pk_rel = "parent_folder__pk"
-            arc_name_rel = "parent_folder__name"
             select_related = (*select_related, "parent_folder")
             arc_index = Value(None, IntegerField())
             ordering = ("path", "pk")
             arc_pk_select_related = ("parent_folder",)
-            arc_pk_only = arc_pk_select_related
         else:
             # browser mode.
             rel = "series"
             fields = self._COMIC_FIELDS
             arc_pk_rel = "series__pk"
-            arc_name_rel = "series__name"
             arc_index = Value(None, IntegerField())
-            ordering = Comic.ORDERING
+            ordering = ()
             arc_pk_select_related = ("series",)
-            arc_pk_only = arc_pk_select_related
-
-        arc_pk = self.params.get("arc_pk")
-        if not arc_pk:
-            # Get the correct arc/folder/series if not submitted with a post.
-            pk = self.kwargs.get("pk")
-            arc_pk_qs = Comic.objects.filter(pk=pk)
-            arc_pk_qs = arc_pk_qs.select_related(*arc_pk_select_related)
-            arc_pk_qs = arc_pk_qs.prefetch_related(*prefetch_related)
-            arc_pk_comic = (
-                arc_pk_qs.annotate(arc_pk=F(arc_pk_rel)).only(*arc_pk_only).first()
-            )
-            arc_pk = arc_pk_comic.arc_pk  # type: ignore
 
+        arc_pks = self._get_reader_arc_pks(
+            arc,
+            arc_pk_select_related,
+            prefetch_related,
+            arc_pk_rel,
+        )
+        nav_filter = {f"{rel}__in": arc_pks}
         group_acl_filter = self.get_group_acl_filter(Comic)
-        nav_filter = {rel: arc_pk}
 
         qs = (
             Comic.objects.filter(group_acl_filter)
@@ -99,22 +147,32 @@ class ReaderView(BookmarkBaseView):
             .prefetch_related(*prefetch_related)
             .only(*fields)
             .annotate(
-                series_name=F("series__name"),
-                volume_name=F("volume__name"),
                 issue_count=F("volume__issue_count"),
             )
             .annotate(
                 arc_pk=F(arc_pk_rel),
-                arc_name=F(arc_name_rel),
                 arc_index=arc_index,
             )
             .annotate(mtime=F("updated_at"))
         )
-
-        return qs.order_by(*ordering)
+        qs = self.annotate_group_names(qs, Comic)
+        if arc_group == "s":
+            show = deepcopy(self.get_from_session("show"))
+            show.pop("p", None)
+            show.pop("i", None)
+            qs, comic_sort_names = self.alias_sort_names(
+                qs, Comic, pks=arc_pks, model_group="i", show=show
+            )
+            ordering = (
+                *comic_sort_names,
+                "issue_number",
+                "issue_suffix",
+                "sort_name",
+            )
+        return qs.order_by(*ordering), arc_group
 
     def _append_with_settings(self, book, bookmark_filter):
-        """Get bookmarks and filename and append to book list."""
+        """Append bookmark to book list."""
         book.settings = (
             Bookmark.objects.filter(**bookmark_filter, comic=book)
             .only(*self.SETTINGS_ATTRS)
@@ -131,7 +189,7 @@ class ReaderView(BookmarkBaseView):
 
         Yields 1 to 3 books
         """
-        comics = self._get_comics_list()
+        comics, arc_group = self._get_comics_list()
         bookmark_filter = self.get_bookmark_filter()
         books = {}
         prev_book = None
@@ -150,13 +208,14 @@ class ReaderView(BookmarkBaseView):
                 # create extra current book attrs:
                 if book.arc_index is None:  # type: ignore
                     book.arc_index = index + 1  # type: ignore
-                book.filename = book.filename()  # type: ignore
-
+                book.filename = book.get_filename()  # type: ignore
+                book.arc_group = arc_group
+                book.arc_count = comics.count()
                 books["current"] = self._append_with_settings(book, bookmark_filter)
             else:
                 # Haven't matched yet, so set the previous comic
                 prev_book = book
-        return books, comics.count()
+        return books
 
     def _get_folder_arc(self, book):
         """Create the folder arc."""
@@ -167,20 +226,48 @@ class ReaderView(BookmarkBaseView):
         )
 
         if efv_flag:
+            folder = book.parent_folder
             folder_arc = {
                 "group": self.FOLDER_GROUP,
-                "pk": book.parent_folder.pk,
-                "name": book.parent_folder.name,
+                "pks": (folder.pk,),
+                "name": folder.name,
             }
         else:
             folder_arc = None
         return folder_arc
 
+    def _get_series_arc(self, book):
+        """Create the series arc."""
+        series = book.series
+        if series:
+            arc_pks = self._get_series_pks_from_breadcrumbs()
+            if book.series.pk not in arc_pks:
+                arc_pks = (book.series.pk,)
+            arc = (
+                {"group": "s", "pks": arc_pks, "name": series.name} if series else None
+            )
+        else:
+            arc = None
+        return arc
+
+    def _get_story_arcs(self, book):
+        """Create story arcs."""
+        sas = []
+        for san in book.story_arc_numbers.all():
+            sa = san.story_arc
+            arc = {
+                "group": "a",
+                "pks": (sa.pk,),
+                "name": sa.name,
+            }
+            sas.append(arc)
+        return sorted(sas, key=lambda x: x["name"])
+
     def _get_arcs(self, book):
         """Get all series/folder/story arcs."""
         # create top arcs
         folder_arc = self._get_folder_arc(book)
-        series_arc = {"group": "s", "pk": book.series.pk, "name": book.series.name}
+        series_arc = self._get_series_arc(book)
 
         # order top arcs
         top_group = self.params.get("top_group")
@@ -197,16 +284,7 @@ class ReaderView(BookmarkBaseView):
             arcs.append(other_arc)
 
         # story arcs
-        sas = []
-        for san in book.story_arc_numbers.all():
-            sa = san.story_arc
-            arc = {
-                "group": "a",
-                "pk": sa.pk,
-                "name": sa.name,
-            }
-            sas.append(arc)
-        sas = sorted(sas, key=lambda x: x["name"])
+        sas = self._get_story_arcs(book)
         arcs += sas
         return arcs
 
@@ -247,7 +325,8 @@ class ReaderView(BookmarkBaseView):
     def get_object(self):
         """Get the previous and next comics in a group or story arc."""
         # Books
-        books, arc_count = self._get_book_collection()
+        self.last_route = self.get_last_route()
+        books = self._get_book_collection()
 
         current = books.get("current")
         if not current:
@@ -266,53 +345,63 @@ class ReaderView(BookmarkBaseView):
         # Arcs
         arcs = self._get_arcs(current)
 
-        arc_group = self.params.get("arc_group")
-        arc = {
-            "group": arc_group,
-            "pk": current.arc_pk,  # type: ignore
-            "index": current.arc_index,  # type: ignore
-            "count": arc_count,
-        }
+        arc = self.params.get("arc", {})
+        if not arc.get("group"):
+            arc["group"] = current.arc_group  # type: ignore
+        if not arc.get("pks"):
+            arc["pks"] = (current.arc_pk,)  # type: ignore
+        arc["index"] = current.arc_index  # type:ignore
+        arc["count"] = current.arc_count  # type: ignore
+        close_route = self.last_route
+        close_route.pop("name", None)
 
-        return {
-            "books": books,
-            "arcs": arcs,
-            "arc": arc,
-        }
+        return {"books": books, "arcs": arcs, "arc": arc, "close_route": close_route}
 
     def _parse_params(self):
         data = self.request.GET
+        # Hack for query_parm parser
+        arc_data = MappingProxyType(
+            {"group": data.get("arc[group]"), "pks": data.get("arc[pks]")}
+        )
+        serializer = self.input_serializer_class(data=arc_data)
+        arc = {}
+        try:
+            serializer.is_valid()
+            arc = serializer.validated_data
+        except ValidationError:
+            pass
 
         # PARAMS
         session = self.request.session.get(BrowserSessionViewBase.SESSION_KEY, {})
         top_group = session.get("top_group", "s")
-        arc_group = data.get("arcGroup")
+
+        # arc.group validation
+        # Can't be in the serializer
+        arc_group = arc.get("group", "")
+        if not arc_group:
+            series_pks = self._get_series_pks_from_breadcrumbs()
+            if series_pks:
+                arc_group = "s"
+                arc["pks"] = series_pks
         if not arc_group:
             arc_group = top_group
-
         if arc_group not in self._VALID_ARC_GROUPS:
-            arc_group = "s"
-
-        arc_pk = data.get("arcPk")
-        if arc_pk is not None:
-            arc_pk = int(arc_pk)
-        elif top_group == "a":
-            last_route = session.get("route", {})
-            arc_pk = last_route.get("pk")
-
-        params = {
-            "arc_group": arc_group,
-            "arc_pk": arc_pk,
-            "top_group": top_group,
-        }
+            arc_group = None
+
+        params = MappingProxyType(
+            {
+                "arc": arc,
+                "top_group": top_group,
+            }
+        )
         self.params = params
 
     @extend_schema(
         parameters=[
             OpenApiParameter(
-                "arcGroup", OpenApiTypes.STR, enum=sorted(_VALID_ARC_GROUPS)
+                "arc[group]", OpenApiTypes.STR, enum=sorted(_VALID_ARC_GROUPS)
             ),
-            OpenApiParameter("arcPk", OpenApiTypes.INT),
+            OpenApiParameter("arc[pks]", OpenApiTypes.STR),
         ]
     )
     def get(self, *args, **kwargs):

codex/views/session.py

@@ -1,8 +1,9 @@
 """Manage user sessions with appropriate defaults."""
 
-from abc import ABC, abstractmethod
+from abc import ABC
 from copy import deepcopy
 from types import MappingProxyType
+from typing import ClassVar
 
 from drf_spectacular.utils import extend_schema
 from rest_framework.generics import GenericAPIView
@@ -19,13 +20,7 @@ class SessionViewBaseBase(GenericAPIView, ABC):
     """Generic Session View."""
 
     # Must override both of these
-    @property
-    @classmethod
-    @abstractmethod
-    def SESSION_KEY(cls):  # noqa: N802, type: ignore
-        """Implement the session key string."""
-        raise NotImplementedError
-
+    SESSION_KEY = ""
     SESSION_DEFAULTS = MappingProxyType({})
 
     @classmethod
@@ -51,6 +46,8 @@ class SessionViewBaseBase(GenericAPIView, ABC):
     def save_params_to_session(self, params):  # reader session & browser final
         """Save the session from params with defaults for missing values."""
         try:
+            # Deepcopy this so serializing the values later later for http response doesn't alter them
+            params = deepcopy(dict(params))
             data = self._get_source_values_or_set_defaults(
                 self.SESSION_DEFAULTS, params, {}
             )
@@ -97,20 +94,32 @@ class BrowserSessionViewBase(SessionViewBaseBase):
     FILTER_ATTRIBUTES = frozenset(_DYNAMIC_FILTER_DEFAULTS.keys())
     SESSION_DEFAULTS = MappingProxyType(
         {
+            "breadcrumbs": DEFAULTS["breadcrumbs"],
             "filters": {
                 "bookmark": DEFAULTS["bookmarkFilter"],
                 **_DYNAMIC_FILTER_DEFAULTS,
             },
             "order_by": DEFAULTS["orderBy"],
-            "order_reverse": False,
+            "order_reverse": DEFAULTS["orderReverse"],
             "q": DEFAULTS["q"],
-            "route": DEFAULTS["route"],
+            "search_results_limit": DEFAULTS["searchResultsLimit"],
             "show": DEFAULTS["show"],
             "twenty_four_hour_time": False,
             "top_group": DEFAULTS["topGroup"],
         }
     )
 
+    def get_last_route(self, name=True):
+        """Get the last route from the breadcrumbs."""
+        breadcrumbs = self.get_from_session("breadcrumbs")
+        if not breadcrumbs:
+            breadcrumbs = DEFAULTS["breadcrumbs"]
+        last_route = breadcrumbs[-1]
+        if not name:
+            last_route.pop("name", None)
+
+        return last_route
+
 
 class ReaderSessionViewBase(SessionViewBaseBase):
     """Reader session base."""
@@ -125,10 +134,10 @@ class ReaderSessionViewBase(SessionViewBaseBase):
     )
 
 
-class SessionViewBase(SessionViewBaseBase, ABC):
+class SessionViewBase(SessionViewBaseBase, GenericAPIView, ABC):
     """Session view for retrieving stored settings."""
 
-    permission_classes = (IsAuthenticatedOrEnabledNonUsers,)
+    permission_classes: ClassVar[list] = [IsAuthenticatedOrEnabledNonUsers]  # type: ignore
 
     def load_params_from_session(self):
         """Set the params from view session, creating missing values from defaults."""