codex 1.7.0__py3-none-any.whl → 1.7.0a0__py3-none-any.whl

codex/views/opds/v1/links.py

@@ -112,6 +112,7 @@ class OPDS1LinksView(OPDS1FacetsView):
             "name": "opds:v1:feed",
         }
     )
+    is_aq_feed = False
 
     def is_top_link_displayed(self, top_link):
         """Determine if this top link should be displayed."""
@@ -159,9 +160,7 @@ class OPDS1LinksView(OPDS1FacetsView):
         """Create all the links."""
         links = []
         try:
-            mime_type = (
-                MimeType.ACQUISITION if self.is_opds_acquisition else MimeType.NAV
-            )
+            mime_type = MimeType.ACQUISITION if self.is_aq_feed else MimeType.NAV
             links += [
                 OPDS1Link("self", self.request.get_full_path(), mime_type),
                 OPDS1Link(
@@ -194,9 +193,9 @@ class OPDS1LinksView(OPDS1FacetsView):
             name=name,
             summary=top_link.desc,
         )
-        zero_pad: int = self.obj["zero_pad"]  # type: ignore
+        zero_pad = self.obj["zero_pad"]
         data = OPDS1EntryData(
-            self.opds_acquisition_groups, zero_pad, False, self.mime_type_map
+            self.acquisition_groups, zero_pad, False, self.mime_type_map
         )
         return OPDS1Entry(entry_obj, top_link.query_params, data)
 

codex/views/opds/v2/feed.py

@@ -9,6 +9,7 @@ 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.settings.settings import FALSY
 from codex.views.const import MAX_OBJ_PER_PAGE
 from codex.views.opds.auth import OPDSAuthMixin
 from codex.views.opds.const import BLANK_TITLE
@@ -176,10 +177,16 @@ class OPDS2FeedView(OPDSAuthMixin, OPDS2PublicationView):
 
     def get_object(self):
         """Get the browser page and serialize it for this subclass."""
-        group_qs, book_qs, _, total_count, zero_pad, mtime = self.group_and_books
+        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 = self.model_group in ("c", "f")
+        self.num_pages = num_pages
+
         # opds page
         title = self._title(title)
         number_of_items = total_count
@@ -208,11 +215,31 @@ class OPDS2FeedView(OPDSAuthMixin, OPDS2PublicationView):
             }
         )
 
+    def set_opds_request_type(self):
+        """Set opds request type variables."""
+        group = self.kwargs.get("group")
+        if group in {"f", "a"}:
+            pks = self.kwargs["pks"]
+            self.is_opds_2_acquisition = bool(pks)
+        else:
+            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
+        )
+
+    def init_request(self):
+        """Initialize request."""
+        super().init_request()
+        self.set_opds_request_type()
+        # self._detect_user_agent()
+
     @extend_schema(
         parameters=[input_serializer_class],
     )
     def get(self, *_args, **_kwargs):
         """Get the feed."""
+        self.init_request()
         obj = self.get_object()
         serializer = self.get_serializer(obj)
         return Response(serializer.data)

codex/views/opds/v2/links.py

@@ -2,10 +2,8 @@
 
 from copy import deepcopy
 from dataclasses import dataclass
-from datetime import datetime
 from urllib.parse import parse_qsl, urlparse
 
-from django.db.models import QuerySet
 from django.urls import reverse
 
 from codex.settings.settings import FALSY
@@ -45,30 +43,7 @@ class LinkData:
 class OPDS2LinksView(BrowserView):
     """Links methods for OPDS 2.0 Feed."""
 
-    def __init__(self, *args, **kwargs):
-        """Initialize properties."""
-        super().__init__(*args, **kwargs)
-        self._num_pages: int | None = None
-        self._group_and_books: (
-            tuple[QuerySet, QuerySet, int, int, int | None, datetime | None] | None
-        ) = None
-
-    @property
-    def group_and_books(
-        self,
-    ) -> tuple[QuerySet, QuerySet, int, int, int | None, datetime | None]:
-        """Memoize Group And Books for num_pages."""
-        # group_qs, book_qs, num_pages, total_count, zero_pad, mtime
-        if self._group_and_books is None:
-            self._group_and_books = self._get_group_and_books()
-        return self._group_and_books
-
-    @property
-    def num_pages(self) -> int:
-        """Memoize num_pages."""
-        if self._num_pages is None:
-            self._num_pages = self.group_and_books[2]
-        return self._num_pages
+    num_pages = 0  # For pyright. Overwritten every run.
 
     def _href_page_validate(self, kwargs, data):
         """Validate the page bounds."""

codex/views/opds/v2/publications.py

@@ -5,9 +5,8 @@ from math import floor
 from types import MappingProxyType
 from urllib.parse import quote_plus
 
-from codex.librarian.covers.create import THUMBNAIL_HEIGHT, THUMBNAIL_WIDTH
+from codex.librarian.covers.create import CoverCreateMixin
 from codex.models import Comic
-from codex.settings.settings import FALSY
 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
@@ -31,6 +30,8 @@ _CONTRIBUTOR_ROLES = frozenset({x for s in _MD_CONTRIBUTOR_MAP.values() for x in
 class OPDS2PublicationView(OPDS2TopLinksView):
     """Publication Methods for OPDS 2.0 feed."""
 
+    is_opds_metadata = False
+
     def _images(self, obj):
         # Images
         kwargs = {"group": obj.group, "pks": obj.ids}
@@ -45,8 +46,8 @@ class OPDS2PublicationView(OPDS2TopLinksView):
             Rel.THUMBNAIL,
             href_data,
             mime_type=MimeType.WEBP,
-            height=THUMBNAIL_HEIGHT,
-            width=THUMBNAIL_WIDTH,
+            height=CoverCreateMixin.THUMBNAIL_HEIGHT,
+            width=CoverCreateMixin.THUMBNAIL_WIDTH,
         )
 
         cover_link = self.link(link_data)
@@ -114,7 +115,7 @@ class OPDS2PublicationView(OPDS2TopLinksView):
             "title": title,
         }
         self._publication_optional_metadata(md, obj)
-        if self.request.GET.get("opdsMetadata", "").lower() not in FALSY:
+        if self.is_opds_metadata:
             self._publication_extended_metadata(md, obj)
         return md
 

codex/views/opds/v2/top_links.py

@@ -26,7 +26,10 @@ class OPDS2TopLinksView(OPDS2LinksView):
         link_data = LinkData(Rel.SEARCH, href_data, template="{?query}")
         return self.link(link_data)
 
-    def _get_static_links(self):
+    def __init__(self, *args, **kwargs):
+        """Initialize static links."""
+        super().__init__(*args, **kwargs)
+
         start_href_data = HrefData(
             {}, url_name="opds:v2:start", absolute_query_params=True
         )
@@ -43,7 +46,7 @@ class OPDS2TopLinksView(OPDS2LinksView):
             mime_type=MimeType.HTML,
         )
 
-        return (
+        self._static_links = (
             self._link_auth(),
             self._link_search(),
             self.link(start_link_data),
@@ -70,7 +73,7 @@ class OPDS2TopLinksView(OPDS2LinksView):
         up_link_data = LinkData(Rel.UP, up_href_data)
         links_data = [
             self.link_self(),
-            *self._get_static_links(),
+            *self._static_links,
             self._link_page("first", 1),
             self._link_page("previous", page - 1),
             self._link_page("next", page + 1),

codex/views/public.py

@@ -3,10 +3,10 @@
 from rest_framework.generics import GenericAPIView
 from rest_framework.mixins import RetrieveModelMixin
 
-from codex.choices import ADMIN_FLAG_CHOICES
 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(
@@ -27,7 +27,7 @@ class AdminFlagsView(GenericAPIView, RetrieveModelMixin):
         """Get admin flags."""
         flags = {}
         for obj in self.get_queryset():  # type: ignore
-            name = ADMIN_FLAG_CHOICES[obj.key].lower().replace(" ", "_")
+            name = CHOICES["admin"]["adminFlags"][obj.key].lower().replace(" ", "_")
             flags[name] = obj.on
         return flags
 

codex/views/reader/arcs.py

@@ -1,5 +1,7 @@
 """Reader get Arcs methods."""
 
+from types import MappingProxyType
+
 from codex.models import AdminFlag
 from codex.util import max_none
 from codex.views.const import (
@@ -15,6 +17,7 @@ class ReaderArcsView(ReaderBooksView):
     def __init__(self, *args, **kwargs):
         """Initialize instance vars."""
         super().__init__(*args, **kwargs)
+        self.params: MappingProxyType = MappingProxyType({})
 
     def _get_group_arc(self, book, attr, browser_arc_group, arcs, max_mtime):
         """Append the volume arc."""

codex/views/reader/books.py

@@ -3,10 +3,9 @@
 from typing import TYPE_CHECKING
 
 from django.db.models import F
-from django.db.models.query import Q
 
 from codex.models import Bookmark, Comic
-from codex.views.bookmark import BookmarkBaseView
+from codex.views.bookmark import BookmarkFilterBaseView
 from codex.views.browser.filters.field import ComicFieldFilterView
 from codex.views.const import (
     FOLDER_GROUP,
@@ -15,8 +14,8 @@ from codex.views.const import (
     NONE_INTEGERFIELD,
     STORY_ARC_GROUP,
 )
-from codex.views.mixins import BookmarkSearchMixin, SharedAnnotationsMixin
-from codex.views.reader.params import ReaderParamsView
+from codex.views.mixins import SharedAnnotationsMixin
+from codex.views.reader.init import ReaderInitView
 
 if TYPE_CHECKING:
     from collections.abc import Mapping
@@ -34,9 +33,7 @@ _COMIC_FIELDS = (
 )
 
 
-class ReaderBooksView(
-    BookmarkBaseView, ReaderParamsView, SharedAnnotationsMixin, BookmarkSearchMixin
-):
+class ReaderBooksView(BookmarkFilterBaseView, ReaderInitView, SharedAnnotationsMixin):
     """Get Books methods."""
 
     def _get_reader_arc_pks(
@@ -65,36 +62,6 @@ class ReaderBooksView(
 
         return arc_pks
 
-    def _get_comics_filter(self, rel, arc, arc_pks):
-        """Build the filter."""
-        group_acl_filter = self.get_group_acl_filter(Comic, self.request.user)
-        nav_filter = {f"{rel}__in": arc_pks}
-        query_filter = group_acl_filter & Q(**nav_filter)
-        if browser_filters := arc.get("filters"):
-            # no search at this time.
-            query_filter &= ComicFieldFilterView.get_all_comic_field_filters(
-                "", browser_filters
-            )
-        return query_filter
-
-    def _get_comics_annotation_and_ordering(self, model, arc_group, arc_pks, ordering):
-        """Get ordering for query."""
-        sort_name_annotations = {}
-        if arc_group in ("v", "s"):
-            show = self.params["show"]
-            model_group = "i" if arc_group == "s" else "s"
-            sort_name_annotations = self.get_sort_name_annotations(
-                model, model_group, arc_pks, show
-            )
-            if sort_name_annotations and model is Comic:
-                ordering += (*sort_name_annotations.keys(),)
-            ordering += (
-                "issue_number",
-                "issue_suffix",
-                "sort_name",
-            )
-        return sort_name_annotations, tuple(ordering)
-
     def _get_comics_list(self):
         """Get the reader naviation group filter."""
         arc: Mapping = self.params.get("arc", {})  # type: ignore
@@ -107,45 +74,63 @@ class ReaderBooksView(
         fields = _COMIC_FIELDS
         arc_pk_rel = rel + "__pk"
         arc_index = NONE_INTEGERFIELD
+        ordering = ()
         arc_pk_select_related = (rel,)
         select_related = ()
         prefetch_related = ()
-        ordering = ()
 
         if arc_group == STORY_ARC_GROUP:
-            arc_index = F("story_arc_numbers__number")
-            arc_pk_select_related = ()
             prefetch_related = (*prefetch_related, rel)
+            arc_index = F("story_arc_numbers__number")
             ordering = ("arc_index", "date", "pk")
+            arc_pk_select_related = ()
         elif arc_group == FOLDER_GROUP:
-            fields = (*_COMIC_FIELDS, rel)
             select_related = (rel,)
+            fields = (*_COMIC_FIELDS, rel)
             ordering = ("path", "pk")
 
         arc_pks = self._get_reader_arc_pks(
             arc, arc_pk_select_related, prefetch_related, arc_pk_rel, arc_group
         )
+        group_acl_filter = self.get_group_acl_filter(Comic)
+        nav_filter = {f"{rel}__in": arc_pks}
 
-        query_filter = self._get_comics_filter(rel, arc, arc_pks)
-        qs = Comic.objects.filter(query_filter)
+        qs = Comic.objects.filter(group_acl_filter).filter(**nav_filter)
+        if browser_filters := arc.get("filters"):
+            # no search at this time.
+            field_filters = ComicFieldFilterView.get_all_comic_field_filters(
+                "", browser_filters
+            )
+            qs = qs.filter(field_filters)
 
         if select_related:
             qs = qs.select_related(*select_related)
         if prefetch_related:
             qs = qs.prefetch_related(*prefetch_related)
-        qs = qs.only(*fields)
-        qs = self.annotate_group_names(qs)
-        qs = qs.annotate(
-            issue_count=F("volume__issue_count"),
-            arc_pk=F(arc_pk_rel),
-            arc_index=arc_index,
-            mtime=F("updated_at"),
-        )
-        sort_names_alias, ordering = self._get_comics_annotation_and_ordering(
-            qs.model, arc_group, arc_pks, ordering
+        qs = (
+            qs.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"))
         )
-        if sort_names_alias:
-            qs = qs.alias(**sort_names_alias)
+        qs = self.annotate_group_names(qs, Comic)
+        if arc_group in ("v", "s"):
+            show = self.params["show"]
+            model_group = "i" if arc_group == "s" else "s"
+            qs, comic_sort_names = self.alias_sort_names(
+                qs, Comic, pks=arc_pks, model_group=model_group, show=show
+            )
+            ordering = (
+                *comic_sort_names,
+                "issue_number",
+                "issue_suffix",
+                "sort_name",
+            )
         qs = qs.order_by(*ordering)
         return qs, arc_group
 
@@ -168,8 +153,7 @@ class ReaderBooksView(
         Yields 1 to 3 books
         """
         comics, arc_group = self._get_comics_list()
-        auth_filter = self.get_bookmark_auth_filter()
-        bookmark_filter = self.get_bookmark_search_kwargs(auth_filter)
+        bookmark_filter = self.get_bookmark_search_kwargs()
         books = {}
         prev_book = None
         pk = self.kwargs.get("pk")

codex/views/reader/{params.py → init.py}

@@ -1,9 +1,8 @@
 """Views for reading comic books."""
 
+from copy import deepcopy
 from types import MappingProxyType
-from typing import Any
 
-from codex.choices import mapping_to_dict
 from codex.logger.logging import get_logger
 from codex.models import Comic
 from codex.serializers.reader import (
@@ -26,7 +25,7 @@ _DEFAULT_PARAMS = {
 }
 
 
-class ReaderParamsView(SessionView):
+class ReaderInitView(SessionView):
     """Reader initialization."""
 
     input_serializer_class = ReaderViewInputSerializer
@@ -34,10 +33,9 @@ class ReaderParamsView(SessionView):
     def __init__(self, *args, **kwargs):
         """Initialize instance vars."""
         super().__init__(*args, **kwargs)
-        self._group_pks: dict[str, tuple[int, ...]] = {}
-        self._params: MappingProxyType[str, Any] | None = None
+        self.group_pks: dict[str, tuple[int, ...]] = {}
 
-    def _get_group_pks_from_breadcrumbs(self, groups, breadcrumbs):
+    def _set_group_pks_from_breadcrumbs(self, groups, breadcrumbs):
         """Set Multi-Group pks from breadcrumbs to the cache."""
         index = len(breadcrumbs) - 1
         min_index = max(index - 1, 0) if FOLDER_GROUP in groups else 0
@@ -46,29 +44,29 @@ class ReaderParamsView(SessionView):
             crumb_group = crumb.get("group")
             if crumb_group in groups:
                 pks = crumb.get("pks", ())
-                self._group_pks[crumb_group] = pks
+                self.group_pks[crumb_group] = pks
                 break
             index -= 1
         else:
             crumb_group = ""
             pks = ()
             for group in groups:
-                self._group_pks[group] = pks
+                self.group_pks[group] = pks
         return crumb_group, pks
 
-    def get_group_pks_from_breadcrumbs(self, groups, params=None):
+    def get_group_pks_from_breadcrumbs(self, groups):
         """Get Multi-Group pks from the breadcrumbs."""
         # Return cached values
         for group in groups:
-            pks = self._group_pks.get(group)
-            if pks is not None:
+            if pks := self.group_pks.get(group):
                 return group, pks
 
-        if params is None:
-            params = self.params
-        breadcrumbs: tuple = params.get("breadcrumbs", ())
+        # Validate input
+        breadcrumbs: tuple = self.params.get("breadcrumbs")  # type: ignore
+        if not breadcrumbs:
+            return "", ()
 
-        return self._get_group_pks_from_breadcrumbs(groups, breadcrumbs)
+        return self._set_group_pks_from_breadcrumbs(groups, breadcrumbs)
 
     def _ensure_arc_contains_comic(self, params):
         """Arc sanity check."""
@@ -101,7 +99,7 @@ class ReaderParamsView(SessionView):
             else:
                 search_groups = "vsip"
 
-            group, pks = self.get_group_pks_from_breadcrumbs(search_groups, params)
+            group, pks = self.get_group_pks_from_breadcrumbs(search_groups)
             if not group:
                 group = "s"
 
@@ -111,24 +109,20 @@ class ReaderParamsView(SessionView):
 
         params["arc"] = arc
 
-    @property
-    def params(self):
-        """Memoized params property."""
-        if self._params is None:
-            try:
-                data = self.request.GET
-                data = reparse_json_query_params(self.request.GET, _JSON_KEYS)
-                serializer = self.input_serializer_class(data=data)
-                serializer.is_valid(raise_exception=True)
-
-                params: dict = mapping_to_dict(_DEFAULT_PARAMS)  # type: ignore
-                if serializer.validated_data:
-                    params.update(serializer.validated_data)  # type: ignore
-                self._ensure_arc_contains_comic(params)
-                self._ensure_arc(params)
-
-                self._params = MappingProxyType(params)
-            except Exception:
-                LOG.exception("validate")
-                raise
-        return self._params
+    def _parse_params(self):
+        try:
+            data = self.request.GET
+            data = reparse_json_query_params(self.request.GET, _JSON_KEYS)
+            serializer = self.input_serializer_class(data=data)
+            serializer.is_valid(raise_exception=True)
+
+            params = deepcopy(_DEFAULT_PARAMS)
+            if serializer.validated_data:
+                params.update(serializer.validated_data)  # type: ignore
+            self._ensure_arc_contains_comic(params)
+            self._ensure_arc(params)
+
+            self.params = MappingProxyType(params)
+        except Exception:
+            LOG.exception("validate")
+            raise

codex/views/reader/page.py

@@ -9,8 +9,6 @@ from drf_spectacular.utils import OpenApiParameter, extend_schema
 from rest_framework.exceptions import NotFound
 from rest_framework.negotiation import BaseContentNegotiation
 
-from codex.librarian.bookmark.tasks import BookmarkUpdateTask
-from codex.librarian.mp_queue import LIBRARIAN_QUEUE
 from codex.logger.logging import get_logger
 from codex.models.comic import Comic, FileType
 from codex.settings.settings import FALSY
@@ -57,19 +55,15 @@ class ReaderPageView(BookmarkBaseView):
         )
         if not do_bookmark:
             return
-
-        auth_filter = self.get_bookmark_auth_filter()
-        pk = self.kwargs.get("pk")
-        comic_filter = {"pk": pk}
         page = self.kwargs.get("page")
         updates = {"page": page}
-
-        task = BookmarkUpdateTask(auth_filter, comic_filter, updates)
-        LIBRARIAN_QUEUE.put(task)
+        pk = self.kwargs.get("pk")
+        comic_filter = {"pk": pk}
+        self.update_bookmarks(updates, comic_filter)
 
     def _get_page_image(self):
         """Get the image data and content type."""
-        group_acl_filter = self.get_group_acl_filter(Comic, self.request.user)
+        group_acl_filter = self.get_group_acl_filter(Comic)
         pk = self.kwargs.get("pk")
         comic = Comic.objects.filter(group_acl_filter).only("path").get(pk=pk)
         page = self.kwargs.get("page")

codex/views/reader/reader.py

@@ -58,7 +58,7 @@ class ReaderView(ReaderArcsView):
             task = LazyImportComicsTask(frozenset(import_pks))
             LIBRARIAN_QUEUE.put(task)
 
-    def get_object(self):  # type: ignore
+    def get_object(self):
         """Get the previous and next comics in a group or story arc."""
         # Books
         books = self.get_book_collection()
@@ -101,6 +101,7 @@ class ReaderView(ReaderArcsView):
     @extend_schema(parameters=[ReaderViewInputSerializer])
     def get(self, *args, **kwargs):
         """Get the book info."""
+        self._parse_params()
         obj = self.get_object()
         serializer = self.get_serializer(obj)
         return Response(serializer.data)