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

codex/views/opds/v2/feed.py

@@ -3,14 +3,15 @@
 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.browser.settings import OPDSSettingsSerializer
 from codex.serializers.opds.v2 import OPDS2FeedSerializer
-from codex.views.const import FALSY, MAX_OBJ_PER_PAGE
-from codex.views.opds.auth import OPDSAuthMixin
+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.opds.const import BLANK_TITLE
 from codex.views.opds.v2.const import (
     FACETS,
@@ -21,22 +22,23 @@ from codex.views.opds.v2.const import (
     NavigationGroup,
 )
 from codex.views.opds.v2.links import HrefData, LinkData
-from codex.views.opds.v2.publications import OPDS2PublicationView
+from codex.views.opds.v2.publications import PublicationMixin
+from codex.views.opds.v2.top_links import TopLinksMixin
 
 LOG = get_logger(__name__)
 
 
-class OPDS2FeedView(OPDSAuthMixin, OPDS2PublicationView):
+class OPDS2FeedView(PublicationMixin, TopLinksMixin):
     """OPDS 2.0 Feed."""
 
     DEFAULT_ROUTE = MappingProxyType(
-        {**OPDS2PublicationView.DEFAULT_ROUTE, "name": "opds:v2:feed"}
+        {**TopLinksMixin.DEFAULT_ROUTE, "name": "opds:v2:feed"}
     )
     TARGET = "opds2"
     throttle_scope = "opds"
 
+    authentication_classes = (SessionAuthentication, BasicAuthentication)
     serializer_class = OPDS2FeedSerializer
-    input_serializer_class = OPDSSettingsSerializer
 
     def _title(self, browser_title):
         """Create the feed title."""
@@ -53,11 +55,11 @@ class OPDS2FeedView(OPDSAuthMixin, OPDS2PublicationView):
             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):
@@ -176,34 +178,32 @@ class OPDS2FeedView(OPDSAuthMixin, OPDS2PublicationView):
 
     def get_object(self):
         """Get the browser page and serialize it for this subclass."""
-        group_qs, book_qs, num_pages, total_count, zero_pad, mtime = (
-            self._get_group_and_books()
-        )
-        title = self.get_browser_page_title()
+        browser_page = super().get_object()
+
         # convert browser_page into opds page
 
         # instance vars
-        self.is_aq_feed = self.model_group in ("c", "f")
-        self.num_pages = num_pages
+        self.is_aq_feed = browser_page.get("model_group") in ("c", "f")
+        self.num_pages = browser_page["num_pages"]
 
         # opds page
-        title = self._title(title)
-        number_of_items = total_count
+        title = self._title(browser_page.get("browser_title"))
+        number_of_items = browser_page["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 = group_qs
-        page_books = book_qs
+        page_groups = browser_page.get("groups")
+        page_books = browser_page.get("books")
+        zero_pad = browser_page["zero_pad"]
         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 +224,7 @@ class OPDS2FeedView(OPDSAuthMixin, OPDS2PublicationView):
             acquisition_groups = frozenset(self.valid_nav_groups[-2:])
             self.is_opds_2_acquisition = group in acquisition_groups
         self.is_opds_metadata = (
-            self.request.GET.get("opdsMetadata", "").lower() not in FALSY
+            self.request.query_params.get("opdsMetadata", "").lower() not in FALSY
         )
 
     def init_request(self):
@@ -234,7 +234,8 @@ class OPDS2FeedView(OPDSAuthMixin, OPDS2PublicationView):
         # self._detect_user_agent()
 
     @extend_schema(
-        parameters=[input_serializer_class],
+        request=BrowserView.input_serializer_class,
+        parameters=[BrowserView.input_serializer_class],
     )
     def get(self, *_args, **_kwargs):
         """Get the feed."""

codex/views/opds/v2/links.py

@@ -10,7 +10,6 @@ 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
@@ -40,7 +39,7 @@ class LinkData:
     num_items: int | None = None
 
 
-class OPDS2LinksView(BrowserView):
+class LinksMixin(BrowserView):
     """Links methods for OPDS 2.0 Feed."""
 
     num_pages = 0  # For pyright. Overwritten every run.
@@ -59,7 +58,7 @@ class OPDS2LinksView(BrowserView):
         elif hasattr(self, "request"):
             # if request link and not init static links
             href = update_href_query_params(
-                href, self.request.GET, new_query_params=data.query_params
+                href, self.request.query_params, new_query_params=data.query_params
             )
         return href
 
@@ -70,7 +69,6 @@ class OPDS2LinksView(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,47 +1,69 @@
 """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.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):
+from codex.views.opds.v2.links import HrefData, LinkData, LinksMixin
+
+
+class PublicationMixin(LinksMixin):
     """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
-        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")
+        cover_pk = obj.cover_pk
+
+        kwargs = {"pk": cover_pk}
+        href_data = HrefData(
+            kwargs, url_name="opds:bin:cover", absolute_query_params=True
+        )
         link_data = LinkData(
             Rel.THUMBNAIL,
             href_data,
@@ -52,9 +74,7 @@ class OPDS2PublicationView(OPDS2TopLinksView):
 
         cover_link = self.link(link_data)
 
-        link_data.rel = Rel.IMAGE
-
-        image_link = self.link(link_data)
+        image_link = self._get_big_image_link(obj, cover_pk)
 
         return [
             cover_link,
@@ -86,9 +106,9 @@ class OPDS2PublicationView(OPDS2TopLinksView):
 
     def _publication_extended_metadata(self, md, obj):
         """Publication m2m metadata only on the metadata alternate link."""
-        for key, roles in _MD_CONTRIBUTOR_MAP.items():
+        for key, roles in self._MD_CONTRIBUTOR_MAP.items():
             self._add_contributors(md, obj.ids, key, roles)
-        if contributors := get_contributors(obj.ids, _CONTRIBUTOR_ROLES, True):
+        if contributors := get_contributors(obj.ids, self._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, OPDS2LinksView
+from codex.views.opds.v2.links import HrefData, LinkData, LinksMixin
 
 
-class OPDS2TopLinksView(OPDS2LinksView):
+class TopLinksMixin(LinksMixin):
     """OPDS 2.0 top links section methods."""
 
     def _link_auth(self):

codex/views/reader/page.py

@@ -1,9 +1,9 @@
 """Views for reading comic books."""
 
-from io import BytesIO
+from typing import ClassVar
 
 from comicbox.box import Comicbox
-from django.http.response import StreamingHttpResponse
+from django.http import HttpResponse
 from drf_spectacular.types import OpenApiTypes
 from drf_spectacular.utils import OpenApiParameter, extend_schema
 from rest_framework.exceptions import NotFound
@@ -11,15 +11,12 @@ 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
-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
-_PAGE_CHUNK_SIZE = (1024**2) * 3  # 3 Mb
+PDF_MIME_TYPE = "application/pdf"
 
 
 class IgnoreClientContentNegotiation(BaseContentNegotiation):
@@ -46,6 +43,7 @@ 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."""
@@ -69,15 +67,11 @@ 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:
             page_image = cb.get_page_by_index(page, to_pixmap=to_pixmap)
-        if not page_image:
-            page_image = b""
-
         return page_image, content_type
 
     @extend_schema(
@@ -87,7 +81,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):
@@ -108,5 +102,4 @@ class ReaderPageView(BookmarkBaseView):
             LOG.warning(exc)
             raise NotFound(detail="comic page not found") from exc
         else:
-            page_chunker = chunker(BytesIO(page_image), _PAGE_CHUNK_SIZE)
-            return StreamingHttpResponse(page_chunker, content_type=content_type)
+            return HttpResponse(page_image, content_type=content_type)