codex 1.6.0__py3-none-any.whl → 1.6.0a1__py3-none-any.whl

codex/views/reader/reader.py

@@ -1,30 +1,293 @@
 """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.utils import extend_schema
-from rest_framework.exceptions import NotFound
+from drf_spectacular.types import OpenApiTypes
+from drf_spectacular.utils import OpenApiParameter, extend_schema
+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.serializers.reader import ReaderComicsSerializer, ReaderViewInputSerializer
+from codex.models import AdminFlag, Bookmark, Comic
+from codex.serializers.reader import ReaderArcSerializer, ReaderComicsSerializer
 from codex.serializers.redirect import ReaderRedirectSerializer
-from codex.views.reader.arcs import ReaderArcsView
-from codex.views.util import pop_name
+from codex.views.bookmark import BookmarkBaseView
+from codex.views.mixins import SharedAnnotationsMixin
+from codex.views.session import BrowserSessionViewBase
 
 LOG = get_logger(__name__)
 
 
-class ReaderView(ReaderArcsView):
+_MIN_CRUMB_WALKBACK_LEN = 3
+
+
+class ReaderView(
+    BookmarkBaseView,
+    BrowserSessionViewBase,
+    SharedAnnotationsMixin,
+):
     """Get info for displaying comic pages."""
 
     serializer_class = ReaderComicsSerializer
+    input_serializer_class = ReaderArcSerializer
 
-    SESSION_KEY = "reader"
+    SETTINGS_ATTRS = ("fit_to", "two_pages", "reading_direction")
+    _COMIC_FIELDS = (
+        "file_type",
+        "issue_number",
+        "issue_suffix",
+        "page_count",
+        "series",
+        "volume",
+        "reading_direction",
+        "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 = 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_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")
+            arc_pk_select_related = ()
+        elif arc_group == self.FOLDER_GROUP:
+            # folder mode
+            rel = "parent_folder"
+            fields = (*self._COMIC_FIELDS, "parent_folder")
+            arc_pk_rel = "parent_folder__pk"
+            select_related = (*select_related, "parent_folder")
+            arc_index = Value(None, IntegerField())
+            ordering = ("path", "pk")
+            arc_pk_select_related = ("parent_folder",)
+        else:
+            # browser mode.
+            rel = "series"
+            fields = self._COMIC_FIELDS
+            arc_pk_rel = "series__pk"
+            arc_index = Value(None, IntegerField())
+            ordering = ()
+            arc_pk_select_related = ("series",)
+
+        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)
+
+        qs = (
+            Comic.objects.filter(group_acl_filter)
+            .filter(**nav_filter)
+            .select_related(*select_related)
+            .prefetch_related(*prefetch_related)
+            .only(*fields)
+            .annotate(
+                issue_count=F("volume__issue_count"),
+            )
+            .annotate(
+                arc_pk=F(arc_pk_rel),
+                arc_index=arc_index,
+            )
+            .annotate(mtime=F("updated_at"))
+        )
+        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):
+        """Append bookmark to book list."""
+        book.settings = (
+            Bookmark.objects.filter(**bookmark_filter, comic=book)
+            .only(*self.SETTINGS_ATTRS)
+            .first()
+        )
+        return book
+
+    def _get_book_collection(self):
+        """Get the -1, +1 window around the current issue.
+
+        Uses iteration in python. There are some complicated ways of
+        doing this with __gt[0] & __lt[0] in the db, but I think they
+        might be even more expensive.
+
+        Yields 1 to 3 books
+        """
+        comics, arc_group = self._get_comics_list()
+        bookmark_filter = self.get_bookmark_filter()
+        books = {}
+        prev_book = None
+        pk = self.kwargs.get("pk")
+        for index, book in enumerate(comics):
+            if books:
+                # after match set next comic and break
+                books["next"] = self._append_with_settings(book, bookmark_filter)
+                break
+            if book.pk == pk:
+                # first match. set previous and current comic
+                if prev_book:
+                    books["prev"] = self._append_with_settings(
+                        prev_book, bookmark_filter
+                    )
+                # create extra current book attrs:
+                if book.arc_index is None:  # type: ignore
+                    book.arc_index = index + 1  # 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
+
+    def _get_folder_arc(self, book):
+        """Create the folder arc."""
+        efv_flag = (
+            AdminFlag.objects.only("on")
+            .get(key=AdminFlag.FlagChoices.FOLDER_VIEW.value)
+            .on
+        )
+
+        if efv_flag:
+            folder = book.parent_folder
+            folder_arc = {
+                "group": self.FOLDER_GROUP,
+                "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 = self._get_series_arc(book)
+
+        # order top arcs
+        top_group = self.params.get("top_group")
+        if top_group == self.FOLDER_GROUP and folder_arc:
+            arc = folder_arc
+            other_arc = series_arc
+        else:
+            arc = series_arc
+            other_arc = folder_arc
+
+        arcs = []
+        arcs.append(arc)
+        if other_arc:
+            arcs.append(other_arc)
+
+        # story arcs
+        sas = self._get_story_arcs(book)
+        arcs += sas
+        return arcs
+
     def _raise_not_found(self):
         """Raise not found exception."""
         pk = self.kwargs.get("pk")
@@ -62,7 +325,8 @@ class ReaderView(ReaderArcsView):
     def get_object(self):
         """Get the previous and next comics in a group or story arc."""
         # Books
-        books = self.get_book_collection()
+        self.last_route = self.get_last_route()
+        books = self._get_book_collection()
 
         current = books.get("current")
         if not current:
@@ -79,7 +343,7 @@ class ReaderView(ReaderArcsView):
         }
 
         # Arcs
-        arcs, mtime = self.get_arcs(current)
+        arcs = self._get_arcs(current)
 
         arc = self.params.get("arc", {})
         if not arc.get("group"):
@@ -88,19 +352,58 @@ class ReaderView(ReaderArcsView):
             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)
 
-        close_route = self.get_last_route()
-        close_route = pop_name(close_route)
+        return {"books": books, "arcs": arcs, "arc": arc, "close_route": close_route}
 
-        return {
-            "books": books,
-            "arcs": arcs,
-            "arc": arc,
-            "close_route": close_route,
-            "mtime": mtime,
-        }
+    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 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 = None
+
+        params = MappingProxyType(
+            {
+                "arc": arc,
+                "top_group": top_group,
+            }
+        )
+        self.params = params
 
-    @extend_schema(parameters=[ReaderViewInputSerializer])
+    @extend_schema(
+        parameters=[
+            OpenApiParameter(
+                "arc[group]", OpenApiTypes.STR, enum=sorted(_VALID_ARC_GROUPS)
+            ),
+            OpenApiParameter("arc[pks]", OpenApiTypes.STR),
+        ]
+    )
     def get(self, *args, **kwargs):
         """Get the book info."""
         self._parse_params()

codex/views/reader/{settings.py → session.py}

@@ -1,12 +1,10 @@
 """Reader session view."""
 
 from codex.serializers.reader import ReaderSettingsSerializer
-from codex.views.settings import SettingsView
+from codex.views.session import ReaderSessionViewBase, SessionViewBase
 
 
-class ReaderSettingsView(SettingsView):
+class ReaderSessionView(ReaderSessionViewBase, SessionViewBase):
     """Get Reader Settings."""
 
     serializer_class = ReaderSettingsSerializer  # type: ignore
-
-    SESSION_KEY = "reader"

codex/views/session.py

@@ -3,21 +3,64 @@
 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
+from rest_framework.response import Response
 
 from codex.logger.logging import get_logger
 from codex.serializers.choices import DEFAULTS
-from codex.views.auth import AuthFilterGenericAPIView
-from codex.views.util import pop_name
+from codex.views.auth import IsAuthenticatedOrEnabledNonUsers
 
 LOG = get_logger(__name__)
 
 
-class SessionView(AuthFilterGenericAPIView, ABC):
+class SessionViewBaseBase(GenericAPIView, ABC):
     """Generic Session View."""
 
     # Must override both of these
     SESSION_KEY = ""
+    SESSION_DEFAULTS = MappingProxyType({})
+
+    @classmethod
+    def _get_source_values_or_set_defaults(cls, defaults_dict, source_dict, data):
+        """Recursively copy source_dict values into data or use defaults."""
+        result = deepcopy(data)
+        for key, default_value in defaults_dict.items():
+            result[key] = source_dict.get(key, default_value)
+            if result[key] is None:
+                # extra check for migrated or corrupt data
+                result[key] = default_value
+            if isinstance(default_value, dict):
+                result[key] = cls._get_source_values_or_set_defaults(
+                    default_value, source_dict.get(key, {}), result[key]
+                )
+        return result
+
+    def get_from_session(self, key):  # only used by frontend
+        """Get one key from the session or its default."""
+        session = self.request.session.get(self.SESSION_KEY, self.SESSION_DEFAULTS)
+        return session.get(key, self.SESSION_DEFAULTS[key])
 
+    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, {}
+            )
+            self.request.session[self.SESSION_KEY] = data
+            self.request.session.save()
+        except Exception as exc:
+            LOG.warning(f"Saving params to session: {exc}")
+
+
+class BrowserSessionViewBase(SessionViewBaseBase):
+    """Browser session base."""
+
+    SESSION_KEY = "browser"  # type: ignore
     CONTRIBUTOR_PERSON_UI_FIELD = "contributors"
     STORY_ARC_UI_FIELD = "story_arcs"
     IDENTIFIER_TYPE_UI_FIELD = "identifier_type"
@@ -37,6 +80,7 @@ class SessionView(AuthFilterGenericAPIView, ABC):
             "locations": [],
             "monochrome": [],
             "original_format": [],
+            "q": "",
             "reading_direction": [],
             "series_groups": [],
             "stories": [],
@@ -48,100 +92,75 @@ class SessionView(AuthFilterGenericAPIView, ABC):
         }
     )
     FILTER_ATTRIBUTES = frozenset(_DYNAMIC_FILTER_DEFAULTS.keys())
-    BROWSER_SESSION_KEY = "browser"
-    READER_SESSION_KEY = "reader"
     SESSION_DEFAULTS = MappingProxyType(
         {
-            BROWSER_SESSION_KEY: {
-                "breadcrumbs": DEFAULTS["breadcrumbs"],
-                "filters": {
-                    "bookmark": DEFAULTS["bookmarkFilter"],
-                    **_DYNAMIC_FILTER_DEFAULTS,
-                },
-                "order_by": DEFAULTS["orderBy"],
-                "order_reverse": DEFAULTS["orderReverse"],
-                "q": DEFAULTS["q"],
-                "search_results_limit": DEFAULTS["searchResultsLimit"],
-                "show": DEFAULTS["show"],
-                "dynamic_covers": DEFAULTS["dynamicCovers"],
-                "custom_covers": DEFAULTS["customCovers"],
-                "twenty_four_hour_time": DEFAULTS["twentyFourHourTime"],
-                "top_group": DEFAULTS["topGroup"],
-            },
-            READER_SESSION_KEY: {
-                "finish_on_last_page": DEFAULTS["finishOnLastPage"],
-                "fit_to": DEFAULTS["fitTo"],
-                "two_pages": DEFAULTS["twoPages"],
-                "read_rtl_in_reverse": DEFAULTS["readRtlInReverse"],
-                "reading_direction": DEFAULTS["readingDirection"],
+            "breadcrumbs": DEFAULTS["breadcrumbs"],
+            "filters": {
+                "bookmark": DEFAULTS["bookmarkFilter"],
+                **_DYNAMIC_FILTER_DEFAULTS,
             },
+            "order_by": DEFAULTS["orderBy"],
+            "order_reverse": DEFAULTS["orderReverse"],
+            "q": DEFAULTS["q"],
+            "search_results_limit": DEFAULTS["searchResultsLimit"],
+            "show": DEFAULTS["show"],
+            "twenty_four_hour_time": False,
+            "top_group": DEFAULTS["topGroup"],
         }
     )
 
-    def get_from_session(
-        self, key, default=None, session_key=None
-    ):  # only used by frontend
-        """Get one key from the session or its default."""
-        if session_key is None:
-            session_key = self.SESSION_KEY
-        session = self.request.session.get(
-            session_key, self.SESSION_DEFAULTS[session_key]
-        )
-        if default is None:
-            default = self.SESSION_DEFAULTS[session_key][key]
-        return session.get(key, default)
-
     def get_last_route(self, name=True):
         """Get the last route from the breadcrumbs."""
-        breadcrumbs = self.get_from_session(
-            "breadcrumbs", session_key=self.BROWSER_SESSION_KEY
-        )
+        breadcrumbs = self.get_from_session("breadcrumbs")
         if not breadcrumbs:
             breadcrumbs = DEFAULTS["breadcrumbs"]
         last_route = breadcrumbs[-1]
         if not name:
-            last_route = pop_name(last_route)
+            last_route.pop("name", None)
 
         return last_route
 
-    @classmethod
-    def _get_source_values_or_set_defaults(cls, defaults_dict, source_dict, data):
-        """Recursively copy source_dict values into data or use defaults."""
-        result = deepcopy(data)
-        for key, default_value in defaults_dict.items():
-            result[key] = source_dict.get(key, default_value)
-            if result[key] is None:
-                # extra check for migrated or corrupt data
-                result[key] = default_value
-            if isinstance(default_value, dict):
-                result[key] = cls._get_source_values_or_set_defaults(
-                    default_value, source_dict.get(key, {}), result[key]
-                )
-        return result
 
-    def load_params_from_session(self, session_key=None, only=None):
-        """Get session settings with defaults."""
-        if not session_key:
-            session_key = self.SESSION_KEY
-        if only:
-            defaults = {}
-            for key in only:
-                if key:
-                    defaults[key] = self.SESSION_DEFAULTS[session_key][key]
-        else:
-            defaults = self.SESSION_DEFAULTS[session_key]
-
-        session = self.request.session.get(session_key, defaults)
-        return self._get_source_values_or_set_defaults(defaults, session, {})
+class ReaderSessionViewBase(SessionViewBaseBase):
+    """Reader session base."""
 
-    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))
-            defaults = self.SESSION_DEFAULTS[self.SESSION_KEY]
-            data = self._get_source_values_or_set_defaults(defaults, params, {})
-            self.request.session[self.SESSION_KEY] = data
-            self.request.session.save()
-        except Exception as exc:
-            LOG.warning(f"Saving params to session: {exc}")
+    SESSION_KEY = "reader"  # type: ignore
+    SESSION_DEFAULTS = MappingProxyType(
+        {
+            "fit_to": DEFAULTS["fitTo"],
+            "two_pages": False,
+            "reading_direction": DEFAULTS["readingDirection"],
+        }
+    )
+
+
+class SessionViewBase(SessionViewBaseBase, GenericAPIView, ABC):
+    """Session view for retrieving stored settings."""
+
+    permission_classes: ClassVar[list] = [IsAuthenticatedOrEnabledNonUsers]  # type: ignore
+
+    def load_params_from_session(self):
+        """Set the params from view session, creating missing values from defaults."""
+        session = self.request.session.get(self.SESSION_KEY, self.SESSION_DEFAULTS)
+        return self._get_source_values_or_set_defaults(
+            self.SESSION_DEFAULTS, session, {}
+        )
+
+    def get(self, *args, **kwargs):
+        """Get session settings."""
+        params = self.load_params_from_session()
+        data = {}
+        for key, filter_name in params.get("filters", {}).items():
+            if filter_name:
+                data[key] = filter_name
+        params["filters"] = data
+        serializer = self.get_serializer(params)
+        return Response(serializer.data)
+
+    @extend_schema(responses=None)
+    def put(self, *args, **kwargs):
+        """Update session settings."""
+        serializer = self.get_serializer(data=self.request.data)
+        serializer.is_valid(raise_exception=True)
+        self.save_params_to_session(serializer.validated_data)
+        return Response()

codex/views/template.py

@@ -13,7 +13,7 @@ class TemplateXMLRenderer(TemplateHTMLRenderer):
     format = "xml"
 
 
-class CodexAPIView(APIView):
+class SimpleAPIView(APIView):
     """APIView with a simple getter and no data."""
 
     content_type = "application/json"
@@ -26,14 +26,14 @@ class CodexAPIView(APIView):
         )
 
 
-class CodexTemplateView(CodexAPIView):
+class CodexTemplateView(SimpleAPIView):
     """HTML Template View."""
 
     renderer_classes = (TemplateHTMLRenderer,)
     content_type = "text/html"
 
 
-class CodexXMLTemplateView(CodexAPIView):
+class CodexXMLTemplateView(SimpleAPIView):
     """XML Template View."""
 
     renderer_classes = (TemplateXMLRenderer,)

codex/views/version.py

@@ -1,13 +1,13 @@
 """Version View."""
 
+from rest_framework.generics import GenericAPIView
 from rest_framework.response import Response
 
 from codex.serializers.versions import VersionsSerializer
 from codex.version import PACKAGE_NAME, VERSION, get_latest_version
-from codex.views.auth import AuthGenericAPIView
 
 
-class VersionView(AuthGenericAPIView):
+class VersionView(GenericAPIView):
     """Return Codex Versions."""
 
     serializer_class = VersionsSerializer