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

codex/views/opds/v2/publications.py

@@ -9,26 +9,27 @@ from codex.librarian.covers.create import CoverCreateMixin
 from codex.models import Comic
 from codex.views.opds.const import AUTHOR_ROLES, MimeType, Rel
 from codex.views.opds.util import get_contributors, get_m2m_objects
-from codex.views.opds.v2.links import HrefData, LinkData, LinksMixin
-
-
-class PublicationMixin(LinksMixin):
+from codex.views.opds.v2.top_links import HrefData, LinkData, OPDS2TopLinksView
+
+_MD_CONTRIBUTOR_MAP = MappingProxyType(
+    {
+        "author": AUTHOR_ROLES,
+        # "translator": {},
+        "editor": {"Editor"},
+        "artist": {"CoverArtist"},
+        # "illustrator": {},
+        "letterer": {"Letterer"},
+        "penciller": {"Penciller"},
+        "colorist": {"Colorist"},
+        "inker": {"Inker"},
+    }
+)
+_CONTRIBUTOR_ROLES = frozenset({x for s in _MD_CONTRIBUTOR_MAP.values() for x in s})
+
+
+class OPDS2PublicationView(OPDS2TopLinksView):
     """Publication Methods for OPDS 2.0 feed."""
 
-    _MD_CONTRIBUTOR_MAP = MappingProxyType(
-        {
-            "author": AUTHOR_ROLES,
-            # "translator": {},
-            "editor": {"Editor"},
-            "artist": {"CoverArtist"},
-            # "illustrator": {},
-            "letterer": {"Letterer"},
-            "penciller": {"Penciller"},
-            "colorist": {"Colorist"},
-            "inker": {"Inker"},
-        }
-    )
-    _CONTRIBUTOR_ROLES = frozenset({x for s in _MD_CONTRIBUTOR_MAP.values() for x in s})
     is_opds_metadata = False
 
     def _get_big_image_link(self, obj, cover_pk):
@@ -106,9 +107,9 @@ 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():
+        for key, roles in _MD_CONTRIBUTOR_MAP.items():
             self._add_contributors(md, obj.ids, key, roles)
-        if contributors := get_contributors(obj.ids, self._CONTRIBUTOR_ROLES, True):
+        if contributors := get_contributors(obj.ids, _CONTRIBUTOR_ROLES, True):
             md["contributor"] = contributors
 
         if m2m_objs := get_m2m_objects(obj.ids):

codex/views/opds/v2/top_links.py

@@ -1,10 +1,10 @@
 """OPDS v2.0 top links section methods."""
 
 from codex.views.opds.const import MimeType, Rel
-from codex.views.opds.v2.links import HrefData, LinkData, LinksMixin
+from codex.views.opds.v2.links import HrefData, LinkData, OPDS2LinksView
 
 
-class TopLinksMixin(LinksMixin):
+class OPDS2TopLinksView(OPDS2LinksView):
     """OPDS 2.0 top links section methods."""
 
     def _link_auth(self):

codex/views/public.py

@@ -0,0 +1,38 @@
+"""Public non-authenticated views."""
+
+from rest_framework.generics import GenericAPIView
+from rest_framework.mixins import RetrieveModelMixin
+from rest_framework.parsers import JSONParser
+
+from codex.logger.logging import get_logger
+from codex.models import AdminFlag
+from codex.serializers.auth import AuthAdminFlagsSerializer
+from codex.serializers.choices import CHOICES
+
+LOG = get_logger(__name__)
+_ADMIN_FLAG_KEYS = frozenset(
+    {
+        AdminFlag.FlagChoices.NON_USERS.value,
+        AdminFlag.FlagChoices.REGISTRATION.value,
+    }
+)
+
+
+class AdminFlagsView(GenericAPIView, RetrieveModelMixin):
+    """Get admin flags relevant to auth."""
+
+    parser_classes = (JSONParser,)
+    serializer_class = AuthAdminFlagsSerializer
+    queryset = AdminFlag.objects.filter(key__in=_ADMIN_FLAG_KEYS).only("key", "on")
+
+    def get_object(self):
+        """Get admin flags."""
+        flags = {}
+        for obj in self.get_queryset():  # type: ignore
+            name = CHOICES["admin"]["adminFlags"][obj.key].lower().replace(" ", "_")
+            flags[name] = obj.on
+        return flags
+
+    def get(self, request, *args, **kwargs):
+        """Get admin flags relevant to auth."""
+        return self.retrieve(request, *args, **kwargs)

codex/views/reader/arcs.py

@@ -0,0 +1,101 @@
+"""Reader get Arcs methods."""
+
+from types import MappingProxyType
+
+from codex.models import AdminFlag
+from codex.util import max_none
+from codex.views.const import FOLDER_GROUP
+from codex.views.reader.books import ReaderBooksView
+
+
+class ReaderArcsView(ReaderBooksView):
+    """Reader get Arcs methods."""
+
+    def __init__(self, *args, **kwargs):
+        """Initialize instance vars."""
+        super().__init__(*args, **kwargs)
+        self.params: MappingProxyType = MappingProxyType({})
+
+    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": FOLDER_GROUP,
+                "pks": (folder.pk,),
+                "name": folder.name,
+                "mtime": folder.updated_at,
+            }
+        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,
+                    "mtime": series.updated_at,
+                }
+                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,
+                "mtime": sa.updated_at,
+            }
+            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 == 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
+
+        max_mtime = None
+        for arc in arcs:
+            max_mtime = max_none(max_mtime, arc["mtime"])
+        return arcs, max_mtime

codex/views/reader/books.py

@@ -0,0 +1,199 @@
+"""Get Books methods."""
+
+from copy import deepcopy
+from typing import TYPE_CHECKING
+
+from django.db.models import F, IntegerField, Value
+
+from codex.models import Bookmark, Comic
+from codex.views.bookmark import BookmarkBaseView
+from codex.views.const import FOLDER_GROUP
+from codex.views.mixins import SharedAnnotationsMixin
+from codex.views.session import SessionView
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+
+_MIN_CRUMB_WALKBACK_LEN = 3
+_SETTINGS_ATTRS = ("fit_to", "two_pages", "reading_direction")
+_COMIC_FIELDS = (
+    "file_type",
+    "issue_number",
+    "issue_suffix",
+    "page_count",
+    "series",
+    "volume",
+    "reading_direction",
+    "updated_at",
+)
+
+
+class ReaderBooksView(BookmarkBaseView, SessionView, SharedAnnotationsMixin):
+    """Get Books methods."""
+
+    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", session_key=self.BROWSER_SESSION_KEY
+        )
+        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: Mapping = self.params.get("arc", {})  # type: ignore
+
+        arc_group = arc.get("group", "s")
+        if arc_group == "a":
+            # for story arcs
+            rel = "story_arc_numbers__story_arc"
+            fields = _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 == FOLDER_GROUP:
+            # folder mode
+            rel = "parent_folder"
+            fields = (*_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 = _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", session_key=self.BROWSER_SESSION_KEY)
+            )
+            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(*_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
+
+    #####

codex/views/reader/page.py

@@ -1,7 +1,5 @@
 """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
@@ -11,12 +9,11 @@ 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
 
 LOG = get_logger(__name__)
-PDF_MIME_TYPE = "application/pdf"
+_PDF_MIME_TYPE = "application/pdf"
 
 
 class IgnoreClientContentNegotiation(BaseContentNegotiation):
@@ -43,7 +40,6 @@ 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."""
@@ -67,7 +63,7 @@ class ReaderPageView(BookmarkBaseView):
         page = self.kwargs.get("page")
         to_pixmap = self.request.GET.get("pixmap", "").lower() not in FALSY
         if comic.file_type == Comic.FileType.PDF.value and not to_pixmap:
-            content_type = PDF_MIME_TYPE
+            content_type = _PDF_MIME_TYPE
         else:
             content_type = self.content_type
         with Comicbox(comic.path) as cb:
@@ -81,7 +77,7 @@ class ReaderPageView(BookmarkBaseView):
         ],
         responses={
             (200, content_type): OpenApiTypes.BINARY,
-            (200, PDF_MIME_TYPE): OpenApiTypes.BINARY,
+            (200, _PDF_MIME_TYPE): OpenApiTypes.BINARY,
         },
     )
     def get(self, *_args, **_kwargs):