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

codex/views/opds/v1/feed.py

@@ -1,32 +1,30 @@
 """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.browser.browser import BrowserView
-from codex.views.browser.const import MAX_OBJ_PER_PAGE
-from codex.views.const import FALSY
+from codex.views.const import FALSY, MAX_OBJ_PER_PAGE
+from codex.views.opds.auth import OPDSTemplateView
 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 (
-    LinksMixin,
+    OPDS1LinksView,
     RootTopLinks,
     TopLinks,
 )
-from codex.views.template import CodexXMLTemplateView
 
 if TYPE_CHECKING:
     from collections.abc import Mapping
@@ -43,22 +41,25 @@ class OpdsNs:
     ACQUISITION = "http://opds-spec.org/2010/acquisition"
 
 
-class UserAgentPrefixes:
+class UserAgentNames:
     """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:
+    CLIENT_REORDERS = frozenset({"Chunky"})
+    FACET_SUPPORT = frozenset({"yar"})  # kybooks
+    SIMPLE_DOWNLOAD_MIME_TYPES = frozenset({"PocketBook Reader"})
+    # Other known valid  names:
     # "Panels", "Chunky"
 
 
-class OPDS1FeedView(CodexXMLTemplateView, LinksMixin):
+class OPDS1FeedView(OPDS1LinksView, OPDSTemplateView):
     """OPDS 1 Feed."""
 
-    authentication_classes = (BasicAuthentication, SessionAuthentication)
     template_name = "opds_v1/index.xml"
     serializer_class = OPDS1TemplateSerializer
+    input_serializer_class = OPDSSettingsSerializer
+    throttle_classes = (ScopedRateThrottle,)
+    throttle_scope = "opds"
+    TARGET = "opds1"
 
     @property
     def opds_ns(self):
@@ -86,10 +87,11 @@ class OPDS1FeedView(CodexXMLTemplateView, LinksMixin):
         """Create the feed title."""
         result = ""
         try:
-            browser_title: Mapping[str, Any] = self.obj.get("browser_title")  # type: ignore
+            browser_title: Mapping[str, Any] = self.obj.get("title")  # type: ignore
             if browser_title:
                 parent_name = browser_title.get("parent_name", "All")
-                if not parent_name and self.kwargs.get("pk") == 0:
+                pks = self.kwargs["pks"]
+                if not parent_name and not pks:
                     parent_name = "All"
                 group_name = browser_title.get("group_name")
                 result = " ".join(filter(None, (parent_name, group_name))).strip()
@@ -102,10 +104,9 @@ class OPDS1FeedView(CodexXMLTemplateView, LinksMixin):
 
     @property
     def updated(self):
-        """Hack in feed update time from cover timestamp."""
+        """Use mtime for updated."""
         try:
-            if ts := self.obj.get("covers_timestamp"):
-                return datetime.fromtimestamp(ts, tz=timezone.utc)  # type: ignore
+            return self.obj.get("mtime", "")
         except Exception:
             LOG.exception("Getting OPDS v1 updated")
 
@@ -131,16 +132,16 @@ class OPDS1FeedView(CodexXMLTemplateView, LinksMixin):
         """Get entries by key section."""
         entries = []
         if objs := self.obj.get(key):
-            issue_number_max: int = self.obj.get("issue_number_max", 0)  # type: ignore
+            zero_pad: int = self.obj["zero_pad"]  # type: ignore
             data = OPDS1EntryData(
-                self.acquisition_groups, issue_number_max, metadata, self.mime_type_map
+                self.acquisition_groups, zero_pad, metadata, self.mime_type_map
             )
             fallback = bool(self.admin_flags.get("folder_view"))
             for obj in objs:  # type: ignore
                 entries += [
                     OPDS1Entry(
                         obj,
-                        self.request.query_params,
+                        self.request.GET,
                         data,
                         title_filename_fallback=fallback,
                     )
@@ -152,17 +153,15 @@ class OPDS1FeedView(CodexXMLTemplateView, LinksMixin):
         """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)
+                at_root = not self.kwargs["pks"]
                 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
-            )
+            metadata = self.request.GET.get("opdsMetadata", "").lower() not in FALSY
             entries += self._get_entries_section("books", metadata)
         except Exception:
             LOG.exception("Getting OPDS v1 entries")
@@ -170,14 +169,17 @@ class OPDS1FeedView(CodexXMLTemplateView, LinksMixin):
 
     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 not book.page_count:
-                with Comicbox(book.path) as cb:
-                    book.file_type = cb.get_file_type()
-                    book.page_count = cb.get_page_count()
+            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()
             new_books.append(book)
             import_pks.add(book.pk)
         if new_books:
@@ -189,18 +191,24 @@ class OPDS1FeedView(CodexXMLTemplateView, LinksMixin):
 
     def get_object(self):  # type: ignore
         """Get the browser page and serialize it for this subclass."""
-        group = self.kwargs.get("group")
-        if group == "a":
-            self.acquisition_groups = frozenset({"a", "c"})
-            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:]} | {"c"})
-            self.is_opds_1_acquisition = group in self.acquisition_groups
-        self.is_opds_metadata = (
-            self.request.query_params.get("opdsMetadata", "").lower() not in FALSY
+        group_qs, book_qs, num_pages, total_count, zero_pad, mtime = (
+            super()._get_group_and_books()
         )
-        self.obj = super().get_object()
+        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.is_aq_feed = self.model_group in ("c", "f")
 
         self._ensure_page_counts()
@@ -210,34 +218,47 @@ class OPDS1FeedView(CodexXMLTemplateView, LinksMixin):
 
     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,
-        parameters=[BrowserView.input_serializer_class],
-    )
-    def get(self, *_args, **_kwargs):
-        """Get the feed."""
-        self.parse_params()
-        self.validate_settings()
+        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
+
+    def set_opds_request_type(self):
+        """Set the opds request type variables."""
+        group = self.kwargs.get("group")
+        if group == "a":
+            self.acquisition_groups = frozenset({"a", "c"})
+            pks = self.kwargs["pks"]
+            self.is_opds_1_acquisition = group in self.acquisition_groups and pks
+        else:
+            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
+        )
+
+    def init_request(self):
+        """Initialize request."""
+        super().init_request()
+        self.set_opds_request_type()
         self._set_user_agent_variables()
         self.skip_order_facets |= self.kwargs.get("group") == "c"
 
+    @extend_schema(parameters=[input_serializer_class])
+    def get(self, *_args, **_kwargs):
+        """Get the feed."""
+        self.init_request()
         obj = self.get_object()
         serializer = self.get_serializer(obj)
         return Response(serializer.data, content_type=self.content_type)

codex/views/opds/v1/links.py

@@ -14,7 +14,8 @@ 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
+from codex.views.opds.v1.facets import OPDS1FacetsView
+from codex.views.util import pop_name
 
 LOG = get_logger(__name__)
 
@@ -22,11 +23,11 @@ LOG = get_logger(__name__)
 class TopRoutes:
     """Routes for top groups."""
 
-    PUBLISHER = MappingProxyType({"group": "p", "pk": 0, "page": 1})
-    SERIES = MappingProxyType({"group": "s", "pk": 0, "page": 1})
-    FOLDER = MappingProxyType({"group": "f", "pk": 0, "page": 1})
-    ROOT = MappingProxyType({"group": "r", "pk": 0, "page": 1})
-    STORY_ARC = MappingProxyType({"group": "a", "pk": 0, "page": 1})
+    PUBLISHER = MappingProxyType({"group": "p", "pks": {}, "page": 1})
+    SERIES = MappingProxyType({"group": "s", "pks": {}, "page": 1})
+    FOLDER = MappingProxyType({"group": "f", "pks": {}, "page": 1})
+    ROOT = MappingProxyType({"group": "r", "pks": {}, "page": 1})
+    STORY_ARC = MappingProxyType({"group": "a", "pks": {}, "page": 1})
 
 
 @dataclass
@@ -101,13 +102,13 @@ class RootTopLinks:
     ALL = (NEW, FEATURED, LAST_READ)
 
 
-class LinksMixin(FacetsMixin):
+class OPDS1LinksView(OPDS1FacetsView):
     """OPDS 1 Links methods."""
 
     # overwritten in get_object()
     DEFAULT_ROUTE = MappingProxyType(
         {
-            **FacetsMixin.DEFAULT_ROUTE,
+            **OPDS1FacetsView.DEFAULT_ROUTE,
             "name": "opds:v1:feed",
         }
     )
@@ -120,7 +121,7 @@ class LinksMixin(FacetsMixin):
                 return False
 
         for key, value in top_link.query_params.items():
-            if str(self.request.query_params.get(key)) != str(value):
+            if str(self.request.GET.get(key)) != str(value):
                 return False
 
         return True
@@ -128,7 +129,8 @@ class LinksMixin(FacetsMixin):
     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
+            query_params = self.request.GET
+        kwargs = pop_name(kwargs)
         href = reverse("opds:v1:feed", kwargs=kwargs)
         href = update_href_query_params(href, query_params)
         return OPDS1Link(rel, href, mime_type)
@@ -142,15 +144,15 @@ class LinksMixin(FacetsMixin):
     def _root_links(self):
         """Navigation Root Links."""
         links = []
-        if route := self.obj.get("up_route"):
-            links += [self._link(route, Rel.UP)]
+        if up_route := self.get_last_route():
+            links += [self._link(up_route, Rel.UP)]
         page = self.kwargs.get("page", 1)
         if page > 1:
-            route = {**self.kwargs, "page": page - 1}
-            links += [self._link(route, Rel.PREV)]
+            prev_route = {**self.kwargs, "page": page - 1}
+            links += [self._link(prev_route, Rel.PREV)]
         if page < self.obj.get("num_pages", 1):
-            route = {**self.kwargs, "page": page + 1}
-            links += [self._link(route, Rel.NEXT)]
+            next_route = {**self.kwargs, "page": page + 1}
+            links += [self._link(next_route, Rel.NEXT)]
         return links
 
     @property
@@ -186,13 +188,13 @@ class LinksMixin(FacetsMixin):
         name = " ".join(filter(None, (top_link.glyph, top_link.title)))
         entry_obj = OPDS1EntryObject(
             group=top_link.kwargs["group"],
-            pk=top_link.kwargs["pk"],
+            ids=top_link.kwargs["pks"],
             name=name,
             summary=top_link.desc,
         )
-        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, top_link.query_params, data)
 

codex/views/opds/v1/opensearch_v1.py

@@ -2,17 +2,16 @@
 
 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.auth import IsAuthenticatedOrEnabledNonUsers
-from codex.views.template import CodexXMLTemplateView
+from codex.views.opds.auth import OPDSTemplateView
 
 
 @extend_schema(responses={("200", "application/xml"): OpenApiTypes.BYTE})
-class OpenSearch1View(CodexXMLTemplateView):
+class OpenSearch1View(OPDSTemplateView):
     """OpenSearchView."""
 
-    authentication_classes = (BasicAuthentication, SessionAuthentication)
-    permission_classes = (IsAuthenticatedOrEnabledNonUsers,)
     template_name = "opds_v1/opensearch_v1.xml"
     content_type = "application/xml"
+    throttle_classes = (ScopedRateThrottle,)
+    throttle_scope = "opensearch"

codex/views/opds/v2/feed.py

@@ -1,18 +1,16 @@
 """OPDS v2.0 Feed."""
 
-from datetime import datetime, timezone
 from types import MappingProxyType
 
 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.models import AdminFlag
+from codex.serializers.browser.settings import OPDSSettingsSerializer
 from codex.serializers.opds.v2 import OPDS2FeedSerializer
-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.const import FALSY, MAX_OBJ_PER_PAGE
+from codex.views.opds.auth import OPDSAuthMixin
 from codex.views.opds.const import BLANK_TITLE
 from codex.views.opds.v2.const import (
     FACETS,
@@ -23,28 +21,30 @@ from codex.views.opds.v2.const import (
     NavigationGroup,
 )
 from codex.views.opds.v2.links import HrefData, LinkData
-from codex.views.opds.v2.publications import PublicationMixin
-from codex.views.opds.v2.top_links import TopLinksMixin
+from codex.views.opds.v2.publications import OPDS2PublicationView
 
 LOG = get_logger(__name__)
 
 
-class OPDS2FeedView(PublicationMixin, TopLinksMixin):
+class OPDS2FeedView(OPDSAuthMixin, OPDS2PublicationView):
     """OPDS 2.0 Feed."""
 
     DEFAULT_ROUTE = MappingProxyType(
-        {**TopLinksMixin.DEFAULT_ROUTE, "name": "opds:v2:feed"}
+        {**OPDS2PublicationView.DEFAULT_ROUTE, "name": "opds:v2:feed"}
     )
+    TARGET = "opds2"
+    throttle_scope = "opds"
 
-    authentication_classes = (BasicAuthentication, SessionAuthentication)
     serializer_class = OPDS2FeedSerializer
+    input_serializer_class = OPDSSettingsSerializer
 
     def _title(self, browser_title):
         """Create the feed title."""
         result = ""
         if browser_title:
             parent_name = browser_title.get("parent_name", "All")
-            if not parent_name and self.kwargs.get("pk") == 0:
+            pks = self.kwargs["pks"]
+            if not parent_name and not pks:
                 parent_name = "All"
             group_name = browser_title.get("group_name")
             result = " ".join(filter(None, (parent_name, group_name))).strip()
@@ -53,11 +53,11 @@ class OPDS2FeedView(PublicationMixin, TopLinksMixin):
             result = BLANK_TITLE
         return result
 
-    def _detect_user_agent(self):
-        """Hacks for individual clients."""
-        user_agent = self.request.headers.get("User-Agent")
-        if not user_agent:
-            return
+    # def _detect_user_agent(self):
+    #    """Hacks for individual clients."""
+    #    user_agent = self.request.headers.get("User-Agent")
+    #    if not user_agent:
+    #        return
 
     @staticmethod
     def _is_allowed(link_spec):
@@ -81,13 +81,13 @@ class OPDS2FeedView(PublicationMixin, TopLinksMixin):
         """Create link kwargs."""
         if data.group_kwarg:
             # Nav Groups
-            pk = getattr(link_spec, "pk", 0)
-            kwargs = {"group": link_spec.group, "pk": pk, "page": 1}
+            pks = getattr(link_spec, "ids", (0,))
+            kwargs = {"group": link_spec.group, "pks": pks, "page": 1}
         elif link_spec.query_param_value in ("f", "a"):
             # Special Facets
             kwargs = {
                 "group": link_spec.query_param_value,
-                "pk": 0,
+                "pks": (0,),
                 "page": 1,
             }
         else:
@@ -112,7 +112,7 @@ class OPDS2FeedView(PublicationMixin, TopLinksMixin):
         if (
             kwargs
             and kwargs.get("group") == "a"
-            and kwargs.get("pk")
+            and kwargs.get("pks")
             and (not qps or not qps.get("orderBy"))
         ):
             if not qps:
@@ -155,7 +155,7 @@ class OPDS2FeedView(PublicationMixin, TopLinksMixin):
                 groups.append(group)
         return groups
 
-    def _get_groups(self, group_qs, book_qs, title, issue_number_max):
+    def _get_groups(self, group_qs, book_qs, title, zero_pad):
         groups = []
 
         # Top Nav Groups
@@ -167,7 +167,7 @@ class OPDS2FeedView(PublicationMixin, TopLinksMixin):
         groups += self._create_links_section(tup, GROUPS_SECTION_DATA)
 
         # Publications
-        groups += self.get_publications(book_qs, issue_number_max, title)
+        groups += self.get_publications(book_qs, zero_pad, title)
 
         return groups
 
@@ -176,53 +176,69 @@ class OPDS2FeedView(PublicationMixin, TopLinksMixin):
 
     def get_object(self):
         """Get the browser page and serialize it for this subclass."""
-        group = self.kwargs.get("group")
-        if group in ("f", "a"):
-            pk = self.kwargs["pk"]
-            self.is_opds_2_acquisition = bool(pk)
-        else:
-            acquisition_groups = frozenset(self.valid_nav_groups[-2:])
-            self.is_opds_2_acquisition = group in acquisition_groups
-        self.is_opds_metadata = (
-            self.request.query_params.get("opdsMetadata", "").lower() not in FALSY
+        group_qs, book_qs, num_pages, total_count, zero_pad, mtime = (
+            self._get_group_and_books()
         )
-        browser_page = super().get_object()
-        groups = browser_page.get("groups")
-        books = browser_page.get("books")
+        title = self.get_browser_page_title()
+        # convert browser_page into opds page
+
+        # instance vars
+        self.is_aq_feed = self.model_group in ("c", "f")
+        self.num_pages = num_pages
+
+        # opds page
+        title = self._title(title)
+        number_of_items = total_count
+        current_page = self.kwargs.get("page")
+        up_route = self.get_last_route()
+        links = self.get_links(up_route)
+        facets = self._get_facets()
+
+        # opds groups
+        page_groups = group_qs
+        page_books = book_qs
+        groups = self._get_groups(page_groups, page_books, title, zero_pad)
 
-        self.is_aq_feed = browser_page.get("model_group") == "c"
-
-        ts: int = browser_page["covers_timestamp"]  # type: ignore
-        datetime.fromtimestamp(ts, tz=timezone.utc)
-        self.num_pages = browser_page["num_pages"]
-        number_of_items = browser_page["total_count"]
-        title = self._title(browser_page.get("browser_title"))
         return MappingProxyType(
             {
                 "metadata": {
                     "title": title,
+                    "modified": mtime,
                     "number_of_items": number_of_items,
                     "items_per_page": MAX_OBJ_PER_PAGE,
-                    "current_page": self.kwargs.get("page"),
+                    "current_page": current_page,
                 },
-                "links": self.get_links(browser_page["up_route"]),
-                "facets": self._get_facets(),
-                "groups": self._get_groups(
-                    groups, books, title, browser_page["issue_number_max"]
-                ),
+                "links": links,
+                "facets": facets,
+                "groups": groups,
             }
         )
 
+    def set_opds_request_type(self):
+        """Set opds request type variables."""
+        group = self.kwargs.get("group")
+        if group in {"f", "a"}:
+            pks = self.kwargs["pks"]
+            self.is_opds_2_acquisition = bool(pks)
+        else:
+            acquisition_groups = frozenset(self.valid_nav_groups[-2:])
+            self.is_opds_2_acquisition = group in acquisition_groups
+        self.is_opds_metadata = (
+            self.request.GET.get("opdsMetadata", "").lower() not in FALSY
+        )
+
+    def init_request(self):
+        """Initialize request."""
+        super().init_request()
+        self.set_opds_request_type()
+        # self._detect_user_agent()
+
     @extend_schema(
-        request=BrowserView.input_serializer_class,
-        parameters=[BrowserView.input_serializer_class],
+        parameters=[input_serializer_class],
     )
     def get(self, *_args, **_kwargs):
         """Get the feed."""
-        self.parse_params()
-        self.validate_settings()
-        # self._detect_user_agent()
-
+        self.init_request()
         obj = self.get_object()
         serializer = self.get_serializer(obj)
         return Response(serializer.data)

codex/views/opds/v2/links.py

@@ -10,6 +10,7 @@ from codex.views.browser.browser import BrowserView
 from codex.views.const import FALSY
 from codex.views.opds.const import MimeType, Rel
 from codex.views.opds.util import update_href_query_params
+from codex.views.util import pop_name
 
 
 @dataclass
@@ -39,7 +40,7 @@ class LinkData:
     num_items: int | None = None
 
 
-class LinksMixin(BrowserView):
+class OPDS2LinksView(BrowserView):
     """Links methods for OPDS 2.0 Feed."""
 
     num_pages = 0  # For pyright. Overwritten every run.
@@ -58,7 +59,7 @@ class LinksMixin(BrowserView):
         elif hasattr(self, "request"):
             # if request link and not init static links
             href = update_href_query_params(
-                href, self.request.query_params, new_query_params=data.query_params
+                href, self.request.GET, new_query_params=data.query_params
             )
         return href
 
@@ -69,6 +70,7 @@ class LinksMixin(BrowserView):
         if "page" in kwargs and not self._href_page_validate(kwargs, data):
             return None
 
+        kwargs = pop_name(kwargs)
         href = reverse(url_name, kwargs=kwargs)
         return self._href_update_query_params(href, data)