codex 1.6.0a6__py3-none-any.whl → 1.6.0a8__py3-none-any.whl

codex/views/opds/v2/feed.py

@@ -3,15 +3,14 @@
 from types import MappingProxyType
 
 from drf_spectacular.utils import extend_schema
-from rest_framework.authentication import BasicAuthentication, SessionAuthentication
 from rest_framework.response import Response
 
 from codex.logger.logging import get_logger
 from codex.models import AdminFlag
 from codex.serializers.opds.v2 import OPDS2FeedSerializer
 from codex.views.browser.browser import BrowserView
-from codex.views.browser.const import MAX_OBJ_PER_PAGE
-from codex.views.const import FALSY
+from codex.views.const import FALSY, MAX_OBJ_PER_PAGE
+from codex.views.opds.auth import OPDSAuthMixin
 from codex.views.opds.const import BLANK_TITLE
 from codex.views.opds.v2.const import (
     FACETS,
@@ -22,22 +21,20 @@ from codex.views.opds.v2.const import (
     NavigationGroup,
 )
 from codex.views.opds.v2.links import HrefData, LinkData
-from codex.views.opds.v2.publications import PublicationMixin
-from codex.views.opds.v2.top_links import TopLinksMixin
+from codex.views.opds.v2.publications import OPDS2PublicationView
 
 LOG = get_logger(__name__)
 
 
-class OPDS2FeedView(PublicationMixin, TopLinksMixin):
+class OPDS2FeedView(OPDSAuthMixin, OPDS2PublicationView):
     """OPDS 2.0 Feed."""
 
     DEFAULT_ROUTE = MappingProxyType(
-        {**TopLinksMixin.DEFAULT_ROUTE, "name": "opds:v2:feed"}
+        {**OPDS2PublicationView.DEFAULT_ROUTE, "name": "opds:v2:feed"}
     )
     TARGET = "opds2"
     throttle_scope = "opds"
 
-    authentication_classes = (SessionAuthentication, BasicAuthentication)
     serializer_class = OPDS2FeedSerializer
 
     def _title(self, browser_title):
@@ -55,11 +52,11 @@ class OPDS2FeedView(PublicationMixin, TopLinksMixin):
             result = BLANK_TITLE
         return result
 
-    def _detect_user_agent(self):
-        """Hacks for individual clients."""
-        user_agent = self.request.headers.get("User-Agent")
-        if not user_agent:
-            return
+    # def _detect_user_agent(self):
+    #    """Hacks for individual clients."""
+    #    user_agent = self.request.headers.get("User-Agent")
+    #    if not user_agent:
+    #        return
 
     @staticmethod
     def _is_allowed(link_spec):
@@ -178,32 +175,34 @@ class OPDS2FeedView(PublicationMixin, TopLinksMixin):
 
     def get_object(self):
         """Get the browser page and serialize it for this subclass."""
-        browser_page = super().get_object()
-
+        group_qs, book_qs, num_pages, total_count, zero_pad, mtime = (
+            self._get_group_and_books()
+        )
+        title = self.get_browser_page_title()
         # convert browser_page into opds page
 
         # instance vars
-        self.is_aq_feed = browser_page.get("model_group") in ("c", "f")
-        self.num_pages = browser_page["num_pages"]
+        self.is_aq_feed = self.model_group in ("c", "f")
+        self.num_pages = num_pages
 
         # opds page
-        title = self._title(browser_page.get("browser_title"))
-        number_of_items = browser_page["total_count"]
+        title = self._title(title)
+        number_of_items = total_count
         current_page = self.kwargs.get("page")
         up_route = self.get_last_route()
         links = self.get_links(up_route)
         facets = self._get_facets()
 
         # opds groups
-        page_groups = browser_page.get("groups")
-        page_books = browser_page.get("books")
-        zero_pad = browser_page["zero_pad"]
+        page_groups = group_qs
+        page_books = book_qs
         groups = self._get_groups(page_groups, page_books, title, zero_pad)
 
         return MappingProxyType(
             {
                 "metadata": {
                     "title": title,
+                    "modified": mtime,
                     "number_of_items": number_of_items,
                     "items_per_page": MAX_OBJ_PER_PAGE,
                     "current_page": current_page,
@@ -224,7 +223,7 @@ class OPDS2FeedView(PublicationMixin, TopLinksMixin):
             acquisition_groups = frozenset(self.valid_nav_groups[-2:])
             self.is_opds_2_acquisition = group in acquisition_groups
         self.is_opds_metadata = (
-            self.request.query_params.get("opdsMetadata", "").lower() not in FALSY
+            self.request.GET.get("opdsMetadata", "").lower() not in FALSY
         )
 
     def init_request(self):

codex/views/opds/v2/links.py

@@ -10,6 +10,7 @@ from codex.views.browser.browser import BrowserView
 from codex.views.const import FALSY
 from codex.views.opds.const import MimeType, Rel
 from codex.views.opds.util import update_href_query_params
+from codex.views.util import pop_name
 
 
 @dataclass
@@ -39,7 +40,7 @@ class LinkData:
     num_items: int | None = None
 
 
-class LinksMixin(BrowserView):
+class OPDS2LinksView(BrowserView):
     """Links methods for OPDS 2.0 Feed."""
 
     num_pages = 0  # For pyright. Overwritten every run.
@@ -58,7 +59,7 @@ class LinksMixin(BrowserView):
         elif hasattr(self, "request"):
             # if request link and not init static links
             href = update_href_query_params(
-                href, self.request.query_params, new_query_params=data.query_params
+                href, self.request.GET, new_query_params=data.query_params
             )
         return href
 
@@ -69,6 +70,7 @@ class LinksMixin(BrowserView):
         if "page" in kwargs and not self._href_page_validate(kwargs, data):
             return None
 
+        kwargs = pop_name(kwargs)
         href = reverse(url_name, kwargs=kwargs)
         return self._href_update_query_params(href, data)
 

codex/views/opds/v2/publications.py

@@ -1,69 +1,47 @@
 """Publication Methods for OPDS v2.0 feed."""
 
+from datetime import datetime
+from math import floor
 from types import MappingProxyType
 from urllib.parse import quote_plus
 
-from django.contrib.staticfiles.storage import staticfiles_storage
-
 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):
-        if cover_pk:
-            mime_type = MimeType.JPEG
-            url_name = "opds:bin:page"
-            href = None
-            min_page = 0
-            max_page = obj.max_page or 1
-        else:
-            mime_type = MimeType.WEBP
-            href = staticfiles_storage.url("img/missing_cover.webp")
-            url_name = None
-            min_page = None
-            max_page = None
-
-        kwargs = {"pk": obj.pk, "page": 0}
-        href_data = HrefData(
-            kwargs,
-            absolute_query_params=True,
-            url_name=url_name,
-            min_page=min_page,
-            max_page=max_page,
-        )
-        link_data = LinkData(Rel.IMAGE, href_data, href=href, mime_type=mime_type)
-        return self.link(link_data)
-
     def _images(self, obj):
         # Images
-        cover_pk = obj.cover_pk
-
-        kwargs = {"pk": cover_pk}
-        href_data = HrefData(
-            kwargs, url_name="opds:bin:cover", absolute_query_params=True
-        )
+        kwargs = {"group": obj.group, "pks": obj.ids}
+        ts = floor(datetime.timestamp(obj.updated_at))
+        query_params = {
+            "customCovers": True,
+            "dynamicCovers": False,
+            "ts": ts,
+        }
+        href_data = HrefData(kwargs, query_params, True, "opds:bin:cover")
         link_data = LinkData(
             Rel.THUMBNAIL,
             href_data,
@@ -74,7 +52,9 @@ class PublicationMixin(LinksMixin):
 
         cover_link = self.link(link_data)
 
-        image_link = self._get_big_image_link(obj, cover_pk)
+        link_data.rel = Rel.IMAGE
+
+        image_link = self.link(link_data)
 
         return [
             cover_link,
@@ -106,9 +86,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,36 @@
+"""Public non-authenticated views."""
+
+from rest_framework.generics import GenericAPIView
+from rest_framework.mixins import RetrieveModelMixin
+
+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."""
+
+    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",)
+        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):