codex 1.7.2__py3-none-any.whl → 1.7.3a0__py3-none-any.whl

codex/views/browser/order_by.py

@@ -19,7 +19,10 @@ class BrowserOrderByView(BrowserGroupMtimeView):
         if not self._order_key:
             order_key: str = self.params["order_by"]
             if (order_key == "search_score" and not self.fts_mode) or (
-                order_key == "filename" and not self.admin_flags["folder_view"]
+                order_key == "filename"
+                and not self.admin_flags["folder_view"]
+                or order_key == "child_count"
+                and self.TARGET == "cover"
             ):
                 order_key = "sort_name"
             self._order_key = order_key
@@ -29,6 +32,8 @@ class BrowserOrderByView(BrowserGroupMtimeView):
         """Order by for comics (and covers)."""
         if not order_key:
             order_key = self.order_key
+        if order_key == "child_count":
+            order_key = "sort_name"
         if order_key == "sort_name":
             if not comic_sort_names:
                 comic_sort_names = self._comic_sort_names

codex/views/frontend.py

@@ -6,6 +6,7 @@ from rest_framework.permissions import AllowAny
 from rest_framework.renderers import TemplateHTMLRenderer
 from rest_framework.response import Response
 
+from codex.models.admin import AdminFlag
 from codex.serializers.route import RouteSerializer
 from codex.views.session import SessionView
 
@@ -19,10 +20,24 @@ class IndexView(SessionView):
     renderer_classes: ClassVar[list] = [TemplateHTMLRenderer]  # type: ignore
     template_name = "index.html"
 
-    def get(self, *_args, **_kwargs):
-        """Get the app index page."""
+    def _get_last_route(self):
+        """Get the last route from the session."""
         last_route = self.get_last_route(name=False)
         serializer = RouteSerializer(last_route)
-        last_route = serializer.data
-        extra_context = {"last_route": last_route}
+        return serializer.data
+
+    def _get_title(self):
+        """Get the title from the banner text."""
+        bt_flag = AdminFlag.objects.get(key="BT")
+        title = "Codex"
+        if bt_flag.value:
+            title = bt_flag.value + " - " + title
+        return title
+
+    def get(self, *_args, **_kwargs):
+        """Get the app index page."""
+        extra_context = {
+            "last_route": self._get_last_route(),
+            "title": self._get_title(),
+        }
         return Response(extra_context)

codex/views/mixins.py

@@ -2,40 +2,45 @@
 
 from django.db.models.expressions import F
 
+from codex.logger.logging import get_logger
 from codex.models.comic import Comic, Imprint, Volume
 from codex.views.const import GROUP_NAME_MAP
 
+LOG = get_logger(__name__)
 _SHOW_GROUPS = tuple(GROUP_NAME_MAP.keys())
+_GROUP_NAME_TARGETS = frozenset({"browser", "opds1", "opds2", "reader"})
+_VARIABLE_SHOW = "pi"
 
 
 class SharedAnnotationsMixin:
     """Cross view annotation methods."""
 
     @staticmethod
-    def _get_order_groups(model_group, pks):
+    def _get_order_groups(parent_group, pks, show):
         """Annotate sort_name."""
-        if not pks or len(pks) > 1:
-            order_groups = _SHOW_GROUPS
-        elif model_group == "c":
+        if parent_group == "c":
             order_groups = ()
         else:
             for index, nav_group in enumerate(_SHOW_GROUPS):
-                if nav_group == model_group:
-                    order_groups = _SHOW_GROUPS[index + 1 :]
+                if nav_group in _VARIABLE_SHOW and not show.get(nav_group):
+                    continue
+                if nav_group == parent_group:
+                    watermark = index
+                    if pks and len(pks) == 1:
+                        watermark += 1
+                    order_groups = _SHOW_GROUPS[watermark:]
                     break
             else:
                 order_groups = _SHOW_GROUPS
         return order_groups
 
     @classmethod
-    def get_sort_name_annotations(cls, model, model_group, pks, show):
+    def get_sort_name_annotations(cls, model, parent_group, pks, show):
         """Annotate sort names for browser subclasses and reader."""
         sort_name_annotations = {}
         if model is Comic:
-            order_groups = cls._get_order_groups(model_group, pks)
+            order_groups = cls._get_order_groups(parent_group, pks, show)
             for order_group in order_groups:
-                if show and not show.get(order_group):
-                    continue
                 group_name = GROUP_NAME_MAP[order_group]
                 ann_name = f"{group_name}_sort_name"
                 name_field = "name" if group_name == "volume" else "sort_name"
@@ -50,7 +55,7 @@ class SharedAnnotationsMixin:
         """Annotate name fields by hoisting them up."""
         # Optimized to only lookup what is used on the frontend
         target = cls.TARGET  # type: ignore
-        if target not in frozenset({"browser", "opds1", "opds2", "reader"}):
+        if target not in _GROUP_NAME_TARGETS:
             return qs
         group_names = {}
         if qs.model is Comic:
@@ -69,20 +74,3 @@ class SharedAnnotationsMixin:
         elif qs.model is Imprint:
             group_names["publisher_name"] = F("publisher__name")
         return qs.annotate(**group_names)
-
-
-class BookmarkSearchMixin:
-    """Create Bookmark Search kwargs."""
-
-    @staticmethod
-    def get_bookmark_search_kwargs(auth_filter, comic_filter=None):
-        """Get the search kwargs for a user's authentication state."""
-        # search kwargs are relative to the bookmark object.
-        search_kwargs = {}
-        search_kwargs.update(auth_filter)
-
-        if comic_filter:
-            for key, value in comic_filter.items():
-                search_kwargs[f"comic__{key}"] = value
-
-        return search_kwargs

codex/views/opds/const.py

@@ -28,6 +28,7 @@ class Rel:
     SORT_NEW = "http://opds-spec.org/sort/new"
     POPULAR = "http://opds-spec.org/sort/popular"
     FEATURED = "http://opds-spec.org/featured"
+    PROGRESSION = "http://www.cantook.com/api/progression"
     SELF = "self"
     START = "start"
     UP = "up"
@@ -55,6 +56,7 @@ class MimeType:
     STREAM = "image/jpeg"
     OPDS_JSON = "application/opds+json"
     OPDS_PUB = "application/opds-publication+json"
+    PROGRESSION = "application/vnd.readium.progression+json"
     BOOK = "http://schema.org/Book"
     # COMIC = "https://schema.org/ComicStory"
     JPEG = "image/jpeg"

codex/views/opds/util.py

@@ -59,8 +59,8 @@ def get_m2m_objects(pks) -> dict:
     for model in OPDS_M2M_MODELS:
         table = model.__name__.lower()
         rel = GroupACLMixin.get_rel_prefix(model)
-        comic_filter = {rel + "__in": pks}
-        qs = model.objects.filter(**comic_filter).order_by("name").only("name")
+        comic_filter = {rel + "in": pks}
+        qs = model.objects.filter(**comic_filter).only("name").order_by("name")
         cats[table] = qs
 
     return cats

codex/views/opds/v1/entry/links.py

@@ -46,8 +46,7 @@ class OPDS1EntryLinksMixin:
             }
             href = reverse("opds:bin:cover", kwargs=kwargs)
             href = update_href_query_params(href, query_params)
-            mime_type = "image/webp"
-            return OPDS1Link(rel, href, mime_type)
+            return OPDS1Link(rel, href, MimeType.WEBP)
         except Exception:
             LOG.exception("create thumb")
 

codex/views/opds/v2/feed.py

@@ -8,7 +8,7 @@ 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.serializers.opds.v2.feed import OPDS2FeedSerializer
 from codex.views.const import MAX_OBJ_PER_PAGE
 from codex.views.opds.auth import OPDSAuthMixin
 from codex.views.opds.const import BLANK_TITLE
@@ -20,7 +20,8 @@ from codex.views.opds.v2.const import (
     TOP_NAV_GROUP_SECTION_DATA,
     NavigationGroup,
 )
-from codex.views.opds.v2.links import HrefData, LinkData
+from codex.views.opds.v2.href import HrefData
+from codex.views.opds.v2.links import LinkData
 from codex.views.opds.v2.publications import OPDS2PublicationView
 
 LOG = get_logger(__name__)

codex/views/opds/v2/href.py

@@ -0,0 +1,60 @@
+"""Href methods for OPDS v2.0 Feed."""
+
+from abc import ABC
+from dataclasses import dataclass
+
+from django.urls import reverse
+from rest_framework.views import APIView
+
+from codex.views.opds.util import update_href_query_params
+from codex.views.util import pop_name
+
+
+@dataclass
+class HrefData:
+    """Data for creating hrefs."""
+
+    kwargs: dict | None = None
+    query_params: dict | None = None
+    absolute_query_params: bool = False
+    url_name: str | None = None
+    min_page: int | None = None
+    max_page: int | None = None
+
+
+class OPDS2HrefMixin(APIView, ABC):
+    """Create links method."""
+
+    @property
+    def num_pages(self) -> int:
+        """Dummy."""
+        return 1
+
+    def _href_page_validate(self, kwargs, data):
+        """Validate the page bounds."""
+        min_page = 1 if data.min_page is None else data.min_page
+        max_page = self.num_pages if data.max_page is None else data.max_page
+        page = int(kwargs["page"])
+        return page >= min_page and page <= max_page
+
+    def _href_update_query_params(self, href, data):
+        """Update the query params."""
+        if data.absolute_query_params and data.query_params:
+            href = update_href_query_params(href, data.query_params)
+        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
+            )
+        return href
+
+    def href(self, data):
+        """Create an href."""
+        url_name = data.url_name if data.url_name else "opds:v2:feed"
+        kwargs = data.kwargs if data.kwargs is not None else self.kwargs
+        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/links.py

@@ -1,30 +1,17 @@
 """Links methods for OPDS v2.0 Feed."""
 
+from collections.abc import Mapping
 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
 from codex.views.browser.browser import BrowserView
 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
-class HrefData:
-    """Data for creating hrefs."""
-
-    kwargs: dict | None = None
-    query_params: dict | None = None
-    absolute_query_params: bool = False
-    url_name: str | None = None
-    min_page: int | None = None
-    max_page: int | None = None
+from codex.views.opds.v2.href import HrefData, OPDS2HrefMixin
 
 
 @dataclass
@@ -40,9 +27,10 @@ class LinkData:
     width: int | None = None
     href: str | None = None
     num_items: int | None = None
+    authenticate: Mapping | None = None
 
 
-class OPDS2LinksView(BrowserView):
+class OPDS2LinksView(OPDS2HrefMixin, BrowserView):
     """Links methods for OPDS 2.0 Feed."""
 
     def __init__(self, *args, **kwargs):
@@ -70,41 +58,12 @@ class OPDS2LinksView(BrowserView):
             self._num_pages = self.group_and_books[2]
         return self._num_pages
 
-    def _href_page_validate(self, kwargs, data):
-        """Validate the page bounds."""
-        min_page = 1 if data.min_page is None else data.min_page
-        max_page = self.num_pages if data.max_page is None else data.max_page
-        page = int(kwargs["page"])
-        return page >= min_page and page <= max_page
-
-    def _href_update_query_params(self, href, data):
-        """Update the query params."""
-        if data.absolute_query_params and data.query_params:
-            href = update_href_query_params(href, data.query_params)
-        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
-            )
-        return href
-
-    def _href(self, data):
-        """Create an href."""
-        url_name = data.url_name if data.url_name else "opds:v2:feed"
-        kwargs = data.kwargs if data.kwargs is not None else self.kwargs
-        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)
-
     def link(self, data):
         """Create a link element."""
         if data.href:
             href = data.href
         else:
-            href = self._href(data.href_data)
+            href = self.href(data.href_data)
             if not href:
                 return None
         mime_type = data.mime_type if data.mime_type else MimeType.OPDS_JSON
@@ -118,8 +77,15 @@ class OPDS2LinksView(BrowserView):
             link["height"] = data.height
         if data.width:
             link["width"] = data.width
+
+        # Properties
+        if data.num_items or data.authenticate:
+            link["properties"] = {}
         if data.num_items:
-            link["properties"] = {"number_of_items": data.num_items}
+            link["properties"]["number_of_items"] = data.num_items
+        if data.authenticate:
+            link["properties"]["authenticate"] = data.authenticate
+
         return link
 
     @staticmethod

codex/views/opds/v2/progression.py

@@ -0,0 +1,137 @@
+"""OPDS 2 Progression view."""
+# https://github.com/opds-community/drafts/discussions/67#discussioncomment-6414507
+
+from types import MappingProxyType
+
+from django.db.models.expressions import F, Value
+from django.db.models.fields import FloatField
+from django.db.models.functions.comparison import Cast, Coalesce, Greatest, Least
+from django.db.models.query_utils import FilteredRelation
+from rest_framework.exceptions import ValidationError
+from rest_framework.response import Response
+
+from codex.logger.logging import get_logger
+from codex.serializers.opds.v2.progression import OPDS2ProgressionSerializer
+from codex.util import max_none
+from codex.views.auth import AuthFilterGenericAPIView
+from codex.views.bookmark import BookmarkFilterMixin, BookmarkPageView
+from codex.views.const import GROUP_MODEL_MAP
+from codex.views.opds.v2.href import HrefData, OPDS2HrefMixin
+
+_EMPTY_DEVICE = MappingProxyType(
+    {
+        "id": "",
+        "name": "",
+    }
+)
+LOG = get_logger(__name__)
+
+
+# This is an independent api requiring a separate get.
+class OPDS2ProgressionView(
+    BookmarkFilterMixin, OPDS2HrefMixin, BookmarkPageView, AuthFilterGenericAPIView
+):
+    """OPDS 2 Progression view."""
+
+    serializer_class = OPDS2ProgressionSerializer
+
+    @property
+    def modified(self):
+        """Get modified from bookmark."""
+        return self._obj.bookmark_updated_at  # type: ignore
+
+    @property
+    def device(self):
+        """Dummy device."""
+        # Codex doesn't record this.
+        return _EMPTY_DEVICE
+
+    @property
+    def title(self):
+        """The locator title is the page number."""
+        return f"Page {self._obj.page}"  # type: ignore
+
+    @property
+    def _progression_href(self):
+        """Build a Progression HRef."""
+        acq_kwargs = {
+            "pk": self._obj.pk,
+            "page": self._obj.page,  # type: ignore
+        }
+        max_page = max_none(self._obj.page_count - 1, 0)  # type: ignore
+        data = HrefData(
+            acq_kwargs,
+            url_name="opds:bin:page",
+            min_page=0,
+            max_page=max_page,  # type: ignore
+            # absolute_query_params=True,
+        )
+        return self.href(data)
+
+    @property
+    def _locations(self):
+        """Build the Locations object."""
+        return {
+            "position": self._obj.page,  # type: ignore
+            "progression": self._obj.progress,  # type: ignore
+            "total_progression": self._obj.progress,  # type: ignore
+        }
+
+    @property
+    def locator(self):
+        """Build the Locator object."""
+        return {
+            "title": self.title,  # See publication.py:103
+            "href": self._progression_href,
+            "type": "image/jpeg",
+            "locations": self._locations,
+        }
+
+    def get_object(self):
+        """Build the progression data object."""
+        group = self.kwargs.get("group")
+        pk = self.kwargs.get("pk")
+
+        if not pk:
+            reason = f"Bad primary key for {group}:{pk}"
+            return ValidationError(reason, code="422")
+
+        model = GROUP_MODEL_MAP.get(group)
+        if not model:
+            reason = f"No model found for group {group}"
+            raise ValidationError(reason, code="422")
+
+        acl_filter = self.get_group_acl_filter(model, self.request.user)
+        qs = model.objects.filter(acl_filter).distinct()
+
+        bm_rel = self.get_bm_rel(model)
+        bm_filter = self.get_my_bookmark_filter(bm_rel)
+        progress = Least(
+            F("page") / Greatest(Cast(F("page_count"), FloatField()), 1.0), Value(1.0)
+        )
+
+        qs = qs.annotate(
+            my_bookmark=FilteredRelation("bookmark", condition=bm_filter),
+            bookmark_updated_at=F("my_bookmark__updated_at"),
+            page=Coalesce(F("my_bookmark__page"), 0),
+            progress=progress,
+        )
+        self._obj = qs.only("page_count").distinct().get(pk=pk)
+
+        return {
+            "modified": self.modified,
+            "device": self.device,
+            "locator": self.locator,
+        }
+
+    def get(self, *args, **kwargs):
+        """Get Response."""
+        try:
+            obj = self.get_object()
+            serializer = self.get_serializer(obj)
+            return Response(serializer.data)
+        except Exception:
+            LOG.exception("progression")
+            raise
+
+    # PUT handled by BookmarkPageView parent

codex/views/opds/v2/publications.py

@@ -10,7 +10,9 @@ 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
+from codex.views.opds.v2.href import HrefData
+from codex.views.opds.v2.links import LinkData
+from codex.views.opds.v2.top_links import OPDS2TopLinksView
 
 _MD_CONTRIBUTOR_MAP = MappingProxyType(
     {
@@ -154,11 +156,29 @@ class OPDS2PublicationView(OPDS2TopLinksView):
             acq_href_data,
             mime_type=download_mime_type,
         )
+        prog_kwargs = {"group": "c", "pk": obj.pk}
+        prog_href_data = HrefData(prog_kwargs, url_name="opds:v2:position")
+
+        auth_href_data = HrefData({}, url_name="opds:authentication:v1")
+        auth_link_data = LinkData(
+            Rel.AUTHENTICATION,
+            auth_href_data,
+            mime_type=MimeType.AUTHENTICATION,
+        )
+        auth_link = self.link(auth_link_data)
+
+        prog_link_data = LinkData(
+            Rel.PROGRESSION,
+            prog_href_data,
+            mime_type=MimeType.PROGRESSION,
+            authenticate=auth_link,
+        )
         links = [
             # Comic streaming link (unsupported)
             # self.link(self_link_data),
             self.link(alt_link_data),
             self.link(acq_link_data),
+            self.link(prog_link_data),
         ]
         pub["links"] = links
 

codex/views/opds/v2/top_links.py

@@ -1,7 +1,8 @@
 """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.href import HrefData
+from codex.views.opds.v2.links import LinkData, OPDS2LinksView
 
 
 class OPDS2TopLinksView(OPDS2LinksView):

codex/views/public.py

@@ -13,6 +13,7 @@ _ADMIN_FLAG_KEYS = frozenset(
     {
         AdminFlag.FlagChoices.NON_USERS.value,
         AdminFlag.FlagChoices.REGISTRATION.value,
+        AdminFlag.FlagChoices.BANNER_TEXT.value,
     }
 )
 
@@ -21,16 +22,22 @@ 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")
+    queryset = AdminFlag.objects.filter(key__in=_ADMIN_FLAG_KEYS).only(
+        "key", "on", "value"
+    )
 
     def get_object(self):
         """Get admin flags."""
         flags = {}
         for obj in self.get_queryset():  # type: ignore
             name = ADMIN_FLAG_CHOICES[obj.key].lower().replace(" ", "_")
-            flags[name] = obj.on
+            if obj.key == AdminFlag.FlagChoices.BANNER_TEXT.value:
+                val = obj.value
+            else:
+                val = obj.on
+            flags[name] = val
         return flags
 
-    def get(self, request, *args, **kwargs):
+    def get(self, *args, **kwargs):
         """Get admin flags relevant to auth."""
-        return self.retrieve(request, *args, **kwargs)
+        return self.retrieve(*args, **kwargs)

codex/views/reader/books.py

@@ -6,7 +6,7 @@ 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 BookmarkAuthMixin
 from codex.views.browser.filters.field import ComicFieldFilterView
 from codex.views.const import (
     FOLDER_GROUP,
@@ -15,7 +15,7 @@ from codex.views.const import (
     NONE_INTEGERFIELD,
     STORY_ARC_GROUP,
 )
-from codex.views.mixins import BookmarkSearchMixin, SharedAnnotationsMixin
+from codex.views.mixins import SharedAnnotationsMixin
 from codex.views.reader.params import ReaderParamsView
 
 if TYPE_CHECKING:
@@ -34,9 +34,7 @@ _COMIC_FIELDS = (
 )
 
 
-class ReaderBooksView(
-    BookmarkBaseView, ReaderParamsView, SharedAnnotationsMixin, BookmarkSearchMixin
-):
+class ReaderBooksView(SharedAnnotationsMixin, BookmarkAuthMixin, ReaderParamsView):
     """Get Books methods."""
 
     def _get_reader_arc_pks(
@@ -81,10 +79,10 @@ class ReaderBooksView(
         """Get ordering for query."""
         sort_name_annotations = {}
         if arc_group in ("v", "s"):
+            parent_group = "i" if arc_group == "s" else "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
+                model, parent_group, arc_pks, show
             )
             if sort_name_annotations and model is Comic:
                 ordering += (*sort_name_annotations.keys(),)
@@ -149,6 +147,19 @@ class ReaderBooksView(
         qs = qs.order_by(*ordering)
         return qs, arc_group
 
+    @staticmethod
+    def _get_bookmark_filter(auth_filter, comic_filter=None):
+        """Get the search kwargs for a user's authentication state."""
+        # search kwargs are relative to the bookmark object.
+        search_kwargs = {}
+        search_kwargs.update(auth_filter)
+
+        if comic_filter:
+            for key, value in comic_filter.items():
+                search_kwargs[f"comic__{key}"] = value
+
+        return search_kwargs
+
     def _append_with_settings(self, book, bookmark_filter):
         """Append bookmark to book list."""
         book.settings = (
@@ -169,7 +180,7 @@ class ReaderBooksView(
         """
         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_filter(auth_filter)
         books = {}
         prev_book = None
         pk = self.kwargs.get("pk")