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

codex/views/opds/authentication_v1.py

@@ -9,58 +9,57 @@ 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(_DOC)
+        serializer = self.get_serializer(self.DOC)
         return Response(serializer.data)

codex/views/opds/binary.py

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

codex/views/opds/const.py

@@ -3,16 +3,6 @@
 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"}
 
@@ -81,6 +71,3 @@ class MimeType:
         }
     )
     OCTET = "application/octet-stream"
-
-
-OPDS_M2M_MODELS = (Character, Genre, Location, SeriesGroup, StoryArc, Tag, Team)

codex/views/opds/urls.py

@@ -1,17 +1,16 @@
 """OPDS URLs."""
 
 from django.urls import reverse
+from rest_framework.generics import GenericAPIView
 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)
+OPDS_VERSIONS = (1, 2)
 
 
-class OPDSURLsView(AuthGenericAPIView):
+class OPDSURLsView(GenericAPIView):
     """OPDS URLs."""
 
     serializer_class = OPDSURLsSerializer
@@ -20,8 +19,7 @@ class OPDSURLsView(AuthGenericAPIView):
         """Resolve the urls."""
         obj = {}
         route = DEFAULTS["breadcrumbs"][0]
-        route = pop_name(route)
-        for version in _OPDS_VERSIONS:
+        for version in OPDS_VERSIONS:
             key = f"v{version}"
             name = f"opds:v{version}:feed"
             value = reverse(name, kwargs=route)

codex/views/opds/util.py

@@ -6,12 +6,19 @@ 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
-from codex.views.auth import GroupACLMixin
-from codex.views.opds.const import OPDS_M2M_MODELS
+
+OPDS_M2M_MODELS = (Character, Genre, Location, SeriesGroup, StoryArc, Tag, Team)
 
 
 def update_href_query_params(href, old_query_params, new_query_params=None):
@@ -58,7 +65,9 @@ def get_m2m_objects(pks) -> dict:
     cats = {}
     for model in OPDS_M2M_MODELS:
         table = model.__name__.lower()
-        rel = GroupACLMixin.get_rel_prefix(model)
+        rel = "comic"
+        if model == StoryArc:
+            rel = "storyarcnumber__" + rel
         comic_filter = {rel + "__in": pks}
         qs = model.objects.filter(**comic_filter).order_by("name").only("name")
         cats[table] = qs
@@ -72,7 +81,6 @@ def full_redirect_view(url_name):
     def func(request):
         """Redirect to view, forwarding query strings and auth."""
         kwargs = DEFAULTS["breadcrumbs"][0]
-        kwargs.pop("name", None)
         url = reverse(url_name, kwargs=kwargs)
 
         # Forward the query string.

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

@@ -1,12 +1,12 @@
 """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.logger.logging import get_logger
+from codex.views.const import MISSING_COVER_FN, MISSING_COVER_NAME_MAP
 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
@@ -31,24 +31,39 @@ class OPDS1EntryLinksMixin:
         self.mime_type_map = data.mime_type_map
         self.title_filename_fallback = title_filename_fallback
 
-    def _cover_link(self, rel):
+    def _thumb_link(self):
         if self.fake:
             return None
-        # 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,
-            }
+        cover_pk = getattr(self.obj, "cover_pk", None)
+        if cover_pk:
+            kwargs = {"pk": cover_pk}
             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)
-        except Exception:
-            LOG.exception("create thumb")
+        else:
+            cover_name = MISSING_COVER_NAME_MAP.get(self.obj.group)
+            cover_path = "img/"
+            if cover_name:
+                cover_path += cover_name + ".svg"
+                mime_type = "image/svg+xml"
+            else:
+                cover_path += MISSING_COVER_FN
+                mime_type = "image/webp"
+            href = staticfiles_storage.url(cover_path)
+        return OPDS1Link(Rel.THUMBNAIL, href, mime_type)
+
+    def _image_link(self):
+        if self.fake:
+            return None
+        cover_pk = getattr(self.obj, "cover_pk", None)
+        if cover_pk:
+            kwargs = {"pk": cover_pk, "page": 0}
+            href = reverse("opds:bin:page", kwargs=kwargs)
+            mime_type = "image/jpeg"
+        else:
+            fn = f"img/{MISSING_COVER_FN}"
+            href = staticfiles_storage.url(fn)
+            mime_type = "image/webp"
+        return OPDS1Link(Rel.IMAGE, href, mime_type)
 
     def _nav_href(self, metadata=False):
         try:
@@ -134,9 +149,9 @@ class OPDS1EntryLinksMixin:
         """Create all entry links."""
         result = []
         try:
-            if thumb := self._cover_link(Rel.THUMBNAIL):
+            if thumb := self._thumb_link():
                 result += [thumb]
-            if image := self._cover_link(Rel.IMAGE):
+            if image := self._image_link():
                 result += [image]
 
             if self.obj.group == "c" and not self.fake:

codex/views/opds/v1/facets.py

@@ -12,7 +12,6 @@ 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
@@ -78,7 +77,7 @@ DEFAULT_FACETS = {
 }
 
 
-class OPDS1FacetsView(BrowserView):
+class FacetsMixin(BrowserView):
     """OPDS 1 Facets methods."""
 
     OPDS = 1
@@ -90,14 +89,15 @@ class OPDS1FacetsView(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.GET.get(key) == val:
+            if self.request.query_params.get(key) == val:
                 facet_active = True
                 break
-        href = update_href_query_params(href, self.request.GET, new_query_params)
+        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(
@@ -118,7 +118,7 @@ class OPDS1FacetsView(BrowserView):
             ids=item.get("pks"),
             name=name,
         )
-        qps = {**self.request.GET}
+        qps = {**self.request.query_params}
         qps.update(query_params)
         zero_pad = self.obj["zero_pad"]
         data = OPDS1EntryData(
@@ -131,7 +131,7 @@ class OPDS1FacetsView(BrowserView):
         default_val = DEFAULT_FACETS.get(facet_group.query_param)
         if facet.value == default_val:
             compare += [None]
-        return self.request.GET.get(facet_group.query_param) in compare
+        return self.request.query_params.get(facet_group.query_param) in compare
 
     @staticmethod
     def _did_special_group_change(group, facet_group):

codex/views/opds/v1/feed.py

@@ -1,30 +1,33 @@
 """OPDS v1 feed."""
 
+from datetime import datetime, timezone
 from types import MappingProxyType
 from typing import TYPE_CHECKING, Any
 
 from comicbox.box import Comicbox
 from drf_spectacular.utils import extend_schema
+from rest_framework.authentication import BasicAuthentication, SessionAuthentication
 from rest_framework.response import Response
 from rest_framework.throttling import ScopedRateThrottle
 
 from codex.librarian.importer.tasks import LazyImportComicsTask
 from codex.librarian.mp_queue import LIBRARIAN_QUEUE
 from codex.logger.logging import get_logger
-from codex.serializers.browser.settings import OPDSSettingsSerializer
 from codex.serializers.opds.v1 import (
     OPDS1TemplateSerializer,
 )
-from codex.views.const import FALSY, MAX_OBJ_PER_PAGE
-from codex.views.opds.auth import OPDSTemplateView
+from codex.views.browser.browser import BrowserView
+from codex.views.browser.const import MAX_OBJ_PER_PAGE
+from codex.views.const import FALSY
 from codex.views.opds.const import BLANK_TITLE, 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 (
-    OPDS1LinksView,
+    LinksMixin,
     RootTopLinks,
     TopLinks,
 )
+from codex.views.template import CodexXMLTemplateView
 
 if TYPE_CHECKING:
     from collections.abc import Mapping
@@ -41,22 +44,22 @@ class OpdsNs:
     ACQUISITION = "http://opds-spec.org/2010/acquisition"
 
 
-class UserAgentNames:
+class UserAgentPrefixes:
     """Control whether to hack in facets with nav links."""
 
-    CLIENT_REORDERS = frozenset({"Chunky"})
-    FACET_SUPPORT = frozenset({"yar"})  # kybooks
-    SIMPLE_DOWNLOAD_MIME_TYPES = frozenset({"PocketBook Reader"})
-    # Other known valid  names:
+    CLIENT_REORDERS = ("Chunky",)
+    FACET_SUPPORT = ("yar",)  # kybooks
+    SIMPLE_DOWNLOAD_MIME_TYPES = ("PocketBook",)
+    # Other known valid  prefixes:
     # "Panels", "Chunky"
 
 
-class OPDS1FeedView(OPDS1LinksView, OPDSTemplateView):
+class OPDS1FeedView(CodexXMLTemplateView, LinksMixin):
     """OPDS 1 Feed."""
 
+    authentication_classes = (SessionAuthentication, BasicAuthentication)
     template_name = "opds_v1/index.xml"
     serializer_class = OPDS1TemplateSerializer
-    input_serializer_class = OPDSSettingsSerializer
     throttle_classes = (ScopedRateThrottle,)
     throttle_scope = "opds"
     TARGET = "opds1"
@@ -87,7 +90,7 @@ class OPDS1FeedView(OPDS1LinksView, OPDSTemplateView):
         """Create the feed title."""
         result = ""
         try:
-            browser_title: Mapping[str, Any] = self.obj.get("title")  # type: ignore
+            browser_title: Mapping[str, Any] = self.obj.get("browser_title")  # type: ignore
             if browser_title:
                 parent_name = browser_title.get("parent_name", "All")
                 pks = self.kwargs["pks"]
@@ -104,9 +107,10 @@ class OPDS1FeedView(OPDS1LinksView, OPDSTemplateView):
 
     @property
     def updated(self):
-        """Use mtime for updated."""
+        """Hack in feed update time from cover timestamp."""
         try:
-            return self.obj.get("mtime", "")
+            if ts := self.obj.get("covers_timestamp"):
+                return datetime.fromtimestamp(ts, tz=timezone.utc)  # type: ignore
         except Exception:
             LOG.exception("Getting OPDS v1 updated")
 
@@ -141,7 +145,7 @@ class OPDS1FeedView(OPDS1LinksView, OPDSTemplateView):
                 entries += [
                     OPDS1Entry(
                         obj,
-                        self.request.GET,
+                        self.request.query_params,
                         data,
                         title_filename_fallback=fallback,
                     )
@@ -161,7 +165,9 @@ class OPDS1FeedView(OPDS1LinksView, OPDSTemplateView):
                 entries += self.facets(entries=True, root=at_root)
 
             entries += self._get_entries_section("groups", False)
-            metadata = self.request.GET.get("opdsMetadata", "").lower() not in FALSY
+            metadata = (
+                self.request.query_params.get("opdsMetadata", "").lower() not in FALSY
+            )
             entries += self._get_entries_section("books", metadata)
         except Exception:
             LOG.exception("Getting OPDS v1 entries")
@@ -169,17 +175,14 @@ class OPDS1FeedView(OPDS1LinksView, OPDSTemplateView):
 
     def _ensure_page_counts(self):
         """Ensure page counts on books with just in time comicbox."""
-        if self.admin_flags.get("import_metadata"):
-            return
         books_qs: QuerySet = self.obj["books"]  # type: ignore
         import_pks = set()
         new_books = []
         for book in books_qs:
-            if book.page_count is not None:
-                continue
-            with Comicbox(book.path) as cb:
-                book.file_type = cb.get_file_type()
-                book.page_count = cb.get_page_count()
+            if not book.page_count:
+                with Comicbox(book.path) as cb:
+                    book.file_type = cb.get_file_type()
+                    book.page_count = cb.get_page_count()
             new_books.append(book)
             import_pks.add(book.pk)
         if new_books:
@@ -191,24 +194,7 @@ class OPDS1FeedView(OPDS1LinksView, OPDSTemplateView):
 
     def get_object(self):  # type: ignore
         """Get the browser page and serialize it for this subclass."""
-        group_qs, book_qs, num_pages, total_count, zero_pad, mtime = (
-            super()._get_group_and_books()
-        )
-        book_qs = book_qs.select_related("series", "volume", "language")
-
-        title = self.get_browser_page_title()
-        self.obj = MappingProxyType(
-            {
-                "title": title,
-                "groups": group_qs,
-                "books": book_qs,
-                "zero_pad": zero_pad,
-                "num_pages": num_pages,
-                "total_count": total_count,
-                "mtime": mtime,
-            }
-        )
-
+        self.obj = super().get_object()
         self.is_aq_feed = self.model_group in ("c", "f")
 
         self._ensure_page_counts()
@@ -218,21 +204,22 @@ class OPDS1FeedView(OPDS1LinksView, OPDSTemplateView):
 
     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
-        user_agent_parts = user_agent.split("/", 1)
-        if user_agent_parts:
-            user_agent_name = user_agent_parts[0]
-        else:
-            return
-
-        if user_agent_name in UserAgentNames.FACET_SUPPORT:
-            self.use_facets = True
-        if user_agent_name in UserAgentNames.CLIENT_REORDERS:
-            self.skip_order_facets = True
-        if user_agent_name in UserAgentNames.SIMPLE_DOWNLOAD_MIME_TYPES:
-            self.mime_type_map = MimeType.SIMPLE_FILE_TYPE_MAP
+        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
 
     def set_opds_request_type(self):
         """Set the opds request type variables."""
@@ -245,7 +232,7 @@ class OPDS1FeedView(OPDS1LinksView, OPDSTemplateView):
             self.acquisition_groups = frozenset({*self.valid_nav_groups[-2:]} | {"c"})
             self.is_opds_1_acquisition = group in self.acquisition_groups
         self.is_opds_metadata = (
-            self.request.GET.get("opdsMetadata", "").lower() not in FALSY
+            self.request.query_params.get("opdsMetadata", "").lower() not in FALSY
         )
 
     def init_request(self):
@@ -255,7 +242,10 @@ class OPDS1FeedView(OPDS1LinksView, OPDSTemplateView):
         self._set_user_agent_variables()
         self.skip_order_facets |= self.kwargs.get("group") == "c"
 
-    @extend_schema(parameters=[input_serializer_class])
+    @extend_schema(
+        request=BrowserView.input_serializer_class,
+        parameters=[BrowserView.input_serializer_class],
+    )
     def get(self, *_args, **_kwargs):
         """Get the feed."""
         self.init_request()

codex/views/opds/v1/links.py

@@ -14,8 +14,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.opds.v1.facets import OPDS1FacetsView
-from codex.views.util import pop_name
+from codex.views.opds.v1.facets import FacetsMixin
 
 LOG = get_logger(__name__)
 
@@ -102,13 +101,13 @@ class RootTopLinks:
     ALL = (NEW, FEATURED, LAST_READ)
 
 
-class OPDS1LinksView(OPDS1FacetsView):
+class LinksMixin(FacetsMixin):
     """OPDS 1 Links methods."""
 
     # overwritten in get_object()
     DEFAULT_ROUTE = MappingProxyType(
         {
-            **OPDS1FacetsView.DEFAULT_ROUTE,
+            **FacetsMixin.DEFAULT_ROUTE,
             "name": "opds:v1:feed",
         }
     )
@@ -121,7 +120,7 @@ class OPDS1LinksView(OPDS1FacetsView):
                 return False
 
         for key, value in top_link.query_params.items():
-            if str(self.request.GET.get(key)) != str(value):
+            if str(self.request.query_params.get(key)) != str(value):
                 return False
 
         return True
@@ -129,8 +128,7 @@ class OPDS1LinksView(OPDS1FacetsView):
     def _link(self, kwargs, rel, query_params=None, mime_type=MimeType.NAV):
         """Create a link."""
         if query_params is None:
-            query_params = self.request.GET
-        kwargs = pop_name(kwargs)
+            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)

codex/views/opds/v1/opensearch_v1.py

@@ -2,15 +2,19 @@
 
 from drf_spectacular.types import OpenApiTypes
 from drf_spectacular.utils import extend_schema
+from rest_framework.authentication import BasicAuthentication, SessionAuthentication
 from rest_framework.throttling import ScopedRateThrottle
 
-from codex.views.opds.auth import OPDSTemplateView
+from codex.views.auth import IsAuthenticatedOrEnabledNonUsers
+from codex.views.template import CodexXMLTemplateView
 
 
 @extend_schema(responses={("200", "application/xml"): OpenApiTypes.BYTE})
-class OpenSearch1View(OPDSTemplateView):
+class OpenSearch1View(CodexXMLTemplateView):
     """OpenSearchView."""
 
+    authentication_classes = (SessionAuthentication, BasicAuthentication)
+    permission_classes = (IsAuthenticatedOrEnabledNonUsers,)
     template_name = "opds_v1/opensearch_v1.xml"
     content_type = "application/xml"
     throttle_classes = (ScopedRateThrottle,)