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

codex/views/mixins.py

@@ -0,0 +1,76 @@
+"""Cross view annotation methods."""
+
+from django.db.models.expressions import F
+
+from codex.models.comic import Comic, Imprint, Volume
+from codex.views.const import GROUP_NAME_MAP
+
+_SHOW_GROUPS = tuple(GROUP_NAME_MAP.keys())
+
+
+class SharedAnnotationsMixin:
+    """Cross view annotation methods."""
+
+    @staticmethod
+    def _get_order_groups(pks, model_group):
+        """Annotate sort_name."""
+        if not pks or len(pks) > 1:
+            order_groups = _SHOW_GROUPS
+        elif model_group == "c":
+            order_groups = ()
+        else:
+            for index, nav_group in enumerate(_SHOW_GROUPS):
+                if nav_group == model_group:
+                    order_groups = _SHOW_GROUPS[index + 1 :]
+                    break
+            else:
+                order_groups = _SHOW_GROUPS
+        return order_groups
+
+    @classmethod
+    def alias_sort_names(cls, qs, model, pks, model_group, show=None):  # noqa PLR0193
+        """Annotate sort names for browser subclasses and reader."""
+        sort_name_annotations = {}
+        comic_sort_names = []
+        if model == Comic:
+            order_groups = cls._get_order_groups(pks, model_group)
+            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"
+                sort_name = F(f"{group_name}__{name_field}")
+                sort_name_annotations[ann_name] = sort_name
+                comic_sort_names.append(ann_name)
+        elif model == Volume:
+            sort_name_annotations["sort_name"] = F("name")
+
+        if sort_name_annotations:
+            qs = qs.alias(**sort_name_annotations)
+        return qs, comic_sort_names
+
+    @classmethod
+    def annotate_group_names(cls, qs, model):
+        """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"}):
+            return qs
+        group_names = {}
+        if model == Comic:
+            if target != "reader":
+                group_names["publisher_name"] = F("publisher__name")
+                if target == "opds2":
+                    group_names["imprint_name"] = F("imprint__name")
+            group_names.update(
+                {
+                    "series_name": F("series__name"),
+                    "volume_name": F("volume__name"),
+                }
+            )
+        elif model == Volume:
+            group_names["series_name"] = F("series__name")
+        elif model == Imprint:
+            group_names["publisher_name"] = F("publisher__name")
+        return qs.annotate(**group_names)

codex/views/opds/auth.py

@@ -0,0 +1,17 @@
+"""OPDS Authentican mixin."""
+
+from rest_framework.authentication import BasicAuthentication, SessionAuthentication
+
+from codex.views.auth import IsAuthenticatedOrEnabledNonUsers
+from codex.views.template import CodexXMLTemplateView
+
+
+class OPDSAuthMixin:
+    """Add Basic Auth."""
+
+    authentication_classes = (SessionAuthentication, BasicAuthentication)
+    permission_classes = (IsAuthenticatedOrEnabledNonUsers,)
+
+
+class OPDSTemplateView(OPDSAuthMixin, CodexXMLTemplateView):
+    """XML Template view with OPDSAuth."""

codex/views/opds/authentication_v1.py

@@ -9,57 +9,58 @@ from rest_framework.response import Response
 
 from codex.serializers.opds.authentication import OPDSAuthentication1Serializer
 
+_LOGO_SIZE = 512
+_DOC = MappingProxyType(
+    {
+        "id": reverse_lazy("opds:authentication:v1"),
+        "title": "Codex",
+        "description": "Codex OPDS Syndication",
+        "links": [
+            {
+                "rel": "logo",
+                "href": staticfiles_storage.url("img/logo.svg"),
+                "type": "image/svg+xml",
+                "width": _LOGO_SIZE,
+                "height": _LOGO_SIZE,
+            },
+            {
+                "rel": "help",
+                "href": "https://github.com/ajslater/codex",
+                "type": "text/html",
+            },
+            {
+                "rel": "register",
+                "href": reverse_lazy("app:start"),
+                "type": "text/html",
+            },
+        ],
+        "authentication": [
+            {
+                "type": "http://opds-spec.org/auth/basic",
+                "labels": {"login": "Username", "password": "Password"},
+            },
+            {
+                # XXX Out of spec type
+                "type": "cookie",
+                "links": [
+                    {
+                        "rel": "authenticate",
+                        "href": reverse_lazy("app:start"),
+                        "type": "text/html",
+                    }
+                ],
+            },
+        ],
+    }
+)
+
 
 class OPDSAuthentication1View(GenericAPIView):
     """Authentication document."""
 
     serializer_class = OPDSAuthentication1Serializer
 
-    DOC = MappingProxyType(
-        {
-            "id": reverse_lazy("opds:authentication:v1"),
-            "title": "Codex",
-            "description": "Codex OPDS Syndication",
-            "links": [
-                {
-                    "rel": "logo",
-                    "href": staticfiles_storage.url("img/logo.svg"),
-                    "type": "image/svg+xml",
-                    "width": 512,
-                    "height": 512,
-                },
-                {
-                    "rel": "help",
-                    "href": "https://github.com/ajslater/codex",
-                    "type": "text/html",
-                },
-                {
-                    "rel": "register",
-                    "href": reverse_lazy("app:start"),
-                    "type": "text/html",
-                },
-            ],
-            "authentication": [
-                {
-                    "type": "http://opds-spec.org/auth/basic",
-                    "labels": {"login": "Username", "password": "Password"},
-                },
-                {
-                    # XXX Out of spec type
-                    "type": "cookie",
-                    "links": [
-                        {
-                            "rel": "authenticate",
-                            "href": reverse_lazy("app:start"),
-                            "type": "text/html",
-                        }
-                    ],
-                },
-            ],
-        }
-    )
-
     def get(self, *args, **kwargs):
         """Fill in the authentication dict."""
-        serializer = self.get_serializer(self.DOC)
+        serializer = self.get_serializer(_DOC)
         return Response(serializer.data)

codex/views/opds/binary.py

@@ -1,21 +1,16 @@
 """Binary views with Basic Authentication added."""
 
-from rest_framework.authentication import BasicAuthentication, SessionAuthentication
-
-from codex.views.cover import CoverView
+from codex.views.browser.cover import CoverView
 from codex.views.download import DownloadView
+from codex.views.opds.auth import OPDSAuthMixin
 from codex.views.reader.page import ReaderPageView
 
 
-class OPDSAuthMixin:
-    """Add Basic Auth."""
-
-    authentication_classes = (BasicAuthentication, SessionAuthentication)
-
-
-class OPDSCoverView(OPDSAuthMixin, CoverView):
+class OPDSCoverView(CoverView):
     """Cover View with Basic Auth."""
 
+    # Panels sometimes doesn't send auth with cover requests.
+
 
 class OPDSDownloadView(OPDSAuthMixin, DownloadView):
     """Download View with Basic Auth."""

codex/views/opds/const.py

@@ -3,6 +3,16 @@
 from collections.abc import Mapping
 from types import MappingProxyType
 
+from codex.models import (
+    Character,
+    Genre,
+    Location,
+    SeriesGroup,
+    StoryArc,
+    Tag,
+    Team,
+)
+
 BLANK_TITLE = "Unknown"
 AUTHOR_ROLES = {"Writer"}
 
@@ -71,3 +81,6 @@ class MimeType:
         }
     )
     OCTET = "application/octet-stream"
+
+
+OPDS_M2M_MODELS = (Character, Genre, Location, SeriesGroup, StoryArc, Tag, Team)

codex/views/opds/urls.py

@@ -0,0 +1,30 @@
+"""OPDS URLs."""
+
+from django.urls import reverse
+from rest_framework.response import Response
+
+from codex.serializers.choices import DEFAULTS
+from codex.serializers.opds.urls import OPDSURLsSerializer
+from codex.views.auth import AuthGenericAPIView
+from codex.views.util import pop_name
+
+_OPDS_VERSIONS = (1, 2)
+
+
+class OPDSURLsView(AuthGenericAPIView):
+    """OPDS URLs."""
+
+    serializer_class = OPDSURLsSerializer
+
+    def get(self, *args, **kwargs):
+        """Resolve the urls."""
+        obj = {}
+        route = DEFAULTS["breadcrumbs"][0]
+        route = pop_name(route)
+        for version in _OPDS_VERSIONS:
+            key = f"v{version}"
+            name = f"opds:v{version}:feed"
+            value = reverse(name, kwargs=route)
+            obj[key] = value
+        serializer = self.get_serializer(obj)
+        return Response(serializer.data)

codex/views/opds/util.py

@@ -6,19 +6,12 @@ from django.urls import reverse
 from django.utils.http import urlencode
 
 from codex.models import (
-    Character,
     Contributor,
     ContributorPerson,
-    Genre,
-    Location,
-    SeriesGroup,
-    StoryArc,
-    Tag,
-    Team,
 )
 from codex.serializers.choices import DEFAULTS
-
-OPDS_M2M_MODELS = (Character, Genre, Location, SeriesGroup, StoryArc, Tag, Team)
+from codex.views.auth import GroupACLMixin
+from codex.views.opds.const import OPDS_M2M_MODELS
 
 
 def update_href_query_params(href, old_query_params, new_query_params=None):
@@ -38,10 +31,10 @@ def update_href_query_params(href, old_query_params, new_query_params=None):
     return href
 
 
-def get_contributor_people(comic_pk, roles, exclude=False):
+def get_contributor_people(comic_pks, roles, exclude=False):
     """Get contributors that are not authors."""
     people = ContributorPerson.objects.filter(
-        contributor__comic=comic_pk,
+        contributor__comic__in=comic_pks,
     )
     if exclude:
         people = people.exclude(contributor__role__name__in=roles)
@@ -50,9 +43,9 @@ def get_contributor_people(comic_pk, roles, exclude=False):
     return people.distinct().only("name")
 
 
-def get_contributors(comic_pk, roles, exclude=False):
+def get_contributors(comic_pks, roles, exclude=False):
     """Get credits that are not part of other roles."""
-    contributors = Contributor.objects.filter(comic=comic_pk)
+    contributors = Contributor.objects.filter(comic__in=comic_pks)
     if exclude:
         contributors = contributors.exclude(role__name__in=roles)
     else:
@@ -60,15 +53,13 @@ def get_contributors(comic_pk, roles, exclude=False):
     return contributors.annotate(name=F("person__name"), role_name=F("role__name"))
 
 
-def get_m2m_objects(pk) -> dict:
+def get_m2m_objects(pks) -> dict:
     """Get Category labels."""
     cats = {}
     for model in OPDS_M2M_MODELS:
         table = model.__name__.lower()
-        rel = "comic"
-        if model == StoryArc:
-            rel = "storyarcnumber__" + rel
-        comic_filter = {rel: pk}
+        rel = GroupACLMixin.get_rel_prefix(model)
+        comic_filter = {rel + "__in": pks}
         qs = model.objects.filter(**comic_filter).order_by("name").only("name")
         cats[table] = qs
 
@@ -80,7 +71,8 @@ def full_redirect_view(url_name):
 
     def func(request):
         """Redirect to view, forwarding query strings and auth."""
-        kwargs = DEFAULTS["route"]
+        kwargs = DEFAULTS["breadcrumbs"][0]
+        kwargs.pop("name", None)
         url = reverse(url_name, kwargs=kwargs)
 
         # Forward the query string.

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

@@ -9,7 +9,7 @@ class OPDS1EntryObject:
     """Fake entry db object for top link & facet entries."""
 
     group: str = ""
-    pk: int = 0
+    ids: frozenset[int] = frozenset()
     name: str = ""
     summary: str = ""
     fake: bool = True
@@ -20,6 +20,6 @@ class OPDS1EntryData:
     """Entry Data class to avoid to many args."""
 
     acquisition_groups: frozenset
-    issue_number_max: int
+    zero_pad: int
     metadata: bool
     mime_type_map: Mapping[str, str]

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

@@ -50,7 +50,7 @@ class OPDS1Entry(OPDS1EntryLinksMixin):
                 elif group == "c":
                     title = Comic.get_title(
                         self.obj,
-                        issue_number_max=self.issue_number_max,
+                        zero_pad=self.zero_pad,
                         filename_fallback=self.title_filename_fallback,
                     )
                     parts.append(title)
@@ -122,7 +122,7 @@ class OPDS1Entry(OPDS1EntryLinksMixin):
     @staticmethod
     def _add_url_to_obj(objs, filter_key):
         """Add filter urls to objects."""
-        kwargs = {"group": "s", "pk": 0, "page": 1}
+        kwargs = {"group": "s", "pks": {}, "page": 1}
         url_base = reverse("opds:v1:feed", kwargs=kwargs)
         result = []
         for obj in objs:
@@ -137,7 +137,7 @@ class OPDS1Entry(OPDS1EntryLinksMixin):
         """Get Author names."""
         if not self.metadata:
             return []
-        people = get_contributor_people(self.obj.pk, AUTHOR_ROLES)
+        people = get_contributor_people(self.obj.ids, AUTHOR_ROLES)
         return self._add_url_to_obj(people, "contributors")
 
     @property
@@ -145,7 +145,7 @@ class OPDS1Entry(OPDS1EntryLinksMixin):
         """Get Contributor names."""
         if not self.metadata:
             return []
-        people = get_contributor_people(self.obj.pk, AUTHOR_ROLES, exclude=True)
+        people = get_contributor_people(self.obj.ids, AUTHOR_ROLES, exclude=True)
         return self._add_url_to_obj(people, "contributors")
 
     @property
@@ -153,4 +153,4 @@ class OPDS1Entry(OPDS1EntryLinksMixin):
         """Get Category labels."""
         if not self.metadata:
             return {}
-        return get_m2m_objects(self.obj.pk)
+        return get_m2m_objects(self.obj.ids)

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

@@ -1,16 +1,19 @@
 """OPDS v1 Entry Links Methods."""
 
+from datetime import datetime
+from math import floor
 from urllib.parse import quote_plus
 
-from django.contrib.staticfiles.storage import staticfiles_storage
 from django.urls import reverse
 
-from codex.models import Comic
+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
 
+LOG = get_logger(__name__)
+
 
 class OPDS1EntryLinksMixin:
     """OPDS v1 Entry Links Methods."""
@@ -23,63 +26,61 @@ class OPDS1EntryLinksMixin:
         self.fake = isinstance(self.obj, OPDS1EntryObject)
         self.query_params = query_params
         self.acquision_groups = data.acquisition_groups
-        self.issue_number_max = data.issue_number_max
+        self.zero_pad = data.zero_pad
         self.metadata = data.metadata
         self.mime_type_map = data.mime_type_map
         self.title_filename_fallback = title_filename_fallback
 
-    def _thumb_link(self):
+    def _cover_link(self, rel):
         if self.fake:
             return None
-        cover_pk = self.obj.cover_pk
-        if cover_pk:
-            kwargs = {"pk": cover_pk}
+        # cover_pk = getattr(self.obj, "cover_pk", None)
+        try:
+            kwargs = {"group": self.obj.group, "pks": self.obj.ids}
+            ts = floor(datetime.timestamp(self.obj.updated_at))
+            query_params = {
+                "customCovers": True,
+                "dynamicCovers": False,
+                "ts": ts,
+            }
             href = reverse("opds:bin:cover", kwargs=kwargs)
-        elif cover_pk == 0:
-            href = staticfiles_storage.url("img/missing_cover.webp")
-        else:
-            return None
-        return OPDS1Link(Rel.THUMBNAIL, href, "image/webp")
-
-    def _image_link(self):
-        if self.fake:
-            return None
-        cover_pk = self.obj.cover_pk
-        if cover_pk:
-            kwargs = {"pk": cover_pk, "page": 0}
-            href = reverse("opds:bin:page", kwargs=kwargs)
-            mime_type = "image/jpeg"
-        elif cover_pk == 0:
-            href = staticfiles_storage.url("img/missing_cover.webp")
+            href = update_href_query_params(href, query_params)
             mime_type = "image/webp"
-        else:
-            return None
-        return OPDS1Link(Rel.IMAGE, href, mime_type)
+            return OPDS1Link(rel, href, mime_type)
+        except Exception:
+            LOG.exception("create thumb")
 
     def _nav_href(self, metadata=False):
-        kwargs = {"group": self.obj.group, "pk": self.obj.pk, "page": 1}
-        href = reverse("opds:v1:feed", kwargs=kwargs)
-        qps = {}
-        if (
-            self.obj.group == "a"
-            and self.obj.pk
-            and not self.query_params.get("orderBy")
-        ):
-            # story arcs get ordered by story_arc_number by default
-            qps.update({"orderBy": "story_arc_number"})
-        if metadata:
-            qps.update({"opdsMetadata": 1})
-        return update_href_query_params(href, self.query_params, qps)
+        try:
+            pks = sorted(self.obj.ids)
+            kwargs = {"group": self.obj.group, "pks": pks, "page": 1}
+            href = reverse("opds:v1:feed", kwargs=kwargs)
+            qps = {}
+            if (
+                self.obj.group == "a"
+                and self.obj.ids
+                and 0 not in self.obj.ids
+                and not self.query_params.get("orderBy")
+            ):
+                # story arcs get ordered by story_arc_number by default
+                qps.update({"orderBy": "story_arc_number"})
+            if metadata:
+                qps.update({"opdsMetadata": 1})
+            return update_href_query_params(href, self.query_params, qps)
+        except Exception:
+            msg = f"creating nav href for entry {self.obj}"
+            LOG.exception(msg)
+            raise
 
     def _nav_link(self, metadata=False):
-        group = self.obj.group
+        href = self._nav_href(metadata)
 
+        group = self.obj.group
         if group in self.acquision_groups:
             mime_type = MimeType.ENTRY_CATALOG if metadata else MimeType.ACQUISITION
         else:
             mime_type = MimeType.NAV
 
-        href = self._nav_href(metadata)
         thr_count = 0 if self.fake else self.obj.child_count
         rel = Rel.ALTERNATE if metadata else "subsection"
 
@@ -89,8 +90,7 @@ class OPDS1EntryLinksMixin:
         pk = self.obj.pk
         if not pk:
             return None
-        fn = Comic.get_filename(self.obj)
-        fn = quote_plus(fn)
+        fn = quote_plus(self.obj.get_filename())
         kwargs = {"pk": pk, "filename": fn}
         href = reverse("opds:bin:download", kwargs=kwargs)
         mime_type = self.mime_type_map.get(self.obj.file_type, MimeType.OCTET)
@@ -118,23 +118,33 @@ class OPDS1EntryLinksMixin:
             pse_last_read_date=bookmark_updated_at,
         )
 
+    def _links_comic(self):
+        """Links for comics."""
+        result = []
+        if download := self._download_link():
+            result += [download]
+        if stream := self._stream_link():
+            result += [stream]
+        if not self.metadata and (metadata := self._nav_link(metadata=True)):
+            result += [metadata]
+        return result
+
     @property
     def links(self):
         """Create all entry links."""
         result = []
-        if thumb := self._thumb_link():
-            result += [thumb]
-        if image := self._image_link():
-            result += [image]
-
-        if self.obj.group == "c" and not self.fake:
-            if download := self._download_link():
-                result += [download]
-            if stream := self._stream_link():
-                result += [stream]
-            if not self.metadata and (metadata := self._nav_link(metadata=True)):
-                result += [metadata]
-        elif nav := self._nav_link():
-            result += [nav]
-
+        try:
+            if thumb := self._cover_link(Rel.THUMBNAIL):
+                result += [thumb]
+            if image := self._cover_link(Rel.IMAGE):
+                result += [image]
+
+            if self.obj.group == "c" and not self.fake:
+                result += self._links_comic()
+            elif nav := self._nav_link():
+                result += [nav]
+
+        except Exception:
+            msg = f"Getting entry links for {self.obj}"
+            LOG.exception(msg)
         return result

codex/views/opds/v1/facets.py

@@ -12,6 +12,7 @@ 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.util import pop_name
 
 
 @dataclass
@@ -77,7 +78,7 @@ DEFAULT_FACETS = {
 }
 
 
-class FacetsMixin(BrowserView):
+class OPDS1FacetsView(BrowserView):
     """OPDS 1 Facets methods."""
 
     OPDS = 1
@@ -89,15 +90,14 @@ class FacetsMixin(BrowserView):
     obj = MappingProxyType({})
 
     def _facet(self, kwargs, facet_group, facet_title, new_query_params):
+        kwargs = pop_name(kwargs)
         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:
+            if self.request.GET.get(key) == val:
                 facet_active = True
                 break
-        href = update_href_query_params(
-            href, self.request.query_params, new_query_params
-        )
+        href = update_href_query_params(href, self.request.GET, new_query_params)
 
         title = " ".join(filter(None, (facet_group.title_prefix, facet_title))).strip()
         return OPDS1Link(
@@ -115,14 +115,14 @@ class FacetsMixin(BrowserView):
         ).strip()
         entry_obj = OPDS1EntryObject(
             group=item.get("group"),
-            pk=item.get("pk"),
+            ids=item.get("pks"),
             name=name,
         )
-        qps = {**self.request.query_params}
+        qps = {**self.request.GET}
         qps.update(query_params)
-        issue_number_max = self.obj.get("issue_number_max", 0)
+        zero_pad = self.obj["zero_pad"]
         data = OPDS1EntryData(
-            self.acquisition_groups, issue_number_max, False, self.mime_type_map
+            self.acquisition_groups, zero_pad, False, self.mime_type_map
         )
         return OPDS1Entry(entry_obj, qps, data)
 
@@ -131,7 +131,7 @@ class FacetsMixin(BrowserView):
         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
+        return self.request.GET.get(facet_group.query_param) in compare
 
     @staticmethod
     def _did_special_group_change(group, facet_group):
@@ -156,7 +156,7 @@ class FacetsMixin(BrowserView):
         if facet_group.query_param == "topGroup" and self._did_special_group_change(
             group, facet.value
         ):
-            kwargs = {"group": facet.value, "pk": 0, "page": 1}
+            kwargs = {"group": facet.value, "pks": {}, "page": 1}
         else:
             kwargs = self.kwargs