codex 1.4.0a1__py3-none-any.whl → 1.4.1__py3-none-any.whl

codex/views/opds/v1/feed.py

@@ -0,0 +1,199 @@
+"""OPDS v1 feed."""
+from datetime import datetime, timezone
+
+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.serializers.opds.v1 import (
+    OPDS1TemplateSerializer,
+)
+from codex.views.browser.browser import BrowserView
+from codex.views.opds.const import (
+    BLANK_TITLE,
+    FALSY,
+    MimeType,
+)
+from codex.views.opds.v1.entry.data import OPDS1EntryData
+from codex.views.opds.v1.entry.entry import OPDS1Entry
+from codex.views.opds.v1.links import (
+    LinksMixin,
+    RootTopLinks,
+    TopLinks,
+)
+from codex.views.template import CodexXMLTemplateView
+
+LOG = get_logger(__name__)
+
+
+class OpdsNs:
+    """XML Namespaces."""
+
+    CATALOG = "http://opds-spec.org/2010/catalog"
+    ACQUISITION = "http://opds-spec.org/2010/acquisition"
+
+
+class UserAgentPrefixes:
+    """Control whether to hack in facets with nav links."""
+
+    CLIENT_REORDERS = ("Chunky",)
+    FACET_SUPPORT = ("yar",)  # kybooks
+    SIMPLE_DOWNLOAD_MIME_TYPES = ("PocketBook",)
+    # Other known valid  prefixes:
+    # "Panels", "Chunky"
+
+
+class OPDS1FeedView(CodexXMLTemplateView, LinksMixin):
+    """OPDS 1 Feed."""
+
+    authentication_classes = (BasicAuthentication, SessionAuthentication)
+    template_name = "opds_v1/index.xml"
+    serializer_class = OPDS1TemplateSerializer
+
+    @property
+    def opds_ns(self):
+        """Dynamic opds namespace."""
+        try:
+            return OpdsNs.ACQUISITION if self.is_aq_feed else OpdsNs.CATALOG
+        except Exception as exc:
+            LOG.exception(exc)
+
+    @property
+    def is_acquisition(self):
+        """Is acquisition."""
+        return self.is_aq_feed
+
+    @property
+    def id_tag(self):
+        """Feed id is the url."""
+        try:
+            return self.request.build_absolute_uri()
+        except Exception as exc:
+            LOG.exception(exc)
+
+    @property
+    def title(self):
+        """Create the feed title."""
+        result = ""
+        try:
+            if browser_title := self.obj.get("browser_title"):
+                parent_name = browser_title.get("parent_name", "All")
+                if not parent_name and self.kwargs.get("pk") == 0:
+                    parent_name = "All"
+                group_name = browser_title.get("group_name")
+                result = " ".join(filter(None, (parent_name, group_name))).strip()
+
+            if not result:
+                result = BLANK_TITLE
+        except Exception as exc:
+            LOG.exception(exc)
+        return result
+
+    @property
+    def updated(self):
+        """Hack in feed update time from cover timestamp."""
+        try:
+            if ts := self.obj.get("covers_timestamp"):
+                return datetime.fromtimestamp(ts, tz=timezone.utc)
+        except Exception as exc:
+            LOG.exception(exc)
+
+    @property
+    def items_per_page(self):
+        """Return opensearch:itemsPerPage."""
+        try:
+            if self.params.get("q"):
+                return self.MAX_OBJ_PER_PAGE
+        except Exception as exc:
+            LOG.exception(exc)
+
+    @property
+    def total_results(self):
+        """Return opensearch:totalResults."""
+        try:
+            if self.params.get("q"):
+                return self.obj.get("total_count", 0)
+        except Exception as exc:
+            LOG.exception(exc)
+
+    def _get_entries_section(self, key, metadata):
+        """Get entries by key section."""
+        entries = []
+        issue_max = self.obj.get("issue_max", 0)
+        data = OPDS1EntryData(
+            self.acquisition_groups, issue_max, metadata, self.mime_type_map
+        )
+        if objs := self.obj.get(key):
+            for obj in objs:
+                entries += [OPDS1Entry(obj, self.request.query_params, data)]
+        return entries
+
+    @property
+    def entries(self):
+        """Create all the entries."""
+        entries = []
+        try:
+            at_root = self.kwargs.get("pk") == 0
+            if not self.use_facets and self.kwargs.get("page") == 1:
+                entries += self.add_top_links(TopLinks.ALL)
+                if at_root:
+                    entries += self.add_top_links(RootTopLinks.ALL)
+                entries += self.facets(entries=True, root=at_root)
+
+            entries += self._get_entries_section("groups", False)
+            metadata = (
+                self.request.query_params.get("opdsMetadata", "").lower() not in FALSY
+            )
+            entries += self._get_entries_section("books", metadata)
+        except Exception as exc:
+            LOG.exception(exc)
+        return entries
+
+    def get_object(self):
+        """Get the browser page and serialize it for this subclass."""
+        group = self.kwargs.get("group")
+        if group == "a":
+            self.acquisition_groups = frozenset(["a"])
+            pk = self.kwargs.get("pk")
+            self.is_opds_1_acquisition = group in self.acquisition_groups and pk
+        else:
+            self.acquisition_groups = frozenset(self.valid_nav_groups[-2:])
+            self.is_opds_1_acquisition = group in self.acquisition_groups
+        self.is_opds_metadata = (
+            self.request.query_params.get("opdsMetadata", "").lower() not in FALSY
+        )
+        self.obj = super().get_object()
+        self.is_aq_feed = self.obj.get("model_group") == "c"
+        return self
+
+    def _set_user_agent_variables(self):
+        """Set User Agent variables."""
+        # defaults in FacetsMixin
+        user_agent = self.request.headers.get("User-Agent")
+        if not user_agent:
+            return
+        for prefix in UserAgentPrefixes.FACET_SUPPORT:
+            if user_agent.startswith(prefix):
+                self.use_facets = True
+                break
+        for prefix in UserAgentPrefixes.CLIENT_REORDERS:
+            if user_agent.startswith(prefix):
+                self.skip_order_facets = True
+                break
+        for prefix in UserAgentPrefixes.SIMPLE_DOWNLOAD_MIME_TYPES:
+            if user_agent.startswith(prefix):
+                self.mime_type_map = MimeType.SIMPLE_FILE_TYPE_MAP
+                break
+
+    @extend_schema(request=BrowserView.input_serializer_class)
+    def get(self, *args, **kwargs):
+        """Get the feed."""
+        self.parse_params()
+        self.validate_settings()
+        self._set_user_agent_variables()
+        self.skip_order_facets |= self.kwargs.get("group") == "c"
+
+        obj = self.get_object()
+        serializer = self.get_serializer(obj)
+        return Response(serializer.data, content_type=self.content_type)

codex/views/opds/v1/links.py

@@ -0,0 +1,198 @@
+"""OPDS v1 Links methods."""
+from collections import defaultdict
+from dataclasses import dataclass
+from typing import Union
+
+from comicbox.metadata.comic_json import json
+from django.urls import reverse
+
+from codex.logger.logging import get_logger
+from codex.views.opds.const import MimeType, Rel
+from codex.views.opds.util import update_href_query_params
+from codex.views.opds.v1.data import OPDS1Link
+from codex.views.opds.v1.entry.data import OPDS1EntryData, OPDS1EntryObject
+from codex.views.opds.v1.entry.entry import OPDS1Entry
+from codex.views.opds.v1.facets import FacetsMixin
+
+LOG = get_logger(__name__)
+
+
+class TopRoutes:
+    """Routes for top groups."""
+
+    PUBLISHER = {"group": "p", "pk": 0, "page": 1}
+    SERIES = {"group": "s", "pk": 0, "page": 1}
+    FOLDER = {"group": "f", "pk": 0, "page": 1}
+    ROOT = {"group": "r", "pk": 0, "page": 1}
+    STORY_ARC = {"group": "a", "pk": 0, "page": 1}
+
+
+@dataclass
+class TopLink:
+    """A non standard root link when facets are unsupported."""
+
+    kwargs: dict
+    rel: str
+    mime_type: str
+    query_params: defaultdict[str, Union[str, bool, int]]
+    glyph: str
+    title: str
+    desc: str
+
+
+class TopLinks:
+    """Top link definitions."""
+
+    START = TopLink(
+        TopRoutes.ROOT,
+        Rel.START,
+        MimeType.NAV,
+        defaultdict(),
+        "⌂",
+        "Start of the catalog",
+        "",
+    )
+    ALL = (START,)
+
+
+class RootTopLinks:
+    """Top Links that only appear at the root."""
+
+    NEW = TopLink(
+        TopRoutes.SERIES,
+        Rel.SORT_NEW,
+        MimeType.ACQUISITION,
+        defaultdict(
+            None, {"orderBy": "created_at", "orderReverse": True, "limit": 100}
+        ),
+        "📥",
+        "Recently Added",
+        "",
+    )
+    FEATURED = TopLink(
+        TopRoutes.SERIES,
+        Rel.FEATURED,
+        MimeType.NAV,
+        defaultdict(
+            None,
+            {
+                "orderBy": "date",
+                "filters": json.dumps({"bookmark": "UNREAD"}),
+                "limit": 100,
+            },
+        ),
+        "📚",
+        "Oldest Unread",
+        "Unread issues, oldest published first",
+    )
+    LAST_READ = TopLink(
+        TopRoutes.SERIES,
+        Rel.POPULAR,
+        MimeType.NAV,
+        defaultdict(
+            None, {"orderBy": "bookmark_updated_at", "orderReverse": True, "limit": 100}
+        ),
+        "👀",
+        "Last Read",
+        "Last Read issues, recently read first.",
+    )
+    ALL = (NEW, FEATURED, LAST_READ)
+
+
+class LinksMixin(FacetsMixin):
+    """OPDS 1 Links methods."""
+
+    # overwritten in get_object()
+    DEFAULT_ROUTE_NAME = "opds:v1:feed"
+    is_aq_feed = False
+
+    def is_top_link_displayed(self, top_link):
+        """Determine if this top link should be displayed."""
+        for key, value in top_link.kwargs.items():
+            if str(self.kwargs.get(key)) != str(value):
+                return False
+
+        for key, value in top_link.query_params.items():
+            if str(self.request.query_params.get(key)) != str(value):
+                return False
+
+        return True
+
+    def _link(self, kwargs, rel, query_params=None, mime_type=MimeType.NAV):
+        """Create a link."""
+        if query_params is None:
+            query_params = self.request.query_params
+        href = reverse("opds:v1:feed", kwargs=kwargs)
+        href = update_href_query_params(href, query_params)
+        return OPDS1Link(rel, href, mime_type)
+
+    def _top_link(self, top_link):
+        """Create a link from a top link."""
+        return self._link(
+            top_link.kwargs, top_link.rel, top_link.query_params, top_link.mime_type
+        )
+
+    def _root_links(self):
+        """Navigation Root Links."""
+        links = []
+        if route := self.obj.get("up_route"):
+            links += [self._link(route, Rel.UP)]
+        page = self.kwargs.get("page", 1)
+        if page > 1:
+            route = {**self.kwargs, "page": page - 1}
+            links += [self._link(route, Rel.PREV)]
+        if page < self.obj.get("num_pages", 1):
+            route = {**self.kwargs, "page": page + 1}
+            links += [self._link(route, Rel.NEXT)]
+        return links
+
+    @property
+    def links(self):
+        """Create all the links."""
+        links = []
+        try:
+            mime_type = MimeType.ACQUISITION if self.is_aq_feed else MimeType.NAV
+            links += [
+                OPDS1Link("self", self.request.get_full_path(), mime_type),
+                OPDS1Link(
+                    Rel.AUTHENTICATION,
+                    reverse("opds:authentication:v1"),
+                    MimeType.AUTHENTICATION,
+                ),
+                OPDS1Link(
+                    "search", reverse("opds:v1:opensearch_v1"), MimeType.OPENSEARCH
+                ),
+            ]
+            links += self._root_links()
+            if self.use_facets:
+                for top_link in TopLinks.ALL + RootTopLinks.ALL:
+                    if not self.is_top_link_displayed(top_link):
+                        links += [self._top_link(top_link)]
+                if facets := self.facets():
+                    links += facets
+        except Exception as exc:
+            LOG.exception(exc)
+        return links
+
+    def _top_link_entry(self, top_link):
+        """Create a entry instead of a facet."""
+        name = " ".join(filter(None, (top_link.glyph, top_link.title)))
+        entry_obj = OPDS1EntryObject(
+            group=top_link.kwargs["group"],
+            pk=top_link.kwargs["pk"],
+            name=name,
+            summary=top_link.desc,
+        )
+        issue_max = self.obj.get("issue_max", 0)
+        data = OPDS1EntryData(
+            self.acquisition_groups, issue_max, False, self.mime_type_map
+        )
+        return OPDS1Entry(entry_obj, top_link.query_params, data)
+
+    def add_top_links(self, top_links):
+        """Add a list of top links as entries if they should be enabled."""
+        entries = []
+        for tl in top_links:
+            if not self.is_top_link_displayed(tl):
+                entries += [self._top_link_entry(tl)]
+        return entries

codex/views/opds/{opensearch.py → v1/opensearch_v1.py}

@@ -1,4 +1,4 @@
-"""Serve an opensearch document."""
+"""Serve an opensearch v1 document."""
 from drf_spectacular.types import OpenApiTypes
 from drf_spectacular.utils import extend_schema
 from rest_framework.authentication import BasicAuthentication, SessionAuthentication
@@ -8,10 +8,10 @@ from codex.views.template import CodexXMLTemplateView
 
 
 @extend_schema(responses={("200", "application/xml"): OpenApiTypes.BYTE})
-class OpenSearchView(CodexXMLTemplateView):
+class OpenSearch1View(CodexXMLTemplateView):
     """OpenSearchView."""
 
     authentication_classes = (BasicAuthentication, SessionAuthentication)
     permission_classes = [IsAuthenticatedOrEnabledNonUsers]
-    template_name = "opds/opensearch.xml"
+    template_name = "opds_v1/opensearch_v1.xml"
     content_type = "application/xml"

codex/views/opds/v2/__init__.py

@@ -1 +1 @@
-"""OPDS 2 Views."""
+"""OPDS v2 Views."""

codex/views/opds/v2/const.py

@@ -1,4 +1,4 @@
-"""OPDS Common consts."""
+"""OPDS v2 consts."""
 from dataclasses import dataclass
 from typing import Optional, Union
 
@@ -41,6 +41,7 @@ FACETS = (
             Facet("p", "Publishers View"),
             Facet("s", "Series View"),
             Facet("f", "Folder View"),
+            Facet("a", "Story Arc View"),
         ),
     )
     # Could add Filters as well.
@@ -81,6 +82,12 @@ GROUPS = (
                 "s",
                 {"orderBy": "date", "orderReverse": False},
             ),
+            NavigationLink(
+                Rel.POPULAR,
+                "Last Read",
+                "s",
+                {"orderBy": "bookmark_updated_at", "orderReverse": True},
+            ),
         ),
     ),
     NavigationGroup(
@@ -89,7 +96,8 @@ GROUPS = (
             NavigationLink(Rel.SUB, "Root", "r", None),
             NavigationLink(Rel.SUB, "Publishers", "p", None),
             NavigationLink(Rel.SUB, "Series", "s", None),
-            NavigationLink(Rel.SUB, "Folders", "f", None),
+            NavigationLink(Rel.SUB, "Folders", "f", {"topGroup": "f"}),
+            NavigationLink(Rel.SUB, "Story Arcs", "a", {"topGroup": "a"}),
         ),
     ),
 )

codex/views/opds/v2/feed.py

@@ -1,4 +1,4 @@
-"""OPDS 2.0 Feed."""
+"""OPDS v2.0 Feed."""
 from datetime import datetime, timezone
 
 from drf_spectacular.utils import extend_schema
@@ -6,6 +6,7 @@ from rest_framework.authentication import BasicAuthentication, SessionAuthentica
 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.opds.const import BLANK_TITLE, FALSY
@@ -27,6 +28,8 @@ LOG = get_logger(__name__)
 class OPDS2FeedView(PublicationMixin, TopLinksMixin):
     """OPDS 2.0 Feed."""
 
+    DEFAULT_ROUTE_NAME = "opds:v2:feed"
+
     authentication_classes = (BasicAuthentication, SessionAuthentication)
     serializer_class = OPDS2FeedSerializer
 
@@ -45,41 +48,92 @@ class OPDS2FeedView(PublicationMixin, TopLinksMixin):
         return result
 
     def _detect_user_agent(self):
-        # Hacks for individual clients
+        """Hacks for individual clients."""
         user_agent = self.request.headers.get("User-Agent")
         if not user_agent:
             return
 
+    @staticmethod
+    def _is_allowed(link_spec):
+        """Return if the link allowed."""
+        if (
+            getattr(link_spec, "group", None) == "f"
+            or getattr(link_spec, "query_param_value", None) == "f"
+        ):
+            # Folder perms
+            efv_flag = (
+                AdminFlag.objects.only("on")
+                .get(key=AdminFlag.FlagChoices.FOLDER_VIEW.value)
+                .on
+            )
+            if not efv_flag:
+                return False
+        return True
+
+    @staticmethod
+    def _create_link_kwargs(data, link_spec):
+        """Create link kwargs."""
+        if data.group_kwarg:
+            # Nav Groups
+            pk = getattr(link_spec, "pk", 0)
+            kwargs = {"group": link_spec.group, "pk": pk, "page": 1}
+        elif link_spec.query_param_value in ("f", "a"):
+            # Special Facets
+            kwargs = {
+                "group": link_spec.query_param_value,
+                "pk": 0,
+                "page": 1,
+            }
+        else:
+            # Regular Facets
+            kwargs = None
+        return kwargs
+
+    @staticmethod
+    def _create_link_query_params(group_spec, link_spec, kwargs):
+        """Create link query params."""
+        if qp_key := getattr(group_spec, "query_param_key", None):
+            # Facet shorthand with group
+            qps = {qp_key: link_spec.query_param_value}
+        elif ls_qps := getattr(link_spec, "query_params", None):
+            # Nav Group
+            qps = ls_qps
+        else:
+            # Regular Group
+            qps = None
+
+        # Special order by for story_arcs
+        if (
+            kwargs
+            and kwargs.get("group") == "a"
+            and kwargs.get("pk")
+            and (not qps or not qps.get("orderBy"))
+        ):
+            if not qps:
+                qps = {}
+            qps["orderBy"] = "story_arc_number"
+        return qps
+
     def _create_links_section(self, group_specs, data):
         """Create links sections for groups and facets."""
         groups = []
         for group_spec in group_specs:
             link_dict = {}
             for link_spec in group_spec.links:
-                if data.group_kwarg:
-                    # Nav Groups
-                    pk = getattr(link_spec, "pk", 0)
-                    kwargs = {"group": link_spec.group, "pk": pk, "page": 1}
-                else:
-                    # Facets & Regular Groups
-                    kwargs = None
-                rel = data.rel if data.rel else link_spec.rel
+                if not self._is_allowed(link_spec):
+                    continue
 
-                if qp_key := getattr(group_spec, "query_param_key", None):
-                    # Facet shorthand with group
-                    qps = {qp_key: link_spec.query_param_value}
-                elif ls_qps := getattr(link_spec, "query_params", None):
-                    # Nav Group
-                    qps = ls_qps
-                else:
-                    # Regular Group
-                    qps = None
+                kwargs = self._create_link_kwargs(data, link_spec)
+
+                qps = self._create_link_query_params(group_spec, link_spec, kwargs)
 
                 title = getattr(link_spec, "title", "")
                 if not title:
                     title = getattr(link_spec, "name", "")
 
                 href_data = HrefData(kwargs, qps)
+
+                rel = data.rel if data.rel else link_spec.rel
                 link_data = LinkData(rel, href_data, title=title)
                 link = self.link(link_data)
                 self.link_aggregate(link_dict, link)
@@ -117,8 +171,15 @@ class OPDS2FeedView(PublicationMixin, TopLinksMixin):
     def get_object(self):
         """Get the browser page and serialize it for this subclass."""
         group = self.kwargs.get("group")
-        self.acquisition_groups = frozenset(self.valid_nav_groups[-2:])
-        self.is_opds_2_acquisition = group in self.acquisition_groups
+        if group in ("f", "a"):
+            self.acquisition_groups = frozenset()
+        else:
+            self.acquisition_groups = frozenset(self.valid_nav_groups[-2:])
+        if group == "a":
+            pk = self.kwargs["pk"]
+            self.is_opds_2_acquisition = bool(pk)
+        else:
+            self.is_opds_2_acquisition = group in self.acquisition_groups
         self.is_opds_metadata = (
             self.request.query_params.get("opdsMetadata", "").lower() not in FALSY
         )

codex/views/opds/v2/links.py

@@ -1,4 +1,4 @@
-"""Links methods for OPDS 2.0 Feed."""
+"""Links methods for OPDS v2.0 Feed."""
 from copy import deepcopy
 from dataclasses import dataclass
 from typing import Optional

codex/views/opds/v2/publications.py

@@ -1,4 +1,4 @@
-"""Publication Methods for OPDS 2.0 feed."""
+"""Publication Methods for OPDS v2.0 feed."""
 from urllib.parse import quote_plus
 
 from django.contrib.staticfiles.storage import staticfiles_storage

codex/views/opds/v2/top_links.py

@@ -1,4 +1,4 @@
-"""OPDS 2.0 top links section methods."""
+"""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
 

codex/views/reader/page.py

@@ -8,11 +8,11 @@ from rest_framework.negotiation import BaseContentNegotiation
 
 from codex.logger.logging import get_logger
 from codex.models import Comic
-from codex.pdf import PDF
 from codex.version import COMICBOX_CONFIG
 from codex.views.bookmark import BookmarkBaseView
 
 LOG = get_logger(__name__)
+PDF_MIME_TYPE = "application/pdf"
 
 
 class IgnoreClientContentNegotiation(BaseContentNegotiation):
@@ -50,23 +50,22 @@ class ReaderPageView(BookmarkBaseView):
 
     def _get_page_image(self):
         """Get the image data and content type."""
-        group_acl_filter = self.get_group_acl_filter(True)
+        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")
         if comic.file_type == Comic.FileType.PDF.value:
-            car = PDF(comic.path)
-            content_type = PDF.MIME_TYPE
+            content_type = PDF_MIME_TYPE
         else:
-            car = ComicArchive(comic.path, config=COMICBOX_CONFIG)
             content_type = self.content_type
-        page_image = car.get_page_by_index(page)
+        with ComicArchive(comic.path, config=COMICBOX_CONFIG) as car:
+            page_image = car.get_page_by_index(page)
         return page_image, content_type
 
     @extend_schema(
         responses={
             (200, content_type): OpenApiTypes.BINARY,
-            (200, PDF.MIME_TYPE): OpenApiTypes.BINARY,
+            (200, PDF_MIME_TYPE): OpenApiTypes.BINARY,
         }
     )
     def get(self, *args, **kwargs):