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

codex/views/opds/v1/facets.py

@@ -0,0 +1,190 @@
+"""OPDS v1 Facets methods."""
+from dataclasses import dataclass
+
+from django.urls import reverse
+
+from codex.models import AdminFlag
+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.opds.v1.data import OPDS1Link
+from codex.views.opds.v1.entry.data import OPDS1EntryData, OPDS1EntryObject
+from codex.views.opds.v1.entry.entry import OPDS1Entry
+
+
+@dataclass
+class FacetGroup:
+    """An opds:facetGroup."""
+
+    title_prefix: str
+    query_param: str
+    glyph: str
+    facets: tuple
+
+
+@dataclass
+class Facet:
+    """An OPDS facet."""
+
+    value: str
+    title: str
+
+
+class FacetGroups:
+    """Facet Group definitions."""
+
+    ORDER_BY = FacetGroup(
+        "Order By",
+        "orderBy",
+        "➠",
+        (
+            Facet("date", "Date"),
+            Facet("sort_name", "Name"),
+        ),
+    )
+    ORDER_REVERSE = FacetGroup(
+        "Order",
+        "orderReverse",
+        "⇕",
+        (Facet("false", "Ascending"), Facet("true", "Descending")),
+    )
+    ALL = (ORDER_BY, ORDER_REVERSE)
+
+
+class RootFacetGroups:
+    """Facet Groups that only appear at the root."""
+
+    TOP_GROUP = FacetGroup(
+        "",
+        "topGroup",
+        "⊙",
+        (
+            Facet("p", "Publishers View"),
+            Facet("s", "Series View"),
+            Facet("f", "Folder View"),
+            Facet("a", "Story Arc View"),
+        ),
+    )
+    ALL = (TOP_GROUP,)
+
+
+DEFAULT_FACETS = {
+    "topGroup": "p",
+    "orderBy": "sort_name",
+    "orderReverse": "false",
+}
+
+
+class FacetsMixin(BrowserView):
+    """OPDS 1 Facets methods."""
+
+    # Overwritten by get_object()
+    use_facets = False
+    skip_order_facets = False
+    acquisition_groups = frozenset()
+    mime_type_map = MimeType.FILE_TYPE_MAP
+    obj = {}
+
+    def _facet(self, kwargs, facet_group, facet_title, new_query_params):
+        href = reverse("opds:v1:feed", kwargs=kwargs)
+        facet_active = False
+        for key, val in new_query_params.items():
+            if self.request.query_params.get(key) == val:
+                facet_active = True
+                break
+        href = update_href_query_params(
+            href, self.request.query_params, new_query_params
+        )
+
+        title = " ".join(filter(None, (facet_group.title_prefix, facet_title))).strip()
+        return OPDS1Link(
+            Rel.FACET,
+            href,
+            MimeType.NAV,
+            title=title,
+            facet_group=facet_group.query_param,
+            facet_active=facet_active,
+        )
+
+    def _facet_entry(self, item, facet_group, facet, query_params):
+        name = " ".join(
+            filter(None, (facet_group.glyph, facet_group.title_prefix, facet.title))
+        ).strip()
+        entry_obj = OPDS1EntryObject(
+            group=item.get("group"),
+            pk=item.get("pk"),
+            name=name,
+        )
+        qps = {**self.request.query_params}
+        qps.update(query_params)
+        issue_max = self.obj.get("issue_max", 0)
+        data = OPDS1EntryData(
+            self.acquisition_groups, issue_max, False, self.mime_type_map
+        )
+        return OPDS1Entry(entry_obj, qps, data)
+
+    def _is_facet_active(self, facet_group, facet):
+        compare = [facet.value]
+        default_val = DEFAULT_FACETS.get(facet_group.query_param)
+        if facet.value == default_val:
+            compare += [None]
+        return self.request.query_params.get(facet_group.query_param) in compare
+
+    @staticmethod
+    def _did_special_group_change(group, facet_group):
+        """Test if one of the special groups changed."""
+        for test_group in ("f", "a"):
+            if (
+                group == test_group
+                and facet_group != test_group
+                or group != test_group
+                and facet_group == test_group
+            ):
+                return True
+        return False
+
+    def _facet_or_facet_entry(self, facet_group, facet, entries):
+        # This logic preempts facet:activeFacet but no one uses it.
+        # don't add default facets if in default mode.
+        if self._is_facet_active(facet_group, facet):
+            return None
+
+        group = self.kwargs.get("group")
+        if facet_group.query_param == "topGroup" and self._did_special_group_change(
+            group, facet.value
+        ):
+            kwargs = {"group": facet.value, "pk": 0, "page": 1}
+        else:
+            kwargs = self.kwargs
+
+        qps = {facet_group.query_param: facet.value}
+        if entries and self.kwargs.get("page") == 1:
+            facet = self._facet_entry(kwargs, facet_group, facet, qps)
+        else:
+            facet = self._facet(kwargs, facet_group, facet.title, qps)
+        return facet
+
+    def _facet_group(self, facet_group, entries):
+        facets = []
+        for facet in facet_group.facets:
+            if facet.value == "f":
+                efv_flag = (
+                    AdminFlag.objects.only("on")
+                    .get(key=AdminFlag.FlagChoices.FOLDER_VIEW.value)
+                    .on
+                )
+                if not efv_flag:
+                    continue
+            if facet_obj := self._facet_or_facet_entry(facet_group, facet, entries):
+                facets += [facet_obj]
+        return facets
+
+    def facets(self, entries=False, root=True):
+        """Return facets."""
+        facets = []
+        if not self.skip_order_facets:
+            facets += self._facet_group(FacetGroups.ORDER_BY, entries)
+            facets += self._facet_group(FacetGroups.ORDER_REVERSE, entries)
+        if root:
+            facets += self._facet_group(RootFacetGroups.TOP_GROUP, entries)
+        return facets

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"}),
         ),
     ),
 )