codex 1.6.0a5__py3-none-any.whl → 1.6.0a7__py3-none-any.whl

codex/views/reader/reader.py

@@ -1,10 +1,8 @@
 """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
@@ -14,41 +12,23 @@ 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 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
+from codex.views.reader.arcs import ReaderArcsView
 
 LOG = get_logger(__name__)
-
-
-_MIN_CRUMB_WALKBACK_LEN = 3
+_VALID_ARC_GROUPS = frozenset({"f", "s", "a"})
 
 
 class ReaderView(
-    BookmarkBaseView,
-    BrowserSessionViewBase,
-    SharedAnnotationsMixin,
+    ReaderArcsView,
 ):
     """Get info for displaying comic pages."""
 
     serializer_class = ReaderComicsSerializer
     input_serializer_class = ReaderArcSerializer
 
-    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"})
+    SESSION_KEY = "reader"
     TARGET = "reader"
 
     def __init__(self, *args, **kwargs):
@@ -56,238 +36,6 @@ class ReaderView(
         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")
@@ -298,6 +46,46 @@ class ReaderView(
         }
         raise NotFound(detail=detail)
 
+    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: dict = serializer.validated_data  # type: ignore
+        except ValidationError:
+            pass
+
+        # PARAMS
+        top_group = self.get_from_session(
+            "top_group", "s", session_key=self.BROWSER_SESSION_KEY
+        )
+
+        # 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 _VALID_ARC_GROUPS:
+            arc_group = None
+
+        params = MappingProxyType(
+            {
+                "arc": arc,
+                "top_group": top_group,
+            }
+        )
+        self.params = params
+
     @staticmethod
     def _lazy_metadata(current, prev_book, next_book):
         """Get reader metadata from comicbox if it's not in the db."""
@@ -326,7 +114,7 @@ class ReaderView(
         """Get the previous and next comics in a group or story arc."""
         # Books
         self.last_route = self.get_last_route()
-        books = self._get_book_collection()
+        books = self.get_book_collection()
 
         current = books.get("current")
         if not current:
@@ -343,7 +131,7 @@ class ReaderView(
         }
 
         # Arcs
-        arcs = self._get_arcs(current)
+        arcs, mtime = self.get_arcs(current)
 
         arc = self.params.get("arc", {})
         if not arc.get("group"):
@@ -355,46 +143,13 @@ class ReaderView(
         close_route = self.last_route
         close_route.pop("name", None)
 
-        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 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
+        return {
+            "books": books,
+            "arcs": arcs,
+            "arc": arc,
+            "close_route": close_route,
+            "mtime": mtime,
+        }
 
     @extend_schema(
         parameters=[

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

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

codex/views/session.py

@@ -3,64 +3,20 @@
 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 IsAuthenticatedOrEnabledNonUsers
+from codex.views.auth import AuthFilterGenericAPIView
 
 LOG = get_logger(__name__)
 
 
-class SessionViewBaseBase(GenericAPIView, ABC):
+class SessionView(AuthFilterGenericAPIView, 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"
@@ -80,7 +36,6 @@ class BrowserSessionViewBase(SessionViewBaseBase):
             "locations": [],
             "monochrome": [],
             "original_format": [],
-            "q": "",
             "reading_direction": [],
             "series_groups": [],
             "stories": [],
@@ -92,27 +47,51 @@ class BrowserSessionViewBase(SessionViewBaseBase):
         }
     )
     FILTER_ATTRIBUTES = frozenset(_DYNAMIC_FILTER_DEFAULTS.keys())
+    BROWSER_SESSION_KEY = "browser"
+    READER_SESSION_KEY = "reader"
     SESSION_DEFAULTS = MappingProxyType(
         {
-            "breadcrumbs": DEFAULTS["breadcrumbs"],
-            "filters": {
-                "bookmark": DEFAULTS["bookmarkFilter"],
-                **_DYNAMIC_FILTER_DEFAULTS,
+            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"],
+                "cover_style": DEFAULTS["coverStyle"],
+                "twenty_four_hour_time": False,
+                "top_group": DEFAULTS["topGroup"],
+            },
+            READER_SESSION_KEY: {
+                "fit_to": DEFAULTS["fitTo"],
+                "two_pages": False,
+                "reading_direction": DEFAULTS["readingDirection"],
             },
-            "order_by": DEFAULTS["orderBy"],
-            "order_reverse": DEFAULTS["orderReverse"],
-            "q": DEFAULTS["q"],
-            "search_results_limit": DEFAULTS["searchResultsLimit"],
-            "show": DEFAULTS["show"],
-            "cover_style": DEFAULTS["coverStyle"],
-            "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")
+        breadcrumbs = self.get_from_session(
+            "breadcrumbs", session_key=self.BROWSER_SESSION_KEY
+        )
         if not breadcrumbs:
             breadcrumbs = DEFAULTS["breadcrumbs"]
         last_route = breadcrumbs[-1]
@@ -121,47 +100,40 @@ class BrowserSessionViewBase(SessionViewBaseBase):
 
         return last_route
 
+    def load_params_from_session(self, validated_data=None, session_key=None):
+        """Load params from the session with defaults."""
+        session_key = session_key if session_key else self.SESSION_KEY
+        params = deepcopy(dict(self.SESSION_DEFAULTS[session_key]))
+        session_params = self.request.session.get(session_key)
+        if session_params:
+            params.update(session_params)
+        if validated_data:
+            params.update(validated_data)
+        self.params = MappingProxyType(params)
 
-class ReaderSessionViewBase(SessionViewBaseBase):
-    """Reader session base."""
-
-    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)
+    @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
 
-    @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()
+    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}")

codex/views/settings.py

@@ -0,0 +1,34 @@
+"""Settings View."""
+
+from abc import ABC
+
+from drf_spectacular.utils import extend_schema
+from rest_framework.response import Response
+
+from codex.views.session import SessionView
+
+
+class SettingsView(SessionView, ABC):
+    """Settings View."""
+
+    def get(self, *args, **kwargs):
+        """Get session settings."""
+        defaults = self.SESSION_DEFAULTS[self.SESSION_KEY]
+        session = self.request.session.get(self.SESSION_KEY, defaults)
+        params = self._get_source_values_or_set_defaults(defaults, 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."""
+        data = self.request.data  # type: ignore
+        serializer = self.get_serializer(data=data)
+        serializer.is_valid(raise_exception=True)
+        self.save_params_to_session(serializer.validated_data)
+        return Response()