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

codex/views/browser/page_in_bounds.py

@@ -1,13 +1,13 @@
 """Browser Page Bounds Checking."""
 
 from codex.logger.logging import get_logger
-from codex.views.browser.annotate.card import BrowserAnnotateCardView
+from codex.views.browser.annotations import BrowserAnnotationsView
 from codex.views.util import Route
 
 LOG = get_logger(__name__)
 
 
-class BrowserPageInBoundsView(BrowserAnnotateCardView):
+class BrowserPageInBoundsView(BrowserAnnotationsView):
     """Browser Page Bounds Checking."""
 
     def _get_back_one_page_route(self, num_pages):

codex/views/browser/paginate.py

@@ -5,8 +5,14 @@ from math import ceil
 from django.core.paginator import EmptyPage, Paginator
 
 from codex.logger.logging import get_logger
+from codex.models import (
+    Comic,
+    Folder,
+)
 from codex.views.browser.page_in_bounds import BrowserPageInBoundsView
-from codex.views.const import MAX_OBJ_PER_PAGE
+from codex.views.const import (
+    MAX_OBJ_PER_PAGE,
+)
 
 LOG = get_logger(__name__)
 
@@ -14,7 +20,7 @@ LOG = get_logger(__name__)
 class BrowserPaginateView(BrowserPageInBoundsView):
     """Paginate Groups and Books."""
 
-    def _paginate_section(self, qs, page):
+    def _paginate_section(self, model, qs, page):
         """Paginate a group or Comic section."""
         orphans = 0 if self.model_group == "f" or self.params.get("q") else 5
         paginator = Paginator(qs, MAX_OBJ_PER_PAGE, orphans=orphans)
@@ -22,21 +28,21 @@ class BrowserPaginateView(BrowserPageInBoundsView):
             paginator_page = paginator.page(page)
             qs = paginator_page.object_list
         except EmptyPage:
-            if self.model_group != "f":
-                model_name = qs.model.__name__ if qs.model else "UnknownGroup"
+            if model != Folder:
+                model_name = self.model.__name__ if self.model else "UnknownGroup"
                 LOG.warning(f"No {model_name}s on page {page}")
-            qs = qs.model.objects.none()
+            qs = model.objects.none()
 
         return qs
 
     def _paginate_groups(self, group_qs):
         """Paginate the group object list before books."""
         page = self.kwargs.get("page", 1)
-        return self._paginate_section(group_qs, page)
+        return self._paginate_section(self.model, group_qs, page)
 
     def _paginate_books(self, book_qs, total_group_count, page_group_count):
         """Paginate the book object list based on how many group/folders are showing."""
-        group_remainder = total_group_count % MAX_OBJ_PER_PAGE
+        group_remainder = page_group_count % MAX_OBJ_PER_PAGE
         num_books_on_mixed_page = MAX_OBJ_PER_PAGE - group_remainder
         if page_group_count:
             # There are books after the groups on the same page
@@ -44,7 +50,7 @@ class BrowserPaginateView(BrowserPageInBoundsView):
             page_book_qs = book_qs[:num_books_on_mixed_page]
         else:
             # There are books after the groups on a new page
-            book_offset = 0 if not group_remainder else num_books_on_mixed_page
+            book_offset = 0 if group_remainder else num_books_on_mixed_page
             page_book_qs = book_qs[book_offset:]
 
             # Which book page are we on after groups?
@@ -52,7 +58,7 @@ class BrowserPaginateView(BrowserPageInBoundsView):
             num_group_and_mixed_pages = ceil(total_group_count / MAX_OBJ_PER_PAGE)
             book_only_page = page - num_group_and_mixed_pages
 
-            page_book_qs = self._paginate_section(page_book_qs, book_only_page)
+            page_book_qs = self._paginate_section(Comic, page_book_qs, book_only_page)
         return page_book_qs
 
     def paginate(self, group_qs, book_qs, group_count):

codex/views/browser/title.py

@@ -1,12 +1,17 @@
 """Browser title."""
 
-from codex.models import Comic, Volume
+from codex.models import BrowserGroupModel, Comic, Volume
 from codex.views.browser.breadcrumbs import BrowserBreadcrumbsView
 
 
 class BrowserTitleView(BrowserBreadcrumbsView):
     """Browser title methods."""
 
+    def __init__(self, *args, **kwargs):
+        """Set params for the type checker."""
+        super().__init__(*args, **kwargs)
+        self.group_instance: BrowserGroupModel | None = None
+
     def _get_root_group_name(self):
         if not self.model:
             reason = "No model set in browser"

codex/views/browser/validate.py

@@ -3,17 +3,13 @@
 from copy import deepcopy
 from types import MappingProxyType
 
-from rest_framework.exceptions import NotFound
-
-from codex.choices import DEFAULT_BROWSER_ROUTE, mapping_to_dict
 from codex.exceptions import SeeOtherRedirectError
 from codex.logger.logging import get_logger
-from codex.models.groups import BrowserGroupModel
-from codex.views.browser.filters.search.parse import SearchFilterView
+from codex.serializers.choices import DEFAULTS
+from codex.views.browser.base import BrowserBaseView
 from codex.views.const import (
     COMIC_GROUP,
     FOLDER_GROUP,
-    GROUP_MODEL_MAP,
     ROOT_GROUP,
     STORY_ARC_GROUP,
 )
@@ -21,55 +17,19 @@ from codex.views.const import (
 LOG = get_logger(__name__)
 
 
-class BrowserValidateView(SearchFilterView):
+class BrowserValidateView(BrowserBaseView):
     """Browser Settings and URL Validation."""
 
     DEFAULT_ROUTE = MappingProxyType(
-        {"name": "browser", "params": DEFAULT_BROWSER_ROUTE}
+        {
+            "name": "browser",
+            "params": deepcopy(DEFAULTS["breadcrumbs"][0]),
+        }
     )
 
-    def __init__(self, *args, **kwargs):
-        """Initialize properties."""
-        super().__init__(*args, **kwargs)
-        self._is_admin: bool | None = None
-        self._model_group: str = ""
-        self._model: type[BrowserGroupModel] | None = None
-        self._rel_prefix: str | None = None
-        self._valid_nav_groups: tuple[str, ...] | None = None
-
-    @property
-    def model_group(self):
-        """Memoize the model group."""
-        if not self._model_group:
-            group = self.kwargs["group"]
-            if group == ROOT_GROUP:
-                group = self.params["top_group"]
-            self._model_group = group
-        return self._model_group
-
-    @property
-    def model(self) -> type[BrowserGroupModel] | None:
-        """Memoize the model for the browse list."""
-        if not self._model:
-            model = GROUP_MODEL_MAP.get(self.model_group)
-            if model is None:
-                group = self.kwargs["group"]
-                detail = f"Cannot browse {group=}"
-                LOG.debug(detail)
-                raise NotFound(detail=detail)
-            self._model = model
-        return self._model
-
-    @property
-    def rel_prefix(self):
-        """Memoize model rel prefix."""
-        if self._rel_prefix is None:
-            self._rel_prefix = self.get_rel_prefix(self.model)
-        return self._rel_prefix
-
     def raise_redirect(self, reason, route_mask=None, settings_mask=None):
         """Redirect the client to a valid group url."""
-        route = mapping_to_dict(self.DEFAULT_ROUTE)
+        route = deepcopy(dict(self.DEFAULT_ROUTE))
         if route_mask:
             route["params"].update(route_mask)  # type: ignore
         settings = deepcopy(dict(self.params))
@@ -113,7 +73,7 @@ class BrowserValidateView(SearchFilterView):
             settings_mask = {"top_group": valid_top_group, "breadcrumbs": breadcrumbs}
             self.raise_redirect(reason, route, settings_mask)
 
-    def _get_valid_browse_nav_groups(self, valid_top_groups):
+    def set_valid_browse_nav_groups(self, valid_top_groups):
         """Get valid nav groups for the current settings.
 
         Valid nav groups are the top group and below that are also
@@ -136,7 +96,7 @@ class BrowserValidateView(SearchFilterView):
             reason = f"Nav group {nav_group} unavailable, redirect to {ROOT_GROUP}"
             self.raise_redirect(reason)
 
-        return tuple(valid_nav_groups)
+        self.valid_nav_groups = tuple(valid_nav_groups)
 
     def _validate_folder_settings(self):
         """Check that all the view variables for folder mode are set right."""
@@ -153,7 +113,7 @@ class BrowserValidateView(SearchFilterView):
 
         valid_top_groups = (FOLDER_GROUP,)
         self._validate_top_group(valid_top_groups)
-        return valid_top_groups
+        self.valid_nav_groups = valid_top_groups
 
     def _validate_browser_group_settings(self):
         """Check that all the view variables for browser mode are set right."""
@@ -172,24 +132,29 @@ class BrowserValidateView(SearchFilterView):
 
         # Validate Browser nav_group
         # Redirect if nav group is wrong
-        return self._get_valid_browse_nav_groups(valid_top_groups)
+        self.set_valid_browse_nav_groups(valid_top_groups)
 
-    def _validate_story_arc_settings(self) -> tuple[str, ...]:
+    def _validate_story_arc_settings(self):
         """Validate story arc settings."""
         valid_top_groups = (STORY_ARC_GROUP,)
         self._validate_top_group(valid_top_groups)
-        return valid_top_groups
-
-    @property
-    def valid_nav_groups(self) -> tuple[str, ...]:
-        """Memoize valid nav groups."""
-        if self._valid_nav_groups is None:
-            group = self.kwargs["group"]
-            if group == FOLDER_GROUP:
-                vng = self._validate_folder_settings()
-            elif group == STORY_ARC_GROUP:
-                vng = self._validate_story_arc_settings()
-            else:
-                vng = self._validate_browser_group_settings()
-            self._valid_nav_groups = vng
-        return self._valid_nav_groups
+        self.valid_nav_groups = valid_top_groups
+
+    def validate_settings(self):
+        """Validate group and top group settings."""
+        group = self.kwargs["group"]
+        if group == FOLDER_GROUP:
+            self._validate_folder_settings()
+        elif group == STORY_ARC_GROUP:
+            self._validate_story_arc_settings()
+        else:
+            self._validate_browser_group_settings()
+
+        # Validate order
+        if self.order_key == "filename" and not self.admin_flags["folder_view"]:
+            pks = self.kwargs["pks"]
+            page = self.kwargs["page"]
+            route_changes = {"group": group, "pks": pks, "page": page}
+            reason = "order by filename not allowed by admin flag."
+            settings_mask = {"order_by": "sort_name"}
+            self.raise_redirect(reason, route_changes, settings_mask)

codex/views/download.py

@@ -22,7 +22,7 @@ class DownloadView(AuthFilterAPIView):
         """Download a comic archive."""
         pk = kwargs.get("pk")
         try:
-            group_acl_filter = self.get_group_acl_filter(Comic, self.request.user)
+            group_acl_filter = self.get_group_acl_filter(Comic)
             comic = (
                 Comic.objects.filter(group_acl_filter)
                 .only("path", "file_type")

codex/views/mixins.py

@@ -12,7 +12,7 @@ class SharedAnnotationsMixin:
     """Cross view annotation methods."""
 
     @staticmethod
-    def _get_order_groups(model_group, pks):
+    def _get_order_groups(pks, model_group):
         """Annotate sort_name."""
         if not pks or len(pks) > 1:
             order_groups = _SHOW_GROUPS
@@ -28,11 +28,12 @@ class SharedAnnotationsMixin:
         return order_groups
 
     @classmethod
-    def get_sort_name_annotations(cls, model, model_group, pks, show):
+    def alias_sort_names(cls, qs, model, pks, model_group, show=None):
         """Annotate sort names for browser subclasses and reader."""
         sort_name_annotations = {}
-        if model is Comic:
-            order_groups = cls._get_order_groups(model_group, pks)
+        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
@@ -41,19 +42,23 @@ class SharedAnnotationsMixin:
                 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
-        elif model is Volume:
+                comic_sort_names.append(ann_name)
+        elif model == Volume:
             sort_name_annotations["sort_name"] = F("name")
-        return sort_name_annotations
+
+        if sort_name_annotations:
+            qs = qs.alias(**sort_name_annotations)
+        return qs, comic_sort_names
 
     @classmethod
-    def annotate_group_names(cls, qs):
+    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 qs.model is Comic:
+        if model == Comic:
             if target != "reader":
                 group_names["publisher_name"] = F("publisher__name")
                 if target == "opds2":
@@ -64,25 +69,8 @@ class SharedAnnotationsMixin:
                     "volume_name": F("volume__name"),
                 }
             )
-        elif qs.model is Volume:
+        elif model == Volume:
             group_names["series_name"] = F("series__name")
-        elif qs.model is Imprint:
+        elif model == Imprint:
             group_names["publisher_name"] = F("publisher__name")
         return qs.annotate(**group_names)
-
-
-class BookmarkSearchMixin:
-    """Create Bookmark Search kwargs."""
-
-    @staticmethod
-    def get_bookmark_search_kwargs(auth_filter, comic_filter=None):
-        """Get the search kwargs for a user's authentication state."""
-        # search kwargs are relative to the bookmark object.
-        search_kwargs = {}
-        search_kwargs.update(auth_filter)
-
-        if comic_filter:
-            for key, value in comic_filter.items():
-                search_kwargs[f"comic__{key}"] = value
-
-        return search_kwargs

codex/views/opds/const.py

@@ -1,5 +1,6 @@
 """OPDS Common consts."""
 
+from collections.abc import Mapping
 from types import MappingProxyType
 
 from codex.models import (
@@ -62,7 +63,7 @@ class MimeType:
     HTML = "text/html"
     AUTH_BASIC = "http://opds-spec.org/auth/basic"
     COOKIE = "cookie"
-    FILE_TYPE_MAP: MappingProxyType[str, str] = MappingProxyType(
+    FILE_TYPE_MAP: Mapping[str, str] = MappingProxyType(
         {
             "CBZ": "application/vnd.comicbook+zip",
             "CBR": "application/vnd.comicbook+rar",
@@ -70,7 +71,7 @@ class MimeType:
             "PDF": "application/pdf",
         }
     )
-    SIMPLE_FILE_TYPE_MAP: MappingProxyType[str, str] = MappingProxyType(
+    SIMPLE_FILE_TYPE_MAP: Mapping[str, str] = MappingProxyType(
         {
             # PocketBooks needs app/zip
             "CBZ": "application/zip",

codex/views/opds/urls.py

@@ -3,7 +3,7 @@
 from django.urls import reverse
 from rest_framework.response import Response
 
-from codex.choices import DEFAULT_BROWSER_ROUTE
+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
@@ -19,7 +19,7 @@ class OPDSURLsView(AuthGenericAPIView):
     def get(self, *args, **kwargs):
         """Resolve the urls."""
         obj = {}
-        route = DEFAULT_BROWSER_ROUTE
+        route = DEFAULTS["breadcrumbs"][0]
         route = pop_name(route)
         for version in _OPDS_VERSIONS:
             key = f"v{version}"

codex/views/opds/util.py

@@ -5,11 +5,11 @@ from django.http.response import HttpResponseRedirect
 from django.urls import reverse
 from django.utils.http import urlencode
 
-from codex.choices import DEFAULT_BROWSER_ROUTE
 from codex.models import (
     Contributor,
     ContributorPerson,
 )
+from codex.serializers.choices import DEFAULTS
 from codex.views.auth import GroupACLMixin
 from codex.views.opds.const import OPDS_M2M_MODELS
 
@@ -71,7 +71,8 @@ def full_redirect_view(url_name):
 
     def func(request):
         """Redirect to view, forwarding query strings and auth."""
-        kwargs = dict(DEFAULT_BROWSER_ROUTE)
+        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

@@ -82,9 +82,7 @@ class OPDS1EntryLinksMixin:
         else:
             mime_type = MimeType.NAV
 
-        thr_count = (
-            0 if self.fake else 1 if self.obj.group == "c" else self.obj.child_count
-        )
+        thr_count = 0 if self.fake else self.obj.child_count
         rel = Rel.ALTERNATE if metadata else "subsection"
 
         return OPDS1Link(rel, href, mime_type, thr_count=thr_count)

codex/views/opds/v1/facets.py

@@ -2,14 +2,13 @@
 
 from dataclasses import dataclass
 from types import MappingProxyType
-from typing import Any
 
 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, UserAgentNames
-from codex.views.opds.util import get_user_agent_name, update_href_query_params
+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
@@ -82,61 +81,13 @@ DEFAULT_FACETS = {
 class OPDS1FacetsView(BrowserView):
     """OPDS 1 Facets methods."""
 
-    def __init__(self, *args, **kwargs):
-        """Initialize properties."""
-        super().__init__(*args, **kwargs)
-        self._user_agent_name: str | None = None
-        self._mime_type_map: MappingProxyType[str, str] | None = None
-        self._use_facets: bool | None = None
-        self._obj: MappingProxyType[str, Any] | None = None
-
-    @property
-    def user_agent_name(self) -> str:
-        """Memoize user agent name."""
-        if self._user_agent_name is None:
-            self._user_agent_name = get_user_agent_name(self.request)
-        return self._user_agent_name
-
-    @property
-    def mime_type_map(self) -> MappingProxyType[str, str]:
-        """Memoize mime type map."""
-        if self._mime_type_map is None:
-            self._mime_type_map = (
-                MimeType.SIMPLE_FILE_TYPE_MAP
-                if self.user_agent_name in UserAgentNames.SIMPLE_DOWNLOAD_MIME_TYPES
-                else MimeType.FILE_TYPE_MAP
-            )
-        return self._mime_type_map
-
-    @property
-    def use_facets(self) -> bool:
-        """Memoize use_facets."""
-        if self._use_facets is None:
-            self._use_facets = self.user_agent_name in UserAgentNames.FACET_SUPPORT
-        return self._use_facets
-
-    @property
-    def obj(self) -> MappingProxyType[str, Any]:
-        """Get the browser page and serialize it for this subclass."""
-        if self._obj is None:
-            group_qs, book_qs, num_pages, total_count, zero_pad, mtime = (
-                self._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,
-                }
-            )
-        return self._obj
+    OPDS = 1
+    # Overwritten by get_object()
+    use_facets = False
+    skip_order_facets = False
+    acquisition_groups = frozenset()
+    mime_type_map = MimeType.FILE_TYPE_MAP
+    obj = MappingProxyType({})
 
     def _facet(self, kwargs, facet_group, facet_title, new_query_params):
         kwargs = pop_name(kwargs)
@@ -169,9 +120,9 @@ class OPDS1FacetsView(BrowserView):
         )
         qps = {**self.request.GET}
         qps.update(query_params)
-        zero_pad: int = self.obj["zero_pad"]  # type: ignore
+        zero_pad = self.obj["zero_pad"]
         data = OPDS1EntryData(
-            self.opds_acquisition_groups, zero_pad, False, self.mime_type_map
+            self.acquisition_groups, zero_pad, False, self.mime_type_map
         )
         return OPDS1Entry(entry_obj, qps, data)
 
@@ -234,11 +185,7 @@ class OPDS1FacetsView(BrowserView):
     def facets(self, entries=False, root=True):
         """Return facets."""
         facets = []
-        group = self.kwargs.get("group")
-        add_order_facets = (
-            group != "c" and self.user_agent_name not in UserAgentNames.CLIENT_REORDERS
-        )
-        if not add_order_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:

codex/views/opds/v1/feed.py

@@ -1,5 +1,6 @@
 """OPDS v1 feed."""
 
+from types import MappingProxyType
 from typing import TYPE_CHECKING, Any
 
 from drf_spectacular.utils import extend_schema
@@ -16,7 +17,8 @@ from codex.serializers.opds.v1 import (
 from codex.settings.settings import FALSY
 from codex.views.const import MAX_OBJ_PER_PAGE
 from codex.views.opds.auth import OPDSTemplateView
-from codex.views.opds.const import BLANK_TITLE
+from codex.views.opds.const import BLANK_TITLE, MimeType, UserAgentNames
+from codex.views.opds.util import get_user_agent_name
 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 (
@@ -53,14 +55,14 @@ class OPDS1FeedView(OPDS1LinksView, OPDSTemplateView):
     def opds_ns(self):
         """Dynamic opds namespace."""
         try:
-            return OpdsNs.ACQUISITION if self.is_opds_acquisition else OpdsNs.CATALOG
+            return OpdsNs.ACQUISITION if self.is_aq_feed else OpdsNs.CATALOG
         except Exception:
             LOG.exception("Getting OPDS v1 namespace")
 
     @property
     def is_acquisition(self):
         """Is acquisition."""
-        return self.is_opds_acquisition
+        return self.is_aq_feed
 
     @property
     def id_tag(self):
@@ -126,7 +128,7 @@ class OPDS1FeedView(OPDS1LinksView, OPDSTemplateView):
         if objs := self.obj.get(key):
             zero_pad: int = self.obj["zero_pad"]  # type: ignore
             data = OPDS1EntryData(
-                self.opds_acquisition_groups, zero_pad, metadata, self.mime_type_map
+                self.acquisition_groups, zero_pad, metadata, self.mime_type_map
             )
             fallback = bool(self.admin_flags.get("folder_view"))
             import_pks = set()
@@ -164,8 +166,65 @@ class OPDS1FeedView(OPDS1LinksView, OPDSTemplateView):
             LOG.exception("Getting OPDS v1 entries")
         return entries
 
+    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.is_aq_feed = self.model_group in ("c", "f")
+
+        # Do not return a Mapping despite the type. Return self for the serializer.
+        return self
+
+    def _set_user_agent_variables(self):
+        """Set User Agent variables."""
+        user_agent_name = get_user_agent_name(self.request)
+
+        self.user_facets = user_agent_name in UserAgentNames.FACET_SUPPORT
+        self.skip_order_facets = user_agent_name in UserAgentNames.CLIENT_REORDERS
+        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."""
-        serializer = self.get_serializer(self)
+        self.init_request()
+        obj = self.get_object()
+        serializer = self.get_serializer(obj)
         return Response(serializer.data, content_type=self.content_type)