codex 1.7.15__py3-none-any.whl → 1.8.0a2__py3-none-any.whl

codex/views/reader/arcs.py

@@ -1,101 +1,170 @@
 """Reader get Arcs methods."""
 
+from collections.abc import Mapping
+from types import MappingProxyType
+
+from codex.choices.admin import AdminFlagChoices
 from codex.models import AdminFlag
+from codex.models.comic import Comic
+from codex.models.functions import JsonGroupArray
+from codex.models.named import StoryArc
 from codex.util import max_none
 from codex.views.const import (
+    EPOCH_START,
     FOLDER_GROUP,
     STORY_ARC_GROUP,
 )
-from codex.views.reader.books import ReaderBooksView
+from codex.views.reader.params import ReaderParamsView
 
+_COMIC_ARC_FIELD_NAMES = ("series", "volume", "parent_folder")
+_STORY_ARC_ONLY = ("name", "ids", "updated_ats")
+_BROWSE_GROUP_SET = frozenset("rpisv")
 
-class ReaderArcsView(ReaderBooksView):
-    """Reader get Arcs methods."""
 
-    def __init__(self, *args, **kwargs):
-        """Initialize instance vars."""
-        super().__init__(*args, **kwargs)
+class ReaderArcsView(ReaderParamsView):
+    """Reader get Arcs methods."""
 
-    def _get_group_arc(self, book, attr, browser_arc_group, arcs, max_mtime):
-        """Append the volume arc."""
-        if browser_arc_group == attr[0]:
-            return max_mtime
-        group = getattr(book, attr, None)
-        if not group:
-            return max_mtime
+    def _get_field_names(self):
+        field_names = []
+        for field_name in _COMIC_ARC_FIELD_NAMES:
+            if field_name == "parent_folder":
+                efv_flag = (
+                    AdminFlag.objects.only("on")
+                    .get(key=AdminFlagChoices.FOLDER_VIEW.value)
+                    .on
+                )
+                if not efv_flag:
+                    continue
+            else:
+                show = self.get_from_session(
+                    "show", session_key=self.BROWSER_SESSION_KEY
+                )
+                group = field_name[0]
+                if not show.get(group):
+                    continue
+            field_names.append(field_name)
+        return tuple(field_names)
 
-        _, arc_pks = self.get_group_pks_from_breadcrumbs([group])
-        if group.pk not in arc_pks:
-            arc_pks = (group.pk,)
-        arcs.append(
-            {
-                "group": attr[0],
-                "pks": arc_pks,
-                "name": group.name,
-                "mtime": group.updated_at,
-            }
+    def _get_group_pks_from_breadcrumbs(self):
+        """Set Multi-Group pks from breadcrumbs to the cache."""
+        group_pks = {}
+        top_group = self.get_from_session(
+            "top_group", session_key=self.BROWSER_SESSION_KEY
         )
-        return max_none(max_mtime, group.updated_at)
-
-    def _get_folder_arc(self, book, browser_arc_group, arcs, max_mtime):
-        """Append the folder arc."""
-        efv_flag = (
-            AdminFlag.objects.only("on")
-            .get(key=AdminFlag.FlagChoices.FOLDER_VIEW.value)
-            .on
+        arc_group = self.params["arc"]["group"]
+        if arc_group != top_group and not (
+            {top_group, arc_group}.issubset(_BROWSE_GROUP_SET)
+        ):
+            # Only do this if we might get a match.
+            return group_pks
+
+        breadcrumbs = self.get_from_session(
+            "breadcrumbs", session_key=self.BROWSER_SESSION_KEY
         )
-        if not efv_flag or browser_arc_group == FOLDER_GROUP:
-            return max_mtime
 
-        folder = book.parent_folder
-        arcs.append(
-            {
-                "group": FOLDER_GROUP,
-                "pks": (folder.pk,),
-                "name": folder.name,
-                "mtime": folder.updated_at,
-            }
+        index = len(breadcrumbs) - 1
+        min_index = (
+            max(index - 1, 0) if top_group in (FOLDER_GROUP, STORY_ARC_GROUP) else 0
         )
-        return max_none(max_mtime, folder.updated_at)
+        while index > min_index:
+            crumb = breadcrumbs[index]
+            crumb_group = crumb.get("group")
+            if crumb_group in "pi":
+                break
+            group_pks[crumb_group] = crumb.get("pks", ())
+            if crumb_group != "v":
+                break
+            index -= 1
+        return MappingProxyType(group_pks)
 
-    def _get_story_arcs(self, book, browser_arc, arcs, max_mtime):
-        """Append the story arcs."""
-        if browser_arc.get("group") == STORY_ARC_GROUP:
-            browser_arc_pks = frozenset(browser_arc.get("pks", ()))
+    def _get_group_arc(
+        self,
+        comic: Comic,
+        group_pks: Mapping,
+        field_name: str,
+        arcs: dict,
+        max_mtime: int | None,
+    ):
+        """Append the series or volume arc."""
+        group = getattr(comic, field_name)
+        arc_ids = tuple(group_pks.get(group, ()))
+        if group.pk not in arc_ids:
+            arc_ids = (group.pk,)
+
+        if len(arc_ids) > 1:
+            mtimes = group.model.objects.filter(pk__in=arc_ids).values_list(
+                "updated_at", flat=True
+            )
+            mtime = max_none(*mtimes)
         else:
-            browser_arc_pks = frozenset()
-
-        for san in book.story_arc_numbers.all().order_by("story_arc__name"):
-            sa = san.story_arc
-            if not browser_arc_pks or sa.pk not in browser_arc_pks:
-                arc = {
-                    "group": "a",
-                    "pks": (sa.pk,),
-                    "name": sa.name,
-                    "mtime": sa.updated_at,
-                }
-                arcs.append(arc)
-                max_mtime = max_none(max_mtime, sa.updated_at)
+            mtime = group.updated_at
+
+        max_mtime = max_none(max_mtime, mtime)
+
+        group_letter = "f" if field_name == "parent_folder" else field_name[0]
+        arcs[group_letter] = {arc_ids: {"name": group.name, "mtime": mtime}}
         return max_mtime
 
-    def get_arcs(self, book):
-        """Get all series/folder/story arcs."""
-        arcs = []
-        max_mtime = None
+    def _get_story_arcs(self, comic: Comic, arcs, max_mtime: int | None):
+        """Append the story arcs."""
+        qs = StoryArc.objects.filter(storyarcnumber__comic__pk=comic.pk)
+        qs = qs.group_by("sort_name")  # pyright: ignore[reportAttributeAccessIssue]
+        qs = qs.annotate(ids=JsonGroupArray("id", distinct=True))
+        qs = qs.annotate(updated_ats=JsonGroupArray("updated_at", distinct=True))
+        qs = qs.order_by("sort_name").values(*_STORY_ARC_ONLY)
+
+        if not qs.exists():
+            return max_mtime
 
-        if browser_arc := self.params.get("browser_arc", {}):
-            arcs.append(browser_arc)
-            browser_arc_mtime = browser_arc.get("mtime")
-            max_mtime = max_none(max_mtime, browser_arc_mtime)
+        arcs[STORY_ARC_GROUP] = {}
 
-        browser_arc_group = browser_arc.get("group", "")
-        max_mtime = self._get_group_arc(
-            book, "series", browser_arc_group, arcs, max_mtime
+        for sa in qs:
+            arc = {"name": sa.name}
+            ids = tuple(sorted(set(sa.ids)))
+            mtime = max_none(EPOCH_START, *sa.updated_ats)
+            arc["mtime"] = mtime
+            max_mtime = max_none(max_mtime, mtime)
+            arcs[STORY_ARC_GROUP][ids] = arc
+        return max_mtime
+
+    def _set_selected_arc(self, arcs):
+        arc = self.params["arc"]
+        arc_group = arc["group"]
+        requested_arc_ids = arc.get("ids", ())
+        arc_id_infos = arcs.get(arc_group)
+        all_arc_ids: frozenset[tuple[int, ...]] = (
+            frozenset(arc_id_infos.keys()) if arc_id_infos else frozenset()
         )
-        max_mtime = self._get_group_arc(
-            book, "volume", browser_arc_group, arcs, max_mtime
+        arc_ids = ()
+        if arc_group == STORY_ARC_GROUP:
+            if requested_arc_ids in all_arc_ids:
+                arc_ids = requested_arc_ids
+            else:
+                for arc_ids in all_arc_ids:
+                    if requested_arc_ids.intersection(frozenset(arc_ids)):
+                        break
+        if not arc_ids:
+            arc_ids = next(iter(all_arc_ids))
+        self._selected_arc_group = arc_group
+        self._selected_arc_ids = arc_ids
+
+    def get_arcs(self) -> tuple[dict, int | None]:
+        """Get all series/folder/story arcs."""
+        field_names = self._get_field_names()
+        comic_pk = self.kwargs.get("pk")
+        comic = (
+            Comic.objects.select_related(*field_names)
+            .only(*field_names)
+            .get(pk=comic_pk)
         )
-        max_mtime = self._get_folder_arc(book, browser_arc_group, arcs, max_mtime)
-        max_mtime = self._get_story_arcs(book, browser_arc, arcs, max_mtime)
 
+        group_pks = self._get_group_pks_from_breadcrumbs()
+        arcs = {}
+        max_mtime = None
+        for field_name in field_names:
+            max_mtime = self._get_group_arc(
+                comic, group_pks, field_name, arcs, max_mtime
+            )
+        max_mtime = self._get_story_arcs(comic, arcs, max_mtime)
+        self._set_selected_arc(arcs)
         return arcs, max_mtime

codex/views/reader/books.py

@@ -1,25 +1,22 @@
 """Get Books methods."""
 
-from typing import TYPE_CHECKING
-
 from django.db.models import F
-from django.db.models.query import Q
+from django.db.models.query import Q, QuerySet
+from django.urls import reverse
+from rest_framework.exceptions import NotFound
 
 from codex.models import Bookmark, Comic
+from codex.serializers.redirect import ReaderRedirectSerializer
 from codex.views.bookmark import BookmarkAuthMixin
 from codex.views.browser.filters.field import ComicFieldFilterView
 from codex.views.const import (
     FOLDER_GROUP,
-    GROUP_MODEL_MAP,
     GROUP_RELATION,
     NONE_INTEGERFIELD,
     STORY_ARC_GROUP,
 )
 from codex.views.mixins import SharedAnnotationsMixin
-from codex.views.reader.params import ReaderParamsView
-
-if TYPE_CHECKING:
-    from collections.abc import Mapping
+from codex.views.reader.arcs import ReaderArcsView
 
 _SETTINGS_ATTRS = ("fit_to", "two_pages", "reading_direction")
 _COMIC_FIELDS = (
@@ -32,142 +29,119 @@ _COMIC_FIELDS = (
     "reading_direction",
     "updated_at",
 )
+_ISSUE_ORDERING = (
+    "issue_number",
+    "issue_suffix",
+    "sort_name",
+)
 
 
-class ReaderBooksView(ReaderParamsView, SharedAnnotationsMixin, BookmarkAuthMixin):
+class ReaderBooksView(ReaderArcsView, SharedAnnotationsMixin, BookmarkAuthMixin):
     """Get Books methods."""
 
-    def _get_reader_arc_pks(
-        self, arc, arc_pk_select_related, prefetch_related, arc_pk_rel, arc_group
-    ):
-        """Get the nav filter."""
-        if arc_pks := arc.get("pks", ()):
-            return 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_qs = arc_pk_qs.values_list(arc_pk_rel, flat=True)
-            arc_pk = arc_pk_qs.first()
-        except IndexError:
-            arc_pk = 0
-
-        _, multi_arc_pks = self.get_group_pks_from_breadcrumbs([arc_group])
-        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_filter(self, rel, arc, arc_pks):
+    @staticmethod
+    def _get_bookmark_filter(auth_filter, comic_filter=None):
+        """Get the search kwargs for a user's authentication state."""
+        # search kwargs are relative to the bookmark object.
+        search_kwargs = {}
+        search_kwargs.update(auth_filter)
+
+        if comic_filter:
+            for key, value in comic_filter.items():
+                search_kwargs[f"comic__{key}"] = value
+
+        return search_kwargs
+
+    @staticmethod
+    def _append_with_settings(book, bookmark_filter):
+        """Append bookmark to book list."""
+        book.settings = (
+            Bookmark.objects.filter(**bookmark_filter, comic=book)
+            .only(*_SETTINGS_ATTRS)
+            .first()
+        )
+        return book
+
+    def _raise_not_found(self):
+        """Raise not found exception."""
+        pk = self.kwargs.get("pk")
+        detail = {
+            "route": reverse("app:start"),
+            "reason": f"comic {pk} not found",
+            "serializer": ReaderRedirectSerializer,
+        }
+        raise NotFound(detail=detail)
+
+    def _get_comics_filter(self, rel):
         """Build the filter."""
         group_acl_filter = self.get_group_acl_filter(Comic, self.request.user)
-        nav_filter = {f"{rel}__in": arc_pks}
+        nav_filter = {f"{rel}__in": self._selected_arc_ids}
         query_filter = group_acl_filter & Q(**nav_filter)
-        if browser_filters := arc.get("filters"):
+        if browser_filters := self.get_from_session(
+            "filters", session_key=self.BROWSER_SESSION_KEY
+        ):
             # no search at this time.
             query_filter &= ComicFieldFilterView.get_all_comic_field_filters(
                 "", browser_filters
             )
         return query_filter
 
-    def _get_comics_annotation_and_ordering(self, model, arc_group, arc_pks, ordering):
+    def _get_comics_annotation_and_ordering(self, model, ordering):
         """Get ordering for query."""
         sort_name_annotations = {}
-        if arc_group in ("v", "s"):
-            parent_group = "i" if arc_group == "s" else "s"
-            show = self.params["show"]
+        if self._selected_arc_group in "sv":
+            parent_group = "i" if self._selected_arc_group == "s" else "s"
+            show = self.get_from_session("show", session_key=self.BROWSER_SESSION_KEY)
             sort_name_annotations = self.get_sort_name_annotations(
-                model, parent_group, arc_pks, show
+                model, parent_group, self._selected_arc_ids, show
             )
             if sort_name_annotations and model is Comic:
                 ordering += (*sort_name_annotations.keys(),)
-            ordering += (
-                "issue_number",
-                "issue_suffix",
-                "sort_name",
-            )
+            ordering += _ISSUE_ORDERING
         return sort_name_annotations, tuple(ordering)
 
-    def _get_comics_list(self):
+    def _get_comics_list(self) -> QuerySet:
         """Get the reader naviation group filter."""
-        arc: Mapping = self.params.get("arc", {})
-
-        arc_group = arc.get("group", "")
-        if not GROUP_MODEL_MAP.get(arc_group):
-            arc_group = "s"
-
-        rel = GROUP_RELATION[arc_group]
+        rel = GROUP_RELATION[self._selected_arc_group]
         fields = _COMIC_FIELDS
         arc_pk_rel = rel + "__pk"
         arc_index = NONE_INTEGERFIELD
-        arc_pk_select_related = (rel,)
         select_related = ()
         prefetch_related = ()
         ordering = ()
 
-        if arc_group == STORY_ARC_GROUP:
+        if self._selected_arc_group == STORY_ARC_GROUP:
             arc_index = F("story_arc_numbers__number")
-            arc_pk_select_related = ()
             prefetch_related = (*prefetch_related, rel)
             ordering = ("arc_index", "date", "pk")
-        elif arc_group == FOLDER_GROUP:
+        elif self._selected_arc_group == FOLDER_GROUP:
             fields = (*_COMIC_FIELDS, rel)
             select_related = (rel,)
             ordering = ("path", "pk")
 
-        arc_pks = self._get_reader_arc_pks(
-            arc, arc_pk_select_related, prefetch_related, arc_pk_rel, arc_group
-        )
-
-        query_filter = self._get_comics_filter(rel, arc, arc_pks)
+        query_filter = self._get_comics_filter(rel)
         qs = Comic.objects.filter(query_filter)
 
-        if select_related:
-            qs = qs.select_related(*select_related)
         if prefetch_related:
             qs = qs.prefetch_related(*prefetch_related)
+        if select_related:
+            qs = qs.select_related(*select_related)
         qs = qs.only(*fields)
         qs = self.annotate_group_names(qs)
         qs = qs.annotate(
+            volume_number_to=(F("volume__number_to")),
             issue_count=F("volume__issue_count"),
             arc_pk=F(arc_pk_rel),
             arc_index=arc_index,
             mtime=F("updated_at"),
+            has_metadata=F("metadata_mtime"),
         )
         sort_names_alias, ordering = self._get_comics_annotation_and_ordering(
-            qs.model, arc_group, arc_pks, ordering
+            qs.model, ordering
         )
         if sort_names_alias:
             qs = qs.alias(**sort_names_alias)
-        qs = qs.order_by(*ordering)
-        return qs, arc_group
-
-    @staticmethod
-    def _get_bookmark_filter(auth_filter, comic_filter=None):
-        """Get the search kwargs for a user's authentication state."""
-        # search kwargs are relative to the bookmark object.
-        search_kwargs = {}
-        search_kwargs.update(auth_filter)
-
-        if comic_filter:
-            for key, value in comic_filter.items():
-                search_kwargs[f"comic__{key}"] = value
-
-        return search_kwargs
-
-    def _append_with_settings(self, book, bookmark_filter):
-        """Append bookmark to book list."""
-        book.settings = (
-            Bookmark.objects.filter(**bookmark_filter, comic=book)
-            .only(*_SETTINGS_ATTRS)
-            .first()
-        )
-        return book
+        return qs.order_by(*ordering)
 
     def get_book_collection(self):
         """
@@ -179,7 +153,7 @@ class ReaderBooksView(ReaderParamsView, SharedAnnotationsMixin, BookmarkAuthMixi
 
         Yields 1 to 3 books
         """
-        comics, arc_group = self._get_comics_list()
+        comics = self._get_comics_list()
         auth_filter = self.get_bookmark_auth_filter()
         bookmark_filter = self._get_bookmark_filter(auth_filter)
         books = {}
@@ -197,13 +171,14 @@ class ReaderBooksView(ReaderParamsView, SharedAnnotationsMixin, BookmarkAuthMixi
                         prev_book, bookmark_filter
                     )
                 # create extra current book attrs:
-                if book.arc_index is None:
-                    book.arc_index = index + 1
                 book.filename = book.get_filename()
-                book.arc_group = arc_group
-                book.arc_count = comics.count()
+                self._selected_arc_index = index + 1
+                self._selected_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
+
+        if not books.get("current"):
+            self._raise_not_found()
         return books

codex/views/reader/page.py

@@ -6,19 +6,19 @@ from comicbox.box import Comicbox
 from django.http.response import StreamingHttpResponse
 from drf_spectacular.types import OpenApiTypes
 from drf_spectacular.utils import OpenApiParameter, extend_schema
+from loguru import logger
 from rest_framework.exceptions import NotFound
 from rest_framework.negotiation import BaseContentNegotiation
+from typing_extensions import override
 
 from codex.librarian.bookmark.tasks import BookmarkUpdateTask
 from codex.librarian.mp_queue import LIBRARIAN_QUEUE
-from codex.logger.logger import get_logger
 from codex.models.comic import Comic, FileType
-from codex.settings.settings import FALSY
+from codex.settings import COMICBOX_CONFIG, FALSY
 from codex.views.auth import AuthFilterAPIView
 from codex.views.bookmark import BookmarkAuthMixin
 from codex.views.util import chunker
 
-LOG = get_logger(__name__)
 _PDF_MIME_TYPE = "application/pdf"
 # Most pages seem to be 2.5 Mb
 # largest pages I've seen were 9 Mb
@@ -28,15 +28,17 @@ _PAGE_CHUNK_SIZE = (1024**2) * 3  # 3 Mb
 class IgnoreClientContentNegotiation(BaseContentNegotiation):
     """Hack for clients with wild accept headers."""
 
-    def select_parser(self, request, parsers):  # noqa: ARG002
+    @override
+    def select_parser(self, request, parsers):
         """Select the first parser in the `.parser_classes` list."""
         return next(iter(parsers))
 
+    @override
     def select_renderer(
         self,
-        request,  # noqa: ARG002
+        request,
         renderers,
-        format_suffix="",  # noqa: ARG002, F841, RUF100
+        format_suffix="",
     ):
         """Select the first renderer in the `.renderer_classes` list."""
         renderer = next(iter(renderers))
@@ -48,7 +50,9 @@ class ReaderPageView(BookmarkAuthMixin, AuthFilterAPIView):
 
     X_MOZ_PRE_HEADERS = frozenset({"prefetch", "preload", "prerender", "subresource"})
     content_type = "image/jpeg"
-    content_negotiation_class = IgnoreClientContentNegotiation  # type: ignore[reportAssignmentType]
+    content_negotiation_class: type[BaseContentNegotiation] = (  # pyright:ignore[reportIncompatibleVariableOverride]
+        IgnoreClientContentNegotiation
+    )
 
     def _update_bookmark(self):
         """Update the bookmark if the bookmark param was passed."""
@@ -78,7 +82,7 @@ class ReaderPageView(BookmarkAuthMixin, AuthFilterAPIView):
         # page_image
         page = self.kwargs.get("page")
         to_pixmap = self.request.GET.get("pixmap", "").lower() not in FALSY
-        with Comicbox(comic.path) as cb:
+        with Comicbox(comic.path, config=COMICBOX_CONFIG, logger=logger) as cb:
             page_image = cb.get_page_by_index(page, to_pixmap=to_pixmap)
         if not page_image:
             page_image = b""
@@ -115,7 +119,7 @@ class ReaderPageView(BookmarkAuthMixin, AuthFilterAPIView):
             detail = f"comic path for {pk} not found: {exc}."
             raise NotFound(detail=detail) from exc
         except Exception as exc:
-            LOG.warning(exc)
+            logger.warning(exc)
             raise NotFound(detail="comic page not found") from exc
         else:
             page_chunker = chunker(BytesIO(page_image), _PAGE_CHUNK_SIZE)