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

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

@@ -5,12 +5,15 @@ 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.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
 from codex.views.opds.v1.entry.data import OPDS1EntryData, OPDS1EntryObject
 
+LOG = get_logger(__name__)
+
 
 class OPDS1EntryLinksMixin:
     """OPDS v1 Entry Links Methods."""
@@ -23,7 +26,7 @@ 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
@@ -31,55 +34,68 @@ class OPDS1EntryLinksMixin:
     def _thumb_link(self):
         if self.fake:
             return None
-        cover_pk = self.obj.cover_pk
+        cover_pk = getattr(self.obj, "cover_pk", None)
         if cover_pk:
             kwargs = {"pk": cover_pk}
             href = reverse("opds:bin:cover", kwargs=kwargs)
-        elif cover_pk == 0:
-            href = staticfiles_storage.url("img/missing_cover.webp")
+            mime_type = "image/webp"
         else:
-            return None
-        return OPDS1Link(Rel.THUMBNAIL, href, "image/webp")
+            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 = self.obj.cover_pk
+        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"
-        elif cover_pk == 0:
-            href = staticfiles_storage.url("img/missing_cover.webp")
-            mime_type = "image/webp"
         else:
-            return None
+            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):
-        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 +105,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 +133,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._thumb_link():
+                result += [thumb]
+            if image := self._image_link():
+                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

@@ -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.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)
 
@@ -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
 

codex/views/opds/v1/feed.py

@@ -8,6 +8,7 @@ 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
@@ -56,9 +57,12 @@ class UserAgentPrefixes:
 class OPDS1FeedView(CodexXMLTemplateView, LinksMixin):
     """OPDS 1 Feed."""
 
-    authentication_classes = (BasicAuthentication, SessionAuthentication)
+    authentication_classes = (SessionAuthentication, BasicAuthentication)
     template_name = "opds_v1/index.xml"
     serializer_class = OPDS1TemplateSerializer
+    throttle_classes = (ScopedRateThrottle,)
+    throttle_scope = "opds"
+    TARGET = "opds1"
 
     @property
     def opds_ns(self):
@@ -89,7 +93,8 @@ class OPDS1FeedView(CodexXMLTemplateView, LinksMixin):
             browser_title: Mapping[str, Any] = self.obj.get("browser_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()
@@ -131,9 +136,9 @@ 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
@@ -152,9 +157,9 @@ 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)
@@ -189,17 +194,6 @@ 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
-        )
         self.obj = super().get_object()
         self.is_aq_feed = self.model_group in ("c", "f")
 
@@ -227,17 +221,34 @@ class OPDS1FeedView(CodexXMLTemplateView, LinksMixin):
                 self.mime_type_map = MimeType.SIMPLE_FILE_TYPE_MAP
                 break
 
+    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.query_params.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(
         request=BrowserView.input_serializer_class,
         parameters=[BrowserView.input_serializer_class],
     )
     def get(self, *_args, **_kwargs):
         """Get the feed."""
-        self.parse_params()
-        self.validate_settings()
-        self._set_user_agent_variables()
-        self.skip_order_facets |= self.kwargs.get("group") == "c"
-
+        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

@@ -22,11 +22,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
@@ -142,15 +142,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 +186,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

@@ -3,6 +3,7 @@
 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
@@ -12,7 +13,9 @@ from codex.views.template import CodexXMLTemplateView
 class OpenSearch1View(CodexXMLTemplateView):
     """OpenSearchView."""
 
-    authentication_classes = (BasicAuthentication, SessionAuthentication)
+    authentication_classes = (SessionAuthentication, BasicAuthentication)
     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,6 +1,5 @@
 """OPDS v2.0 Feed."""
 
-from datetime import datetime, timezone
 from types import MappingProxyType
 
 from drf_spectacular.utils import extend_schema
@@ -35,8 +34,10 @@ class OPDS2FeedView(PublicationMixin, TopLinksMixin):
     DEFAULT_ROUTE = MappingProxyType(
         {**TopLinksMixin.DEFAULT_ROUTE, "name": "opds:v2:feed"}
     )
+    TARGET = "opds2"
+    throttle_scope = "opds"
 
-    authentication_classes = (BasicAuthentication, SessionAuthentication)
+    authentication_classes = (SessionAuthentication, BasicAuthentication)
     serializer_class = OPDS2FeedSerializer
 
     def _title(self, browser_title):
@@ -44,7 +45,8 @@ class OPDS2FeedView(PublicationMixin, TopLinksMixin):
         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()
@@ -81,13 +83,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 +114,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 +157,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 +169,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 +178,68 @@ 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
-        )
         browser_page = super().get_object()
-        groups = browser_page.get("groups")
-        books = browser_page.get("books")
 
-        self.is_aq_feed = browser_page.get("model_group") == "c"
+        # convert browser_page into opds page
 
-        ts: int = browser_page["covers_timestamp"]  # type: ignore
-        datetime.fromtimestamp(ts, tz=timezone.utc)
+        # instance vars
+        self.is_aq_feed = browser_page.get("model_group") in ("c", "f")
         self.num_pages = browser_page["num_pages"]
-        number_of_items = browser_page["total_count"]
+
+        # opds page
         title = self._title(browser_page.get("browser_title"))
+        number_of_items = browser_page["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 = browser_page.get("groups")
+        page_books = browser_page.get("books")
+        zero_pad = browser_page["zero_pad"]
+        groups = self._get_groups(page_groups, page_books, title, zero_pad)
+
         return MappingProxyType(
             {
                 "metadata": {
                     "title": title,
                     "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.query_params.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],
     )
     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)